开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
parse.c
资源名称：snmp.src.rar　[点击查看]
上传用户：cxs890
上传日期：2021-05-22
资源大小：347k
文件大小：103k
源码类别：

SNMP编程

开发平台：

C/C++

parse.c：源码内容
  1. /*
  2.  * parse.c
  3.  *
  4.  * Update: 1998-09-22 <mslifcak@iss.net>
  5.  * Clear nbuckets in init_node_hash.
  6.  * New method xcalloc returns zeroed data structures.
  7.  * New method alloc_node encapsulates common node creation.
  8.  * New method to configure terminate comment at end of line.
  9.  * New method to configure accept underscore in labels.
  10.  *
  11.  * Update: 1998-10-10 <daves@csc.liv.ac.uk>
  12.  * fully qualified OID parsing patch
  13.  *
  14.  * Update: 1998-10-20 <daves@csc.liv.ac.uk>
  15.  * merge_anon_children patch
  16.  *
  17.  * Update: 1998-10-21 <mslifcak@iss.net>
  18.  * Merge_parse_objectid associates information with last node in chain.
  19.  */
  20. /******************************************************************
  21.         Copyright 1989, 1991, 1992 by Carnegie Mellon University
  23.                       All Rights Reserved
  25. Permission to use, copy, modify, and distribute this software and its
  26. documentation for any purpose and without fee is hereby granted,
  27. provided that the above copyright notice appear in all copies and that
  28. both that copyright notice and this permission notice appear in
  29. supporting documentation, and that the name of CMU not be
  30. used in advertising or publicity pertaining to distribution of the
  31. software without specific, written prior permission.
  33. CMU DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  34. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  35. CMU BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  36. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  37. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  38. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  39. SOFTWARE.
  40. ******************************************************************/
  41. #include <config.h>
  42. #include <snmp_logging.h>
  43. #include <stdio.h>
  44. #if HAVE_STDLIB_H
  45. #include <stdlib.h>
  46. #endif
  47. #if HAVE_STRING_H
  48. #include <string.h>
  49. #else
  50. #include <strings.h>
  51. #endif
  52. #include <ctype.h>
  53. #include <sys/types.h>
  54. #include <sys/stat.h>
  56. /* Wow.  This is ugly.  -- Wes */
  57. #if HAVE_DIRENT_H
  58. # include <dirent.h>
  59. # define NAMLEN(dirent) strlen((dirent)->d_name)
  60. #else
  61. # define dirent direct
  62. # define NAMLEN(dirent) (dirent)->d_namlen
  63. #endif
  64. #if HAVE_WINSOCK_H
  65. #include <ip/socket.h>
  66. #endif
  67. #if HAVE_NETINET_IN_H
  68. #include <netinet/in.h>
  69. #endif
  70. #if defined(HAVE_REGEX_H) && defined(HAVE_REGCOMP)
  71. #include <regex.h>
  72. #endif
  73. #if HAVE_DMALLOC_H
  74. #include <dmalloc.h>
  75. #endif
  77. #include "system.h"
  78. #include "parse.h"
  79. #include "asn1.h"
  80. #include "mib.h"
  81. #include "snmp_api.h"
  82. #include "snmp_debug.h"
  83. #include "snmp_logging.h"
  84. #include "default_store.h"
  85. #include "tools.h"
  87. /*
  88.  * This is one element of an object identifier with either an integer
  89.  * subidentifier, or a textual string label, or both.
  90.  * The subid is -1 if not present, and label is NULL if not present.
  91.  */
  92. struct subid_s {
  93.     int subid;
  94.     int modid;
  95.     char *label;
  96. };
  98. #define MAXTC   1024
  99. struct tc {     /* textual conventions */
  100.     int type;
  101.     int modid;
  102.     char *descriptor;
  103.     char *hint;
  104.     struct enum_list *enums;
  105.     struct range_list *ranges;
  106. } tclist[MAXTC];
  108. int Line = 0;
  109. const char *File = "(none)";
  110. static int anonymous = 0;
  112. #define SYNTAX_MASK     0x80
  113. /* types of tokens
  114.  Tokens wiht the SYNTAX_MASK bit set are syntax tokens */
  115. #define CONTINUE    -1
  116. #define ENDOFFILE   0
  117. #define LABEL       1
  118. #define SUBTREE     2
  119. #define SYNTAX      3
  120. #define OBJID       (4 | SYNTAX_MASK)
  121. #define OCTETSTR    (5 | SYNTAX_MASK)
  122. #define INTEGER     (6 | SYNTAX_MASK)
  123. #define INTEGER32   INTEGER
  124. #define NETADDR     (7 | SYNTAX_MASK)
  125. #define IPADDR      (8 | SYNTAX_MASK)
  126. #define COUNTER     (9 | SYNTAX_MASK)
  127. #define GAUGE       (10 | SYNTAX_MASK)
  128. #define TIMETICKS   (11 | SYNTAX_MASK)
  129. #define KW_OPAQUE   (12 | SYNTAX_MASK)
  130. #define NUL         (13 | SYNTAX_MASK)
  131. #define SEQUENCE    14
  132. #define OF          15  /* SEQUENCE OF */
  133. #define OBJTYPE     16
  134. #define ACCESS      17
  135. #define READONLY    18
  136. #define READWRITE   19
  137. #define WRITEONLY   20
  138. #define NOACCESS    21
  139. #undef  STATUS
  140. #define STATUS      22
  141. #define MANDATORY   23
  142. #define KW_OPTIONAL    24
  143. #define OBSOLETE    25
  144. /* #define RECOMMENDED 26 */
  145. #define PUNCT       27
  146. #define EQUALS      28
  147. #define NUMBER      29
  148. #define LEFTBRACKET 30
  149. #define RIGHTBRACKET 31
  150. #define LEFTPAREN   32
  151. #define RIGHTPAREN  33
  152. #define COMMA       34
  153. #define DESCRIPTION 35
  154. #define QUOTESTRING 36
  155. #define INDEX       37
  156. #define DEFVAL      38
  157. #define DEPRECATED  39
  158. #define SIZE        40
  159. #define BITSTRING   (41 | SYNTAX_MASK)
  160. #define NSAPADDRESS (42 | SYNTAX_MASK)
  161. #define COUNTER64   (43 | SYNTAX_MASK)
  162. #define OBJGROUP    44
  163. #define NOTIFTYPE   45
  164. #define AUGMENTS    46
  165. #define COMPLIANCE  47
  166. #define READCREATE  48
  167. #define UNITS       49
  168. #define REFERENCE   50
  169. #define NUM_ENTRIES 51
  170. #define MODULEIDENTITY 52
  171. #define LASTUPDATED 53
  172. #define ORGANIZATION 54
  173. #define CONTACTINFO 55
  174. #define UINTEGER32 (56 | SYNTAX_MASK)
  175. #define CURRENT     57
  176. #define DEFINITIONS 58
  177. #define END         59
  178. #define SEMI        60
  179. #define TRAPTYPE    61
  180. #define ENTERPRISE  62
  181. /* #define DISPLAYSTR (63 | SYNTAX_MASK) */
  182. #define BEGIN       64
  183. #define IMPORTS     65
  184. #define EXPORTS     66
  185. #define ACCNOTIFY   67
  186. #define BAR         68
  187. #define RANGE       69
  188. #define CONVENTION  70
  189. #define DISPLAYHINT 71
  190. #define FROM        72
  191. #define CAPABILITIES 73
  192. #define MACRO       74
  193. #define IMPLIED     75
  194. struct tree *
  195. read_module(const char *name);
  196. struct tok {
  197.     const char *name;                 /* token name */
  198.     int len;                    /* length not counting nul */
  199.     int token;                  /* value */
  200.     int hash;                   /* hash of name */
  201.     struct tok *next;           /* pointer to next in hash table */
  202. };
  204. /*
  205. static struct tok tokens[] = {
  206.     { "obsolete", sizeof ("obsolete")-1, OBSOLETE },
  207.     { "Opaque", sizeof ("Opaque")-1, KW_OPAQUE },
  208.     { "optional", sizeof ("optional")-1, KW_OPTIONAL },
  209.     { "LAST-UPDATED", sizeof ("LAST-UPDATED")-1, LASTUPDATED },
  210.     { "ORGANIZATION", sizeof ("ORGANIZATION")-1, ORGANIZATION },
  211.     { "CONTACT-INFO", sizeof ("CONTACT-INFO")-1, CONTACTINFO },
  212.     { "MODULE-IDENTITY", sizeof ("MODULE-IDENTITY")-1, MODULEIDENTITY },
  213.     { "MODULE-COMPLIANCE", sizeof ("MODULE-COMPLIANCE")-1, COMPLIANCE },
  214.     { "DEFINITIONS", sizeof("DEFINITIONS")-1, DEFINITIONS},
  215.     { "END", sizeof("END")-1, END},
  216.     { "AUGMENTS", sizeof ("AUGMENTS")-1, AUGMENTS },
  217.     { "not-accessible", sizeof ("not-accessible")-1, NOACCESS },
  218.     { "write-only", sizeof ("write-only")-1, WRITEONLY },
  219.     { "NsapAddress", sizeof("NsapAddress")-1, NSAPADDRESS},
  220.     { "UNITS", sizeof("Units")-1, UNITS},
  221.     { "REFERENCE", sizeof("REFERENCE")-1, REFERENCE},
  222.     { "NUM-ENTRIES", sizeof("NUM-ENTRIES")-1, NUM_ENTRIES},
  223.     { "BITSTRING", sizeof("BITSTRING")-1, BITSTRING},
  224.     { "BIT", sizeof("BIT")-1, CONTINUE},
  225.     { "BITS", sizeof("BITS")-1, BITSTRING},
  226.     { "Counter64", sizeof("Counter64")-1, COUNTER64},
  227.     { "TimeTicks", sizeof ("TimeTicks")-1, TIMETICKS },
  228.     { "NOTIFICATION-TYPE", sizeof ("NOTIFICATION-TYPE")-1, NOTIFTYPE },
  229.     { "OBJECT-GROUP", sizeof ("OBJECT-GROUP")-1, OBJGROUP },
  230.     { "OBJECT-IDENTITY", sizeof ("OBJECT-IDENTITY")-1, OBJGROUP },
  231.     { "OBJECTIDENTIFIER", sizeof ("OBJECTIDENTIFIER")-1, OBJID },
  232.     { "OBJECT", sizeof ("OBJECT")-1, CONTINUE },
  233.     { "NetworkAddress", sizeof ("NetworkAddress")-1, NETADDR },
  234.     { "Gauge", sizeof ("Gauge")-1, GAUGE },
  235.     { "Gauge32", sizeof ("Gauge32")-1, GAUGE },
  236.     { "Unsigned32", sizeof ("Unsigned32")-1, GAUGE },
  237.     { "read-write", sizeof ("read-write")-1, READWRITE },
  238.     { "read-create", sizeof ("read-create")-1, READCREATE },
  239.     { "OCTETSTRING", sizeof ("OCTETSTRING")-1, OCTETSTR },
  240.     { "OCTET", sizeof ("OCTET")-1, CONTINUE },
  241.     { "OF", sizeof ("OF")-1, OF },
  242.     { "SEQUENCE", sizeof ("SEQUENCE")-1, SEQUENCE },
  243.     { "NULL", sizeof ("NULL")-1, NUL },
  244.     { "IpAddress", sizeof ("IpAddress")-1, IPADDR },
  245.     { "UInteger32", sizeof ("UInteger32")-1, UINTEGER32 },
  246.     { "INTEGER", sizeof ("INTEGER")-1, INTEGER },
  247.     { "Integer32", sizeof ("Integer32")-1, INTEGER32 },
  248.     { "Counter", sizeof ("Counter")-1, COUNTER },
  249.     { "Counter32", sizeof ("Counter32")-1, COUNTER },
  250.     { "read-only", sizeof ("read-only")-1, READONLY },
  251.     { "DESCRIPTION", sizeof ("DESCRIPTION")-1, DESCRIPTION },
  252.     { "INDEX", sizeof ("INDEX")-1, INDEX },
  253.     { "DEFVAL", sizeof ("DEFVAL")-1, DEFVAL },
  254.     { "deprecated", sizeof ("deprecated")-1, DEPRECATED },
  255.     { "SIZE", sizeof ("SIZE")-1, SIZE },
  256.     { "MAX-ACCESS", sizeof ("MAX-ACCESS")-1, ACCESS },
  257.     { "ACCESS", sizeof ("ACCESS")-1, ACCESS },
  258.     { "mandatory", sizeof ("mandatory")-1, MANDATORY },
  259.     { "current", sizeof ("current")-1, CURRENT },
  260.     { "STATUS", sizeof ("STATUS")-1, STATUS },
  261.     { "SYNTAX", sizeof ("SYNTAX")-1, SYNTAX },
  262.     { "OBJECT-TYPE", sizeof ("OBJECT-TYPE")-1, OBJTYPE },
  263.     { "TRAP-TYPE", sizeof ("TRAP-TYPE")-1, TRAPTYPE },
  264.     { "ENTERPRISE", sizeof ("ENTERPRISE")-1, ENTERPRISE },
  265.     { "BEGIN", sizeof ("BEGIN")-1, BEGIN },
  266.     { "IMPORTS", sizeof ("IMPORTS")-1, IMPORTS },
  267.     { "EXPORTS", sizeof ("EXPORTS")-1, EXPORTS },
  268.     { "accessible-for-notify", sizeof ("accessible-for-notify")-1, ACCNOTIFY },
  269.     { "TEXTUAL-CONVENTION", sizeof ("TEXTUAL-CONVENTION")-1, CONVENTION },
  270.     { "NOTIFICATION-GROUP", sizeof ("NOTIFICATION-GROUP")-1, NOTIFTYPE },
  271.     { "DISPLAY-HINT", sizeof ("DISPLAY-HINT")-1, DISPLAYHINT },
  272.     { "FROM", sizeof ("FROM")-1, FROM },
  273.     { "AGENT-CAPABILITIES", sizeof ("AGENT-CAPABILITIES")-1, CAPABILITIES },
  274.     { "MACRO", sizeof ("MACRO")-1, MACRO },
  275.     { "IMPLIED", sizeof ("IMPLIED")-1, IMPLIED },
  276.     { NULL }
  277. }; */
  279. static struct module_compatability *module_map_head;
  280. /* static struct module_compatability module_map[] = {
  281. { "RFC1065-SMI", "RFC1155-SMI", NULL, 0},
  282. { "RFC1066-MIB", "RFC1156-MIB", NULL, 0},
  283.           /* 'mib' -> 'mib-2'  
  284. { "RFC1156-MIB", "RFC1158-MIB", NULL, 0},
  285.           /* 'snmpEnableAuthTraps' -> 'snmpEnableAuthenTraps'  
  286. { "RFC1158-MIB",       "RFC1213-MIB", NULL, 0},
  287.           /* 'nullOID' -> 'zeroDotZero'  
  288. { "RFC1155-SMI", "SNMPv2-SMI", NULL, 0},
  289. { "RFC1213-MIB", "SNMPv2-SMI", "mib-2", 0},
  290. { "RFC1213-MIB", "SNMPv2-MIB", "sys", 3},
  291. { "RFC1213-MIB", "IF-MIB", "if", 2},
  292. { "RFC1213-MIB", "IP-MIB", "ip", 2},
  293. { "RFC1213-MIB", "IP-MIB", "icmp", 4},
  294. { "RFC1213-MIB", "TCP-MIB", "tcp", 3},
  295. { "RFC1213-MIB", "UDP-MIB", "udp", 3},
  296. { "RFC1213-MIB", "SNMPv2-SMI", "transmission", 0},
  297. { "RFC1213-MIB", "SNMPv2-MIB", "snmp", 4},
  298. { "RFC1271-MIB", "RMON-MIB", NULL, 0},
  299. { "RFC1286-MIB", "SOURCE-ROUTING-MIB", "dot1dSr", 7},
  300. { "RFC1286-MIB", "BRIDGE-MIB", NULL, 0},
  301. { "RFC1315-MIB", "FRAME-RELAY-DTE-MIB", NULL, 0},
  302. { "RFC1316-MIB", "CHARACTER-MIB", NULL, 0},
  303. }; */
  304. #define MODULE_NOT_FOUND 0
  305. #define MODULE_LOADED_OK 1
  306. #define MODULE_ALREADY_LOADED 2
  307. /* #define MODULE_LOAD_FAILED 3  */
  308. #define MODULE_LOAD_FAILED MODULE_NOT_FOUND
  311. #define HASHSIZE        32
  312. #define BUCKET(x)       (x & (HASHSIZE-1))
  314. #define NHASHSIZE    128
  315. #define NBUCKET(x)   (x & (NHASHSIZE-1))
  317. static struct tok      *buckets[HASHSIZE];
  318. char * module_name (int modid,  char *cp);
  320. static struct node *nbuckets[NHASHSIZE];
  321. static struct tree *tbuckets[NHASHSIZE];
  322. static struct module *module_head = NULL;
  324. struct node *orphan_nodes = NULL;
  325. struct tree   *tree_head = NULL;
  326. extern struct tree tree[];
  328. #define NUMBER_OF_ROOT_NODES 3
  329. static struct module_import root_imports[NUMBER_OF_ROOT_NODES];
  331. static int current_module = 0;
  332. static int     max_module = 0;
  333. static char *last_err_module = 0; /* no repeats on "Cannot find module..." */
  334. #ifdef UCD_SNMP
  335. static void tree_from_node(struct tree *tp, struct node *np);
  336. static struct index_list * copy_indexes(struct index_list *);
  337. static void build_translation_table (void);
  338. static void init_tree_roots (void);
  339. static void unlink_tree(struct tree *);
  340. static void read_import_replacements (const char *, struct module_import *);
  341. #endif
  342. static void do_subtree (struct tree *, struct node **);
  343. static void do_linkup (struct module *, struct node *);
  344. static void dump_module_list (void);
  345. static int get_token (FILE *, char *, int);
  346. static int parseQuoteString (FILE *, char *, int);
  347. static int tossObjectIdentifier (FILE *);
  348. static int  name_hash (const char *);
  349. static void init_node_hash (struct node *);
  350. static void print_error (const char *, const char *, int);
  351. static void free_tree (struct tree *);
  352. static void free_partial_tree (struct tree *, int);
  353. static void free_node (struct node *);
  355. static void merge_anon_children (struct tree *, struct tree *);
  356. static void unlink_tbucket(struct tree *);
  358. static int getoid (FILE *, struct subid_s *, int);
  359. static struct node *parse_objectid (FILE *, char *);
  360. static int get_tc (const char *, int, int *, struct enum_list **, struct range_list **, char **);
  361. static int get_tc_index (const char *, int);
  362. static struct enum_list *parse_enumlist (FILE *, struct enum_list **);
  363. static struct range_list *parse_ranges(FILE *fp, struct range_list **);
  364. static struct node *parse_asntype (FILE *, char *, int *, char *);
  365. static struct node *parse_objecttype (FILE *, char *);
  366. static struct node *parse_objectgroup (FILE *, char *);
  367. static struct node *parse_notificationDefinition (FILE *, char *);
  368. static struct node *parse_trapDefinition (FILE *, char *);
  369. static struct node *parse_compliance (FILE *, char *);
  370. static struct node *parse_capabilities(FILE *, char *);
  371. static struct node *parse_moduleIdentity (FILE *, char *);
  372. static struct node *parse_macro(FILE *, char *);
  373. static        void  parse_imports (FILE *);
  374. static struct node *parse (FILE *, struct node *);
  376. static int read_module_internal (const char *);
  377. static void read_module_replacements (const char *);
  380. static void  new_module  (const char *, const char *);
  382. static struct node *merge_parse_objectid (struct node *, FILE *, char *);
  383. static struct index_list *getIndexes(FILE *fp, struct index_list **);
  384. static void free_indexes(struct index_list **);
  385. static void free_ranges(struct range_list **);
  386. static void free_enums(struct enum_list **);
  387. static struct range_list * copy_ranges(struct range_list *);
  388. static struct enum_list  * copy_enums(struct enum_list *);
  391. /* backwards compatibility wrappers */
  392. void snmp_set_mib_errors(int err)
  393. {
  394.   ds_set_boolean(DS_LIBRARY_ID, DS_LIB_MIB_ERRORS, err);
  395. }
  397. void snmp_set_mib_warnings(int warn)
  398. {
  399.   ds_set_int(DS_LIBRARY_ID, DS_LIB_MIB_WARNINGS, warn);
  400. }
  402. void snmp_set_save_descriptions(int save)
  403. {
  404.   ds_set_boolean(DS_LIBRARY_ID, DS_LIB_SAVE_MIB_DESCRS, save);
  405. }
  407. void snmp_set_mib_comment_term(int save)
  408. {
  409.   /* 0=strict, 1=EOL terminated */
  410.   ds_set_boolean(DS_LIBRARY_ID, DS_LIB_MIB_COMMENT_TERM, save);
  411. }
  413. void snmp_set_mib_parse_label(int save)
  414. {
  415.   /* 0=strict, 1=underscore OK in label */
  416.   ds_set_boolean(DS_LIBRARY_ID, DS_LIB_MIB_PARSE_LABEL, save);
  417. }
  419. /* end wrappers */
  421. void snmp_mib_toggle_options_usage(const char *lead, FILE *outf) {
  422.   fprintf(outf, "%sMIBOPTS values:n", lead);
  423.   fprintf(outf, "%s    u: %sallow the usage of underlines in mib symbols.n",
  424.           lead, ((ds_get_boolean(DS_LIBRARY_ID, DS_LIB_MIB_PARSE_LABEL))?"dis":""));
  425.   fprintf(outf, "%s    c: %sallow the usage of "--" to terminate comments.n",
  426.           lead, ((ds_get_boolean(DS_LIBRARY_ID, DS_LIB_MIB_COMMENT_TERM))?"":"dis"));
  427.   fprintf(outf, "%s    d: %ssave the descriptions of the mib objects.n",
  428.           lead, ((ds_get_boolean(DS_LIBRARY_ID, DS_LIB_SAVE_MIB_DESCRS))?"don't ":""));
  429.   fprintf(outf, "%s    e: Disable mib errors of MIB symbols conflictsn",
  430.           lead);
  431.   fprintf(outf, "%s    w: Enable mib warnings of MIB symbols conflictsn",
  432.           lead);
  433.   fprintf(outf, "%s    W: Enable detailed warnings of MIB symbols conflictsn",
  434.           lead);
  435.   fprintf(outf, "%s    R: Replace MIB symbols from latest modulen",
  436.           lead);
  437. }
  439. char *snmp_mib_toggle_options(char *options) {
  440.   if (options) {
  441.     while(*options) {
  442.       switch(*options) {
  443.         case 'u':
  444.           ds_set_boolean(DS_LIBRARY_ID, DS_LIB_MIB_PARSE_LABEL, !ds_get_boolean(DS_LIBRARY_ID, DS_LIB_MIB_PARSE_LABEL));
  445.           break;
  447.         case 'c':
  448.           ds_toggle_boolean(DS_LIBRARY_ID, DS_LIB_MIB_COMMENT_TERM);
  449.           break;
  451.         case 'e':
  452.           ds_toggle_boolean(DS_LIBRARY_ID, DS_LIB_MIB_ERRORS);
  453.           break;
  455.         case 'w':
  456.           ds_set_int(DS_LIBRARY_ID, DS_LIB_MIB_WARNINGS, 1);
  457.           break;
  459.         case 'W':
  460.           ds_set_int(DS_LIBRARY_ID, DS_LIB_MIB_WARNINGS, 2);
  461.           break;
  463.         case 'd':
  464.           ds_toggle_boolean(DS_LIBRARY_ID, DS_LIB_SAVE_MIB_DESCRS);
  465.           break;
  467.         case 'R':
  468.           ds_toggle_boolean(DS_LIBRARY_ID, DS_LIB_MIB_REPLACE);
  469.           break;
  471.         default:
  472.           /* return at the unknown option */
  473.           return options;
  474.       }
  475.       options++;
  476.     }
  477.   }
  478.   return NULL;
  479. }
  481. static int
  482. name_hash(const char* name)
  483. {
  484.     int hash = 0;
  485.     const char *cp;
  487.     if (name) {
  488.       for(cp = name; *cp; cp++) {
  489.         hash += tolower(*cp);
  490.       }
  491.     }
  492.     return(hash);
  493. }
  495. static void
  496. init_node_hash(struct node *nodes)
  497. {
  498.      register struct node *np, *nextp;
  499.      register int hash;
  501.      memset(nbuckets, 0, sizeof(nbuckets));
  502.      for(np = nodes; np;){
  503.          nextp = np->next;
  504.          hash = NBUCKET(name_hash(np->parent));
  505.          np->next = nbuckets[hash];
  506.          nbuckets[hash] = np;
  507.          np = nextp;
  508.      }
  509. }
  511. static int erroneousMibs = 0;
  513. int get_mib_parse_error_count(void)
  514. {
  515.     return erroneousMibs;
  516. }
  519. static void
  520. print_error(const char *string,
  521.     const char *token,
  522.     int type)
  523. {
  524.     erroneousMibs++;
  525.     DEBUGMSGTL(("parse-mibs", "n"));
  526.     if (type == ENDOFFILE)
  527.         snmp_log(LOG_ERR, "%s (EOF): At line %d in %sn", string, Line,
  528.                 File);
  529.     else if (token && *token)
  530.         snmp_log(LOG_ERR, "%s (%s): At line %d in %sn", string, token,
  531.                 Line, File);
  532.     else
  533.         snmp_log(LOG_ERR, "%s: At line %d in %sn", string, Line, File);
  534. }
  535. extern char *strdup (const char*);
  536. static void
  537. print_module_not_found(const char *cp)
  538. {
  539.     if (!last_err_module || strcmp(cp, last_err_module))
  540.         print_error("Cannot find module", cp, CONTINUE);
  541.     if (last_err_module) free(last_err_module);
  542.     last_err_module = strdup(cp);
  543. }
  545. static struct node *
  546. alloc_node(int modid)
  547. {
  548.     struct node *np;
  549.     np = (struct node *) calloc(1, sizeof(struct node));
  550.     if (np) {
  551.         np->tc_index = -1;
  552.         np->modid = modid;
  553.     }
  554.     return np;
  555. }
  557. static void unlink_tbucket(struct tree *tp)
  558. {
  559.     int hash = NBUCKET(name_hash(tp->label));
  560.     struct tree *otp = NULL, *ntp = tbuckets[hash];
  562.     while (ntp && ntp != tp) {
  563. otp = ntp; ntp = ntp->next;
  564.     }
  565.     if (!ntp) snmp_log(LOG_EMERG, "Can't find %s in tbucketsn", tp->label);
  566.     else if (otp) otp->next = ntp->next;
  567.     else tbuckets[hash] = tp->next;
  568. }
  570. #ifdef UCD_SNMP
  571. static void unlink_tree(struct tree *tp)
  572. {
  574. struct tree *otp = NULL, *ntp = tp->parent->child_list;
  576.     while (ntp && ntp != tp) {
  577. otp = ntp; ntp = ntp->next_peer;
  578.     }
  579.     if (!ntp) snmp_log(LOG_EMERG, "Can't find %s in %s's childrenn",
  580. tp->label, tp->parent->label);
  581.     else if (otp) otp->next_peer = ntp->next_peer;
  582.     else tp->parent->child_list = tp->next_peer;
  584. }
  585. #endif
  586. static void
  587. free_partial_tree(struct tree *tp, int keep_label)
  588. {
  589.     if ( !tp)
  590.         return;
  592.     /* remove the data from this tree node */
  593.     free_enums(&tp->enums);
  594.     if (!keep_label)
  595. SNMP_FREE(tp->label);
  596.     SNMP_FREE(tp->hint);
  597.     SNMP_FREE(tp->units);
  598.     SNMP_FREE(tp->description);
  599. }
  601. /*
  602.  * free a tree node. Note: the node must already have been unlinked
  603.  * from the tree when calling this routine
  604.  */
  605. static void
  606. free_tree(struct tree *Tree)
  607. {
  608.     if (!Tree)
  609.         return;
  611.     unlink_tbucket(Tree);
  612.     free_partial_tree (Tree, FALSE);
  613. #ifdef UCD_SNMP
  614.     if (Tree->number_modules > 1 )
  615.         free(Tree->module_list);
  616. #endif
  617.     free (Tree);
  618. }
  620. static void
  621. free_node(struct node *np)
  622. {
  623.     if ( !np) return;
  625.     free_enums(&np->enums);
  626.     free_ranges(&np->ranges);
  627.     free_indexes(&np->indexes);
  628.     if (np->label) free(np->label);
  629.     if (np->hint) free(np->hint);
  630.     if (np->units) free(np->units);
  631.     if (np->description) free(np->description);
  632.     if (np->parent) free(np->parent);
  633.     free(np);
  634. }
  636. #ifdef TEST
  637. static void
  638. print_nodes(FILE *fp,
  639.     struct node *root)
  640. {
  641. extern void xmalloc_stats (FILE *);
  642.     struct enum_list *ep;
  643.     struct index_list *ip;
  644.     struct range_list *rp;
  645.     struct node *np;
  647.     for(np = root; np; np = np->next){
  648.         fprintf(fp, "%s ::= { %s %ld } (%d)n", np->label, np->parent,
  649.                 np->subid, np->type);
  650.         if (np->tc_index >= 0)
  651.             fprintf(fp, "  TC = %sn", tclist[np->tc_index].descriptor);
  652.         if (np->enums){
  653.             fprintf(fp, "  Enums: n");
  654.             for(ep = np->enums; ep; ep = ep->next){
  655.                 fprintf(fp, "    %s(%d)n", ep->label, ep->value);
  656.             }
  657.         }
  658.         if (np->ranges){
  659.             fprintf(fp, "  Ranges: n");
  660.             for(rp = np->ranges; rp; rp = rp->next){
  661.                 fprintf(fp, "    %d..%dn", rp->low, rp->high);
  662.             }
  663.         }
  664.         if (np->indexes){
  665.             fprintf(fp, "  Indexes: n");
  666.             for(ip = np->indexes; ip; ip = ip->next){
  667.                 fprintf(fp, "    %sn", ip->ilabel);
  668.             }
  669.         }
  670.         if (np->hint)
  671.             fprintf(fp, "  Hint: %sn", np->hint);
  672.         if (np->units)
  673.             fprintf(fp, "  Units: %sn", np->units);
  674.     }
  675. }
  676. #endif
  678. void
  679. print_subtree(FILE *f,
  680.       struct tree *tree,
  681.       int count)
  682. {
  684. #ifdef UCD_SNMP
  685.     struct tree *tp;
  686.     int i;
  687.     char modbuf[256];
  689.     for(i = 0; i < count; i++)
  690.         fprintf(f, "  ");
  691.     fprintf(f, "Children of %s(%ld):n", tree->label, tree->subid);
  692.     count++;
  693.     for(tp = tree->child_list; tp; tp = tp->next_peer){
  694.         for(i = 0; i < count; i++)
  695.             fprintf(f, "  ");
  696.         fprintf(f, "%s:%s(%ld) type=%d",
  697.                 module_name(tp->module_list[0], modbuf),
  698.                 tp->label, tp->subid, tp->type);
  699.         if (tp->tc_index != -1) fprintf(f, " tc=%d", tp->tc_index);
  700.         if (tp->hint) fprintf(f, " hint=%s", tp->hint);
  701.         if (tp->units) fprintf(f, " units=%s", tp->units);
  702. if (tp->number_modules > 1) {
  703.     fprintf(f, " modules:");
  704.     for (i = 1; i < tp->number_modules; i++)
  705. fprintf(f, " %s", module_name(tp->module_list[i], modbuf));
  706. }
  707. fprintf(f, "n");
  708.     }
  709.     for(tp = tree->child_list; tp; tp = tp->next_peer){
  710.         if (tp->child_list)
  711.             print_subtree(f, tp, count);
  712.     }
  713. #endif
  714. }
  716. void
  717. print_ascii_dump_tree(FILE *f,
  718.       struct tree *tree,
  719.       int count)
  720. {
  721.     struct tree *tp;
  723.     count++;
  724.     for(tp = tree->child_list; tp; tp = tp->next_peer){
  725.           fprintf(f, "%s OBJECT IDENTIFIER ::= { %s %ld }n", tp->label, tree->label, tp->subid);
  726.     }
  727.     for(tp = tree->child_list; tp; tp = tp->next_peer){
  728.         if (tp->child_list)
  729.             print_ascii_dump_tree(f, tp, count);
  730.     }
  731. }
  732. #ifdef UCD_SNMP
  733. static int translation_table[256];
  735. static void
  736. build_translation_table()
  737. {
  738.     int count;
  740.     for(count = 0; count < 256; count++){
  741.         switch(count){
  742.             case OBJID:
  743.                 translation_table[count] = TYPE_OBJID;
  744.                 break;
  745.             case OCTETSTR:
  746.                 translation_table[count] = TYPE_OCTETSTR;
  747.                 break;
  748.             case INTEGER:
  749.                 translation_table[count] = TYPE_INTEGER;
  750.                 break;
  751.             case NETADDR:
  752.                 translation_table[count] = TYPE_IPADDR;
  753.                 break;
  754.             case IPADDR:
  755.                 translation_table[count] = TYPE_IPADDR;
  756.                 break;
  757.             case COUNTER:
  758.                 translation_table[count] = TYPE_COUNTER;
  759.                 break;
  760.             case GAUGE:
  761.                 translation_table[count] = TYPE_GAUGE;
  762.                 break;
  763.             case TIMETICKS:
  764.                 translation_table[count] = TYPE_TIMETICKS;
  765.                 break;
  766.             case KW_OPAQUE:
  767.                 translation_table[count] = TYPE_OPAQUE;
  768.                 break;
  769.             case NUL:
  770.                 translation_table[count] = TYPE_NULL;
  771.                 break;
  772.             case COUNTER64:
  773.                 translation_table[count] = TYPE_COUNTER64;
  774.                 break;
  775.             case BITSTRING:
  776.                 translation_table[count] = TYPE_BITSTRING;
  777.                 break;
  778.             case NSAPADDRESS:
  779.                 translation_table[count] = TYPE_NSAPADDRESS;
  780.                 break;
  781.             case UINTEGER32:
  782.                 translation_table[count] = TYPE_UINTEGER;
  783.                 break;
  784.             default:
  785.                 translation_table[count] = TYPE_OTHER;
  786.                 break;
  787.         }
  788.     }
  789. }
  790. #endif
  791. /*static void
  792. init_tree_roots()
  793. {
  794.     struct tree *tp, *lasttp;
  795.     int  base_modid;
  796.     int  hash;
  798.     base_modid = which_module("SNMPv2-SMI");
  799.     if (base_modid == -1 )
  800.         base_modid = which_module("RFC1155-SMI");
  801.     if (base_modid == -1 )
  802.         base_modid = which_module("RFC1213-MIB");
  804.     // build root node 
  805.     tp = (struct tree *) calloc(1, sizeof(struct tree));
  806.     if (tp == NULL) return;
  807.     tp->label = strdup("joint-iso-ccitt");
  808. #ifdef UCD_SNMP
  809.     tp->modid = base_modid;
  810.     tp->number_modules = 1;
  811.     tp->module_list = &(tp->modid);
  812.     tp->tc_index = -1;
  813. #endif
  814.     tp->subid = 2;
  815.     set_function(tp); // from mib.c 
  816.     hash = NBUCKET(name_hash(tp->label));
  817.     tp->next = tbuckets[hash];
  818.     tbuckets[hash] = tp;
  819.     lasttp = tp;
  820.     root_imports[0].label = strdup( tp->label );
  821.     root_imports[0].modid = base_modid;
  823.     // build root node 
  824.     tp = (struct tree *) calloc(1, sizeof(struct tree));
  825.     if (tp == NULL) return;
  826.     tp->next_peer = lasttp;
  827.     tp->label = strdup("ccitt");
  828. #ifdef UCD_SNMP
  829.     tp->modid = base_modid;
  830.     tp->number_modules = 1;
  831.     tp->module_list = &(tp->modid);
  832.     tp->tc_index = -1;
  833. #endif
  834.     tp->subid = 0;
  835.     set_function(tp); // from mib.c 
  836.     hash = NBUCKET(name_hash(tp->label));
  837.     tp->next = tbuckets[hash];
  838.     tbuckets[hash] = tp;
  839.     lasttp = tp;
  840.     root_imports[1].label = strdup( tp->label );
  841.     root_imports[1].modid = base_modid;
  843.     // build root node 
  844.     tp = (struct tree *) calloc(1, sizeof(struct tree));
  845.     if (tp == NULL) return;
  846.     tp->next_peer = lasttp;
  847.     tp->label = strdup("iso");
  848. #ifdef UCD_SNMP
  849.     tp->modid = base_modid;
  850.     tp->number_modules = 1;
  851.     tp->module_list = &(tp->modid);
  852.     tp->tc_index = -1;
  853. #endif
  854.     tp->subid = 1;
  855.     set_function(tp); // from mib.c
  856.     hash = NBUCKET(name_hash(tp->label));
  857.     tp->next = tbuckets[hash];
  858.     tbuckets[hash] = tp;
  859.     lasttp = tp;
  860.     root_imports[2].label = strdup( tp->label );
  861.     root_imports[2].modid = base_modid;
  863.     tree_head = tp;
  864. }
  865. */
  866. #ifdef STRICT_MIB_PARSEING
  867. #define label_compare strcasecmp
  868. #else
  869. #define label_compare strcmp
  870. #endif
  872. struct tree *
  873. find_tree_node(const char *name,
  874.        int modid)
  875. {
  876.     struct tree *tp, *headtp;
  877.   #ifdef UCD_SNMP
  878.     int count, *int_p, i;
  879.   #endif
  881.     if (!name || !*name)
  882. return(NULL);
  884.     headtp = tbuckets[NBUCKET(name_hash(name))];
  885.     for ( tp = headtp ; tp ; tp = tp->next ) {
  886.         if ( !label_compare(tp->label, name) ) {
  888.             if ( modid == -1 ) /* Any module */
  889.                 return(tp);
  890. #ifdef UCD_SNMP
  891.             for (int_p = tp->module_list, count=0 ;
  892.                        count < tp->number_modules ;
  893.                        ++count, ++int_p )
  894.                 if ( *int_p == modid )
  895. #endif
  896.                     return(tp);
  897.         }
  898.     }
  900.     return(NULL);
  901. }
  903. /* computes a value which represents how close name1 is to name2.
  904.  * high scores mean a worse match.
  905.  * (yes, the algorithm sucks!)
  906.  */
  907. #define MAX_BAD 0xffffff
  909. u_int
  910. compute_match(const char *search_base, const char *key) {
  911. #if defined(HAVE_REGEX_H) && defined(HAVE_REGCOMP)
  912.     int rc;
  913.     regex_t parsetree;
  914.     regmatch_t pmatch;
  916.     rc=regcomp(&parsetree, key, REG_ICASE | REG_EXTENDED);
  917.     if (rc == 0)
  918.         rc=regexec(&parsetree, search_base, 1, &pmatch, 0);
  919.     regfree(&parsetree);
  920.     if (rc == 0) {
  921.         /* found */
  922.         return pmatch.rm_so;
  923.     }
  924. #else /* use our own wildcard matcher */
  925.     /* first find the longest matching substring (ick) */
  926.     char *first = NULL, *result = NULL, *entry;
  927.     const char *position;
  928.     char *newkey = strdup(key);
  931.     entry = strtok( newkey, "*" );
  932.     position = search_base;
  933.     while ( entry ) {
  934.         result = strcasestr(position, entry);
  936.         if (result == NULL) {
  937.             free(newkey);
  938.             return MAX_BAD;
  939.         }
  941.         if (first == NULL)
  942.             first = result;
  944.         position = result + strlen(entry);
  945.         entry = strtok( NULL, "*" );
  946.     }
  947.     free(newkey);
  948.     if (result)
  949.         return(first-search_base);
  950. #endif
  952.     /* not found */
  953.     return MAX_BAD;
  954. }
  956. /*
  957.  * Find the tree node that best matches the pattern string.
  958.  * Use the "reported" flag such that only one match
  959.  * is attempted for every node.
  960.  *
  961.  * Warning! This function may recurse.
  962.  *
  963.  * Caller _must_ invoke clear_tree_flags before first call
  964.  * to this function.  This function may be called multiple times
  965.  * to ensure that the entire tree is traversed.
  966.  */
  968. struct tree *
  969. find_best_tree_node(const char *pattrn, struct tree *tree_top, u_int *match)
  970. {
  971.     struct tree *tp, *best_so_far = NULL, *retptr;
  972.     u_int old_match=MAX_BAD, new_match=MAX_BAD;
  974.     if (!pattrn || !*pattrn)
  975. return(NULL);
  977.     if (!tree_top)
  978.         tree_top = get_tree_head();
  980.     for ( tp = tree_top ; tp ; tp=tp->next_peer ) {
  981.         if (!tp->reported)
  982.             new_match = compute_match(tp->label, pattrn);
  983.         tp->reported = 1;
  985.         if (new_match < old_match) {
  986.             best_so_far = tp;
  987.             old_match = new_match;
  988.         }
  989.         if (new_match == 0)
  990.             break;  /* this is the best result we can get */
  991.         if (tp->child_list) {
  992.             retptr = find_best_tree_node(pattrn, tp->child_list, &new_match);
  993.             if (new_match < old_match) {
  994.                 best_so_far = retptr;
  995.                 old_match = new_match;
  996.             }
  997.             if (new_match == 0)
  998.                 break;  /* this is the best result we can get */
  999.         }
  1000.     }
  1002.     if (match)
  1003.         *match = old_match;
  1004.     return(best_so_far);
  1005. }
  1008. static void
  1009. merge_anon_children(struct tree *tp1,
  1010.     struct tree *tp2)
  1011. /* NB: tp1 is the 'anonymous' node */
  1012. {
  1013.     struct tree *child1, *child2, *previous;
  1015.     for ( child1 = tp1->child_list ; child1 ; ) {
  1017.         for ( child2 = tp2->child_list, previous = NULL ;
  1018.               child2 ; previous = child2, child2 = child2->next_peer ) {
  1020.             if ( child1->subid == child2->subid ) {
  1021. /*
  1022.  * Found 'matching' children,
  1023.  *  so merge them
  1024.  */
  1025. if ( !strncmp( child1->label, ANON, ANON_LEN)) {
  1026.                     merge_anon_children( child1, child2 );
  1028.                     child1->child_list = NULL;
  1029.                     previous = child1; /* Finished with 'child1' */
  1030.                     child1 = child1->next_peer;
  1031.                     free_tree( previous );
  1032.                     goto next;
  1033.                 }
  1035. else if ( !strncmp( child2->label, ANON, ANON_LEN)) {
  1036.                     merge_anon_children( child2, child1 );
  1038.                     if ( previous )
  1039.                          previous->next_peer = child2->next_peer;
  1040.                     else
  1041.                          tp2->child_list = child2->next_peer;
  1042.                     free_tree(child2);
  1044.                     previous = child1; /* Move 'child1' to 'tp2' */
  1045.                     child1 = child1->next_peer;
  1046.                     previous->next_peer = tp2->child_list;
  1047.                     tp2->child_list = previous;
  1048.                     for ( previous = tp2->child_list ;
  1049.                           previous ;
  1050.                           previous = previous->next_peer )
  1051.                                 previous->parent = tp2;
  1052.                     goto next;
  1053.                 }
  1054. else if ( !label_compare( child1->label, child2->label) ) {
  1055.             if (ds_get_int(DS_LIBRARY_ID, DS_LIB_MIB_WARNINGS))
  1056.         snmp_log(LOG_WARNING, "Warning: %s.%ld is both %s and %s (%s)n",
  1057.         tp2->label, child1->subid,
  1058.                                 child1->label, child2->label, File);
  1059.                     continue;
  1060.                 }
  1061.                 else {
  1062. /*
  1063.  * Two copies of the same node.
  1064.  * 'child2' adopts the children of 'child1'
  1065.  */
  1067.                     if ( child2->child_list ) {
  1068.                         for ( previous = child2->child_list ;
  1069.                               previous->next_peer ;
  1070.                               previous = previous->next_peer )
  1071.                                   ; /* Find the end of the list */
  1072.                         previous->next_peer = child1->child_list;
  1073.                     }
  1074.                     else
  1075.                         child2->child_list = child1->child_list;
  1076.                     for ( previous = child1->child_list ;
  1077.                           previous ;
  1078.                           previous = previous->next_peer )
  1079.                                   previous->parent = child2;
  1080.                     child1->child_list = NULL;
  1082.                     previous = child1; /* Finished with 'child1' */
  1083.                     child1 = child1->next_peer;
  1084.                     free_tree( previous );
  1085.                     goto next;
  1086.                 }
  1087.             }
  1088.         }
  1089. /*
  1090.  * If no match, move 'child1' to 'tp2' child_list
  1091.  */
  1092.         if ( child1 ) {
  1093.             previous = child1;
  1094.             child1 = child1->next_peer;
  1095.             previous->parent = tp2;
  1096.             previous->next_peer = tp2->child_list;
  1097.             tp2->child_list = previous;
  1098.         }
  1099.       next:;
  1100.     }
  1101. }
  1104. /*
  1105.  * Find all the children of root in the list of nodes.  Link them into the
  1106.  * tree and out of the nodes list.
  1107.  */
  1108. static void
  1109. do_subtree(struct tree *root,
  1110.    struct node **nodes)
  1111. {
  1112. #ifdef UCD_SNMP
  1113.     register struct tree *tp, *anon_tp=NULL;
  1114.     register struct node *np, **headp;
  1115.     struct node *oldnp = NULL, *child_list = NULL, *childp = NULL;
  1116.     int hash;
  1117.     int *int_p;
  1119.     tp = root;
  1120.     headp = &nbuckets[NBUCKET(name_hash(tp->label))];
  1121.     /*
  1122.      * Search each of the nodes for one whose parent is root, and
  1123.      * move each into a separate list.
  1124.      */
  1125.     for(np = *headp; np; np = np->next){
  1126.         if ( !label_compare(tp->label, np->parent)){
  1127.             /* take this node out of the node list */
  1128.             if (oldnp == NULL){
  1129.                 *headp = np->next;  /* fix root of node list */
  1130.             } else {
  1131.                 oldnp->next = np->next; /* link around this node */
  1132.             }
  1133.             if (child_list) childp->next = np;
  1134.             else child_list = np;
  1135.             childp = np;
  1136.         }
  1137.         else {
  1138.     oldnp = np;
  1139.         }
  1141.     }
  1142.     if (childp) childp->next = NULL;
  1143.     /*
  1144.      * Take each element in the child list and place it into the tree.
  1145.      */
  1146.     for(np = child_list; np; np = np->next){
  1147. anon_tp = NULL;
  1148.         tp = root->child_list;
  1149.         while (tp)
  1150.             if (tp->subid == np->subid) break;
  1151.             else tp = tp->next_peer;
  1152.         if (tp) {
  1153.     if (!label_compare (tp->label, np->label)) {
  1154.     /* Update list of modules */
  1155.                 int_p = (int *) malloc((tp->number_modules+1) * sizeof(int));
  1156.                 if (int_p == NULL) return;
  1157.                 memcpy(int_p, tp->module_list, tp->number_modules*sizeof(int));
  1158.                 int_p[tp->number_modules] = np->modid;
  1159.                 if (tp->number_modules > 1 )
  1160.                    free(tp->module_list);
  1161.                 ++tp->number_modules;
  1162.                 tp->module_list = int_p;
  1164. if ( ds_get_boolean(DS_LIBRARY_ID, DS_LIB_MIB_REPLACE) ) {
  1165.     /* Replace from node */
  1166.     tree_from_node(tp,np);
  1167. }
  1168.     /* Handle children */
  1169. do_subtree(tp, nodes);
  1170. continue;
  1171.             }
  1172.             if (!strncmp( np->label, ANON, ANON_LEN) ||
  1173.                 !strncmp( tp->label, ANON, ANON_LEN)) {
  1174.                 anon_tp = tp; /* Need to merge these two trees later */
  1175.             }
  1176.     else if (ds_get_int(DS_LIBRARY_ID, DS_LIB_MIB_WARNINGS))
  1177. snmp_log(LOG_WARNING, "Warning: %s.%ld is both %s and %s (%s)n",
  1178. root->label, np->subid, tp->label, np->label, File);
  1179. }
  1181.         tp = (struct tree *) calloc(1, sizeof(struct tree));
  1182.         if (tp == NULL) return;
  1183.         tp->parent = root;
  1184.         tp->modid = np->modid;
  1185.         tp->number_modules = 1;
  1186.         tp->module_list = &(tp->modid);
  1187.         tree_from_node(tp, np);
  1188.         tp->next_peer = root->child_list;
  1189.         root->child_list = tp;
  1190.         hash = NBUCKET(name_hash(tp->label));
  1191.         tp->next = tbuckets[hash];
  1192.         tbuckets[hash] = tp;
  1193. /*      if (tp->type == TYPE_OTHER) */
  1194.             do_subtree(tp, nodes);      /* recurse on this child if it isn't
  1195.                                            an end node */
  1196.         if ( anon_tp ) {
  1197.             if (!strncmp( tp->label, ANON, ANON_LEN)) {
  1198. /*
  1199.  * The new node is anonymous,
  1200.  *  so merge it with the existing one.
  1201.  */
  1202.                 merge_anon_children( tp, anon_tp );
  1204. /* unlink and destroy tp */
  1205. unlink_tree(tp);
  1206. free_tree(tp);
  1207.             }
  1208.             else if (!strncmp( anon_tp->label, ANON, ANON_LEN)) {
  1209. struct tree *ntp;
  1210. /*
  1211.  * The old node was anonymous,
  1212.  *  so merge it with the existing one,
  1213.  *  and fill in the full information.
  1214.  */
  1215.                 merge_anon_children( anon_tp, tp );
  1217. /* unlink anon_tp from the hash */
  1218. unlink_tbucket(anon_tp);
  1220. /* get rid of old contents of anon_tp */
  1221.                 free_partial_tree(anon_tp, FALSE);
  1223. /* put in the current information */
  1224.                 anon_tp->label = tp->label;
  1225.                 anon_tp->child_list = tp->child_list;
  1226.                 anon_tp->modid = tp->modid;
  1227.                 anon_tp->tc_index = tp->tc_index;
  1228.                 anon_tp->type = tp->type;
  1229.                 anon_tp->enums = tp->enums;
  1230.                 anon_tp->indexes = tp->indexes;
  1231.                 anon_tp->ranges = tp->ranges;
  1232.                 anon_tp->hint = tp->hint;
  1233.                 anon_tp->units = tp->units;
  1234.                 anon_tp->description = tp->description;
  1235. anon_tp->parent = tp->parent;
  1236.                 set_function(anon_tp);
  1238. /* update parent pointer in moved children */
  1239. ntp = anon_tp->child_list;
  1240. while (ntp) {
  1241.     ntp->parent = anon_tp;
  1242.     ntp = ntp->next_peer;
  1243. }
  1245. /* hash in anon_tp in its new place */
  1246. hash = NBUCKET(name_hash(anon_tp->label));
  1247. anon_tp->next = tbuckets[hash];
  1248. tbuckets[hash] = anon_tp;
  1250. /* unlink and destroy tp */
  1251. unlink_tbucket(tp);
  1252. unlink_tree(tp);
  1253. free(tp);
  1254.             }
  1255.             else {
  1256.                 /* Uh?  One of these two should have been anonymous! */
  1257.         if (ds_get_int(DS_LIBRARY_ID, DS_LIB_MIB_WARNINGS))
  1258.     snmp_log(LOG_WARNING,
  1259.                              "Warning: expected anonymous node (either %s or %s) in %sn",
  1260.                              tp->label, anon_tp->label, File);
  1261.             }
  1262.             anon_tp = NULL;
  1263.         }
  1264.     }
  1265.     /* free all nodes that were copied into tree */
  1266.     oldnp = NULL;
  1267.     for(np = child_list; np; np = np->next){
  1268.         if (oldnp)
  1269.             free_node(oldnp);
  1270.         oldnp = np;
  1271.     }
  1272.     if (oldnp)
  1273.         free_node(oldnp);
  1274. #endif
  1275. }
  1277. static void do_linkup(struct module *mp,
  1278.       struct node *np)
  1279. {
  1280.     struct module_import *mip;
  1281.     struct node *onp;
  1282.     struct tree *tp;
  1283.     int i;
  1284. /*
  1285.  * All modules implicitly import
  1286.  *   the roots of the tree
  1287.  */
  1288.     if (snmp_get_do_debugging() > 1) dump_module_list();
  1289.     DEBUGMSGTL(("parse-mibs", "Processing IMPORTS for module %d %sn", mp->modid, mp->name));
  1290.     if ( mp->no_imports == 0 ) {
  1291. mp->no_imports = NUMBER_OF_ROOT_NODES;
  1292. mp->imports = root_imports;
  1293.     }
  1295. /*
  1296.  * Build the tree
  1297.  */
  1298.     init_node_hash( np );
  1299.     for ( i=0, mip=mp->imports ; i < mp->no_imports ; ++i, ++mip ) {
  1300. char modbuf[256];
  1301. DEBUGMSGTL(("parse-mibs", "  Processing import: %sn", mip->label));
  1302. if (get_tc_index( mip->label, mip->modid ) != -1)
  1303.     continue;
  1304. tp = find_tree_node( mip->label, mip->modid );
  1305. if (!tp) {
  1306.     if (mip->modid != -1)
  1307. snmp_log(LOG_WARNING, "Did not find '%s' in module %s (%s)n",
  1308.                          mip->label, module_name(mip->modid, modbuf), File);
  1309.     continue;
  1310. }
  1311. do_subtree( tp, &np );
  1312.     }
  1314. /*
  1315.  * If any nodes left over,
  1316.  *   check that they're not the result of a "fully qualified"
  1317.  *   name, and then add them to the list of orphans
  1318.  */
  1320.     if (!np) return;
  1321.     for ( tp = tree_head ; tp ; tp=tp->next_peer )
  1322.         do_subtree( tp, &np );
  1323.     if (!np) return;
  1324.     for ( np = orphan_nodes ; np && np->next ; np = np->next )
  1325. ; /* find the end of the orphan list */
  1326.     for (i = 0; i < NHASHSIZE; i++)
  1327. if ( nbuckets[i] ) {
  1328.     if ( orphan_nodes )
  1329. onp = np->next = nbuckets[i];
  1330.     else
  1331. onp = orphan_nodes = nbuckets[i];
  1332.     nbuckets[i] = NULL;
  1333.     while (onp) {
  1334. if (ds_get_int(DS_LIBRARY_ID, DS_LIB_MIB_WARNINGS))
  1335.     snmp_log(LOG_WARNING,
  1336.                              "Unlinked OID in %s: %s ::= { %s %ld }n",
  1337.                              (mp->name ? mp->name : "<no module>"),
  1338.                              (onp->label ? onp->label : "<no label>"),
  1339.                              (onp->parent ? onp->parent : "<no parent>"),
  1340.                              onp->subid);
  1341. np = onp;
  1342. onp = onp->next;
  1343.     }
  1344. }
  1346.     return;
  1347. }
  1350. /*
  1351.  * Takes a list of the form:
  1352.  * { iso org(3) dod(6) 1 }
  1353.  * and creates several nodes, one for each parent-child pair.
  1354.  * Returns 0 on error.
  1355.  */
  1356. static int
  1357. getoid(FILE *fp,
  1358.        struct subid_s *id, /* an array of subids */
  1359.        int length)  /* the length of the array */
  1360. {
  1361.     register int count;
  1362.     int type;
  1363.     char token[MAXTOKEN];
  1365.     if ((type = get_token(fp, token, MAXTOKEN)) != LEFTBRACKET){
  1366.         print_error("Expected "{"", token, type);
  1367.         return 0;
  1368.     }
  1369.     type = get_token(fp, token, MAXTOKEN);
  1370.     for(count = 0; count < length; count++, id++){
  1371.         id->label = NULL;
  1372.         id->modid = current_module;
  1373.         id->subid = -1;
  1374.         if (type == RIGHTBRACKET){
  1375.             return count;
  1376.         } else if (type != LABEL && type != NUMBER){
  1377.             print_error("Not valid for object identifier", token, type);
  1378.             return 0;
  1379.         }
  1380.         if (type == LABEL){
  1381.             /* this entry has a label */
  1382.             id->label = strdup(token);
  1383.             type = get_token(fp, token, MAXTOKEN);
  1384.             if (type == LEFTPAREN){
  1385.                 type = get_token(fp, token, MAXTOKEN);
  1386.                 if (type == NUMBER){
  1387.                     id->subid = atoi(token);
  1388.                     if ((type = get_token(fp, token, MAXTOKEN)) != RIGHTPAREN){
  1389.                         print_error("Expected a closing parenthesis",
  1390.                                     token, type);
  1391.                         return 0;
  1392.                     }
  1393.                 } else {
  1394.                     print_error("Expected a number", token, type);
  1395.                     return 0;
  1396.                 }
  1397.             } else {
  1398.                 continue;
  1399.             }
  1400.         } else if (type == NUMBER) {
  1401.             /* this entry  has just an integer sub-identifier */
  1402.             id->subid = atoi(token);
  1403.         }
  1404. else {
  1405.     print_error("Expected label or number", token, type);
  1406.     return 0;
  1407. }
  1408.         type = get_token(fp, token, MAXTOKEN);
  1409.     }
  1410.     print_error ("Too long OID", token, type);
  1411.     return 0;
  1412. }
  1414. /*
  1415.  * Parse a sequence of object subidentifiers for the given name.
  1416.  * The "label OBJECT IDENTIFIER ::=" portion has already been parsed.
  1417.  *
  1418.  * The majority of cases take this form :
  1419.  * label OBJECT IDENTIFIER ::= { parent 2 }
  1420.  * where a parent label and a child subidentifier number are specified.
  1421.  *
  1422.  * Variations on the theme include cases where a number appears with
  1423.  * the parent, or intermediate subidentifiers are specified by label,
  1424.  * by number, or both.
  1425.  *
  1426.  * Here are some representative samples :
  1427.  * internet        OBJECT IDENTIFIER ::= { iso org(3) dod(6) 1 }
  1428.  * mgmt            OBJECT IDENTIFIER ::= { internet 2 }
  1429.  * rptrInfoHealth  OBJECT IDENTIFIER ::= { snmpDot3RptrMgt 0 4 }
  1430.  *
  1431.  * Here is a very rare form :
  1432.  * iso             OBJECT IDENTIFIER ::= { 1 }
  1433.  *
  1434.  * Returns NULL on error.  When this happens, memory may be leaked.
  1435.  */
  1436. static struct node *
  1437. parse_objectid(FILE *fp,
  1438.        char *name)
  1439. {
  1440.     register int count;
  1441.     register struct subid_s *op, *nop;
  1442.     int length;
  1443.     struct subid_s loid[32];
  1444.     struct node *np, *root = NULL, *oldnp = NULL;
  1445.     struct tree *tp;
  1447.     if ((length = getoid(fp, loid, 32)) == 0){
  1448.         print_error("Bad object identifier", NULL, CONTINUE);
  1449.         return NULL;
  1450.     }
  1452.     /*
  1453.      * Handle numeric-only object identifiers,
  1454.      *  by labelling the first sub-identifier
  1455.      */
  1456.     op = loid;
  1457.     if ( !op->label )
  1458.       for ( tp = tree_head ; tp ; tp=tp->next_peer )
  1459.         if ( (int)tp->subid == op->subid ) {
  1460.             op->label = strdup(tp->label);
  1461.             break;
  1462.         }
  1464.     /*
  1465.      * Handle  "label OBJECT-IDENTIFIER ::= { subid }"
  1466.      */
  1467.     if (length == 1) {
  1468.         op = loid;
  1469.         np = alloc_node(op->modid);
  1470.         if (np == NULL) return(NULL);
  1471.         np->subid = op->subid;
  1472.         np->label = strdup(name);
  1473.         if (op->label) free(op->label);
  1474.         return np;
  1475.     }
  1477.     /*
  1478.      * For each parent-child subid pair in the subid array,
  1479.      * create a node and link it into the node list.
  1480.      */
  1481.     for(count = 0, op = loid, nop=loid+1; count < (length - 1);
  1482.       count++, op++, nop++){
  1483.         /* every node must have parent's name and child's name or number */
  1484. /* XX the next statement is always true -- does it matter ?? */
  1485.         if (op->label && (nop->label || (nop->subid != -1))){
  1486.             np = alloc_node(nop->modid);
  1487.             if (np == NULL) return(NULL);
  1488.             if (root == NULL) root = np;
  1490.             np->parent = strdup (op->label);
  1491.             if (count == (length - 2)) {
  1492.                 /* The name for this node is the label for this entry */
  1493.                 np->label = strdup (name);
  1494.             }
  1495.             else {
  1496.                 if (!nop->label) {
  1497.                     nop->label = (char *) malloc(20 + ANON_LEN);
  1498.                     if (nop->label == NULL) return(NULL);
  1499.                     sprintf(nop->label, "%s%d", ANON, anonymous++);
  1500.                 }
  1501.                 np->label = strdup (nop->label);
  1502.             }
  1503.             if (nop->subid != -1)
  1504.                 np->subid = nop->subid;
  1505.             else
  1506.                 print_error("Warning: This entry is pretty silly",
  1507.     np->label, CONTINUE);
  1509.             /* set up next entry */
  1510.             if (oldnp) oldnp->next = np;
  1511.             oldnp = np;
  1512.         } /* end if(op->label... */
  1513.     }
  1515.     /* free the loid array */
  1516.     for(count = 0, op = loid; count < length; count++, op++){
  1517.         if (op->label)
  1518.             free(op->label);
  1519.     }
  1521.     return root;
  1522. }
  1524. static int
  1525. get_tc(const char *descriptor,
  1526.        int modid,
  1527.        int *tc_index,
  1528.        struct enum_list **ep,
  1529.        struct range_list **rp,
  1530.        char **hint)
  1531. {
  1532.     int i;
  1533.     struct tc *tcp;
  1535.     i = get_tc_index(descriptor, modid);
  1536.     if (tc_index) *tc_index = i;
  1537.     if (i != -1)
  1538.       {
  1539.   tcp = &tclist[i];
  1540. if (ep) {
  1541.     free_enums(ep);
  1542.     *ep = copy_enums(tcp->enums);
  1543. }
  1544. if (rp) {
  1545.     free_ranges(rp);
  1546.     *rp = copy_ranges(tcp->ranges);
  1547. }
  1548. if (hint) {
  1549.     if (*hint) free(*hint);
  1550.     *hint = (tcp->hint ? strdup(tcp->hint) : NULL);
  1551. }
  1552. return tcp->type;
  1553.       }
  1554.     return LABEL;
  1555. }
  1557. /* return index into tclist of given TC descriptor
  1558.    return -1 if not found
  1559.  */
  1560. static int
  1561. get_tc_index(const char *descriptor,
  1562.      int modid)
  1563. {
  1564.     int i;
  1565.     struct tc *tcp;
  1566.     struct module *mp;
  1567.     struct module_import *mip;
  1569. /*
  1570.  * Check that the descriptor isn't imported
  1571.  *  by searching the import list
  1572.  */
  1574.     for ( mp = module_head ; mp ; mp = mp->next )
  1575.          if ( mp->modid == modid )
  1576.              break;
  1577.     if ( mp )
  1578.          for ( i=0, mip=mp->imports ; i < mp->no_imports ; ++i, ++mip ) {
  1579.              if ( !label_compare( mip->label, descriptor )) {
  1580. /* Found it - so amend the module ID */
  1581.                   modid = mip->modid;
  1582.                   break;
  1583.              }
  1584.          }
  1587.     for(i=0, tcp=tclist; i < MAXTC; i++, tcp++){
  1588.       if (tcp->type == 0)
  1589.           break;
  1590.       if (!label_compare(descriptor, tcp->descriptor) &&
  1591. ((modid == tcp->modid) || (modid == -1))){
  1592.           return i;
  1593.       }
  1594.     }
  1595.     return -1;
  1596. }
  1598. /* translate integer tc_index to string identifier from tclist
  1599.  *
  1600.  * Returns pointer to string in table (should not be modified) or NULL
  1601.  */
  1602. const char *
  1603. get_tc_descriptor(int tc_index)
  1604. {
  1605.   if (tc_index < 0 || tc_index >= MAXTC) return NULL;
  1606.   return (tclist[tc_index].descriptor);
  1607. }
  1610. /*
  1611.  * Parses an enumeration list of the form:
  1612.  *        { label(value) label(value) ... }
  1613.  * The initial { has already been parsed.
  1614.  * Returns NULL on error.
  1615.  */
  1617. static struct enum_list *
  1618. parse_enumlist(FILE *fp, struct enum_list **retp)
  1619. {
  1620.     register int type;
  1621.     char token [MAXTOKEN];
  1622.     struct enum_list *ep = NULL, **epp = &ep;
  1624.     free_enums(retp);
  1626.     while((type = get_token(fp, token, MAXTOKEN)) != ENDOFFILE){
  1627.         if (type == RIGHTBRACKET)
  1628.             break;
  1629.         if (type == LABEL){
  1630.             /* this is an enumerated label */
  1631.             *epp = (struct enum_list *) calloc(1, sizeof(struct enum_list));
  1632.             if (*epp == NULL) return(NULL);
  1633.             /* a reasonable approximation for the length */
  1634.             (*epp)->label = strdup(token);
  1635.             type = get_token(fp, token, MAXTOKEN);
  1636.             if (type != LEFTPAREN) {
  1637.                 print_error("Expected "("", token, type);
  1638.                 return NULL;
  1639.             }
  1640.             type = get_token(fp, token, MAXTOKEN);
  1641.             if (type != NUMBER) {
  1642.                 print_error("Expected integer", token, type);
  1643.                 return NULL;
  1644.             }
  1645.             (*epp)->value = atoi(token);
  1646.             type = get_token(fp, token, MAXTOKEN);
  1647.             if (type != RIGHTPAREN) {
  1648.                 print_error("Expected ")"", token, type);
  1649.                 return NULL;
  1650.             }
  1651.             epp = &(*epp)->next;
  1652.         }
  1653.     }
  1654.     if (type == ENDOFFILE){
  1655.         print_error("Expected "}"", token, type);
  1656.         return NULL;
  1657.     }
  1658.     *retp = ep;
  1659.     return ep;
  1660. }
  1662. static struct range_list *parse_ranges(FILE *fp, struct range_list **retp)
  1663. {   int low, high;
  1664.     char nexttoken[MAXTOKEN];
  1665.     int nexttype;
  1666.     struct range_list *rp = NULL, **rpp = &rp;
  1667.     int size = 0, taken = 1;
  1669.     free_ranges(retp);
  1671.     nexttype = get_token(fp, nexttoken, MAXTOKEN);
  1672.     if (nexttype == SIZE) {
  1673. size = 1;
  1674. taken = 0;
  1675. nexttype = get_token(fp, nexttoken, MAXTOKEN);
  1676. if (nexttype != LEFTPAREN)
  1677.     print_error("Expected "(" after SIZE", nexttoken, nexttype);
  1678.     }
  1680.     do {
  1681. if (!taken) nexttype = get_token(fp, nexttoken, MAXTOKEN);
  1682. else taken = 0;
  1683. high = low = atol(nexttoken);
  1684. nexttype = get_token(fp, nexttoken, MAXTOKEN);
  1685. if (nexttype == RANGE) {
  1686.     nexttype = get_token(fp, nexttoken, MAXTOKEN);
  1687.     high = atol(nexttoken);
  1688.     nexttype = get_token(fp, nexttoken, MAXTOKEN);
  1689. }
  1690. *rpp = (struct range_list *)calloc (1, sizeof(struct range_list));
  1691. if (*rpp == NULL) break;
  1692. (*rpp)->low = low;
  1693. (*rpp)->high = high;
  1694. rpp = &(*rpp)->next;
  1696.     } while (nexttype == BAR);
  1697.     if (size) {
  1698. if (nexttype != RIGHTPAREN)
  1699.     print_error ("Expected ")" after SIZE", nexttoken, nexttype);
  1700. nexttype = get_token(fp, nexttoken, nexttype);
  1701.     }
  1702.     if (nexttype != RIGHTPAREN)
  1703. print_error ("Expected ")"", nexttoken, nexttype);
  1705.     *retp = rp;
  1706.     return rp;
  1707. }
  1709. /*
  1710.  * Parses an asn type.  Structures are ignored by this parser.
  1711.  * Returns NULL on error.
  1712.  */
  1713. static struct node *
  1714. parse_asntype(FILE *fp,
  1715.       char *name,
  1716.       int *ntype,
  1717.       char *ntoken)
  1718. {
  1719.     int type, i;
  1720.     char token[MAXTOKEN];
  1721.     char quoted_string_buffer[MAXQUOTESTR];
  1722.     char *hint = NULL;
  1723.     struct tc *tcp;
  1724.     int level;
  1726.     type = get_token(fp, token, MAXTOKEN);
  1727.     if (type == SEQUENCE){
  1728.         level = 0;
  1729.         while((type = get_token(fp, token, MAXTOKEN)) != ENDOFFILE){
  1730.             if (type == LEFTBRACKET){
  1731.                 level++;
  1732.             }
  1733.             else if (type == RIGHTBRACKET && --level == 0){
  1734.                 *ntype = get_token(fp, ntoken, MAXTOKEN);
  1735.                 return NULL;
  1736.             }
  1737.         }
  1738.         print_error("Expected "}"", token, type);
  1739.         return NULL;
  1740.     } else if (type == LEFTBRACKET) {
  1741.         struct node *np;
  1742.         int ch_next = '{';
  1743.         ungetc(ch_next, fp);
  1744.         np = parse_objectid (fp, name);
  1745.         if (np != NULL) {
  1746.             *ntype = get_token(fp, ntoken, MAXTOKEN);
  1747.             return np;
  1748.         }
  1749.         return NULL;
  1750.     } else {
  1751.         if (type == CONVENTION) {
  1752.             while (type != SYNTAX && type != ENDOFFILE) {
  1753.                 if (type == DISPLAYHINT) {
  1754.                     type = get_token(fp, token, MAXTOKEN);
  1755.                     if (type != QUOTESTRING) print_error("DISPLAY-HINT must be string", token, type);
  1756.                     else hint = strdup (token);
  1757.                 }
  1758.                 else
  1759.     type = get_token(fp, quoted_string_buffer, MAXQUOTESTR);
  1760.             }
  1761.             type = get_token(fp, token, MAXTOKEN);
  1762.         }
  1764.         if (type == LABEL)
  1765.         {
  1766.             type = get_tc(token, current_module, NULL, NULL, NULL, NULL);
  1767.         }
  1769.         /* textual convention */
  1770.         for(i = 0; i < MAXTC; i++){
  1771.             if (tclist[i].type == 0)
  1772.                 break;
  1773.         }
  1775.         if (i == MAXTC){
  1776.             print_error("Too many textual conventions", token, type);
  1777.             SNMP_FREE(hint);
  1778.             return NULL;
  1779.         }
  1780.         if (!(type & SYNTAX_MASK)){
  1781.             print_error("Textual convention doesn't map to real type", token,
  1782.                         type);
  1783.             SNMP_FREE(hint);
  1784.             return NULL;
  1785.         }
  1786.         tcp = &tclist[i];
  1787.         tcp->modid = current_module;
  1788.         tcp->descriptor = strdup(name);
  1789.         tcp->hint = hint;
  1790.         tcp->type = type;
  1791.         *ntype = get_token(fp, ntoken, MAXTOKEN);
  1792.         if (*ntype == LEFTPAREN){
  1793.     tcp->ranges = parse_ranges(fp, &tcp->ranges);
  1794.             *ntype = get_token(fp, ntoken, MAXTOKEN);
  1795.         } else if (*ntype == LEFTBRACKET) {
  1796.             /* if there is an enumeration list, parse it */
  1797.             tcp->enums = parse_enumlist(fp, &tcp->enums);
  1798.             *ntype = get_token(fp, ntoken, MAXTOKEN);
  1799.         }
  1800.         return NULL;
  1801.     }
  1802. }
  1805. /*
  1806.  * Parses an OBJECT TYPE macro.
  1807.  * Returns 0 on error.
  1808.  */
  1809. static struct node *
  1810. parse_objecttype(FILE *fp,
  1811.  char *name)
  1812. {
  1813.     register int type;
  1814.     char token[MAXTOKEN];
  1815.     char nexttoken[MAXTOKEN];
  1816.     char quoted_string_buffer[MAXQUOTESTR];
  1817.     int nexttype, tctype;
  1818.     register struct node *np;
  1820.     type = get_token(fp, token, MAXTOKEN);
  1821.     if (type != SYNTAX){
  1822.         print_error("Bad format for OBJECT-TYPE", token, type);
  1823.         return NULL;
  1824.     }
  1825.     np = alloc_node(current_module);
  1826.     if (np == NULL) return(NULL);
  1827.     type = get_token(fp, token, MAXTOKEN);
  1828.     if (type == LABEL){
  1829.         int tmp_index;
  1830.         tctype = get_tc(token, current_module, &tmp_index,
  1831.                         &np->enums, &np->ranges, &np->hint);
  1832.         if (tctype == LABEL &&
  1833.             ds_get_int(DS_LIBRARY_ID, DS_LIB_MIB_WARNINGS) > 1){
  1834.             print_error("Warning: No known translation for type", token, type);
  1835.         }
  1836.         type = tctype;
  1837.         np->tc_index = tmp_index; /* store TC for later reference */
  1838.     }
  1839.     np->type = type;
  1840.     nexttype = get_token(fp, nexttoken, MAXTOKEN);
  1841.     switch(type){
  1842.         case SEQUENCE:
  1843.             if (nexttype == OF){
  1844.                 nexttype = get_token(fp, nexttoken, MAXTOKEN);
  1845.                 nexttype = get_token(fp, nexttoken, MAXTOKEN);
  1846.             }
  1847.             break;
  1848.         case INTEGER:
  1849.         case UINTEGER32:
  1850.         case COUNTER:
  1851.         case GAUGE:
  1852.         case BITSTRING:
  1853.         case LABEL:
  1854.             if (nexttype == LEFTBRACKET) {
  1855.                 /* if there is an enumeration list, parse it */
  1856.                 np->enums = parse_enumlist(fp, &np->enums);
  1857.                 nexttype = get_token(fp, nexttoken, MAXTOKEN);
  1858.             } else if (nexttype == LEFTPAREN){
  1859.                 /* if there is a range list, parse it */
  1860. np->ranges = parse_ranges(fp, &np->ranges);
  1861.                 nexttype = get_token(fp, nexttoken, MAXTOKEN);
  1862.             }
  1863.             break;
  1864.         case OCTETSTR:
  1865.         case KW_OPAQUE:
  1866.             /* parse any SIZE specification */
  1867.             if (nexttype == LEFTPAREN) {
  1868.                 nexttype = get_token(fp, nexttoken, MAXTOKEN);
  1869.                 if (nexttype == SIZE) {
  1870.                     nexttype = get_token(fp, nexttoken, MAXTOKEN);
  1871.                     if (nexttype == LEFTPAREN) {
  1872. np->ranges = parse_ranges(fp, &np->ranges);
  1873.                         nexttype = get_token(fp, nexttoken, MAXTOKEN); /* ) */
  1874.                         if (nexttype == RIGHTPAREN)
  1875.                         {
  1876.                             nexttype = get_token(fp, nexttoken, MAXTOKEN);
  1877.                             break;
  1878.                         }
  1879.                     }
  1880.                 }
  1881.                 print_error("Bad SIZE syntax", token, type);
  1882.                 free_node(np);
  1883.                 return NULL;
  1884.             }
  1885.             break;
  1886.         case OBJID:
  1887.         case NETADDR:
  1888.         case IPADDR:
  1889.         case TIMETICKS:
  1890.         case NUL:
  1891.         case NSAPADDRESS:
  1892.         case COUNTER64:
  1893.             break;
  1894.         default:
  1895.             print_error("Bad syntax", token, type);
  1896.             free_node(np);
  1897.             return NULL;
  1898.     }
  1899.     if (nexttype == UNITS){
  1900.         type = get_token(fp, quoted_string_buffer, MAXQUOTESTR);
  1901.         if (type != QUOTESTRING) {
  1902.             print_error("Bad UNITS", quoted_string_buffer, type);
  1903.             free_node(np);
  1904.             return NULL;
  1905.         }
  1906. np->units = strdup (quoted_string_buffer);
  1907.         nexttype = get_token(fp, nexttoken, MAXTOKEN);
  1908.     }
  1909.     if (nexttype != ACCESS){
  1910.         print_error("Should be ACCESS", nexttoken, nexttype);
  1911.         free_node(np);
  1912.         return NULL;
  1913.     }
  1914.     type = get_token(fp, token, MAXTOKEN);
  1915.     if (type != READONLY && type != READWRITE && type != WRITEONLY
  1916.         && type != NOACCESS && type != READCREATE && type != ACCNOTIFY){
  1917.         print_error("Bad ACCESS type", token, type);
  1918.         free_node(np);
  1919.         return NULL;
  1920.     }
  1921.     np->access = type;
  1922.     type = get_token(fp, token, MAXTOKEN);
  1923.     if (type != STATUS){
  1924.         print_error("Should be STATUS", token, type);
  1925.         free_node(np);
  1926.         return NULL;
  1927.     }
  1928.     type = get_token(fp, token, MAXTOKEN);
  1929.     if (type != MANDATORY && type != CURRENT && type != KW_OPTIONAL &&
  1930.         type != OBSOLETE && type != DEPRECATED){
  1931.         print_error("Bad STATUS", token, type);
  1932.         free_node(np);
  1933.         return NULL;
  1934.     }
  1935.     np->status = type;
  1936.     /*
  1937.      * Optional parts of the OBJECT-TYPE macro
  1938.      */
  1939.     type = get_token(fp, token, MAXTOKEN);
  1940.     while (type != EQUALS && type != ENDOFFILE) {
  1941.       switch (type) {
  1942.         case DESCRIPTION:
  1943.           type = get_token(fp, quoted_string_buffer, MAXQUOTESTR);
  1944.           if (type != QUOTESTRING) {
  1945.               print_error("Bad DESCRIPTION", quoted_string_buffer, type);
  1946.               free_node(np);
  1947.               return NULL;
  1948.           }
  1949.           if (ds_get_boolean(DS_LIBRARY_ID, DS_LIB_SAVE_MIB_DESCRS)) {
  1950.               np->description = strdup (quoted_string_buffer);
  1951.           }
  1952.           break;
  1954.         case REFERENCE:
  1955.           type = get_token(fp, quoted_string_buffer, MAXQUOTESTR);
  1956.           if (type != QUOTESTRING) {
  1957.               print_error("Bad REFERENCE", quoted_string_buffer, type);
  1958.               free_node(np);
  1959.               return NULL;
  1960.           }
  1961.           break;
  1962.         case INDEX:
  1963.           np->indexes = getIndexes(fp, &np->indexes);
  1964.           if (np->indexes == NULL) {
  1965.             print_error("Bad Index List",token,type);
  1966.             free_node(np);
  1967.             return NULL;
  1968.           }
  1969.           break;
  1971.         case DEFVAL:
  1972.         case AUGMENTS:
  1973.         case NUM_ENTRIES:
  1974.           if (tossObjectIdentifier(fp) != OBJID) {
  1975.               print_error("Bad Object Identifier", token, type);
  1976.               free_node(np);
  1977.               return NULL;
  1978.           }
  1979.           break;
  1981.         default:
  1982.           print_error("Bad format of optional clauses", token, type);
  1983.           free_node(np);
  1984.           return NULL;
  1986.       }
  1987.       type = get_token(fp, token, MAXTOKEN);
  1988.     }
  1989.     if (type != EQUALS){
  1990.         print_error("Bad format", token, type);
  1991.         free_node(np);
  1992.         return NULL;
  1993.     }
  1994.     return merge_parse_objectid(np, fp, name);
  1995. }
  1997. /*
  1998.  * Parses an OBJECT GROUP macro.
  1999.  * Returns 0 on error.
  2000.  *
  2001.  * Also parses object-identity, since they are similar (ignore STATUS).
  2002.  *   - WJH 10/96
  2003.  */
  2004. static struct node *
  2005. parse_objectgroup(FILE *fp,
  2006.   char *name)
  2007. {
  2008.     register int type;
  2009.     char token[MAXTOKEN];
  2010.     char quoted_string_buffer[MAXQUOTESTR];
  2011.     register struct node *np;
  2013.     np = alloc_node(current_module);
  2014.     if (np == NULL) return(NULL);
  2015.     type = get_token(fp, token, MAXTOKEN);
  2016.     while (type != EQUALS && type != ENDOFFILE) {
  2017.       switch (type) {
  2018.         case DESCRIPTION:
  2019.           type = get_token(fp, quoted_string_buffer, MAXQUOTESTR);
  2020.           if (type != QUOTESTRING) {
  2021.               print_error("Bad DESCRIPTION", quoted_string_buffer, type);
  2022.               free_node(np);
  2023.               return NULL;
  2024.           }
  2025.           if (ds_get_boolean(DS_LIBRARY_ID, DS_LIB_SAVE_MIB_DESCRS)) {
  2026.               np->description = strdup (quoted_string_buffer);
  2027.           }
  2028.           break;
  2030. case REFERENCE:
  2031.   type = get_token(fp, quoted_string_buffer, MAXQUOTESTR);
  2032.           if (type != QUOTESTRING) {
  2033.               print_error("Bad REFERENCE", quoted_string_buffer, type);
  2034.               free_node(np);
  2035.               return NULL;
  2036.           }
  2037.   break;
  2039.         default:
  2040.           /* NOTHING */
  2041.           break;
  2042.       }
  2043.       type = get_token(fp, token, MAXTOKEN);
  2044.     }
  2045.     return merge_parse_objectid(np, fp, name);
  2046. }
  2048. /*
  2049.  * Parses a NOTIFICATION-TYPE macro.
  2050.  * Returns 0 on error.
  2051.  */
  2052. static struct node *
  2053. parse_notificationDefinition(FILE *fp,
  2054.      char *name)
  2055. {
  2056.     register int type;
  2057.     char token[MAXTOKEN];
  2058.     char quoted_string_buffer[MAXQUOTESTR];
  2059.     register struct node *np;
  2061.     np = alloc_node(current_module);
  2062.     if (np == NULL) return(NULL);
  2063.     type = get_token(fp, token, MAXTOKEN);
  2064.     while (type != EQUALS && type != ENDOFFILE) {
  2065.       switch (type) {
  2066.         case DESCRIPTION:
  2067.           type = get_token(fp, quoted_string_buffer, MAXQUOTESTR);
  2068.           if (type != QUOTESTRING) {
  2069.               print_error("Bad DESCRIPTION", quoted_string_buffer, type);
  2070.               free_node(np);
  2071.               return NULL;
  2072.           }
  2073.           if (ds_get_boolean(DS_LIBRARY_ID, DS_LIB_SAVE_MIB_DESCRS)) {
  2074.               np->description = strdup (quoted_string_buffer);
  2075.           }
  2076.           break;
  2078.         default:
  2079.           /* NOTHING */
  2080.           break;
  2081.       }
  2082.       type = get_token(fp, token, MAXTOKEN);
  2083.     }
  2084.     return merge_parse_objectid(np, fp, name);
  2085. }
  2087. /*
  2088.  * Parses a TRAP-TYPE macro.
  2089.  * Returns 0 on error.
  2090.  */
  2091. static struct node *
  2092. parse_trapDefinition(FILE *fp,
  2093.      char *name)
  2094. {
  2095.     register int type;
  2096.     char token[MAXTOKEN];
  2097.     char quoted_string_buffer[MAXQUOTESTR];
  2098.     register struct node *np;
  2100.     np = alloc_node(current_module);
  2101.     if (np == NULL) return(NULL);
  2102.     type = get_token(fp, token, MAXTOKEN);
  2103.     while (type != EQUALS && type != ENDOFFILE) {
  2104.         switch (type) {
  2105.             case DESCRIPTION:
  2106.                 type = get_token(fp, quoted_string_buffer, MAXQUOTESTR);
  2107.                 if (type != QUOTESTRING) {
  2108.                     print_error("Bad DESCRIPTION", quoted_string_buffer, type);
  2109.                     free_node(np);
  2110.                     return NULL;
  2111.                 }
  2112.                 if (ds_get_boolean(DS_LIBRARY_ID, DS_LIB_SAVE_MIB_DESCRS)) {
  2113.                     np->description = strdup (quoted_string_buffer);
  2114.                 }
  2115.                 break;
  2116.             case ENTERPRISE:
  2117.                 type = get_token(fp, token, MAXTOKEN);
  2118.                 if (type == LEFTBRACKET) {
  2119.                     type = get_token(fp, token, MAXTOKEN);
  2120.                     if (type != LABEL) {
  2121.                         print_error("Bad Trap Format", token, type);
  2122.                         free_node(np);
  2123.                         return NULL;
  2124.                     }
  2125.                     np->parent = strdup(token);
  2126.                     /* Get right bracket */
  2127.                     type = get_token(fp, token, MAXTOKEN);
  2128.                 }
  2129.                 else if (type == LABEL)
  2130.                     np->parent = strdup(token);
  2131.                 break;
  2132.             default:
  2133.                 /* NOTHING */
  2134.                 break;
  2135.         }
  2136.         type = get_token(fp, token, MAXTOKEN);
  2137.     }
  2138.     type = get_token(fp, token, MAXTOKEN);
  2140.     np->label = strdup(name);
  2142.     if (type != NUMBER) {
  2143.         print_error("Expected a Number", token, type);
  2144.         free_node(np);
  2145.         return NULL;
  2146.     }
  2147.     np->subid = atoi(token);
  2148.     np->next = alloc_node(current_module);
  2149.     if (np->next == NULL)  {
  2150.         free_node(np);
  2151.         return(NULL);
  2152.     }
  2153.     np->next->parent = np->parent;
  2154.     np->parent = (char *)malloc(strlen(np->parent)+2);
  2155.     if (np->parent == NULL) {
  2156.         free_node(np->next); free_node(np);
  2157.         return(NULL);
  2158.     }
  2159.     strcpy(np->parent, np->next->parent);
  2160.     strcat(np->parent, "#");
  2161.     np->next->label = strdup(np->parent);
  2162.     return np;
  2163. }
  2166. /*
  2167.  * Parses a compliance macro
  2168.  * Returns 0 on error.
  2169.  */
  2170. static struct node *
  2171. parse_compliance(FILE *fp,
  2172.  char *name)
  2173. {
  2174.     register int type;
  2175.     char token[MAXTOKEN];
  2176.     char quoted_string_buffer[MAXQUOTESTR];
  2177.     register struct node *np;
  2179.     np = alloc_node(current_module);
  2180.     if (np == NULL) return(NULL);
  2181.     type = get_token(fp, token, MAXTOKEN);
  2182.     while (type != EQUALS && type != ENDOFFILE) {
  2183.         type = get_token(fp, quoted_string_buffer, MAXQUOTESTR);
  2184.     }
  2185.     return merge_parse_objectid(np, fp, name);
  2186. }
  2189. /*
  2190.  * Parses a capabilities macro
  2191.  * Returns 0 on error.
  2192.  */
  2193. static struct node *
  2194. parse_capabilities(FILE *fp,
  2195.    char *name)
  2196. {
  2197.     register int type;
  2198.     char token[MAXTOKEN];
  2199.     char quoted_string_buffer[MAXQUOTESTR];
  2200.     register struct node *np;
  2202.     np = alloc_node(current_module);
  2203.     if (np == NULL) return(NULL);
  2204.     type = get_token(fp, token, MAXTOKEN);
  2205.     while (type != EQUALS && type != ENDOFFILE) {
  2206.         type = get_token(fp, quoted_string_buffer, MAXQUOTESTR);
  2207.     }
  2208.     return merge_parse_objectid(np, fp, name);
  2209. }
  2211. /*
  2212.  * Parses a module identity macro
  2213.  * Returns 0 on error.
  2214.  */
  2215. static struct node *
  2216. parse_moduleIdentity(FILE *fp,
  2217.      char *name)
  2218. {
  2219.     register int type;
  2220.     char token[MAXTOKEN];
  2221.     char quoted_string_buffer[MAXQUOTESTR];
  2222.     register struct node *np;
  2224.     np = alloc_node(current_module);
  2225.     if (np == NULL) return(NULL);
  2226.     type = get_token(fp, token, MAXTOKEN);
  2227.     while (type != EQUALS && type != ENDOFFILE) {
  2228.         type = get_token(fp, quoted_string_buffer, MAXQUOTESTR);
  2229.     }
  2230.     return merge_parse_objectid(np, fp, name);
  2231. }
  2234. /*
  2235.  * Parses a MACRO definition
  2236.  * Expect BEGIN, discard everything to end.
  2237.  * Returns 0 on error.
  2238.  */
  2239. static struct node *
  2240. parse_macro(FILE *fp,
  2241.     char *name)
  2242. {
  2243.     register int type;
  2244.     char token[MAXTOKEN];
  2245.     struct node *np;
  2246.     int iLine = Line;
  2248.     np = alloc_node(current_module);
  2249.     if (np == NULL) return(NULL);
  2250.     type = get_token(fp, token, sizeof(token));
  2251.     while (type != EQUALS && type != ENDOFFILE) {
  2252.         type = get_token(fp, token, sizeof(token));
  2253.     }
  2254.     if (type != EQUALS) return NULL;
  2255.     while (type != BEGIN && type != ENDOFFILE) {
  2256.         type = get_token(fp, token, sizeof(token));
  2257.     }
  2258.     if (type != BEGIN) return NULL;
  2259.     while (type != END && type != ENDOFFILE) {
  2260.         type = get_token(fp, token, sizeof(token));
  2261.     }
  2262.     if (type != END) return NULL;
  2264.     if (ds_get_int(DS_LIBRARY_ID, DS_LIB_MIB_WARNINGS))
  2265. snmp_log(LOG_WARNING,
  2266.  "%s MACRO (lines %d..%d parsed and ignored).n", name, iLine, Line);
  2268.     return np;
  2269. }
  2271. /*
  2272.  * Parses a module import clause
  2273.  *   loading any modules referenced
  2274.  */
  2275. static void
  2276. parse_imports(FILE *fp)
  2277. {
  2278. #ifdef UCD_SNMP
  2279.     register int type;
  2280.     char token[MAXTOKEN];
  2281.     char modbuf[256];
  2282. #define MAX_IMPORTS 256
  2283.     struct module_import import_list[MAX_IMPORTS];
  2284.     int this_module, old_current_module;
  2285.     const char *old_File;
  2286.     int old_line;
  2287.     struct module *mp;
  2289.     int import_count=0; /* Total number of imported descriptors */
  2290.     int i=0, old_i; /* index of first import from each module */
  2292.     type = get_token(fp, token, MAXTOKEN);
  2294. /*
  2295.  * Parse the IMPORTS clause
  2296.  */
  2297.     while (type != SEMI && type != ENDOFFILE) {
  2298. if (type == LABEL ) {
  2299.     if (import_count == MAX_IMPORTS ) {
  2300. print_error("Too many imported symbols", token, type);
  2301. do {
  2302.     type = get_token(fp, token, MAXTOKEN);
  2303. } while (type != SEMI && type != ENDOFFILE);
  2304. return;
  2305.     }
  2306.     import_list[import_count++].label = strdup(token);
  2307. }
  2308. else if ( type == FROM ) {
  2309.     type = get_token(fp, token, MAXTOKEN);
  2310.             if ( import_count == i ) { /* All imports are handled internally */
  2311.        type = get_token(fp, token, MAXTOKEN);
  2312.                continue;
  2313.             }
  2314.     this_module = which_module(token);
  2316.     for ( old_i=i ; i<import_count ; ++i)
  2317. import_list[i].modid = this_module;
  2319.     old_current_module = current_module; /* Save state */
  2320.             old_File = File;
  2321.     old_line = Line;
  2322.     current_module = this_module;
  2324. /*
  2325.  * Recursively read any pre-requisite modules
  2326.  */
  2327.     if  (read_module_internal(token) == MODULE_NOT_FOUND ) {
  2328. for ( ; old_i<import_count ; ++old_i ) {
  2329.     read_import_replacements( token, &import_list[old_i]);
  2330. }
  2331.     }
  2333.     current_module = old_current_module; /* Restore state */
  2334.     File = old_File;
  2335.     Line = old_line;
  2336. }
  2337. type = get_token(fp, token, MAXTOKEN);
  2338.     }
  2340. /*
  2341.  * Save the import information
  2342.  *   in the global module table
  2343.  */
  2344.     for ( mp=module_head ; mp ; mp=mp->next )
  2345. if ( mp->modid == current_module) {
  2346.             if ( import_count == 0)
  2347. return;
  2348.             if (mp->imports && (mp->imports != root_imports))
  2349.     {
  2350. /* this can happen if all modules are in one source file. */
  2351. for ( i=0 ; i<mp->no_imports; ++i ) {
  2352. DEBUGMSGTL(("parse-mibs",  "#### freeing Module %d '%s' %dn",
  2353. mp->modid, mp->imports[i].label, mp->imports[i].modid));
  2354.     free(mp->imports[i].label);
  2355. }
  2356. free(mp->imports);
  2357.     }
  2358.             mp->imports = (struct module_import *)
  2359.               calloc(import_count, sizeof(struct module_import));
  2360.             if (mp->imports == NULL) return;
  2361.     for ( i=0 ; i<import_count ; ++i ) {
  2362. mp->imports[i].label = import_list[i].label;
  2363. mp->imports[i].modid = import_list[i].modid;
  2364. DEBUGMSGTL(("parse-mibs",  "#### adding Module %d '%s' %dn",
  2365. mp->modid, mp->imports[i].label, mp->imports[i].modid));
  2366.     }
  2367.     mp->no_imports = import_count;
  2368.     return;
  2369. }
  2371. /*
  2372.  * Shouldn't get this far
  2373.  */
  2374.     print_module_not_found(module_name(current_module,modbuf));
  2375.     return;
  2376. #endif
  2377. }
  2381. /*
  2382.  * MIB module handling routines
  2383.  */
  2385. static void dump_module_list (void)
  2386. {
  2387.     struct module *mp = module_head;
  2389.     DEBUGMSGTL(("parse-mibs", "Module list:n"));
  2390.     while (mp) {
  2391. DEBUGMSGTL(("parse-mibs", "  %s %d %s %dn", mp->name, mp->modid, mp->file, mp->no_imports));
  2392. mp = mp->next;
  2393.     }
  2394. }
  2396. int
  2397. which_module(const char *name)
  2398. {
  2399.     struct module *mp;
  2401.     for ( mp=module_head ; mp ; mp=mp->next )
  2402. if ( !label_compare(mp->name, name))
  2403.     return(mp->modid);
  2405.     DEBUGMSGTL(("parse-mibs", "Module %s not foundn", name));
  2406.     return(-1);
  2407. }
  2409. /*
  2410.  * module_name - copy module name to user buffer, return ptr to same.
  2411.  */
  2412. char *
  2413. module_name (int modid,
  2414.      char *cp)
  2415. {
  2416.     struct module *mp;
  2418.     for ( mp=module_head ; mp ; mp=mp->next )
  2419. if ( mp->modid == modid )
  2420. {
  2421.     strcpy(cp, mp->name);
  2422.     return(cp);
  2423. }
  2425.     DEBUGMSGTL(("parse-mibs", "Module %d not foundn", modid));
  2426.     sprintf(cp, "#%d", modid);
  2427.     return(cp);
  2428. }
  2430. /*
  2431.  *  Backwards compatability
  2432.  *  Read newer modules that replace the one specified:-
  2433.  * either all of them (read_module_replacements),
  2434.  * or those relating to a specified identifier (read_import_replacements)
  2435.  * plus an interface to add new replacement requirements
  2436.  */
  2437. void
  2438. add_module_replacement(const char *old_module,
  2439.        const char *new_module_name,
  2440.        const char *tag,
  2441.        int len)
  2442. {
  2443.     struct module_compatability *mcp;
  2445.     mcp =  (struct module_compatability *)
  2446.       calloc(1, sizeof( struct module_compatability));
  2447.     if (mcp == NULL) return;
  2449.     mcp->old_module = strdup( old_module );
  2450.     mcp->new_module = strdup( new_module_name );
  2451. if (tag)
  2452.     mcp->tag     = strdup( tag );
  2453.     mcp->tag_len = len;
  2455.     mcp->next    = module_map_head;
  2456.     module_map_head = mcp;
  2457. }
  2459. static void
  2460. read_module_replacements(const char *name)
  2461. {
  2462.     struct module_compatability *mcp;
  2464.     for ( mcp=module_map_head ; mcp; mcp=mcp->next ) {
  2465. if ( !label_compare( mcp->old_module, name )) {
  2466.     if (ds_get_int(DS_LIBRARY_ID, DS_LIB_MIB_WARNINGS))
  2467. snmp_log(LOG_WARNING,
  2468.                          "Loading replacement module %s for %s (%s)n",
  2469.                          mcp->new_module, name, File);
  2470.     (void)read_module( mcp->new_module );
  2471.     return;
  2472. }
  2473.     }
  2474.     if (!ds_get_boolean(DS_LIBRARY_ID, DS_LIB_MIB_ERRORS))
  2475. print_module_not_found(name);
  2477. }
  2478. #ifdef UCD_SNMP
  2479. static void
  2480. read_import_replacements(const char *old_module_name,
  2481.  struct module_import *identifier)
  2482. {
  2484. struct module_compatability *mcp;
  2486. /*
  2487.  * Look for matches first
  2488.  */
  2489.     for ( mcp=module_map_head ; mcp; mcp=mcp->next ) {
  2490.       if ( !label_compare( mcp->old_module, old_module_name )) {
  2492. if ( /* exact match */
  2493.      ( mcp->tag_len==0 &&
  2494.     (mcp->tag == NULL ||
  2495.                      !label_compare( mcp->tag, identifier->label ))) ||
  2496. /* prefix match */
  2497.           ( mcp->tag_len!=0 &&
  2498.     !strncmp( mcp->tag, identifier->label, mcp->tag_len ))
  2499.    ) {
  2501.     if (ds_get_int(DS_LIBRARY_ID, DS_LIB_MIB_WARNINGS))
  2502.         snmp_log(LOG_WARNING,
  2503.                          "Importing %s from replacement module %s instead of %s (%s)n",
  2504.                          identifier->label, mcp->new_module, old_module_name, File);
  2505.     (void)read_module( mcp->new_module );
  2506.     identifier->modid = which_module(mcp->new_module);
  2507.     return; /* finished! */
  2508.         }
  2509.       }
  2510.     }
  2512. /*
  2513.  * If no exact match, load everything relevant
  2514.  */
  2515.     read_module_replacements( old_module_name );
  2516. }
  2517. #endif
  2519. /*
  2520.  *  Read in the named module
  2521.  * Returns the root of the whole tree
  2522.  * (by analogy with 'read_mib')
  2523.  */
  2524. static int
  2525. read_module_internal (const char *name)
  2526. {
  2527.     struct module *mp;
  2528.     FILE *fp;
  2529.     struct node *np;
  2531.     if ( tree_head == NULL )
  2532. init_mib_internals(); /* was init_mib */
  2534.     for ( mp=module_head ; mp ; mp=mp->next )
  2535. if ( !label_compare(mp->name, name)) {
  2536.          const char *oldFile = File;
  2537.          int oldLine = Line;
  2539.     if ( mp->no_imports != -1 ) {
  2540. DEBUGMSGTL(("parse-mibs", "Module %s already loadedn", name));
  2541. return MODULE_ALREADY_LOADED;
  2542.     }
  2543.     if ((fp = fopen(mp->file, "r")) == NULL) {
  2544. snmp_log_perror(mp->file);
  2545. return MODULE_LOAD_FAILED;
  2546.     }
  2547.     mp->no_imports=0; /* Note that we've read the file */
  2548.     File = mp->file;
  2549.     Line = 1;
  2550. /*
  2551.  * Parse the file
  2552.  */
  2553.     np = parse( fp, NULL );
  2554.     fclose(fp);
  2555.     File = oldFile;
  2556.     Line = oldLine;
  2557.     return MODULE_LOADED_OK;
  2558. }
  2560.     if (ds_get_int(DS_LIBRARY_ID, DS_LIB_MIB_WARNINGS) > 1)
  2561. snmp_log(LOG_WARNING, "Module %s not foundn", name);
  2562.     return MODULE_NOT_FOUND;
  2563. }
  2565. void
  2566. adopt_orphans (void)
  2567. {
  2568.     struct node *np, *onp;
  2569.     struct tree *tp = NULL;
  2570.     int i, adopted;
  2572.     if ( !orphan_nodes )
  2573. return;
  2574.     init_node_hash(orphan_nodes);
  2575.     orphan_nodes = NULL;
  2577.     while (1) {
  2578. adopted = 0;
  2579. for ( i = 0; i < NHASHSIZE; i++)
  2580.     if ( nbuckets[i] ) {
  2581.         for ( np = nbuckets[i] ; np!= NULL ; np=np->next )
  2582.             tp = find_tree_node( np->parent, -1 );
  2583.             if ( tp ) {
  2584.         do_subtree( tp, &np );
  2585.         adopted = 1;
  2586.             }
  2587.     }
  2588. if ( adopted == 0 )
  2589.     break;
  2590.     }
  2592. /*
  2593.  * Report on outstanding orphans
  2594.  *    and link them back into the orphan list
  2595.  */
  2596.     for (i = 0; i < NHASHSIZE; i++)
  2597. if ( nbuckets[i] ) {
  2598.     if ( orphan_nodes )
  2599. onp = np->next = nbuckets[i];
  2600.     else
  2601. onp = orphan_nodes = nbuckets[i];
  2602.     nbuckets[i] = NULL;
  2603.     while (onp) {
  2604.          char modbuf[256];
  2605.          snmp_log (LOG_WARNING,
  2606.                           "Unlinked OID in %s: %s ::= { %s %ld }n",
  2607.                           module_name(onp->modid, modbuf),
  2608.                           (onp->label ? onp->label : "<no label>"),
  2609.                           (onp->parent ? onp->parent : "<no parent>"),
  2610.                           onp->subid);
  2612. np = onp;
  2613. onp = onp->next;
  2614.     }
  2615. }
  2616. }
  2618. struct tree *
  2619. read_module(const char *name)
  2620. {
  2621.     if ( read_module_internal(name) == MODULE_NOT_FOUND )
  2622. read_module_replacements( name );
  2623.     return tree_head;
  2624. }
  2626. void
  2627. unload_module_by_ID( int modID, struct tree *tree_top )
  2628. {
  2629. #ifdef UCD_SNMP
  2630.     struct tree *tp, *prev, *next;
  2631.     int i;
  2633.     prev = NULL;
  2634.     for ( tp=tree_top ; tp ; tp=next ) {
  2635. next = tp->next_peer;
  2636. /*
  2637.  * This next section looks rather complex.
  2638.  * Essentially, this is equivalent to the code fragment:
  2639.  *   if (tp->modID = modID)
  2640.  *     tp->number_modules--;
  2641.  * but handles one tree node being part of several modules.
  2642.  */
  2643. for ( i=0 ; i<tp->number_modules ; i++ ) {
  2644.     if ( tp->module_list[i] == modID ) {
  2645. tp->number_modules--;
  2646. switch ( tp->number_modules ) {
  2648.     case 0: /* That was the only module */
  2649. tp->modid = -1; /* Mark as unused */
  2650. break;
  2652.     case 1: /* We did have a list of two, but this is no
  2653.    longer needed.  Transfer the other entry
  2654.    ( i.e. module_list[1-i] - think about it! )
  2655.    to the 'single' slot tp->modid, and discard
  2656.    the list.
  2657.  */
  2658. tp->modid = tp->module_list[1-i];
  2659. free(tp->module_list);
  2660. tp->module_list = NULL; /* let's be tidy */
  2661. break;
  2663.     default: /* We still need the list, so shuffle down
  2664.    all following entries to close up the gap */
  2665. while ( i < tp->number_modules ) {
  2666.    tp->module_list[i] = tp->module_list[i+1];
  2667.    i++;
  2668. }
  2669. break;
  2670. }
  2671. break; /* Don't need to look through the rest of the list */
  2672.     }
  2673. }
  2675. /*
  2676.  *  OK - that's dealt with *this* node.
  2677.  * Now let's look at the children.
  2678.  * (Isn't recursion wonderful!)
  2679.  */
  2680. if ( tp->child_list )
  2681.     unload_module_by_ID( modID, tp->child_list );
  2684. if ( tp->number_modules == 0 ) {
  2685. /* This node isn't needed any more (except perhaps
  2686. for the sake of the children) */
  2687.       if ( tp->child_list == NULL ) {
  2688. if ( prev )
  2689.     prev->next_peer = tp->next_peer;
  2690. else
  2691.     tp->parent->child_list = tp->next_peer;
  2692. free_tree( tp );
  2693.    }
  2694.    else
  2695. free_partial_tree( tp, TRUE );
  2696. }
  2697. else
  2698.     prev = tp;
  2699.     }
  2700. #endif
  2701. }
  2703. int
  2704. unload_module(const char *name)
  2705. {
  2706.     struct module *mp;
  2707.     int modID = -1;
  2709.     for ( mp=module_head ; mp ; mp=mp->next )
  2710. if ( !label_compare(mp->name, name)) {
  2711.     modID = mp->modid;
  2712.     break;
  2713. }
  2715.     if ( modID == -1 ) {
  2716. DEBUGMSGTL(("unload-mib", "Module %s not found to unloadn", name));
  2717. return MODULE_NOT_FOUND;
  2718.     }
  2719.     unload_module_by_ID( modID, tree_head );
  2720.     mp->no_imports = -1; /* mark as unloaded */
  2721.     return MODULE_LOADED_OK; /* Well, you know what I mean! */
  2722. }
  2724. static void
  2725. new_module (const char *name,
  2726.     const char *file)
  2727. {
  2728.     struct module *mp;
  2730.     for ( mp=module_head ; mp ; mp=mp->next )
  2731. if ( !label_compare(mp->name, name)) {
  2732.     DEBUGMSGTL(("parse-mibs", "Module %s already notedn", name));
  2733. /* Not the same file */
  2734.     if (label_compare(mp->file, file)) {
  2735. if (ds_get_int(DS_LIBRARY_ID, DS_LIB_MIB_WARNINGS))
  2736.     snmp_log(LOG_WARNING,
  2737.                              "Warning: Module %s was in %s now is %sn",
  2738.                              name, mp->file, file);
  2740. /* Use the new one in preference */
  2741. free(mp->file);
  2742.                 mp->file = strdup(file);
  2743.             }
  2744.     return;
  2745. }
  2747. /* Add this module to the list */
  2748.     DEBUGMSGTL(("parse-mibs", "  Module %d %s is in %sn", max_module, name, file));
  2749.     mp = (struct module *) calloc(1, sizeof(struct module));
  2750.     if (mp == NULL) return;
  2751.     mp->name = strdup(name);
  2752.     mp->file = strdup(file);
  2753.     mp->imports = NULL;
  2754.     mp->no_imports = -1; /* Not yet loaded */
  2755.     mp->modid = max_module;
  2756.     ++max_module;
  2758.     mp->next = module_head; /* Or add to the *end* of the list? */
  2759.     module_head = mp;
  2760. }
  2765. /*
  2766.  * Parses a mib file and returns a linked list of nodes found in the file.
  2767.  * Returns NULL on error.
  2768.  */
  2769. static struct node *
  2770. parse(FILE *fp,
  2771.       struct node *root)
  2772. {
  2773.     char token[MAXTOKEN];
  2774.     char name[MAXTOKEN];
  2775.     int type = LABEL;
  2776.     int lasttype = LABEL;
  2778. #define BETWEEN_MIBS          1
  2779. #define IN_MIB                2
  2780.     int state = BETWEEN_MIBS;
  2781.     struct node *np, *nnp;
  2783.     DEBUGMSGTL(("parse-file", "Parsing file:  %s...n", File));
  2785.     if (last_err_module) free(last_err_module); last_err_module = 0;
  2787.     np = root;
  2788.     if (np != NULL) {
  2789.         /* now find end of chain */
  2790.         while(np->next)
  2791.             np = np->next;
  2792.     }
  2794.     while (type != ENDOFFILE){
  2795.         if (lasttype == CONTINUE) lasttype = type;
  2796.         else type = lasttype = get_token(fp, token, MAXTOKEN);
  2798.         switch (type) {
  2799.         case END:
  2800.             if (state != IN_MIB){
  2801.                 print_error("Error, END before start of MIB", NULL, type);
  2802.                 return NULL;
  2803.             }
  2804.     else {
  2805. struct module *mp;
  2806. #ifdef TEST
  2807. printf("nNodes for Module %s:n", name);
  2808. print_nodes( stdout, np );
  2809. #endif
  2810. for (mp = module_head; mp; mp = mp->next)
  2811.     if (mp->modid == current_module) break;
  2812. do_linkup(mp, root);
  2813. np = root = NULL;
  2814.     }
  2815.             state = BETWEEN_MIBS;
  2816. #ifdef TEST
  2817.             if (ds_get_int(DS_LIBRARY_ID, DS_LIB_MIB_WARNINGS))
  2818.               xmalloc_stats (stderr);
  2819. #endif
  2820.             continue;
  2821.         case IMPORTS:
  2822.             parse_imports( fp );
  2823.             continue;
  2824.         case EXPORTS:
  2825.             while (type != SEMI && type != ENDOFFILE)
  2826.                 type = get_token(fp, token, MAXTOKEN);
  2827.             continue;
  2828.         case LABEL:
  2829.             break;
  2830.         case ENDOFFILE:
  2831.             continue;
  2832.         default:
  2833.     strcpy(name, token);
  2834.     type = get_token(fp, token, MAXTOKEN);
  2835.     nnp = NULL;
  2836.     if (type == MACRO) {
  2837. nnp = parse_macro(fp, name);
  2838. if (nnp == NULL){
  2839.     print_error("Bad parse of MACRO", NULL, type);
  2840.     /*return NULL;*/
  2841. }
  2842. free_node(nnp); /* IGNORE */
  2843. nnp = NULL;
  2844.     }
  2845.     else
  2846. print_error(name, "is a reserved word", lasttype);
  2847.             continue;         /* see if we can parse the rest of the file */
  2848.         }
  2849.         strcpy(name, token);
  2850.         type = get_token(fp, token, MAXTOKEN);
  2851.         nnp = NULL;
  2853. /* Handle obsolete method to assign an object identifier to a
  2854.    module*/
  2855. if (lasttype == LABEL && type == LEFTBRACKET) {
  2856.     while (type != RIGHTBRACKET && type != ENDOFFILE)
  2857. type = get_token(fp, token, MAXTOKEN);
  2858.     if (type == ENDOFFILE){
  2859. print_error("Expected "}"", token, type);
  2860. return NULL;
  2861.     }
  2862.     type = get_token(fp, token, MAXTOKEN);
  2863. }
  2865.         switch (type) {
  2866.         case DEFINITIONS:
  2867.             if (state != BETWEEN_MIBS){
  2868.                 print_error("Error, nested MIBS", NULL, type);
  2869.                 return NULL;
  2870.             }
  2871.             state = IN_MIB;
  2872.             current_module = which_module( name );
  2873.             if ( current_module == -1 ) {
  2874.                 new_module(name, File);
  2875.                 current_module = which_module(name);
  2876.             }
  2877.             DEBUGMSGTL(("parse-mibs", "Parsing MIB: %d %sn", current_module, name));
  2878.             while ((type = get_token (fp, token, MAXTOKEN)) != ENDOFFILE)
  2879.                 if (type == BEGIN) break;
  2880.             break;
  2881.         case OBJTYPE:
  2882.             nnp = parse_objecttype(fp, name);
  2883.             if (nnp == NULL){
  2884.                 print_error("Bad parse of OBJECT-TYPE", NULL, type);
  2885.                 return NULL;
  2886.             }
  2887.             break;
  2888.         case OBJGROUP:
  2889.             nnp = parse_objectgroup(fp, name);
  2890.             if (nnp == NULL){
  2891.                 print_error("Bad parse of OBJECT-GROUP", NULL, type);
  2892.                 return NULL;
  2893.             }
  2894.             break;
  2895.         case TRAPTYPE:
  2896.             nnp = parse_trapDefinition(fp, name);
  2897.             if (nnp == NULL){
  2898.                 print_error("Bad parse of TRAP-TYPE", NULL, type);
  2899.                 return NULL;
  2900.             }
  2901.             break;
  2902.         case NOTIFTYPE:
  2903.             nnp = parse_notificationDefinition(fp, name);
  2904.             if (nnp == NULL){
  2905.                 print_error("Bad parse of NOTIFICATION-TYPE", NULL, type);
  2906.                 return NULL;
  2907.             }
  2908.             break;
  2909.         case COMPLIANCE:
  2910.             nnp = parse_compliance(fp, name);
  2911.             if (nnp == NULL){
  2912.                 print_error("Bad parse of MODULE-COMPLIANCE", NULL, type);
  2913.                 return NULL;
  2914.             }
  2915.             break;
  2916.         case CAPABILITIES:
  2917.             nnp = parse_capabilities(fp, name);
  2918.             if (nnp == NULL){
  2919.                 print_error("Bad parse of AGENT-CAPABILITIES", NULL, type);
  2920.                 return NULL;
  2921.             }
  2922.             break;
  2923.         case MACRO:
  2924.             nnp = parse_macro(fp, name);
  2925.             if (nnp == NULL){
  2926.                 print_error("Bad parse of MACRO", NULL, type);
  2927.                 /*return NULL;*/
  2928.             }
  2929.             free_node(nnp); /* IGNORE */
  2930.     nnp = NULL;
  2931.             break;
  2932.         case MODULEIDENTITY:
  2933.             nnp = parse_moduleIdentity(fp, name);
  2934.             if (nnp == NULL){
  2935.                 print_error("Bad parse of MODULE-IDENTITY", NULL, type);
  2936.                 return NULL;
  2937.             }
  2938.             break;
  2939.         case OBJID:
  2940.             type = get_token(fp, token, MAXTOKEN);
  2941.             if (type != EQUALS){
  2942.                 print_error("Expected "::="", token, type);
  2943.                 return NULL;
  2944.             }
  2945.             nnp = parse_objectid(fp, name);
  2946.             if (nnp == NULL){
  2947.                 print_error("Bad parse of OBJECT IDENTIFIER", NULL, type);
  2948.                 return NULL;
  2949.             }
  2950.             break;
  2951.         case EQUALS:
  2952.             nnp = parse_asntype(fp, name, &type, token);
  2953.             lasttype = CONTINUE;
  2954.             break;
  2955.         case ENDOFFILE:
  2956.             break;
  2957.         default:
  2958.     print_error("Bad operator", token, type);
  2959.     return NULL;
  2960.         }
  2961.         if (nnp) {
  2962.             if (np) np->next = nnp;
  2963.             else np = root = nnp;
  2964.             while (np->next) np = np->next;
  2965.         }
  2966.     }
  2967.     DEBUGMSGTL(("parse-file", "End of file (%s)n", File));
  2968.     return root;
  2969. }
  2971. /* return zero if character is not a label character. */
  2972. static int
  2973. is_labelchar (int ich)
  2974. {
  2975.     if ((isalnum(ich)) || (ich == '-'))
  2976.     return 1;
  2977.     if (ich == '_' && ds_get_boolean(DS_LIBRARY_ID, DS_LIB_MIB_PARSE_LABEL))
  2978.     return 1;
  2980.     return 0;
  2981. }
  2983. /*
  2984.  * Parses a token from the file.  The type of the token parsed is returned,
  2985.  * and the text is placed in the string pointed to by token.
  2986.  * Warning: this method may recurse.
  2987.  */
  2988. static int
  2989. get_token(FILE *fp,
  2990.   char *token,
  2991.   int maxtlen)
  2992. {
  2993.     register int ch, ch_next;
  2994.     register char *cp = token;
  2995.     register int hash = 0;
  2996.     register struct tok *tp;
  2997.     int too_long = 0;
  2999.     /* skip all white space */
  3000.     do {
  3001.         ch = getc(fp);
  3002.         if (ch == 'n')
  3003.             Line++;
  3004.     }
  3005.     while(isspace(ch) && ch != EOF);
  3006.     *cp++ = (char)ch; *cp = '';
  3007.     switch (ch) {
  3008.     case EOF:
  3009.         return ENDOFFILE;
  3010.     case '"':
  3011.         return parseQuoteString(fp, token, maxtlen);
  3012.     case ''': /* binary or hex constant */
  3013. while ((ch = getc(fp)) != EOF && ch != ''' && cp-token < maxtlen-2)
  3014.     *cp++ = (char)ch;
  3015. if (ch == ''') {
  3016.     unsigned long val = 0;
  3017.     *cp++ = ''';
  3018. ch = getc(fp);
  3019.     *cp++ = (char)ch;
  3020.     *cp = 0;
  3021.     cp = token+1;
  3022.     switch (ch) {
  3023.     case EOF:
  3024. return ENDOFFILE;
  3025.     case 'b':
  3026.     case 'B':
  3027. while ((ch = *cp++) != ''')
  3028.     if (ch != '0' && ch != '1') return LABEL;
  3029.     else val = val * 2 + ch - '0';
  3030. break;
  3031.     case 'h':
  3032.     case 'H':
  3033. while ((ch = *cp++) != ''')
  3034.     if ('0' <= ch && ch <= '9') val = val*16+ch-'0';
  3035.     else if ('a' <= ch && ch <= 'f') val = val*16+ch-'a'+10;
  3036.     else if ('A' <= ch && ch <= 'F') val = val*16+ch-'A'+10;
  3037.     else return LABEL;
  3038. break;
  3039.     default:
  3040. return LABEL;
  3041.     }
  3042.     sprintf(token, "%ld", val);
  3043.     return NUMBER;
  3044. }
  3045. else return LABEL;
  3046.     case '(':
  3047. return LEFTPAREN;
  3048.     case ')':
  3049. return RIGHTPAREN;
  3050.     case '{':
  3051. return LEFTBRACKET;
  3052.     case '}':
  3053. return RIGHTBRACKET;
  3054.     case ';':
  3055. return SEMI;
  3056.     case ',':
  3057. return COMMA;
  3058.     case '|':
  3059. return BAR;
  3060.     case '.':
  3061. ch_next = getc(fp);
  3062. if (ch_next == '.') return RANGE;
  3063. ungetc(ch_next, fp);
  3064. return LABEL;
  3065.     case ':':
  3066. ch_next = getc(fp);
  3067. if (ch_next != ':') {
  3068.     ungetc(ch_next, fp);
  3069.     return LABEL;
  3070. }
  3071. ch_next = getc(fp);
  3072. if (ch_next != '=') {
  3073.     ungetc(ch_next, fp);
  3074.     return LABEL;
  3075. }
  3076. return EQUALS;
  3077.     case '-':
  3078. ch_next = getc(fp);
  3079. if (ch_next == '-') {
  3080.   if (ds_get_boolean(DS_LIBRARY_ID, DS_LIB_MIB_COMMENT_TERM)) {
  3081.     /* Treat the rest of this line as a comment. */
  3082.     while ((ch_next != EOF) && (ch_next != 'n'))
  3083.     ch_next = getc(fp);
  3084.   } else {
  3085.             /* Treat the rest of the line or until another '--' as a comment */
  3086.             /* (this is the "technically" correct way to parse comments) */
  3087.     ch = ' ';
  3088.     ch_next = getc(fp);
  3089.     while (ch_next != EOF && ch_next != 'n' &&
  3090. (ch != '-' || ch_next != '-')) {
  3091. ch = ch_next; ch_next = getc(fp);
  3092.     }
  3093.   }
  3094.     if (ch_next == EOF) return ENDOFFILE;
  3095.     if (ch_next == 'n') Line++;
  3096.     return get_token (fp, token, maxtlen);
  3097. }
  3098. ungetc(ch_next, fp);
  3099.     default:
  3100. /*
  3101.  * Accumulate characters until end of token is found.  Then attempt to
  3102.  * match this token as a reserved word.  If a match is found, return the
  3103.  * type.  Else it is a label.
  3104.  */
  3105. if (!is_labelchar(ch)) return LABEL;
  3106. hash += tolower(ch);
  3107.   more:
  3108. while (is_labelchar(ch_next = getc(fp))) {
  3109.     hash += tolower(ch_next);
  3110.     if (cp - token < maxtlen - 1) *cp++ = (char)ch_next;
  3111.     else too_long = 1;
  3112. }
  3113. ungetc(ch_next, fp);
  3114. *cp = '';
  3116. if (too_long)
  3117.     print_error("Warning: token too long", token, CONTINUE);
  3118. for (tp = buckets[BUCKET(hash)]; tp; tp = tp->next) {
  3119.     if ((tp->hash == hash) && (!label_compare(tp->name, token)))
  3120. break;
  3121. }
  3122. if (tp) {
  3123.     if (tp->token != CONTINUE) return (tp->token);
  3124.     while (isspace((ch_next = getc(fp))))
  3125. if (ch_next == 'n') Line++;
  3126.     if (ch_next == EOF) return ENDOFFILE;
  3127.     if (isalnum(ch_next)) {
  3128. *cp++ = (char)ch_next;
  3129. hash += tolower(ch_next);
  3130. goto more;
  3131.     }
  3132. }
  3133. if (token[0] == '-' || isdigit(token[0])) {
  3134.    for(cp = token+1; *cp; cp++)
  3135.       if (!isdigit(*cp))
  3136.   return LABEL;
  3137.    return NUMBER;
  3138. }
  3139. return LABEL;
  3140.     }
  3141. }
  3143. int
  3144. snmp_get_token(FILE *fp,
  3145.   char *token,
  3146.   int maxtlen)
  3147. {
  3148.     return get_token(fp, token, maxtlen);
  3149. }
  3152. /*
  3153.  * Returns the root of the whole tree
  3154.  *   (for backwards compatability)
  3155.  */
  3156. struct tree *
  3157. read_mib(const char *filename)
  3158. {
  3159.     FILE *fp;
  3160.     char token[MAXTOKEN];
  3162.     fp = fopen(filename, "r");
  3163.     if (fp == NULL) {
  3164.         snmp_log_perror(filename);
  3165.         return NULL;
  3166.     }
  3167.     Line = 1;
  3168.     File = filename;
  3169.     DEBUGMSGTL(("parse-mibs", "Parsing file: %s...n", filename));
  3170.     get_token( fp, token, MAXTOKEN);
  3171.     fclose(fp);
  3172.     new_module(token, filename);
  3173.     (void) read_module(token);
  3175.     return tree_head;
  3176. }
  3179. struct tree *
  3180. read_all_mibs(void)
  3181. {
  3182.     struct module *mp;
  3184.     for ( mp=module_head ; mp ; mp=mp->next )
  3185. if ( mp->no_imports == -1 )
  3186.             read_module( mp->name );
  3187.     adopt_orphans();
  3189.     return tree_head;
  3190. }
  3194. static int
  3195. parseQuoteString(FILE *fp,
  3196.  char *token,
  3197.  int maxtlen)
  3198. {
  3199.     register int ch;
  3200.     int count = 0;
  3201.     int too_long = 0;
  3202.     char *token_start = token;
  3204.     for (ch = getc(fp); ch != EOF; ch = getc(fp)) {
  3205.         if (ch == 'r') continue;
  3206.         if (ch == 'n') {
  3207.             Line++;
  3208.         }
  3209.         else if (ch == '"') {
  3210.             *token = '';
  3211.             if (too_long &&
  3212.                 ds_get_int(DS_LIBRARY_ID, DS_LIB_MIB_WARNINGS) > 1)
  3213.             {
  3214.                 /* show short form for brevity sake */
  3215.                 char ch_save = *(token_start + 50);
  3216.                 *(token_start + 50) = '';
  3217.                 print_error ("Warning: string too long",
  3218.                              token_start, QUOTESTRING);
  3219.                 *(token_start + 50) = ch_save;
  3220.             }
  3221.             return QUOTESTRING;
  3222.         }
  3223.         /* maximum description length check.  If greater, keep parsing
  3224.            but truncate the string */
  3225.         if (++count < maxtlen)
  3226.             *token++ = (char)ch;
  3227.         else too_long = 1;
  3228.     }
  3230.     return 0;
  3231. }
  3233. /*
  3234.  * struct index_list *
  3235.  * getIndexes(FILE *fp):
  3236.  *   This routine parses a string like  { blah blah blah } and returns a
  3237.  *   list of the strings enclosed within it.
  3238.  *
  3239.  */
  3240. static struct index_list *
  3241. getIndexes(FILE *fp, struct index_list **retp) {
  3242.   int type;
  3243.   char token[MAXTOKEN];
  3244.   char nextIsImplied = 0;
  3246.   struct index_list *mylist = NULL;
  3247.   struct index_list **mypp = &mylist;
  3249.   free_indexes(retp);
  3251.   type = get_token(fp, token, MAXTOKEN);
  3253.   if (type != LEFTBRACKET) {
  3254.     return NULL;
  3255.   }
  3257.   type = get_token(fp, token, MAXTOKEN);
  3258.   while (type != RIGHTBRACKET && type != ENDOFFILE) {
  3259.     if ((type == LABEL) || (type & SYNTAX_MASK)) {
  3260.       *mypp = (struct index_list *) calloc(1, sizeof(struct index_list));
  3261.       if (*mypp) {
  3262.         (*mypp)->ilabel = strdup(token);
  3263.         (*mypp)->isimplied = nextIsImplied;
  3264.         mypp = &(*mypp)->next;
  3265.         nextIsImplied = 0;
  3266.       }
  3267.     } else if (type == IMPLIED) {
  3268.         nextIsImplied = 1;
  3269.     }
  3270.     type = get_token(fp, token, MAXTOKEN);
  3271.   }
  3273.   *retp = mylist;
  3274.   return mylist;
  3275. }
  3277. static void
  3278. free_indexes(struct index_list **spp) {
  3279.   if (spp && *spp) {
  3280.   struct index_list *pp, *npp;
  3282.   pp = *spp; *spp = NULL;
  3284.   while(pp) {
  3285.     npp = pp->next;
  3286.     if (pp->ilabel) free(pp->ilabel);
  3287.     free(pp);
  3288.     pp = npp;
  3289.   }
  3290.   }
  3291. }
  3293. static void
  3294. free_ranges(struct range_list **spp) {
  3295.   if (spp && *spp) {
  3296.   struct range_list *pp, *npp;
  3298.   pp = *spp; *spp = NULL;
  3300.   while(pp) {
  3301.     npp = pp->next;
  3302.     free(pp);
  3303.     pp = npp;
  3304.   }
  3305.   }
  3306. }
  3308. static void
  3309. free_enums(struct enum_list **spp)
  3310. {
  3311.   if (spp && *spp) {
  3312.   struct enum_list *pp, *npp;
  3314.   pp = *spp; *spp = NULL;
  3316.   while(pp)
  3317.   {
  3318.     npp = pp->next;
  3319.     if (pp->label) free(pp->label);
  3320.     free(pp);
  3321.     pp = npp;
  3322.   }
  3323.   }
  3324. }
  3326. static struct enum_list *
  3327. copy_enums (struct enum_list *sp)
  3328. {
  3329.   struct enum_list *xp = NULL, **spp = &xp;
  3331.   while (sp) {
  3332.     *spp = (struct enum_list *) calloc(1, sizeof(struct enum_list));
  3333.     if (!*spp) break;
  3334.     (*spp)->label = strdup(sp->label);
  3335.     (*spp)->value = sp->value;
  3336.     spp = &(*spp)->next;
  3337.     sp = sp->next;
  3338.   }
  3339.   return (xp);
  3340. }
  3342. static struct range_list *
  3343. copy_ranges (struct range_list *sp)
  3344. {
  3345.   struct range_list *xp = NULL, **spp = &xp;
  3347.   while (sp) {
  3348.     *spp = (struct range_list *) calloc(1, sizeof(struct range_list));
  3349.     if (!*spp) break;
  3350.     (*spp)->low = sp->low;
  3351.     (*spp)->high = sp->high;
  3352.     spp = &(*spp)->next;
  3353.     sp = sp->next;
  3354.   }
  3355.   return (xp);
  3356. }
  3357. /*
  3358. static struct index_list *
  3359. copy_indexes (struct index_list *sp)
  3360. {
  3361.   struct index_list *xp = NULL, **spp = &xp;
  3363.   while (sp) {
  3364.     *spp = (struct index_list *) calloc(1, sizeof(struct index_list));
  3365.     if (!*spp) break;
  3366.     (*spp)->ilabel = strdup(sp->ilabel);
  3367.     spp = &(*spp)->next;
  3368.     sp = sp->next;
  3369.   }
  3370.   return (xp);
  3371. }
  3372. */
  3373. /*
  3374.  * This routine parses a string like  { blah blah blah } and returns OBJID if
  3375.  * it is well formed, and NULL if not.
  3376.  */
  3377. static int
  3378. tossObjectIdentifier(FILE *fp)
  3379. {
  3380.     int type;
  3381.     char token[MAXTOKEN];
  3382.     int bracketcount = 1;
  3384.     type = get_token(fp, token, MAXTOKEN);
  3386.     if (type != LEFTBRACKET)
  3387.         return 0;
  3388.     while ((type != RIGHTBRACKET || bracketcount > 0) && type != ENDOFFILE )
  3389.     {
  3390.         type = get_token(fp, token, MAXTOKEN);
  3391.         if (type == LEFTBRACKET)
  3392.           bracketcount++;
  3393.         else if (type == RIGHTBRACKET)
  3394.           bracketcount--;
  3395.     }
  3397.     if (type == RIGHTBRACKET)
  3398.         return OBJID;
  3399.     else
  3400.         return 0;
  3401. }
  3403. struct tree *
  3404. find_node(const char *name,
  3405.   struct tree *subtree)    /* Unused */
  3406. {
  3407.   return( find_tree_node( name, -1 ));
  3408. }
  3410. struct module *
  3411. find_module(int mid)
  3412. {
  3413.   struct module *mp;
  3415.   for(mp=module_head; mp!=NULL; mp = mp->next) {
  3416.     if (mp->modid == mid)
  3417.       break;
  3418.   }
  3419.   if (mp != 0)
  3420.     return mp;
  3421.   return NULL;
  3422. }
  3425. static char leave_indent[256];
  3426. static int leave_was_simple;
  3428. static void print_mib_leaves(FILE *f, struct tree *tp, int width)
  3429. { 
  3430. #ifdef UCD_SNMP
  3431. struct tree *ntp;
  3432.   char *ip = leave_indent+strlen(leave_indent)-1;
  3433.   char last_ipch = *ip;
  3435.   *ip = '+';
  3436.   if (tp->type == 0)
  3437.     fprintf(f, "%s--%s(%ld)n", leave_indent, tp->label, tp->subid);
  3438.   else {
  3439.     const char *acc, *typ;
  3440.     int size = 0;
  3441.     switch (tp->access) {
  3442.     case MIB_ACCESS_NOACCESS: acc = "----"; break;
  3443.     case MIB_ACCESS_READONLY: acc = "-R--"; break;
  3444.     case MIB_ACCESS_WRITEONLY: acc = "--W-"; break;
  3445.     case MIB_ACCESS_READWRITE: acc = "-RW-"; break;
  3446.     case MIB_ACCESS_NOTIFY: acc = "---N"; break;
  3447.     case MIB_ACCESS_CREATE: acc = "CR--"; break;
  3448.     default: acc = "    "; break;
  3449.     }
  3450.     switch (tp->type) {
  3451.     case TYPE_OBJID: typ = "ObjID    "; break;
  3452.     case TYPE_OCTETSTR: typ = "String   "; size = 1; break;
  3453.     case TYPE_INTEGER:
  3454. if (tp->enums) typ = "EnumVal  ";
  3455. else typ = "Integer  "; break;
  3456.     case TYPE_NETADDR: typ = "NetAddr  "; break;
  3457.     case TYPE_IPADDR: typ = "IpAddr   "; break;
  3458.     case TYPE_COUNTER: typ = "Counter  "; break;
  3459.     case TYPE_GAUGE: typ = "Gauge    "; break;
  3460.     case TYPE_TIMETICKS: typ = "TimeTicks"; break;
  3461.     case TYPE_OPAQUE: typ = "Opaque   "; size = 1; break;
  3462.     case TYPE_NULL: typ = "Null     "; break;
  3463.     case TYPE_COUNTER64: typ = "Counter64"; break;
  3464.     case TYPE_BITSTRING: typ = "BitString"; break;
  3465.     case TYPE_NSAPADDRESS: typ = "NsapAddr "; break;
  3466.     case TYPE_UINTEGER: typ = "UInteger "; break;
  3467.     default: typ = "         "; break;
  3468.     }
  3469.     fprintf(f, "%s-- %s %s %s(%ld)n", leave_indent, acc, typ, tp->label, tp->subid);
  3470.     *ip = last_ipch;
  3471.     if (tp->tc_index >= 0)
  3472.       fprintf(f, "%s        Textual Convention: %sn", leave_indent,
  3473.       tclist[tp->tc_index].descriptor);
  3474.     if (tp->enums) {
  3475.       struct enum_list *ep = tp->enums;
  3476.       int cpos = 0, cmax = width - strlen(leave_indent) - 16;
  3477.       fprintf(f, "%s        Values: ", leave_indent);
  3478.       while (ep) {
  3479. char buf[80];
  3480. int bufw;
  3481. if (ep != tp->enums) fprintf(f, ", ");
  3482. sprintf(buf, "%s(%d)", ep->label, ep->value);
  3483. cpos += (bufw = strlen(buf) + 2);
  3484. if (cpos >= cmax) {
  3485.   fprintf(f, "n%s                ", leave_indent);
  3486.   cpos = bufw;
  3487. }
  3488. fprintf(f, "%s", buf);
  3489. ep = ep->next;
  3490.       }
  3491.       fprintf(f, "n");
  3492.     }
  3493.     if (tp->ranges) {
  3494.       struct range_list *rp = tp->ranges;
  3495.       if (size) fprintf(f, "%s        Size: ", leave_indent);
  3496.       else fprintf(f, "%s        Range: ", leave_indent);
  3497.       while (rp) {
  3498.         if (rp != tp->ranges) fprintf(f, " | ");
  3499. if (rp->low == rp->high) fprintf(f, "%d", rp->low);
  3500. else fprintf(f, "%d..%d", rp->low, rp->high);
  3501. rp = rp->next;
  3502.       }
  3503.       fprintf(f, "n");
  3504.     }
  3505.   }
  3506.   *ip = last_ipch;
  3507.   strcat(leave_indent, "  |");
  3508.   leave_was_simple = tp->type != 0;
  3510.   { int i, j, count = 0;
  3511.     struct leave {
  3512.       oid id;
  3513.       struct tree *tp;
  3514.     } *leaves, *lp;
  3516.     for (ntp = tp->child_list; ntp; ntp = ntp->next_peer) count++;
  3517.     if (count) {
  3518.       leaves = (struct leave *)calloc(count, sizeof(struct leave));
  3519.       if (!leaves) return;
  3520.       for (ntp = tp->child_list, count = 0; ntp; ntp = ntp->next_peer) {
  3521. for (i = 0, lp = leaves; i < count; i++, lp++)
  3522.   if (lp->id >= ntp->subid) break;
  3523. for (j = count; j > i; j--) leaves[j] = leaves[j-1];
  3524. lp->id = ntp->subid;
  3525. lp->tp = ntp;
  3526. count++;
  3527.       }
  3528.       for (i = 1, lp = leaves; i <= count; i++, lp++) {
  3529. if (!leave_was_simple || lp->tp->type == 0)
  3530.   fprintf(f, "%sn", leave_indent);
  3531. if (i == count) ip[3] = ' ';
  3532. print_mib_leaves(f, lp->tp, width);
  3533.       }
  3534.       free(leaves);
  3535.       leave_was_simple = 0;
  3536.     }
  3537.   }
  3538.   ip[1] = 0;
  3539. #endif
  3540. }
  3542. void print_mib_tree(FILE *f, struct tree *tp, int width)
  3543. {
  3544.   leave_indent[0] = ' ';
  3545.   leave_indent[1] = 0;
  3546.   leave_was_simple = 1;
  3547.   print_mib_leaves(f, tp, width);
  3548. }
  3551. /*
  3552.  * Merge the parsed object identifier with the existing node.
  3553.  * If there is a problem with the identifier, release the existing node.
  3554.  */
  3555. static struct node *
  3556. merge_parse_objectid(struct node *np,
  3557.      FILE *fp,
  3558.      char *name)
  3559. {
  3560.     struct node *nnp;
  3562.     nnp = parse_objectid(fp, name);
  3563.     if (nnp) {
  3564. /* apply last OID sub-identifier data to the information */
  3565. /* already collected for this node. */
  3566. struct node *headp, *nextp;
  3567. int ncount = 0;
  3568. nextp = headp = nnp;
  3569. while (nnp->next) {
  3570.     nextp = nnp;
  3571.     ncount++;
  3572.     nnp = nnp->next;
  3573. }
  3575. np->label = nnp->label;
  3576. np->subid = nnp->subid;
  3577. np->modid = nnp->modid;
  3578. np->parent = nnp->parent;
  3579. free(nnp);
  3581. if (ncount) {
  3582.     nextp->next = np;
  3583.     np = headp;
  3584. }
  3585.     }
  3586.     else {
  3587.         free_node(np); np = NULL;
  3588.     }
  3590.     return np;
  3591. }
  3593. /*
  3594.  * transfer data to tree from node
  3595.  *
  3596.  * move pointers for alloc'd data from np to tp.
  3597.  * this prevents them from being freed when np is released.
  3598.  * parent member is not moved.
  3599.  *
  3600.  * CAUTION: nodes may be repeats of existing tree nodes.
  3601.  * This can happen especially when resolving IMPORT clauses.
  3602.  *
  3603.  */
  3604. #ifdef UCD_SNMP
  3605. static void
  3606. tree_from_node(struct tree *tp, struct node *np)
  3607. {
  3609.    free_partial_tree(tp, FALSE);
  3611.     tp->label = np->label;  np->label = NULL;
  3612.     tp->enums = np->enums;  np->enums = NULL;
  3614.     tp->ranges = np->ranges;  np->ranges = NULL;
  3615.     tp->indexes = np->indexes;  np->indexes = NULL;
  3616.     tp->tc_index = np->tc_index;
  3617.     tp->access = np->access;
  3618.     tp->status = np->status;
  3620.     tp->hint = np->hint;  np->hint = NULL;
  3621.     tp->units = np->units;  np->units = NULL;
  3622.     tp->description = np->description;  np->description = NULL;
  3624.     tp->subid = np->subid;
  3625.     tp->type = translation_table[np->type];
  3626.     set_function(tp);
  3628. }
  3629.  #endif