/*      $OpenBSD: mib.y,v 1.2 2024/02/20 12:41:13 martijn Exp $ */

/*
 * Copyright (c) 2023 Martijn van Duren <martijn@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, 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.
 */

%{

#include <sys/tree.h>

#include <assert.h>
#include <ber.h>
#include <ctype.h>
#include <dirent.h>
#include <errno.h>
#include <inttypes.h>
#include <limits.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <strings.h>
#include <time.h>

#include "log.h"
#include "mib.h"

/* RFC2578 section 3.1 */
#define DESCRIPTOR_MAX 64

/* Values from real life testing, could be adjusted */
#define ITEM_MAX DESCRIPTOR_MAX
#define MODULENAME_MAX 64
#define SYMBOLS_MAX 256
#define IMPORTS_MAX 16
#define TEXT_MAX 16384

#ifndef nitems
#define nitems(_a) (sizeof((_a)) / sizeof((_a)[0]))
#endif

struct objidcomponent {
        enum {
                OCT_DESCRIPTOR,
                OCT_NUMBER,
                OCT_NAMEANDNUMBER
        }                        type;
        uint32_t                 number;
        char                     name[DESCRIPTOR_MAX + 1];
};

struct oid_unresolved {
        /* Unusual to have long lists of unresolved components */
        struct objidcomponent    bo_id[16];
        size_t                   bo_n;
};

struct oid_resolved {
        uint32_t                *bo_id;
        size_t                   bo_n;
};

enum status {
        CURRENT,
        DEPRECATED,
        OBSOLETE
};

enum access {
        NOTACCESSIBLE,
        ACCESSIBLEFORNOTIFY,
        READONLY,
        READWRITE,
        READCREATE
};

struct objectidentity {
        enum status              status;
        char                    *description;
        char                    *reference;
};

struct objecttype {
        void                    *syntax;
        char                    *units;
        enum access              maxaccess;
        enum status              status;
        char                    *description;
        char                    *reference;
        void                    *index;
        void                    *defval;
};

struct notificationtype {
        void                    *objects;
        enum status              status;
        char                    *description;
        char                    *reference;
};

struct textualconvention {
        char                    *displayhint;
        enum status              status;
        char                    *description;
        char                    *reference;
        void                    *syntax;
};

struct item {
        char                     name[DESCRIPTOR_MAX + 1];
        enum item_type {
                IT_OID,
                IT_MACRO,
                IT_MODULE_IDENTITY,
                IT_OBJECT_IDENTITY,
                IT_APPLICATIONSYNTAX,
                IT_OBJECT_TYPE,
                IT_NOTIFICATION_TYPE,
                IT_TEXTUAL_CONVENTION,
                IT_OBJECT_GROUP,
                IT_NOTIFICATION_GROUP,
                IT_MODULE_COMPLIANCE,
                IT_AGENT_CAPABITIES
        }                        type;
        int                      resolved;
        struct module           *module;

        union {
                struct oid_unresolved   *oid_unresolved;
                struct oid_resolved      oid;
        };

        union {
                struct objectidentity    objectidentity;
                struct objecttype        objecttype;
                struct notificationtype  notificationtype;
                struct textualconvention textualconvention;
        };

        /* Global case insensitive */
        RB_ENTRY(item)           entrygci;
        /* Module case insensitive */
        RB_ENTRY(item)           entryci;
        /* Module case sensitive */
        RB_ENTRY(item)           entrycs;
        /* Global oid */
        RB_ENTRY(item)           entry;
};

struct import_symbol {
        char                     name[DESCRIPTOR_MAX + 1];
        struct item             *item;
};

struct import {
        char                     name[MODULENAME_MAX + 1];
        struct module           *module;
        struct import_symbol     symbols[SYMBOLS_MAX];
        size_t                   nsymbols;
};

static struct module {
        char                     name[MODULENAME_MAX + 1];
        int8_t                   resolved;

        time_t                   lastupdated;

        struct import           *imports;

        RB_HEAD(itemscs, item) itemscs;
        RB_HEAD(itemsci, item) itemsci;

        RB_ENTRY(module) entryci;
        RB_ENTRY(module) entrycs;
} *module;

int              yylex(void);
static void      yyerror(const char *, ...)
    __attribute__((__format__ (printf, 1, 2)));
void             mib_defaults(void);
void             mib_modulefree(struct module *);
int              mib_imports_add(char *, char **);
int              mib_oid_append(struct oid_unresolved *,
                    const struct objidcomponent *);
int              mib_macro(const char *);
int              mib_oid_concat(struct oid_unresolved *,
                    const struct oid_unresolved *);
struct item     *mib_item(const char *, enum item_type);
int              mib_item_oid(struct item *,
                    const struct oid_unresolved *);
int              mib_macro(const char *);
int              mib_applicationsyntax(const char *);
struct item     *mib_oid(const char *, const struct oid_unresolved *);
int              mib_moduleidentity(const char *, time_t, const char *,
                    const char *, const char *, const struct oid_unresolved *);
int              mib_objectidentity(const char *, enum status, const char *,
                    const char *, const struct oid_unresolved *);
int              mib_objecttype(const char *, void  *, const char *,
                    enum access, enum status, const char *, const char *,
                    void *, void *, const struct oid_unresolved *);
int              mib_notificationtype(const char *, void *, enum status,
                    const char *, const char *, const struct oid_unresolved *);
int              mib_textualconvetion(const char *, const char *, enum status,
                    const char *, const char *, void *);
int              mib_objectgroup(const char *, void *, enum status,
                    const char *, const char *, const struct oid_unresolved *);
int              mib_notificationgroup(const char *, void *, enum status,
                    const char *, const char *, const struct oid_unresolved *);
int              mib_modulecompliance(const char *, enum status, const char *,
                    const char *, void *, const struct oid_unresolved *);
struct item     *mib_item_find(struct item *, const char *);
struct item     *mib_item_parent(struct ber_oid *);
int               mib_resolve_oid(struct oid_resolved *,
                    struct oid_unresolved *, struct item *);
int              mib_resolve_item(struct item *);
int              mib_resolve_module(struct module *);
int              module_cmp_cs(struct module *, struct module *);
int              module_cmp_ci(struct module *, struct module *);
int              item_cmp_cs(struct item *, struct item *);
int              item_cmp_ci(struct item *, struct item *);
int              item_cmp_oid(struct item *, struct item *);

RB_HEAD(modulesci, module) modulesci = RB_INITIALIZER(&modulesci);
RB_HEAD(modulescs, module) modulescs = RB_INITIALIZER(&modulescs);
RB_HEAD(items, item) items = RB_INITIALIZER(&items);
RB_HEAD(itemsgci, item) itemsci = RB_INITIALIZER(&itemsci);
/*
 * Use case sensitive matching internally (for resolving IMPORTS) and
 * case sensitive matching, followed by case insensitive matching
 * for end-user resolving (e.g. mib_string2oid()).
 * It shouldn't happen there's case-based overlap in module/item names,
 * but allow all to be resolved in case there is.
 */
RB_PROTOTYPE_STATIC(modulesci, module, entryci, module_cmp_ci);
RB_PROTOTYPE_STATIC(modulescs, module, entrycs, module_cmp_cs);
/*
 * mib_string2oid() should match case insensitive on:
 * <module>::<descriptor>
 * <descriptor>
 */
RB_PROTOTYPE_STATIC(itemsgci, item, entrygci, item_cmp_ci);
RB_PROTOTYPE_STATIC(itemsci, item, entryci, item_cmp_ci);
RB_PROTOTYPE_STATIC(itemscs, item, entrycs, item_cmp_cs);
RB_PROTOTYPE_STATIC(items, item, entry, item_cmp_oid);

struct file {
        FILE            *stream;
        const char      *name;
        size_t           lineno;
        enum {
                FILE_UNDEFINED,
                FILE_ASN1,
                FILE_SMI2
        }                state;
} file;

typedef union {
        char                     string[TEXT_MAX];
        unsigned long long       number;
        long long                signednumber;
        char                     symbollist[SYMBOLS_MAX][DESCRIPTOR_MAX + 1];
        struct objidcomponent    objidcomponent;
        struct oid_unresolved    oid;
        time_t                   time;
        enum status              status;
        enum access              access;
} YYSTYPE;

%}

%token  ERROR
%token  HSTRING BSTRING

