![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uuxqt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / uucp|
Return to uuxqt.c CVS log | Up to [Research Unix] / researchv10dc / cmd / uucp |
1.1 root 1: /* @(#)uuxqt.c 1.13 */
2:
3: #include "uucp.h"
4: VERSION(@(#)uuxqt.c 1.13);
5:
6: /*
7: * execute commands set up by a uux command,
8: * usually from a remote machine - set by uucp.
9: */
10:
11: #ifndef V7
12: #define LOGNAME "LOGNAME=uucp"
13: #else
14: #define LOGNAME "USER=uucp"
15: #endif
16:
17: #define C_COMMAND 1
18: #define C_FILE 2
19: #define BAD_COMMAND 1
20: #define BAD_FILE 2
21: #define USAGE "[-xDEGUG] [-sSYSTEM]"
22: #define APPCMD(p) {(void) strcat(_Cmd, p); (void) strcat(_Cmd, " ");}
23: #define APPCMDNS(p) {(void) strcat(_Cmd, p);}
24:
25: char _Xfile[MAXFULLNAME];
26: char _Cmd[2 * BUFSIZ]; /* build up command buffer */
27: int _CargType; /* argument type of next C argument */
28: char frogs[] = ";&|<>^`\\('\"";
29:
30: static void retosndr(), uucpst();
31: static int chkFile();
32: static int doFileChk();
33:
34: main(argc, argv, envp)
35: char *argv[], *envp[];
36: {
37: DIR *fp1;
38: int ret, maxnumb;
39: char dirname[MAXFULLNAME], lockname[MAXFULLNAME];
40: extern onintr();
41: FILE *fp;
42:
43: (void) signal(SIGILL, onintr);
44: (void) signal(SIGTRAP, onintr);
45: (void) signal(SIGIOT, onintr);
46: (void) signal(SIGEMT, onintr);
47: (void) signal(SIGFPE, onintr);
48: (void) signal(SIGBUS, onintr);
49: (void) signal(SIGSEGV, onintr);
50: (void) signal(SIGSYS, onintr);
51: (void) signal(SIGPIPE, onintr);
52: (void) signal(SIGTERM, SIG_IGN);
53:
54: /* choose LOGFILE */
55: (void) strcpy(Logfile, LOGUUXQT);
56:
57: /*
58: * get local system name
59: */
60: Env = envp;
61: Nstat.t_qtime = time((time_t *)0);
62: (void) strcpy(Progname, "uuxqt");
63: Pchar = 'Q';
64: uucpname(Myname);
65: Ofn = 1;
66: Ifn = 0;
67: dirname[0] = NULLCHAR;
68: while ((ret = getopt(argc, argv, "s:x:")) != EOF) {
69: switch(ret){
70:
71: /*
72: * debugging level
73: */
74: case 'x':
75: Debug = atoi(optarg);
76: if (Debug <= 0)
77: Debug = 1;
78: break;
79:
80: case 's':
81: /* fake out uuxqt and use the argument as if
82: * it were the spool directory for the purpose
83: * of determining what subdirectories to search
84: * EX: mkdir /tmp/foo; touch /tmp/foo/{baz,gorp}
85: * uuxqt -s/tmp/foo
86: * this will cause uuxqt to only run on the sub
87: * baz and gorp in the Spool directory. Trust me.
88: */
89: (void) strncpy(dirname, optarg, MAXFULLNAME);
90: break;
91:
92: default:
93: (void) fprintf(stderr, "\tusage: %s %s\n",
94: Progname, USAGE);
95: exit(1);
96: }
97: }
98: if (argc != optind) {
99: (void) fprintf(stderr, "\tusage: %s %s\n", Progname, USAGE);
100: exit(1);
101: }
102:
103: DEBUG(4, "\n\n** START **\n", "");
104: fp = fopen(LMTUUXQT, "r");
105: if (fp == NULL) {
106: DEBUG(1, "No limitfile - %s\n", LMTUUXQT);
107: } else {
108: (void) fscanf(fp, "%d", &maxnumb);
109: (void) fclose(fp);
110: DEBUG(4, "Uuxqt limit %d -- ", maxnumb);
111: ret = cuantos(X_LOCKPRE, X_LOCKDIR);
112: DEBUG(4, "found %d -- ", ret);
113: if (maxnumb >= 0 && ret >= maxnumb) {
114: DEBUG(4, "exiting\n", maxnumb);
115: exit(0);
116: }
117: DEBUG(4, "continuing\n", maxnumb);
118: }
119:
120: /*
121: * determine user who started uuxqt (in principle)
122: */
123: strcpy(User, "uucp"); /* in case all else fails (can't happen) */
124: Uid = getuid();
125: Euid = geteuid(); /* this should be UUCPUID */
126: guinfo(Euid, User);
127: setuucp(User);
128: DEBUG(4, "User - %s\n", User);
129: guinfo(Uid, Loginuser);
130:
131: DEBUG(4, "process %s\n", "");
132:
133: fp1 = opendir(Spool);
134: ASSERT(fp1 != NULL, Ct_OPEN, Spool, errno);
135:
136: if (dirname[0] != NULLCHAR) {
137: (void) sprintf(lockname, "%s.%s", X_LOCK, dirname);
138: if (ulockf(lockname, (time_t) X_LOCKTIME) == 0) {
139: xprocess(dirname);
140: rmlock(CNULL);
141: }
142: }
143: else {
144: while (gdirf(fp1, dirname, Spool) == TRUE) {
145: if (strpbrk(dirname, frogs) != NULL) /* skip naughty names */
146: continue;
147: (void) sprintf(lockname, "%s.%s", X_LOCK, dirname);
148: if (ulockf(lockname, (time_t) X_LOCKTIME) != 0)
149: continue;
150: xprocess(dirname);
151: rmlock(CNULL);
152: }
153: }
154:
155: closedir(fp1);
156: cleanup(0);
157: }
158:
159: cleanup(code)
160: int code;
161: {
162: rmlock(CNULL);
163: exit(code);
164: }
165:
166: /*
167: * catch signal then cleanup and exit
168: */
169: onintr(inter)
170: register int inter;
171: {
172: char str[30];
173: (void) signal(inter, SIG_IGN);
174: (void) sprintf(str, "QSIGNAL %d", inter);
175: logent(str, "QCAUGHT");
176: cleanup(-inter);
177: }
178:
179: #define XCACHESIZE (4096 / (MAXBASENAME + 1))
180: static char xcache[XCACHESIZE][MAXBASENAME + 1]; /* cache for X. files */
181: static int xcachesize = 0; /* how many left? */
182:
183: /*
184: * stash an X. file so we can process them sorted first by grade, then by
185: * sequence number
186: */
187: static int
188: xstash(file)
189: char *file;
190: {
191: DEBUG(4, "stashing %s\n", file);
192: strcpy(xcache[xcachesize++], file);
193: }
194:
195: /*
196: * xcompare
197: * comparison routine for for qsort()
198: */
199: static int
200: xcompare(f1, f2)
201: register char *f1, *f2;
202: {
203: /* assumes file name is X.siteG1234 */
204: /* use -strcmp() so that xstash is sorted largest first */
205: /* pull files out of the stash from largest index to smallest */
206:
207: return(-strcmp(f1 + strlen(f1) - 5, f2 + strlen(f2) - 5));
208: }
209:
210: /*
211: * xsort
212: * sort the cached X. files,
213: * largest (last) to smallest (next to be processed)
214: */
215: static int
216: xsort()
217: {
218: DEBUG(4, "xsort: first was %s\n", xcache[0]);
219: qsort(xcache, xcachesize, MAXBASENAME + 1, xcompare);
220: DEBUG(4, "xsort: first is %s\n", xcache[0]);
221: }
222:
223: /*
224: * xget
225: * return smallest X. file in cache
226: * (hint: it's the last one in the array)
227: */
228: static int
229: xget(file)
230: char *file;
231: {
232: if (xcachesize > 0) {
233: strcpy(file, xcache[--xcachesize]);
234: DEBUG(4, "xget: returning %s\n", file);
235: return(1);
236: } else {
237: /* avoid horror of xcachesize < 0 (impossible, you say?)! */
238: xcachesize = 0;
239: return(0);
240: }
241: }
242:
243:
244: /*
245: * get a file to execute
246: * file -> a read to return filename in
247: * returns:
248: * 0 -> no file
249: * 1 -> file to execute
250: */
251: gt_Xfile(file, dir)
252: register char *file, *dir;
253: {
254: DIR *pdir;
255:
256: if (xcachesize == 0) {
257: /* open spool directory */
258: pdir = opendir(dir);
259: /* this was an ASSERT, but it's not so bad as all that */
260: if (pdir == NULL)
261: return(0);
262:
263: /* scan spool directory looking for X. files to stash */
264: while (gnamef(pdir, file) == TRUE) {
265: DEBUG(4, "gt_Xfile got %s\n", file);
266: /* look for x prefix */
267: if (file[0] != XQTPRE)
268: continue;
269:
270: /* check to see if required files have arrived */
271: if (gotfiles(file))
272: xstash(file);
273: if (xcachesize >= XCACHESIZE)
274: break;
275: }
276: closedir(pdir);
277: xsort();
278: }
279:
280: return(xget(file));
281: }
282:
283: /*
284: * check for needed files
285: * file -> name of file to check
286: * return:
287: * 0 -> not ready
288: * 1 -> all files ready
289: */
290: gotfiles(file)
291: register char *file;
292: {
293: register FILE *fp;
294: struct stat stbuf;
295: char buf[BUFSIZ], rqfile[MAXFULLNAME];
296:
297: fp = fopen(file, "r");
298: if (fp == NULL)
299: return(FALSE);
300:
301: while (fgets(buf, BUFSIZ, fp) != NULL) {
302: DEBUG(4, "%s\n", buf);
303:
304: /*
305: * look at required files
306: */
307: if (buf[0] != X_RQDFILE)
308: continue;
309: (void) sscanf(&buf[1], "%s", rqfile);
310:
311: /*
312: * expand file name
313: */
314: expfile(rqfile);
315:
316: /*
317: * see if file exists
318: */
319: if (stat(rqfile, &stbuf) == -1) {
320: fclose(fp);
321: return(FALSE);
322: }
323: }
324:
325: fclose(fp);
326: return(TRUE);
327: }
328:
329: /*
330: * remove execute files to x-directory
331: *
332: * _Xfile is a global
333: * return:
334: * none
335: */
336: rm_Xfiles()
337: {
338: register FILE *fp;
339: char buf[BUFSIZ], file[NAMESIZE], tfile[NAMESIZE];
340: char tfull[MAXFULLNAME];
341:
342: if ((fp = fopen(_Xfile, "r")) == NULL) {
343: DEBUG(4, "rm_Xfiles: can't read %s\n", _Xfile);
344: return;
345: }
346:
347: /*
348: * (void) unlink each file belonging to job
349: */
350: while (fgets(buf, BUFSIZ, fp) != NULL) {
351: if (buf[0] != X_RQDFILE)
352: continue;
353: if (sscanf(&buf[1], "%s%s", file, tfile) < 2)
354: continue;
355: (void) sprintf(tfull, "%s/%s", XQTDIR, tfile);
356: (void) unlink(tfull);
357: }
358: fclose(fp);
359: return;
360: }
361:
362: /*
363: * move execute files to x-directory
364: * _Xfile is a global
365: * return:
366: * none
367: */
368: mv_Xfiles()
369: {
370: register FILE *fp;
371: char buf[BUFSIZ], ffile[MAXNAMESIZE], tfile[MAXNAMESIZE];
372: char tfull[MAXNAMESIZE];
373:
374: if ((fp = fopen(_Xfile, "r")) == NULL) {
375: DEBUG(4, "mv_Xfiles: can't read %s\n", _Xfile);
376: return;
377: }
378:
379: while (fgets(buf, BUFSIZ, fp) != NULL) {
380: if (buf[0] != X_RQDFILE)
381: continue;
382: if (sscanf(&buf[1], "%s%s", ffile, tfile) < 2)
383: continue;
384:
385: /*
386: * expand file names and move to
387: * execute directory
388: * Make files readable by anyone
389: */
390: expfile(ffile);
391: (void) sprintf(tfull, "%s/%s", XQTDIR, tfile);
392:
393: ASSERT(xmv(ffile, tfull) == 0, "XMV ERROR", tfull, errno);
394: chmod(tfull, 0666);
395: }
396: fclose(fp);
397: return;
398: }
399:
400: /*
401: * undo what mv_Xfiles did
402: * _Xfile is a global
403: * return:
404: * none
405: */
406: unmv_Xfiles()
407: {
408: FILE *fp;
409: char buf[BUFSIZ], ffile[MAXNAMESIZE], tfile[MAXNAMESIZE];
410: char tfull[MAXNAMESIZE], ffull[MAXNAMESIZE], xfull[MAXNAMESIZE];
411:
412: (void) sprintf(xfull, "%s/%s", RemSpool, _Xfile);
413: if ((fp = fopen(xfull, "r")) == NULL) {
414: DEBUG(4, "unmv_Xfiles: can't read %s\n", xfull);
415: return;
416: }
417:
418: while (fgets(buf, BUFSIZ, fp) != NULL) {
419: if (buf[0] != X_RQDFILE)
420: continue;
421: if (sscanf(&buf[1], "%s%s", ffile, tfile) < 2)
422: continue;
423:
424: /*
425: * expand file names and move back to
426: * spool directory
427: * Make files readable by uucp
428: */
429: (void) sprintf(ffull, "%s/%s", RemSpool, ffile);
430: /* i know we're in .Xqtdir, but what the hell ... */
431: (void) sprintf(tfull, "%s/%s", XQTDIR, tfile);
432:
433: ASSERT(xmv(tfull, ffull) == 0, "XMV ERROR", ffull, errno);
434: (void) chmod(ffull, 0600);
435: }
436: fclose(fp);
437: return;
438: }
439:
440: /* chkpart - checks the string (ptr points to it) for illegal command or
441: * file permission restriction - called recursively
442: * to check lines that have `string` or (string) form.
443: * _Cmd is the buffer where the command is built up.
444: * _CargType is the type of the next C line argument
445: *
446: * Return:
447: * BAD_FILE if a non permitted file is found
448: * BAD_COMMAND if non permitted command is found
449: * 0 - ok
450: */
451:
452: static
453: int
454: chkpart(ptr)
455: char *ptr;
456: {
457: char prm[BUFSIZ], xcmd[BUFSIZ];
458: char savechar[2]; /* one character string with NULL */
459: int ret;
460:
461: /* _CargType is the arg type for this iteration (cmd or file) */
462: while ((ptr = getprm(ptr, prm)) != NULL) {
463: DEBUG(4, "prm='%s'\n", prm);
464: switch(*prm) {
465:
466: /* End of command delimiter */
467: case ';':
468: case '^':
469: case '&':
470: case '|':
471: APPCMDNS(prm);
472: _CargType = C_COMMAND;
473: continue;
474:
475: /* Other delimiter */
476: case '>':
477: case '<':
478: APPCMDNS(prm);
479: continue;
480:
481: case '`': /* don't allow any ` commands */
482: case '\\':
483: return(BAD_COMMAND);
484:
485: /* Some allowable quoted string */
486: case '(':
487: case '"':
488: case '\'':
489: /* must recurse */
490: savechar[0] = *prm;
491: savechar[1] = NULLCHAR;
492: APPCMD(savechar); /* put first char into command */
493: savechar[0] = prm[strlen(prm)-1];
494: prm[strlen(prm)-1] = NULLCHAR; /* delete last character */
495:
496: /* recurse */
497: if (ret = chkpart(prm+1)) { /* failed */
498: return(ret);
499: }
500: APPCMD(savechar); /* put last char into command */
501: continue;
502:
503: default: /* check for command or file */
504: break;
505: }
506:
507: if (_CargType == C_COMMAND) {
508: if ( (cmdOK(prm, xcmd)) == FALSE)
509: return(BAD_COMMAND);
510: APPCMD(xcmd);
511: _CargType = C_FILE;
512: continue;
513: }
514:
515: #if NOTDEF
516: if (chkFile(prm))
517: return(BAD_FILE);
518: else
519: #endif
520: APPCMD(prm);
521: }
522: return(0); /* all ok */
523: }
524:
525: /* chkFile - try to find a path name in the prm.
526: * if found, check it for access permission.
527: *
528: * check file access permissions
529: * if ! in name assume that access on local machine is required
530: *
531: * Return:
532: * BAD_FILE - not permitted
533: * 0 - ok
534: */
535:
536: static
537: int
538: chkFile(prm)
539: char *prm;
540: {
541: char *p, buf[BUFSIZ];
542:
543: (void) strcpy(buf, prm);
544: switch(*prm) {
545: case '~':
546: case '/':
547: if (doFileChk(buf))
548: return(BAD_FILE);
549: else
550: return(0);
551: /*NOTREACHED*/
552:
553: case '!':
554: return(chkFile(buf+1));
555: /*NOTREACHED*/
556:
557: default:
558: break;
559: }
560:
561: if ( (p =strchr(buf, '!')) == NULL) { /* no "!", look for "/" */
562: if ( (p = strchr(buf, '/')) == NULL) { /* ok */
563: return(0);
564: }
565: if (doFileChk(p))
566: return(BAD_FILE);
567: else
568: return(0);
569: }
570:
571: /* there is at least one '!' - see if it refers to my system */
572: if (PREFIX(Myname, buf)) /* my system so far, check further */
573: return(chkFile(p+1)); /* recurse with thing after '!' */
574: else /* not my system - not my worry */
575: return(0);
576: }
577:
578: /* doFileChk - check file path permission
579: * NOTE: file is assumed to be a buffer that expfile an
580: * write into.
581: * Return
582: * BAD_FILE - not allowed
583: * 0 - ok
584: */
585:
586: static
587: int
588: doFileChk(file)
589: char *file;
590: {
591: expfile(file);
592: DEBUG(7, "fullname: %s\n", file);
593: if (chkpth(file, CK_READ) == FAIL
594: || chkpth(file, CK_WRITE) == FAIL )
595: return(BAD_FILE);
596: else
597: return(0);
598: }
599:
600:
601: /*
602: * return stuff to user
603: * user -> user to notify
604: * rmt -> system name where user resides
605: * file -> file to return (generally contains input)
606: * cmd -> command that was to be executed
607: * buf -> user friendly face saving uplifting edifying missive
608: * errfile -> stderr output from cmd xeqn
609: * return:
610: * none
611: */
612: static void
613: retosndr(user, rmt, file, cmd, buf, errfile)
614: char *user, *rmt, *file, *cmd, *buf, *errfile;
615: {
616: char ruser[BUFSIZ], msg[BUFSIZ];
617:
618: (void) sprintf(msg,
619: "remote execution\t[uucp job %s (%s)]\n\t%s\n%s\n",
620: &_Xfile[2], timeStamp(), cmd, buf);
621:
622: DEBUG(5, "retosndr %s, ", msg);
623:
624: if (EQUALS(rmt, Myname))
625: (void) strcpy(ruser, user);
626: else
627: (void) sprintf(ruser, "%s!%s", rmt, user);
628:
629: mailst(ruser, msg, file, errfile);
630: }
631:
632:
633: /*
634: * uucpst - send the status message back using a uucp command
635: * NOTE - this would be better if the file could be appended.
636: * - suggestion for the future - if rmail would take a file name
637: * instead of just person, then that facility would be correct,
638: * and this routine would not be needed.
639: */
640:
641: static
642: void
643: uucpst(rmt, tofile, errfile, cmd, buf)
644: char *rmt, *tofile, *errfile, *cmd, *buf;
645: {
646: char arg[MAXFULLNAME], tmp[MAXBASENAME], msg[BUFSIZ];
647: int ret;
648: FILE *fp, *fi;
649: int pid, rpid;
650:
651: (void) sprintf(msg,
652: "uucp job %s (%s) remote execution\n\t%s\n%s\n",
653: &_Xfile[2], timeStamp(), cmd, buf);
654:
655: (void) sprintf(tmp, "%s.%d", rmt, getpid());
656: if ((fp = fopen(tmp, "w")) == NULL)
657: return;
658: (void) fprintf(fp, "%s\n", msg);
659:
660: /* copy back stderr */
661: if (*errfile != '\0' && NOTEMPTY(errfile)
662: && (fi = fopen(errfile, "r")) != NULL) {
663: fputs("\n\t===== stderr was =====\n", fp);
664: if (xfappend(fi, fp) != SUCCESS)
665: fputs("\n\t===== well, i tried =====\n", fp);
666: (void) fclose(fi);
667: fputc('\n', fp);
668: }
669:
670:
671: (void) fclose(fp);
672: (void) sprintf(arg, "%s!%s", rmt, tofile);
673:
674: /* start uucp */
675:
676: if ((pid = fork()) == 0) {
677: (void) close(0);
678: (void) close(1);
679: (void) close(2);
680: (void) open("/dev/null", 2);
681: (void) open("/dev/null", 2);
682: (void) open("/dev/null", 2);
683: #ifdef V8
684: (void) close(3);
685: (void) open("/dev/null", 2);
686: #endif
687: (void) signal(SIGINT, SIG_IGN);
688: (void) signal(SIGHUP, SIG_IGN);
689: (void) signal(SIGQUIT, SIG_IGN);
690: closelog();
691:
692: (void) execle("/usr/bin/uucp", "UUCP",
693: "-C", tmp, arg, 0, Env);
694: (void) _exit(100);
695: }
696:
697: while ((rpid = wait(&ret)) > 0 && rpid != pid)
698: ;
699: (void) unlink(tmp);
700: return;
701: }
702:
703: static
704: xprocess(dirname)
705: char *dirname;
706: {
707: int return_stdin; /* return stdin for failed commands */
708: int cmdok, mask, ret, badfiles;
709: int send_zero; /* return successful completion status */
710: int send_nonzero; /* return unsuccessful completion status */
711: int send_nothing; /* request for no exit status */
712: int store_status; /* store status of command in local file */
713: char lbuf[BUFSIZ];
714: char *p;
715: char dfile[MAXFULLNAME], cfile[MAXFULLNAME], incmd[BUFSIZ];
716: char errDfile[BUFSIZ];
717: char fin[MAXFULLNAME], sysout[NAMESIZE], fout[MAXFULLNAME];
718: char file[MAXNAMESIZE], tempname[NAMESIZE];
719: char _Sfile[MAXFULLNAME]; /* name of local file for status */
720: FILE *xfp, *dfp, *fp, *errdfp;
721: struct stat sb;
722: char buf[BUFSIZ], user[BUFSIZ], retaddr[BUFSIZ], msgbuf[BUFSIZ];
723:
724: (void) strcpy(Rmtname, dirname);
725: chremdir(Rmtname);
726: (void) mchFind(Rmtname);
727: while (gt_Xfile(_Xfile, RemSpool) > 0) {
728: DEBUG(4, "_Xfile - %s\n", _Xfile);
729:
730: if ( (xfp = fopen(_Xfile, "r")) == NULL) {
731: toCorrupt(_Xfile);
732: continue;
733: }
734: ASSERT(xfp != NULL, Ct_OPEN, _Xfile, errno);
735:
736: if (stat(_Xfile, &sb) != -1)
737: Nstat.t_qtime = sb.st_mtime;
738: /*
739: * initialize to defaults
740: */
741: (void) strcpy(user, User);
742: (void) strcpy(fin, "/dev/null");
743: (void) strcpy(fout, "/dev/null");
744: (void) sprintf(sysout, "%.*s", MAXBASENAME, Myname);
745: badfiles = 0;
746: *incmd = *retaddr = NULLCHAR;
747: (void) initSeq();
748: send_zero = send_nonzero = send_nothing = store_status = return_stdin = 0;
749:
750: while (fgets(buf, BUFSIZ, xfp) != NULL) {
751: /*
752: * interpret JCL card
753: */
754: switch (buf[0]) {
755: case X_USER: /* user name */
756: /* ignore Rmtname -- i don't believe it */
757: (void) sscanf(&buf[1], "%s", user);
758: break;
759:
760: case X_STDIN: /* standard input */
761: (void) sscanf(&buf[1], "%s", fin);
762: expfile(fin);
763: if (chkpth(fin, CK_READ)) {
764: DEBUG(4, "badfile - in: %s\n", fin);
765: badfiles = 1;
766: }
767: break;
768:
769: case X_STDOUT: /* standard output */
770: (void) sscanf(&buf[1], "%s%s", fout, sysout);
771: if ((p = strpbrk(sysout, "!/")) != NULL)
772: *p = NULLCHAR; /* these can hurt! */
773: if (*sysout != NULLCHAR && !EQUALS(sysout, Myname))
774: break;
775:
776: expfile(fout);
777: if (chkpth(fout, CK_WRITE)) {
778: badfiles = 1;
779: DEBUG(4, "badfile - out: %s\n", fout);
780: }
781: break;
782:
783:
784: case X_CMD: /* command to execute */
785: (void) strcpy(incmd, &buf[2]);
786: if (*(incmd + strlen(incmd) - 1) == '\n')
787: *(incmd + strlen(incmd) - 1) = NULLCHAR;
788: break;
789:
790: case X_MAILF: /* put status in _Sfile */
791: store_status = 1;
792: (void) sscanf(&buf[1], "%s", _Sfile);
793: break;
794:
795: case X_SENDNOTHING: /* no failure notification */
796: send_nothing++;
797: break;
798:
799: case X_SENDZERO: /* success notification */
800: send_zero++;
801: break;
802:
803: case X_NONZERO: /* failure notification */
804: send_nonzero++;
805: break;
806:
807: case X_BRINGBACK: /* return stdin on command failure */
808: return_stdin = 1;
809: break;
810:
811:
812: case X_RETADDR: /* return address */
813: (void) sscanf(&buf[1], "%s", retaddr);
814: break;
815:
816: default:
817: break;
818: }
819: }
820:
821: fclose(xfp);
822: DEBUG(4, "fin - %s, ", fin);
823: DEBUG(4, "fout - %s, ", fout);
824: DEBUG(4, "sysout - %s, ", sysout);
825: DEBUG(4, "user - %s\n", user);
826: DEBUG(4, "incmd - %s\n", incmd);
827:
828: if (retaddr[0] != NULLCHAR)
829: (void) strcpy(user, retaddr); /* pick on this guy */
830:
831: /* get rid of stuff that can hurt */
832: if ( (p = strpbrk(user, frogs)) != NULL)
833: *p = NULLCHAR;
834: if (incmd[0] == NULLCHAR) {
835: /* this is a bad X. file - just get rid of it */
836: toCorrupt(_Xfile);
837: continue;
838: }
839:
840: /*
841: * send_nothing must be explicitly requested to avert failure status
842: * send_zero must be explicitly requested for success notification
843: */
844: if (!send_nothing)
845: send_nonzero++;
846:
847: /*
848: * command execution
849: * generate a temporary file (if necessary)
850: * to hold output to be shipped back
851: */
852: if (EQUALS(fout, "/dev/null"))
853: (void) strcpy(dfile, "/dev/null");
854: else {
855: gename(DATAPRE, sysout, 'O', tempname);
856: (void) sprintf(dfile, "%s/%s", WORKSPACE, tempname);
857: }
858:
859: /* initialize command line */
860: /* set up two environment variables, remote machine name */
861: /* and remote user name if available from R line */
862: (void) sprintf(_Cmd,
863: "%s %s UU_MACHINE=%s UU_USER=%s export UU_MACHINE UU_USER PATH; exec ",
864: PATH, LOGNAME, Rmtname, user);
865:
866: /*
867: * check to see if command can be executed
868: */
869: _CargType = C_COMMAND; /* the first thing is a command */
870: cmdok = chkpart(incmd);
871:
872: if (badfiles || (cmdok == BAD_COMMAND) || cmdok == BAD_FILE) {
873: if (cmdok == BAD_COMMAND) {
874: (void) sprintf(lbuf, "%s XQT DENIED", user);
875: (void) sprintf(msgbuf, "execution permission denied to %s", user);
876: } else {
877: (void) sprintf(lbuf,
878: "%s XQT- STDIN(%s)/STDOUT/FILE ACCESS DENIED", user, fin);
879: (void) sprintf(msgbuf, "file access denied to %s", user);
880: }
881: return_stdin = 0; /* it might not be his data */
882: logent(incmd, lbuf);
883: DEBUG(4, "bad command %s\n", incmd);
884:
885: if (send_nonzero)
886: retosndr(user, Rmtname, return_stdin ? fin : "", incmd, msgbuf, "");
887: if (store_status)
888: uucpst(Rmtname, _Sfile, "", incmd, msgbuf);
889: goto rmfiles;
890: }
891:
892: (void) sprintf(lbuf, "%s XQT <%s >%s", user, fin, fout);
893: logent(_Cmd, lbuf);
894: DEBUG(4, "cmd %s\n", _Cmd);
895:
896: /* move files to execute directory and change to that directory */
897:
898: mv_Xfiles();
899:
900: ASSERT(chdir(XQTDIR) == 0, Ct_CHDIR, XQTDIR, errno);
901:
902: /* invoke shell to execute command */
903:
904: mask = umask(0);
905: DEBUG(7, "full cmd: %s\n", _Cmd);
906:
907: /* temp file to capture error output */
908: gename(DATAPRE, sysout, 'E', tempname);
909: (void) sprintf(errDfile, "%s/%s", WORKSPACE, tempname);
910: ret = shio(_Cmd, fin, dfile, errDfile);
911: umask(mask);
912: if (ret == -1) { /* -1 means the fork() failed */
913: unmv_Xfiles(); /* put things back */
914: errent(Ct_FORK, buf, errno, sccsid, __FILE__, __LINE__);
915: cleanup(1); /* g'nite! */
916: }
917:
918: if (ret == 0) { /* exit == signal == 0 */
919: (void) strcpy(msgbuf, "exited normally");
920: if (send_zero)
921: retosndr(user, Rmtname, "", incmd, msgbuf, "");
922: if (store_status)
923: uucpst(Rmtname, _Sfile, "", incmd, msgbuf);
924: } else { /* exit != 0 */
925: int exitcode = (ret >> 8) & 0377;
926:
927: if (exitcode) /* exit != 0 */
928: (void) sprintf(msgbuf, "exited with status %d", exitcode);
929: else /* signal != 0 */
930: (void) sprintf(msgbuf, "terminated by signal %d", ret & 0177);
931: DEBUG(5, "%s\n", msgbuf);
932:
933: if (send_nonzero)
934: retosndr(user, Rmtname, return_stdin ? fin : "", incmd, msgbuf, errDfile);
935: if (store_status)
936: uucpst(Rmtname, _Sfile, errDfile, incmd, msgbuf);
937:
938: (void) sprintf(lbuf, "%s - %s", incmd, msgbuf);
939: logent(lbuf, "COMMAND FAIL");
940: }
941:
942: /* change back to spool directory */
943:
944: chremdir(Rmtname);
945:
946: /* remove file */
947:
948: rm_Xfiles();
949:
950: if (ret != 0) {
951: /*
952: * exit status not zero,
953: * so append bad news message and stderr to returned data
954: */
955: if (access(dfile, 0) != 0)
956: close(creat(dfile, DFILEMODE));
957: dfp = fopen(dfile, "a");
958: ASSERT(dfp != NULL, Ct_OPEN, dfile, errno);
959: if (NOTEMPTY(errDfile) && (errdfp = fopen(errDfile, "r")) != NULL) {
960: (void) fprintf(dfp, "%s\n\t===== error output =====\n", msgbuf);
961: (void) xfappend(errdfp, dfp); /* who cares if it fails? */
962: (void) fclose(errdfp);
963: }
964: (void) fclose(dfp);
965: }
966:
967: if (!EQUALS(fout, "/dev/null")) {
968: /*
969: * if output is on this machine copy output
970: * there, otherwise spawn job to send to send
971: * output elsewhere.
972: */
973:
974: if (EQUALS(sysout, Myname)) {
975: xmv(dfile, fout);
976: }
977: else {
978: gename(CMDPRE, sysout, 'O', tempname);
979: (void) sprintf(cfile, "%s/%s", WORKSPACE, tempname);
980: fp = fdopen(ret = creat(cfile, CFILEMODE), "w");
981: ASSERT(ret >= 0 && fp != NULL, Ct_OPEN, cfile, errno);
982: (void) fprintf(fp, "S %s %s %s -d %s 0666\n",
983: BASENAME(dfile, '/'), fout, user, BASENAME(dfile, '/'));
984: fclose(fp);
985: wfcommit(dfile, BASENAME(dfile, '/'), sysout);
986: wfcommit(cfile, BASENAME(cfile, '/'), sysout);
987: }
988: }
989: rmfiles:
990:
991: /* delete job files in spool directory */
992: xfp = fopen(_Xfile, "r");
993: ASSERT(xfp != NULL, Ct_OPEN, _Xfile, errno);
994: while (fgets(buf, BUFSIZ, xfp) != NULL) {
995: if (buf[0] != X_RQDFILE)
996: continue;
997: (void) sscanf(&buf[1], "%s", file);
998: (void) unlink(file);
999: }
1000: (void) unlink(_Xfile);
1001: fclose(xfp);
1002: unlink(errDfile);
1003: }
1004: }
1005:
1006:
1007: /*
1008: * return the number of files in directory <dir> who's names
1009: * begin with <prefix>
1010: * This is used to count the number of uuxqts currently running.
1011: *
1012: */
1013:
1014: cuantos(prefix, dir)
1015: char *prefix, *dir;
1016: {
1017: int i = 0;
1018: DIR *pdir;
1019: char fullname[MAXNAMESIZE], file[MAXNAMESIZE];
1020:
1021: pdir = opendir(dir);
1022: ASSERT(pdir != NULL, Ct_OPEN, dir, errno);
1023:
1024: while (gnamef(pdir, file) == TRUE)
1025: if (PREFIX(prefix, file)) {
1026: (void) sprintf(fullname, "%s/%s", dir, file);
1027: if (checkLock(fullname))
1028: i++;
1029: }
1030: closedir(pdir);
1031: return(i);
1032: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.