Source Code 1992 March/Source_Code_CD-ROM_Walnut_Creek_March_1992.iso/usenet/altsrcs/2/2641

Internet Message Format | 1991-01-30 | 42KB

From: [e-mail] (Martin Junius)
Newsgroups: alt.sources
Subject: FIDOGATE Part 6/6
Message-ID: <mj.665055383@suntex>
Date: 28 Jan 91 09:36:23 GMT

---- Cut Here and feed the following to sh ----
#!/bin/sh
# This is part 06 of a multipart archive
# ============= nodelist.c ==============
if test -f 'nodelist.c' -a X"$1" != X"-c"; then
    echo 'x - skipping nodelist.c (File already exists)'
else
echo 'x - extracting nodelist.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'nodelist.c' &&
/*:ts=4*/
/*****************************************************************************
X * FIDOGATE --- Gateway software UNIX <-> FIDO
X *
X * $Id: nodelist.c,v 1.8 90/12/13 20:05:57 mj Exp $
X *
X * Routines to get and translate information in nodelist.
X *
X * $Log:    nodelist.c,v $
X * Revision 1.8  90/12/13  20:05:57  mj
X * Removed some unused functions.
X *
X * Revision 1.7  90/12/02  21:22:12  mj
X * Changed program header to mention both authors of the original
X * software posted to alt.sources.
X *
X * Revision 1.6  90/11/05  20:50:48  mj
X * Changed my signature in all program headers.
X *
X * Revision 1.5  90/09/03  17:57:25  mj
X * Moved function stripbad() to funpack.c
X *
X * Revision 1.4  90/08/02  19:09:16  mj
X * Fixed a bug in stripbad(). Digit are now allowed in user
X * names.
X *
X * Revision 1.3  90/07/01  15:20:26  mj
X * Fixed some bugs in funpack caused by the removal of alloca().
X * No more core dumps, but heaven knows, why it works now. Strange.
X *
X * Revision 1.2  90/07/01  13:45:58  mj
X * Removed all calls to alloca(). All unsave malloc()'s without
X * checking the returned pointer are now done via xmalloc().
X * Fixed a malloc() error in rmail.
X *
X * Revision 1.1  90/06/28  22:04:29  mj
X * Much rework of the sources, no more hsu.h and other clean up.
X * rmail improved, now handles special XENIX quirks.
X *
X * Revision 1.0  90/06/19  18:32:43  mj
X * Initial revision
X *
X *
X *****************************************************************************
X * This version hacked and maintained by:
X *    _____ _____
X *   |     |___  |   Martin Junius     FIDO:    2:242/6.1   2:242/6.0
X *   | | | |   | |   Republikplatz 3   DOMAIN:  [e-mail]
X *   |_|_|_|_____|   D-5100 Aachen     Tel. (Voice) 0241-86931
X *
X * Original version of these programs and files:
X *
X *   Teemu Torma
X *   Heikki Suonsivu   FIDO: 2:504/1   UUCP: ...!mcsun!santra!hsu
X *
X *****************************************************************************/
X
/*
X  Sat Oct  8 17:36:11 1988
X  Rewrote nodelist index handling and reading. Now index is kept
X  in memory, and has zones also.
X  */
X
#include "fidogate.h"
X
#include <values.h>
#include <sys/stat.h>
X
X
X
#ifndef SEEK_SET
#define SEEK_SET 0
#endif
#ifndef SEEK_CUR
#define SEEK_CUR 1
#endif
#ifndef SEEK_END
#define SEEK_END 2
#endif
X
extern long atol();
Node originnode;
NODEINDEX *nodeindex = NULL;
NAMEINDEX *nameindex = NULL;
int nodes, names, compile_zone, compile_region, compile_net;
X
/* Compare two strings, considering '_' and ' ', and converting
X   {|}[\] to aoaAOA instead, and ignoring case.
X
X   ascii_convert(string) does conversion.
X   */
X
char *ascii_convert(s)
X     char *s;
{
X  char *p;
X
X  p = s;
X  while (*s) {
X    switch (*s) {
X     case '_':
X      *s = ' ';
X      break;
#if 0
X     case '{':
X     case '}':
X     case '[':
X     case ']':
X      *s = 'a';
X      break;
X     case '|':
X     case '\\':
X      *s = 'o';
X      break;
X     default:
X      *s = tolower(*s);
#endif
X    }
X    s++;
X  }
X  return p;
}
X
X
X
/* Compare nodelist index entry (for qsort) */
cmpnodeindex(node1, node2)
X     NODEINDEX *node1, *node2;
{
X  if (node1->zone < node2->zone) return -1;
X  if (node1->zone > node2->zone) return 1;
X  if (node1->net < node2->net) return -1;
X  if (node1->net > node2->net) return 1;
X  if (node1->node < node2->node) return -1;
X  if (node1->node > node2->node) return 1;
X  return 0; /* Same node */
}
X
cmpnameindex(name1, name2)
X     NAMEINDEX *name1, *name2;
{
X  int n;
X  n = strcmp(name1->name, name2->name);
X  /* debug(9, "name1 %s name2 %s = %d", name1->name, name2->name, n); */
X  return n;
}
X
X
X
#ifdef NODELIST_SUPPORT
/* Read file in to a buffer allocating buffer for it */
X
long read_file(buffer, name)
char **buffer, *name;
{
FILE *fp;
long size = 0;
X
X  if (fp = fopen(name, "r")) {
X    fseek(fp, 0L, SEEK_END);
X    size = ftell(fp);
X
X    /* Apparently we are on 16-bit? */
X    if (size > MAXINT)
X      {
X    log("Brain damaged CPU architecture reading file?");
X    size = 0;
X    goto out;
X      }
X
X    fseek(fp, 0L, SEEK_SET);
X
X    if (*buffer)
X      *buffer = xrealloc( *buffer, (unsigned) size);
X    else
X      *buffer = xmalloc( (unsigned) size);
X
X    debug(2, "Reading %d bytes from %s", size, name);
X    if (fread( *buffer, 1, (int) size, fp) != size) size = 0;
X    fclose(fp);
X  }
X
X out:
X  return size;
}
X
write_file(buffer, name, size)
X     char *buffer, *name;
X     int size;
{
X  FILE *fp;
X  int rvalue = 0;
X
X  if (fp = fopen(name, "w+"))
X    {
X      debug(2, "Writing %d bytes to %s", size, name);
X      if (fwrite(buffer, 1, size, fp) != size) rvalue = -1;
X      fclose(fp);
X    }
X
X  return rvalue;
}
X
read_nodeindex()
{
X  nodes = read_file( (char **) &nodeindex,
X            sprintfs("%s/%s", LIBDIR, INODELIST)) / sizeof(NODEINDEX);
X  return nodes == 0L;
}
X
read_nameindex()
{
X  names = read_file( (char **) &nameindex,
X            sprintfs("%s/%s", LIBDIR, NAMELIST)) / sizeof(NAMEINDEX);
X  return names == 0L;
}
X
write_nodeindex()
{
X  return write_file( (char *) nodeindex,
X            sprintfs("%s/%s", LIBDIR, INODELIST),
X            (int) (nodes * sizeof(NODEINDEX)));
}
X
write_nameindex()
{
X  return write_file( (char *) nameindex,
X            sprintfs("%s/%s", LIBDIR, NAMELIST),
X            (int) (names * sizeof(NAMEINDEX)));
}
X
/* Make nodelist's index-file. That index-file will be used to search
X   desired net/region from nodelist.
X   Return NULL if everything was fine, otherwise error-message string. */
X
char *
update_index()
{
X  struct stat nlstat, inlstat;
X  FILE *nl = NULL, *nlidx = NULL, *namefp = NULL;
X  char nodelist[BUFLEN], inodelist[BUFLEN], namelist[BUFLEN];
X  char buffer[BUFSIZ];
X  long offset;
X  char *error;
X  Node node;
X  NODEINDEX nodei;
X  NAMEINDEX namei;
X  extern void qsort();
X
X  /* generate nodelist and index-file names */
X  (void) sprintf(nodelist, "%s/%s", LIBDIR, NODELIST);
X  (void) sprintf(inodelist, "%s/%s", LIBDIR, INODELIST);
X  (void) sprintf(namelist, "%s/%s", LIBDIR, NAMELIST);
X
X  /* get statuses of nodelist and index */
X  if (stat(nodelist, &nlstat) == -1)
X    return "$Error in getting nodelist status";
X
X  errno = 0;
X  if (stat(inodelist, &inlstat) == -1 && errno != ENOENT)
X    return "$Error in getting status of existing nodelist-index";
X
X  /* If index-file does exists then check modification times and
X     first lines. If nodelist is older and first lines are the same,
X     no update is needed. If index-file should be rebuild, assume
X     also rebuilding namelist. */
X
X  if (errno == 0 && nlstat.st_mtime <= inlstat.st_mtime)
X    {
X      error = NULL;
X      goto done;
X    }
X  else
X    log("Update nodelist-index: nodelist is newer than index");
X
X  /* open index-file for writing */
X  if (nlidx != NULL)
X    (void) fclose(nlidx);
X  if ((nlidx = fopen(inodelist, "w")) == NULL)
X    {
X      error = "$Unable to open nodelist-index for writing";
X      goto done;
X    }
X  if (namefp)
X    (void) fclose(namefp);
X  if ((namefp = fopen(namelist, "w")) == NULL)
X    {
X      error = "$Unable to open namelist-index for writing";
X      goto done;
X    }
X
X  if (!nl)
X    if ((nl = fopen(nodelist, "r")) == NULL)
X      return "$Unable to open nodelist";
X
X  (void) rewind(nl);
X
X  compile_zone = MY_ZONE;
X  compile_region = MY_REGION;
X  compile_net = MY_NET;
X  nodes = 0;
X  names = 0;
X
X  /* save host/region offsets */
X  for (offset = ftell(nl); fgets(buffer, BUFSIZ, nl); offset = ftell(nl))
X    {
X      if (*buffer == '\n' || *buffer == ';') continue;
X
X      parse_entry(&node, buffer);
X
X      nodei.zone = node.zone;
X      nodei.net = node.net;
X      nodei.node = node.node;
X      nodei.offset = offset;
X
#ifdef NEEDED
X      debug(8, "%s", buffer);
X      debug(8, "writing %d:%d/%d", node.zone, node.net, node.node);
#endif
X      fwrite( (char *) &nodei, sizeof(NODEINDEX), 1, nlidx);
X      if (ferror(nlidx))
X    {
X      error = "$Cannot write index, no space?";
X      goto done;
X    }
X
X      if (node.type != REGION && node.type != HOST &&
X      node.type != ZONE && node.type != KENL && node.type != HUB)
X    {
X      strcpy(namei.name, node.sysop);
X      namei.offset = offset;
X      namei.zone = compile_zone;
X      namei.net = compile_net;
X      names++;
X      fwrite( (char *) &namei, sizeof(NAMEINDEX), 1, namefp);
X      if (ferror(namefp))
X        {
X          error = "$Cannot write name index, no space?";
X          goto done;
X        }
X    }
X
X      nodes++;
X    }
X  error = NULL;
X
X  /* Ok, now get both indices back and qsort them */
X
X  (void) fclose(nl);
X  nl = NULL;
X  (void) fclose(nlidx);
X  nlidx = NULL;
X  (void) fclose(namefp);
X  namefp = NULL;
X
X  if (read_nodeindex())
X    {
X      error = "$Cannot read nodelist index";
X      goto done;
X    }
X  if (read_nameindex())
X    {
X      error = "$Cannot read name index";
X      goto done;
X    }
X
X  log("Sorting nodelist index");
X  (void) qsort( (char *) nodeindex, (unsigned) nodes,
X           sizeof(NODEINDEX), cmpnodeindex);
X  log("Sorting name index");
X  (void) qsort( (char *) nameindex, (unsigned) names,
X           sizeof(NAMEINDEX), cmpnameindex);
X  log("Sorted indices");
X
X  if (write_nodeindex())
X    {
X      error = "$Cannot write nodelist index";
X      goto done;
X    }
X  if (write_nameindex())
X    {
X      error = "$Cannot write name index";
X      goto done;
X    }
X
X  /* done, close files and return error message */
X done:
X  if (nl)
X    (void) fclose(nl);
X  if (nlidx)
X    (void) fclose(nlidx);
X  if (namefp)
X    (void) fclose(namefp);
X  return error;
}
X
X
X
/* Convert underscores in string to spaces. In nodelist there is always
X   underscore insted of space (flags is special case). */
X
void
convert_space(s)
X     register char *s;
{
X  while (*s)
X    {
X      if (*s == '_')
X        *s = ' ';
X      s++;
X    }
}
X
/* Get one comma-terminated field from buffer, retrun pointer to right
X   after terminating comma. Convert underscores to spaces in string. */
X
char *
parse_field(buffer, entry, size)
X     char *buffer, *entry;
X     int size;
{
X  char *np = entry;
X
X  /* copy string */
X  while (--size >= 0 && *buffer && *buffer != ',')
X    *entry++ = *buffer++;
X  *entry = 0;
X
X  switch (*buffer)
X    {
X    case 0:
X      /* end of buffer */
X      log("No closing comma in field");
X      return (char *) 0;
X    case ',':
X      /* succesful copy */
X      convert_space(np);
X      return buffer + 1;
X    default:
X      /* buffer too long, find comma */
X      while (*buffer && *buffer != ',')
X        buffer++;
X      if (*buffer)
X        {
X          convert_space(np);
X          return buffer + 1;
X        }
X      else
X        {
X          log("Missing comma in field");
X          return (char *) 0;
X        }
X    }
X  /* NOTREACHED */
}
X
/* Parse one line of nodelist to node structure. Return NULL is there
X   was error's in that line or missing fields. */
X
Node *
parse_entry(entry, buffer)
X     Node *entry;
X     char *buffer;
{
X  char *cp;
X  int n;
X
X  /* strip newline if exists */
X  if (cp = strchr(buffer, '\n'))
X    *cp = 0;
X
X  /* get type of entry */
X  if (!strncmp("Zone,", buffer, 5))
X    entry->type = ZONE;
X  else if (!strncmp("Region,", buffer, 7))
X    entry->type = REGION;
X  else if (!strncmp("Host,", buffer, 5))
X    entry->type = HOST;
X  else if (!strncmp("Hub,", buffer, 4))
X    entry->type = HUB;
X  else if (!strncmp("Pvt,", buffer, 4))
X    entry->type = PVT;
X  else if (!strncmp("Hold,", buffer, 5))
X    entry->type = HOLD;
X  else if (!strncmp("Down,", buffer, 5))
X    entry->type = DOWN;
X  else if (!strncmp("Kenl,", buffer, 5))
X    entry->type = KENL;
X  else if (*buffer == ',')
X    entry->type = NORMAL;
X  else
X    {
X      log("Unknown type in line '%s'", buffer);
X      return (Node *) 0;
X    }
X
X  /* get net/region/node number */
X  if ((cp = strchr(buffer, ',')) == NULL)
X    {
X      log("Missing zone/net/node/region in line '%s'", buffer);
X      return (Node *) 0;
X    }
X  if ((n = atoi(++cp)) == 0)
X    {
X      log("Value of zone/net/node/region is 0 in line '%s'", buffer);
X      return (Node *) 0;
X    }
X  if (entry->type == ZONE)
X    {
X      entry->zone = n;
X      entry->net = 0;
X      entry->node = 0;
X      entry->point = 0;
X      compile_zone = n;
X      debug(8, "Zone %d", compile_zone);
X    }
X  else if (entry->type == REGION)
X    {
X      entry->zone = compile_zone;
X      entry->region = n;
X      entry->net = n;    /* For compatibility with old version */
X      entry->node = 0;
X      entry->point = 0;
X      compile_region = n;
X      compile_net = n;    /* For compatibility with old version */
X      debug(8, "Region %d", compile_region);
X    }
X  else if (entry->type == HOST)
X    {
X      entry->zone = compile_zone;
X      entry->region = compile_region;
X      entry->net = n;
X      entry->node = 0;
X      entry->point = 0;
X      compile_net = n;
X      debug(8, "Net %d", compile_net);
X    }
X  else
X    {
X      entry->zone = compile_zone;
X      entry->region = compile_region;
X      entry->net = compile_net;
X      entry->node = n;
X      entry->point = 0;
X    }
X  while (*cp && *cp++ != ',');
X
X  /* get node/net/region name */
X  if ((cp = parse_field(cp, entry->name, sizeof(entry->name))) == NULL)
X    {
X      log("Invalid name in line '%s'", buffer);
X      return (Node *) 0;
X    }
X
X  /* get city */
X  if ((cp = parse_field(cp, entry->city, sizeof(entry->city))) == NULL)
X    {
X      log("Invalid city in line '%s'", buffer);
X      return (Node *) 0;
X    }
X
X  /* get sysop */
X  if ((cp = parse_field(cp, entry->sysop, sizeof(entry->sysop))) == NULL)
X    {
X      log("Invalid sysop in line '%s'", buffer);
X      return (Node *) 0;
X    }
X
X  /* get phone number */
X  if ((cp = parse_field(cp, entry->phone, sizeof(entry->phone))) == NULL)
X    {
X      log("Invalid phone-number in line '%s'", buffer);
X      return (Node *) 0;
X    }
X
X  /* get maximum baud rate */
X  if ((n = atoi(cp)) == 0)
X    {
X      log("Baud rate is 0 in line '%s'", buffer);
X      return (Node *) 0;
X    }
X  entry->speed = n;
X  while (*cp && *cp++ != ',');
X
X  /* get flags */
X  (void) strncpy(entry->flags, cp, sizeof(entry->flags));
X  entry->flags[sizeof(entry->flags) - 1] = 0;
X
X  /* all done */
X  return entry;
}
X
/* Get entry for one node from nodelist. Return NULL, if there is no
X   entry for that node. */
X
Node *
node_entry(node)
X     Node node;
{
X  static Node entry;
X  FILE *fp;
X  char buffer[BUFSIZ];
X  extern char *bsearch();
X  long offset;
X  NODEINDEX *nodeip, nodei;
X
X  /* Read index file into memory */
X
X  if (!nodeindex)
X    if (read_nodeindex())
X      {
X    log("$Unable to read nodelist");
X    return (Node *) 0;
X      }
X
X  nodei.zone = node.zone;
X  nodei.net = node.net;
X  nodei.node = node.node;
X
X  debug(2, "Searching %s from %d nodes", ascnodei(nodei), nodes);
X  nodeip = (NODEINDEX *) bsearch( (char *) &nodei, (char *) nodeindex,
X                 (unsigned) nodes, sizeof(NODEINDEX),
X                 cmpnodeindex);
X
X  if (nodeip) {
X    offset = nodeip->offset;
X
X    /* open nodelist */
X    (void) sprintf(buffer, "%s/%s", LIBDIR, NODELIST);
X    if ((fp = fopen(buffer, "r")) == NULL)
X      {
X    log("$Unable to open %s", buffer);
X    return (Node *) 0;
X      }
X
X    if (fseek(fp, offset, 0))
X      {
X    log("$Seek error on nodelist");
X    (void) fclose(fp);
X    return (Node *) 0;
X      }
X
X    fgets(buffer, BUFSIZ, fp);
X    fclose(fp);
X
X    compile_zone = nodeip->zone;
X    compile_net = nodeip->net;
X    return parse_entry(&entry, buffer);
X  }
X
X  log("Could not find node %s", ascnodei(nodei));
X
X  /* we didn't find net/region */
X  (void) fclose(fp);
X  return (Node *) 0;
}
X
char *dialtable[] = { DIALTABLE };
X
dial_translation(dest, source)
X     char *dest, *source;
{
X  register int count = 0;
X
X  for (;;) {
X    if (!*dialtable[count] ||
X    !strncmp(dialtable[count], source, strlen(dialtable[count]))) {
X
X      /* Matched, take prefix, */
X      strcpy(dest, dialtable[count + 1]);
X
X      /* Then add phone number */
X      strcat(dest, source + strlen(dialtable[count]));
X      return;
X    }
X    count += 2;
X  }
}
X
static char **aliastable = NULL;
static allocated = 0;
static aliases = 0;
X
expand_aliastable()
{
X  if (!aliastable)
X    {
X      aliastable = (char **) xmalloc(sizeof(char *) * 20);
X      if (aliastable) allocated = 20;
X    }
X
X  if (aliases == allocated) /* Need more pointers */
X    {
X      allocated += 20;
X      aliastable = (char **) xrealloc( (char *) aliastable,
X                     sizeof(char *) * allocated);
X      if (!aliastable)
X    {
X      log("Cannot realloc %d bytes", sizeof(char *) * allocated);
X      return -1;
X    }
X    }
X  return 0;
}
X
#define FILENAME_SIZE 256
X
search_name(name)
X     char *name;
{
X  Node entry;
X  FILE *fp;
X  char buffer[BUFSIZ];
X  extern char *bsearch();
X  char *nlname;
X  long offset;
X  NAMEINDEX *nameip, namei;
X
X  if (!nameindex)
X    if (read_nameindex())
X      {
X    log("$Unable to read namelist");
X    return -1;
X      }
X
X  strncpy(namei.name, name, 36);
X  namei.name[35] = 0;
X
X  nameip = (NAMEINDEX *) bsearch( (char *) &namei, (char *) nameindex,
X                 (unsigned) names, sizeof(NAMEINDEX),
X                 cmpnameindex);
X
X  if (nameip)
X    {
X      offset = nameip->offset;
X
X      /* Open nodelist */
X      if ((fp =
X       fopen(nlname = sprintfs("%s/%s", LIBDIR, NODELIST), "r")) == NULL)
X    {
X      log("$Unable to open nodelist %s", nlname);
X      return -1;
X    }
X
X      if (fseek(fp, offset, 0))
X    {
X      log("$Seek error on nodelist");
X      (void) fclose(fp);
X      return -1;
X    }
X
X      fgets(buffer, BUFSIZ, fp);
X      fclose(fp);
X
X      compile_zone = nameip->zone;
X      compile_net = nameip->net;
X      if (parse_entry(&entry, buffer) == NULL) return -1;
X
X      debug(1, "Search name %s returns %d:%d/%d.%d", name,
X        entry.zone, entry.net, entry.node, entry.point);
X      memcpy( (char *) &originnode, (char *) &entry, sizeof(Node));
X      return 0;
X    }
X
X  debug(1, "Search name %s return no node", name);
X  return -1;
}
#endif /**NODELIST_SUPPORT**/
SHAR_EOF
chmod 0644 nodelist.c ||
echo 'restore of nodelist.c failed'
Wc_c="`wc -c < 'nodelist.c'`"
test 17722 -eq "$Wc_c" ||
    echo 'nodelist.c: original size 17722, current size' "$Wc_c"
