/* uuconv.c
   Convert one type of UUCP configuration file to another.

   Copyright (C) 1991, 1992, 1993, 1994, 1995 Ian Lance Taylor

   This file is part of the Taylor UUCP package.

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.

   This program is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

   The author of the program may be contacted at ian@airs.com or
   c/o Cygnus Support, 48 Grove Street, Somerville, MA 02144.
   */

#include "uucnfi.h"

#if USE_RCS_ID
const char uuconv_rcsid[] = "$Id$";
#endif

#include "getopt.h"

/* Local functions.  */

static void uvusage P((void));
static void uvhelp P((void));
static void uvwrite_time P((FILE *e, struct uuconf_timespan *qtime));
static void uvwrite_string P((FILE *e, const char *zarg, const char *zcmd));
static void uvwrite_size P((FILE *e, struct uuconf_timespan *qsize,
			    const char *zcmd));
static void uvwrite_boolean P((FILE *e, int iarg, const char *zcmd));
static void uvwrite_string_array P((FILE *e, char **pz, const char *zcmd));
static void uvwrite_chat_script P((FILE *e, char **pz));
static void uvwrite_chat P((FILE *e, const struct uuconf_chat *qchat,
			    const struct uuconf_chat *qlast,
			    const char *zprefix, boolean fforce));
static void uvwrite_proto_params P((FILE *e,
				    const struct uuconf_proto_param *qparam,
				    const char *zprefix));
static void uvwrite_taylor_system P((FILE *e,
				     const struct uuconf_system *qsys));
static void uvwrite_v2_system P((FILE *e,
				 const struct uuconf_system *qsys));
static void uvwrite_hdb_system P((FILE *e,
				  const struct uuconf_system *qsys));
static boolean fvperm_string_cmp P((const char *z1, const char *z2));
static boolean fvperm_array_cmp P((const char **pz1, const char **pz2));
static void uvadd_perm P((struct shpermissions *qadd));
static void uvwrite_perms P((void));
static void uvwrite_perm_array P((FILE *e, const char **pz,
				  const char *zcmd, size_t *pccol));
static void uvwrite_perm_boolean P((FILE *e, int f, const char *zcmd,
				    size_t *pccol, boolean fsendfiles));
static void uvwrite_perm_rw_array P((FILE *e, const char **pz,
				     const char *zcmd, size_t *pccol));
static void uvwrite_perm_string P((FILE *e, const char *z, const char *zcmd,
				   size_t *pccol));
static int ivwrite_taylor_port P((struct uuconf_port *qport,
				  pointer pinfo));
static int ivwrite_v2_port P((struct uuconf_port *qport, pointer pinfo));
static int ivwrite_hdb_port P((struct uuconf_port *qport, pointer pinfo));
static void uvwrite_taylor_port P((FILE *e, struct uuconf_port *qport,
				   const char *zprefix));
static void uvwrite_taylor_dialer P((FILE *e, struct uuconf_dialer *qdialer,
				     const char *zprefix));
static void uvwrite_hdb_dialer P((FILE *e, struct uuconf_dialer *qdialer));
static void uvuuconf_error P((pointer puuconf, int iret));

/* The program name.  */
const char *zProgram;

/* A list of Permissions entries built when writing out HDB system
   information.  */
static struct shpermissions *qVperms;

/* Type of configuration file.  */
enum tconfig
{
  CONFIG_TAYLOR,
  CONFIG_V2,
  CONFIG_HDB
};

/* Long getopt options.  */
static const struct option asVlongopts[] =
{
  { "input", required_argument, NULL, 'i' },
  { "output", required_argument, NULL, 'o' },
  { "program", required_argument, NULL, 'p' },
  { "config", required_argument, NULL, 'I' },
  { "debug", required_argument, NULL, 'x' },
  { "version", no_argument, NULL, 'v' },
  { "help", no_argument, NULL, 1 },
  { NULL, 0, NULL, 0 }
};

