Return to Oserver.c CVS log

Up to [Research Unix] / researchv10no / cmd / server

Annotation of researchv10no/cmd/server/Oserver.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #include <dk.h>
                      3: 
                      4: /*
                      5:  * program to run a command
                      6:  * on another cpu on Datakit.
                      7:  * Suitable for setuid to daemon, and checks for argument frogs
                      8:  * and a restricted list of commands
                      9:  */
                     10: 
                     11: int     rem;            /* remote file descriptor */
                     12: int     t;
                     13: char   *bldargs();
                     14: char   buf[BUFSIZ];
                     15: char   *cmdfile = "/etc/server";       /* legal commands here */
                     16: 
                     17: char   frogs[] = "\n&;^|`<>()";
                     18: 
                     19: #define MAXCHARS 8192
                     20: char args[MAXCHARS];
                     21: 
                     22: main(argc, argv)
                     23: char **argv;
                     24: {
                     25: 
                     26:        if (argc < 3) {
                     27:                fprintf(stderr, "usage: server <machine> <command>\n");
                     28:                exit(1);
                     29:        }
                     30:        setuid(geteuid());
                     31:         rem = tdkexec(argv[1], bldargs(argc-2, &argv[2]));
                     32:         if (rem<0) {
                     33:                extern char *dkerror;
                     34:                fprintf(stderr, "server: %s: %s\n", argv[1], dkerror);
                     35:                 exit(1);
                     36:        }
                     37:         t = fork();
                     38:         if (t < 0) {
                     39:                 fprintf(stderr,"server: can't fork\n");
                     40:                 exit(1);
                     41:         }
                     42:         if (t == 0)
                     43:                 to_proc();
                     44:         else
                     45:                 from_proc();
                     46:        exit(0);
                     47: }
                     48: 
                     49: to_proc()
                     50: {
                     51:        register cc;
                     52: 
                     53:        while ((cc = read(0, buf, sizeof buf)) > 0)
                     54:                write(rem, buf, cc);
                     55:         /*
                     56:          * send some EOFs to
                     57:          * make it go away.
                     58:          */
                     59:         write(rem, 0, 0);
                     60:         write(rem, 0, 0);
                     61:         write(rem, 0, 0);
                     62: }
                     63: 
                     64: from_proc()
                     65: {
                     66:        register cc;
                     67: 
                     68:         while ((cc = read(rem, buf, sizeof buf)) > 0)
                     69:                 write(1,  buf, cc);
                     70:         kill(t, 9);
                     71: }
                     72: 
                     73: char *
                     74: bldargs(argc, argv)
                     75: register char *argv[];
                     76: {
                     77:        register char *s, **t;
                     78:        FILE *f;
                     79:        char cmd[100];
                     80:        int ok = 0;
                     81: 
                     82:        if ((f = fopen(cmdfile, "r")) == NULL) {
                     83:                fprintf(stderr, "server can't open %s\n", cmdfile);
                     84:                exit(1);
                     85:        }
                     86:        while (fscanf(f, "%s", cmd) != EOF)
                     87:                if (strcmp(cmd, argv[0]) == 0) {
                     88:                        ok = 1;
                     89:                        break;
                     90:                }
                     91:        if (!ok) {
                     92:                fprintf(stderr, "server: disallowed command %s\n", argv[0]);
                     93:                exit(1);
                     94:        }
                     95:        while (argc) {
                     96:                if (strlen(args)+strlen(*argv)+3 >= MAXCHARS) {
                     97:                        fprintf(stderr, "server: arg list too long\n");
                     98:                        exit(1);
                     99:                }
                    100:                for (s = frogs; *s; s++) {
                    101:                        if (index(*argv, *s)) {
                    102:                                fprintf(stderr, "server: disallowed char %c\n",
                    103:                                    *s);
                    104:                                exit(1);
                    105:                        }
                    106:                }
                    107:                strcat(args, *argv);
                    108:                strcat(args, " ");
                    109:                argc--;
                    110:                argv++;
                    111:        }
                    112:        return(args);
                    113: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.