/*

 * parse.c

 *

 */

/* Portions of this file are subject to the following copyrights.  See

 * the Net-SNMP's COPYING file for more details and other copyrights

 * that may apply:

 */

/******************************************************************

        Copyright 1989, 1991, 1992 by Carnegie Mellon University

                      All Rights Reserved

Permission to use, copy, modify, and distribute this software and its

documentation for any purpose and without fee is hereby granted,

provided that the above copyright notice appear in all copies and that

both that copyright notice and this permission notice appear in

supporting documentation, and that the name of CMU not be

used in advertising or publicity pertaining to distribution of the

software without specific, written prior permission.

CMU DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING

ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL

CMU BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR

ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,

ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS

SOFTWARE.

******************************************************************/

/*

 * Copyright © 2003 Sun Microsystems, Inc. All rights reserved.

 * Use is subject to license terms specified in the COPYING file

 * distributed with the Net-SNMP package.

 */

#include <net-snmp/net-snmp-config.h>

#include <net-snmp/net-snmp-features.h>

#ifndef NETSNMP_DISABLE_MIB_LOADING

#ifdef HAVE_LIMITS_H

#include <limits.h>

#endif

#include <stdio.h>

#ifdef HAVE_STDLIB_H

#include <stdlib.h>

#endif

#ifdef HAVE_STRING_H

#include <string.h>

#else

#include <strings.h>

#endif

#include <ctype.h>

#include <sys/types.h>

#ifdef HAVE_SYS_STAT_H

#include <sys/stat.h>

#endif

#ifdef HAVE_DIRENT_H

#include <dirent.h>

#endif

#ifdef TIME_WITH_SYS_TIME

# include <sys/time.h>

# include <time.h>

#else

# ifdef HAVE_SYS_TIME_H

#  include <sys/time.h>

# else

#  include <time.h>

# endif

#endif

#ifdef HAVE_NETINET_IN_H

#include <netinet/in.h>

#endif

#if defined(HAVE_REGEX_H) && defined(HAVE_REGCOMP)

#include <regex.h>

#endif

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <errno.h>

#include <net-snmp/types.h>

#include <net-snmp/output_api.h>

#include <net-snmp/config_api.h>

#include <net-snmp/utilities.h>

#include <net-snmp/library/parse.h>

#include <net-snmp/library/mib.h>

#include <net-snmp/library/snmp_api.h>

#include <net-snmp/library/tools.h>

netsnmp_feature_child_of(find_module, mib_api);

netsnmp_feature_child_of(get_tc_description, mib_api);

/*

 * A linked list of nodes.

 */

struct node {

    struct node    *next;

    char           *label;  /* This node's (unique) textual name */

    u_long          subid;  /* This node's integer subidentifier */

    int             modid;  /* The module containing this node */

    char           *parent; /* The parent's textual name */

    int             tc_index; /* index into tclist (-1 if NA) */

    int             type;   /* The type of object this represents */

    int             access;

    int             status;

    struct enum_list *enums; /* (optional) list of enumerated integers */

    struct range_list *ranges;

    struct index_list *indexes;

    char           *augments;

    struct varbind_list *varbinds;

    char           *hint;

    char           *units;

    char           *description; /* description (a quoted string) */

    char           *reference; /* references (a quoted string) */

    char           *defaultValue;

    char           *filename;

    int             lineno;

};

/*

 * This is one element of an object identifier with either an integer

 * subidentifier, or a textual string label, or both.

 * The subid is -1 if not present, and label is NULL if not present.

 */

struct subid_s {

    int             subid;

    int             modid;

    char           *label;

};

#define TC_INCR 100

struct tc {                     /* textual conventions */

    int             type;

    int             modid;

    char           *descriptor;

    char           *hint;

    struct enum_list *enums;

    struct range_list *ranges;

    char           *description;

    int             lineno;

} *tclist;

int tc_alloc;

static int      mibLine;

static const char *File = "(none)";

static int      anonymous;

struct objgroup {

    char           *name;

    int             line;

    struct objgroup *next;

}              *objgroups = NULL, *objects = NULL, *notifs = NULL;

#define SYNTAX_MASK     0x80

/*

 * types of tokens

 * Tokens with the SYNTAX_MASK bit set are syntax tokens 

 */

#define CONTINUE    -1

#define ENDOFFILE   0

#define LABEL       1

#define SUBTREE     2

#define SYNTAX      3

#define OBJID       (4 | SYNTAX_MASK)

#define OCTETSTR    (5 | SYNTAX_MASK)

#define INTEGER     (6 | SYNTAX_MASK)

#define NETADDR     (7 | SYNTAX_MASK)