int
main (argc, argv)
     int argc;
     char **argv;
{
  /* -I: The configuration file name.  */
  const char *zconfig = NULL;
  /* -i: Input type.  */
  const char *zinput = NULL;
  /* -o: Output type.  */
  const char *zoutput = NULL;
  /* -p: Program name.  */
  const char *zprogram = NULL;
  int iopt;
  enum tconfig tinput, toutput;
  int iret;
  pointer pinput;

  zProgram = argv[0];

  while ((iopt = getopt_long (argc, argv, "i:I:o:p:vx:", asVlongopts,
			      (int *) NULL)) != EOF)
    {
      switch (iopt)
	{
	case 'i':
	  /* Input type.  */
	  zinput = optarg;
	  break;

	case 'o':
	  /* Output type.  */
	  zoutput = optarg;
	  break;

	case 'p':
	  /* Program name.  */
	  zprogram = optarg;
	  break;

	case 'I':
	  /* Set the configuration file name.  */
	  zconfig = optarg;
	  break;

	case 'x':
	  /* Set the debugging level.  */
	  break;

	case 'v':
	  /* Print version and exit.  */
	  fprintf
	    (stderr,
	     "%s: Taylor UUCP %s, copyright (C) 1991, 92, 93, 94, 1995 Ian Lance Taylor\n",
	     zProgram, VERSION);
	  exit (EXIT_SUCCESS);
	  /*NOTREACHED*/

	case 1:
	  /* --help.  */
	  uvhelp ();
	  exit (EXIT_SUCCESS);
	  /*NOTREACHED*/

	case 0:
	  /* Long option found, and flag value set.  */
	  break;

	default:
	  uvusage ();
	  break;
	}
    }

  if (optind != argc
      || zinput == NULL
      || zoutput == NULL)
    uvusage ();

  if (strcasecmp (zinput, "taylor") == 0)
    tinput = CONFIG_TAYLOR;
  else if (strcasecmp (zinput, "v2") == 0)
    tinput = CONFIG_V2;
  else if (strcasecmp (zinput, "hdb") == 0)
    tinput = CONFIG_HDB;
  else
    {
      uvusage ();
      tinput = CONFIG_TAYLOR;
    }

  if (strcasecmp (zoutput, "taylor") == 0)
    toutput = CONFIG_TAYLOR;
  else if (strcasecmp (zoutput, "v2") == 0)
    toutput = CONFIG_V2;
  else if (strcasecmp (zoutput, "hdb") == 0)
    toutput = CONFIG_HDB;
  else
    {
      uvusage ();
      toutput = CONFIG_TAYLOR;
    }

  if (tinput == toutput)
    uvusage ();

  iret = UUCONF_SUCCESS;

  /* Initialize the input.  */
  pinput = NULL;
  switch (tinput)
    {
    case CONFIG_TAYLOR:
      iret = uuconf_taylor_init (&pinput, zprogram, zconfig);
      break;
    case CONFIG_V2:
      iret = uuconf_v2_init (&pinput);
      break;
    case CONFIG_HDB:
      iret = uuconf_hdb_init (&pinput, zprogram);
      break;
    }
  if (iret != UUCONF_SUCCESS)
    {
      uvuuconf_error (pinput, iret);
      exit (EXIT_FAILURE);
    }

  {
    char **pzsystems;
    char *zsys;
    char abtaylor[sizeof ZCURDIR + sizeof SYSFILE - 1];
    char abv2[sizeof ZCURDIR + sizeof V2_SYSTEMS - 1];
    char abhdb[sizeof ZCURDIR + sizeof HDB_SYSTEMS - 1];
    FILE *esys;
    char **pz;

    /* Get the list of systems.  */
    switch (tinput)
      {
      case CONFIG_TAYLOR:
	iret = uuconf_taylor_system_names (pinput, &pzsystems, FALSE);
	break;
      case CONFIG_V2:
	iret = uuconf_v2_system_names (pinput, &pzsystems, FALSE);
	break;
      case CONFIG_HDB:
	iret = uuconf_hdb_system_names (pinput, &pzsystems, FALSE);
	break;
      }
    if (iret != UUCONF_SUCCESS)
      uvuuconf_error (pinput, iret);
    else
      {
	/* Open the sys file for the output type.  */
	switch (toutput)
	  {
	  default:
	  case CONFIG_TAYLOR:
	    sprintf (abtaylor, "%s%s", ZCURDIR, SYSFILE);
	    zsys = abtaylor;
	    break;
	  case CONFIG_V2:
	    sprintf (abv2, "%s%s", ZCURDIR, V2_SYSTEMS);
	    zsys = abv2;
	    break;
	  case CONFIG_HDB:
	    sprintf (abhdb, "%s%s", ZCURDIR, HDB_SYSTEMS);
	    zsys = abhdb;
	    break;
	  }
	esys = fopen (zsys, "w");
	if (esys == NULL)
	  {
	    fprintf (stderr, "uuchk:%s: ", zsys);
	    perror ("fopen");
	    exit (EXIT_FAILURE);
	  }

	fprintf (esys, "# %s file automatically generated by uuconv.\n",
		 zsys);

	/* Read and write each system.  We cheat and call the internal
	   routines, so that we can easily detect default information and
	   not write it out.  This isn't necessary, but it makes the output
	   smaller and simpler.  */
	for (pz = pzsystems; *pz != NULL; pz++)
	  {
	    struct uuconf_system ssys;

	    switch (tinput)
	      {
	      case CONFIG_TAYLOR:
		iret = _uuconf_itaylor_system_internal (pinput, *pz, &ssys);
		break;
	      case CONFIG_V2:
		iret = _uuconf_iv2_system_internal (pinput, *pz, &ssys);
		break;
	      case CONFIG_HDB:
		iret = _uuconf_ihdb_system_internal (pinput, *pz, &ssys);
		break;
	      }
	    if (iret != UUCONF_SUCCESS)
	      uvuuconf_error (pinput, iret);
	    else
	      {
		switch (toutput)
		  {
		  case CONFIG_TAYLOR:
		    uvwrite_taylor_system (esys, &ssys);
		    break;
		  case CONFIG_V2:
		    uvwrite_v2_system (esys, &ssys);
		    break;
		  case CONFIG_HDB:
		    uvwrite_hdb_system (esys, &ssys);
		    break;
		  }
		if (toutput != CONFIG_HDB)
		  (void) uuconf_system_free (pinput, &ssys);
	      }
	  }

	if (toutput == CONFIG_HDB)
	  uvwrite_perms ();

	if (ferror (esys)
	    || fclose (esys) == EOF)
	  {
	    fprintf (stderr, "uuchk:%s: error during output\n", zsys);
	    exit (EXIT_FAILURE);
	  }
      }
  }

  {
    /* Open the port file for the output type.  */
    char *zport;
    char abtaylor[sizeof ZCURDIR + sizeof PORTFILE - 1];
    char abv2[sizeof ZCURDIR + sizeof V2_DEVICES - 1];
    char abhdb[sizeof ZCURDIR + sizeof HDB_DEVICES - 1];
    FILE *eport;
    int (*piportfn) P((struct uuconf_port *, pointer));
    struct uuconf_port sport;

    switch (toutput)
      {
      default:
      case CONFIG_TAYLOR:
	sprintf (abtaylor, "%s%s", ZCURDIR, PORTFILE);
	zport = abtaylor;
	piportfn = ivwrite_taylor_port;
	break;
      case CONFIG_V2:
	sprintf (abv2, "%s%s", ZCURDIR, V2_DEVICES);
	zport = abv2;
	piportfn = ivwrite_v2_port;
	break;
      case CONFIG_HDB:
	sprintf (abhdb, "%s%s", ZCURDIR, HDB_DEVICES);
	zport = abhdb;
	piportfn = ivwrite_hdb_port;
	break;
      }
    eport = fopen (zport, "w");
    if (eport == NULL)
      {
	fprintf (stderr, "uuchk:%s: ", zport);
	perror ("fopen");
	exit (EXIT_FAILURE);
      }

    fprintf (eport, "# %s file automatically generated by uuconv.\n", zport);

    switch (tinput)
      {
      case CONFIG_TAYLOR:
	iret = uuconf_taylor_find_port (pinput, (const char *) NULL, 0L,
					0L, piportfn, (pointer) eport,
					&sport);
	break;
      case CONFIG_V2:
	iret = uuconf_v2_find_port (pinput, (const char *) NULL, 0L, 0L,
				    piportfn, (pointer) eport, &sport);
	break;
      case CONFIG_HDB:
	iret = uuconf_hdb_find_port (pinput, (const char *) NULL, 0L, 0L,
				     piportfn, (pointer) eport, &sport);
	break;
      }
	
    if (iret != UUCONF_NOT_FOUND)
      uvuuconf_error (pinput, iret);

    if (ferror (eport)
	|| fclose (eport) == EOF)
      {
	fprintf (stderr, "uuchk:%s: error during output\n", zport);
	exit (EXIT_FAILURE);
      }
  }

  /* V2 configuration files don't support dialers.  */
  if (tinput != CONFIG_V2 && toutput != CONFIG_V2)
    {
      char **pzdialers;
      char *zdialer;
      char abtaylor[sizeof ZCURDIR + sizeof DIALFILE - 1];
      char abhdb[sizeof ZCURDIR + sizeof HDB_DIALERS - 1];
      FILE *edialer;
      char **pz;

      /* Get the list of dialers.  */
      switch (tinput)
	{
	default:
	case CONFIG_TAYLOR:
	  iret = uuconf_taylor_dialer_names (pinput, &pzdialers);
	  break;
	case CONFIG_HDB:
	  iret = uuconf_hdb_dialer_names (pinput, &pzdialers);
	  break;
	}
      if (iret != UUCONF_SUCCESS)
	uvuuconf_error (pinput, iret);
      else
	{
	  /* Open the sys file for the output type.  */
	  switch (toutput)
	    {
	    default:
	    case CONFIG_TAYLOR:
	      sprintf (abtaylor, "%s%s", ZCURDIR, DIALFILE);
	      zdialer = abtaylor;
	      break;
	    case CONFIG_HDB:
	      sprintf (abhdb, "%s%s", ZCURDIR, HDB_DIALERS);
	      zdialer = abhdb;
	      break;
	    }
	  edialer = fopen (zdialer, "w");
	  if (edialer == NULL)
	    {
	      fprintf (stderr, "uuchk:%s: ", zdialer);
	      perror ("fopen");
	      exit (EXIT_FAILURE);
	    }

	  fprintf (edialer, "# %s file automatically generated by uuconv.\n",
		   zdialer);

	  /* Read and write each dialer.  */
	  for (pz = pzdialers; *pz != NULL; pz++)
	    {
	      struct uuconf_dialer sdialer;

	      switch (tinput)
		{
		default:
		case CONFIG_TAYLOR:
		  iret = uuconf_taylor_dialer_info (pinput, *pz, &sdialer);
		  break;
		case CONFIG_HDB:
		  iret = uuconf_hdb_dialer_info (pinput, *pz, &sdialer);
		  break;
		}
	      if (iret != UUCONF_SUCCESS)
		uvuuconf_error (pinput, iret);
	      else
		{
		  switch (toutput)
		    {
		    default:
		    case CONFIG_TAYLOR:
		      fprintf (edialer, "# Start of dialer %s\n",
			       sdialer.uuconf_zname);
		      fprintf (edialer, "dialer %s\n", sdialer.uuconf_zname);
		      uvwrite_taylor_dialer (edialer, &sdialer, "");
		      break;
		    case CONFIG_HDB:
		      uvwrite_hdb_dialer (edialer, &sdialer);
		      break;
		    }
		  (void) uuconf_dialer_free (pinput, &sdialer);
		}
	    }

	  if (ferror (edialer)
	      || fclose (edialer) == EOF)
	    {
	      fprintf (stderr, "uuchk:%s: error during output\n", zdialer);
	      exit (EXIT_FAILURE);
	    }
	}
    }

  exit (EXIT_SUCCESS);

  /* Avoid complaints about not returning.  */
  return 0;
}

/* Print out a usage message and die.  */

static void
uvusage ()
{
  fprintf (stderr, "Usage: %s -i input-type -o output-type [-p program]\n",
	   zProgram);
  fprintf (stderr, "Use %s --help for help\n", zProgram);
  exit (EXIT_FAILURE);
}

/* Print a help message.  */

static void
uvhelp ()
{
  fprintf (stderr,
	   "Taylor UUCP %s, copyright (C) 1991, 92, 93, 94, 1995 Ian Lance Taylor\n",
	   VERSION);
  fprintf (stderr, "Converts UUCP configuration files from one format to another.\n");
  fprintf (stderr,
	   "Usage: %s -i input -o output [-p program] [-I file]\n", zProgram);
  fprintf (stderr,
	   " -i,--input input: Set input type (one of taylor, v2, hdb)\n");
  fprintf (stderr,
	   " -o,--output output: Set output type (one of taylor, v2, hdb)\n");
  fprintf (stderr,
	   " -p,--program program: Program to convert (e.g., uucp or cu)\n");
  fprintf (stderr,
	   " -I,--config file: Set Taylor UUCP configuration file to use\n");
  fprintf (stderr,
	   " -v,--version: Print version and exit\n");
  fprintf (stderr,
	   " --help: Print help and exit\n");
}

/* Write out a timespan.  */

static void
uvwrite_time (e, qtime)
     FILE *e;
     struct uuconf_timespan *qtime;
{
  if (qtime == NULL)
    {
      fprintf (e, "Never");
      return;
    }

  if (qtime->uuconf_istart == 0 && qtime->uuconf_iend == 7 * 24 * 60)
    {
      fprintf (e, "Any");
      return;
    }

  for (; qtime != NULL; qtime = qtime->uuconf_qnext)
    {
      int idaystart, idayend;
      int ihourstart, ihourend;
      int iminutestart, iminuteend;
      const char * const zdays = "Su\0Mo\0Tu\0We\0Th\0Fr\0Sa";

      idaystart = qtime->uuconf_istart / (24 * 60);
      ihourstart = (qtime->uuconf_istart % (24 * 60)) / 60;
      iminutestart = qtime->uuconf_istart % 60;
      if (qtime->uuconf_iend >= 7 * 24 * 60)
	qtime->uuconf_iend = 7 * 24 * 60 - 1;
      idayend = qtime->uuconf_iend / (24 * 60);
      ihourend = (qtime->uuconf_iend % (24 * 60)) / 60;
      iminuteend = qtime->uuconf_iend % 60;
      if (ihourend == 0 && iminuteend == 0)
	--idayend;

      if (idaystart == idayend)
	fprintf (e, "%s%02d%02d-%02d%02d", zdays + idaystart * 3,
		 ihourstart, iminutestart, ihourend, iminuteend);
      else
	{
	  int i;

	  fprintf (e, "%s%02d%02d-0000", zdays + idaystart * 3,
		   ihourstart, iminutestart);
	  for (i = idaystart + 1; i < idayend; i++)
	    fprintf (e, ",%s", zdays + i * 3);
	  if (ihourend != 0 || iminuteend != 0)
	    fprintf (e, ",%s0000-%02d%02d", zdays + idayend * 3, ihourend,
		     iminuteend);
	}

      if (qtime->uuconf_qnext != NULL)
	fprintf (e, ",");
    }
}

