![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cu.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 cu.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104 |
1.1 root 1: /* cu.c
2: Call up a remote system.
3:
4: Copyright (C) 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 cu_rcsid[] = "$Id: cu.c,v 1.1 93/07/30 07:53:00 bin Exp Locker: bin $";
30: #endif
31:
32: #include "cu.h"
33: #include "uudefs.h"
34: #include "uuconf.h"
35: #include "conn.h"
36: #include "prot.h"
37: #include "system.h"
38: #include "sysdep.h"
39: #include "getopt.h"
40:
41: #include <stdio.h>
42: #include <ctype.h>
43: #include <errno.h>
44:
45: /* Here are the user settable variables. The user is permitted to
46: change these while running the program, using ~s. */
47:
48: /* The escape character used to introduce a special command. The
49: escape character is the first character of this string. */
50: const char *zCuvar_escape = "~";
51:
52: /* Whether to delay for a second before printing the host name after
53: seeing an escape character. */
54: boolean fCuvar_delay = TRUE;
55:
56: /* The input characters which finish a line. The escape character is
57: only recognized following one of these characters. The default is
58: carriage return, ^U, ^C, ^O, ^D, ^S, ^Q, ^R, which I got from the
59: Ultrix /etc/remote file. */
60: const char *zCuvar_eol = "\r\025\003\017\004\023\021\022";
61:
62: /* Whether to transfer binary data (nonprintable characters other than
63: newline and tab) when sending a file. If this is FALSE, then
64: newline is changed to carriage return. */
65: boolean fCuvar_binary = FALSE;
66:
67: /* A prefix string to use before sending a binary character from a
68: file; this is only used if fCuvar_binary is TRUE. The default is
69: ^Z. */
70: const char *zCuvar_binary_prefix = "\026";
71:
72: /* Whether to check for echoes of characters sent when sending a file.
73: This is ignored if fCuvar_binary is TRUE. */
74: boolean fCuvar_echocheck = FALSE;
75:
76: /* A character to look for after each newline is sent when sending a
77: file. The character is the first character in this string, except
78: that a '\0' means that no echo check is done. */
79: const char *zCuvar_echonl = "\r";
80:
81: /* The timeout to use when looking for an character. */
82: int cCuvar_timeout = 30;
83:
84: /* The character to use to kill a line if an echo check fails. The
85: first character in this string is sent. The default is ^U. */
86: const char *zCuvar_kill = "\025";
87:
88: /* The number of times to try resending a line if the echo check keeps
89: failing. */
90: int cCuvar_resend = 10;
91:
92: /* The string to send at the end of a file sent with ~>. The default
93: is ^D. */
94: const char *zCuvar_eofwrite = "\004";
95:
96: /* The string to look for to finish a file received with ~<. For tip
97: this is a collection of single characters, but I don't want to do
98: that because it means that there are characters which cannot be
99: received. The default is a guess at a typical shell prompt. */
100: const char *zCuvar_eofread = "$";
101:
102: /* Whether to provide verbose information when sending or receiving a
103: file. */
104: boolean fCuvar_verbose = TRUE;
105:
106: /* The table used to give a value to a variable, and to print all the
107: variable values. */
108:
109: static const struct uuconf_cmdtab asCuvars[] =
110: {
111: { "escape", UUCONF_CMDTABTYPE_STRING, (pointer) &zCuvar_escape, NULL },
112: { "delay", UUCONF_CMDTABTYPE_BOOLEAN, (pointer) &fCuvar_delay, NULL },
113: { "eol", UUCONF_CMDTABTYPE_STRING, (pointer) &zCuvar_eol, NULL },
114: { "binary", UUCONF_CMDTABTYPE_BOOLEAN, (pointer) &fCuvar_binary, NULL },
115: { "binary-prefix", UUCONF_CMDTABTYPE_STRING,
116: (pointer) &zCuvar_binary_prefix, NULL },
117: { "echocheck", UUCONF_CMDTABTYPE_BOOLEAN,
118: (pointer) &fCuvar_echocheck, NULL },
119: { "echonl", UUCONF_CMDTABTYPE_STRING, (pointer) &zCuvar_echonl, NULL },
120: { "timeout", UUCONF_CMDTABTYPE_INT, (pointer) &cCuvar_timeout, NULL },
121: { "kill", UUCONF_CMDTABTYPE_STRING, (pointer) &zCuvar_kill, NULL },
122: { "resend", UUCONF_CMDTABTYPE_INT, (pointer) &cCuvar_resend, NULL },
123: { "eofwrite", UUCONF_CMDTABTYPE_STRING, (pointer) &zCuvar_eofwrite, NULL },
124: { "eofread", UUCONF_CMDTABTYPE_STRING, (pointer) &zCuvar_eofread, NULL },
125: { "verbose", UUCONF_CMDTABTYPE_BOOLEAN, (pointer) &fCuvar_verbose, NULL },
126: { NULL, 0, NULL, NULL}
127: };
128:
129: /* The program name. */
130: char abProgram[] = "cu";
131:
132: /* The string printed at the initial connect. */
133: #if ANSI_C
134: #define ZCONNMSG "\aConnected."
135: #else
136: #define ZCONNMSG "Connected."
137: #endif
138:
139: /* The string printed when disconnecting. */
140: #if ANSI_C
141: #define ZDISMSG "\aDisconnected."
142: #else
143: #define ZDISMSG "Disconnected."
144: #endif
145:
146: /* Local variables. */
147:
148: /* The string we print when the user is once again connected to the
149: port after transferring a file or taking some other action. */
150: static const char abCuconnected[]
151: #if ANSI_C
152: = "\a[connected]";
153: #else
154: = "[connected]";
155: #endif
156:
157: /* Global uuconf pointer. */
158: static pointer pCuuuconf;
159:
160: /* Connection. */
161: static struct sconnection *qCuconn;
162:
163: /* Whether to close the connection. */
164: static boolean fCuclose_conn;
165:
166: /* Dialer used to dial out. */
167: static struct uuconf_dialer *qCudialer;
168:
169: /* Whether we need to restore the terminal. */
170: static boolean fCurestore_terminal;
171:
172: /* Whether we are doing local echoing. */
173: static boolean fCulocalecho;
174:
175: /* Whether we need to call fsysdep_cu_finish. */
176: static boolean fCustarted;
177:
178: /* A structure used to pass information to icuport_lock. */
179: struct sconninfo
180: {
181: boolean fmatched;
182: boolean flocked;
183: struct sconnection *qconn;
184: const char *zline;
185: };
186:
187: /* Local functions. */
188:
189: static void ucuusage P((void));
190: static void ucuabort P((void));
191: static void uculog_start P((void));
192: static void uculog_end P((void));
193: static int icuport_lock P((struct uuconf_port *qport, pointer pinfo));
194: static boolean fcudo_cmd P((pointer puuconf, struct sconnection *qconn,
195: int bcmd));
196: static boolean fcuset_var P((pointer puuconf, char *zline));
197: static int icuunrecogvar P((pointer puuconf, int argc, char **argv,
198: pointer pvar, pointer pinfo));
199: static int icuunrecogfn P((pointer puuconf, int argc, char **argv,
200: pointer pvar, pointer pinfo));
201: static void uculist_vars P((void));
202: static void uculist_fns P((const char *zescape));
203: static boolean fcudo_subcmd P((pointer puuconf, struct sconnection *qconn,
204: char *zline));
205: static boolean fcusend_buf P((struct sconnection *qconn, const char *zbuf,
206: size_t cbuf));
207:
208: #define ucuputs(zline) \
209: do { if (! fsysdep_terminal_puts (zline)) ucuabort (); } while (0)
210:
211: /* Long getopt options. */
212: static const struct option asCulongopts[] = { { NULL, 0, NULL, 0 } };
213:
214: int
215: main (argc, argv)
216: int argc;
217: char **argv;
218: {
219: /* -c: phone number. */
220: char *zphone = NULL;
221: /* -e: even parity. */
222: boolean feven = FALSE;
223: /* -l: line. */
224: char *zline = NULL;
225: /* -n: prompt for phone number. */
226: boolean fprompt = FALSE;
227: /* -o: odd parity. */
228: boolean fodd = FALSE;
229: /* -p: port name. */
230: const char *zport = NULL;
231: /* -s: speed. */
232: long ibaud = 0L;
233: /* -t: map cr to crlf. */
234: boolean fmapcr = FALSE;
235: /* -z: system. */
236: const char *zsystem = NULL;
237: /* -I: configuration file name. */
238: const char *zconfig = NULL;
239: int iopt;
240: pointer puuconf;
241: int iuuconf;
242: const char *zlocalname;
243: int i;
244: struct uuconf_system ssys;
245: const struct uuconf_system *qsys = NULL;
246: boolean flooped;
247: struct uuconf_port sport;
248: struct sconnection sconn;
249: struct sconninfo sinfo;
250: long ihighbaud;
251: struct uuconf_dialer sdialer;
252: struct uuconf_dialer *qdialer;
253: char bcmd;
254:
255: /* We want to accept -# as a speed. It's easiest to look through
256: the arguments, replace -# with -s#, and let getopt handle it. */
257: for (i = 1; i < argc; i++)
258: {
259: if (argv[i][0] == '-'
260: && isdigit (BUCHAR (argv[i][1])))
261: {
262: size_t clen;
263: char *z;
264:
265: clen = strlen (argv[i]);
266: z = zbufalc (clen + 2);
267: z[0] = '-';
268: z[1] = 's';
269: memcpy (z + 2, argv[i] + 1, clen);
270: argv[i] = z;
271: }
272: }
273:
274: while ((iopt = getopt_long (argc, argv, "a:c:dehnI:l:op:s:tx:z:",
275: asCulongopts, (int *) NULL)) != EOF)
276: {
277: switch (iopt)
278: {
279: case 'c':
280: /* Phone number. */
281: zphone = optarg;
282: break;
283:
284: case 'd':
285: /* Set debugging level to maximum. */
286: #if DEBUG > 1
287: iDebug = DEBUG_MAX;
288: #endif
289: break;
290:
291: case 'e':
292: /* Even parity. */
293: feven = TRUE;
294: break;
295:
296: case 'h':
297: /* Local echo. */
298: fCulocalecho = TRUE;
299: break;
300:
301: case 'n':
302: /* Prompt for phone number. */
303: fprompt = TRUE;
304: break;
305:
306: case 'l':
307: /* Line name. */
308: zline = optarg;
309: break;
310:
311: case 'o':
312: /* Odd parity. */
313: fodd = TRUE;
314: break;
315:
316: case 'p':
317: case 'a':
318: /* Port name (-a is for compatibility). */
319: zport = optarg;
320: break;
321:
322: case 's':
323: /* Speed. */
324: ibaud = strtol (optarg, (char **) NULL, 10);
325: break;
326:
327: case 't':
328: /* Map cr to crlf. */
329: fmapcr = TRUE;
330: break;
331:
332: case 'z':
333: /* System name. */
334: zsystem = optarg;
335: break;
336:
337: case 'I':
338: /* Configuration file name. */
339: if (fsysdep_other_config (optarg))
340: zconfig = optarg;
341: break;
342:
343: case 'x':
344: #if DEBUG > 1
345: /* Set debugging level. */
346: iDebug |= idebug_parse (optarg);
347: #endif
348: break;
349:
350: case 0:
351: /* Long option found and flag set. */
352: break;
353:
354: default:
355: ucuusage ();
356: break;
357: }
358: }
359:
360: /* There can be one more argument, which is either a system name, a
361: phone number, or "dir". We decide which it is based on the first
362: character. To call a UUCP system whose name begins with a digit,
363: or one which is named "dir", you must use -z. */
364: if (optind != argc)
365: {
366: if (optind != argc - 1
367: || zsystem != NULL
368: || zphone != NULL)
369: ucuusage ();
370: if (strcmp (argv[optind], "dir") != 0)
371: {
372: if (isdigit (BUCHAR (argv[optind][0])))
373: zphone = argv[optind];
374: else
375: zsystem = argv[optind];
376: }
377: }
378:
379: /* If the user doesn't give a system, port, line or speed, then
380: there's no basis on which to select a port. */
381: if (zsystem == NULL
382: && zport == NULL
383: && zline == NULL
384: && ibaud == 0L)
385: ucuusage ();
386:
387: if (fprompt)
388: {
389: size_t cphone;
390:
391: printf ("Phone number: ");
392: (void) fflush (stdout);
393: zphone = NULL;
394: cphone = 0;
395: if (getline (&zphone, &cphone, stdin) <= 0
396: || *zphone == '\0')
397: {
398: fprintf (stderr, "%s: No phone number entered\n", abProgram);
399: exit (EXIT_FAILURE);
400: }
401: }
402:
403: iuuconf = uuconf_init (&puuconf, "cu", zconfig);
404: if (iuuconf != UUCONF_SUCCESS)
405: ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
406: pCuuuconf = puuconf;
407:
408: #if DEBUG > 1
409: {
410: const char *zdebug;
411:
412: iuuconf = uuconf_debuglevel (puuconf, &zdebug);
413: if (iuuconf != UUCONF_SUCCESS)
414: ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
415: if (zdebug != NULL)
416: iDebug |= idebug_parse (zdebug);
417: }
418: #endif
419:
420: usysdep_initialize (puuconf, INIT_NOCHDIR | INIT_SUID);
421:
422: iuuconf = uuconf_localname (puuconf, &zlocalname);
423: if (iuuconf == UUCONF_NOT_FOUND)
424: {
425: zlocalname = zsysdep_localname ();
426: if (zlocalname == NULL)
427: exit (EXIT_FAILURE);
428: }
429: else if (iuuconf != UUCONF_SUCCESS)
430: ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
431:
432: ulog_fatal_fn (ucuabort);
433: pfLstart = uculog_start;
434: pfLend = uculog_end;
435:
436: #ifdef SIGINT
437: usysdep_signal (SIGINT);
438: #endif
439: #ifdef SIGHUP
440: usysdep_signal (SIGHUP);
441: #endif
442: #ifdef SIGQUIT
443: usysdep_signal (SIGQUIT);
444: #endif
445: #ifdef SIGTERM
446: usysdep_signal (SIGTERM);
447: #endif
448: #ifdef SIGPIPE
449: usysdep_signal (SIGPIPE);
450: #endif
451:
452: if (zsystem != NULL)
453: {
454: iuuconf = uuconf_system_info (puuconf, zsystem, &ssys);
455: if (iuuconf != UUCONF_SUCCESS)
456: {
457: if (iuuconf != UUCONF_NOT_FOUND)
458: ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
459: ulog (LOG_FATAL, "%s: System not found", zsystem);
460: }
461: qsys = &ssys;
462: }
463:
464: /* This loop is used if a system is specified. It loops over the
465: various alternates until it finds one for which the dial
466: succeeds. This is an ugly spaghetti construction, and it should
467: be broken up into different functions someday. */
468: flooped = FALSE;
469: while (TRUE)
470: {
471: enum tparitysetting tparity;
472: enum tstripsetting tstrip;
473:
474: /* The uuconf_find_port function only selects directly on a port
475: name and a speed. To select based on the line name, we use a
476: function. If we can't find any defined port, and the user
477: specified a line name but did not specify a port name or a
478: system or a phone number, then we fake a direct port with
479: that line name (we don't fake a port if a system or phone
480: number were given because if we fake a port we have no way to
481: place a call; perhaps we should automatically look up a
482: particular dialer). This permits users to say cu -lttyd0
483: without having to put ttyd0 in the ports file, provided they
484: have read and write access to the port. */
485: sinfo.fmatched = FALSE;
486: sinfo.flocked = FALSE;
487: sinfo.qconn = &sconn;
488: sinfo.zline = zline;
489: if (zport != NULL || zline != NULL || ibaud != 0L)
490: {
491: iuuconf = uuconf_find_port (puuconf, zport, ibaud, 0L,
492: icuport_lock, (pointer) &sinfo,
493: &sport);
494: if (iuuconf != UUCONF_SUCCESS)
495: {
496: if (iuuconf != UUCONF_NOT_FOUND)
497: {
498: if (sinfo.flocked)
499: {
500: (void) fconn_unlock (&sconn);
501: uconn_free (&sconn);
502: }
503: ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
504: }
505: if (zline == NULL
506: || zport != NULL
507: || zphone != NULL
508: || qsys != NULL)
509: {
510: if (sinfo.fmatched)
511: ulog (LOG_FATAL, "All matching ports in use");
512: else
513: ulog (LOG_FATAL, "No matching ports");
514: }
515:
516: sport.uuconf_zname = zline;
517: sport.uuconf_ttype = UUCONF_PORTTYPE_DIRECT;
518: sport.uuconf_zprotocols = NULL;
519: sport.uuconf_qproto_params = NULL;
520: sport.uuconf_ireliable = 0;
521: sport.uuconf_zlockname = NULL;
522: sport.uuconf_palloc = NULL;
523: sport.uuconf_u.uuconf_sdirect.uuconf_zdevice = NULL;
524: sport.uuconf_u.uuconf_sdirect.uuconf_ibaud = ibaud;
525:
526: if (! fsysdep_port_access (&sport))
527: ulog (LOG_FATAL, "%s: Permission denied", zline);
528:
529: if (! fconn_init (&sport, &sconn))
530: ucuabort ();
531:
532: if (! fconn_lock (&sconn, FALSE))
533: ulog (LOG_FATAL, "%s: Line in use", zline);
534:
535: qCuconn = &sconn;
536: }
537: ihighbaud = 0L;
538: }
539: else
540: {
541: for (; qsys != NULL; qsys = qsys->uuconf_qalternate)
542: {
543: if (! qsys->uuconf_fcall)
544: continue;
545: if (qsys->uuconf_qport != NULL)
546: {
547: if (fconn_init (qsys->uuconf_qport, &sconn))
548: {
549: if (fconn_lock (&sconn, FALSE))
550: {
551: qCuconn = &sconn;
552: break;
553: }
554: uconn_free (&sconn);
555: }
556: }
557: else
558: {
559: sinfo.fmatched = FALSE;
560: sinfo.flocked = FALSE;
561: sinfo.qconn = &sconn;
562: iuuconf = uuconf_find_port (puuconf, qsys->uuconf_zport,
563: qsys->uuconf_ibaud,
564: qsys->uuconf_ihighbaud,
565: icuport_lock,
566: (pointer) &sinfo,
567: &sport);
568: if (iuuconf == UUCONF_SUCCESS)
569: break;
570: if (iuuconf != UUCONF_NOT_FOUND)
571: {
572: if (sinfo.flocked)
573: {
574: (void) fconn_unlock (&sconn);
575: uconn_free (&sconn);
576: }
577: ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
578: }
579: }
580: }
581:
582: if (qsys == NULL)
583: {
584: const char *zrem;
585:
586: if (flooped)
587: zrem = "remaining ";
588: else
589: zrem = "";
590: if (sinfo.fmatched)
591: ulog (LOG_FATAL, "%s: All %smatching ports in use",
592: zsystem, zrem);
593: else
594: ulog (LOG_FATAL, "%s: No %smatching ports", zsystem, zrem);
595: }
596:
597: ibaud = qsys->uuconf_ibaud;
598: ihighbaud = qsys->uuconf_ihighbaud;
599: }
600:
601: /* Here we have locked a connection to use. */
602: if (! fconn_open (&sconn, ibaud, ihighbaud, FALSE))
603: ucuabort ();
604:
605: fCuclose_conn = TRUE;
606:
607: if (FGOT_SIGNAL ())
608: ucuabort ();
609:
610: /* Set up the connection. */
611: if (fodd && feven)
612: {
613: tparity = PARITYSETTING_NONE;
614: tstrip = STRIPSETTING_SEVENBITS;
615: }
616: else if (fodd)
617: {
618: tparity = PARITYSETTING_ODD;
619: tstrip = STRIPSETTING_SEVENBITS;
620: }
621: else if (feven)
622: {
623: tparity = PARITYSETTING_EVEN;
624: tstrip = STRIPSETTING_SEVENBITS;
625: }
626: else
627: {
628: tparity = PARITYSETTING_DEFAULT;
629: tstrip = STRIPSETTING_DEFAULT;
630: }
631:
632: if (! fconn_set (&sconn, tparity, tstrip, XONXOFF_ON))
633: ucuabort ();
634:
635: if (qsys != NULL)
636: zphone = qsys->uuconf_zphone;
637:
638: if (qsys != NULL || zphone != NULL)
639: {
640: enum tdialerfound tdialer;
641:
642: if (! fconn_dial (&sconn, puuconf, qsys, zphone, &sdialer,
643: &tdialer))
644: {
645: if (zport != NULL
646: || zline != NULL
647: || ibaud != 0L
648: || qsys == NULL)
649: ucuabort ();
650:
651: if (qsys->uuconf_qalternate == NULL)
652: ulog (LOG_FATAL, "%s: No remaining alternates", zsystem);
653:
654: fCuclose_conn = FALSE;
655: (void) fconn_close (&sconn, pCuuuconf, qCudialer, FALSE);
656: qCuconn = NULL;
657: (void) fconn_unlock (&sconn);
658: uconn_free (&sconn);
659:
660: /* Loop around and try another alternate. */
661: flooped = TRUE;
662: continue;
663: }
664: if (tdialer == DIALERFOUND_FALSE)
665: qdialer = NULL;
666: else
667: qdialer = &sdialer;
668: }
669: else
670: {
671: /* If no system or phone number was specified, we connect
672: directly to the modem. We only permit this if the user
673: has access to the port, since it permits various
674: shenanigans such as reprogramming the automatic
675: callbacks. */
676: if (! fsysdep_port_access (sconn.qport))
677: ulog (LOG_FATAL, "Access to port denied");
678: qdialer = NULL;
679: if (! fconn_carrier (&sconn, FALSE))
680: ulog (LOG_FATAL, "Can't turn off carrier");
681: }
682:
683: break;
684: }
685:
686: qCudialer = qdialer;
687:
688: if (FGOT_SIGNAL ())
689: ucuabort ();
690:
691: /* Here we have connected, and can start the main cu protocol. The
692: program spends most of its time in system dependent code, and
693: only comes out when a special command is received from the
694: terminal. */
695: printf ("%s\n", ZCONNMSG);
696:
697: if (! fsysdep_terminal_raw (fCulocalecho))
698: ucuabort ();
699:
700: fCurestore_terminal = TRUE;
701:
702: if (! fsysdep_cu_init (&sconn))
703: ucuabort ();
704:
705: fCustarted = TRUE;
706:
707: while (fsysdep_cu (&sconn, &bcmd, zlocalname))
708: if (! fcudo_cmd (puuconf, &sconn, bcmd))
709: break;
710:
711: fCustarted = FALSE;
712: if (! fsysdep_cu_finish ())
713: ucuabort ();
714:
715: fCurestore_terminal = FALSE;
716: (void) fsysdep_terminal_restore ();
717:
718: (void) fconn_close (&sconn, puuconf, qdialer, TRUE);
719: (void) fconn_unlock (&sconn);
720: uconn_free (&sconn);
721:
722: printf ("\n%s\n", ZDISMSG);
723:
724: ulog_close ();
725:
726: usysdep_exit (TRUE);
727:
728: /* Avoid errors about not returning a value. */
729: return 0;
730: }
731:
732: /* Print a usage message and die. */
733:
734: static void
735: ucuusage ()
736: {
737: fprintf (stderr,
738: "Taylor UUCP version %s, copyright (C) 1991, 1992 Ian Lance Taylor\n",
739: VERSION);
740: fprintf (stderr,
741: "Usage: cu [options] [system or phone-number]\n");
742: fprintf (stderr,
743: " -a port, -p port: Use named port\n");
744: fprintf (stderr,
745: " -l line: Use named device (e.g. tty0)\n");
746: fprintf (stderr,
747: " -s speed, -#: Use given speed\n");
748: fprintf (stderr,
749: " -c phone: Phone number to call\n");
750: fprintf (stderr,
751: " -z system: System to call\n");
752: fprintf (stderr,
753: " -e: Set even parity\n");
754: fprintf (stderr,
755: " -o: Set odd parity\n");
756: fprintf (stderr,
757: " -h: Echo locally\n");
758: fprintf (stderr,
759: " -t: Map carriage return to carriage return/linefeed\n");
760: fprintf (stderr,
761: " -n: Prompt for phone number\n");
762: fprintf (stderr,
763: " -d: Set maximum debugging level\n");
764: fprintf (stderr,
765: " -x debug: Set debugging type\n");
766: #if HAVE_TAYLOR_CONFIG
767: fprintf (stderr,
768: " -I file: Set configuration file to use\n");
769: #endif /* HAVE_TAYLOR_CONFIG */
770:
771: exit (EXIT_FAILURE);
772: }
773:
774: /* This function is called when a fatal error occurs. */
775:
776: static void
777: ucuabort ()
778: {
779: if (fCustarted)
780: {
781: fCustarted = FALSE;
782: (void) fsysdep_cu_finish ();
783: }
784:
785: if (fCurestore_terminal)
786: {
787: fCurestore_terminal = FALSE;
788: (void) fsysdep_terminal_restore ();
789: }
790:
791: if (qCuconn != NULL)
792: {
793: struct sconnection *qconn;
794:
795: if (fCuclose_conn)
796: {
797: fCuclose_conn = FALSE;
798: (void) fconn_close (qCuconn, pCuuuconf, qCudialer, FALSE);
799: }
800: qconn = qCuconn;
801: qCuconn = NULL;
802: (void) fconn_unlock (qconn);
803: uconn_free (qconn);
804: }
805:
806: ulog_close ();
807:
808: printf ("\n%s\n", ZDISMSG);
809:
810: usysdep_exit (FALSE);
811: }
812:
813: /* This variable is just used to communicate between uculog_start and
814: uculog_end. */
815: static boolean fCulog_restore;
816:
817: /* This function is called by ulog before it output anything. We use
818: it to restore the terminal, if necessary. ulog is only called for
819: errors or debugging in cu, so it's not too costly to do this. If
820: we didn't do it, then at least on Unix each line would leave the
821: cursor in the same column rather than wrapping back to the start,
822: since CRMOD will not be on. */
823:
824: static void
825: uculog_start ()
826: {
827: if (! fCurestore_terminal)
828: fCulog_restore = FALSE;
829: else
830: {
831: fCulog_restore = TRUE;
832: fCurestore_terminal = FALSE;
833: if (! fsysdep_terminal_restore ())
834: ucuabort ();
835: }
836: }
837:
838: /* This function is called by ulog after everything is output. It
839: sets the terminal back, if necessary. */
840:
841: static void
842: uculog_end ()
843: {
844: if (fCulog_restore)
845: {
846: if (! fsysdep_terminal_raw (fCulocalecho))
847: ucuabort ();
848: fCurestore_terminal = TRUE;
849: }
850: }
851:
852: /* Check to see if this port has the desired line, to handle the -l
853: option. If it does, or if no line was specified, set up a
854: connection and lock it. */
855:
856: static int
857: icuport_lock (qport, pinfo)
858: struct uuconf_port *qport;
859: pointer pinfo;
860: {
861: struct sconninfo *q = (struct sconninfo *) pinfo;
862:
863: if (q->zline != NULL
864: && ! fsysdep_port_is_line (qport, q->zline))
865: return UUCONF_NOT_FOUND;
866:
867: q->fmatched = TRUE;
868:
869: if (! fconn_init (qport, q->qconn))
870: return UUCONF_NOT_FOUND;
871: else if (! fconn_lock (q->qconn, FALSE))
872: {
873: uconn_free (q->qconn);
874: return UUCONF_NOT_FOUND;
875: }
876: else
877: {
878: qCuconn = q->qconn;
879: q->flocked = TRUE;
880: return UUCONF_SUCCESS;
881: }
882: }
883:
884: /* Execute a cu escape command. Return TRUE if the connection should
885: continue, or FALSE if the connection should be terminated. */
886:
887: static boolean
888: fcudo_cmd (puuconf, qconn, bcmd)
889: pointer puuconf;
890: struct sconnection *qconn;
891: int bcmd;
892: {
893: char *zline;
894: char *z;
895: char abescape[5];
896: boolean fret;
897: size_t clen;
898: char abbuf[100];
899:
900: /* Some commands take a string up to the next newline character. */
901: switch (bcmd)
902: {
903: default:
904: zline = NULL;
905: break;
906: case '!':
907: case '$':
908: case '|':
909: case '+':
910: case '%':
911: case 'c':
912: case '>':
913: case '<':
914: case 'p':
915: case 't':
916: case 's':
917: {
918: zline = zsysdep_terminal_line ((const char *) NULL);
919: if (zline == NULL)
920: ucuabort ();
921: zline[strcspn (zline, "\n")] = '\0';
922: }
923: break;
924: }
925:
926: switch (bcmd)
927: {
928: default:
929: if (! isprint (*zCuvar_escape))
930: sprintf (abescape, "\\%03o", (unsigned int) *zCuvar_escape);
931: else
932: {
933: abescape[0] = *zCuvar_escape;
934: abescape[1] = '\0';
935: }
936: sprintf (abbuf, "[Unrecognized. Use %s%s to send %s]",
937: abescape, abescape, abescape);
938: ucuputs (abbuf);
939: return TRUE;
940:
941: case '.':
942: /* Hangup. */
943: return FALSE;
944:
945: case '!':
946: case '$':
947: case '|':
948: case '+':
949: /* Shell out. */
950: if (! fsysdep_cu_copy (FALSE)
951: || ! fsysdep_terminal_restore ())
952: ucuabort ();
953: fCurestore_terminal = FALSE;
954: {
955: enum tshell_cmd t;
956:
957: switch (bcmd)
958: {
959: default:
960: case '!': t = SHELL_NORMAL; break;
961: case '$': t = SHELL_STDOUT_TO_PORT; break;
962: case '|': t = SHELL_STDIN_FROM_PORT; break;
963: case '+': t = SHELL_STDIO_ON_PORT; break;
964: }
965:
966: (void) fsysdep_shell (qconn, zline, t);
967: }
968: if (! fsysdep_cu_copy (TRUE)
969: || ! fsysdep_terminal_raw (fCulocalecho))
970: ucuabort ();
971: fCurestore_terminal = TRUE;
972: ubuffree (zline);
973: return TRUE;
974:
975: case '%':
976: fret = fcudo_subcmd (puuconf, qconn, zline);
977: ubuffree (zline);
978: return fret;
979:
980: case '#':
981: if (! fconn_break (qconn))
982: ucuabort ();
983: return TRUE;
984:
985: case 'c':
986: (void) fsysdep_chdir (zline);
987: ubuffree (zline);
988: return TRUE;
989:
990: case '>':
991: case '<':
992: case 'p':
993: case 't':
994: clen = strlen (zline);
995: z = zbufalc (clen + 3);
996: z[0] = bcmd;
997: z[1] = ' ';
998: memcpy (z + 2, zline, clen + 1);
999: ubuffree (zline);
1000: fret = fcudo_subcmd (puuconf, qconn, z);
1001: ubuffree (z);
1002: return fret;
1003:
1004: case 'z':
1005: if (! fsysdep_cu_copy (FALSE)
1006: || ! fsysdep_terminal_restore ())
1007: ucuabort ();
1008: fCurestore_terminal = FALSE;
1009: if (! fsysdep_suspend ())
1010: ucuabort ();
1011: if (! fsysdep_cu_copy (TRUE)
1012: || ! fsysdep_terminal_raw (fCulocalecho))
1013: ucuabort ();
1014: fCurestore_terminal = TRUE;
1015: return TRUE;
1016:
1017: case 's':
1018: fret = fcuset_var (puuconf, zline);
1019: ubuffree (zline);
1020: return fret;
1021:
1022: case 'v':
1023: uculist_vars ();
1024: return TRUE;
1025:
1026: case '?':
1027: if (! isprint (*zCuvar_escape))
1028: sprintf (abescape, "\\%03o", (unsigned int) *zCuvar_escape);
1029: else
1030: {
1031: abescape[0] = *zCuvar_escape;
1032: abescape[1] = '\0';
1033: }
1034: ucuputs ("");
1035: ucuputs ("[Escape sequences]");
1036: sprintf (abbuf,
1037: "[%s. hangup] [%s!CMD run shell]",
1038: abescape, abescape);
1039: ucuputs (abbuf);
1040: sprintf (abbuf,
1041: "[%s$CMD stdout to remote] [%s|CMD stdin from remote]",
1042: abescape, abescape);
1043: ucuputs (abbuf);
1044: sprintf (abbuf,
1045: "[%s+CMD stdin and stdout to remote]",
1046: abescape);
1047: ucuputs (abbuf);
1048: sprintf (abbuf,
1049: "[%s# send break] [%scDIR change directory]",
1050: abescape, abescape);
1051: ucuputs (abbuf);
1052: sprintf (abbuf,
1053: "[%s> send file] [%s< receive file]",
1054: abescape, abescape);
1055: ucuputs (abbuf);
1056: sprintf (abbuf,
1057: "[%spFROM TO send to Unix] [%stFROM TO receive from Unix]",
1058: abescape, abescape);
1059: ucuputs (abbuf);
1060: sprintf (abbuf,
1061: "[%ssVAR VAL set variable] [%ssVAR set boolean]",
1062: abescape, abescape);
1063: ucuputs (abbuf);
1064: sprintf (abbuf,
1065: "[%ss!VAR unset boolean] [%sv list variables]",
1066: abescape, abescape);
1067: ucuputs (abbuf);
1068: #ifdef SIGTSTP
1069: sprintf (abbuf,
1070: "[%sz suspend]",
1071: abescape);
1072: ucuputs (abbuf);
1073: #endif
1074: uculist_fns (abescape);
1075: return TRUE;
1076: }
1077: }
1078:
1079: /* List ~% functions. */
1080:
1081: static void
1082: uculist_fns (zescape)
1083: const char *zescape;
1084: {
1085: char abbuf[100];
1086:
1087: sprintf (abbuf,
1088: "[%s%%break send break] [%s%%cd DIR change directory]",
1089: zescape, zescape);
1090: ucuputs (abbuf);
1091: sprintf (abbuf,
1092: "[%s%%put FROM TO send file] [%s%%take FROM TO receive file]",
1093: zescape, zescape);
1094: ucuputs (abbuf);
1095: sprintf (abbuf,
1096: "[%s%%nostop no XON/XOFF] [%s%%stop use XON/XOFF]",
1097: zescape, zescape);
1098: ucuputs (abbuf);
1099: }
1100:
1101: /* Set a variable. */
1102:
1103: static boolean
1104: fcuset_var (puuconf, zline)
1105: pointer puuconf;
1106: char *zline;
1107: {
1108: char *zvar, *zval;
1109: char *azargs[2];
1110: char azbool[2];
1111: int iuuconf;
1112:
1113: zvar = strtok (zline, "= \t");
1114: if (zvar == NULL)
1115: {
1116: ucuputs (abCuconnected);
1117: return TRUE;
1118: }
1119:
1120: zval = strtok ((char *) NULL, " \t");
1121:
1122: if (zval == NULL)
1123: {
1124: azargs[0] = zvar;
1125: if (azargs[0][0] != '!')
1126: azbool[0] = 't';
1127: else
1128: {
1129: ++azargs[0];
1130: azbool[0] = 'f';
1131: }
1132: azbool[1] = '\0';
1133: azargs[1] = azbool;
1134: }
1135: else
1136: {
1137: azargs[0] = zvar;
1138: azargs[1] = zval;
1139: }
1140:
1141: iuuconf = uuconf_cmd_args (puuconf, 2, azargs, asCuvars,
1142: (pointer) NULL, icuunrecogvar, 0,
1143: (pointer) NULL);
1144: if (iuuconf != UUCONF_SUCCESS)
1145: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
1146:
1147: return TRUE;
1148: }
1149:
1150: /* Warn about an unknown variable. */
1151:
1152: /*ARGSUSED*/
1153: static int
1154: icuunrecogvar (puuconf, argc, argv, pvar, pinfo)
1155: pointer puuconf;
1156: int argc;
1157: char **argv;
1158: pointer pvar;
1159: pointer pinfo;
1160: {
1161: char abescape[5];
1162:
1163: if (! isprint (*zCuvar_escape))
1164: sprintf (abescape, "\\%03o", (unsigned int) *zCuvar_escape);
1165: else
1166: {
1167: abescape[0] = *zCuvar_escape;
1168: abescape[1] = '\0';
1169: }
1170: ulog (LOG_ERROR, "%s: unknown variable (%sv lists variables)",
1171: argv[0], abescape);
1172: return UUCONF_CMDTABRET_CONTINUE;
1173: }
1174:
1175: /* List all the variables with their values. */
1176:
1177: static void
1178: uculist_vars ()
1179: {
1180: const struct uuconf_cmdtab *q;
1181: char abbuf[100];
1182:
1183: ucuputs ("");
1184: for (q = asCuvars; q->uuconf_zcmd != NULL; q++)
1185: {
1186: switch (UUCONF_TTYPE_CMDTABTYPE (q->uuconf_itype))
1187: {
1188: case UUCONF_TTYPE_CMDTABTYPE (UUCONF_CMDTABTYPE_BOOLEAN):
1189: if (*(boolean *) q->uuconf_pvar)
1190: sprintf (abbuf, "%s true", q->uuconf_zcmd);
1191: else
1192: sprintf (abbuf, "%s false", q->uuconf_zcmd);
1193: break;
1194:
1195: case UUCONF_TTYPE_CMDTABTYPE (UUCONF_CMDTABTYPE_INT):
1196: sprintf (abbuf, "%s %d", q->uuconf_zcmd, *(int *) q->uuconf_pvar);
1197: break;
1198:
1199: case UUCONF_TTYPE_CMDTABTYPE (UUCONF_CMDTABTYPE_LONG):
1200: sprintf (abbuf, "%s %ld", q->uuconf_zcmd,
1201: *(long *) q->uuconf_pvar);
1202: break;
1203:
1204: case UUCONF_TTYPE_CMDTABTYPE (UUCONF_CMDTABTYPE_STRING):
1205: case UUCONF_TTYPE_CMDTABTYPE (UUCONF_CMDTABTYPE_FULLSTRING):
1206: {
1207: const char *z;
1208: char abchar[5];
1209: size_t clen;
1210:
1211: sprintf (abbuf, "%s ", q->uuconf_zcmd);
1212: clen = strlen (abbuf);
1213: for (z = *(const char **) q->uuconf_pvar; *z != '\0'; z++)
1214: {
1215: int cchar;
1216:
1217: if (! isprint (*z))
1218: {
1219: sprintf (abchar, "\\%03o", (unsigned int) *z);
1220: cchar = 4;
1221: }
1222: else
1223: {
1224: abchar[0] = *z;
1225: abchar[1] = '\0';
1226: cchar = 1;
1227: }
1228: if (clen + cchar < sizeof (abbuf))
1229: strcat (abbuf, abchar);
1230: clen += cchar;
1231: }
1232: }
1233: break;
1234:
1235: default:
1236: sprintf (abbuf, "%s [unprintable type]", q->uuconf_zcmd);
1237: break;
1238: }
1239:
1240: ucuputs (abbuf);
1241: }
1242: }
1243:
1244: /* Subcommands. These are commands that begin with ~%. */
1245:
1246: /* This variable is only used so that we can pass a non-NULL address
1247: in pvar. It is never assigned to or examined. */
1248:
1249: static char bCutype;
1250:
1251: /* The command table for the subcommands. */
1252:
1253: static int icubreak P((pointer puuconf, int argc, char **argv, pointer pvar,
1254: pointer pinfo));
1255: static int icudebug P((pointer puuconf, int argc, char **argv, pointer pvar,
1256: pointer pinfo));
1257: static int icuchdir P((pointer puuconf, int argc, char **argv, pointer pvar,
1258: pointer pinfo));
1259: static int icuput P((pointer puuconf, int argc, char **argv, pointer pvar,
1260: pointer pinfo));
1261: static int icutake P((pointer puuconf, int argc, char **argv, pointer pvar,
1262: pointer pinfo));
1263: static int icunostop P((pointer puuconf, int argc, char **argv, pointer pvar,
1264: pointer pinfo));
1265:
1266: static const struct uuconf_cmdtab asCucmds[] =
1267: {
1268: { "break", UUCONF_CMDTABTYPE_FN | 1, NULL, icubreak },
1269: { "b", UUCONF_CMDTABTYPE_FN | 1, NULL, icubreak },
1270: { "cd", UUCONF_CMDTABTYPE_FN | 0, NULL, icuchdir },
1271: { "d", UUCONF_CMDTABTYPE_FN | 1, NULL, icudebug },
1272: { "put", UUCONF_CMDTABTYPE_FN | 0, NULL, icuput },
1273: { "take", UUCONF_CMDTABTYPE_FN | 0, NULL, icutake },
1274: { "nostop", UUCONF_CMDTABTYPE_FN | 1, NULL, icunostop },
1275: { "stop", UUCONF_CMDTABTYPE_FN | 1, &bCutype, icunostop },
1276: { ">", UUCONF_CMDTABTYPE_FN | 0, &bCutype, icuput },
1277: { "<", UUCONF_CMDTABTYPE_FN | 0, &bCutype, icutake },
1278: { "p", UUCONF_CMDTABTYPE_FN | 0, NULL, icuput },
1279: { "t", UUCONF_CMDTABTYPE_FN | 0, NULL, icutake },
1280: { NULL, 0, NULL, NULL }
1281: };
1282:
1283: /* Do a subcommand. This is called by commands beginning with ~%. */
1284:
1285: static boolean
1286: fcudo_subcmd (puuconf, qconn, zline)
1287: pointer puuconf;
1288: struct sconnection *qconn;
1289: char *zline;
1290: {
1291: char *azargs[3];
1292: int iarg;
1293: int iuuconf;
1294:
1295: for (iarg = 0; iarg < 3; iarg++)
1296: {
1297: azargs[iarg] = strtok (iarg == 0 ? zline : (char *) NULL, " \t\n");
1298: if (azargs[iarg] == NULL)
1299: break;
1300: }
1301:
1302: if (iarg == 0)
1303: {
1304: ucuputs (abCuconnected);
1305: return TRUE;
1306: }
1307:
1308: iuuconf = uuconf_cmd_args (puuconf, iarg, azargs, asCucmds,
1309: (pointer) qconn, icuunrecogfn,
1310: 0, (pointer) NULL);
1311: if (iuuconf != UUCONF_SUCCESS)
1312: ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
1313:
1314: return TRUE;
1315: }
1316:
1317: /* Warn about an unknown function. */
1318:
1319: /*ARGSUSED*/
1320: static int
1321: icuunrecogfn (puuconf, argc, argv, pvar, pinfo)
1322: pointer puuconf;
1323: int argc;
1324: char **argv;
1325: pointer pvar;
1326: pointer pinfo;
1327: {
1328: char abescape[5];
1329:
1330: if (! isprint (*zCuvar_escape))
1331: sprintf (abescape, "\\%03o", (unsigned int) *zCuvar_escape);
1332: else
1333: {
1334: abescape[0] = *zCuvar_escape;
1335: abescape[1] = '\0';
1336: }
1337: if (argv[0][0] == '?')
1338: uculist_fns (abescape);
1339: else
1340: ulog (LOG_ERROR, "%s: unknown (%s%%? lists choices)",
1341: argv[0], abescape);
1342: return UUCONF_CMDTABRET_CONTINUE;
1343: }
1344:
1345: /* Send a break. */
1346:
1347: /*ARGSUSED*/
1348: static int
1349: icubreak (puuconf, argc, argv, pvar, pinfo)
1350: pointer puuconf;
1351: int argc;
1352: char **argv;
1353: pointer pvar;
1354: pointer pinfo;
1355: {
1356: struct sconnection *qconn = (struct sconnection *) pinfo;
1357:
1358: if (! fconn_break (qconn))
1359: ucuabort ();
1360: return UUCONF_CMDTABRET_CONTINUE;
1361: }
1362:
1363: /* Change directories. */
1364:
1365: /*ARGSUSED*/
1366: static int
1367: icuchdir (puuconf, argc, argv, pvar, pinfo)
1368: pointer puuconf;
1369: int argc;
1370: char **argv;
1371: pointer pvar;
1372: pointer pinfo;
1373: {
1374: const char *zarg;
1375:
1376: if (argc <= 1)
1377: zarg = NULL;
1378: else
1379: zarg = argv[1];
1380: (void) fsysdep_chdir (zarg);
1381: return UUCONF_CMDTABRET_CONTINUE;
1382: }
1383:
1384: /* Toggle debugging. */
1385:
1386: /*ARGSUSED*/
1387: static int
1388: icudebug (puuconf, argc, argv, pvar, pinfo)
1389: pointer puuconf;
1390: int argc;
1391: char **argv;
1392: pointer pvar;
1393: pointer pinfo;
1394: {
1395: #if DEBUG > 1
1396: if (iDebug != 0)
1397: iDebug = 0;
1398: else
1399: iDebug = DEBUG_MAX;
1400: #else
1401: ucuputs ("[compiled without debugging]");
1402: #endif
1403: return UUCONF_CMDTABRET_CONTINUE;
1404: }
1405:
1406: /* Control whether the port does xon/xoff handshaking. If pvar is not
1407: NULL, this is "stop"; otherwise it is "nostop". */
1408:
1409: /*ARGSUSED*/
1410: static int
1411: icunostop (puuconf, argc, argv, pvar, pinfo)
1412: pointer puuconf;
1413: int argc;
1414: char **argv;
1415: pointer pvar;
1416: pointer pinfo;
1417: {
1418: struct sconnection *qconn = (struct sconnection *) pinfo;
1419:
1420: if (! fconn_set (qconn, PARITYSETTING_DEFAULT, STRIPSETTING_DEFAULT,
1421: pvar == NULL ? XONXOFF_OFF : XONXOFF_ON))
1422: ucuabort ();
1423: return UUCONF_CMDTABRET_CONTINUE;
1424: }
1425:
1426: /* Send a file to the remote system. The first argument is the file
1427: to send. If that argument is not present, it is prompted for. The
1428: second argument is to file name to use on the remote system. If
1429: that argument is not present, the basename of the local filename is
1430: used. If pvar is not NULL, then this is ~>, which is used to send
1431: a command to a non-Unix system. We treat is the same as ~%put,
1432: except that we assume the user has already entered the appropriate
1433: command (for ~%put, we force ``cat >to'' to the other side). */
1434:
1435: /*ARGSUSED*/
1436: static int
1437: icuput (puuconf, argc, argv, pvar, pinfo)
1438: pointer puuconf;
1439: int argc;
1440: char **argv;
1441: pointer pvar;
1442: pointer pinfo;
1443: {
1444: struct sconnection *qconn = (struct sconnection *) pinfo;
1445: char *zfrom;
1446: char *zto = NULL;
1447: char *zalc;
1448: openfile_t e;
1449: int cline;
1450: char *zbuf;
1451: size_t cbuf;
1452:
1453: if (argc > 1)
1454: zfrom = zbufcpy (argv[1]);
1455: else
1456: {
1457: zfrom = zsysdep_terminal_line ("File to send: ");
1458: if (zfrom == NULL)
1459: ucuabort ();
1460: zfrom[strcspn (zfrom, " \t\n")] = '\0';
1461:
1462: if (*zfrom == '\0')
1463: {
1464: ubuffree (zfrom);
1465: ucuputs (abCuconnected);
1466: return UUCONF_CMDTABRET_CONTINUE;
1467: }
1468: }
1469:
1470: if (pvar == NULL)
1471: {
1472: if (argc > 2)
1473: zto = zbufcpy (argv[2]);
1474: else
1475: {
1476: char *zbase;
1477: char *zprompt;
1478:
1479: zbase = zsysdep_base_name (zfrom);
1480: if (zbase == NULL)
1481: ucuabort ();
1482:
1483: zprompt = zbufalc (sizeof "Remote file name []: " +
1484: strlen (zbase));
1485: sprintf (zprompt, "Remote file name [%s]: ", zbase);
1486: zto = zsysdep_terminal_line (zprompt);
1487: ubuffree (zprompt);
1488: if (zto == NULL)
1489: ucuabort ();
1490:
1491: zto[strcspn (zto, " \t\n")] = '\0';
1492: if (*zto != '\0')
1493: ubuffree (zbase);
1494: else
1495: {
1496: ubuffree (zto);
1497: zto = zbase;
1498: }
1499: }
1500: }
1501:
1502: e = esysdep_user_fopen (zfrom, TRUE, fCuvar_binary);
1503: if (! ffileisopen (e))
1504: {
1505: const char *zerrstr;
1506:
1507: if (pvar == NULL)
1508: ubuffree (zto);
1509: zerrstr = strerror (errno);
1510: zalc = zbufalc (strlen (zfrom) + sizeof ": " + strlen (zerrstr));
1511: sprintf (zalc, "%s: %s", zfrom, zerrstr);
1512: ubuffree (zfrom);
1513: ucuputs (zalc);
1514: ubuffree (zalc);
1515: ucuputs (abCuconnected);
1516: return UUCONF_CMDTABRET_CONTINUE;
1517: }
1518:
1519: ubuffree (zfrom);
1520:
1521: /* Tell the system dependent layer to stop copying data from the
1522: port to the terminal. We want to read the echoes ourself. Also
1523: permit the local user to generate signals. */
1524: if (! fsysdep_cu_copy (FALSE)
1525: || ! fsysdep_terminal_signals (TRUE))
1526: ucuabort ();
1527:
1528: /* If pvar is NULL, then we are sending a file to a Unix system. We
1529: send over the command "cat > TO" to prepare it to receive. If
1530: pvar is not NULL, the user is assumed to have set up whatever
1531: action was needed to receive the file. */
1532: if (pvar == NULL)
1533: {
1534: boolean fret;
1535:
1536: zalc = zbufalc (sizeof "cat > \n" + strlen (zto));
1537: sprintf (zalc, "cat > %s\n", zto);
1538: ubuffree (zto);
1539: fret = fcusend_buf (qconn, zalc, strlen (zalc));
1540: ubuffree (zalc);
1541: if (! fret)
1542: {
1543: (void) ffileclose (e);
1544: if (! fsysdep_cu_copy (TRUE)
1545: || ! fsysdep_terminal_signals (FALSE))
1546: ucuabort ();
1547: ucuputs (abCuconnected);
1548: return UUCONF_CMDTABRET_CONTINUE;
1549: }
1550: }
1551:
1552: cline = 0;
1553:
1554: zbuf = NULL;
1555: cbuf = 0;
1556:
1557: while (TRUE)
1558: {
1559: char abbuf[512];
1560: size_t c;
1561:
1562: #if USE_STDIO
1563: if (fCuvar_binary)
1564: #endif
1565: {
1566: if (ffileeof (e))
1567: break;
1568: c = cfileread (e, abbuf, sizeof abbuf);
1569: if (ffilereaderror (e, c))
1570: {
1571: ucuputs ("[file read error]");
1572: break;
1573: }
1574: if (c == 0)
1575: break;
1576: zbuf = abbuf;
1577: }
1578: #if USE_STDIO
1579: else
1580: {
1581: if (getline (&zbuf, &cbuf, e) <= 0)
1582: {
1583: xfree ((pointer) zbuf);
1584: break;
1585: }
1586: c = strlen (zbuf);
1587: }
1588: #endif
1589:
1590: if (fCuvar_verbose)
1591: {
1592: ++cline;
1593: printf ("%d ", cline);
1594: (void) fflush (stdout);
1595: }
1596:
1597: if (! fcusend_buf (qconn, zbuf, c))
1598: {
1599: if (! fCuvar_binary)
1600: xfree ((pointer) zbuf);
1601: (void) fclose (e);
1602: if (! fsysdep_cu_copy (TRUE)
1603: || ! fsysdep_terminal_signals (FALSE))
1604: ucuabort ();
1605: ucuputs (abCuconnected);
1606: return UUCONF_CMDTABRET_CONTINUE;
1607: }
1608: }
1609:
1610: (void) ffileclose (e);
1611:
1612: if (pvar == NULL)
1613: {
1614: char beof;
1615:
1616: beof = '\004';
1617: if (! fconn_write (qconn, &beof, 1))
1618: ucuabort ();
1619: }
1620: else
1621: {
1622: if (*zCuvar_eofwrite != '\0')
1623: {
1624: if (! fconn_write (qconn, zCuvar_eofwrite,
1625: strlen (zCuvar_eofwrite)))
1626: ucuabort ();
1627: }
1628: }
1629:
1630: if (fCuvar_verbose)
1631: ucuputs ("");
1632:
1633: ucuputs ("[file transfer complete]");
1634:
1635: if (! fsysdep_cu_copy (TRUE)
1636: || ! fsysdep_terminal_signals (FALSE))
1637: ucuabort ();
1638:
1639: ucuputs (abCuconnected);
1640: return UUCONF_CMDTABRET_CONTINUE;
1641: }
1642:
1643: /* Get a file from the remote side. This is ~%take, or ~t, or ~<.
1644: The first two are assumed to be taking the file from a Unix system,
1645: so we force the command "cat FROM; echo */
1646:
1647: /*ARGSUSED*/
1648: static int
1649: icutake (puuconf, argc, argv, pvar, pinfo)
1650: pointer puuconf;
1651: int argc;
1652: char **argv;
1653: pointer pvar;
1654: pointer pinfo;
1655: {
1656: struct sconnection *qconn = (struct sconnection *) pinfo;
1657: const char *zeof;
1658: char *zfrom, *zto, *zcmd;
1659: char *zalc;
1660: openfile_t e;
1661: char bcr;
1662: size_t ceoflen;
1663: char *zlook = NULL;
1664: size_t ceofhave;
1665: boolean ferr;
1666:
1667: if (argc > 1)
1668: zfrom = zbufcpy (argv[1]);
1669: else
1670: {
1671: zfrom = zsysdep_terminal_line ("Remote file to retreive: ");
1672: if (zfrom == NULL)
1673: ucuabort ();
1674: zfrom[strcspn (zfrom, " \t\n")] = '\0';
1675: if (*zfrom == '\0')
1676: {
1677: ubuffree (zfrom);
1678: ucuputs (abCuconnected);
1679: return UUCONF_CMDTABRET_CONTINUE;
1680: }
1681: }
1682:
1683: if (argc > 2)
1684: zto = zbufcpy (argv[2]);
1685: else
1686: {
1687: char *zbase;
1688: char *zprompt;
1689:
1690: zbase = zsysdep_base_name (zfrom);
1691: if (zbase == NULL)
1692: ucuabort ();
1693:
1694: zprompt = zbufalc (sizeof "Local file name []: " + strlen (zbase));
1695: sprintf (zprompt, "Local file name [%s]: ", zbase);
1696: zto = zsysdep_terminal_line (zprompt);
1697: ubuffree (zprompt);
1698: if (zto == NULL)
1699: ucuabort ();
1700:
1701: zto[strcspn (zto, " \t\n")] = '\0';
1702: if (*zto != '\0')
1703: ubuffree (zbase);
1704: else
1705: {
1706: ubuffree (zto);
1707: zto = zbase;
1708: }
1709: }
1710:
1711: if (pvar != NULL)
1712: {
1713: zcmd = zsysdep_terminal_line ("Remote command to execute: ");
1714: if (zcmd == NULL)
1715: ucuabort ();
1716: zcmd[strcspn (zcmd, "\n")] = '\0';
1717: zeof = zCuvar_eofread;
1718: }
1719: else
1720: {
1721: zcmd = zbufalc (sizeof "cat ; echo; echo ////cuend////"
1722: + strlen (zfrom));
1723: sprintf (zcmd, "cat %s; echo; echo ////cuend////", zfrom);
1724: zeof = "\n////cuend////\n";
1725: }
1726:
1727: ubuffree (zfrom);
1728:
1729: e = esysdep_user_fopen (zto, FALSE, fCuvar_binary);
1730: if (! ffileisopen (e))
1731: {
1732: const char *zerrstr;
1733:
1734: ubuffree (zcmd);
1735: zerrstr = strerror (errno);
1736: zalc = zbufalc (strlen (zto) + sizeof ": " + strlen (zerrstr));
1737: sprintf (zalc, "%s: %s\n", zto, zerrstr);
1738: ucuputs (zalc);
1739: ubuffree (zalc);
1740: ucuputs (abCuconnected);
1741: ubuffree (zto);
1742: return UUCONF_CMDTABRET_CONTINUE;
1743: }
1744:
1745: ubuffree (zto);
1746:
1747: if (! fsysdep_cu_copy (FALSE)
1748: || ! fsysdep_terminal_signals (TRUE))
1749: ucuabort ();
1750:
1751: if (! fconn_write (qconn, zcmd, strlen (zcmd)))
1752: ucuabort ();
1753: bcr = '\r';
1754: if (! fconn_write (qconn, &bcr, 1))
1755: ucuabort ();
1756:
1757: ubuffree (zcmd);
1758:
1759: /* Eliminated any previously echoed data to avoid confusion. */
1760: iPrecstart = 0;
1761: iPrecend = 0;
1762:
1763: /* If we're dealing with a Unix system, we can reliably discard the
1764: command. Otherwise, the command will probably wind up in the
1765: file; too bad. */
1766: if (pvar == NULL)
1767: {
1768: int b;
1769:
1770: while ((b = breceive_char (qconn, cCuvar_timeout, TRUE)) != '\n')
1771: {
1772: if (b == -2)
1773: ucuabort ();
1774: if (b < 0)
1775: {
1776: ucuputs ("[timed out waiting for newline]");
1777: ucuputs (abCuconnected);
1778: return UUCONF_CMDTABRET_CONTINUE;
1779: }
1780: }
1781: }
1782:
1783: ceoflen = strlen (zeof);
1784: zlook = zbufalc (ceoflen);
1785: ceofhave = 0;
1786: ferr = FALSE;
1787:
1788: while (TRUE)
1789: {
1790: int b;
1791:
1792: if (FGOT_SIGNAL ())
1793: {
1794: /* Make sure the signal is logged. */
1795: ulog (LOG_ERROR, (const char *) NULL);
1796: ucuputs ("[file receive aborted]");
1797: /* Reset the SIGINT flag so that it does not confuse us in
1798: the future. */
1799: afSignal[INDEXSIG_SIGINT] = FALSE;
1800: break;
1801: }
1802:
1803: b = breceive_char (qconn, cCuvar_timeout, TRUE);
1804: if (b == -2)
1805: ucuabort ();
1806: if (b < 0)
1807: {
1808: if (ceofhave > 0)
1809: (void) fwrite (zlook, sizeof (char), ceofhave, e);
1810: ucuputs ("[timed out]");
1811: break;
1812: }
1813:
1814: if (ceoflen == 0)
1815: {
1816: if (cfilewrite (e, &b, 1) != 1)
1817: {
1818: ferr = TRUE;
1819: break;
1820: }
1821: }
1822: else
1823: {
1824: zlook[ceofhave] = b;
1825: ++ceofhave;
1826: if (ceofhave == ceoflen)
1827: {
1828: size_t cmove;
1829: char *zmove;
1830:
1831: if (memcmp (zeof, zlook, ceoflen) == 0)
1832: {
1833: ucuputs ("[file transfer complete]");
1834: break;
1835: }
1836:
1837: if (cfilewrite (e, zlook, 1) != 1)
1838: {
1839: ferr = TRUE;
1840: break;
1841: }
1842:
1843: zmove = zlook;
1844: for (cmove = ceoflen - 1, zmove = zlook;
1845: cmove > 0;
1846: cmove--, zmove++)
1847: zmove[0] = zmove[1];
1848:
1849: --ceofhave;
1850: }
1851: }
1852: }
1853:
1854: ubuffree (zlook);
1855:
1856: if (! ffileclose (e))
1857: ferr = TRUE;
1858: if (ferr)
1859: ucuputs ("[file write error]");
1860:
1861: if (! fsysdep_cu_copy (TRUE)
1862: || ! fsysdep_terminal_signals (FALSE))
1863: ucuabort ();
1864:
1865: ucuputs (abCuconnected);
1866:
1867: return UUCONF_CMDTABRET_CONTINUE;
1868: }
1869:
1870: /* Send a buffer to the remote system. If fCuvar_binary is FALSE,
1871: each buffer passed in will be a single line; in this case we can
1872: check the echoed characters and kill the line if they do not match.
1873: This returns FALSE if an echo check fails. If a port error
1874: occurrs, it calls ucuabort. */
1875:
1876: static boolean
1877: fcusend_buf (qconn, zbufarg, cbufarg)
1878: struct sconnection *qconn;
1879: const char *zbufarg;
1880: size_t cbufarg;
1881: {
1882: const char *zbuf;
1883: size_t cbuf;
1884: int ctries;
1885: size_t cbplen;
1886: char *zsendbuf;
1887:
1888: zbuf = zbufarg;
1889: cbuf = cbufarg;
1890: ctries = 0;
1891:
1892: if (fCuvar_binary)
1893: cbplen = strlen (zCuvar_binary_prefix);
1894: else
1895: cbplen = 1;
1896: zsendbuf = zbufalc (64 * (cbplen + 1));
1897:
1898: /* Loop while we still have characters to send. The value of cbuf
1899: will be reset to cbufarg if an echo failure occurs while sending
1900: a line in non-binary mode. */
1901: while (cbuf > 0)
1902: {
1903: int csend;
1904: char *zput;
1905: const char *zget;
1906: boolean fnl;
1907: int i;
1908:
1909: if (FGOT_SIGNAL ())
1910: {
1911: /* Make sure the signal is logged. */
1912: ubuffree (zsendbuf);
1913: ulog (LOG_ERROR, (const char *) NULL);
1914: ucuputs ("[file send aborted]");
1915: /* Reset the SIGINT flag so that it does not confuse us in
1916: the future. */
1917: afSignal[INDEXSIG_SIGINT] = FALSE;
1918: return FALSE;
1919: }
1920:
1921: /* Discard anything we've read from the port up to now, to avoid
1922: confusing the echo checking. */
1923: iPrecstart = 0;
1924: iPrecend = 0;
1925:
1926: /* Send all characters up to a newline before actually sending
1927: the newline. This makes it easier to handle the special
1928: newline echo checking. Send up to 64 characters at a time
1929: before doing echo checking. */
1930: if (*zbuf == '\n')
1931: csend = 1;
1932: else
1933: {
1934: const char *znl;
1935:
1936: znl = memchr (zbuf, '\n', cbuf);
1937: if (znl == NULL)
1938: csend = cbuf;
1939: else
1940: csend = znl - zbuf;
1941: if (csend > 64)
1942: csend = 64;
1943: }
1944:
1945: /* Translate this part of the buffer. If we are not in binary
1946: mode, we translate \n to \r, and ignore any nonprintable
1947: characters. */
1948: zput = zsendbuf;
1949: fnl = FALSE;
1950: for (i = 0, zget = zbuf; i < csend; i++, zget++)
1951: {
1952: if (isprint (*zget)
1953: || *zget == '\t')
1954: *zput++ = *zget;
1955: else if (*zget == '\n')
1956: {
1957: if (fCuvar_binary)
1958: *zput++ = '\n';
1959: else
1960: *zput++ = '\r';
1961: fnl = TRUE;
1962: }
1963: else if (fCuvar_binary)
1964: {
1965: strcpy (zput, zCuvar_binary_prefix);
1966: zput += cbplen;
1967: *zput++ = *zget;
1968: }
1969: }
1970:
1971: zbuf += csend;
1972: cbuf -= csend;
1973:
1974: if (zput == zsendbuf)
1975: continue;
1976:
1977: /* Send the data over the port. */
1978: if (! fsend_data (qconn, zsendbuf, (size_t) (zput - zsendbuf), TRUE))
1979: ucuabort ();
1980:
1981: /* We do echo checking if requested, unless we are in binary
1982: mode. Echo checking of a newline is different from checking
1983: of normal characters; when we send a newline we look for
1984: *zCuvar_echonl. */
1985: if ((fCuvar_echocheck && ! fCuvar_binary)
1986: || (fnl && *zCuvar_echonl != '\0'))
1987: {
1988: long iend;
1989:
1990: iend = ixsysdep_time ((long *) NULL) + (long) cCuvar_timeout;
1991: for (zget = zsendbuf; zget < zput; zget++)
1992: {
1993: int bread;
1994: int bwant;
1995:
1996: if (fCuvar_binary ? *zget == '\n' : *zget == '\r')
1997: {
1998: bwant = *zCuvar_echonl;
1999: if (bwant == '\0')
2000: continue;
2001: }
2002: else
2003: {
2004: if (! fCuvar_echocheck || ! isprint (*zget))
2005: continue;
2006: bwant = *zget;
2007: }
2008:
2009: do
2010: {
2011: if (FGOT_SIGNAL ())
2012: {
2013: /* Make sure the signal is logged. */
2014: ubuffree (zsendbuf);
2015: ulog (LOG_ERROR, (const char *) NULL);
2016: ucuputs ("[file send aborted]");
2017: /* Reset the SIGINT flag so that it does not
2018: confuse us in the future. */
2019: afSignal[INDEXSIG_SIGINT] = FALSE;
2020: return FALSE;
2021: }
2022:
2023: bread = breceive_char (qconn,
2024: iend - ixsysdep_time ((long *) NULL),
2025: TRUE);
2026: if (bread < 0)
2027: {
2028: if (bread == -2)
2029: ucuabort ();
2030:
2031: /* If we timed out, and we're not in binary
2032: mode, we kill the line and try sending it
2033: again from the beginning. */
2034: if (! fCuvar_binary && *zCuvar_kill != '\0')
2035: {
2036: ++ctries;
2037: if (ctries < cCuvar_resend)
2038: {
2039: if (fCuvar_verbose)
2040: {
2041: printf ("R ");
2042: (void) fflush (stdout);
2043: }
2044: if (! fsend_data (qconn, zCuvar_kill, 1,
2045: TRUE))
2046: ucuabort ();
2047: zbuf = zbufarg;
2048: cbuf = cbufarg;
2049: break;
2050: }
2051: }
2052: ubuffree (zsendbuf);
2053: ucuputs ("[timed out looking for echo]");
2054: return FALSE;
2055: }
2056: }
2057: while (bread != *zget);
2058:
2059: if (bread < 0)
2060: break;
2061: }
2062: }
2063: }
2064:
2065: ubuffree (zsendbuf);
2066:
2067: return TRUE;
2068: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.