fi
# ============= gethost.c ==============
if test -f 'gethost.c' -a X"$1" != X"-c"; then
    echo 'x - skipping gethost.c (File already exists)'
else
echo 'x - extracting gethost.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'gethost.c' &&
/*:ts=4*/
/*****************************************************************************
X * FIDOGATE --- Gateway software UNIX <-> FIDO
X *
X * $Id: gethost.c,v 1.2 90/12/02 21:22:08 mj Exp $
X *
X * gethostname()
X *
X * $Log:    gethost.c,v $
X * Revision 1.2  90/12/02  21:22:08  mj
X * Changed program header to mention both authors of the original
X * software posted to alt.sources.
X *
X * Revision 1.1  90/11/05  20:50:42  mj
X * Changed my signature in all program headers.
X *
X * Revision 1.0  90/06/19  18:35:36  mj
X * Initial revision
X *
X *
X *****************************************************************************
X * This version hacked and maintained by:
X *    _____ _____
X *   |     |___  |   Martin Junius     FIDO:    2:242/6.1   2:242/6.0
X *   | | | |   | |   Republikplatz 3   DOMAIN:  [e-mail]
X *   |_|_|_|_____|   D-5100 Aachen     Tel. (Voice) 0241-86931
X *
X * Original version of these programs and files:
X *
X *   Teemu Torma
X *   Heikki Suonsivu   FIDO: 2:504/1   UUCP: ...!mcsun!santra!hsu
X *
X *****************************************************************************/
X
#include "fidogate.h"
X
#include <sys/utsname.h>
X
/* Get name of this uucp-node. Name is stored in buffer. Len in maximum
X   length of buffer. Return -1 if can not do uname(2), otherwise 0. */
X
int
gethostname(buffer, len)
X     char *buffer;
X     int len;
{
#ifdef MY_HOSTNAME
X    strncpy(buffer, MY_HOSTNAME, len);
X    buffer[len - 1] = 0;
#else
struct utsname name;
X
X    if (uname(&name) == -1)
X        return -1;
X    (void) strncpy(buffer, name.nodename, len);
X    buffer[len - 1] = 0;
#endif
X    return 0;
}
SHAR_EOF
chmod 0644 gethost.c ||
echo 'restore of gethost.c failed'
Wc_c="`wc -c < 'gethost.c'`"
test 1592 -eq "$Wc_c" ||
    echo 'gethost.c: original size 1592, current size' "$Wc_c"