/* RFC2578 section 3.7 */
%token  ABSENT ACCESS AGENTCAPABILITIES ANY APPLICATION AUGMENTS BEGIN
%token  BIT BITS BOOLEAN BY CHOICE COMPONENT COMPONENTS CONTACTINFO
%token  CREATIONREQUIRES Counter32 Counter64 DEFAULT DEFINED
%token  DEFINITIONS DEFVAL DESCRIPTION DISPLAYHINT END ENUMERATED
%token  ENTERPRISE EXPLICIT EXPORTS EXTERNAL FALSE FROM GROUP Gauge32
%token  IDENTIFIER IMPLICIT IMPLIED IMPORTS INCLUDES INDEX INTEGER
%token  Integer32 IpAddress LASTUPDATED MANDATORYGROUPS MAX MAXACCESS
%token  MIN MINACCESS MINUSINFINITY MODULE MODULECOMPLIANCE MODULEIDENTITY 
%token  NOTIFICATIONGROUP NOTIFICATIONTYPE NOTIFICATIONS ASNNULL
%token  OBJECT OBJECTGROUP OBJECTIDENTITY OBJECTTYPE OBJECTS OCTET OF
%token  OPTIONAL ORGANIZATION Opaque PLUSINFINITY PRESENT PRIVATE
%token  PRODUCTRELEASE REAL REFERENCE REVISION SEQUENCE SET SIZE STATUS
%token  STRING SUPPORTS SYNTAX TAGS TEXTUALCONVENTION TRAPTYPE TRUE
%token  TimeTicks UNITS UNIVERSAL Unsigned32 VARIABLES VARIATION WITH
%token  WRITESYNTAX

/* SMIv2 */
%token  SNMPv2SMI SNMPv2CONF SNMPv2TC

/* X.208 */
%token  PRODUCTION RANGESEPARATOR

%token  <string>        typereference identifier TEXT HSTRING BSTRING
%token  <number>        NUMBER
%token  <signednumber>  SIGNEDNUMBER
%type   <string>        moduleidentifier smiv2moduleidentifier
%type   <import>        symbolsfrom
%type   <symbollist>    symbollist
%type   <string>        descriptor symbol
%type   <objidcomponent>objidcomponentfirst objidcomponent
%type   <oid>           objidcomponentlist objectidentifiervalue
%type   <string>        displaypart referpart unitspart
%type   <time>          lastupdated
%type   <status>        status
%type   <access>        access

%%

grammar                 : /* empty */
                        | grammar module
                        ;

module                  : moduleidentifier DEFINITIONS PRODUCTION BEGIN {
                                file.state = FILE_ASN1;
                                module = calloc(1, sizeof(*module));
                                if (module == NULL) {
                                        yyerror("malloc");
                                        YYERROR;
                                }
                                RB_INIT(&module->itemscs);
                                RB_INIT(&module->itemsci);
                                module->resolved = 0;
                                if (strlcpy(module->name, $1,
                                    sizeof(module->name)) >=
                                    sizeof(module->name)) {
                                        yyerror("module name too long");
                                        free(module);
                                        YYERROR;
                                }
                        } imports moduleidentity modulebody END {
                                struct module *mprev;

                                if ((mprev = RB_INSERT(modulescs, &modulescs,
                                    module)) != NULL) {
                                        if (module->lastupdated >
                                            mprev->lastupdated) {
                                                mib_modulefree(mprev);
                                                RB_INSERT(modulescs, &modulescs,
                                                    module);
                                                RB_INSERT(modulesci, &modulesci,
                                                    module);
                                        } else
                                                mib_modulefree(module);
                                } else 
                                        RB_INSERT(modulesci, &modulesci, module);
                                module = NULL;
                        }
                        | smiv2moduleidentifier {
                                log_debug("%s: SMIv2 definitions: skipping",
                                   file.name);
                                YYACCEPT;
                        }
                        ;

moduleidentifier        : typereference { strlcpy($$, $1, sizeof($$)); }
                        ;

smiv2moduleidentifier   : SNMPv2SMI { strlcpy($$, "SNMPv2-SMI", sizeof($$)); }
                        | SNMPv2CONF { strlcpy($$, "SNMPv2-CONF", sizeof($$)); }
                        | SNMPv2TC { strlcpy($$, "SNMPv2-TC", sizeof($$)); }
                        ;

modulebody              : assignmentlist
                        ;

imports                 : IMPORTS importlist ';'
                        ;

importlist              : importlist symbolsfrom
                        | /* start */
                        ;

symbolsfrom             : symbollist FROM moduleidentifier {
                                size_t i;
                                char *symbols[SYMBOLS_MAX];

                                for (i = 0; $1[i][0] != '\0'; i++)
                                        symbols[i] = $1[i];
                                symbols[i] = NULL;
                                        
                                if (mib_imports_add($3, symbols) == -1)
                                        YYERROR;
                        }
                        | symbollist FROM smiv2moduleidentifier {
                                size_t i;
                                char *symbols[SYMBOLS_MAX];

                                for (i = 0; $1[i][0] != '\0'; i++)
                                        symbols[i] = $1[i];
                                symbols[i] = NULL;
                                        
                                if (mib_imports_add($3, symbols) == -1)
                                        YYERROR;

                                file.state = FILE_SMI2;
                        }
                        ;

symbollist              : symbollist ',' symbol {
                                size_t i;
                                for (i = 0; $1[i][0] != '\0'; i++)
                                        strlcpy($$[i], $1[i], sizeof($$[i]));
                                if (i + 1 == nitems($$)) {
                                        yyerror("too many symbols from module");
                                        YYERROR;
                                }
                                if (strlcpy($$[i], $3, sizeof($$[i])) >=
                                    sizeof($$[i])) {
                                        yyerror("symbol too long");
                                        YYERROR;
                                }
                                $$[i + 1][0] = '\0';
                        }
                        | symbol {
                                if (strlcpy($$[0], $1, sizeof($$[0])) >=
                                    sizeof($$[0])) {
                                        yyerror("symbol too long");
                                        YYERROR;
                                }
                                $$[1][0] = '\0';
                        }
                        ;

symbol                  : typereference { strlcpy($$, $1, sizeof($$)); }
                        | descriptor { strlcpy($$, $1, sizeof($$)); }
                        /* SNMPv2-SMI */
                        | MODULEIDENTITY {
                                strlcpy($$, "MODULE-IDENTITY", sizeof($$));
                        }
                        | OBJECTIDENTITY {
                                strlcpy($$, "OBJECT-IDENTITY", sizeof($$));
                        }
                        | Integer32  { strlcpy($$, "Integer32", sizeof($$)); }
                        | IpAddress { strlcpy($$, "IpAddress", sizeof($$)); }
                        | Counter32 { strlcpy($$, "Counter32", sizeof($$)); }
                        | Gauge32 { strlcpy($$, "Gauge32", sizeof($$)); }
                        | Unsigned32 { strlcpy($$, "Unsigned32", sizeof($$)); }
                        | TimeTicks { strlcpy($$, "TimeTicks", sizeof($$)); }
                        | Opaque { strlcpy($$, "Opaque", sizeof($$)); }
                        | Counter64 { strlcpy($$, "Counter64", sizeof($$)); }
                        | OBJECTTYPE { strlcpy($$, "OBJECT-TYPE", sizeof($$)); }
                        | NOTIFICATIONTYPE {
                                strlcpy($$, "NOTIFICATION-TYPE", sizeof($$));
                        }
                        /* SNMPv2-TC */
                        | TEXTUALCONVENTION {
                                strlcpy($$, "TEXTUAL-CONVENTION", sizeof($$));
                        }
                        /* SNMPv2-CONF */
                        | OBJECTGROUP {
                                strlcpy($$, "OBJECT-GROUP", sizeof($$));
                        }
                        | NOTIFICATIONGROUP {
                                strlcpy($$, "NOTIFICATION-GROUP", sizeof($$));
                        }
                        | MODULECOMPLIANCE {
                                strlcpy($$, "MODULE-COMPLIANCE", sizeof($$));
                        }
                        | AGENTCAPABILITIES {
                                strlcpy($$, "AGENT-CAPABILITIES", sizeof($$));
                        }
                        ;

descriptor              : identifier {
                                if (strlen($1) > DESCRIPTOR_MAX) {
                                        yyerror("descriptor too long");
                                        YYERROR;
                                }
                                strlcpy($$, $1, sizeof($$));
                        }
                        ;

moduleidentity          : descriptor MODULEIDENTITY lastupdated
                          ORGANIZATION TEXT CONTACTINFO TEXT DESCRIPTION TEXT
                          revisionpart PRODUCTION objectidentifiervalue {
                                if (mib_moduleidentity(
                                    $1, $3, $5, $7, $9, &$12) == -1)
                                        YYERROR;
                        }
                        ;

lastupdated             : LASTUPDATED TEXT {
                                char timebuf[14] = "";
                                struct tm tm = {};
                                size_t len;

                                if ((len = strlen($2)) == 11)
                                        snprintf(timebuf, sizeof(timebuf),
                                            "19%s", $2);
                                else if (len == 13)
                                        strlcpy(timebuf, $2, sizeof(timebuf));
                                else {
                                        yyerror("Invalid LAST-UPDATED: %s", $2);
                                        YYERROR;
                                }

                                if (strptime(timebuf, "%Y%m%d%H%MZ", &tm) == NULL) {
                                        yyerror("Invalid LAST-UPDATED: %s", $2);
                                        YYERROR;
                                }

                                if (($$ = mktime(&tm)) == -1) {
                                        yyerror("Invalid LAST-UPDATED: %s", $2);
                                        YYERROR;
                                }
                        }
                        ;

