home *** CD-ROM | disk | FTP | other *** search
/ ftp.wwiv.com / ftp.wwiv.com.zip / ftp.wwiv.com / pub / MISC / MN325SRC.ZIP / makenl-3.2.5 / src / fts5.c < prev    next >
C/C++ Source or Header  |  2005-02-06  |  7KB  |  301 lines
  1. /* $Id: fts5.c,v 1.9 2004/07/17 03:05:06 ozzmosis Exp $ */
  2.  
  3. #include <stdio.h>
  4. #include <string.h>
  5. #include <ctype.h>
  6. #include "config.h"
  7. #include "makenl.h"
  8. #include "fts5.h"
  9. #include "unused.h"
  10.  
  11. #ifdef MALLOC_DEBUG
  12. #include "rmalloc.h"
  13. #endif
  14.  
  15. #ifdef DMALLOC
  16. #include "dmalloc.h"
  17. #endif
  18.  
  19. static struct switchstruct FTS5KWords[] = {
  20.     {"", 0, 5},
  21.     {"GLOBAL", 6, LEVEL_TOP},
  22.     {"ZONE", 4, LEVEL_ZONE},
  23.     {"REGION", 6, LEVEL_REGION},
  24.     {"HOST", 4, LEVEL_HOST},
  25.     {"HUB", 3, LEVEL_HUB},
  26.     {"PRIVATE", 7, LEVEL_PRIVATE},
  27.     {"PVT", 3, LEVEL_PRIVATE},
  28.     {"OGATE", 5, LEVEL_OGATE},
  29.     {"DOWN", 4, LEVEL_DOWN},
  30.     {"HOLD", 4, LEVEL_HOLD},
  31.     {"POINT", 5, LEVEL_POINT},
  32.     {"KENNEL", 6, LEVEL_DOWN},
  33.     {"KENL", 4, LEVEL_DOWN},
  34.     {NULL, 0, -1}
  35. };
  36.  
  37. const int Level4DPos[] = {
  38. /* LEVEL_TOP   --> */ A_ZONE,
  39. /* LEVEL_ZONE  --> */ A_ZONE,
  40. /* LEVEL_REGION--> */ A_NET,
  41. /* LEVEL_HOST  --> */ A_NET,
  42. /* LEVEL_HUB   --> */ A_NODE,
  43. /* LEVEL_NODE  --> */ A_NODE,
  44. /* LEVEL_OGATE --> */ A_NODE,
  45. /* LEVEL_PRIVATE-> */ A_NODE,
  46. /* LEVEL_DOWN  --> */ A_NODE,
  47. /* LEVEL_HOLD  --> */ A_NODE,
  48. /* LEVEL_POINT --> */ A_POINT,
  49. /* LEVEL_COMMENT-> */ 127,
  50. /* LEVEL_COMMENT-> */ 127
  51. };
  52. const char *const LevelsSimple[] =
  53.     { "", "Zone", "Region", "Network", "Hub", "Node" };
  54. char namebuf[16];
  55. char *Levels[] =
  56.     { namebuf, "Zone", "Region", "Host", "Hub", "", "Ogate", "Pvt", "Down",
  57.     "Hold", "Point"
  58. };
  59. int Minphone = 3;
  60. int Alphaphone = 0;
  61. int Allowunpub = 0;
  62. int PrivateLevel;
  63. int PointLevel = -2;            /* don't allow points */
  64. char *FTS5Line[8];
  65.  
  66. static void Space2Under(char *string)
  67. {
  68.     for (; *string; string++)
  69.         if (*string == ' ')
  70.             *string = '_';
  71. }
  72.  
  73. static int getkeyword(char **instring, int *linelevel, int *linenum)
  74. {
  75.     unused(linenum);
  76.  
  77.     if ((*linelevel = xlate_switch(strupr(*instring), FTS5KWords)) == -1)
  78.     {
  79.         sprintf(ErrorMessage, "Invalid keyword -- \"%s\"", *instring);
  80.         return 1;
  81.     }
  82.  
  83.     return 0;
  84. }
  85.  
  86. int getnodenum(char **instring, int *linelevel, int *linenum)
  87. {
  88.     int addrlen;
  89.     const char *type;
  90.  
  91.     addrlen = strlen(*instring);
  92.     if (addrlen != 0)
  93.         if (getnumber(*instring, linenum) == addrlen)
  94.             if (*linenum != 0)
  95.             {
  96.                 while (**instring == '0')
  97.                     ++(*instring);
  98.                 return 0;
  99.             }
  100.  
  101.     if (*linelevel == LEVEL_POINT)
  102.     {
  103.         type = "Point";
  104.     }
  105.     else if (*linelevel > LEVEL_HUB)
  106.     {
  107.         type = "Node";
  108.     }
  109.     else
  110.     {
  111.         if (*linelevel == -1)
  112.         {
  113.             type = "Node";
  114.         }
  115.         else
  116.         {
  117.             type = LevelsSimple[*linelevel];
  118.         }
  119.     }
  120.     sprintf(ErrorMessage, "Invalid %s number -- \"%s\"", type, *instring);
  121.     return 1;
  122. }
  123.  
  124. static int getstring(char **instring, int *linelevel, int *linenum)
  125. {
  126.     char *workptr;
  127.  
  128.     unused(linelevel);
  129.     unused(linenum);
  130.  
  131.     workptr = *instring;
  132.     if (strlen(workptr) != 0)
  133.     {
  134.         Space2Under(workptr--);
  135.         while (*(++workptr) != 0)
  136.         {
  137.             if (*workptr & 0x80)
  138.                 *workptr = '?';
  139.         }
  140.     }
  141.     else
  142.         *instring = "-Unknown-";
  143.  
  144.     return 0;
  145. }
  146.  
  147. static int getphone(char **instring, int *linelevel, int *linenum)
  148. {
  149.     int parts;
  150.     int digit_seen;
  151.     char *phoneno;
  152.     char *phonewalk;
  153.     char phonechar;
  154.     int brackets;
  155.  
  156.     unused(linenum);
  157.  
  158. /* MGMMGM Pass through any -Unpublished- phone number without further checking */
  159. /*        Standardise capitalisation */
  160.  
  161.     if (Allowunpub == 1)
  162.         if (stricmp(*instring, "-unpublished-") == 0)
  163.         {
  164.             *instring = "-Unpublished-";
  165.             return 0;
  166.         }
  167.     if (Alphaphone == 1 && (stricmp(*instring, "-Unpublished-") != 0))
  168.         return 0;
  169.  
  170. /* end MGMMGM */
  171.  
  172.     switch (*linelevel)
  173.     {
  174.     case LEVEL_PRIVATE:
  175.         *instring = "-Unpublished-";
  176.         break;
  177.     case LEVEL_HOLD:
  178.     case LEVEL_DOWN:
  179.         /* Hold and down nodes don't need a valid number */
  180.         break;
  181.     case LEVEL_POINT:
  182.         /* Points may have unpublished phones */
  183.         if (!stricmp(*instring, "-Unpublished-"))
  184.             return 0;
  185.     default:
  186.         phoneno = *instring;
  187.         phonewalk = phoneno;
  188.         brackets = 0;
  189.         digit_seen = 0;
  190.         parts = 0;
  191.         do
  192.         {
  193.             phonechar = *phonewalk;
  194.             phonewalk++;
  195.             if (isdigit((unsigned char)phonechar))
  196.                 digit_seen = 1;
  197.             else if (digit_seen != 0)
  198.             {
  199.                 switch (phonechar)
  200.                 {
  201.                   BadPhone:
  202.                 default:
  203.                     sprintf(ErrorMessage, "Invalid phone number -- \"%s\"",
  204.                             phoneno);
  205.                     return 1;
  206.                 case '[':
  207.                     if (parts + 1 < Minphone)
  208.                         goto FewParts;
  209.                     parts = -1;
  210.                 case ']':
  211.                     brackets++;
  212.                 case 0:
  213.                 case '-':
  214.                     digit_seen = 0;
  215.                     parts++;
  216.                 }
  217.             }
  218.             else if (!(phonechar == '\0' && brackets == 2)) /* Allow \0
  219.                                                                directly
  220.                                                                after ] */
  221.                 goto BadPhone;
  222.         }
  223.         while (phonechar);
  224.         if (parts < Minphone)
  225.         {
  226.           FewParts:
  227.             sprintf(ErrorMessage,
  228.                     "Phone number \"%s\" has fewer than %d parts", phoneno,
  229.                     Minphone);
  230.             return 1;
  231.         }
  232.         break;
  233.     }
  234.  
  235.     return 0;
  236. }
  237.  
  238. static int getbaud(char **instring, int *linelevel, int *linenum)
  239. {
  240.     int e_len;
  241.     char *baud_no;
  242.  
  243.     unused(linelevel);
  244.     unused(linenum);
  245.  
  246.     e_len = 0;
  247.     baud_no = *instring;
  248.  
  249.     while ((unsigned char)baud_no[e_len] != 0)
  250.     {
  251.         if (!isdigit((unsigned char)baud_no[e_len]))
  252.         {
  253.             sprintf(ErrorMessage, "Invalid baud rate -- \"%s\"",
  254.                     *instring);
  255.             return 1;
  256.         }
  257.         e_len++;
  258.     }
  259.  
  260.     return 0;
  261. }
  262.  
  263. typedef int (*handlefunc) (char **instring, int *linelevel, int *linenum);
  264. static handlefunc HandleFields[] =
  265.     { getkeyword, getnodenum, getstring, getstring, getstring, getphone,
  266.     getbaud
  267. };
  268.  
  269. int ParseFTS5(char *line, int *a, int *b)
  270. {
  271.     int fieldno;
  272.     int hiterror;
  273.     char **ElementPPtr = &FTS5Keyword;
  274.     handlefunc *y = HandleFields;
  275.  
  276.     if (strlen(cutspaces(line)) == 0)
  277.     {
  278.         *a = LEVEL_EMPTY;
  279.         return 0;
  280.     }
  281.     if (line[0] == ';')
  282.     {
  283.         *a = LEVEL_COMMENT;
  284.         return 0;
  285.     }
  286.     hiterror = 0;
  287.     for (fieldno = 0; *ElementPPtr = skipspaces(line), fieldno < 7;
  288.          fieldno++, ElementPPtr++)
  289.     {
  290.         line += strcspn(line, ",\r\n");
  291.         if (*line != 0)
  292.             *(line++) = 0;
  293.         cutspaces(*ElementPPtr);
  294.         if (!hiterror)
  295.             hiterror = (*(y++)) (ElementPPtr, a, b);
  296.     }
  297.     if (!hiterror)
  298.         FTS5Keyword = Levels[*a];
  299.     return hiterror;
  300. }
  301.