fi
# ============= address.c ==============
if test -f 'address.c' -a X"$1" != X"-c"; then
    echo 'x - skipping address.c (File already exists)'
else
echo 'x - extracting address.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'address.c' &&
/*:ts=4*/
/*****************************************************************************
X * FIDOGATE --- Gateway software UNIX <-> FIDO
X *
X * $Id: address.c,v 1.11 90/12/13 20:04:41 mj Exp $
X *
X * Address format is (domain style addresses for FIDO):
X *     <name>@<point>.<node>.<net>.<zone>.FIDODOMAIN
X * or (new)
X *     <name>@p<point>.f<node>.n<net>.z<zone>.FIDODOMAIN
X * FIDODOMAIN is defined config.h
X *
X * $Log:    address.c,v $
X * Revision 1.11  90/12/13  20:04:41  mj
X * Fixed a bug in parsefnetaddress().
X *
X * Revision 1.10  90/12/02  21:21:07  mj
X * Changed program header to mention both authors of the original
X * software posted to alt.sources.
X *
X * Revision 1.9  90/11/20  21:07:24  mj
X * New function ascnoden(): convert node address to string, point not
X * included.
X *
X * Revision 1.8  90/11/05  20:48:49  mj
X * Changed my signature in all program headers.
X *
X * Revision 1.7  90/09/30  14:39:52  mj
X * Better parsing for FIDO addresses including domain.
X * (e.g. "2:242/6@fidonet")
X *
X * Revision 1.6  90/09/16  17:35:07  mj
X * Always output zone address in internode().
X *
X * Revision 1.5  90/08/12  14:12:38  mj
X * Output of ascnode() now <zone>:<net>/<node> for non-point addresses.
X *
X * Revision 1.4  90/07/30  19:58:57  mj
X * Added support for new style FIDO addresses:
X *     p<point>.f<node>.n<net>.z<zone>.FIDODOMAIN
X * FIDODOMAIN is defined in config.h
X *
X * Revision 1.3  90/07/11  17:03:58  mj
X * Removed a bug in address parsing, when address is of type
X * `domain!name'.
X *
X * Revision 1.2  90/07/01  13:27:11  mj
X * Removed all calls to alloca(). All unsave malloc()'s without
X * checking the returned pointer are now done via xmalloc().
X * Fixed a malloc() error in rmail.
X *
X * Revision 1.1  90/06/28  22:02:46  mj
X * Much rework of the sources, no more hsu.h and other clean up.
X * rmail improved, now handles special XENIX quirks.
X *
X * Revision 1.0  90/06/19  18:31:45  mj
X * Initial revision
X *
X *
X *****************************************************************************
X * This version hacked and maintained by:
X *    _____ _____
X *   |     |___  |   Martin Junius     FIDO:    2:242/6.1   2:242/6.0
X *   | | | |   | |   Republikplatz 3   DOMAIN:  [e-mail]
X *   |_|_|_|_____|   D-5100 Aachen     Tel. (Voice) 0241-86931
X *
X * Original version of these programs and files:
X *
X *   Teemu Torma
X *   Heikki Suonsivu   FIDO: 2:504/1   UUCP: ...!mcsun!santra!hsu
X *
X *****************************************************************************/
X
#include "fidogate.h"
X
#include "shuffle.h"
X
X
X
/*
X * char *parse_address()  ---  parse fidonet address to name, net/node
X *
X * Parameters:    char *address    --- address string
X *                char *name        --- pointer to return name
X *                Node *node        --- pointer to return node address
X *
X * Return:        (char *) error string or NULL.
X *
X * Two types of addresses are understood:
X *    Domain:        [e-mail]
X *    Bang:        P.N.N.Z.fidonet!name
X */
X
char *
parse_address(address, name, node)
char *address, *name;
Node *node;
{
static char error[64];
register char *cp;
register int cnt;
X
X    /* make address to lowercase */
X    for (cp = address; *cp; cp++)
X        if (isupper(*cp))
X            *cp = tolower(*cp);
X
X    /* Get name. We assume that name has space at least 36 charcers (maximum
X       length of name in fido). First check wheather format is name@domain
X       of domain!name format. */
X    if ((cp = strchr(address, '!')) != NULL) {
X        debug(2, "Fidonet address domain!name");
X        for (cp++, cnt = 0; *cp && cnt < 35; cnt++, cp++)
X            name[cnt] = *cp;
X        name[cnt] = 0;
X        cp = address;
X        debug(3, "Name %s", name);
X    }
X    else {
X        debug(2, "Fidonet address name@domain");
X        for (cp = address, cnt = 0; *cp && cnt < 35 && *cp != '@'; cp++, cnt++)
X            name[cnt] = *cp;
X        name[cnt] = 0;
X        debug(3, "Name %s", name);
X
X        if (*cp != '@') {
X            /* name is too long or address is invalid */
X            while (*cp && *cp != '@')
X                cp++;
X            if (*cp == 0) {
X                debug(1, "Invalid address: %s: missing @", address);
X                (void) sprintf(error, "No @ in address %s", address);
X                return error;
X            }
X        }
X        cp++;
X    }
X
X    debug(2, "Address %s, up to '!' or end", cp);
X
X    if (parseinternode(cp, node)) {
X        sprintf(error, "Bad address %s", cp);
X        return error;
X    }
X
X    /* we're done */
X    return NULL;
}
X
X
X
returnbad(errtype, s, node)
char *errtype, *s;
Node *node;
{
X    node->zone = MY_ZONE;
X    node->net = MY_NET;
X    node->node = MY_NODE;
X    node->point = MY_POINT;
X    return -1;
}
X
X
X
/* Parse internet format fidonet address */
X
parseinternode(address, node)
char *address;
Node *node;
{
char *p, *s;
int numbers[4], count;
X
X    s = xmalloc(strlen(address) + 1);
X    strcpy(s, address);
X    numbers[0] = numbers[1] = numbers[2] = numbers[3] = -1;
X
X    /* Remove `!...' */
X    if(p = strrchr(s, '!'))
X        *p = 0;
X
X    /* Remove FIDODOMAIN */
X    if (strlen(s) > strlen(FIDODOMAIN))
X        if (!strcmp(s + strlen(s) - strlen(FIDODOMAIN), FIDODOMAIN))
X            s[strlen(s) - strlen(FIDODOMAIN)] = 0;
X
X    if(isdigit(*s)) {
X        /*
X         * Assume old style address: <point>.<node>.<net>.<zone>
X         */
X        /* convert ascii numbers to integer */
X        for (count=0, p=strtok(s, "."); p && count<4; p = strtok(NULL, "."))
X            numbers[count++] = isdigit(*p) ? atoi(p) : -1 ;
X
X        free(s);
X
X        if (!count)
X            return returnbad("empty fidonet address", address, node);
X
X        if (count == 4) {
X            node->zone  = numbers[3];
X            node->net   = numbers[2];
X            node->node  = numbers[1];
X            node->point = numbers[0];
X            return 0;
X        }
X
X        if (numbers[0] == -1)
X            return returnbad("no node", address, node);
X        if (numbers[1] == -1)
X            numbers[1] = REAL_NET;
X        if (numbers[2] == -1)
X            numbers[2] = REAL_ZONE;
X
X        node->zone = numbers[2];
X        node->net = numbers[1];
X        node->node = numbers[0];
X        node->point = 0;
X
X    }
X    else {
X        /*
X         * New address format: p<point>.f<node>.n<net>.z<zone>
X         */
X        node->zone  = REAL_ZONE;
X        node->net   = REAL_NET;
X        node->node  = REAL_NODE;
X        node->point = 0;
X
X        for(count=0, p=strtok(s, "."); p && count<4; p = strtok(NULL, "."))
X            switch(*p) {
X                case 'p':
X                    if(!isdigit(p[1]))
X                        goto address_error;
X                    node->point = atoi(p+1);
X                    break;
X                case 'f':
X                    if(!isdigit(p[1]))
X                        goto address_error;
X                    node->node  = atoi(p+1);
X                    break;
X                case 'n':
X                    if(!isdigit(p[1]))
X                        goto address_error;
X                    node->net   = atoi(p+1);
X                    break;
X                case 'z':
X                    if(!isdigit(p[1]))
X                        goto address_error;
X                    node->zone  = atoi(p+1);
X                    break;
X                default:
address_error:
X                    return returnbad("address syntax error", address, node);
X                    break;
X            }
X
X    }
X
X    return 0;
}
X
X
X
/*
X * Parse FIDO address  <zone>:<net>/<node>.<point> into
X * Node structure. Leading non-digits are ignored.
X */
X
parsefnetaddress(s, node)
char *s;
Node *node;
{
char *p, *lastnumber;
char nodenbuf[100];
int point_flag = 0;
X
X    strncpy(nodenbuf, s, 99);
X    nodenbuf[99] = 0;
X    s = nodenbuf;
X
X    node->zone  = 0;
X    node->net   = 0;
X    node->node  = 0;
X    node->point = 0;
X    p = s;
X
X    /* skip non-digits */
X    while (!isdigit(*p) && *p) p++;
X
X    lastnumber = NULL;
X
X    while (1) {
X        switch (*p) {
X            case '0':  case '1':  case '2': case '3':
X            case '4':  case '5':  case '6': case '7':
X            case '8':  case '9':
X                lastnumber = p;
X                while (isdigit(*++p));
X                continue;
X                break;
X            case ':':
X                /* Previous number is zone */
X                if (node->zone) return returnbad("two zones", s, node);
X                node->zone = atoi(lastnumber);
X                lastnumber = p + 1;
X                break;
X            case '/':
X                /* Previous number is net */
X                if (node->net) return returnbad("two nets", s, node);
X                node->net = atoi(lastnumber);
X                lastnumber = p + 1;
X                break;
X            case '.':
X                /* Previous number is node */
X                if (node->node) return returnbad("two nodes", s, node);
X                node->node = atoi(lastnumber);
X                lastnumber = p + 1;
X                point_flag = 1;
X                break;
X            case 0:                    /* Terminated by end of string or '@' */
X            case '@':                /* starting domain part of address    */
X                if(!lastnumber)
X                    return returnbad("empty address", s, node);
X                if(point_flag)
X                    node->point = atoi(lastnumber);
X                else
X                    node->node  = atoi(lastnumber);
X                if (node->zone == 0) node->zone = MY_ZONE;
X                if (node->net == 0) node->net = MY_NET;
X                return 0;
X                break;
X            default:
X                return returnbad("bad char", s, node);
X        }
X        p++;
X    }
X    if (node->zone == 0) node->zone = MY_ZONE;
X    if (node->net == 0) return returnbad("no net", s, node);
X    if (node->node == 0)
X        node->node = atoi(lastnumber);
X
X    return 0;
}
X
X
X
/* Return address in string format */
X
char *ascnode(node)
Node node;
{
X    SHUFFLEBUFFERS;
X
X    if(node.point)
X        sprintf(tcharp, "%d:%d/%d.%d", node.zone, node.net, node.node, node.point);
X    else
X        sprintf(tcharp, "%d:%d/%d", node.zone, node.net, node.node);
X    return tcharp;
}
X
X
char *ascnoden(node)
Node node;
{
X    SHUFFLEBUFFERS;
X
X    sprintf(tcharp, "%d:%d/%d", node.zone, node.net, node.node);
X    return tcharp;
}
X
X
X
/* Internet format */
char *internode(node)
Node node;
{
X    SHUFFLEBUFFERS;
X
#ifdef NEW_STYLE_ADDRESS
X    if(node.point)
X        sprintf(tcharp, "p%d.f%d.n%d.z%d%s", node.point, node.node,
X                                             node.net,   node.zone,
X                                             FIDODOMAIN            );
X    else
X        sprintf(tcharp, "f%d.n%d.z%d%s", node.node, node.net,
X                                         node.zone, FIDODOMAIN );
#else
X    if (node.point)
X        sprintf(tcharp, "%d.%d.%d.%d.fidonet", node.point, node.node, node.net,
X                        node.zone);
X    else
X        sprintf(tcharp, "%d.%d.%d.fidonet", node.node, node.net, node.zone);
#endif
X    return tcharp;
}
X
X
X
/* same for index node structure */
X
char *ascnodei(node)
NODEINDEX node;
{
X    SHUFFLEBUFFERS;
X
X    sprintf(tcharp, "%d:%d/%d", node.zone, node.net, node.node);
X    return tcharp;
}
SHAR_EOF
chmod 0644 address.c ||
echo 'restore of address.c failed'
Wc_c="`wc -c < 'address.c'`"
test 9474 -eq "$Wc_c" ||
    echo 'address.c: original size 9474, current size' "$Wc_c"
