home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 2 BBS / 02-BBS.zip / PLST_133.SZH / PARSELST.C < prev    next >
Text File  |  1991-09-20  |  48KB  |  1,773 lines
  1. /*
  2.                               Nodelist Parser
  3.  
  4.               This module was originally written by Bob Hartman
  5.                        Sysop of FidoNet node 1:104/501
  6.  
  7.  This program source code is being released with the following provisions:
  8.  
  9.  1.  You are  free to make  changes to this source  code for use on your own
  10.  machine,  however,  altered source files may not be distributed without the
  11.  consent of Spark Software.
  12.  
  13.  2.  You may distribute "patches"  or  "diff" files for any changes that you
  14.  have made, provided that the "patch" or "diff" files are also sent to Spark
  15.  Software for inclusion in future releases of the entire package.   A "diff"
  16.  file for the source archives may also contain a compiled version,  provided
  17.  it is  clearly marked as not  being created  from the original source code.
  18.  No other  executable  versions may be  distributed without  the  consent of
  19.  Spark Software.
  20.  
  21.  3.  You are free to include portions of this source code in any program you
  22.  develop, providing:  a) Credit is given to Spark Software for any code that
  23.  may is used, and  b) The resulting program is free to anyone wanting to use
  24.  it, including commercial and government users.
  25.  
  26.  4.  There is  NO  technical support  available for dealing with this source
  27.  code, or the accompanying executable files.  This source  code  is provided
  28.  as is, with no warranty expressed or implied (I hate legalease).   In other
  29.  words, if you don't know what to do with it,  don't use it,  and if you are
  30.  brave enough to use it, you're on your own.
  31.  
  32. */
  33.  
  34. #include <stdio.h>
  35. #include <ctype.h>
  36. #include <fcntl.h>
  37. #include <sys/types.h>
  38. #include <sys/stat.h>
  39. #include <time.h>
  40. #include <malloc.h>
  41. #include <string.h>
  42. #include <io.h>
  43. #include <stdlib.h>
  44.  
  45. /* Should we generate an Opus style nodelist output */
  46.  
  47. #include "types.h"
  48. #include "externs.h"
  49.  
  50. #ifndef OS2
  51. #define open fast_open
  52. #define close fast_close
  53. #define read fast_read
  54. #define write fast_write
  55. #endif
  56.  
  57. #ifndef OS2
  58.  
  59. char           *REV = "$Revision: 1.33 $";      /* Used in my code for my RCS
  60.                                                  * program */
  61. #else
  62.  
  63. char           *REV = "$Revision: 1.33-OS/2 $";      /* Used in my code for my RCS
  64.                                                  * program */
  65. #endif
  66.  
  67. struct _node    new_node;
  68. struct _oldnode old_node;
  69. struct netls    seanet;
  70. struct nodels   seanode;
  71. struct extrastuff bt_node;
  72. struct nidxs   *seaidx;
  73. struct nidxs   *seaptr;
  74. struct qidx     qbbsidx;
  75. struct qdat     qbbsnode;
  76. long            seanodecnt;
  77. int             seacnt;
  78. long            seanetcnt;
  79.  
  80. char            buf[256];
  81. char            prn_first_line[256];
  82. char            txt_first_line[256];
  83. int             prn_pg_lines;
  84. int             txt_pg_lines;
  85. int             prn_pagenum;
  86. int             txt_pagenum;
  87. int             cmdbaud = 0;
  88.  
  89. static FILE    *nodelist_bbs, *nodelist_fon, *fidouser_$$1;
  90. static int     nodelist_dat, nodelist_idx, nodelist_sys;
  91. static FILE    *nodelist_prn, *nodelist_txt;
  92. static int     netlist_dog, nodelist_dog, index_dog;
  93. static int     nodelist_ext;
  94. static int     qnl_idx_bbs, qnl_dat_bbs;
  95.  
  96. /* extern int     *cmp(); */
  97.  
  98. main (int argc,char *argv[])
  99. {
  100.    char            buff1[20], buff2[20];        /* Junk buffers */
  101.    char         *s,*config_file ="PARSELST.CFG";
  102.    char         *mylist=NULL,*pvtlist=NULL;
  103.    char         *nodelist=NULL,editnl=0,cl_nodelist=0;
  104.    int           i;
  105.  
  106.    sscanf (REV, "$%s %s", buff1, buff2);
  107.    fprintf (stderr, "ParseLst - %s %s by Bob Hartman, SysOp of FidoNet Node 1:104/501\n", buff1, buff2);
  108.    fprintf (stderr, "Modified by George Peace and Bill Andrus, FidoNet Nodes 1:13/13 & 1:13/0\n", buff1, buff2);
  109.    fprintf (stderr, "This program is placed in the  Public Domain  as part of the BBS project.\n");
  110.    fprintf (stderr, "For information on BBS (Bit Bucket Software), contact 104/501 or 343/491.\n\n");
  111.  
  112.    if (argc > 1){
  113.        for (i=1;i<argc;i++) {
  114.            s=argv[i];
  115.            if ((s[0] == '/') || (s[0] == '-')) {
  116.                switch(tolower(s[1])) {
  117.  
  118. #ifndef OS2
  119.                    case 'e' :    editnl++;
  120.                                  break;
  121. #endif
  122.  
  123.                    case 'n' :    nodelist=(s+2);
  124.                                  strupr(nodelist);
  125.                                  cl_nodelist++;
  126.                                  break;
  127.  
  128.                    case 'c' :    config_file=s+2;
  129.                                  strupr (config_file);
  130.                                  break;
  131.  
  132.                    case 'm' :   mylist=(s+2);
  133.                                 strupr(mylist);
  134.                                 break;
  135.  
  136.                    case 'p' :   pvtlist=s+2;
  137.                                 strupr(pvtlist);
  138.                                 break;
  139.  
  140.                    case 'b' :   cmdbaud=atoi(&s[2]);
  141.                                 break;
  142.  
  143.                    default:      printf("Don't understand %s\n\n",s);
  144.                                  break;
  145.  
  146.                                  }
  147.                              }
  148.                          }
  149.                      }
  150. #ifndef OS2
  151.       if (editnl > 0)
  152.          {
  153.          printf ("Using EditNL to update Nodelist\n");
  154.          system ("EditNL");
  155.          printf ("\n");
  156.          }
  157.      else   edit();
  158. #else
  159.      edit();
  160. #endif
  161.  
  162.    strcpy (country, "1");
  163.  
  164.    /* Need to find the correct file to use */
  165.    fn = &fn_head;
  166.    if (cl_nodelist > 0)
  167.       {
  168.       fn->fname = nodelist;
  169.       strupr (fn->fname);
  170.       }
  171.    else
  172.       {
  173.       nfile_name (&(fn->fname));
  174.       }
  175.    fn->next = NULL;
  176.    fn->private = 0;
  177.  
  178.    ph = ph_head;
  179.    bd = bd_head;
  180.    dl = dl_head;
  181.    co = co_head;
  182.    et = et_head;
  183.  
  184.    /* Parse configuration file */
  185.    parse_config (config_file,mylist,pvtlist);
  186.  
  187.    if (cmdbaud > 0)
  188.       maxbaud = cmdbaud;
  189.  
  190.    /* Open output files */
  191.    open_outfiles ();
  192.  
  193.    /* Set up the output type */
  194.    if (out_type == -1)
  195.       {
  196.       if (myzone > 0)
  197.          out_type = 0;
  198.       else
  199.          out_type = 1;
  200.       }
  201.  
  202.    fn = &fn_head;
  203.    while (fn != NULL)
  204.       {
  205.       process_file (1);
  206.       }
  207.  
  208.    /* Close all the files */
  209.    if (nodelist_bbs != NULL)
  210.       {
  211.       fclose (nodelist_bbs);
  212.       }
  213.    if (nodelist_fon != NULL)
  214.       {
  215.       fclose (nodelist_fon);
  216.       }
  217.    if (fidouser_$$1 != NULL)
  218.       {
  219.       fclose (fidouser_$$1);
  220.       }
  221.    if (nodelist_dat != -1)
  222.       {
  223.       close (nodelist_dat);
  224.       }
  225.    if (nodelist_sys != -1)
  226.       {
  227.       close (nodelist_sys);
  228.       }
  229.    if (nodelist_idx != -1)
  230.       {
  231.       close (nodelist_idx);
  232.       }
  233.    if (nodelist_ext != -1)
  234.       {
  235.       close (nodelist_ext);
  236.       }
  237.    if (nodelist_prn != NULL)
  238.       {
  239.       fclose (nodelist_prn);
  240.       }
  241.    if (nodelist_txt != NULL)
  242.       {
  243.       fclose (nodelist_txt);
  244.       }
  245.    if (nodelist_dog != -1)
  246.       {
  247.       close (nodelist_dog);
  248.       }
  249.    if (qnl_idx_bbs != -1)
  250.       {
  251.       close (qnl_idx_bbs);
  252.       }
  253.    if (qnl_dat_bbs != -1)
  254.       {
  255.       close (qnl_dat_bbs);
  256.       }
  257.    if (netlist_dog != -1)
  258.       {
  259.       if (seanet.numnodes)
  260.          {
  261.          write (netlist_dog, (char *) &seanet, sizeof (struct netls));
  262.          }
  263.       close (netlist_dog);
  264.  
  265.       if (seaidx != NULL)
  266.          {
  267.          printf ("\nSorting for INDEX.DOG\n");
  268.          qsort (seaidx, seacnt, sizeof (struct nidxs), cmp);
  269.          unlink ("INDEX.DOG");
  270.          if ((index_dog = open ("INDEX.DOG", O_WRONLY|O_BINARY|O_CREAT, S_IREAD|S_IWRITE)) == -1)
  271.             {
  272.             printf ("Error opening INDEX.DOG - not generated\n");
  273.             unlink ("INDEX.DOG");
  274.             }
  275.          else
  276.             {
  277.             write (index_dog, (char *) seaidx, sizeof (struct nidxs) * seacnt);
  278.             close (index_dog);
  279.             }
  280.          }
  281.       else
  282.          {
  283.          /* Have to get rid of this to make sure no one gets confused */
  284.          unlink ("INDEX.DOG");
  285.          }
  286.       }
  287.  
  288.    printf ("\rProcessing Completed Without Errors.\n\n");
  289.  
  290.    /* Do any additional processing that might be needed */
  291.    if (doreport)
  292.       {
  293.       size_report ();
  294.       }
  295.  
  296.    if (fidouser_$$1 != NULL)
  297.       {
  298.       do_names ();
  299.       }
  300.    return (0);
  301. }
  302.  
  303. void
  304. open_outfiles ()
  305. {
  306.    int             i;
  307.  
  308.    if (nlist)
  309.       {
  310.       if ((nodelist_bbs = fopen ("NODELIST.BBS", "w")) == NULL)
  311.          {
  312.          printf ("Error opening output file\n");
  313.          exit (1);
  314.          }
  315.       }
  316.    else
  317.       {
  318.       nodelist_bbs = NULL;
  319.       }
  320.  
  321.    /* Open the NODELIST.FON file? */
  322.    if (rdata)
  323.       {
  324.       if ((nodelist_fon = fopen ("NODELIST.FON", "w")) == NULL)
  325.          {
  326.          printf ("Error opening NODELIST.FON - not generated\n");
  327.          }
  328.       }
  329.    else
  330.       {
  331.       nodelist_fon = NULL;
  332.       }
  333.  
  334.    /* Open the Fidouser.$$1 file */
  335.    if (udata)
  336.       {
  337.       if ((fidouser_$$1 = fopen ("FIDOUSER.$$1", "w")) == NULL)
  338.          {
  339.          printf ("Error opening FIDOUSER.$$1 - not generated\n");
  340.          }
  341.       }
  342.    else
  343.       {
  344.       fidouser_$$1 = NULL;
  345.       }
  346.  
  347.    nodelist_dat = -1;
  348.    nodelist_idx = -1;
  349.  
  350.    if (version6)
  351.       {
  352.       unlink ("NODELIST.DAT");
  353.       if ((nodelist_dat = open ("NODELIST.DAT", O_WRONLY|O_BINARY|O_CREAT, S_IREAD|S_IWRITE)) == -1)
  354.          {
  355.          printf ("Error opening NODELIST.DAT - not generated\n");
  356.          }
  357.       else
  358.          {
  359.          unlink ("NODELIST.IDX");
  360.          if ((nodelist_idx = open ("NODELIST.IDX", O_WRONLY|O_BINARY|O_CREAT, S_IREAD|S_IWRITE)) == -1)
  361.             {
  362.             printf ("Error opening NODELIST.IDX - NODELIST.DAT not generated\n");
  363.             close (nodelist_dat);
  364.             nodelist_dat = -1;
  365.             }
  366.          else
  367.             {
  368.             /* Write out the start of the .SYS file */
  369.             memset (&new_node, 0, sizeof (struct _node));
  370.             new_node.number = 6;
  371.             new_node.net = -1;
  372.             strcpy (new_node.name, "ParseLst");
  373.             strcpy (new_node.city, "1:132/101 in Nashua, NH USA");
  374.             write (nodelist_dat, (char *) &new_node, sizeof (struct _node));
  375.  
  376.             /* Write out the start of the .IDX file */
  377.             i = 5;
  378.             write (nodelist_idx, (char *) &i, sizeof (int));
  379.             i = -1;
  380.             write (nodelist_idx, (char *) &i, sizeof (int));
  381.             }
  382.          }
  383.       }
  384.    else
  385.       {
  386.       nodelist_dat = -1;
  387.       nodelist_idx = -1;
  388.       }
  389.  
  390.    nodelist_sys = -1;
  391.  
  392.    if (version5)
  393.       {
  394.       unlink ("NODELIST.SYS");
  395.       if ((nodelist_sys = open ("NODELIST.SYS", O_WRONLY|O_BINARY|O_CREAT, S_IREAD|S_IWRITE)) == -1)
  396.          {
  397.          printf ("Error opening NODELIST.SYS - not generated\n");
  398.          }
  399.       else
  400.          {
  401.          if (nodelist_idx == -1)
  402.             {
  403.             unlink ("NODELIST.IDX");
  404.             if ((nodelist_idx = open ("NODELIST.IDX", O_WRONLY|O_BINARY|O_CREAT, S_IREAD|S_IWRITE)) == -1)
  405.                {
  406.                printf ("Error opening NODELIST.IDX - NODELIST.SYS not generated\n");
  407.                close (nodelist_sys);
  408.                nodelist_sys = -1;
  409.                }
  410.             else
  411.                {
  412.                /* Write out the start of the .IDX file */
  413.                i = 5;
  414.                write (nodelist_idx, (char *) &i, sizeof (int));
  415.                i = -1;
  416.                write (nodelist_idx, (char *) &i, sizeof (int));
  417.                }
  418.             }
  419.  
  420.          /* Write out the start of the .SYS file */
  421.          memset (&old_node, 0, sizeof (struct _oldnode));
  422.          old_node.number = 5;
  423.          old_node.net = -1;
  424.          strcpy (old_node.name, "ParseLst");
  425.          strcpy (old_node.city, "1:132/101 in Nashua, NH USA");
  426.          write (nodelist_sys, (char *) &old_node, sizeof (struct _oldnode));
  427.          }
  428.       }
  429.    else
  430.       {
  431.       nodelist_sys = -1;
  432.       }
  433.  
  434.    nodelist_ext = -1;
  435.  
  436.    if (binkley)
  437.       {
  438.       unlink ("NODELIST.EXT");
  439.       if ((nodelist_ext = open ("NODELIST.EXT", O_WRONLY|O_BINARY|O_CREAT, S_IREAD|S_IWRITE)) == -1)
  440.          {
  441.          printf ("Error opening NODELIST.EXT - not generated\n");
  442.          }
  443.       else
  444.          {
  445.          if (nodelist_idx == -1)
  446.             {
  447.             unlink ("NODELIST.IDX");
  448.             if ((nodelist_idx = open ("NODELIST.IDX", O_WRONLY|O_BINARY|O_CREAT, S_IREAD|S_IWRITE)) == -1)
  449.                {
  450.                printf ("Error opening NODELIST.IDX - NODELIST.EXT not generated\n");
  451.                close (nodelist_ext);
  452.                nodelist_ext = -1;
  453.                }
  454.             else
  455.                {
  456.                /* Write out the start of the .IDX file */
  457.                i = 7;
  458.                write (nodelist_idx, (char *) &i, sizeof (int));
  459.                i = -1;
  460.                write (nodelist_idx, (char *) &i, sizeof (int));
  461.                }
  462.             }
  463.  
  464.          /* Write out the start of the .EXT file */
  465.          memset (&bt_node, 0, sizeof (struct extrastuff));
  466.          strcpy (bt_node.password, "ParseLst");
  467.          write (nodelist_ext, (char *) &bt_node, sizeof (struct extrastuff));
  468.          }
  469.       }
  470.    else
  471.       {
  472.       nodelist_ext = -1;
  473.       }
  474.  
  475.    if (sealist)
  476.       {
  477.       unlink ("NODELIST.DOG");
  478.       if ((nodelist_dog = open ("NODELIST.DOG", O_WRONLY|O_BINARY|O_CREAT, S_IREAD|S_IWRITE)) == -1)
  479.          {
  480.          printf ("Error opening NODELIST.DOG - not generated\n");
  481.          }
  482.       else
  483.          {
  484.          unlink ("NETLIST.DOG");
  485.          if ((netlist_dog = open ("NETLIST.DOG", O_WRONLY|O_BINARY|O_CREAT, S_IREAD|S_IWRITE)) == -1)
  486.             {
  487.             printf ("Error opening NETLIST.DOG - NODELIST.DOG not generated\n");
  488.             close (nodelist_dog);
  489.             nodelist_dog = -1;
  490.             seanetcnt = sizeof (struct netls);
  491.             }
  492.          else
  493.             {
  494.             /* Write out the start of the NETLIST.DOG file */
  495.             memset (&seanet, 0, sizeof (struct netls));
  496.             write (netlist_dog, (char *) &seanet, sizeof (struct netls));
  497.             }
  498.          }
  499.  
  500.       if ((seaidx = calloc (sizeof (struct nidxs), 4000)) == NULL)
  501.          {
  502.          printf ("Could not allocate space for INDEX.DOG - not generating\n");
  503.          seaptr = NULL;
  504.          }
  505.       else
  506.          {
  507.          seaptr = seaidx;
  508.          }
  509.       }
  510.    else
  511.       {
  512.       nodelist_dog = -1;
  513.       netlist_dog = -1;
  514.       }
  515.  
  516.    if (quickbbs)
  517.       {
  518.       unlink ("QNL_DAT.BBS");
  519.       if ((qnl_dat_bbs = open ("QNL_DAT.BBS", O_WRONLY|O_BINARY|O_CREAT, S_IREAD|S_IWRITE)) == -1)
  520.          {
  521.          printf ("Error opening QNL_DAT.BBS - not generated\n");
  522.          }
  523.       else
  524.          {
  525.          unlink ("QNL_IDX.BBS");
  526.          if ((qnl_idx_bbs = open ("QNL_IDX.BBS", O_WRONLY|O_BINARY|O_CREAT, S_IREAD|S_IWRITE)) == -1)
  527.             {
  528.             printf ("Error opening QNL_IDX.BBS - QNL_DAT.BBS not generated\n");
  529.             close (qnl_dat_bbs);
  530.             qnl_dat_bbs = -1;
  531.             }
  532.          }
  533.       }
  534.    else
  535.       {
  536.       qnl_idx_bbs = -1;
  537.       qnl_dat_bbs = -1;
  538.       }
  539.  
  540.    if (fidoprn)
  541.       {
  542.       if ((nodelist_prn = fopen ("NODELIST.PRN", "w")) != NULL)
  543.          prn_pg_lines = 100;
  544.       }
  545.    if (fidotxt)
  546.       {
  547.       if ((nodelist_txt = fopen ("NODELIST.TXT", "w")) != NULL)
  548.          txt_pg_lines = 100;
  549.       }
  550. }
  551.  
  552. void process_file (int times)
  553. {
  554.    int             n_num = 0;
  555.    int             old_n_num;
  556.    int             n_cost;
  557.    int             n_baud;
  558.    int             node;
  559.    int             addrs[5];
  560.    char            this_file[64];
  561.    char            def_phone[30];
  562.    char            def_flags[30];
  563.    int             def_cost;
  564.    int             def_baud;
  565.    int             cur_addr_lev;
  566.    int             did_cost;
  567.    int             i;
  568.    int             did_phone;
  569.    char            buff[128];
  570.    FILE           *f;
  571.    char           *p, *p1, *p2;
  572.    int             dphone;
  573.    char            b1[50];
  574.    char            b2[50];
  575.    char            b3[50];
  576.    char            b4[50];
  577.    char            b5[50];
  578.    char            b6[50];
  579.    char            b7[128];
  580.    char            pn1[20], pn2[20], pn3[20];
  581.    char            orig_phone[30];
  582.    int             pvt, hold, skip, def, n_out, this_list;
  583.    char            ntyp;
  584.    char           *mymalloc ();
  585.    extern char    *strchr ();
  586.  
  587.    /* Open the next filename */
  588.    f = NULL;
  589.    cur_addr_lev = 0;
  590.    if ((f = fopen (fn->fname, "r")) == NULL)
  591.       {
  592.       printf ("\rCould not open Nodelist File '%s' - Exiting\n", fn->fname);
  593.       exit (1);
  594.       }
  595.  
  596.    this_list = fn->private;
  597.  
  598.    if (times)
  599.       {
  600.       printf ("\nProcessing Nodelist File '%s'\n", fn->fname);
  601.       fgets (buf,256, f);
  602.       p1 = buf + strlen (buf) - 1;
  603.       while ((p1 >= buf) && (*p1 != ':'))
  604.          --p1;
  605.       if (p1 >= buf)
  606.          {
  607.          strcpy (p1, "-- Page");
  608.          sprintf (prn_first_line, "Bulletin Board Listing from %s", buf + 3);
  609.          sprintf (txt_first_line, "%s", buf + 3);
  610.          }
  611.       else
  612.          {
  613.          prn_first_line[0] = '\0';
  614.          txt_first_line[0] = '\0';
  615.          }
  616.  
  617.       if ((nodelist_prn != NULL) && !this_list)
  618.          {
  619.          ++prn_pagenum;
  620.          fprintf (nodelist_prn, "%s %d\n\n", prn_first_line, prn_pagenum);
  621.          }
  622.  
  623.       if ((nodelist_txt != NULL) && !this_list)
  624.          {
  625.          ++txt_pagenum;
  626.          fprintf (nodelist_txt, "%s %d\n\n", txt_first_line, txt_pagenum);
  627.          }
  628.       }
  629.    else
  630.       printf ("\nAdding Nodelist File '%s' to Zone %d\n", fn->fname, myzone);
  631.    strcpy (this_file, fn->fname);
  632.  
  633.    /* Show that we are not skipping here */
  634.    skip = -1;
  635.  
  636.    addrs[0] = addrs[1] = addrs[2] = addrs[3] = (myzone > 0) ? myzone : 1;
  637.  
  638.    for (;;)
  639.       {
  640.       if (fgets (buf, 256, f) == NULL)
  641.          break;
  642.  
  643.       pvt = 0;
  644.       dphone = 0;
  645.       n_cost = 0;
  646.       did_cost = 0;
  647.       hold = 0;
  648.       ntyp = 'L';
  649.       def = 0;
  650.       likely = 0;
  651.  
  652.       p = buff;
  653.       p1 = buf;
  654.       while (*p1)
  655.          {
  656.          if (!isspace (*p1))
  657.             *p++ = *p1;
  658.          ++p1;
  659.          }
  660.       *p++ = '\n';
  661.       *p = '\0';
  662.       p = buff;
  663.  
  664.       if (*p == ';')
  665.          {
  666.          if (comments)
  667.             {
  668.             fputs (buf, stdout);
  669.             }
  670.  
  671.          if ((!this_list) && (buf[1] == 'A'))
  672.             {
  673.             if ((nodelist_prn != NULL) && (prn_pg_lines == 100))
  674.                fputs (buf + 2, nodelist_prn);
  675.             if ((nodelist_txt != NULL) && (txt_pg_lines == 100))
  676.                fputs (buf + 2, nodelist_txt);
  677.             }
  678.          continue;
  679.          }
  680.  
  681.       nnodes++;
  682.  
  683.       /* Modifier (Host, Region, etc.) */
  684.       p = nextfield (p, b1);
  685.  
  686.       /* Node number (or region or zone) */
  687.       old_n_num = n_num;
  688.       p = nextfield (p, b2);
  689.       n_num = atoi (b2);
  690.  
  691.       /* Did we get anything? */
  692.       if (b1[0] != '\0')
  693.          {
  694.          /* Is it something we need to worry about? */
  695.          if (stricmp (b1, "zone") == 0)
  696.             {
  697.             if ((myzone > 0) && (addrs[0] == myzone) && nzones)
  698.                {
  699.                if (fn != NULL)
  700.                   fn = fn->next;
  701.                i = 0;
  702.                while (fn != NULL)
  703.                   {
  704.                   process_file (0);
  705.                   i = 1;
  706.                   }
  707.                if (i)
  708.                   printf ("\nReturning to finish file '%s'\n", this_file);
  709.                }
  710.  
  711.             ++nzones;
  712.             if (out_type == 0)
  713.                {
  714.                if (usezone)
  715.                   strcpy (b1, "ZONE ");
  716.                else
  717.                   strcpy (b1, "REGION ");
  718.                dphone = 1;
  719.                }
  720.             else
  721.                {
  722.                if (usezone)
  723.                   strcpy (b1, "ZONE ");
  724.                else
  725.                   strcpy (b1, "REGION ");
  726.                dphone = 1;
  727.                if (myzone > 0)
  728.                   {
  729.                   if (n_num != myzone)
  730.                      {
  731.                      skip = 1;
  732.                      }
  733.                   else
  734.                      {
  735.                      skip = 0;
  736.                      }
  737.                   }
  738.                }
  739.             ntyp = 'Z';
  740.             }
  741.          else
  742.          if (stricmp (b1, "region") == 0)
  743.             {
  744.             ++nregions;
  745.             spec_word (b1);
  746.             dphone = 2;
  747.             if (skip == 1)
  748.                skip = 2;
  749.             }
  750.          else
  751.          if (stricmp (b1, "host") == 0)
  752.             {
  753.             ++nnets;
  754.             spec_word (b1);
  755.             dphone = 3;
  756.             if (skip == 1)
  757.                skip = 2;
  758.             ntyp = 'I';
  759.             }
  760.          else
  761.          if (stricmp (b1, "hub") == 0)
  762.             {
  763.             ++nhubs;
  764.             if (out_type)
  765.                spec_word (b1);
  766.             else
  767.                b1[0] = '\0';
  768.             dphone = 4;
  769.             if (skip == 1)
  770.                skip = 2;
  771.             ntyp = 'H';
  772.             }
  773.          else
  774.          if (stricmp (b1, "point") == 0)
  775.             {
  776.             ++npoints;
  777.             spec_word (b1);
  778.             dphone = 5;
  779.             if (skip == 1)
  780.                skip = 2;
  781.             ntyp = 'P';
  782.             }
  783.          else
  784.          if (stricmp (b1, "pvt") == 0)
  785.             {
  786.             /* It is just a private node */
  787.             b1[0] = '\0';
  788.             pvt = 1;
  789.             }
  790.          else
  791.          if (stricmp (b1, "hold") == 0)
  792.             {
  793.             /* It is on hold */
  794.             b1[0] = '\0';
  795.             hold = 1;
  796.             }
  797.          else
  798.             {
  799.             ++ndown;
  800.             /* It is something we don't understand, or the node is down */
  801.             continue;
  802.             }
  803.          }
  804.  
  805.       if (dphone)
  806.          {
  807.          addrs[dphone - 1] = n_num;
  808.          for (i = dphone; i < 5; i++)
  809.             {
  810.             addrs[i] = n_num;
  811.             }
  812.          cur_addr_lev = dphone;
  813.          if (dphone < 4)
  814.             {
  815.             printf ("\rZone %2d, Region %2d, Net %5d", addrs[0], addrs[1], addrs[2]);
  816.             node = 0;
  817.             }
  818.          else
  819.             {
  820.             node = n_num;
  821.             }
  822.          }
  823.       else
  824.          {
  825.          node = n_num;
  826.          }
  827.  
  828.       /* Translate the node type if necessary */
  829.       if (b1[0] == '\0')
  830.          {
  831.          et = et_head;
  832.          while (et != NULL)
  833.             {
  834.             if (((addrs[0] == et->zone) || (et->zone == -1)) &&
  835.                (addrs[2] == et->net) && (node == et->node))
  836.                {
  837.                switch (et->etype)
  838.                   {
  839.                   case 'I':
  840.                      strcpy (b1, "IGATE ");
  841.                      break;
  842.                   case 'O':
  843.                      strcpy (b1, "OGATE ");
  844.                      break;
  845.                   case 'G':
  846.                      strcpy (b1, "GATE ");
  847.                      break;
  848.                   case 'H':
  849.                      strcpy (b1, "HUB ");
  850.                      break;
  851.                   }
  852.                ntyp = et->etype;
  853.                break;
  854.                }
  855.             et = et->next;
  856.             }
  857.          }
  858.  
  859.       /* Board name */
  860.       p = nextfield (p, b2);
  861.  
  862.       /* Location */
  863.       p = nextfield (p, b3);
  864.  
  865.       /* Sysop name */
  866.       p = nextfield (p, b4);
  867.  
  868.       /* Phone number */
  869.       p = nextfield (p, b5);
  870.       strcpy (orig_phone, b5);
  871.  
  872.       /* Determine the cost for this node */
  873.       co = co_head;
  874.       while (co != NULL)
  875.          {
  876.          if (strnicmp (b5, co->mstr, co->mlen) == 0)
  877.             {
  878.             n_cost = co->cost;
  879.             did_cost = 1;
  880.             break;
  881.             }
  882.          co = co->next;
  883.          }
  884.  
  885.       /* If we didn't get a match, then it gets intl cost */
  886.       if ((!did_cost) && (co == NULL) &&
  887.          (strnicmp (country, b5, strlen (country)) == 0))
  888.          {
  889.          did_cost = 1;
  890.          }
  891.  
  892.       /* Translate the phone number if possible via phone translations */
  893.       did_phone = 0;
  894.       ph = ph_head;
  895.       while (ph != NULL)
  896.          {
  897.          if (((addrs[0] == ph->zone) || (ph->zone == -1)) &&
  898.             (addrs[2] == ph->net) && (node == ph->node))
  899.             {
  900.             did_phone = 1;
  901.             strcpy (b5, ph->num);
  902.             break;
  903.             }
  904.          ph = ph->next;
  905.          }
  906.  
  907.       if (dphone)
  908.          {
  909.          if (isdigit (b5[0]) || (ph != NULL))
  910.             {
  911.             strcpy (def_phone, b5);
  912.             }
  913.          else
  914.             {
  915.             /* Bad news - an unlisted where we need a phone number */
  916.             ++ndown;
  917.             continue;
  918.             }
  919.          }
  920.  
  921.       /* If this guy is unpublished, put something in there */
  922.       if (((!isdigit (b5[0])) || (hold)) && (ph == NULL))
  923.          {
  924.          if (cur_addr_lev >= 3)
  925.             {
  926.             strcpy (b5, def_phone);
  927.             def = 1;
  928.             ++nredirect;
  929.             }
  930.          else
  931.             {
  932.             /* No dice - he is unpublished in a region or zone */
  933.             ++ndown;
  934.             continue;
  935.             }
  936.          }
  937.  
  938.       /* Determine the cost for this node */
  939.       if (!did_cost)
  940.          {
  941.          co = co_head;
  942.          while (co != NULL)
  943.             {
  944.             if (strnicmp (b5, co->mstr, co->mlen) == 0)
  945.                {
  946.                n_cost = co->cost;
  947.                did_cost = 1;
  948.                break;
  949.                }
  950.             co = co->next;
  951.             }
  952.          }
  953.  
  954.       /* Determine some things from the phone number */
  955.       p1 = b5;
  956.       p2 = pn1;
  957.       while ((*p1) && isdigit (*p1))
  958.          {
  959.          *p2++ = *p1++;
  960.          }
  961.       *p2 = '\0';
  962.  
  963.       if (*p1 != '\0')
  964.          ++p1;
  965.  
  966.       p2 = pn2;
  967.       while ((*p1) && isdigit (*p1))
  968.          {
  969.          *p2++ = *p1++;
  970.          }
  971.       *p2 = '\0';
  972.  
  973.       if (*p1 != '\0')
  974.          ++p1;
  975.  
  976.       p2 = pn3;
  977.       while ((*p1) && isdigit (*p1))
  978.          {
  979.          *p2++ = *p1++;
  980.          }
  981.       *p2 = '\0';
  982.  
  983.       if (*p1 != '\0')
  984.          ++p1;
  985.  
  986.       if (pn1[0] == '\0')
  987.          {
  988.          pn1[0] = '1';
  989.          pn1[1] = '\0';
  990.          }
  991.  
  992.       if (pn2[0] == '\0')
  993.          {
  994.          pn2[0] = '1';
  995.          pn2[1] = '\0';
  996.          }
  997.  
  998.       if (pn3[0] == '\0')
  999.          {
  1000.          pn3[0] = '1';
  1001.          pn3[1] = '\0';
  1002.          }
  1003.  
  1004.       /* Translate the number if possible via dial translations */
  1005.       dl = dl_head;
  1006.       while (dl != NULL)
  1007.          {
  1008.          if (strnicmp (b5, dl->mstr, dl->mlen) == 0)
  1009.             {
  1010.             strcpy (b7, &b5[dl->mlen]);
  1011.             sprintf (b5, "%s%s%s", dl->pre, b7, dl->post);
  1012.             break;
  1013.             }
  1014.          dl = dl->next;
  1015.          }
  1016.  
  1017.       if ((dl == NULL) && (!did_phone) && (strnicmp (country, b5, strlen (country)) != 0))
  1018.          {
  1019.          sprintf (b7, "%s%s%s", intl_pre_dl, b5, intl_post_dl);
  1020.          strcpy (b5, b7);
  1021.          }
  1022.  
  1023.       /* Determine the cost for this node */
  1024.       if (!did_cost)
  1025.          {
  1026.          co = co_head;
  1027.          while (co != NULL)
  1028.             {
  1029.             if (strnicmp (b5, co->mstr, co->mlen) == 0)
  1030.                {
  1031.                n_cost = co->cost;
  1032.                did_cost = 1;
  1033.                break;
  1034.                }
  1035.             co = co->next;
  1036.             }
  1037.          }
  1038.  
  1039.       /* If we didn't get a match, then it gets intl cost */
  1040.       if (!did_cost)
  1041.          {
  1042.          n_cost = intl_cost;
  1043.          }
  1044.  
  1045.       /* Baud rate */
  1046.       p = nextfield (p, b6);
  1047.       n_baud = atoi (b6);
  1048.  
  1049.       /* If necessary, translate the baud rate */
  1050.       bd = bd_head;
  1051.       while (bd != NULL)
  1052.          {
  1053.          if (((addrs[0] == bd->zone) || (bd->zone == -1)) &&
  1054.             (addrs[2] == bd->net) && (node == bd->node))
  1055.             {
  1056.             n_baud = bd->baud;
  1057.             break;
  1058.             }
  1059.          bd = bd->next;
  1060.          }
  1061.  
  1062.       /* Fix the baud rate downward if necessary */
  1063.       if (n_baud > maxbaud)
  1064.          {
  1065.          n_baud = maxbaud;
  1066.          }
  1067.  
  1068.       /* Get rid of the newline at the end */
  1069.       p1 = p;
  1070.       while ((*p1) && (!isspace (*p1)))
  1071.          {
  1072.          ++p1;
  1073.          }
  1074.       *p1 = '\0';
  1075.  
  1076.       if (dphone)
  1077.          {
  1078.          strcpy (def_flags, p);
  1079.          def_baud = n_baud;
  1080.          def_cost = n_cost;
  1081.          }
  1082.  
  1083.       if (def)
  1084.          {
  1085.          strcpy (p, def_flags);
  1086.          n_baud = def_baud;
  1087.          n_cost = def_cost;
  1088.          }
  1089.  
  1090.       /* Put the results into the proper files */
  1091.       if (skip < 2)
  1092.          {
  1093.          /* Print out the results in NODELIST.BBS format */
  1094.          if (nodelist_bbs != NULL)
  1095.             {
  1096.             if (nodash)
  1097.                {
  1098.                undash (b5);
  1099.                }
  1100.  
  1101.             fprintf (nodelist_bbs, "%s%d %d %d %s %s %s\n", b1, n_num, n_cost, n_baud, b2, b5, b3);
  1102.             }
  1103.  
  1104.          /* Output to NODELIST.FON */
  1105.          if (nodelist_fon != NULL)
  1106.             {
  1107.             /* Convert to upper case */
  1108.             strupr (p);
  1109.  
  1110.             /* Print it out in NODELIST.FON format */
  1111.             fprintf (nodelist_fon, "%4d %4d %3s %3s %3s %4d %c %s\n",
  1112.                      addrs[2], node, pn1, pn2, pn3, n_baud, ntyp,
  1113.                      (*p == '\0') ? "-" : p);
  1114.             }
  1115.  
  1116.          if (nodelist_dat != -1)
  1117.             {
  1118.             memset (&new_node, 0, sizeof (struct _node));
  1119.             new_node.number = node;
  1120.             new_node.net = addrs[2];
  1121.             new_node.cost = n_cost;
  1122.             new_node.rate = (unsigned char) (n_baud / 300);
  1123.             new_node.realcost = n_cost;
  1124.             strncpy (new_node.name, b2, 33);
  1125.             p1 = new_node.name;
  1126.             while ((p1 = strchr (p1, '_')) != NULL)
  1127.                {
  1128.                *p1 = ' ';
  1129.                }
  1130.  
  1131.             strncpy (new_node.phone, b5, 39);
  1132.             strncpy (new_node.city, b3, 29);
  1133.             p1 = new_node.city;
  1134.             while ((p1 = strchr (p1, '_')) != NULL)
  1135.                {
  1136.                *p1 = ' ';
  1137.                }
  1138.  
  1139.             /* Stick in a password if there is one */
  1140.             pw = pw_head;
  1141.             while (pw != NULL)
  1142.                {
  1143.                if (((addrs[0] == pw->zone) || (pw->zone == -1)) &&
  1144.                   (addrs[2] == pw->net) && (node == pw->node))
  1145.                   {
  1146.                   strncpy (new_node.password, &(pw->pw[1]), 8);
  1147.                   break;
  1148.                   }
  1149.                pw = pw->next;
  1150.                }
  1151.  
  1152.             if (cur_addr_lev == 4)
  1153.                {
  1154.                new_node.hubnode = addrs[3];
  1155.                }
  1156.             else
  1157.                {
  1158.                new_node.hubnode = 0;
  1159.                }
  1160.  
  1161.             new_node.modem = 0;
  1162.             if (strstr (p, "HST"))
  1163.                {
  1164.                new_node.modem |= M_HST;
  1165.                }
  1166.             if (strstr (p, "PEP"))
  1167.                {
  1168.                new_node.modem |= M_PEP;
  1169.                }
  1170.             if (strstr (p, "V32"))
  1171.                {
  1172.                new_node.modem |= M_V32;
  1173.                }
  1174.             if (strstr (p, "V32b"))
  1175.                {
  1176.                new_node.modem |= M_V32B;
  1177.                }
  1178.             if (strstr (p, "H96"))
  1179.                {
  1180.                new_node.modem |= M_H96;
  1181.                }
  1182.  
  1183.             new_node.flags1 = 0;
  1184.  
  1185.             switch (dphone)
  1186.                {
  1187.                case 0:
  1188.                   break;
  1189.  
  1190.                case 1:
  1191.                   new_node.flags1 |= B_zone;
  1192.                   break;
  1193.  
  1194.                case 2:
  1195.                   new_node.flags1 |= B_region;
  1196.                   break;
  1197.  
  1198.                case 3:
  1199.                   new_node.flags1 |= B_host;
  1200.                   break;
  1201.  
  1202.                case 4:
  1203.                   new_node.flags1 |= B_hub;
  1204.                   break;
  1205.  
  1206.                case 5:
  1207.                   new_node.flags1 |= B_point;
  1208.                   break;
  1209.                }
  1210.  
  1211.             if (strstr (p, "CM"))
  1212.                {
  1213.                new_node.flags1 |= B_CM;
  1214.                }
  1215.  
  1216.             /* Stick in a CM flag is there is one done manually */
  1217.             cm = cm_head;
  1218.             while (cm != NULL)
  1219.                {
  1220.                if (((addrs[0] == cm->zone) || (cm->zone == -1)) &&
  1221.                   (addrs[2] == cm->net) && (node == cm->node))
  1222.                   {
  1223.                   new_node.flags1 |= B_CM;
  1224.                   break;
  1225.                   }
  1226.                cm = cm->next;
  1227.                }
  1228.  
  1229.             write (nodelist_dat, (char *) &new_node, sizeof (struct _node));
  1230.             }
  1231.  
  1232.          if (qnl_dat_bbs != -1)
  1233.             {
  1234.             memset (&qbbsnode, 0, sizeof (struct qdat));
  1235.             qbbsidx.zone = addrs[0];
  1236.             qbbsidx.net = addrs[2];
  1237.             qbbsidx.node = node;
  1238.             qbbsidx.nodetype = qbbsnode.nodetype = (char) dphone;
  1239.             if ((dphone == 1) && (b1[0] == 'R'))
  1240.                {
  1241.                qbbsidx.nodetype = qbbsnode.nodetype = 2;
  1242.                }
  1243.  
  1244.             write (qnl_idx_bbs, (char *) &qbbsidx, sizeof (struct qidx));
  1245.  
  1246.             qbbsnode.zone = addrs[0];
  1247.             qbbsnode.net = addrs[2];
  1248.             qbbsnode.node = node;
  1249.  
  1250.             strncpy (qbbsnode.name, b2, 20);
  1251.             p1 = qbbsnode.name;
  1252.             while ((p1 = strchr (p1, '_')) != NULL)
  1253.                {
  1254.                *p1 = ' ';
  1255.                }
  1256.             qbbsnode.namesize = (char) strlen (b2);
  1257.             if (qbbsnode.namesize > 20)
  1258.                qbbsnode.namesize = 20;
  1259.  
  1260.             strncpy (qbbsnode.city, b3, 40);
  1261.             p1 = qbbsnode.city;
  1262.             while ((p1 = strchr (p1, '_')) != NULL)
  1263.                {
  1264.                *p1 = ' ';
  1265.                }
  1266.             qbbsnode.citysize = (char) strlen (b3);
  1267.             if (qbbsnode.citysize > 40)
  1268.                qbbsnode.citysize = 40;
  1269.  
  1270.             strncpy (qbbsnode.phone, b5, 40);
  1271.             qbbsnode.phonesize = (char) strlen (b5);
  1272.             if (qbbsnode.phonesize > 40)
  1273.                qbbsnode.phonesize = 40;
  1274.  
  1275.             /* Stick in a password if there is one */
  1276.             pw = pw_head;
  1277.             while (pw != NULL)
  1278.                {
  1279.                if (((addrs[0] == pw->zone) || (pw->zone == -1)) &&
  1280.                   (addrs[2] == pw->net) && (node == pw->node))
  1281.                   {
  1282.                   strncpy (qbbsnode.password, &(pw->pw[1]), 8);
  1283.                   qbbsnode.passwordsize = (char) strlen (&(pw->pw[1]));
  1284.                   if (qbbsnode.passwordsize > 8)
  1285.                      qbbsnode.passwordsize = 8;
  1286.                   break;
  1287.                   }
  1288.                pw = pw->next;
  1289.                }
  1290.  
  1291.             qbbsnode.flags = 0;
  1292.  
  1293.             switch (dphone)
  1294.                {
  1295.                case 0:
  1296.                   break;
  1297.  
  1298.                case 1:
  1299.                   qbbsnode.flags |= B_zone;
  1300.                   break;
  1301.  
  1302.                case 2:
  1303.                   qbbsnode.flags |= B_region;
  1304.                   break;
  1305.  
  1306.                case 3:
  1307.                   qbbsnode.flags |= B_host;
  1308.                   break;
  1309.  
  1310.                case 4:
  1311.                   qbbsnode.flags |= B_hub;
  1312.                   break;
  1313.                }
  1314.  
  1315.             if (strstr (p, "CM"))
  1316.                {
  1317.                qbbsnode.flags |= B_CM;
  1318.                }
  1319.  
  1320.             /* Stick in a CM flag is there is one done manually */
  1321.             cm = cm_head;
  1322.             while (cm != NULL)
  1323.                {
  1324.                if (((addrs[0] == cm->zone) || (cm->zone == -1)) &&
  1325.                   (addrs[2] == cm->net) && (node == cm->node))
  1326.                   {
  1327.                   qbbsnode.flags |= B_CM;
  1328.                   break;
  1329.                   }
  1330.                cm = cm->next;
  1331.                }
  1332.  
  1333.             qbbsnode.baudrate = n_baud;
  1334.             qbbsnode.cost = n_cost;
  1335.  
  1336.             write (qnl_dat_bbs, (char *) &qbbsnode, sizeof (struct qdat));
  1337.             }
  1338.  
  1339.          if (nodelist_ext != -1)
  1340.             {
  1341.             memset (&bt_node, 0, sizeof (struct extrastuff));
  1342.  
  1343.             /* Stick in a password if there is one */
  1344.             pw = pw_head;
  1345.             while (pw != NULL)
  1346.                {
  1347.                if (((addrs[0] == pw->zone) || (pw->zone == -1)) &&
  1348.                   (addrs[2] == pw->net) && (node == pw->node))
  1349.                   {
  1350.                   strncpy (bt_node.password, &(pw->pw[1]), 8);
  1351.                   break;
  1352.                   }
  1353.                pw = pw->next;
  1354.                }
  1355.  
  1356.             bt_node.flags1 = 0;
  1357.  
  1358.             switch (dphone)
  1359.                {
  1360.                case 0:
  1361.                   break;
  1362.  
  1363.                case 1:
  1364.                   bt_node.flags1 |= B_zone;
  1365.                   break;
  1366.  
  1367.                case 2:
  1368.                   bt_node.flags1 |= B_region;
  1369.                   break;
  1370.  
  1371.                case 3:
  1372.                   bt_node.flags1 |= B_host;
  1373.                   break;
  1374.  
  1375.                case 4:
  1376.                   bt_node.flags1 |= B_hub;
  1377.                   break;
  1378.                }
  1379.  
  1380.             if (strstr (p, "CM"))
  1381.                {
  1382.                bt_node.flags1 |= B_CM;
  1383.                }
  1384.  
  1385.             /* Stick in a CM flag is there is one done manually */
  1386.             cm = cm_head;
  1387.             while (cm != NULL)
  1388.                {
  1389.                if (((addrs[0] == cm->zone) || (cm->zone == -1)) &&
  1390.                   (addrs[2] == cm->net) && (node == cm->node))
  1391.                   {
  1392.                   bt_node.flags1 |= B_CM;
  1393.                   break;
  1394.                   }
  1395.                cm = cm->next;
  1396.                }
  1397.  
  1398.             write (nodelist_ext, (char *) &bt_node, sizeof (struct extrastuff));
  1399.             }
  1400.  
  1401.          if (nodelist_dog != -1)
  1402.             {
  1403.             if (node <= 0)
  1404.                {
  1405.                if (seanet.numnodes)
  1406.                   {
  1407.                   write (netlist_dog, (char *) &seanet, sizeof (struct netls));
  1408.                   seanetcnt += sizeof (struct netls);
  1409.                   }
  1410.  
  1411.                memset (&seanet, 0, sizeof (struct netls));
  1412.                seanet.netnum = addrs[2];
  1413.                strncpy (seanet.netname, b2, 13);
  1414.                p1 = seanet.netname;
  1415.                while ((p1 = strchr (p1, '_')) != NULL)
  1416.                   {
  1417.                   *p1 = ' ';
  1418.                   }
  1419.  
  1420.                strncpy (seanet.netcity, b3, 39);
  1421.                p1 = seanet.netcity;
  1422.                while ((p1 = strchr (p1, '_')) != NULL)
  1423.                   {
  1424.                   *p1 = ' ';
  1425.                   }
  1426.  
  1427.                seanet.nodeptr = seanodecnt;
  1428.                }
  1429.  
  1430.             if (seacnt < 4000)
  1431.                {
  1432.                if (seaptr != NULL)
  1433.                   {
  1434.                   seaptr->idxnet = addrs[2];
  1435.                   seaptr->idxnode = node;
  1436.                   seaptr->netlptr = seanetcnt;
  1437.                   seaptr->nodelptr = seanodecnt;
  1438.                   ++seaptr;
  1439.                   }
  1440.                }
  1441.             else
  1442.                {
  1443.                seacnt = 3999;
  1444.                }
  1445.  
  1446.             memset (&seanode, 0, sizeof (struct nodels));
  1447.             seanode.nodenum = node;
  1448.             strncpy (seanode.nodename, b2, 13);
  1449.             p1 = seanode.nodename;
  1450.             while ((p1 = strchr (p1, '_')) != NULL)
  1451.                {
  1452.                *p1 = ' ';
  1453.                }
  1454.  
  1455.             strncpy (seanode.nodecity, b3, 39);
  1456.             p1 = seanode.nodecity;
  1457.             while ((p1 = strchr (p1, '_')) != NULL)
  1458.                {
  1459.                *p1 = ' ';
  1460.                }
  1461.  
  1462.             strncpy (seanode.nodephone, b5, 39);
  1463.             if (cur_addr_lev == 4)
  1464.                {
  1465.                seanode.havehub = 1;
  1466.                seanode.nodehub = addrs[3];
  1467.                }
  1468.             seanode.nodecost = n_cost;
  1469.             seanode.nodebaud = n_baud;
  1470.             write (nodelist_dog, (char *) &seanode, sizeof (struct nodels));
  1471.             ++seanet.numnodes;
  1472.             seanodecnt += sizeof (struct nodels);
  1473.             ++seacnt;
  1474.             }
  1475.  
  1476.          if (nodelist_sys != -1)
  1477.             {
  1478.             memset (&old_node, 0, sizeof (struct _oldnode));
  1479.             old_node.number = node;
  1480.             old_node.net = addrs[2];
  1481.             old_node.cost = n_cost;
  1482.             old_node.rate = n_baud;
  1483.             strncpy (old_node.name, b2, 19);
  1484.             p1 = old_node.name;
  1485.             while ((p1 = strchr (p1, '_')) != NULL)
  1486.                {
  1487.                *p1 = ' ';
  1488.                }
  1489.  
  1490.             strncpy (old_node.phone, b5, 39);
  1491.             strncpy (old_node.city, b3, 39);
  1492.             p1 = old_node.city;
  1493.             while ((p1 = strchr (p1, '_')) != NULL)
  1494.                {
  1495.                *p1 = ' ';
  1496.                }
  1497.  
  1498.             /* Stick in a password if there is one */
  1499.             pw = pw_head;
  1500.             while (pw != NULL)
  1501.                {
  1502.                if (((addrs[0] == pw->zone) || (pw->zone == -1)) &&
  1503.                   (addrs[2] == pw->net) && (node == pw->node))
  1504.                   {
  1505.                   strncpy (&(old_node.city[strlen (old_node.city) + 1]), pw->pw, 8);
  1506.                   break;
  1507.                   }
  1508.                pw = pw->next;
  1509.                }
  1510.  
  1511.             write (nodelist_sys, (char *) &old_node, sizeof (struct _oldnode));
  1512.             }
  1513.  
  1514.          if (nodelist_idx != -1)
  1515.             {
  1516.             if ((node == 0) && (dphone <= 2))
  1517.                {
  1518.                if ((ntyp != 'Z') || (!usezone))
  1519.                   n_out = -1;
  1520.                else
  1521.                   n_out = -2;
  1522.                }
  1523.             else
  1524.                {
  1525.                n_out = node;
  1526.                }
  1527.  
  1528.             write (nodelist_idx, (char *) &n_out, sizeof (int));
  1529.             write (nodelist_idx, (char *) &addrs[2], sizeof (int));
  1530.             }
  1531.  
  1532.          if (dphone == 3)
  1533.             {
  1534.             seanet.havehost = 1;
  1535.             seanet.nethost = 0;
  1536.             }
  1537.  
  1538.          if ((ntyp == 'G') || (ntyp == 'I'))
  1539.             {
  1540.             seanet.havegate = 1;
  1541.             seanet.netgate = node;
  1542.             }
  1543.          }
  1544.  
  1545.       /* Print out the Nodelist.Prn file */
  1546.       if ((!this_list) && (nodelist_prn != NULL) && !def)
  1547.          {
  1548.          ++prn_pg_lines;
  1549.  
  1550.          if (dphone && (dphone <= 3) && (prn_pg_lines >= 40))
  1551.             {
  1552.             header (1);
  1553.             prn_pg_lines = 4;
  1554.             }
  1555.  
  1556.          if (prn_pg_lines >= 60)
  1557.             {
  1558.             header (1);
  1559.             prn_pg_lines = 4;
  1560.             }
  1561.  
  1562.          fprintf (nodelist_prn,
  1563.                   "%-10.10s %4d %-20.20s %-20.20s %-25.25s %-20.20s %4d %-20.20s\n",
  1564.                   b1, n_num, b2, orig_phone, b3, b4, n_baud, p);
  1565.          }
  1566.  
  1567.       /* Print out the Nodelist.Txt file */
  1568.       if ((!this_list) && (nodelist_txt != NULL) && !def)
  1569.          {
  1570.          ++txt_pg_lines;
  1571.  
  1572.          if (dphone && (dphone <= 3) && (txt_pg_lines >= 40))
  1573.             {
  1574.             header (0);
  1575.             txt_pg_lines = 4;
  1576.             }
  1577.  
  1578.          if (txt_pg_lines >= 60)
  1579.             {
  1580.             header (0);
  1581.             txt_pg_lines = 4;
  1582.             }
  1583.  
  1584.          fprintf (nodelist_txt,
  1585.                   "%-10.10s %4d %-20.20s %-17.17s %-19.19s %4d\n",
  1586.                   b1, n_num, b2, orig_phone, b3, n_baud);
  1587.          }
  1588.  
  1589.       /* Print out the Fidouser.$$1 file */
  1590.       if (fidouser_$$1 != NULL)
  1591.          {
  1592.          /* Should we just be on our way? */
  1593.          if ((myzone > 0) && (myzone != addrs[0]) && (udata == 2))
  1594.             {
  1595.             continue;
  1596.             }
  1597.  
  1598.          how_likely (p, dphone, addrs, node, n_baud);
  1599.  
  1600.          /* If this is a bad place, make it horrible */
  1601.          if (hold || pvt || def)
  1602.             likely = 100;
  1603.  
  1604.          p = b4;
  1605.          b1[1] = b2[1] = b3[1] = b5[1] = '\0';
  1606.          p1 = b1;
  1607.          while ((*p) && (*p != '_'))
  1608.             {
  1609.             *p1++ = *p++;
  1610.             }
  1611.          *p1 = '\0';
  1612.  
  1613.          if (*p != '\0')
  1614.             ++p;
  1615.  
  1616.          p1 = b2;
  1617.          while ((*p) && (*p != '_'))
  1618.             {
  1619.             *p1++ = *p++;
  1620.             }
  1621.          *p1 = '\0';
  1622.  
  1623.          if (*p != '\0')
  1624.             ++p;
  1625.  
  1626.          p1 = b3;
  1627.          while ((*p) && (*p != '_'))
  1628.             {
  1629.             *p1++ = *p++;
  1630.             }
  1631.          *p1 = '\0';
  1632.  
  1633.          p1 = b5;
  1634.          while ((*p) && (*p != '_'))
  1635.             {
  1636.             *p1++ = *p++;
  1637.             }
  1638.          *p1 = '\0';
  1639.  
  1640.          if (*p == '_')
  1641.             continue;
  1642.  
  1643.          b5[0] = (char) toupper (b5[0]);
  1644.          b3[0] = (char) toupper (b3[0]);
  1645.          b2[0] = (char) toupper (b2[0]);
  1646.          b1[0] = (char) toupper (b1[0]);
  1647.          strlwr (&b5[1]);
  1648.          strlwr (&b3[1]);
  1649.          strlwr (&b2[1]);
  1650.          strlwr (&b1[1]);
  1651.          if (b5[0] != '\0')
  1652.             {
  1653.             sprintf (buff, "%s, %s %s %s", b5, b1, b2, b3);
  1654.             }
  1655.          else
  1656.          if (b3[0] != '\0')
  1657.             {
  1658.             sprintf (buff, "%s, %s %s", b3, b1, b2);
  1659.             }
  1660.          else
  1661.          if (b2[0] != '\0')
  1662.             {
  1663.             sprintf (buff, "%s, %s", b2, b1);
  1664.             }
  1665.          else
  1666.          if (b1[0] != '\0')
  1667.             {
  1668.             sprintf (buff, "%s", b1);
  1669.             }
  1670.          else
  1671.             {
  1672.             continue;
  1673.             }
  1674.          if ((myzone > 0) && (myzone != addrs[0]))
  1675.             {
  1676.             sprintf (b5, "%d:%d", addrs[0], addrs[2]);
  1677.             }
  1678.          else
  1679.             {
  1680.             sprintf (b5, "%d", addrs[2]);
  1681.             }
  1682.  
  1683.          fprintf (fidouser_$$1, "%-40.40s%13.13s/%-6d%5d\n", buff, b5, node, likely);
  1684.          }
  1685.       }
  1686.  
  1687. /*   close (f); */
  1688.    fclose (f);
  1689.    if (fn != NULL)
  1690.       fn = fn->next;
  1691. }
  1692.  
  1693. void header (int which)
  1694. {
  1695.    if (which == 1)
  1696.       {
  1697.       if (prn_pagenum != 0)
  1698.          {
  1699.          fprintf (nodelist_prn, " \n");
  1700.          }
  1701.       ++prn_pagenum;
  1702.       fprintf (nodelist_prn, "%s %d\n", prn_first_line, prn_pagenum);
  1703.       fprintf (nodelist_prn, "Type       Node Board's Name         Phone Number         City                      Sysop's Name         Baud Flags\n");
  1704.       fprintf (nodelist_prn, "====       ==== ============         ============         ====                      ============         ==== =====\n\n");
  1705.       }
  1706.    else if (which == 0)
  1707.       {
  1708.       if (txt_pagenum != 0)
  1709.          {
  1710.          fprintf (nodelist_txt, " \n");
  1711.          }
  1712.       ++txt_pagenum;
  1713.       fprintf (nodelist_txt, "%s %d\n", txt_first_line, txt_pagenum);
  1714.       fprintf (nodelist_txt, "Type       Node Board's Name         Phone Number      City                Baud\n");
  1715.       fprintf (nodelist_txt, "====       ==== ============         ============      ====                ====\n");
  1716.       }
  1717. }
  1718.  
  1719. /*
  1720. char mybuf[4097];
  1721. char *myptr = mybuf;
  1722. int got_tok;
  1723. get_data (buffer, f)
  1724. char *buffer;
  1725. int f;
  1726. {
  1727.    char *s;
  1728.    char *save;
  1729.    int n;
  1730.  
  1731.    s = NULL;
  1732.    if (got_tok)
  1733.       {
  1734.       s = strtok (NULL, "\n");
  1735.       }
  1736.  
  1737.    got_tok = 0;
  1738.    if (s != NULL)
  1739.       {
  1740.       save = myptr;
  1741.       myptr = s + strlen (s) + 1;
  1742.       if (myptr < mybuf + 4097)
  1743.          strcpy (buffer, s);
  1744.       else
  1745.          {
  1746.          s = NULL;
  1747.          myptr = save;
  1748.          }
  1749.       }
  1750.  
  1751.    if (s == NULL)
  1752.       {
  1753.       strcpy (buffer, myptr);
  1754.       if ((n = read (f, mybuf, 4096)) <= 0)
  1755.          return (1);
  1756.  
  1757.       mybuf[n] = '\0';
  1758.  
  1759.       myptr = mybuf;
  1760.       s = strtok (myptr, "\n");
  1761.       if (s == NULL)
  1762.          return (1);
  1763.  
  1764.       strcat (buffer, s);
  1765.       myptr = s + strlen (s) + 1;
  1766.       }
  1767.  
  1768.    got_tok = 1;
  1769.    return (0);
  1770. }
  1771. */
  1772.  
  1773.