![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uucp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / uucp|
Return to uucp.c CVS log | Up to [Research Unix] / researchv10no / cmd / uucp |
1.1 root 1: /* @(#)uucp.c 1.6
2: */
3: #include "uucp.h"
4: VERSION(@(#)uucp.c 1.6);
5:
6: /*
7: * uucp
8: * user id
9: * make a copy in spool directory
10: */
11: int Copy = 0;
12: static int _Transfer = 0;
13: char Nuser[32];
14: char *Ropt = " ";
15: char Optns[10];
16: char Uopts[BUFSIZ];
17: char Grade = 'N';
18:
19: char Sfile[MAXFULLNAME];
20: #ifndef V7
21: long ulimit();
22: #endif
23:
24: main(argc, argv, envp)
25: char *argv[];
26: char **envp;
27: {
28: int ret;
29: int errors = 0;
30: char *fopt;
31: char sys1[MAXFULLNAME], sys2[MAXFULLNAME];
32: char fwd1[MAXFULLNAME], fwd2[MAXFULLNAME];
33: char file1[MAXFULLNAME], file2[MAXFULLNAME];
34: short jflag = 0; /* -j flag Jobid printout */
35:
36: void split();
37: #ifndef V7
38: long limit, dummy;
39: char msg[100];
40: #endif V7
41:
42:
43: /* this fails in some versions, but it doesn't hurt */
44: Uid = getuid();
45: Euid = geteuid();
46: if (Uid == 0)
47: (void) setuid(UUCPUID);
48:
49: /* choose LOGFILE */
50: (void) strcpy(Logfile, LOGUUCP);
51:
52: Env = envp;
53: fopt = NULL;
54: (void) strcpy(Progname, "uucp");
55: Pchar = 'U';
56: *Uopts = NULLCHAR;
57:
58: /*
59: * find name of local system
60: */
61: uucpname(Myname);
62: Optns[0] = '-';
63: Optns[1] = 'd';
64: Optns[2] = 'c';
65: Optns[3] = Nuser[0] = Sfile[0] = NULLCHAR;
66:
67: /*
68: * find id of user who spawned command to
69: * determine
70: */
71: (void) guinfo(Uid, User);
72:
73: while ((ret = getopt(argc, argv, "Ccdfg:jmn:rx:")) != EOF) {
74: switch (ret) {
75:
76: /*
77: * make a copy of the file in the spool
78: * directory.
79: */
80: case 'C':
81: Copy = 1;
82: Optns[2] = 'C';
83: break;
84:
85: /*
86: * not used (default)
87: */
88: case 'c':
89: break;
90:
91: /*
92: * not used (default)
93: */
94: case 'd':
95: break;
96: case 'f':
97: Optns[1] = 'f';
98: break;
99:
100: /*
101: * set service grade
102: */
103: case 'g':
104: Grade = *optarg;
105: break;
106:
107: case 'j': /* job id */
108: jflag = 1;
109: break;
110:
111: /*
112: * send notification to local user
113: */
114: case 'm':
115: (void) strcat(Optns, "m");
116: break;
117:
118: /*
119: * send notification to user on remote
120: * if no user specified do not send notification
121: */
122: case 'n':
123: (void) strcat(Optns, "n");
124: (void) sprintf(Nuser, "%.8s", optarg);
125: (void) sprintf(Uopts+strlen(Uopts), "-n%s ", Nuser);
126: break;
127:
128: /*
129: * create JCL files but do not start uucico
130: */
131: case 'r':
132: Ropt = "-r";
133: break;
134:
135: /*
136: * return status file
137: */
138:
139: /*
140: * turn on debugging
141: */
142: case 'x':
143: Debug = atoi(optarg);
144: if (Debug <= 0)
145: Debug = 1;
146: break;
147:
148: default:
149: /* getopt has already (stupidly) babbled */
150: break;
151: }
152: }
153: DEBUG(4, "\n\n** %s **\n", "START");
154: gwd(Wrkdir);
155: if (fopt) {
156: if (*fopt != '/')
157: (void) sprintf(Sfile, "%s/%s", Wrkdir, fopt);
158: else
159: (void) sprintf(Sfile, "%s", fopt);
160:
161: }
162: /*
163: * work in WORKSPACE directory
164: */
165: ret = chdir(WORKSPACE);
166: if (ret != 0) {
167: (void) fprintf(stderr, "No work directory - %s - get help\n",
168: WORKSPACE);
169: cleanup(-12);
170: }
171:
172: if (Nuser[0] == NULLCHAR)
173: (void) strcpy(Nuser, User);
174: (void) strcpy(Loginuser, User);
175: DEBUG(4, "UID %d, ", Uid);
176: DEBUG(4, "User %s\n", User);
177: if (argc - optind < 2) {
178: (void) fprintf(stderr, "usage uucp from ... to\n");
179: cleanup(-2);
180: }
181:
182: /*
183: * set up "to" system and file names
184: */
185:
186: split(argv[argc - 1], sys2, fwd2, file2);
187: if (*sys2 != NULLCHAR) {
188: if (versys(sys2, 0) != 0) {
189: (void) fprintf(stderr, "bad system: %s\n", sys2);
190: cleanup(-11);
191: }
192: }
193: else
194: (void) strcpy(sys2, Myname);
195:
196: (void) strncpy(Rmtname, sys2, MAXBASENAME);
197: Rmtname[MAXBASENAME] = NULLCHAR;
198:
199: DEBUG(9, "sys2: %s, ", sys2);
200: DEBUG(9, "fwd2: %s, ", fwd2);
201: DEBUG(9, "file2: %s\n", file2);
202:
203: /*
204: * if there are more than 2 argsc, file2 is a directory
205: */
206: if (argc - optind > 2)
207: (void) strcat(file2, "/");
208:
209: /*
210: * do each from argument
211: */
212:
213: for ( ; optind < argc - 1; optind++) {
214: split(argv[optind], sys1, fwd1, file1);
215: if (*sys1 != NULLCHAR) {
216: if (versys(sys1, 0) != 0) {
217: (void) fprintf(stderr, "bad system: %s\n", sys1);
218: cleanup(-11);
219: }
220: }
221:
222: /* source files can have at most one ! */
223: if (*fwd1 != NULLCHAR) {
224: /* syntax error */
225: (void) fprintf(stderr, "illegal syntax %s\n", argv[optind]);
226: exit(2);
227: }
228:
229: /*
230: * check for required remote expansion of file names -- generate
231: * and execute a uux command
232: * e.g.
233: * uucp owl!~/dan/* ~/dan/
234: *
235: * NOTE: The source file part must be full path name.
236: * If ~ it will be expanded locally - it assumes the remote
237: * names are the same.
238: */
239:
240: if (*sys1 != NULLCHAR)
241: if ((strchr(file1, '*') != NULL
242: || strchr(file1, '?') != NULL
243: || strchr(file1, '[') != NULL)) {
244: /* do a uux command */
245: if (ckexpf(file1) == FAIL)
246: exit(6);
247: ruux(sys1, sys1, file1, sys2, fwd2, file2);
248: continue;
249: }
250:
251: /*
252: * check for forwarding -- generate and execute a uux command
253: * e.g.
254: * uucp uucp.c raven!owl!~/dan/
255: */
256:
257: if (*fwd2 != NULLCHAR) {
258: ruux(sys2, sys1, file1, "", fwd2, file2);
259: continue;
260: }
261:
262: /*
263: * check for both source and destination on other systems --
264: * generate and execute a uux command
265: */
266:
267: if (*sys1 != NULLCHAR )
268: if ( (!EQUALS(Myname, sys1))
269: && *sys2 != NULLCHAR
270: && (!EQUALS(sys2, Myname)) ) {
271: ruux(sys2, sys1, file1, "", fwd2, file2);
272: continue;
273: }
274:
275:
276: if (*sys1 == NULLCHAR)
277: (void) strcpy(sys1, Myname);
278: else {
279: (void) strncpy(Rmtname, sys1, MAXBASENAME);
280: Rmtname[MAXBASENAME] = NULLCHAR;
281: }
282:
283: DEBUG(4, "sys1 - %s, ", sys1);
284: DEBUG(4, "file1 - %s, ", file1);
285: DEBUG(4, "Rmtname - %s\n", Rmtname);
286: if (copy(sys1, file1, sys2, file2))
287: errors++;
288: }
289:
290: /* move the work files to their proper places */
291: commitall();
292:
293: /*
294: * do not spawn daemon if -r option specified
295: */
296: #ifndef V7
297: limit = ulimit(1, dummy);
298: #endif V7
299: if (*Ropt != '-')
300: #ifndef V7
301: if (limit < MINULIMIT) {
302: (void) sprintf(msg,
303: "ULIMIT (%ld) < MINULIMIT (%ld)", limit, MINULIMIT);
304: logent(msg, "Low-ULIMIT");
305: }
306: else
307: #endif
308: xuucico(Rmtname);
309: if (jflag)
310: printf("%s\n", Jobid);
311: cleanup(errors);
312: }
313:
314: /*
315: * cleanup lock files before exiting
316: */
317: cleanup(code)
318: register int code;
319: {
320: rmlock(CNULL);
321: if (code != 0)
322: wfabort(); /* this may be extreme -- abort all work */
323: if (code < 0) {
324: (void) fprintf(stderr, "uucp failed completely (%d)\n", (-code));
325: exit(-code);
326: }
327: else if (code > 0) {
328: (void) fprintf(stderr,
329: "uucp failed partially: %d file(s) sent; %d error(s)\n",
330: _Transfer, code);
331: exit(code);
332: }
333: exit(code);
334: }
335:
336: /*
337: * generate copy files for s1!f1 -> s2!f2
338: * Note: only one remote machine, other situations
339: * have been taken care of in main.
340: * return:
341: * 0 -> success
342: * Non-zero -> failure
343: */
344:
345: copy(s1, f1, s2, f2)
346: char *s1, *f1, *s2, *f2;
347: {
348: FILE *cfp, *syscfile();
349: struct stat stbuf, stbuf1;
350: int type, statret;
351: char dfile[NAMESIZE];
352: char cfile[NAMESIZE];
353: char file1[MAXFULLNAME], file2[MAXFULLNAME];
354: char msg[BUFSIZ];
355:
356: type = 0;
357: (void) strcpy(file1, f1);
358: (void) strcpy(file2, f2);
359: if (!EQUALS(s1, Myname))
360: type = 1;
361: if (!EQUALS(s2, Myname))
362: type = 2;
363:
364: switch (type) {
365: case 0:
366:
367: /*
368: * all work here
369: */
370: DEBUG(4, "all work here %d\n", type);
371:
372: /*
373: * check access control permissions
374: */
375: if (ckexpf(file1))
376: return(-6);
377: if (ckexpf(file2))
378: return(-7);
379: if (uidstat(file1, &stbuf) != 0) {
380: (void) fprintf(stderr,
381: "can't get file status %s\n copy failed\n", file1);
382: return(8);
383: }
384: statret = uidstat(file2, &stbuf1);
385: if (statret == 0
386: && stbuf.st_ino == stbuf1.st_ino
387: && stbuf.st_dev == stbuf1.st_dev) {
388: (void) fprintf(stderr,
389: "%s %s - same file; can't copy\n", file1, file2);
390: return(5);
391: }
392: if (chkperm(file1, file2, strchr(Optns, 'd')) ) {
393: (void) fprintf(stderr, "permission denied\n");
394: cleanup(1);
395: }
396: if ((stbuf.st_mode & S_IFMT) == S_IFDIR) {
397: (void) fprintf(stderr, "directory name illegal - %s\n",
398: file1);
399: return(9);
400: }
401: /* see if I can read this file as read uid, gid */
402: if ( !(stbuf.st_mode & ANYREAD)
403: && !(stbuf.st_uid == Uid && stbuf.st_mode & 0400)
404: && !(stbuf.st_gid == getgid() && stbuf.st_mode & 0040)
405: ) {
406: (void) fprintf(stderr,
407: "uucp can't read (%s) mode (%o)\n",
408: file1, stbuf.st_mode);
409: (void) fprintf(stderr, "use cp command\n");
410: return(3);
411: }
412: if (statret == 0 && (stbuf1.st_mode & ANYWRITE) == 0) {
413: (void) fprintf(stderr,
414: "can't write file (%s) mode (%o)\n",
415: file2, stbuf1.st_mode);
416: return(4);
417: }
418:
419: /*
420: * copy file locally
421: */
422: DEBUG(2, "local copy: uidxcp(%s, ", file1);
423: DEBUG(2, "%s\n", file2);
424:
425: /* do copy as Uid, but the file will be owned by uucp */
426: if (uidxcp(file1, file2) == FAIL) {
427: (void) fprintf(stderr,
428: "can't copy file (%s) errno %d\n", file2, errno);
429: return(5);
430: }
431: (void) chmod(file2, (int) (stbuf.st_mode | 0666) & 0777);
432: return(0);
433: case 1:
434:
435: /*
436: * receive file
437: */
438: DEBUG(4, "receive file - %d\n", type);
439:
440: /*
441: * expand source and destination file names
442: * and check access permissions
443: */
444: if (file1[0] != '~')
445: if (ckexpf(file1))
446: return(6);
447: if (ckexpf(file2))
448: return(7);
449:
450: /*
451: * insert JCL card in file
452: */
453: cfp = syscfile(cfile, s1);
454: (void) fprintf(cfp,
455: "R %s %s %s %s %s %o %s\n", file1, file2,
456: User, Optns,
457: *Sfile ? Sfile : "dummy",
458: 0777, Nuser);
459: (void) fclose(cfp);
460: (void) sprintf(msg, "%s!%s --> %s!%s", Rmtname, file1,
461: Myname, file2);
462: logent(msg, "QUEUED");
463: break;
464: case 2:
465:
466: /*
467: * send file
468: */
469: if (ckexpf(file1))
470: return(6);
471: /* XQTDIR hook enables 3rd party uux requests (cough) */
472: if (file2[0] != '~' && !EQUALS(Wrkdir, XQTDIR))
473: if (ckexpf(file2))
474: return(7);
475: DEBUG(4, "send file - %d\n", type);
476:
477: if (uidstat(file1, &stbuf) != 0) {
478: (void) fprintf(stderr,
479: "can't get status for file %s\n", file1);
480: return(8);
481: }
482: if ((stbuf.st_mode & S_IFMT) == S_IFDIR) {
483: (void) fprintf(stderr,
484: "directory name illegal - %s\n", file1);
485: return(9);
486: }
487:
488: /*
489: * make a copy of file in spool directory
490: */
491: if (Copy || !READANY(file1) ) {
492: gename(DATAPRE, s2, Grade, dfile);
493:
494: if (uidxcp(file1, dfile))
495: return(5);
496:
497: (void) chmod(dfile, DFILEMODE);
498: wfcommit(dfile, dfile, s2);
499: } else {
500:
501: /*
502: * make a dummy D. name
503: * cntrl.c knows names < 6 chars are dummy D. files
504: */
505: (void) strcpy(dfile, "D.0");
506: }
507:
508: /*
509: * insert JCL card in file
510: */
511: cfp = syscfile(cfile, s2);
512: (void) fprintf(cfp, "S %s %s %s %s %s %o %s %s\n",
513: file1, file2, User, Optns, dfile,
514: stbuf.st_mode & 0777, Nuser, Sfile);
515: (void) fclose(cfp);
516: (void) sprintf(msg, "%s!%s --> %s!%s", Myname, file1,
517: Rmtname, file2);
518: logent(msg, "QUEUED");
519: break;
520: }
521: _Transfer++;
522: return(0);
523: }
524:
525:
526: /*
527: * syscfile(file, sys)
528: * char *file, *sys;
529: *
530: * get the cfile for system sys (creat if need be)
531: * return stream pointer
532: *
533: * returns
534: * stream pointer to open cfile
535: *
536: */
537:
538: static FILE *
539: syscfile(file, sys)
540: char *file, *sys;
541: {
542: FILE *cfp;
543:
544: if (gtcfile(file, sys) == FAIL) {
545: gename(CMDPRE, sys, Grade, file);
546: ASSERT(access(file, 0) != 0, Fl_EXISTS, file, errno);
547: cfp = fdopen(creat(file, CFILEMODE), "w");
548: svcfile(file, sys);
549: } else
550: cfp = fopen(file, "a");
551: /* set Jobid -- C.jobid */
552: (void) strncpy(Jobid, BASENAME(file, '.'), NAMESIZE);
553: Jobid[NAMESIZE-1] = '\0';
554: ASSERT(cfp != NULL, Ct_OPEN, file, errno);
555: return(cfp);
556: }
557:
558:
559: /*
560: * split - split the name into parts:
561: * sys - system name
562: * fwd - intermediate destinations
563: * file - file part
564: */
565:
566: static
567: void
568: split(arg, sys, fwd, file)
569: char *arg, *sys, *fwd, *file;
570: {
571: register char *cl, *cr, *n;
572: *sys = *fwd = *file = NULLCHAR;
573:
574: for (n=arg ;; n=cl+1) {
575: cl = strchr(n, '!');
576: if ( cl == NULL) {
577: /* no ! in n */
578: (void) strcpy(file, n);
579: return;
580: }
581:
582: if (PREFIX(Myname, n))
583: continue;
584:
585: cr = strrchr(n, '!');
586: (void) strcpy(file, cr+1);
587: (void) strncpy(sys, n, cl-n);
588: sys[cl-n] = NULLCHAR;
589:
590: if (cr != cl) {
591: /* more than one ! */
592: (void) strncpy(fwd, cl+1, cr-cl-1);
593: fwd[cr-cl-1] = NULLCHAR;
594: }
595: return;
596: }
597: /*NOTREACHED*/
598: }
599:
600:
601: /*
602: * generate and execute a uux command
603: */
604:
605: ruux(rmt, sys1, file1, sys2, fwd2, file2)
606: char *rmt, *sys1, *file1, *sys2, *fwd2, *file2;
607: {
608: char cmd[BUFSIZ];
609:
610: if (*Uopts != NULLCHAR)
611: (void) sprintf(cmd, "uux -C %s %s!uucp -C \\(%s\\) ", Ropt, rmt, Uopts);
612: else
613: (void) sprintf(cmd, "uux -C %s %s!uucp -C ", Ropt, rmt);
614:
615: if (*sys1 == NULLCHAR || EQUALS(sys1, Myname)) {
616: if (ckexpf(file1))
617: exit(6);
618: (void) sprintf(cmd+strlen(cmd), " %s!%s ", sys1, file1);
619: }
620: else
621: if (!EQUALS(rmt, sys1))
622: (void) sprintf(cmd+strlen(cmd), " \\(%s!%s\\) ", sys1, file1);
623: else
624: (void) sprintf(cmd+strlen(cmd), " \\(%s\\) ", file1);
625:
626: if (*fwd2 != NULLCHAR) {
627: if (*sys2 != NULLCHAR)
628: (void) sprintf(cmd+strlen(cmd),
629: " \\(%s!%s!%s\\) ", sys2, fwd2, file2);
630: else
631: (void) sprintf(cmd+strlen(cmd), " \\(%s!%s\\) ", fwd2, file2);
632: }
633: else {
634: if (*sys2 == NULLCHAR || EQUALS(sys2, Myname))
635: if (ckexpf(file2))
636: exit(7);
637: (void) sprintf(cmd+strlen(cmd), " \\(%s!%s\\) ", sys2, file2);
638: }
639:
640: DEBUG(2, "cmd: %s\n", cmd);
641: logent(cmd, "QUEUED");
642: system(cmd);
643: return;
644: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.