fi
# ============= sprintfs.c ==============
if test -f 'sprintfs.c' -a X"$1" != X"-c"; then
    echo 'x - skipping sprintfs.c (File already exists)'
else
echo 'x - extracting sprintfs.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'sprintfs.c' &&
/*:ts=4*/
/*****************************************************************************
X * FIDOGATE --- Gateway software UNIX <-> FIDO
X *
X * $Id: sprintfs.c,v 1.2 90/12/02 21:22:41 mj Exp $
X *
X * Special printf() function
X *
X * $Log:    sprintfs.c,v $
X * Revision 1.2  90/12/02  21:22:41  mj
X * Changed program header to mention both authors of the original
X * software posted to alt.sources.
X *
X * Revision 1.1  90/11/05  20:51:10  mj
X * Changed my signature in all program headers.
X *
X * Revision 1.0  90/06/21  19:10:16  mj
X * Initial revision
X *
X *
X *****************************************************************************
X * This version hacked and maintained by:
X *    _____ _____
X *   |     |___  |   Martin Junius     FIDO:    2:242/6.1   2:242/6.0
X *   | | | |   | |   Republikplatz 3   DOMAIN:  [e-mail]
X *   |_|_|_|_____|   D-5100 Aachen     Tel. (Voice) 0241-86931
X *
X * Original version of these programs and files:
X *
X *   Teemu Torma
X *   Heikki Suonsivu   FIDO: 2:504/1   UUCP: ...!mcsun!santra!hsu
X *
X *****************************************************************************/
X
#include "fidogate.h"
X
#include <varargs.h>
#include "shuffle.h"
X
X
/* Strcat creating its own buffer */
X
char *sstrcat(d, s)
X     char *d, *s;
{
X  SHUFFLEBUFFERS;
X
X  (void) strncpy(tcharp, d, MAX_CONVERT_BUFLEN);
X  tcharp[MAX_CONVERT_BUFLEN - 1] = '\0';
X  (void) strncat(tcharp, s, MAX_CONVERT_BUFLEN);
X  return tcharp;
}
X
/* Sprintf with own buffer */
X
/*VARARGS1*/
char *sprintfs(fmt, va_alist)
X     char *fmt;
X     va_dcl
{
X  va_list pvar;
X
X  va_start(pvar);
X
X  SHUFFLEBUFFERS;
X
X  vsprintf(tcharp, fmt, pvar);
X
X  va_end(pvar);
X
X  return tcharp;
}
X
SHAR_EOF
chmod 0644 sprintfs.c ||
echo 'restore of sprintfs.c failed'
Wc_c="`wc -c < 'sprintfs.c'`"
test 1670 -eq "$Wc_c" ||
    echo 'sprintfs.c: original size 1670, current size' "$Wc_c"