#define IPADDR      (8 | SYNTAX_MASK)

#define COUNTER     (9 | SYNTAX_MASK)

#define GAUGE       (10 | SYNTAX_MASK)

#define TIMETICKS   (11 | SYNTAX_MASK)

#define KW_OPAQUE   (12 | SYNTAX_MASK)

#define NUL         (13 | SYNTAX_MASK)

#define SEQUENCE    14

#define OF          15          /* SEQUENCE OF */

#define OBJTYPE     16

#define ACCESS      17

#define READONLY    18

#define READWRITE   19

#define WRITEONLY   20

#ifdef NOACCESS

#undef NOACCESS                 /* agent 'NOACCESS' token */

#endif

#define NOACCESS    21

#define STATUS      22

#define MANDATORY   23

#define KW_OPTIONAL    24

#define OBSOLETE    25

/*

 * #define RECOMMENDED 26 

 */

#define PUNCT       27

#define EQUALS      28

#define NUMBER      29

#define LEFTBRACKET 30

#define RIGHTBRACKET 31

#define LEFTPAREN   32

#define RIGHTPAREN  33

#define COMMA       34

#define DESCRIPTION 35

#define QUOTESTRING 36

#define INDEX       37

#define DEFVAL      38

#define DEPRECATED  39

#define SIZE        40

#define BITSTRING   (41 | SYNTAX_MASK)

#define NSAPADDRESS (42 | SYNTAX_MASK)

#define COUNTER64   (43 | SYNTAX_MASK)

#define OBJGROUP    44

#define NOTIFTYPE   45

#define AUGMENTS    46

#define COMPLIANCE  47

#define READCREATE  48

#define UNITS       49

#define REFERENCE   50

#define NUM_ENTRIES 51

#define MODULEIDENTITY 52

#define LASTUPDATED 53

#define ORGANIZATION 54

#define CONTACTINFO 55

#define UINTEGER32 (56 | SYNTAX_MASK)

#define CURRENT     57

#define DEFINITIONS 58

#define END         59

#define SEMI        60

#define TRAPTYPE    61

#define ENTERPRISE  62

/*

 * #define DISPLAYSTR (63 | SYNTAX_MASK) 

 */

#define BEGIN       64

#define IMPORTS     65

#define EXPORTS     66

#define ACCNOTIFY   67

#define BAR         68

#define RANGE       69

#define CONVENTION  70

#define DISPLAYHINT 71

#define FROM        72

#define AGENTCAP    73

#define MACRO       74

#define IMPLIED     75

#define SUPPORTS    76

#define INCLUDES    77

#define VARIATION   78

#define REVISION    79

#define NOTIMPL     80

#define OBJECTS     81

#define NOTIFICATIONS 82

#define MODULE      83

#define MINACCESS   84

#define PRODREL     85

#define WRSYNTAX    86

#define CREATEREQ   87

#define NOTIFGROUP  88

#define MANDATORYGROUPS 89

#define GROUP     90

#define OBJECT      91

#define IDENTIFIER  92

#define CHOICE      93

#define LEFTSQBRACK 95

#define RIGHTSQBRACK  96

#define IMPLICIT    97

#define APPSYNTAX (98 | SYNTAX_MASK)

#define OBJSYNTAX (99 | SYNTAX_MASK)

#define SIMPLESYNTAX  (100 | SYNTAX_MASK)

#define OBJNAME   (101 | SYNTAX_MASK)

#define NOTIFNAME (102 | SYNTAX_MASK)

#define VARIABLES 103

#define UNSIGNED32  (104 | SYNTAX_MASK)

#define INTEGER32 (105 | SYNTAX_MASK)

#define OBJIDENTITY 106

/*

 * Beware of reaching SYNTAX_MASK (0x80) 

 */

struct tok {

    const char     *name;       /* token name */

    int             len;        /* length not counting nul */

    int             token;      /* value */

    int             hash;       /* hash of name */

    struct tok     *next;       /* pointer to next in hash table */

};

static struct tok tokens[] = {

    {"obsolete", sizeof("obsolete") - 1, OBSOLETE}

    ,

    {"Opaque", sizeof("Opaque") - 1, KW_OPAQUE}

    ,

    {"optional", sizeof("optional") - 1, KW_OPTIONAL}

    ,

    {"LAST-UPDATED", sizeof("LAST-UPDATED") - 1, LASTUPDATED}

    ,

    {"ORGANIZATION", sizeof("ORGANIZATION") - 1, ORGANIZATION}

    ,

    {"CONTACT-INFO", sizeof("CONTACT-INFO") - 1, CONTACTINFO}

    ,

