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