fi
# ============= strempty.c ==============
if test -f 'strempty.c' -a X"$1" != X"-c"; then
    echo 'x - skipping strempty.c (File already exists)'
else
echo 'x - extracting strempty.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'strempty.c' &&
/*:ts=4*/
/*****************************************************************************
X * FIDOGATE --- Gateway software UNIX <-> FIDO
X *
X * $Id: strempty.c,v 1.2 90/12/02 21:22:42 mj Exp $
X *
X * strempty(), strclean()
X *
X * $Log:    strempty.c,v $
X * Revision 1.2  90/12/02  21:22:42  mj
X * Changed program header to mention both authors of the original
X * software posted to alt.sources.
X *
X * Revision 1.1  90/11/05  20:51:11  mj
X * Changed my signature in all program headers.
X *
X * Revision 1.0  90/06/21  19:11:09  mj
X * Initial revision
X *
X *
X *****************************************************************************
X * This version hacked and maintained by:
X *    _____ _____
X *   |     |___  |   Martin Junius     FIDO:    2:242/6.1   2:242/6.0
X *   | | | |   | |   Republikplatz 3   DOMAIN:  [e-mail]
X *   |_|_|_|_____|   D-5100 Aachen     Tel. (Voice) 0241-86931
X *
X * Original version of these programs and files:
X *
X *   Teemu Torma
X *   Heikki Suonsivu   FIDO: 2:504/1   UUCP: ...!mcsun!santra!hsu
X *
X *****************************************************************************/
X
#include "fidogate.h"
X
X
X
/* Check if string just consists of space (or is null). Return TRUE if so */
X
strempty(s)
X     char *s;
{
X  while (*s) if (!isspace(*s)) return FALSE; else s++;
X  return TRUE;
}
X
/* Clean up space from start and end */
X
char *strclean(s)
X     char *s;
{
X  char *d = s, *p = s;
X
X  /* Find first non-space char */
X  for (; *p; p++) if (!isspace(*p)) break;
X
X  /* Copy until end */
X  if (d != p) while (*d++ = *p++);
X
X  /* Strip space from end */
X  while (strlen(s) && isspace(s[strlen(s) - 1])) s[strlen(s) - 1] = 0;
X
X  return s;
}
X
/* Clean up whitespace from start */
char *strsclean(s)
X     char *s;
{
X  char *d = s, *p = s;
X
X  /* Find first non-space char */
X  for (; *p; p++) if (!isspace(*p)) break;
X
X  /* Copy until end */
X  if (d != p) while (*d++ = *p++);
X
X  return s;
}
SHAR_EOF
chmod 0644 strempty.c ||
echo 'restore of strempty.c failed'
Wc_c="`wc -c < 'strempty.c'`"
test 1919 -eq "$Wc_c" ||
    echo 'strempty.c: original size 1919, current size' "$Wc_c"
