![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uucico.c.mwcbb 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 uucico.c.mwcbb CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 |
1.1 root 1: /* uucico.c
2: This is the main UUCP communication program.
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 uucico_rcsid[] = "$Id: uucico.c,v 1.140 1993/01/18 05:03:06 ian Rel $";
30: #endif
31:
32: #include <ctype.h>
33:
34: #if HAVE_LIMITS_H
35: #include <limits.h>
36: #else
37: #define LONG_MAX 2147483647L
38: #endif
39:
40: #include "getopt.h"
41:
42: #include "uudefs.h"
43: #include "uuconf.h"
44: #include "conn.h"
45: #include "prot.h"
46: #include "trans.h"
47: #include "system.h"
48:
49: /* The program name. */
50: char abProgram[] = "uucico";
51:
52: /* Define the known protocols. */
53:
54: #define TCP_PROTO \
55: (UUCONF_RELIABLE_ENDTOEND \
56: | UUCONF_RELIABLE_RELIABLE \
57: | UUCONF_RELIABLE_EIGHT)
58:
59: static const struct sprotocol asProtocols[] =
60: {
61: { 't', TCP_PROTO, 1,
62: asTproto_params, ftstart, ftshutdown, ftsendcmd, ztgetspace,
63: ftsenddata, ftwait, ftfile },
64: { 'e', TCP_PROTO, 1,
65: asEproto_params, festart, feshutdown, fesendcmd, zegetspace,
66: fesenddata, fewait, fefile },
67: { 'i', UUCONF_RELIABLE_EIGHT, 7,
68: asIproto_params, fistart, fishutdown, fisendcmd, zigetspace,
69: fisenddata, fiwait, NULL },
70: { 'a', UUCONF_RELIABLE_EIGHT, 1,
71: asZproto_params, fzstart, fzshutdown, fzsendcmd, zzgetspace,
72: fzsenddata, fzwait, fzfile },
73: { 'g', UUCONF_RELIABLE_EIGHT, 1,
74: asGproto_params, fgstart, fgshutdown, fgsendcmd, zggetspace,
75: fgsenddata, fgwait, NULL },
76: { 'G', UUCONF_RELIABLE_EIGHT, 1,
77: asGproto_params, fbiggstart, fgshutdown, fgsendcmd, zggetspace,
78: fgsenddata, fgwait, NULL },
79: { 'j', UUCONF_RELIABLE_EIGHT, 7,
80: asIproto_params, fjstart, fjshutdown, fisendcmd, zigetspace,
81: fisenddata, fiwait, NULL },
82: { 'f', UUCONF_RELIABLE_RELIABLE, 1,
83: asFproto_params, ffstart, ffshutdown, ffsendcmd, zfgetspace,
84: ffsenddata, ffwait, fffile },
85: };
86:
87: #define CPROTOCOLS (sizeof asProtocols / sizeof asProtocols[0])
88:
89: /* Locked system. */
90: static boolean fLocked_system;
91: static struct uuconf_system sLocked_system;
92:
93: /* Daemon structure holding information about the remote system (must
94: be global so the error handler can see it. */
95: static struct sdaemon sDaemon;
96:
97: /* Open connection. */
98: static struct sconnection *qConn;
99:
100: /* uuconf global pointer; need to close the connection after a fatal
101: error. */
102: static pointer pUuconf;
103:
104: /* This structure is passed to iuport_lock via uuconf_find_port. */
105: struct spass
106: {
107: boolean fmatched;
108: boolean flocked;
109: struct sconnection *qconn;
110: };
111:
112: /* Local functions. */
113:
114: static void uusage P((void));
115: static void uabort P((void));
116: static boolean fcall P((pointer puuconf,
117: const struct uuconf_system *qsys,
118: struct uuconf_port *qport, boolean fifwork,
119: boolean fforce, boolean fdetach,
120: boolean ftimewarn));
121: static boolean fconn_call P((struct sdaemon *qdaemon,
122: struct uuconf_port *qport,
123: struct sstatus *qstat, int cretry,
124: boolean *pfcalled));
125: static boolean fdo_call P((struct sdaemon *qdaemon,
126: struct sstatus *qstat,
127: const struct uuconf_dialer *qdialer,
128: boolean *pfcalled, enum tstatus_type *pterr));
129: static int iuport_lock P((struct uuconf_port *qport, pointer pinfo));
130: static boolean flogin_prompt P((pointer puuconf,
131: struct sconnection *qconn));
132: static boolean faccept_call P((pointer puuconf, const char *zlogin,
133: struct sconnection *qconn,
134: const char **pzsystem));
135: static void uapply_proto_params P((pointer puuconf, int bproto,
136: struct uuconf_cmdtab *qcmds,
137: struct uuconf_proto_param *pas));
138: static boolean fsend_uucp_cmd P((struct sconnection *qconn,
139: const char *z));
140: static char *zget_uucp_cmd P((struct sconnection *qconn,
141: boolean frequired));
142: static char *zget_typed_line P((struct sconnection *qconn));
143:
144: /* Long getopt options. */
145: static const struct option asLongopts[] = { { NULL, 0, NULL, 0 } };
146:
147: int
148: main (argc, argv)
149: int argc;
150: char **argv;
151: {
152: /* -c: Whether to warn if a call is attempted at a bad time. */
153: boolean ftimewarn = TRUE;
154: /* -D: don't detach from controlling terminal. */
155: boolean fdetach = TRUE;
156: /* -e: Whether to do an endless loop of accepting calls. */
157: boolean fendless = FALSE;
158: /* -f: Whether to force a call despite status of previous call. */
159: boolean fforce = FALSE;
160: /* -I file: configuration file name. */
161: const char *zconfig = NULL;
162: /* -l: Whether to give a single login prompt. */
163: boolean flogin = FALSE;
164: /* -P port: port to use; in master mode, call out on this port. In
165: slave mode, accept logins on this port. If port not specified,
166: then in master mode figure it out for each system, and in slave
167: mode use stdin and stdout. */
168: const char *zport = NULL;
169: /* -q: Whether to start uuxqt when done. */
170: boolean fuuxqt = TRUE;
171: /* -r1: Whether we are the master. */
172: boolean fmaster = FALSE;
173: /* -s,-S system: system to call. */
174: const char *zsystem = NULL;
175: /* -w: Whether to wait for a call after doing one. */
176: boolean fwait = FALSE;
177: int iopt;
178: struct uuconf_port *qport;
179: struct uuconf_port sport;
180: boolean fret = TRUE;
181: pointer puuconf;
182: int iuuconf;
183: #if DEBUG > 1
184: int iholddebug;
185: #endif
186:
187: while ((iopt = getopt_long (argc, argv,
188: "cDefI:lp:qr:s:S:u:x:X:w",
189: asLongopts, (int *) NULL)) != EOF)
190: {
191: switch (iopt)
192: {
193: case 'c':
194: /* Don't warn if a call is attempted at a bad time. */
195: ftimewarn = FALSE;
196: break;
197:
198: case 'D':
199: /* Don't detach from controlling terminal. */
200: fdetach = FALSE;
201: break;
202:
203: case 'e':
204: /* Do an endless loop of accepting calls. */
205: fendless = TRUE;
206: break;
207:
208: case 'f':
209: /* Force a call even if it hasn't been long enough since the last
210: failed call. */
211: fforce = TRUE;
212: break;
213:
214: case 'I':
215: /* Set configuration file name (default is in sysdep.h). */
216: if (fsysdep_other_config (optarg))
217: zconfig = optarg;
218: break;
219:
220: case 'l':
221: /* Prompt for login name and password. */
222: flogin = TRUE;
223: break;
224:
225: case 'p':
226: /* Port to use */
227: zport = optarg;
228: break;
229:
230: case 'q':
231: /* Don't start uuxqt. */
232: fuuxqt = FALSE;
233: break;
234:
235: case 'r':
236: /* Set mode: -r1 for master, -r0 for slave (default) */
237: if (strcmp (optarg, "1") == 0)
238: fmaster = TRUE;
239: else if (strcmp (optarg, "0") == 0)
240: fmaster = FALSE;
241: else
242: uusage ();
243: break;
244:
245: case 's':
246: /* Set system name */
247: zsystem = optarg;
248: fmaster = TRUE;
249: break;
250:
251: case 'S':
252: /* Set system name and force call like -f */
253: zsystem = optarg;
254: fforce = TRUE;
255: fmaster = TRUE;
256: break;
257:
258: case 'u':
259: /* Some versions of uucpd invoke uucico with a -u argument
260: specifying the login name. I'm told it is safe to ignore
261: this value, although perhaps we should use it rather than
262: zsysdep_login_name (). */
263: break;
264:
265: case 'x':
266: case 'X':
267: #if DEBUG > 1
268: /* Set debugging level */
269: iDebug |= idebug_parse (optarg);
270: #endif
271: break;
272:
273: case 'w':
274: /* Call out and then wait for a call in */
275: fwait = TRUE;
276: break;
277:
278: case 0:
279: /* Long option found, and flag value set. */
280: break;
281:
282: default:
283: uusage ();
284: break;
285: }
286: }
287:
288: if (optind != argc)
289: uusage ();
290:
291: if (fwait && zport == NULL)
292: {
293: ulog (LOG_ERROR, "-w requires -e");
294: uusage ();
295: }
296:
297: iuuconf = uuconf_init (&puuconf, (const char *) NULL, zconfig);
298: if (iuuconf != UUCONF_SUCCESS)
299: ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
300: pUuconf = puuconf;
301:
302: #if DEBUG > 1
303: {
304: const char *zdebug;
305:
306: iuuconf = uuconf_debuglevel (puuconf, &zdebug);
307: if (iuuconf != UUCONF_SUCCESS)
308: ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
309: if (zdebug != NULL)
310: iDebug |= idebug_parse (zdebug);
311: }
312: #endif
313:
314: /* If a port was named, get its information. */
315: if (zport == NULL)
316: qport = NULL;
317: else
318: {
319: iuuconf = uuconf_find_port (puuconf, zport, (long) 0, (long) 0,
320: (int (*) P((struct uuconf_port *,
321: pointer))) NULL,
322: (pointer) NULL, &sport);
323: if (iuuconf == UUCONF_NOT_FOUND)
324: ulog (LOG_FATAL, "%s: Port not found", zport);
325: else if (iuuconf != UUCONF_SUCCESS)
326: ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
327: qport = &sport;
328: }
329:
330: #ifdef SIGINT
331: usysdep_signal (SIGINT);
332: #endif
333: #ifdef SIGHUP
334: usysdep_signal (SIGHUP);
335: #endif
336: #ifdef SIGQUIT
337: usysdep_signal (SIGQUIT);
338: #endif
339: #ifdef SIGTERM
340: usysdep_signal (SIGTERM);
341: #endif
342: #ifdef SIGPIPE
343: usysdep_signal (SIGPIPE);
344: #endif
345:
346: usysdep_initialize (puuconf, INIT_SUID);
347:
348: ulog_to_file (puuconf, TRUE);
349: ulog_fatal_fn (uabort);
350:
351: if (fmaster)
352: {
353: if (zsystem != NULL)
354: {
355: /* A system was named. Call it. */
356: iuuconf = uuconf_system_info (puuconf, zsystem,
357: &sLocked_system);
358: if (iuuconf == UUCONF_NOT_FOUND)
359: ulog (LOG_FATAL, "%s: System not found", zsystem);
360: else if (iuuconf != UUCONF_SUCCESS)
361: ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
362:
363: /* Detach from the controlling terminal for the call. This
364: probably makes sense only on Unix. We want the modem
365: line to become the controlling terminal. */
366: if (fdetach &&
367: (qport == NULL
368: || qport->uuconf_ttype != UUCONF_PORTTYPE_STDIN))
369: usysdep_detach ();
370:
371: ulog_system (sLocked_system.uuconf_zname);
372:
373: #if DEBUG > 1
374: iholddebug = iDebug;
375: if (sLocked_system.uuconf_zdebug != NULL)
376: iDebug |= idebug_parse (sLocked_system.uuconf_zdebug);
377: #endif
378:
379: if (! fsysdep_lock_system (&sLocked_system))
380: {
381: ulog (LOG_ERROR, "System already locked");
382: fret = FALSE;
383: }
384: else
385: {
386: fLocked_system = TRUE;
387: fret = fcall (puuconf, &sLocked_system, qport, FALSE,
388: fforce, fdetach, ftimewarn);
389: if (fLocked_system)
390: {
391: (void) fsysdep_unlock_system (&sLocked_system);
392: fLocked_system = FALSE;
393: }
394: }
395: #if DEBUG > 1
396: iDebug = iholddebug;
397: #endif
398: ulog_system ((const char *) NULL);
399: (void) uuconf_system_free (puuconf, &sLocked_system);
400: }
401: else
402: {
403: char **pznames, **pz;
404: int c, i;
405: boolean fdidone;
406:
407: /* Call all systems which have work to do. */
408: fret = TRUE;
409: fdidone = FALSE;
410:
411: iuuconf = uuconf_system_names (puuconf, &pznames, 0);
412: if (iuuconf != UUCONF_SUCCESS)
413: ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
414:
415: /* Randomize the order in which we call the systems. */
416: c = 0;
417: for (pz = pznames; *pz != NULL; pz++)
418: c++;
419:
420: srand ((unsigned int) ixsysdep_time ((long *) NULL));
421: for (i = c - 1; i > 0; i--)
422: {
423: int iuse;
424: char *zhold;
425:
426: iuse = rand () % (i + 1);
427: zhold = pznames[i];
428: pznames[i] = pznames[iuse];
429: pznames[iuse] = zhold;
430: }
431:
432: for (pz = pznames; *pz != NULL && ! FGOT_SIGNAL (); pz++)
433: {
434: iuuconf = uuconf_system_info (puuconf, *pz,
435: &sLocked_system);
436: if (iuuconf != UUCONF_SUCCESS)
437: {
438: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
439: xfree ((pointer) *pz);
440: continue;
441: }
442:
443: if (fsysdep_has_work (&sLocked_system))
444: {
445: fdidone = TRUE;
446:
447: /* Detach from the controlling terminal. On Unix
448: this means that we will wind up forking a new
449: process for each system we call. */
450: if (fdetach
451: && (qport == NULL
452: || qport->uuconf_ttype != UUCONF_PORTTYPE_STDIN))
453: usysdep_detach ();
454:
455: ulog_system (sLocked_system.uuconf_zname);
456:
457: #if DEBUG > 1
458: iholddebug = iDebug;
459: if (sLocked_system.uuconf_zdebug != NULL)
460: iDebug |= idebug_parse (sLocked_system.uuconf_zdebug);
461: #endif
462:
463: if (! fsysdep_lock_system (&sLocked_system))
464: {
465: ulog (LOG_ERROR, "System already locked");
466: fret = FALSE;
467: }
468: else
469: {
470: fLocked_system = TRUE;
471: if (! fcall (puuconf, &sLocked_system, qport, TRUE,
472: fforce, fdetach, ftimewarn))
473: fret = FALSE;
474:
475: /* Now ignore any SIGHUP that we got. */
476: afSignal[INDEXSIG_SIGHUP] = FALSE;
477:
478: if (fLocked_system)
479: {
480: (void) fsysdep_unlock_system (&sLocked_system);
481: fLocked_system = FALSE;
482: }
483: }
484: #if DEBUG > 1
485: iDebug = iholddebug;
486: #endif
487: ulog_system ((const char *) NULL);
488: }
489:
490: (void) uuconf_system_free (puuconf, &sLocked_system);
491: xfree ((pointer) *pz);
492: }
493:
494: xfree ((pointer) pznames);
495:
496: if (! fdidone)
497: ulog (LOG_NORMAL, "No work");
498: }
499:
500: /* If requested, wait for calls after dialing out. */
501: if (fwait)
502: {
503: fendless = TRUE;
504: fmaster = FALSE;
505: }
506: }
507:
508: if (! fmaster)
509: {
510: struct sconnection sconn;
511: boolean flocked;
512:
513: /* If a port was specified by name, we go into endless loop
514: mode. In this mode, we wait for calls and prompt them with
515: "login:" and "Password:", so that they think we are a regular
516: UNIX system. If we aren't in endless loop mode, we have been
517: called by some other system. If flogin is TRUE, we prompt
518: with "login:" and "Password:" a single time. */
519:
520: fret = TRUE;
521: zsystem = NULL;
522:
523: if (! fconn_init (qport, &sconn))
524: fret = FALSE;
525:
526: if (qport != NULL)
527: {
528: /* We are not using standard input. Detach from the
529: controlling terminal, so that the port we are about to
530: use becomes our controlling terminal. */
531: if (fdetach
532: && qport->uuconf_ttype != UUCONF_PORTTYPE_STDIN)
533: usysdep_detach ();
534:
535: /* If a port was given, we loop forever. */
536: fendless = TRUE;
537: }
538:
539: if (fconn_lock (&sconn, TRUE))
540: flocked = TRUE;
541: else
542: {
543: flocked = FALSE;
544: ulog (LOG_ERROR, "%s: Port already locked",
545: qport->uuconf_zname);
546: fret = FALSE;
547: }
548:
549: if (fret)
550: {
551: if (! fconn_open (&sconn, (long) 0, (long) 0, TRUE))
552: fret = FALSE;
553: qConn = &sconn;
554: }
555:
556: if (fret)
557: {
558: if (fendless)
559: {
560: while (! FGOT_SIGNAL ()
561: && flogin_prompt (puuconf, &sconn))
562: {
563: /* Now ignore any SIGHUP that we got. */
564: afSignal[INDEXSIG_SIGHUP] = FALSE;
565:
566: if (fLocked_system)
567: {
568: (void) fsysdep_unlock_system (&sLocked_system);
569: fLocked_system = FALSE;
570: }
571: if (! fconn_reset (&sconn))
572: break;
573: }
574: fret = FALSE;
575: }
576: else
577: {
578: if (flogin)
579: fret = flogin_prompt (puuconf, &sconn);
580: else
581: {
582: #if DEBUG > 1
583: iholddebug = iDebug;
584: #endif
585: fret = faccept_call (puuconf, zsysdep_login_name (),
586: &sconn, &zsystem);
587: #if DEBUG > 1
588: iDebug = iholddebug;
589: #endif
590: }
591: }
592: }
593:
594: if (qConn != NULL)
595: {
596: if (! fconn_close (&sconn, puuconf, (struct uuconf_dialer *) NULL,
597: fret))
598: fret = FALSE;
599: qConn = NULL;
600: }
601:
602: if (flocked)
603: (void) fconn_unlock (&sconn);
604:
605: if (fLocked_system)
606: {
607: (void) fsysdep_unlock_system (&sLocked_system);
608: fLocked_system = FALSE;
609: }
610:
611: uconn_free (&sconn);
612: }
613:
614: ulog_close ();
615: ustats_close ();
616:
617: /* If we got a SIGTERM, perhaps because the system is going down,
618: don't run uuxqt. We go ahead and run it for any other signal,
619: since I think they indicate more temporary conditions. */
620: if (afSignal[INDEXSIG_SIGTERM])
621: fuuxqt = FALSE;
622:
623: if (fuuxqt)
624: {
625: /* Detach from the controlling terminal before starting up uuxqt,
626: so that it runs as a true daemon. */
627: if (fdetach)
628: usysdep_detach ();
629: if (zsystem == NULL)
630: {
631: if (! fsysdep_run ("uuxqt", (const char *) NULL,
632: (const char *) NULL))
633: fret = FALSE;
634: }
635: else
636: {
637: if (! fsysdep_run ("uuxqt", "-s", zsystem))
638: fret = FALSE;
639: }
640: }
641:
642: usysdep_exit (fret);
643:
644: /* Avoid complaints about not returning. */
645: return 0;
646: }
647:
648: /* Print out a usage message. */
649:
650: static void
651: uusage ()
652: {
653: fprintf (stderr,
654: "Taylor UUCP version %s, copyright (C) 1991, 1992 Ian Lance Taylor\n",
655: VERSION);
656: fprintf (stderr,
657: "Usage: uucico [options]\n");
658: fprintf (stderr,
659: " -s,-S system: Call system (-S implies -f)\n");
660: fprintf (stderr,
661: " -f: Force call despite system status\n");
662: fprintf (stderr,
663: " -r state: 1 for master, 0 for slave (default)\n");
664: fprintf (stderr,
665: " -p port: Specify port (implies -e)\n");
666: fprintf (stderr,
667: " -l: prompt for login name and password\n");
668: fprintf (stderr,
669: " -e: Endless loop of login prompts and daemon execution\n");
670: fprintf (stderr,
671: " -w: After calling out, wait for incoming calls\n");
672: fprintf (stderr,
673: " -q: Don't start uuxqt when done\n");
674: fprintf (stderr,
675: " -x,-X debug: Set debugging level\n");
676: #if HAVE_TAYLOR_CONFIG
677: fprintf (stderr,
678: " -I file: Set configuration file to use\n");
679: #endif /* HAVE_TAYLOR_CONFIG */
680:
681: exit (EXIT_FAILURE);
682: }
683:
684: /* This function is called when a LOG_FATAL error occurs. */
685:
686: static void
687: uabort ()
688: {
689: if (fLocked_system)
690: ufailed (&sDaemon);
691:
692: ulog_user ((const char *) NULL);
693:
694: if (qConn != NULL)
695: {
696: (void) fconn_close (qConn, pUuconf, (struct uuconf_dialer *) NULL,
697: FALSE);
698: (void) fconn_unlock (qConn);
699: uconn_free (qConn);
700: }
701:
702: if (fLocked_system)
703: {
704: (void) fsysdep_unlock_system (&sLocked_system);
705: fLocked_system = FALSE;
706: }
707:
708: ulog_system ((const char *) NULL);
709:
710: ulog_close ();
711: ustats_close ();
712:
713: usysdep_exit (FALSE);
714: }
715:
716: /* Call another system, trying all the possible sets of calling
717: instructions. The qsys argument is the system to call. The qport
718: argument is the port to use, and may be NULL. If the fifwork
719: argument is TRUE, the call is only placed if there is work to be
720: done. If the fforce argument is TRUE, a call is forced even if not
721: enough time has passed since the last failed call. If the
722: ftimewarn argument is TRUE (the normal case), then a warning is
723: given if calls are not permitted at this time. */
724:
725: static boolean
726: fcall (puuconf, qorigsys, qport, fifwork, fforce, fdetach, ftimewarn)
727: pointer puuconf;
728: const struct uuconf_system *qorigsys;
729: struct uuconf_port *qport;
730: boolean fifwork;
731: boolean fforce;
732: boolean fdetach;
733: boolean ftimewarn;
734: {
735: struct sstatus sstat;
736: long inow;
737: boolean fbadtime, fnevertime;
738: const struct uuconf_system *qsys;
739:
740: if (! fsysdep_get_status (qorigsys, &sstat, (boolean *) NULL))
741: return FALSE;
742:
743: /* Make sure it's been long enough since the last failed call, and
744: that we haven't exceeded the maximum number of retries. Even if
745: we are over the limit on retries, we permit a call to be made if
746: 24 hours have passed. This 24 hour limit is still controlled by
747: the retry time. */
748: inow = ixsysdep_time ((long *) NULL);
749: if (! fforce)
750: {
751: if (qorigsys->uuconf_cmax_retries > 0
752: && sstat.cretries >= qorigsys->uuconf_cmax_retries
753: && sstat.ilast + 24 * 60 * 60 < inow)
754: {
755: ulog (LOG_ERROR, "Too many retries");
756: return FALSE;
757: }
758:
759: if (sstat.ttype == STATUS_COMPLETE
760: ? sstat.ilast + qorigsys->uuconf_csuccess_wait > inow
761: : sstat.ilast + sstat.cwait > inow)
762: {
763: ulog (LOG_NORMAL, "Retry time not reached");
764: return FALSE;
765: }
766: }
767:
768: sDaemon.puuconf = puuconf;
769: sDaemon.qsys = NULL;
770: sDaemon.zlocalname = NULL;
771: sDaemon.qconn = NULL;
772: sDaemon.qproto = NULL;
773: sDaemon.clocal_size = -1;
774: sDaemon.cremote_size = -1;
775: sDaemon.cmax_ever = -2;
776: sDaemon.cmax_receive = -1;
777: sDaemon.ifeatures = 0;
778: sDaemon.frequest_hangup = FALSE;
779: sDaemon.fhangup_requested = FALSE;
780: sDaemon.fhangup = FALSE;
781: sDaemon.fmaster = TRUE;
782: sDaemon.fcaller = TRUE;
783: sDaemon.ireliable = 0;
784: sDaemon.bgrade = '\0';
785:
786: fbadtime = TRUE;
787: fnevertime = TRUE;
788:
789: for (qsys = qorigsys; qsys != NULL; qsys = qsys->uuconf_qalternate)
790: {
791: int cretry;
792: boolean fany, fret, fcalled;
793:
794: if (FGOT_SIGNAL ())
795: return FALSE;
796:
797: if (! qsys->uuconf_fcall || qsys->uuconf_qtimegrade == NULL)
798: continue;
799:
800: fnevertime = FALSE;
801:
802: /* Make sure this is a legal time to call. */
803: if (! ftimespan_match (qsys->uuconf_qtimegrade, (long *) NULL,
804: &cretry))
805: continue;
806:
807: sDaemon.qsys = qsys;
808:
809: /* Queue up any work there is to do. */
810: if (! fqueue (&sDaemon, &fany))
811: return FALSE;
812:
813: /* If we are only supposed to call if there is work, and there
814: isn't any work, check the next alternates. We can't give up
815: at this point because there might be some other alternates
816: with fewer restrictions on grade or file transfer size. */
817: if (fifwork && ! fany)
818: {
819: uclear_queue (&sDaemon);
820: continue;
821: }
822:
823: fbadtime = FALSE;
824:
825: fret = fconn_call (&sDaemon, qport, &sstat, cretry, &fcalled);
826:
827: uclear_queue (&sDaemon);
828:
829: if (fret)
830: return TRUE;
831: if (fcalled)
832: return FALSE;
833:
834: /* Now we have to dump that port so that we can aquire a new
835: one. On Unix this means that we will fork and get a new
836: process ID, so we must unlock and relock the system. */
837: if (fdetach)
838: {
839: (void) fsysdep_unlock_system (&sLocked_system);
840: fLocked_system = FALSE;
841: usysdep_detach ();
842: if (! fsysdep_lock_system (&sLocked_system))
843: return FALSE;
844: fLocked_system = TRUE;
845: }
846: }
847:
848: if (fbadtime && ftimewarn)
849: {
850: ulog (LOG_NORMAL, "Wrong time to call");
851:
852: /* Update the status, unless the system can never be called. If
853: the system can never be called, there is little point to
854: putting in a ``wrong time to call'' message. We don't change
855: the number of retries, although we do set the wait until the
856: next retry to 0. */
857: if (! fnevertime)
858: {
859: sstat.ttype = STATUS_WRONG_TIME;
860: sstat.ilast = inow;
861: sstat.cwait = 0;
862: (void) fsysdep_set_status (qorigsys, &sstat);
863: }
864: }
865:
866: return FALSE;
867: }
868:
869: /* Find a port to use when calling a system, open a connection, and
870: dial the system. The actual call is done in fdo_call. This
871: routine is responsible for opening and closing the connection. */
872:
873: static boolean
874: fconn_call (qdaemon, qport, qstat, cretry, pfcalled)
875: struct sdaemon *qdaemon;
876: struct uuconf_port *qport;
877: struct sstatus *qstat;
878: int cretry;
879: boolean *pfcalled;
880: {
881: pointer puuconf;
882: const struct uuconf_system *qsys;
883: struct uuconf_port sport;
884: struct sconnection sconn;
885: enum tstatus_type terr;
886: boolean fret;
887:
888: puuconf = qdaemon->puuconf;
889: qsys = qdaemon->qsys;
890:
891: *pfcalled = FALSE;
892:
893: /* Ignore any SIGHUP signal we may have received up to this point.
894: This is needed on Unix because we may have gotten one from the
895: shell before we detached from the controlling terminal. */
896: afSignal[INDEXSIG_SIGHUP] = FALSE;
897:
898: /* If no port was specified on the command line, use any port
899: defined for the system. To select the system port: 1) see if
900: port information was specified directly; 2) see if a port was
901: named; 3) get an available port given the baud rate. We don't
902: change the system status if a port is unavailable; i.e. we don't
903: force the system to wait for the retry time. */
904: if (qport == NULL)
905: qport = qsys->uuconf_qport;
906: if (qport != NULL)
907: {
908: if (! fconn_init (qport, &sconn))
909: return FALSE;
910: if (! fconn_lock (&sconn, FALSE))
911: {
912: ulog (LOG_ERROR, "%s: Port already locked",
913: qport->uuconf_zname);
914: return FALSE;
915: }
916: }
917: else
918: {
919: struct spass s;
920: int iuuconf;
921:
922: s.fmatched = FALSE;
923: s.flocked = FALSE;
924: s.qconn = &sconn;
925: iuuconf = uuconf_find_port (puuconf, qsys->uuconf_zport,
926: qsys->uuconf_ibaud,
927: qsys->uuconf_ihighbaud,
928: iuport_lock, (pointer) &s,
929: &sport);
930: if (iuuconf == UUCONF_NOT_FOUND)
931: {
932: if (s.fmatched)
933: ulog (LOG_ERROR, "All matching ports in use");
934: else
935: ulog (LOG_ERROR, "No matching ports");
936: return FALSE;
937: }
938: else if (iuuconf != UUCONF_SUCCESS)
939: {
940: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
941: if (s.flocked)
942: {
943: (void) fconn_unlock (&sconn);
944: uconn_free (&sconn);
945: }
946: return FALSE;
947: }
948: }
949:
950: if (! fconn_open (&sconn, qsys->uuconf_ibaud, qsys->uuconf_ihighbaud,
951: FALSE))
952: {
953: terr = STATUS_PORT_FAILED;
954: fret = FALSE;
955: }
956: else
957: {
958: struct uuconf_dialer *qdialer;
959: struct uuconf_dialer sdialer;
960: enum tdialerfound tdialer;
961:
962: if (qsys->uuconf_zalternate == NULL)
963: ulog (LOG_NORMAL, "Calling system %s (port %s)", qsys->uuconf_zname,
964: zLdevice == NULL ? (char *) "unknown" : zLdevice);
965: else
966: ulog (LOG_NORMAL, "Calling system %s (alternate %s, port %s)",
967: qsys->uuconf_zname, qsys->uuconf_zalternate,
968: zLdevice == NULL ? (char *) "unknown" : zLdevice);
969:
970: qdialer = NULL;
971:
972: if (! fconn_dial (&sconn, puuconf, qsys, qsys->uuconf_zphone,
973: &sdialer, &tdialer))
974: {
975: terr = STATUS_DIAL_FAILED;
976: fret = FALSE;
977: }
978: else
979: {
980: qdaemon->qconn = &sconn;
981: if (tdialer == DIALERFOUND_FALSE)
982: qdialer = NULL;
983: else
984: qdialer = &sdialer;
985: fret = fdo_call (qdaemon, qstat, qdialer, pfcalled, &terr);
986: }
987:
988: (void) fconn_close (&sconn, puuconf, qdialer, fret);
989:
990: if (tdialer == DIALERFOUND_FREE)
991: (void) uuconf_dialer_free (puuconf, &sdialer);
992: }
993:
994: if (! fret)
995: {
996: DEBUG_MESSAGE2 (DEBUG_HANDSHAKE, "Call failed: %d (%s)",
997: (int) terr, azStatus[(int) terr]);
998: qstat->ttype = terr;
999: qstat->cretries++;
1000: qstat->ilast = ixsysdep_time ((long *) NULL);
1001: if (cretry == 0)
1002: qstat->cwait = CRETRY_WAIT (qstat->cretries);
1003: else
1004: qstat->cwait = cretry * 60;
1005: (void) fsysdep_set_status (qsys, qstat);
1006: }
1007:
1008: (void) fconn_unlock (&sconn);
1009: uconn_free (&sconn);
1010:
1011: if (qport == NULL)
1012: (void) uuconf_port_free (puuconf, &sport);
1013:
1014: return fret;
1015: }
1016:
1017: /* Do the actual work of calling another system. The qsys argument is
1018: the system to call, the qconn argument is the connection to use,
1019: the qstat argument holds the current status of the ssystem, and the
1020: qdialer argument holds the dialer being used (it may be NULL). If
1021: we log in successfully, set *pfcalled to TRUE; this is used to
1022: distinguish a failed dial from a failure during the call. If an
1023: error occurs *pterr is set to the status type to record. */
1024:
1025: static boolean
1026: fdo_call (qdaemon, qstat, qdialer, pfcalled, pterr)
1027: struct sdaemon *qdaemon;
1028: struct sstatus *qstat;
1029: const struct uuconf_dialer *qdialer;
1030: boolean *pfcalled;
1031: enum tstatus_type *pterr;
1032: {
1033: pointer puuconf;
1034: const struct uuconf_system *qsys;
1035: struct sconnection *qconn;
1036: const char *zport;
1037: int iuuconf;
1038: char *zstr;
1039: long istart_time;
1040: char *zlog;
1041:
1042: puuconf = qdaemon->puuconf;
1043: qsys = qdaemon->qsys;
1044: qconn = qdaemon->qconn;
1045:
1046: *pterr = STATUS_LOGIN_FAILED;
1047:
1048: if (qconn->qport == NULL)
1049: zport = "unknown";
1050: else
1051: zport = qconn->qport->uuconf_zname;
1052: if (! fchat (qconn, puuconf, &qsys->uuconf_schat, qsys,
1053: (const struct uuconf_dialer *) NULL,
1054: (const char *) NULL, FALSE, zport,
1055: iconn_baud (qconn)))
1056: return FALSE;
1057:
1058: *pfcalled = TRUE;
1059: istart_time = ixsysdep_time ((long *) NULL);
1060:
1061: *pterr = STATUS_HANDSHAKE_FAILED;
1062:
1063: /* We should now see "Shere" from the other system. Newer systems
1064: send "Shere=foo" where foo is the remote name. */
1065: zstr = zget_uucp_cmd (qconn, TRUE);
1066: if (zstr == NULL)
1067: return FALSE;
1068:
1069: if (strncmp (zstr, "Shere", 5) != 0)
1070: {
1071: ulog (LOG_ERROR, "Bad initialization string");
1072: ubuffree (zstr);
1073: return FALSE;
1074: }
1075:
1076: ulog (LOG_NORMAL, "Login successful");
1077:
1078: qstat->ttype = STATUS_TALKING;
1079: qstat->ilast = ixsysdep_time ((long *) NULL);
1080: qstat->cretries = 0;
1081: qstat->cwait = 0;
1082: if (! fsysdep_set_status (qsys, qstat))
1083: return FALSE;
1084:
1085: if (zstr[5] == '=')
1086: {
1087: const char *zheresys;
1088: size_t clen;
1089: int icmp;
1090:
1091: /* Some UUCP packages only provide seven characters in the Shere
1092: machine name. Others only provide fourteen. */
1093: zheresys = zstr + 6;
1094: clen = strlen (zheresys);
1095: if (clen == 7 || clen == 14)
1096: icmp = strncmp (zheresys, qsys->uuconf_zname, clen);
1097: else
1098: icmp = strcmp (zheresys, qsys->uuconf_zname);
1099: if (icmp != 0)
1100: {
1101: if (qsys->uuconf_pzalias != NULL)
1102: {
1103: char **pz;
1104:
1105: for (pz = qsys->uuconf_pzalias; *pz != NULL; pz++)
1106: {
1107: if (clen == 7 || clen == 14)
1108: icmp = strncmp (zheresys, *pz, clen);
1109: else
1110: icmp = strcmp (zheresys, *pz);
1111: if (icmp == 0)
1112: break;
1113: }
1114: }
1115: if (icmp != 0)
1116: {
1117: ulog (LOG_ERROR, "Called wrong system (%s)", zheresys);
1118: ubuffree (zstr);
1119: return FALSE;
1120: }
1121: }
1122: }
1123: #if DEBUG > 1
1124: else if (zstr[5] != '\0')
1125: DEBUG_MESSAGE1 (DEBUG_HANDSHAKE,
1126: "fdo_call: Strange Shere: %s", zstr);
1127: #endif
1128:
1129: ubuffree (zstr);
1130:
1131: /* We now send "S" name switches, where name is our UUCP name. If
1132: we are using sequence numbers with this system, we send a -Q
1133: argument with the sequence number. If the call-timegrade command
1134: was used, we send a -p argument and a -vgrade= argument with the
1135: grade to send us (we send both argument to make it more likely
1136: that one is recognized). We always send a -N (for new) switch
1137: indicating what new features we support. */
1138: {
1139: long ival;
1140: char bgrade;
1141: char *zsend;
1142: boolean fret;
1143:
1144: /* Determine the grade we should request of the other system. A
1145: '\0' means that no restrictions have been made. */
1146: if (! ftimespan_match (qsys->uuconf_qcalltimegrade, &ival,
1147: (int *) NULL))
1148: bgrade = '\0';
1149: else
1150: bgrade = (char) ival;
1151:
1152: /* Determine the name we will call ourselves. */
1153: if (qsys->uuconf_zlocalname != NULL)
1154: qdaemon->zlocalname = qsys->uuconf_zlocalname;
1155: else
1156: {
1157: iuuconf = uuconf_localname (puuconf, &qdaemon->zlocalname);
1158: if (iuuconf == UUCONF_NOT_FOUND)
1159: {
1160: qdaemon->zlocalname = zsysdep_localname ();
1161: if (qdaemon->zlocalname == NULL)
1162: return FALSE;
1163: }
1164: else if (iuuconf != UUCONF_SUCCESS)
1165: {
1166: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
1167: return FALSE;
1168: }
1169: }
1170:
1171: zsend = zbufalc (strlen (qdaemon->zlocalname) + 70);
1172: if (! qsys->uuconf_fsequence)
1173: {
1174: if (bgrade == '\0')
1175: sprintf (zsend, "S%s -R -N0%o", qdaemon->zlocalname,
1176: (unsigned int) (FEATURE_SIZES
1177: | FEATURE_EXEC
1178: | FEATURE_RESTART));
1179: else
1180: sprintf (zsend, "S%s -p%c -vgrade=%c -R -N0%o",
1181: qdaemon->zlocalname, bgrade, bgrade,
1182: (unsigned int) (FEATURE_SIZES
1183: | FEATURE_EXEC
1184: | FEATURE_RESTART));
1185: }
1186: else
1187: {
1188: long iseq;
1189:
1190: iseq = ixsysdep_get_sequence (qsys);
1191: if (iseq < 0)
1192: return FALSE;
1193: if (bgrade == '\0')
1194: sprintf (zsend, "S%s -Q%ld -R -N0%o", qdaemon->zlocalname, iseq,
1195: (unsigned int) (FEATURE_SIZES
1196: | FEATURE_EXEC
1197: | FEATURE_RESTART));
1198: else
1199: sprintf (zsend, "S%s -Q%ld -p%c -vgrade=%c -R -N0%o",
1200: qdaemon->zlocalname, iseq, bgrade, bgrade,
1201: (unsigned int) (FEATURE_SIZES
1202: | FEATURE_EXEC
1203: | FEATURE_RESTART));
1204: }
1205:
1206: fret = fsend_uucp_cmd (qconn, zsend);
1207: ubuffree (zsend);
1208: if (! fret)
1209: return FALSE;
1210: }
1211:
1212: /* Now we should see ROK or Rreason where reason gives a cryptic
1213: reason for failure. If we are talking to a counterpart, we will
1214: get back ROKN, possibly with a feature bitfield attached. */
1215: zstr = zget_uucp_cmd (qconn, TRUE);
1216: if (zstr == NULL)
1217: return FALSE;
1218:
1219: if (zstr[0] != 'R')
1220: {
1221: ulog (LOG_ERROR, "Bad reponse to handshake string (%s)",
1222: zstr);
1223: ubuffree (zstr);
1224: return FALSE;
1225: }
1226:
1227: if (strncmp (zstr + 1, "OKN", sizeof "OKN" - 1) == 0)
1228: {
1229: if (zstr[sizeof "ROKN" - 1] == '\0')
1230: qdaemon->ifeatures |= FEATURE_SIZES | FEATURE_V103;
1231: else
1232: qdaemon->ifeatures |= (int) strtol (zstr + sizeof "ROKN" - 1,
1233: (char **) NULL, 0);
1234: }
1235: else if (strncmp (zstr + 1, "OK", sizeof "OK" - 1) == 0)
1236: {
1237: if (zstr[sizeof "ROK" - 1] != '\0')
1238: {
1239: char *zopt;
1240:
1241: /* SVR4 UUCP returns options following the ROK string. */
1242: zopt = zstr + sizeof "ROK" - 1;
1243: while (*zopt != '\0')
1244: {
1245: char b;
1246: long c;
1247: char *zend;
1248:
1249: b = *zopt++;
1250: if (isspace (b) || b != '-')
1251: continue;
1252: switch (*zopt)
1253: {
1254: case 'R':
1255: qdaemon->ifeatures |= (FEATURE_RESTART
1256: | FEATURE_SVR4
1257: | FEATURE_SIZES);
1258: break;
1259: case 'U':
1260: c = strtol (zopt, &zend, 0);
1261: if (c > 0 && c <= LONG_MAX / (long) 512)
1262: qdaemon->cmax_receive = c * (long) 512;
1263: zopt = zend;
1264: break;
1265: }
1266: while (*zopt != '\0' && ! isspace (*zopt))
1267: ++zopt;
1268: }
1269: }
1270: }
1271: else if (strcmp (zstr + 1, "CB") == 0)
1272: {
1273: ulog (LOG_NORMAL, "Remote system will call back");
1274: qstat->ttype = STATUS_COMPLETE;
1275: (void) fsysdep_set_status (qsys, qstat);
1276: ubuffree (zstr);
1277: return TRUE;
1278: }
1279: else
1280: {
1281: ulog (LOG_ERROR, "Handshake failed (%s)", zstr + 1);
1282: ubuffree (zstr);
1283: return FALSE;
1284: }
1285:
1286: ubuffree (zstr);
1287:
1288: /* The slave should now send \020Pprotos\0 where protos is a list of
1289: supported protocols. Each protocol is a single character. */
1290: zstr = zget_uucp_cmd (qconn, TRUE);
1291: if (zstr == NULL)
1292: return FALSE;
1293:
1294: if (zstr[0] != 'P')
1295: {
1296: ulog (LOG_ERROR, "Bad protocol handshake (%s)", zstr);
1297: ubuffree (zstr);
1298: return FALSE;
1299: }
1300:
1301: /* Determine the reliability characteristics of the connection by
1302: combining information for the port and the dialer. If we have no
1303: information, default to a reliable eight-bit full-duplex
1304: connection. */
1305: if (qconn->qport != NULL
1306: && (qconn->qport->uuconf_ireliable & UUCONF_RELIABLE_SPECIFIED) != 0)
1307: qdaemon->ireliable = qconn->qport->uuconf_ireliable;
1308: if (qdialer != NULL
1309: && (qdialer->uuconf_ireliable & UUCONF_RELIABLE_SPECIFIED) != 0)
1310: {
1311: if (qdaemon->ireliable != 0)
1312: qdaemon->ireliable &= qdialer->uuconf_ireliable;
1313: else
1314: qdaemon->ireliable = qdialer->uuconf_ireliable;
1315: }
1316: if (qdaemon->ireliable == 0)
1317: qdaemon->ireliable = (UUCONF_RELIABLE_RELIABLE
1318: | UUCONF_RELIABLE_EIGHT
1319: | UUCONF_RELIABLE_FULLDUPLEX
1320: | UUCONF_RELIABLE_SPECIFIED);
1321:
1322: /* Now decide which protocol to use. The system and the port may
1323: have their own list of protocols. */
1324: {
1325: int i;
1326: char ab[5];
1327:
1328: i = CPROTOCOLS;
1329: if (qsys->uuconf_zprotocols != NULL
1330: || (qconn->qport != NULL
1331: && qconn->qport->uuconf_zprotocols != NULL))
1332: {
1333: const char *zproto;
1334:
1335: if (qsys->uuconf_zprotocols != NULL)
1336: zproto = qsys->uuconf_zprotocols;
1337: else
1338: zproto = qconn->qport->uuconf_zprotocols;
1339: for (; *zproto != '\0'; zproto++)
1340: {
1341: if (strchr (zstr + 1, *zproto) != NULL)
1342: {
1343: for (i = 0; i < CPROTOCOLS; i++)
1344: if (asProtocols[i].bname == *zproto)
1345: break;
1346: if (i < CPROTOCOLS)
1347: break;
1348: }
1349: }
1350: }
1351: else
1352: {
1353: /* If neither the system nor the port specified a list of
1354: protocols, we want only protocols that match the known
1355: reliability of the dialer and the port. */
1356: for (i = 0; i < CPROTOCOLS; i++)
1357: {
1358: int ipr;
1359:
1360: ipr = asProtocols[i].ireliable;
1361: if ((ipr & qdaemon->ireliable) != ipr)
1362: continue;
1363: if (strchr (zstr + 1, asProtocols[i].bname) != NULL)
1364: break;
1365: }
1366: }
1367:
1368: ubuffree (zstr);
1369:
1370: if (i >= CPROTOCOLS)
1371: {
1372: (void) fsend_uucp_cmd (qconn, "UN");
1373: ulog (LOG_ERROR, "No mutually supported protocols");
1374: return FALSE;
1375: }
1376:
1377: qdaemon->qproto = &asProtocols[i];
1378:
1379: sprintf (ab, "U%c", qdaemon->qproto->bname);
1380: if (! fsend_uucp_cmd (qconn, ab))
1381: return FALSE;
1382: }
1383:
1384: /* Run any protocol parameter commands. */
1385: if (qdaemon->qproto->qcmds != NULL)
1386: {
1387: if (qsys->uuconf_qproto_params != NULL)
1388: uapply_proto_params (puuconf, qdaemon->qproto->bname,
1389: qdaemon->qproto->qcmds,
1390: qsys->uuconf_qproto_params);
1391: if (qconn->qport != NULL
1392: && qconn->qport->uuconf_qproto_params != NULL)
1393: uapply_proto_params (puuconf, qdaemon->qproto->bname,
1394: qdaemon->qproto->qcmds,
1395: qconn->qport->uuconf_qproto_params);
1396: if (qdialer != NULL
1397: && qdialer->uuconf_qproto_params != NULL)
1398: uapply_proto_params (puuconf, qdaemon->qproto->bname,
1399: qdaemon->qproto->qcmds,
1400: qdialer->uuconf_qproto_params);
1401: }
1402:
1403: /* Turn on the selected protocol. */
1404: if (! (*qdaemon->qproto->pfstart) (qdaemon, &zlog))
1405: return FALSE;
1406: if (zlog == NULL)
1407: {
1408: zlog = zbufalc (sizeof "protocol ''" + 1);
1409: sprintf (zlog, "protocol '%c'", qdaemon->qproto->bname);
1410: }
1411: ulog (LOG_NORMAL, "Handshake successful (%s)", zlog);
1412: ubuffree (zlog);
1413:
1414: *pterr = STATUS_FAILED;
1415:
1416: {
1417: boolean fret;
1418: long iend_time;
1419:
1420: fret = floop (qdaemon);
1421:
1422: /* Now send the hangup message. As the caller, we send six O's
1423: and expect to receive seven O's. We send the six O's twice to
1424: help the other side. We don't worry about errors here. */
1425: if (fsend_uucp_cmd (qconn, "OOOOOO")
1426: && fsend_uucp_cmd (qconn, "OOOOOO"))
1427: {
1428: int i, fdone;
1429:
1430: /* We look for the remote hangup string to ensure that the
1431: modem has sent out our hangup string. This is only
1432: necessary because some versions of UUCP complain if they
1433: don't get the hangup string. The remote site should send 7
1434: O's, but some versions of UUCP only send 6. We look for
1435: the string several times because supposedly some
1436: implementations send some garbage after the last packet but
1437: before the hangup string. */
1438: for (i = 0; i < 25; i++)
1439: {
1440: zstr = zget_uucp_cmd (qconn, FALSE);
1441: if (zstr == NULL)
1442: break;
1443: fdone = strstr (zstr, "OOOOOO") != NULL;
1444: ubuffree (zstr);
1445: if (fdone)
1446: break;
1447: }
1448: }
1449:
1450: iend_time = ixsysdep_time ((long *) NULL);
1451:
1452: ulog (LOG_NORMAL, "Call complete (%ld seconds)",
1453: iend_time - istart_time);
1454:
1455: if (fret)
1456: {
1457: qstat->ttype = STATUS_COMPLETE;
1458: qstat->ilast = iend_time;
1459: (void) fsysdep_set_status (qsys, qstat);
1460: }
1461:
1462: return fret;
1463: }
1464: }
1465:
1466: /* This routine is called via uuconf_find_port when a matching port is
1467: found. It tries to lock the port. If it fails, it returns
1468: UUCONF_NOT_FOUND to force uuconf_find_port to continue searching
1469: for the next matching port. */
1470:
1471: static int
1472: iuport_lock (qport, pinfo)
1473: struct uuconf_port *qport;
1474: pointer pinfo;
1475: {
1476: struct spass *q = (struct spass *) pinfo;
1477:
1478: q->fmatched = TRUE;
1479:
1480: if (! fconn_init (qport, q->qconn))
1481: return UUCONF_NOT_FOUND;
1482: else if (! fconn_lock (q->qconn, FALSE))
1483: {
1484: uconn_free (q->qconn);
1485: return UUCONF_NOT_FOUND;
1486: }
1487: else
1488: {
1489: q->flocked = TRUE;
1490: return UUCONF_SUCCESS;
1491: }
1492: }
1493:
1494: /* Prompt for a login name and a password, and run as the slave. */
1495:
1496: static boolean
1497: flogin_prompt (puuconf, qconn)
1498: pointer puuconf;
1499: struct sconnection *qconn;
1500: {
1501: char *zuser, *zpass;
1502: boolean fret;
1503: int iuuconf;
1504:
1505: DEBUG_MESSAGE0 (DEBUG_HANDSHAKE, "flogin_prompt: Waiting for login");
1506:
1507: zuser = NULL;
1508: do
1509: {
1510: ubuffree (zuser);
1511: if (! fconn_write (qconn, "login: ", sizeof "login: " - 1))
1512: return FALSE;
1513: zuser = zget_typed_line (qconn);
1514: }
1515: while (zuser != NULL && *zuser == '\0');
1516:
1517: if (zuser == NULL)
1518: return TRUE;
1519:
1520: if (! fconn_write (qconn, "Password:", sizeof "Password:" - 1))
1521: {
1522: ubuffree (zuser);
1523: return FALSE;
1524: }
1525:
1526: zpass = zget_typed_line (qconn);
1527: if (zpass == NULL)
1528: {
1529: ubuffree (zuser);
1530: return TRUE;
1531: }
1532:
1533: fret = TRUE;
1534:
1535: iuuconf = uuconf_callin (puuconf, zuser, zpass);
1536: ubuffree (zpass);
1537: if (iuuconf == UUCONF_NOT_FOUND)
1538: ulog (LOG_ERROR, "Bad login");
1539: else if (iuuconf != UUCONF_SUCCESS)
1540: {
1541: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
1542: fret = FALSE;
1543: }
1544: else
1545: {
1546: #if DEBUG > 1
1547: int iholddebug;
1548: #endif
1549:
1550: /* We ignore the return value of faccept_call because we really
1551: don't care whether the call succeeded or not. We are going
1552: to reset the port anyhow. */
1553: #if DEBUG > 1
1554: iholddebug = iDebug;
1555: #endif
1556: (void) faccept_call (puuconf, zuser, qconn, (const char **) NULL);
1557: #if DEBUG > 1
1558: iDebug = iholddebug;
1559: #endif
1560: }
1561:
1562: ubuffree (zuser);
1563:
1564: return fret;
1565: }
1566:
1567: /* Accept a call from a remote system. If pqsys is not NULL, *pqsys
1568: will be set to the system that called in if known. */
1569:
1570: static boolean
1571: faccept_call (puuconf, zlogin, qconn, pzsystem)
1572: pointer puuconf;
1573: const char *zlogin;
1574: struct sconnection *qconn;
1575: const char **pzsystem;
1576: {
1577: long istart_time;
1578: const char *zport;
1579: struct uuconf_port *qport;
1580: struct uuconf_port sport;
1581: int iuuconf;
1582: struct uuconf_dialer *qdialer;
1583: struct uuconf_dialer sdialer;
1584: boolean ftcp_port;
1585: char *zsend, *zspace;
1586: boolean fret;
1587: char *zstr;
1588: struct uuconf_system ssys;
1589: const struct uuconf_system *qsys;
1590: const struct uuconf_system *qany;
1591: char *zloc;
1592: struct sstatus sstat;
1593: boolean fgotseq, fgotn;
1594: int i;
1595: char *zlog;
1596: char *zgrade;
1597:
1598: #ifdef MWCBBS
1599: char mwcbbs[40];
1600: char *mwcspace;
1601: char bbsuser[40];
1602: #endif /* MWCBBS */
1603:
1604: if (pzsystem != NULL)
1605: *pzsystem = NULL;
1606:
1607: ulog (LOG_NORMAL, "Incoming call (login %s port %s)", zlogin,
1608: zLdevice == NULL ? (char *) "unknown" : zLdevice);
1609:
1610: istart_time = ixsysdep_time ((long *) NULL);
1611:
1612: /* Figure out protocol parameters determined by the port. If no
1613: port was specified we're reading standard input, so try to get
1614: the port name and read information from the port file. We only
1615: use the port information to get protocol parameters; we don't
1616: want to start treating the port as though it were a modem, for
1617: example. */
1618: if (qconn->qport != NULL)
1619: {
1620: qport = qconn->qport;
1621: zport = qport->uuconf_zname;
1622: ftcp_port = FALSE;
1623: }
1624: else
1625: {
1626: zport = zsysdep_port_name (&ftcp_port);
1627: if (zport == NULL)
1628: {
1629: qport = NULL;
1630: zport = "unknown";
1631: }
1632: else
1633: {
1634: iuuconf = uuconf_find_port (puuconf, zport, (long) 0, (long) 0,
1635: (int (*) P((struct uuconf_port *,
1636: pointer pinfo))) NULL,
1637: (pointer) NULL,
1638: &sport);
1639: if (iuuconf == UUCONF_NOT_FOUND)
1640: qport = NULL;
1641: else if (iuuconf != UUCONF_SUCCESS)
1642: {
1643: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
1644: return FALSE;
1645: }
1646: else
1647: qport = &sport;
1648: }
1649: }
1650:
1651: /* If we've managed to figure out that this is a modem port, now try
1652: to get protocol parameters from the dialer. */
1653: qdialer = NULL;
1654: if (qport != NULL)
1655: {
1656: if (qport->uuconf_ttype == UUCONF_PORTTYPE_MODEM)
1657: {
1658: if (qport->uuconf_u.uuconf_smodem.uuconf_pzdialer != NULL)
1659: {
1660: const char *zdialer;
1661:
1662: zdialer = qport->uuconf_u.uuconf_smodem.uuconf_pzdialer[0];
1663: iuuconf = uuconf_dialer_info (puuconf, zdialer, &sdialer);
1664: if (iuuconf == UUCONF_SUCCESS)
1665: qdialer = &sdialer;
1666: }
1667: else
1668: qdialer = qport->uuconf_u.uuconf_smodem.uuconf_qdialer;
1669: }
1670: else if (qport->uuconf_ttype == UUCONF_PORTTYPE_TCP
1671: || (qport->uuconf_ttype == UUCONF_PORTTYPE_TLI
1672: && (qport->uuconf_ireliable
1673: & UUCONF_RELIABLE_SPECIFIED) == 0))
1674: ftcp_port = TRUE;
1675: }
1676:
1677: sDaemon.puuconf = puuconf;
1678: sDaemon.qsys = NULL;
1679: sDaemon.zlocalname = NULL;
1680: sDaemon.qconn = qconn;
1681: sDaemon.qproto = NULL;
1682: sDaemon.clocal_size = -1;
1683: sDaemon.cremote_size = -1;
1684: sDaemon.cmax_ever = -2;
1685: sDaemon.cmax_receive = -1;
1686: sDaemon.ifeatures = 0;
1687: sDaemon.frequest_hangup = FALSE;
1688: sDaemon.fhangup_requested = FALSE;
1689: sDaemon.fhangup = FALSE;
1690: sDaemon.fmaster = FALSE;
1691: sDaemon.fcaller = FALSE;
1692: sDaemon.ireliable = 0;
1693: sDaemon.bgrade = UUCONF_GRADE_LOW;
1694:
1695: /* Get the local name to use. If uuconf_login_localname returns a
1696: value, it is not always freed up, although it should be. */
1697: iuuconf = uuconf_login_localname (puuconf, zlogin, &zloc);
1698: if (iuuconf == UUCONF_SUCCESS)
1699: sDaemon.zlocalname = zloc;
1700: else if (iuuconf == UUCONF_NOT_FOUND)
1701: {
1702: sDaemon.zlocalname = zsysdep_localname ();
1703: if (sDaemon.zlocalname == NULL)
1704: return FALSE;
1705: }
1706: else
1707: {
1708: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
1709: return FALSE;
1710: }
1711:
1712: /* Tell the remote system who we are. */
1713: zsend = zbufalc (strlen (sDaemon.zlocalname) + sizeof "Shere=");
1714: sprintf (zsend, "Shere=%s", sDaemon.zlocalname);
1715: fret = fsend_uucp_cmd (qconn, zsend);
1716: ubuffree (zsend);
1717: if (! fret)
1718: return FALSE;
1719:
1720: zstr = zget_uucp_cmd (qconn, TRUE);
1721: if (zstr == NULL)
1722: return FALSE;
1723:
1724: if (zstr[0] != 'S')
1725: {
1726: ulog (LOG_ERROR, "Bad introduction string");
1727: ubuffree (zstr);
1728: return FALSE;
1729: }
1730:
1731: #ifdef MWCBBS
1732: strcpy(mwcbbs,zstr);
1733: mwcspace = strchr(mwcbbs,' ');
1734: if (mwcspace != NULL){
1735: *mwcspace = '\0';
1736: }
1737: #endif /* MWCBBS */
1738:
1739:
1740: zspace = strchr (zstr, ' ');
1741: if (zspace != NULL)
1742: *zspace = '\0';
1743:
1744: #ifdef MWCBBS
1745: {
1746: char *tmp;
1747:
1748: if((strcmp(mwcbbs+1, "bbsuser") == 0) &&
1749: ((tmp = ttyname(fileno(stdin))) != NULL)){
1750: sprintf(bbsuser,"SU%s%s",tmp+5,mwcspace+1);
1751: zspace = mwcspace;
1752: zstr = bbsuser;
1753: /* ulog(LOG_NORMAL,"bbsuser is {%s}",bbsuser);
1754: * ulog(LOG_NORMAL,"mwcspace is {%s}",mwcspace+1);
1755: * ulog(LOG_NORMAL,"zstr is {%s}",zstr);
1756: * ulog(LOG_NORMAL,"zspace is {%s}",zspace+1);
1757: */
1758: }
1759: }
1760: #endif /* MWCBBS */
1761:
1762: iuuconf = uuconf_system_info (puuconf, zstr + 1, &ssys);
1763: if (iuuconf == UUCONF_NOT_FOUND)
1764: {
1765: char *zscript;
1766:
1767: /* Run the remote.unknown script, if appropriate. */
1768: iuuconf = uuconf_remote_unknown (puuconf, &zscript);
1769: if (iuuconf == UUCONF_SUCCESS)
1770: {
1771: if (! fsysdep_unknown_caller (zscript, zstr + 1))
1772: {
1773: xfree ((pointer) zscript);
1774: (void) fsend_uucp_cmd (qconn, "RYou are unknown to me");
1775: ubuffree (zstr);
1776: return FALSE;
1777: }
1778: xfree ((pointer) zscript);
1779: }
1780: else if (iuuconf != UUCONF_NOT_FOUND)
1781: {
1782: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
1783: ubuffree (zstr);
1784: return FALSE;
1785: }
1786:
1787: if (! funknown_system (puuconf, zstr + 1, &ssys))
1788: {
1789: (void) fsend_uucp_cmd (qconn, "RYou are unknown to me");
1790: ulog (LOG_ERROR, "Call from unknown system %s", zstr + 1);
1791: ubuffree (zstr);
1792: return FALSE;
1793: }
1794: }
1795: else if (iuuconf != UUCONF_SUCCESS)
1796: {
1797: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
1798: ubuffree (zstr);
1799: return FALSE;
1800: }
1801:
1802: qany = NULL;
1803: for (qsys = &ssys; qsys != NULL; qsys = qsys->uuconf_qalternate)
1804: {
1805: if (! qsys->uuconf_fcalled)
1806: continue;
1807:
1808: if (qsys->uuconf_zcalled_login == NULL
1809: || strcmp (qsys->uuconf_zcalled_login, "ANY") == 0)
1810: {
1811: if (qany == NULL)
1812: qany = qsys;
1813: }
1814: else if (strcmp (qsys->uuconf_zcalled_login, zlogin) == 0)
1815: break;
1816: }
1817:
1818: if (qsys == NULL && qany != NULL)
1819: {
1820: iuuconf = uuconf_validate (puuconf, qany, zlogin);
1821: if (iuuconf == UUCONF_SUCCESS)
1822: qsys = qany;
1823: else if (iuuconf != UUCONF_NOT_FOUND)
1824: {
1825: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
1826: ubuffree (zstr);
1827: return FALSE;
1828: }
1829: }
1830:
1831: if (qsys == NULL)
1832: {
1833: (void) fsend_uucp_cmd (qconn, "RLOGIN");
1834: ulog (LOG_ERROR, "System %s used wrong login name %s",
1835: zstr + 1, zlogin);
1836: ubuffree (zstr);
1837: return FALSE;
1838: }
1839:
1840: sDaemon.qsys = qsys;
1841:
1842: if (pzsystem != NULL)
1843: *pzsystem = zbufcpy (qsys->uuconf_zname);
1844:
1845: ulog_system (qsys->uuconf_zname);
1846:
1847: #if DEBUG > 1
1848: if (qsys->uuconf_zdebug != NULL)
1849: iDebug |= idebug_parse (qsys->uuconf_zdebug);
1850: #endif
1851:
1852: /* See if we are supposed to call the system back. This will queue
1853: up an empty command. It would be better to actually call back
1854: directly at this point as well. */
1855: if (qsys->uuconf_fcallback)
1856: {
1857: (void) fsend_uucp_cmd (qconn, "RCB");
1858: ulog (LOG_NORMAL, "Will call back");
1859:
1860: /* Clear any existing status. */
1861: sstat.ttype = STATUS_COMPLETE;
1862: sstat.cretries = 0;
1863: sstat.ilast = ixsysdep_time ((long *) NULL);
1864: sstat.cwait = 0;
1865: (void) fsysdep_set_status (qsys, &sstat);
1866:
1867: ubuffree (zsysdep_spool_commands (qsys, UUCONF_GRADE_HIGH, 0,
1868: (const struct scmd *) NULL));
1869: ubuffree (zstr);
1870: return TRUE;
1871: }
1872:
1873: /* We only permit one call at a time from a remote system. Lock it. */
1874: if (! fsysdep_lock_system (qsys))
1875: {
1876: (void) fsend_uucp_cmd (qconn, "RLCK");
1877: ulog (LOG_ERROR, "System already locked");
1878: ubuffree (zstr);
1879: return FALSE;
1880: }
1881: sLocked_system = *qsys;
1882: fLocked_system = TRUE;
1883:
1884: /* Set the system status. We don't care what the status was before.
1885: We also don't want to kill the conversation just because we can't
1886: output the .Status file, so we ignore any errors. */
1887: sstat.ttype = STATUS_TALKING;
1888: sstat.cretries = 0;
1889: sstat.ilast = ixsysdep_time ((long *) NULL);
1890: sstat.cwait = 0;
1891: (void) fsysdep_set_status (qsys, &sstat);
1892:
1893: /* Check the arguments of the remote system, if any. */
1894: fgotseq = FALSE;
1895: fgotn = FALSE;
1896: if (zspace != NULL)
1897: {
1898: char **paz;
1899: char **pzset;
1900:
1901: ++zspace;
1902:
1903: /* Break the introduction line up into arguments. */
1904: paz = (char **) xmalloc ((strlen (zspace) / 2 + 2) * sizeof (char *));
1905: pzset = paz;
1906: *pzset++ = NULL;
1907: while (TRUE)
1908: {
1909: while (*zspace != '\0' && isspace (BUCHAR (*zspace)))
1910: ++zspace;
1911: if (*zspace == '\0')
1912: break;
1913: *pzset++ = zspace;
1914: ++zspace;
1915: while (*zspace != '\0' && ! isspace (BUCHAR (*zspace)))
1916: ++zspace;
1917: if (*zspace == '\0')
1918: break;
1919: *zspace++ = '\0';
1920: }
1921:
1922: if (pzset != paz + 1)
1923: {
1924: int iopt;
1925:
1926: *pzset = NULL;
1927:
1928: /* We are going to use getopt to parse the arguments. We
1929: must clear optind to force getopt to reinitialize, and
1930: clear opterr to prevent getopt from printing an error
1931: message. This approach assumes we are using the GNU
1932: getopt, which is distributed with the program anyhow. */
1933: optind = 0;
1934: opterr = 0;
1935:
1936: while ((iopt = getopt (pzset - paz, paz,
1937: "N::p:Q:RU:v:x:")) != EOF)
1938: {
1939: long iseq;
1940: long c;
1941: char b;
1942: int iwant;
1943:
1944: switch (iopt)
1945: {
1946: case 'N':
1947: /* This is used to indicate support for Taylor UUCP
1948: extensions. An plain -N mean support for size
1949: negotiation. If -N is followed by a number (with
1950: no intervening space), the number is a bit field
1951: of feature flags as defined in trans.h. Note
1952: that the argument may start with 0x for hex or 0
1953: for octal. */
1954: fgotn = TRUE;
1955: if (optarg == NULL)
1956: sDaemon.ifeatures |= FEATURE_SIZES | FEATURE_V103;
1957: else
1958: sDaemon.ifeatures |= (int) strtol (optarg,
1959: (char **) NULL,
1960: 0);
1961: break;
1962:
1963: case 'p':
1964: /* The argument is the lowest grade of work the
1965: local system should send. */
1966: if (UUCONF_GRADE_LEGAL (optarg[0]))
1967: sDaemon.bgrade = optarg[0];
1968: break;
1969:
1970: case 'Q':
1971: /* The conversation sequence number. */
1972: iseq = strtol (optarg, (char **) NULL, 10);
1973: if (qsys->uuconf_fsequence
1974: && iseq != ixsysdep_get_sequence (qsys))
1975: {
1976: (void) fsend_uucp_cmd (qconn, "RBADSEQ");
1977: ulog (LOG_ERROR, "Out of sequence call rejected");
1978: sstat.ttype = STATUS_FAILED;
1979: (void) fsysdep_set_status (qsys, &sstat);
1980: xfree ((pointer) paz);
1981: ubuffree (zstr);
1982: return FALSE;
1983: }
1984: fgotseq = TRUE;
1985: break;
1986:
1987: case 'R':
1988: /* The remote system supports file restart. */
1989: sDaemon.ifeatures |= FEATURE_RESTART;
1990: break;
1991:
1992: case 'U':
1993: /* The maximum file size the remote system is
1994: prepared to received, in blocks where each block
1995: is 512 bytes. */
1996: c = strtol (optarg, (char **) NULL, 0);
1997: if (c > 0 && c < LONG_MAX / (long) 512)
1998: sDaemon.cmax_receive = c * (long) 512;
1999: break;
2000:
2001: case 'v':
2002: /* -vgrade=X can be used to set the lowest grade of
2003: work the local system should send. */
2004: if (strncmp (optarg, "grade=", sizeof "grade=" - 1) == 0)
2005: {
2006: b = optarg[sizeof "grade=" - 1];
2007: if (UUCONF_GRADE_LEGAL (b))
2008: sDaemon.bgrade = b;
2009: }
2010: break;
2011:
2012: case 'x':
2013: iwant = (int) strtol (optarg, (char **) NULL, 10);
2014: #if DEBUG > 1
2015: if (iwant <= 9)
2016: iwant = (1 << iwant) - 1;
2017: if (qsys->uuconf_zmax_remote_debug != NULL)
2018: iwant &= idebug_parse (qsys->uuconf_zmax_remote_debug);
2019: if ((iDebug | iwant) != iDebug)
2020: {
2021: iDebug |= iwant;
2022: ulog (LOG_NORMAL, "Setting debugging mode to 0%o",
2023: iDebug);
2024: }
2025: #endif
2026: break;
2027:
2028: default:
2029: break;
2030: }
2031: }
2032: }
2033:
2034: xfree ((pointer) paz);
2035: }
2036:
2037: ubuffree (zstr);
2038:
2039: if (qsys->uuconf_fsequence && ! fgotseq)
2040: {
2041: (void) fsend_uucp_cmd (qconn, "RBADSEQ");
2042: ulog (LOG_ERROR, "No sequence number (call rejected)");
2043: sstat.ttype = STATUS_FAILED;
2044: (void) fsysdep_set_status (qsys, &sstat);
2045: return FALSE;
2046: }
2047:
2048: /* We recognized the system, and the sequence number (if any) was
2049: OK. Send an ROK, and send a list of protocols. If we got the -N
2050: switch, send ROKN to confirm it; if the -N switch was followed by
2051: a feature bitfield, return our own feature bitfield. */
2052: {
2053: char ab[20];
2054: const char *zreply;
2055:
2056: if (! fgotn)
2057: {
2058: if ((sDaemon.ifeatures & FEATURE_RESTART) == 0)
2059: zreply = "ROK";
2060: else
2061: {
2062: /* We got -R without -N, so assume that this is SVR4 UUCP.
2063: SVR4 UUCP expects ROK -R to signal support for file
2064: restart. */
2065: sDaemon.ifeatures |= FEATURE_SVR4 | FEATURE_SIZES;
2066: zreply = "ROK -R";
2067: }
2068: }
2069: else if ((sDaemon.ifeatures & FEATURE_V103) != 0)
2070: zreply = "ROKN";
2071: else
2072: {
2073: sprintf (ab, "ROKN0%o",
2074: (unsigned int) (FEATURE_SIZES
2075: | FEATURE_EXEC
2076: | FEATURE_RESTART));
2077: zreply = ab;
2078: }
2079: if (! fsend_uucp_cmd (qconn, zreply))
2080: {
2081: sstat.ttype = STATUS_FAILED;
2082: (void) fsysdep_set_status (qsys, &sstat);
2083: return FALSE;
2084: }
2085: }
2086:
2087: /* Determine the reliability of the connection based on the
2088: reliability of the port and the dialer. If we have no
2089: information, default to a reliable eight-bit full-duplex
2090: connection. */
2091: if (ftcp_port)
2092: sDaemon.ireliable = (UUCONF_RELIABLE_SPECIFIED
2093: | UUCONF_RELIABLE_ENDTOEND
2094: | UUCONF_RELIABLE_RELIABLE
2095: | UUCONF_RELIABLE_EIGHT
2096: | UUCONF_RELIABLE_FULLDUPLEX);
2097: else
2098: {
2099: if (qport != NULL
2100: && (qport->uuconf_ireliable & UUCONF_RELIABLE_SPECIFIED) != 0)
2101: sDaemon.ireliable = qport->uuconf_ireliable;
2102: if (qdialer != NULL
2103: && (qdialer->uuconf_ireliable & UUCONF_RELIABLE_SPECIFIED) != 0)
2104: {
2105: if (sDaemon.ireliable != 0)
2106: sDaemon.ireliable &= qdialer->uuconf_ireliable;
2107: else
2108: sDaemon.ireliable = qdialer->uuconf_ireliable;
2109: }
2110: if (sDaemon.ireliable == 0)
2111: sDaemon.ireliable = (UUCONF_RELIABLE_RELIABLE
2112: | UUCONF_RELIABLE_EIGHT
2113: | UUCONF_RELIABLE_FULLDUPLEX
2114: | UUCONF_RELIABLE_SPECIFIED);
2115: }
2116:
2117: if (qsys->uuconf_zprotocols != NULL ||
2118: (qport != NULL && qport->uuconf_zprotocols != NULL))
2119: {
2120: const char *zprotos;
2121:
2122: if (qsys->uuconf_zprotocols != NULL)
2123: zprotos = qsys->uuconf_zprotocols;
2124: else
2125: zprotos = qport->uuconf_zprotocols;
2126: zsend = zbufalc (strlen (zprotos) + 2);
2127: sprintf (zsend, "P%s", zprotos);
2128: }
2129: else
2130: {
2131: char *zset;
2132:
2133: zsend = zbufalc (CPROTOCOLS + 2);
2134: zset = zsend;
2135: *zset++ = 'P';
2136:
2137: /* If the system did not specify a list of protocols, we want
2138: only protocols that match the known reliability of the dialer
2139: and the port. */
2140: for (i = 0; i < CPROTOCOLS; i++)
2141: {
2142: int ipr;
2143:
2144: ipr = asProtocols[i].ireliable;
2145: if ((ipr & sDaemon.ireliable) != ipr)
2146: continue;
2147: *zset++ = asProtocols[i].bname;
2148: }
2149: *zset = '\0';
2150: }
2151:
2152: fret = fsend_uucp_cmd (qconn, zsend);
2153: ubuffree (zsend);
2154: if (! fret)
2155: {
2156: sstat.ttype = STATUS_FAILED;
2157: (void) fsysdep_set_status (qsys, &sstat);
2158: return FALSE;
2159: }
2160:
2161: /* The master will now send back the selected protocol. */
2162: zstr = zget_uucp_cmd (qconn, TRUE);
2163: if (zstr == NULL)
2164: {
2165: sstat.ttype = STATUS_FAILED;
2166: (void) fsysdep_set_status (qsys, &sstat);
2167: return FALSE;
2168: }
2169:
2170: if (zstr[0] != 'U' || zstr[2] != '\0')
2171: {
2172: ulog (LOG_ERROR, "Bad protocol response string");
2173: sstat.ttype = STATUS_FAILED;
2174: (void) fsysdep_set_status (qsys, &sstat);
2175: ubuffree (zstr);
2176: return FALSE;
2177: }
2178:
2179: if (zstr[1] == 'N')
2180: {
2181: ulog (LOG_ERROR, "No supported protocol");
2182: sstat.ttype = STATUS_FAILED;
2183: (void) fsysdep_set_status (qsys, &sstat);
2184: ubuffree (zstr);
2185: return FALSE;
2186: }
2187:
2188: for (i = 0; i < CPROTOCOLS; i++)
2189: if (asProtocols[i].bname == zstr[1])
2190: break;
2191:
2192: ubuffree (zstr);
2193:
2194: if (i >= CPROTOCOLS)
2195: {
2196: ulog (LOG_ERROR, "No supported protocol");
2197: sstat.ttype = STATUS_FAILED;
2198: (void) fsysdep_set_status (qsys, &sstat);
2199: return FALSE;
2200: }
2201:
2202: sDaemon.qproto = &asProtocols[i];
2203:
2204: /* Run the chat script for when a call is received. */
2205: if (! fchat (qconn, puuconf, &qsys->uuconf_scalled_chat, qsys,
2206: (const struct uuconf_dialer *) NULL, (const char *) NULL,
2207: FALSE, zport, iconn_baud (qconn)))
2208: {
2209: sstat.ttype = STATUS_FAILED;
2210: sstat.ilast = ixsysdep_time ((long *) NULL);
2211: (void) fsysdep_set_status (qsys, &sstat);
2212: return FALSE;
2213: }
2214:
2215: /* Run any protocol parameter commands. */
2216: if (sDaemon.qproto->qcmds != NULL)
2217: {
2218: if (qsys->uuconf_qproto_params != NULL)
2219: uapply_proto_params (puuconf, sDaemon.qproto->bname,
2220: sDaemon.qproto->qcmds,
2221: qsys->uuconf_qproto_params);
2222: if (qport != NULL
2223: && qport->uuconf_qproto_params != NULL)
2224: uapply_proto_params (puuconf, sDaemon.qproto->bname,
2225: sDaemon.qproto->qcmds,
2226: qport->uuconf_qproto_params);
2227: if (qdialer != NULL
2228: && qdialer->uuconf_qproto_params != NULL)
2229: uapply_proto_params (puuconf, sDaemon.qproto->bname,
2230: sDaemon.qproto->qcmds,
2231: qdialer->uuconf_qproto_params);
2232: }
2233:
2234: /* We don't need the dialer information any more. */
2235: if (qdialer == &sdialer)
2236: (void) uuconf_dialer_free (puuconf, &sdialer);
2237:
2238: /* Get any jobs queued for the system, and turn on the selected
2239: protocol. */
2240: if (! fqueue (&sDaemon, (boolean *) NULL)
2241: || ! (*sDaemon.qproto->pfstart) (&sDaemon, &zlog))
2242: {
2243: uclear_queue (&sDaemon);
2244: sstat.ttype = STATUS_FAILED;
2245: sstat.ilast = ixsysdep_time ((long *) NULL);
2246: (void) fsysdep_set_status (qsys, &sstat);
2247: return FALSE;
2248: }
2249:
2250: if (zlog == NULL)
2251: {
2252: zlog = zbufalc (sizeof "protocol ''" + 1);
2253: sprintf (zlog, "protocol '%c'", sDaemon.qproto->bname);
2254: }
2255:
2256: zgrade = zbufalc (sizeof "grade " + 1);
2257: if (sDaemon.bgrade == UUCONF_GRADE_LOW)
2258: *zgrade = '\0';
2259: else
2260: sprintf (zgrade, "grade %c ", sDaemon.bgrade);
2261:
2262: /* If we are using HAVE_HDB_LOGGING, then the previous ``incoming
2263: call'' message went to the general log, since we didn't know the
2264: system name at that point. In that case, we repeat the port and
2265: login names. */
2266: #if HAVE_HDB_LOGGING
2267: ulog (LOG_NORMAL, "Handshake successful (login %s port %s %s%s)",
2268: zlogin,
2269: zLdevice == NULL ? "unknown" : zLdevice,
2270: zgrade, zlog);
2271: #else /* ! HAVE_HDB_LOGGING */
2272: ulog (LOG_NORMAL, "Handshake successful (%s%s)", zgrade, zlog);
2273: #endif /* ! HAVE_HDB_LOGGING */
2274:
2275: ubuffree (zlog);
2276: ubuffree (zgrade);
2277:
2278: {
2279: long iend_time;
2280:
2281: fret = floop (&sDaemon);
2282:
2283: /* Hangup. As the answerer, we send seven O's and expect to
2284: receive six O's. We send the seven O's twice to help the other
2285: side. We don't worry about errors here. */
2286: if (fsend_uucp_cmd (qconn, "OOOOOOO")
2287: && fsend_uucp_cmd (qconn, "OOOOOOO"))
2288: {
2289: int fdone;
2290:
2291: /* We look for the remote hangup string to ensure that the
2292: modem has sent out our hangup string. This is only
2293: necessary because some versions of UUCP complain if they
2294: don't get the hangup string. We look for the string
2295: several times because supposedly some implementations send
2296: some garbage after the last packet but before the hangup
2297: string. */
2298: for (i = 0; i < 25; i++)
2299: {
2300: zstr = zget_uucp_cmd (qconn, FALSE);
2301: if (zstr == NULL)
2302: break;
2303: fdone = strstr (zstr, "OOOOOO") != NULL;
2304: ubuffree (zstr);
2305: if (fdone)
2306: break;
2307: }
2308: }
2309:
2310: iend_time = ixsysdep_time ((long *) NULL);
2311:
2312: ulog (LOG_NORMAL, "Call complete (%ld seconds)",
2313: iend_time - istart_time);
2314:
2315: uclear_queue (&sDaemon);
2316:
2317: if (fret)
2318: sstat.ttype = STATUS_COMPLETE;
2319: else
2320: sstat.ttype = STATUS_FAILED;
2321: sstat.ilast = iend_time;
2322: (void) fsysdep_set_status (qsys, &sstat);
2323:
2324: (void) uuconf_system_free (puuconf, &ssys);
2325: if (qport == &sport)
2326: (void) uuconf_port_free (puuconf, &sport);
2327: xfree ((pointer) zloc);
2328:
2329: return fret;
2330: }
2331: }
2332:
2333: /* Apply protocol parameters, once we know the protocol. */
2334:
2335: static void
2336: uapply_proto_params (puuconf, bproto, qcmds, pas)
2337: pointer puuconf;
2338: int bproto;
2339: struct uuconf_cmdtab *qcmds;
2340: struct uuconf_proto_param *pas;
2341: {
2342: struct uuconf_proto_param *qp;
2343:
2344: for (qp = pas; qp->uuconf_bproto != '\0'; qp++)
2345: {
2346: if (qp->uuconf_bproto == bproto)
2347: {
2348: struct uuconf_proto_param_entry *qe;
2349:
2350: for (qe = qp->uuconf_qentries; qe->uuconf_cargs > 0; qe++)
2351: {
2352: int iuuconf;
2353:
2354: iuuconf = uuconf_cmd_args (puuconf, qe->uuconf_cargs,
2355: qe->uuconf_pzargs, qcmds,
2356: (pointer) NULL,
2357: (uuconf_cmdtabfn) NULL, 0,
2358: (pointer) NULL);
2359: if (UUCONF_ERROR_VALUE (iuuconf) != UUCONF_SUCCESS)
2360: {
2361: ulog (LOG_ERROR, "Error in %c protocol parameters",
2362: bproto);
2363: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
2364: }
2365: }
2366:
2367: break;
2368: }
2369: }
2370: }
2371:
2372: /* Send a string to the other system beginning with a DLE
2373: character and terminated with a null byte. This is only
2374: used when no protocol is in force. */
2375:
2376: static boolean
2377: fsend_uucp_cmd (qconn, z)
2378: struct sconnection *qconn;
2379: const char *z;
2380: {
2381: size_t cwrite;
2382: char *zalc;
2383: boolean fret;
2384:
2385: DEBUG_MESSAGE1 (DEBUG_HANDSHAKE, "fsend_uucp_cmd: Sending \"%s\"", z);
2386:
2387: cwrite = strlen (z) + 2;
2388:
2389: zalc = zbufalc (cwrite);
2390: zalc[0] = '\020';
2391: memcpy (zalc + 1, z, cwrite - 1);
2392:
2393: fret = fconn_write (qconn, zalc, cwrite);
2394: ubuffree (zalc);
2395: return fret;
2396: }
2397:
2398: /* Get a UUCP command beginning with a DLE character and ending with a
2399: null byte. This is only used when no protocol is in force. This
2400: implementation has the potential of being seriously slow. It also
2401: doesn't have any real error recovery. The frequired argument is
2402: passed as TRUE if we need the string; we don't care that much if
2403: we're closing down the connection anyhow. */
2404:
2405: #define CTIMEOUT (120)
2406: #define CSHORTTIMEOUT (10)
2407: #define CINCREMENT (100)
2408:
2409: static char *
2410: zget_uucp_cmd (qconn, frequired)
2411: struct sconnection *qconn;
2412: boolean frequired;
2413: {
2414: char *zalc;
2415: size_t calc;
2416: size_t cgot;
2417: boolean fintro;
2418: long iendtime;
2419: int ctimeout;
2420: #if DEBUG > 1
2421: int cchars;
2422: int iolddebug;
2423: #endif
2424:
2425: iendtime = ixsysdep_time ((long *) NULL);
2426: if (frequired)
2427: iendtime += CTIMEOUT;
2428: else
2429: iendtime += CSHORTTIMEOUT;
2430:
2431: #if DEBUG > 1
2432: cchars = 0;
2433: iolddebug = iDebug;
2434: if (FDEBUGGING (DEBUG_HANDSHAKE))
2435: {
2436: ulog (LOG_DEBUG_START, "zget_uucp_cmd: Got \"");
2437: iDebug &=~ (DEBUG_INCOMING | DEBUG_PORT);
2438: }
2439: #endif
2440:
2441: zalc = NULL;
2442: calc = 0;
2443: cgot = 0;
2444: fintro = FALSE;
2445: while ((ctimeout = (int) (iendtime - ixsysdep_time ((long *) NULL))) > 0)
2446: {
2447: int b;
2448:
2449: b = breceive_char (qconn, ctimeout, frequired);
2450: /* Now b == -1 on timeout, -2 on error. */
2451: if (b < 0)
2452: {
2453: #if DEBUG > 1
2454: if (FDEBUGGING (DEBUG_HANDSHAKE))
2455: {
2456: ulog (LOG_DEBUG_END, "\" (%s)",
2457: b == -1 ? "timeout" : "error");
2458: iDebug = iolddebug;
2459: }
2460: #endif
2461: if (b == -1 && frequired)
2462: ulog (LOG_ERROR, "Timeout");
2463: ubuffree (zalc);
2464: return NULL;
2465: }
2466:
2467: /* Apparently some systems use parity on these strings, so we
2468: strip the parity bit. This may need to be configurable at
2469: some point, although only if system names can have eight bit
2470: characters. */
2471: if (! isprint (BUCHAR (b)))
2472: b &= 0x7f;
2473:
2474: #if DEBUG > 1
2475: if (FDEBUGGING (DEBUG_HANDSHAKE))
2476: {
2477: char ab[5];
2478:
2479: ++cchars;
2480: if (cchars > 60)
2481: {
2482: ulog (LOG_DEBUG_END, "\"");
2483: ulog (LOG_DEBUG_START, "zget_uucp_cmd: Got \"");
2484: cchars = 0;
2485: }
2486: (void) cdebug_char (ab, b);
2487: ulog (LOG_DEBUG_CONTINUE, "%s", ab);
2488: }
2489: #endif
2490:
2491: if (! fintro)
2492: {
2493: if (b == '\020')
2494: fintro = TRUE;
2495: continue;
2496: }
2497:
2498: /* If we see another DLE, something has gone wrong; continue
2499: as though this were the first one we saw. */
2500: if (b == '\020')
2501: {
2502: cgot = 0;
2503: continue;
2504: }
2505:
2506: /* Some systems send a trailing \n on the Shere line. As far as
2507: I can tell this line can never contain a \n, so this
2508: modification should be safe enough. */
2509: if (b == '\r' || b == '\n')
2510: b = '\0';
2511:
2512: if (cgot >= calc)
2513: {
2514: char *znew;
2515:
2516: calc += CINCREMENT;
2517: znew = zbufalc (calc);
2518: memcpy (znew, zalc, cgot);
2519: ubuffree (zalc);
2520: zalc = znew;
2521: }
2522:
2523: zalc[cgot] = (char) b;
2524: ++cgot;
2525:
2526: if (b == '\0')
2527: {
2528: #if DEBUG > 1
2529: if (FDEBUGGING (DEBUG_HANDSHAKE))
2530: {
2531: ulog (LOG_DEBUG_END, "\"");
2532: iDebug = iolddebug;
2533: }
2534: #endif
2535: return zalc;
2536: }
2537: }
2538:
2539: #if DEBUG > 1
2540: if (FDEBUGGING (DEBUG_HANDSHAKE))
2541: {
2542: ulog (LOG_DEBUG_END, "\" (timeout)");
2543: iDebug = iolddebug;
2544: }
2545: #endif
2546:
2547: ubuffree (zalc);
2548:
2549: if (frequired)
2550: ulog (LOG_ERROR, "Timeout");
2551: return NULL;
2552: }
2553:
2554: /* Read a sequence of characters up to a newline or carriage return, and
2555: return the line without the line terminating character. */
2556:
2557: static char *
2558: zget_typed_line (qconn)
2559: struct sconnection *qconn;
2560: {
2561: char *zalc;
2562: size_t calc;
2563: size_t cgot;
2564:
2565: #if DEBUG > 1
2566: int cchars;
2567: int iolddebug;
2568:
2569: cchars = 0;
2570: iolddebug = iDebug;
2571: if (FDEBUGGING (DEBUG_CHAT))
2572: {
2573: ulog (LOG_DEBUG_START, "zget_typed_line: Got \"");
2574: iDebug &=~ (DEBUG_INCOMING | DEBUG_PORT);
2575: }
2576: #endif
2577:
2578: zalc = NULL;
2579: calc = 0;
2580: cgot = 0;
2581: while (TRUE)
2582: {
2583: int b;
2584:
2585: b = breceive_char (qconn, CTIMEOUT, FALSE);
2586:
2587: /* Now b == -1 on timeout, -2 on error. */
2588:
2589: if (b == -2 || FGOT_SIGNAL ())
2590: {
2591: #if DEBUG > 1
2592: if (FDEBUGGING (DEBUG_CHAT))
2593: {
2594: ulog (LOG_DEBUG_END, "\" (error)");
2595: iDebug = iolddebug;
2596: }
2597: #endif
2598: ubuffree (zalc);
2599: return NULL;
2600: }
2601:
2602: if (b == -1)
2603: continue;
2604:
2605: #if DEBUG > 1
2606: if (FDEBUGGING (DEBUG_CHAT))
2607: {
2608: char ab[5];
2609:
2610: ++cchars;
2611: if (cchars > 60)
2612: {
2613: ulog (LOG_DEBUG_END, "\"");
2614: ulog (LOG_DEBUG_START, "zget_typed_line: Got \"");
2615: cchars = 0;
2616: }
2617: (void) cdebug_char (ab, b);
2618: ulog (LOG_DEBUG_CONTINUE, "%s", ab);
2619: }
2620: #endif
2621:
2622: if (cgot >= calc)
2623: {
2624: char *znew;
2625:
2626: calc += CINCREMENT;
2627: znew = zbufalc (calc);
2628: memcpy (znew, zalc, cgot);
2629: ubuffree (zalc);
2630: zalc = znew;
2631: }
2632:
2633: if (b == '\r' || b == '\n')
2634: b = '\0';
2635:
2636: zalc[cgot] = (char) b;
2637: ++cgot;
2638:
2639: if (b == '\0')
2640: {
2641: #if DEBUG > 1
2642: if (FDEBUGGING (DEBUG_CHAT))
2643: {
2644: ulog (LOG_DEBUG_END, "\"");
2645: iDebug = iolddebug;
2646: }
2647: #endif
2648: return zalc;
2649: }
2650: }
2651: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.