    {"MODULE-IDENTITY", sizeof("MODULE-IDENTITY") - 1, MODULEIDENTITY}

    ,

    {"MODULE-COMPLIANCE", sizeof("MODULE-COMPLIANCE") - 1, COMPLIANCE}

    ,

    {"DEFINITIONS", sizeof("DEFINITIONS") - 1, DEFINITIONS}

    ,

    {"END", sizeof("END") - 1, END}

    ,

    {"AUGMENTS", sizeof("AUGMENTS") - 1, AUGMENTS}

    ,

    {"not-accessible", sizeof("not-accessible") - 1, NOACCESS}

    ,

    {"write-only", sizeof("write-only") - 1, WRITEONLY}

    ,

    {"NsapAddress", sizeof("NsapAddress") - 1, NSAPADDRESS}

    ,

    {"UNITS", sizeof("Units") - 1, UNITS}

    ,

    {"REFERENCE", sizeof("REFERENCE") - 1, REFERENCE}

    ,

    {"NUM-ENTRIES", sizeof("NUM-ENTRIES") - 1, NUM_ENTRIES}

    ,

    {"BITSTRING", sizeof("BITSTRING") - 1, BITSTRING}

    ,

    {"BIT", sizeof("BIT") - 1, CONTINUE}

    ,

    {"BITS", sizeof("BITS") - 1, BITSTRING}

    ,

    {"Counter64", sizeof("Counter64") - 1, COUNTER64}

    ,

    {"TimeTicks", sizeof("TimeTicks") - 1, TIMETICKS}

    ,

    {"NOTIFICATION-TYPE", sizeof("NOTIFICATION-TYPE") - 1, NOTIFTYPE}

    ,

    {"OBJECT-GROUP", sizeof("OBJECT-GROUP") - 1, OBJGROUP}

    ,

    {"OBJECT-IDENTITY", sizeof("OBJECT-IDENTITY") - 1, OBJIDENTITY}

    ,

    {"IDENTIFIER", sizeof("IDENTIFIER") - 1, IDENTIFIER}

    ,

    {"OBJECT", sizeof("OBJECT") - 1, OBJECT}

    ,

    {"NetworkAddress", sizeof("NetworkAddress") - 1, NETADDR}

    ,

    {"Gauge", sizeof("Gauge") - 1, GAUGE}

    ,

    {"Gauge32", sizeof("Gauge32") - 1, GAUGE}

    ,

    {"Unsigned32", sizeof("Unsigned32") - 1, UNSIGNED32}

    ,

    {"read-write", sizeof("read-write") - 1, READWRITE}

    ,

    {"read-create", sizeof("read-create") - 1, READCREATE}

    ,

    {"OCTETSTRING", sizeof("OCTETSTRING") - 1, OCTETSTR}

    ,

    {"OCTET", sizeof("OCTET") - 1, CONTINUE}

    ,

    {"OF", sizeof("OF") - 1, OF}

    ,

    {"SEQUENCE", sizeof("SEQUENCE") - 1, SEQUENCE}

    ,

    {"NULL", sizeof("NULL") - 1, NUL}

    ,

    {"IpAddress", sizeof("IpAddress") - 1, IPADDR}

    ,

    {"UInteger32", sizeof("UInteger32") - 1, UINTEGER32}

    ,

    {"INTEGER", sizeof("INTEGER") - 1, INTEGER}

    ,

    {"Integer32", sizeof("Integer32") - 1, INTEGER32}

    ,

    {"Counter", sizeof("Counter") - 1, COUNTER}

    ,

    {"Counter32", sizeof("Counter32") - 1, COUNTER}

    ,

    {"read-only", sizeof("read-only") - 1, READONLY}

    ,

    {"DESCRIPTION", sizeof("DESCRIPTION") - 1, DESCRIPTION}

    ,

    {"INDEX", sizeof("INDEX") - 1, INDEX}

    ,

    {"DEFVAL", sizeof("DEFVAL") - 1, DEFVAL}

    ,

    {"deprecated", sizeof("deprecated") - 1, DEPRECATED}

    ,

    {"SIZE", sizeof("SIZE") - 1, SIZE}

    ,

    {"MAX-ACCESS", sizeof("MAX-ACCESS") - 1, ACCESS}

    ,

    {"ACCESS", sizeof("ACCESS") - 1, ACCESS}

    ,

    {"mandatory", sizeof("mandatory") - 1, MANDATORY}

    ,

    {"current", sizeof("current") - 1, CURRENT}

    ,

    {"STATUS", sizeof("STATUS") - 1, STATUS}

    ,

    {"SYNTAX", sizeof("SYNTAX") - 1, SYNTAX}

    ,