/* Some subroutines used when writing out Taylor UUCP configuration
   files.  */

/* Write a command with a string argument.  */

static void
uvwrite_string (e, zarg, zcmd)
     FILE *e;
     const char *zarg;
     const char *zcmd;
{
  if (zarg != (const char *) &_uuconf_unset)
    fprintf (e, "%s %s\n", zcmd, zarg == NULL ? (const char *) "" : zarg);
}

/* Write out a size restriction command.  */

static void
uvwrite_size (e, qtime, zcmd)
     FILE *e;
     struct uuconf_timespan *qtime;
     const char *zcmd;
{
  if (qtime != (struct uuconf_timespan *) &_uuconf_unset)
    {
      for (; qtime != NULL; qtime = qtime->uuconf_qnext)
	{
	  fprintf (e, "%s %ld", zcmd, qtime->uuconf_ival);
	  uvwrite_time (e, qtime);
	  fprintf (e, "\n");
	}
    }
}

/* Write out a boolean argument with a string command.  If the value
   is less than zero, than it was uninitialized and we don't write
   anything.  */

static void
uvwrite_boolean (e, fval, zcmd)
     FILE *e;
     int fval;
     const char *zcmd;
{
  if (fval >= 0)
    fprintf (e, "%s %s\n", zcmd, fval > 0 ? "true" : "false");
}

/* Write out a string array as a single command.  */

static void
uvwrite_string_array (e, pz, zcmd)
     FILE *e;
     char **pz;
     const char *zcmd;
{
  if (pz != (char **) &_uuconf_unset)
    {
      fprintf (e, "%s", zcmd);
      if (pz != NULL)
	for (; *pz != NULL; pz++)
	  fprintf (e, " %s", *pz);
      fprintf (e, "\n");
    }
}

/* Write out a chat script.  Don't separate subsend/subexpect strings
   by spaces.  */

static void
uvwrite_chat_script (e, pzarg)
     FILE *e;
     char **pzarg;
{
  char **pz;

  if (pzarg == NULL || pzarg == (char **) &_uuconf_unset)
    return;

  for (pz = pzarg; *pz != NULL; pz++)
    {
      if ((*pz)[0] != '-' && pz != pzarg)
	fprintf (e, " ");
      fprintf (e, *pz);
    }
}

/* Write out chat information.  If the qlast argument is not NULL,
   then only values that are different from qlast should be written.
   The fforce argument is used to get around a peculiar problem: if
   the ``chat'' command is used with no arguments for a system, then
   uuconf_pzchat will be NULL (not &_uuconf_unset) and the default
   chat script will not be used.  We must distinguish this case from
   the ``chat'' command not appearing at all for a port or dialer, in
   which case the value will again be NULL.  In the former case we
   must output a ``chat'' command, in the latter case we would prefer
   not to.  */

static void
uvwrite_chat (e, q, qlast, zprefix, fforce)
     FILE *e;
     const struct uuconf_chat *q;
     const struct uuconf_chat *qlast;
     const char *zprefix;
     boolean fforce;
{
  char **pz;
  char ab[100];

  if (q->uuconf_pzchat != (char **) &_uuconf_unset
      && (qlast == NULL
	  ? (fforce || q->uuconf_pzchat != NULL)
	  : qlast->uuconf_pzchat != q->uuconf_pzchat))
    {
      fprintf (e, "%schat ", zprefix);
      uvwrite_chat_script (e, q->uuconf_pzchat);
      fprintf (e, "\n");
    }

  if (q->uuconf_pzprogram != (char **) &_uuconf_unset
      && (qlast == NULL
	  ? q->uuconf_pzprogram != NULL
	  : qlast->uuconf_pzprogram != q->uuconf_pzprogram))
    {
      sprintf (ab, "%schat-program", zprefix);
      uvwrite_string_array (e, q->uuconf_pzprogram, ab);
    }

  if (q->uuconf_ctimeout >= 0
      && (qlast == NULL
	  || qlast->uuconf_ctimeout != q->uuconf_ctimeout))
    fprintf (e, "%schat-timeout %d\n", zprefix, q->uuconf_ctimeout);

  if (q->uuconf_pzfail != NULL
      && q->uuconf_pzfail != (char **) &_uuconf_unset
      && (qlast == NULL
	  || qlast->uuconf_pzfail != q->uuconf_pzfail))
    for (pz = q->uuconf_pzfail; *pz != NULL; pz++)
      fprintf (e, "%schat-fail %s\n", zprefix, *pz);
      
  if (qlast == NULL || qlast->uuconf_fstrip != q->uuconf_fstrip)
    {
      sprintf (ab, "%schat-strip", zprefix);
      uvwrite_boolean (e, q->uuconf_fstrip, ab);
    }
}

/* Write out protocol parameters to a Taylor UUCP file.  */

static void
uvwrite_proto_params (e, qparams, zprefix)
     FILE *e;
     const struct uuconf_proto_param *qparams;
     const char *zprefix;
{
  const struct uuconf_proto_param *qp;

  if (qparams == NULL
      || qparams == (struct uuconf_proto_param *) &_uuconf_unset)
    return;

  for (qp = qparams; qp->uuconf_bproto != '\0'; qp++)
    {
      const struct uuconf_proto_param_entry *qe;

      for (qe = qp->uuconf_qentries; qe->uuconf_cargs > 0; qe++)
	{
	  int i;

	  fprintf (e, "%sprotocol-parameter %c", zprefix, qp->uuconf_bproto);
	  for (i = 0; i < qe->uuconf_cargs; i++)
	    fprintf (e, " %s", qe->uuconf_pzargs[i]);
	  fprintf (e, "\n");
	}
    }
}

/* Write out Taylor UUCP system information.  */

