?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / cmd / bnu / cntrl.c
blob50b968cde454ac264a9dba5e35a7506a06afd2b4
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
28 /* All Rights Reserved */
29
30
31 #include "uucp.h"
32 #include "log.h"
33
34 void notify(), lnotify(), unlinkdf(), arrived();
35 static void stmesg();
36 static int nospace();
37
38 struct Proto {
39 char P_id;
40 int (*P_turnon)();
41 int (*P_rdmsg)();
42 int (*P_wrmsg)();
43 int (*P_rddata)();
44 int (*P_wrdata)();
45 int (*P_turnoff)();
46 };
47
48 extern char _Protocol[];
49 extern char *findProto();
50
51 extern char uuxqtarg[];
52
53 extern int gturnon(), gturnoff();
54 extern int grdmsg(), grddata();
55 extern int gwrmsg(), gwrdata();
56
57 extern int wmesg(), rmesg(), expfile(), putinpub(), stptcl();
58 extern void setline(), TMname(), cleanup(), pfEndfile(), statlog(), mailst();
59
60 #ifdef D_PROTOCOL
61 extern int dturnon(), dturnoff();
62 extern int drdmsg(), drddata();
63 extern int dwrmsg(), dwrdata();
64 #endif /* D_PROTOCOL */
65
66 #ifdef X_PROTOCOL
67 extern int xturnon(), xturnoff();
68 extern int xrdmsg(), xrddata();
69 extern int xwrmsg(), xwrdata();
70 #endif /* X_PROTOCOL */
71
72 #ifdef E_PROTOCOL
73 extern int eturnon(), eturnoff();
74 extern int erdmsg(), erddata();
75 extern int ewrmsg(), ewrdata();
76 extern int trdmsg(), twrmsg();
77 extern int trddata(), twrdata();
78 #endif /* E_PROTOCOL */
79
80 #ifdef F_PROTOCOL
81 extern int fturnon(), fturnoff();
82 extern int frdmsg(), frddata();
83 extern int fwrmsg(), fwrdata();
84 #endif /* F_PROTOCOL */
85
86 extern int imsg();
87 extern int omsg();
88 extern int turnoff();
89 extern long strtol();
90
91 struct Proto Ptbl[]={
92 {'g', gturnon, grdmsg, gwrmsg, grddata, gwrdata, gturnoff},
93 {'G', gturnon, grdmsg, gwrmsg, grddata, gwrdata, gturnoff},
94
95 #ifdef E_PROTOCOL
96 {'e', eturnon, erdmsg, ewrmsg, erddata, ewrdata, eturnoff},
97 {'t', eturnon, trdmsg, twrmsg, trddata, twrdata, eturnoff},
98 #endif /* E_PROTOCOL */
99
100 #ifdef D_PROTOCOL
101 {'d', dturnon, drdmsg, dwrmsg, drddata, dwrdata, dturnoff},
102 #endif /* D_PROTOCOL */
103
104 #ifdef X_PROTOCOL
105 {'x', xturnon, xrdmsg, xwrmsg, xrddata, xwrdata, xturnoff},
106 #endif /* X_PROTOCOL */
107
108 #ifdef F_PROTOCOL
109 {'f', fturnon, frdmsg, fwrmsg, frddata, fwrdata, fturnoff},
110 #endif /* F_PROTOCOL */
111 '\0'
112 };
113
114 #define VALIDSIZE sizeof(Ptbl)/sizeof(struct Proto)
115
116 int (*Rdmsg)()=imsg, (*Rddata)();
117 int (*Wrmsg)()=omsg, (*Wrdata)();
118 int (*Turnon)(), (*Turnoff)()=turnoff;
119
120
121 #define YES "Y"
122 #define NO "N"
123
124 #define TBUFSIZE 128 /* temporary buffer size */
125 #define FLENRADIX (16) /* output radix for file start point */
126
127 /*
128 * failure messages
129 */
130 #define EM_MAX 10
131 #define EM_LOCACC "N1" /* local access to file denied */
132 #define EM_RMTACC "N2" /* remote access to file/path denied */
133 #define EM_BADUUCP "N3" /* a bad uucp command was generated */
134 #define EM_NOTMP "N4" /* remote error - can't create temp */
135 #define EM_RMTCP "N5" /* can't copy to remote directory - file in public */
136 #define EM_LOCCP "N6" /* can't copy on local system */
137 #define EM_SEEK "N7" /* can't seek to checkpoint */
138 /* EM_ "N8" */ /* placeholder*/
139 /* EM_ "N9" */ /* placeholder*/
140 #define EM_ULIMIT "N10" /* receiver ulimit exceeded */
141
142 char *Em_msg[] = {
143 "COPY FAILED (reason not given by remote)",
144 "local access to file denied",
145 "remote access to path/file denied",
146 "system error - bad uucp command generated",
147 "remote system can't create temp file",
148 "can't copy to file/directory - file left in PUBDIR/user/file",
149 "can't copy to file/directory - file left in PUBDIR/user/file",
150 "can't seek to checkpoint",
151 "COPY FAILED (reason not given by remote)", /* placeholder */
152 "COPY FAILED (reason not given by remote)", /* placeholder */
153 "file exceeds ulimit of receiving system",
154 "forwarding error"
155 };
156
157
158 #define XUUCP 'X' /* execute uucp (string) */
159 #define SLTPTCL 'P' /* select protocol (string) */
160 #define USEPTCL 'U' /* use protocol (character) */
161 #define RCVFILE 'R' /* receive file (string) */
162 #define SNDFILE 'S' /* send file (string) */
163 #define RQSTCMPT 'C' /* request complete (string - yes | no) */
164 #define HUP 'H' /* ready to hangup (string - yes | no) */
165 #define RESET 'X' /* reset line modes */
166
167 #define W_MAX 10 /* maximum number of C. files per line */
168 #define W_MIN 7 /* min number of entries */
169 #define W_TYPE wrkvec[0]
170 #define W_FILE1 wrkvec[1]
171 #define W_FILE2 wrkvec[2]
172 #define W_USER wrkvec[3]
173 #define W_OPTNS wrkvec[4]
174 #define W_DFILE wrkvec[5]
175 #define W_MODE wrkvec[6]
176 #define W_NUSER wrkvec[7]
177 #define W_SFILE wrkvec[8]
178 #define W_RDFILE wrkvec[8]
179 #define W_POINT wrkvec[9]
180 #define W_FSIZE wrkvec[9]
181 #define W_RFILE wrkvec[5]
182 #define W_XFILE wrkvec[5]
183 char *mf;
184
185 #define RMESG(m, s) if (rmesg(m, s) != 0) {(*Turnoff)(); return(FAIL);}
186 #define RAMESG(s) if (rmesg('\0', s) != 0) {(*Turnoff)(); return(FAIL);}
187 #define WMESG(m, s) if(wmesg(m, s) != 0) {(*Turnoff)(); return(FAIL);}
188
189 char Wfile[MAXFULLNAME] = {'\0'};
190 char Dfile[MAXFULLNAME];
191
192 char *wrkvec[W_MAX+1];
193 int statfopt;
194
195 /*
196 * Create restart point filename
197 */
198
199 static void
200 Pname(fileid, dfile, direct)
201 char *fileid;
202 char *dfile;
203 int direct; /* indicates a direct delivery temp file nameneeded */
204 {
205 char *p;
206
207 /*
208 * If the file is direct delivery, then its name is:
209 *
210 * /dir/dir/dir/.Pnnnnnnnn
211 *
212 * in the target directory. We create this by replacing the
213 * name of the target file with the D.nnnnnn name from the
214 * work vector, and then overwriting the D. with .P
215 */
216
217 if (direct) {
218 if (p = strrchr(dfile, '/')) { /* find the last slash */
219 p++;
220 strcpy(p, fileid); /* append D.nnnnn name to dir */
221 *p++ = '.';
222 *p = 'P'; /* replace beginning with .P */
223 DEBUG(7, "Point file (direct) =%s\n", dfile);
224 return;
225 }
226 }
227 strcpy(dfile, RemSpool);
228 strcat(dfile, "/");
229 p = dfile + strlen(Dfile);
230 strcat(dfile, fileid);
231 *p = 'P';
232 DEBUG(7, "Point file=%s\n", dfile);
233 return;
234 }
235
236
237 /*
238 * execute the conversation between the two machines
239 * after both programs are running.
240 * returns:
241 * SUCCESS -> ok
242 * FAIL -> failed
243 */
244 int
245 cntrl()
246 {
247 FILE * fp;
248 struct stat stbuf;
249 char * p;
250 long startp; /* checkpoint restart point */
251 long actualsize; /* actual file size */
252 long im;
253 long lfilemode;
254 mode_t filemode;
255 int status;
256 int i, narg;
257 int mailopt, ntfyopt;
258 int ret;
259 char tbuf[TBUFSIZE];
260 char rqstr[BUFSIZ]; /* contains the current request message */
261 char msg[BUFSIZ];
262 char filename[MAXFULLNAME], wrktype;
263 char fsize[NAMESIZE]; /* holds file size/checkpoint string */
264 char localname[MAXFULLNAME]; /* real local system name */
265 char Recspool[MAXFULLNAME]; /* spool area for slave uucico */
266 static pid_t pnum;
267 extern int uuxqtflag; /* set if received X. or D. file */
268
269 pnum = getpid();
270 Wfile[0] = '\0';
271 (void) sprintf(Recspool, "%s/%s", SPOOL, Rmtname);
272 top:
273 (void) strcpy(User, Uucp);
274 statfopt = 0;
275 *Jobid = '\0';
276 DEBUG(4, "*** TOP *** - Role=%d, ", Role);
277 setline(RESET);
278 if (Role == MASTER) {
279
280 /*
281 * get work
282 */
283 pfFindFile();
284 if ((narg = gtwvec(Wfile, wrkvec, W_MAX)) == 0) {
285 acEnd(COMPLETE); /*stop collecting accounting log */
286 WMESG(HUP, ""); /* I(master) am done. want me to quit? */
287 RMESG(HUP, msg);
288 goto process;
289 }
290 DEBUG(7, "Wfile - %s,", Wfile);
291 strncpy(Jobid, BASENAME(Wfile, '/')+2, NAMESIZE);
292 Jobid[NAMESIZE-1] = '\0';
293 DEBUG(7, "Jobid = %s\n", Jobid);
294 wrktype = W_TYPE[0];
295 pfFound(Jobid, W_OPTNS, Nstat.t_qtime);
296 mailopt = strchr(W_OPTNS, 'm') != NULL;
297 statfopt = strchr(W_OPTNS, 'o') != NULL;
298 ntfyopt = strchr(W_OPTNS, 'n') != NULL;
299
300 uucpname(localname); /* get real local machine name */
301 acDojob(Jobid, localname, W_USER);
302 scRequser(W_USER); /* log requestor user id */
303
304 /*
305 * We used to check for corrupt workfiles here (narg < 5),
306 * but we were doing it wrong, and besides, anlwrk.c is the
307 * appropriate place to do it.
308 */
309
310 (void) sprintf(User, "%s", W_USER);
311 if (wrktype == SNDFILE ) {
312 (void) sprintf(rqstr, "%s!%s --> %s!%s (%s)", Myname,
313 W_FILE1, Rmtname, W_FILE2, User);
314
315 /* log destination node, user and file name */
316
317 scDest(Rmtname,NOTAVAIL,W_FILE2);
318
319 /* log source node, file owner, file name, mod time and size */
320
321 scSrc(Myname,scOwn(W_FILE1),W_FILE1,scMtime(W_FILE1)
322 ,scSize(W_FILE1));
323
324 logent(rqstr, "REQUEST");
325 CDEBUG(1, "Request: %s\n", rqstr);
326 mf = W_SFILE;
327 (void) strcpy(filename, W_FILE1);
328 expfile(filename);
329 (void) strcpy(Dfile, W_DFILE);
330 if ( (fp = fopen(Dfile, "r")) == NULL) {
331 if ( (fp = fopen(filename, "r")) == NULL) {
332 /* cannot read spool or original file */
333 unlinkdf(Dfile);
334 lnotify(User, rqstr, "can't access");
335 (void) sprintf(msg, "CAN'T READ %s %d",
336 filename, errno);
337 logent(msg, "FAILED");
338 CDEBUG(1, "Failed: Can't Read %s\n", filename);
339 scWrite(); /* log the security violation */
340 goto top;
341 } else {
342 /* ensure original file is publicly readable */
343 if ( !F_READANY(fileno(fp)) ) {
344 /* access denied */
345 logent("DENIED", "ACCESS");
346 unlinkdf(W_DFILE);
347 lnotify(User, rqstr, "access denied");
348 CDEBUG(1, "Failed: Access Denied\n%s", "");
349 scWrite(); /* log the security violation */
350 goto top;
351 }
352 }
353 }
354
355 if (Restart && !(fstat(fileno(fp), &stbuf))) {
356 (void) sprintf(fsize, "0x%lx", stbuf.st_size);
357 W_FSIZE = fsize; /* set file size in vector */
358 }
359
360 /* Check whether remote's ulimit is exceeded */
361 if (SizeCheck) {
362 if (((stbuf.st_size-1)/512 + 1) > RemUlimit) {
363 /* remote ulimit exceeded */
364 unlinkdf(Dfile);
365 lnotify(User, rqstr, "remote ulimit exceeded");
366 logent("DENIED", "REMOTE ULIMIT EXCEEDED");
367 CDEBUG(1, "Denied: remote ulimit exceeded %s\n", filename);
368 scWrite();
369 (void) fclose(fp);
370 goto top;
371 }
372 }
373 }
374
375 if (wrktype == RCVFILE) {
376 (void) sprintf(rqstr, "%s!%s --> %s!%s (%s)", Rmtname,
377 W_FILE1, Myname, W_FILE2, User);
378
379 /* log destination node, user and file name */
380
381 scDest(Myname,NOTAVAIL,W_FILE2);
382
383 /* log source node, file owner, file name, mod time and size */
384
385 scSrc(Rmtname,NOTAVAIL,W_FILE1,NOTAVAIL,NOTAVAIL);
386
387 logent(rqstr, "REQUEST");
388 CDEBUG(1, "Request: %s\n", rqstr);
389 mf = W_RFILE;
390 (void) strcpy(filename, W_FILE2);
391
392 /* change Wrkdir to SPOOL/Rmtname in case the file being
393 ** requested is needed for some remote execution.
394 */
395
396 (void) strcpy(Wrkdir, Recspool);
397 expfile(filename);
398
399 /* now change Wrkdir back to what it was
400 ** just being paranoid.
401 */
402
403 (void) strcpy(Wrkdir, RemSpool);
404 if (chkperm(W_FILE1, filename, strchr(W_OPTNS, 'd'))) {
405
406 /* access denied */
407 logent("DENIED", "ACCESS");
408 lnotify(User, rqstr, "access denied");
409 CDEBUG(1, "Failed: Access Denied--File: %s\n",
410 filename);
411 scWrite(); /* log the security violation */
412 goto top;
413 }
414
415 /*
416 * If we are not going to spool the file in the spool
417 * directory, just use the destination file name. If we
418 * are not supporting restart, wipe out the target file.
419 * else:
420 *
421 * If restart is enabled, make up the Point file name
422 * as the file to open, else use the TM style name.
423 *
424 * If we run into a spool name of "D.0", this implies
425 * that someone forgot to install the new uucp and
426 * uux commands. Such jobs will not be checkpointed.
427 */
428
429
430 if (Restart && (strlen(W_RDFILE) > (size_t) 6)) {
431 if (noSpool()) {
432 strcpy(Dfile, filename); /* use Dest file directly */
433 Pname(W_RDFILE, Dfile, TRUE);
434 }
435 else
436 Pname(W_RDFILE, Dfile, FALSE);
437 }
438 else {
439 TMname(Dfile, pnum); /* get TM file name */
440 unlink(Dfile);
441 }
442
443 /*
444 * If the spool file exists, it better have the right owner
445 * and permissions!
446 */
447
448 if (Restart && noSpool()) {
449 if ((! stat(Dfile, &stbuf)) &&
450 ((stbuf.st_mode != (DFILEMODE|S_IFREG)) ||
451 ((stbuf.st_gid != UUCPGID) ||
452 (stbuf.st_uid != UUCPUID)))) {
453 lnotify(User, rqstr,
454 "bad spool file ownership/permissions");
455 logent("BAD DESTFILE OWNER/PERMS", "FAIL");
456 CDEBUG(1, "Failed: bad dest file owner/perms 0%o; fail\n", stbuf.st_mode);
457 goto top;
458 }
459 }
460 if ( ((fp = fopen(Dfile, "a+")) == NULL)
461 || nospace(Dfile)) {
462
463 /* can not create temp */
464 if (noSpool())
465 logent("CAN'T CREATE/OPEN DEST FILE", "FAILED");
466 else
467 logent("CAN'T CREATE TM FILE", "FAILED");
468 CDEBUG(1, "Failed: No Space!\n%s", "");
469 unlinkdf(Dfile);
470 assert(Ct_CREATE, Dfile, nospace(Dfile),
471 __FILE__, __LINE__);
472 cleanup(FAIL);
473 }
474
475 /*
476 * Send the W_POINT value to the other side.
477 */
478
479 if (Restart) {
480 if (fstat (fileno(fp), &stbuf)) {
481 logent("CAN'T STAT DFILE", "START FROM BEGINNING");
482 stbuf.st_size = 0L;
483 }
484
485 /*
486 * find a good start point. Take care of simple
487 * underflow and the signed nature of longs.
488 */
489
490 DEBUG(7, "Dfile length 0x%lx\n", stbuf.st_size);
491 startp = stbuf.st_size - (stbuf.st_size % BUFSIZ);
492 if((stbuf.st_size >= 0) && (startp < 0))
493 startp = 0;
494
495 if(startp)
496 {
497 if(startp < 0)
498 sprintf(tbuf,"start=0x%lx", startp);
499 else
500 sprintf(tbuf,"start=%ld", startp);
501
502 logent(tbuf, "RESTART");
503 }
504
505 sprintf(fsize, "0x%lx", startp);
506 W_POINT = fsize; /* set start point in vector */
507 if (lseek(fileno(fp), startp, 0) == -1) {
508 WMESG(SNDFILE, EM_SEEK);
509 logent("CAN'T SEEK", "DENIED");
510 CDEBUG(1, "Failed, Can't seek in Dfile\n%s", "");
511 unlinkdf(Dfile);
512 goto top;
513 }
514 fp->_cnt = 0;
515 fp->_ptr = fp->_base;
516 }
517
518 Seqn++;
519 chmod(Dfile, DFILEMODE); /* no peeking! */
520 chown(Dfile, UUCPUID, UUCPGID);
521
522 }
523 DEBUG(4, "wrktype - %c\n ", wrktype);
524
525 /* Build up the message itself */
526
527 msg[0] = '\0';
528 for (i = 1; i < narg; i++) {
529 (void) strcat(msg, " ");
530 (void) strcat(msg, wrkvec[i]);
531 }
532
533 WMESG(wrktype, msg); /* I(master) am sending you our work file */
534 RMESG(wrktype, msg); /* I(master) am waiting for your response */
535 goto process;
536 }
537
538 /*
539 * role is slave
540 */
541
542 RAMESG(msg); /* I(slave) am waiting for our work file */
543
544 process:
545
546 DEBUG(4, " PROCESS: msg - %s\n", msg);
547 switch (msg[0]) {
548
549 case RQSTCMPT:
550 DEBUG(4, "%s\n", "RQSTCMPT:");
551 if (msg[1] == 'N') {
552 i = atoi(&msg[2]);
553 if (i < 0 || i > EM_MAX)
554 i = 0;
555 logent(Em_msg[i], "REQUESTED");
556 }
557 if (Role == MASTER) {
558 notify(mailopt, W_USER, rqstr, Rmtname, &msg[1]);
559 }
560 pfEndfile(""); /* "" indicates the file transfer completely */
561 goto top;
562
563 case HUP:
564 DEBUG(4, "%s\n", "HUP:");
565 if (msg[1] == 'Y') {
566 WMESG(HUP, YES); /* let's quit */
567 (*Turnoff)();
568 Rdmsg = imsg;
569 Wrmsg = omsg;
570 Turnoff = turnoff;
571 return(0);
572 }
573
574 if (msg[1] == 'N') {
575 ASSERT(Role == MASTER, Wr_ROLE, "", Role);
576 Role = SLAVE;
577 scReqsys(Rmtname); /* log requestor system */
578 chremdir(Rmtname);
579 goto top;
580 }
581
582 /*
583 * get work
584 */
585 if ( (switchRole() == FALSE) || !iswrk(Wfile) ) {
586 DEBUG(5, "SLAVE-switchRole (%s)\n",
587 switchRole() ? "TRUE" : "FALSE");
588 WMESG(HUP, YES); /* let's quit */
589 RMESG(HUP, msg);
590 goto process;
591 }
592
593 /* Note that Wfile is the first C. to process at top
594 * set above by iswrk() call
595 */
596 if (uuxqtflag) {
597 xuuxqt(uuxqtarg);
598 uuxqtflag = 0;
599 }
600 WMESG(HUP, NO); /* don't quit. I(slave) have more to do */
601 Role = MASTER;
602 uucpname(localname); /* get real local machine name */
603 scReqsys(localname); /* log requestor system */
604 acInit("xfer");
605 goto top;
606
607 case XUUCP:
608 /*
609 * slave part
610 * No longer accepted
611 */
612
613 WMESG(XUUCP, NO);
614 goto top;
615
616 case SNDFILE:
617
618 /*
619 * MASTER section of SNDFILE
620 */
621 DEBUG(4, "%s\n", "SNDFILE:");
622 if (msg[1] == 'N')
623 {
624 i = atoi(&msg[2]);
625 if (i < 0 || i > EM_MAX)
626 i = 0;
627 logent(Em_msg[i], "REQUEST");
628 notify(mailopt, W_USER, rqstr, Rmtname, &msg[1]);
629 ASSERT(Role == MASTER, Wr_ROLE, "", Role);
630 (void) fclose(fp);
631 /* if remote is out of tmp space, then just hang up */
632 ASSERT(i != 4, Em_msg[4], Rmtname, i); /* EM_NOTMP */
633 unlinkdf(W_DFILE);
634 scWrite(); /* something is wrong on other side,
635 log the security violation */
636 Seqn++;
637 goto top;
638 }
639
640 if (msg[1] == 'Y') {
641
642 /*
643 * send file
644 */
645 ASSERT(Role == MASTER, Wr_ROLE, "", Role);
646 if (fstat(fileno(fp), &stbuf)) /* never fail but .. */
647 stbuf.st_size = 0; /* for time loop calculation */
648
649 /*
650 * If checkpoint restart is enabled, seek to the
651 * starting point in the file. We use hex because
652 * C doesn't support unsigned long directly.
653 */
654
655 if (Restart) {
656 if((startp = strtol(&msg[2], (char **) 0, FLENRADIX))) {
657 CDEBUG(1, "Restart point=0x%lx\n", startp);
658 if(startp < 0)
659 sprintf(tbuf,"start=0x%lx", startp);
660 else
661 sprintf(tbuf,"start=%ld", startp);
662 p = tbuf + strlen(tbuf);
663 if (stbuf.st_size < 0)
664 sprintf(p,", length=0x%lx", stbuf.st_size);
665 else
666 sprintf(p,", length=%ld", stbuf.st_size);
667
668 logent(tbuf, "RESTART");
669 errno = 0;
670 if (lseek(fileno(fp), startp, 0) == -1) {
671 logent(strerror(errno), "FSEEK ERROR");
672 (void) fclose(fp);
673 (*Turnoff)();
674 Seqn++;
675 return(FAIL);
676 }
677 fp->_cnt = 0;
678 fp->_ptr = fp->_base;
679 }
680 }
681 (void) millitick(); /* start msec timer */
682 pfStrtXfer(MCHAR, SNDFILE);
683 scStime(); /* log start transfer time for security log */
684
685 /* (ret != 0) implies the trammission error occurred.
686 If checkpoint protocol is available then the next
687 transfer will restart from the breakpoint of the file,
688 otherwise from the beginning of the file */
689
690 ret = (*Wrdata)(fp, Ofn);
691
692 /* the second millitick() returns the duration between
693 the first and second call.
694 writes "PARTIAL FILE to the transfer log indicating
695 a transmission error. */
696
697 statlog( "->", getfilesize(), millitick(),
698 (ret) ? "PARTIAL FILE" : "" );
699
700 acInc(); /* increment job size in accounting log */
701 pfEndXfer();
702 scEtime(); /* log end transfer time for security log */
703 Seqn++;
704 (void) fclose(fp);
705 if (ret != 0) {
706 pfEndfile("PARTIAL FILE");
707 acEnd(PARTIAL); /*stop collecting accounting log */
708 (*Turnoff)();
709 return(FAIL);
710 }
711
712 /* loop depending on the size of the file */
713 /* give an extra try for each megabyte */
714 for (im = stbuf.st_size >> 10; im >= 0; --im) {
715 if ((ret = rmesg(RQSTCMPT, msg)) == 0)
716 break; /* got message */
717 }
718 if (ret != 0) {
719 (*Turnoff)();
720 return(FAIL);
721 }
722 unlinkdf(W_DFILE);
723 goto process;
724 }
725
726 /*
727 * SLAVE section of SNDFILE
728 */
729 ASSERT(Role == SLAVE, Wr_ROLE, "", Role);
730
731 /*
732 * request to receive file
733 * check permissions
734 */
735 i = getargs(msg, wrkvec, W_MAX);
736
737 scRequser(W_USER); /* log requestor user id */
738
739 /* log destination node, user and file name */
740
741 scDest(Myname,NOTAVAIL,W_FILE2);
742
743 /* log source node, file owner, file name, mod time and size */
744
745 scSrc(Rmtname,NOTAVAIL,W_FILE1,NOTAVAIL,NOTAVAIL);
746
747 /* Check for bad request */
748 if (i < W_MIN) {
749 WMESG(SNDFILE, EM_BADUUCP); /* you(remote master) gave me
750 bad work file */
751 logent("DENIED", "TOO FEW ARGS IN SLAVE SNDFILE");
752 goto top;
753 }
754 /* SLAVE gets the original filesize from sender (MASTER) */
755 /* This will be used to check the length of the P. file */
756 if (Restart) {
757 if (W_FSIZE && (*W_FSIZE != '\0')) {
758 actualsize = strtol(W_FSIZE, (char **) 0, FLENRADIX);
759 CDEBUG(7, "Actual File Length %ld\n", actualsize);
760 } else {
761 actualsize = -1;
762 CDEBUG(7, "Actual File Length Not Provided\n%s", "");
763 }
764 }
765
766 mf = W_SFILE;
767 (void) sprintf(rqstr, "%s!%s --> %s!%s (%s)", Rmtname,
768 W_FILE1, Myname, W_FILE2, W_USER);
769 logent(rqstr, "REMOTE REQUESTED");
770 DEBUG(4, "msg - %s\n", msg);
771 CDEBUG(1, "Remote Requested: %s\n", rqstr);
772 (void) strcpy(filename, W_FILE2);
773 expfile(filename);
774 DEBUG(4, "SLAVE - filename: %s\n", filename);
775 if (chkpth(filename, CK_WRITE)
776 || chkperm(W_FILE1, filename, strchr(W_OPTNS, 'd'))) {
777 WMESG(SNDFILE, EM_RMTACC); /* you(remote master) can't
778 send data to this file(directory) */
779 logent("DENIED", "PERMISSION");
780 CDEBUG(1, "Failed: Access Denied\n%s", "");
781 scWrite(); /* log security violation */
782 goto top;
783 }
784 (void) sprintf(User, "%s", W_USER);
785
786 DEBUG(4, "chkpth ok Rmtname - %s\n", Rmtname);
787
788
789
790 if (Restart && (strlen(W_DFILE) > (size_t) 6)) {
791 if (noSpool()) {
792 strcpy(Dfile, filename); /* use Dest file directly */
793 Pname(W_DFILE, Dfile, TRUE);
794 if (! Restart)
795 unlink(Dfile);
796 }
797 else
798 Pname(W_DFILE, Dfile, FALSE);
799 }
800 else {
801 TMname(Dfile, pnum); /* get TM file name */
802 unlink(Dfile);
803 }
804
805 /*
806 * If the spool file exists, it better have the right owner
807 * and permissions!
808 */
809
810 if (Restart && noSpool()) {
811 if ((! stat(Dfile, &stbuf)) &&
812 ((stbuf.st_mode != (DFILEMODE|S_IFREG)) ||
813 ((stbuf.st_gid != UUCPGID) ||
814 (stbuf.st_uid != UUCPUID)))) {
815 WMESG(SNDFILE, EM_NOTMP); /* I(slave) see bad perms */
816 logent("BAD DESTFILE OWNER/PERMS", "FAILED");
817 CDEBUG(1, "Failed: bad dest file owner/perms 0%o\n", stbuf.st_mode);
818 goto top;
819 }
820 }
821 if ( ((fp = fopen(Dfile, "a+")) == NULL) || nospace(Dfile) ) {
822 WMESG(SNDFILE, EM_NOTMP); /* I(slave) can't create TM file */
823 logent("CAN'T OPEN", "DENIED");
824 CDEBUG(1, "Failed: Can't Create Temp File\n%s", "");
825 unlinkdf(Dfile);
826 goto top;
827 }
828 chmod(Dfile, DFILEMODE); /* no peeking! */
829 chown(Dfile, UUCPUID, UUCPGID);
830 if (Restart && (strlen(W_DFILE) > (size_t) 6)) {
831 if(fstat(fileno(fp), &stbuf)) {
832 WMESG(SNDFILE, EM_NOTMP);
833 logent("CAN'T STAT", "DENIED");
834 CDEBUG(1, "Failed: Can't Stat Temp File\n%s", "");
835 unlinkdf(Dfile);
836 Seqn++;
837 goto top;
838 }
839 /*
840 * find a good start point. Take care of simple underflow
841 * and the signed nature of longs.
842 */
843
844 DEBUG(7, "Dfile length 0x%lx\n", stbuf.st_size);
845 startp = stbuf.st_size - (stbuf.st_size % BUFSIZ);
846 if((stbuf.st_size >= 0) && (startp < 0))
847 startp = 0;
848
849 if(startp)
850 {
851 if(startp < 0)
852 sprintf(tbuf,"start=0x%lx", startp);
853 else
854 sprintf(tbuf,"start=%ld", startp);
855
856 logent(tbuf, "RESTART");
857 }
858
859 sprintf(tbuf, "%s 0x%lx", YES, startp);
860 if (lseek(fileno(fp), startp, 0) == -1) {
861 WMESG(SNDFILE, EM_SEEK);
862 logent("CAN'T SEEK", "DENIED");
863 CDEBUG(1, "Failed, Can't seek in Dfile\n%s", "");
864 unlinkdf(Dfile);
865 Seqn++;
866 goto top;
867 }
868 fp->_cnt = 0;
869 fp->_ptr = fp->_base;
870 CDEBUG(1," restart msg %s\n", tbuf);
871 WMESG(SNDFILE, tbuf);
872 }
873 else
874 WMESG(SNDFILE, YES); /* I(slave) clear to send */
875 (void) millitick(); /* start msec timer */
876 pfStrtXfer(SCHAR, RCVFILE);
877 scStime(); /* log start transfer time for security log */
878 /* (ret != 0) implies the trammission error occurred.
879 If checkpoint protocol is available then the next
880 recieve will restart from the breakpoint of the file,
881 otherwise from the beginning of the file */
882
883 setline(RCVFILE);
884 ret = (*Rddata)(Ifn, fp);
885 setline(SNDFILE);
886
887 /* the second millitick() returns the duration between
888 the first and second call.
889 writes "PARTIAL FILE to the transfer log indicating
890 a transmission error. */
891
892 statlog( "<-", getfilesize(), millitick(),
893 (ret) ? "PARTIAL FILE" : "" );
894
895 pfEndXfer();
896 scEtime(); /* log end transfer time for security log */
897 Seqn++;
898
899 if (ret != 0) {
900 pfEndfile("PARTIAL FILE");
901 (void) fclose(fp);
902 if ( ret == EFBIG ) {
903 WMESG(RQSTCMPT, EM_ULIMIT);
904 logent("FILE EXCEEDS ULIMIT","FAILED");
905 CDEBUG(1, "Failed: file size exceeds ulimit%s\n", "");
906 goto top;
907 }
908 (*Turnoff)();
909 logent("INPUT FAILURE", "IN SEND/SLAVE MODE");
910 return(FAIL);
911 }
912 if (Restart && (actualsize != -1)) {
913 if (fstat(fileno(fp), &stbuf)) {
914 (void) fclose(fp);
915 unlinkdf(Dfile);
916 (*Turnoff)();
917 logent("CAN'T STAT PFILE", "FAILED");
918 return(FAIL);
919 }
920 if (stbuf.st_size != actualsize) {
921 (void) fclose(fp);
922 unlinkdf(Dfile);
923 (*Turnoff)();
924 logent("RECEIVED SIZE NOT EQUAL TO ACTUAL SIZE", "FAILED");
925 CDEBUG(1, "Failed: receive size %ld ", stbuf.st_size);
926 CDEBUG(1, "not equal to actual size %ld\n", actualsize);
927 return(FAIL);
928 }
929 }
930 (void) fclose(fp);
931
932 /* copy to user directory */
933 ntfyopt = strchr(W_OPTNS, 'n') != NULL;
934
935 /*
936 * See if spool file and target file in the same file system
937 */
938
939 ret = 0;
940 if (p = strrchr(Dfile, '/'))
941 {
942 *p = '\0';
943 ret = PREFIX(Dfile, filename);
944 *p = '/';
945 }
946
947 if (noSpool() && ret)
948 {
949 /*
950 * if we are not already in the right file, and
951 * it is theoretically in the same file system,
952 * link it there...
953 */
954
955 if(strcmp (filename, Dfile)) {
956 unlink(filename);
957 if(link(Dfile, filename))
958 {
959 logent("FAILED", "MOVE");
960 scWrite();
961 putinpub(filename, Dfile, BASENAME(W_USER,'!'));
962 }
963 else
964 DEBUG(7, "linked Point file to %s\n", filename);
965 unlink(Dfile);
966 }
967 else
968 DEBUG(7, "Point file and %s the same\n", filename);
969 status = 0; /* all done */
970 }
971 else
972 status = xmv(Dfile, filename);
973
974 scSize(Dfile); /* log source file size */
975 WMESG(RQSTCMPT, status ? EM_RMTCP : YES);
976 if (status == 0) {
977 sscanf(W_MODE, "%lo", &lfilemode);
978 if (lfilemode <= 0)
979 filemode = PUB_FILEMODE;
980 else
981 filemode = (mode_t)lfilemode;
982 if (PREFIX(RemSpool, filename))
983 chmod(filename, DFILEMODE);
984 else
985 chmod(filename, (filemode & LEGALMODE) | PUB_FILEMODE);
986 arrived(ntfyopt, filename, W_NUSER, Rmtname, User);
987 } else {
988 logent("FAILED", "COPY");
989 scWrite(); /* log the security violation */
990 status = putinpub(filename, Dfile,
991 BASENAME(W_USER, '!'));
992 DEBUG(4, "->PUBDIR %d\n", status);
993 if (status == 0)
994 arrived(ntfyopt, filename, W_NUSER,
995 Rmtname, User);
996 }
997 pfEndfile(""); /* "" indicates the file transfer completely */
998 if ( W_FILE2[1] == '.' &&
999 (W_FILE2[0] == XQTPRE || W_FILE2[0] == DATAPRE) )
1000 uuxqtflag = 1;
1001 goto top;
1002
1003 case RCVFILE:
1004
1005 /*
1006 * MASTER section of RCVFULE
1007 */
1008 DEBUG(4, "%s\n", "RCVFILE:");
1009 if (msg[1] == 'N') {
1010 i = atoi(&msg[2]);
1011 if (i < 0 || i > EM_MAX)
1012 i = 0;
1013 logent(Em_msg[i], "REQUEST");
1014 notify(mailopt, W_USER, rqstr, Rmtname, &msg[1]);
1015 ASSERT(Role == MASTER, Wr_ROLE, "", Role);
1016 (void) fclose(fp);
1017 unlinkdf(Dfile);
1018 scWrite(); /* something is wrong on other side,
1019 log the security violation */
1020 goto top;
1021 }
1022
1023 if (msg[1] == 'Y') {
1024
1025 /* MASTER gets the original filesize from sender (SLAVE) */
1026 /* This will be used to check the length of the P. file */
1027 if (Restart) {
1028 *fsize = '\0';
1029 sscanf(&msg[2], "%*o %s", fsize);
1030 if (*fsize != '\0') {
1031 actualsize = strtol(fsize, (char **) 0, FLENRADIX);
1032 CDEBUG(7, "Actual File Length %ld\n", actualsize);
1033 } else {
1034 actualsize = -1;
1035 CDEBUG(7, "Actual File Length Not Provided\n%s", "");
1036 }
1037 }
1038
1039 /*
1040 * receive file
1041 */
1042 ASSERT(Role == MASTER, Wr_ROLE, "", Role);
1043 (void) millitick(); /* start msec timer */
1044 pfStrtXfer(MCHAR, SNDFILE);
1045 scStime();
1046 /* (ret != 0) implies the trammission error occurred.
1047 If checkpoint protocol is available then the next
1048 recieve will restart from the breakpoint of the file,
1049 otherwise from the beginning of the file */
1050
1051 ret = (*Rddata)(Ifn, fp);
1052
1053 /* the second millitick() returns the duration between
1054 the first and second call.
1055 writes "PARTIAL FILE to the transfer log indicating
1056 a transmission error. */
1057
1058 statlog( "<-", getfilesize(), millitick(),
1059 (ret) ? "PARTIAL FILE" : "" );
1060 pfEndXfer();
1061 scEtime();
1062 if (ret != 0) {
1063 pfEndfile("PARTIAL FILE");
1064 (void) fclose(fp);
1065 if ( ret == EFBIG ) {
1066 WMESG(RQSTCMPT, EM_ULIMIT);
1067 logent("FILE EXCEEDS ULIMIT","FAILED");
1068 CDEBUG(1, "Failed: file size exceeds ulimit%s\n", "");
1069 goto top;
1070 }
1071 (*Turnoff)();
1072 logent("INPUT FAILURE", "IN RECEIVE/MASTER MODE");
1073 return(FAIL);
1074 }
1075 if (Restart && (actualsize != -1)) {
1076 if (fstat(fileno(fp), &stbuf)) {
1077 (void) fclose(fp);
1078 unlinkdf(Dfile);
1079 (*Turnoff)();
1080 logent("CAN'T STAT PFILE", "FAILED");
1081 return(FAIL);
1082 }
1083 if (stbuf.st_size != actualsize) {
1084 (void) fclose(fp);
1085 unlinkdf(Dfile);
1086 (*Turnoff)();
1087 logent("RECEIVED SIZE NOT EQUAL TO ACTUAL SIZE", "FAILED");
1088 CDEBUG(1, "Failed: receive size %ld ", stbuf.st_size);
1089 CDEBUG(1, "not equal to actual size %ld\n", actualsize);
1090 return(FAIL);
1091 }
1092 }
1093 (void) fclose(fp);
1094
1095 /*
1096 * See if spool file and target file in the same file system
1097 */
1098
1099 ret = 0;
1100 if (p = strrchr(Dfile, '/'))
1101 {
1102 *p = '\0';
1103 ret = PREFIX(Dfile, filename);
1104 *p = '/';
1105 }
1106
1107 if (noSpool() && ret)
1108 {
1109 /*
1110 * if we are not already in the right file, and
1111 * it is theoretically in the same file system,
1112 * link it there...
1113 */
1114
1115 if(strcmp (filename, Dfile)) {
1116 unlink(filename);
1117 if(link(Dfile, filename))
1118 {
1119 logent("FAILED", "MOVE");
1120 scWrite();
1121 putinpub(filename, Dfile, W_USER);
1122 }
1123 else
1124 DEBUG(7, "linked Point file to %s\n", filename);
1125 unlink(Dfile);
1126 }
1127 else
1128 DEBUG(7, "Point file and %s the same\n", filename);
1129 status = 0; /* all done */
1130 }
1131 else
1132 status = xmv(Dfile, filename);
1133
1134 WMESG(RQSTCMPT, status ? EM_RMTCP : YES);
1135 notify(mailopt, W_USER, rqstr, Rmtname,
1136 status ? EM_LOCCP : YES);
1137 if (status == 0) {
1138 sscanf(&msg[2], "%lo", &lfilemode);
1139 if (lfilemode <= 0)
1140 filemode = PUB_FILEMODE;
1141 else
1142 filemode = (mode_t)lfilemode;
1143 if (PREFIX(RemSpool, filename))
1144 chmod(filename, DFILEMODE);
1145 else
1146 chmod(filename, (filemode & LEGALMODE) | PUB_FILEMODE);
1147 } else {
1148 logent("FAILED", "COPY");
1149 scWrite(); /* log the security violation */
1150 putinpub(filename, Dfile, W_USER);
1151 }
1152 pfEndfile(""); /* "" indicates the file transfer completely */
1153 if ( W_FILE2[1] == '.' &&
1154 (W_FILE2[0] == XQTPRE || W_FILE2[0] == DATAPRE) )
1155 uuxqtflag = 1;
1156 goto top;
1157 }
1158
1159 /*
1160 * SLAVE section of RCVFILE
1161 * (request to send file)
1162 */
1163 ASSERT(Role == SLAVE, Wr_ROLE, "", Role);
1164
1165 /* check permissions */
1166 i = getargs(msg, wrkvec, W_MAX);
1167
1168 scRequser(W_USER); /* log requestor user id */
1169
1170 /* log destination node, user and file name */
1171
1172 scDest(Rmtname,NOTAVAIL,W_FILE2);
1173
1174 /* log source node, file owner, file name, mod time and size */
1175
1176 scSrc(Myname,scOwn(W_FILE1),W_FILE1,scMtime(W_FILE1),scSize(W_FILE1));
1177 /* Check for bad request */
1178 if (i < 5) {
1179 WMESG(RCVFILE, EM_BADUUCP); /* you(remote master) gave me
1180 bad work file */
1181 logent("DENIED", "TOO FEW ARGS IN SLAVE RCVFILE");
1182 goto top;
1183 }
1184
1185 (void) sprintf(rqstr, "%s!%s --> %s!%s (%s)", Myname,
1186 W_FILE1, Rmtname, W_FILE2, W_USER);
1187 logent(rqstr, "REMOTE REQUESTED");
1188 CDEBUG(1, "Remote Requested: %s\n", rqstr);
1189 mf = W_RFILE;
1190 DEBUG(4, "msg - %s\n", msg);
1191 DEBUG(4, "W_FILE1 - %s\n", W_FILE1);
1192 (void) strcpy(filename, W_FILE1);
1193 expfile(filename);
1194 if (DIRECTORY(filename)) {
1195 (void) strcat(filename, "/");
1196 (void) strcat(filename, BASENAME(W_FILE2, '/'));
1197 }
1198 (void) sprintf(User, "%s", W_USER);
1199
1200 if (requestOK() == FALSE) {
1201 /* remote can't request data from my system */
1202 WMESG(RCVFILE, EM_RMTACC);
1203 logent("DENIED", "REQUESTING");
1204 CDEBUG(1, "Failed: Access Denied\n%s", "");
1205 scWrite(); /* log the security violation */
1206 goto top;
1207 }
1208 DEBUG(4, "requestOK for Loginuser - %s\n", Loginuser);
1209
1210 if ((fp = fopen(filename, "r")) == NULL) {
1211 WMESG(RCVFILE, EM_RMTACC); /* you(remote master) can't
1212 read my file */
1213 logent("CAN'T OPEN", "DENIED");
1214 CDEBUG(1, "Failed: Can't Open %s\n", filename);
1215 scWrite(); /* log the security violation */
1216 goto top;
1217 }
1218
1219 if (chkpth(filename, CK_READ) || !F_READANY(fileno(fp))) {
1220 WMESG(RCVFILE, EM_RMTACC); /* you(remote master) can't
1221 retrive my file */
1222 logent("DENIED", "PERMISSION");
1223 CDEBUG(1, "Failed: Access Denied\n%s", "");
1224 scWrite(); /* log the security violation */
1225 fclose(fp);
1226 goto top;
1227 }
1228 DEBUG(4, "chkpth ok Loginuser - %s\n", Loginuser);
1229
1230 ASSERT(fstat(fileno(fp), &stbuf) == 0, Ct_STAT,
1231 filename, errno);
1232
1233 /* Check whether remote's ulimit is exceeded */
1234 if (SizeCheck) {
1235 if (((stbuf.st_size-1)/512 + 1) > RemUlimit) {
1236 /* remote ulimit exceeded */
1237 WMESG(RCVFILE, EM_ULIMIT);
1238 logent("DENIED", "REMOTE ULIMIT EXCEEDED");
1239 CDEBUG(1, "Denied: remote ulimit exceeded %s\n", filename);
1240 scWrite();
1241 (void) fclose(fp);
1242 goto top;
1243 }
1244 }
1245
1246 /*
1247 * ok to send file
1248 */
1249
1250 if (Restart && i >= 10) {
1251 if (startp = strtol(W_POINT, (char **) 0, FLENRADIX)) {
1252 CDEBUG(1,"Restart point=0x%lx\n", startp);
1253 errno = 0;
1254 if (lseek(fileno(fp), startp, 0) == -1) {
1255 WMESG(RCVFILE, EM_SEEK);
1256 logent(strerror(errno), "FSEEK ERROR");
1257 (void) fclose(fp);
1258 goto top;
1259 }
1260 fp->_cnt = 0;
1261 fp->_ptr = fp->_base;
1262 if(startp < 0)
1263 sprintf(tbuf,"start=0x%lx", startp);
1264 else
1265 sprintf(tbuf,"start=%ld", startp);
1266 p = tbuf + strlen(tbuf);
1267 if (stbuf.st_size < 0)
1268 sprintf(p,", length=0x%lx", stbuf.st_size);
1269 else
1270 sprintf(p,", length=%ld", stbuf.st_size);
1271
1272 logent(tbuf, "RESTART");
1273 }
1274 }
1275
1276 if (Restart)
1277 (void) sprintf(msg, "%s %lo 0x%lx", YES,
1278 (long) (stbuf.st_mode & LEGALMODE),
1279 (long) stbuf.st_size);
1280 else
1281 (void) sprintf(msg, "%s %lo", YES,
1282 (long) (stbuf.st_mode & LEGALMODE));
1283 WMESG(RCVFILE, msg); /* I(slave) send you my file now */
1284 Seqn++;
1285 (void) millitick(); /* start msec timer */
1286 scStime();
1287 pfStrtXfer(SCHAR, SNDFILE);
1288 /* (ret != 0) implies the trammission error occurred.
1289 If checkpoint protocol is available then the next
1290 transfer will restart from the breakpoint of the file,
1291 otherwise from the beginning of the file */
1292
1293 ret = (*Wrdata)(fp, Ofn);
1294
1295 /* the second millitick() returns the duration between
1296 the first and second call.
1297 writes "PARTIAL FILE to the transfer log indicating
1298 a transmission error. */
1299
1300 statlog( "->", getfilesize(), millitick(),
1301 (ret) ? "PARTIAL FILE" : "" );
1302 pfEndXfer();
1303 scEtime();
1304
1305 (void) fclose(fp);
1306 if (ret != 0) {
1307 pfEndfile("PARTIAL FILE");
1308 (*Turnoff)();
1309 return(FAIL);
1310 }
1311
1312 /* loop depending on the size of the file */
1313 /* give an extra try for each megabyte */
1314 /* stbuf set in fstat several lines back */
1315 for (im = stbuf.st_size >> 10; im >= 0; --im) {
1316 if ((ret = rmesg(RQSTCMPT, msg)) == 0)
1317 break; /* got message */
1318 }
1319 if (ret != 0) {
1320 (*Turnoff)();
1321 return(FAIL);
1322 }
1323 goto process;
1324 }
1325 (*Turnoff)();
1326 return(FAIL);
1327 }
1328
1329
1330
1331 /*
1332 * read message
1333 * returns:
1334 * 0 -> success
1335 * FAIL -> failure
1336 */
1337 int
1338 rmesg(c, msg)
1339 char *msg, c;
1340 {
1341 char str[50];
1342
1343 DEBUG(4, "rmesg - '%c' ", c);
1344 if ((*Rdmsg)(msg, Ifn) != 0) {
1345 DEBUG(4, "got %s\n", "FAIL");
1346 (void) sprintf(str, "expected '%c' got FAIL", c);
1347 logent(str, "BAD READ");
1348 return(FAIL);
1349 }
1350 if (c != '\0' && msg[0] != c) {
1351 DEBUG(4, "got %s\n", msg);
1352 (void) sprintf(str, "expected '%c' got %s", c, msg);
1353 logent(str, "BAD READ");
1354 return(FAIL);
1355 }
1356 DEBUG(4, "got %s\n", msg);
1357 return(0);
1358 }
1359
1360
1361 /*
1362 * write a message
1363 * returns:
1364 * 0 -> ok
1365 * FAIL -> ng
1366 */
1367 int
1368 wmesg(m, s)
1369 char *s, m;
1370 {
1371 CDEBUG(4, "wmesg '%c'", m);
1372 CDEBUG(4, "%s\n", s);
1373 return((*Wrmsg)(m, s, Ofn));
1374 }
1375
1376
1377 /*
1378 * mail results of command
1379 * return:
1380 * none
1381 */
1382 void
1383 notify(mailopt, user, msgin, sys, msgcode)
1384 char *user, *msgin, *sys;
1385 char *msgcode;
1386 {
1387 int i;
1388 char str[BUFSIZ];
1389 char *msg;
1390
1391 DEBUG(4,"mailopt %d, ", mailopt);
1392 DEBUG(4,"statfopt %d\n", statfopt);
1393 if (statfopt == 0 && mailopt == 0 && *msgcode == 'Y')
1394 return;
1395 if (*msgcode == 'Y')
1396 msg = "copy succeeded";
1397 else {
1398 i = atoi(msgcode + 1);
1399 if (i < 1 || i > EM_MAX)
1400 i = 0;
1401 msg = Em_msg[i];
1402 }
1403 if(statfopt){
1404 stmesg(msgin, msg);
1405 return;
1406 }
1407 (void) sprintf(str, "REQUEST: %s\n(SYSTEM: %s) %s\n",
1408 msgin, sys, msg);
1409 mailst(user, msg, str, "", "");
1410 return;
1411 }
1412
1413 /*
1414 * local notify
1415 * return:
1416 * none
1417 */
1418 void
1419 lnotify(user, msgin, mesg)
1420 char *user, *msgin, *mesg;
1421 {
1422 char mbuf[BUFSIZ];
1423
1424 if(statfopt){
1425 stmesg(msgin, mesg);
1426 return;
1427 }
1428 (void) sprintf(mbuf, "REQUEST: %s\n(SYSTEM: %s) %s\n",
1429 msgin, Myname, mesg);
1430 mailst(user, mesg, mbuf, "", "");
1431 return;
1432 }
1433
1434 /*ARGSUSED*/
1435 static void
1436 stmesg(f, m)
1437 char *f, *m;
1438 {
1439 #ifdef notdef
1440 FILE *Cf;
1441 time_t clock;
1442 long td, th, tm, ts;
1443 #endif
1444 char msg[BUFSIZ];
1445
1446 DEBUG(4,"STMES %s\n",mf);
1447 sprintf(msg, "STMESG - %s", mf);
1448 logent("DENIED", msg);
1449 #ifdef notdef
1450 /*
1451 * This code is a giant security hole.
1452 * No checking is done on what file is
1453 * written and chmod'ed. For now we
1454 * just ifdef this out.
1455 */
1456 if((Cf = fopen(mf, "a+")) == NULL){
1457 chmod(mf, PUB_FILEMODE);
1458 return;
1459 }
1460 (void) time(&clock);
1461 (void) fprintf(Cf, "uucp job: %s (%s) ", Jobid, timeStamp());
1462 td = clock - Nstat.t_qtime;
1463 ts = td%60;
1464 td /= 60;
1465 tm = td%60;
1466 td /= 60;
1467 th = td;
1468 (void) fprintf(Cf, "(%ld:%ld:%ld)\n%s\n%s\n\n", th, tm, ts, f, m);
1469 (void) fclose(Cf);
1470 chmod(mf, PUB_FILEMODE);
1471 #endif
1472 }
1473
1474 /*
1475 * converse with the remote machine, agree upon a
1476 * protocol (if possible) and start the protocol.
1477 * return:
1478 * SUCCESS -> successful protocol selection
1479 * FAIL -> can't find common or open failed
1480 */
1481 int
1482 startup(void)
1483 {
1484 extern void blptcl();
1485 extern int fptcl();
1486 char msg[BUFSIZ], str[BUFSIZ];
1487
1488 Rdmsg = imsg;
1489 Wrmsg = omsg;
1490 Turnoff = turnoff;
1491 blptcl(str);
1492 if (Role == MASTER) {
1493 RMESG(SLTPTCL, msg);
1494 if ( fptcl(&msg[1], str) == FAIL) {
1495 /* no protocol match */
1496 WMESG(USEPTCL, NO);
1497 return(FAIL);
1498 } else {
1499 /* got protocol match */
1500 WMESG(USEPTCL, &msg[1]);
1501 return(stptcl(&msg[1]));
1502 }
1503 } else {
1504 WMESG(SLTPTCL, str);
1505 RMESG(USEPTCL, msg);
1506 if ( fptcl(&msg[1], str) == FAIL ) {
1507 return(FAIL);
1508 } else {
1509 return(stptcl(&msg[1]));
1510 }
1511 }
1512 }
1513
1514 /*
1515 * choose a protocol from the input string (str)
1516 * and return the found letter.
1517 * Use the MASTER string (valid) for order of selection.
1518 * return:
1519 * '\0' -> no acceptable protocol
1520 * any character -> the chosen protocol
1521 */
1522 int
1523 fptcl(str, valid)
1524 char *str, *valid;
1525 {
1526 char *l;
1527
1528 DEBUG(9, "Slave protocol list(%s)\n", str);
1529 DEBUG(9, "Master protocol list(%s)\n", valid);
1530
1531 for (l = valid; *l != '\0'; l++) {
1532 if ( strchr(str, *l) != NULL) {
1533 *str = *l;
1534 *(str+1) = '\0';
1535 /* also update string with parms */
1536 strcpy(_Protocol, findProto(_Protocol, *str));
1537 return(SUCCESS);
1538 }
1539 }
1540 return(FAIL);
1541 }
1542
1543 /*
1544 * build a string of the letters of the available
1545 * protocols and return the string (str). The string consists of protocols
1546 * that are specified in the Systems and Devices files. If nothing was
1547 * specified in those files, then the string is the list of protocols from
1548 * our Ptble.
1549 *
1550 * str = place to put the protocol list
1551 * length = size of buffer at str
1552 *
1553 * return:
1554 * a pointer to string (str)
1555 */
1556 void
1557 blptcl(str)
1558 char *str;
1559 {
1560 struct Proto *p;
1561 char *validPtr;
1562
1563 /* Build list of valid protocols. */
1564 for (validPtr = str, p = Ptbl; (*validPtr = p->P_id) != NULLCHAR;
1565 validPtr++, p++);
1566
1567 /* Build _Protocol */
1568 (void) protoString(str); /* Get desired protocols. */
1569 return;
1570 }
1571
1572 /*
1573 * set up the six routines (Rdmg. Wrmsg, Rddata
1574 * Wrdata, Turnon, Turnoff) for the desired protocol.
1575 * returns:
1576 * SUCCESS -> ok
1577 * FAIL -> no find or failed to open
1578 */
1579 int
1580 stptcl(c)
1581 char *c;
1582 {
1583 struct Proto *p;
1584
1585 for (p = Ptbl; p->P_id != '\0'; p++) {
1586 if (*c == p->P_id) {
1587
1588 /*
1589 * found protocol
1590 * set routine
1591 */
1592 Rdmsg = p->P_rdmsg;
1593 Wrmsg = p->P_wrmsg;
1594 Rddata = p->P_rddata;
1595 Wrdata = p->P_wrdata;
1596 Turnon = p->P_turnon;
1597 Turnoff = p->P_turnoff;
1598 if ((*Turnon)() != 0)
1599 break;
1600 CDEBUG(4, "Proto started %c\n", *c);
1601 pfPtcl(c);
1602 return(SUCCESS);
1603 }
1604 }
1605 CDEBUG(4, "Proto start-fail %c\n", *c);
1606 return(FAIL);
1607 }
1608
1609 /*
1610 * unlink D. file
1611 * returns:
1612 * none
1613 */
1614 void
1615 unlinkdf(file)
1616 char *file;
1617 {
1618 if (strlen(file) > (size_t) 6)
1619 (void) unlink(file);
1620 return;
1621 }
1622
1623 /*
1624 * notify receiver of arrived file
1625 * returns:
1626 * none
1627 */
1628 void
1629 arrived(opt, file, nuser, rmtsys, rmtuser)
1630 char *file, *nuser, *rmtsys, *rmtuser;
1631 {
1632 char mbuf[200];
1633
1634 if (!opt)
1635 return;
1636 (void) sprintf(mbuf, "%s from %s!%s arrived\n", file, rmtsys, rmtuser);
1637 mailst(nuser, mbuf, mbuf, "", "");
1638 return;
1639 }
1640
1641
1642 /*
1643 * Check to see if there is space for file
1644 */
1645
1646 #define FREESPACE 50 /* Minimum freespace in blocks to permit transfer */
1647 #define FREENODES 5 /* Minimum number of inodes to permit transfer */
1648
1649 /*ARGSUSED*/
1650 static int
1651 nospace(name)
1652 char *name;
1653 #ifdef NOUSTAT
1654 {return(FALSE);}
1655 #else
1656 {
1657 struct stat statb;
1658 #ifdef STATFS
1659 struct statfs statfsb;
1660 #else
1661 struct ustat ustatb;
1662 #endif
1663
1664 if( stat(name, &statb) < 0 )
1665 return(TRUE);
1666 #ifdef RT
1667 if( (statb.st_mode|S_IFMT) == S_IFREG ||
1668 (statb.st_mode|S_IFMT) == S_IFEXT ||
1669 (statb.st_mode&S_IFMT) == S_IF1EXT )
1670 #else
1671 if( (statb.st_mode&S_IFMT) == S_IFREG )
1672 #endif
1673 {
1674 #ifdef STATFS
1675 if( statfs(name, &statfsb)<0 )
1676 #else
1677 if( ustat(statb.st_dev, &ustatb)<0 )
1678 #endif
1679 return(TRUE);
1680 #ifdef STATFS
1681 /*
1682 * Use 512-byte blocks, because that's the unit "ustat" tends
1683 * to work in.
1684 */
1685 if( ((statfsb.f_bavail*statfsb.f_bsize)/512) < FREESPACE )
1686 #else
1687 if( ustatb.f_tfree < FREESPACE )
1688 #endif
1689 {
1690 logent("FREESPACE IS LOW","REMOTE TRANSFER DENIED - ");
1691 return(TRUE);
1692 }
1693 #ifdef STATFS
1694 /*
1695 * The test for "> 0" is there because the @$%#@#@$ NFS
1696 * protocol doesn't pass the number of free files over the
1697 * wire, so "statfs" on an NFS file system always returns -1.
1698 */
1699 if( statfsb.f_ffree > 0
1700 && statfsb.f_ffree < FREENODES )
1701 #else
1702 if( ustatb.f_tinode < FREENODES )
1703 #endif
1704 {
1705 logent("TOO FEW INODES","REMOTE TRANSFER DENIED - ");
1706 return(TRUE);
1707 }
1708 }
1709 return(FALSE);
1710 }
1711 #endif
1712
1713 #ifdef V7USTAT
1714 int
1715 ustat(dev, ustat)
1716 int dev;
1717 struct ustat *ustat;
1718 {
1719 FILE *dfp, *popen();
1720 char *fval, buf[BUFSIZ];
1721
1722 sprintf(buf, "%s %d %d 2>&1", V7USTAT, major(dev), minor(dev));
1723 if ((dfp = popen(buf, "r")) == NULL)
1724 return(-1);
1725 fval = fgets(buf, sizeof(buf), dfp);
1726 if (pclose(dfp) != 0
1727 || fval == NULL
1728 || sscanf(buf, "%d %d", &ustat->f_tfree, &ustat->f_tinode) != 2)
1729 return(-1);
1730 return(0);
1731 }
1732 #endif /* V7USTAT */
unleashed repo fork