Return to llib-lisnmp CVS log

Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / snmp

Annotation of 43BSDReno/contrib/isode-beta/snmp/llib-lisnmp, revision 1.1

1.1     ! root        1: /* llib-lisnmp - lint library for -lisnmp */
        !             2: 
        !             3: /* 
        !             4:  * $Header: /f/osi/snmp/RCS/llib-lisnmp,v 7.2 90/03/08 08:05:41 mrose Exp $
        !             5:  *
        !             6:  *
        !             7:  * $Log:       llib-lisnmp,v $
        !             8:  * Revision 7.2  90/03/08  08:05:41  mrose
        !             9:  * isnmp
        !            10:  * 
        !            11:  * Revision 7.1  90/02/19  16:25:54  mrose
        !            12:  * typo
        !            13:  * 
        !            14:  * Revision 7.0  90/02/19  15:53:14  mrose
        !            15:  * *** empty log message ***
        !            16:  * 
        !            17:  */
        !            18: 
        !            19: /*
        !            20:  *                               NOTICE
        !            21:  *
        !            22:  *    Acquisition, use, and distribution of this module and related
        !            23:  *    materials are subject to the restrictions of a license agreement.
        !            24:  *    Consult the Preface in the User's Manual for the full terms of
        !            25:  *    this agreement.
        !            26:  *
        !            27:  */
        !            28: 
        !            29: 
        !            30: /* LINTLIBRARY */
        !            31: 
        !            32: #include <stdio.h>
        !            33: #include "smux.h"
        !            34: #include "objects.h"
        !            35: 
        !            36: /*  */
        !            37: 
        !            38: int    smux_init (debug)
        !            39: int    debug;                  /* if non-zero says to print PDUs on tty */
        !            40: {
        !            41:     return smux_init (debug);
        !            42: }
        !            43: 
        !            44: 
        !            45: int    smux_simple_open (identity, description, commname, commlen)
        !            46: OID    identity;               /* identity of SMUX initiator */
        !            47: char   *description;           /* implementation-specific string */
        !            48: char   *commname;                      /* password, may be zero-length */
        !            49: int    commlen;                /*   .. */
        !            50: {
        !            51:     return smux_simple_open (identity, description, commname, commlen);
        !            52: }
        !            53: 
        !            54: 
        !            55: smux_close (reason)
        !            56: int    reason;                 /* a symbolic value defined in smux.h */
        !            57: {
        !            58:     return smux_close (reason);
        !            59: }
        !            60: 
        !            61: int    smux_register (subtree, priority, operation)
        !            62: OID    subtree;                /* subtree to register */
        !            63: int    priority,               /* desired priority (use -1 for default) */
        !            64:        operation;              /* a symbolic value defined in smux.h */
        !            65: {
        !            66:     return smux_register (subtree, priority, operation);
        !            67: }
        !            68: 
        !            69: int    smux_wait (event, secs)
        !            70: struct type_SNMP_SMUX__PDUs **event;   
        !            71:                                /* initialized to next event */
        !            72: int    secs;                   /* maximum time to wait: -1=forever, 0=poll */
        !            73: {
        !            74:     return smux_wait (event, secs);
        !            75: }
        !            76:                                        
        !            77: 
        !            78: int    smux_response (event)
        !            79: struct type_SNMP_GetResponse__PDU *event;
        !            80:                                /* event to send back */
        !            81: {
        !            82:     return smux_response (event);
        !            83: }
        !            84: 
        !            85: int    smux_trap (generic, specific, bindings)
        !            86: int    generic,
        !            87:        specific;
        !            88: struct type_SNMP_VarBindList *bindings;
        !            89: {
        !            90:     return smux_trap (generic, specific, bindings);
        !            91: }
        !            92: 
        !            93: 
        !            94: char   *smux_error (i)         /* a SMUX error code */
        !            95: int    i;
        !            96: {
        !            97:     return smux_error (i);
        !            98: }
        !            99: 
        !           100: /*  */
        !           101: 
        !           102: int    setsmuxEntry (f)
        !           103: int    f;
        !           104: {
        !           105:     return setsmuxEntry (f);
        !           106: }
        !           107: 
        !           108: 
        !           109: int    endsmuxEntry ()
        !           110: {
        !           111:     return endsmuxEntry ();
        !           112: }
        !           113: 
        !           114: struct smuxEntry *getsmuxEntry ()
        !           115: {
        !           116:     return getsmuxEntry ();
        !           117: }
        !           118: 
        !           119: struct smuxEntry *getsmuxEntrybyname (name)
        !           120: char   *name;
        !           121: {
        !           122:     return getsmuxEntrybyname (name);
        !           123: }
        !           124: 
        !           125: 
        !           126: struct smuxEntry *getsmuxEntrybyidentity (identity)
        !           127: OID    identity;
        !           128: {
        !           129:     return getsmuxEntrybyidentity (identity);
        !           130: }
        !           131: 
        !           132: /*  */
        !           133: 
        !           134: int    readsyntax ()
        !           135: {
        !           136:     return readsyntax ();
        !           137: }
        !           138: 
        !           139: 
        !           140: int    add_syntax (name, f_encode, f_decode, f_free, f_parse, f_print)
        !           141: char   *name;
        !           142: IFP    f_encode,
        !           143:        f_decode,
        !           144:        f_free,
        !           145:        f_parse,
        !           146:        f_print;
        !           147: {
        !           148:     return add_syntax (name, f_encode, f_decode, f_free, f_parse, f_print);
        !           149: }
        !           150: 
        !           151: 
        !           152: OS     text2syn (name)
        !           153: char   *name;
        !           154: {
        !           155:     return text2syn (name);
        !           156: }
        !           157: 
        !           158: /*  */
        !           159: 
        !           160: int    readobjects (file)
        !           161: char   *file;
        !           162: {
        !           163:     return readobjects (file);
        !           164: }
        !           165: 
        !           166: 
        !           167: int    add_objects (ot)
        !           168: OT     ot;
        !           169: {
        !           170:     return add_objects (ot);
        !           171: }
        !           172: 
        !           173: 
        !           174: OT     name2obj (oid)
        !           175: OID    oid;
        !           176: {
        !           177:     return name2obj (oid);
        !           178: }
        !           179: 
        !           180: 
        !           181: OT     text2obj (text)
        !           182: char   *text;
        !           183: {
        !           184:     return text2obj (text);
        !           185: }
        !           186: 
        !           187: 
        !           188: OID    text2oid (name)
        !           189: char   *name;
        !           190: {
        !           191:     return text2oid (name);
        !           192: }
        !           193: 
        !           194: 
        !           195: char   *oid2ode (oid)
        !           196: OID    oid;
        !           197: {
        !           198:     return oid2ode (oid);
        !           199: }
        !           200: 
        !           201: 
        !           202: OI     name2inst (oid)
        !           203: OID    oid;
        !           204: {
        !           205:     return name2inst (oid);
        !           206: }
        !           207: 
        !           208: 
        !           209: OI     next2inst (oid)
        !           210: OID    oid;
        !           211: {
        !           212:     return next2inst (oid);
        !           213: }
        !           214: 
        !           215: 
        !           216: OI     text2inst (text)
        !           217: char   *text;
        !           218: {
        !           219:     return text2inst (text);
        !           220: }
        !           221: 
        !           222: 
        !           223: char   *strdup (s)
        !           224: char   *s;
        !           225: {
        !           226:     return strdup (s);
        !           227: }
        !           228: 
        !           229: /*  */
        !           230: 
        !           231: int    o_generic (oi, v, offset)
        !           232: OI     oi;
        !           233: struct type_SNMP_VarBind *v;
        !           234: int    offset;
        !           235: {
        !           236:     return o_generic (oi, v, offset);
        !           237: }
        !           238: 
        !           239: 
        !           240: int    o_number (oi, v, number)
        !           241: OI     oi;
        !           242: struct type_SNMP_VarBind *v;
        !           243: integer        number;
        !           244: {
        !           245:     return o_number (oi, v, number);
        !           246: }
        !           247: 
        !           248: 
        !           249: int    o_string (oi, v, base, len)
        !           250: OI     oi;
        !           251: struct type_SNMP_VarBind *v;
        !           252: char   *base;
        !           253: int    len;
        !           254: {
        !           255:     return o_string (oi, v, base, len);
        !           256: }
        !           257: 
        !           258: 
        !           259: int    o_specific (oi, v, offset)
        !           260: OI     oi;
        !           261: struct type_SNMP_VarBind *v;
        !           262: int    offset;
        !           263: {
        !           264:     return o_specific (oi, v, offset);
        !           265: }
        !           266: 
        !           267: 
        !           268: int    mediaddr2oid (ip, addr, len, islen)
        !           269: unsigned int *ip;
        !           270: u_char *addr;
        !           271: int    len,
        !           272:        islen;
        !           273: {
        !           274:     return mediaddr2oid (ip, addr, len, islen);
        !           275: }
        !           276: 
        !           277: 
        !           278: OID    oid_extend (q, howmuch)
        !           279: OID    q;
        !           280: int    howmuch;
        !           281: {
        !           282:     return oid_extend (q, howmuch);
        !           283: }
        !           284: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.