static void
uvwrite_taylor_system (e, q)
     FILE *e;
     const struct uuconf_system *q;
{
  char **pz;
  const struct uuconf_system *qlast;

  fprintf (e, "# Start of system %s\n", q->uuconf_zname);

  fprintf (e, "system %s\n", q->uuconf_zname);
  if (q->uuconf_pzalias != NULL
      && q->uuconf_pzalias != (char **) &_uuconf_unset)
    for (pz = q->uuconf_pzalias; *pz != NULL; pz++)
      uvwrite_string (e, *pz, "alias");

  for (qlast = NULL; q != NULL; qlast = q, q = q->uuconf_qalternate)
    {
      struct uuconf_timespan *qtime;

      if (qlast != NULL)
	{
	  fprintf (e, "alternate");
	  if (q->uuconf_zalternate != (char *) &_uuconf_unset
	      && q->uuconf_zalternate != NULL)
	    fprintf (e, " %s", q->uuconf_zalternate);
	  fprintf (e, "\n");
	}

#define CHANGED(x) (qlast == NULL || qlast->x != q->x)

      if (CHANGED (uuconf_qtimegrade)
	  && (q->uuconf_qtimegrade
	      != (struct uuconf_timespan *) &_uuconf_unset))
	{
	  if (q->uuconf_qtimegrade == NULL)
	    fprintf (e, "time never\n");
	  else
	    {
	      for (qtime = q->uuconf_qtimegrade;
		   qtime != NULL;
		   qtime = qtime->uuconf_qnext)
		{
		  if ((char) qtime->uuconf_ival == UUCONF_GRADE_LOW)
		    fprintf (e, "time ");
		  else
		    fprintf (e, "timegrade %c ", (char) qtime->uuconf_ival);
		  uvwrite_time (e, qtime);
		  if (qtime->uuconf_cretry != 0)
		    fprintf (e, " %d", qtime->uuconf_cretry);
		  fprintf (e, "\n");
		}
	    }
	}

      if (CHANGED (uuconf_qcalltimegrade)
	  && (q->uuconf_qcalltimegrade
	      != (struct uuconf_timespan *) &_uuconf_unset))
	{
	  for (qtime = q->uuconf_qcalltimegrade;
	       qtime != NULL;
	       qtime = qtime->uuconf_qnext)
	    {
	      fprintf (e, "call-timegrade %c ", (char) qtime->uuconf_ival);
	      uvwrite_time (e, qtime);
	      fprintf (e, "\n");
	    }
	}

      if (CHANGED (uuconf_qcalledtimegrade)
	  && (q->uuconf_qcalledtimegrade
	      != (struct uuconf_timespan *) &_uuconf_unset))
	{
	  for (qtime = q->uuconf_qcalledtimegrade;
	       qtime != NULL;
	       qtime = qtime->uuconf_qnext)
	    {
	      fprintf (e, "called-timegrade %c ", (char) qtime->uuconf_ival);
	      uvwrite_time (e, qtime);
	      fprintf (e, "\n");
	    }
	}

      if (CHANGED (uuconf_qcall_local_size))
	uvwrite_size (e, q->uuconf_qcall_local_size, "call-local-size");

      if (CHANGED (uuconf_qcall_remote_size))
	uvwrite_size (e, q->uuconf_qcall_remote_size, "call-remote-size");

      if (CHANGED (uuconf_qcalled_local_size))
	uvwrite_size (e, q->uuconf_qcalled_local_size, "called-local-size");

      if (CHANGED (uuconf_qcalled_remote_size))
	uvwrite_size (e, q->uuconf_qcalled_remote_size, "called-remote-size");

      if (CHANGED (uuconf_ibaud) || CHANGED (uuconf_ihighbaud))
	{
	  if (q->uuconf_ibaud >= 0)
	    {
	      if (q->uuconf_ihighbaud > 0)
		fprintf (e, "baud-range %ld %ld\n", q->uuconf_ibaud,
			 q->uuconf_ihighbaud);
	      else
		fprintf (e, "baud %ld\n", q->uuconf_ibaud);
	    }
	}

      if (CHANGED (uuconf_zport) || CHANGED (uuconf_qport))
	{
	  if (q->uuconf_zport != NULL
	      && q->uuconf_zport != (char *) &_uuconf_unset)
	    uvwrite_string (e, q->uuconf_zport, "port");
	  else if (q->uuconf_qport != NULL
		   && (q->uuconf_qport
		       != (struct uuconf_port *) &_uuconf_unset))
	    uvwrite_taylor_port (e, q->uuconf_qport, "port ");
	}

      if (CHANGED (uuconf_zphone))
	{
	  const char *zcmd;

	  if (q->uuconf_qport != NULL
	      && q->uuconf_qport != (struct uuconf_port *) &_uuconf_unset
	      && (q->uuconf_qport->uuconf_ttype == UUCONF_PORTTYPE_TCP
		  || q->uuconf_qport->uuconf_ttype == UUCONF_PORTTYPE_TLI))
	    zcmd = "address";
	  else
	    zcmd = "phone";
	  uvwrite_string (e, q->uuconf_zphone, zcmd);
	}

      uvwrite_chat (e, &q->uuconf_schat,
		    (qlast == NULL
		     ? (struct uuconf_chat *) NULL
		     : &qlast->uuconf_schat),
		    "", TRUE);

      if (CHANGED (uuconf_zcall_login))
	uvwrite_string (e, q->uuconf_zcall_login, "call-login");

      if (CHANGED (uuconf_zcall_password))
	uvwrite_string (e, q->uuconf_zcall_password, "call-password");

      if (CHANGED (uuconf_zcalled_login))
	uvwrite_string (e, q->uuconf_zcalled_login, "called-login");

      if (CHANGED (uuconf_fcallback))
	uvwrite_boolean (e, q->uuconf_fcallback, "callback");

      if (CHANGED (uuconf_fsequence))
	uvwrite_boolean (e, q->uuconf_fsequence, "sequence");

      if (CHANGED (uuconf_zprotocols))
	uvwrite_string (e, q->uuconf_zprotocols, "protocol");

      if (CHANGED (uuconf_qproto_params))
	uvwrite_proto_params (e, q->uuconf_qproto_params, "");
      
      uvwrite_chat (e, &q->uuconf_scalled_chat,
		    (qlast == NULL
		     ? (struct uuconf_chat *) NULL
		     : &qlast->uuconf_scalled_chat),
		    "called-", FALSE);

      if (CHANGED (uuconf_zdebug))
	uvwrite_string (e, q->uuconf_zdebug, "debug");

      if (CHANGED (uuconf_zmax_remote_debug))
	uvwrite_string (e, q->uuconf_zmax_remote_debug, "max-remote-debug");

      if ((CHANGED (uuconf_fsend_request)
	   || CHANGED (uuconf_frec_request))
	  && (q->uuconf_fsend_request >= 0
	      || q->uuconf_frec_request >= 0))
	{
	  if (q->uuconf_fsend_request >= 0
	      && (q->uuconf_fsend_request > 0
		  ? q->uuconf_frec_request > 0
		  : q->uuconf_frec_request == 0))
	    uvwrite_boolean (e, q->uuconf_fsend_request, "request");
	  else
	    {
	      uvwrite_boolean (e, q->uuconf_fsend_request, "send-request");
	      uvwrite_boolean (e, q->uuconf_frec_request,
			       "receive-request");
	    }
	}

      if ((CHANGED (uuconf_fcall_transfer)
	   || CHANGED (uuconf_fcalled_transfer))
	  && (q->uuconf_fcall_transfer >= 0
	      || q->uuconf_fcalled_transfer >= 0))
	{
	  if (q->uuconf_fcall_transfer >= 0
	      && (q->uuconf_fcall_transfer > 0
		  ? q->uuconf_fcalled_transfer > 0
		  : q->uuconf_fcalled_transfer == 0))
	    uvwrite_boolean (e, q->uuconf_fcall_transfer, "transfer");
	  else
	    {
	      uvwrite_boolean (e, q->uuconf_fcall_transfer, "call-transfer");
	      uvwrite_boolean (e, q->uuconf_fcalled_transfer,
			       "called-transfer");
	    }
	}

      if (CHANGED (uuconf_pzlocal_send))
	uvwrite_string_array (e, q->uuconf_pzlocal_send, "local-send");

      if (CHANGED (uuconf_pzremote_send))
	uvwrite_string_array (e, q->uuconf_pzremote_send, "remote-send");

      if (CHANGED (uuconf_pzlocal_receive))
	uvwrite_string_array (e, q->uuconf_pzlocal_receive, "local-receive");

      if (CHANGED (uuconf_pzremote_receive))
	uvwrite_string_array (e, q->uuconf_pzremote_receive,
			      "remote-receive");

      if (CHANGED (uuconf_pzpath))
	uvwrite_string_array (e, q->uuconf_pzpath, "command-path");

      if (CHANGED (uuconf_pzcmds))
	uvwrite_string_array (e, q->uuconf_pzcmds, "commands");

      if (CHANGED (uuconf_cfree_space)
	  && q->uuconf_cfree_space >= 0)
	fprintf (e, "free-space %ld\n", q->uuconf_cfree_space);

      if (CHANGED (uuconf_pzforward_from))
	uvwrite_string_array (e, q->uuconf_pzforward_from, "forward-from");

      if (CHANGED (uuconf_pzforward_to))
	uvwrite_string_array (e, q->uuconf_pzforward_to, "forward-to");

      if (CHANGED (uuconf_zpubdir))
	uvwrite_string (e, q->uuconf_zpubdir, "pubdir");

      if (CHANGED (uuconf_zlocalname))
	uvwrite_string (e, q->uuconf_zlocalname, "myname");
    }
}

/* Write out V2 system information.  */

static void
uvwrite_v2_system (e, q)
     FILE *e;
     const struct uuconf_system *q;
{
  for (; q != NULL; q = q->uuconf_qalternate)
    {
      fprintf (e, "%s", q->uuconf_zname);

      if (q->uuconf_qtimegrade != (struct uuconf_timespan *) &_uuconf_unset)
	{
	  fprintf (e, " ");
	  uvwrite_time (e, q->uuconf_qtimegrade);

	  if (q->uuconf_zport != (char *) &_uuconf_unset
	      || q->uuconf_qport != (struct uuconf_port *) &_uuconf_unset)
	    {
	      struct uuconf_port *qp;
	      boolean ftcp;

	      qp = q->uuconf_qport;
	      ftcp = (qp != (struct uuconf_port *) &_uuconf_unset
		      && qp != NULL
		      && qp->uuconf_ttype == UUCONF_PORTTYPE_TCP);
	      if (ftcp
		  || (q->uuconf_zport != NULL
		      && q->uuconf_zport != (char *) &_uuconf_unset))
		{
		  if (ftcp)
		    fprintf (e, " TCP");
		  else
		    fprintf (e, " %s", q->uuconf_zport);

		  if (ftcp || q->uuconf_ibaud >= 0)
		    {
		      fprintf (e, " ");
		      if (ftcp)
			{
			  const char *zport;

			  zport = qp->uuconf_u.uuconf_stcp.uuconf_zport;
			  if (zport == NULL)
			    zport = "uucp";
			  fprintf (e, "%s", zport);
			}
		      else
			fprintf (e, "%ld", q->uuconf_ibaud);

		      if (q->uuconf_zphone != (char *) &_uuconf_unset
			  && q->uuconf_zphone != NULL)
			{
			  char **pzc;
			  
			  fprintf (e, " %s", q->uuconf_zphone);
			  pzc = q->uuconf_schat.uuconf_pzchat;
			  if (pzc != (char **) &_uuconf_unset
			      && pzc != NULL)
			    {
			      fprintf (e, " ");
			      uvwrite_chat_script (e, pzc);
			    }
			}
		    }
		}
	    }
	}

      fprintf (e, "\n");

      /* Here we should gather information to write out to USERFILE
	 and L.cmds, and perhaps some day we will.  It's much more
	 likely to happen if somebody else does it, though.  */
    }
}

/* Write out HDB system information.  */

