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