revisionpart            : revisions
                        | /* empty */
                        ;

revisions               : revision
                        | revisions revision
                        ;

revision                : REVISION TEXT DESCRIPTION TEXT
                        ;

assignmentlist          : assignment assignmentlist
                        | /* empty */
                        ;

assignment              : descriptor OBJECT IDENTIFIER PRODUCTION
                          objectidentifiervalue {
                                if (mib_oid($1, &$5) == NULL)
                                        YYERROR;
                        }
                        | descriptor OBJECTIDENTITY STATUS status
                          DESCRIPTION TEXT referpart PRODUCTION
                          objectidentifiervalue {
                                const char *reference;

                                reference = $7[0] == '\0' ? NULL : $7;

                                if (mib_objectidentity($1, $4, $6, reference,
                                    &$9) == -1)
                                        YYERROR;
                        }
                        | descriptor OBJECTTYPE SYNTAX syntax unitspart
                          MAXACCESS access STATUS status DESCRIPTION TEXT
                          referpart indexpart defvalpart PRODUCTION
                          objectidentifiervalue {
                                const char *units, *reference;

                                units = $5[0] == '\0' ? NULL : $5;
                                reference = $12[0] == '\0' ? NULL : $12;

                                if (mib_objecttype($1, NULL, units, $7, $9, $11,
                                    reference, NULL, NULL, &$16) == -1)
                                        YYERROR;
                        }
                        | descriptor NOTIFICATIONTYPE objectspart STATUS status
                          DESCRIPTION TEXT referpart PRODUCTION
                          objectidentifiervalue {
                                const char *reference;

                                reference = $8[0] == '\0' ? NULL : $8;

                                if (mib_notificationtype($1, NULL, $5, $7,
                                    reference, &$10) == -1)
                                        YYERROR;
                        }
                        | typereference PRODUCTION SEQUENCE '{' entries '}' {
                                /* Table entry, ignore for now */
                        }
                        | typereference PRODUCTION TEXTUALCONVENTION displaypart
                          STATUS status DESCRIPTION TEXT referpart SYNTAX syntax {
                                const char *displayhint, *reference;

                                displayhint = $4[0] == '\0' ? NULL : $4;
                                reference = $9[0] == '\0' ? NULL : $9;

                                if (mib_textualconvetion($1, displayhint, $6,
                                    $8, reference, NULL) == -1)
                                        YYERROR;
                        }
                        | descriptor MODULECOMPLIANCE STATUS status
                          DESCRIPTION TEXT referpart compliancemodulepart
                          PRODUCTION objectidentifiervalue {
                                const char *reference;

                                reference = $7[0] == '\0' ? NULL : $7;

                                if (mib_modulecompliance($1, $4, $6, reference,
                                    NULL, &$10) == -1)
                                        YYERROR;
                        }
                        | descriptor OBJECTGROUP objectspart STATUS status
                          DESCRIPTION TEXT referpart PRODUCTION
                          objectidentifiervalue {
                                const char *reference;

                                reference = $8[0] == '\0' ? NULL : $8;

                                if (mib_objectgroup($1, NULL, $5, $7, reference,
                                    &$10) == -1)
                                        YYERROR;
                        }
                        | descriptor NOTIFICATIONGROUP notificationspart
                          STATUS status DESCRIPTION TEXT referpart PRODUCTION
                          objectidentifiervalue {
                                const char *reference;

                                reference = $8[0] == '\0' ? NULL : $8;

                                if (mib_notificationgroup($1, NULL, $5, $7, reference,
                                    &$10) == -1)
                                        YYERROR;
                        }
                        | typereference PRODUCTION syntax
                        ;

notificationspart       : NOTIFICATIONS '{' notifications '}'
                        ;

notifications           : notification
                        | notification ',' notifications
                        ;

notification            : descriptor
                        ;

objectspart             : OBJECTS '{' objects '}'
                        | /* empty */
                        ;

objects                 : object
                        | objects ',' object
                        ;

object                  : descriptor
                        ;

syntax                  : type
                        | SEQUENCE OF typereference
                        | integersubtype
                        | octetstringsubtype
                        | enumeration
                        | bits
                        ;

unitspart               : UNITS TEXT {
                                strlcpy($$, $2, sizeof($$));
                        }
                        | /* empty */ {
                                $$[0] = '\0';
                        }
                        ;

referpart               : REFERENCE TEXT {
                                strlcpy($$, $2, sizeof($$));
                        }
                        | /* empty */ {
                                $$[0] = '\0';
                        }
                        ;

indexpart               : INDEX '{' indextypes '}'
                        | AUGMENTS '{' descriptor '}'
                        | /* empty */
                        ;

indextypes              : indextype
                        | indextypes ',' indextype
                        ;

indextype               : IMPLIED index
                        | index
                        ;

index                   : descriptor
                        ;

defvalpart              : DEFVAL '{' defvalue '}'
                        | /* empty */
                        ;

defvalue                : descriptor
                        | NUMBER
                        | SIGNEDNUMBER
                        | HSTRING
                        | TEXT
                        | bitsvalue
                        | objectidentifiervalue
                        ;

/* single-value and empty are covered by objectidentifiervalue */
bitsvalue               : '{' bitscomponentlist '}'
                        ;

bitscomponentlist       : bitscomponentlist ',' bitscomponent
                        | bitscomponent
                        | /* empty */
                        ;

bitscomponent           : identifier
                        ;

displaypart             : DISPLAYHINT TEXT {
                                strlcpy($$, $2, sizeof($$));
                        }
                        | /* empty */ {
                                $$[0] = '\0';
                        }
                        ;

entries                 : entry ',' entries
                        | entry
                        ;

entry                   : descriptor syntax
                        ;

compliancemodulepart    : compliancemodules
                        ;

compliancemodules       : compliancemodule
                        | compliancemodules compliancemodule
                        ;

compliancemodule        : MODULE modulename modulemandatorypart
                          modulecompliancepart
                        ;

modulename              : moduleidentifier
                        | /* empty */
                        ;

modulemandatorypart     : MANDATORYGROUPS '{' modulegroups '}'
                        | /* empty */
                        ;

modulegroups            : modulegroup
                        | modulegroups ',' modulegroup
                        ;

modulegroup             : objectidentifiervalue
                        | descriptor
                        ;

modulecompliancepart    : modulecompliances
                        | /* empty */
                        ;

modulecompliances       : modulecompliance
                        | modulecompliances modulecompliance
                        ;

modulecompliance        : modulecompliancegroup
                        | moduleobject
                        ;

modulecompliancegroup   : GROUP modulegroupobjectname DESCRIPTION TEXT
                        ;

moduleobject            : OBJECT moduleobjectname modulesyntaxpart
                          writesyntaxpart moduleaccesspart DESCRIPTION TEXT
                        ;

moduleobjectname        : objectidentifiervalue
                        | descriptor
                        ;

modulegroupobjectname   : objectidentifiervalue
                        | descriptor
                        ;

modulesyntaxpart        : SYNTAX syntax
                        | /* empty */
                        ;

writesyntaxpart         : WRITESYNTAX syntax
                        | /* empty */
                        ;

moduleaccesspart        : MINACCESS access
                        | /* empty */
                        ;

/*
 * An OBJECT IDENTIFIER needs at least 2 components and are needed to
 * distinguish from BITS, which can have 0 elements and only differentiate by a
 * comma separator.
 */
objectidentifiervalue   : '{' objidcomponentfirst objidcomponent
                          objidcomponentlist '}' {
                                $$.bo_n = 0;

                                if ($3.type == OCT_DESCRIPTOR) {
                                        yyerror("only first component of "
                                            "OBJECT IDENTIFIER can be a "
                                            "descriptor");
                                        YYERROR;
                                }
                                if (mib_oid_append(&$$, &$2) == -1)
                                        YYERROR;
                                if (mib_oid_append(&$$, &$3) == -1)
                                        YYERROR;
                                if (mib_oid_concat(&$$, &$4) == -1)
                                        YYERROR;
                        }
                        ;

objidcomponentlist      : objidcomponent objidcomponentlist {
                                if ($1.type == OCT_DESCRIPTOR) {
                                        yyerror("only first component of "
                                            "OBJECT IDENTIFIER can be a "
                                            "descriptor");
                                        YYERROR;
                                }

                                $$.bo_n = 0;
                                if (mib_oid_append(&$$, &$1) == -1)
                                        YYERROR;
                                if (mib_oid_concat(&$$, &$2) == -1)
                                        YYERROR;
                        }
                        | /* empty */ {
                                $$.bo_n = 0;
                        }
                        ;

objidcomponentfirst     : descriptor {
                                $$.type = OCT_DESCRIPTOR;
                                strlcpy($$.name, $1, sizeof($$.name));
                        }
                        | objidcomponent {
                                $$.type = $1.type;
                                $$.number = $1.number;
                                strlcpy($$.name, $1.name, sizeof($$.name));
                        }
                        ;

