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