    {"OBJECT-TYPE", sizeof("OBJECT-TYPE") - 1, OBJTYPE}

    ,

    {"TRAP-TYPE", sizeof("TRAP-TYPE") - 1, TRAPTYPE}

    ,

    {"ENTERPRISE", sizeof("ENTERPRISE") - 1, ENTERPRISE}

    ,

    {"BEGIN", sizeof("BEGIN") - 1, BEGIN}

    ,

    {"IMPORTS", sizeof("IMPORTS") - 1, IMPORTS}

    ,

    {"EXPORTS", sizeof("EXPORTS") - 1, EXPORTS}

    ,

    {"accessible-for-notify", sizeof("accessible-for-notify") - 1,

     ACCNOTIFY}

    ,

    {"TEXTUAL-CONVENTION", sizeof("TEXTUAL-CONVENTION") - 1, CONVENTION}

    ,

    {"NOTIFICATION-GROUP", sizeof("NOTIFICATION-GROUP") - 1, NOTIFGROUP}

    ,

    {"DISPLAY-HINT", sizeof("DISPLAY-HINT") - 1, DISPLAYHINT}

    ,

    {"FROM", sizeof("FROM") - 1, FROM}

    ,

    {"AGENT-CAPABILITIES", sizeof("AGENT-CAPABILITIES") - 1, AGENTCAP}

    ,

    {"MACRO", sizeof("MACRO") - 1, MACRO}

    ,

    {"IMPLIED", sizeof("IMPLIED") - 1, IMPLIED}

    ,

    {"SUPPORTS", sizeof("SUPPORTS") - 1, SUPPORTS}

    ,

    {"INCLUDES", sizeof("INCLUDES") - 1, INCLUDES}

    ,

    {"VARIATION", sizeof("VARIATION") - 1, VARIATION}

    ,

    {"REVISION", sizeof("REVISION") - 1, REVISION}

    ,

    {"not-implemented", sizeof("not-implemented") - 1, NOTIMPL}

    ,

    {"OBJECTS", sizeof("OBJECTS") - 1, OBJECTS}

    ,

    {"NOTIFICATIONS", sizeof("NOTIFICATIONS") - 1, NOTIFICATIONS}

    ,

    {"MODULE", sizeof("MODULE") - 1, MODULE}

    ,

    {"MIN-ACCESS", sizeof("MIN-ACCESS") - 1, MINACCESS}

    ,

    {"PRODUCT-RELEASE", sizeof("PRODUCT-RELEASE") - 1, PRODREL}

    ,

    {"WRITE-SYNTAX", sizeof("WRITE-SYNTAX") - 1, WRSYNTAX}

    ,

    {"CREATION-REQUIRES", sizeof("CREATION-REQUIRES") - 1, CREATEREQ}

    ,

    {"MANDATORY-GROUPS", sizeof("MANDATORY-GROUPS") - 1, MANDATORYGROUPS}

    ,

    {"GROUP", sizeof("GROUP") - 1, GROUP}

    ,

    {"CHOICE", sizeof("CHOICE") - 1, CHOICE}

    ,

    {"IMPLICIT", sizeof("IMPLICIT") - 1, IMPLICIT}

    ,

    {"ObjectSyntax", sizeof("ObjectSyntax") - 1, OBJSYNTAX}

    ,

    {"SimpleSyntax", sizeof("SimpleSyntax") - 1, SIMPLESYNTAX}

    ,

    {"ApplicationSyntax", sizeof("ApplicationSyntax") - 1, APPSYNTAX}

    ,

    {"ObjectName", sizeof("ObjectName") - 1, OBJNAME}

    ,

    {"NotificationName", sizeof("NotificationName") - 1, NOTIFNAME}

    ,

    {"VARIABLES", sizeof("VARIABLES") - 1, VARIABLES}

    ,

    {NULL}

};

static struct module_compatability *module_map_head;

static struct module_compatability module_map[] = {

    {"RFC1065-SMI", "RFC1155-SMI", NULL, 0},

    {"RFC1066-MIB", "RFC1156-MIB", NULL, 0},

    /*

     * 'mib' -> 'mib-2' 

     */

    {"RFC1156-MIB", "RFC1158-MIB", NULL, 0},

    /*

     * 'snmpEnableAuthTraps' -> 'snmpEnableAuthenTraps' 

     */

    {"RFC1158-MIB", "RFC1213-MIB", NULL, 0},

    /*

     * 'nullOID' -> 'zeroDotZero' 

     */

    {"RFC1155-SMI", "SNMPv2-SMI", NULL, 0},

    {"RFC1213-MIB", "SNMPv2-SMI", "mib-2", 0},