objidcomponent          : NUMBER {
                                $$.type = OCT_NUMBER;
                                if ($1 > UINT32_MAX) {
                                        yyerror("OBJECT IDENTIFIER number "
                                            "too large");
                                        YYERROR;
                                }
                                $$.number = $1;
                                $$.name[0] = '\0';
                        }
                        | descriptor '(' NUMBER ')' {
                                $$.type = OCT_NAMEANDNUMBER;
                                if ($3 > UINT32_MAX) {
                                        yyerror("OBJECT IDENTIFIER number "
                                            "too large");
                                        YYERROR;
                                }
                                $$.number = $3;
                                strlcpy($$.name, $1, sizeof($$.name));
                        }
                        ;

type                    : typereference
                        | INTEGER
                        | OBJECT IDENTIFIER
                        | OCTET STRING
                        | Integer32
                        | IpAddress
                        | Counter32
                        | Gauge32
                        | Unsigned32
                        | TimeTicks
                        | Opaque
                        | Counter64
                        | BITS
                        ;

integersubtype          : INTEGER '(' ranges ')'
                        | Integer32 '(' ranges ')'
                        | Unsigned32 '(' ranges ')'
                        | Gauge32 '(' ranges ')'
                        | typereference '(' ranges ')'
                        ;

octetstringsubtype      : OCTET STRING '(' SIZE '(' ranges ')' ')'
                        | Opaque '(' SIZE '(' ranges ')' ')'
                        | typereference '(' SIZE '(' ranges ')' ')'
                        ;

bits                    : BITS '{' namedbits '}'
                        ;

namedbits               : namedbit
                        | namedbits ',' namedbit
                        ;

namedbit                : identifier '(' NUMBER ')'
                        ;

enumeration             : INTEGER '{' namednumbers '}'
                        | typereference '{' namednumbers '}'
                        ;

namednumbers            : namednumber
                        | namednumbers ',' namednumber
                        ;

namednumber             : identifier '(' NUMBER ')'
                        | identifier '(' SIGNEDNUMBER ')'
                        ;

ranges                  : range '|' ranges
                        | range
                        ;

range                   : value
                        | value RANGESEPARATOR value
                        ;

value                   : SIGNEDNUMBER
                        | NUMBER
                        | HSTRING
                        | BSTRING
                        ;

access                  : descriptor {
                                if (strcmp($1, "not-accessible") == 0)
                                        $$ = NOTACCESSIBLE;
                                else if (
                                    strcmp($1, "accessible-for-notify") == 0)
                                        $$ = ACCESSIBLEFORNOTIFY;
                                else if (strcmp($1, "read-only") == 0)
                                        $$ = READONLY;
                                else if (strcmp($1, "read-write") == 0)
                                        $$ = READWRITE;
                                else if (strcmp($1, "read-create") == 0)
                                        $$ = READCREATE;
                                else {
                                        yyerror("invalid access");
                                        YYERROR;
                                }
                        }
                        ;

status                  : descriptor {
                                if (strcmp($1, "current") == 0)
                                        $$ = CURRENT;
                                else if (strcmp($1, "deprecated") == 0)
                                        $$ = DEPRECATED;
                                else if (strcmp($1, "obsolete") == 0)
                                        $$ = OBSOLETE;
                                else {
                                        yyerror("invalid status");
                                        YYERROR;
                                }
                        }
                        ;
%%

void
yyerror(const char *fmt, ...)
{
        va_list          ap;
        char             msg[1024] = "";

        if (file.state == FILE_UNDEFINED) {
                log_debug("%s: not an ASN.1 file: skipping", file.name);
                return;
        }
        if (file.state == FILE_ASN1) {
                if (strcmp(fmt, "syntax error") == 0) {
                        log_debug("%s: not an SMIv2 file: skipping", file.name);
                        return;
                }
        }
        if (fmt != NULL) {
                va_start(ap, fmt);
                vsnprintf(msg, sizeof(msg), fmt, ap);
                va_end(ap);
        }
        log_warnx("%s:%zu: %s", file.name, file.lineno, msg);
}

/*
 * X.208
 */
