Man Linux: Main Page and Category List

NAME

       smiGetNode,     smiGetNodeByOID,    smiGetFirstNode,    smiGetNextNode,
       smiGetParentNode,       smiGetRelatedNode,        smiGetFirstChildNode,
       smiGetNextChildNode,  smiGetNodeModule, smiGetNodeType, smiGetNodeLine,
       smiGetFirstElement,        smiGetNextElement,        smiGetElementNode,
       smiGetFirstOption,          smiGetNextOption,         smiGetOptionNode,
       smiGetFirstRefinement,  smiGetNextRefinement,   smiGetRefinementModule,
       smiGetRefinementNode, smiGetRefinementType, smiGetRefinementWriteType -
       SMI type information routines

SYNOPSIS

       #include <smi.h>

       SmiNode *smiGetNode(SmiModule *smiModulePtr, char *node);

       SmiNode *smiGetNodeByOID(unsigned int oidlen, SmiSubid oid[]);

       SmiNode *smiGetFirstNode(SmiModule *smiModulePtr, SmiNodekind kinds);

       SmiNode *smiGetNextNode(SmiNode *smiNodePtr, SmiNodekind kinds);

       SmiNode *smiGetParentNode(SmiNode *smiNodePtr);

       SmiNode *smiGetRelatedNode(SmiNode *smiNodePtr);

       SmiNode *smiGetFirstChildNode(SmiNode *smiNodePtr);

       SmiNode *smiGetNextChildNode(SmiNode *smiNodePtr);

       SmiModule *smiGetNodeModule(SmiNode *smiNodePtr);

       SmiType *smiGetNodeType(SmiNode *smiNodePtr);

       int smiGetNodeLine(SmiNode *smiNodePtr);

       SmiElement *smiGetFirstElement(SmiNode *smiNodePtr);

       SmiElement *smiGetNextElement(SmiElement *smiElementPtr);

       SmiNode *smiGetElementNode(SmiElement *smiElementPtr);

       SmiOption *smiGetFirstOption(SmiNode *smiComplianceNodePtr);

       SmiOption *smiGetNextOption(SmiOption *smiOptionPtr);

       SmiNode *smiGetOptionNode(SmiOption *smiOptionPtr);

       SmiRefinement *smiGetFirstRefinement(SmiNode *smiComplianceNodePtr);

       SmiRefinement *smiGetNextRefinement(SmiRefinement *smiRefinementPtr);

       SmiNode *smiGetRefinementNode(SmiRefinement *smiRefinementPtr);

       SmiType *smiGetRefinementType(SmiRefinement *smiRefinementPtr);

       SmiType *smiGetRefinementWriteType(SmiRefinement *smiRefinementPtr);

       typedef struct SmiNode {
           SmiIdentifier       name;
           int                 oidlen;
           SmiSubid            *oid;         /* array of length oidlen */
           SmiDecl             decl;
           SmiAccess           access;
           SmiStatus           status;
           char                *format;
           SmiValue            value;
           char                *units;
           char                *description;
           char                *reference;
           SmiIndexkind        indexkind;
           int                 implied;
           int                 create;
           SmiNodekind         nodekind;
       } SmiNode;

       typedef struct SmiElement {
           /* no visible attributes */
       } SmiElement;

       typedef struct SmiOption {
           char                *description;
       } SmiOption;

       typedef struct SmiRefinement {
           SmiAccess           access;
           char                *description;
       } SmiRefinement;

