home *** CD-ROM | disk | FTP | other *** search
/ OpenStep 4.2J (Developer) / os42jdev.iso / NextDeveloper / Source / GNU / uucp / Uucp.framework / uuconf.subproj / hsinfo.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-10-09  |  16.9 KB  |  638 lines
  1. /* hsinfo.c
  2.    Get information about a system from the HDB configuration files.
  3.  
  4.    Copyright (C) 1992, 1993, 1995 Ian Lance Taylor
  5.  
  6.    This file is part of the Taylor UUCP uuconf library.
  7.  
  8.    This library is free software; you can redistribute it and/or
  9.    modify it under the terms of the GNU Library General Public License
  10.    as published by the Free Software Foundation; either version 2 of
  11.    the License, or (at your option) any later version.
  12.  
  13.    This library 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.    Library General Public License for more details.
  17.  
  18.    You should have received a copy of the GNU Library General Public
  19.    License along with this library; 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 "uucnfi.h"
  27.  
  28. #if USE_RCS_ID
  29. const char _uuconf_hsinfo_rcsid[] = "$Id: hsinfo.c,v 1.14 1995/06/21 19:23:03 ian Rel $";
  30. #endif
  31.  
  32. #include <errno.h>
  33. #include <ctype.h>
  34.  
  35. static int ihadd_machine_perm P((struct sglobal *qglobal,
  36.                  struct uuconf_system *qsys,
  37.                  struct shpermissions *qperm));
  38. static int ihadd_logname_perm P((struct sglobal *qglobal,
  39.                  struct uuconf_system *qsys,
  40.                  struct shpermissions *qperm));
  41.  
  42. /* Get the information for a particular system from the HDB
  43.    configuration files.  This does not make sure that all the default
  44.    values are set.  */
  45.  
  46. int
  47. _uuconf_ihdb_system_internal (qglobal, zsystem, qsys)
  48.      struct sglobal *qglobal;
  49.      const char *zsystem;
  50.      struct uuconf_system *qsys;
  51. {
  52.   int iret;
  53.   struct shpermissions *qperm;
  54.   char *zline;
  55.   size_t cline;
  56.   char **pzsplit;
  57.   size_t csplit;
  58.   char **pzcomma;
  59.   size_t ccomma;
  60.   pointer pblock;
  61.   char **pz;
  62.   boolean ffound_machine, ffound_login;
  63.   struct shpermissions *qother_machine;
  64.   struct uuconf_system *qalt;
  65.  
  66.   if (! qglobal->qprocess->fhdb_read_permissions)
  67.     {
  68.       iret = _uuconf_ihread_permissions (qglobal);
  69.       if (iret != UUCONF_SUCCESS)
  70.     return iret;
  71.     }
  72.  
  73.   /* First look through the Permissions information to see if this is
  74.      an alias for some system.  I assume that an alias applies to the
  75.      first name in the corresponding MACHINE entry.  */
  76.  
  77.   for (qperm = qglobal->qprocess->qhdb_permissions;
  78.        qperm != NULL;
  79.        qperm = qperm->qnext)
  80.     {
  81.       if (qperm->pzalias == NULL
  82.       || qperm->pzmachine == NULL
  83.       || qperm->pzalias == (char **) &_uuconf_unset
  84.       || qperm->pzmachine == (char **) &_uuconf_unset)
  85.     continue;
  86.  
  87.       for (pz = qperm->pzalias; *pz != NULL; pz++)
  88.     {
  89.       if (strcmp (*pz, zsystem) == 0)
  90.         {
  91.           zsystem = qperm->pzmachine[0];
  92.           break;
  93.         }
  94.     }
  95.       if (*pz != NULL)
  96.     break;
  97.     }
  98.  
  99.   zline = NULL;
  100.   cline = 0;
  101.   pzsplit = NULL;
  102.   csplit = 0;
  103.   pzcomma = NULL;
  104.   ccomma = 0;
  105.  
  106.   pblock = NULL;
  107.  
  108.   iret = UUCONF_SUCCESS;
  109.  
  110.   for (pz = qglobal->qprocess->pzhdb_systems; *pz != NULL; pz++)
  111.     {
  112.       FILE *e;
  113.       int cchars;
  114.  
  115.       qglobal->ilineno = 0;
  116.  
  117.       e = fopen (*pz, "r");
  118.       if (e == NULL)
  119.     {
  120.       if (FNO_SUCH_FILE ())
  121.         continue;
  122.       qglobal->ierrno = errno;
  123.       iret = UUCONF_FOPEN_FAILED | UUCONF_ERROR_ERRNO;
  124.       break;
  125.     }
  126.  
  127.       while ((cchars = _uuconf_getline (qglobal, &zline, &cline, e)) > 0)
  128.     {
  129.       int ctoks, ctimes, i;
  130.       struct uuconf_system *qset;
  131.       char *z, *zretry;
  132.       int cretry;
  133.  
  134.       ++qglobal->ilineno;
  135.  
  136.       --cchars;
  137.       if (zline[cchars] == '\n')
  138.         zline[cchars] = '\0';
  139.       if (isspace (BUCHAR (zline[0])) || zline[0] == '#')
  140.         continue;
  141.  
  142.       ctoks = _uuconf_istrsplit (zline, '\0', &pzsplit, &csplit);
  143.       if (ctoks < 0)
  144.         {
  145.           qglobal->ierrno = errno;
  146.           iret = UUCONF_MALLOC_FAILED | UUCONF_ERROR_ERRNO;
  147.           break;
  148.         }
  149.  
  150.       /* If this isn't the system we're looking for, keep reading
  151.          the file.  */
  152.       if (ctoks < 1
  153.           || strcmp (zsystem, pzsplit[0]) != 0)
  154.         continue;
  155.  
  156.       /* If this is the first time we've found the system, we want
  157.          to set *qsys directly.  Otherwise, we allocate a new
  158.          alternate.  */
  159.       if (pblock == NULL)
  160.         {
  161.           pblock = uuconf_malloc_block ();
  162.           if (pblock == NULL)
  163.         {
  164.           qglobal->ierrno = errno;
  165.           iret = UUCONF_MALLOC_FAILED | UUCONF_ERROR_ERRNO;
  166.           break;
  167.         }
  168.           _uuconf_uclear_system (qsys);
  169.           qsys->uuconf_palloc = pblock;
  170.           qset = qsys;
  171.         }
  172.       else
  173.         {
  174.           struct uuconf_system **pq;
  175.  
  176.           qset = ((struct uuconf_system *)
  177.               uuconf_malloc (pblock, sizeof (struct uuconf_system)));
  178.           if (qset == NULL)
  179.         {
  180.           qglobal->ierrno = errno;
  181.           iret = UUCONF_MALLOC_FAILED | UUCONF_ERROR_ERRNO;
  182.           break;
  183.         }
  184.           _uuconf_uclear_system (qset);
  185.           for (pq = &qsys->uuconf_qalternate;
  186.            *pq != NULL;
  187.            pq = &(*pq)->uuconf_qalternate)
  188.         ;
  189.           *pq = qset;
  190.         }
  191.  
  192.       /* Add this line to the memory block we are building for the
  193.          system.  */
  194.       if (uuconf_add_block (pblock, zline) != 0)
  195.         {
  196.           qglobal->ierrno = errno;
  197.           iret = UUCONF_MALLOC_FAILED | UUCONF_ERROR_ERRNO;
  198.           break;
  199.         }
  200.  
  201.       zline = NULL;
  202.       cline = 0;
  203.  
  204.       /* The format of a line in Systems is
  205.          system time device speed phone chat
  206.          For example,
  207.          airs Any ACU 9600 5551212 ogin: foo pass: bar
  208.          */
  209.  
  210.       /* Get the system name.  */
  211.  
  212.       qset->uuconf_zname = pzsplit[0];
  213.       qset->uuconf_fcall = TRUE;
  214.       qset->uuconf_fcalled = FALSE;
  215.  
  216.       if (ctoks < 2)
  217.         continue;
  218.  
  219.       /* A time string is "time/grade,time/grade;retry".  A
  220.          missing grade is taken as BGRADE_LOW.  */
  221.       zretry = strchr (pzsplit[1], ';');
  222.       if (zretry == NULL)
  223.         cretry = 0;
  224.       else
  225.         {
  226.           *zretry = '\0';
  227.           cretry = (int) strtol (zretry + 1, (char **) NULL, 10);
  228.         }
  229.  
  230.       ctimes = _uuconf_istrsplit (pzsplit[1], ',', &pzcomma, &ccomma);
  231.       if (ctimes < 0)
  232.         {
  233.           qglobal->ierrno = errno;
  234.           iret = UUCONF_MALLOC_FAILED | UUCONF_ERROR_ERRNO;
  235.           break;
  236.         }
  237.  
  238.       for (i = 0; i < ctimes; i++)
  239.         {
  240.           char *zslash;
  241.           char bgrade;
  242.  
  243.           z = pzcomma[i];
  244.           zslash = strchr (z, '/');
  245.           if (zslash == NULL)
  246.         bgrade = UUCONF_GRADE_LOW;
  247.           else
  248.         {
  249.           *zslash = '\0';
  250.           bgrade = zslash[1];
  251.           if (! UUCONF_GRADE_LEGAL (bgrade))
  252.             bgrade = UUCONF_GRADE_LOW;
  253.         }
  254.  
  255.           iret = _uuconf_itime_parse (qglobal, z, (long) bgrade,
  256.                       cretry, _uuconf_itime_grade_cmp,
  257.                       &qset->uuconf_qtimegrade,
  258.                       pblock);
  259.  
  260.           /* We treat a syntax error in the time field as
  261.                  equivalent to ``never'', on the assumption that that
  262.                  is what HDB does.  */
  263.           if (iret == UUCONF_SYNTAX_ERROR)
  264.         iret = UUCONF_SUCCESS;
  265.  
  266.           if (iret != UUCONF_SUCCESS)
  267.         break;
  268.  
  269.           /* Treat any time/grade setting as both a timegrade and
  270.          a call-timegrade.  */
  271.           if (bgrade != UUCONF_GRADE_LOW)
  272.         qset->uuconf_qcalltimegrade = qset->uuconf_qtimegrade;
  273.         }
  274.  
  275.       if (iret != UUCONF_SUCCESS)
  276.         break;
  277.  
  278.       if (ctoks < 3)
  279.         continue;
  280.  
  281.       /* Pick up the device name.  It can be followed by a comma
  282.          and a list of protocols.  */
  283.       qset->uuconf_zport = pzsplit[2];
  284.       z = strchr (pzsplit[2], ',');
  285.       if (z != NULL)
  286.         {
  287.           qset->uuconf_zprotocols = z + 1;
  288.           *z = '\0';
  289.         }
  290.  
  291.       if (ctoks < 4)
  292.         continue;
  293.  
  294.       /* The speed entry can be a numeric speed, or a range of
  295.          speeds, or "Any", or "-".  If it starts with a letter,
  296.          the initial nonnumeric prefix is a modem class, which
  297.          gets appended to the port name.  */
  298.       z = pzsplit[3];
  299.       if (strcasecmp (z, "Any") != 0
  300.           && strcmp (z, "-") != 0)
  301.         {
  302.           char *zend;
  303.  
  304.           while (*z != '\0' && ! isdigit (BUCHAR (*z)))
  305.         ++z;
  306.  
  307.           qset->uuconf_ibaud = strtol (z, &zend, 10);
  308.           if (*zend == '-')
  309.         qset->uuconf_ihighbaud = strtol (zend + 1, (char **) NULL,
  310.                          10);
  311.  
  312.           if (z != pzsplit[3])
  313.         {
  314.           size_t cport, cclass;
  315.  
  316.           cport = strlen (pzsplit[2]);
  317.           cclass = z - pzsplit[3];
  318.           qset->uuconf_zport = uuconf_malloc (pblock,
  319.                               cport + cclass + 1);
  320.           if (qset->uuconf_zport == NULL)
  321.             {
  322.               qglobal->ierrno = errno;
  323.               iret = UUCONF_MALLOC_FAILED | UUCONF_ERROR_ERRNO;
  324.               break;
  325.             }
  326.           memcpy ((pointer) qset->uuconf_zport, (pointer) pzsplit[2],
  327.               cport);
  328.           memcpy ((pointer) (qset->uuconf_zport + cport),
  329.               (pointer) pzsplit[3], cclass);
  330.           qset->uuconf_zport[cport + cclass] = '\0';
  331.         }
  332.         }
  333.  
  334.       if (ctoks < 5)
  335.         continue;
  336.  
  337.       /* Get the phone number.  */
  338.       qset->uuconf_zphone = pzsplit[4];
  339.  
  340.       if (ctoks < 6)
  341.         continue;
  342.  
  343.       /* Get the chat script.  We just hand this off to the chat
  344.          script processor, so that it will parse subsend and
  345.          subexpect strings correctly.  */
  346.       pzsplit[4] = (char *) "chat";
  347.       iret = _uuconf_ichat_cmd (qglobal, ctoks - 4, pzsplit + 4,
  348.                     &qset->uuconf_schat, pblock);
  349.       iret &=~ UUCONF_CMDTABRET_KEEP;
  350.       if (iret != UUCONF_SUCCESS)
  351.         break;
  352.     }
  353.   
  354.       (void) fclose (e);
  355.  
  356.       if (iret != UUCONF_SUCCESS)
  357.     break;
  358.     }
  359.  
  360.   if (zline != NULL)
  361.     free ((pointer) zline);
  362.   if (pzsplit != NULL)
  363.     free ((pointer) pzsplit);
  364.   if (pzcomma != NULL)
  365.     free ((pointer) pzcomma);
  366.  
  367.   if (iret != UUCONF_SUCCESS)
  368.     {
  369.       qglobal->zfilename = *pz;
  370.       return iret | UUCONF_ERROR_FILENAME | UUCONF_ERROR_LINENO;
  371.     }
  372.  
  373.   if (pblock == NULL)
  374.     return UUCONF_NOT_FOUND;
  375.  
  376.   /* Now we have to put in the Permissions information.  The relevant
  377.      Permissions entries are those with this system in the MACHINE
  378.      list and (if this system does not have a VALIDATE entry) those
  379.      with a LOGNAME list but no MACHINE list.  If no entry is found
  380.      with this system in the MACHINE list, then we must look for an
  381.      entry with "OTHER" in the MACHINE list.  */
  382.   ffound_machine = FALSE;
  383.   ffound_login = FALSE;
  384.   qother_machine = NULL;
  385.   for (qperm = qglobal->qprocess->qhdb_permissions;
  386.        qperm != NULL;
  387.        qperm = qperm->qnext)
  388.     {
  389.       boolean fmachine;
  390.  
  391.       /* MACHINE=OTHER is recognized specially.  It appears that OTHER
  392.      need only be recognized by itself, not when combined with
  393.      other machine names.  */
  394.       if (qother_machine == NULL
  395.       && qperm->pzmachine != NULL
  396.       && qperm->pzmachine != (char **) &_uuconf_unset
  397.       && qperm->pzmachine[0][0] == 'O'
  398.       && strcmp (qperm->pzmachine[0], "OTHER") == 0)
  399.     qother_machine = qperm;
  400.  
  401.       /* If this system is named in a MACHINE entry, we must add the
  402.      appropriate information to every alternate that could be used
  403.      for calling out.  */
  404.       fmachine = FALSE;
  405.       if (! ffound_machine
  406.       && qperm->pzmachine != NULL
  407.       && qperm->pzmachine != (char **) &_uuconf_unset)
  408.     {
  409.       for (pz = qperm->pzmachine; *pz != NULL; pz++)
  410.         {
  411.           if ((*pz)[0] == zsystem[0]
  412.           && strcmp (*pz, zsystem) == 0)
  413.         {
  414.           for (qalt = qsys;
  415.                qalt != NULL;
  416.                qalt = qalt->uuconf_qalternate)
  417.             {
  418.               if (qalt->uuconf_fcall)
  419.             {
  420.               iret = ihadd_machine_perm (qglobal, qalt, qperm);
  421.               if (iret != UUCONF_SUCCESS)
  422.                 return iret;
  423.             }
  424.             }
  425.  
  426.           fmachine = TRUE;
  427.           ffound_machine = TRUE;
  428.  
  429.           break;
  430.         }
  431.         }
  432.     }
  433.  
  434.       /* A LOGNAME line applies to this machine if it is listed in the
  435.      corresponding VALIDATE entry, or if it is not listed in any
  436.      VALIDATE entry.  On this pass through the Permissions entry
  437.      we pick up the information if the system appears in a
  438.      VALIDATE entry; if it does not, we make another pass to put
  439.      in all the LOGNAME lines.  */
  440.       if (qperm->pzlogname != NULL
  441.       && qperm->pzlogname != (char **) &_uuconf_unset
  442.       && qperm->pzvalidate != NULL
  443.       && qperm->pzvalidate != (char **) &_uuconf_unset)
  444.     {
  445.       for (pz = qperm->pzvalidate; *pz != NULL; ++pz)
  446.         if ((*pz)[0] == zsystem[0]
  447.         && strcmp (*pz, zsystem) == 0)
  448.           break;
  449.       if (*pz != NULL)
  450.         {
  451.           for (pz = qperm->pzlogname; *pz != NULL; ++pz)
  452.         {
  453.           /* If this LOGNAME line is also a matching MACHINE
  454.              line, we can add the LOGNAME permissions to the
  455.              first alternate.  Otherwise, we must create a new
  456.              alternate.  We cannot put a LOGNAME line in the
  457.              first alternate if MACHINE does not match,
  458.              because certain permissions (e.g. READ) may be
  459.              specified by both types of lines, and we must use
  460.              LOGNAME entries only when accepting calls and
  461.              MACHINE entries only when placing calls.  */
  462.           if (fmachine
  463.               && (qsys->uuconf_zcalled_login == NULL
  464.               || (qsys->uuconf_zcalled_login
  465.                   == (char *) &_uuconf_unset)))
  466.             {
  467.               qsys->uuconf_zcalled_login = *pz;
  468.               iret = ihadd_logname_perm (qglobal, qsys, qperm);
  469.             }
  470.           else
  471.             {
  472.               struct uuconf_system *qnew;
  473.               struct uuconf_system **pq;
  474.  
  475.               qnew = ((struct uuconf_system *)
  476.                   uuconf_malloc (pblock,
  477.                          sizeof (struct uuconf_system)));
  478.               if (qnew == NULL)
  479.             {
  480.               qglobal->ierrno = errno;
  481.               return UUCONF_MALLOC_FAILED | UUCONF_ERROR_ERRNO;
  482.             }
  483.  
  484.               *qnew = *qsys;
  485.               qnew->uuconf_qalternate = NULL;
  486.               for (pq = &qsys->uuconf_qalternate;
  487.                *pq != NULL;
  488.                pq = &(*pq)->uuconf_qalternate)
  489.             ;
  490.               *pq = qnew;
  491.  
  492.               qnew->uuconf_zcalled_login = *pz;
  493.               qnew->uuconf_fcall = FALSE;
  494.               iret = ihadd_logname_perm (qglobal, qnew, qperm);
  495.             }
  496.  
  497.           if (iret != UUCONF_SUCCESS)
  498.             return iret;
  499.         }
  500.  
  501.           ffound_login = TRUE;
  502.         }
  503.     }
  504.     }
  505.  
  506.   /* If we didn't find an entry for the machine, we must use the
  507.      MACHINE=OTHER entry, if any.  */
  508.   if (! ffound_machine && qother_machine != NULL)
  509.     {
  510.       for (qalt = qsys; qalt != NULL; qalt = qalt->uuconf_qalternate)
  511.     {
  512.       if (qalt->uuconf_fcall)
  513.         {
  514.           iret = ihadd_machine_perm (qglobal, qalt, qother_machine);
  515.           if (iret != UUCONF_SUCCESS)
  516.         return iret;
  517.         }
  518.     }
  519.     }
  520.  
  521.   /* If this system was not listed in any VALIDATE entry, then we must
  522.      add a called-login for each LOGNAME entry in Permissions.  */
  523.   if (! ffound_login)
  524.     {
  525.       for (qperm = qglobal->qprocess->qhdb_permissions;
  526.        qperm != NULL;
  527.        qperm = qperm->qnext)
  528.     {
  529.       if (qperm->pzlogname == NULL
  530.           || qperm->pzlogname == (char **) &_uuconf_unset)
  531.         continue;
  532.  
  533.       for (pz = qperm->pzlogname; *pz != NULL; pz++)
  534.         {
  535.           struct uuconf_system *qnew;
  536.           struct uuconf_system **pq;
  537.  
  538.           qnew = ((struct uuconf_system *)
  539.               uuconf_malloc (pblock,
  540.                       sizeof (struct uuconf_system)));
  541.           if (qnew == NULL)
  542.         {
  543.           qglobal->ierrno = errno;
  544.           return UUCONF_MALLOC_FAILED | UUCONF_ERROR_ERRNO;
  545.         }
  546.  
  547.           *qnew = *qsys;
  548.           qnew->uuconf_qalternate = NULL;
  549.           for (pq = &qsys->uuconf_qalternate;
  550.            *pq != NULL;
  551.            pq = &(*pq)->uuconf_qalternate)
  552.         ;
  553.           *pq = qnew;
  554.  
  555.           /* We recognize LOGNAME=OTHER specially, although this
  556.          appears to be an SCO innovation.  */
  557.           if (strcmp (*pz, "OTHER") == 0)
  558.         qnew->uuconf_zcalled_login = (char *) "ANY";
  559.           else
  560.         qnew->uuconf_zcalled_login = *pz;
  561.           qnew->uuconf_fcall = FALSE;
  562.           iret = ihadd_logname_perm (qglobal, qnew, qperm);
  563.           if (iret != UUCONF_SUCCESS)
  564.         return iret;
  565.         }
  566.     }
  567.     }
  568.  
  569.   /* HDB permits local requests to receive to any directory, which is
  570.      not the default put in by _uuconf_isystem_basic_default.  We set
  571.      it here instead.  */
  572.   for (qalt = qsys; qalt != NULL; qalt = qalt->uuconf_qalternate)
  573.     {
  574.       iret = _uuconf_iadd_string (qglobal, (char *) ZROOTDIR,
  575.                   FALSE, FALSE,
  576.                   &qalt->uuconf_pzlocal_receive,
  577.                   pblock);
  578.       if (iret != UUCONF_SUCCESS)
  579.     return iret;
  580.     }
  581.  
  582.   /* HDB does not have a maximum number of retries if a retry time is
  583.      given in the time field.  */
  584.   if (qsys->uuconf_qtimegrade != NULL
  585.       && qsys->uuconf_qtimegrade != (struct uuconf_timespan *) &_uuconf_unset
  586.       && qsys->uuconf_qtimegrade->uuconf_cretry > 0)
  587.     qsys->uuconf_cmax_retries = 0;
  588.  
  589.   return UUCONF_SUCCESS;
  590. }
  591.  
  592. /* Add the settings of a MACHINE line in Permissions to a system.  */
  593.  
  594. /*ARGSIGNORED*/
  595. static int
  596. ihadd_machine_perm (qglobal, qsys, qperm)
  597.      struct sglobal *qglobal;
  598.      struct uuconf_system *qsys;
  599.      struct shpermissions *qperm;
  600. {
  601.   if (qperm->frequest >= 0)
  602.     qsys->uuconf_fsend_request = qperm->frequest;
  603.   else
  604.     qsys->uuconf_fsend_request = FALSE;
  605.   qsys->uuconf_pzremote_send = qperm->pzread;
  606.   qsys->uuconf_pzremote_receive = qperm->pzwrite;
  607.   qsys->uuconf_pzcmds = qperm->pzcommands;
  608.   qsys->uuconf_zlocalname = qperm->zmyname;
  609.   qsys->uuconf_zpubdir = qperm->zpubdir;
  610.   qsys->uuconf_pzalias = qperm->pzalias;
  611.  
  612.   return UUCONF_SUCCESS;
  613. }
  614.  
  615. /* Add the settings of a LOGNAME line in Permissions to a system.  */
  616.  
  617. /*ARGSIGNORED*/
  618. static int
  619. ihadd_logname_perm (qglobal, qsys, qperm)
  620.      struct sglobal *qglobal;
  621.      struct uuconf_system *qsys;
  622.      struct shpermissions *qperm;
  623. {
  624.   qsys->uuconf_fcalled = TRUE;
  625.   if (qperm->frequest >= 0)
  626.     qsys->uuconf_fsend_request = qperm->frequest;
  627.   else
  628.     qsys->uuconf_fsend_request = FALSE;
  629.   qsys->uuconf_fcalled_transfer = qperm->fsendfiles;
  630.   qsys->uuconf_pzremote_send = qperm->pzread;
  631.   qsys->uuconf_pzremote_receive = qperm->pzwrite;
  632.   qsys->uuconf_fcallback = qperm->fcallback;
  633.   qsys->uuconf_zlocalname = qperm->zmyname;
  634.   qsys->uuconf_zpubdir = qperm->zpubdir;
  635.  
  636.   return UUCONF_SUCCESS;
  637. }
  638.