fi
# ============= listscan.c ==============
if test -f 'listscan.c' -a X"$1" != X"-c"; then
    echo 'x - skipping listscan.c (File already exists)'
else
echo 'x - extracting listscan.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'listscan.c' &&
/*:ts=4*/
/*****************************************************************************
X * FIDOGATE --- Gateway software UNIX <-> FIDO
X *
X * $Id: listscan.c,v 1.2 90/12/02 21:22:09 mj Exp $
X *
X * Searches char * table for string
X *
X * $Log:    listscan.c,v $
X * Revision 1.2  90/12/02  21:22:09  mj
X * Changed program header to mention both authors of the original
X * software posted to alt.sources.
X *
X * Revision 1.1  90/11/05  20:50:43  mj
X * Changed my signature in all program headers.
X *
X * Revision 1.0  90/06/21  19:07:00  mj
X * Initial revision
X *
X *
X *****************************************************************************
X * This version hacked and maintained by:
X *    _____ _____
X *   |     |___  |   Martin Junius     FIDO:    2:242/6.1   2:242/6.0
X *   | | | |   | |   Republikplatz 3   DOMAIN:  [e-mail]
X *   |_|_|_|_____|   D-5100 Aachen     Tel. (Voice) 0241-86931
X *
X * Original version of these programs and files:
X *
X *   Teemu Torma
X *   Heikki Suonsivu   FIDO: 2:504/1   UUCP: ...!mcsun!santra!hsu
X *
X *****************************************************************************/
X
#include "fidogate.h"
X
X
X
int listscan(list,search)
char **list;
char *search;
{
X  register int i;
X  static char *p1, *p2;
X
X  i = 0;
X  p1 = *list++;
X  while (*p1 != '\0') {
X    p2 = search;
X    while (*p1 == *p2) {
X      if (*p1++ == '\0')
X    return(i);
X      p2++;
X    }
X    if (*p2 == ' ') return i;
X    i++;
X    p1 = *list++;
X  }
X  return -1;
}
SHAR_EOF
chmod 0644 listscan.c ||
echo 'restore of listscan.c failed'
Wc_c="`wc -c < 'listscan.c'`"
test 1474 -eq "$Wc_c" ||
    echo 'listscan.c: original size 1474, current size' "$Wc_c"