    {"RFC1213-MIB", "SNMPv2-MIB", "sys", 3},

    {"RFC1213-MIB", "IF-MIB", "if", 2},

    {"RFC1213-MIB", "IP-MIB", "ip", 2},

    {"RFC1213-MIB", "IP-MIB", "icmp", 4},

    {"RFC1213-MIB", "TCP-MIB", "tcp", 3},

    {"RFC1213-MIB", "UDP-MIB", "udp", 3},

    {"RFC1213-MIB", "SNMPv2-SMI", "transmission", 0},

    {"RFC1213-MIB", "SNMPv2-MIB", "snmp", 4},

    {"RFC1231-MIB", "TOKENRING-MIB", NULL, 0},

    {"RFC1271-MIB", "RMON-MIB", NULL, 0},

    {"RFC1286-MIB", "SOURCE-ROUTING-MIB", "dot1dSr", 7},

    {"RFC1286-MIB", "BRIDGE-MIB", NULL, 0},

    {"RFC1315-MIB", "FRAME-RELAY-DTE-MIB", NULL, 0},

    {"RFC1316-MIB", "CHARACTER-MIB", NULL, 0},

    {"RFC1406-MIB", "DS1-MIB", NULL, 0},

    {"RFC-1213", "RFC1213-MIB", NULL, 0},

};

#define MODULE_NOT_FOUND  0

#define MODULE_LOADED_OK  1

#define MODULE_ALREADY_LOADED 2

/*

 * #define MODULE_LOAD_FAILED   3       

 */

#define MODULE_LOAD_FAILED  MODULE_NOT_FOUND

#define MODULE_SYNTAX_ERROR     4

int gMibError = 0,gLoop = 0;

static char *gpMibErrorString;

char gMibNames[STRINGMAX];

#define HASHSIZE        32

#define BUCKET(x)       (x & (HASHSIZE-1))

#define NHASHSIZE    128

#define NBUCKET(x)   (x & (NHASHSIZE-1))

static struct tok *buckets[HASHSIZE];

static struct node *nbuckets[NHASHSIZE];

static struct tree *tbuckets[NHASHSIZE];

static struct module *module_head = NULL;

static struct node *orphan_nodes = NULL;

NETSNMP_IMPORT struct tree *tree_head;

struct tree        *tree_head = NULL;

#define NUMBER_OF_ROOT_NODES  3

static struct module_import root_imports[NUMBER_OF_ROOT_NODES];

static int      current_module = 0;

static int      max_module = 0;

static int      first_err_module = 1;

static char    *last_err_module = NULL; /* no repeats on "Cannot find module..." */

static void     tree_from_node(struct tree *tp, struct node *np);

static void     do_subtree(struct tree *, struct node **);

static void     do_linkup(struct module *, struct node *);

static void     dump_module_list(void);

static int      get_token(FILE *, char *, int);

static int      parseQuoteString(FILE *, char *, int);

static int      tossObjectIdentifier(FILE *);

static int      name_hash(const char *);

static void     init_node_hash(struct node *);

static void     print_error(const char *, const char *, int);

static void     free_tree(struct tree *);

static void     free_partial_tree(struct tree *, int);

static void     free_node(struct node *);

static void     build_translation_table(void);

static void     init_tree_roots(void);

static void     merge_anon_children(struct tree *, struct tree *);

static void     unlink_tbucket(struct tree *);

static void     unlink_tree(struct tree *);

static struct node *parse_objectid(FILE *, char *);

static int      get_tc(const char *, int, int *, struct enum_list **,

                       struct range_list **, char **);

static int      get_tc_index(const char *, int);

static struct enum_list *parse_enumlist(FILE *, struct enum_list **);

static struct range_list *parse_ranges(FILE * fp, struct range_list **);

static struct node *parse_asntype(FILE *, char *, int *, char *);

static struct node *parse_objecttype(FILE *, char *);

static struct node *parse_objectgroup(FILE *, char *, int,

                                      struct objgroup **);

static struct node *parse_notificationDefinition(FILE *, char *);

static struct node *parse_trapDefinition(FILE *, char *);

static struct node *parse_compliance(FILE *, char *);

static struct node *parse_capabilities(FILE *, char *);

static struct node *parse_moduleIdentity(FILE *, char *);

static struct node *parse_macro(FILE *, char *);

static void     parse_imports(FILE *);

static struct node *parse(FILE *);

static int     read_module_internal(const char *);

static int     read_module_replacements(const char *);

static int     read_import_replacements(const char *,

                                         struct module_import *);

static struct node *merge_parse_objectid(struct node *, FILE *, char *);

static struct index_list *getIndexes(FILE * fp, struct index_list **);