DESCRIPTION

       These functions retrieve information on any SMI node definition in  the
       object  identifier tree, these are ASN.1 object identifier assignments,
       MODULE-IDENTITYs, OBJECT-IDENTITYs,  OBJECT-TYPEs,  NOTIFICATION-TYPEs,
       TRAP-TYPEs, OBJECT-GROUPs, NOTIFICATION-GROUPs, MODULE-COMPLIANCEs, and
       AGENT-CAPABILITYs in SMIv1/v2 and node,  scalar,  table,  row,  column,
       notification, group, and compliance statements in SMIng.

       The  smiGetNode() function retrieves a struct SmiNode that represents a
       node of any kind. Node may be either a fully  qualified  descriptor,  a
       simple  node  name,  or a numerical OID.  Nodes are also found, if node
       contains an instance identifier suffix.  If smiModulePtr is not NULL it
       used to limit the search to the given module. If the node is not found,
       smiGetNode() returns NULL.

       The smiGetNodeByOID() function retrieves a struct SmiNode that  matches
       the  longest  prefix  of  the  node  that  is  specified  by the object
       identifier oid[] with the length oidlen.  If no such node is not found,
       smiGetNodeByOID() returns NULL.

       The  smiGetFirstNode()  and  smiGetNextNode()  functions  are  used  to
       iteratively   retrieve   struct    SmiNodes    in    tree    pre-order.
       smiGetFirstNode()   returns  the  first  node  defined  in  the  module
       specified by smiModulePtr that is of any kind specified  in  the  kinds
       bitset.   Subsequent  calls to smiGetNextNode() return the next node of
       any kind specified in the kinds bitset.  If  there  are  no  more  node
       definitions in the module, NULL is returned.

       The smiGetFirstChildNode() and smiGetNextChildNode() functions are used
       to iteratively retrieve struct SmiNodes that  represent  the  immediate
       child  nodes  of  the  node  specified  by  smiNodePtr  passed  to  the
       smiGetFirstChildNode() call.

       The smiGetParentNode() function is used to retrieve a  struct  SmiNodes
       that represents the parent node of the node specified by smiNodePtr.

       The  smiGetRelatedNode() function is used to retrieve a struct SmiNodes
       that is related to the node specified by smiNodePtr. Actually, this  is
       used for SMIv2 table augmentation entries and similar SMIng constructs.

       The smiGetNodeModule() function returns the  module  that  defines  the
       node given by struct SmiNodePtr.

       The  smiGetNodeType()  function  returns  the  type  of  the (scalar or
       columnar) node given by struct SmiNodePtr.  If struct  SmiNodePtr  does
       not specify a scalar or columnar node, NULL is returned.

       The  smiGetFirstElement() and smiGetNextElement() functions are used to
       iteratively retrieve struct  SmiElements  that  represent  elements  of
       index  clauses  or notification object lists, groups of object types or
       notification  types,  and  mandatory  groups   of   module   compliance
       statements.  The  node to which the list belongs has to be specified by
       smiNodePtr. To retrieve the  node  that  is  represented  by  a  struct
       SmiElement, the smiGetElementNode() function has to be called.

       The  smiGetFirstOption()  and  smiGetNextOption() functions are used to
       iteratively retrieve struct SmiOptions  that  represent  statements  on
       optional   (object   or  notification)  groups  within  the  compliance
       statement specified by smiComplianceNodePtr. The group  node  which  is
       subject  of such a statement can be retrieved by the smiGetOptionNode()
       function.

       Similarly,  the  smiGetFirstRefinement()   and   smiGetNextRefinement()
       functions  are  used to iteratively retrieve struct SmiRefinements that
       represent  statements  on  optional  object  refinements   within   the
       compliance  statement specified by smiComplianceNodePtr. The node which
       is  subject  of  such  a   refinement   can   be   retrieved   by   the
       smiGetRefinementNode()  function.  The optional refined type and write-
       type of a refinement can be retrieved by the smiGetRefinementType() and
       smiGetRefinementWriteType() functions. If they are not present, NULL is
       returned.

       The smiGetNodeLine() function returns the line number within the module
       where the node specified by smiNodePtr is defined.

FILES

       ${prefix}/include/smi.h    SMI library header file

SEE ALSO

       libsmi(3), smi_config(3), smi_type(3), smi_module(3), smi.h

AUTHOR

       (C)    1999-2004    Frank    Strauss,    TU    Braunschweig,    Germany
       <strauss@ibr.cs.tu-bs.de>