home *** CD-ROM | disk | FTP | other *** search
/ OpenStep 4.2J (Developer) / os42jdev.iso / NextDeveloper / Source / GNU / uucp / Uucp.framework / chat.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-08-20  |  32.1 KB  |  1,467 lines
  1. /* chat.c
  2.    Chat routine for the UUCP package.
  3.  
  4.    Copyright (C) 1991, 1992, 1993, 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 chat_rcsid[] = "$Id: chat.c,v 1.46 1995/06/21 19:14:29 ian Rel $";
  30. #endif
  31.  
  32. #include <ctype.h>
  33. #include <errno.h>
  34.  
  35. #include "uudefs.h"
  36. #include "uuconf.h"
  37. #include "conn.h"
  38. #include "prot.h"
  39. #include "system.h"
  40.  
  41. /* Local functions.  */
  42.  
  43. static int icexpect P((struct sconnection *qconn, int cstrings,
  44.                char **azstrings, size_t *aclens,
  45.                int ctimeout, boolean fstrip));
  46. static boolean fcsend P((struct sconnection *qconn, pointer puuconf,
  47.              const char *zsend,
  48.              const struct uuconf_system *qsys,
  49.              const struct uuconf_dialer *qdial,
  50.              const char *zphone,
  51.              boolean ftranslate, boolean fstrip));
  52. static boolean fcecho_send_strip P((struct sconnection *qconn,
  53.                     const char *z, size_t clen));
  54. static boolean fcecho_send_nostrip P((struct sconnection  *qconn,
  55.                       const char *z, size_t clen));
  56. static boolean fcecho_send P((struct sconnection *qconn, const char *z,
  57.                   size_t clen, boolean fstrip));
  58. static boolean fcphone P((struct sconnection *qconn,
  59.               pointer puuconf,
  60.               const struct uuconf_dialer *qdial,
  61.               const char *zphone,
  62.               boolean (*pfwrite) P((struct sconnection *qc,
  63.                         const char *zwrite,
  64.                         size_t cwrite)),
  65.               boolean ftranslate, boolean *pfquote));
  66. static boolean fctranslate P((pointer puuconf, const char *zphone,
  67.                   const char **pzprefix,
  68.                   const char **pzsuffix));
  69. static boolean fcprogram P((struct sconnection *qconn, pointer puuconf,
  70.                 char **pzprogram,
  71.                 const struct uuconf_system *qsys,
  72.                 const struct uuconf_dialer *qdial,
  73.                 const char *zphone, const char *zport,
  74.                 long ibaud));
  75.  
  76. /* Run a chat script with the other system.  The chat script is a
  77.    series of expect send pairs.  We wait for the expect string to show
  78.    up, and then we send the send string.  The chat string for a system
  79.    holds the expect and send strings separated by a single space.  */
  80.  
  81. boolean
  82. fchat (qconn, puuconf, qchat, qsys, qdial, zphone, ftranslate, zport, ibaud)
  83.      struct sconnection *qconn;
  84.      pointer puuconf;
  85.      const struct uuconf_chat *qchat;
  86.      const struct uuconf_system *qsys;
  87.      const struct uuconf_dialer *qdial;
  88.      const char *zphone;
  89.      boolean ftranslate;
  90.      const char *zport;
  91.      long ibaud;
  92. {
  93.   int cstrings;
  94.   char **azstrings;
  95.   size_t *aclens;
  96.   char **pzchat;
  97.   char *zbuf;
  98.   size_t cbuflen;
  99.   boolean fret;
  100.   int i;
  101.  
  102.   /* First run the program, if any.  */
  103.   if (qchat->uuconf_pzprogram != NULL)
  104.     {
  105.       if (! fcprogram (qconn, puuconf, qchat->uuconf_pzprogram, qsys, qdial,
  106.                zphone, zport, ibaud))
  107.     return FALSE;
  108.     }
  109.  
  110.   /* If there's no chat script, we're done.  */
  111.   if (qchat->uuconf_pzchat == NULL)
  112.     return TRUE;
  113.  
  114.   if (qchat->uuconf_pzfail == NULL)
  115.     {
  116.       cstrings = 1;
  117.       azstrings = (char **) xmalloc (sizeof (char *));
  118.       aclens = (size_t *) xmalloc (sizeof (size_t));
  119.     }
  120.   else
  121.     {
  122.       char **pz;
  123.  
  124.       /* We leave string number 0 for the chat script.  */
  125.       cstrings = 1;
  126.       for (pz = qchat->uuconf_pzfail; *pz != NULL; pz++)
  127.     ++cstrings;
  128.  
  129.       azstrings = (char **) xmalloc (cstrings * sizeof (char *));
  130.       aclens = (size_t *) xmalloc (cstrings * sizeof (size_t));
  131.  
  132.       /* Get the strings into the array, and handle all the escape
  133.      characters.  */
  134.       for (cstrings = 1, pz = qchat->uuconf_pzfail;
  135.        *pz != NULL;
  136.        cstrings++, pz++)
  137.     {
  138.       azstrings[cstrings] = zbufcpy (*pz);
  139.       aclens[cstrings] = cescape (azstrings[cstrings]);
  140.     }
  141.     }
  142.  
  143.   cbuflen = 0;
  144.   zbuf = NULL;
  145.   fret = TRUE;
  146.  
  147.   pzchat = qchat->uuconf_pzchat;
  148.  
  149.   while (*pzchat != NULL)
  150.     {
  151.       size_t clen;
  152.  
  153.       /* Loop over subexpects and subsends.  */
  154.       while (TRUE)
  155.     {
  156.       char *ztimeout;
  157.       int ctimeout;
  158.  
  159.       /* Copy the expect string into the buffer so that we can
  160.          modify it in cescape.  */
  161.       clen = strlen (*pzchat);
  162.       if (clen >= cbuflen)
  163.         {
  164.           ubuffree (zbuf);
  165.           zbuf = zbufalc (clen + 1);
  166.           cbuflen = clen;
  167.         }
  168.       memcpy (zbuf, *pzchat, clen + 1);
  169.  
  170.       azstrings[0] = zbuf;
  171.       if (azstrings[0][0] == '-')
  172.         ++azstrings[0];
  173.  
  174.       /* \Wnum at the end of the string is a timeout.  */
  175.       ctimeout = qchat->uuconf_ctimeout;
  176.       ztimeout = strrchr (azstrings[0], '\\');
  177.       if (ztimeout != NULL && ztimeout[1] == 'W')
  178.         {
  179.           char *zend;
  180.           int cval;
  181.  
  182.           cval = (int) strtol (ztimeout + 2, &zend, 10);
  183.           if (zend != ztimeout + 2 && *zend == '\0')
  184.         {
  185.           ctimeout = cval;
  186.           *ztimeout = '\0';
  187.         }
  188.         }
  189.  
  190.       aclens[0] = cescape (azstrings[0]);
  191.  
  192.       if (aclens[0] == 0
  193.           || (aclens[0] == 2
  194.           && strcmp (azstrings[0], "\"\"") == 0))
  195.         {
  196.           /* There is no subexpect sequence.  If there is a
  197.          subsend sequence we move on to it.  Otherwise we let
  198.          this expect succeed.  This is somewhat inconsistent,
  199.          but it seems to be the traditional approach.  */
  200.           if (pzchat[1] == NULL || pzchat[1][0] != '-')
  201.         break;
  202.         }
  203.       else
  204.         {
  205.           int istr;
  206.  
  207.           istr = icexpect (qconn, cstrings, azstrings, aclens,
  208.                    ctimeout, qchat->uuconf_fstrip);
  209.  
  210.           /* If we found the string, break out of the
  211.          subexpect/subsend loop.  */
  212.           if (istr == 0)
  213.         break;
  214.  
  215.           /* If we got an error, return FALSE.  */
  216.           if (istr < -1)
  217.         {
  218.           fret = FALSE;
  219.           break;
  220.         }
  221.  
  222.           /* If we found a failure string, log it and get out.  */
  223.           if (istr > 0)
  224.         {
  225.           ulog (LOG_ERROR, "Chat script failed: Got \"%s\"",
  226.             qchat->uuconf_pzfail[istr - 1]);
  227.           fret = FALSE;
  228.           break;
  229.         }
  230.  
  231.           /* We timed out; look for a send subsequence.  If none,
  232.          the chat script has failed.  */
  233.           if (pzchat[1] == NULL || pzchat[1][0] != '-')
  234.         {
  235.           ulog (LOG_ERROR, "Timed out in chat script");
  236.           fret = FALSE;
  237.           break;
  238.         }
  239.         }
  240.  
  241.       /* Send the send subsequence without the leading '-'.  A
  242.          \"\" will send nothing.  An empty string will send a
  243.          carriage return.  */
  244.       ++pzchat;
  245.       if (! fcsend (qconn, puuconf, *pzchat + 1, qsys, qdial, zphone,
  246.             ftranslate, qchat->uuconf_fstrip))
  247.         {
  248.           fret = FALSE;
  249.           break;
  250.         }
  251.  
  252.       /* If there is no expect subsequence, we are done.  */
  253.       if (pzchat[1] == NULL || pzchat[1][0] != '-')
  254.         break;
  255.  
  256.       /* Move on to next expect subsequence.  */
  257.       ++pzchat;
  258.     }
  259.  
  260.       if (! fret)
  261.     break;
  262.  
  263.       /* Move on to the send string.  If there is none, we have
  264.      succeeded.  */
  265.       do
  266.     {
  267.       ++pzchat;
  268.     }
  269.       while (*pzchat != NULL && (*pzchat)[0] == '-');
  270.  
  271.       if (*pzchat == NULL)
  272.     break;
  273.  
  274.       if (**pzchat != '\0')
  275.     {
  276.       if (! fcsend (qconn, puuconf, *pzchat, qsys, qdial, zphone,
  277.             ftranslate, qchat->uuconf_fstrip))
  278.         {
  279.           fret = FALSE;
  280.           break;
  281.         }
  282.     }
  283.  
  284.       ++pzchat;
  285.     }
  286.  
  287.   ubuffree (zbuf);
  288.   for (i = 1; i < cstrings; i++)
  289.     ubuffree (azstrings[i]);
  290.   xfree ((pointer) azstrings);
  291.   xfree ((pointer) aclens);
  292.  
  293.   return fret;
  294. }
  295.  
  296. /* Read characters and wait for one of a set of memory strings to come
  297.    in.  This returns the index into the array of the string that
  298.    arrives, or -1 on timeout, or -2 on error.  */
  299.  
  300. static int
  301. icexpect (qconn, cstrings, azstrings, aclens, ctimeout, fstrip)
  302.      struct sconnection *qconn;
  303.      int cstrings;
  304.      char **azstrings;
  305.      size_t *aclens;
  306.      int ctimeout;
  307.      boolean fstrip;
  308. {
  309.   int i;
  310.   size_t cmax;
  311.   char *zhave;
  312.   size_t chave;
  313.   long iendtime;
  314. #if DEBUG > 1
  315.   int cchars;
  316.   int iolddebug;
  317. #endif
  318.  
  319.   cmax = aclens[0];
  320.   for (i = 1; i < cstrings; i++)
  321.     if (cmax < aclens[i])
  322.       cmax = aclens[i];
  323.  
  324.   zhave = zbufalc (cmax);
  325.   chave = 0;
  326.  
  327.   iendtime = ixsysdep_time ((long *) NULL) + ctimeout;
  328.  
  329. #if DEBUG > 1
  330.   cchars = 0;
  331.   iolddebug = iDebug;
  332.   if (FDEBUGGING (DEBUG_CHAT))
  333.     {
  334.       udebug_buffer ("icexpect: Looking for", azstrings[0],
  335.              aclens[0]);
  336.       ulog (LOG_DEBUG_START, "icexpect: Got \"");
  337.       iDebug &=~ (DEBUG_INCOMING | DEBUG_PORT);
  338.     }
  339. #endif
  340.  
  341.   while (TRUE)
  342.     {
  343.       int bchar;
  344.  
  345.       /* If we have no more time, get out.  */
  346.       if (ctimeout <= 0)
  347.     {
  348. #if DEBUG > 1
  349.       if (FDEBUGGING (DEBUG_CHAT))
  350.         {
  351.           ulog (LOG_DEBUG_END, "\" (timed out)");
  352.           iDebug = iolddebug;
  353.         }
  354. #endif
  355.       ubuffree (zhave);
  356.       return -1;
  357.     }
  358.  
  359.       /* Read one character at a time.  We could use a more complex
  360.      algorithm to read in larger batches, but it's probably not
  361.      worth it.  If the buffer is full, shift it left; we already
  362.      know that no string matches, and the buffer holds the largest
  363.      string, so this can't lose a match.  */
  364.       if (chave >= cmax)
  365.     {
  366.       size_t imove;
  367.  
  368.       for (imove = 0; imove < cmax - 1; imove++)
  369.         zhave[imove] = zhave[imove + 1];
  370.       --chave;
  371.     }
  372.  
  373.       /* The timeout/error return values from breceive_char are the
  374.      same as for this function.  */
  375.       bchar = breceive_char (qconn, ctimeout, TRUE);
  376.       if (bchar < 0)
  377.     {
  378. #if DEBUG > 1
  379.       if (FDEBUGGING (DEBUG_CHAT))
  380.         {
  381.           /* If there was an error, it will probably be logged in
  382.          the middle of our string, but this is only debugging
  383.          so it's not a big deal.  */
  384.           ulog (LOG_DEBUG_END, "\" (%s)",
  385.             bchar == -1 ? "timed out" : "error");
  386.           iDebug = iolddebug;
  387.         }
  388. #endif
  389.       ubuffree (zhave);
  390.       return bchar;
  391.     }
  392.  
  393.       /* Strip the parity bit if desired.  */
  394.       if (fstrip)
  395.     bchar &= 0x7f;
  396.  
  397.       zhave[chave] = (char) bchar;
  398.       ++chave;
  399.  
  400. #if DEBUG > 1
  401.       if (FDEBUGGING (DEBUG_CHAT))
  402.     {
  403.       char ab[5];
  404.  
  405.       ++cchars;
  406.       if (cchars > 60)
  407.         {
  408.           ulog (LOG_DEBUG_END, "\"");
  409.           ulog (LOG_DEBUG_START, "icexpect: Got \"");
  410.           cchars = 0;
  411.         }
  412.       (void) cdebug_char (ab, bchar);
  413.       ulog (LOG_DEBUG_CONTINUE, "%s", ab);
  414.     }
  415. #endif
  416.  
  417.       /* See if any of the strings can be found in the buffer.  Since
  418.      we read one character at a time, the string can only be found
  419.      at the end of the buffer.  */
  420.       for (i = 0; i < cstrings; i++)
  421.     {
  422.       if (aclens[i] <= chave
  423.           && memcmp (zhave + chave - aclens[i], azstrings[i],
  424.              aclens[i]) == 0)
  425.         {
  426. #if DEBUG > 1
  427.           if (FDEBUGGING (DEBUG_CHAT))
  428.         {
  429.           if (i == 0)
  430.             ulog (LOG_DEBUG_END, "\" (found it)");
  431.           else
  432.             {
  433.               ulog (LOG_DEBUG_END, "\"");
  434.               udebug_buffer ("icexpect: Found", azstrings[i],
  435.                      aclens[i]);
  436.             }
  437.           iDebug = iolddebug;
  438.         }
  439. #endif
  440.           ubuffree (zhave);
  441.           return i;
  442.         }
  443.     }
  444.  
  445.       ctimeout = (int) (iendtime - ixsysdep_time ((long *) NULL));
  446.     }
  447. }
  448.  
  449. #if DEBUG > 1
  450.  
  451. /* Debugging function for fcsend.  This takes the fquote variable, the
  452.    length of the string (0 if this an informational string which can
  453.    be printed directly) and the string itself.  It returns the new
  454.    value for fquote.  The fquote variable is TRUE if the debugging
  455.    output is in the middle of a quoted string.  */
  456.  
  457. static size_t cCsend_chars;
  458. static int iColddebug;
  459.  
  460. static boolean fcsend_debug P((boolean, size_t, const char *));
  461.  
  462. static boolean
  463. fcsend_debug (fquote, clen, zbuf)
  464.      boolean fquote;
  465.      size_t clen;
  466.      const char *zbuf;
  467. {
  468.   size_t cwas;
  469.  
  470.   if (! FDEBUGGING (DEBUG_CHAT))
  471.     return TRUE;
  472.  
  473.   cwas = cCsend_chars;
  474.   if (clen > 0)
  475.     cCsend_chars += clen;
  476.   else
  477.     cCsend_chars += strlen (zbuf);
  478.   if (cCsend_chars > 60 && cwas > 10)
  479.     {
  480.       ulog (LOG_DEBUG_END, "%s", fquote ? "\"" : "");
  481.       fquote = FALSE;
  482.       ulog (LOG_DEBUG_START, "fcsend: Writing");
  483.       cCsend_chars = 0;
  484.     }
  485.  
  486.   if (clen == 0)
  487.     {
  488.       ulog (LOG_DEBUG_CONTINUE, "%s %s", fquote ? "\"" : "", zbuf);
  489.       return FALSE;
  490.     }
  491.   else
  492.     {
  493.       int i;
  494.  
  495.       if (! fquote)
  496.     ulog (LOG_DEBUG_CONTINUE, " \"");
  497.       for (i = 0; i < clen; i++)
  498.     {
  499.       char ab[5];
  500.  
  501.       (void) cdebug_char (ab, zbuf[i]);
  502.       ulog (LOG_DEBUG_CONTINUE, "%s", ab);
  503.     }
  504.  
  505.       return TRUE;
  506.     }
  507. }
  508.  
  509. /* Finish up the debugging information for fcsend.  */
  510.  
  511. static void ucsend_debug_end P((boolean, boolean));
  512.  
  513. static void
  514. ucsend_debug_end (fquote, ferr)
  515.      boolean fquote;
  516.      boolean ferr;
  517. {
  518.   if (! FDEBUGGING (DEBUG_CHAT))
  519.     return;
  520.  
  521.   if (fquote)
  522.     ulog (LOG_DEBUG_CONTINUE, "\"");
  523.  
  524.   if (ferr)
  525.     ulog (LOG_DEBUG_CONTINUE, " (error)");
  526.  
  527.   ulog (LOG_DEBUG_END, "%s", "");
  528.  
  529.   iDebug = iColddebug;
  530. }
  531.  
  532. #else /* DEBUG <= 1 */
  533.  
  534. /* Use macro definitions to make fcsend look neater.  */
  535.  
  536. #define fcsend_debug(fquote, clen, zbuf) TRUE
  537.  
  538. #define ucsend_debug_end(fquote, ferror)
  539.  
  540. #endif /* DEBUG <= 1 */
  541.  
  542. /* Send a string out.  This has to parse escape sequences as it goes.
  543.    Note that it handles the dialer escape sequences (\e, \E, \D, \T)
  544.    although they make no sense for chatting with a system.  */
  545.  
  546. static boolean
  547. fcsend (qconn, puuconf, z, qsys, qdial, zphone, ftranslate, fstrip)
  548.      struct sconnection *qconn;
  549.      pointer puuconf;
  550.      const char *z;
  551.      const struct uuconf_system *qsys;
  552.      const struct uuconf_dialer *qdial;
  553.      const char *zphone;
  554.      boolean ftranslate;
  555.      boolean fstrip;
  556. {
  557.   boolean fnocr;
  558.   boolean (*pfwrite) P((struct sconnection *, const char *, size_t));
  559.   char *zcallout_login;
  560.   char *zcallout_pass;
  561.   boolean fquote;
  562.  
  563.   if (strcmp (z, "\"\"") == 0)
  564.     return TRUE;
  565.  
  566.   fnocr = FALSE;
  567.   pfwrite = fconn_write;
  568.   zcallout_login = NULL;
  569.   zcallout_pass = NULL;
  570.  
  571. #if DEBUG > 1
  572.   if (FDEBUGGING (DEBUG_CHAT))
  573.     {
  574.       ulog (LOG_DEBUG_START, "fcsend: Writing");
  575.       fquote = FALSE;
  576.       cCsend_chars = 0;
  577.       iColddebug = iDebug;
  578.       iDebug &=~ (DEBUG_OUTGOING | DEBUG_PORT);
  579.     }
  580. #endif
  581.  
  582.   while (*z != '\0')
  583.     {
  584.       const char *zlook;
  585.       boolean fsend;
  586.       char bsend;
  587.  
  588.       zlook = z + strcspn ((char *) z, "\\BE");
  589.  
  590.       if (zlook > z)
  591.     {
  592.       size_t c;
  593.  
  594.       c = zlook - z;
  595.       fquote = fcsend_debug (fquote, c, z);
  596.       if (! (*pfwrite) (qconn, z, c))
  597.         {
  598.           ucsend_debug_end (fquote, TRUE);
  599.           return FALSE;
  600.         }
  601.     }
  602.  
  603.       if (*zlook == '\0')
  604.     break;
  605.  
  606.       z = zlook;
  607.  
  608.       fsend = FALSE;
  609.       switch (*z)
  610.     {
  611.     case 'B':
  612.       if (strncmp (z, "BREAK", 5) == 0)
  613.         {
  614.           fquote = fcsend_debug (fquote, (size_t) 0, "break");
  615.           if (! fconn_break (qconn))
  616.         {
  617.           ucsend_debug_end (fquote, TRUE);
  618.           return FALSE;
  619.         }
  620.           fnocr = TRUE;
  621.           z += 5;
  622.         }
  623.       else
  624.         {
  625.           fsend = TRUE;
  626.           bsend = 'B';
  627.           ++z;
  628.         }
  629.       break;
  630.     case 'E':
  631.       if (strncmp (z, "EOT", 3) == 0)
  632.         {
  633.           fsend = TRUE;
  634.           bsend = '\004';
  635.           fnocr = TRUE;
  636.           z += 3;
  637.         }
  638.       else
  639.         {
  640.           fsend = TRUE;
  641.           bsend = 'E';
  642.           ++z;
  643.         }
  644.       break;
  645.     case '\\':
  646.       ++z;
  647.       switch (*z)
  648.         {
  649.         case '-':
  650.           fsend = TRUE;
  651.           bsend = '-';
  652.           break;
  653.         case 'b':
  654.           fsend = TRUE;
  655.           bsend = '\b';
  656.           break;
  657.         case 'c':
  658.           fnocr = TRUE;
  659.           break;
  660.         case 'd':
  661.           fquote = fcsend_debug (fquote, (size_t) 0, "sleep");
  662.           usysdep_sleep (1);
  663.           break;
  664.         case 'e':
  665.           fquote = fcsend_debug (fquote, (size_t) 0, "echo-check-off");
  666.           pfwrite = fconn_write;
  667.           break;
  668.         case 'E':
  669.           fquote = fcsend_debug (fquote, (size_t) 0, "echo-check-on");
  670.           if (fstrip)
  671.         pfwrite = fcecho_send_strip;
  672.           else
  673.         pfwrite = fcecho_send_nostrip;
  674.           break;
  675.         case 'K':
  676.           fquote = fcsend_debug (fquote, (size_t) 0, "break");
  677.           if (! fconn_break (qconn))
  678.         {
  679.           ucsend_debug_end (fquote, TRUE);
  680.           return FALSE;
  681.         }
  682.           break;
  683.         case 'n':
  684.           fsend = TRUE;
  685.           bsend = '\n';
  686.           break;
  687.         case 'N':
  688.           fsend = TRUE;
  689.           bsend = '\0';
  690.           break;
  691.         case 'p':
  692.           fquote = fcsend_debug (fquote, (size_t) 0, "pause");
  693.           usysdep_pause ();
  694.           break;
  695.         case 'r':
  696.           fsend = TRUE;
  697.           bsend = '\r';
  698.           break;
  699.         case 's':
  700.           fsend = TRUE;
  701.           bsend = ' ';
  702.           break;
  703.         case 't':
  704.           fsend = TRUE;
  705.           bsend = '\t';
  706.           break;
  707.         case '\0':
  708.           --z;
  709.           /* Fall through.  */
  710.         case '\\':
  711.           fsend = TRUE;
  712.           bsend = '\\';
  713.           break;
  714.         case '0': case '1': case '2': case '3': case '4':
  715.         case '5': case '6': case '7': case '8': case '9':
  716.           fsend = TRUE;
  717.           bsend = *z - '0';
  718.           if (z[1] >= '0' && z[1] <= '7')
  719.         bsend = (char) (8 * bsend + *++z - '0');
  720.           if (z[1] >= '0' && z[1] <= '7')
  721.         bsend = (char) (8 * bsend + *++z - '0');
  722.           break;
  723.         case 'x':
  724.           fsend = TRUE;
  725.           bsend = 0;
  726.           while (isxdigit (BUCHAR (z[1])))
  727.         {
  728.           if (isdigit (BUCHAR (z[1])))
  729.             bsend = (char) (16 * bsend + *++z - '0');
  730.           else if (isupper (BUCHAR (z[1])))
  731.             bsend = (char) (16 * bsend + *++z - 'A' + 10);
  732.           else
  733.             bsend = (char) (16 * bsend + *++z - 'a' + 10);
  734.         }
  735.           break;
  736.         case 'L':
  737.           {
  738.         const char *zlog;
  739.         char *zcopy;
  740.         size_t clen;
  741.  
  742.         if (qsys == NULL)
  743.           {
  744.             ucsend_debug_end (fquote, TRUE);
  745.             ulog (LOG_ERROR, "Illegal use of \\L");
  746.             return FALSE;
  747.           }
  748.         zlog = qsys->uuconf_zcall_login;
  749.         if (zlog == NULL)
  750.           {
  751.             ucsend_debug_end (fquote, TRUE);
  752.             ulog (LOG_ERROR, "No login defined");
  753.             return FALSE;
  754.           }
  755.         if (zlog[0] == '*' && zlog[1] == '\0')
  756.           {
  757.             if (zcallout_login == NULL)
  758.               {
  759.             int iuuconf;
  760.  
  761.             iuuconf = uuconf_callout (puuconf, qsys,
  762.                           &zcallout_login,
  763.                           &zcallout_pass);
  764.             if (iuuconf == UUCONF_NOT_FOUND
  765.                 || zcallout_login == NULL)
  766.               {
  767.                 ucsend_debug_end (fquote, TRUE);
  768.                 ulog (LOG_ERROR, "No login defined");
  769.                 return FALSE;
  770.               }
  771.             else if (iuuconf != UUCONF_SUCCESS)
  772.               {
  773.                 ucsend_debug_end (fquote, TRUE);
  774.                 ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
  775.                 return FALSE;
  776.               }
  777.               }
  778.             zlog = zcallout_login;
  779.           }
  780.         zcopy = zbufcpy (zlog);
  781.         clen = cescape (zcopy);
  782.         fquote = fcsend_debug (fquote, (size_t) 0, "login");
  783.         fquote = fcsend_debug (fquote, clen, zcopy);
  784.         if (! (*pfwrite) (qconn, zcopy, clen))
  785.           {
  786.             ubuffree (zcopy);
  787.             ucsend_debug_end (fquote, TRUE);
  788.             return FALSE;
  789.           }
  790.         ubuffree (zcopy);
  791.           }
  792.           break;
  793.         case 'P':
  794.           {
  795.         const char *zpass;
  796.         char *zcopy;
  797.         size_t clen;
  798.  
  799.         if (qsys == NULL)
  800.           {
  801.             ucsend_debug_end (fquote, TRUE);
  802.             ulog (LOG_ERROR, "Illegal use of \\P");
  803.             return FALSE;
  804.           }
  805.         zpass = qsys->uuconf_zcall_password;
  806.         if (zpass == NULL)
  807.           {
  808.             ucsend_debug_end (fquote, TRUE);
  809.             ulog (LOG_ERROR, "No password defined");
  810.             return FALSE;
  811.           }
  812.         if (zpass[0] == '*' && zpass[1] == '\0')
  813.           {
  814.             if (zcallout_pass == NULL)
  815.               {
  816.             int iuuconf;
  817.  
  818.             iuuconf = uuconf_callout (puuconf, qsys,
  819.                           &zcallout_login,
  820.                           &zcallout_pass);
  821.             if (iuuconf == UUCONF_NOT_FOUND
  822.                 || zcallout_pass == NULL)
  823.               {
  824.                 ucsend_debug_end (fquote, TRUE);
  825.                 ulog (LOG_ERROR, "No password defined");
  826.                 return FALSE;
  827.               }
  828.             else if (iuuconf != UUCONF_SUCCESS)
  829.               {
  830.                 ucsend_debug_end (fquote, TRUE);
  831.                 ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
  832.                 return FALSE;
  833.               }
  834.               }
  835.             zpass = zcallout_pass;
  836.           }
  837.         zcopy = zbufcpy (zpass);
  838.         clen = cescape (zcopy);
  839.         fquote = fcsend_debug (fquote, (size_t) 0, "password");
  840.         fquote = fcsend_debug (fquote, clen, zcopy);
  841.         if (! (*pfwrite) (qconn, zcopy, clen))
  842.           {
  843.             ubuffree (zcopy);
  844.             ucsend_debug_end (fquote, TRUE);
  845.             return FALSE;
  846.           }
  847.         ubuffree (zcopy);
  848.           }
  849.           break;
  850.         case 'D':
  851.           if (qdial == NULL || zphone == NULL)
  852.         {
  853.           ucsend_debug_end (fquote, TRUE);
  854.           ulog (LOG_ERROR, "Illegal use of \\D");
  855.           return FALSE;
  856.         }
  857.           fquote = fcsend_debug (fquote, (size_t) 0, "\\D");
  858.           if (! fcphone (qconn, puuconf, qdial, zphone, pfwrite,
  859.                  ftranslate, &fquote))
  860.         {
  861.           ucsend_debug_end (fquote, TRUE);
  862.           return FALSE;
  863.         }
  864.           break;
  865.         case 'T':
  866.           if (qdial == NULL || zphone == NULL)
  867.         {
  868.           ucsend_debug_end (fquote, TRUE);
  869.           ulog (LOG_ERROR, "Illegal use of \\T");
  870.           return FALSE;
  871.         }
  872.           fquote = fcsend_debug (fquote, (size_t) 0, "\\T");
  873.           if (! fcphone (qconn, puuconf, qdial, zphone, pfwrite, TRUE,
  874.                  &fquote))
  875.         {
  876.           ucsend_debug_end (fquote, TRUE);
  877.           return FALSE;
  878.         }
  879.           break;
  880.         case 'M':
  881.           if (qdial == NULL)
  882.         {
  883.           ucsend_debug_end (fquote, TRUE);
  884.           ulog (LOG_ERROR, "Illegal use of \\M");
  885.           return FALSE;
  886.         }
  887.           fquote = fcsend_debug (fquote, (size_t) 0, "ignore-carrier");
  888.           if (! fconn_carrier (qconn, FALSE))
  889.         {
  890.           ucsend_debug_end (fquote, TRUE);
  891.           return FALSE;
  892.         }
  893.           break;
  894.         case 'm':
  895.           if (qdial == NULL)
  896.         {
  897.           ucsend_debug_end (fquote, TRUE);
  898.           ulog (LOG_ERROR, "Illegal use of \\m");
  899.           return FALSE;
  900.         }
  901.           if (qdial->uuconf_fcarrier)
  902.         {
  903.           fquote = fcsend_debug (fquote, (size_t) 0, "need-carrier");
  904.           if (! fconn_carrier (qconn, TRUE))
  905.             {
  906.               ucsend_debug_end (fquote, TRUE);
  907.               return FALSE;
  908.             }
  909.         }
  910.           break;
  911.         default:
  912.           /* This error message will screw up any debugging
  913.          information, but it's easily avoidable.  */
  914.           ulog (LOG_ERROR,
  915.             "Unrecognized escape sequence \\%c in send string",
  916.             *z);
  917.           fsend = TRUE;
  918.           bsend = *z;
  919.           break;
  920.         }
  921.       ++z;
  922.       break;
  923. #if DEBUG > 0
  924.     default:
  925.       ulog (LOG_FATAL, "fcsend: Can't happen");
  926.       break;
  927. #endif
  928.     }
  929.       
  930.       if (fsend)
  931.     {
  932.       fquote = fcsend_debug (fquote, (size_t) 1, &bsend);
  933.       if (! (*pfwrite) (qconn, &bsend, (size_t) 1))
  934.         {
  935.           ucsend_debug_end (fquote, TRUE);
  936.           return FALSE;
  937.         }
  938.     }
  939.     }
  940.  
  941.   xfree ((pointer) zcallout_login);
  942.   xfree ((pointer) zcallout_pass);
  943.  
  944.   /* Output a final carriage return, unless there was a \c.  Don't
  945.      bother to check for an echo.  */
  946.   if (! fnocr)
  947.     {
  948.       char b;
  949.  
  950.       b = '\r';
  951.       fquote = fcsend_debug (fquote, (size_t) 1, &b);
  952.       if (! fconn_write (qconn, &b, (size_t) 1))
  953.     {
  954.       ucsend_debug_end (fquote, TRUE);
  955.       return FALSE;
  956.     }
  957.     }
  958.  
  959.   ucsend_debug_end (fquote, FALSE);
  960.  
  961.   return TRUE;
  962. }
  963.  
  964. /* Write out a phone number with optional dialcode translation.  The
  965.    pfquote argument is only used for debugging.  */
  966.  
  967. static boolean
  968. fcphone (qconn, puuconf, qdial, zphone, pfwrite, ftranslate, pfquote)
  969.      struct sconnection *qconn;
  970.      pointer puuconf;
  971.      const struct uuconf_dialer *qdial;
  972.      const char *zphone;
  973.      boolean (*pfwrite) P((struct sconnection *qc, const char *zwrite,
  974.                size_t cwrite));
  975.      boolean ftranslate;
  976.      boolean *pfquote;
  977. {
  978.   const char *zprefix, *zsuffix;
  979.  
  980.   if (ftranslate)
  981.     {
  982.       if (! fctranslate (puuconf, zphone, &zprefix, &zsuffix))
  983.     return FALSE;
  984.     }
  985.   else
  986.     {
  987.       zprefix = zphone;
  988.       zsuffix = NULL;
  989.     }
  990.  
  991.   while (zprefix != NULL)
  992.     {
  993.       while (TRUE)
  994.     {
  995.       const char *z;
  996.       const char *zstr;
  997.  
  998.       z = zprefix + strcspn ((char *) zprefix, "=-");
  999.       if (z > zprefix)
  1000.         {
  1001.           size_t clen;
  1002.  
  1003.           clen = z - zprefix;
  1004.           *pfquote = fcsend_debug (*pfquote, clen, zprefix);
  1005.           if (! (*pfwrite) (qconn, zprefix, clen))
  1006.         return FALSE;
  1007.         }
  1008.  
  1009.       if (*z == '=')
  1010.         zstr = qdial->uuconf_zdialtone;
  1011.       else if (*z == '-')
  1012.         zstr = qdial->uuconf_zpause;
  1013.       else            /* *z == '\0' */
  1014.         break;
  1015.  
  1016.       if (zstr != NULL)
  1017.         {
  1018.           *pfquote = fcsend_debug (*pfquote, strlen (zstr), zstr);
  1019.           if (! (*pfwrite) (qconn, zstr, strlen (zstr)))
  1020.         return FALSE;
  1021.         }
  1022.  
  1023.       zprefix = z + 1;
  1024.     }
  1025.  
  1026.       zprefix = zsuffix;
  1027.       zsuffix = NULL;
  1028.     }
  1029.  
  1030.   return TRUE;
  1031. }
  1032.  
  1033. /* Given a phone number, run it through dial code translation
  1034.    returning two strings.  */
  1035.  
  1036. static boolean
  1037. fctranslate (puuconf, zphone, pzprefix, pzsuffix)
  1038.      pointer puuconf;
  1039.      const char *zphone;
  1040.      const char **pzprefix;
  1041.      const char **pzsuffix;
  1042. {
  1043.   int iuuconf;
  1044.   char *zdialcode, *zto;
  1045.   const char *zfrom;
  1046.   char *ztrans;
  1047.  
  1048.   *pzprefix = zphone;
  1049.   *pzsuffix = NULL;
  1050.  
  1051.   zdialcode = zbufalc (strlen (zphone) + 1);
  1052.   zfrom = zphone;
  1053.   zto = zdialcode;
  1054.   while (*zfrom != '\0' && isalpha (BUCHAR (*zfrom)))
  1055.     *zto++ = *zfrom++;
  1056.   *zto = '\0';
  1057.  
  1058.   if (*zdialcode == '\0')
  1059.     {
  1060.       ubuffree (zdialcode);
  1061.       return TRUE;
  1062.     }
  1063.  
  1064.   iuuconf = uuconf_dialcode (puuconf, zdialcode, &ztrans);
  1065.  
  1066.   ubuffree (zdialcode);
  1067.  
  1068.   if (iuuconf == UUCONF_NOT_FOUND)
  1069.     return TRUE;
  1070.   else if (iuuconf != UUCONF_SUCCESS)
  1071.     {
  1072.       ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
  1073.       return FALSE;
  1074.     }
  1075.   else
  1076.     {
  1077.       /* We really should figure out a way to free up ztrans here.  */
  1078.       *pzprefix = ztrans;
  1079.       *pzsuffix = zfrom;
  1080.       return TRUE;
  1081.     }
  1082. }
  1083.  
  1084. /* Write out a string making sure the each character is echoed back.
  1085.    There are two versions of this function, one which strips the
  1086.    parity bit from the characters and one which does not.  This is so
  1087.    that I can use a single function pointer in fcsend, and to avoid
  1088.    using any static variables so that I can put chat scripts in a
  1089.    library some day.  */
  1090.  
  1091. static boolean
  1092. fcecho_send_strip (qconn, zwrite, cwrite)
  1093.      struct sconnection *qconn;
  1094.      const char *zwrite;
  1095.      size_t cwrite;
  1096. {
  1097.   return fcecho_send (qconn, zwrite, cwrite, TRUE);
  1098. }
  1099.  
  1100. static boolean
  1101. fcecho_send_nostrip (qconn, zwrite, cwrite)
  1102.      struct sconnection *qconn;
  1103.      const char *zwrite;
  1104.      size_t cwrite;
  1105. {
  1106.   return fcecho_send (qconn, zwrite, cwrite, FALSE);
  1107. }
  1108.  
  1109. static boolean
  1110. fcecho_send (qconn, zwrite, cwrite, fstrip)
  1111.      struct sconnection *qconn;
  1112.      const char *zwrite;
  1113.      size_t cwrite;
  1114.      boolean fstrip;
  1115. {
  1116.   const char *zend;
  1117.  
  1118.   zend = zwrite + cwrite;
  1119.  
  1120.   for (; zwrite < zend; zwrite++)
  1121.     {
  1122.       int b;
  1123.       char bwrite;
  1124.  
  1125.       bwrite = *zwrite;
  1126.       if (! fconn_write (qconn, &bwrite, (size_t) 1))
  1127.     return FALSE;
  1128.       if (fstrip)
  1129.     bwrite &= 0x7f;
  1130.       do
  1131.     {
  1132.       /* We arbitrarily wait five seconds for the echo.  */
  1133.       b = breceive_char (qconn, 5, TRUE);
  1134.       /* Now b == -1 on timeout, -2 on error.  */
  1135.       if (b < 0)
  1136.         {
  1137.           if (b == -1)
  1138.         ulog (LOG_ERROR, "Character not echoed");
  1139.           return FALSE;
  1140.         }
  1141.       if (fstrip)
  1142.         b &= 0x7f;
  1143.     }
  1144.       while (b != BUCHAR (bwrite));
  1145.     }
  1146.  
  1147.   return TRUE;
  1148. }
  1149.  
  1150. /* Run a chat program.  Expand any escape sequences and call a system
  1151.    dependent program to run it.  */
  1152.  
  1153. static boolean
  1154. fcprogram (qconn, puuconf, pzprogram, qsys, qdial, zphone, zport, ibaud)
  1155.      struct sconnection *qconn;
  1156.      pointer puuconf;
  1157.      char **pzprogram;
  1158.      const struct uuconf_system *qsys;
  1159.      const struct uuconf_dialer *qdial;
  1160.      const char *zphone;
  1161.      const char *zport;
  1162.      long ibaud;
  1163. {
  1164.   size_t cargs;
  1165.   char **pzpass, **pzarg;
  1166.   char **pz;
  1167.   char *zcallout_login;
  1168.   char *zcallout_pass;
  1169.   boolean fret;
  1170.  
  1171.   cargs = 1;
  1172.   for (pz = pzprogram; *pz != NULL; pz++)
  1173.     ++cargs;
  1174.  
  1175.   pzpass = (char **) xmalloc (cargs * sizeof (char *));
  1176.  
  1177.   zcallout_login = NULL;
  1178.   zcallout_pass = NULL;
  1179.   fret = TRUE;
  1180.  
  1181.   /* Copy the string into memory expanding escape sequences.  */
  1182.   for (pz = pzprogram, pzarg = pzpass; *pz != NULL; pz++, pzarg++)
  1183.     {
  1184.       const char *zfrom;
  1185.       size_t calc, clen;
  1186.       char *zto;
  1187.  
  1188.       if (strchr (*pz, '\\') == NULL)
  1189.     {
  1190.       *pzarg = zbufcpy (*pz);
  1191.       continue;
  1192.     }
  1193.       
  1194.       *pzarg = NULL;
  1195.       zto = NULL;
  1196.       calc = 0;
  1197.       clen = 0;
  1198.  
  1199.       for (zfrom = *pz; *zfrom != '\0'; zfrom++)
  1200.     {
  1201.       const char *zadd = NULL;
  1202.       char *zfree = NULL;
  1203.       size_t cadd;
  1204.       char abadd[15];
  1205.  
  1206.       if (*zfrom != '\\')
  1207.         {
  1208.           if (clen + 2 > calc)
  1209.         {
  1210.           char *znew;
  1211.  
  1212.           calc = clen + 50;
  1213.           znew = zbufalc (calc);
  1214.           memcpy (znew, *pzarg, clen);
  1215.           ubuffree (*pzarg);
  1216.           *pzarg = znew;
  1217.           zto = znew + clen;
  1218.         }
  1219.           *zto++ = *zfrom;
  1220.           ++clen;
  1221.           continue;
  1222.         }
  1223.  
  1224.       ++zfrom;
  1225.       switch (*zfrom)
  1226.         {
  1227.         case '\0':
  1228.           --zfrom;
  1229.           /* Fall through.  */
  1230.         case '\\':
  1231.           zadd = "\\";
  1232.           break;
  1233.         case 'L':
  1234.           {
  1235.         const char *zlog;
  1236.  
  1237.         if (qsys == NULL)
  1238.           {
  1239.             ulog (LOG_ERROR, "chat-program: Illegal use of \\L");
  1240.             fret = FALSE;
  1241.             break;
  1242.           }
  1243.         zlog = qsys->uuconf_zcall_login;
  1244.         if (zlog == NULL)
  1245.           {
  1246.             ulog (LOG_ERROR, "chat-program: No login defined");
  1247.             fret = FALSE;
  1248.             break;
  1249.           }
  1250.         if (zlog[0] == '*' && zlog[1] == '\0')
  1251.           {
  1252.             if (zcallout_login == NULL)
  1253.               {
  1254.             int iuuconf;
  1255.  
  1256.             iuuconf = uuconf_callout (puuconf, qsys,
  1257.                           &zcallout_login,
  1258.                           &zcallout_pass);
  1259.             if (iuuconf == UUCONF_NOT_FOUND
  1260.                 || zcallout_login == NULL)
  1261.               {
  1262.                 ulog (LOG_ERROR,
  1263.                   "chat-program: No login defined");
  1264.                 fret = FALSE;
  1265.                 break;
  1266.               }
  1267.             else if (iuuconf != UUCONF_SUCCESS)
  1268.               {
  1269.                 ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
  1270.                 fret = FALSE;
  1271.                 break;
  1272.               }
  1273.               }
  1274.             zlog = zcallout_login;
  1275.           }
  1276.         zfree = zbufcpy (zlog);
  1277.         (void) cescape (zfree);
  1278.         zadd = zfree;
  1279.           }
  1280.           break;
  1281.         case 'P':
  1282.           {
  1283.         const char *zpass;
  1284.  
  1285.         if (qsys == NULL)
  1286.           {
  1287.             ulog (LOG_ERROR, "chat-program: Illegal use of \\P");
  1288.             fret = FALSE;
  1289.             break;
  1290.           }
  1291.         zpass = qsys->uuconf_zcall_password;
  1292.         if (zpass == NULL)
  1293.           {
  1294.             ulog (LOG_ERROR, "chat-program: No password defined");
  1295.             fret = FALSE;
  1296.             break;
  1297.           }
  1298.         if (zpass[0] == '*' && zpass[1] == '\0')
  1299.           {
  1300.             if (zcallout_pass == NULL)
  1301.               {
  1302.             int iuuconf;
  1303.  
  1304.             iuuconf = uuconf_callout (puuconf, qsys,
  1305.                           &zcallout_login,
  1306.                           &zcallout_pass);
  1307.             if (iuuconf == UUCONF_NOT_FOUND
  1308.                 || zcallout_pass == NULL)
  1309.               {
  1310.                 ulog (LOG_ERROR,
  1311.                   "chat-program: No password defined");
  1312.                 fret = FALSE;
  1313.                 break;
  1314.               }
  1315.             else if (iuuconf != UUCONF_SUCCESS)
  1316.               {
  1317.                 ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
  1318.                 fret = FALSE;
  1319.                 break;
  1320.               }
  1321.               }
  1322.             zpass = zcallout_pass;
  1323.           }
  1324.         zfree = zbufcpy (zpass);
  1325.         (void) cescape (zfree);
  1326.         zadd = zfree;
  1327.           }
  1328.           break;
  1329.         case 'D':
  1330.           if (qdial == NULL || zphone == NULL)
  1331.         {
  1332.           ulog (LOG_ERROR, "chat-program: Illegal use of \\D");
  1333.           fret = FALSE;
  1334.           break;
  1335.         }
  1336.           zadd = zphone;
  1337.           break;
  1338.         case 'T':
  1339.           {
  1340.         const char *zprefix, *zsuffix;
  1341.  
  1342.         if (qdial == NULL || zphone == NULL)
  1343.           {
  1344.             ulog (LOG_ERROR, "chat-program: Illegal use of \\T");
  1345.             fret = FALSE;
  1346.             break;
  1347.           }
  1348.  
  1349.         if (! fctranslate (puuconf, zphone, &zprefix, &zsuffix))
  1350.           {
  1351.             fret = FALSE;
  1352.             break;
  1353.           }
  1354.  
  1355.         if (zsuffix == NULL)
  1356.           zadd = zprefix;
  1357.         else
  1358.           {
  1359.             size_t cprefix;
  1360.  
  1361.             cprefix = strlen (zprefix);
  1362.             if (clen + cprefix + 1 > calc)
  1363.               {
  1364.             char *znew;
  1365.  
  1366.             calc = clen + cprefix + 20;
  1367.             znew = zbufalc (calc);
  1368.             memcpy (znew, *pzarg, clen);
  1369.             ubuffree (*pzarg);
  1370.             *pzarg = znew;
  1371.             zto = znew + clen;
  1372.               }
  1373.             memcpy (zto, zprefix, cprefix);
  1374.             zto += cprefix;
  1375.             clen += cprefix;
  1376.             zadd = zsuffix;
  1377.           }
  1378.           }
  1379.           break;
  1380.         case 'Y':
  1381.           if (zLdevice == NULL && zport == NULL)
  1382.         {
  1383.           ulog (LOG_ERROR, "chat-program: Illegal use of \\Y");
  1384.           fret = FALSE;
  1385.           break;
  1386.         }
  1387.           /* zLdevice will generally make more sense than zport, but
  1388.          it might not be set yet.  */
  1389.           zadd = zLdevice;
  1390.           if (zadd == NULL)
  1391.         zadd = zport;
  1392.           break;
  1393.         case 'Z':
  1394.           if (qsys == NULL)
  1395.         {
  1396.           ulog (LOG_ERROR, "chat-program: Illegal use of \\Z");
  1397.           fret = FALSE;
  1398.           break;
  1399.         }
  1400.           zadd = qsys->uuconf_zname;
  1401.           break;
  1402.         case 'S':
  1403.           {
  1404.         if (ibaud == 0)
  1405.           {
  1406.             ulog (LOG_ERROR, "chat-program: Illegal use of \\S");
  1407.             fret = FALSE;
  1408.             break;
  1409.           }
  1410.         sprintf (abadd, "%ld", ibaud);
  1411.         zadd = abadd;
  1412.           }
  1413.           break;
  1414.         default:
  1415.           {
  1416.         ulog (LOG_ERROR,
  1417.               "chat-program: Unrecognized escape sequence \\%c",
  1418.               *zfrom);
  1419.         abadd[0] = *zfrom;
  1420.         abadd[1] = '\0';
  1421.         zadd = abadd;
  1422.           }
  1423.           break;
  1424.         }
  1425.  
  1426.       if (! fret)
  1427.         break;
  1428.  
  1429.       cadd = strlen (zadd);
  1430.       if (clen + cadd + 1 > calc)
  1431.         {
  1432.           char *znew;
  1433.  
  1434.           calc = clen + cadd + 20;
  1435.           znew = zbufalc (calc);
  1436.           memcpy (znew, *pzarg, clen);
  1437.           ubuffree (*pzarg);
  1438.           *pzarg = znew;
  1439.           zto = znew + clen;
  1440.         }
  1441.       memcpy (zto, zadd, cadd + 1);
  1442.       zto += cadd;
  1443.       clen += cadd;
  1444.       ubuffree (zfree);
  1445.     }
  1446.  
  1447.       if (! fret)
  1448.     break;
  1449.  
  1450.       *zto++ = '\0';
  1451.       ++clen;
  1452.     }
  1453.  
  1454.   *pzarg = NULL;
  1455.  
  1456.   if (fret)
  1457.     fret = fconn_run_chat (qconn, pzpass);
  1458.  
  1459.   for (pz = pzpass; *pz != NULL; pz++)
  1460.     ubuffree (*pz);
  1461.   xfree ((pointer) pzpass);
  1462.   xfree ((pointer) zcallout_login);
  1463.   xfree ((pointer) zcallout_pass);
  1464.  
  1465.   return fret;
  1466. }
  1467.