static struct varbind_list *getVarbinds(FILE * fp, struct varbind_list **);

static void     free_indexes(struct index_list **);

static void     free_varbinds(struct varbind_list **);

static void     free_ranges(struct range_list **);

static void     free_enums(struct enum_list **);

static struct range_list *copy_ranges(struct range_list *);

static struct enum_list *copy_enums(struct enum_list *);

static u_int    compute_match(const char *search_base, const char *key);

void

snmp_mib_toggle_options_usage(const char *lead, FILE * outf)

{

    fprintf(outf, "%su:  %sallow the use of underlines in MIB symbols\n",

            lead, ((netsnmp_ds_get_boolean(NETSNMP_DS_LIBRARY_ID,

             NETSNMP_DS_LIB_MIB_PARSE_LABEL)) ?

       "dis" : ""));

    fprintf(outf, "%sc:  %sallow the use of \"--\" to terminate comments\n",

            lead, ((netsnmp_ds_get_boolean(NETSNMP_DS_LIBRARY_ID,

             NETSNMP_DS_LIB_MIB_COMMENT_TERM)) ?

       "" : "dis"));

    fprintf(outf, "%sd:  %ssave the DESCRIPTIONs of the MIB objects\n",

            lead, ((netsnmp_ds_get_boolean(NETSNMP_DS_LIBRARY_ID, 

             NETSNMP_DS_LIB_SAVE_MIB_DESCRS)) ?

       "do not " : ""));

    fprintf(outf, "%se:  disable errors when MIB symbols conflict\n", lead);

    fprintf(outf, "%sw:  enable warnings when MIB symbols conflict\n", lead);

    fprintf(outf, "%sW:  enable detailed warnings when MIB symbols conflict\n",

            lead);

    fprintf(outf, "%sR:  replace MIB symbols from latest module\n", lead);

}

char           *

snmp_mib_toggle_options(char *options)

{

    if (options) {

        while (*options) {

            switch (*options) {

            case 'u':

                netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_MIB_PARSE_LABEL,

                               !netsnmp_ds_get_boolean(NETSNMP_DS_LIBRARY_ID,

                                               NETSNMP_DS_LIB_MIB_PARSE_LABEL));

                break;

            case 'c':

                netsnmp_ds_toggle_boolean(NETSNMP_DS_LIBRARY_ID,

            NETSNMP_DS_LIB_MIB_COMMENT_TERM);

                break;

            case 'e':

                netsnmp_ds_toggle_boolean(NETSNMP_DS_LIBRARY_ID,

            NETSNMP_DS_LIB_MIB_ERRORS);

                break;

            case 'w':

                netsnmp_ds_set_int(NETSNMP_DS_LIBRARY_ID,

           NETSNMP_DS_LIB_MIB_WARNINGS, 1);

                break;

            case 'W':

                netsnmp_ds_set_int(NETSNMP_DS_LIBRARY_ID,

           NETSNMP_DS_LIB_MIB_WARNINGS, 2);

                break;

            case 'd':

                netsnmp_ds_toggle_boolean(NETSNMP_DS_LIBRARY_ID, 

            NETSNMP_DS_LIB_SAVE_MIB_DESCRS);

                break;

            case 'R':

                netsnmp_ds_toggle_boolean(NETSNMP_DS_LIBRARY_ID, 

            NETSNMP_DS_LIB_MIB_REPLACE);

                break;

            default:

                /*

                 * return at the unknown option 

                 */

                return options;

            }

            options++;

        }

    }

    return NULL;

}

static int

name_hash(const char *name)

{

    int             hash = 0;

    const char     *cp;

    if (!name)

        return 0;

    for (cp = name; *cp; cp++)

        hash += tolower((unsigned char)(*cp));

    return (hash);

}

void

netsnmp_init_mib_internals(void)

{

    register struct tok *tp;

    register int    b, i;

    int             max_modc;

    if (tree_head)

        return;

    /*

     * Set up hash list of pre-defined tokens

     */

    memset(buckets, 0, sizeof(buckets));

    for (tp = tokens; tp->name; tp++) {

        tp->hash = name_hash(tp->name);

        b = BUCKET(tp->hash);

        if (buckets[b])

            tp->next = buckets[b];      /* BUG ??? */

        buckets[b] = tp;

    }

    /*

     * Initialise other internal structures

     */

    max_modc = sizeof(module_map) / sizeof(module_map[0]) - 1;

    for (i = 0; i < max_modc; ++i)

        module_map[i].next = &(module_map[i + 1]);

    module_map[max_modc].next = NULL;

    module_map_head = module_map;

    memset(nbuckets, 0, sizeof(nbuckets));

    memset(tbuckets, 0, sizeof(tbuckets));

    free(tclist);

    tc_alloc = TC_INCR;

    tclist = calloc(tc_alloc, sizeof(struct tc));

    build_translation_table();

    init_tree_roots();          /* Set up initial roots */

    /*

     * Relies on 'add_mibdir' having set up the modules 

     */

}

