1: #ifndef lint 2: static char sccsid[] = "@(#)cntrl.c 5.1 (Berkeley) 7/2/83"; 3: #endif 4: 5: #include "uucp.h" 6: #include <sys/types.h> 7: #include <sys/stat.h> 8: 9: 10: 11: struct Proto { 12: char P_id; 13: int (*P_turnon)(); 14: int (*P_rdmsg)(); 15: int (*P_wrmsg)(); 16: int (*P_rddata)(); 17: int (*P_wrdata)(); 18: int (*P_turnoff)(); 19: }; 20: 21: 22: extern int gturnon(), gturnoff(); 23: extern int grdmsg(), grddata(); 24: extern int gwrmsg(), gwrdata(); 25: extern int imsg(), omsg(); 26: 27: struct Proto Ptbl[]={ 28: 'g', gturnon, grdmsg, gwrmsg, grddata, gwrdata, gturnoff, 29: '\0' 30: }; 31: 32: int (*Imsg)() = imsg, (*Omsg)() = omsg; /* avoid SEL compiler limitation */ 33: 34: int (*Rdmsg)()=imsg, (*Rddata)(); 35: int (*Wrmsg)()=omsg, (*Wrdata)(); 36: int (*Turnon)(), (*Turnoff)(); 37: 38: 39: #define YES "Y" 40: #define NO "N" 41: 42: /* failure messages */ 43: #define EM_MAX 6 44: #define EM_LOCACC "N1" /* local access to file denied */ 45: #define EM_RMTACC "N2" /* remote access to file/path denied */ 46: #define EM_BADUUCP "N3" /* a bad uucp command was generated */ 47: #define EM_NOTMP "N4" /* remote error - can't create temp */ 48: #define EM_RMTCP "N5" /* can't copy to remote directory - file in public */ 49: #define EM_LOCCP "N6" /* can't copy on local system */ 50: 51: char *Em_msg[] = { 52: "COPY FAILED (reason not given by remote)", 53: "local access to file denied", 54: "remote access to path/file denied", 55: "system error - bad uucp command generated", 56: "remote system can't create temp file", 57: "can't copy to file/directory - file left in PUBDIR/user/file", 58: "can't copy to file/directory - file left in PUBDIR/user/file" 59: }; 60: 61: /* */ 62: 63: 64: #define XUUCP 'X' /* execute uucp (string) */ 65: #define SLTPTCL 'P' /* select protocol (string) */ 66: #define USEPTCL 'U' /* use protocol (character) */ 67: #define RCVFILE 'R' /* receive file (string) */ 68: #define SNDFILE 'S' /* send file (string) */ 69: #define RQSTCMPT 'C' /* request complete (string - yes | no) */ 70: #define HUP 'H' /* ready to hangup (string - yes | no) */ 71: #define RESET 'X' /* reset line modes */ 72: 73: 74: #define W_TYPE wrkvec[0] 75: #define W_FILE1 wrkvec[1] 76: #define W_FILE2 wrkvec[2] 77: #define W_USER wrkvec[3] 78: #define W_OPTNS wrkvec[4] 79: #define W_DFILE wrkvec[5] 80: #define W_MODE wrkvec[6] 81: #define W_NUSER wrkvec[7] 82: 83: #define XFRRATE 350000L 84: #define RMESG(m, s, n) if (rmesg(m, s, n) != 0) {(*Turnoff)(); return(FAIL);} else 85: #define RAMESG(s, n) if (rmesg('\0', s, n) != 0) {(*Turnoff)(); return(FAIL);} else 86: #define WMESG(m, s) if(wmesg(m, s) != 0) {(*Turnoff)(); return(FAIL);} else 87: 88: char Wfile[MAXFULLNAME] = {'\0'}; 89: char Dfile[MAXFULLNAME]; 90: 91: /* 92: * To avoid a huge backlog of X. files, start uuxqt every so often. 93: * To avoid a huge number of uuxqt zombies, 94: * wait for one occasionally! 95: */ 96: static int nXfiles = 0; /* number of X files since last uuxqt start */ 97: static int nXQTs = 0; /* number of uuxqts started */ 98: 99: /******* 100: * cntrl(role, wkpre) 101: * int role; 102: * char *wkpre; 103: * 104: * cntrl - this routine will execute the conversation 105: * between the two machines after both programs are 106: * running. 107: * 108: * return codes 109: * SUCCESS - ok 110: * FAIL - failed 111: */ 112: 113: cntrl(role, wkpre) 114: int role; 115: char *wkpre; 116: { 117: char msg[BUFSIZ], rqstr[BUFSIZ]; 118: register FILE *fp; 119: int filemode; 120: struct stat stbuf; 121: char filename[MAXFULLNAME], wrktype, *wrkvec[20]; 122: extern (*Rdmsg)(), (*Wrmsg)(); 123: extern char *index(), *lastpart(); 124: int status = 1; 125: register int i, narg; 126: int mailopt, ntfyopt; 127: int ret; 128: static int pnum, tmpnum = 0; 129: 130: pnum = getpid(); 131: /* 132: * ima.247, John Levine, IECC, PO Box 349, Cambridge MA 02238; (617) 491-5450 133: * zap Wfile to prevent reuse of wrong C. file 134: */ 135: Wfile[0] = '\0'; 136: top: 137: for (i = 0; i < sizeof wrkvec / sizeof wrkvec[0]; i++) 138: wrkvec[i] = 0; 139: DEBUG(4, "*** TOP *** - role=%d, ", role); 140: setline(RESET); 141: if (role == MASTER) { 142: /* get work */ 143: if ((narg = gtwvec(Wfile, Spool, wkpre, wrkvec)) == 0) { 144: WMESG(HUP, ""); 145: RMESG(HUP, msg, 1); 146: goto process; 147: } 148: wrktype = W_TYPE[0]; 149: mailopt = index(W_OPTNS, 'm') != NULL; 150: ntfyopt = index(W_OPTNS, 'n') != NULL; 151: 152: msg[0] = '\0'; 153: for (i = 1; i < narg; i++) { 154: strcat(msg, " "); 155: strcat(msg, wrkvec[i]); 156: } 157: 158: if (wrktype == XUUCP) { 159: sprintf(rqstr, "X %s", msg); 160: logent(rqstr, "REQUEST"); 161: goto sendmsg; 162: } 163: 164: ASSERT(narg > 4, "ARG COUNT<5", "", i); 165: sprintf(User, "%.9s", W_USER); 166: sprintf(rqstr, "%s %s %s %s", W_TYPE, W_FILE1, 167: W_FILE2, W_USER); 168: logent(rqstr, "REQUEST"); 169: if (wrktype == SNDFILE ) { 170: strcpy(filename, W_FILE1); 171: i = expfile(filename); 172: DEBUG(4, "expfile type - %d", i); 173: if (i != 0 && chkpth(User, "", filename)) 174: goto e_access; 175: strcpy(Dfile, W_DFILE); 176: fp = NULL; 177: if (index(W_OPTNS, 'c') == NULL) { 178: fp = fopen(subfile(Dfile), "r"); 179: if (fp != NULL) 180: i = 0; 181: } 182: if (fp == NULL && 183: (fp = fopen(subfile(filename), "r")) == NULL) { 184: /* can not read data file */ 185: logent("CAN'T READ DATA", "FAILED"); 186: unlinkdf(Dfile); 187: lnotify(User, filename, "can't access"); 188: goto top; 189: } 190: /* if file exists but is not generally readable... */ 191: if (i != 0 && fstat(fileno(fp), &stbuf) == 0 192: && (stbuf.st_mode & ANYREAD) == 0) { 193: e_access:; 194: /* access denied */ 195: fclose(fp); 196: fp = NULL; 197: logent("DENIED", "ACCESS"); 198: unlinkdf(W_DFILE); 199: lnotify(User, filename, "access denied"); 200: goto top; 201: } 202: 203: setline(SNDFILE); 204: } 205: 206: if (wrktype == RCVFILE) { 207: strcpy(filename, W_FILE2); 208: expfile(filename); 209: if (chkpth(User, "", filename) 210: || chkperm(filename, index(W_OPTNS, 'd'))) { 211: /* access denied */ 212: logent("DENIED", "ACCESS"); 213: lnotify(User, filename, "access denied"); 214: goto top; 215: } 216: sprintf(Dfile, "%s/TM.%05d.%03d", Spool, pnum, tmpnum++); 217: if ((fp = fopen(subfile(Dfile), "w")) == NULL) { 218: /* can not create temp */ 219: logent("CAN'T CREATE TM", "FAILED"); 220: unlinkdf(Dfile); 221: goto top; 222: } 223: setline(RCVFILE); 224: } 225: sendmsg: 226: DEBUG(4, "wrktype - %c\n ", wrktype); 227: WMESG(wrktype, msg); 228: RMESG(wrktype, msg, 1); 229: goto process; 230: } 231: 232: /* role is slave */ 233: RAMESG(msg, 1); 234: goto process; 235: 236: process: 237: /* rti!trt: ultouch is now done in gio.c (yes, kludge) 238: * ultouch(); 239: */ 240: DEBUG(4, " PROCESS: msg - %s\n", msg); 241: switch (msg[0]) { 242: 243: case RQSTCMPT: 244: DEBUG(4, "%s\n", "RQSTCMPT:"); 245: if (msg[1] == 'N') { 246: i = atoi(&msg[2]); 247: if (i<0 || i>EM_MAX) i=0; 248: /* duke!rti: only note failed requests */ 249: logent(msg, "REQUESTED"); 250: } 251: if (role == MASTER) { 252: notify(mailopt, W_USER, W_FILE1, Rmtname, &msg[1]); 253: } 254: goto top; 255: 256: case HUP: 257: DEBUG(4, "%s\n", "HUP:"); 258: if (msg[1] == 'Y') { 259: WMESG(HUP, YES); 260: (*Turnoff)(); 261: Rdmsg = Imsg; 262: Wrmsg = Omsg; 263: return(0); 264: } 265: 266: if (msg[1] == 'N') { 267: ASSERT(role == MASTER, "WRONG ROLE", "", role); 268: role = SLAVE; 269: goto top; 270: } 271: 272: /* get work */ 273: if (!iswrk(Wfile, "chk", Spool, wkpre)) { 274: WMESG(HUP, YES); 275: RMESG(HUP, msg, 1); 276: goto process; 277: } 278: 279: WMESG(HUP, NO); 280: role = MASTER; 281: goto top; 282: 283: case XUUCP: 284: if (role == MASTER) { 285: goto top; 286: } 287: 288: /* slave part */ 289: i = getargs(msg, wrkvec); 290: strcpy(filename, W_FILE1); 291: if (index(filename, ';') != NULL 292: || index(W_FILE2, ';') != NULL 293: || i < 3) { 294: WMESG(XUUCP, NO); 295: goto top; 296: } 297: expfile(filename); 298: if (chkpth("", Rmtname, filename)) { 299: WMESG(XUUCP, NO); 300: logent("XUUCP DENIED", filename); 301: goto top; 302: } 303: sprintf(rqstr, "%s %s", filename, W_FILE2); 304: xuucp(rqstr); 305: WMESG(XUUCP, YES); 306: goto top; 307: 308: case SNDFILE: 309: /* MASTER section of SNDFILE */ 310: 311: DEBUG(4, "%s\n", "SNDFILE:"); 312: if (msg[1] == 'N') { 313: i = atoi(&msg[2]); 314: if (i < 0 || i > EM_MAX) 315: i = 0; 316: logent(Em_msg[i], "REQUEST"); 317: notify(mailopt, W_USER, W_FILE1, Rmtname, &msg[1]); 318: ASSERT(role == MASTER, "WRONG ROLE", "", role); 319: fclose(fp); 320: fp = NULL; 321: if (msg[1] != '4') 322: unlinkdf(W_DFILE); 323: goto top; 324: } 325: 326: if (msg[1] == 'Y') { 327: /* send file */ 328: ASSERT(role == MASTER, "WRONG ROLE", "", role); 329: ret = fstat(fileno(fp), &stbuf); 330: ASSERT(ret != -1, "STAT FAILED", filename, 0); 331: i = 1 + (int)(stbuf.st_size / XFRRATE); 332: ret = (*Wrdata)(fp, Ofn); 333: fclose(fp); 334: fp = NULL; 335: if (ret != 0) { 336: (*Turnoff)(); 337: return(FAIL); 338: } 339: RMESG(RQSTCMPT, msg, i); 340: /* put the unlink *after* the RMESG -- fortune!Dave-Yost */ 341: unlinkdf(W_DFILE); 342: goto process; 343: } 344: 345: /* SLAVE section of SNDFILE */ 346: ASSERT(role == SLAVE, "WRONG ROLE", "", role); 347: 348: /* request to receive file */ 349: /* check permissions */ 350: i = getargs(msg, wrkvec); 351: ASSERT(i > 4, "ARG COUNT<5", "", i); 352: sprintf(rqstr, "%s %s %s %s", W_TYPE, W_FILE1, 353: W_FILE2, W_USER); 354: logent(rqstr, "REQUESTED"); 355: DEBUG(4, "msg - %s\n", msg); 356: strcpy(filename, W_FILE2); 357: /* Run uuxqt occasionally */ 358: if (filename[0] == XQTPRE) { 359: if (++nXfiles > 10) { 360: nXfiles = 0; 361: /* I sure hope the wait(II) does not hang. 362: * One can never tell about UNIX variants. 363: */ 364: if (++nXQTs > 2) 365: wait((int *)0); 366: xuuxqt(); 367: } 368: } 369: /* rti!trt: expand filename, i is set to 0 if this is 370: * is a vanilla spool file, so no stat(II)s are needed */ 371: i = expfile(filename); 372: DEBUG(4, "expfile type - %d\n", i); 373: if (i != 0) { 374: if (chkpth("", Rmtname, filename) 375: || chkperm(filename, index(W_OPTNS, 'd'))) { 376: WMESG(SNDFILE, EM_RMTACC); 377: logent("DENIED", "PERMISSION"); 378: goto top; 379: } 380: if (isdir(filename)) { 381: strcat(filename, "/"); 382: strcat(filename, lastpart(W_FILE1)); 383: } 384: } 385: sprintf(User, "%.9s", W_USER); 386: 387: DEBUG(4, "chkpth ok Rmtname - %s\n", Rmtname); 388: sprintf(Dfile, "%s/TM.%05d.%03d", Spool, pnum, tmpnum++); 389: if((fp = fopen(subfile(Dfile), "w")) == NULL) { 390: WMESG(SNDFILE, EM_NOTMP); 391: logent("CAN'T OPEN", "DENIED"); 392: unlinkdf(Dfile); 393: goto top; 394: } 395: 396: WMESG(SNDFILE, YES); 397: ret = (*Rddata)(Ifn, fp); 398: /* ittvax!swatt: (try to) make sure IO successful */ 399: fflush(fp); 400: if (ferror(fp) || fclose(fp)) 401: ret = FAIL; 402: if (ret != 0) { 403: (*Turnoff)(); 404: return(FAIL); 405: } 406: /* copy to user directory */ 407: ntfyopt = index(W_OPTNS, 'n') != NULL; 408: status = xmv(Dfile, filename); 409: WMESG(RQSTCMPT, status ? EM_RMTCP : YES); 410: if (status == 0) { 411: sscanf(W_MODE, "%o", &filemode); 412: if (filemode <= 0) 413: filemode = BASEMODE; 414: chmod(subfile(filename), filemode | BASEMODE); 415: arrived(ntfyopt, filename, W_NUSER, Rmtname, User); 416: } 417: else { 418: logent("FAILED", "COPY"); 419: status = putinpub(filename, Dfile, W_USER); 420: DEBUG(4, "->PUBDIR %d\n", status); 421: if (status == 0) 422: arrived(ntfyopt, filename, W_NUSER, 423: Rmtname, User); 424: } 425: 426: goto top; 427: 428: case RCVFILE: 429: /* MASTER section of RCVFILE */ 430: 431: DEBUG(4, "%s\n", "RCVFILE:"); 432: if (msg[1] == 'N') { 433: i = atoi(&msg[2]); 434: if (i < 0 || i > EM_MAX) 435: i = 0; 436: logent(Em_msg[i], "REQUEST"); 437: notify(mailopt, W_USER, W_FILE1, Rmtname, &msg[1]); 438: ASSERT(role == MASTER, "WRONG ROLE", "", role); 439: fclose(fp); 440: unlinkdf(Dfile); 441: goto top; 442: } 443: 444: if (msg[1] == 'Y') { 445: /* receive file */ 446: ASSERT(role == MASTER, "WRONG ROLE", "", role); 447: ret = (*Rddata)(Ifn, fp); 448: /* ittvax!swatt: (try to) make sure IO successful */ 449: fflush(fp); 450: if (ferror(fp) || fclose(fp)) 451: ret = FAIL; 452: if (ret != 0) { 453: (*Turnoff)(); 454: return(FAIL); 455: } 456: /* copy to user directory */ 457: if (isdir(filename)) { 458: strcat(filename, "/"); 459: strcat(filename, lastpart(W_FILE1)); 460: } 461: status = xmv(Dfile, filename); 462: WMESG(RQSTCMPT, status ? EM_RMTCP : YES); 463: notify(mailopt, W_USER, filename, Rmtname, 464: status ? EM_LOCCP : YES); 465: if (status == 0) { 466: sscanf(&msg[2], "%o", &filemode); 467: if (filemode <= 0) 468: filemode = BASEMODE; 469: chmod(subfile(filename), filemode | BASEMODE); 470: } 471: else { 472: logent("FAILED", "COPY"); 473: putinpub(filename, Dfile, W_USER); 474: } 475: goto top; 476: } 477: 478: /* SLAVE section of RCVFILE */ 479: ASSERT(role == SLAVE, "WRONG ROLE", "", role); 480: 481: /* request to send file */ 482: strcpy(rqstr, msg); 483: logent(rqstr, "REQUESTED"); 484: 485: /* check permissions */ 486: i = getargs(msg, wrkvec); 487: ASSERT(i > 3, "ARG COUNT<4", "", i); 488: DEBUG(4, "msg - %s\n", msg); 489: DEBUG(4, "W_FILE1 - %s\n", W_FILE1); 490: strcpy(filename, W_FILE1); 491: expfile(filename); 492: if (isdir(filename)) { 493: strcat(filename, "/"); 494: strcat(filename, lastpart(W_FILE2)); 495: } 496: sprintf(User, "%.9s", W_USER); 497: if (chkpth("", Rmtname, filename) || anyread(filename)) { 498: WMESG(RCVFILE, EM_RMTACC); 499: logent("DENIED", "PERMISSION"); 500: goto top; 501: } 502: DEBUG(4, "chkpth ok Rmtname - %s\n", Rmtname); 503: 504: if ((fp = fopen(subfile(filename), "r")) == NULL) { 505: WMESG(RCVFILE, EM_RMTACC); 506: logent("CAN'T OPEN", "DENIED"); 507: goto top; 508: } 509: 510: /* ok to send file */ 511: ret = fstat(fileno(fp), &stbuf); 512: ASSERT(ret != -1, "STAT FAILED", filename, 0); 513: i = 1 + (int)(stbuf.st_size / XFRRATE); 514: sprintf(msg, "%s %o", YES, stbuf.st_mode & 0777); 515: WMESG(RCVFILE, msg); 516: ret = (*Wrdata)(fp, Ofn); 517: fclose(fp); 518: if (ret != 0) { 519: (*Turnoff)(); 520: return(FAIL); 521: } 522: RMESG(RQSTCMPT, msg, i); 523: goto process; 524: } 525: (*Turnoff)(); 526: return(FAIL); 527: } 528: 529: 530: /*** 531: * rmesg(c, msg, n) read message 'c' 532: * try 'n' times 533: * char *msg, c; 534: * 535: * return code: 0 | FAIL 536: */ 537: 538: rmesg(c, msg, n) 539: register char *msg, c; 540: register int n; 541: { 542: char str[50]; 543: 544: DEBUG(4, "rmesg - '%c' ", c); 545: if (n != 1) { 546: sprintf(str, "%d", n); 547: logent(str, "PATIENCE"); 548: } 549: while ((*Rdmsg)(msg, Ifn) != 0) { 550: if (--n > 0) 551: continue; 552: DEBUG(4, "got %s\n", "FAIL"); 553: sprintf(str, "expected '%c' got FAIL", c); 554: logent(str, "BAD READ"); 555: return(FAIL); 556: } 557: if (c != '\0' && msg[0] != c) { 558: DEBUG(4, "got %s\n", msg); 559: sprintf(str, "expected '%c' got %.25s", c, msg); 560: logent(str, "BAD READ"); 561: return(FAIL); 562: } 563: DEBUG(4, "got %.25s\n", msg); 564: return(0); 565: } 566: 567: 568: /*** 569: * wmesg(m, s) write a message (type m) 570: * char *s, m; 571: * 572: * return codes: 0 - ok | FAIL - ng 573: */ 574: 575: wmesg(m, s) 576: register char *s, m; 577: { 578: DEBUG(4, "wmesg '%c'", m); 579: DEBUG(4, "%.25s\n", s); 580: return((*Wrmsg)(m, s, Ofn)); 581: } 582: 583: 584: /*** 585: * notify mail results of command 586: * 587: * return codes: none 588: */ 589: 590: notify(mailopt, user, file, sys, msgcode) 591: char *user, *file, *sys, *msgcode; 592: { 593: char str[200]; 594: int i; 595: char *msg; 596: 597: if (!mailopt && *msgcode == 'Y') 598: return; 599: if (*msgcode == 'Y') 600: msg = "copy succeeded"; 601: else { 602: i = atoi(msgcode + 1); 603: if (i < 1 || i > EM_MAX) 604: i = 0; 605: msg = Em_msg[i]; 606: } 607: sprintf(str, "file %s, system %s\n%s\n", 608: file, sys, msg); 609: mailst(user, str, ""); 610: return; 611: } 612: 613: /*** 614: * lnotify(user, file, mesg) - local notify 615: * 616: * return code - none 617: */ 618: 619: lnotify(user, file, mesg) 620: char *user, *file, *mesg; 621: { 622: char mbuf[200]; 623: sprintf(mbuf, "file %s on %s\n%s\n", file, Myname, mesg); 624: mailst(user, mbuf, ""); 625: return; 626: } 627: 628: 629: /*** 630: * startup(role) 631: * int role; 632: * 633: * startup - this routine will converse with the remote 634: * machine, agree upon a protocol (if possible) and start the 635: * protocol. 636: * 637: * return codes: 638: * SUCCESS - successful protocol selection 639: * FAIL - can't find common or open failed 640: */ 641: 642: startup(role) 643: int role; 644: { 645: extern (*Rdmsg)(), (*Wrmsg)(); 646: extern char *blptcl(), fptcl(); 647: char msg[BUFSIZ], str[BUFSIZ]; 648: 649: Rdmsg = Imsg; 650: Wrmsg = Omsg; 651: if (role == MASTER) { 652: RMESG(SLTPTCL, msg, 1); 653: if ((str[0] = fptcl(&msg[1])) == NULL) { 654: /* no protocol match */ 655: WMESG(USEPTCL, NO); 656: return(FAIL); 657: } 658: str[1] = '\0'; 659: WMESG(USEPTCL, str); 660: if (stptcl(str) != 0) 661: return(FAIL); 662: DEBUG(4, "protocol %s\n", str); 663: return(SUCCESS); 664: } 665: else { 666: WMESG(SLTPTCL, blptcl(str)); 667: RMESG(USEPTCL, msg, 1); 668: if (msg[1] == 'N') { 669: return(FAIL); 670: } 671: 672: if (stptcl(&msg[1]) != 0) 673: return(FAIL); 674: DEBUG(4, "Protocol %s\n", msg); 675: return(SUCCESS); 676: } 677: } 678: 679: 680: /******* 681: * char 682: * fptcl(str) 683: * char *str; 684: * 685: * fptcl - this routine will choose a protocol from 686: * the input string (str) and return the found letter. 687: * 688: * return codes: 689: * '\0' - no acceptable protocol 690: * any character - the chosen protocol 691: */ 692: 693: char 694: fptcl(str) 695: register char *str; 696: { 697: register struct Proto *p; 698: 699: for (p = Ptbl; p->P_id != '\0'; p++) { 700: if (index(str, p->P_id) != NULL) { 701: return(p->P_id); 702: } 703: } 704: 705: return('\0'); 706: } 707: 708: 709: /*** 710: * char * 711: * blptcl(str) 712: * char *str; 713: * 714: * blptcl - this will build a string of the 715: * letters of the available protocols and return 716: * the string (str). 717: * 718: * return: 719: * a pointer to string (str) 720: */ 721: 722: char * 723: blptcl(str) 724: register char *str; 725: { 726: register struct Proto *p; 727: register char *s; 728: 729: for (p = Ptbl, s = str; (*s++ = p->P_id) != '\0'; p++); 730: return(str); 731: } 732: 733: /*** 734: * stptcl(c) 735: * char *c; 736: * 737: * stptcl - this routine will set up the six routines 738: * (Rdmsg, Wrmsg, Rddata, Wrdata, Turnon, Turnoff) for the 739: * desired protocol. 740: * 741: * return codes: 742: * SUCCESS - ok 743: * FAIL - no find or failed to open 744: * 745: */ 746: 747: stptcl(c) 748: register char *c; 749: { 750: register struct Proto *p; 751: 752: for (p = Ptbl; p->P_id != '\0'; p++) { 753: if (*c == p->P_id) { 754: /* found protocol - set routines */ 755: Rdmsg = p->P_rdmsg; 756: Wrmsg = p->P_wrmsg; 757: Rddata = p->P_rddata; 758: Wrdata = p->P_wrdata; 759: Turnon = p->P_turnon; 760: Turnoff = p->P_turnoff; 761: if ((*Turnon)() != 0) 762: return(FAIL); 763: DEBUG(4, "Proto started %c\n", *c); 764: return(SUCCESS); 765: } 766: } 767: DEBUG(4, "Proto start-fail %c\n", *c); 768: return(FAIL); 769: } 770: 771: /*** 772: * putinpub put file in public place 773: * if successful, filename is modified 774: * 775: * return code 0 | FAIL 776: */ 777: 778: putinpub(file, tmp, user) 779: register char *file, *user, *tmp; 780: { 781: char fullname[MAXFULLNAME]; 782: char *lastpart(); 783: int status; 784: 785: sprintf(fullname, "%s/%s/", PUBDIR, user); 786: if (mkdirs(fullname) != 0) { 787: /* can not make directories */ 788: return(FAIL); 789: } 790: strcat(fullname, lastpart(file)); 791: status = xmv(tmp, fullname); 792: if (status == 0) { 793: strcpy(file, fullname); 794: chmod(subfile(fullname), BASEMODE); 795: } 796: return(status); 797: } 798: 799: /*** 800: * unlinkdf(file) - unlink D. file 801: * 802: * return code - none 803: */ 804: 805: unlinkdf(file) 806: register char *file; 807: { 808: if (strlen(file) > 6) 809: unlink(subfile(file)); 810: return; 811: } 812: 813: /*** 814: * arrived - notify receiver of arrived file 815: * 816: * return code - none 817: */ 818: 819: arrived(opt, file, nuser, rmtsys, rmtuser) 820: char *file, *nuser, *rmtsys, *rmtuser; 821: { 822: char mbuf[200]; 823: 824: if (!opt) 825: return; 826: sprintf(mbuf, "%s from %s!%s arrived\n", file, rmtsys, rmtuser); 827: mailst(nuser, mbuf, ""); 828: return; 829: }