int
yylex(void)
{
        const struct {
                const char *name;
                int token;
        } keywords[] = {
                /* RFC2578 section 3.7 */
                { "ABSENT",             ABSENT },
                { "ACCESS",             ACCESS },
                { "AGENT-CAPABILITIES", AGENTCAPABILITIES },
                { "ANY",                ANY },
                { "APPLICATION",        APPLICATION },
                { "AUGMENTS",           AUGMENTS },
                { "BEGIN",              BEGIN },
                { "BIT",                BIT },
                { "BITS",               BITS },
                { "BOOLEAN",            BOOLEAN },
                { "BY",                 BY },
                { "CHOICE",             CHOICE },
                { "COMPONENT",          COMPONENT },
                { "COMPONENTS",         COMPONENTS },
                { "CONTACT-INFO",       CONTACTINFO },
                { "CREATION-REQUIRES",  CREATIONREQUIRES },
                { "Counter32",          Counter32 },
                { "Counter64",          Counter64 },
                { "DEFAULT",            DEFAULT },
                { "DEFINED",            DEFINED },
                { "DEFINITIONS",        DEFINITIONS },
                { "DEFVAL",             DEFVAL },
                { "DESCRIPTION",        DESCRIPTION },
                { "DISPLAY-HINT",       DISPLAYHINT },
                { "END",                END },
                { "ENUMERATED",         ENUMERATED },
                { "ENTERPRISE",         ENTERPRISE },
                { "EXPLICIT",           EXPLICIT },
                { "EXPORTS",            EXPORTS },
                { "EXTERNAL",           EXTERNAL },
                { "FALSE",              FALSE },
                { "FROM",               FROM },
                { "GROUP",              GROUP },
                { "Gauge32",            Gauge32 },
                { "IDENTIFIER",         IDENTIFIER },
                { "IMPLICIT",           IMPLICIT },
                { "IMPLIED",            IMPLIED },
                { "IMPORTS",            IMPORTS },
                { "INCLUDES",           INCLUDES },
                { "INDEX",              INDEX },
                { "INTEGER",            INTEGER },
                { "Integer32",          Integer32 },
                { "IpAddress",          IpAddress },
                { "LAST-UPDATED",       LASTUPDATED },
                { "MANDATORY-GROUPS",   MANDATORYGROUPS },
                { "MAX",                MAX },
                { "MAX-ACCESS",         MAXACCESS },
                { "MIN",                MIN },
                { "MIN-ACCESS",         MINACCESS },
                { "MINUS-INFINITY",     MINUSINFINITY },
                { "MODULE",             MODULE },
                { "MODULE-COMPLIANCE",  MODULECOMPLIANCE },
                { "MODULE-IDENTITY",    MODULEIDENTITY },
                { "NOTIFICATION-GROUP", NOTIFICATIONGROUP },
                { "NOTIFICATION-TYPE",  NOTIFICATIONTYPE },
                { "NOTIFICATIONS",      NOTIFICATIONS },
                { "NULL",               ASNNULL },
                { "OBJECT",             OBJECT },
                { "OBJECT-GROUP",       OBJECTGROUP },
                { "OBJECT-IDENTITY",    OBJECTIDENTITY },
                { "OBJECT-TYPE",        OBJECTTYPE },
                { "OBJECTS",            OBJECTS },
                { "OCTET",              OCTET },
                { "OF",                 OF },
                { "OPTIONAL",           OPTIONAL },
                { "ORGANIZATION",       ORGANIZATION },
                { "Opaque",             Opaque },
                { "PLUS-INFINITY",      PLUSINFINITY },
                { "PRESENT",            PRESENT },
                { "PRIVATE",            PRIVATE },
                { "PRODUCT-RELEASE",    PRODUCTRELEASE },
                { "REAL",               REAL },
                { "REFERENCE",          REFERENCE },
                { "REVISION",           REVISION },
                { "SEQUENCE",           SEQUENCE },
                { "SET",                SET },
                { "SIZE",               SIZE },
                { "STATUS",             STATUS },
                { "STRING",             STRING },
                { "SUPPORTS",           SUPPORTS },
                { "SYNTAX",             SYNTAX },
                { "TAGS",               TAGS },
                { "TEXTUAL-CONVENTION", TEXTUALCONVENTION },
                { "TRAP-TYPE",          TRAPTYPE },
                { "TRUE",               TRUE },
                { "TimeTicks",          TimeTicks },
                { "UNITS",              UNITS },
                { "UNIVERSAL",          UNIVERSAL },
                { "Unsigned32",         Unsigned32 },
                { "VARIABLES",          VARIABLES },
                { "VARIATION",          VARIATION },
                { "WITH",               WITH },
                { "WRITE-SYNTAX",       WRITESYNTAX },

                /* ASN.1 */
                { "::=",                PRODUCTION },
                { "..",                 RANGESEPARATOR },

                /* SMIv2 */
                { "SNMPv2-SMI",         SNMPv2SMI },
                { "SNMPv2-CONF",        SNMPv2CONF },
                { "SNMPv2-TC",          SNMPv2TC },

                {}
        };
        char buf[TEXT_MAX];
        size_t i = 0, j;
        int c, comment = 0;
        const char *errstr;
        char *endptr;

        while ((c = fgetc(file.stream)) != EOF) {
                if (i == sizeof(buf)) {
                        yyerror("token too large");
                        return ERROR;
                }
                if (i > 0 && buf[0] == '"') {
                        if (c == '"') {
                                buf[i] = '\0';
                                (void)strlcpy(yylval.string, buf + 1,
                                    sizeof(yylval.string));
                                return TEXT;
                        }
                        if (c == '\n')
                                file.lineno++;
                        buf[i++] = c;
                        continue;
                }
                if (comment) {
                        if (c == '-') {
                                if (++comment == 3)
                                        comment = 0;
                        } else if (c == '\n') {
                                file.lineno++;
                                comment = 0;
                        } else
                                comment = 1;
                        continue;
                }
                if (c == '\n') {
                        if (i != 0) {
                                if (buf[i - 1] == '\r') {
                                        i--;
                                        if (i == 0) {
                                                file.lineno++;
                                                continue;
                                        }
                                }
                                ungetc(c, file.stream);
                                goto token;
                        }
                        file.lineno++;
                        continue;
                }
                if (c == ' ' || c == '\t') {
                        if (i == 0)
                                continue;
                        goto token;
                }
                if (c == '.' || c == ':') {
                        if (i > 0 && buf[0] != '.' && buf[0] != ':') {
                                ungetc(c, file.stream);
                                goto token;
                        }
                }
                if (i > 0 && (buf[0] == '.' || buf[0] == ':')) {
                        if (c != '.' && c != ':' && c != '=') {
                                ungetc(c, file.stream);
                                goto token;
                        }
                }
                if (c == ',' || c == ';' || c == '{' || c == '}' ||
                    c == '(' || c == ')' || c == '[' || c == ']' || c == '|') {
                        if (i == 0)
                                return c;
                        ungetc(c, file.stream);
                        goto token;
                }
                buf[i++] = c;
                if (i >= 2) {
                        if (buf[i - 2] == '-' && buf[i - 1] == '-') {
                                if (i > 2) {
                                        ungetc('-', file.stream);
                                        ungetc('-', file.stream);
                                        i -= 2;
                                        goto token;
                                }
                                comment = 1;
                                i = 0;
                                continue;
                        }
                }
        }

        if (ferror(file.stream)) {
                yyerror(NULL);
                return ERROR;
        }
        if (i == 0)
                return 0;

 token:
        buf[i] = '\0';

        for (i = 0; keywords[i].name != NULL; i++) {
                if (strcmp(keywords[i].name, buf) == 0)
                        return keywords[i].token;
        }

        if (isupper(buf[0])) {
                for (i = 1; buf[i] != '\0'; i++) {
                        if (!isalnum(buf[i]) && buf[i] != '-')
                                break;
                }
                if (buf[i] == '\0' && buf[i - 1] != '-') {
                        strlcpy(yylval.string, buf, sizeof(yylval.string));
                        return typereference;
                }
        }
        if (islower(buf[0])) {
                for (i = 1; buf[i] != '\0'; i++) {
                        if (!isalnum(buf[i]) && buf[i] != '-')
                                break;
                }
                if (buf[i] == '\0'&& buf[i - 1] != '-') {
                        strlcpy(yylval.string, buf, sizeof(yylval.string));
                        return identifier;
                }
        }

        if (buf[0] == '\'') {
                for (i = 1; buf[i] != '\0'; i++)
                        continue;
                if (i < 3 || buf[i - 2] != '\'') {
                        yyerror("incomplete binary or hexadecimal string");
                        return ERROR;
                }
                if (tolower(buf[i - 1]) == 'b') {
                        for (j = 1; j < i - 2; j++) {
                                if (buf[j] != '0' && buf[j] != '1') {
                                        yyerror("invalid character in bstring");
                                        return ERROR;
                                }
                        }
                        strlcpy(yylval.string, buf + 1, sizeof(yylval.string));
                        yylval.string[i - 2] = '\0';
                        return BSTRING;
                } else if (tolower(buf[i - 1]) == 'h') {
                        for (j = 1; j < i - 2; j++) {
                                if (!isxdigit(buf[j])) {
                                        yyerror("invalid character in hstring");
                                        return ERROR;
                                }
                        }
                        strlcpy(yylval.string, buf + 1, sizeof(yylval.string));
                        yylval.string[i - 2] = '\0';
                        return HSTRING;
                }
                yyerror("no valid binary or hexadecimal string");
                return ERROR;
        }
        for (i = 0; buf[i] != '\0'; i++) {
                if (i == 0 && buf[i] == '-')
                        continue;
                if (!isdigit(buf[i]))
                        break;
        }
        if ((i == 1 && isdigit(buf[0])) || i > 1) {
                yylval.signednumber =
                    strtonum(buf, LLONG_MIN, LLONG_MAX, &errstr);
                if (errstr != NULL) {
                        if (errno == ERANGE && isdigit(buf[0])) {
                                errno = 0;
                                yylval.number = strtoull(buf, &endptr, 10);
                                if (errno == 0)
                                        return NUMBER;
                        }
                        yyerror("invalid number: %s: %s", buf, errstr);
                        return ERROR;
                }
                if (buf[0] == '-')
                        return SIGNEDNUMBER;
                yylval.number = yylval.signednumber;
                return NUMBER;
        }

        yyerror("unknown token: %s", buf);
        return ERROR;
}

void
mib_clear(void)
{
        struct module *m;
        struct item *iso;

        while ((m = RB_ROOT(&modulesci)) != NULL)
                mib_modulefree(m);

        /* iso */
        iso = RB_ROOT(&items);
        assert(strcmp(iso->name, "iso") == 0);
        RB_REMOVE(itemsgci, &itemsci, iso);
        RB_REMOVE(items, &items, iso);
        free(iso->oid.bo_id);
        free(iso);
        assert(RB_EMPTY(&modulesci));
        assert(RB_EMPTY(&modulescs));
        assert(RB_EMPTY(&items));
        assert(RB_EMPTY(&itemsci));
}

void
mib_modulefree(struct module *m)
{
        struct item *item;

        if (m == NULL)
                return;

        if (RB_FIND(modulesci, &modulesci, m) == m)
                RB_REMOVE(modulesci, &modulesci, m);
        if (RB_FIND(modulescs, &modulescs, m) == m)
                RB_REMOVE(modulescs, &modulescs, m);
        free(m->imports);

        while ((item = RB_ROOT(&m->itemscs)) != NULL) {
                RB_REMOVE(itemscs, &m->itemscs, item);
                if (RB_FIND(itemsci, &m->itemsci, item) == item)
                        RB_REMOVE(itemsci, &m->itemsci, item);
                if (RB_FIND(items, &items, item) == item)
                        RB_REMOVE(items, &items, item);
                if (RB_FIND(itemsgci, &itemsci, item) == item)
                        RB_REMOVE(itemsgci, &itemsci, item);
                if (!item->resolved)
                        free(item->oid_unresolved);
                else
                        free(item->oid.bo_id);
                free(item);
        }

        free(m);
}

int
mib_imports_add(char *name, char **symbols)
{
        size_t im, ism, isi;
        struct import *import;

        for (im = 0; module->imports != NULL &&
            module->imports[im].name[0] != '\0'; im++) {
                if (strcmp(module->imports[im].name, name) == 0)
                        break;
        }
        if (module->imports == NULL || module->imports[im].name[0] == '\0') {
                if ((import = reallocarray(module->imports, im + 2,
                    sizeof(*module->imports))) == NULL) {
                        yyerror("malloc");
                        return -1;
                }
                module->imports = import;
                strlcpy(module->imports[im].name, name,
                    sizeof(module->imports[im].name));
                module->imports[im].nsymbols = 0;

                module->imports[im + 1].name[0] = '\0';
        }

        import = &module->imports[im];
        for (isi = 0; symbols[isi] != NULL; isi++) {
                for (ism = 0; ism < import->nsymbols; ism++) {
                        if (strcmp(symbols[isi],
                            import->symbols[ism].name) == 0) {
                                yyerror("symbol %s already imported",
                                    symbols[isi]);
                                break;
                        }
                }
                if (ism != import->nsymbols)
                        continue;

                if (import->nsymbols == nitems(import->symbols)) {
                        yyerror("Too many symbols imported");
                        return -1;
                }
                strlcpy(import->symbols[ism].name, symbols[isi],
                    sizeof(import->symbols[ism].name));
                import->symbols[ism].item = NULL;
                import->nsymbols++;
        }
        return 0;
}