#ifndef NETSNMP_NO_LEGACY_DEFINITIONS

void

init_mib_internals(void)

{

    netsnmp_init_mib_internals();

}

#endif

static void

init_node_hash(struct node *nodes)

{

    struct node    *np, *nextp;

    int             hash;

    memset(nbuckets, 0, sizeof(nbuckets));

    for (np = nodes; np;) {

        nextp = np->next;

        hash = NBUCKET(name_hash(np->parent));

        np->next = nbuckets[hash];

        nbuckets[hash] = np;

        np = nextp;

    }

}

static int      erroneousMibs = 0;

netsnmp_feature_child_of(parse_get_error_count, netsnmp_unused);

#ifndef NETSNMP_FEATURE_REMOVE_PARSE_GET_ERROR_COUNT

int

get_mib_parse_error_count(void)

{

    return erroneousMibs;

}

#endif /* NETSNMP_FEATURE_REMOVE_PARSE_GET_ERROR_COUNT */

static void

print_error(const char *str, const char *token, int type)

{

    erroneousMibs++;

    if (!netsnmp_ds_get_boolean(NETSNMP_DS_LIBRARY_ID,

                                NETSNMP_DS_LIB_MIB_ERRORS))

  return;

    DEBUGMSGTL(("parse-mibs", "\n"));

    if (type == ENDOFFILE)

        snmp_log(LOG_ERR, "%s (EOF): At line %d in %s\n", str, mibLine,

                 File);

    else if (token && *token)

        snmp_log(LOG_ERR, "%s (%s): At line %d in %s\n", str, token,

                 mibLine, File);

    else

        snmp_log(LOG_ERR, "%s: At line %d in %s\n", str, mibLine, File);

}

static void

print_module_not_found(const char *cp)

{

    if (first_err_module) {

        snmp_log(LOG_ERR, "MIB search path: %s\n",

                           netsnmp_get_mib_directory());

        first_err_module = 0;

    }

    if (!last_err_module || strcmp(cp, last_err_module))

        print_error("Cannot find module", cp, CONTINUE);

    if (last_err_module)

        free(last_err_module);

    last_err_module = strdup(cp);

}

static struct node *

alloc_node(int modid)

{

    struct node    *np;

    np = calloc(1, sizeof(struct node));

    if (!np)

        return NULL;

    np->tc_index = -1;

    np->modid = modid;

    np->filename = strdup(File);

    np->lineno = mibLine;

    return np;

}

static void

unlink_tbucket(struct tree *tp)

{

    int             hash = NBUCKET(name_hash(tp->label));

    struct tree    *otp = NULL, *ntp = tbuckets[hash];

    while (ntp && ntp != tp) {

        otp = ntp;

        ntp = ntp->next;

    }

    if (!ntp)

        snmp_log(LOG_EMERG, "Can't find %s in tbuckets\n", tp->label);

    else if (otp)

        otp->next = ntp->next;

    else

        tbuckets[hash] = tp->next;

}

static void

unlink_tree(struct tree *tp)

{

    struct tree    *otp = NULL, *ntp = tp->parent;

    if (!ntp) {                 /* this tree has no parent */

        DEBUGMSGTL(("unlink_tree", "Tree node %s has no parent\n",

                    tp->label));

    } else {

        ntp = ntp->child_list;

        while (ntp && ntp != tp) {

            otp = ntp;

            ntp = ntp->next_peer;

        }

        if (!ntp)

            snmp_log(LOG_EMERG, "Can't find %s in %s's children\n",

                     tp->label, tp->parent->label);

        else if (otp)

            otp->next_peer = ntp->next_peer;

        else

            tp->parent->child_list = tp->next_peer;

    }

    if (tree_head == tp)

        tree_head = tp->next_peer;

}

static void

free_partial_tree(struct tree *tp, int keep_label)

{

    if (!tp)

        return;

    /*

     * remove the data from this tree node 

     */

    free_enums(&tp->enums);

    free_ranges(&tp->ranges);

    free_indexes(&tp->indexes);

    free_varbinds(&tp->varbinds);

    if (!keep_label)

        SNMP_FREE(tp->label);

    SNMP_FREE(tp->hint);

    SNMP_FREE(tp->units);

    SNMP_FREE(tp->description);

    SNMP_FREE(tp->reference);

    SNMP_FREE(tp->augments);

    SNMP_FREE(tp->defaultValue);

}

