![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rec.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104|
Return to rec.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 |
1.1 root 1: /* rec.c
2: Routines to receive a file.
3:
4: Copyright (C) 1991, 1992 Ian Lance Taylor
5:
6: This file is part of the Taylor UUCP package.
7:
8: This program is free software; you can redistribute it and/or
9: modify it under the terms of the GNU General Public License as
10: published by the Free Software Foundation; either version 2 of the
11: License, or (at your option) any later version.
12:
13: This program is distributed in the hope that it will be useful, but
14: WITHOUT ANY WARRANTY; without even the implied warranty of
15: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16: General Public License for more details.
17:
18: You should have received a copy of the GNU General Public License
19: along with this program; if not, write to the Free Software
20: Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21:
22: The author of the program may be contacted at [email protected] or
23: c/o Infinity Development Systems, P.O. Box 520, Waltham, MA 02254.
24: */
25:
26: #include "uucp.h"
27:
28: #if USE_RCS_ID
29: const char rec_rcsid[] = "$Id: rec.c,v 1.1 93/07/30 07:53:56 bin Exp Locker: bin $";
30: #endif
31:
32: #include <errno.h>
33:
34: #include "uudefs.h"
35: #include "uuconf.h"
36: #include "system.h"
37: #include "prot.h"
38: #include "trans.h"
39:
40: /* If the other side does not tell us the size of a file it wants to
41: send us, we assume it is this long. This is only used for free
42: space checking. */
43: #define CASSUMED_FILE_SIZE (10240)
44:
45: /* We keep this information in the pinfo field of the stransfer
46: structure. */
47: struct srecinfo
48: {
49: /* Local user to send mail to (may be NULL). */
50: char *zmail;
51: /* Full file name. */
52: char *zfile;
53: /* Temporary file name. */
54: char *ztemp;
55: /* TRUE if this is a spool directory file. */
56: boolean fspool;
57: /* TRUE if this was a local request. */
58: boolean flocal;
59: /* TRUE if the file has been completely received. */
60: boolean freceived;
61: /* TRUE if remote request has been replied to. */
62: boolean freplied;
63: /* TRUE if we moved the file to the final destination. */
64: boolean fmoved;
65: };
66:
67: /* This structure is kept in the pinfo field if we are refusing a
68: remote request. */
69: struct srecfailinfo
70: {
71: /* Reason for refusal. */
72: enum tfailure twhy;
73: /* TRUE if we have sent the reason for refusal. */
74: boolean fsent;
75: /* TRUE if we have seen the end of the file. */
76: boolean freceived;
77: };
78:
79: /* Local functions. */
80:
81: static void urrec_free P((struct stransfer *qtrans));
82: static boolean flocal_rec_fail P((struct stransfer *qtrans,
83: struct scmd *qcmd,
84: const struct uuconf_system *qsys,
85: const char *zwhy));
86: static boolean flocal_rec_send_request P((struct stransfer *qtrans,
87: struct sdaemon *qdaemon));
88: static boolean flocal_rec_await_reply P((struct stransfer *qtrans,
89: struct sdaemon *qdaemon,
90: const char *zdata,
91: size_t cdata));
92: static boolean fremote_send_reply P((struct stransfer *qtrans,
93: struct sdaemon *qdaemon));
94: static boolean fremote_send_fail P((struct sdaemon *qdaemon,
95: struct scmd *qcmd,
96: enum tfailure twhy,
97: int iremote));
98: static boolean fremote_send_fail_send P((struct stransfer *qtrans,
99: struct sdaemon *qdaemon));
100: static boolean fremote_discard P((struct stransfer *qtrans,
101: struct sdaemon *qdaemon,
102: const char *zdata, size_t cdata));
103: static boolean frec_file_end P((struct stransfer *qtrans,
104: struct sdaemon *qdaemon,
105: const char *zdata, size_t cdata));
106: static boolean frec_file_send_confirm P((struct stransfer *qtrans,
107: struct sdaemon *qdaemon));
108:
109: /* Free up a receive stransfer structure. */
110:
111: static void
112: urrec_free (qtrans)
113: struct stransfer *qtrans;
114: {
115: struct srecinfo *qinfo = (struct srecinfo *) qtrans->pinfo;
116:
117: if (qinfo != NULL)
118: {
119: ubuffree (qinfo->zmail);
120: ubuffree (qinfo->zfile);
121: ubuffree (qinfo->ztemp);
122: xfree (qtrans->pinfo);
123: }
124:
125: utransfree (qtrans);
126: }
127:
128: /* Set up a request for a file from the remote system. This may be
129: called before the remote system has been called.
130:
131: This is the order of function calls:
132:
133: flocal_rec_file_init --> fqueue_local
134: flocal_rec_send_request (send R ...) --> fqueue_receive
135: flocal_rec_await_reply (open file, call pffile) --> fqueue_receive
136: receive file
137: frec_file_end (close and move file, call pffile) --> fqueue_send
138: frec_file_send_confirm (send CY)
139: */
140:
141: boolean
142: flocal_rec_file_init (qdaemon, qcmd)
143: struct sdaemon *qdaemon;
144: struct scmd *qcmd;
145: {
146: const struct uuconf_system *qsys;
147: boolean fspool;
148: char *zfile;
149: struct srecinfo *qinfo;
150: struct stransfer *qtrans;
151:
152: qsys = qdaemon->qsys;
153:
154: /* Make sure we are permitted to transfer files. */
155: if (qdaemon->fcaller
156: ? ! qsys->uuconf_fcall_transfer
157: : ! qsys->uuconf_fcalled_transfer)
158: {
159: /* This case will have been checked by uucp or uux, but it could
160: have changed. */
161: if (! qsys->uuconf_fcall_transfer
162: && ! qsys->uuconf_fcalled_transfer)
163: return flocal_rec_fail ((struct stransfer *) NULL, qcmd, qsys,
164: "not permitted to request files");
165: return TRUE;
166: }
167:
168: fspool = fspool_file (qcmd->zto);
169:
170: if (fspool)
171: {
172: pointer puuconf;
173: int iuuconf;
174: const char *zlocalname;
175: struct uuconf_system slocalsys;
176:
177: /* Normal users are not allowed to request files to be received
178: into the spool directory. To support uux forwarding, we use
179: the special option '9'. This permits a file to be received
180: into the spool directory for the local system only without
181: the usual checking. This is only done for local requests, of
182: course. */
183: if (qcmd->zto[0] != 'D'
184: || strchr (qcmd->zoptions, '9') == NULL)
185: return flocal_rec_fail ((struct stransfer *) NULL, qcmd, qsys,
186: "not permitted to receive");
187:
188: puuconf = qdaemon->puuconf;
189: iuuconf = uuconf_localname (puuconf, &zlocalname);
190: if (iuuconf == UUCONF_NOT_FOUND)
191: {
192: zlocalname = zsysdep_localname ();
193: if (zlocalname == NULL)
194: return FALSE;
195: }
196: else if (iuuconf != UUCONF_SUCCESS)
197: {
198: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
199: return FALSE;
200: }
201:
202: iuuconf = uuconf_system_info (puuconf, zlocalname, &slocalsys);
203: if (iuuconf == UUCONF_NOT_FOUND)
204: {
205: iuuconf = uuconf_system_local (puuconf, &slocalsys);
206: if (iuuconf != UUCONF_SUCCESS)
207: {
208: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
209: return FALSE;
210: }
211: }
212: else if (iuuconf != UUCONF_SUCCESS)
213: {
214: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
215: return FALSE;
216: }
217:
218: zfile = zsysdep_spool_file_name (&slocalsys, qcmd->zto, qcmd->pseq);
219:
220: (void) uuconf_system_free (puuconf, &slocalsys);
221:
222: if (zfile == NULL)
223: return FALSE;
224: }
225: else
226: {
227: zfile = zsysdep_add_base (qcmd->zto, qcmd->zfrom);
228: if (zfile == NULL)
229: return FALSE;
230:
231: /* Check permissions. */
232: if (! fin_directory_list (zfile, qsys->uuconf_pzlocal_receive,
233: qsys->uuconf_zpubdir, TRUE,
234: FALSE, qcmd->zuser))
235: {
236: ubuffree (zfile);
237: return flocal_rec_fail ((struct stransfer *) NULL, qcmd, qsys,
238: "not permitted to receive");
239: }
240:
241: /* The 'f' option means that directories should not
242: be created if they do not already exist. */
243: if (strchr (qcmd->zoptions, 'f') == NULL)
244: {
245: if (! fsysdep_make_dirs (zfile, TRUE))
246: {
247: ubuffree (zfile);
248: return flocal_rec_fail ((struct stransfer *) NULL, qcmd,
249: qsys, "cannot create directories");
250: }
251: }
252: }
253:
254: qinfo = (struct srecinfo *) xmalloc (sizeof (struct srecinfo));
255: if (strchr (qcmd->zoptions, 'm') == NULL)
256: qinfo->zmail = NULL;
257: else
258: qinfo->zmail = zbufcpy (qcmd->zuser);
259: qinfo->zfile = zfile;
260: qinfo->ztemp = NULL;
261: qinfo->fspool = fspool;
262: qinfo->flocal = TRUE;
263: qinfo->freceived = FALSE;
264: qinfo->freplied = TRUE;
265:
266: qtrans = qtransalc (qcmd);
267: qtrans->psendfn = flocal_rec_send_request;
268: qtrans->pinfo = (pointer) qinfo;
269:
270: return fqueue_local (qdaemon, qtrans);
271: }
272:
273: /* Report an error for a local receive request. */
274:
275: static boolean
276: flocal_rec_fail (qtrans, qcmd, qsys, zwhy)
277: struct stransfer *qtrans;
278: struct scmd *qcmd;
279: const struct uuconf_system *qsys;
280: const char *zwhy;
281: {
282: if (zwhy != NULL)
283: {
284: ulog (LOG_ERROR, "%s: %s", qcmd->zfrom, zwhy);
285: (void) fmail_transfer (FALSE, qcmd->zuser, (const char *) NULL, zwhy,
286: qcmd->zfrom, qsys->uuconf_zname,
287: qcmd->zto, (const char *) NULL,
288: (const char *) NULL);
289: (void) fsysdep_did_work (qcmd->pseq);
290: }
291: if (qtrans != NULL)
292: urrec_free (qtrans);
293: return TRUE;
294: }
295:
296: /* This is called when we are ready to send the actual request to the
297: other system. */
298:
299: static boolean
300: flocal_rec_send_request (qtrans, qdaemon)
301: struct stransfer *qtrans;
302: struct sdaemon *qdaemon;
303: {
304: struct srecinfo *qinfo = (struct srecinfo *) qtrans->pinfo;
305: long cbytes, cbytes2;
306: size_t clen;
307: char *zsend;
308: boolean fret;
309:
310: qinfo->ztemp = zsysdep_receive_temp (qdaemon->qsys, qinfo->zfile,
311: (const char *) NULL);
312: if (qinfo->ztemp == NULL)
313: {
314: urrec_free (qtrans);
315: return FALSE;
316: }
317:
318: /* Check the amount of free space available for both the temporary
319: file and the real file. */
320: cbytes = csysdep_bytes_free (qinfo->ztemp);
321: cbytes2 = csysdep_bytes_free (qinfo->zfile);
322: if (cbytes < cbytes2)
323: cbytes = cbytes2;
324: if (cbytes != -1)
325: {
326: cbytes -= qdaemon->qsys->uuconf_cfree_space;
327: if (cbytes < 0)
328: cbytes = 0;
329: }
330:
331: if (qdaemon->clocal_size != -1
332: && (cbytes == -1 || qdaemon->clocal_size < cbytes))
333: cbytes = qdaemon->clocal_size;
334:
335: /* We send the string
336: R from to user options
337:
338: We put a dash in front of options. If we are talking to a
339: counterpart, we also send the maximum size file we are prepared
340: to accept, as returned by esysdep_open_receive. */
341: clen = (strlen (qtrans->s.zfrom) + strlen (qtrans->s.zto)
342: + strlen (qtrans->s.zuser) + strlen (qtrans->s.zoptions) + 30);
343: zsend = zbufalc (clen);
344: if ((qdaemon->ifeatures & FEATURE_SIZES) == 0)
345: sprintf (zsend, "R %s %s %s -%s", qtrans->s.zfrom, qtrans->s.zto,
346: qtrans->s.zuser, qtrans->s.zoptions);
347: else if ((qdaemon->ifeatures & FEATURE_V103) == 0)
348: sprintf (zsend, "R %s %s %s -%s 0x%lx", qtrans->s.zfrom, qtrans->s.zto,
349: qtrans->s.zuser, qtrans->s.zoptions, (unsigned long) cbytes);
350: else
351: sprintf (zsend, "R %s %s %s -%s %ld", qtrans->s.zfrom, qtrans->s.zto,
352: qtrans->s.zuser, qtrans->s.zoptions, cbytes);
353:
354: fret = (*qdaemon->qproto->pfsendcmd) (qdaemon, zsend, qtrans->ilocal,
355: qtrans->iremote);
356: ubuffree (zsend);
357: if (! fret)
358: {
359: urrec_free (qtrans);
360: return FALSE;
361: }
362:
363: qtrans->fcmd = TRUE;
364: qtrans->precfn = flocal_rec_await_reply;
365:
366: return fqueue_receive (qdaemon, qtrans);
367: }
368:
369: /* This is called when a reply is received for the request. */
370:
371: /*ARGSUSED*/
372: static boolean
373: flocal_rec_await_reply (qtrans, qdaemon, zdata, cdata)
374: struct stransfer *qtrans;
375: struct sdaemon *qdaemon;
376: const char *zdata;
377: size_t cdata;
378: {
379: struct srecinfo *qinfo = (struct srecinfo *) qtrans->pinfo;
380: long crestart;
381: const char *zlog;
382:
383: if (zdata[0] != 'R'
384: || (zdata[1] != 'Y' && zdata[1] != 'N'))
385: {
386: ulog (LOG_ERROR, "%s: bad response to receive request: \"%s\"",
387: qtrans->s.zfrom, zdata);
388: urrec_free (qtrans);
389: return FALSE;
390: }
391:
392: if (zdata[1] == 'N')
393: {
394: boolean fnever;
395: const char *zerr;
396:
397: fnever = TRUE;
398: if (zdata[2] == '2')
399: zerr = "no such file";
400: else if (zdata[2] == '6')
401: {
402: /* We sent over the maximum file size we were prepared to
403: receive, and the remote system is telling us that the
404: file is larger than that. Try again later. It would be
405: better if we could know whether there will ever be enough
406: room. */
407: zerr = "too large to receive now";
408: fnever = FALSE;
409: }
410: else
411: zerr = "unknown reason";
412:
413: if (fnever)
414: return flocal_rec_fail (qtrans, &qtrans->s, qdaemon->qsys, zerr);
415:
416: ulog (LOG_ERROR, "%s: %s", qtrans->s.zfrom, zerr);
417:
418: urrec_free (qtrans);
419:
420: return TRUE;
421: }
422:
423: /* The mode should have been sent as "RY 0%o". If it wasn't, we use
424: 0666. */
425: qtrans->s.imode = (unsigned int) strtol ((char *) (zdata + 2),
426: (char **) NULL, 8);
427: if (qtrans->s.imode == 0)
428: qtrans->s.imode = 0666;
429:
430: /* Open the file to receive into. We just ignore any restart count,
431: since we have no way to tell it to the other side. SVR4 may have
432: some way to do this, but I don't know what it is. */
433: qtrans->e = esysdep_open_receive (qdaemon->qsys, qinfo->zfile,
434: (const char *) NULL, qinfo->ztemp,
435: &crestart);
436: if (! ffileisopen (qtrans->e))
437: return flocal_rec_fail (qtrans, &qtrans->s, qdaemon->qsys,
438: "cannot open file");
439:
440: if (qinfo->fspool)
441: zlog = qtrans->s.zto;
442: else
443: zlog = qinfo->zfile;
444: qtrans->zlog = zbufalc (sizeof "Receiving " + strlen (zlog));
445: sprintf (qtrans->zlog, "Receiving %s", zlog);
446:
447: if (qdaemon->qproto->pffile != NULL)
448: {
449: boolean fhandled;
450:
451: if (! (*qdaemon->qproto->pffile) (qdaemon, qtrans, TRUE, FALSE,
452: (long) -1, &fhandled))
453: {
454: (void) ffileclose (qtrans->e);
455: return flocal_rec_fail (qtrans, &qtrans->s, qdaemon->qsys,
456: (const char *) NULL);
457: }
458: if (fhandled)
459: return TRUE;
460: }
461:
462: qtrans->frecfile = TRUE;
463: qtrans->psendfn = frec_file_send_confirm;
464: qtrans->precfn = frec_file_end;
465:
466: return fqueue_receive (qdaemon, qtrans);
467: }
468:
469: /* Make sure there is still enough disk space available to receive a
470: file. */
471:
472: boolean
473: frec_check_free (qtrans, cfree_space)
474: struct stransfer *qtrans;
475: long cfree_space;
476: {
477: struct srecinfo *qinfo = (struct srecinfo *) qtrans->pinfo;
478: long cfree1, cfree2;
479:
480: cfree1 = csysdep_bytes_free (qinfo->ztemp);
481: cfree2 = csysdep_bytes_free (qinfo->zfile);
482: if (cfree1 < cfree2)
483: cfree1 = cfree2;
484: if (cfree1 != -1 && cfree1 < cfree_space)
485: {
486: ulog (LOG_ERROR, "%s: too big to receive now", qinfo->zfile);
487: return FALSE;
488: }
489:
490: return TRUE;
491: }
492:
493: /* A remote request to send a file to the local system, meaning that
494: we are going to receive a file.
495:
496: If we are using a protocol which does not support multiple
497: channels, the remote system will not start sending us the file
498: until it has received our confirmation. In that case, the order of
499: functions is as follows:
500:
501: fremote_send_file_init (open file) --> fqueue_remote
502: fremote_send_reply (send SY, call pffile) --> fqueue_receive
503: receive file
504: frec_file_end (close and move file, call pffile) --> fqueue_send
505: frec_file_send_confirm (send CY)
506:
507: If the protocol supports multiple channels, then the remote system
508: will start sending the file immediately after the send request.
509: That means that the data may come in before remote_send_reply is
510: called, so frec_file_end may be called before fremote_send_reply.
511: Note that this means the pffile entry points may be called in
512: reverse order for such a protocol.
513:
514: If the send request is rejected, via fremote_send_fail, and the
515: protocol supports multiple channels, we must accept and discard
516: data until a zero byte buffer is received from the other side,
517: indicating that it has received our rejection.
518:
519: This code also handles execution requests, which are very similar
520: to send requests. */
521:
522: boolean
523: fremote_send_file_init (qdaemon, qcmd, iremote)
524: struct sdaemon *qdaemon;
525: struct scmd *qcmd;
526: int iremote;
527: {
528: const struct uuconf_system *qsys;
529: boolean fspool;
530: char *zfile;
531: openfile_t e;
532: char *ztemp;
533: long cbytes, cbytes2;
534: long crestart;
535: struct srecinfo *qinfo;
536: struct stransfer *qtrans;
537: const char *zlog;
538:
539: qsys = qdaemon->qsys;
540:
541: if (! qsys->uuconf_frec_request)
542: {
543: ulog (LOG_ERROR, "%s: not permitted to receive files from remote",
544: qcmd->zfrom);
545: return fremote_send_fail (qdaemon, qcmd, FAILURE_PERM, iremote);
546: }
547:
548: fspool = fspool_file (qcmd->zto);
549:
550: /* We don't accept remote command files. An execution request may
551: only send a simple data file. */
552: if ((fspool && qcmd->zto[0] == 'C')
553: || (qcmd->bcmd == 'E'
554: && (! fspool || qcmd->zto[0] != 'D')))
555: {
556: ulog (LOG_ERROR, "%s: not permitted to receive", qcmd->zfrom);
557: return fremote_send_fail (qdaemon, qcmd, FAILURE_PERM, iremote);
558: }
559:
560: /* See if we have already received this file in a previous
561: conversation. */
562: if (fsysdep_already_received (qsys, qcmd->zto, qcmd->ztemp))
563: return fremote_send_fail (qdaemon, qcmd, FAILURE_RECEIVED, iremote);
564:
565: if (fspool)
566: {
567: zfile = zsysdep_spool_file_name (qsys, qcmd->zto, (pointer) NULL);
568: if (zfile == NULL)
569: return FALSE;
570: }
571: else
572: {
573: zfile = zsysdep_local_file (qcmd->zto, qsys->uuconf_zpubdir);
574: if (zfile != NULL)
575: {
576: char *zadd;
577:
578: zadd = zsysdep_add_base (zfile, qcmd->zfrom);
579: ubuffree (zfile);
580: zfile = zadd;
581: }
582: if (zfile == NULL)
583: return FALSE;
584:
585: /* Check permissions. */
586: if (! fin_directory_list (zfile, qsys->uuconf_pzremote_receive,
587: qsys->uuconf_zpubdir, TRUE,
588: FALSE, (const char *) NULL))
589: {
590: ulog (LOG_ERROR, "%s: not permitted to receive", zfile);
591: ubuffree (zfile);
592: return fremote_send_fail (qdaemon, qcmd, FAILURE_PERM, iremote);
593: }
594:
595: if (strchr (qcmd->zoptions, 'f') == NULL)
596: {
597: if (! fsysdep_make_dirs (zfile, TRUE))
598: {
599: ubuffree (zfile);
600: return fremote_send_fail (qdaemon, qcmd, FAILURE_OPEN,
601: iremote);
602: }
603: }
604: }
605:
606: ztemp = zsysdep_receive_temp (qsys, zfile, qcmd->ztemp);
607:
608: /* Adjust the number of bytes we are prepared to receive according
609: to the amount of free space we are supposed to leave available
610: and the maximum file size we are permitted to transfer. */
611: cbytes = csysdep_bytes_free (ztemp);
612: cbytes2 = csysdep_bytes_free (zfile);
613: if (cbytes < cbytes2)
614: cbytes = cbytes2;
615:
616: if (cbytes != -1)
617: {
618: cbytes -= qsys->uuconf_cfree_space;
619: if (cbytes < 0)
620: cbytes = 0;
621: }
622:
623: if (qdaemon->cremote_size != -1
624: && (cbytes == -1 || qdaemon->cremote_size < cbytes))
625: cbytes = qdaemon->cremote_size;
626:
627: /* If the number of bytes we are prepared to receive is less than
628: the file size, we must fail. If the remote did not tell us the
629: file size, arbitrarily assumed that it is 10240 bytes. */
630: if (cbytes != -1)
631: {
632: long csize;
633:
634: csize = qcmd->cbytes;
635: if (csize == -1)
636: csize = CASSUMED_FILE_SIZE;
637: if (cbytes < csize)
638: {
639: ulog (LOG_ERROR, "%s: too big to receive", zfile);
640: ubuffree (ztemp);
641: ubuffree (zfile);
642: return fremote_send_fail (qdaemon, qcmd, FAILURE_SIZE, iremote);
643: }
644: }
645:
646: /* Open the file to receive into. This may find an old copy of the
647: file, which will be used for file restart if the other side
648: supports it. */
649: e = esysdep_open_receive (qsys, zfile, qcmd->ztemp, ztemp, &crestart);
650: if (! ffileisopen (e))
651: {
652: ubuffree (ztemp);
653: ubuffree (zfile);
654: return fremote_send_fail (qdaemon, qcmd, FAILURE_OPEN, iremote);
655: }
656:
657: if (crestart > 0)
658: {
659: if ((qdaemon->ifeatures & FEATURE_RESTART) == 0)
660: crestart = -1;
661: else
662: {
663: DEBUG_MESSAGE1 (DEBUG_UUCP_PROTO,
664: "fremote_send_file_init: Restarting receive from %ld",
665: crestart);
666: if (! ffileseek (e, crestart))
667: {
668: ulog (LOG_ERROR, "seek: %s", strerror (errno));
669: (void) ffileclose (e);
670: ubuffree (ztemp);
671: ubuffree (zfile);
672: return FALSE;
673: }
674: }
675: }
676:
677: qinfo = (struct srecinfo *) xmalloc (sizeof (struct srecinfo));
678: if (strchr (qcmd->zoptions, 'n') == NULL)
679: qinfo->zmail = NULL;
680: else
681: qinfo->zmail = zbufcpy (qcmd->znotify);
682: qinfo->zfile = zfile;
683: qinfo->ztemp = ztemp;
684: qinfo->fspool = fspool;
685: qinfo->flocal = FALSE;
686: qinfo->freceived = FALSE;
687: qinfo->freplied = FALSE;
688:
689: qtrans = qtransalc (qcmd);
690: qtrans->psendfn = fremote_send_reply;
691: qtrans->precfn = frec_file_end;
692: qtrans->iremote = iremote;
693: qtrans->pinfo = (pointer) qinfo;
694: qtrans->frecfile = TRUE;
695: qtrans->e = e;
696: if (crestart > 0)
697: qtrans->ipos = crestart;
698:
699: if (qcmd->bcmd == 'E')
700: zlog = qcmd->zcmd;
701: else
702: {
703: if (qinfo->fspool)
704: zlog = qcmd->zto;
705: else
706: zlog = qinfo->zfile;
707: }
708: qtrans->zlog = zbufalc (sizeof "Receiving " + strlen (zlog));
709: sprintf (qtrans->zlog, "Receiving %s", zlog);
710:
711: return fqueue_remote (qdaemon, qtrans);
712: }
713:
714: /* Reply to a send request, and prepare to receive the file. */
715:
716: static boolean
717: fremote_send_reply (qtrans, qdaemon)
718: struct stransfer *qtrans;
719: struct sdaemon *qdaemon;
720: {
721: struct srecinfo *qinfo = (struct srecinfo *) qtrans->pinfo;
722: char ab[50];
723:
724: ab[0] = qtrans->s.bcmd;
725: ab[1] = 'Y';
726: if (qtrans->ipos <= 0)
727: ab[2] = '\0';
728: else
729: sprintf (ab + 2, " 0x%lx", (unsigned long) qtrans->ipos);
730:
731: if (! (*qdaemon->qproto->pfsendcmd) (qdaemon, ab, qtrans->ilocal,
732: qtrans->iremote))
733: {
734: (void) ffileclose (qtrans->e);
735: (void) remove (qinfo->ztemp);
736: urrec_free (qtrans);
737: return FALSE;
738: }
739:
740: qinfo->freplied = TRUE;
741:
742: if (qdaemon->qproto->pffile != NULL)
743: {
744: boolean fhandled;
745:
746: if (! (*qdaemon->qproto->pffile) (qdaemon, qtrans, TRUE, FALSE,
747: (long) -1, &fhandled))
748: {
749: (void) ffileclose (qtrans->e);
750: (void) remove (qinfo->ztemp);
751: urrec_free (qtrans);
752: return FALSE;
753: }
754: if (fhandled)
755: return TRUE;
756: }
757:
758: /* If the file has been completely received, we just want to send
759: the final confirmation. Otherwise, we must wait for the file
760: first. */
761: qtrans->psendfn = frec_file_send_confirm;
762: if (qinfo->freceived)
763: return fqueue_send (qdaemon, qtrans);
764: else
765: return fqueue_receive (qdaemon, qtrans);
766: }
767:
768: /* If we can't receive a file, queue up a response to the remote
769: system. */
770:
771: static boolean
772: fremote_send_fail (qdaemon, qcmd, twhy, iremote)
773: struct sdaemon *qdaemon;
774: struct scmd *qcmd;
775: enum tfailure twhy;
776: int iremote;
777: {
778: struct srecfailinfo *qinfo;
779: struct stransfer *qtrans;
780:
781: qinfo = (struct srecfailinfo *) xmalloc (sizeof (struct srecfailinfo));
782: qinfo->twhy = twhy;
783: qinfo->fsent = FALSE;
784:
785: /* If the protocol does not support multiple channels (cchans <= 1),
786: then we have essentially already received the entire file. */
787: qinfo->freceived = qdaemon->qproto->cchans <= 1;
788:
789: qtrans = qtransalc (qcmd);
790: qtrans->psendfn = fremote_send_fail_send;
791: qtrans->precfn = fremote_discard;
792: qtrans->iremote = iremote;
793: qtrans->pinfo = (pointer) qinfo;
794:
795: return fqueue_remote (qdaemon, qtrans);
796: }
797:
798: /* Send a failure string for a send command to the remote system;
799: this is called when we are ready to reply to the command. */
800:
801: static boolean
802: fremote_send_fail_send (qtrans, qdaemon)
803: struct stransfer *qtrans;
804: struct sdaemon *qdaemon;
805: {
806: struct srecfailinfo *qinfo = (struct srecfailinfo *) qtrans->pinfo;
807: char ab[4];
808: boolean fret;
809:
810: ab[0] = qtrans->s.bcmd;
811: ab[1] = 'N';
812:
813: switch (qinfo->twhy)
814: {
815: case FAILURE_PERM:
816: ab[2] = '2';
817: break;
818: case FAILURE_OPEN:
819: ab[2] = '4';
820: break;
821: case FAILURE_SIZE:
822: ab[2] = '6';
823: break;
824: case FAILURE_RECEIVED:
825: /* Remember this file as though we successfully received it;
826: when the other side acknowledges our rejection, we know that
827: we no longer have to remember that we received this file. */
828: usent_receive_ack (qdaemon, qtrans);
829: ab[2] = '8';
830: break;
831: default:
832: ab[2] = '\0';
833: break;
834: }
835:
836: ab[3] = '\0';
837:
838: fret = (*qdaemon->qproto->pfsendcmd) (qdaemon, ab, qtrans->ilocal,
839: qtrans->iremote);
840:
841: qinfo->fsent = TRUE;
842:
843: /* Wait for the end of file marker if we haven't gotten it yet. */
844: if (! qinfo->freceived)
845: {
846: if (! fqueue_receive (qdaemon, qtrans))
847: fret = FALSE;
848: }
849: else
850: {
851: xfree (qtrans->pinfo);
852: utransfree (qtrans);
853: }
854:
855: return fret;
856: }
857:
858: /* Discard data until we reach the end of the file. This is used for
859: a protocol with multiple channels, since the remote system may
860: start sending the file before the confirmation is sent. If we
861: refuse the file, the remote system will get us back in synch by
862: sending an empty buffer, which is what we look for here. */
863:
864: /*ARGSUSED*/
865: static boolean
866: fremote_discard (qtrans, qdaemon, zdata, cdata)
867: struct stransfer *qtrans;
868: struct sdaemon *qdaemon;
869: const char *zdata;
870: size_t cdata;
871: {
872: struct srecfailinfo *qinfo = (struct srecfailinfo *) qtrans->pinfo;
873:
874: DEBUG_MESSAGE1 (DEBUG_UUCP_PROTO,
875: "fremote_discard: Discarding %lu bytes",
876: (unsigned long) cdata);
877:
878: if (cdata != 0)
879: return TRUE;
880:
881: qinfo->freceived = TRUE;
882:
883: /* If we have already sent the denial, we are done. */
884: if (qinfo->fsent)
885: {
886: xfree (qtrans->pinfo);
887: utransfree (qtrans);
888: }
889:
890: return TRUE;
891: }
892:
893: /* This is called when a file has been completely received. It sends
894: a response to the remote system. */
895:
896: /*ARGSUSED*/
897: static boolean
898: frec_file_end (qtrans, qdaemon, zdata, cdata)
899: struct stransfer *qtrans;
900: struct sdaemon *qdaemon;
901: const char *zdata;
902: size_t cdata;
903: {
904: struct srecinfo *qinfo = (struct srecinfo *) qtrans->pinfo;
905: const char *zerr;
906: boolean fnever;
907:
908: DEBUG_MESSAGE3 (DEBUG_UUCP_PROTO, "frec_file_end: %s to %s (freplied %s)",
909: qtrans->s.zfrom, qtrans->s.zto,
910: qinfo->freplied ? "TRUE" : "FALSE");
911:
912: if (qdaemon->qproto->pffile != NULL)
913: {
914: boolean fhandled;
915:
916: if (! (*qdaemon->qproto->pffile) (qdaemon, qtrans, FALSE, FALSE,
917: (long) -1, &fhandled))
918: {
919: (void) ffileclose (qtrans->e);
920: (void) remove (qinfo->ztemp);
921: urrec_free (qtrans);
922: return FALSE;
923: }
924: if (fhandled)
925: return TRUE;
926: }
927:
928: qinfo->freceived = TRUE;
929:
930: fnever = FALSE;
931:
932: if (! ffileclose (qtrans->e))
933: {
934: zerr = strerror (errno);
935: ulog (LOG_ERROR, "%s: close: %s", qtrans->s.zto, zerr);
936: }
937: else if (! fsysdep_move_file (qinfo->ztemp, qinfo->zfile, qinfo->fspool,
938: FALSE, ! qinfo->fspool,
939: (qinfo->flocal
940: ? qtrans->s.zuser
941: : (const char *) NULL)))
942: {
943: zerr = "could not move to final location";
944: ulog (LOG_ERROR, "%s: %s", qinfo->zfile, zerr);
945: fnever = TRUE;
946: }
947: else
948: {
949: if (! qinfo->fspool)
950: {
951: unsigned int imode;
952:
953: /* Unless we can change the ownership of the file, the only
954: choice to make about these bits is whether to set the
955: execute bit or not. */
956: if ((qtrans->s.imode & 0111) != 0)
957: imode = 0777;
958: else
959: imode = 0666;
960: (void) fsysdep_change_mode (qinfo->zfile, imode);
961: }
962:
963: zerr = NULL;
964: }
965:
966: if (zerr != NULL)
967: (void) remove (qinfo->ztemp);
968:
969: ustats (zerr == NULL, qtrans->s.zuser, qdaemon->qsys->uuconf_zname,
970: FALSE, qtrans->cbytes, qtrans->isecs, qtrans->imicros,
971: qdaemon->fmaster);
972:
973: if (zerr == NULL)
974: {
975: if (qinfo->zmail != NULL && *qinfo->zmail != '\0')
976: (void) fmail_transfer (TRUE, qtrans->s.zuser, qinfo->zmail,
977: (const char *) NULL,
978: qtrans->s.zfrom, qdaemon->qsys->uuconf_zname,
979: qtrans->s.zto, (const char *) NULL,
980: (const char *) NULL);
981:
982: if (qtrans->s.pseq != NULL)
983: (void) fsysdep_did_work (qtrans->s.pseq);
984:
985: if (! qinfo->flocal)
986: {
987: /* Remember that we have received this file, so that if the
988: connection drops at this point we won't receive it again.
989: We could check the return value here, but if we return
990: FALSE we couldn't do anything but drop the connection,
991: which would hardly be reasonable. Instead we trust that
992: the administrator will notice and handle any error
993: messages, which are very unlikely to occur if everything
994: is set up correctly. */
995: (void) fsysdep_remember_reception (qdaemon->qsys, qtrans->s.zto,
996: qtrans->s.ztemp);
997: }
998: }
999: else
1000: {
1001: /* If the transfer failed, we send mail if it was requested
1002: locally and if it can never succeed. */
1003: if (qinfo->flocal && fnever)
1004: {
1005: (void) fmail_transfer (FALSE, qtrans->s.zuser, qinfo->zmail,
1006: zerr, qtrans->s.zfrom,
1007: qdaemon->qsys->uuconf_zname,
1008: qtrans->s.zto, (const char *) NULL,
1009: (const char *) NULL);
1010: (void) fsysdep_did_work (qtrans->s.pseq);
1011: }
1012: }
1013:
1014: /* If this is an execution request, we must create the execution
1015: file itself. */
1016: if (qtrans->s.bcmd == 'E' && zerr == NULL)
1017: {
1018: char *zxqt, *zxqtfile, *ztemp;
1019: FILE *e;
1020: boolean fbad;
1021:
1022: /* We get an execution file name by simply replacing the leading
1023: D in the received file name with an X. This pretty much
1024: always has to work since we can always receive a file name
1025: starting with X, so the system dependent code must be
1026: prepared to see one. */
1027: zxqt = zbufcpy (qtrans->s.zto);
1028: zxqt[0] = 'X';
1029: zxqtfile = zsysdep_spool_file_name (qdaemon->qsys, zxqt,
1030: (pointer) NULL);
1031: ubuffree (zxqt);
1032:
1033: if (zxqtfile == NULL)
1034: {
1035: urrec_free (qtrans);
1036: return FALSE;
1037: }
1038:
1039: /* We have to write via a temporary file, because otherwise
1040: uuxqt might pick up the file before we have finished writing
1041: it. */
1042: e = NULL;
1043: ztemp = zsysdep_receive_temp (qdaemon->qsys, zxqtfile, "D.0");
1044: if (ztemp != NULL)
1045: e = esysdep_fopen (ztemp, FALSE, FALSE, TRUE);
1046:
1047: if (e == NULL)
1048: {
1049: ubuffree (zxqtfile);
1050: ubuffree (ztemp);
1051: urrec_free (qtrans);
1052: return FALSE;
1053: }
1054:
1055: fprintf (e, "U %s %s\n", qtrans->s.zuser, qdaemon->qsys->uuconf_zname);
1056: fprintf (e, "F %s\n", qtrans->s.zto);
1057: fprintf (e, "I %s\n", qtrans->s.zto);
1058: if (strchr (qtrans->s.zoptions, 'N') != NULL)
1059: fprintf (e, "N\n");
1060: if (strchr (qtrans->s.zoptions, 'Z') != NULL)
1061: fprintf (e, "Z\n");
1062: if (strchr (qtrans->s.zoptions, 'R') != NULL)
1063: fprintf (e, "R %s\n", qtrans->s.znotify);
1064: if (strchr (qtrans->s.zoptions, 'e') != NULL)
1065: fprintf (e, "e\n");
1066: fprintf (e, "C %s\n", qtrans->s.zcmd);
1067:
1068: fbad = FALSE;
1069: if (fclose (e) == EOF)
1070: {
1071: ulog (LOG_ERROR, "fclose: %s", strerror (errno));
1072: (void) remove (ztemp);
1073: fbad = TRUE;
1074: }
1075:
1076: if (! fbad)
1077: {
1078: if (! fsysdep_move_file (ztemp, zxqtfile, TRUE, FALSE, FALSE,
1079: (const char *) NULL))
1080: fbad = TRUE;
1081: }
1082:
1083: ubuffree (zxqtfile);
1084: ubuffree (ztemp);
1085:
1086: if (fbad)
1087: {
1088: urrec_free (qtrans);
1089: return FALSE;
1090: }
1091: }
1092:
1093: /* Prepare to send the completion string to the remote system. If
1094: we have not yet replied to the remote send request, we leave the
1095: transfer structure on the remote queue. Otherwise we add it to
1096: the send queue. The psendfn field will already be set. */
1097: qinfo->fmoved = zerr == NULL;
1098: if (qinfo->freplied)
1099: return fqueue_send (qdaemon, qtrans);
1100:
1101: return TRUE;
1102: }
1103:
1104: /* Send the final confirmation string to the remote system. */
1105:
1106: static boolean
1107: frec_file_send_confirm (qtrans, qdaemon)
1108: struct stransfer *qtrans;
1109: struct sdaemon *qdaemon;
1110: {
1111: struct srecinfo *qinfo = (struct srecinfo *) qtrans->pinfo;
1112: const char *zsend;
1113: boolean fret;
1114:
1115: if (! qinfo->fmoved)
1116: zsend = "CN5";
1117: else if (! qdaemon->frequest_hangup)
1118: zsend = "CY";
1119: else
1120: {
1121: #if DEBUG > 0
1122: if (qdaemon->fmaster)
1123: ulog (LOG_FATAL, "frec_file_send_confirm: Can't happen");
1124: #endif
1125:
1126: DEBUG_MESSAGE0 (DEBUG_UUCP_PROTO,
1127: "frec_send_file_confirm: Requesting remote to transfer control");
1128: zsend = "CYM";
1129: }
1130:
1131: fret = (*qdaemon->qproto->pfsendcmd) (qdaemon, zsend,
1132: qtrans->ilocal, qtrans->iremote);
1133:
1134: /* Now, if that was a remote command, then when the confirmation
1135: message is acked we no longer have to remember that we received
1136: that file. */
1137: if (! qinfo->flocal && qinfo->fmoved)
1138: usent_receive_ack (qdaemon, qtrans);
1139:
1140: urrec_free (qtrans);
1141: return fret;
1142: }
1143:
1144: /* Discard a temporary file if it is not useful. A temporary file is
1145: useful if it could be used to restart a receive. This is called if
1146: the connection is lost. It is only called if qtrans->frecfile is
1147: TRUE. */
1148:
1149: boolean
1150: frec_discard_temp (qdaemon, qtrans)
1151: struct sdaemon *qdaemon;
1152: struct stransfer *qtrans;
1153: {
1154: struct srecinfo *qinfo = (struct srecinfo *) qtrans->pinfo;
1155:
1156: if ((qdaemon->ifeatures & FEATURE_RESTART) == 0
1157: || qtrans->s.ztemp == NULL
1158: || qtrans->s.ztemp[0] != 'D'
1159: || strcmp (qtrans->s.ztemp, "D.0") == 0)
1160: (void) remove (qinfo->ztemp);
1161: return TRUE;
1162: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.