Return to server.c CVS log

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

Annotation of researchv10no/cmd/server/server.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(), *getenv();
                     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:        char *machine;
                     26:        if (getenv("REXEC")) {
                     27:                checkcmd(argv[1]);
                     28:                execvp(argv[1], &argv[1]);
                     29:                fprintf(stderr, "%s: command not found\n", argv[1]);
                     30:                exit(1);
                     31:        }
                     32:        if (argc < 3) {
                     33:                fprintf(stderr, "usage: server <machine> <command>\n");
                     34:                exit(1);
                     35:        }
                     36:        setuid(geteuid());
                     37:        machine = argv[1];
                     38:        argv[1] = "/usr/bin/server";
                     39:         rem = tdkexec(machine, bldargs(argc-1, &argv[1]));
                     40:         if (rem<0) {
                     41:                extern char *dkerror;
                     42:                fprintf(stderr, "server: %s: %s\n", machine, dkerror);
                     43:                 exit(1);
                     44:        }
                     45:         t = fork();
                     46:         if (t < 0) {
                     47:                 fprintf(stderr,"server: can't fork\n");
                     48:                 exit(1);
                     49:         }
                     50:         if (t == 0)
                     51:                 to_proc();
                     52:         else
                     53:                 from_proc();
                     54:        exit(0);
                     55: }
                     56: 
                     57: to_proc()
                     58: {
                     59:        register cc;
                     60: 
                     61:        while ((cc = read(0, buf, sizeof buf)) > 0)
                     62:                write(rem, buf, cc);
                     63:         /*
                     64:          * send some EOFs to
                     65:          * make it go away.
                     66:          */
                     67:         write(rem, 0, 0);
                     68:         write(rem, 0, 0);
                     69:         write(rem, 0, 0);
                     70: }
                     71: 
                     72: from_proc()
                     73: {
                     74:        register cc;
                     75: 
                     76:         while ((cc = read(rem, buf, sizeof buf)) > 0)
                     77:                 write(1,  buf, cc);
                     78:         kill(t, 9);
                     79: }
                     80: 
                     81: checkcmd(arg)
                     82: register char *arg;
                     83: {
                     84:        register FILE *f;
                     85:        char cmd[100];
                     86: 
                     87:        if ((f = fopen(cmdfile, "r")) == NULL) {
                     88:                fprintf(stderr, "server can't open %s\n", cmdfile);
                     89:                exit(1);
                     90:        }
                     91:        while (fscanf(f, "%s", cmd) != EOF)
                     92:                if (strcmp(cmd, arg) == 0)
                     93:                        return fclose(f);
                     94:        fprintf(stderr, "server: disallowed command %s\n", arg);
                     95:        exit(1);
                     96: }
                     97: 
                     98: char *
                     99: bldargs(argc, argv)
                    100: register char *argv[];
                    101: {
                    102:        register char *s;
                    103: 
                    104:        while (argc) {
                    105:                if (strlen(args)+strlen(*argv)+3 >= MAXCHARS) {
                    106:                        fprintf(stderr, "server: arg list too long\n");
                    107:                        exit(1);
                    108:                }
                    109:                for (s = frogs; *s; s++) {
                    110:                        if (index(*argv, *s)) {
                    111:                                fprintf(stderr, "server: disallowed char %c\n",
                    112:                                    *s);
                    113:                                exit(1);
                    114:                        }
                    115:                }
                    116:                strcat(args, *argv);
                    117:                strcat(args, " ");
                    118:                argc--;
                    119:                argv++;
                    120:        }
                    121:        return(args);
                    122: }

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