int
mib_oid_append(struct oid_unresolved *oid, const struct objidcomponent *subid)
{
        if (oid->bo_n == nitems(oid->bo_id)) {
                yyerror("oid too long");
                return -1;
        }

        switch (oid->bo_id[oid->bo_n].type = subid->type) {
        case OCT_DESCRIPTOR:
                strlcpy(oid->bo_id[oid->bo_n].name, subid->name,
                    sizeof(oid->bo_id[oid->bo_n].name));
                break;
        case OCT_NUMBER:
                oid->bo_id[oid->bo_n].number = subid->number;
                break;
        case OCT_NAMEANDNUMBER:
                oid->bo_id[oid->bo_n].number = subid->number;
                strlcpy(oid->bo_id[oid->bo_n].name, subid->name,
                    sizeof(oid->bo_id[oid->bo_n].name));
        }
        oid->bo_n++;
        return 0;
}

int
mib_oid_concat(struct oid_unresolved *dst, const struct oid_unresolved *src)
{
        size_t i;

        for (i = 0; i < src->bo_n; i++)
                if (mib_oid_append(dst, &src->bo_id[i]) == -1)
                        return -1;
        return 0;
}

struct item *
mib_item(const char *name, enum item_type type)
{
        struct item *item;

        if ((item = calloc(1, sizeof(*item))) == NULL) {
                log_warn("malloc");
                return NULL;
        }

        item->type = type;
        item->resolved = 0;
        item->module = module;
        (void)strlcpy(item->name, name, sizeof(item->name));

        if (RB_INSERT(itemscs, &module->itemscs, item) != NULL) {
                yyerror("duplicate item %s", name);
                free(item);
                return NULL;
        }

        return item;
}

int
mib_item_oid(struct item *item, const struct oid_unresolved *oid)
{
        if ((item->oid_unresolved = calloc(1,
            sizeof(*item->oid_unresolved))) == NULL) {
                yyerror("malloc");
                return -1;
        }

        *item->oid_unresolved = *oid;
        return 0;
}

int
mib_macro(const char *name)
{
        return mib_item(name, IT_MACRO) == NULL ? -1 : 0;
}

struct item *
mib_oid(const char *name, const struct oid_unresolved *oid)
{
        struct item *item;

        if ((item = mib_item(name, IT_OID)) == NULL)
                return NULL;

        if (mib_item_oid(item, oid) == -1)
                return NULL;
        return item;
}

int
mib_applicationsyntax(const char *name)
{
        return mib_item(name, IT_APPLICATIONSYNTAX) == NULL ? -1 : 0;
}

int
mib_moduleidentity(const char *name, time_t lastupdated,
    const char *organization, const char *contactinfo, const char *description,
    const struct oid_unresolved *oid)
{
        struct item *item;

        if ((item = mib_item(name, IT_MODULE_IDENTITY)) == NULL)
                return -1;

        if (mib_item_oid(item, oid) == -1)
                return -1;

        module->lastupdated = lastupdated;
        return 0;
}

int
mib_objectidentity(const char *name, enum status status,
    const char *description, const char *reference,
    const struct oid_unresolved *oid)
{
        struct item *item;

        if ((item = mib_item(name, IT_OBJECT_IDENTITY)) == NULL)
                return -1;

        item->objectidentity.status = status;
        if (mib_item_oid(item, oid) == -1)
                return -1;

        return 0;
}

int
mib_objecttype(const char *name, void *syntax, const char *units,
    enum access maxaccess, enum status status, const char *description,
    const char *reference, void *index, void *defval,
    const struct oid_unresolved *oid)
{
        struct item *item;

        if ((item = mib_item(name, IT_OBJECT_TYPE)) == NULL)
                return -1;

        item->objecttype.maxaccess = maxaccess;
        item->objecttype.status = status;
        if (mib_item_oid(item, oid) == -1)
                return -1;
        return 0;
}

int
mib_notificationtype(const char *name, void *objects, enum status status,
    const char *description, const char *reference,
    const struct oid_unresolved *oid)
{
        struct item *item;

        if ((item = mib_item(name, IT_NOTIFICATION_TYPE)) == NULL)
                return -1;

        item->notificationtype.status = status;
        if (mib_item_oid(item, oid) == -1)
                return -1;
        return 0;
}

int
mib_textualconvetion(const char *name, const char *displayhint,
    enum status status, const char *description, const char *reference,
    void *syntax)
{
        struct item *item;

        if ((item = mib_item(name, IT_TEXTUAL_CONVENTION)) == NULL)
                return -1;
        item->textualconvention.status = status;
        return 0;
}

int
mib_objectgroup(const char *name, void *objects, enum status status,
    const char *description, const char *reference,
    const struct oid_unresolved *oid)
{
        struct item *item;

        if ((item = mib_item(name, IT_OBJECT_GROUP)) == NULL)
                return -1;

        if (mib_item_oid(item, oid) == -1)
                return -1;
        return 0;
}

int
mib_notificationgroup(const char *name, void *notifications, enum status status,
    const char *description, const char *reference,
    const struct oid_unresolved *oid)
{
        struct item *item;

        if ((item = mib_item(name, IT_NOTIFICATION_GROUP)) == NULL)
                return -1;

        if (mib_item_oid(item, oid) == -1)
                return -1;
        return 0;
}

int
mib_modulecompliance(const char *name, enum status status,
    const char *description, const char *reference, void *mods,
    const struct oid_unresolved *oid)
{
        struct item *item;

        if ((item = mib_item(name, IT_MODULE_COMPLIANCE)) == NULL)
                return -1;

        if (mib_item_oid(item, oid) == -1)
                return -1;
        return 0;
}

void
mib_parsefile(const char *path)
{
        mib_defaults();

        log_debug("mib parsing %s", path);
        if ((file.stream = fopen(path, "r")) == NULL) {
                log_warn("fopen");
                return;
        }
        file.lineno = 1;
        file.name = path;
        file.state = FILE_UNDEFINED;

        if (yyparse() != 0) {
                mib_modulefree(module);
                module = NULL;
        }

        fclose(file.stream);
}

void
mib_parsedir(const char *path)
{
        DIR *dir;
        struct dirent *dirent;
        char mibfile[PATH_MAX];

        if ((dir = opendir(path)) == NULL) {
                log_warn("opendir(%s)", path);
                return;
        }

        errno = 0;
        while ((dirent = readdir(dir)) != NULL) {
                if (dirent->d_name[0] == '.')
                        continue;
                if (snprintf(mibfile, sizeof(mibfile), "%s/%s",
                    path, dirent->d_name) >= (int)sizeof(mibfile))
                        continue;
                if (dirent->d_type == DT_DIR) {
                        mib_parsedir(mibfile);
                        continue;
                }
                if (dirent->d_type != DT_REG)
                        continue;
                mib_parsefile(mibfile);
        }

        closedir(dir);
}

struct item *
mib_item_parent(struct ber_oid *oid)
{
        struct item *item, search;

        search.oid.bo_n = oid->bo_n;
        search.oid.bo_id = oid->bo_id;

        while (search.oid.bo_n > 0) {
                if ((item = RB_FIND(items, &items, &search)) != NULL)
                        return item;
                search.oid.bo_n--;
        }
        return NULL;
}

const char *
mib_string2oid(const char *str, struct ber_oid *oid)
{
        char mname[512], *descriptor, *digits;
        struct module *m = NULL, msearch;
        struct item *item = NULL, isearch;
        struct ber_oid oidbuf;
        size_t i;

        oid->bo_n = 0;

        if (isdigit(str[0])) {
                if (ober_string2oid(str, oid) == -1)
                        return "invalid OID";
                return NULL;
        }

        if (strlcpy(mname, str, sizeof(mname)) >= sizeof(mname))
                return "OID name too long";

        if ((descriptor = strchr(mname, ':')) != NULL) {
                descriptor[0] = '\0';
                if (descriptor[1] != ':')
                        return "module and descriptor must be separated by "
                            "double colon";
                descriptor += 2;
                if (strlcpy(msearch.name, mname, sizeof(msearch.name)) >=
                    sizeof(msearch.name))
                        return "module not found";
                if ((m = RB_FIND(modulescs, &modulescs, &msearch)) == NULL) {
                        m = RB_FIND(modulesci, &modulesci, &msearch);
                        if (m == NULL)
                                return "module not found";
                }
        } else
                descriptor = mname;

        if ((digits = strchr(descriptor, '.')) != NULL) {
                digits++[0] = '\0';
                if (ober_string2oid(digits, &oidbuf) == -1)
                        return "invalid OID";
        } else
                oidbuf.bo_n = 0;

        if (strlcpy(isearch.name, descriptor, sizeof(isearch.name)) >=
            sizeof(isearch.name))
                return "descriptor not found";

        if (m != NULL) {
                item = RB_FIND(itemscs, &m->itemscs, &isearch);
                if (item == NULL)
                        item = RB_FIND(itemsci, &m->itemsci, &isearch);
        } else
                item = RB_FIND(itemsgci, &itemsci, &isearch);
        if (item == NULL)
                return "descriptor not found";

        if (item->oid.bo_n + oidbuf.bo_n > nitems(oid->bo_id))
                return "OID too long";

        for (i = 0; i < item->oid.bo_n; i++)
                oid->bo_id[oid->bo_n++] = item->oid.bo_id[i];
        for (i = 0; i < oidbuf.bo_n; i++)
                oid->bo_id[oid->bo_n++] = oidbuf.bo_id[i];

        return NULL;
}