static void
uvwrite_hdb_system (e, qsys)
     FILE *e;
     const struct uuconf_system *qsys;
{
  const struct uuconf_system *q;
  struct shpermissions sperm;
  char *azmachine[2];
  char *azlogname[2];

  for (q = qsys; q != NULL; q = q->uuconf_qalternate)
    {
      if (q->uuconf_fcall)
	{
	  fprintf (e, "%s", q->uuconf_zname);

	  if (q->uuconf_qtimegrade
	      != (struct uuconf_timespan *) &_uuconf_unset)
	    {
	      const char *zport;

	      fprintf (e, " ");
	      uvwrite_time (e, q->uuconf_qtimegrade);

	      zport = q->uuconf_zport;
	      if (q->uuconf_qport != NULL
		  && q->uuconf_qport != (struct uuconf_port *) &_uuconf_unset
		  && q->uuconf_qport->uuconf_ttype == UUCONF_PORTTYPE_TCP)
		zport = "TCP";
	      if (zport != NULL && zport != (char *) &_uuconf_unset)
		{
		  fprintf (e, " %s", zport);
		  if (q->uuconf_zprotocols != (char *) &_uuconf_unset
		      && q->uuconf_zprotocols != NULL)
		    fprintf (e, ",%s", q->uuconf_zprotocols);

		  if (q->uuconf_ibaud >= 0
		      || q->uuconf_zphone != (char *) &_uuconf_unset)
		    {
		      fprintf (e, " ");
		      if (q->uuconf_ibaud < 0)
			fprintf (e, "Any");
		      else
			{
			  fprintf (e, "%ld", q->uuconf_ibaud);
			  if (q->uuconf_ihighbaud >= 0)
			    fprintf (e, "-%ld", q->uuconf_ihighbaud);
			}

		      if (q->uuconf_zphone != (char *) &_uuconf_unset
			  && q->uuconf_zphone != NULL)
			{
			  char **pzc;
			  
			  fprintf (e, " %s", q->uuconf_zphone);
			  pzc = q->uuconf_schat.uuconf_pzchat;
			  if (pzc != (char **) &_uuconf_unset
			      && pzc != NULL)
			    {
			      fprintf (e, " ");
			      uvwrite_chat_script (e, pzc);
			    }
			}
		    }
		}
	    }

	  fprintf (e, "\n");
	}
    }

  /* Build a Permissions entry for this system.  There will be only
     one MACHINE entry for a given system.  */

  for (q = qsys; q != NULL; q = q->uuconf_qalternate)
    if (q->uuconf_fcall)
      break;

  if (q != NULL)
    {
      sperm.qnext = NULL;
      sperm.pzlogname = NULL;
      sperm.pzmachine = NULL;
      sperm.frequest = -1;
      sperm.fsendfiles = -1;
      sperm.pzread = NULL;
      sperm.pzwrite = NULL;
      sperm.fcallback = -1;
      sperm.pzcommands = NULL;
      sperm.pzvalidate = NULL;
      sperm.zmyname = NULL;
      sperm.zpubdir = NULL;
      sperm.pzalias = NULL;

      azmachine[0] = q->uuconf_zname;
      azmachine[1] = NULL;
      sperm.pzmachine = azmachine;
      if (q->uuconf_fsend_request >= 0)
	sperm.frequest = q->uuconf_fsend_request;
      if (q->uuconf_pzremote_send != (char **) &_uuconf_unset
	  && q->uuconf_pzremote_send != NULL)
	sperm.pzread = q->uuconf_pzremote_send;
      if (q->uuconf_pzremote_receive != (char **) &_uuconf_unset
	  && q->uuconf_pzremote_receive != NULL)
	sperm.pzwrite = q->uuconf_pzremote_receive;
      if (q->uuconf_pzcmds != (char **) &_uuconf_unset
	  && q->uuconf_pzcmds != NULL)
	sperm.pzcommands = q->uuconf_pzcmds;
      if (q->uuconf_zlocalname != (char *) &_uuconf_unset
	  && q->uuconf_zlocalname != NULL)
	sperm.zmyname = q->uuconf_zlocalname;
      if (q->uuconf_zpubdir != (char *) &_uuconf_unset
	  && q->uuconf_zpubdir != NULL)
	sperm.zpubdir = q->uuconf_zpubdir;
      if (q->uuconf_pzalias != (char **) &_uuconf_unset
	  && q->uuconf_pzalias != NULL)
	sperm.pzalias = q->uuconf_pzalias;

      if (q->uuconf_fcalled
	  && q->uuconf_zcalled_login != (char *) &_uuconf_unset
	  && q->uuconf_zcalled_login != NULL)
	{
	  azlogname[0] = q->uuconf_zcalled_login;
	  azlogname[1] = NULL;
	  sperm.pzlogname = azlogname;
	  if (q->uuconf_fcalled_transfer >= 0)
	    sperm.fsendfiles = q->uuconf_fcalled_transfer;
	  if (q->uuconf_fcallback >= 0)
	    sperm.fcallback = q->uuconf_fcallback;
	  sperm.pzvalidate = azmachine;
	}

      uvadd_perm (&sperm);
    }

  /* Now add a Permissions entry for each alternative that is not used
     for calling out.  */
  for (q = qsys; q != NULL; q = q->uuconf_qalternate)
    {
      if (! q->uuconf_fcalled || q->uuconf_fcall)
	continue;

      sperm.qnext = NULL;
      sperm.pzlogname = NULL;
      sperm.pzmachine = NULL;
      sperm.frequest = -1;
      sperm.fsendfiles = -1;
      sperm.pzread = NULL;
      sperm.pzwrite = NULL;
      sperm.fcallback = -1;
      sperm.pzcommands = NULL;
      sperm.pzvalidate = NULL;
      sperm.zmyname = NULL;
      sperm.zpubdir = NULL;
      sperm.pzalias = NULL;

      if (q->uuconf_zcalled_login != (char *) &_uuconf_unset
	  && q->uuconf_zcalled_login != NULL)
	azlogname[0] = q->uuconf_zcalled_login;
      else
	azlogname[0] = (char *) "OTHER";
      azlogname[1] = NULL;
      sperm.pzlogname = azlogname;

      if (q->uuconf_fsend_request >= 0)
	sperm.frequest = q->uuconf_fsend_request;
      if (q->uuconf_fcalled_transfer >= 0)
	sperm.fsendfiles = q->uuconf_fcalled_transfer;
      if (q->uuconf_pzremote_send != (char **) &_uuconf_unset
	  && q->uuconf_pzremote_send != NULL)
	sperm.pzread = q->uuconf_pzremote_send;
      if (q->uuconf_pzremote_receive != (char **) &_uuconf_unset
	  && q->uuconf_pzremote_receive != NULL)
	sperm.pzwrite = q->uuconf_pzremote_receive;
      if (q->uuconf_fcallback >= 0)
	sperm.fcallback = q->uuconf_fcallback;
      if (q->uuconf_zlocalname != (char *) &_uuconf_unset
	  && q->uuconf_zlocalname != NULL)
	sperm.zmyname = q->uuconf_zlocalname;
      if (q->uuconf_zpubdir != (char *) &_uuconf_unset
	  && q->uuconf_zpubdir != NULL)
	sperm.zpubdir = q->uuconf_zpubdir;

      uvadd_perm (&sperm);
    }
}

/* Compare two strings from a Permissions entry, returning TRUE if
   they are the same.  */

static boolean
fvperm_string_cmp (z1, z2)
     const char *z1;
     const char *z2;
{
  if (z1 == NULL)
    return z2 == NULL;

  if (z2 == NULL)
    return FALSE;

  return strcmp (z1, z2) == 0;
}

/* Compare two arrays of strings from a Permissions entry, returning
   TRUE if they are the same.  */

static boolean
fvperm_array_cmp (pz1, pz2)
     const char **pz1;
     const char **pz2;
{
  if (pz1 == NULL)
    return pz2 == NULL;

  if (pz2 == NULL)
    return FALSE;

  for (; *pz1 != NULL && *pz2 != NULL; pz1++, pz2++)
    if (strcmp (*pz1, *pz2) != 0)
      break;

  return *pz1 == NULL && *pz2 == NULL;
}      

/* Add a Permissions entry to a global list, combining entries where
   possible.  */

static void
uvadd_perm (qadd)
     struct shpermissions *qadd;
{
  struct shpermissions *qlook;
  struct shpermissions *qnew;
  int iret;

  /* If there's no information, don't bother to add this entry.  */
  if (qadd->pzlogname == NULL
      && qadd->frequest < 0
      && qadd->fsendfiles < 0
      && qadd->pzread == NULL
      && qadd->pzwrite == NULL
      && qadd->fcallback < 0
      && qadd->pzcommands == NULL
      && qadd->pzvalidate == NULL
      && qadd->zmyname == NULL
      && qadd->zpubdir == NULL
      && qadd->pzalias == NULL)
    return;