/*

 * free a tree node. Note: the node must already have been unlinked

 * from the tree when calling this routine

 */

static void

free_tree(struct tree *Tree)

{

    if (!Tree)

        return;

    unlink_tbucket(Tree);

    free_partial_tree(Tree, FALSE);

    if (Tree->module_list != &Tree->modid)

        free(Tree->module_list);

    free(Tree);

}

static void

free_node(struct node *np)

{

    if (!np)

        return;

    free_enums(&np->enums);

    free_ranges(&np->ranges);

    free_indexes(&np->indexes);

    free_varbinds(&np->varbinds);

    free(np->label);

    free(np->hint);

    free(np->units);

    free(np->description);

    free(np->reference);

    free(np->defaultValue);

    free(np->parent);

    free(np->augments);

    free(np->filename);

    free(np);

}

static void

print_range_value(FILE * fp, int type, struct range_list * rp)

{

    switch (type) {

    case TYPE_INTEGER:

    case TYPE_INTEGER32:

        if (rp->low == rp->high)

            fprintf(fp, "%d", rp->low);

        else

            fprintf(fp, "%d..%d", rp->low, rp->high);

        break;

    case TYPE_UNSIGNED32:

    case TYPE_OCTETSTR:

    case TYPE_GAUGE:

    case TYPE_UINTEGER:

        if (rp->low == rp->high)

            fprintf(fp, "%u", (unsigned)rp->low);

        else

            fprintf(fp, "%u..%u", (unsigned)rp->low, (unsigned)rp->high);

        break;

    default:

        /* No other range types allowed */

        break;

    }

}

#ifdef TEST

static void

print_nodes(FILE * fp, struct node *root)

{

    struct enum_list *ep;

    struct index_list *ip;

    struct varbind_list *vp;

    struct node    *np;

    for (np = root; np; np = np->next) {

        fprintf(fp, "%s ::= { %s %ld } (%d)\n", np->label, np->parent,

                np->subid, np->type);

        if (np->tc_index >= 0)

            fprintf(fp, "  TC = %s\n", tclist[np->tc_index].descriptor);

        if (np->enums) {

            fprintf(fp, "  Enums: \n");

            for (ep = np->enums; ep; ep = ep->next) {

                fprintf(fp, "    %s(%d)\n", ep->label, ep->value);

            }

        }

        if (np->ranges) {

            struct range_list *rp;

            fprintf(fp, "  Ranges: ");

            for (rp = np->ranges; rp; rp = rp->next) {

                fprintf(fp, "\n    ");

                print_range_value(fp, np->type, rp);

            }

            fprintf(fp, "\n");

        }

        if (np->indexes) {

            fprintf(fp, "  Indexes: \n");

            for (ip = np->indexes; ip; ip = ip->next) {

                fprintf(fp, "    %s\n", ip->ilabel);

            }

        }

        if (np->augments)

            fprintf(fp, "  Augments: %s\n", np->augments);

        if (np->varbinds) {

            fprintf(fp, "  Varbinds: \n");

            for (vp = np->varbinds; vp; vp = vp->next) {

                fprintf(fp, "    %s\n", vp->vblabel);

            }

        }

        if (np->hint)

            fprintf(fp, "  Hint: %s\n", np->hint);

        if (np->units)

            fprintf(fp, "  Units: %s\n", np->units);

        if (np->defaultValue)

            fprintf(fp, "  DefaultValue: %s\n", np->defaultValue);

    }

}

#endif

void

print_subtree(FILE * f, struct tree *tree, int count)

{

    struct tree    *tp;

    int             i;

    char            modbuf[256];

    for (i = 0; i < count; i++)

        fprintf(f, "  ");

    fprintf(f, "Children of %s(%ld):\n", tree->label, tree->subid);

    count++;

    for (tp = tree->child_list; tp; tp = tp->next_peer) {

        for (i = 0; i < count; i++)

            fprintf(f, "  ");

        fprintf(f, "%s:%s(%ld) type=%d",

                module_name(tp->module_list[0], modbuf),

                tp->label, tp->subid, tp->type);

        if (tp->tc_index != -1)

            fprintf(f, " tc=%d", tp->tc_index);

        if (tp->hint)

            fprintf(f, " hint=%s", tp->hint);

        if (tp->units)

            fprintf(f, " units=%s", tp->units);

        if (tp->number_modules > 1) {

            fprintf(f, " modules:");

            for (i = 1; i < tp->number_modules; i++)

                fprintf(f, " %s", module_name(tp->module_list[i], modbuf));