char *
mib_oid2string(struct ber_oid *oid, char *buf, size_t buflen,
    enum mib_oidfmt fmt)
{
        struct item *item;
        char digit[11];
        size_t i = 0;

        buf[0] = '\0';
        if (fmt == MIB_OIDSYMBOLIC && (item = mib_item_parent(oid)) != NULL) {
                snprintf(buf, buflen, "%s::%s", item->module->name,
                    item->name);
                i = item->oid.bo_n;
        }

        for (; i < oid->bo_n; i++) {
                if (i != 0)
                        strlcat(buf, ".", buflen);
                snprintf(digit, sizeof(digit), "%"PRIu32, oid->bo_id[i]);
                strlcat(buf, digit, buflen);
        }

        return buf;
}

void
mib_defaults(void)
{
        struct oid_unresolved oid;
        struct item *iso;

        if (!RB_EMPTY(&modulesci))
                return;

        /* ASN.1 constant, not part of a module */
        if ((iso = calloc(1, sizeof(*iso))) == NULL)
                fatal("malloc");
        iso->type = IT_OID;
        iso->resolved = 1;
        iso->module = NULL;
        strlcpy(iso->name, "iso", sizeof(iso->name));
        if ((iso->oid.bo_id = calloc(1, sizeof(*iso->oid.bo_id))) == NULL)
                fatal("malloc");
        iso->oid.bo_id[0] = 1;
        iso->oid.bo_n = 1;
        RB_INSERT(items, &items, iso);
        RB_INSERT(itemsgci, &itemsci, iso);

        file.state = FILE_SMI2;
        file.lineno = 0;

        if ((module = calloc(1, sizeof(*module))) == NULL)
                fatal("malloc");
        RB_INIT(&module->itemscs);
        RB_INIT(&module->itemsci);
        module->resolved = 0;

        strlcpy(module->name, "SNMPv2-SMI", sizeof(module->name));
        file.name = module->name;
        oid.bo_id[0].type = oid.bo_id[1].type = OCT_NUMBER;
        oid.bo_n = 2;

        oid.bo_id[0].number = 1;
        oid.bo_id[1].number = 3;
        if (mib_oid("org", &oid) == NULL)
                exit(1);

        oid.bo_id[0].number = oid.bo_id[1].number = 0;
        if (mib_oid("zeroDotZero", &oid) == NULL)
                exit(1);

        oid.bo_id[0].type = OCT_DESCRIPTOR;
        strlcpy(oid.bo_id[0].name, "org", sizeof(oid.bo_id[0].name));
        oid.bo_id[1].number = 6;
        if (mib_oid("dod", &oid) == NULL)
                exit(1);

        strlcpy(oid.bo_id[0].name, "dod", sizeof(oid.bo_id[0].name));
        oid.bo_id[1].number = 1;
        if (mib_oid("internet", &oid) == NULL)
                exit(1);

        strlcpy(oid.bo_id[0].name, "internet", sizeof(oid.bo_id[0].name));
        oid.bo_id[1].number = 1;
        if (mib_oid("directory", &oid) == NULL)
                exit(1);

        oid.bo_id[1].number = 2;
        if (mib_oid("mgmt", &oid) == NULL)
                exit(1);

        strlcpy(oid.bo_id[0].name, "mgmt", sizeof(oid.bo_id[0].name));
        oid.bo_id[1].number = 1;
        if (mib_oid("mib-2", &oid) == NULL)
                exit(1);

        strlcpy(oid.bo_id[0].name, "mib-2", sizeof(oid.bo_id[0].name));
        oid.bo_id[1].number = 10;
        if (mib_oid("transmission", &oid) == NULL)
                exit(1);

        strlcpy(oid.bo_id[0].name, "internet", sizeof(oid.bo_id[0].name));
        oid.bo_id[1].number = 3;
        if (mib_oid("experimental", &oid) == NULL)
                exit(1);

        oid.bo_id[1].number = 4;
        if (mib_oid("private", &oid) == NULL)
                exit(1);

        oid.bo_id[1].number = 5;
        if (mib_oid("security", &oid) == NULL)
                exit(1);

        oid.bo_id[1].number = 6;
        if (mib_oid("snmpV2", &oid) == NULL)
                exit(1);

        strlcpy(oid.bo_id[0].name, "private", sizeof(oid.bo_id[0].name));
        oid.bo_id[1].number = 1;
        if (mib_oid("enterprises", &oid) == NULL)
                exit(1);

        strlcpy(oid.bo_id[0].name, "snmpV2", sizeof(oid.bo_id[0].name));
        oid.bo_id[1].number = 1;
        if (mib_oid("snmpDomains", &oid) == NULL)
                exit(1);

        oid.bo_id[1].number = 2;
        if (mib_oid("snmpProxys", &oid) == NULL)
                exit(1);

        oid.bo_id[1].number = 3;
        if (mib_oid("snmpModules", &oid) == NULL)
                exit(1);

        if (mib_macro("MODULE-IDENTITY") == -1 ||
            mib_macro("OBJECT-IDENTITY") == -1 ||
            mib_macro("OBJECT-TYPE") == -1 ||
            mib_macro("NOTIFICATION-TYPE") == -1)
                exit(1);

        if (mib_applicationsyntax("Integer32") == -1 ||
            mib_applicationsyntax("IpAddress") == -1 ||
            mib_applicationsyntax("Counter32") == -1 ||
            mib_applicationsyntax("Gauge32") == -1 ||
            mib_applicationsyntax("Unsigned32") == -1 ||
            mib_applicationsyntax("TimeTicks") == -1 ||
            mib_applicationsyntax("Opaque") == -1 ||
            mib_applicationsyntax("Counter64") == -1)
                exit(1);

        RB_INSERT(modulesci, &modulesci, module);
        RB_INSERT(modulescs, &modulescs, module);

        if ((module = calloc(1, sizeof(*module))) == NULL)
                fatal("malloc");
        RB_INIT(&module->itemscs);
        RB_INIT(&module->itemsci);
        module->resolved = 0;

        strlcpy(module->name, "SNMPv2-TC", sizeof(module->name));
        file.name = module->name;

        if (mib_macro("TEXTUAL-CONVENTION") == -1)
                exit(1);

        if (mib_textualconvetion(
            "DisplayString", "255a", CURRENT, "", NULL, NULL) == -1 ||
            mib_textualconvetion(
            "PhysAddress", "1x:", CURRENT, "", NULL, NULL) == -1 ||
            mib_textualconvetion(
            "MacAddress", "1x:", CURRENT, "", NULL, NULL) == -1 ||
            mib_textualconvetion(
            "TruthValue", NULL, CURRENT, "", NULL, NULL) == -1 ||
            mib_textualconvetion(
            "TestAndIncr", NULL, CURRENT, "", NULL, NULL) == -1 ||
            mib_textualconvetion(
            "AutonomousType", NULL, CURRENT, "", NULL, NULL) == -1 ||
            mib_textualconvetion(
            "InstancePointer", NULL, OBSOLETE, "", NULL, NULL) == -1 ||
            mib_textualconvetion(
            "VariablePointer", NULL, CURRENT, "", NULL, NULL) == -1 ||
            mib_textualconvetion(
            "RowPointer", NULL, CURRENT, "", NULL, NULL) == -1 ||
            mib_textualconvetion(
            "RowStatus", NULL, CURRENT, "", NULL, NULL) == -1 ||
            mib_textualconvetion(
            "TimeStamp", NULL, CURRENT, "", NULL, NULL) == -1 ||
            mib_textualconvetion(
            "TimeInterval", NULL, CURRENT, "", NULL, NULL) == -1 ||
            mib_textualconvetion(
            "DateAndTime", NULL, CURRENT, "", NULL, NULL) == -1 ||
            mib_textualconvetion(
            "StorageType", NULL, CURRENT, "", NULL, NULL) == -1 ||
            mib_textualconvetion(
            "TDomain", NULL, CURRENT, "", NULL, NULL) == -1 ||
            mib_textualconvetion(
            "TAddress", NULL, CURRENT, "", NULL, NULL) == -1)
                exit(1);

        RB_INSERT(modulesci, &modulesci, module);
        RB_INSERT(modulescs, &modulescs, module);

        if ((module = calloc(1, sizeof(*module))) == NULL)
                fatal("malloc");
        RB_INIT(&module->itemscs);
        RB_INIT(&module->itemsci);
        module->resolved = 0;

        strlcpy(module->name, "SNMPv2-CONF", sizeof(module->name));
        file.name = module->name;

        if (mib_macro("OBJECT-GROUP") == -1 ||
            mib_macro("NOTIFICATION-GROUP") == -1 ||
            mib_macro("MODULE-COMPLIANCE") == -1 ||
            mib_macro("AGENT-CAPABILITIES") == -1)
                exit(1);

        RB_INSERT(modulesci, &modulesci, module);
        RB_INSERT(modulescs, &modulescs, module);

        module = NULL;
}