  for (qlook = qVperms; qlook != NULL; qlook = qlook->qnext)
    {
      /* See if we can merge qadd into qlook.  */
      if (qadd->pzlogname == NULL
	  ? qlook->pzlogname != NULL
	  : qlook->pzlogname == NULL)
	continue;
      if (qadd->pzmachine == NULL
	  ? qlook->pzmachine != NULL
	  : qlook->pzmachine == NULL)
	continue;
      if (qadd->frequest != qlook->frequest
	  || qadd->fsendfiles != qlook->fsendfiles
	  || qadd->fcallback != qlook->fcallback)
	continue;
      if (! fvperm_string_cmp (qadd->zmyname, qlook->zmyname)
	  || ! fvperm_string_cmp (qadd->zpubdir, qlook->zpubdir))
	continue;
      if (! fvperm_array_cmp ((const char **) qadd->pzread,
			      (const char **) qlook->pzread)
	  || ! fvperm_array_cmp ((const char **)  qadd->pzwrite,
				 (const char **) qlook->pzwrite)
	  || ! fvperm_array_cmp ((const char **) qadd->pzcommands,
				 (const char **) qlook->pzcommands))
	continue;

      /* Merge qadd into qlook.  */
      if (qadd->pzmachine != NULL)
	{
	  iret = _uuconf_iadd_string ((struct sglobal *) NULL,
				      qadd->pzmachine[0], FALSE,
				      TRUE, &qlook->pzmachine,
				      (pointer) NULL);
	  if (iret != UUCONF_SUCCESS)
	    uvuuconf_error ((pointer) NULL, iret);
	}
      if (qadd->pzlogname != NULL)
	{
	  iret = _uuconf_iadd_string ((struct sglobal *) NULL,
				      qadd->pzlogname[0], FALSE,
				      TRUE, &qlook->pzlogname,
				      (pointer) NULL);
	  if (iret != UUCONF_SUCCESS)
	    uvuuconf_error ((pointer) NULL, iret);
	}
      if (qadd->pzalias != NULL)
	{
	  char **pz;

	  for (pz = qadd->pzalias; *pz != NULL; pz++)
	    {
	      iret = _uuconf_iadd_string ((struct sglobal *) NULL,
					  *pz, FALSE, TRUE,
					  &qlook->pzalias, (pointer) NULL);
	      if (iret != UUCONF_SUCCESS)
		uvuuconf_error ((pointer) NULL, iret);
	    }
	}

      return;
    }

  /* We must add qadd as a new entry on the list, which means we must
     copy it into the heap.  */

  qnew = (struct shpermissions *) malloc (sizeof (struct shpermissions));
  if (qnew == NULL)
    uvuuconf_error ((pointer) NULL, UUCONF_MALLOC_FAILED);
  *qnew = *qadd;
  if (qadd->pzmachine != NULL)
    {
      qnew->pzmachine = NULL;
      iret = _uuconf_iadd_string ((struct sglobal *) NULL,
				  qadd->pzmachine[0], FALSE,
				  FALSE, &qnew->pzmachine,
				  (pointer) NULL);
      if (iret != UUCONF_SUCCESS)
	uvuuconf_error ((pointer) NULL, iret);
    }
  if (qadd->pzlogname != NULL)
    {
      qnew->pzlogname = NULL;
      iret = _uuconf_iadd_string ((struct sglobal *) NULL,
				  qadd->pzlogname[0], FALSE,
				  FALSE, &qnew->pzlogname,
				  (pointer) NULL);
      if (iret != UUCONF_SUCCESS)
	uvuuconf_error ((pointer) NULL, iret);
    }
  if (qadd->pzvalidate != NULL)
    qnew->pzvalidate = qnew->pzmachine;

  qnew->qnext = qVperms;
  qVperms = qnew;
}

/* Write out the Permissions entries.  */

static void
uvwrite_perms ()
{
  char ab[sizeof ZCURDIR + sizeof HDB_PERMISSIONS - 1];
  FILE *e;
  struct shpermissions *q;

  sprintf (ab, "%s%s", ZCURDIR, HDB_PERMISSIONS);
  e = fopen (ab, "w");
  if (e == NULL)
    {
      fprintf (stderr, "uuchk:%s: ", ab);
      perror ("fopen");
      exit (EXIT_FAILURE);
    }

  fprintf (e, "# Permissions file automatically generated by uuconv.\n");

  for (q = qVperms; q != NULL; q = q->qnext)
    {
      size_t ccol;

      ccol = 0;
      uvwrite_perm_array (e, (const char **) q->pzlogname, "LOGNAME", &ccol);
      uvwrite_perm_array (e, (const char **) q->pzmachine, "MACHINE", &ccol);
      uvwrite_perm_boolean (e, q->frequest, "REQUEST", &ccol, FALSE);
      uvwrite_perm_boolean (e, q->fsendfiles, "SENDFILES", &ccol, TRUE);
      uvwrite_perm_rw_array (e, (const char **) q->pzread, "READ", &ccol);
      uvwrite_perm_rw_array (e, (const char **) q->pzwrite, "WRITE", &ccol);
      uvwrite_perm_boolean (e, q->fcallback, "CALLBACK", &ccol, FALSE);
      uvwrite_perm_array (e, (const char **) q->pzcommands, "COMMANDS",
			  &ccol);
      uvwrite_perm_array (e, (const char **) q->pzvalidate, "VALIDATE",
			  &ccol);
      uvwrite_perm_string (e, q->zmyname, "MYNAME", &ccol);
      uvwrite_perm_string (e, q->zpubdir, "PUBDIR", &ccol);
      uvwrite_perm_array (e, (const char **) q->pzalias, "ALIAS", &ccol);

      fprintf (e, "\n");
    }

  if (ferror (e)
      || fclose (e) == EOF)
    {
      fprintf (stderr, "uuchk:%s: error during output\n", HDB_PERMISSIONS);
      exit (EXIT_FAILURE);
    }
}

/* Write an array out to the Permissions file.  */

static void
uvwrite_perm_array (e, pzarg, zcmd, pccol)
     FILE *e;
     const char **pzarg;
     const char *zcmd;
     size_t *pccol;
{
  size_t c;
  const char **pz;

  if (pzarg == NULL)
    return;

  c = strlen (zcmd) + 1;
  
  for (pz = pzarg; *pz != NULL; pz++)
    c += strlen (*pz) + 1;

  if (*pccol > 20 && c + *pccol > 75)
    {
      fprintf (e, " \\\n");
      *pccol = c - 1;
    }
  else
    {
      if (*pccol != 0)
	fprintf (e, " ");
      *pccol += c;
    }

  fprintf (e, "%s=", zcmd);
  for (pz = pzarg; *pz != NULL; pz++)
    {
      if (pz != pzarg)
	fprintf (e, ":");
      fprintf (e, "%s", *pz);
    }
}

/* Write a boolean value out to the Permissions file.  This may be
   either a yes/no boolean or a yes/call boolean (the latter is for
   SENDFILES).  */

static void
uvwrite_perm_boolean (e, f, zcmd, pccol, fsendfiles)
     FILE *e;
     int f;
     const char *zcmd;
     size_t *pccol;
     boolean fsendfiles;
{
  const char *az[2];

  if (f < 0)
    return;

  if (f)
    az[0] = "yes";
  else
    az[0] = fsendfiles ? "call" : "no";
  az[1] = NULL;

  uvwrite_perm_array (e, az, zcmd, pccol);
}

/* Write a set of READ or WRITE entries to the Permissions file.  We
   have to separate out all entries that start with '!'.  */

static void
uvwrite_perm_rw_array (e, pzarg, zcmd, pccol)
     FILE *e;
     const char **pzarg;
     const char *zcmd;
     size_t *pccol;
{
  size_t c;
  const char **pz, **pzcopy, **pzset;

  if (pzarg == NULL)
    return;

  c = 0;
  for (pz = pzarg; *pz != NULL; pz++)
    c++;

  pzcopy = (const char **) malloc ((c + 1) * sizeof (char *));
  if (pzcopy == NULL)
    uvuuconf_error ((pointer) NULL, UUCONF_MALLOC_FAILED);

  pzset = pzcopy;
  for (pz = pzarg; *pz != NULL; pz++)
    if ((*pz)[0] != '!')
      *pzset++ = *pz;
  *pzset = NULL;

  if (pzset != pzcopy)
    uvwrite_perm_array (e, (const char **) pzcopy, zcmd, pccol);

  pzset = pzcopy;
  for (pz = pzarg; *pz != NULL; pz++)
    if ((*pz)[0] == '!')
      *pzset++ = *pz;
  *pzset = NULL;

  if (pzset != pzcopy)
    {
      char ab[20];

      sprintf (ab, "NO%s", zcmd);
      uvwrite_perm_array (e, (const char **) pzcopy, ab, pccol);
    }
}

/* Write a string out to the Permissions file.  */

static void
uvwrite_perm_string (e, z, zcmd, pccol)
     FILE *e;
     const char *z;
     const char *zcmd;
     size_t *pccol;
{
  const char *az[2];

  if (z == NULL)
    return;

  az[0] = z;
  az[1] = NULL;

  uvwrite_perm_array (e, az, zcmd, pccol);
}

/* Write out a Taylor UUCP port.  This is called via uuconf_find_port;
   the pinfo argument is the port file.  */

static int
ivwrite_taylor_port (qport, pinfo)
     struct uuconf_port *qport;
     pointer pinfo;
{
  FILE *e = (FILE *) pinfo;

  fprintf (e, "port %s\n", qport->uuconf_zname);

  uvwrite_taylor_port (e, qport, "");

  /* Return UUCONF_NOT_FOUND to force uuconf_find_port to keep looking
     for ports.  */
  return UUCONF_NOT_FOUND;
}

/* Write a port out to a Taylor UUCP configuration file.  This doesn't
   output the name, since it is called to output a specially defined
   port in the sys file.  */