fi
# ============= xalloc.c ==============
if test -f 'xalloc.c' -a X"$1" != X"-c"; then
    echo 'x - skipping xalloc.c (File already exists)'
else
echo 'x - extracting xalloc.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'xalloc.c' &&
/*:ts=4*/
/*****************************************************************************
X * FIDOGATE --- Gateway software UNIX <-> FIDO
X *
X * $Id: xalloc.c,v 1.4 90/11/05 20:51:14 mj Exp $
X *
X * Safe alloc routines.
X *
X * $Log:    xalloc.c,v $
X * Revision 1.4  90/11/05  20:51:14  mj
X * Changed my signature in all program headers.
X *
X * Revision 1.3  90/09/08  18:49:31  mj
X * Move strsaveline() to xalloc.c
X *
X * Revision 1.2  90/07/01  15:20:50  mj
X * Fixed some bugs in funpack caused by the removal of alloca().
X * No more core dumps, but heaven knows, why it works now. Strange.
X *
X * Revision 1.1  90/07/01  13:46:30  mj
X * Removed all calls to alloca(). All unsave malloc()'s without
X * checking the returned pointer are now done via xmalloc().
X * Fixed a malloc() error in rmail.
X *
X * Revision 1.0  90/06/28  21:25:56  mj
X * Initial revision
X *
X *
X *****************************************************************************
X * This version hacked and maintained by:
X *    _____ _____
X *   |     |___  |   Martin Junius     FIDO:    2:242/6.1   2:242/6.0
X *   | | | |   | |   Republikplatz 3   DOMAIN:  [e-mail]
X *   |_|_|_|_____|   D-5100 Aachen     Tel. (Voice) 0241-86931
X *
X *****************************************************************************/
X
#include "fidogate.h"
X
char *malloc(), *realloc();
X
X
/*
X * xmalloc(), xrealloc()  ---  safe versions of malloc() and realloc()
X */
X
char *xmalloc(size)
int size;
{
char *p;
X
X    if(p = malloc(size))
X        return(p);
X    log("Memory exhausted.");
X    exit(EX_OSERR);
}
X
char *xrealloc(ptr, size)
char *ptr;
int size;
{
char *p;
X
X    if(p = realloc(ptr, size))
X        return(p);
X    log("Memory exhausted.");
X    exit(EX_OSERR);
}
X
X
X
/*
X * strsave()  ---  make a copy of a string
X */
X
char *strsave(s)
char *s;
{
char *p;
X
X    p = xmalloc(strlen(s) + 1);
X    strcpy(p, s);
X    return(p);
}
X
X
X
/*
X * strsaveline() --- like strsave(), but remove '\n' at end of line if any
X */
X
char *strsaveline(s)
char *s;
{
char *r;
int len;
X
X    r = strsave(s);
X    len = strlen(r);
X    if(r[len - 1] == '\n')
X        r[len - 1] = 0;
X    return(r);
}
SHAR_EOF
chmod 0644 xalloc.c ||
echo 'restore of xalloc.c failed'
Wc_c="`wc -c < 'xalloc.c'`"
test 2067 -eq "$Wc_c" ||
    echo 'xalloc.c: original size 2067, current size' "$Wc_c"
