Return to uuconv.c CVS log

Up to [MW Coherent from dump] / coherent / g / usr / lib / uucp / tay104

Annotation of coherent/g/usr/lib/uucp/tay104/uuconv.c, revision 1.1

1.1     ! root        1: /* uuconv.c
        !             2:    Convert one type of UUCP configuration file to another.
        !             3: 
        !             4:    Copyright (C) 1991, 1992 Ian Lance Taylor
        !             5: 
        !             6:    This file is part of the Taylor UUCP package.
        !             7: 
        !             8:    This program is free software; you can redistribute it and/or
        !             9:    modify it under the terms of the GNU General Public License as
        !            10:    published by the Free Software Foundation; either version 2 of the
        !            11:    License, or (at your option) any later version.
        !            12: 
        !            13:    This program is distributed in the hope that it will be useful, but
        !            14:    WITHOUT ANY WARRANTY; without even the implied warranty of
        !            15:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
        !            16:    General Public License for more details.
        !            17: 
        !            18:    You should have received a copy of the GNU General Public License
        !            19:    along with this program; if not, write to the Free Software
        !            20:    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
        !            21: 
        !            22:    The author of the program may be contacted at [email protected] or
        !            23:    c/o Infinity Development Systems, P.O. Box 520, Waltham, MA 02254.
        !            24:    */
        !            25: 
        !            26: #include "uucnfi.h"
        !            27: 
        !            28: #if USE_RCS_ID
        !            29: const char uuconv_rcsid[] = "$Id: uuconv.c,v 1.1 93/07/30 07:58:14 bin Exp Locker: bin $";
        !            30: #endif
        !            31: 
        !            32: #include "getopt.h"
        !            33: 
        !            34: /* Local functions.  */
        !            35: 
        !            36: static void uvusage P((void));
        !            37: static void uvwrite_time P((FILE *e, struct uuconf_timespan *qtime));
        !            38: static void uvwrite_string P((FILE *e, const char *zarg, const char *zcmd));
        !            39: static void uvwrite_size P((FILE *e, struct uuconf_timespan *qsize,
        !            40:                            const char *zcmd));
        !            41: static void uvwrite_boolean P((FILE *e, int iarg, const char *zcmd));
        !            42: static void uvwrite_string_array P((FILE *e, char **pz, const char *zcmd));
        !            43: static void uvwrite_chat_script P((FILE *e, char **pz));
        !            44: static void uvwrite_chat P((FILE *e, const struct uuconf_chat *qchat,
        !            45:                            const struct uuconf_chat *qlast,
        !            46:                            const char *zprefix, boolean fforce));
        !            47: static void uvwrite_proto_params P((FILE *e,
        !            48:                                    const struct uuconf_proto_param *qparam,
        !            49:                                    const char *zprefix));
        !            50: static void uvwrite_taylor_system P((FILE *e,
        !            51:                                     const struct uuconf_system *qsys));
        !            52: static void uvwrite_v2_system P((FILE *e,
        !            53:                                 const struct uuconf_system *qsys));
        !            54: static void uvwrite_hdb_system P((FILE *e,
        !            55:                                  const struct uuconf_system *qsys));
        !            56: static boolean fvperm_string_cmp P((const char *z1, const char *z2));
        !            57: static boolean fvperm_array_cmp P((const char **pz1, const char **pz2));
        !            58: static void uvadd_perm P((struct shpermissions *qadd));
        !            59: static void uvwrite_perms P((void));
        !            60: static void uvwrite_perm_array P((FILE *e, const char **pz,
        !            61:                                  const char *zcmd, size_t *pccol));
        !            62: static void uvwrite_perm_boolean P((FILE *e, int f, const char *zcmd,
        !            63:                                    size_t *pccol, boolean fsendfiles));
        !            64: static void uvwrite_perm_rw_array P((FILE *e, const char **pz,
        !            65:                                     const char *zcmd, size_t *pccol));
        !            66: static void uvwrite_perm_string P((FILE *e, const char *z, const char *zcmd,
        !            67:                                   size_t *pccol));
        !            68: static int ivwrite_taylor_port P((struct uuconf_port *qport,
        !            69:                                  pointer pinfo));
        !            70: static int ivwrite_v2_port P((struct uuconf_port *qport, pointer pinfo));
        !            71: static int ivwrite_hdb_port P((struct uuconf_port *qport, pointer pinfo));
        !            72: static void uvwrite_taylor_port P((FILE *e, struct uuconf_port *qport,
        !            73:                                   const char *zprefix));
        !            74: static void uvwrite_taylor_dialer P((FILE *e, struct uuconf_dialer *qdialer,
        !            75:                                     const char *zprefix));
        !            76: static void uvwrite_hdb_dialer P((FILE *e, struct uuconf_dialer *qdialer));
        !            77: static void uvuuconf_error P((pointer puuconf, int iret));
        !            78: 
        !            79: /* A list of Permissions entries built when writing out HDB system
        !            80:    information.  */
        !            81: static struct shpermissions *qVperms;
        !            82: 
        !            83: /* Type of configuration file.  */
        !            84: enum tconfig
        !            85: {
        !            86:   CONFIG_TAYLOR,
        !            87:   CONFIG_V2,
        !            88:   CONFIG_HDB
        !            89: };
        !            90: 
        !            91: /* Long getopt options.  */
        !            92: static const struct option asVlongopts[] = { { NULL, 0, NULL, 0 } };
        !            93: 
        !            94: int
        !            95: main (argc, argv)
        !            96:      int argc;
        !            97:      char **argv;
        !            98: {
        !            99:   /* -I: The configuration file name.  */
        !           100:   const char *zconfig = NULL;
        !           101:   /* -i: Input type.  */
        !           102:   const char *zinput = NULL;
        !           103:   /* -o: Output type.  */
        !           104:   const char *zoutput = NULL;
        !           105:   /* -p: Program name.  */
        !           106:   const char *zprogram = NULL;
        !           107:   int iopt;
        !           108:   enum tconfig tinput, toutput;
        !           109:   int iret;
        !           110:   pointer pinput;
        !           111: 
        !           112:   while ((iopt = getopt_long (argc, argv, "i:I:o:p:x:", asVlongopts,
        !           113:                              (int *) NULL)) != EOF)
        !           114:     {
        !           115:       switch (iopt)
        !           116:        {
        !           117:        case 'i':
        !           118:          /* Input type.  */
        !           119:          zinput = optarg;
        !           120:          break;
        !           121: 
        !           122:        case 'o':
        !           123:          /* Output type.  */
        !           124:          zoutput = optarg;
        !           125:          break;
        !           126: 
        !           127:        case 'p':
        !           128:          /* Program name.  */
        !           129:          zprogram = optarg;
        !           130:          break;
        !           131: 
        !           132:        case 'I':
        !           133:          /* Set the configuration file name.  */
        !           134:          zconfig = optarg;
        !           135:          break;
        !           136: 
        !           137:        case 'x':
        !           138:          /* Set the debugging level.  */
        !           139:          break;
        !           140: 
        !           141:        case 0:
        !           142:          /* Long option found and flag set.  */
        !           143:          break;
        !           144: 
        !           145:        default:
        !           146:          uvusage ();
        !           147:          break;
        !           148:        }
        !           149:     }
        !           150: 
        !           151:   if (optind != argc
        !           152:       || zinput == NULL
        !           153:       || zoutput == NULL)
        !           154:     uvusage ();
        !           155: 
        !           156:   if (strcasecmp (zinput, "taylor") == 0)
        !           157:     tinput = CONFIG_TAYLOR;
        !           158:   else if (strcasecmp (zinput, "v2") == 0)
        !           159:     tinput = CONFIG_V2;
        !           160:   else if (strcasecmp (zinput, "hdb") == 0)
        !           161:     tinput = CONFIG_HDB;
        !           162:   else
        !           163:     {
        !           164:       uvusage ();
        !           165:       tinput = CONFIG_TAYLOR;
        !           166:     }
        !           167: 
        !           168:   if (strcasecmp (zoutput, "taylor") == 0)
        !           169:     toutput = CONFIG_TAYLOR;
        !           170:   else if (strcasecmp (zoutput, "v2") == 0)
        !           171:     toutput = CONFIG_V2;
        !           172:   else if (strcasecmp (zoutput, "hdb") == 0)
        !           173:     toutput = CONFIG_HDB;
        !           174:   else
        !           175:     {
        !           176:       uvusage ();
        !           177:       toutput = CONFIG_TAYLOR;
        !           178:     }
        !           179: 
        !           180:   if (tinput == toutput)
        !           181:     uvusage ();
        !           182: 
        !           183:   iret = UUCONF_SUCCESS;
        !           184: 
        !           185:   /* Initialize the input.  */
        !           186:   pinput = NULL;
        !           187:   switch (tinput)
        !           188:     {
        !           189:     case CONFIG_TAYLOR:
        !           190:       iret = uuconf_taylor_init (&pinput, zprogram, zconfig);
        !           191:       break;
        !           192:     case CONFIG_V2:
        !           193:       iret = uuconf_v2_init (&pinput);
        !           194:       break;
        !           195:     case CONFIG_HDB:
        !           196:       iret = uuconf_hdb_init (&pinput, zprogram);
        !           197:       break;
        !           198:     }
        !           199:   if (iret != UUCONF_SUCCESS)
        !           200:     {
        !           201:       uvuuconf_error (pinput, iret);
        !           202:       exit (EXIT_FAILURE);
        !           203:     }
        !           204: 
        !           205:   {
        !           206:     char **pzsystems;
        !           207:     char *zsys;
        !           208:     char abtaylor[sizeof ZCURDIR + sizeof SYSFILE - 1];
        !           209:     char abv2[sizeof ZCURDIR + sizeof V2_SYSTEMS - 1];
        !           210:     char abhdb[sizeof ZCURDIR + sizeof HDB_SYSTEMS - 1];
        !           211:     FILE *esys;
        !           212:     char **pz;
        !           213: 
        !           214:     /* Get the list of systems.  */
        !           215:     switch (tinput)
        !           216:       {
        !           217:       case CONFIG_TAYLOR:
        !           218:        iret = uuconf_taylor_system_names (pinput, &pzsystems, FALSE);
        !           219:        break;
        !           220:       case CONFIG_V2:
        !           221:        iret = uuconf_v2_system_names (pinput, &pzsystems, FALSE);
        !           222:        break;
        !           223:       case CONFIG_HDB:
        !           224:        iret = uuconf_hdb_system_names (pinput, &pzsystems, FALSE);
        !           225:        break;
        !           226:       }
        !           227:     if (iret != UUCONF_SUCCESS)
        !           228:       uvuuconf_error (pinput, iret);
        !           229:     else
        !           230:       {
        !           231:        /* Open the sys file for the output type.  */
        !           232:        switch (toutput)
        !           233:          {
        !           234:          default:
        !           235:          case CONFIG_TAYLOR:
        !           236:            sprintf (abtaylor, "%s%s", ZCURDIR, SYSFILE);
        !           237:            zsys = abtaylor;
        !           238:            break;
        !           239:          case CONFIG_V2:
        !           240:            sprintf (abv2, "%s%s", ZCURDIR, V2_SYSTEMS);
        !           241:            zsys = abv2;
        !           242:            break;
        !           243:          case CONFIG_HDB:
        !           244:            sprintf (abhdb, "%s%s", ZCURDIR, HDB_SYSTEMS);
        !           245:            zsys = abhdb;
        !           246:            break;
        !           247:          }
        !           248:        esys = fopen (zsys, "w");
        !           249:        if (esys == NULL)
        !           250:          {
        !           251:            fprintf (stderr, "uuchk:%s: ", zsys);
        !           252:            perror ("fopen");
        !           253:            exit (EXIT_FAILURE);
        !           254:          }
        !           255: 
        !           256:        fprintf (esys, "# %s file automatically generated by uuconv.\n",
        !           257:                 zsys);
        !           258: 
        !           259:        /* Read and write each system.  We cheat and call the internal
        !           260:           routines, so that we can easily detect default information and
        !           261:           not write it out.  This isn't necessary, but it makes the output
        !           262:           smaller and simpler.  */
        !           263:        for (pz = pzsystems; *pz != NULL; pz++)
        !           264:          {
        !           265:            struct uuconf_system ssys;
        !           266: 
        !           267:            switch (tinput)
        !           268:              {
        !           269:              case CONFIG_TAYLOR:
        !           270:                iret = _uuconf_itaylor_system_internal (pinput, *pz, &ssys);
        !           271:                break;
        !           272:              case CONFIG_V2:
        !           273:                iret = _uuconf_iv2_system_internal (pinput, *pz, &ssys);
        !           274:                break;
        !           275:              case CONFIG_HDB:
        !           276:                iret = _uuconf_ihdb_system_internal (pinput, *pz, &ssys);
        !           277:                break;
        !           278:              }
        !           279:            if (iret != UUCONF_SUCCESS)
        !           280:              uvuuconf_error (pinput, iret);
        !           281:            else
        !           282:              {
        !           283:                switch (toutput)
        !           284:                  {
        !           285:                  case CONFIG_TAYLOR:
        !           286:                    uvwrite_taylor_system (esys, &ssys);
        !           287:                    break;
        !           288:                  case CONFIG_V2:
        !           289:                    uvwrite_v2_system (esys, &ssys);
        !           290:                    break;
        !           291:                  case CONFIG_HDB:
        !           292:                    uvwrite_hdb_system (esys, &ssys);
        !           293:                    break;
        !           294:                  }
        !           295:                if (toutput != CONFIG_HDB)
        !           296:                  (void) uuconf_system_free (pinput, &ssys);
        !           297:              }
        !           298:          }
        !           299: 
        !           300:        if (toutput == CONFIG_HDB)
        !           301:          uvwrite_perms ();
        !           302: 
        !           303:        if (ferror (esys)
        !           304:            || fclose (esys) == EOF)
        !           305:          {
        !           306:            fprintf (stderr, "uuchk:%s: error during output\n", zsys);
        !           307:            exit (EXIT_FAILURE);
        !           308:          }
        !           309:       }
        !           310:   }
        !           311: 
        !           312:   {
        !           313:     /* Open the port file for the output type.  */
        !           314:     char *zport;
        !           315:     char abtaylor[sizeof ZCURDIR + sizeof PORTFILE - 1];
        !           316:     char abv2[sizeof ZCURDIR + sizeof V2_DEVICES - 1];
        !           317:     char abhdb[sizeof ZCURDIR + sizeof HDB_DEVICES - 1];
        !           318:     FILE *eport;
        !           319:     int (*piportfn) P((struct uuconf_port *, pointer));
        !           320:     struct uuconf_port sport;
        !           321: 
        !           322:     switch (toutput)
        !           323:       {
        !           324:       default:
        !           325:       case CONFIG_TAYLOR:
        !           326:        sprintf (abtaylor, "%s%s", ZCURDIR, PORTFILE);
        !           327:        zport = abtaylor;
        !           328:        piportfn = ivwrite_taylor_port;
        !           329:        break;
        !           330:       case CONFIG_V2:
        !           331:        sprintf (abv2, "%s%s", ZCURDIR, V2_DEVICES);
        !           332:        zport = abv2;
        !           333:        piportfn = ivwrite_v2_port;
        !           334:        break;
        !           335:       case CONFIG_HDB:
        !           336:        sprintf (abhdb, "%s%s", ZCURDIR, HDB_DEVICES);
        !           337:        zport = abhdb;
        !           338:        piportfn = ivwrite_hdb_port;
        !           339:        break;
        !           340:       }
        !           341:     eport = fopen (zport, "w");
        !           342:     if (eport == NULL)
        !           343:       {
        !           344:        fprintf (stderr, "uuchk:%s: ", zport);
        !           345:        perror ("fopen");
        !           346:        exit (EXIT_FAILURE);
        !           347:       }
        !           348: 
        !           349:     fprintf (eport, "# %s file automatically generated by uuconv.\n", zport);
        !           350: 
        !           351:     switch (tinput)
        !           352:       {
        !           353:       case CONFIG_TAYLOR:
        !           354:        iret = uuconf_taylor_find_port (pinput, (const char *) NULL, 0L,
        !           355:                                        0L, piportfn, (pointer) eport,
        !           356:                                        &sport);
        !           357:        break;
        !           358:       case CONFIG_V2:
        !           359:        iret = uuconf_v2_find_port (pinput, (const char *) NULL, 0L, 0L,
        !           360:                                    piportfn, (pointer) eport, &sport);
        !           361:        break;
        !           362:       case CONFIG_HDB:
        !           363:        iret = uuconf_hdb_find_port (pinput, (const char *) NULL, 0L, 0L,
        !           364:                                     piportfn, (pointer) eport, &sport);
        !           365:        break;
        !           366:       }
        !           367:        
        !           368:     if (iret != UUCONF_NOT_FOUND)
        !           369:       uvuuconf_error (pinput, iret);
        !           370: 
        !           371:     if (ferror (eport)
        !           372:        || fclose (eport) == EOF)
        !           373:       {
        !           374:        fprintf (stderr, "uuchk:%s: error during output\n", zport);
        !           375:        exit (EXIT_FAILURE);
        !           376:       }
        !           377:   }
        !           378: 
        !           379:   /* V2 configuration files don't support dialers.  */
        !           380:   if (tinput != CONFIG_V2 && toutput != CONFIG_V2)
        !           381:     {
        !           382:       char **pzdialers;
        !           383:       char *zdialer;
        !           384:       char abtaylor[sizeof ZCURDIR + sizeof DIALFILE - 1];
        !           385:       char abhdb[sizeof ZCURDIR + sizeof HDB_DIALERS - 1];
        !           386:       FILE *edialer;
        !           387:       char **pz;
        !           388: 
        !           389:       /* Get the list of dialers.  */
        !           390:       switch (tinput)
        !           391:        {
        !           392:        default:
        !           393:        case CONFIG_TAYLOR:
        !           394:          iret = uuconf_taylor_dialer_names (pinput, &pzdialers);
        !           395:          break;
        !           396:        case CONFIG_HDB:
        !           397:          iret = uuconf_hdb_dialer_names (pinput, &pzdialers);
        !           398:          break;
        !           399:        }
        !           400:       if (iret != UUCONF_SUCCESS)
        !           401:        uvuuconf_error (pinput, iret);
        !           402:       else
        !           403:        {
        !           404:          /* Open the sys file for the output type.  */
        !           405:          switch (toutput)
        !           406:            {
        !           407:            default:
        !           408:            case CONFIG_TAYLOR:
        !           409:              sprintf (abtaylor, "%s%s", ZCURDIR, DIALFILE);
        !           410:              zdialer = abtaylor;
        !           411:              break;
        !           412:            case CONFIG_HDB:
        !           413:              sprintf (abhdb, "%s%s", ZCURDIR, HDB_DIALERS);
        !           414:              zdialer = abhdb;
        !           415:              break;
        !           416:            }
        !           417:          edialer = fopen (zdialer, "w");
        !           418:          if (edialer == NULL)
        !           419:            {
        !           420:              fprintf (stderr, "uuchk:%s: ", zdialer);
        !           421:              perror ("fopen");
        !           422:              exit (EXIT_FAILURE);
        !           423:            }
        !           424: 
        !           425:          fprintf (edialer, "# %s file automatically generated by uuconv.\n",
        !           426:                   zdialer);
        !           427: 
        !           428:          /* Read and write each dialer.  */
        !           429:          for (pz = pzdialers; *pz != NULL; pz++)
        !           430:            {
        !           431:              struct uuconf_dialer sdialer;
        !           432: 
        !           433:              switch (tinput)
        !           434:                {
        !           435:                default:
        !           436:                case CONFIG_TAYLOR:
        !           437:                  iret = uuconf_taylor_dialer_info (pinput, *pz, &sdialer);
        !           438:                  break;
        !           439:                case CONFIG_HDB:
        !           440:                  iret = uuconf_hdb_dialer_info (pinput, *pz, &sdialer);
        !           441:                  break;
        !           442:                }
        !           443:              if (iret != UUCONF_SUCCESS)
        !           444:                uvuuconf_error (pinput, iret);
        !           445:              else
        !           446:                {
        !           447:                  switch (toutput)
        !           448:                    {
        !           449:                    default:
        !           450:                    case CONFIG_TAYLOR:
        !           451:                      fprintf (edialer, "# Start of dialer %s\n",
        !           452:                               sdialer.uuconf_zname);
        !           453:                      fprintf (edialer, "dialer %s\n", sdialer.uuconf_zname);
        !           454:                      uvwrite_taylor_dialer (edialer, &sdialer, "");
        !           455:                      break;
        !           456:                    case CONFIG_HDB:
        !           457:                      uvwrite_hdb_dialer (edialer, &sdialer);
        !           458:                      break;
        !           459:                    }
        !           460:                  (void) uuconf_dialer_free (pinput, &sdialer);
        !           461:                }
        !           462:            }
        !           463: 
        !           464:          if (ferror (edialer)
        !           465:              || fclose (edialer) == EOF)
        !           466:            {
        !           467:              fprintf (stderr, "uuchk:%s: error during output\n", zdialer);
        !           468:              exit (EXIT_FAILURE);
        !           469:            }
        !           470:        }
        !           471:     }
        !           472: 
        !           473:   exit (EXIT_SUCCESS);
        !           474: }
        !           475: 
        !           476: /* Print out a usage message and die.  */
        !           477: 
        !           478: static void
        !           479: uvusage ()
        !           480: {
        !           481:   fprintf (stderr,
        !           482:           "Taylor UUCP version %s, copyright (C) 1991, 1992 Ian Lance Taylor\n",
        !           483:           VERSION);
        !           484:   fprintf (stderr,
        !           485:           "Usage: uuconv -i input -o output [-p program] [-I file]\n");
        !           486:   fprintf (stderr,
        !           487:           " -i input: Set input type (one of taylor, v2, hdb)\n");
        !           488:   fprintf (stderr,
        !           489:           " -o output: Set output type (one of taylor, v2, hdb)\n");
        !           490:   fprintf (stderr,
        !           491:           " -p program: Program to convert (e.g., uucp or cu)\n");
        !           492:   fprintf (stderr,
        !           493:           " -I file: Set Taylor UUCP configuration file to use\n");
        !           494:   exit (EXIT_FAILURE);
        !           495: }
        !           496: 
        !           497: /* Write out a timespan.  */
        !           498: 
        !           499: static void
        !           500: uvwrite_time (e, qtime)
        !           501:      FILE *e;
        !           502:      struct uuconf_timespan *qtime;
        !           503: {
        !           504:   if (qtime == NULL)
        !           505:     {
        !           506:       fprintf (e, "Never");
        !           507:       return;
        !           508:     }
        !           509: 
        !           510:   if (qtime->uuconf_istart == 0 && qtime->uuconf_iend == 7 * 24 * 60)
        !           511:     {
        !           512:       fprintf (e, "Any");
        !           513:       return;
        !           514:     }
        !           515: 
        !           516:   for (; qtime != NULL; qtime = qtime->uuconf_qnext)
        !           517:     {
        !           518:       int idaystart, idayend;
        !           519:       int ihourstart, ihourend;
        !           520:       int iminutestart, iminuteend;
        !           521:       const char * const zdays = "Su\0Mo\0Tu\0We\0Th\0Fr\0Sa";
        !           522: 
        !           523:       idaystart = qtime->uuconf_istart / (24 * 60);
        !           524:       ihourstart = (qtime->uuconf_istart % (24 * 60)) / 60;
        !           525:       iminutestart = qtime->uuconf_istart % 60;
        !           526:       if (qtime->uuconf_iend >= 7 * 24 * 60)
        !           527:        qtime->uuconf_iend = 7 * 24 * 60 - 1;
        !           528:       idayend = qtime->uuconf_iend / (24 * 60);
        !           529:       ihourend = (qtime->uuconf_iend % (24 * 60)) / 60;
        !           530:       iminuteend = qtime->uuconf_iend % 60;
        !           531:       if (ihourend == 0 && iminuteend == 0)
        !           532:        --idayend;
        !           533: 
        !           534:       if (idaystart == idayend)
        !           535:        fprintf (e, "%s%02d%02d-%02d%02d", zdays + idaystart * 3,
        !           536:                 ihourstart, iminutestart, ihourend, iminuteend);
        !           537:       else
        !           538:        {
        !           539:          int i;
        !           540: 
        !           541:          fprintf (e, "%s%02d%02d-0000", zdays + idaystart * 3,
        !           542:                   ihourstart, iminutestart);
        !           543:          for (i = idaystart + 1; i < idayend; i++)
        !           544:            fprintf (e, ",%s", zdays + i * 3);
        !           545:          if (ihourend != 0 || iminuteend != 0)
        !           546:            fprintf (e, ",%s0000-%02d%02d", zdays + idayend * 3, ihourend,
        !           547:                     iminuteend);
        !           548:        }
        !           549: 
        !           550:       if (qtime->uuconf_qnext != NULL)
        !           551:        fprintf (e, ",");
        !           552:     }
        !           553: }
        !           554: 
        !           555: /* Some subroutines used when writing out Taylor UUCP configuration
        !           556:    files.  */
        !           557: 
        !           558: /* Write a command with a string argument.  */
        !           559: 
        !           560: static void
        !           561: uvwrite_string (e, zarg, zcmd)
        !           562:      FILE *e;
        !           563:      const char *zarg;
        !           564:      const char *zcmd;
        !           565: {
        !           566:   if (zarg != (const char *) &_uuconf_unset)
        !           567:     fprintf (e, "%s %s\n", zcmd, zarg == NULL ? (const char *) "" : zarg);
        !           568: }
        !           569: 
        !           570: /* Write out a size restriction command.  */
        !           571: 
        !           572: static void
        !           573: uvwrite_size (e, qtime, zcmd)
        !           574:      FILE *e;
        !           575:      struct uuconf_timespan *qtime;
        !           576:      const char *zcmd;
        !           577: {
        !           578:   if (qtime != (struct uuconf_timespan *) &_uuconf_unset)
        !           579:     {
        !           580:       for (; qtime != NULL; qtime = qtime->uuconf_qnext)
        !           581:        {
        !           582:          fprintf (e, "%s %ld", zcmd, qtime->uuconf_ival);
        !           583:          uvwrite_time (e, qtime);
        !           584:          fprintf (e, "\n");
        !           585:        }
        !           586:     }
        !           587: }
        !           588: 
        !           589: /* Write out a boolean argument with a string command.  If the value
        !           590:    is less than zero, than it was uninitialized and we don't write
        !           591:    anything.  */
        !           592: 
        !           593: static void
        !           594: uvwrite_boolean (e, fval, zcmd)
        !           595:      FILE *e;
        !           596:      int fval;
        !           597:      const char *zcmd;
        !           598: {
        !           599:   if (fval >= 0)
        !           600:     fprintf (e, "%s %s\n", zcmd, fval > 0 ? "true" : "false");
        !           601: }
        !           602: 
        !           603: /* Write out a string array as a single command.  */
        !           604: 
        !           605: static void
        !           606: uvwrite_string_array (e, pz, zcmd)
        !           607:      FILE *e;
        !           608:      char **pz;
        !           609:      const char *zcmd;
        !           610: {
        !           611:   if (pz != (char **) &_uuconf_unset)
        !           612:     {
        !           613:       fprintf (e, "%s", zcmd);
        !           614:       if (pz != NULL)
        !           615:        for (; *pz != NULL; pz++)
        !           616:          fprintf (e, " %s", *pz);
        !           617:       fprintf (e, "\n");
        !           618:     }
        !           619: }
        !           620: 
        !           621: /* Write out a chat script.  Don't separate subsend/subexpect strings
        !           622:    by spaces.  */
        !           623: 
        !           624: static void
        !           625: uvwrite_chat_script (e, pzarg)
        !           626:      FILE *e;
        !           627:      char **pzarg;
        !           628: {
        !           629:   char **pz;
        !           630: 
        !           631:   if (pzarg == NULL || pzarg == (char **) &_uuconf_unset)
        !           632:     return;
        !           633: 
        !           634:   for (pz = pzarg; *pz != NULL; pz++)
        !           635:     {
        !           636:       if ((*pz)[0] != '-' && pz != pzarg)
        !           637:        fprintf (e, " ");
        !           638:       fprintf (e, *pz);
        !           639:     }
        !           640: }
        !           641: 
        !           642: /* Write out chat information.  If the qlast argument is not NULL,
        !           643:    then only values that are different from qlast should be written.
        !           644:    The fforce argument is used to get around a peculiar problem: if
        !           645:    the ``chat'' command is used with no arguments for a system, then
        !           646:    uuconf_pzchat will be NULL (not &_uuconf_unset) and the default
        !           647:    chat script will not be used.  We must distinguish this case from
        !           648:    the ``chat'' command not appearing at all for a port or dialer, in
        !           649:    which case the value will again be NULL.  In the former case we
        !           650:    must output a ``chat'' command, in the latter case we would prefer
        !           651:    not to.  */
        !           652: 
        !           653: static void
        !           654: uvwrite_chat (e, q, qlast, zprefix, fforce)
        !           655:      FILE *e;
        !           656:      const struct uuconf_chat *q;
        !           657:      const struct uuconf_chat *qlast;
        !           658:      const char *zprefix;
        !           659:      boolean fforce;
        !           660: {
        !           661:   char **pz;
        !           662:   char ab[100];
        !           663: 
        !           664:   if (q->uuconf_pzchat != (char **) &_uuconf_unset
        !           665:       && (qlast == NULL
        !           666:          ? (fforce || q->uuconf_pzchat != NULL)
        !           667:          : qlast->uuconf_pzchat != q->uuconf_pzchat))
        !           668:     {
        !           669:       fprintf (e, "%schat ", zprefix);
        !           670:       uvwrite_chat_script (e, q->uuconf_pzchat);
        !           671:       fprintf (e, "\n");
        !           672:     }
        !           673: 
        !           674:   if (q->uuconf_pzprogram != (char **) &_uuconf_unset
        !           675:       && (qlast == NULL
        !           676:          ? q->uuconf_pzprogram != NULL
        !           677:          : qlast->uuconf_pzprogram != q->uuconf_pzprogram))
        !           678:     {
        !           679:       sprintf (ab, "%schat-program", zprefix);
        !           680:       uvwrite_string_array (e, q->uuconf_pzprogram, ab);
        !           681:     }
        !           682: 
        !           683:   if (q->uuconf_ctimeout >= 0
        !           684:       && (qlast == NULL
        !           685:          || qlast->uuconf_ctimeout != q->uuconf_ctimeout))
        !           686:     fprintf (e, "%schat-timeout %d\n", zprefix, q->uuconf_ctimeout);
        !           687: 
        !           688:   if (q->uuconf_pzfail != NULL
        !           689:       && q->uuconf_pzfail != (char **) &_uuconf_unset
        !           690:       && (qlast == NULL
        !           691:          || qlast->uuconf_pzfail != q->uuconf_pzfail))
        !           692:     for (pz = q->uuconf_pzfail; *pz != NULL; pz++)
        !           693:       fprintf (e, "%schat-fail %s\n", zprefix, *pz);
        !           694:       
        !           695:   if (qlast == NULL || qlast->uuconf_fstrip != q->uuconf_fstrip)
        !           696:     {
        !           697:       sprintf (ab, "%schat-strip", zprefix);
        !           698:       uvwrite_boolean (e, q->uuconf_fstrip, ab);
        !           699:     }
        !           700: }
        !           701: 
        !           702: /* Write out protocol parameters to a Taylor UUCP file.  */
        !           703: 
        !           704: static void
        !           705: uvwrite_proto_params (e, qparams, zprefix)
        !           706:      FILE *e;
        !           707:      const struct uuconf_proto_param *qparams;
        !           708:      const char *zprefix;
        !           709: {
        !           710:   const struct uuconf_proto_param *qp;
        !           711: 
        !           712:   if (qparams == NULL
        !           713:       || qparams == (struct uuconf_proto_param *) &_uuconf_unset)
        !           714:     return;
        !           715: 
        !           716:   for (qp = qparams; qp->uuconf_bproto != '\0'; qp++)
        !           717:     {
        !           718:       const struct uuconf_proto_param_entry *qe;
        !           719: 
        !           720:       for (qe = qp->uuconf_qentries; qe->uuconf_cargs > 0; qe++)
        !           721:        {
        !           722:          int i;
        !           723: 
        !           724:          fprintf (e, "%sprotocol-parameter %c", zprefix, qp->uuconf_bproto);
        !           725:          for (i = 0; i < qe->uuconf_cargs; i++)
        !           726:            fprintf (e, " %s", qe->uuconf_pzargs[i]);
        !           727:          fprintf (e, "\n");
        !           728:        }
        !           729:     }
        !           730: }
        !           731: 
        !           732: /* Write out Taylor UUCP system information.  */
        !           733: 
        !           734: static void
        !           735: uvwrite_taylor_system (e, q)
        !           736:      FILE *e;
        !           737:      const struct uuconf_system *q;
        !           738: {
        !           739:   char **pz;
        !           740:   const struct uuconf_system *qlast;
        !           741: 
        !           742:   fprintf (e, "# Start of system %s\n", q->uuconf_zname);
        !           743: 
        !           744:   fprintf (e, "system %s\n", q->uuconf_zname);
        !           745:   if (q->uuconf_pzalias != NULL
        !           746:       && q->uuconf_pzalias != (char **) &_uuconf_unset)
        !           747:     for (pz = q->uuconf_pzalias; *pz != NULL; pz++)
        !           748:       uvwrite_string (e, *pz, "alias");
        !           749: 
        !           750:   for (qlast = NULL; q != NULL; qlast = q, q = q->uuconf_qalternate)
        !           751:     {
        !           752:       struct uuconf_timespan *qtime;
        !           753: 
        !           754:       if (qlast != NULL)
        !           755:        {
        !           756:          fprintf (e, "alternate");
        !           757:          if (q->uuconf_zalternate != (char *) &_uuconf_unset
        !           758:              && q->uuconf_zalternate != NULL)
        !           759:            fprintf (e, " %s", q->uuconf_zalternate);
        !           760:          fprintf (e, "\n");
        !           761:        }
        !           762: 
        !           763: #define CHANGED(x) (qlast == NULL || qlast->x != q->x)
        !           764: 
        !           765:       if (CHANGED (uuconf_qtimegrade)
        !           766:          && (q->uuconf_qtimegrade
        !           767:              != (struct uuconf_timespan *) &_uuconf_unset))
        !           768:        {
        !           769:          if (q->uuconf_qtimegrade == NULL)
        !           770:            fprintf (e, "time never\n");
        !           771:          else
        !           772:            {
        !           773:              for (qtime = q->uuconf_qtimegrade;
        !           774:                   qtime != NULL;
        !           775:                   qtime = qtime->uuconf_qnext)
        !           776:                {
        !           777:                  if ((char) qtime->uuconf_ival == UUCONF_GRADE_LOW)
        !           778:                    fprintf (e, "time ");
        !           779:                  else
        !           780:                    fprintf (e, "timegrade %c ", (char) qtime->uuconf_ival);
        !           781:                  uvwrite_time (e, qtime);
        !           782:                  if (qtime->uuconf_cretry != 0)
        !           783:                    fprintf (e, " %d", qtime->uuconf_cretry);
        !           784:                  fprintf (e, "\n");
        !           785:                }
        !           786:            }
        !           787:        }
        !           788: 
        !           789:       if (CHANGED (uuconf_qcalltimegrade)
        !           790:          && (q->uuconf_qcalltimegrade
        !           791:              != (struct uuconf_timespan *) &_uuconf_unset))
        !           792:        {
        !           793:          for (qtime = q->uuconf_qcalltimegrade;
        !           794:               qtime != NULL;
        !           795:               qtime = qtime->uuconf_qnext)
        !           796:            {
        !           797:              fprintf (e, "call-timegrade %c ", (char) qtime->uuconf_ival);
        !           798:              uvwrite_time (e, qtime);
        !           799:              fprintf (e, "\n");
        !           800:            }
        !           801:        }
        !           802: 
        !           803:       if (CHANGED (uuconf_qcall_local_size))
        !           804:        uvwrite_size (e, q->uuconf_qcall_local_size, "call-local-size");
        !           805: 
        !           806:       if (CHANGED (uuconf_qcall_remote_size))
        !           807:        uvwrite_size (e, q->uuconf_qcall_remote_size, "call-remote-size");
        !           808: 
        !           809:       if (CHANGED (uuconf_qcalled_local_size))
        !           810:        uvwrite_size (e, q->uuconf_qcalled_local_size, "called-local-size");
        !           811: 
        !           812:       if (CHANGED (uuconf_qcalled_remote_size))
        !           813:        uvwrite_size (e, q->uuconf_qcalled_remote_size, "called-remote-size");
        !           814: 
        !           815:       if (CHANGED (uuconf_ibaud) || CHANGED (uuconf_ihighbaud))
        !           816:        {
        !           817:          if (q->uuconf_ibaud >= 0)
        !           818:            {
        !           819:              if (q->uuconf_ihighbaud > 0)
        !           820:                fprintf (e, "baud-range %ld %ld\n", q->uuconf_ibaud,
        !           821:                         q->uuconf_ihighbaud);
        !           822:              else
        !           823:                fprintf (e, "baud %ld\n", q->uuconf_ibaud);
        !           824:            }
        !           825:        }
        !           826: 
        !           827:       if (CHANGED (uuconf_zport) || CHANGED (uuconf_qport))
        !           828:        {
        !           829:          if (q->uuconf_zport != NULL
        !           830:              && q->uuconf_zport != (char *) &_uuconf_unset)
        !           831:            uvwrite_string (e, q->uuconf_zport, "port");
        !           832:          else if (q->uuconf_qport != NULL
        !           833:                   && (q->uuconf_qport
        !           834:                       != (struct uuconf_port *) &_uuconf_unset))
        !           835:            uvwrite_taylor_port (e, q->uuconf_qport, "port ");
        !           836:        }
        !           837: 
        !           838:       if (CHANGED (uuconf_zphone))
        !           839:        {
        !           840:          const char *zcmd;
        !           841: 
        !           842:          if (q->uuconf_qport != NULL
        !           843:              && q->uuconf_qport != (struct uuconf_port *) &_uuconf_unset
        !           844:              && (q->uuconf_qport->uuconf_ttype == UUCONF_PORTTYPE_TCP
        !           845:                  || q->uuconf_qport->uuconf_ttype == UUCONF_PORTTYPE_TLI))
        !           846:            zcmd = "address";
        !           847:          else
        !           848:            zcmd = "phone";
        !           849:          uvwrite_string (e, q->uuconf_zphone, zcmd);
        !           850:        }
        !           851: 
        !           852:       uvwrite_chat (e, &q->uuconf_schat,
        !           853:                    (qlast == NULL
        !           854:                     ? (struct uuconf_chat *) NULL
        !           855:                     : &qlast->uuconf_schat),
        !           856:                    "", TRUE);
        !           857: 
        !           858:       if (CHANGED (uuconf_zcall_login))
        !           859:        uvwrite_string (e, q->uuconf_zcall_login, "call-login");
        !           860: 
        !           861:       if (CHANGED (uuconf_zcall_password))
        !           862:        uvwrite_string (e, q->uuconf_zcall_password, "call-password");
        !           863: 
        !           864:       if (CHANGED (uuconf_zcalled_login))
        !           865:        uvwrite_string (e, q->uuconf_zcalled_login, "called-login");
        !           866: 
        !           867:       if (CHANGED (uuconf_fcallback))
        !           868:        uvwrite_boolean (e, q->uuconf_fcallback, "callback");
        !           869: 
        !           870:       if (CHANGED (uuconf_fsequence))
        !           871:        uvwrite_boolean (e, q->uuconf_fsequence, "sequence");
        !           872: 
        !           873:       if (CHANGED (uuconf_zprotocols))
        !           874:        uvwrite_string (e, q->uuconf_zprotocols, "protocol");
        !           875: 
        !           876:       if (CHANGED (uuconf_qproto_params))
        !           877:        uvwrite_proto_params (e, q->uuconf_qproto_params, "");
        !           878:       
        !           879:       uvwrite_chat (e, &q->uuconf_scalled_chat,
        !           880:                    (qlast == NULL
        !           881:                     ? (struct uuconf_chat *) NULL
        !           882:                     : &qlast->uuconf_scalled_chat),
        !           883:                    "called-", FALSE);
        !           884: 
        !           885:       if (CHANGED (uuconf_zdebug))
        !           886:        uvwrite_string (e, q->uuconf_zdebug, "debug");
        !           887: 
        !           888:       if (CHANGED (uuconf_zmax_remote_debug))
        !           889:        uvwrite_string (e, q->uuconf_zmax_remote_debug, "max-remote-debug");
        !           890: 
        !           891:       if ((CHANGED (uuconf_fsend_request)
        !           892:           || CHANGED (uuconf_frec_request))
        !           893:          && (q->uuconf_fsend_request >= 0
        !           894:              || q->uuconf_frec_request >= 0))
        !           895:        {
        !           896:          if (q->uuconf_fsend_request >= 0
        !           897:              && (q->uuconf_fsend_request > 0
        !           898:                  ? q->uuconf_frec_request > 0
        !           899:                  : q->uuconf_frec_request == 0))
        !           900:            uvwrite_boolean (e, q->uuconf_fsend_request, "request");
        !           901:          else
        !           902:            {
        !           903:              uvwrite_boolean (e, q->uuconf_fsend_request, "send-request");
        !           904:              uvwrite_boolean (e, q->uuconf_frec_request,
        !           905:                               "receive-request");
        !           906:            }
        !           907:        }
        !           908: 
        !           909:       if ((CHANGED (uuconf_fcall_transfer)
        !           910:           || CHANGED (uuconf_fcalled_transfer))
        !           911:          && (q->uuconf_fcall_transfer >= 0
        !           912:              || q->uuconf_fcalled_transfer >= 0))
        !           913:        {
        !           914:          if (q->uuconf_fcall_transfer >= 0
        !           915:              && (q->uuconf_fcall_transfer > 0
        !           916:                  ? q->uuconf_fcalled_transfer > 0
        !           917:                  : q->uuconf_fcalled_transfer == 0))
        !           918:            uvwrite_boolean (e, q->uuconf_fcall_transfer, "transfer");
        !           919:          else
        !           920:            {
        !           921:              uvwrite_boolean (e, q->uuconf_fcall_transfer, "call-transfer");
        !           922:              uvwrite_boolean (e, q->uuconf_fcalled_transfer,
        !           923:                               "called-transfer");
        !           924:            }
        !           925:        }
        !           926: 
        !           927:       if (CHANGED (uuconf_pzlocal_send))
        !           928:        uvwrite_string_array (e, q->uuconf_pzlocal_send, "local-send");
        !           929: 
        !           930:       if (CHANGED (uuconf_pzremote_send))
        !           931:        uvwrite_string_array (e, q->uuconf_pzremote_send, "remote-send");
        !           932: 
        !           933:       if (CHANGED (uuconf_pzlocal_receive))
        !           934:        uvwrite_string_array (e, q->uuconf_pzlocal_receive, "local-receive");
        !           935: 
        !           936:       if (CHANGED (uuconf_pzremote_receive))
        !           937:        uvwrite_string_array (e, q->uuconf_pzremote_receive,
        !           938:                              "remote-receive");
        !           939: 
        !           940:       if (CHANGED (uuconf_pzpath))
        !           941:        uvwrite_string_array (e, q->uuconf_pzpath, "command-path");
        !           942: 
        !           943:       if (CHANGED (uuconf_pzcmds))
        !           944:        uvwrite_string_array (e, q->uuconf_pzcmds, "commands");
        !           945: 
        !           946:       if (CHANGED (uuconf_cfree_space)
        !           947:          && q->uuconf_cfree_space >= 0)
        !           948:        fprintf (e, "free-space %ld\n", q->uuconf_cfree_space);
        !           949: 
        !           950:       if (CHANGED (uuconf_pzforward_from))
        !           951:        uvwrite_string_array (e, q->uuconf_pzforward_from, "forward-from");
        !           952: 
        !           953:       if (CHANGED (uuconf_pzforward_to))
        !           954:        uvwrite_string_array (e, q->uuconf_pzforward_to, "forward-to");
        !           955: 
        !           956:       if (CHANGED (uuconf_zpubdir))
        !           957:        uvwrite_string (e, q->uuconf_zpubdir, "pubdir");
        !           958: 
        !           959:       if (CHANGED (uuconf_zlocalname))
        !           960:        uvwrite_string (e, q->uuconf_zlocalname, "myname");
        !           961:     }
        !           962: }
        !           963: 
        !           964: /* Write out V2 system information.  */
        !           965: 
        !           966: static void
        !           967: uvwrite_v2_system (e, q)
        !           968:      FILE *e;
        !           969:      const struct uuconf_system *q;
        !           970: {
        !           971:   for (; q != NULL; q = q->uuconf_qalternate)
        !           972:     {
        !           973:       fprintf (e, "%s", q->uuconf_zname);
        !           974: 
        !           975:       if (q->uuconf_qtimegrade != (struct uuconf_timespan *) &_uuconf_unset)
        !           976:        {
        !           977:          fprintf (e, " ");
        !           978:          uvwrite_time (e, q->uuconf_qtimegrade);
        !           979: 
        !           980:          if (q->uuconf_zport != (char *) &_uuconf_unset
        !           981:              || q->uuconf_qport != (struct uuconf_port *) &_uuconf_unset)
        !           982:            {
        !           983:              struct uuconf_port *qp;
        !           984:              boolean ftcp;
        !           985: 
        !           986:              qp = q->uuconf_qport;
        !           987:              ftcp = (qp != (struct uuconf_port *) &_uuconf_unset
        !           988:                      && qp != NULL
        !           989:                      && qp->uuconf_ttype == UUCONF_PORTTYPE_TCP);
        !           990:              if (ftcp
        !           991:                  || (q->uuconf_zport != NULL
        !           992:                      && q->uuconf_zport != (char *) &_uuconf_unset))
        !           993:                {
        !           994:                  if (ftcp)
        !           995:                    fprintf (e, " TCP");
        !           996:                  else
        !           997:                    fprintf (e, " %s", q->uuconf_zport);
        !           998: 
        !           999:                  if (ftcp || q->uuconf_ibaud >= 0)
        !          1000:                    {
        !          1001:                      fprintf (e, " ");
        !          1002:                      if (ftcp)
        !          1003:                        {
        !          1004:                          const char *zport;
        !          1005: 
        !          1006:                          zport = qp->uuconf_u.uuconf_stcp.uuconf_zport;
        !          1007:                          if (zport == NULL)
        !          1008:                            zport = "uucp";
        !          1009:                          fprintf (e, "%s", zport);
        !          1010:                        }
        !          1011:                      else
        !          1012:                        fprintf (e, "%ld", q->uuconf_ibaud);
        !          1013: 
        !          1014:                      if (q->uuconf_zphone != (char *) &_uuconf_unset
        !          1015:                          && q->uuconf_zphone != NULL)
        !          1016:                        {
        !          1017:                          char **pzc;
        !          1018:                          
        !          1019:                          fprintf (e, " %s", q->uuconf_zphone);
        !          1020:                          pzc = q->uuconf_schat.uuconf_pzchat;
        !          1021:                          if (pzc != (char **) &_uuconf_unset
        !          1022:                              && pzc != NULL)
        !          1023:                            {
        !          1024:                              fprintf (e, " ");
        !          1025:                              uvwrite_chat_script (e, pzc);
        !          1026:                            }
        !          1027:                        }
        !          1028:                    }
        !          1029:                }
        !          1030:            }
        !          1031:        }
        !          1032: 
        !          1033:       fprintf (e, "\n");
        !          1034: 
        !          1035:       /* Here we should gather information to write out to USERFILE
        !          1036:         and L.cmds, and perhaps some day we will.  It's much more
        !          1037:         likely to happen if somebody else does it, though.  */
        !          1038:     }
        !          1039: }
        !          1040: 
        !          1041: /* Write out HDB system information.  */
        !          1042: 
        !          1043: static void
        !          1044: uvwrite_hdb_system (e, qsys)
        !          1045:      FILE *e;
        !          1046:      const struct uuconf_system *qsys;
        !          1047: {
        !          1048:   const struct uuconf_system *q;
        !          1049:   struct shpermissions sperm;
        !          1050:   char *azmachine[2];
        !          1051:   char *azlogname[2];
        !          1052: 
        !          1053:   for (q = qsys; q != NULL; q = q->uuconf_qalternate)
        !          1054:     {
        !          1055:       if (q->uuconf_fcall)
        !          1056:        {
        !          1057:          fprintf (e, "%s", q->uuconf_zname);
        !          1058: 
        !          1059:          if (q->uuconf_qtimegrade
        !          1060:              != (struct uuconf_timespan *) &_uuconf_unset)
        !          1061:            {
        !          1062:              const char *zport;
        !          1063: 
        !          1064:              fprintf (e, " ");
        !          1065:              uvwrite_time (e, q->uuconf_qtimegrade);
        !          1066: 
        !          1067:              zport = q->uuconf_zport;
        !          1068:              if (q->uuconf_qport != NULL
        !          1069:                  && q->uuconf_qport != (struct uuconf_port *) &_uuconf_unset
        !          1070:                  && q->uuconf_qport->uuconf_ttype == UUCONF_PORTTYPE_TCP)
        !          1071:                zport = "TCP";
        !          1072:              if (zport != NULL && zport != (char *) &_uuconf_unset)
        !          1073:                {
        !          1074:                  fprintf (e, " %s", zport);
        !          1075:                  if (q->uuconf_zprotocols != (char *) &_uuconf_unset
        !          1076:                      && q->uuconf_zprotocols != NULL)
        !          1077:                    fprintf (e, ",%s", q->uuconf_zprotocols);
        !          1078: 
        !          1079:                  if (q->uuconf_ibaud >= 0
        !          1080:                      || q->uuconf_zphone != (char *) &_uuconf_unset)
        !          1081:                    {
        !          1082:                      fprintf (e, " ");
        !          1083:                      if (q->uuconf_ibaud < 0)
        !          1084:                        fprintf (e, "Any");
        !          1085:                      else
        !          1086:                        {
        !          1087:                          fprintf (e, "%ld", q->uuconf_ibaud);
        !          1088:                          if (q->uuconf_ihighbaud >= 0)
        !          1089:                            fprintf (e, "-%ld", q->uuconf_ihighbaud);
        !          1090:                        }
        !          1091: 
        !          1092:                      if (q->uuconf_zphone != (char *) &_uuconf_unset
        !          1093:                          && q->uuconf_zphone != NULL)
        !          1094:                        {
        !          1095:                          char **pzc;
        !          1096:                          
        !          1097:                          fprintf (e, " %s", q->uuconf_zphone);
        !          1098:                          pzc = q->uuconf_schat.uuconf_pzchat;
        !          1099:                          if (pzc != (char **) &_uuconf_unset
        !          1100:                              && pzc != NULL)
        !          1101:                            {
        !          1102:                              fprintf (e, " ");
        !          1103:                              uvwrite_chat_script (e, pzc);
        !          1104:                            }
        !          1105:                        }
        !          1106:                    }
        !          1107:                }
        !          1108:            }
        !          1109: 
        !          1110:          fprintf (e, "\n");
        !          1111:        }
        !          1112:     }
        !          1113: 
        !          1114:   /* Build a Permissions entry for this system.  There will be only
        !          1115:      one MACHINE entry for a given system.  */
        !          1116: 
        !          1117:   for (q = qsys; q != NULL; q = q->uuconf_qalternate)
        !          1118:     if (q->uuconf_fcall)
        !          1119:       break;
        !          1120: 
        !          1121:   if (q != NULL)
        !          1122:     {
        !          1123:       sperm.qnext = NULL;
        !          1124:       sperm.pzlogname = NULL;
        !          1125:       sperm.pzmachine = NULL;
        !          1126:       sperm.frequest = -1;
        !          1127:       sperm.fsendfiles = -1;
        !          1128:       sperm.pzread = NULL;
        !          1129:       sperm.pzwrite = NULL;
        !          1130:       sperm.fcallback = -1;
        !          1131:       sperm.pzcommands = NULL;
        !          1132:       sperm.pzvalidate = NULL;
        !          1133:       sperm.zmyname = NULL;
        !          1134:       sperm.zpubdir = NULL;
        !          1135:       sperm.pzalias = NULL;
        !          1136: 
        !          1137:       azmachine[0] = q->uuconf_zname;
        !          1138:       azmachine[1] = NULL;
        !          1139:       sperm.pzmachine = azmachine;
        !          1140:       if (q->uuconf_fsend_request >= 0)
        !          1141:        sperm.frequest = q->uuconf_fsend_request;
        !          1142:       if (q->uuconf_pzremote_send != (char **) &_uuconf_unset
        !          1143:          && q->uuconf_pzremote_send != NULL)
        !          1144:        sperm.pzread = q->uuconf_pzremote_send;
        !          1145:       if (q->uuconf_pzremote_receive != (char **) &_uuconf_unset
        !          1146:          && q->uuconf_pzremote_receive != NULL)
        !          1147:        sperm.pzwrite = q->uuconf_pzremote_receive;
        !          1148:       if (q->uuconf_pzcmds != (char **) &_uuconf_unset
        !          1149:          && q->uuconf_pzcmds != NULL)
        !          1150:        sperm.pzcommands = q->uuconf_pzcmds;
        !          1151:       if (q->uuconf_zlocalname != (char *) &_uuconf_unset
        !          1152:          && q->uuconf_zlocalname != NULL)
        !          1153:        sperm.zmyname = q->uuconf_zlocalname;
        !          1154:       if (q->uuconf_zpubdir != (char *) &_uuconf_unset
        !          1155:          && q->uuconf_zpubdir != NULL)
        !          1156:        sperm.zpubdir = q->uuconf_zpubdir;
        !          1157:       if (q->uuconf_pzalias != (char **) &_uuconf_unset
        !          1158:          && q->uuconf_pzalias != NULL)
        !          1159:        sperm.pzalias = q->uuconf_pzalias;
        !          1160: 
        !          1161:       if (q->uuconf_fcalled
        !          1162:          && q->uuconf_zcalled_login != (char *) &_uuconf_unset
        !          1163:          && q->uuconf_zcalled_login != NULL)
        !          1164:        {
        !          1165:          azlogname[0] = q->uuconf_zcalled_login;
        !          1166:          azlogname[1] = NULL;
        !          1167:          sperm.pzlogname = azlogname;
        !          1168:          if (q->uuconf_fcalled_transfer >= 0)
        !          1169:            sperm.fsendfiles = q->uuconf_fcalled_transfer;
        !          1170:          if (q->uuconf_fcallback >= 0)
        !          1171:            sperm.fcallback = q->uuconf_fcallback;
        !          1172:          sperm.pzvalidate = azmachine;
        !          1173:        }
        !          1174: 
        !          1175:       uvadd_perm (&sperm);
        !          1176:     }
        !          1177: 
        !          1178:   /* Now add a Permissions entry for each alternative that is not used
        !          1179:      for calling out.  */
        !          1180:   for (q = qsys; q != NULL; q = q->uuconf_qalternate)
        !          1181:     {
        !          1182:       if (! q->uuconf_fcalled || q->uuconf_fcall)
        !          1183:        continue;
        !          1184: 
        !          1185:       sperm.qnext = NULL;
        !          1186:       sperm.pzlogname = NULL;
        !          1187:       sperm.pzmachine = NULL;
        !          1188:       sperm.frequest = -1;
        !          1189:       sperm.fsendfiles = -1;
        !          1190:       sperm.pzread = NULL;
        !          1191:       sperm.pzwrite = NULL;
        !          1192:       sperm.fcallback = -1;
        !          1193:       sperm.pzcommands = NULL;
        !          1194:       sperm.pzvalidate = NULL;
        !          1195:       sperm.zmyname = NULL;
        !          1196:       sperm.zpubdir = NULL;
        !          1197:       sperm.pzalias = NULL;
        !          1198: 
        !          1199:       if (q->uuconf_zcalled_login != (char *) &_uuconf_unset
        !          1200:          && q->uuconf_zcalled_login != NULL)
        !          1201:        azlogname[0] = q->uuconf_zcalled_login;
        !          1202:       else
        !          1203:        azlogname[0] = (char *) "OTHER";
        !          1204:       azlogname[1] = NULL;
        !          1205:       sperm.pzlogname = azlogname;
        !          1206: 
        !          1207:       if (q->uuconf_fsend_request >= 0)
        !          1208:        sperm.frequest = q->uuconf_fsend_request;
        !          1209:       if (q->uuconf_fcalled_transfer >= 0)
        !          1210:        sperm.fsendfiles = q->uuconf_fcalled_transfer;
        !          1211:       if (q->uuconf_pzremote_send != (char **) &_uuconf_unset
        !          1212:          && q->uuconf_pzremote_send != NULL)
        !          1213:        sperm.pzread = q->uuconf_pzremote_send;
        !          1214:       if (q->uuconf_pzremote_receive != (char **) &_uuconf_unset
        !          1215:          && q->uuconf_pzremote_receive != NULL)
        !          1216:        sperm.pzwrite = q->uuconf_pzremote_receive;
        !          1217:       if (q->uuconf_fcallback >= 0)
        !          1218:        sperm.fcallback = q->uuconf_fcallback;
        !          1219:       if (q->uuconf_zlocalname != (char *) &_uuconf_unset
        !          1220:          && q->uuconf_zlocalname != NULL)
        !          1221:        sperm.zmyname = q->uuconf_zlocalname;
        !          1222:       if (q->uuconf_zpubdir != (char *) &_uuconf_unset
        !          1223:          && q->uuconf_zpubdir != NULL)
        !          1224:        sperm.zpubdir = q->uuconf_zpubdir;
        !          1225: 
        !          1226:       uvadd_perm (&sperm);
        !          1227:     }
        !          1228: }
        !          1229: 
        !          1230: /* Compare two strings from a Permissions entry, returning TRUE if
        !          1231:    they are the same.  */
        !          1232: static boolean
        !          1233: fvperm_string_cmp (z1, z2)
        !          1234:      const char *z1;
        !          1235:      const char *z2;
        !          1236: {
        !          1237:   if (z1 == NULL
        !          1238:       ? z2 != NULL
        !          1239:       : z2 == NULL)
        !          1240:     return FALSE;
        !          1241: 
        !          1242:   if (z1 == NULL)
        !          1243:     return TRUE;
        !          1244: 
        !          1245:   return strcmp (z1, z2) == 0;
        !          1246: }
        !          1247: 
        !          1248: /* Compare two arrays of strings from a Permissions entry, returning
        !          1249:    TRUE if they are the same.  */
        !          1250: 
        !          1251: static boolean
        !          1252: fvperm_array_cmp (pz1, pz2)
        !          1253:      const char **pz1;
        !          1254:      const char **pz2;
        !          1255: {
        !          1256:   if (pz1 == NULL
        !          1257:       ? pz2 != NULL
        !          1258:       : pz2 == NULL)
        !          1259:     return FALSE;
        !          1260: 
        !          1261:   if (pz1 == NULL)
        !          1262:     return TRUE;
        !          1263: 
        !          1264:   for (; *pz1 != NULL && *pz2 != NULL; pz1++, pz2++)
        !          1265:     if (strcmp (*pz1, *pz2) != 0)
        !          1266:       break;
        !          1267: 
        !          1268:   return *pz1 == NULL && *pz2 == NULL;
        !          1269: }      
        !          1270: 
        !          1271: /* Add a Permissions entry to a global list, combining entries where
        !          1272:    possible.  */
        !          1273: 
        !          1274: static void
        !          1275: uvadd_perm (qadd)
        !          1276:      struct shpermissions *qadd;
        !          1277: {
        !          1278:   struct shpermissions *qlook;
        !          1279:   struct shpermissions *qnew;
        !          1280:   int iret;
        !          1281: 
        !          1282:   /* If there's no information, don't bother to add this entry.  */
        !          1283:   if (qadd->pzlogname == NULL
        !          1284:       && qadd->frequest < 0
        !          1285:       && qadd->fsendfiles < 0
        !          1286:       && qadd->pzread == NULL
        !          1287:       && qadd->pzwrite == NULL
        !          1288:       && qadd->fcallback < 0
        !          1289:       && qadd->pzcommands == NULL
        !          1290:       && qadd->pzvalidate == NULL
        !          1291:       && qadd->zmyname == NULL
        !          1292:       && qadd->zpubdir == NULL
        !          1293:       && qadd->pzalias == NULL)
        !          1294:     return;
        !          1295: 
        !          1296:   for (qlook = qVperms; qlook != NULL; qlook = qlook->qnext)
        !          1297:     {
        !          1298:       /* See if we can merge qadd into qlook.  */
        !          1299:       if (qadd->pzlogname == NULL
        !          1300:          ? qlook->pzlogname != NULL
        !          1301:          : qlook->pzlogname == NULL)
        !          1302:        continue;
        !          1303:       if (qadd->pzmachine == NULL
        !          1304:          ? qlook->pzmachine != NULL
        !          1305:          : qlook->pzmachine == NULL)
        !          1306:        continue;
        !          1307:       if (qadd->frequest != qlook->frequest
        !          1308:          || qadd->fsendfiles != qlook->fsendfiles
        !          1309:          || qadd->fcallback != qlook->fcallback)
        !          1310:        continue;
        !          1311:       if (! fvperm_string_cmp (qadd->zmyname, qlook->zmyname)
        !          1312:          || ! fvperm_string_cmp (qadd->zpubdir, qlook->zpubdir))
        !          1313:        continue;
        !          1314:       if (! fvperm_array_cmp ((const char **) qadd->pzread,
        !          1315:                              (const char **) qlook->pzread)
        !          1316:          || ! fvperm_array_cmp ((const char **)  qadd->pzwrite,
        !          1317:                                 (const char **) qlook->pzwrite)
        !          1318:          || ! fvperm_array_cmp ((const char **) qadd->pzcommands,
        !          1319:                                 (const char **) qlook->pzcommands))
        !          1320:        continue;
        !          1321: 
        !          1322:       /* Merge qadd into qlook.  */
        !          1323:       if (qadd->pzmachine != NULL)
        !          1324:        {
        !          1325:          iret = _uuconf_iadd_string ((struct sglobal *) NULL,
        !          1326:                                      qadd->pzmachine[0], FALSE,
        !          1327:                                      TRUE, &qlook->pzmachine,
        !          1328:                                      (pointer) NULL);
        !          1329:          if (iret != UUCONF_SUCCESS)
        !          1330:            uvuuconf_error ((pointer) NULL, iret);
        !          1331:        }
        !          1332:       if (qadd->pzlogname != NULL)
        !          1333:        {
        !          1334:          iret = _uuconf_iadd_string ((struct sglobal *) NULL,
        !          1335:                                      qadd->pzlogname[0], FALSE,
        !          1336:                                      TRUE, &qlook->pzlogname,
        !          1337:                                      (pointer) NULL);
        !          1338:          if (iret != UUCONF_SUCCESS)
        !          1339:            uvuuconf_error ((pointer) NULL, iret);
        !          1340:        }
        !          1341:       if (qadd->pzalias != NULL)
        !          1342:        {
        !          1343:          char **pz;
        !          1344: 
        !          1345:          for (pz = qadd->pzalias; *pz != NULL; pz++)
        !          1346:            {
        !          1347:              iret = _uuconf_iadd_string ((struct sglobal *) NULL,
        !          1348:                                          *pz, FALSE, TRUE,
        !          1349:                                          &qlook->pzalias, (pointer) NULL);
        !          1350:              if (iret != UUCONF_SUCCESS)
        !          1351:                uvuuconf_error ((pointer) NULL, iret);
        !          1352:            }
        !          1353:        }
        !          1354: 
        !          1355:       return;
        !          1356:     }
        !          1357: 
        !          1358:   /* We must add qadd as a new entry on the list, which means we must
        !          1359:      copy it into the heap.  */
        !          1360: 
        !          1361:   qnew = (struct shpermissions *) malloc (sizeof (struct shpermissions));
        !          1362:   if (qnew == NULL)
        !          1363:     uvuuconf_error ((pointer) NULL, UUCONF_MALLOC_FAILED);
        !          1364:   *qnew = *qadd;
        !          1365:   if (qadd->pzmachine != NULL)
        !          1366:     {
        !          1367:       qnew->pzmachine = NULL;
        !          1368:       iret = _uuconf_iadd_string ((struct sglobal *) NULL,
        !          1369:                                  qadd->pzmachine[0], FALSE,
        !          1370:                                  FALSE, &qnew->pzmachine,
        !          1371:                                  (pointer) NULL);
        !          1372:       if (iret != UUCONF_SUCCESS)
        !          1373:        uvuuconf_error ((pointer) NULL, iret);
        !          1374:     }
        !          1375:   if (qadd->pzlogname != NULL)
        !          1376:     {
        !          1377:       qnew->pzlogname = NULL;
        !          1378:       iret = _uuconf_iadd_string ((struct sglobal *) NULL,
        !          1379:                                  qadd->pzlogname[0], FALSE,
        !          1380:                                  FALSE, &qnew->pzlogname,
        !          1381:                                  (pointer) NULL);
        !          1382:       if (iret != UUCONF_SUCCESS)
        !          1383:        uvuuconf_error ((pointer) NULL, iret);
        !          1384:     }
        !          1385:   if (qadd->pzvalidate != NULL)
        !          1386:     qnew->pzvalidate = qnew->pzmachine;
        !          1387: 
        !          1388:   qnew->qnext = qVperms;
        !          1389:   qVperms = qnew;
        !          1390: }
        !          1391: 
        !          1392: /* Write out the Permissions entries.  */
        !          1393: 
        !          1394: static void
        !          1395: uvwrite_perms ()
        !          1396: {
        !          1397:   char ab[sizeof ZCURDIR + sizeof HDB_PERMISSIONS - 1];
        !          1398:   FILE *e;
        !          1399:   struct shpermissions *q;
        !          1400: 
        !          1401:   sprintf (ab, "%s%s", ZCURDIR, HDB_PERMISSIONS);
        !          1402:   e = fopen (ab, "w");
        !          1403:   if (e == NULL)
        !          1404:     {
        !          1405:       fprintf (stderr, "uuchk:%s: ", ab);
        !          1406:       perror ("fopen");
        !          1407:       exit (EXIT_FAILURE);
        !          1408:     }
        !          1409: 
        !          1410:   fprintf (e, "# Permissions file automatically generated by uuconv.\n");
        !          1411: 
        !          1412:   for (q = qVperms; q != NULL; q = q->qnext)
        !          1413:     {
        !          1414:       size_t ccol;
        !          1415: 
        !          1416:       ccol = 0;
        !          1417:       uvwrite_perm_array (e, (const char **) q->pzlogname, "LOGNAME", &ccol);
        !          1418:       uvwrite_perm_array (e, (const char **) q->pzmachine, "MACHINE", &ccol);
        !          1419:       uvwrite_perm_boolean (e, q->frequest, "REQUEST", &ccol, FALSE);
        !          1420:       uvwrite_perm_boolean (e, q->fsendfiles, "SENDFILES", &ccol, TRUE);
        !          1421:       uvwrite_perm_rw_array (e, (const char **) q->pzread, "READ", &ccol);
        !          1422:       uvwrite_perm_rw_array (e, (const char **) q->pzwrite, "WRITE", &ccol);
        !          1423:       uvwrite_perm_boolean (e, q->fcallback, "CALLBACK", &ccol, FALSE);
        !          1424:       uvwrite_perm_array (e, (const char **) q->pzcommands, "COMMANDS",
        !          1425:                          &ccol);
        !          1426:       uvwrite_perm_array (e, (const char **) q->pzvalidate, "VALIDATE",
        !          1427:                          &ccol);
        !          1428:       uvwrite_perm_string (e, q->zmyname, "MYNAME", &ccol);
        !          1429:       uvwrite_perm_string (e, q->zpubdir, "PUBDIR", &ccol);
        !          1430:       uvwrite_perm_array (e, (const char **) q->pzalias, "ALIAS", &ccol);
        !          1431: 
        !          1432:       fprintf (e, "\n");
        !          1433:     }
        !          1434: 
        !          1435:   if (ferror (e)
        !          1436:       || fclose (e) == EOF)
        !          1437:     {
        !          1438:       fprintf (stderr, "uuchk:%s: error during output\n", HDB_PERMISSIONS);
        !          1439:       exit (EXIT_FAILURE);
        !          1440:     }
        !          1441: }
        !          1442: 
        !          1443: /* Write an array out to the Permissions file.  */
        !          1444: 
        !          1445: static void
        !          1446: uvwrite_perm_array (e, pzarg, zcmd, pccol)
        !          1447:      FILE *e;
        !          1448:      const char **pzarg;
        !          1449:      const char *zcmd;
        !          1450:      size_t *pccol;
        !          1451: {
        !          1452:   size_t c;
        !          1453:   const char **pz;
        !          1454: 
        !          1455:   if (pzarg == NULL)
        !          1456:     return;
        !          1457: 
        !          1458:   c = strlen (zcmd) + 1;
        !          1459:   
        !          1460:   for (pz = pzarg; *pz != NULL; pz++)
        !          1461:     c += strlen (*pz) + 1;
        !          1462: 
        !          1463:   if (*pccol > 20 && c + *pccol > 75)
        !          1464:     {
        !          1465:       fprintf (e, " \\\n");
        !          1466:       *pccol = c - 1;
        !          1467:     }
        !          1468:   else
        !          1469:     {
        !          1470:       if (*pccol != 0)
        !          1471:        fprintf (e, " ");
        !          1472:       *pccol += c;
        !          1473:     }
        !          1474: 
        !          1475:   fprintf (e, "%s=", zcmd);
        !          1476:   for (pz = pzarg; *pz != NULL; pz++)
        !          1477:     {
        !          1478:       if (pz != pzarg)
        !          1479:        fprintf (e, ":");
        !          1480:       fprintf (e, "%s", *pz);
        !          1481:     }
        !          1482: }
        !          1483: 
        !          1484: /* Write a boolean value out to the Permissions file.  This may be
        !          1485:    either a yes/no boolean or a yes/call boolean (the latter is for
        !          1486:    SENDFILES).  */
        !          1487: 
        !          1488: static void
        !          1489: uvwrite_perm_boolean (e, f, zcmd, pccol, fsendfiles)
        !          1490:      FILE *e;
        !          1491:      int f;
        !          1492:      const char *zcmd;
        !          1493:      size_t *pccol;
        !          1494:      boolean fsendfiles;
        !          1495: {
        !          1496:   const char *az[2];
        !          1497: 
        !          1498:   if (f < 0)
        !          1499:     return;
        !          1500: 
        !          1501:   if (f)
        !          1502:     az[0] = "yes";
        !          1503:   else
        !          1504:     az[0] = fsendfiles ? "call" : "no";
        !          1505:   az[1] = NULL;
        !          1506: 
        !          1507:   uvwrite_perm_array (e, az, zcmd, pccol);
        !          1508: }
        !          1509: 
        !          1510: /* Write a set of READ or WRITE entries to the Permissions file.  We
        !          1511:    have to separate out all entries that start with '!'.  */
        !          1512: 
        !          1513: static void
        !          1514: uvwrite_perm_rw_array (e, pzarg, zcmd, pccol)
        !          1515:      FILE *e;
        !          1516:      const char **pzarg;
        !          1517:      const char *zcmd;
        !          1518:      size_t *pccol;
        !          1519: {
        !          1520:   size_t c;
        !          1521:   const char **pz, **pzcopy, **pzset;
        !          1522: 
        !          1523:   if (pzarg == NULL)
        !          1524:     return;
        !          1525: 
        !          1526:   c = 0;
        !          1527:   for (pz = pzarg; *pz != NULL; pz++)
        !          1528:     c++;
        !          1529: 
        !          1530:   pzcopy = (const char **) malloc ((c + 1) * sizeof (char *));
        !          1531:   if (pzcopy == NULL)
        !          1532:     uvuuconf_error ((pointer) NULL, UUCONF_MALLOC_FAILED);
        !          1533: 
        !          1534:   pzset = pzcopy;
        !          1535:   for (pz = pzarg; *pz != NULL; pz++)
        !          1536:     if ((*pz)[0] != '!')
        !          1537:       *pzset++ = *pz;
        !          1538:   *pzset = NULL;
        !          1539: 
        !          1540:   if (pzset != pzcopy)
        !          1541:     uvwrite_perm_array (e, (const char **) pzcopy, zcmd, pccol);
        !          1542: 
        !          1543:   pzset = pzcopy;
        !          1544:   for (pz = pzarg; *pz != NULL; pz++)
        !          1545:     if ((*pz)[0] == '!')
        !          1546:       *pzset++ = *pz;
        !          1547:   *pzset = NULL;
        !          1548: 
        !          1549:   if (pzset != pzcopy)
        !          1550:     {
        !          1551:       char ab[20];
        !          1552: 
        !          1553:       sprintf (ab, "NO%s", zcmd);
        !          1554:       uvwrite_perm_array (e, (const char **) pzcopy, ab, pccol);
        !          1555:     }
        !          1556: }
        !          1557: 
        !          1558: /* Write a string out to the Permissions file.  */
        !          1559: 
        !          1560: static void
        !          1561: uvwrite_perm_string (e, z, zcmd, pccol)
        !          1562:      FILE *e;
        !          1563:      const char *z;
        !          1564:      const char *zcmd;
        !          1565:      size_t *pccol;
        !          1566: {
        !          1567:   const char *az[2];
        !          1568: 
        !          1569:   if (z == NULL)
        !          1570:     return;
        !          1571: 
        !          1572:   az[0] = z;
        !          1573:   az[1] = NULL;
        !          1574: 
        !          1575:   uvwrite_perm_array (e, az, zcmd, pccol);
        !          1576: }
        !          1577: 
        !          1578: /* Write out a Taylor UUCP port.  This is called via uuconf_find_port;
        !          1579:    the pinfo argument is the port file.  */
        !          1580: 
        !          1581: static int
        !          1582: ivwrite_taylor_port (qport, pinfo)
        !          1583:      struct uuconf_port *qport;
        !          1584:      pointer pinfo;
        !          1585: {
        !          1586:   FILE *e = (FILE *) pinfo;
        !          1587: 
        !          1588:   fprintf (e, "port %s\n", qport->uuconf_zname);
        !          1589: 
        !          1590:   uvwrite_taylor_port (e, qport, "");
        !          1591: 
        !          1592:   /* Return UUCONF_NOT_FOUND to force uuconf_find_port to keep looking
        !          1593:      for ports.  */
        !          1594:   return UUCONF_NOT_FOUND;
        !          1595: }
        !          1596: 
        !          1597: /* Write a port out to a Taylor UUCP configuration file.  This doesn't
        !          1598:    output the name, since it is called to output a specially defined
        !          1599:    port in the sys file.  */
        !          1600: 
        !          1601: static void
        !          1602: uvwrite_taylor_port (e, qport, zprefix)
        !          1603:      FILE *e;
        !          1604:      struct uuconf_port *qport;
        !          1605:      const char *zprefix;
        !          1606: {
        !          1607:   const char *ztype;
        !          1608:   char ab[100];
        !          1609: 
        !          1610:   switch (qport->uuconf_ttype)
        !          1611:     {
        !          1612:     default:
        !          1613:     case UUCONF_PORTTYPE_UNKNOWN:
        !          1614:       fprintf (stderr, "uuconv: Bad port type\n");
        !          1615:       exit (EXIT_FAILURE);
        !          1616:       break;
        !          1617:     case UUCONF_PORTTYPE_STDIN:
        !          1618:       ztype = "stdin";
        !          1619:       break;
        !          1620:     case UUCONF_PORTTYPE_MODEM:
        !          1621:       ztype = "modem";
        !          1622:       break;
        !          1623:     case UUCONF_PORTTYPE_DIRECT:
        !          1624:       ztype = "direct";
        !          1625:       break;
        !          1626:     case UUCONF_PORTTYPE_TCP:
        !          1627:       ztype = "tcp";
        !          1628:       break;
        !          1629:     case UUCONF_PORTTYPE_TLI:
        !          1630:       ztype = "tli";
        !          1631:       break;
        !          1632:     }
        !          1633: 
        !          1634:   fprintf (e, "%stype %s\n", zprefix, ztype);
        !          1635: 
        !          1636:   if (qport->uuconf_zprotocols != NULL)
        !          1637:     fprintf (e, "%sprotocol %s\n", zprefix, qport->uuconf_zprotocols);
        !          1638: 
        !          1639:   if (qport->uuconf_qproto_params != NULL)
        !          1640:     uvwrite_proto_params (e, qport->uuconf_qproto_params, zprefix);
        !          1641: 
        !          1642:   if ((qport->uuconf_ireliable & UUCONF_RELIABLE_SPECIFIED) != 0)
        !          1643:     {
        !          1644:       sprintf (ab, "%sseven-bit", zprefix);
        !          1645:       uvwrite_boolean (e,
        !          1646:                       ((qport->uuconf_ireliable & UUCONF_RELIABLE_EIGHT)
        !          1647:                        == 0),
        !          1648:                       ab);
        !          1649:       sprintf (ab, "%sreliable", zprefix);
        !          1650:       uvwrite_boolean (e,
        !          1651:                       ((qport->uuconf_ireliable & UUCONF_RELIABLE_RELIABLE)
        !          1652:                        != 0),
        !          1653:                       ab);
        !          1654:       sprintf (ab, "%shalf-duplex", zprefix);
        !          1655:       uvwrite_boolean (e,
        !          1656:                       ((qport->uuconf_ireliable & UUCONF_RELIABLE_FULLDUPLEX)
        !          1657:                        == 0),
        !          1658:                       ab);
        !          1659:     }
        !          1660: 
        !          1661:   if (qport->uuconf_zlockname != NULL)
        !          1662:     fprintf (e, "%slockname %s\n", zprefix, qport->uuconf_zlockname);
        !          1663: 
        !          1664:   switch (qport->uuconf_ttype)
        !          1665:     {
        !          1666:     default:
        !          1667:       break;
        !          1668:     case UUCONF_PORTTYPE_MODEM:
        !          1669:       {
        !          1670:        struct uuconf_modem_port *qm;
        !          1671: 
        !          1672:        qm = &qport->uuconf_u.uuconf_smodem;
        !          1673:        if (qm->uuconf_zdevice != NULL)
        !          1674:          fprintf (e, "%sdevice %s\n", zprefix, qm->uuconf_zdevice);
        !          1675:        if (qm->uuconf_zdial_device != NULL)
        !          1676:          fprintf (e, "%sdial-device %s\n", zprefix, qm->uuconf_zdial_device);
        !          1677:        if (qm->uuconf_ibaud != 0)
        !          1678:          fprintf (e, "%sbaud %ld\n", zprefix, qm->uuconf_ibaud);
        !          1679:        if (qm->uuconf_ilowbaud != 0)
        !          1680:          fprintf (e, "%sbaud-range %ld %ld\n", zprefix, qm->uuconf_ilowbaud,
        !          1681:                   qm->uuconf_ihighbaud);
        !          1682:        if (! qm->uuconf_fcarrier)
        !          1683:          fprintf (e, "%scarrier false\n", zprefix);
        !          1684:        if (qm->uuconf_pzdialer != NULL)
        !          1685:          {
        !          1686:            if (qm->uuconf_pzdialer[1] == NULL)
        !          1687:              fprintf (e, "%sdialer %s\n", zprefix, qm->uuconf_pzdialer[0]);
        !          1688:            else
        !          1689:              {
        !          1690:                sprintf (ab, "%sdialer-sequence", zprefix);
        !          1691:                uvwrite_string_array (e, qm->uuconf_pzdialer, zprefix);
        !          1692:              }
        !          1693:          }
        !          1694:        if (qm->uuconf_qdialer != NULL)
        !          1695:          {
        !          1696:            sprintf (ab, "%sdialer ", zprefix);
        !          1697:            uvwrite_taylor_dialer (e, qm->uuconf_qdialer, ab);
        !          1698:          }
        !          1699:       }
        !          1700:       break;
        !          1701:     case UUCONF_PORTTYPE_DIRECT:
        !          1702:       {
        !          1703:        struct uuconf_direct_port *qd;
        !          1704: 
        !          1705:        qd = &qport->uuconf_u.uuconf_sdirect;
        !          1706:        if (qd->uuconf_zdevice != NULL)
        !          1707:          fprintf (e, "%sdevice %s\n", zprefix, qd->uuconf_zdevice);
        !          1708:        if (qd->uuconf_ibaud != 0)
        !          1709:          fprintf (e, "%sbaud %ld\n", zprefix, qd->uuconf_ibaud);
        !          1710:       }
        !          1711:       break;
        !          1712:     case UUCONF_PORTTYPE_TCP:
        !          1713:       if (qport->uuconf_u.uuconf_stcp.uuconf_zport != NULL)
        !          1714:        fprintf (e, "%sservice %s\n", zprefix,
        !          1715:                 qport->uuconf_u.uuconf_stcp.uuconf_zport);
        !          1716:       break;
        !          1717:     case UUCONF_PORTTYPE_TLI:
        !          1718:       {
        !          1719:        struct uuconf_tli_port *qt;
        !          1720: 
        !          1721:        qt = &qport->uuconf_u.uuconf_stli;
        !          1722:        if (qt->uuconf_zdevice != NULL)
        !          1723:          fprintf (e, "%sdevice %s\n", zprefix, qt->uuconf_zdevice);
        !          1724:        sprintf (ab, "%sstream", zprefix);
        !          1725:        uvwrite_boolean (e, qt->uuconf_fstream, ab);
        !          1726:        if (qt->uuconf_pzpush != NULL)
        !          1727:          {
        !          1728:            sprintf (ab, "%spush", zprefix);
        !          1729:            uvwrite_string_array (e, qt->uuconf_pzpush, ab);
        !          1730:          }
        !          1731:        if (qt->uuconf_pzdialer != NULL)
        !          1732:          {
        !          1733:            sprintf (ab, "%sdialer-sequence", zprefix);
        !          1734:            uvwrite_string_array (e, qt->uuconf_pzdialer, ab);
        !          1735:          }
        !          1736:        if (qt->uuconf_zservaddr != NULL)
        !          1737:          fprintf (e, "%sserver-address %s\n", zprefix,
        !          1738:                   qt->uuconf_zservaddr);
        !          1739:       }
        !          1740:       break;
        !          1741:     }
        !          1742: }
        !          1743: 
        !          1744: /* Write out a port to the V2 L-devices file.  This is called via
        !          1745:    uuconf_find_port.  */
        !          1746: 
        !          1747: static int
        !          1748: ivwrite_v2_port (qport, pinfo)
        !          1749:      struct uuconf_port *qport;
        !          1750:      pointer pinfo;
        !          1751: {
        !          1752:   FILE *e = (FILE *) pinfo;
        !          1753: 
        !          1754:   if (qport->uuconf_ttype == UUCONF_PORTTYPE_DIRECT)
        !          1755:     {
        !          1756:       fprintf (e, "DIR %s - %ld direct",
        !          1757:               qport->uuconf_u.uuconf_sdirect.uuconf_zdevice,
        !          1758:               qport->uuconf_u.uuconf_sdirect.uuconf_ibaud);
        !          1759:     }
        !          1760:   else if (qport->uuconf_ttype == UUCONF_PORTTYPE_MODEM)
        !          1761:     {
        !          1762:       fprintf (e, "%s %s ", qport->uuconf_zname,
        !          1763:               qport->uuconf_u.uuconf_smodem.uuconf_zdevice);
        !          1764:       if (qport->uuconf_u.uuconf_smodem.uuconf_zdial_device != NULL)
        !          1765:        fprintf (e, "%s", qport->uuconf_u.uuconf_smodem.uuconf_zdial_device);
        !          1766:       else
        !          1767:        fprintf (e, "-");
        !          1768:       fprintf (e, " ");
        !          1769:       if (qport->uuconf_u.uuconf_smodem.uuconf_ilowbaud != 0L)
        !          1770:        fprintf (e, "%ld-%ld",
        !          1771:                 qport->uuconf_u.uuconf_smodem.uuconf_ilowbaud,
        !          1772:                 qport->uuconf_u.uuconf_smodem.uuconf_ihighbaud);
        !          1773:       else if (qport->uuconf_u.uuconf_smodem.uuconf_ibaud != 0L)
        !          1774:        fprintf (e, "%ld", qport->uuconf_u.uuconf_smodem.uuconf_ibaud);
        !          1775:       else
        !          1776:        fprintf (e, "Any");
        !          1777:       if (qport->uuconf_u.uuconf_smodem.uuconf_pzdialer != NULL)
        !          1778:        fprintf (e, " %s",
        !          1779:                 qport->uuconf_u.uuconf_smodem.uuconf_pzdialer[0]);
        !          1780:     }
        !          1781:   else
        !          1782:     {
        !          1783:       fprintf (e, "# Ignoring port %s with unsupported type",
        !          1784:               qport->uuconf_zname);
        !          1785:     }
        !          1786: 
        !          1787:   fprintf (e, "\n");
        !          1788: 
        !          1789:   /* Return UUCONF_NOT_FOUND to force uuconf_find_port to keep looking
        !          1790:      for a port.  */
        !          1791:   return UUCONF_NOT_FOUND;
        !          1792: }
        !          1793: 
        !          1794: /* Write out a port to the HDB Devices file.  This is called via
        !          1795:    uuconf_find_port.  */
        !          1796: 
        !          1797: static int
        !          1798: ivwrite_hdb_port (qport, pinfo)
        !          1799:      struct uuconf_port *qport;
        !          1800:      pointer pinfo;
        !          1801: {
        !          1802:   FILE *e = (FILE *) pinfo;
        !          1803: 
        !          1804:   if (qport->uuconf_ttype == UUCONF_PORTTYPE_DIRECT)
        !          1805:     {
        !          1806:       fprintf (e, "Direct");
        !          1807:       if (qport->uuconf_zprotocols != NULL)
        !          1808:        fprintf (e, ",%s", qport->uuconf_zprotocols);
        !          1809:       fprintf (e, " ");
        !          1810:       if (qport->uuconf_u.uuconf_sdirect.uuconf_zdevice != NULL)
        !          1811:        fprintf (e, "%s", qport->uuconf_u.uuconf_sdirect.uuconf_zdevice);
        !          1812:       else
        !          1813:        fprintf (e, "%s", qport->uuconf_zname);
        !          1814:       fprintf (e, " - %ld", qport->uuconf_u.uuconf_sdirect.uuconf_ibaud);
        !          1815:     }
        !          1816:   else if (qport->uuconf_ttype == UUCONF_PORTTYPE_MODEM)
        !          1817:     {
        !          1818:       fprintf (e, "%s", qport->uuconf_zname);
        !          1819:       if (qport->uuconf_zprotocols != NULL)
        !          1820:        fprintf (e, ",%s", qport->uuconf_zprotocols);
        !          1821:       fprintf (e, " ");
        !          1822:       if (qport->uuconf_u.uuconf_smodem.uuconf_zdevice != NULL)
        !          1823:        fprintf (e, "%s", qport->uuconf_u.uuconf_smodem.uuconf_zdevice);
        !          1824:       else
        !          1825:        fprintf (e, "%s", qport->uuconf_zname);
        !          1826:       fprintf (e, " ");
        !          1827:       if (qport->uuconf_u.uuconf_smodem.uuconf_zdial_device != NULL)
        !          1828:        fprintf (e, "%s", qport->uuconf_u.uuconf_smodem.uuconf_zdial_device);
        !          1829:       else
        !          1830:        fprintf (e, "-");
        !          1831:       fprintf (e, " ");
        !          1832:       if (qport->uuconf_u.uuconf_smodem.uuconf_ilowbaud != 0L)
        !          1833:        fprintf (e, "%ld-%ld",
        !          1834:                 qport->uuconf_u.uuconf_smodem.uuconf_ilowbaud,
        !          1835:                 qport->uuconf_u.uuconf_smodem.uuconf_ihighbaud);
        !          1836:       else if (qport->uuconf_u.uuconf_smodem.uuconf_ibaud != 0L)
        !          1837:        fprintf (e, "%ld", qport->uuconf_u.uuconf_smodem.uuconf_ibaud);
        !          1838:       else
        !          1839:        fprintf (e, "Any");
        !          1840:       if (qport->uuconf_u.uuconf_smodem.uuconf_pzdialer != NULL)
        !          1841:        {
        !          1842:          char **pz;
        !          1843: 
        !          1844:          for (pz = qport->uuconf_u.uuconf_smodem.uuconf_pzdialer;
        !          1845:               *pz != NULL;
        !          1846:               pz++)
        !          1847:            fprintf (e, " %s", *pz);
        !          1848:        }
        !          1849:     }
        !          1850:   else if (qport->uuconf_ttype == UUCONF_PORTTYPE_TCP)
        !          1851:     {
        !          1852:       fprintf (e, "TCP");
        !          1853:       if (qport->uuconf_zprotocols != NULL)
        !          1854:        fprintf (e, ",%s", qport->uuconf_zprotocols);
        !          1855:       fprintf (e, " ");
        !          1856:       if (qport->uuconf_u.uuconf_stcp.uuconf_zport == NULL)
        !          1857:        fprintf (e, "uucp");
        !          1858:       else
        !          1859:        fprintf (e, "%s", qport->uuconf_u.uuconf_stcp.uuconf_zport);
        !          1860:       fprintf (e, " - -");
        !          1861:     }
        !          1862:   else if (qport->uuconf_ttype == UUCONF_PORTTYPE_TLI)
        !          1863:     {
        !          1864:       char **pz;
        !          1865: 
        !          1866:       fprintf (e, "%s", qport->uuconf_zname);
        !          1867:       if (qport->uuconf_zprotocols != NULL)
        !          1868:        fprintf (e, ",%s", qport->uuconf_zprotocols);
        !          1869:       fprintf (e, " ");
        !          1870:       if (qport->uuconf_u.uuconf_stli.uuconf_zdevice != NULL)
        !          1871:        fprintf (e, "%s", qport->uuconf_u.uuconf_smodem.uuconf_zdevice);
        !          1872:       else
        !          1873:        fprintf (e, "-");
        !          1874:       fprintf (e, " - -");
        !          1875:       pz = qport->uuconf_u.uuconf_stli.uuconf_pzdialer;
        !          1876:       if (pz == NULL
        !          1877:          || *pz == NULL
        !          1878:          || (strcmp (*pz, "TLI") != 0
        !          1879:              && strcmp (*pz, "TLIS") != 0))
        !          1880:        fprintf (e, " TLI%s \\D",
        !          1881:                 qport->uuconf_u.uuconf_stli.uuconf_fstream ? "S" : "");
        !          1882:       if (pz != NULL)
        !          1883:        for (; *pz != NULL; pz++)
        !          1884:          fprintf (e, " %s", *pz);
        !          1885:     }
        !          1886:   else
        !          1887:     {
        !          1888:       fprintf (e, "# Ignoring port %s with unsupported type",
        !          1889:               qport->uuconf_zname);
        !          1890:     }
        !          1891: 
        !          1892:   fprintf (e, "\n");
        !          1893: 
        !          1894:   /* Return UUCONF_NOT_FOUND to force uuconf_find_port to keep looking
        !          1895:      for a port.  */
        !          1896:   return UUCONF_NOT_FOUND;
        !          1897: }
        !          1898: 
        !          1899: /* Write a dialer out to a Taylor UUCP configuration file.  This
        !          1900:    doesn't output the name, since it is called to output a specially
        !          1901:    defined dialer in the sys or port file.  */
        !          1902: 
        !          1903: static void
        !          1904: uvwrite_taylor_dialer (e, qdialer, zprefix)
        !          1905:      FILE *e;
        !          1906:      struct uuconf_dialer *qdialer;
        !          1907:      const char *zprefix;
        !          1908: {
        !          1909:   char ab[100];
        !          1910: 
        !          1911:   /* Reset default values, so we don't output them unnecessarily.  */
        !          1912:   if (qdialer->uuconf_schat.uuconf_ctimeout == 60)
        !          1913:     qdialer->uuconf_schat.uuconf_ctimeout = -1;
        !          1914:   if (qdialer->uuconf_schat.uuconf_fstrip)
        !          1915:     qdialer->uuconf_schat.uuconf_fstrip = -1;
        !          1916:   if (qdialer->uuconf_scomplete.uuconf_ctimeout == 60)
        !          1917:     qdialer->uuconf_scomplete.uuconf_ctimeout = -1;
        !          1918:   if (qdialer->uuconf_scomplete.uuconf_fstrip)
        !          1919:     qdialer->uuconf_scomplete.uuconf_fstrip = -1;
        !          1920:   if (qdialer->uuconf_sabort.uuconf_ctimeout == 60)
        !          1921:     qdialer->uuconf_sabort.uuconf_ctimeout = -1;
        !          1922:   if (qdialer->uuconf_sabort.uuconf_fstrip)
        !          1923:     qdialer->uuconf_sabort.uuconf_fstrip = -1;
        !          1924:   
        !          1925:   uvwrite_chat (e, &qdialer->uuconf_schat, (struct uuconf_chat *) NULL,
        !          1926:                zprefix, FALSE);
        !          1927:   if (qdialer->uuconf_zdialtone != NULL
        !          1928:       && strcmp (qdialer->uuconf_zdialtone, ",") != 0)
        !          1929:     fprintf (e, "%sdialtone %s\n", zprefix, qdialer->uuconf_zdialtone);
        !          1930:   if (qdialer->uuconf_zpause != NULL
        !          1931:       && strcmp (qdialer->uuconf_zpause, ",") != 0)
        !          1932:     fprintf (e, "%spause %s\n", zprefix, qdialer->uuconf_zpause);
        !          1933:   if (! qdialer->uuconf_fcarrier)
        !          1934:     fprintf (e, "%scarrier false\n", zprefix);
        !          1935:   if (qdialer->uuconf_ccarrier_wait != 60)
        !          1936:     fprintf (e, "%scarrier-wait %d\n", zprefix,
        !          1937:             qdialer->uuconf_ccarrier_wait);
        !          1938:   if (qdialer->uuconf_fdtr_toggle)
        !          1939:     fprintf (e, "%sdtr-toggle %s %s\n", zprefix,
        !          1940:             qdialer->uuconf_fdtr_toggle ? "true" : "false",
        !          1941:             qdialer->uuconf_fdtr_toggle_wait ? "true" : "false");
        !          1942:   sprintf (ab, "%scomplete-", zprefix);
        !          1943:   uvwrite_chat (e, &qdialer->uuconf_scomplete, (struct uuconf_chat *) NULL,
        !          1944:                ab, FALSE);
        !          1945:   sprintf (ab, "%sabort-", zprefix);
        !          1946:   uvwrite_chat (e, &qdialer->uuconf_sabort, (struct uuconf_chat *) NULL,
        !          1947:                ab, FALSE);
        !          1948:   if (qdialer->uuconf_qproto_params != NULL)
        !          1949:     uvwrite_proto_params (e, qdialer->uuconf_qproto_params, zprefix);
        !          1950:   if ((qdialer->uuconf_ireliable & UUCONF_RELIABLE_SPECIFIED) != 0)
        !          1951:     {
        !          1952:       sprintf (ab, "%sseven-bit", zprefix);
        !          1953:       uvwrite_boolean (e,
        !          1954:                       ((qdialer->uuconf_ireliable & UUCONF_RELIABLE_EIGHT)
        !          1955:                        == 0),
        !          1956:                       ab);
        !          1957:       sprintf (ab, "%sreliable", zprefix);
        !          1958:       uvwrite_boolean (e,
        !          1959:                       ((qdialer->uuconf_ireliable & UUCONF_RELIABLE_RELIABLE)
        !          1960:                        != 0),
        !          1961:                       ab);
        !          1962:       sprintf (ab, "%shalf-duplex", zprefix);
        !          1963:       uvwrite_boolean (e,
        !          1964:                       ((qdialer->uuconf_ireliable
        !          1965:                         & UUCONF_RELIABLE_FULLDUPLEX) == 0),
        !          1966:                       ab);
        !          1967:     }
        !          1968: }
        !          1969: 
        !          1970: /* Write a dialer out to an HDB configuration file.  */
        !          1971: 
        !          1972: static void
        !          1973: uvwrite_hdb_dialer (e, qdialer)
        !          1974:      FILE *e;
        !          1975:      struct uuconf_dialer *qdialer;
        !          1976: {
        !          1977:   fprintf (e, "%s ", qdialer->uuconf_zname);
        !          1978: 
        !          1979:   if (qdialer->uuconf_zdialtone != NULL)
        !          1980:     fprintf (e, "=%c", qdialer->uuconf_zdialtone[0]);
        !          1981:   if (qdialer->uuconf_zpause != NULL)
        !          1982:     fprintf (e, "-%c", qdialer->uuconf_zpause[0]);
        !          1983: 
        !          1984:   if (qdialer->uuconf_schat.uuconf_pzchat != NULL)
        !          1985:     {
        !          1986:       if (qdialer->uuconf_zdialtone == NULL
        !          1987:          && qdialer->uuconf_zpause == NULL)
        !          1988:        fprintf (e, "\"\"");
        !          1989:       fprintf (e, " ");
        !          1990:       uvwrite_chat_script (e, qdialer->uuconf_schat.uuconf_pzchat);
        !          1991:     }
        !          1992: 
        !          1993:   fprintf (e, "\n");
        !          1994: }
        !          1995: 
        !          1996: /* Display a uuconf error and exit.  */
        !          1997: 
        !          1998: static void
        !          1999: uvuuconf_error (puuconf, iret)
        !          2000:      pointer puuconf;
        !          2001:      int iret;
        !          2002: {
        !          2003:   char ab[512];
        !          2004: 
        !          2005:   (void) uuconf_error_string (puuconf, iret, ab, sizeof ab);
        !          2006:   if ((iret & UUCONF_ERROR_FILENAME) == 0)
        !          2007:     fprintf (stderr, "uuconv: %s\n", ab);
        !          2008:   else
        !          2009:     fprintf (stderr, "uuconv:%s\n", ab);
        !          2010:   if (UUCONF_ERROR_VALUE (iret) != UUCONF_FOPEN_FAILED)
        !          2011:     exit (EXIT_FAILURE);
        !          2012: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.