static void
uvwrite_taylor_port (e, qport, zprefix)
     FILE *e;
     struct uuconf_port *qport;
     const char *zprefix;
{
  const char *ztype;
  char ab[100];

  switch (qport->uuconf_ttype)
    {
    default:
    case UUCONF_PORTTYPE_UNKNOWN:
      fprintf (stderr, "uuconv: Bad port type\n");
      exit (EXIT_FAILURE);
      break;
    case UUCONF_PORTTYPE_STDIN:
      ztype = "stdin";
      break;
    case UUCONF_PORTTYPE_MODEM:
      ztype = "modem";
      break;
    case UUCONF_PORTTYPE_DIRECT:
      ztype = "direct";
      break;
    case UUCONF_PORTTYPE_TCP:
      ztype = "tcp";
      break;
    case UUCONF_PORTTYPE_TLI:
      ztype = "tli";
      break;
    case UUCONF_PORTTYPE_PIPE:
      ztype = "pipe";
      break;
    }

  fprintf (e, "%stype %s\n", zprefix, ztype);

  if (qport->uuconf_zprotocols != NULL)
    fprintf (e, "%sprotocol %s\n", zprefix, qport->uuconf_zprotocols);

  if (qport->uuconf_qproto_params != NULL)
    uvwrite_proto_params (e, qport->uuconf_qproto_params, zprefix);

  if ((qport->uuconf_ireliable & UUCONF_RELIABLE_SPECIFIED) != 0)
    {
      sprintf (ab, "%sseven-bit", zprefix);
      uvwrite_boolean (e,
		       ((qport->uuconf_ireliable & UUCONF_RELIABLE_EIGHT)
			== 0),
		       ab);
      sprintf (ab, "%sreliable", zprefix);
      uvwrite_boolean (e,
		       ((qport->uuconf_ireliable & UUCONF_RELIABLE_RELIABLE)
			!= 0),
		       ab);
      sprintf (ab, "%shalf-duplex", zprefix);
      uvwrite_boolean (e,
		       ((qport->uuconf_ireliable & UUCONF_RELIABLE_FULLDUPLEX)
			== 0),
		       ab);
    }

  if (qport->uuconf_zlockname != NULL)
    fprintf (e, "%slockname %s\n", zprefix, qport->uuconf_zlockname);

  switch (qport->uuconf_ttype)
    {
    default:
      break;
    case UUCONF_PORTTYPE_MODEM:
      {
	struct uuconf_modem_port *qm;

	qm = &qport->uuconf_u.uuconf_smodem;
	if (qm->uuconf_zdevice != NULL)
	  fprintf (e, "%sdevice %s\n", zprefix, qm->uuconf_zdevice);
	if (qm->uuconf_zdial_device != NULL)
	  fprintf (e, "%sdial-device %s\n", zprefix, qm->uuconf_zdial_device);
	if (qm->uuconf_ibaud != 0)
	  fprintf (e, "%sbaud %ld\n", zprefix, qm->uuconf_ibaud);
	if (qm->uuconf_ilowbaud != 0)
	  fprintf (e, "%sbaud-range %ld %ld\n", zprefix, qm->uuconf_ilowbaud,
		   qm->uuconf_ihighbaud);
	if (! qm->uuconf_fcarrier)
	  fprintf (e, "%scarrier false\n", zprefix);
	if (! qm->uuconf_fhardflow)
	  fprintf (e, "%shardflow false\n", zprefix);
	if (qm->uuconf_pzdialer != NULL)
	  {
	    if (qm->uuconf_pzdialer[1] == NULL)
	      fprintf (e, "%sdialer %s\n", zprefix, qm->uuconf_pzdialer[0]);
	    else
	      {
		sprintf (ab, "%sdialer-sequence", zprefix);
		uvwrite_string_array (e, qm->uuconf_pzdialer, ab);
	      }
	  }
	if (qm->uuconf_qdialer != NULL)
	  {
	    sprintf (ab, "%sdialer ", zprefix);
	    uvwrite_taylor_dialer (e, qm->uuconf_qdialer, ab);
	  }
      }
      break;
    case UUCONF_PORTTYPE_DIRECT:
      {
	struct uuconf_direct_port *qd;

	qd = &qport->uuconf_u.uuconf_sdirect;
	if (qd->uuconf_zdevice != NULL)
	  fprintf (e, "%sdevice %s\n", zprefix, qd->uuconf_zdevice);
	if (qd->uuconf_ibaud != 0)
	  fprintf (e, "%sbaud %ld\n", zprefix, qd->uuconf_ibaud);
	if (qd->uuconf_fcarrier)
	  fprintf (e, "%scarrier true\n", zprefix);
	if (! qd->uuconf_fhardflow)
	  fprintf (e, "%shardflow false\n", zprefix);
      }
      break;
    case UUCONF_PORTTYPE_TCP:
      if (qport->uuconf_u.uuconf_stcp.uuconf_zport != NULL)
	fprintf (e, "%sservice %s\n", zprefix,
		 qport->uuconf_u.uuconf_stcp.uuconf_zport);
      if (qport->uuconf_u.uuconf_stcp.uuconf_pzdialer != NULL)
	{
	  sprintf (ab, "%sdialer-sequence", zprefix);
	  uvwrite_string_array (e,
				qport->uuconf_u.uuconf_stcp.uuconf_pzdialer,
				ab);
	}
      break;
    case UUCONF_PORTTYPE_TLI:
      {
	struct uuconf_tli_port *qt;

	qt = &qport->uuconf_u.uuconf_stli;
	if (qt->uuconf_zdevice != NULL)
	  fprintf (e, "%sdevice %s\n", zprefix, qt->uuconf_zdevice);
	sprintf (ab, "%sstream", zprefix);
	uvwrite_boolean (e, qt->uuconf_fstream, ab);
	if (qt->uuconf_pzpush != NULL)
	  {
	    sprintf (ab, "%spush", zprefix);
	    uvwrite_string_array (e, qt->uuconf_pzpush, ab);
	  }
	if (qt->uuconf_pzdialer != NULL)
	  {
	    sprintf (ab, "%sdialer-sequence", zprefix);
	    uvwrite_string_array (e, qt->uuconf_pzdialer, ab);
	  }
	if (qt->uuconf_zservaddr != NULL)
	  fprintf (e, "%sserver-address %s\n", zprefix,
		   qt->uuconf_zservaddr);
      }
      break;
    case UUCONF_PORTTYPE_PIPE:
      {
	struct uuconf_pipe_port *qp;

	qp = &qport->uuconf_u.uuconf_spipe;
	if (qp->uuconf_pzcmd != NULL)
	  {
	    sprintf (ab, "%scommad", zprefix);
	    uvwrite_string_array (e, qp->uuconf_pzcmd, ab);
	  }
      }
      break;
    }
}

/* Write out a port to the V2 L-devices file.  This is called via
   uuconf_find_port.  */

static int
ivwrite_v2_port (qport, pinfo)
     struct uuconf_port *qport;
     pointer pinfo;
{
  FILE *e = (FILE *) pinfo;

  if (qport->uuconf_ttype == UUCONF_PORTTYPE_DIRECT)
    {
      fprintf (e, "DIR %s - %ld direct",
	       qport->uuconf_u.uuconf_sdirect.uuconf_zdevice,
	       qport->uuconf_u.uuconf_sdirect.uuconf_ibaud);
    }
  else if (qport->uuconf_ttype == UUCONF_PORTTYPE_MODEM)
    {
      fprintf (e, "%s %s ", qport->uuconf_zname,
	       qport->uuconf_u.uuconf_smodem.uuconf_zdevice);
      if (qport->uuconf_u.uuconf_smodem.uuconf_zdial_device != NULL)
	fprintf (e, "%s", qport->uuconf_u.uuconf_smodem.uuconf_zdial_device);
      else
	fprintf (e, "-");
      fprintf (e, " ");
      if (qport->uuconf_u.uuconf_smodem.uuconf_ilowbaud != 0L)
	fprintf (e, "%ld-%ld",
		 qport->uuconf_u.uuconf_smodem.uuconf_ilowbaud,
		 qport->uuconf_u.uuconf_smodem.uuconf_ihighbaud);
      else if (qport->uuconf_u.uuconf_smodem.uuconf_ibaud != 0L)
	fprintf (e, "%ld", qport->uuconf_u.uuconf_smodem.uuconf_ibaud);
      else
	fprintf (e, "Any");
      if (qport->uuconf_u.uuconf_smodem.uuconf_pzdialer != NULL)
	fprintf (e, " %s",
		 qport->uuconf_u.uuconf_smodem.uuconf_pzdialer[0]);
    }
  else
    {
      fprintf (e, "# Ignoring port %s with unsupported type",
	       qport->uuconf_zname);
    }

  fprintf (e, "\n");

  /* Return UUCONF_NOT_FOUND to force uuconf_find_port to keep looking
     for a port.  */
  return UUCONF_NOT_FOUND;
}

/* Write out a port to the HDB Devices file.  This is called via
   uuconf_find_port.  */