fi
# ============= msgidseq.c ==============
if test -f 'msgidseq.c' -a X"$1" != X"-c"; then
    echo 'x - skipping msgidseq.c (File already exists)'
else
echo 'x - extracting msgidseq.c (Text)'
sed 's/^X//' << 'SHAR_EOF' > 'msgidseq.c' &&
/*:ts=4*/
/*****************************************************************************
X * FIDOGATE --- Gateway software UNIX <-> FIDO
X *
X * $Id: msgidseq.c,v 1.1 90/11/05 20:50:47 mj Exp $
X *
X * Output new message id number from sequencer file. Stand alone program
X * for use by CNews.
X *
X * Install this program in /u/lib/newsbin or similar directory. Then change
X * Message-ID: generating software to use msgidseq, e.g. last line of
X * inject/anne.jones for CNews.
X *
X * $Log:    msgidseq.c,v $
X * Revision 1.1  90/11/05  20:50:47  mj
X * Changed my signature in all program headers.
X *
X * Revision 1.0  90/08/18  15:43:18  mj
X * Initial revision
X *
X *
X *****************************************************************************
X * This version hacked and maintained by:
X *    _____ _____
X *   |     |___  |   Martin Junius     FIDO:    2:242/6.1   2:242/6.0
X *   | | | |   | |   Republikplatz 3   DOMAIN:  [e-mail]
X *   |_|_|_|_____|   D-5100 Aachen     Tel. (Voice) 0241-86931
X *
X *****************************************************************************/
X
#include "fidogate.h"
X
X
X
int verbose = 0;
X
X
main()
{
long msgid;
X
X    msgid = sequencer(MSGIDSEQ);
X    printf("%ld\n", msgid);
}
SHAR_EOF
chmod 0644 msgidseq.c ||
echo 'restore of msgidseq.c failed'
Wc_c="`wc -c < 'msgidseq.c'`"
test 1206 -eq "$Wc_c" ||
    echo 'msgidseq.c: original size 1206, current size' "$Wc_c"
fi
exit 0

--
 _____ _____
|     |___  |   Martin Junius     FIDO:    2:242/6.1   2:242/6.0
| | | |   | |   Republikplatz 3   DOMAIN:  [e-mail]
|_|_|_|_____|   D-5100 Aachen     Tel. (Voice) 0241-86931