home *** CD-ROM | disk | FTP | other *** search
/ Crawly Crypt Collection 2 / crawlyvol2.bin / program / c / ios_src / config.c < prev    next >
C/C++ Source or Header  |  1993-01-31  |  49KB  |  2,489 lines
  1. /*********************************************************************
  2.  
  3.                     IOS - configuration handler
  4.                     
  5.     Program : IOSmail
  6.     Source  : free
  7.     Author  : Rinaldo Visscher
  8.     Date    : 1991
  9.     
  10.     This part contains,
  11.     
  12.     Read configuration and parse it.
  13.     Read AREAS.BBS and parse it.
  14.     Read LED.NEW and parse it.
  15.     Update LED.NEW
  16.     
  17. *********************************************************************/
  18.  
  19.  
  20. #include        <stdio.h>
  21. #include        <stdlib.h>
  22. #include        <aes.h>
  23.  
  24. #if !defined LATTICE
  25. #include        <ext.h>
  26. #include        <tos.h>
  27. #else
  28. #include        <dos.h>
  29. #include        <sys/stat.h>
  30. #endif
  31. #include        <ctype.h>
  32. #include        <string.h>
  33. #include        <time.h>
  34. #include        <errno.h>
  35.  
  36. #include        "portab.h"
  37.  
  38. #include        "defs.h"
  39. #include        "ioslib.h"
  40.  
  41. #include        "inmail.h"
  42. #include        "strutil.h"
  43. #include        "lang.h"
  44.  
  45. #include        "vars.h"
  46.  
  47.  
  48. MLOCAL CONST BYTE    *Myweek[] = {"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
  49.  
  50. MLOCAL CONST BYTE    *DFTpkt[] = {"2.0","2+","2.1","2.2",NULL};
  51.  
  52. MLOCAL VOID check_N_space(VOID)
  53. {
  54.     if (nRouteDef >= MaxRouteDef)
  55.     {
  56.         if (MaxRouteDef >= 30000)
  57.         {
  58.             log_line(-1,Logmessage[M__ROUTE_OVERFLOW]);
  59.             nRouteDef = 0;
  60.             return;
  61.         }
  62.         
  63.         MaxRouteDef += 1000;
  64.         
  65.         RouteDef = (struct _RouteDef *) realloc(RouteDef,
  66.             MaxRouteDef * sizeof(struct _RouteDef));
  67.         
  68.         if (!RouteDef)
  69.         {
  70.             log_line(6,Logmessage[M__MEMORY_ERROR]);
  71.             terminate(-31);
  72.         }
  73.     }
  74. }
  75.  
  76. MLOCAL VOID parse_readdress(BYTE *line) {
  77.     BYTE    *p, *q,
  78.             temp[100];
  79.     
  80.  
  81.     p = line;
  82.     
  83.     for (q=temp; *p && *p != ','; *q++=*p++);
  84.     *q = EOS;
  85.     if (!*p) goto Read_ERR;
  86.     
  87.     strncpy (readdress[nreaddress].fname, temp, 36);
  88.     
  89.     p = skip_blanks (++p);
  90.     
  91.     for (q=temp; *p && *p != ','; *q++=*p++);
  92.     *q = EOS;
  93.     if (!*p) goto Read_ERR;
  94.     
  95.     strncpy (readdress[nreaddress].fnode, temp, 20);
  96.  
  97.     p = skip_blanks (++p);
  98.     
  99.     for (q=temp; *p && *p != ','; *q++=*p++);
  100.     *q = EOS;
  101.     if (!*p) goto Read_ERR;
  102.     
  103.     strncpy (readdress[nreaddress].tname, temp, 36);
  104.  
  105.     p = skip_blanks (++p);
  106.  
  107.     for (q=temp; *p && *p != ','; *q++=*p++);
  108.     *q = EOS;
  109.     
  110.     strncpy (readdress[nreaddress++].tnode, temp, 20);
  111.     
  112.     return;
  113.     
  114.     Read_ERR:
  115.     
  116.     log_line (-1, "!Error in Readdress line.");
  117. }
  118.  
  119. MLOCAL BYTE *parse_event(BYTE *line)
  120. {
  121.     BYTE    *p = line,
  122.             *q,
  123.             temp[80],
  124.             day[20];
  125.     WORD    shour,
  126.             smin,
  127.             ehour,
  128.             emin,
  129.             start,
  130.             end,
  131.             now;
  132.     LONG    secs_now;
  133.     
  134.     for (q = temp; *p && !isspace(*p); *q++ = *p++);
  135.     *q = EOS;
  136.     
  137.     strncpy(day, temp, 19);
  138.     p = skip_blanks(p);
  139.     
  140.     if (!isdigit(*p))
  141.     {
  142.         Illegal_event:
  143.         
  144.         log_line(4,Logmessage[M__EVENT_ERROR]);
  145.         return(NULL);
  146.     }
  147.     
  148.     for (q = temp; *p && !isspace(*p); *q++ = *p++);
  149.     *q = EOS;
  150.     
  151.     p = skip_blanks(p);
  152.     q = temp;
  153.     shour = atoi(q);
  154.     
  155.     while (*q != ':' && *q) q++;
  156.     
  157.     if (!*q)
  158.     {
  159.         Illegal_date:
  160.         
  161.         log_line(4,Logmessage[M__DATE_ERROR]);
  162.         return(NULL);
  163.     }
  164.     
  165.     smin = atoi(++q);
  166.     
  167.     if (shour > 23 || smin > 59)
  168.     {
  169.         Illegal_hour:
  170.         
  171.         log_line(4,Logmessage[M__HOUR_ERROR]);
  172.         return(NULL);
  173.     }
  174.     
  175.     if (!isdigit(*p)) goto Illegal_event;
  176.     
  177.     for (q = temp; *p && !isspace(*p); *q++ = *p++);
  178.     *q = EOS;
  179.     
  180.     p = skip_blanks(p);
  181.     q = temp;
  182.     ehour = atoi(q);
  183.     
  184.     while (*q != ':' && *q) q++;
  185.     if (!*q) goto Illegal_date;
  186.     
  187.     emin = atoi(++q);
  188.     
  189.     if (ehour > 23 || emin > 59) goto Illegal_hour;
  190.     
  191.     time(&secs_now);
  192.     tijd = localtime(&secs_now);
  193.     
  194.     /*
  195.     **    Weekends, week, day.
  196.     */
  197.     
  198.     if (stricmp(day, "all"))
  199.     {
  200.         if (!stricmp(day, "wkd") &&
  201.             (tijd->tm_wday == 0) || (tijd->tm_wday == 6))
  202.             goto have_event;
  203.         
  204.         if (!stricmp(day, "week"))
  205.         {
  206.             if (tijd->tm_wday == 0 || tijd->tm_wday == 6) return(NULL);
  207.             goto have_event;
  208.         }
  209.         
  210.         if (stricmp(day, Myweek[tijd->tm_wday])) return(NULL);
  211.     }
  212.     
  213.     have_event:
  214.     
  215.     start = (shour * 60) + smin;
  216.     end = (ehour * 60) + emin;
  217.     now = (tijd->tm_hour * 60) + tijd->tm_min;
  218.     
  219.     if (start < end)
  220.     {
  221.         if (start <= now && now <= end)
  222.             return(p);
  223.         else
  224.             return(NULL);
  225.     }
  226.     else
  227.     {
  228.         if ((start >= now && now < (24*60)) ||
  229.             (now <= end && now >= 0))
  230.             return(p);
  231.         else
  232.             return(NULL);
  233.     }
  234. }
  235.  
  236. MLOCAL VOID parsepassword(BYTE *line)
  237. {
  238.     BYTE    temp[80],
  239.             *q,
  240.             *p = skip_blanks(line);
  241.     UWORD    i, j;
  242.     
  243.     for (q = temp; *p && !isspace(*p); *q++ = *p++);
  244.     *q = EOS;
  245.     
  246.     address(temp, &pwd[nkey].zone, &pwd[nkey].net, &pwd[nkey].node,
  247.         &pwd[nkey].point, &i, pwd[nkey].Domain);
  248.     
  249.     pwd[nkey].mtype = TYPE3d;
  250.     pwd[nkey].htype = FTS_TYPE;
  251.     pwd[nkey].intl_type = TYPE4d;
  252.     pwd[nkey].intl_always=FALSE;
  253.     pwd[nkey].Uname[0] = EOS;
  254.     pwd[nkey].Ugroup[0] = EOS;
  255.     pwd[nkey].crash_to = NO_CRASH;
  256.     pwd[nkey].Send_PKT = FALSE;
  257.     pwd[nkey].TosScan = FALSE;
  258.     
  259.     j = 0;
  260.     
  261.     while (*p)
  262.     {
  263.         p = skip_blanks(p);
  264.         if (!*p) break;
  265.  
  266.         if (*p == '"')
  267.         {
  268.             p++;
  269.             j=0;
  270.             while (*p != '"') {
  271.                 pwd[nkey].Uname[j++] = *p++;
  272.                 
  273.                 if (!*p) break;
  274.             }
  275.             p++;
  276.             continue;
  277.         }
  278.         
  279.         
  280.         for (q = temp; *p && !isspace(*p); *q++ = *p++);
  281.         *q = EOS;
  282.         
  283.         i = 0;
  284.         
  285.         if (*temp == '{') 
  286.         {
  287.             j = 1;
  288.             
  289.             while (temp[j] != '}')
  290.             {
  291.                 pwd[nkey].Ugroup[i++] = temp[j++];
  292.             }
  293.             continue;
  294.         }
  295.         
  296.         if (*temp == '$')
  297.         {
  298.             if (!strlen(&temp[1]))
  299.             {
  300.                 log_line(-1,Logmessage[M__AREAFIX_PWD], line);
  301.                 continue;
  302.             }
  303.             
  304.             strcpy(pwd[nkey].Afix, &temp[1]);
  305.             continue;
  306.         }
  307.         
  308.         if (!strcmp(temp, "*"))
  309.         {
  310.             pwd[nkey].mtype = TYPE4d;
  311.             continue;
  312.         }
  313.         
  314.         if (!strcmp(temp, "#"))
  315.         {
  316.             pwd[nkey].htype = FRONTDOOR;
  317.             continue;
  318.         }
  319.         
  320.         if (!strcmp(temp, "&"))
  321.         {
  322.             pwd[nkey].htype = TYPE_2_2;
  323.             continue;
  324.         }
  325.         
  326.         if (!strcmp(temp, "^"))
  327.         {
  328.             pwd[nkey].intl_type = TYPE3d;
  329.             continue;
  330.         }
  331.         
  332.         if (!strcmp(temp, "!"))
  333.         {
  334.             pwd[nkey].intl_always = TRUE;
  335.             continue;
  336.         }
  337.         
  338.         if (!strcmp (temp, "+"))
  339.         {
  340.             pwd[nkey].crash_to = AT_CRASH;
  341.             continue;
  342.         }
  343.         
  344.         if (!strcmp (temp, "-")) 
  345.         {
  346.             pwd[nkey].Send_PKT = TRUE;
  347.             continue;
  348.         }
  349.         
  350.         if (!strcmp (temp, "T"))
  351.         {
  352.             pwd[nkey].TosScan = TRUE;
  353.             continue;
  354.         }
  355.         
  356.         if (*temp == '*' || *temp == '#' || *temp == '^' ||
  357.             *temp == '!' || *temp == '&' || *temp == '+' ||
  358.             *temp == '-')
  359.         {
  360.             q = temp;
  361.             
  362.             while (*q)
  363.             {
  364.                 if (*q == '*') pwd[nkey].mtype = TYPE3d;
  365.                 if (*q == '#') pwd[nkey].htype = FRONTDOOR;
  366.                 if (*q == '&') pwd[nkey].htype = TYPE_2_2;
  367.                 if (*q == '^') pwd[nkey].intl_type = TYPE3d;
  368.                 if (*q == '!') pwd[nkey].intl_always=TRUE;
  369.                 if (*q == '+') pwd[nkey].crash_to = AT_CRASH;
  370.                 if (*q == '-') pwd[nkey].Send_PKT = TRUE;
  371.                 if (*q == 'T') pwd[nkey].TosScan  = TRUE;
  372.                 q++;
  373.             }
  374.             
  375.             continue;
  376.         }
  377.         
  378.         if (*temp == '%')
  379.         {
  380.             if (!strnicmp(&temp[1], "lzhmail", 7))
  381.             {
  382.                 pwd[nkey].arctype = isLZHmail;
  383.                 continue;
  384.             }
  385.             
  386.             if (!strnicmp(&temp[1], "arcmail", 7))
  387.             {
  388.                 pwd[nkey].arctype = isARCmail;
  389.                 continue;
  390.             }
  391.             
  392.             if (!strnicmp(&temp[1], "zipmail", 7))
  393.             {
  394.                 pwd[nkey].arctype = isZIPmail;
  395.                 continue;
  396.             }
  397.  
  398.             if (!strnicmp(&temp[1], "arjmail", 7))
  399.             {
  400.                 pwd[nkey].arctype = isARJmail;
  401.                 continue;
  402.             }
  403.         }
  404.         
  405.         strncpy(pwd[nkey].pwd, temp, 8);
  406.     }
  407.     
  408.     nkey++;
  409. }
  410.  
  411. MLOCAL VOID parse_domain(BYTE *line)
  412. {
  413.     BYTE    temp[128],
  414.             *p = skip_blanks(line),
  415.             *q;
  416.     
  417.     for (q = temp; *p && !isspace(*p); *q++ = *p++);
  418.     *q = EOS;
  419.     
  420.     Appl[domain].zone = atoi(temp);
  421.     
  422.     p = skip_blanks(p);
  423.     
  424.     for (q = temp; *p && !isspace(*p); *q++ = *p++);
  425.     *q = EOS;
  426.     
  427.     strcpy(Appl[domain].path, temp);
  428.     
  429.     
  430.     p = skip_blanks(p);
  431.     
  432.     if (!*p) {
  433.         Appl[domain].domain[0] = EOS;
  434.         domain++;
  435.         return ;
  436.     }
  437.     
  438.     for (q = temp; *p && !isspace(*p); *q++ = *p++);
  439.     *q = EOS;
  440.     
  441.     strncpy(Appl[domain].domain, temp,40);
  442.     
  443.     if (strchr(Appl[domain].path, '\\') == NULL ||
  444.         !strlen(Appl[domain].domain)) {
  445.         log_line(-1, Logmessage[M__MISSING_DOMAIN]);
  446.     } else {
  447.         domain++;
  448.     }
  449. }
  450.  
  451. /*
  452. **    Look for which nodes and points are connected to this area.
  453. **    Store them in Tozone,Tonet,Tonode,Topoint.
  454. **    line  : line with nodenumbers
  455. **    where : which area
  456. */
  457.  
  458. MLOCAL VOID get_connected(BYTE *line, WORD where)
  459. {
  460.     BYTE    *p = skip_blanks(line),
  461.             *q,
  462.             Odomain[10],
  463.             temp[80],
  464.             *dummy = NULL;
  465.     UWORD    w = 0,
  466.             i, j, z,
  467.             current_address = 0;
  468.     
  469.     while (*p)
  470.     {
  471.         if (dummy) free(dummy);
  472.         
  473.         for (q = temp; *p && !isspace(*p); *q++ = *p++);
  474.         *q = EOS;
  475.         
  476.         dummy = ctl_string(temp);
  477.         
  478.         address(dummy, &Tz[w], &Tnt[w], &Tne[w], &Tp[w], &i, Odomain);
  479.         
  480.         if (!current_address) {
  481.             if (strlen (Odomain)) {
  482.                 strcpy (Todomain [where], Odomain);
  483.                 Odomain [0] = EOS;
  484.                 current_address++;
  485.             } else {
  486.                 log_line (6, "+Please add DOMAIN at area %s", Areaname[where]);
  487.                 exit (10);
  488.             }
  489.         }
  490.         
  491.         p = skip_blanks(p);
  492.         w++;
  493.     }
  494.     
  495.     Tz[w] = Tnt[w] = Tne[w] = Tp[w] = (-1);
  496.     
  497.     if (w > 1)
  498.     {
  499.         for (i = 0; i < nalias; i++)
  500.         {
  501.             if (Tz[0] == alias[i].zone)
  502.             {
  503.                 for (z = 1; z < w; z++)
  504.                 {
  505.                     if (Tz[z] != Tz[0] && Tp[z])
  506.                     {
  507.                         for (j = 0; j < nkey; j++)
  508.                         {
  509.                             if (alias[i].zone == pwd[j].zone &&
  510.                                 alias[i].net == pwd[j].net &&
  511.                                 alias[i].node== pwd[j].node &&
  512.                                 Tp[z] == pwd[j].point)
  513.                             {
  514.                                 Tz[z] = alias[i].zone;
  515.                                 Tnt[z] = alias[i].net;
  516.                                 Tne[z] = alias[i].node;
  517.                                 break;
  518.                             }
  519.                         }
  520.                     }
  521.                     else
  522.                     {
  523.                         for (j = 0; j < nkey; j++)
  524.                         {
  525.                             if (Tnt[z] == pwd[j].net &&
  526.                                 Tne[z] == pwd[j].node)
  527.                             {
  528.                                 Tz[z] = pwd[j].zone;
  529.                                 break;
  530.                             }
  531.                         }
  532.                     }
  533.                 }
  534.                 break;
  535.             }
  536.         }
  537.     }
  538.     
  539.     w++;
  540.  
  541.     /*
  542.     **    Store numbers
  543.     */
  544.     
  545.     Tozone[where] = (UWORD *) myalloc((w+1) * sizeof(UWORD));
  546.     Tonet[where] = (UWORD *) myalloc((w+1) * sizeof(UWORD));
  547.     Tonode[where] = (UWORD *) myalloc((w+1) * sizeof(UWORD));
  548.     Topoint[where] = (UWORD *) myalloc((w+1) * sizeof(UWORD));
  549.     
  550.     memset(Tozone[where], -1, w+1);
  551.     memset(Tonet[where], -1, w+1);
  552.     memset(Tonode[where], -1, w+1);
  553.     memset(Topoint[where], -1, w+1);
  554.     
  555.     sort_connected(w, 1);
  556.     
  557.     memmove(Tozone[where], Tz, sizeof(WORD) * w);
  558.     memmove(Tonet[where], Tnt, sizeof(WORD) * w);
  559.     memmove(Tonode[where], Tne, sizeof(WORD) * w);
  560.     memmove(Topoint[where], Tp, sizeof(WORD) * w);
  561.     
  562.     free(dummy);
  563. }
  564.  
  565. /*
  566. **    Read the areas we have.
  567. */
  568.     
  569. BOOLEAN read_areas(BYTE *filename, BYTE what)
  570. {
  571.     BYTE    buffer[2048],
  572.             temp[130],
  573.             *q, *p,
  574.             Hday = 0,
  575.             Horg = 0,
  576.             Hmin = 0,
  577.             Hrd  = 0,
  578.             Hkp  = 0,
  579.             Huse = 0,
  580.             Hgr  = 0,
  581.             Hrand=0,
  582.             PASSarea = FALSE;
  583.             
  584.     WORD    i, attrib;
  585.     
  586.     sprintf(temp, "%s%s", Envpath, filename);
  587.     if (findfirst(temp, &blok, 0)) sprintf(temp, "%s", filename);
  588.     
  589.     if ((FDUMMY = fopen(temp, "r")) == NULL)
  590.     {
  591.          if (!what) log_line(-1,Logmessage[M__CANT_OPEN],temp);
  592.         
  593.         return(FALSE);
  594.     }
  595.     
  596.     if (!what)
  597.     {
  598.         while (fgets(buffer, 2048, FDUMMY))
  599.         {
  600.             p = skip_blanks(buffer);
  601.             if (*p == ';') continue;
  602.             if ((i = (WORD)strlen(p)) < 3) continue;
  603.             
  604.             giveTIMEslice();
  605.                         
  606.             p = &p[--i];
  607.             *p = EOS;
  608.             
  609.             if ((p = strchr(buffer,';')) != NULL) *p = EOS;
  610.             
  611.             p = skip_blanks(buffer);
  612.             
  613.             if (*p)
  614.             {
  615.                 Mainorg = ctl_string(p);
  616.                 break;
  617.             }
  618.             else continue;
  619.         }
  620.     }
  621.     
  622.     while (fgets(buffer, 2048, FDUMMY))
  623.     {
  624.         p = skip_blanks(buffer);
  625.         if (*p == ';') continue;
  626.         if ((i = (WORD)strlen(p)) < 3) continue;
  627.         
  628.         p = &p[--i];
  629.         *p = EOS;
  630.         
  631.         if (what) PASSarea = TRUE;
  632.         
  633.         giveTIMEslice();
  634.         
  635.         if ((p = strchr(buffer, ';')) != NULL) *p = EOS;
  636.         
  637.         p = skip_blanks(buffer);
  638.         if (!*p) continue;
  639.         
  640.         if (!Horg && !Hday && !Hmin && !Hrd && !Huse && !Hkp && !Hgr && !Hrand)
  641.         {
  642.             Areaday[msgareas] = -1;
  643.             Areaorg[msgareas] = NULL;
  644.             Randorgfile[msgareas] = NULL;
  645.  
  646.             Areamin[msgareas] = -1;
  647.             Read_only[msgareas] = PUBLIC;
  648.             Ausername[msgareas] = NULL;
  649.             Areakeep[msgareas]  = KILLMSGS;
  650.             if (doDEFgroup == TRUE) {
  651.                 Areagroup[msgareas] = Defaultgroup;
  652.             } else {
  653.                 Areagroup[msgareas] = 0;
  654.             }
  655.         }
  656.         
  657.         if (*p == '-')
  658.         {
  659.             switch (toupper(*++p))
  660.             {
  661.                 case 'O':        /* Origin line */
  662.                 
  663.                     p = skip_to_blank(p);
  664.                     Areaorg[msgareas] = ctl_string(p);
  665.                     Horg++;
  666.                     break;
  667.                 
  668.                 case 'D':        /* Days */
  669.                 
  670.                     p = skip_to_blank(p);
  671.                     p = skip_blanks(p);
  672.                     Areaday[msgareas] = atoi(p);
  673.                     Hday++;
  674.                     break;
  675.                 
  676.                 case 'G':
  677.                     p = skip_to_blank(p);
  678.                     p = skip_blanks(p);
  679.                     
  680.                     if (*p) {
  681.                         if (isalnum(*p))
  682.                             Areagroup[msgareas] = *p;
  683.                     }
  684.                     Hgr++;
  685.                     break;
  686.  
  687.                 case 'M':
  688.                         
  689.                     p = skip_to_blank(p);
  690.                     p = skip_blanks(p);
  691.                     Areamin[msgareas] = atoi(p);
  692.                     Hmin++;
  693.                     break;
  694.                 
  695.                 case 'N':
  696.                     if (Huse) break;
  697.                     p = skip_to_blank(p);
  698.                     p = skip_blanks(p);
  699.                     Ausername[msgareas] = ctl_string(p);
  700.                     Huse++;
  701.                     break;
  702.                 
  703.                 case 'K':
  704.                     Areakeep[msgareas] = KEEPMSGS;
  705.                     Hkp++;
  706.                     break;
  707.  
  708.                 case 'L':
  709.                 
  710.                     Read_only[msgareas] = READ_ONLY;
  711.                     Hrd++;
  712.                     break;
  713.                     
  714.                 case 'R':
  715.                     p = skip_to_blank(p);
  716.                     p = skip_blanks(p);
  717.                     
  718.                     if (!*p) {
  719.                         log_line(4,Logmessage[M__NO_REMOTE]);
  720.                         break;
  721.                     }
  722.                     
  723.                     Read_only[msgareas] = REMOTE_ONLY;
  724.                     ROnode[msgareas] = ctl_string(p);
  725.                     Hrd++;
  726.                     break;
  727.                 
  728.                 case 'F':
  729.                     p = skip_to_blank(p);
  730.                     p = skip_blanks(p);
  731.                     if (!*p) {
  732.                         log_line(3,Logmessage[M__NO_ORIGINFILE]);
  733.                         break;
  734.                     }
  735.                     Randorgfile[msgareas] = ctl_file(p);
  736.                     Hrand++;
  737.                     break;
  738.                     
  739.                 case 'P':
  740.                     PASSarea = TRUE;
  741.                     break;
  742.  
  743.             }
  744.             
  745.             continue;
  746.         }
  747.         
  748.         /*
  749.         **    Get areapath first if not DAREAS file
  750.         **
  751.         **    if this area has the magic name:
  752.         **    MAIL
  753.         **    then this is the netmail. Copy it and continue
  754.         */
  755.         
  756.         if (!what || PASSarea == FALSE)
  757.         {
  758.             for (q = temp; *p && !isspace(*p); *q++ = *p++);
  759.             *q = EOS;
  760.             Areapath[msgareas] = ctl_string(temp);
  761.         }
  762.         
  763.         /*
  764.         **    Get areaname next
  765.         */
  766.         
  767.         p = skip_blanks(p);
  768.         
  769.         for (q = temp; *p && !isspace(*p); *q++ = *p++);
  770.         *q = EOS;
  771.         
  772.         /*
  773.         **    Netmail path found in areas
  774.         */
  775.         
  776.         if (!stricmp(temp, "mail"))
  777.         {
  778.             if (strlen(mailarea)) free(mailarea);
  779.             
  780.             mailarea = (BYTE *) myalloc(strlen(Areapath[msgareas]) + 10);
  781.             sprintf(mailarea, "%s", Areapath[msgareas]);
  782.             
  783.             if (Areaday[msgareas] == -1) maildays = def_days;
  784.             else maildays = Areaday[msgareas];
  785.             
  786.             if(Areamin[msgareas] == -1) mailmin = minmsgs;
  787.             else mailmin = Areamin[msgareas];
  788.             
  789.             mailkeep = Areakeep[msgareas];
  790.             Horg = Hday = Hmin = Hrd = Huse = Hkp = Hgr = Hrand = 0;
  791.             
  792.             continue;
  793.         }
  794.         
  795.         /*
  796.         **    Trasharea path found in areas
  797.         */
  798.         
  799.         if (!stricmp(temp, "trasharea"))
  800.         {
  801.             if (strlen(trasharea)) free(trasharea);
  802.             
  803.             trasharea = (BYTE *) myalloc(strlen(Areapath[msgareas]) + 10);
  804.             sprintf(trasharea, "%s", Areapath[msgareas]);
  805.             
  806.             if (Areaday[msgareas] == -1) trashdays = def_days;
  807.             else trashdays = Areaday[msgareas];
  808.             
  809.             if (Areamin[msgareas] == -1) trashmin = minmsgs;
  810.             else trashmin = Areamin[msgareas];
  811.             
  812.             trashkeep = Areakeep[msgareas];
  813.             Horg = Hday = Hmin = Hrd = Huse = Hkp = Hgr = Hrand = 0;
  814.             
  815.             continue;
  816.         }
  817.         
  818.         /*
  819.         **    Dupe messages in this area.
  820.         */
  821.         
  822.         if (!stricmp(temp, "dupe_area"))
  823.         {
  824.             if (strlen(dupearea)) free(dupearea);
  825.             dupearea = ctl_string (Areapath[msgareas]);
  826.  
  827.             if (Areaday[msgareas] == -1) dupedays = def_days;
  828.             else dupedays = Areaday[msgareas];
  829.             
  830.             if(Areamin[msgareas] == -1) dupemin = minmsgs;
  831.             else dupemin = Areamin[msgareas];
  832.             
  833.             dupekeep = Areakeep[msgareas];
  834.             Horg = Hday = Hmin = Hrd = Huse = Hkp = Hgr = Hrand = 0;
  835.             
  836.             continue;
  837.         }
  838.             
  839.         if (!stricmp(temp, "privateboxarea"))
  840.         {
  841.             PVTmailBOX:
  842.             
  843.             if (strlen(privatebox)) free(privatebox);
  844.             
  845.             privatebox = (BYTE *) myalloc(strlen(Areapath[msgareas]) +10);
  846.             sprintf(privatebox, "%s", Areapath[msgareas]);
  847.             
  848.             if (Areaday[msgareas] == -1) pvtboxdays = def_days;
  849.             else pvtboxdays = Areaday[msgareas];
  850.             
  851.             if(Areamin[msgareas] == -1) pvtboxmin = minmsgs;
  852.             else pvtboxmin = Areamin[msgareas];
  853.             
  854.             pvtkeep = Areakeep[msgareas];
  855.             Horg = Hday = Hmin = Hrd = Huse = Hkp = Hgr = Hrand = 0;
  856.             
  857.             continue;
  858.         }
  859.         
  860.         if (!stricmp(temp, "privatemailbox")) goto PVTmailBOX;
  861.         if (!stricmp(temp, "privatemail")) goto PVTmailBOX;
  862.         
  863.         /*
  864.         **    Normal echomail
  865.         */
  866.         
  867.         Areaname[msgareas] = ctl_string(temp);
  868.         
  869.         p = skip_blanks(p);
  870.         
  871.         /*
  872.         **    Check on non nummeric numbers.
  873.         */
  874.         
  875.         if (!isdigit (*p) && strlen (p)) {
  876.             log_line (6, "!Error in areafile, no nodenumber specified.");
  877.             terminate (10);
  878.         }
  879.                 
  880.         /*
  881.         **    Store connected systems as words
  882.         */
  883.         
  884.         get_connected(p, msgareas);
  885.         
  886.         /*
  887.         **    Look for origin etc.
  888.         */
  889.  
  890.         if (Areaorg[msgareas] == NULL) Areaorg[msgareas] = ctl_string(Mainorg);
  891.         
  892.         if (Areaday[msgareas] == -1) Areaday[msgareas] = def_days;
  893.         if (Areamin[msgareas] == -1) Areamin[msgareas] = minmsgs;
  894.         
  895.         Areamsgs[msgareas] = 0;
  896.         Tosysop[msgareas] = 0;
  897.         Horg = Hday = Hmin = Hrd = Huse = Hkp = Hgr = Hrand = 0;
  898.         
  899.         if (PASSarea == TRUE)
  900.             Dareas[msgareas++] = 1;
  901.         else
  902.             Dareas[msgareas++] = what;
  903.             
  904.         PASSarea = FALSE;
  905.     }
  906.     
  907.     fclose(FDUMMY);
  908.     sprintf(temp, "%s%s", Envpath, filename);
  909.     attrib = Fattrib(temp, 0, -1);
  910.     if (attrib != -33 && attrib != -34 && attrib & FA_ARCHIVE)
  911.     {
  912.         if (intel(Sversion()) >= 0x0015U)
  913.             Fattrib(temp, 1, 0);
  914.         else
  915.             Fattrib(temp, 1, FA_ARCHIVE);
  916.     }
  917.         
  918.     return (TRUE);
  919. }
  920.  
  921. VOID read_lednew(VOID)
  922. {
  923.     CONST BYTE    *filename = "LED.NEW";
  924.     BYTE        buffer[2048],
  925.                 temp[130],
  926.                 *q, *p;
  927.     WORD        i;
  928.     
  929.     sprintf(temp, "%s%s", Envpath, filename);
  930.     
  931.     if ((FDUMMY = fopen(temp, "r")) == NULL)
  932.     {
  933.         log_line(-1,Logmessage[M__NO_OPEN_CREATE], temp);
  934.         
  935.         for (i = 0; i < msgareas; i++)
  936.         {
  937.             Lareaname[i] = ctl_string(Areaname[i]);
  938.             Lledmask[i] = Lledmsgs[i] = 0;
  939.         }
  940.         
  941.         nled = msgareas;
  942.         return;
  943.     }
  944.     
  945.     while (fgets(buffer, 2048, FDUMMY))
  946.     {
  947.         p = skip_blanks(buffer);
  948.         if (*p == ';') continue;
  949.         if ((i = (WORD)strlen(p)) < 3) continue;
  950.         
  951.         giveTIMEslice();
  952.         
  953.         p = &p[--i];
  954.         *p = EOS;
  955.         
  956.         if ((p = strchr(buffer, ';')) != NULL) *p = EOS;
  957.         
  958.         p = skip_blanks(buffer);
  959.         if (!*p) continue;
  960.         
  961.         for (q = temp; *p && !isspace(*p); *q++ = *p++);
  962.         *q = EOS;
  963.         
  964.         Lareaname[nled] = ctl_string(temp);
  965.         
  966.         p = skip_blanks(p);
  967.         
  968.         if (!*p)
  969.         {
  970.             Lledmsgs[nled] = Lledmask[nled++] = 0;
  971.             continue;
  972.         }
  973.         
  974.         for (q = temp; *p && !isspace(*p); *q++ = *p++);
  975.         *q = EOS;
  976.         
  977.         Lledmsgs[nled] = atoi(temp);
  978.         
  979.         p = skip_blanks(p);
  980.         
  981.         if (!*p)
  982.         {
  983.             Lledmask[nled++] = 0;
  984.             continue;
  985.         }
  986.         
  987.         Lledmask[nled++] = atoi(p);
  988.     }
  989.     
  990.     fclose(FDUMMY);
  991.     
  992.     return;
  993. }
  994.  
  995. VOID write_lednew(VOID)
  996. {
  997.     BYTE    buffer[128];
  998.     WORD    i, j;
  999.     
  1000.     log_line(4,Logmessage[M__WRITE_LASTRD]);
  1001.     
  1002.     sprintf(buffer, "%sLED.NEW", Envpath);
  1003.     
  1004.     if ((OUT = fopen(buffer, "w")) == NULL)
  1005.     {
  1006.         log_line(6,Logmessage[M__CANT_OPEN_LR]);
  1007.         return;
  1008.     }
  1009.     
  1010.     if (nnetmails) {
  1011.         if(nled) {
  1012.             if (Lareaname[0])
  1013.                 fprintf(OUT, "%s %d %d\n", Lareaname[0], Lledmsgs[0],
  1014.                     (Lledmask[0] | (UNREADMSGS|NEWMSGS|SYSOPMSGS)));
  1015.         }
  1016.         else if (Lareaname[0])
  1017.             fprintf(OUT, "%-20s 0 4\n", "FidoNetmail");
  1018.     }
  1019.     else if (Lareaname[0])
  1020.         fprintf(OUT, "%-20s %d %d\n", Lareaname[0], Lledmsgs[0], Lledmask[0]);
  1021.     
  1022.     for (i = 0; i < msgareas; i++)
  1023.     {
  1024.         if (Dareas[i]) continue;
  1025.         
  1026.         for (j = 0; j < nled; j++) {
  1027.             giveTIMEslice();
  1028.             
  1029.             if (Lareaname[j]) {
  1030.                 if (!stricmp(Lareaname[j], Areaname[i]))
  1031.                 {
  1032.                     if (Tosysop[i]) Lledmask[j] |= SYSOPMSGS;
  1033.                     
  1034.                     fprintf(OUT, "%-20s %d %d\n", Lareaname[j], Lledmsgs[j],
  1035.                         (Areamsgs[i]) ? (Lledmask[j] | (UNREADMSGS|NEWMSGS)) : Lledmask[j]);
  1036.                     break;
  1037.                 }
  1038.             }
  1039.         }
  1040.         if (j >= nled) fprintf(OUT, "%-20s 0 %d\n", Areaname[i], (UNREADMSGS|NEWMSGS));
  1041.     }
  1042.     
  1043.     for (i = 0; i < nled; i++)
  1044.     {
  1045.         if (!stricmp(Lareaname[i], "privateboxarea"))
  1046.         {
  1047.             strcpy(buffer, "PRIVATEBOXAREA");
  1048.             break;
  1049.         }
  1050.         
  1051.         if (!stricmp(Lareaname[i], "privatemailbox"))
  1052.         {
  1053.             strcpy(buffer, "PRIVATEMAILAREA");
  1054.             break;
  1055.         }
  1056.         
  1057.         if (!stricmp(Lareaname[i], "privatemail"))
  1058.         {
  1059.             strcpy(buffer, "PRIVATEMAIL");
  1060.             break;
  1061.         }
  1062.     }
  1063.     
  1064.     if (i < nled) fprintf(OUT, "%-20s %d %d\n", buffer, Lledmsgs[i],
  1065.         (nprivate) ? (Lledmask[i] | (UNREADMSGS|NEWMSGS)) : Lledmask[i]);
  1066.     
  1067.     for (i = 0; i < nled; i++)
  1068.         if (!stricmp(Lareaname[i], "trasharea"))
  1069.         {
  1070.             fprintf(OUT, "%-20s %d %d\n", "TRASHAREA", Lledmsgs[i],
  1071.                 (ntrashed) ? (Lledmask[i] | (UNREADMSGS|NEWMSGS)) : Lledmask[i]);
  1072.             break;
  1073.         }
  1074.     
  1075.     for (i = 0; i < nled; i++) {
  1076.         if (stricmp(Lareaname[i], "dupearea")) {
  1077.             fprintf(OUT, "%-20s %d %d\n", "DUPEAREA", Lledmsgs[i],
  1078.             (HaveDUPES) ? (Lledmask[i] | (NEWMSGS)) : Lledmask[i]);
  1079.             break;
  1080.         }
  1081.     }
  1082.     
  1083.     fclose(OUT); 
  1084. }
  1085.  
  1086. BOOLEAN init_cfg(BOOLEAN *foundlabel)
  1087. {
  1088.     BYTE    *p = getenv("MAILER"),
  1089.             *q,
  1090.             *cfgname = CONFIGFILE,
  1091.             buffer[1024],        /*    line buffer of statements    */
  1092.             temp[1024],
  1093.             *havelabel = "",    /*    having labels                */
  1094.             uselabel = NOLABEL,
  1095.             No[30];
  1096.     WORD    line = 0;
  1097.     UWORD    i;                    /*    dummy integer                */
  1098.     
  1099.     if (findfirst(cfgname, &blok, 0) && p && *p != EOS)
  1100.         Envpath = ctl_path(p);
  1101.     
  1102.     Inboundpaths[0] = Inboundpaths[1] = Inboundpaths[2] = NULL;
  1103.     
  1104.     sprintf(buffer, "%s%s", Envpath, cfgname);
  1105.     
  1106. #if defined EXTERNDEBUG
  1107.     log_line(6,">Environment path = %s", Envpath);
  1108.     log_line(6,">Config assumed as %s", buffer);
  1109. #endif
  1110.     
  1111.     if ((FDUMMY = fopen(buffer, "r")) == NULL)
  1112.     {
  1113.         log_line(-1,Logmessage[M__CONFIG_NOT_FOUND], buffer);
  1114.         return(FALSE);
  1115.     }
  1116.     
  1117.     RouteDef = (struct _RouteDef *) myalloc(1000L * sizeof(struct _RouteDef));
  1118.     MaxRouteDef = 1000;
  1119.     
  1120.     Dateformat[0] = EOS;
  1121.     
  1122.     while ((fgets(buffer, 1023, FDUMMY)))
  1123.     {
  1124.         line++;
  1125.         p = skip_blanks(buffer);
  1126.         
  1127.         giveTIMEslice();
  1128.         
  1129.         if (*p == ';') continue;
  1130.         if ((i = (WORD)strlen(p)) < 3) continue;
  1131.         if ((p = strchr(buffer, ';')) != NULL) *p = EOS;
  1132.         
  1133.         p = &buffer[--i];
  1134.         
  1135.         if (*p == '\r' || *p == '\n') *p = EOS;
  1136.         
  1137.         p = skip_blanks(buffer);
  1138.         
  1139.         /*
  1140.         **    Using labels? Label starts always with an '#'
  1141.         **    If in the defined label, take all commands etc.
  1142.         */
  1143.         
  1144.         if (dolabel)
  1145.         {
  1146.             if (*p == '#')
  1147.             {
  1148.                 if (strlen(havelabel)) free(havelabel);
  1149.                 
  1150.                 havelabel = ctl_string(skip_blanks(&p[1]));
  1151.                 uselabel = USELABEL;
  1152.                 
  1153.                 if (!stricmp(havelabel, configlabel))
  1154.                     *foundlabel = TRUE;
  1155.                 
  1156.                 if (!stricmp(havelabel, "endlabel"))
  1157.                     uselabel = ENDLABEL;
  1158.                 if (!stricmp(havelabel, "endall"))
  1159.                 {
  1160.                     uselabel = NOLABEL;
  1161.                     dolabel = FALSE;
  1162.                     continue;
  1163.                 }
  1164.                 
  1165.                 continue;
  1166.             }
  1167.             
  1168.             if (uselabel && (stricmp(havelabel, configlabel) ||
  1169.                 uselabel == ENDLABEL)) continue;
  1170.             else
  1171.                 *foundlabel = TRUE;
  1172.         }
  1173.         
  1174.         if (*p == '#') continue;
  1175.         
  1176.         if (!strnicmp(p, "event", 5))
  1177.         {
  1178.             p = skip_blanks(&p[5]);
  1179.             if ((p = parse_event(p)) == NULL) continue;
  1180.         }
  1181.         
  1182.         if (!strnicmp(p, "commands", 8))
  1183.         {
  1184.             if (!dolabel) continue;
  1185.             p = &p[8];
  1186.             
  1187.             while (*p)
  1188.             {
  1189.                 p = skip_blanks(++p);
  1190.                 if (!*p) break;
  1191.                 if (*p == '-') p++;
  1192.                 
  1193.                 if (*p)
  1194.                     switch (toupper(*p))
  1195.                     {
  1196.                         case    'A':    keepmsg = TRUE; break;
  1197.                         case    'B':    toprivate = TRUE; break;
  1198.                         case    'C':    dochanged = TRUE; break;
  1199.                         case    'D':    docrunch = TRUE; break;
  1200.                         case    'E':    log_line(-1,Logmessage[M__CANT_EXEC_LABEL]);
  1201.                                         break;
  1202.                         case    'H':    log_line(-1,Logmessage[M__NO_HELP]);
  1203.                                         break;
  1204.                         case    'I':    doimport = TRUE; break;
  1205.                         case    'K':    doifna = TRUE; break;
  1206.                         case    'L':    doled = TRUE; break;
  1207.                         case    'M':    domsg = TRUE; break;
  1208.                         case    'O':    dopack = TRUE; break;
  1209.                         case    'P':    dopkt = TRUE; break;
  1210.                         case    'Q':    doquit = TRUE; break;
  1211.                         case    'R':    dosecure = TRUE; break;
  1212.                         case    'S':    doscanmail = TRUE; break;
  1213.                         case    'T':    dolog = TRUE; break;
  1214.                         case    'V':    CRspec = TRUE; break;
  1215.                         case    'W':    dowait = TRUE; break;
  1216.                         case    'X':    domulti_reg = TRUE; break;
  1217.                         case    'Z':    dostripzone = TRUE; break;
  1218.                         
  1219.                         default:    log_line(-1,Logmessage[M__SWITCH_CONF], *p, line, CONFIGFILE);
  1220.                     }
  1221.                 else
  1222.                     log_line(-1,Logmessage[M__NO_COMMAND], line, CONFIGFILE);
  1223.             }
  1224.             
  1225.             continue;
  1226.         }
  1227.         
  1228.         if (!strnicmp(p, "sysop", 5))
  1229.         {
  1230.             p = skip_blanks(&p[5]);
  1231.             p = skip_after_blanks(p);
  1232.             
  1233.             strncpy(SysOp, p, 78);
  1234.             SysOp[77] = EOS;
  1235.             continue;
  1236.         }
  1237.         
  1238.         if (!strnicmp(p, "address", 7))
  1239.         {
  1240.             p = skip_blanks(&p[7]);
  1241.             
  1242.             address(p, &alias[nalias].zone, &alias[nalias].net,
  1243.                         &alias[nalias].node, &alias[nalias].point,
  1244.                         &alias[nalias].pointnet, alias[nalias].Domain);
  1245.             
  1246.             nalias++;
  1247.             continue;
  1248.         }
  1249.         
  1250.         if (!strnicmp(p, "netmail", 7))
  1251.         {
  1252.             mailarea = ctl_string(&p[7]);
  1253.             continue;
  1254.         }
  1255.         
  1256.         if (!strnicmp(p, "logfile", 7))
  1257.         {
  1258.             if (!strlen(logfile)) logfile = ctl_string(&p[7]);
  1259.             continue;
  1260.         }
  1261.         
  1262.         if(!strnicmp(p,"loglevel",8)) {
  1263.             p = skip_blanks(&p[8]);
  1264.             if(!*p || !isdigit(*p)) 
  1265.                 log_line(-1,Logmessage[M__NO_LOGLEVEL]);
  1266.             else
  1267.                 loglevel = atoi(p);
  1268.             continue;
  1269.         }
  1270.         
  1271.         if (!strnicmp(p, "nolog", 5))
  1272.         {
  1273.             p = skip_blanks(&p[5]);
  1274.             
  1275.             if (*p == EOS) continue;
  1276.             
  1277.             for (i=0; i < strlen(p); i++)
  1278.                 if (strchr(logtypes, p[i]))
  1279.                     *(strchr(logtypes, p[i])) = ' ';
  1280.             
  1281.             continue;
  1282.         }
  1283.         
  1284.         if (!strnicmp(p, "nodisplay", 9))
  1285.         {
  1286.             p = skip_blanks(&p[9]);
  1287.             
  1288.             if (*p == EOS) continue;
  1289.             
  1290.             for (i=0; i < strlen(p); i++)
  1291.                 if (strchr(disptypes, p[i]))
  1292.                     *(strchr(disptypes, p[i])) = ' ';
  1293.             
  1294.             continue;
  1295.         }
  1296.         
  1297.         if (!strnicmp(p, "mailtemp", 8))
  1298.         {
  1299.             mailtemp = ctl_path(&p[8]);
  1300.             continue;
  1301.         }
  1302.         
  1303.         if (!strnicmp(p, "pkttemp",7)) {
  1304.             pkt_temp = ctl_path(&p[7]);
  1305.             continue;
  1306.         }
  1307.         
  1308.         if (!strnicmp(p, "outbound", 8))
  1309.         {
  1310.             outbound = ctl_path(&p[8]);
  1311.             continue;
  1312.         }
  1313.         
  1314.         if (!strnicmp(p, "inbound", 7))
  1315.         {
  1316.             Inboundpaths[2] = ctl_path(&p[7]);
  1317.             continue;
  1318.         }
  1319.         
  1320.         if (!strnicmp(p, "knowninbound", 12))
  1321.         {
  1322.             Inboundpaths[1] = ctl_path(&p[12]);
  1323.             continue;
  1324.         }
  1325.         
  1326.         if (!strnicmp(p, "protinbound", 11))
  1327.         {
  1328.             Inboundpaths[0] = ctl_path(&p[11]);
  1329.             continue;
  1330.         }
  1331.         
  1332.         if (!strnicmp(p, "trasharea", 9))
  1333.         {
  1334.             trasharea = ctl_file(&p[9]);
  1335.             continue;
  1336.         }
  1337.         
  1338.         if (!strnicmp(p, "archiver", 8))
  1339.         {
  1340.             p = skip_blanks(&p[8]);
  1341.             
  1342.             for (q = temp; *p && !isspace(*p); *q++ = *p++);
  1343.             *q = EOS;
  1344.             
  1345.             Arch = ctl_string(temp);
  1346.             
  1347.             p = skip_blanks(p);
  1348.             if (*p)
  1349.             {
  1350.                 for (q = temp; *p && !isspace(*p); *q++ = *p++);
  1351.                 *q = EOS;
  1352.                 
  1353.                 Archcmdi = ctl_string(temp);
  1354.                 
  1355.                 p = skip_blanks(p);
  1356.                 if (*p) Archcmdo = ctl_string(p);
  1357.                 else goto ARCcommand_error;
  1358.             }
  1359.             else goto ARCcommand_error;
  1360.             
  1361.             continue;
  1362.         }
  1363.         
  1364.         if (!strnicmp(p, "lzharchive", 10))
  1365.         {
  1366.             p = skip_blanks(&p[10]);
  1367.             for (q = temp; *p && !isspace(*p); *q++ = *p++);
  1368.             *q = EOS;
  1369.             
  1370.             Lzh = ctl_file(temp);
  1371.             
  1372.             p = skip_blanks(p);
  1373.             if (*p)
  1374.             {
  1375.                 for (q = temp; *p && !isspace(*p); *q++ = *p++);
  1376.                 *q = EOS;
  1377.                 
  1378.                 LzheC = ctl_string(temp);
  1379.                 
  1380.                 p = skip_blanks(p);
  1381.                 if (*p) LzheA = ctl_string(p);
  1382.                 else goto ARCcommand_error;
  1383.             }
  1384.             else
  1385.             {
  1386.                 ARCcommand_error:
  1387.                 
  1388.                 log_line(-1,Logmessage[M__ARCHIVER_CMD_UNKN], line, CONFIGFILE);
  1389.             }
  1390.             
  1391.             continue;
  1392.         }
  1393.         
  1394.         if (!strnicmp(p, "arcarchive", 10))
  1395.         {
  1396.             p = skip_blanks(&p[10]);
  1397.             for (q = temp; *p && !isspace(*p); *q++ = *p++);
  1398.             *q = EOS;
  1399.             
  1400.             Arc = ctl_file(temp);
  1401.             
  1402.             p = skip_blanks(p);
  1403.             if (*p)
  1404.             {
  1405.                 for (q = temp; *p && !isspace(*p); *q++ = *p++);
  1406.                 *q = EOS;
  1407.                 
  1408.                 ArceC = ctl_string(temp);
  1409.                 
  1410.                 p = skip_blanks(p);
  1411.                 if (*p) ArceA = ctl_string(p);
  1412.                 else goto ARCcommand_error;
  1413.             }
  1414.             else goto ARCcommand_error;
  1415.             
  1416.             continue;
  1417.         }
  1418.         
  1419.         if (!strnicmp(p, "ziparchive", 10))
  1420.         {
  1421.             p = skip_blanks(&p[10]);
  1422.             for (q = temp; *p && !isspace(*p); *q++ = *p++);
  1423.             *q = EOS;
  1424.             
  1425.             Zip = ctl_file(temp);
  1426.             
  1427.             p = skip_blanks(p);
  1428.             if (*p)
  1429.             {
  1430.                 for (q = temp; *p && !isspace(*p); *q++ = *p++);
  1431.                 *q = EOS;
  1432.                 
  1433.                 ZipeC = ctl_string(temp);
  1434.                 
  1435.                 p = skip_blanks(p);
  1436.                 if (*p) ZipeA = ctl_string(p);
  1437.                 else goto ARCcommand_error;
  1438.             }
  1439.             else goto ARCcommand_error;
  1440.             
  1441.             continue;
  1442.         }
  1443.         
  1444.         if (!strnicmp(p, "arjarchive", 10))
  1445.         {
  1446.             p = skip_blanks(&p[10]);
  1447.             for (q = temp; *p && !isspace(*p); *q++ = *p++);
  1448.             *q = EOS;
  1449.             
  1450.             Arj = ctl_file(temp);
  1451.             
  1452.             p = skip_blanks(p);
  1453.             if (*p)
  1454.             {
  1455.                 for (q = temp; *p && !isspace(*p); *q++ = *p++);
  1456.                 *q = EOS;
  1457.                 
  1458.                 ArjeC = ctl_string(temp);
  1459.                 
  1460.                 p = skip_blanks(p);
  1461.                 if (*p) ArjeA = ctl_string(p);
  1462.                 else goto ARCcommand_error;
  1463.             }
  1464.             else goto ARCcommand_error;
  1465.             
  1466.             continue;
  1467.         }
  1468.         
  1469.         if (!strnicmp(p, "applzone", 8))
  1470.         {
  1471.             p = skip_blanks(&p[8]);
  1472.             parse_domain(p);
  1473.             
  1474.             continue;
  1475.         }
  1476.  
  1477.         if(!strnicmp(p,"newbinkley",10)) {
  1478.             donewbink = TRUE;
  1479.             continue;
  1480.         }
  1481.         
  1482.         if(!strnicmp(p,"the-box",7)) {
  1483.             dothebox = TRUE;
  1484.             continue;
  1485.         }
  1486.         
  1487.         if (!strnicmp(p, "password", 8))
  1488.         {
  1489.             p = skip_blanks(&p[8]);
  1490.             parsepassword(p);
  1491.             
  1492.             continue;
  1493.         }
  1494.         
  1495.         if (!strnicmp(p, "boss", 4))
  1496.         {
  1497.             p = skip_blanks(&p[4]);
  1498.             
  1499.             address(p, &bosszone[nbosses], &bossnet[nbosses],
  1500.                 &bossnode[nbosses], &i, &i, q);
  1501.             nbosses++;
  1502.             
  1503.             continue;
  1504.         }
  1505.  
  1506.         if(!strnicmp(p,"copyarea",8)) {
  1507.             p = skip_blanks(&p[8]);
  1508.             
  1509.             Copy_or_Move(p,COPYAREA);
  1510.             
  1511.             continue;
  1512.         }
  1513.         
  1514.         if (!strnicmp(p,"movearea",8)) {
  1515.             p = skip_blanks(&p[8]);
  1516.             
  1517.             Copy_or_Move(p,MOVEAREA);
  1518.             
  1519.             continue;
  1520.         }
  1521.         
  1522.         if (!strnicmp(p,"copy-to-point",13)) {
  1523.             dopointcpy = TRUE;
  1524.             continue;
  1525.         }
  1526.  
  1527.         if (!strnicmp(p, "nodupecheck",11)) {
  1528.             doNOdupecheck = TRUE;
  1529.             continue;
  1530.         }
  1531.                 
  1532.         if (!strnicmp(p,"fdatabase",9)) {
  1533.             p = skip_blanks(&p[9]);
  1534.             
  1535.             if ( !*p ) {
  1536.                 log_line(-1,Logmessage[M__EMPTY_DBASE]);
  1537.                 continue;
  1538.             }
  1539.             
  1540.             if (strlen(FDbase)) {
  1541.                 log_line(-1,Logmessage[M__DBASE_KNOWN]);
  1542.                 continue;
  1543.             }
  1544.             
  1545.             FDbase = ctl_path(p);
  1546.             
  1547.             continue;
  1548.         }
  1549.         
  1550.         if (!strnicmp(p,"fdgetfrom",9)) {
  1551.             p = skip_blanks(&p[9]);
  1552.             
  1553.             if (!*p) {
  1554.                 log_line(-1,Logmessage[M__NO_NAME_DBASE]);
  1555.                 continue;
  1556.             }
  1557.             
  1558.             if (*p != '<' || *p != '>') {
  1559.                 log_line(-1,Logmessage[M__DIRECTION_ERROR]);
  1560.                 continue;
  1561.             }
  1562.             
  1563.             if (*p == '<') FDcompare[nfdbase] = FD_FROM;
  1564.             else           FDcompare[nfdbase] = FD_TO;
  1565.             
  1566.             ToBase[nfdbase++] = ctl_string(&p[1]);
  1567.             
  1568.             continue;
  1569.         }
  1570.  
  1571.         if (!strnicmp(p, "dateformat", 10)) {
  1572.             p = skip_blanks(&p[10]);
  1573.             p = skip_after_blanks(p);
  1574.             
  1575.             strncpy (Dateformat, p, 79);
  1576.             continue;
  1577.         }
  1578.         
  1579.         if (!strnicmp(p, "shorttear", 9)) {
  1580.             doonly_tear = TRUE;
  1581.             continue;
  1582.         }
  1583.         
  1584.         if (!strnicmp(p, "adddomain",9)) {
  1585.             doadd_domain = TRUE;
  1586.             p = skip_blanks(&p[9]);
  1587.             while (*p) {
  1588.                 if (*p && isdigit(*p)) {
  1589.                     for (q=temp; *p && !isspace(*p); *q++ = *p++);
  1590.                     *q= EOS;
  1591.                     if (strlen(temp))
  1592.                         Zdomain[Ndomain++] = atoi(temp);
  1593.                     p = skip_blanks(p);
  1594.                 } else {
  1595.                     p = skip_to_blank(p);
  1596.                     p = skip_blanks(p);
  1597.                 }
  1598.                 if (!*p) break;
  1599.             }
  1600.             continue;
  1601.         }
  1602.         
  1603.         if (!strnicmp(p, "nopoint", 7)) {
  1604.             p = skip_blanks(&p[7]);
  1605.             while (*p) {
  1606.                 if (*p && isdigit(*p)) {
  1607.                     for(q=temp ; *p && !isspace(*p); *q++=*p++);
  1608.                     *q = EOS;
  1609.                     if (strlen(temp)) 
  1610.                         Zpoint[Npoint++] = atoi(temp);
  1611.                     p = skip_blanks(p);
  1612.                 } else {
  1613.                     p = skip_to_blank(p);
  1614.                     p = skip_blanks(p);
  1615.                 }
  1616.                 if (!*p) break;
  1617.             }
  1618.             continue;
  1619.         }
  1620.         
  1621.         if (!strnicmp(p, "multitasker", 11)) {
  1622.             p = skip_blanks(&p[11]);
  1623.             p = skip_after_blanks(p);
  1624.             
  1625.             for (i=0 ;Mtasker[i] != NULL; i++) {
  1626.                 if (!stricmp(p , Mtasker[i]))
  1627.                     MTask = i+1;
  1628.                 
  1629.             }
  1630.             
  1631.             if (MTask == MULTIGEM) install_gem();
  1632.             
  1633.             continue;
  1634.         }
  1635.  
  1636.         if (!strnicmp(p, "fastimport", 10)) {
  1637.             dofastimport = TRUE;
  1638.             continue;
  1639.         }
  1640.         
  1641.         if (!strnicmp(p, "tinyseenby", 10)) {
  1642.             donopointadd = TRUE;
  1643.             continue;
  1644.         }
  1645.         
  1646.         if (!strnicmp(p, "tinypath", 8)) {
  1647.             donopointpath = TRUE;
  1648.             continue;
  1649.         }
  1650.         
  1651.         if (!strnicmp(p, "defaultpkt", 10)) {
  1652.             p = skip_blanks(&p[10]);
  1653.             
  1654.             if (!*p) continue;
  1655.             
  1656.             for (i=0; DFTpkt[i] != NULL; i++) {
  1657.                 if (!strnicmp(p, DFTpkt[i], strlen(DFTpkt[i]))) {
  1658.                     defPKT = i;
  1659.                     break;
  1660.                 }
  1661.             }
  1662.             continue;
  1663.         }
  1664.         
  1665.         if (!strnicmp(p, "sendalwayspkt", 13)) {
  1666.             dosentpkt = TRUE;
  1667.             continue;
  1668.         }
  1669.         
  1670.         if (!strnicmp(p, "checknames", 10)) {
  1671.             docheckname = TRUE;
  1672.             continue;
  1673.         }
  1674.  
  1675.         if (!strnicmp(p, "strippid", 8)) {
  1676.             dostripPID = TRUE;
  1677.             continue;
  1678.         }
  1679.         
  1680.         if (!strnicmp(p, "msgbuffer", 9)) {
  1681.             p = skip_blanks(&p[9]);
  1682.             
  1683.             if (isdigit(*p)) {
  1684.                 for (q=temp; *p && !isspace(*p); *q++=*p++);
  1685.                 *q=EOS;
  1686.                 MAXMSGLENGTH = atol(temp);
  1687.                 if (MAXMSGLENGTH < 8192L)
  1688.                     MAXMSGLENGTH = 8192L;
  1689.             }
  1690.             continue;
  1691.         }
  1692.  
  1693.         if (!strnicmp(p, "4dmsgheader", 11)) {
  1694.             MSGheader4d = TRUE;
  1695.             continue;
  1696.         }
  1697.         
  1698.         if (!strnicmp (p, "KeepFidoBits", 12)) {
  1699.             SENDfido_bits = TRUE;
  1700.             continue;
  1701.         }
  1702.  
  1703.         if (!strnicmp(p, "stripcontrols", 12)) {
  1704.             dostripINTL = TRUE;
  1705.             continue;
  1706.         }
  1707.         
  1708.         if (!strnicmp (p, "auto-addareas", 13)) {
  1709.             doAUTOaddareas = TRUE;
  1710.             continue;
  1711.         }
  1712.                 
  1713.         if (!strnicmp(p, "killfrom", 8)) {
  1714.             p = skip_blanks(&p[8]);
  1715.             
  1716.             if (!*p)
  1717.             {
  1718.                 log_line(-1,Logmessage[M__NO_NAME_KILL], line, CONFIGFILE);
  1719.                 continue;
  1720.             }
  1721.             
  1722.             Killfrom[nkill++] = ctl_string(p);
  1723.             continue;
  1724.         }
  1725.         
  1726.         if (!strnicmp( p, "defaultgroup", 12)) {
  1727.             p = skip_blanks(&p[12]);
  1728.             strncpy( &Defaultgroup, p, 1);
  1729.             doDEFgroup = TRUE;
  1730.             continue;
  1731.         }
  1732.         
  1733.         if (!strnicmp(p, "minpacketsize", 13))
  1734.         {
  1735.             p = skip_blanks(&p[13]);
  1736.             minpktsize = atol(p);
  1737.             continue;
  1738.         }
  1739.         
  1740.         if (!strnicmp(p, "dupelog", 7)) {
  1741.             p = skip_blanks(&p[7]);
  1742.             DupeLog = atol(p);
  1743.             continue;
  1744.         }
  1745.         
  1746. #if defined OUTDEBUG
  1747.         if (!strnicmp(p, "outmaildebug", 12))
  1748.         {
  1749.             dooutdeb = TRUE;
  1750.             continue;
  1751.         }
  1752. #endif
  1753.         
  1754.         if (!strnicmp(p, "nonetmailpack", 13))
  1755.         {
  1756.             donopack = TRUE;
  1757.             continue;
  1758.         }
  1759.         
  1760.         if (!strnicmp(p, "redirectnetmail", 15))
  1761.         {
  1762.             doredirect = TRUE;
  1763.             continue;
  1764.         }
  1765.         
  1766.         if (!strnicmp(p, "addaka", 6))
  1767.         {
  1768.             doadd_AKA = TRUE;
  1769.             continue;
  1770.         }
  1771.         
  1772.         if (!strnicmp(p, "pathcheck", 9))
  1773.         {
  1774.             dopathcheck = TRUE;
  1775.             continue;
  1776.         }
  1777.         
  1778.         if (!strnicmp(p, "nozone", 6))
  1779.         {
  1780.             donozone = TRUE;
  1781.             continue;
  1782.         }
  1783.         
  1784. #if defined EXTERNDEBUG
  1785.         if (!strnicmp(p, "debug", 5))
  1786.         {
  1787.             debugflag = TRUE;
  1788.             continue;
  1789.         }
  1790. #endif
  1791.         
  1792.         if (!strnicmp(p, "niceoutput", 10))
  1793.         {
  1794.             doniceout = TRUE;
  1795.             continue;
  1796.         }
  1797.         
  1798.         if (!strnicmp(p, "qbbslastread", 12))
  1799.         {
  1800.             p = skip_blanks(&p[12]);
  1801.             
  1802.             if (!*p)
  1803.             {
  1804.                 log_line(-1,Logmessage[M__NO_QBBS]);
  1805.                 continue;
  1806.             }
  1807.             
  1808.             Qbbslr = ctl_file(p);
  1809.             doQbbslr = TRUE;
  1810.             
  1811.             continue;
  1812.         }
  1813.         
  1814.         if (!strnicmp(p, "mindiskspace", 12))
  1815.         {
  1816.             p = skip_blanks(&p[12]);
  1817.             
  1818.             if (!*p)
  1819.             {
  1820.                 log_line(-1,Logmessage[M__NO_NUMBER_DISKSPC], line, CONFIGFILE);
  1821.                 
  1822.                 continue;
  1823.             }
  1824.             
  1825.             mindiskspace = atol(p);
  1826.             dodiskcheck = TRUE;
  1827.             
  1828.             continue;
  1829.         }
  1830.         
  1831.         if (!strnicmp(p, "minmessages", 11))
  1832.         {
  1833.             p = skip_blanks(&p[11]);
  1834.             
  1835.             if (isdigit(*p)) minmsgs = atoi(p);
  1836.             continue;
  1837.         }
  1838.         
  1839.         if (!strnicmp(p, "maxmessages", 11))
  1840.         {
  1841.             p = skip_blanks(&p[11]);
  1842.             
  1843.             if (isdigit(*p)) maxmsgs = (UWORD) atoi(p);
  1844.             continue;
  1845.         }
  1846.         
  1847.         if (!strnicmp(p, "defdays", 7))
  1848.         {
  1849.             p = skip_blanks(&p[7]);
  1850.             
  1851.             if (isdigit(*p)) def_days = atoi(p);
  1852.             continue;
  1853.         }
  1854.         
  1855.         if (!strnicmp(p, "compactmsgs", 11))
  1856.         {
  1857.             p = skip_blanks(&p[11]);
  1858.             
  1859.             if (isdigit(*p)) defcrunch = (BYTE) atoi(p);
  1860.             if (defcrunch > CRUNCHALWAYS) defcrunch = AFTERSCAN;
  1861.             
  1862.             continue;
  1863.         }
  1864.         
  1865.         if (!strnicmp(p, "keepprivate", 11))
  1866.         {
  1867.             dosaveprivate = TRUE;
  1868.             continue;
  1869.         }
  1870.         
  1871.         if (!strnicmp(p, "killsent", 8))
  1872.         {
  1873.             dokillsent = TRUE;
  1874.             continue;
  1875.         }
  1876.         
  1877.         if (!strnicmp(p, "msgreport", 9))
  1878.         {
  1879.             doreport = TRUE;
  1880.             continue;
  1881.         }
  1882.         
  1883.         if (!strnicmp(p, "realname", 8))
  1884.         {
  1885.             p = skip_blanks(&p[8]);
  1886.             
  1887.             if (isdigit(*p)) dorealname = (BYTE) atoi(p);
  1888.             else dorealname = REALAL;
  1889.             
  1890.             continue;
  1891.         }
  1892.         
  1893.         if (!strnicmp(p, "killall", 7))
  1894.         {
  1895.             dokillall = TRUE;
  1896.             continue;
  1897.         }
  1898.         
  1899.         if (!strnicmp(p, "copypvtmail", 11))
  1900.         {
  1901.             dopvtmail = TRUE;
  1902.             continue;
  1903.         }
  1904.         
  1905.         if (!strnicmp(p, "packknown", 9))
  1906.         {
  1907.             doknown = TRUE;
  1908.             continue;
  1909.         }
  1910.         
  1911.         if (!strnicmp(p, "areafix", 7))
  1912.         {
  1913.             p = skip_blanks(&p[7]);
  1914.             
  1915.             for (q = temp; *p && !isspace(*p); *q++ =*p++);
  1916.             *q = EOS;
  1917.             
  1918.             Areafix = ctl_string(temp);
  1919.             
  1920.             p = skip_blanks(p);
  1921.             p = skip_after_blanks(p);
  1922.             
  1923.             Areafixcmd = (BYTE *) myalloc(strlen(p)+2);
  1924.             strcpy(Areafixcmd, p);
  1925.             
  1926.             doareafix = TRUE;
  1927.             continue;
  1928.         }
  1929.         
  1930.         if (!strnicmp(p, "capture", 7))
  1931.         {
  1932.             p = skip_blanks(&p[7]);
  1933.             
  1934.             address(p, &capbuf[ncapbuf].zone, &capbuf[ncapbuf].net,
  1935.                 &capbuf[ncapbuf].node, &capbuf[ncapbuf].point, &i, q);
  1936.             
  1937.             p = skip_to_blank(p);
  1938.             p = skip_blanks(p);
  1939.             p = skip_after_blanks(p);
  1940.             strcpy(capbuf[ncapbuf++].name, p);
  1941.             
  1942.             continue;
  1943.         }
  1944.         
  1945.         if (!strnicmp(p, "savelocal", 9))
  1946.         {
  1947.             dosavelocal = TRUE;
  1948.             continue;
  1949.         }
  1950.         
  1951.         if (!strnicmp(p, "savescreen", 10))
  1952.         {
  1953.             p = skip_blanks(&p[10]);
  1954.             
  1955.             _screen = atoi(p);
  1956.             continue;
  1957.         }
  1958.         
  1959.         if (!strnicmp (p, "readdress", 9)) {
  1960.             p = skip_blanks (&p[9]);
  1961.             
  1962.             parse_readdress(p);
  1963.             continue;
  1964.         }
  1965.         
  1966.         if (!strnicmp (p, "trackmessage", 12)) {
  1967.             p = skip_blanks(&p[12]);
  1968.  
  1969.             TRACKmsg = ctl_string (p);
  1970.             continue;
  1971.         }
  1972.         
  1973.         if (!strnicmp (p ,"nodelist", 8)) {
  1974.             p = skip_blanks (&p[8]);
  1975.             
  1976.             NODElist[nnodelist++] = ctl_string(p);
  1977.             continue;
  1978.         }
  1979.         
  1980.         if (!strnicmp(p, "arc-for", 7))
  1981.         {
  1982.             p = skip_blanks(&p[7]);
  1983.             
  1984.             while (*p)
  1985.             {
  1986.                 RouteDef[nRouteDef].flags = SENDARC;
  1987.                 
  1988.                 for (q = temp; *p && !isspace(*p); *q++=*p++);
  1989.                 *q = EOS;
  1990.                 
  1991.                 strncpy(RouteDef[nRouteDef++].destnode, temp, 29);
  1992.                 check_N_space();
  1993.                 p = skip_blanks(p);
  1994.             }
  1995.             
  1996.             continue;
  1997.         }
  1998.         
  1999.         if (!strnicmp (p, "track-except", 12)) {
  2000.             
  2001.             doNODELIST = TRUE;
  2002.             
  2003.             p = skip_blanks(&p[12]);
  2004.             
  2005.             while (*p)
  2006.             {
  2007.                 RouteDef[nRouteDef].flags = MSGTRACK;
  2008.                 
  2009.                 for (q = temp; *p && !isspace(*p); *q++=*p++);
  2010.                 *q = EOS;
  2011.                 
  2012.                 strncpy(RouteDef[nRouteDef++].destnode, temp, 29);
  2013.                 check_N_space();
  2014.                 p = skip_blanks(p);
  2015.             }
  2016.             
  2017.             continue;
  2018.         }
  2019.         
  2020.         if (!strnicmp(p, "move-mail", 9))
  2021.         {
  2022.             p = skip_blanks(&p[9]);
  2023.             
  2024.             for (q = temp; *p && !isspace(*p); *q++=*p++);
  2025.             *q = EOS;
  2026.             
  2027.             if (!*p)
  2028.             {
  2029.                 log_line(-1,Logmessage[M__NO_NODE_MOVE_M], temp);
  2030.                 RouteDef[nRouteDef].flags = 0;
  2031.                 
  2032.                 continue;
  2033.             }
  2034.             
  2035.             strncpy(No, temp, 29);
  2036.             
  2037.             p = skip_blanks(p);
  2038.             
  2039.             while (*p)
  2040.             {
  2041.                 RouteDef[nRouteDef].flags = KNOWNAS;
  2042.                 
  2043.                 for (q = temp; *p && !isspace(*p); *q++=*p++);
  2044.                 *q = EOS;
  2045.                 
  2046.                 strncpy(RouteDef[nRouteDef].fromnode, temp, 29);
  2047.                 strcpy(RouteDef[nRouteDef++].destnode, No);
  2048.                 check_N_space();
  2049.                 p = skip_blanks(p);
  2050.             }
  2051.             
  2052.             continue;
  2053.         }
  2054.         
  2055.         if (!strnicmp(p, "hold-for", 8))
  2056.         {
  2057.             p = skip_blanks(&p[8]);
  2058.             
  2059.             while (*p)
  2060.             {
  2061.                 RouteDef[nRouteDef].flags = HOLDMSG;
  2062.                 
  2063.                 for (q = temp; *p && !isspace(*p); *q++=*p++);
  2064.                 *q = EOS;
  2065.                 
  2066.                 strncpy((BYTE *)RouteDef[nRouteDef++].destnode, temp, 29);
  2067.                 check_N_space();
  2068.                 p = skip_blanks(p);
  2069.             }
  2070.             
  2071.             continue;
  2072.         }
  2073.         
  2074.         if (!strnicmp(p, "route", 5))
  2075.         {
  2076.             p = skip_blanks(&p[5]);
  2077.             
  2078.             for (q = temp; *p && !isspace(*p); *q++=*p++);
  2079.             *q = EOS;
  2080.             
  2081.             strncpy(No, temp, 29);
  2082.             
  2083.             p = skip_blanks(p);
  2084.             
  2085.             while (*p)
  2086.             {
  2087.                 RouteDef[nRouteDef].flags = ROUTE;
  2088.                 
  2089.                 for(q = temp; *p && !isspace(*p); *q++=*p++);
  2090.                 *q = EOS;
  2091.                 
  2092.                 strncpy(RouteDef[nRouteDef].fromnode, temp, 29);
  2093.                 strcpy(RouteDef[nRouteDef++].destnode, No);
  2094.                 check_N_space();
  2095.                 p = skip_blanks(p);
  2096.             }
  2097.             
  2098.             continue;
  2099.         }            
  2100.         
  2101.         if (!strnicmp(p, "file-to", 7))
  2102.         {
  2103.             p = skip_blanks(&p[7]);
  2104.             
  2105.             while (*p)
  2106.             {
  2107.                 RouteDef[nRouteDef].flags = FILETO;
  2108.                 
  2109.                 for (q = temp; *p && !isspace(*p); *q++=*p++);
  2110.                 *q = EOS;
  2111.                 
  2112.                 strncpy(RouteDef[nRouteDef++].destnode, temp, 29);
  2113.                 check_N_space();
  2114.                 p = skip_blanks(p);
  2115.             }
  2116.             
  2117.             continue;
  2118.         }
  2119.         
  2120.         if (!strnicmp(p, "prepare-poll", 12))
  2121.         {
  2122.             p = skip_blanks(&p[12]);
  2123.             
  2124.             while (*p)
  2125.             {
  2126.                 RouteDef[nRouteDef].flags = POLLNODE;
  2127.                 
  2128.                 for (q = temp; *p && !isspace(*p); *q++=*p++);
  2129.                 *q = EOS;
  2130.                 
  2131.                 strncpy(RouteDef[nRouteDef++].destnode, temp, 29);
  2132.                 check_N_space();
  2133.                 p = skip_blanks(p);
  2134.             }
  2135.             
  2136.             continue;
  2137.         }
  2138.         
  2139.         if (!strnicmp(p, "hold-to-poll", 12))
  2140.         {
  2141.             p = skip_blanks(&p[12]);
  2142.             
  2143.             while (*p)
  2144.             {
  2145.                 RouteDef[nRouteDef].flags = HOLDPOLL;
  2146.                 
  2147.                 for (q = temp; *p && !isspace(*p); *q++=*p++);
  2148.                 *q = EOS;
  2149.                 
  2150.                 strncpy(RouteDef[nRouteDef++].destnode,temp,29);
  2151.                 check_N_space();
  2152.                 p = skip_blanks(p);
  2153.             }
  2154.             
  2155.             continue;
  2156.         }
  2157.  
  2158.         if (!strnicmp(p, "crash-point", 11))
  2159.         {
  2160.             p = skip_blanks(&p[11]);
  2161.             
  2162.             while(*p) {
  2163.                 RouteDef[nRouteDef].flags = CRASHPOINT;
  2164.                 for (q = temp; *p && !isspace(*p); *q++=*p++);
  2165.                 *q = EOS;
  2166.                 
  2167.                 strncpy(RouteDef[nRouteDef++].destnode, temp, 29);
  2168.                 check_N_space();
  2169.                 p = skip_blanks(p);
  2170.             }
  2171.             continue;
  2172.         }
  2173.                 
  2174.         if (!strnicmp (p, "deny-except", 10)) {
  2175.             
  2176.             doDENIED = TRUE;
  2177.             
  2178.             p = skip_blanks(&p[8]);
  2179.             
  2180.             while (*p)
  2181.             {
  2182.                 RouteDef[nRouteDef].flags = DENYOK;
  2183.                 
  2184.                 for (q = temp; *p && !isspace(*p); *q++=*p++);
  2185.                 *q = EOS;
  2186.                 
  2187.                 strncpy(RouteDef[nRouteDef++].destnode, temp, 29);
  2188.                 check_N_space();
  2189.                 p = skip_blanks(p);
  2190.             }
  2191.             continue;
  2192.         }
  2193.                              
  2194.         if (!strnicmp(p, "crash-to", 8))
  2195.         {
  2196.             p = skip_blanks(&p[8]);
  2197.             
  2198.             while (*p)
  2199.             {
  2200.                 RouteDef[nRouteDef].flags = CRASHOK;
  2201.                 
  2202.                 for (q = temp; *p && !isspace(*p); *q++=*p++);
  2203.                 *q = EOS;
  2204.                 
  2205.                 strncpy(RouteDef[nRouteDef++].destnode, temp, 29);
  2206.                 check_N_space();
  2207.                 p = skip_blanks(p);
  2208.             }
  2209.             continue;
  2210.         }
  2211.         
  2212.         if (!strnicmp(p, "hold-max", 8))
  2213.         {
  2214.             p = skip_blanks(&p[8]);
  2215.             
  2216.             for (q = temp; *p && !isspace(*p); *q++=*p++);
  2217.             *q = EOS;
  2218.             
  2219.             strncpy(No, temp, 29);
  2220.             p = skip_blanks(p);
  2221.             
  2222.             while (*p)
  2223.             {
  2224.                 RouteDef[nRouteDef].flags = HOLDMAX;
  2225.                 
  2226.                 for (q = temp; *p && !isspace(*p); *q++=*p++);
  2227.                 *q = EOS;
  2228.                 
  2229.                 strncpy(RouteDef[nRouteDef].destnode, temp, 29);
  2230.                 strcpy(RouteDef[nRouteDef++].fromnode, No);
  2231.                 
  2232.                 check_N_space();
  2233.                 p = skip_blanks(p);
  2234.             }
  2235.             
  2236.             continue;
  2237.         }                
  2238.                 
  2239.         if (!strnicmp(p, "hold-del", 8))
  2240.         {
  2241.             p = skip_blanks(&p[8]);
  2242.             
  2243.             for (q = temp; *p && !isspace(*p); *q++ = *p++);
  2244.             *q = EOS;
  2245.             
  2246.             strncpy(No, temp, 29);
  2247.             p = skip_blanks(p);
  2248.             
  2249.             while (*p)
  2250.             {
  2251.                 RouteDef[nRouteDef].flags = HOLDDEL;
  2252.                 
  2253.                 for (q = temp; *p && !isspace(*p); *q++ = *p++);
  2254.                 *q = EOS;
  2255.                 
  2256.                 strncpy(RouteDef[nRouteDef].destnode, temp, 29);
  2257.                 strcpy(RouteDef[nRouteDef++].fromnode, No);
  2258.                 
  2259.                 check_N_space();
  2260.                 p = skip_blanks(p);
  2261.             }
  2262.             
  2263.             continue;
  2264.         }                
  2265.  
  2266.         if (!strnicmp(p, "file-max", 8))
  2267.         {
  2268.             p = skip_blanks(&p[8]);
  2269.             
  2270.             for (q = temp; *p &&!isspace(*p); *q++ = *p++);
  2271.             *q = EOS;
  2272.             
  2273.             strncpy(No, temp, 29);
  2274.             p = skip_blanks(p);
  2275.             
  2276.             if (!*p)
  2277.             {
  2278.                 log_line(-1,Logmessage[M__NO_NODE_FILE_M]);
  2279.                 continue;
  2280.             }
  2281.             
  2282.             while (*p)
  2283.             {
  2284.                 RouteDef[nRouteDef].flags = FILEMAX;
  2285.                 
  2286.                 for (q = temp; *p && !isspace(*p); *q++ = *p++);
  2287.                 *q = EOS;
  2288.                 
  2289.                 strncpy(RouteDef[nRouteDef].destnode,temp,29);
  2290.                 strcpy(RouteDef[nRouteDef++].fromnode,No);
  2291.                 
  2292.                 check_N_space();
  2293.                 p = skip_blanks(p);
  2294.             }
  2295.             
  2296.             continue;
  2297.         }            
  2298.  
  2299. #if defined AREAFIX
  2300.         
  2301.         if (!strnicmp (p, "areaconsultant", 14)) {
  2302.             p = &p[14];
  2303.             
  2304.             while (*p) {
  2305.                 p = skip_blanks(++p);
  2306.                 if (!*p) break;
  2307.                 
  2308.                 switch (toupper(*p)) {
  2309.                     case ' ':
  2310.                     case '-':    continue;
  2311.                     case 'R':    dorescan = TRUE;    break;
  2312.                     case 'Q':    doquery = TRUE;        break;
  2313.                     case 'L':    dototallist = TRUE;    break;
  2314.                 }
  2315.             }
  2316.             
  2317.             areafix_on = TRUE;
  2318.             continue;
  2319.         }
  2320. #endif
  2321.  
  2322.         log_line(-1,Logmessage[M__UNKNOWN_COMMAND], p, line, CONFIGFILE);
  2323.         sleep(4);
  2324.     }
  2325.     
  2326.     fclose(FDUMMY);
  2327.     
  2328.     if (dolabel) free(havelabel);
  2329.  
  2330.     if (uselabel == USELABEL) {
  2331.         log_line (-1, "!Label(s) not undefined with '#ENDALL', exiting .....");
  2332.         exit (10);
  2333.     }
  2334.     
  2335.     giveTIMEslice();
  2336.     
  2337.     if (!strlen(outbound))
  2338.     {
  2339.         log_line(-1,Logmessage[M__DIR_NOT_SPECIFIED],"OUTBOUND");
  2340.         return(FALSE);
  2341.     }
  2342.     
  2343.     if (Inboundpaths[0] == NULL && Inboundpaths[1] == NULL)
  2344.     {
  2345.         if (Inboundpaths[2] == NULL)
  2346.         {
  2347.             log_line(-1,Logmessage[M__DIR_NOT_SPECIFIED],"INBOUND");
  2348.             return(FALSE);
  2349.         }
  2350.         
  2351.         Inboundpaths[0] = ctl_path(Inboundpaths[2]);
  2352.         free(Inboundpaths[2]);
  2353.         Inboundpaths[2] = NULL;
  2354.     }
  2355.     else
  2356.         if (Inboundpaths[0] == NULL && Inboundpaths[1] != NULL)
  2357.         {
  2358.             Inboundpaths[0] = ctl_path(Inboundpaths[1]);
  2359.             free(Inboundpaths[1]);
  2360.             Inboundpaths[1] = ctl_path(Inboundpaths[2]);
  2361.             free(Inboundpaths[2]);
  2362.             Inboundpaths[2] = NULL;
  2363.         }
  2364.     
  2365.     if (!nalias)
  2366.     {
  2367.         log_line(-1,Logmessage[M__ADDRESS_NOT_SPECIFIED]);
  2368.         return(FALSE);
  2369.     }
  2370.     
  2371.     if(nfdbase) {
  2372.         if(!strlen(FDbase)) {
  2373.             log_line(-1,Logmessage[M__NO_DBASE_DIR]);
  2374.             for (i=0;i < nfdbase; i++) {
  2375.                 free(ToBase[i]);
  2376.             }
  2377.             nfdbase = 0;
  2378.         }
  2379.     }
  2380.     
  2381.     /*
  2382.     ** Notice, this is changed. If an user has NO mailtemp
  2383.     ** mentioned in the config an buseeror is the result.
  2384.     ** An checking is done on the mailtemp variable.
  2385.     ** If zero bytes an new directoryname must be created, so
  2386.     ** no buserror can be occured.
  2387.     **
  2388.     ** Rinaldo Visscher 22-12-1991
  2389.     **
  2390.     */
  2391.     
  2392.     if (strlen(pkt_temp)) {
  2393.         strcpy(buffer, pkt_temp);
  2394.         *(strrchr(buffer, '\\')) = EOS;
  2395.     } else {
  2396.         i = Dgetdrv();
  2397.         sprintf(buffer,"%c:\\INTEMP\\",'A'+i);
  2398.         pkt_temp = ctl_string(buffer);
  2399.         *(strrchr(buffer, '\\')) = EOS;        
  2400.     }
  2401.     
  2402.     sprintf (temp, "%c:", 'A' + Dgetdrv());
  2403.     
  2404.     if (!Dgetpath (&temp[strlen (temp)], Dgetdrv())) {
  2405.         if (!strnicmp (temp, buffer, (WORD)strlen (buffer))) {
  2406.             log_line (6, "?Temp. INmail folder same as your mailfolder.");
  2407.             terminate (-3);
  2408.         }
  2409.     }
  2410.     
  2411.     if (stat(buffer, &stbuf) == FAILURE ) {
  2412.         if(Dcreate(buffer) < 0) {
  2413.             log_line(-1,Logmessage[M__CANT_CREATE_TEMP_DIR],"INmail", mailtemp);
  2414.             terminate(10);
  2415.         }
  2416.     }
  2417.         
  2418.     if (strlen(mailtemp)) {
  2419.         strcpy(buffer, mailtemp);
  2420.         *(strrchr(buffer, '\\')) = EOS;
  2421.     } else {
  2422.         i = Dgetdrv();
  2423.         
  2424.         /*
  2425.         ** I don't like sprintf, because there is original an big
  2426.         ** error is in the TC 2.0 lib. I don't know if this is changed
  2427.         ** in PureC, but the original source uses 'sprint', so I did't
  2428.         ** use 'sprintf'.
  2429.         **
  2430.         ** Rinaldo Visscher 21-12-1991
  2431.         **
  2432.         */
  2433.         
  2434.         sprintf(buffer,"%c:\\OUTTEMP\\",'A'+i);
  2435.         mailtemp = ctl_string(buffer);
  2436.         *(strrchr(buffer, '\\')) = EOS;        
  2437.     }
  2438.     
  2439.     if (stat(buffer, &stbuf) == FAILURE ) {
  2440.         if(Dcreate(buffer) < 0) {
  2441.             log_line(-1,Logmessage[M__CANT_CREATE_TEMP_DIR],"OUTmail", mailtemp);
  2442.             terminate(10);
  2443.         }
  2444.     }
  2445.     
  2446.     return(TRUE);
  2447. }
  2448.  
  2449. VOID Copy_or_Move(BYTE *line, BOOLEAN what) {
  2450.     BYTE temp[1024],
  2451.          *p,*q;
  2452.     
  2453.     p = line;
  2454.  
  2455.     Copy_area[ncopyareas] = what;
  2456.     
  2457.     if(!*p) {
  2458.         log_line(-1,Logmessage[M__AREA_NOT_],(what == COPYAREA) ? "copy" : "move");
  2459.         return;
  2460.     }
  2461.  
  2462.     for(q = temp; *p && !isspace(*p); *q++ = *p++);
  2463.     *q = EOS;
  2464.     
  2465.     Copyarea[ncopyareas] = ctl_string(temp);
  2466.     
  2467.     p = skip_blanks(p);
  2468.     if(    !*p ) {
  2469.         log_line(-1,Logmessage[M__DEST_AREA_ERROR]);
  2470.         free(Copyarea[ncopyareas]);
  2471.         return;
  2472.     }
  2473.     for(q = temp; *p && !isspace(*p); *q++ = *p++);
  2474.     *q = EOS;
  2475.     
  2476.     Destarea[ncopyareas] = ctl_string(temp);
  2477.     
  2478.     p = skip_blanks(p);
  2479.     
  2480.     if( !*p ) {
  2481.         log_line(-1,Logmessage[M__ARGUMENT_ERROR],(what == COPYAREA) ? "'copyarea'" : "'movearea'");
  2482.         free(Copyarea[ncopyareas]);
  2483.         free(Destarea[ncopyareas]);
  2484.         return;
  2485.     }
  2486.  
  2487.     Copylegal[ncopyareas++] = ctl_string(p);
  2488. }
  2489.