home *** CD-ROM | disk | FTP | other *** search
/ OpenStep 4.2J (Developer) / os42jdev.iso / NextDeveloper / Source / GNU / uucp / Uucp.framework / conn.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-08-20  |  14.4 KB  |  588 lines
  1. /* conn.c
  2.    Connection routines for the Taylor UUCP package.
  3.  
  4.    Copyright (C) 1991, 1992, 1993, 1994 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 conn_rcsid[] = "$Id: conn.c,v 1.15 1995/06/21 19:14:35 ian Rel $";
  30. #endif
  31.  
  32. #include <ctype.h>
  33.  
  34. #include "uudefs.h"
  35. #include "uuconf.h"
  36. #include "conn.h"
  37.  
  38. /* Create a new connection.  This relies on system dependent functions
  39.    to set the qcmds and psysdep fields.  If qport is NULL, it opens a
  40.    standard input port, in which case ttype is the type of port to
  41.    use.  */
  42.  
  43. boolean
  44. fconn_init (qport, qconn, ttype)
  45.      struct uuconf_port *qport;
  46.      struct sconnection *qconn;
  47.      enum uuconf_porttype ttype;
  48. {
  49.   qconn->qport = qport;
  50.   switch (qport == NULL ? ttype : qport->uuconf_ttype)
  51.     {
  52.     case UUCONF_PORTTYPE_STDIN:
  53.       return fsysdep_stdin_init (qconn);
  54.     case UUCONF_PORTTYPE_MODEM:
  55.       return fsysdep_modem_init (qconn);
  56.     case UUCONF_PORTTYPE_DIRECT:
  57.       return fsysdep_direct_init (qconn);
  58. #if HAVE_TCP
  59.     case UUCONF_PORTTYPE_TCP:
  60.       return fsysdep_tcp_init (qconn);
  61. #endif
  62. #if HAVE_TLI
  63.     case UUCONF_PORTTYPE_TLI:
  64.       return fsysdep_tli_init (qconn);
  65. #endif
  66.     case UUCONF_PORTTYPE_PIPE:
  67.       return fsysdep_pipe_init (qconn);
  68.     default:
  69.       ulog (LOG_ERROR, "Unknown or unsupported port type");
  70.       return FALSE;
  71.     }
  72. }
  73.  
  74. /* Connection dispatch routines.  */
  75.  
  76. /* Free a connection.  */
  77.  
  78. void
  79. uconn_free (qconn)
  80.      struct sconnection *qconn;
  81. {
  82.   (*qconn->qcmds->pufree) (qconn);
  83. }
  84.  
  85. /* Lock a connection.   */
  86.  
  87. boolean
  88. fconn_lock (qconn, fin)
  89.      struct sconnection *qconn;
  90.      boolean fin;
  91. {
  92.   boolean (*pflock) P((struct sconnection *, boolean));
  93.  
  94.   pflock = qconn->qcmds->pflock;
  95.   if (pflock == NULL)
  96.     return TRUE;
  97.   return (*pflock) (qconn, fin);
  98. }
  99.  
  100. /* Unlock a connection.  */
  101.  
  102. boolean
  103. fconn_unlock (qconn)
  104.      struct sconnection *qconn;
  105. {
  106.   boolean (*pfunlock) P((struct sconnection *));
  107.  
  108.   pfunlock = qconn->qcmds->pfunlock;
  109.   if (pfunlock == NULL)
  110.     return TRUE;
  111.   return (*pfunlock) (qconn);
  112. }
  113.  
  114. /* Open a connection.  */
  115.  
  116. boolean
  117. fconn_open (qconn, ibaud, ihighbaud, fwait)
  118.      struct sconnection *qconn;
  119.      long ibaud;
  120.      long ihighbaud;
  121.      boolean fwait;
  122. {
  123.   boolean fret;
  124.  
  125. #if DEBUG > 1
  126.   if (FDEBUGGING (DEBUG_PORT))
  127.     {
  128.       char abspeed[20];
  129.  
  130.       if (ibaud == (long) 0)
  131.     strcpy (abspeed, "default speed");
  132.       else
  133.     sprintf (abspeed, "speed %ld", ibaud);
  134.  
  135.       if (qconn->qport == NULL)
  136.     ulog (LOG_DEBUG, "fconn_open: Opening stdin port (%s)",
  137.           abspeed);
  138.       else if (qconn->qport->uuconf_zname == NULL)
  139.     ulog (LOG_DEBUG, "fconn_open: Opening unnamed port (%s)",
  140.           abspeed);
  141.       else
  142.     ulog (LOG_DEBUG, "fconn_open: Opening port %s (%s)",
  143.           qconn->qport->uuconf_zname, abspeed);
  144.     }
  145. #endif
  146.  
  147.   /* If the system provides a range of baud rates, we select the
  148.      highest baud rate supported by the port.  */
  149.   if (ihighbaud != 0 && qconn->qport != NULL)
  150.     {
  151.       struct uuconf_port *qport;
  152.  
  153.       qport = qconn->qport;
  154.       ibaud = ihighbaud;
  155.       if (qport->uuconf_ttype == UUCONF_PORTTYPE_MODEM)
  156.     {
  157.       if (qport->uuconf_u.uuconf_smodem.uuconf_ilowbaud != 0)
  158.         {
  159.           if (qport->uuconf_u.uuconf_smodem.uuconf_ihighbaud < ibaud)
  160.         ibaud = qport->uuconf_u.uuconf_smodem.uuconf_ihighbaud;
  161.         }
  162.       else if (qport->uuconf_u.uuconf_smodem.uuconf_ibaud != 0)
  163.         ibaud = qport->uuconf_u.uuconf_smodem.uuconf_ibaud;
  164.     }
  165.       else if (qport->uuconf_ttype == UUCONF_PORTTYPE_DIRECT)
  166.     {
  167.       if (qport->uuconf_u.uuconf_sdirect.uuconf_ibaud != 0)
  168.         ibaud = qport->uuconf_u.uuconf_sdirect.uuconf_ibaud;
  169.     }
  170.     }
  171.  
  172.   /* This will normally be overridden by the port specific open
  173.      routine.  */
  174.   if (qconn->qport == NULL)
  175.     ulog_device ("stdin");
  176.   else
  177.     ulog_device (qconn->qport->uuconf_zname);
  178.  
  179.   fret = (*qconn->qcmds->pfopen) (qconn, ibaud, fwait);
  180.  
  181.   if (! fret)
  182.     ulog_device ((const char *) NULL);
  183.  
  184.   return fret;
  185. }
  186.  
  187. /* Close a connection.  */
  188.  
  189. boolean
  190. fconn_close (qconn, puuconf, qdialer, fsuccess)
  191.      struct sconnection *qconn;
  192.      pointer puuconf;
  193.      struct uuconf_dialer *qdialer;
  194.      boolean fsuccess;
  195. {
  196.   boolean fret;
  197.  
  198.   DEBUG_MESSAGE0 (DEBUG_PORT, "fconn_close: Closing connection");
  199.  
  200.   /* Don't report hangup signals while we're closing.  */
  201.   fLog_sighup = FALSE;
  202.  
  203.   fret = (*qconn->qcmds->pfclose) (qconn, puuconf, qdialer, fsuccess);
  204.  
  205.   /* Ignore any SIGHUP we may have gotten, and make sure any signal
  206.      reporting has been done before we reset fLog_sighup.  */
  207.   afSignal[INDEXSIG_SIGHUP] = FALSE;
  208.   ulog (LOG_ERROR, (const char *) NULL);
  209.   fLog_sighup = TRUE;
  210.  
  211.   ulog_device ((const char *) NULL);
  212.  
  213.   return fret;
  214. }
  215.  
  216. /* Dial out on the connection.  */
  217.  
  218. boolean
  219. fconn_dial (qconn, puuconf, qsys, zphone, qdialer, ptdialerfound)
  220.      struct sconnection *qconn;
  221.      pointer puuconf;
  222.      const struct uuconf_system *qsys;
  223.      const char *zphone;
  224.      struct uuconf_dialer *qdialer;
  225.      enum tdialerfound *ptdialerfound;
  226. {
  227.   struct uuconf_dialer sdialer;
  228.   enum tdialerfound tfound;
  229.   boolean (*pfdial) P((struct sconnection *, pointer,
  230.                const struct uuconf_system *, const char *,
  231.                struct uuconf_dialer *, enum tdialerfound *));
  232.  
  233.   if (qdialer == NULL)
  234.     qdialer = &sdialer;
  235.   if (ptdialerfound == NULL)
  236.     ptdialerfound = &tfound;
  237.       
  238.   qdialer->uuconf_zname = NULL;
  239.   *ptdialerfound = DIALERFOUND_FALSE;
  240.  
  241.   pfdial = qconn->qcmds->pfdial;
  242.   if (pfdial == NULL)
  243.     return TRUE;
  244.   return (*pfdial) (qconn, puuconf, qsys, zphone, qdialer, ptdialerfound);
  245. }
  246.  
  247. /* Read data from the connection.  */
  248.  
  249. boolean
  250. fconn_read (qconn, zbuf, pclen, cmin, ctimeout, freport)
  251.      struct sconnection *qconn;
  252.      char *zbuf;
  253.      size_t *pclen;
  254.      size_t cmin;
  255.      int ctimeout;
  256.      boolean freport;
  257. {
  258.   boolean fret;
  259.  
  260.   fret = (*qconn->qcmds->pfread) (qconn, zbuf, pclen, cmin, ctimeout,
  261.                   freport);
  262.  
  263. #if DEBUG > 1
  264.   if (FDEBUGGING (DEBUG_INCOMING))
  265.     udebug_buffer ("fconn_read: Read", zbuf, *pclen);
  266.   else if (FDEBUGGING (DEBUG_PORT))
  267.     ulog (LOG_DEBUG, "fconn_read: Read %lu", (unsigned long) *pclen);
  268. #endif
  269.  
  270.   return fret;
  271. }
  272.  
  273. /* Write data to the connection.  */
  274.  
  275. boolean
  276. fconn_write (qconn, zbuf, clen)
  277.      struct sconnection *qconn;
  278.      const char *zbuf;
  279.      size_t clen;
  280. {
  281. #if DEBUG > 1
  282.   if (FDEBUGGING (DEBUG_OUTGOING))
  283.     udebug_buffer ("fconn_write: Writing", zbuf, clen);
  284.   else if (FDEBUGGING (DEBUG_PORT))
  285.     ulog (LOG_DEBUG, "fconn_write: Writing %lu", (unsigned long) clen);
  286. #endif
  287.  
  288.   return (*qconn->qcmds->pfwrite) (qconn, zbuf, clen);
  289. }
  290.  
  291. /* Read and write data.  */
  292.  
  293. boolean
  294. fconn_io (qconn, zwrite, pcwrite, zread, pcread)
  295.      struct sconnection *qconn;
  296.      const char *zwrite;
  297.      size_t *pcwrite;
  298.      char *zread;
  299.      size_t *pcread;
  300. {
  301.   boolean fret;
  302. #if DEBUG > 1
  303.   size_t cwrite = *pcwrite;
  304.   size_t cread = *pcread;
  305.  
  306.   if (cread == 0 || cwrite == 0)
  307.     ulog (LOG_FATAL, "fconn_io: cread %lu; cwrite %lu",
  308.       (unsigned long) cread, (unsigned long) cwrite);
  309. #endif
  310.  
  311. #if DEBUG > 1
  312.   if (FDEBUGGING (DEBUG_OUTGOING))
  313.     udebug_buffer ("fconn_io: Writing", zwrite, cwrite);
  314. #endif
  315.  
  316.   fret = (*qconn->qcmds->pfio) (qconn, zwrite, pcwrite, zread, pcread);
  317.  
  318.   DEBUG_MESSAGE4 (DEBUG_PORT,
  319.           "fconn_io: Wrote %lu of %lu, read %lu of %lu",
  320.           (unsigned long) *pcwrite, (unsigned long) cwrite,
  321.           (unsigned long) *pcread, (unsigned long) cread);
  322.  
  323. #if DEBUG > 1
  324.   if (*pcread > 0 && FDEBUGGING (DEBUG_INCOMING))
  325.     udebug_buffer ("fconn_io: Read", zread, *pcread);
  326. #endif
  327.  
  328.   return fret;
  329. }
  330.  
  331. /* Send a break character to a connection.  Some port types may not
  332.    support break characters, in which case we just return TRUE.  */
  333.  
  334. boolean
  335. fconn_break (qconn)
  336.      struct sconnection *qconn;
  337. {
  338.   boolean (*pfbreak) P((struct sconnection *));
  339.  
  340.   pfbreak = qconn->qcmds->pfbreak;
  341.   if (pfbreak == NULL)
  342.     return TRUE;
  343.  
  344.   DEBUG_MESSAGE0 (DEBUG_PORT, "fconn_break: Sending break character");
  345.  
  346.   return (*pfbreak) (qconn);
  347. }
  348.  
  349. /* Change the setting of a connection.  Some port types may not
  350.    support this, in which case we just return TRUE.  */
  351.  
  352. boolean
  353. fconn_set (qconn, tparity, tstrip, txonxoff)
  354.      struct sconnection *qconn;
  355.      enum tparitysetting tparity;
  356.      enum tstripsetting tstrip;
  357.      enum txonxoffsetting txonxoff;
  358. {
  359.   boolean (*pfset) P((struct sconnection *, enum tparitysetting,
  360.               enum tstripsetting, enum txonxoffsetting));
  361.  
  362.   pfset = qconn->qcmds->pfset;
  363.   if (pfset == NULL)
  364.     return TRUE;
  365.  
  366.   DEBUG_MESSAGE3 (DEBUG_PORT,
  367.           "fconn_set: Changing setting to %d, %d, %d",
  368.           (int) tparity, (int) tstrip, (int) txonxoff);
  369.  
  370.   return (*pfset) (qconn, tparity, tstrip, txonxoff);
  371. }
  372.  
  373. /* Require or ignore carrier on a connection.  */
  374.  
  375. boolean
  376. fconn_carrier (qconn, fcarrier)
  377.      struct sconnection *qconn;
  378.      boolean fcarrier;
  379. {
  380.   boolean (*pfcarrier) P((struct sconnection *, boolean));
  381.  
  382.   pfcarrier = qconn->qcmds->pfcarrier;
  383.   if (pfcarrier == NULL)
  384.     return TRUE;
  385.   return (*pfcarrier) (qconn, fcarrier);
  386. }
  387.  
  388. /* Run a chat program on a connection.  */
  389.  
  390. boolean
  391. fconn_run_chat (qconn, pzprog)
  392.      struct sconnection *qconn;
  393.      char **pzprog;
  394. {
  395.   return (*qconn->qcmds->pfchat) (qconn, pzprog);
  396. }
  397.  
  398. /* Get the baud rate of a connection.  */
  399.  
  400. long
  401. iconn_baud (qconn)
  402.      struct sconnection *qconn;
  403. {
  404.   long (*pibaud) P((struct sconnection *));
  405.  
  406.   pibaud = qconn->qcmds->pibaud;
  407.   if (pibaud == NULL)
  408.     return 0;
  409.   return (*pibaud) (qconn);
  410. }
  411.  
  412. /* Run through a dialer sequence.  The pzdialer argument is a list of
  413.    strings, which are considered in dialer/token pairs.  The dialer
  414.    string names a dialer to use.  The token string is what \D and \T
  415.    in the chat script expand to.  If there is no token for the last
  416.    dialer, the zphone argument is used.  The qdialer argument is
  417.    filled in with information for the first dialer, and *ptdialerfound
  418.    is set to whether the information should be freed or not.  However,
  419.    if *ptdialerfound is not DIALERFOUND_FALSE when this function is
  420.    called, then the information for the first dialer is already in
  421.    qdialer.  */
  422.  
  423. boolean
  424. fconn_dial_sequence (qconn, puuconf, pzdialer, qsys, zphone, qdialer,
  425.              ptdialerfound)
  426.      struct sconnection *qconn;
  427.      pointer puuconf;
  428.      char **pzdialer;
  429.      const struct uuconf_system *qsys;
  430.      const char *zphone;
  431.      struct uuconf_dialer *qdialer;
  432.      enum tdialerfound *ptdialerfound;
  433. {
  434.   const char *zname;
  435.   boolean ffirst, ffreefirst;
  436.  
  437.   if (qconn->qport == NULL)
  438.     zname = NULL;
  439.   else
  440.     zname = qconn->qport->uuconf_zname;
  441.   ffirst = TRUE;
  442.   ffreefirst = FALSE;
  443.   while (*pzdialer != NULL)
  444.     {
  445.       struct uuconf_dialer *q;
  446.       struct uuconf_dialer s;
  447.       const char *ztoken;
  448.       boolean ftranslate;
  449.  
  450.       if (! ffirst)
  451.     q = &s;
  452.       else
  453.     q = qdialer;
  454.  
  455.       if (! ffirst || *ptdialerfound == DIALERFOUND_FALSE)
  456.     {
  457.       int iuuconf;
  458.  
  459.       iuuconf = uuconf_dialer_info (puuconf, *pzdialer, q);
  460.       if (iuuconf == UUCONF_NOT_FOUND)
  461.         {
  462.           ulog (LOG_ERROR, "%s: Dialer not found", *pzdialer);
  463.           if (ffreefirst)
  464.         (void) uuconf_dialer_free (puuconf, qdialer);
  465.           return FALSE;
  466.         }
  467.       else if (iuuconf != UUCONF_SUCCESS)
  468.         {
  469.           ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
  470.           if (ffreefirst)
  471.         (void) uuconf_dialer_free (puuconf, qdialer);
  472.           return FALSE;
  473.         }
  474.  
  475.       if (ffirst)
  476.         {
  477.           *ptdialerfound = DIALERFOUND_FREE;
  478.           ffreefirst = TRUE;
  479.         }
  480.     }
  481.  
  482.       ++pzdialer;
  483.       ztoken = *pzdialer;
  484.  
  485.       ftranslate = FALSE;
  486.       if (ztoken == NULL
  487.       || strcmp (ztoken, "\\D") == 0)
  488.     ztoken = zphone;
  489.       else if (strcmp (ztoken, "\\T") == 0)
  490.     {
  491.       ztoken = zphone;
  492.       ftranslate = TRUE;
  493.     }
  494.  
  495.       if (! fchat (qconn, puuconf, &q->uuconf_schat, qsys, q, ztoken,
  496.            ftranslate, zname, iconn_baud (qconn)))
  497.     {
  498.       if (q == &s)
  499.         (void) uuconf_dialer_free (puuconf, q);
  500.       if (ffreefirst)
  501.         (void) uuconf_dialer_free (puuconf, qdialer);
  502.       return FALSE;
  503.     }
  504.  
  505.       if (ffirst)
  506.     ffirst = FALSE;
  507.       else
  508.     (void) uuconf_dialer_free (puuconf, q);
  509.  
  510.       if (*pzdialer != NULL)
  511.     ++pzdialer;
  512.     }
  513.  
  514.   return TRUE;
  515. }
  516.  
  517. /* Modem dialing routine.  */
  518.  
  519. /*ARGSUSED*/
  520. boolean
  521. fmodem_dial (qconn, puuconf, qsys, zphone, qdialer, ptdialerfound)
  522.      struct sconnection *qconn;
  523.      pointer puuconf;
  524.      const struct uuconf_system *qsys;
  525.      const char *zphone;
  526.      struct uuconf_dialer *qdialer;
  527.      enum tdialerfound *ptdialerfound;
  528. {
  529.   char **pzdialer;
  530.  
  531.   *ptdialerfound = DIALERFOUND_FALSE;
  532.  
  533.   pzdialer = qconn->qport->uuconf_u.uuconf_smodem.uuconf_pzdialer;
  534.   if (pzdialer != NULL && *pzdialer != NULL)
  535.     {
  536.       int iuuconf;
  537.       boolean fret;
  538.  
  539.       iuuconf = uuconf_dialer_info (puuconf, *pzdialer, qdialer);
  540.       if (iuuconf == UUCONF_NOT_FOUND)
  541.     {
  542.       ulog (LOG_ERROR, "%s: Dialer not found", *pzdialer);
  543.       return FALSE;
  544.     }
  545.       else if (iuuconf != UUCONF_SUCCESS)
  546.     {
  547.       ulog_uuconf (LOG_ERROR, puuconf, iuuconf);
  548.       return FALSE;
  549.     }
  550.  
  551.       *ptdialerfound = DIALERFOUND_FREE;
  552.  
  553.       fret = (fsysdep_modem_begin_dial (qconn, qdialer)
  554.           && fconn_dial_sequence (qconn, puuconf, pzdialer, qsys, zphone,
  555.                       qdialer, ptdialerfound)
  556.           && fsysdep_modem_end_dial (qconn, qdialer));
  557.  
  558.       if (! fret)
  559.     (void) uuconf_dialer_free (puuconf, qdialer);
  560.  
  561.       return fret;
  562.     }
  563.   else if (qconn->qport->uuconf_u.uuconf_smodem.uuconf_qdialer != NULL)
  564.     {
  565.       struct uuconf_dialer *q;
  566.       const char *zname;
  567.  
  568.       q = qconn->qport->uuconf_u.uuconf_smodem.uuconf_qdialer;
  569.       *qdialer = *q;
  570.       *ptdialerfound = DIALERFOUND_TRUE;
  571.  
  572.       if (qconn->qport == NULL)
  573.     zname = NULL;
  574.       else
  575.     zname = qconn->qport->uuconf_zname;
  576.  
  577.       return (fsysdep_modem_begin_dial (qconn, q)
  578.           && fchat (qconn, puuconf, &q->uuconf_schat, qsys, q,
  579.             zphone, FALSE, zname, iconn_baud (qconn))
  580.           && fsysdep_modem_end_dial (qconn, q));
  581.     }
  582.   else
  583.     {
  584.       ulog (LOG_ERROR, "No dialer information");
  585.       return FALSE;
  586.     }
  587. }
  588.