home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 2 BBS / 02-BBS.zip / BSRC_250.LZH / BTCONFIG.C < prev    next >
Text File  |  1991-09-15  |  38KB  |  1,156 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.                 strcpy(pipename, skip_blanks(c));
  728.             else
  729.                 strcpy(pipename, getenv("SNOOPPIPE"));
  730.  
  731.             if (pipename[0] != '\0')
  732.                 snoop_open(pipename);
  733. #endif /* Snoop */
  734.             break;
  735.  
  736.          case 114:                               /* "Flags"        */
  737.             flag_dir = ctl_slash_string (c);
  738.             break;
  739.  
  740.          case 115:                               /* "Tasknumber"   */
  741.             c = skip_blanks (c);
  742.             TaskNumber = atoi (c);
  743.             break;
  744.  
  745.          case 116:                               /* "MaxBytes"     */
  746.             (void) sscanf (c, "%ld %ld", &DEFAULT.byte_Limit, &DEFAULT.byte_Cum_Limit);
  747.             break;
  748.  
  749.          case 117:                               /* "KnownMaxBytes"*/
  750.             (void) sscanf (c, "%ld %ld", &KNOWN.byte_Limit, &KNOWN.byte_Cum_Limit);
  751.             break;
  752.  
  753.          case 118:                               /* "ProtMaxBytes" */
  754.             (void) sscanf (c, "%ld %ld", &PROT.byte_Limit, &PROT.byte_Cum_Limit);
  755.             break;
  756.  
  757.          case 119:                               /* "StartBlkLen"  */
  758.             c = skip_blanks (c);
  759.             fstblklen = atoi (c);
  760.             if ((fstblklen < 64) || (fstblklen > 2048))
  761.                fstblklen = 1024;
  762.             break;
  763.  
  764.          case 120:                               /* "MaxTime"      */
  765.             (void) sscanf (c, "%d %ld", &DEFAULT.time_Limit, &DEFAULT.time_Cum_Limit);
  766.             DEFAULT.time_Limit *= 60;
  767.             DEFAULT.time_Cum_Limit *= 60;
  768.             break;
  769.  
  770.          case 121:                               /* "KnownMaxTime" */
  771.             (void) sscanf (c, "%d %ld", &KNOWN.time_Limit, &KNOWN.time_Cum_Limit);
  772.             KNOWN.time_Limit *= 60;
  773.             KNOWN.time_Cum_Limit *= 60;
  774.             break;
  775.  
  776.          case 122:                               /* "ProtMaxTime"  */
  777.             (void) sscanf (c, "%d %ld", &PROT.time_Limit, &PROT.time_Cum_Limit);
  778.             PROT.time_Limit *= 60;
  779.             PROT.time_Cum_Limit *= 60;
  780.             break;
  781.  
  782.          case 123:                               /* "RingTries"    */
  783.             c = skip_blanks (c);
  784.             ring_tries = atoi (c);
  785.             break;
  786.  
  787.          case 124:                               /* "NoSharing"    */
  788.             no_sharing = 1;
  789.             break;
  790.  
  791.          case 125:                               /* "Version7"     */
  792.             version7 = 1;
  793.             nodefunc = ver7find;
  794.             userfunc = opususer;
  795.             newnodelist = 0;
  796.             break;
  797.  
  798.          case 126:                               /* "BlankWait"    */
  799.             c = skip_blanks (c);
  800.             blank_time = (unsigned int)100 * (unsigned int)atoi (c);
  801.             break;
  802.  
  803.          case 127:                               /* "Serial"       */
  804.             c = skip_blanks (c);
  805.             if (isdigit (*c))
  806.                serial = atoi (c);
  807.             break;
  808.  
  809.          case 128:                               /* "NoDietIfna"   */
  810.             no_dietifna = 1;
  811.             break;
  812.  
  813.          case 130:
  814.             winslice = 1;                        /* "WinSlice"     */
  815.             break;
  816.  
  817.          case 131:                               /* "NoSize"       */
  818.             no_size = 1;
  819.             break;
  820.  
  821. bad_line:
  822.          default:
  823.             (void) printf (MSG_TXT(M_UNKNOWN_LINE), temp);
  824.          }
  825.       }
  826.    (void) fclose (stream);                       /* close input file */
  827.  
  828.    if (debugging_log)
  829.       loglevel = 6;
  830. }
  831.  
  832. char *ctl_string (char *source)                  /* malloc & copy to ctl      */
  833. {
  834.    char *dest, *c;
  835.    int i;
  836.  
  837.    c = skip_blanks (source);                     /* get over the blanks       */
  838.    i = (int) strlen (c);                         /* get length of remainder   */
  839.    if (i < 1)                                    /* must have at least 1      */
  840.       return (NULL);                             /* if not, return NULL       */
  841.    dest = calloc (1, (unsigned int) (++i));      /* allocate space for string */
  842.    if (dest == NULL)                             /* If we failed to get it,   */
  843.       return (NULL);                             /* Just return NULL          */
  844.    (void) strcpy (dest, c);                      /* copy the stuff over       */
  845.    return (dest);                                /* and return the address    */
  846. }
  847.  
  848. char *ctl_slash_string (char *source)            /* malloc & copy to ctl      */
  849. {
  850.    char *dest, *c;
  851.    int i;
  852.    struct stat buffer;
  853.  
  854.    c = skip_blanks (source);                     /* get over the blanks       */
  855.    i = (int) strlen (c);                         /* get length of remainder   */
  856.    if (i < 1)                                    /* must have at least 1      */
  857.       return (NULL);                             /* if not, return NULL       */
  858.    dest = calloc (1, (unsigned int) (i+2));      /* allocate space for string */
  859.    if (dest == NULL)                             /* If we failed to get it,   */
  860.       return (NULL);                             /* Just return NULL          */
  861.    (void) strcpy (dest, c);                      /* copy the stuff over       */
  862.    (void) delete_backslash (dest);               /* get rid of trailing stuff */
  863.    /* Check to see if the directory exists */
  864.    i = stat (dest, &buffer);
  865.    if (i || (!(buffer.st_mode & S_IFDIR)))
  866.       {
  867.       (void) printf (MSG_TXT(M_BAD_DIR), dest);
  868.       (void) printf (MSG_TXT(M_FAIL_EXEC));
  869.       return(NULL);
  870.       }
  871.    (void) add_backslash (dest);                         /* add the backslash         */
  872.    return (dest);                                /* return the directory name */
  873. }
  874.  
  875.  
  876. char *add_backslash (char *str)
  877. {
  878.    char *p;
  879.  
  880.    p = str + strlen (str) - 1;
  881.  
  882.    if (p >= str)
  883.       {
  884.       /* Strip off the trailing blanks */
  885.       while ((p >= str) && (isspace (*p)))
  886.          {
  887.          *p = '\0';
  888.          --p;
  889.          }
  890.  
  891.       /* Put a backslash if there isn't one */
  892.       if ((p >=str) && (*p != '\\') && (*p != '/'))
  893.          {
  894.          *(++p) = '\\';
  895.          *(++p) = '\0';
  896.          }
  897.       }
  898.  
  899.    return (fancy_str (str));
  900. }
  901.  
  902. char *delete_backslash (char *str)
  903. {
  904.    char *p;
  905.  
  906.    p = str + strlen (str) - 1;
  907.  
  908.    if (p >= str)
  909.       {
  910.       /* Strip off the trailing blanks */
  911.       while ((p >= str) && (isspace (*p)))
  912.          {
  913.          *p = '\0';
  914.          --p;
  915.          }
  916.  
  917.       /* Get rid of backslash if there is one */
  918.       if ((p >=str) && ((*p == '\\') || (*p == '/')))
  919.          {
  920.          if ((p > str) && (*(p-1) != ':'))      /* Don't delete on root */
  921.             *p = '\0';
  922.          }
  923.       }
  924.  
  925.    return (fancy_str (str));
  926. }
  927.  
  928. void cfg_macro (char *c)
  929. {
  930.    int i;
  931.    char *p;
  932.  
  933.    c = skip_blanks (c);
  934.    i = atoi (c);
  935.    if ((i <= 0) || (i > 9))
  936.       {
  937.       (void) printf ("%s %d %s\n", MSG_TXT(M_MACRO_NUMBER), i, MSG_TXT(M_OUT_OF_RANGE));
  938.       return;
  939.       }
  940.    c = skip_to_blank (c);
  941.    c = skip_blanks (c);
  942.    keys[i - 1] = calloc (1, strlen (c) + 1);
  943.    p = keys[i - 1];
  944.    while (*c && (*c != '\n'))
  945.       {
  946.       if (*c == '|')
  947.          *p++ = '\r';
  948.       else *p++ = *c;
  949.       ++c;
  950.       }
  951.    *p = '\0';
  952. }
  953.  
  954. void cfg_dial_string (char *c)
  955. {
  956.    char *p, *p1;
  957.    PN_TRNS *tpn;
  958.  
  959.    p = c;
  960.    while ((*p) && (isspace (*p)))
  961.       ++p;
  962.  
  963.    if ((*p == ';') || (*p == '\0'))
  964.       {
  965.       return;
  966.       }
  967.  
  968.    tpn = (PN_TRNS *) calloc (1, sizeof (PN_TRNS));
  969.  
  970.    p1 = tpn->num;
  971.    while ((*p) && (!isspace (*p)))
  972.       {
  973.       *p1++ = *p++;
  974.       }
  975.    *p1 = '\0';
  976.  
  977.    while ((*p) && (isspace (*p)))
  978.       {
  979.       ++p;
  980.       }
  981.  
  982.    p1 = tpn->pre;
  983.    while ((*p) && (*p != '/') && (!isspace (*p)))
  984.       {
  985.       *p1++ = *p++;
  986.       }
  987.    *p1 = '\0';
  988.  
  989.    p1 = tpn->suf;
  990.    if ((*p == '\0') || (isspace (*p)))
  991.       {
  992.       *p1 = '\0';
  993.       }
  994.    else
  995.       {
  996.       ++p;
  997.  
  998.       while ((*p) && (!isspace (*p)))
  999.          {
  1000.          *p1++ = *p++;
  1001.          }
  1002.       *p1 = '\0';
  1003.       }
  1004.  
  1005.    tpn->len = (int) strlen (tpn->num);
  1006.    tpn->next = NULL;
  1007.    if (pn_head == NULL)
  1008.       {
  1009.       pn_head = tpn;
  1010.       }
  1011.    else
  1012.       {
  1013.       pn->next = tpn;
  1014.       }
  1015.    pn = tpn;
  1016. }
  1017.  
  1018. void cfg_mdm_trans (char *c)
  1019. {
  1020.    char *p, *p1;
  1021.    MDM_TRNS *tmm;
  1022.  
  1023.    p = c;
  1024.    while ((*p) && (isspace (*p)))
  1025.       ++p;
  1026.  
  1027.    if ((*p == ';') || (*p == '\0'))
  1028.       {
  1029.       return;
  1030.       }
  1031.  
  1032.    tmm = (MDM_TRNS *) calloc (1, sizeof (MDM_TRNS));
  1033.  
  1034.    tmm->mdm = (byte) atoi (p);
  1035.    while ((*p) && (!isspace (*p)))
  1036.       {
  1037.       p++;
  1038.       }
  1039.  
  1040.    while ((*p) && (isspace (*p)))
  1041.       {
  1042.       ++p;
  1043.       }
  1044.  
  1045.    p1 = tmm->pre;
  1046.    while ((*p) && (*p != '/') && (!isspace (*p)))
  1047.       {
  1048.       *p1++ = *p++;
  1049.       }
  1050.    *p1 = '\0';
  1051.  
  1052.    p1 = tmm->suf;
  1053.    if ((*p == '\0') || (isspace (*p)))
  1054.       {
  1055.       *p1 = '\0';
  1056.       }
  1057.    else
  1058.       {
  1059.       ++p;
  1060.  
  1061.       while ((*p) && (!isspace (*p)))
  1062.          {
  1063.          *p1++ = *p++;
  1064.          }
  1065.       *p1 = '\0';
  1066.       }
  1067.  
  1068.    tmm->next = NULL;
  1069.    if (mm_head == NULL)
  1070.       {
  1071.       mm_head = tmm;
  1072.       }
  1073.    else
  1074.       {
  1075.       mm->next = tmm;
  1076.       }
  1077.    mm = tmm;
  1078. }
  1079.  
  1080. void cfg_domain (char *c)
  1081. {
  1082.    char *p, *p1, *p2;
  1083.    int i;
  1084.  
  1085.    p = skip_blanks (c);
  1086.    p = strtok (p, "; \t\r\n");
  1087.    if (p != NULL)
  1088.       {
  1089.       /* Have the domain name, now get the abbreviated name */
  1090.       p2 = strtok (NULL, "; \t\r\n");
  1091.       if (strlen (p2) > 8)
  1092.          *(p2 + 8) = '\0';
  1093.       if (p2 != NULL)
  1094.          {
  1095.          /* Have the domain name and abbreviated, now get the list name */
  1096.          p1 = strtok (NULL, "; \t\r\n");
  1097.          if (p1 == NULL)
  1098.             p1 = p2;
  1099.  
  1100.          /* Have the list name and the domain name, now use them */
  1101.          for (i = 0; domain_name[i] != NULL; i++)
  1102.             {
  1103.             if (strnicmp (domain_name[i], p, strlen (domain_name[i])) == 0)
  1104.                {
  1105.                domain_nodelist[i] = strdup (p1);
  1106.                domain_abbrev[i] = strdup (p2);
  1107.                break;
  1108.                }
  1109.             }
  1110.          if ((domain_name[i] == NULL) && (i < 49))
  1111.             {
  1112.             domain_name[i] = strdup (p);
  1113.             domain_abbrev[i] = strdup (p2);
  1114.             domain_nodelist[i] = strdup (p1);
  1115.             }
  1116.          }
  1117.       }
  1118. }
  1119.  
  1120. void cfg_Janus (char *c)
  1121. {
  1122.    J_TYPES *tjt;
  1123.    char *p, *p1;
  1124.  
  1125.    p = c;
  1126.    while ((*p) && (isspace (*p)))
  1127.       ++p;
  1128.  
  1129.    if ((*p == ';') || (*p == '\0'))
  1130.       {
  1131.       return;
  1132.       }
  1133.  
  1134.    tjt = (J_TYPES *) calloc (1, sizeof (J_TYPES));
  1135.  
  1136.    p1 = tjt->j_match;
  1137.    while ((*p) && (!isspace (*p)))
  1138.       {
  1139.       *p1++ = *p++;
  1140.       }
  1141.    *p1 = '\0';
  1142.  
  1143.    tjt->next = NULL;
  1144.  
  1145.    if (j_top == NULL)
  1146.       {
  1147.       j_top = tjt;
  1148.       }
  1149.    else
  1150.       {
  1151.       j_next->next = tjt;
  1152.       }
  1153.    j_next = tjt;
  1154. }
  1155. 
  1156.