Annotation of 43BSDReno/contrib/isode-beta/snmp/llib-lisnmp, revision 1.1.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: 

unix.superglobalmegacorp.com

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