home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 2 BBS / 02-BBS.zip / BSRCP250.LZH / BTCONFIG.C < prev    next >
Text File  |  1991-09-21  |  38KB  |  1,154 lines
  1. /*--------------------------------------------------------------------------*/
  2. /*                                                                          */
  3. /*                                                                          */
  4. /*      ------------         Bit-Bucket Software, Co.                       */
  5. /*      \ 10001101 /         Writers and Distributors of                    */
  6. /*       \ 011110 /          Freely Available<tm> Software.                 */
  7. /*        \ 1011 /                                                          */
  8. /*         ------                                                           */
  9. /*                                                                          */
  10. /*  (C) Copyright 1987-91, Bit Bucket Software Co., a Delaware Corporation. */
  11. /*                                                                          */
  12. /*                                                                          */
  13. /*               This module was written by Vince Perriello                 */
  14. /*                                                                          */
  15. /*                                                                          */
  16. /*                  BinkleyTerm Configuration File Parser                   */
  17. /*                                                                          */
  18. /*                                                                          */
  19. /*    For complete  details  of the licensing restrictions, please refer    */
  20. /*    to the License  agreement,  which  is published in its entirety in    */
  21. /*    the MAKEFILE and BT.C, and also contained in the file LICENSE.250.    */
  22. /*                                                                          */
  23. /*    USE  OF THIS FILE IS SUBJECT TO THE  RESTRICTIONS CONTAINED IN THE    */
  24. /*    BINKLEYTERM  LICENSING  AGREEMENT.  IF YOU DO NOT FIND THE TEXT OF    */
  25. /*    THIS  AGREEMENT IN ANY OF THE  AFOREMENTIONED FILES,  OR IF YOU DO    */
  26. /*    NOT HAVE THESE FILES,  YOU  SHOULD  IMMEDIATELY CONTACT BIT BUCKET    */
  27. /*    SOFTWARE CO.  AT ONE OF THE  ADDRESSES  LISTED BELOW.  IN NO EVENT    */
  28. /*    SHOULD YOU  PROCEED TO USE THIS FILE  WITHOUT HAVING  ACCEPTED THE    */
  29. /*    TERMS  OF  THE  BINKLEYTERM  LICENSING  AGREEMENT,  OR  SUCH OTHER    */
  30. /*    AGREEMENT AS YOU ARE ABLE TO REACH WITH BIT BUCKET SOFTWARE, CO.      */
  31. /*                                                                          */
  32. /*                                                                          */
  33. /* You can contact Bit Bucket Software Co. at any one of the following      */
  34. /* addresses:                                                               */
  35. /*                                                                          */
  36. /* Bit Bucket Software Co.        FidoNet  1:104/501, 1:343/491             */
  37. /* P.O. Box 460398                AlterNet 7:491/0                          */
  38. /* Aurora, CO 80046               BBS-Net  86:2030/1                        */
  39. /*                                Internet f491.n343.z1.fidonet.org         */
  40. /*                                                                          */
  41. /* Please feel free to contact us at any time to share your comments about  */
  42. /* our software and/or licensing policies.                                  */
  43. /*                                                                          */
  44. /*--------------------------------------------------------------------------*/
  45.  
  46. /* Include this file before any other includes or defines! */
  47.  
  48. #include "includes.h"
  49.  
  50. char *ctl_slash_string (char *);
  51. static int Zone = 1;
  52.  
  53. void cfg_macro (char *);
  54. void cfg_dial_string (char *);
  55. void cfg_mdm_trans (char *);
  56. void cfg_domain (char *);
  57. void cfg_Janus (char *);
  58.  
  59. void parse_config (char *config_file)
  60. {
  61.    FILE *stream;
  62.    char temp[256];
  63.    char *c;
  64.    int i;
  65.    unsigned temp_num;
  66.    char *p;
  67.    ADDR temp_addr;                               /* Used to get address */
  68.  
  69.    (void) sprintf (temp, "%s%s", BINKpath, config_file);
  70.    if ((stream = share_fopen (temp, "rt", DENY_WRITE)) == NULL)     /* OK, let's open the file   */
  71.       return;                                    /* no file, no work to do    */
  72.  
  73.    while ((fgets (temp, 255, stream)) != NULL)   /* Now we parse the file ... */
  74.       {
  75.       c = temp;                                  /* Check out the first char  */
  76.       if ((*c == '%') || (*c == ';'))            /* See if it's a comment
  77.                                                   * line */
  78.          continue;
  79.  
  80.       i = (int) strlen (temp);                         /* how long this line is     */
  81.  
  82.       if (i < 3)
  83.          continue;                               /* If too short, ignore it   */
  84.  
  85.       c = &temp[--i];                            /* point at last character   */
  86.       if (*c == '\n')                            /* if it's a newline,        */
  87.          *c = '\0';                              /* strip it off              */
  88.  
  89.       if ((i = parse (temp, config_lines)) != 0)
  90.          {
  91.          c = &temp [(config_lines [i - 1]).p_length];
  92.          }
  93.  
  94.       switch (i)
  95.          {
  96.          case 1:                                /* "SameRing"      */
  97.             modemring = 1;
  98.             break;
  99.  
  100.          case 2:                                /* "NewNodeList"   */
  101.          case 129:                              /* "Version6"      */
  102.             newnodelist = 1;
  103.             break;
  104.  
  105.          case 3:                                /* "QuickNodeList" */
  106. #ifdef QUICK_LIST
  107.             nodefunc = QuickLookup;
  108.             newnodelist = 0;
  109. #endif
  110.             break;
  111.  
  112.          case 4:                                /* "Answerback"  */
  113.             answerback = ctl_string (c);
  114.             break;
  115.  
  116.          case 5:                                /* "Macro"         */
  117.             cfg_macro (c);
  118.             break;
  119.  
  120.          case 6:                                /* "Shell"        */
  121.             c = skip_blanks (c);
  122.             i = atoi (c);
  123.             if ((i <= 0) || (i > 9))
  124.                {
  125.                (void) printf ("%s %d %s\n", MSG_TXT(M_SHELL_NUMBER), i, MSG_TXT(M_OUT_OF_RANGE));
  126.                break;
  127.                }
  128.             c = skip_to_blank (c);
  129.             c = skip_blanks (c);
  130.             shells[i - 1] = calloc (1, strlen (c) + 1);
  131.             (void) strcpy (shells[i - 1], c);
  132.             (void) strupr (shells[i - 1]);
  133.             break;
  134.  
  135.          case 7:                                /* "Dial"         */
  136.             cfg_dial_string (c);
  137.             break;
  138.  
  139.          case 8:                                /* "Event"        */
  140.             c = skip_blanks (c);
  141.             (void) parse_event (c);
  142.             break;
  143.  
  144.          case 9:                                /* "Zone"         */
  145.             c = skip_blanks (c);
  146.             Zone = atoi (c);
  147.             if (!Zone)                          /* if we didn't find a zone  */
  148.                (void) printf (MSG_TXT(M_ILLEGAL_ZONE), &temp[4]);
  149.             break;
  150.  
  151.          case 10:                               /* "MaxReq"       */
  152.             (void) sscanf (c, "%d %d", &DEFAULT.rq_Limit, &DEFAULT.rq_Cum_Limit);
  153.             if (!DEFAULT.rq_Limit)              /* No requests??? */
  154.                (void) printf ("0 %s\n", MSG_TXT(M_REQUESTS_ALLOWED));
  155.             break;
  156.  
  157.          case 11:                               /* "LogLevel"     */
  158.             c = skip_blanks (c);
  159.             i = atoi (c);
  160.             if ((i <= 5) && (i > 0))
  161.                {
  162.                loglevel = i;
  163.                }
  164.             else
  165.                {
  166.                (void) printf (MSG_TXT(M_BAD_LOGLEVEL), &temp[8]);
  167.                }
  168.             break;
  169.  
  170.          case 12:                               /* "Baud"         */
  171.             temp_num = (unsigned int) atoi (c);
  172.             max_baud.rate_value = 0;
  173.             for (i = 0; btypes[i].rate_value; i++)
  174.                {
  175.                if (btypes[i].rate_value == temp_num)
  176.                   {
  177.                   max_baud.rate_mask = btypes[i].rate_mask;
  178.                   max_baud.rate_value = temp_num;
  179.                   break;
  180.                   }
  181.                }
  182.             if (!max_baud.rate_value)
  183.                goto bad_line;
  184.             break;
  185.  
  186.          case 13:                               /* "MaxPort"      */
  187.             c = skip_blanks (c);
  188.             i = atoi (c);                        /* make it binary            */
  189.             if ((i > 0) && (i < 33))             /* if range is reasonable,   */
  190.                MAXport = i;                      /* Make it the max value     */
  191.             else
  192.                (void) printf (MSG_TXT(M_BAD_MAXPORT), &temp[7]);
  193.             break;
  194.  
  195.          case 14:                               /* "Port"         */
  196.             c = skip_blanks (c);
  197.             i = atoi (c);                        /* make it binary            */
  198.             if ((i > 0) || (i < 33))             /* see if it's OK            */
  199.                {
  200.                port_ptr = i - 1;                 /* store it if so            */
  201.                if (MAXport < i)                  /* See if MAXport is less    */
  202.                   MAXport = i;                   /* If so, increase MAXport   */
  203.                original_port = port_ptr;
  204.                }
  205.             else
  206.                (void) printf (MSG_TXT(M_ILLEGAL_PORT), &temp[4]);
  207.             break;
  208.  
  209.          case 15:                               /* "Carrier"      */
  210.             c = skip_blanks (c);
  211.             i = 0;
  212.             (void) sscanf (c, "%x", &i);         /* convert it to binary      */
  213.             if (i != 0)                          /* if we got anything        */
  214.                carrier_mask = (unsigned int) i;
  215.             else
  216.                (void) printf (MSG_TXT(M_ILLEGAL_CARRIER), &temp[7]);
  217.             break;
  218.  
  219.          case 16:                               /* "StatusLog"    */
  220.             log_name = ctl_string (c);
  221.             if ((status_log = share_fopen (log_name, "at", DENY_WRITE)) == NULL)
  222.                {
  223.                free (log_name);
  224.                log_name = NULL;
  225.                }
  226.             else
  227.                {
  228.                (void) fprintf (status_log, "\n");
  229.                (void) fflush (status_log);
  230.                (void) real_flush (fileno (status_log));
  231.                }
  232.             break;
  233.  
  234.          case 17:                               /* "Reader"       */
  235.             BBSreader = ctl_string (c);
  236.             break;
  237.  
  238.          case 18:                               /* "BossPhone"    */
  239.             BOSSphone = ctl_string (c);
  240.             break;
  241.  
  242.          case 19:                               /* "BossPwd"      */
  243.             BOSSpwd = ctl_string (c);
  244.             break;
  245.  
  246.          case 20:                               /* "Protocol"     */
  247.             if (extern_index == 5)
  248.                break;
  249.             protocols[extern_index++] = ctl_string (c);
  250.             break;
  251.  
  252.          case 21:                               /* "System"       */
  253.             system_name = ctl_string (c);
  254.             break;
  255.  
  256.          case 22:                               /* "Sysop"        */
  257.             sysop = ctl_string (c);
  258.             break;
  259.  
  260.          case 23:                               /* "Boss"         */
  261.             c = skip_blanks (c);
  262.             (void) parse_address (c, &boss_addr);
  263.             break;
  264.  
  265.          case 24:                               /* "Point"        */
  266.          case 25:                               /* "Aka"          */
  267.          case 94:                               /* "Address"      */
  268.             c = skip_blanks (c);
  269.             if (num_addrs == 0)
  270.                alias[0].Zone = Zone;
  271.             (void) parse_address (c, &temp_addr);
  272.             alias[num_addrs] = temp_addr;
  273.             Zone = (int) alias[0].Zone;         /* First is real default */
  274.             ++num_addrs;
  275.             break;
  276.  
  277.          case 26:                               /* "Hold"         */
  278.             hold_area = ctl_slash_string (c);
  279.             domain_area = strdup (hold_area);
  280.  
  281.             domain_area[strlen (domain_area) - 1] = '\0';
  282.             p = strrchr (domain_area, '\\');
  283.             if (p == NULL)
  284.                {
  285.                p = strrchr (domain_area, '/');
  286.                if (p == NULL)
  287.                   {
  288.                   p = strrchr (domain_area, ':');
  289.                   if (p == NULL)
  290.                      p = domain_area;
  291.                   }
  292.                }
  293.             if (p != domain_area)
  294.                ++p;
  295.  
  296.             domain_loc = p;
  297.             *p = '\0';
  298.             break;
  299.  
  300.          case 27:                               /* "DownLoads"    */
  301.             download_path = ctl_slash_string (c);
  302.             break;
  303.  
  304.          case 28:                               /* "NetFile"      */
  305.             DEFAULT.sc_Inbound = ctl_slash_string (c);
  306.             break;
  307.  
  308.          case 29:                               /* "Init"         */
  309.             modem_init = ctl_string (c);
  310.             break;
  311.  
  312.          case 30:                               /* "Busy"         */
  313.             modem_busy = ctl_string (c);
  314.             break;
  315.  
  316.          case 31:                               /* "Prefix"       */
  317.             predial = ctl_string (c);
  318.             normprefix = predial;
  319.             break;
  320.  
  321.          case 32:                               /* "NodeList"     */
  322.             net_info = ctl_slash_string (c);
  323.             break;
  324.  
  325.          case 33:                               /* "Avail"        */
  326.             DEFAULT.rq_FILES = ctl_string (c);
  327.             break;
  328.  
  329.          case 34:                               /* "OKFile"       */
  330.             DEFAULT.rq_OKFile = ctl_string (c);
  331.             break;
  332.  
  333.          case 35:                               /* "About"        */
  334.             DEFAULT.rq_About = ctl_string (c);
  335.             break;
  336.  
  337.          case 36:                               /* "MAILnote"     */
  338.             MAILnote = ctl_string (c);
  339.             break;
  340.  
  341.          case 37:                               /* "Banner"       */
  342.             BBSbanner = ctl_string (c);
  343.             break;
  344.  
  345.          case 38:                               /* "UnAttended"   */
  346.             un_attended = 1;
  347.             command_line_un = 1;
  348.             break;
  349.  
  350.          case 39:                               /* "OverWrite"    */
  351.             overwrite = 1;
  352.             break;
  353.  
  354.          case 40:                               /* "Rev3"         */
  355.             rev3 = 1;
  356.             break;
  357.  
  358.          case 41:                               /* "ReqOnUs"      */
  359.             on_our_nickel = 1;
  360.             break;
  361.  
  362.          case 42:                               /* "LockBaud"     */
  363.             c = skip_blanks (c);                /* Skip to baud   */
  364.  
  365.             if (*c == '\0')                     /* Case 1: no arg */
  366.                {
  367.                lock_baud = 1;                   /* Always lock    */
  368.                break;
  369.                }
  370.  
  371.             if (isdigit (*c))                   /* Case 2: baud   */
  372.                {
  373.                lock_baud = (unsigned)(atoi (c));/* Lock at >= baud*/
  374.                break;
  375.                }
  376.  
  377.             i = 1 + strlen (c);                 /* Case 3: ARQ    */
  378.             if (ARQs > 16)                      /* Only 16 allowed*/
  379.                break;
  380.             p = calloc (1, i);                  /* Allocate space */
  381.             if (p == NULL)                      /* Give up if none*/
  382.                break;
  383.             (void) strcpy (p, c);               /* Copy ARQ string*/
  384.             ARQ[ARQs++] = p;                    /* Update array   */
  385.             break;
  386.  
  387.  
  388.          case 43:                               /* "TimeOut"      */
  389.             c = skip_blanks (c);
  390.             BBStimeout = (unsigned) (atoi (c) * 100);
  391.             if (BBStimeout < 2000)
  392.                BBStimeout = 2000;
  393.             break;
  394.  
  395.          case 44:                               /* "NoSLO"        */
  396.             no_overdrive = 1;
  397.             break;
  398.  
  399.          case 45:                               /* "SlowModem"    */
  400.             slowmodem = 1;
  401.             break;
  402.  
  403.          case 46:                               /* "SmallWindow"  */
  404.             small_window = 1;
  405.             break;
  406.  
  407.          case 47:                               /* "NoPickup"     */
  408.             no_pickup = 1;
  409.             break;
  410.  
  411.          case 48:                               /* "NoRequests"   */
  412.             no_requests = 1;
  413.             break;
  414.  
  415.          case 49:                               /* "NetMail"      */
  416.             netmail = ctl_slash_string(c);
  417.             break;                              /* for BTCTL & MAIL.SYS */
  418.  
  419.          case 50:                               /* "Suffix"       */
  420.             postdial = ctl_string (c);
  421.             normsuffix = postdial;
  422.             break;
  423.  
  424.          case 51:                               /* "NoFullScreen" */
  425. #ifndef MILQ
  426.             fullscreen = 0;
  427. #endif
  428.             break;
  429.  
  430.          case 52:                               /* "AutoBaud"     */
  431.             autobaud = 1;
  432.             break;
  433.  
  434.          case 53:                               /* "Gong"         */
  435.             gong_allowed = 1;
  436.             break;
  437.  
  438.          case 54:                               /* "NoCollide"    */
  439.             no_collide = 1;
  440.             break;
  441.  
  442.          case 55:                               /* "TBBSlist"     */
  443. #ifdef OLDTBBSLIST
  444.             nodefunc = TBBSLookup;
  445.             newnodelist = 0;
  446. #endif
  447.             break;
  448.  
  449.          case 56:                               /* "TaskView"     */
  450.          case 57:                               /* "TopView"      */
  451.             have_tv = 1;
  452.             break;
  453.  
  454.          case 58:                               /* "ExtrnMail"    */
  455.             c = skip_blanks (c);
  456.             if (isdigit (*c))
  457.                {
  458.                lev_ext_mail[num_ext_mail] = atoi (c);
  459.                while ((*c) && (!isspace (*c)))
  460.                   ++c;
  461.                }
  462.             else
  463.                {
  464.                lev_ext_mail[num_ext_mail] = 99;
  465.                }
  466.             ext_mail_string[num_ext_mail++] = ctl_string (c);
  467.             break;
  468.  
  469.          case 59:                               /* "BBSnote"      */
  470.             BBSnote = ctl_string (c);
  471.             break;
  472.  
  473.          case 60:                               /* "BBS"          */
  474.             BBSopt = ctl_string (c);
  475.             break;
  476.  
  477.          case 61:                               /* "ScriptPath"   */
  478.             script_path = ctl_slash_string (c);
  479.             break;
  480.  
  481.          case 62:                               /* "BoxType"      */
  482.             c = skip_blanks (c);
  483.             boxtype = atoi (c);
  484.             if ((boxtype > 4) || (boxtype < 0))
  485.                boxtype = 1;
  486.             break;
  487.  
  488.          case 63:                               /* "MultiLink"    */
  489.             have_ml = 1;
  490.             break;
  491.  
  492.          case 64:                               /* "Include"      */
  493.             c = skip_blanks (c);
  494.             parse_config (c);
  495.             break;
  496.  
  497.          case 65:                               /* "CaptureFile"  */
  498.             logptr = ctl_string (c);
  499.             break;
  500.  
  501.          case 66:                               /* "CursorCol"    */
  502.             c = skip_blanks (c);
  503.             cursor_col = atoi (c) - 1;
  504.             break;
  505.  
  506.          case 67:                               /* "CursorRow"    */
  507.             c = skip_blanks (c);
  508.             cursor_row = atoi (c) - 1;
  509.             break;
  510.  
  511.          case 68:                               /* "DoingMail"    */
  512.             c = skip_blanks (c);
  513.             (void) sprintf (junk, "\r\r%s\r\r", c);
  514.             noBBS = calloc (1, strlen (junk) + 1);
  515.             (void) strcpy (noBBS, junk);
  516.             break;
  517.  
  518.          case 69:                               /* "EnterBBS"     */
  519.             c = skip_blanks (c);
  520.             (void) sprintf (junk, "\r%s\r", c);
  521.             BBSesc = calloc (1, strlen (junk) + 1);
  522.             (void) strcpy (BBSesc, junk);
  523.             break;
  524.  
  525.          case 70:                               /* "PrivateNet"   */
  526.             c = skip_blanks (c);
  527.             pvtnet = atoi (c);
  528.             break;
  529.  
  530.          case 71:                               /* "Packer"       */
  531.             packer = ctl_string (c);
  532.             break;
  533.  
  534.          case 72:                               /* "Cleanup"      */
  535.             cleanup = ctl_string (c);
  536.             break;
  537.  
  538.          case 73:                               /* "AfterMail"    */
  539.             aftermail = ctl_string (c);
  540.             break;
  541.  
  542.          case 74:                               /* "Colors"       */
  543.             sscanf (c, "%d %d %d %d %d %d %d %d",
  544.                   &colors.background, &colors.settings, &colors.history,
  545.                   &colors.hold, &colors.call, &colors.file,
  546.                   &colors.calling, &colors.popup);
  547.             break;
  548.  
  549.          case 75:                               /* "JanusBaud"    */
  550.             c = skip_blanks (c);
  551.             janus_baud = (unsigned) atoi(c);
  552.             break;
  553.  
  554.          case 76:                               /* "ReqTemplate"  */
  555.             DEFAULT.rq_Template = ctl_string (c);
  556.             break;
  557.  
  558.          case 77:                               /* "KnownAvail"   */
  559.             KNOWN.rq_FILES = ctl_string(c);
  560.             break;
  561.  
  562.          case 78:                               /* "KnownReqList" */
  563.             KNOWN.rq_OKFile = ctl_string(c);
  564.             break;
  565.  
  566.          case 79:                               /* "KnownAbout"   */
  567.             KNOWN.rq_About = ctl_string (c);
  568.             break;
  569.  
  570.          case 80:                               /* "KnownInbound" */
  571.             KNOWN.sc_Inbound = ctl_slash_string (c);
  572.             break;
  573.  
  574.          case 81:                               /* "KnownReqLim"  */
  575.             (void) sscanf (c, "%d %d", &KNOWN.rq_Limit, &KNOWN.rq_Cum_Limit);
  576.             break;
  577.  
  578.          case 82:                               /* "KnownReqTpl"  */
  579.             KNOWN.rq_Template = ctl_string (c);
  580.             break;
  581.  
  582.          case 83:                               /* "ProtAvail"   */
  583.             PROT.rq_FILES = ctl_string(c);
  584.             break;
  585.  
  586.          case 84:                               /* "ProtReqList" */
  587.             PROT.rq_OKFile = ctl_string(c);
  588.             break;
  589.  
  590.          case 85:                               /* "ProtAbout"   */
  591.             PROT.rq_About = ctl_string (c);
  592.             break;
  593.  
  594.          case 86:                               /* "ProtInbound" */
  595.             PROT.sc_Inbound = ctl_slash_string (c);
  596.             break;
  597.  
  598.          case 87:                               /* "ProtReqLim"  */
  599.             (void) sscanf (c, "%d %d", &PROT.rq_Limit, &PROT.rq_Cum_Limit);
  600.             break;
  601.  
  602.          case 88:                               /* "ProtReqTpl"  */
  603.             PROT.rq_Template = ctl_string (c);
  604.             break;
  605.  
  606.          case 89:                               /* "Application" */
  607.             break;
  608.  
  609.          case 90:                               /* "NoZones"     */
  610.             no_zones = 1;
  611.             break;
  612.  
  613.          case 91:                               /* "Answer"        */
  614.             ans_str = ctl_string (c);
  615.             break;
  616.  
  617.          case 92:                               /* "PollTries"   */
  618.             c = skip_blanks (c);
  619.             poll_tries = atoi (c);
  620.             break;
  621.  
  622.          case 93:                               /* "SwapDir"     */
  623.             c = skip_blanks (c);
  624.             i = (int) strlen (c);
  625.             swapdir = calloc (1, i + 2);
  626.             (void) strcpy (swapdir, c);
  627.             (void) add_backslash (swapdir);
  628.             break;
  629.  
  630.          case 95:                               /* "Curmudgeon"  */
  631.             ++curmudgeon;                       /* Do it like Randy */
  632.             break;
  633.  
  634.          case 96:                               /* "NoWaZOO"     */
  635.             no_WaZOO_Session = ++no_WaZOO;      /* FTSC sessions */
  636.             break;
  637.  
  638.          case 97:                               /* "ScreenBlank" */
  639.             do_screen_blank = 1;
  640.             p = skip_blanks (c);
  641.             if (strnicmp (p, MSG_TXT(M_KEY), 3) == 0)
  642.                {
  643.                blank_on_key = 1;
  644.                }
  645.             else if (strnicmp (p, MSG_TXT(M_CALL), 4) == 0)
  646.                {
  647.                blank_on_key = 0;
  648.                }
  649.             break;
  650.  
  651.          case 98:                               /* "Mark_Kromm"  */
  652.  
  653.             /* These colors from Mark Kromm, Fidonet 1:261/1034  */
  654.  
  655.             colors.background = 112;            /* The           */
  656.             colors.settings   =   9;            /* Great         */
  657.             colors.history    =  10;            /* BinkleyTerm   */
  658.             colors.hold       =  11;            /* Colors        */
  659.             colors.call       =  14;            /* Contest       */
  660.             colors.file       =  12;            /* Winner!!!!    */
  661.             colors.calling    =  56;
  662.             colors.popup      =  15;
  663.             break;
  664.  
  665.          case 99:                               /* "Server"      */
  666.             server_mode = 1;
  667.             break;
  668.  
  669.          case 100:                              /* "ModemTrans"  */
  670.             cfg_mdm_trans (c);
  671.             break;
  672.  
  673.          case 101:                              /* "PreDial" */
  674.             dial_setup = ctl_string (c);
  675.             break;
  676.  
  677.          case 102:                              /* "PreInit" */
  678.             init_setup = ctl_string (c);
  679.             break;
  680.  
  681.          case 103:                              /* "DTRHigh" */
  682.             leave_dtr_high = 1;
  683.             break;
  684.  
  685.          case 104:                              /* "Debug" */
  686.             debugging_log = !debugging_log;
  687.             break;
  688.  
  689.          case 105:                              /* "NoZedZap" */
  690.             no_zapzed = !no_zapzed;
  691.             break;
  692.  
  693.          case 106:                              /* "NoResync" */
  694.             no_resync = !no_resync;
  695.             break;
  696.  
  697.          case 107:                              /* "NoSEAlink" */
  698.             no_sealink = !no_sealink;
  699.             break;
  700.  
  701.          case 108:                              /* "FTS-0001" */
  702.             no_sealink = 1;
  703.             no_resync = 1;
  704.             no_overdrive = 1;
  705.             ++no_WaZOO;                         /* FTSC sessions */
  706.             break;
  707.  
  708.          case 109:                              /* "LineUpdate" */
  709.             immed_update = !immed_update;
  710.             break;
  711.  
  712.          case 110:                              /* "JanusOK"      */
  713.             cfg_Janus (c);
  714.             break;
  715.  
  716.          case 111:                              /* "TermInit"     */
  717.             term_init = ctl_string (c);
  718.             break;
  719.  
  720.          case 112:                              /* "Domain"       */
  721.             cfg_domain (c);
  722.             break;
  723.  
  724.          case 113:                               /* "Snoop"        */
  725. #ifdef Snoop
  726.             if (getenv("SNOOPPIPE") == NULL)
  727.                 {
  728.                 strcpy(pipename, skip_blanks(c));
  729.                 if (pipename[0] != '\0')
  730.                    snoop_open(pipename);
  731.                 }
  732. #endif /* Snoop */
  733.             break;
  734.  
  735.          case 114:                               /* "Flags"        */
  736.             flag_dir = ctl_slash_string (c);
  737.             break;
  738.  
  739.          case 115:                               /* "Tasknumber"   */
  740.             c = skip_blanks (c);
  741.             TaskNumber = atoi (c);
  742.             break;
  743.  
  744.          case 116:                               /* "MaxBytes"     */
  745.             (void) sscanf (c, "%ld %ld", &DEFAULT.byte_Limit, &DEFAULT.byte_Cum_Limit);
  746.             break;
  747.  
  748.          case 117:                               /* "KnownMaxBytes"*/
  749.             (void) sscanf (c, "%ld %ld", &KNOWN.byte_Limit, &KNOWN.byte_Cum_Limit);
  750.             break;
  751.  
  752.          case 118:                               /* "ProtMaxBytes" */
  753.             (void) sscanf (c, "%ld %ld", &PROT.byte_Limit, &PROT.byte_Cum_Limit);
  754.             break;
  755.  
  756.          case 119:                               /* "StartBlkLen"  */
  757.             c = skip_blanks (c);
  758.             fstblklen = atoi (c);
  759.             if ((fstblklen < 64) || (fstblklen > 2048))
  760.                fstblklen = 1024;
  761.             break;
  762.  
  763.          case 120:                               /* "MaxTime"      */
  764.             (void) sscanf (c, "%d %ld", &DEFAULT.time_Limit, &DEFAULT.time_Cum_Limit);
  765.             DEFAULT.time_Limit *= 60;
  766.             DEFAULT.time_Cum_Limit *= 60;
  767.             break;
  768.  
  769.          case 121:                               /* "KnownMaxTime" */
  770.             (void) sscanf (c, "%d %ld", &KNOWN.time_Limit, &KNOWN.time_Cum_Limit);
  771.             KNOWN.time_Limit *= 60;
  772.             KNOWN.time_Cum_Limit *= 60;
  773.             break;
  774.  
  775.          case 122:                               /* "ProtMaxTime"  */
  776.             (void) sscanf (c, "%d %ld", &PROT.time_Limit, &PROT.time_Cum_Limit);
  777.             PROT.time_Limit *= 60;
  778.             PROT.time_Cum_Limit *= 60;
  779.             break;
  780.  
  781.          case 123:                               /* "RingTries"    */
  782.             c = skip_blanks (c);
  783.             ring_tries = atoi (c);
  784.             break;
  785.  
  786.          case 124:                               /* "NoSharing"    */
  787.             no_sharing = 1;
  788.             break;
  789.  
  790.          case 125:                               /* "Version7"     */
  791.             version7 = 1;
  792.             nodefunc = ver7find;
  793.             userfunc = opususer;
  794.             newnodelist = 0;
  795.             break;
  796.  
  797.          case 126:                               /* "BlankWait"    */
  798.             c = skip_blanks (c);
  799.             blank_time = (unsigned int)100 * (unsigned int)atoi (c);
  800.             break;
  801.  
  802.          case 127:                               /* "Serial"       */
  803.             c = skip_blanks (c);
  804.             if (isdigit (*c))
  805.                serial = atoi (c);
  806.             break;
  807.  
  808.          case 128:                               /* "NoDietIfna"   */
  809.             no_dietifna = 1;
  810.             break;
  811.  
  812.          case 130:
  813.             winslice = 1;                        /* "WinSlice"     */
  814.             break;
  815.  
  816.          case 131:                               /* "NoSize"       */
  817.             no_size = 1;
  818.             break;
  819.  
  820. bad_line:
  821.          default:
  822.             (void) printf (MSG_TXT(M_UNKNOWN_LINE), temp);
  823.          }
  824.       }
  825.    (void) fclose (stream);                       /* close input file */
  826.  
  827.    if (debugging_log)
  828.       loglevel = 6;
  829. }
  830.  
  831. char *ctl_string (char *source)                  /* malloc & copy to ctl      */
  832. {
  833.    char *dest, *c;
  834.    int i;
  835.  
  836.    c = skip_blanks (source);                     /* get over the blanks       */
  837.    i = (int) strlen (c);                         /* get length of remainder   */
  838.    if (i < 1)                                    /* must have at least 1      */
  839.       return (NULL);                             /* if not, return NULL       */
  840.    dest = calloc (1, (unsigned int) (++i));      /* allocate space for string */
  841.    if (dest == NULL)                             /* If we failed to get it,   */
  842.       return (NULL);                             /* Just return NULL          */
  843.    (void) strcpy (dest, c);                      /* copy the stuff over       */
  844.    return (dest);                                /* and return the address    */
  845. }
  846.  
  847. char *ctl_slash_string (char *source)            /* malloc & copy to ctl      */
  848. {
  849.    char *dest, *c;
  850.    int i;
  851.    struct stat buffer;
  852.  
  853.    c = skip_blanks (source);                     /* get over the blanks       */
  854.    i = (int) strlen (c);                         /* get length of remainder   */
  855.    if (i < 1)                                    /* must have at least 1      */
  856.       return (NULL);                             /* if not, return NULL       */
  857.    dest = calloc (1, (unsigned int) (i+2));      /* allocate space for string */
  858.    if (dest == NULL)                             /* If we failed to get it,   */
  859.       return (NULL);                             /* Just return NULL          */
  860.    (void) strcpy (dest, c);                      /* copy the stuff over       */
  861.    (void) delete_backslash (dest);               /* get rid of trailing stuff */
  862.    /* Check to see if the directory exists */
  863.    i = stat (dest, &buffer);
  864.    if (i || (!(buffer.st_mode & S_IFDIR)))
  865.       {
  866.       (void) printf (MSG_TXT(M_BAD_DIR), dest);
  867.       (void) printf (MSG_TXT(M_FAIL_EXEC));
  868.       return(NULL);
  869.       }
  870.    (void) add_backslash (dest);                         /* add the backslash         */
  871.    return (dest);                                /* return the directory name */
  872. }
  873.  
  874.  
  875. char *add_backslash (char *str)
  876. {
  877.    char *p;
  878.  
  879.    p = str + strlen (str) - 1;
  880.  
  881.    if (p >= str)
  882.       {
  883.       /* Strip off the trailing blanks */
  884.       while ((p >= str) && (isspace (*p)))
  885.          {
  886.          *p = '\0';
  887.          --p;
  888.          }
  889.  
  890.       /* Put a backslash if there isn't one */
  891.       if ((p >=str) && (*p != '\\') && (*p != '/'))
  892.          {
  893.          *(++p) = '\\';
  894.          *(++p) = '\0';
  895.          }
  896.       }
  897.  
  898.    return (fancy_str (str));
  899. }
  900.  
  901. char *delete_backslash (char *str)
  902. {
  903.    char *p;
  904.  
  905.    p = str + strlen (str) - 1;
  906.  
  907.    if (p >= str)
  908.       {
  909.       /* Strip off the trailing blanks */
  910.       while ((p >= str) && (isspace (*p)))
  911.          {
  912.          *p = '\0';
  913.          --p;
  914.          }
  915.  
  916.       /* Get rid of backslash if there is one */
  917.       if ((p >=str) && ((*p == '\\') || (*p == '/')))
  918.          {
  919.          if ((p > str) && (*(p-1) != ':'))      /* Don't delete on root */
  920.             *p = '\0';
  921.          }
  922.       }
  923.  
  924.    return (fancy_str (str));
  925. }
  926.  
  927. void cfg_macro (char *c)
  928. {
  929.    int i;
  930.    char *p;
  931.  
  932.    c = skip_blanks (c);
  933.    i = atoi (c);
  934.    if ((i <= 0) || (i > 9))
  935.       {
  936.       (void) printf ("%s %d %s\n", MSG_TXT(M_MACRO_NUMBER), i, MSG_TXT(M_OUT_OF_RANGE));
  937.       return;
  938.       }
  939.    c = skip_to_blank (c);
  940.    c = skip_blanks (c);
  941.    keys[i - 1] = calloc (1, strlen (c) + 1);
  942.    p = keys[i - 1];
  943.    while (*c && (*c != '\n'))
  944.       {
  945.       if (*c == '|')
  946.          *p++ = '\r';
  947.       else *p++ = *c;
  948.       ++c;
  949.       }
  950.    *p = '\0';
  951. }
  952.  
  953. void cfg_dial_string (char *c)
  954. {
  955.    char *p, *p1;
  956.    PN_TRNS *tpn;
  957.  
  958.    p = c;
  959.    while ((*p) && (isspace (*p)))
  960.       ++p;
  961.  
  962.    if ((*p == ';') || (*p == '\0'))
  963.       {
  964.       return;
  965.       }
  966.  
  967.    tpn = (PN_TRNS *) calloc (1, sizeof (PN_TRNS));
  968.  
  969.    p1 = tpn->num;
  970.    while ((*p) && (!isspace (*p)))
  971.       {
  972.       *p1++ = *p++;
  973.       }
  974.    *p1 = '\0';
  975.  
  976.    while ((*p) && (isspace (*p)))
  977.       {
  978.       ++p;
  979.       }
  980.  
  981.    p1 = tpn->pre;
  982.    while ((*p) && (*p != '/') && (!isspace (*p)))
  983.       {
  984.       *p1++ = *p++;
  985.       }
  986.    *p1 = '\0';
  987.  
  988.    p1 = tpn->suf;
  989.    if ((*p == '\0') || (isspace (*p)))
  990.       {
  991.       *p1 = '\0';
  992.       }
  993.    else
  994.       {
  995.       ++p;
  996.  
  997.       while ((*p) && (!isspace (*p)))
  998.          {
  999.          *p1++ = *p++;
  1000.          }
  1001.       *p1 = '\0';
  1002.       }
  1003.  
  1004.    tpn->len = (int) strlen (tpn->num);
  1005.    tpn->next = NULL;
  1006.    if (pn_head == NULL)
  1007.       {
  1008.       pn_head = tpn;
  1009.       }
  1010.    else
  1011.       {
  1012.       pn->next = tpn;
  1013.       }
  1014.    pn = tpn;
  1015. }
  1016.  
  1017. void cfg_mdm_trans (char *c)
  1018. {
  1019.    char *p, *p1;
  1020.    MDM_TRNS *tmm;
  1021.  
  1022.    p = c;
  1023.    while ((*p) && (isspace (*p)))
  1024.       ++p;
  1025.  
  1026.    if ((*p == ';') || (*p == '\0'))
  1027.       {
  1028.       return;
  1029.       }
  1030.  
  1031.    tmm = (MDM_TRNS *) calloc (1, sizeof (MDM_TRNS));
  1032.  
  1033.    tmm->mdm = (byte) atoi (p);
  1034.    while ((*p) && (!isspace (*p)))
  1035.       {
  1036.       p++;
  1037.       }
  1038.  
  1039.    while ((*p) && (isspace (*p)))
  1040.       {
  1041.       ++p;
  1042.       }
  1043.  
  1044.    p1 = tmm->pre;
  1045.    while ((*p) && (*p != '/') && (!isspace (*p)))
  1046.       {
  1047.       *p1++ = *p++;
  1048.       }
  1049.    *p1 = '\0';
  1050.  
  1051.    p1 = tmm->suf;
  1052.    if ((*p == '\0') || (isspace (*p)))
  1053.       {
  1054.       *p1 = '\0';
  1055.       }
  1056.    else
  1057.       {
  1058.       ++p;
  1059.  
  1060.       while ((*p) && (!isspace (*p)))
  1061.          {
  1062.          *p1++ = *p++;
  1063.          }
  1064.       *p1 = '\0';
  1065.       }
  1066.  
  1067.    tmm->next = NULL;
  1068.    if (mm_head == NULL)
  1069.       {
  1070.       mm_head = tmm;
  1071.       }
  1072.    else
  1073.       {
  1074.       mm->next = tmm;
  1075.       }
  1076.    mm = tmm;
  1077. }
  1078.  
  1079. void cfg_domain (char *c)
  1080. {
  1081.    char *p, *p1, *p2;
  1082.    int i;
  1083.  
  1084.    p = skip_blanks (c);
  1085.    p = strtok (p, "; \t\r\n");
  1086.    if (p != NULL)
  1087.       {
  1088.       /* Have the domain name, now get the abbreviated name */
  1089.       p2 = strtok (NULL, "; \t\r\n");
  1090.       if (strlen (p2) > 8)
  1091.          *(p2 + 8) = '\0';
  1092.       if (p2 != NULL)
  1093.          {
  1094.          /* Have the domain name and abbreviated, now get the list name */
  1095.          p1 = strtok (NULL, "; \t\r\n");
  1096.          if (p1 == NULL)
  1097.             p1 = p2;
  1098.  
  1099.          /* Have the list name and the domain name, now use them */
  1100.          for (i = 0; domain_name[i] != NULL; i++)
  1101.             {
  1102.             if (strnicmp (domain_name[i], p, strlen (domain_name[i])) == 0)
  1103.                {
  1104.                domain_nodelist[i] = strdup (p1);
  1105.                domain_abbrev[i] = strdup (p2);
  1106.                break;
  1107.                }
  1108.             }
  1109.          if ((domain_name[i] == NULL) && (i < 49))
  1110.             {
  1111.             domain_name[i] = strdup (p);
  1112.             domain_abbrev[i] = strdup (p2);
  1113.             domain_nodelist[i] = strdup (p1);
  1114.             }
  1115.          }
  1116.       }
  1117. }
  1118.  
  1119. void cfg_Janus (char *c)
  1120. {
  1121.    J_TYPES *tjt;
  1122.    char *p, *p1;
  1123.  
  1124.    p = c;
  1125.    while ((*p) && (isspace (*p)))
  1126.       ++p;
  1127.  
  1128.    if ((*p == ';') || (*p == '\0'))
  1129.       {
  1130.       return;
  1131.       }
  1132.  
  1133.    tjt = (J_TYPES *) calloc (1, sizeof (J_TYPES));
  1134.  
  1135.    p1 = tjt->j_match;
  1136.    while ((*p) && (!isspace (*p)))
  1137.       {
  1138.       *p1++ = *p++;
  1139.       }
  1140.    *p1 = '\0';
  1141.  
  1142.    tjt->next = NULL;
  1143.  
  1144.    if (j_top == NULL)
  1145.       {
  1146.       j_top = tjt;
  1147.       }
  1148.    else
  1149.       {
  1150.       j_next->next = tjt;
  1151.       }
  1152.    j_next = tjt;
  1153. }
  1154.