Blob Blame History Raw
 * 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 <stdio.h>

#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
					   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 */