/*
 * Used only for resolving phase
 */
struct item *
mib_item_find(struct item *orig, const char *name)
{
        struct module *m = orig->module;
        struct item *item, search;
        struct import *import;
        size_t i, j;

        strlcpy(search.name, name, sizeof(search.name));
        if ((item = RB_FIND(itemscs, &m->itemscs, &search)) != NULL) {
                if (mib_resolve_item(item) == -1)
                        return NULL;
                return item;
        }

        for (i = 0; m->imports != NULL && m->imports[i].name[0] != '\0'; i++) {
                import = &m->imports[i];
                for (j = 0; j < import->nsymbols; j++) {
                        if (strcmp(name, import->symbols[j].name) == 0)
                                return import->symbols[j].item;
                }
        }

        log_warnx("%s::%s: item %s not found: disabling",
            m->name, orig->name, name);

        return NULL;
}

int
mib_resolve_oid(struct oid_resolved *dst, struct oid_unresolved *src,
    struct item *item)
{
        struct module *m = item->module;
        struct item *reference, search;
        struct ber_oid oid;
        size_t i, j, bo_n;

        oid.bo_n = 0;
        for (i = 0; i < src->bo_n; i++) {
                switch (src->bo_id[i].type) {
                case OCT_DESCRIPTOR:
                        if ((reference = mib_item_find(item,
                            src->bo_id[i].name)) == NULL)
                                return -1;
                        for (j = 0; j < reference->oid.bo_n; j++)
                                oid.bo_id[oid.bo_n++] =
                                    reference->oid.bo_id[j];
                        break;
                case OCT_NUMBER:
                        if (oid.bo_n == nitems(oid.bo_id)) {
                                log_warnx("%s::%s: OID too long: disabling",
                                    m->name, item->name);
                                return -1;
                        }
                        oid.bo_id[oid.bo_n++] = src->bo_id[i].number;
                        break;
                case OCT_NAMEANDNUMBER:
                        if (oid.bo_n == nitems(oid.bo_id)) {
                                log_warnx("%s::%s: OID too long: disabling",
                                    m->name, item->name);
                                return -1;
                        }
                        oid.bo_id[oid.bo_n++] = src->bo_id[i].number;
                        if (i == src->bo_n - 1) {
                                if (strcmp(src->bo_id[i].name, item->name) != 0) {
                                        log_warnx("%s::%s: last OBJECT "
                                            "IDENTIFIER component name doesn't "
                                            "match item: disabling", m->name,
                                            item->name);
                                        return -1;
                                }
                                break;
                        }
                        strlcpy(search.name, src->bo_id[i].name,
                            sizeof(search.name));
                        reference = RB_FIND(itemscs, &m->itemscs, &search);
                        if (reference != NULL) {
                                search.oid.bo_n = oid.bo_n;
                                search.oid.bo_id = oid.bo_id;
                                if (item_cmp_oid(reference, &search) != 0) {
                                        log_warnx("%s::%s: two different OIDs "
                                            "for same descriptor: disabling",
                                            m->name, item->name);
                                        return -1;
                                }
                                break;
                        }

                        bo_n = src->bo_n;
                        src->bo_n = i + 1;
                        module = m;
                        reference = mib_oid(src->bo_id[i].name, src);
                        module = NULL;
                        if (reference == NULL)
                                return -1;
                        if (mib_resolve_item(reference) == -1)
                                return -1;
                        src->bo_n = bo_n;
                        break;
                }
        }

        dst->bo_n = oid.bo_n;
        if ((dst->bo_id = calloc(dst->bo_n, sizeof(*dst->bo_id))) == NULL) {
                log_warn("malloc");
                return -1;
        }
        for (i = 0; i < oid.bo_n; i++)
                dst->bo_id[i] = oid.bo_id[i];

        return 0;
}

/*
 * No recursion protection. Assume MIBs do the right thing
 */
int
mib_resolve_item(struct item *item)
{
        struct item *prev;
        struct oid_resolved oid;

        if (item->resolved)
                return 0;

        item->resolved = 1;

        if (item->type == IT_MACRO ||
            item->type == IT_APPLICATIONSYNTAX ||
            item->type == IT_TEXTUAL_CONVENTION)
                return 0;

        if (mib_resolve_oid(&oid, item->oid_unresolved, item) == -1)
                return -1;
        free(item->oid_unresolved);
        item->oid = oid;

        if ((prev = RB_INSERT(items, &items, item)) != NULL) {
                /* Prioritize an OID derived from a MACRO over a plain OID */
                if (prev->type == IT_OID && item->type != IT_OID) {
                        RB_REMOVE(items, &items, prev);
                        RB_INSERT(items, &items, item);
                }
        }
        RB_INSERT(itemsgci, &itemsci, item);
        RB_INSERT(itemsci, &item->module->itemsci, item);

        return 0;
}

int
mib_resolve_module(struct module *m)
{
        struct module msearch;
        struct import *import;
        struct import_symbol *symbol;
        struct item *item, isearch;
        size_t i, j;

        if (m->resolved)
                return 0;

        m->resolved = 1;

        for (i = 0; m->imports != NULL && m->imports[i].name[0] != '\0'; i++) {
                import = &m->imports[i];
                strlcpy(msearch.name, import->name, sizeof(msearch.name));
                import->module = RB_FIND(modulescs, &modulescs, &msearch);
                if (import->module == NULL ||
                    mib_resolve_module(import->module) == -1) {
                        log_warnx("%s: import %s not found: disabling",
                            m->name, import->name);
                        goto fail;
                }

                for (j = 0; j < import->nsymbols; j++) {
                        symbol = &import->symbols[j];
                        strlcpy(isearch.name, symbol->name,
                            sizeof(isearch.name));
                        symbol->item = RB_FIND(itemscs,
                            &import->module->itemscs, &isearch);
                        if (symbol->item == NULL) {
                                log_warnx("%s: symbol %s not found in %s: "
                                    "disabling", m->name, symbol->name,
                                    import->name);
                                goto fail;
                        }
                }
        }

        RB_FOREACH(item, itemscs, &m->itemscs) {
                if (mib_resolve_item(item) == -1)
                        goto fail;
        }

        free(m->imports);
        m->imports = NULL;

        return 0;
 fail:
        mib_modulefree(m);
        return -1;
}

void
mib_resolve(void)
{
        struct module *m;

        mib_defaults();
 next:
        RB_FOREACH(m, modulescs, &modulescs) {
                if (mib_resolve_module(m) == -1) {
                        /*
                         * mib_resolve_module can recurse and remove,
                         * for which RB_FOEACH_SAFE doesn't protect.
                         */
                        goto next;
                }
        }
}

int
module_cmp_cs(struct module *m1, struct module *m2)
{
        return strcmp(m1->name, m2->name);
}

int
module_cmp_ci(struct module *m1, struct module *m2)
{
        return strcasecmp(m1->name, m2->name);
}

int
item_cmp_cs(struct item *d1, struct item *d2)
{
        return strcmp(d1->name, d2->name);
}

int
item_cmp_ci(struct item *d1, struct item *d2)
{
        return strcasecmp(d1->name, d2->name);
}

int
item_cmp_oid(struct item *i1, struct item *i2)
{
        size_t   i, min;

        min = i1->oid.bo_n < i2->oid.bo_n ? i1->oid.bo_n : i2->oid.bo_n;
        for (i = 0; i < min; i++) {
                if (i1->oid.bo_id[i] < i2->oid.bo_id[i])
                        return (-1);
                if (i1->oid.bo_id[i] > i2->oid.bo_id[i])
                        return (1);
        }
        /* i1 is parent of i2 */
        if (i1->oid.bo_n < i2->oid.bo_n)
                return (-2);
        /* i1 is child of i2 */
        if (i1->oid.bo_n > i2->oid.bo_n)
                return 2;
        return (0);
}

RB_GENERATE_STATIC(modulesci, module, entryci, module_cmp_ci);
RB_GENERATE_STATIC(modulescs, module, entrycs, module_cmp_cs);
RB_GENERATE_STATIC(itemsgci, item, entrygci, item_cmp_ci);
RB_GENERATE_STATIC(itemsci, item, entryci, item_cmp_ci);
RB_GENERATE_STATIC(itemscs, item, entrycs, item_cmp_cs);
RB_GENERATE_STATIC(items, item, entry, item_cmp_oid);