static int
ivwrite_hdb_port (qport, pinfo)
     struct uuconf_port *qport;
     pointer pinfo;
{
  FILE *e = (FILE *) pinfo;

  if (qport->uuconf_ttype == UUCONF_PORTTYPE_DIRECT)
    {
      fprintf (e, "Direct");
      if (qport->uuconf_zprotocols != NULL)
	fprintf (e, ",%s", qport->uuconf_zprotocols);
      fprintf (e, " ");
      if (qport->uuconf_u.uuconf_sdirect.uuconf_zdevice != NULL)
	fprintf (e, "%s", qport->uuconf_u.uuconf_sdirect.uuconf_zdevice);
      else
	fprintf (e, "%s", qport->uuconf_zname);
      fprintf (e, " - %ld", qport->uuconf_u.uuconf_sdirect.uuconf_ibaud);
    }
  else if (qport->uuconf_ttype == UUCONF_PORTTYPE_MODEM)
    {
      fprintf (e, "%s", qport->uuconf_zname);
      if (qport->uuconf_zprotocols != NULL)
	fprintf (e, ",%s", qport->uuconf_zprotocols);
      fprintf (e, " ");
      if (qport->uuconf_u.uuconf_smodem.uuconf_zdevice != NULL)
	fprintf (e, "%s", qport->uuconf_u.uuconf_smodem.uuconf_zdevice);
      else
	fprintf (e, "%s", qport->uuconf_zname);
      fprintf (e, " ");
      if (qport->uuconf_u.uuconf_smodem.uuconf_zdial_device != NULL)
	fprintf (e, "%s", qport->uuconf_u.uuconf_smodem.uuconf_zdial_device);
      else
	fprintf (e, "-");
      fprintf (e, " ");
      if (qport->uuconf_u.uuconf_smodem.uuconf_ilowbaud != 0L)
	fprintf (e, "%ld-%ld",
		 qport->uuconf_u.uuconf_smodem.uuconf_ilowbaud,
		 qport->uuconf_u.uuconf_smodem.uuconf_ihighbaud);
      else if (qport->uuconf_u.uuconf_smodem.uuconf_ibaud != 0L)
	fprintf (e, "%ld", qport->uuconf_u.uuconf_smodem.uuconf_ibaud);
      else
	fprintf (e, "Any");
      if (qport->uuconf_u.uuconf_smodem.uuconf_pzdialer != NULL)
	{
	  char **pz;

	  for (pz = qport->uuconf_u.uuconf_smodem.uuconf_pzdialer;
	       *pz != NULL;
	       pz++)
	    fprintf (e, " %s", *pz);
	}
    }
  else if (qport->uuconf_ttype == UUCONF_PORTTYPE_TCP)
    {
      char **pz;

      fprintf (e, "TCP");
      if (qport->uuconf_zprotocols != NULL)
	fprintf (e, ",%s", qport->uuconf_zprotocols);
      fprintf (e, " ");
      if (qport->uuconf_u.uuconf_stcp.uuconf_zport == NULL)
	fprintf (e, "uucp");
      else
	fprintf (e, "%s", qport->uuconf_u.uuconf_stcp.uuconf_zport);
      fprintf (e, " - -");
      pz = qport->uuconf_u.uuconf_stcp.uuconf_pzdialer;
      if (pz != NULL)
	for (; *pz != NULL; pz++)
	  fprintf (e, " %s", *pz);
    }
  else if (qport->uuconf_ttype == UUCONF_PORTTYPE_TLI)
    {
      char **pz;

      fprintf (e, "%s", qport->uuconf_zname);
      if (qport->uuconf_zprotocols != NULL)
	fprintf (e, ",%s", qport->uuconf_zprotocols);
      fprintf (e, " ");
      if (qport->uuconf_u.uuconf_stli.uuconf_zdevice != NULL)
	fprintf (e, "%s", qport->uuconf_u.uuconf_smodem.uuconf_zdevice);
      else
	fprintf (e, "-");
      fprintf (e, " - -");
      pz = qport->uuconf_u.uuconf_stli.uuconf_pzdialer;
      if (pz == NULL
	  || *pz == NULL
	  || (strcmp (*pz, "TLI") != 0
	      && strcmp (*pz, "TLIS") != 0))
	fprintf (e, " TLI%s \\D",
		 qport->uuconf_u.uuconf_stli.uuconf_fstream ? "S" : "");
      if (pz != NULL)
	for (; *pz != NULL; pz++)
	  fprintf (e, " %s", *pz);
    }
  else
    {
      fprintf (e, "# Ignoring port %s with unsupported type",
	       qport->uuconf_zname);
    }

  fprintf (e, "\n");

  /* Return UUCONF_NOT_FOUND to force uuconf_find_port to keep looking
     for a port.  */
  return UUCONF_NOT_FOUND;
}

/* Write a dialer out to a Taylor UUCP configuration file.  This
   doesn't output the name, since it is called to output a specially
   defined dialer in the sys or port file.  */

static void
uvwrite_taylor_dialer (e, qdialer, zprefix)
     FILE *e;
     struct uuconf_dialer *qdialer;
     const char *zprefix;
{
  char ab[100];

  /* Reset default values, so we don't output them unnecessarily.  */
  if (qdialer->uuconf_schat.uuconf_ctimeout == 60)
    qdialer->uuconf_schat.uuconf_ctimeout = -1;
  if (qdialer->uuconf_schat.uuconf_fstrip)
    qdialer->uuconf_schat.uuconf_fstrip = -1;
  if (qdialer->uuconf_scomplete.uuconf_ctimeout == 60)
    qdialer->uuconf_scomplete.uuconf_ctimeout = -1;
  if (qdialer->uuconf_scomplete.uuconf_fstrip)
    qdialer->uuconf_scomplete.uuconf_fstrip = -1;
  if (qdialer->uuconf_sabort.uuconf_ctimeout == 60)
    qdialer->uuconf_sabort.uuconf_ctimeout = -1;
  if (qdialer->uuconf_sabort.uuconf_fstrip)
    qdialer->uuconf_sabort.uuconf_fstrip = -1;
  
  uvwrite_chat (e, &qdialer->uuconf_schat, (struct uuconf_chat *) NULL,
		zprefix, FALSE);
  if (qdialer->uuconf_zdialtone != NULL
      && strcmp (qdialer->uuconf_zdialtone, ",") != 0)
    fprintf (e, "%sdialtone %s\n", zprefix, qdialer->uuconf_zdialtone);
  if (qdialer->uuconf_zpause != NULL
      && strcmp (qdialer->uuconf_zpause, ",") != 0)
    fprintf (e, "%spause %s\n", zprefix, qdialer->uuconf_zpause);
  if (! qdialer->uuconf_fcarrier)
    fprintf (e, "%scarrier false\n", zprefix);
  if (qdialer->uuconf_ccarrier_wait != 60)
    fprintf (e, "%scarrier-wait %d\n", zprefix,
	     qdialer->uuconf_ccarrier_wait);
  if (qdialer->uuconf_fdtr_toggle)
    fprintf (e, "%sdtr-toggle %s %s\n", zprefix,
	     qdialer->uuconf_fdtr_toggle ? "true" : "false",
	     qdialer->uuconf_fdtr_toggle_wait ? "true" : "false");
  sprintf (ab, "%scomplete-", zprefix);
  uvwrite_chat (e, &qdialer->uuconf_scomplete, (struct uuconf_chat *) NULL,
		ab, FALSE);
  sprintf (ab, "%sabort-", zprefix);
  uvwrite_chat (e, &qdialer->uuconf_sabort, (struct uuconf_chat *) NULL,
		ab, FALSE);
  if (qdialer->uuconf_qproto_params != NULL)
    uvwrite_proto_params (e, qdialer->uuconf_qproto_params, zprefix);
  if ((qdialer->uuconf_ireliable & UUCONF_RELIABLE_SPECIFIED) != 0)
    {
      sprintf (ab, "%sseven-bit", zprefix);
      uvwrite_boolean (e,
		       ((qdialer->uuconf_ireliable & UUCONF_RELIABLE_EIGHT)
			== 0),
		       ab);
      sprintf (ab, "%sreliable", zprefix);
      uvwrite_boolean (e,
		       ((qdialer->uuconf_ireliable & UUCONF_RELIABLE_RELIABLE)
			!= 0),
		       ab);
      sprintf (ab, "%shalf-duplex", zprefix);
      uvwrite_boolean (e,
		       ((qdialer->uuconf_ireliable
			 & UUCONF_RELIABLE_FULLDUPLEX) == 0),
		       ab);
    }
}

/* Write a dialer out to an HDB configuration file.  */

static void
uvwrite_hdb_dialer (e, qdialer)
     FILE *e;
     struct uuconf_dialer *qdialer;
{
  fprintf (e, "%s ", qdialer->uuconf_zname);

  if (qdialer->uuconf_zdialtone != NULL)
    fprintf (e, "=%c", qdialer->uuconf_zdialtone[0]);
  if (qdialer->uuconf_zpause != NULL)
    fprintf (e, "-%c", qdialer->uuconf_zpause[0]);

  if (qdialer->uuconf_schat.uuconf_pzchat != NULL)
    {
      if (qdialer->uuconf_zdialtone == NULL
	  && qdialer->uuconf_zpause == NULL)
	fprintf (e, "\"\"");
      fprintf (e, " ");
      uvwrite_chat_script (e, qdialer->uuconf_schat.uuconf_pzchat);
    }

  fprintf (e, "\n");
}

/* Display a uuconf error and exit.  */

static void
uvuuconf_error (puuconf, iret)
     pointer puuconf;
     int iret;
{
  char ab[512];

  (void) uuconf_error_string (puuconf, iret, ab, sizeof ab);
  if ((iret & UUCONF_ERROR_FILENAME) == 0)
    fprintf (stderr, "uuconv: %s\n", ab);
  else
    fprintf (stderr, "uuconv:%s\n", ab);
  if (UUCONF_ERROR_VALUE (iret) != UUCONF_FOPEN_FAILED)
    exit (EXIT_FAILURE);
}