/* * data.h -- * * Definitions for the main data structures. * * Copyright (c) 1999 Frank Strauss, Technical University of Braunschweig. * * See the file "COPYING" for information on usage and redistribution * of this file, and for a DISCLAIMER OF ALL WARRANTIES. * * @(#) $Id: data.h 7966 2008-03-27 21:25:52Z schoenw $ */ #ifndef _DATA_H #define _DATA_H #include #include "smi.h" typedef struct List { SmiElement export; void *ptr; struct List *nextPtr; } List; typedef enum Kind { KIND_UNKNOWN = 0 , /* */ KIND_MODULE = 1 , /* */ KIND_MACRO = 2 , /* */ KIND_TYPE = 3 , /* */ KIND_OBJECT = 4 , /* */ KIND_IMPORT = 5 , /* descriptors to be imported. */ KIND_IMPORTED = 6 , /* imported descriptor. syntax `mod.descr'. */ KIND_NOTFOUND = 7 /* to be imported, but not found */ } Kind; #define NUM_KINDS 7 typedef unsigned short ParserFlags; typedef unsigned short ModuleFlags; typedef unsigned short ImportFlags; typedef unsigned short ObjectFlags; typedef unsigned short NodeFlags; typedef unsigned short TypeFlags; typedef unsigned short MacroFlags; #define NODE_FLAG_ROOT 0x0001 /* mark node tree's root */ #define FLAG_SEQTYPE 0x0002 /* type is set from SMIv1/2 SEQUENCE. */ #define FLAG_REGISTERED 0x0004 /* On an Object: this is registered. */ #define FLAG_INCOMPLETE 0x0008 /* Just defined by a forward */ /* referenced type or object. */ #define FLAG_CREATABLE 0x0040 /* On a Row: New rows can be created. */ #define FLAG_INGROUP 0x0080 /* Node is contained in a group. */ #define FLAG_INCOMPLIANCE 0x0100 /* Group is mentioned in a compliance statement. In case of ImportFlags: the import is done through a compliance MODULE phrase. */ #define FLAG_INSYNTAX 0x0200 /* Type is mentioned in a syntax statement. */ typedef struct View { char *name; struct View *nextPtr; struct View *prevPtr; } View; typedef struct Module { SmiModule export; time_t lastUpdated; /* only for SMIv2 modules */ struct Object *objectPtr; struct Object *firstObjectPtr; struct Object *lastObjectPtr; struct Type *firstTypePtr; struct Type *lastTypePtr; struct Class *firstClassPtr; struct Class *lastClassPtr; struct Macro *firstMacroPtr; struct Macro *lastMacroPtr; struct Identity *firstIdentityPtr; struct Identity *lastIdentityPtr; struct Import *firstImportPtr; struct Import *lastImportPtr; struct Revision *firstRevisionPtr; struct Revision *lastRevisionPtr; ModuleFlags flags; int numImportedIdentifiers; int numStatements; int numModuleIdentities; struct Module *nextPtr; struct Module *prevPtr; struct Node *prefixNodePtr; } Module; typedef struct Revision { SmiRevision export; Module *modulePtr; struct Revision *nextPtr; struct Revision *prevPtr; int line; } Revision; typedef struct Import { SmiImport export; Module *modulePtr; ImportFlags flags; struct Import *nextPtr; struct Import *prevPtr; Kind kind; int use; int line; } Import; typedef struct NamedNumber { SmiNamedNumber export; struct Type *typePtr; } NamedNumber; typedef struct Range { SmiRange export; struct Type *typePtr; } Range; typedef struct Type { SmiType export; Module *modulePtr; struct Type *parentPtr; struct List *listPtr; TypeFlags flags; struct Type *nextPtr; struct Type *prevPtr; int line; } Type; typedef struct Option { SmiOption export; struct Object *compliancePtr; struct Object *objectPtr; int line; } Option; typedef struct Refinement { SmiRefinement export; struct Object *compliancePtr; /* the compl. Object this Ref belongs to */ struct Object *objectPtr; /* the Object refined by this Refinement */ Type *typePtr; /* the refined Type (or NULL) */ Type *writetypePtr; /* the refined WriteType (or NULL) */ int line; } Refinement; typedef struct Compl { List *mandatorylistPtr; List *optionlistPtr; List *refinementlistPtr; } Compl; typedef struct Index { int implied; SmiIndexkind indexkind; struct List *listPtr; /* list of index columns (Object *) */ struct Object *rowPtr; /* a referenced row (e.g. SMIv2 AUGMENTS) */ } Index; typedef struct SubjectCategories { struct List *categories; int allCategories; } SubjectCategories; typedef struct Object { SmiNode export; Module *modulePtr; ObjectFlags flags; Type *typePtr; struct Object *relatedPtr; /* a related Object (augmented row) */ struct List *listPtr; /* OG, NT, NG, MC */ struct List *optionlistPtr; struct List *refinementlistPtr; struct Node *nodePtr; struct Object *prevPtr; /* chain of Objects in this Module */ struct Object *nextPtr; struct Object *prevSameNodePtr; /* chain of Objects for this Node */ struct Object *nextSameNodePtr; struct List *uniquenessPtr; /* UNIQUENESS */ int line; } Object; typedef struct Node { SmiSubid subid; NodeFlags flags; int oidlen; SmiSubid *oid; struct Node *parentPtr; struct Node *nextPtr; struct Node *prevPtr; struct Node *firstChildPtr; struct Node *lastChildPtr; Object *firstObjectPtr; Object *lastObjectPtr; } Node; typedef struct Macro { SmiMacro export; Module *modulePtr; MacroFlags flags; struct Macro *nextPtr; struct Macro *prevPtr; int line; } Macro; typedef struct Identity { SmiIdentity export; Module *modulePtr; struct Identity *parentPtr; struct Identity *nextPtr; struct Identity *prevPtr; int line; } Identity; typedef struct Class { SmiClass export; Module *modulePtr; struct Attribute *firstAttributePtr; struct Attribute *lastAttributePtr; struct List *uniqueList; struct Event *firstEventPtr; struct Event *lastEventPtr; struct Class *parentPtr; struct Class *nextPtr; struct Class *prevPtr; int line; } Class; /*NOTE: if first element of uniqueList points to current class that is class->uniqueList-> = class; the class is scalar. If uniqueList = NULL; it is not meant to be instatiated directly. Otherwise it contains list of pointers to the class unique attributes. */ typedef struct Attribute { SmiAttribute export; Class *classPtr; struct Type *parentTypePtr; struct List *listPtr; struct Attribute *nextPtr; struct Attribute *prevPtr; int line; struct Class *parentClassPtr; } Attribute; typedef struct Event { SmiEvent export; Class *classPtr; struct Event *nextPtr; struct Event *prevPtr; int line; } Event; typedef struct Parser { char *path; FILE *file; int line; int lcline; /* for SMI comment warning */ Module *modulePtr; ParserFlags flags; List *firstIndexlabelPtr; /* only for the SMIng parser */ char *identityObjectName; /* only for the SMIng parser */ Module *complianceModulePtr; Module *capabilitiesModulePtr; Node *parentNodePtr; int currentDecl; int firstStatementLine; int firstNestedStatementLine; int firstRevisionLine; Node *pendingNodePtr; } Parser; typedef struct Handle { char *name; struct Handle *prevPtr; struct Handle *nextPtr; View *firstViewPtr; View *lastViewPtr; Module *firstModulePtr; Module *lastModulePtr; Node *rootNodePtr; Type *typeOctetStringPtr; Type *typeObjectIdentifierPtr; Type *typeInteger32Ptr; Type *typeUnsigned32Ptr; Type *typeInteger64Ptr; Type *typeUnsigned64Ptr; Type *typeFloat32Ptr; Type *typeFloat64Ptr; Type *typeFloat128Ptr; Type *typeEnumPtr; Type *typeBitsPtr; Type *typePointerPtr; int flags; char *path; char *cache; char *cacheProg; int errorLevel; SmiErrorHandler *errorHandler; Parser *parserPtr; } Handle; extern int smiDepth; /* SMI parser recursion depth */ extern Handle *smiHandle; /* The current handle */ extern Handle *addHandle(const char *name); extern void removeHandle(Handle *handlePtr); extern Handle *findHandleByName(const char *name); extern View *addView(const char *modulename); extern int isInView(const char *modulename); extern Module *addModule(char *modulename, char *path, ModuleFlags flags, Parser *parserPtr); extern void setModuleIdentityObject(Module *modulePtr, Object *objectPtr); extern void setModuleLastUpdated(Module *modulePtr, time_t lastUpdated); extern void setModuleOrganization(Module *modulePtr, char *organization); extern void setModuleContactInfo(Module *modulePtr, char *contactinfo); extern void setModuleDescription(Module *modulePtr, char *description, Parser *parserPtr); extern void setModuleReference(Module *modulePtr, char *reference, Parser *parserPtr); extern Module *findModuleByName(const char *modulename); extern Revision *addRevision(time_t date, char *description, Parser *parserPtr); extern void setRevisionLine(Revision *revisionPtr, int line, Parser *parserPtr); extern Import *addImport(char *name, Parser *parserPtr); extern void addImportFlags(Import *importPtr, ImportFlags flags); extern void setImportModulename(Import *importPtr, char *modulename); extern int checkImports(Module *modulePtr, Parser *parserPtr); extern Import *findImportByName(const char *name, Module *modulePtr); extern Import *findImportByModulenameAndName(const char *modulename, const char *name, Module *modulePtr); extern Object *addObject(char *objectname, Node *parentNodePtr, SmiSubid subid, ObjectFlags flags, Parser *parserPtr); extern Object *duplicateObject(Object *templatePtr, ObjectFlags flags, Parser *parserPtr); extern Node *addNode(Node *parentNodePtr, SmiSubid subid, NodeFlags flags, Parser *parserPtr); extern Node *createNodes(unsigned int oidlen, SmiSubid *oid); extern Node *createNodesByOidString(const char *oid); extern Node *getParentNode(Node *nodePtr); /* * setObjectName() might relink MIB tree object structures. If the * current objectPtr is to be used after the call, it should look like * objectPtr = setObjectName(objectPtr, name); */ extern Object *setObjectName(Object *objectPtr, char *name, Parser *parserPtr); extern void setObjectType(Object *objectPtr, Type *typePtr); extern void setObjectAccess(Object *objectPtr, SmiAccess access); extern void setObjectStatus(Object *objectPtr, SmiStatus status); extern void setObjectDescription(Object *objectPtr, char *description, Parser *parserPtr); extern void setObjectReference(Object *objectPtr, char *reference, Parser *parserPtr); extern void setObjectDecl(Object *objectPtr, SmiDecl decl); extern void setObjectUniqueness(Object *objectPtr, List *listPtr); extern void setObjectInstallErrors(Object *objectPtr, List *listPtr); extern void setObjectLine(Object *objectPtr, int line, Parser *parserPtr); extern void setObjectNodekind(Object *objectPtr, SmiNodekind nodekind); extern void addObjectFlags(Object *objectPtr, ObjectFlags flags); extern void deleteObjectFlags(Object *objectPtr, ObjectFlags flags); extern int checkObjectFlags(Object *objectPtr, ObjectFlags flags); extern void setObjectList(Object *objectPtr, struct List *listPtr); extern void setObjectRelated(Object *objectPtr, Object *relatedPtr); extern void setObjectImplied(Object *objectPtr, int implied); extern void setObjectCreate(Object *objectPtr, int create); extern void setObjectIndexkind(Object *objectPtr, SmiIndexkind indexkind); extern void setObjectIndex(Object *objectPtr, Index *indexPtr); extern void setObjectFormat(Object *objectPtr, char *format); extern void setObjectUnits(Object *objectPtr, char *units); extern void setObjectValue(Object *objectPtr, SmiValue *valuePtr); extern Node *findNodeByParentAndSubid(Node *parentNodePtr, SmiSubid subid); extern Node *findNodeByOid(unsigned int oidlen, SmiSubid *oid); extern Node *findNodeByOidString(char *oid); extern Object *findObjectByNode(Node *nodePtr); extern Object *findObjectByModuleAndNode(Module *modulePtr, Node *nodePtr); extern Object *findObjectByModulenameAndNode(const char *modulename, Node *nodePtr); extern Object *findObjectByName(const char *objectname); extern Object *findNextObjectByName(const char *objectname, Object *prevObjectPtr); extern Object *findObjectByModuleAndName(Module *modulePtr, const char *objectname); extern Object *findObjectByModulenameAndName(const char *modulename, const char *objectname); extern Type *addType(char *type_name, SmiBasetype basetype, TypeFlags flags, Parser *parserPtr); extern Type *duplicateType(Type *templatePtr, TypeFlags flags, Parser *parserPtr); extern Type *setTypeName(Type *typePtr, char *name); extern void setTypeStatus(Type *typePtr, SmiStatus status); extern void setTypeBasetype(Type *typePtr, SmiBasetype basetype); extern void setTypeParent(Type *typePtr, Type *parentPtr); extern void setTypeList(Type *typePtr, struct List *listPtr); extern void setTypeDescription(Type *typePtr, char *description, Parser *parserPtr); extern void setTypeReference(Type *typePtr, char *reference, Parser *parserPtr); extern void setTypeDecl(Type *typePtr, SmiDecl decl); extern void setTypeLine(Type *typePtr, int line, Parser *parserPtr); extern void addTypeFlags(Type *typePtr, TypeFlags flags); extern void deleteTypeFlags(Type *typePtr, TypeFlags flags); extern void setTypeFormat(Type *typePtr, char *format); extern void setTypeUnits(Type *typePtr, char *units); extern void setTypeValue(Type *typePtr, SmiValue *valuePtr); extern Type *findTypeByName(const char *type_name); extern Type *findNextTypeByName(const char *type_name, Type *prevTypePtr); extern Type *findTypeByModuleAndName(Module *modulePtr, const char *type_name); extern Type *findTypeByModulenameAndName(const char *modulename, const char *type_name); extern NamedNumber *findTypeNamedNumber(Type *typePtr, SmiInteger32 number); extern Identity *addIdentity(char *identityname, Parser *parserPtr); extern void setIdentityDecl(Identity *identityPtr, SmiDecl decl); extern void setIdentityStatus(Identity *identityPtr, SmiStatus status); extern void setIdentityDescription(Identity *identityPtr, char *description, Parser *parserPtr); extern void setIdentityReference(Identity *identityPtr, char *reference, Parser *parserPtr); extern void setIdentityParent(Identity *identityPtr, Identity *parentPtr); extern Identity *findIdentityByName(const char *identityname); extern Identity *findIdentityByModuleAndName(Module *modulePtr, const char *identityname); extern Identity *findIdentityByModulenameAndName(const char *modulename, const char *identity_name); extern Class *addClass(char *classname, Parser *parserPtr); extern void setClassDecl(Class *classPtr, SmiDecl decl); extern void setClassStatus(Class *classPtr, SmiStatus status); extern void setClassDescription(Class *classPtr, char *description, Parser *parserPtr); extern void setClassReference(Class *classPtr, char *reference, Parser *parserPtr); extern Class *findClassByModuleAndName(Module *modulePtr, char *name); extern Class *findClassByModulenameAndName(const char *modulename, const char *class_name); extern Attribute *duplicateTypeToAttribute(Type *templatePtr, Class *classPtr, Parser *parserPtr); extern Attribute *addAttribute(char *attribute_name, Class *classPtr, Parser *parserPtr); extern void setAttributeName(Attribute *attributePtr, char *name); extern void setAttributeDecl(Attribute *attributePtr, SmiDecl decl); extern void setAttributeStatus(Attribute *attributePtr, SmiStatus status); extern void setAttributeDescription(Attribute *attributePtr, char *description); extern void setAttributeReference(Attribute *attributePtr, char *reference); extern void setAttributeAccess(Attribute *attributePtr,SmiAccess access); extern void setAttributeParentType(Attribute *attributePtr, Type *parentPtr); extern void setAttributeParentClass(Attribute *attributePtr, Class *parentPtr); extern void setAttributeList(Attribute *attributePtr, List *listPtr); extern Event *addEvent(char *eventname, Class *classPtr, Parser *parserPtr); extern Macro *addMacro(char *macroname, MacroFlags flags, Parser *parserPtr); extern void setMacroStatus(Macro *macroPtr, SmiStatus status); extern void setMacroDescription(Macro *macroPtr, char *description, Parser *parserPtr); extern void setMacroReference(Macro *macroPtr, char *reference, Parser *parserPtr); extern void setMacroDecl(Macro *macroPtr, SmiDecl decl); extern void setMacroAbnf(Macro *macroPtr, char *abnf, Parser *parserPtr); extern void setMacroLine(Macro *macroPtr, int line, Parser *parserPtr); extern Macro *findMacroByName(const char *macroname); extern Macro *findMacroByModuleAndName(Module *modulePtr, const char *macroname); extern Macro *findMacroByModulenameAndName(const char *modulename, const char *macroname); extern NamedNumber *findNamedNumberByName(Type *typePtr, const char *name); extern int smiInitData(void); extern void smiFreeData(void); extern Module *loadModule(const char *modulename, Parser *parserPtr); #endif /* _DATA_H */