CVS: linux-atm/src/ilmid rfc1157_snmp.c,NONE,1.1.2.1 rfc1157_snmp.h,NONE,1.1.2.1 io.c,NONE,1.1.2.1 io.h,NONE,1.1.2.1 mib.c,NONE,1.1.2.1 mib.h,NONE,1.1.2.1 atmf_uni.c,NONE,1.1.2.1 atmf_uni.h,NONE,1.1.2.1 Makefile.am,NONE,1.1.2.1 sysgroup.c,NONE,1.1.2.1 sysgroup.h,NONE,1.1.2.1 util.c,NONE,1.1.2.1 util.h,NONE,1.1.2.1 rfc1155_smi.c,NONE,1.1.2.1 rfc1155_smi.h,NONE,1.1.2.1 message.c,NONE,1.1.2.1 message.h,NONE,1.1.2.1 ilmid.c,NONE,1.1.2.1 COPYRIGHT,NONE,1.1.2.1

[Paul B. S. <pa...@us...>]

Update of /cvsroot/linux-atm/linux-atm/src/ilmid
In directory usw-pr-cvs1:/tmp/cvs-serv10656/ilmid

Added Files:
      Tag: V2_4_0
	rfc1157_snmp.c rfc1157_snmp.h io.c io.h mib.c mib.h atmf_uni.c 
	atmf_uni.h Makefile.am sysgroup.c sysgroup.h util.c util.h 
	rfc1155_smi.c rfc1155_smi.h message.c message.h ilmid.c 
	COPYRIGHT 
Log Message:


--- NEW FILE: rfc1157_snmp.c ---
/*
 *    rfc1157_snmp.c
 *
 *    "RFC1157-SNMP" ASN.1 module encode/decode/print/free C src.
 *
 *    This file was generated by snacc on Fri Jan 31 14:49:02 1997
 *
 *    UBC snacc written by Mike Sample
 *
 *    NOTE: This is a machine generated file - editing not recommended
 */

#if HAVE_CONFIG_H
#include <config.h>
#endif

#include "asn_incl.h"
#include "rfc1155_smi.h"
#include "rfc1157_snmp.h"


AsnLen
BEncVarBindContent PARAMS((b, v),
BUF_TYPE b _AND_
VarBind* v)
{
    AsnLen totalLen = 0;
    AsnLen itemLen;
    AsnLen listLen;
    void* component;

    itemLen = BEncObjectSyntaxContent( b, (v->value));

    totalLen += itemLen;

    itemLen = BEncObjectNameContent( b, (&v->name));
    itemLen += BEncDefLen( b, itemLen);
    itemLen += BEncTag1(b, UNIV, PRIM, 6);

    totalLen += itemLen;

    return (totalLen);

}  /* BEncVarBindContent */

void
BDecVarBindContent PARAMS((b, tagId0, elmtLen0, v, bytesDecoded, env),
BUF_TYPE b _AND_
AsnTag tagId0 _AND_
AsnLen elmtLen0 _AND_
VarBind* v _AND_
AsnLen* bytesDecoded _AND_
ENV_TYPE env)
{
    int seqDone = FALSE;
    AsnLen totalElmtsLen1 = 0;
    AsnLen elmtLen1;
    AsnTag tagId1;
    int mandatoryElmtCount1 = 0;
    AsnLen totalElmtsLen2 = 0;
    AsnLen elmtLen2;
    AsnTag tagId2;


    tagId1 = BDecTag(b, &totalElmtsLen1, env);

    if ((( tagId1 == MAKE_TAG_ID( UNIV, PRIM, OID_TAG_CODE))))
    {
    elmtLen1 = BDecLen (b, &totalElmtsLen1, env);
    BDecObjectNameContent( b, tagId1, elmtLen1, (&v->name), &totalElmtsLen1, env);
    tagId1 = BDecTag(b, &totalElmtsLen1, env);
    }
    else
        longjmp(env, -100);


    if ((( tagId1 == MAKE_TAG_ID( UNIV, PRIM, INTEGER_TAG_CODE)) ||
     ( tagId1 ==MAKE_TAG_ID( UNIV, PRIM, OCTETSTRING_TAG_CODE))||
    ( tagId1 == MAKE_TAG_ID( UNIV, CONS, OCTETSTRING_TAG_CODE)) ||
     ( tagId1 ==MAKE_TAG_ID( UNIV, PRIM, OID_TAG_CODE)) ||
     ( tagId1 ==MAKE_TAG_ID( UNIV, PRIM, NULLTYPE_TAG_CODE)) ||
    ( tagId1 == MAKE_TAG_ID( APPL, PRIM, 0))||
    ( tagId1 == MAKE_TAG_ID( APPL, CONS, 0)) ||
    ( tagId1 == MAKE_TAG_ID( APPL, PRIM, 1)) ||
    ( tagId1 == MAKE_TAG_ID( APPL, PRIM, 2)) ||
    ( tagId1 == MAKE_TAG_ID( APPL, PRIM, 3)) ||
    ( tagId1 == MAKE_TAG_ID( APPL, PRIM, 4))||
    ( tagId1 == MAKE_TAG_ID( APPL, CONS, 4))))
    {
        elmtLen1 = BDecLen (b, &totalElmtsLen1, env);
    (v->value) = (ObjectSyntax*) Asn1Alloc(sizeof(ObjectSyntax));
    CheckAsn1Alloc((v->value), env);
    BDecObjectSyntaxContent( b, tagId1, elmtLen1, (v->value), &totalElmtsLen1, env);
        seqDone = TRUE;
        if ( elmtLen0 == INDEFINITE_LEN )
            BDecEoc(b, &totalElmtsLen1, env);
        else if (totalElmtsLen1 != elmtLen0)
            longjmp(env, -101);
    }
    else
        longjmp(env, -102);


    if (!seqDone)
        longjmp(env, -103);

    (*bytesDecoded) += totalElmtsLen1;
}  /* BDecVarBindContent */

void
PrintVarBind PARAMS((f, v, indent),
FILE* f _AND_
VarBind* v _AND_
unsigned short int indent)
{
    if (v == NULL)
        return;

    fprintf(f,"{ -- SEQUENCE --\n");

    Indent(f, indent + stdIndentG);
    fprintf(f,"name ");
    PrintObjectName(f, (&v->name), indent + stdIndentG);
    fprintf(f, ",\n");
    Indent(f, indent + stdIndentG);
    fprintf(f,"value ");
    PrintObjectSyntax(f, (v->value), indent + stdIndentG);
    fprintf(f,"\n");
    Indent(f, indent);
    fprintf(f,"}");
}  /* PrintVarBind */




AsnLen
BEncVarBindListContent PARAMS((b, v),
BUF_TYPE b _AND_
VarBindList* v)
{
    AsnLen totalLen = 0;
    AsnLen itemLen;
    AsnLen listLen;
    void* component;

        listLen = 0;
    FOR_EACH_LIST_ELMT_RVS( component, v)
    {
    BEncEocIfNec(b);
    itemLen = BEncVarBindContent( b, component);
    itemLen += BEncConsLen( b, itemLen);
    itemLen += BEncTag1(b, UNIV, CONS, 16);

        listLen += itemLen;
    }
    return (listLen);

}  /* BEncVarBindListContent */

void
BDecVarBindListContent PARAMS((b, tagId0, elmtLen0, v, bytesDecoded, env),
BUF_TYPE b _AND_
AsnTag tagId0 _AND_
AsnLen elmtLen0 _AND_
VarBindList* v _AND_
AsnLen* bytesDecoded _AND_
ENV_TYPE env)
{
    int seqDone = FALSE;
    AsnLen totalElmtsLen1 = 0;
    AsnLen elmtLen1;
    AsnTag tagId1;
    int mandatoryElmtCount1 = 0;


    for ( totalElmtsLen1 = 0; (totalElmtsLen1 < elmtLen0) || (elmtLen0 == INDEFINITE_LEN);)
    {
        VarBind** tmpVar;
    tagId1 = BDecTag(b, &totalElmtsLen1, env);

    if ( (tagId1 == EOC_TAG_ID) && (elmtLen0 == INDEFINITE_LEN))
    {
        BDEC_2ND_EOC_OCTET(b, &totalElmtsLen1, env)
        break; /* got EOC so can exit this SET OF/SEQ OF's for loop*/
    }
    if ( (tagId1 == MAKE_TAG_ID( UNIV, CONS, SEQ_TAG_CODE)))
    {
        elmtLen1 = BDecLen (b, &totalElmtsLen1, env);
    tmpVar = (VarBind**) AsnListAppend(v);
    (*tmpVar) = (VarBind*) Asn1Alloc(sizeof(VarBind));
    CheckAsn1Alloc((*tmpVar), env);
    BDecVarBindContent( b, tagId1, elmtLen1, (*tmpVar), &totalElmtsLen1, env);
    }  /* end of tag check if */
    else  /* wrong tag */
    {
         Asn1Error("Unexpected Tag\n");
         longjmp(env, -104);
    }
    } /* end of for */

    (*bytesDecoded) += totalElmtsLen1;
}  /* BDecVarBindListContent */

void
PrintVarBindList PARAMS((f, v, indent),
FILE* f _AND_
VarBindList* v _AND_
unsigned short int indent)
{
    VarBind* tmp;
    if (v == NULL)
        return;
    fprintf(f,"{ -- SEQUENCE OF -- \n");
    FOR_EACH_LIST_ELMT(tmp, v)
    {
        Indent(f, indent+ stdIndentG);
        PrintVarBind(f, tmp, indent + stdIndentG);
        if (tmp != (VarBind*)LAST_LIST_ELMT(v))
            fprintf(f,",\n");
    }
    fprintf(f,"\n");
    Indent(f, indent);
    fprintf(f,"}");
}  /* PrintVarBindList */




AsnLen
BEncPDUContent PARAMS((b, v),
BUF_TYPE b _AND_
PDU* v)
{
    AsnLen totalLen = 0;
    AsnLen itemLen;
    AsnLen listLen;
    void* component;

    BEncEocIfNec(b);
    itemLen = BEncVarBindListContent( b, (v->variable_bindings));
    itemLen += BEncConsLen( b, itemLen);
    itemLen += BEncTag1(b, UNIV, CONS, 16);

    totalLen += itemLen;

    itemLen = BEncAsnIntContent( b, (&v->error_index));
    BEncDefLenTo127( b, itemLen);
    itemLen++;
    itemLen += BEncTag1(b, UNIV, PRIM, 2);

    totalLen += itemLen;

    itemLen = BEncPDUIntContent( b, (&v->error_status));
    BEncDefLenTo127( b, itemLen);
    itemLen++;
    itemLen += BEncTag1(b, UNIV, PRIM, 2);

    totalLen += itemLen;

    itemLen = BEncAsnIntContent( b, (&v->request_id));
    BEncDefLenTo127( b, itemLen);
    itemLen++;
    itemLen += BEncTag1(b, UNIV, PRIM, 2);

    totalLen += itemLen;

    return (totalLen);

}  /* BEncPDUContent */

void
BDecPDUContent PARAMS((b, tagId0, elmtLen0, v, bytesDecoded, env),
BUF_TYPE b _AND_
AsnTag tagId0 _AND_
AsnLen elmtLen0 _AND_
PDU* v _AND_
AsnLen* bytesDecoded _AND_
ENV_TYPE env)
{
    int seqDone = FALSE;
    AsnLen totalElmtsLen1 = 0;
    AsnLen elmtLen1;
    AsnTag tagId1;
    int mandatoryElmtCount1 = 0;


    tagId1 = BDecTag(b, &totalElmtsLen1, env);

    if ((( tagId1 == MAKE_TAG_ID( UNIV, PRIM, INTEGER_TAG_CODE))))
    {
    elmtLen1 = BDecLen (b, &totalElmtsLen1, env);
    BDecAsnIntContent( b, tagId1, elmtLen1, (&v->request_id), &totalElmtsLen1, env);
    tagId1 = BDecTag(b, &totalElmtsLen1, env);
    }
    else
        longjmp(env, -105);


    if ((( tagId1 == MAKE_TAG_ID( UNIV, PRIM, INTEGER_TAG_CODE))))
    {
    elmtLen1 = BDecLen (b, &totalElmtsLen1, env);
    BDecPDUIntContent( b, tagId1, elmtLen1, (&v->error_status), &totalElmtsLen1, env);
    tagId1 = BDecTag(b, &totalElmtsLen1, env);
    }
    else
        longjmp(env, -106);


    if ((( tagId1 == MAKE_TAG_ID( UNIV, PRIM, INTEGER_TAG_CODE))))
    {
    elmtLen1 = BDecLen (b, &totalElmtsLen1, env);
    BDecAsnIntContent( b, tagId1, elmtLen1, (&v->error_index), &totalElmtsLen1, env);
    tagId1 = BDecTag(b, &totalElmtsLen1, env);
    }
    else
        longjmp(env, -107);


    if ((( tagId1 == MAKE_TAG_ID( UNIV, CONS, SEQ_TAG_CODE))))
    {
    elmtLen1 = BDecLen (b, &totalElmtsLen1, env);
    (v->variable_bindings) = AsnListNew(sizeof(char*));
    CheckAsn1Alloc((v->variable_bindings), env);
    BDecVarBindListContent( b, tagId1, elmtLen1, (v->variable_bindings), &totalElmtsLen1, env);
        seqDone = TRUE;
        if ( elmtLen0 == INDEFINITE_LEN )
            BDecEoc(b, &totalElmtsLen1, env);
        else if (totalElmtsLen1 != elmtLen0)
            longjmp(env, -108);
    }
    else
        longjmp(env, -109);


    if (!seqDone)
        longjmp(env, -110);

    (*bytesDecoded) += totalElmtsLen1;
}  /* BDecPDUContent */

void
PrintPDU PARAMS((f, v, indent),
FILE* f _AND_
PDU* v _AND_
unsigned short int indent)
{
    if (v == NULL)
        return;

    fprintf(f,"{ -- SEQUENCE --\n");

    Indent(f, indent + stdIndentG);
    fprintf(f,"request-id ");
    PrintAsnInt(f, (&v->request_id), indent + stdIndentG);
    fprintf(f, ",\n");
    Indent(f, indent + stdIndentG);
    fprintf(f,"error-status ");
    PrintPDUInt(f, (&v->error_status), indent + stdIndentG);
    fprintf(f, ",\n");
    Indent(f, indent + stdIndentG);
    fprintf(f,"error-index ");
    PrintAsnInt(f, (&v->error_index), indent + stdIndentG);
    fprintf(f, ",\n");
    Indent(f, indent + stdIndentG);
    fprintf(f,"variable-bindings ");
    PrintVarBindList(f, (v->variable_bindings), indent + stdIndentG);
    fprintf(f,"\n");
    Indent(f, indent);
    fprintf(f,"}");
}  /* PrintPDU */




AsnLen
BEncTrap_PDUContent PARAMS((b, v),
BUF_TYPE b _AND_
Trap_PDU* v)
{
    AsnLen totalLen = 0;
    AsnLen itemLen;
    AsnLen listLen;
    void* component;

    BEncEocIfNec(b);
    itemLen = BEncVarBindListContent( b, (v->variable_bindings));
    itemLen += BEncConsLen( b, itemLen);
    itemLen += BEncTag1(b, UNIV, CONS, 16);

    totalLen += itemLen;

    itemLen = BEncTimeTicksContent( b, (&v->time_stamp));
    BEncDefLenTo127( b, itemLen);
    itemLen++;
    itemLen += BEncTag1(b, APPL, PRIM, 3);

    totalLen += itemLen;

    itemLen = BEncAsnIntContent( b, (&v->specific_trap));
    BEncDefLenTo127( b, itemLen);
    itemLen++;
    itemLen += BEncTag1(b, UNIV, PRIM, 2);

    totalLen += itemLen;

    itemLen = BEncTrap_PDUIntContent( b, (&v->generic_trap));
    BEncDefLenTo127( b, itemLen);
    itemLen++;
    itemLen += BEncTag1(b, UNIV, PRIM, 2);

    totalLen += itemLen;

    itemLen = BEncNetworkAddressContent( b, (v->agent_addr));

    totalLen += itemLen;

    itemLen = BEncAsnOidContent( b, (&v->enterprise));
    itemLen += BEncDefLen( b, itemLen);
    itemLen += BEncTag1(b, UNIV, PRIM, 6);

    totalLen += itemLen;

    return (totalLen);

}  /* BEncTrap_PDUContent */

void
BDecTrap_PDUContent PARAMS((b, tagId0, elmtLen0, v, bytesDecoded, env),
BUF_TYPE b _AND_
AsnTag tagId0 _AND_
AsnLen elmtLen0 _AND_
Trap_PDU* v _AND_
AsnLen* bytesDecoded _AND_
ENV_TYPE env)
{
    int seqDone = FALSE;
    AsnLen totalElmtsLen1 = 0;
    AsnLen elmtLen1;
    AsnTag tagId1;
    int mandatoryElmtCount1 = 0;
    AsnLen totalElmtsLen2 = 0;
    AsnLen elmtLen2;
    AsnTag tagId2;


    tagId1 = BDecTag(b, &totalElmtsLen1, env);

    if ((( tagId1 == MAKE_TAG_ID( UNIV, PRIM, OID_TAG_CODE))))
    {
    elmtLen1 = BDecLen (b, &totalElmtsLen1, env);
    BDecAsnOidContent( b, tagId1, elmtLen1, (&v->enterprise), &totalElmtsLen1, env);
    tagId1 = BDecTag(b, &totalElmtsLen1, env);
    }
    else
        longjmp(env, -111);


    if ((( tagId1 == MAKE_TAG_ID( APPL, PRIM, 0)) ||
( tagId1 == MAKE_TAG_ID( APPL, CONS, 0))))
    {
        elmtLen1 = BDecLen (b, &totalElmtsLen1, env);
    (v->agent_addr) = (NetworkAddress*) Asn1Alloc(sizeof(NetworkAddress));
    CheckAsn1Alloc((v->agent_addr), env);
    BDecNetworkAddressContent( b, tagId1, elmtLen1, (v->agent_addr), &totalElmtsLen1, env);
    tagId1 = BDecTag(b, &totalElmtsLen1, env);
    }
    else
        longjmp(env, -112);


    if ((( tagId1 == MAKE_TAG_ID( UNIV, PRIM, INTEGER_TAG_CODE))))
    {
    elmtLen1 = BDecLen (b, &totalElmtsLen1, env);
    BDecTrap_PDUIntContent( b, tagId1, elmtLen1, (&v->generic_trap), &totalElmtsLen1, env);
    tagId1 = BDecTag(b, &totalElmtsLen1, env);
    }
    else
        longjmp(env, -113);


    if ((( tagId1 == MAKE_TAG_ID( UNIV, PRIM, INTEGER_TAG_CODE))))
    {
    elmtLen1 = BDecLen (b, &totalElmtsLen1, env);
    BDecAsnIntContent( b, tagId1, elmtLen1, (&v->specific_trap), &totalElmtsLen1, env);
    tagId1 = BDecTag(b, &totalElmtsLen1, env);
    }
    else
        longjmp(env, -114);


    if ((( tagId1 == MAKE_TAG_ID( APPL, PRIM, 3))))
    {
    elmtLen1 = BDecLen (b, &totalElmtsLen1, env);
    BDecTimeTicksContent( b, tagId1, elmtLen1, (&v->time_stamp), &totalElmtsLen1, env);
    tagId1 = BDecTag(b, &totalElmtsLen1, env);
    }
    else
        longjmp(env, -115);


    if ((( tagId1 == MAKE_TAG_ID( UNIV, CONS, SEQ_TAG_CODE))))
    {
    elmtLen1 = BDecLen (b, &totalElmtsLen1, env);
    (v->variable_bindings) = AsnListNew(sizeof(char*));
    CheckAsn1Alloc((v->variable_bindings), env);
    BDecVarBindListContent( b, tagId1, elmtLen1, (v->variable_bindings), &totalElmtsLen1, env);
        seqDone = TRUE;
        if ( elmtLen0 == INDEFINITE_LEN )
            BDecEoc(b, &totalElmtsLen1, env);
        else if (totalElmtsLen1 != elmtLen0)
            longjmp(env, -116);
    }
    else
        longjmp(env, -117);


    if (!seqDone)
        longjmp(env, -118);

    (*bytesDecoded) += totalElmtsLen1;
}  /* BDecTrap_PDUContent */

void
PrintTrap_PDU PARAMS((f, v, indent),
FILE* f _AND_
Trap_PDU* v _AND_
unsigned short int indent)
{
    if (v == NULL)
        return;

    fprintf(f,"{ -- SEQUENCE --\n");

    Indent(f, indent + stdIndentG);
    fprintf(f,"enterprise ");
    PrintAsnOid(f, (&v->enterprise), indent + stdIndentG);
    fprintf(f, ",\n");
    Indent(f, indent + stdIndentG);
    fprintf(f,"agent-addr ");
    PrintNetworkAddress(f, (v->agent_addr), indent + stdIndentG);
    fprintf(f, ",\n");
    Indent(f, indent + stdIndentG);
    fprintf(f,"generic-trap ");
    PrintTrap_PDUInt(f, (&v->generic_trap), indent + stdIndentG);
    fprintf(f, ",\n");
    Indent(f, indent + stdIndentG);
    fprintf(f,"specific-trap ");
    PrintAsnInt(f, (&v->specific_trap), indent + stdIndentG);
    fprintf(f, ",\n");
    Indent(f, indent + stdIndentG);
    fprintf(f,"time-stamp ");
    PrintTimeTicks(f, (&v->time_stamp), indent + stdIndentG);
    fprintf(f, ",\n");
    Indent(f, indent + stdIndentG);
    fprintf(f,"variable-bindings ");
    PrintVarBindList(f, (v->variable_bindings), indent + stdIndentG);
    fprintf(f,"\n");
    Indent(f, indent);
    fprintf(f,"}");
}  /* PrintTrap_PDU */




AsnLen
BEncPDUsContent PARAMS((b, v),
BUF_TYPE b _AND_
PDUs* v)
{
    AsnLen totalLen = 0;
    AsnLen itemLen;
    AsnLen listLen;
    void* component;

    switch(v->choiceId)
    {
       case(PDUS_GET_REQUEST):
    BEncEocIfNec(b);
    itemLen = BEncGetRequest_PDUContent( b, (v->a.get_request));
    itemLen += BEncConsLen( b, itemLen);
    itemLen += BEncTag1(b, CNTX, CONS, 0);

    totalLen += itemLen;

    break;

       case(PDUS_GET_NEXT_REQUEST):
    BEncEocIfNec(b);
    itemLen = BEncGetNextRequest_PDUContent( b, (v->a.get_next_request));
    itemLen += BEncConsLen( b, itemLen);
    itemLen += BEncTag1(b, CNTX, CONS, 1);

    totalLen += itemLen;

    break;

       case(PDUS_GET_RESPONSE):
    BEncEocIfNec(b);
    itemLen = BEncGetResponse_PDUContent( b, (v->a.get_response));
    itemLen += BEncConsLen( b, itemLen);
    itemLen += BEncTag1(b, CNTX, CONS, 2);

    totalLen += itemLen;

    break;

       case(PDUS_SET_REQUEST):
    BEncEocIfNec(b);
    itemLen = BEncSetRequest_PDUContent( b, (v->a.set_request));
    itemLen += BEncConsLen( b, itemLen);
    itemLen += BEncTag1(b, CNTX, CONS, 3);

    totalLen += itemLen;

    break;

       case(PDUS_TRAP):
    BEncEocIfNec(b);
    itemLen = BEncTrap_PDUContent( b, (v->a.trap));
    itemLen += BEncConsLen( b, itemLen);
    itemLen += BEncTag1(b, CNTX, CONS, 4);

    totalLen += itemLen;

    break;

    }
    return (totalLen);

}  /* BEncPDUsContent */

void
BDecPDUsContent PARAMS((b, tagId0, elmtLen0, v, bytesDecoded, env),
BUF_TYPE b _AND_
AsnTag tagId0 _AND_
AsnLen elmtLen0 _AND_
PDUs* v _AND_
AsnLen* bytesDecoded _AND_
ENV_TYPE env)
{
    int seqDone = FALSE;
    AsnLen totalElmtsLen1 = 0;
    AsnLen elmtLen1;
    AsnTag tagId1;
    int mandatoryElmtCount1 = 0;


    switch(tagId0)
    {
       case(MAKE_TAG_ID( CNTX, CONS, 0)):
        (v->choiceId) = PDUS_GET_REQUEST;
    (v->a.get_request) = (GetRequest_PDU*) Asn1Alloc(sizeof(GetRequest_PDU));
    CheckAsn1Alloc((v->a.get_request), env);
    BDecGetRequest_PDUContent( b, tagId0, elmtLen0, (v->a.get_request), &totalElmtsLen1, env);
    break;

       case(MAKE_TAG_ID( CNTX, CONS, 1)):
        (v->choiceId) = PDUS_GET_NEXT_REQUEST;
    (v->a.get_next_request) = (GetNextRequest_PDU*) Asn1Alloc(sizeof(GetNextRequest_PDU));
    CheckAsn1Alloc((v->a.get_next_request), env);
    BDecGetNextRequest_PDUContent( b, tagId0, elmtLen0, (v->a.get_next_request), &totalElmtsLen1, env);
    break;

       case(MAKE_TAG_ID( CNTX, CONS, 2)):
        (v->choiceId) = PDUS_GET_RESPONSE;
    (v->a.get_response) = (GetResponse_PDU*) Asn1Alloc(sizeof(GetResponse_PDU));
    CheckAsn1Alloc((v->a.get_response), env);
    BDecGetResponse_PDUContent( b, tagId0, elmtLen0, (v->a.get_response), &totalElmtsLen1, env);
    break;

       case(MAKE_TAG_ID( CNTX, CONS, 3)):
        (v->choiceId) = PDUS_SET_REQUEST;
    (v->a.set_request) = (SetRequest_PDU*) Asn1Alloc(sizeof(SetRequest_PDU));
    CheckAsn1Alloc((v->a.set_request), env);
    BDecSetRequest_PDUContent( b, tagId0, elmtLen0, (v->a.set_request), &totalElmtsLen1, env);
    break;

       case(MAKE_TAG_ID( CNTX, CONS, 4)):
        (v->choiceId) = PDUS_TRAP;
    (v->a.trap) = (Trap_PDU*) Asn1Alloc(sizeof(Trap_PDU));
    CheckAsn1Alloc((v->a.trap), env);
    BDecTrap_PDUContent( b, tagId0, elmtLen0, (v->a.trap), &totalElmtsLen1, env);
    break;

    default:
        Asn1Error("ERROR - unexpected tag in CHOICE\n");
        longjmp(env, -119);
        break;
    } /* end switch */
    (*bytesDecoded) += totalElmtsLen1;
}  /* BDecPDUsContent */

void
PrintPDUs PARAMS((f, v, indent),
FILE* f _AND_
PDUs* v _AND_
unsigned short int indent)
{
    switch(v->choiceId)
    {
      case(PDUS_GET_REQUEST):
          fprintf(f,"get-request ");
    PrintGetRequest_PDU(f, (v->a.get_request), indent + stdIndentG);
          break;

      case(PDUS_GET_NEXT_REQUEST):
          fprintf(f,"get-next-request ");
    PrintGetNextRequest_PDU(f, (v->a.get_next_request), indent + stdIndentG);
          break;

      case(PDUS_GET_RESPONSE):
          fprintf(f,"get-response ");
    PrintGetResponse_PDU(f, (v->a.get_response), indent + stdIndentG);
          break;

      case(PDUS_SET_REQUEST):
          fprintf(f,"set-request ");
    PrintSetRequest_PDU(f, (v->a.set_request), indent + stdIndentG);
          break;

      case(PDUS_TRAP):
          fprintf(f,"trap ");
    PrintTrap_PDU(f, (v->a.trap), indent + stdIndentG);
          break;

    }
}  /* PrintPDUs */




AsnLen BEncMessage PARAMS((b, v),
BUF_TYPE b _AND_
Message* v)
{
    AsnLen l;
    BEncEocIfNec(b);
    l = BEncMessageContent(b, v);
    l += BEncConsLen(b, l);
    l += BEncTag1(b, UNIV, CONS, SEQ_TAG_CODE);
    return(l);
} /* BEncMessage */

void BDecMessage PARAMS((b, result, bytesDecoded, env),
BUF_TYPE b _AND_
Message* result _AND_
AsnLen* bytesDecoded _AND_
ENV_TYPE env)
{
    AsnTag tag;
    AsnLen elmtLen1;

    if ( ((tag = BDecTag(b, bytesDecoded, env)) != 
MAKE_TAG_ID(UNIV, CONS, SEQ_TAG_CODE)))
    {
        Asn1Error("BDecMessage: ERROR - wrong tag\n");
        longjmp(env, -120);
    }
    elmtLen1 = BDecLen(b, bytesDecoded, env);
    BDecMessageContent(b, tag, elmtLen1, result, bytesDecoded, env);
}  /* BDecMessage */

AsnLen
BEncMessageContent PARAMS((b, v),
BUF_TYPE b _AND_
Message* v)
{
    AsnLen totalLen = 0;
    AsnLen itemLen;
    AsnLen listLen;
    void* component;

    itemLen = BEncPDUsContent( b, (v->data));

    totalLen += itemLen;

    itemLen = BEncAsnOctsContent( b, (&v->community));
    itemLen += BEncDefLen( b, itemLen);
    itemLen += BEncTag1(b, UNIV, PRIM, 4);

    totalLen += itemLen;

    itemLen = BEncMessageIntContent( b, (&v->version));
    BEncDefLenTo127( b, itemLen);
    itemLen++;
    itemLen += BEncTag1(b, UNIV, PRIM, 2);

    totalLen += itemLen;

    return (totalLen);

}  /* BEncMessageContent */

void
BDecMessageContent PARAMS((b, tagId0, elmtLen0, v, bytesDecoded, env),
BUF_TYPE b _AND_
AsnTag tagId0 _AND_
AsnLen elmtLen0 _AND_
Message* v _AND_
AsnLen* bytesDecoded _AND_
ENV_TYPE env)
{
    int seqDone = FALSE;
    AsnLen totalElmtsLen1 = 0;
    AsnLen elmtLen1;
    AsnTag tagId1;
    int mandatoryElmtCount1 = 0;
    AsnLen totalElmtsLen2 = 0;
    AsnLen elmtLen2;
    AsnTag tagId2;


    tagId1 = BDecTag(b, &totalElmtsLen1, env);

    if ((( tagId1 == MAKE_TAG_ID( UNIV, PRIM, INTEGER_TAG_CODE))))
    {
    elmtLen1 = BDecLen (b, &totalElmtsLen1, env);
    BDecMessageIntContent( b, tagId1, elmtLen1, (&v->version), &totalElmtsLen1, env);
    tagId1 = BDecTag(b, &totalElmtsLen1, env);
    }
    else
        longjmp(env, -121);


    if ((( tagId1 == MAKE_TAG_ID( UNIV, PRIM, OCTETSTRING_TAG_CODE)) ||
( tagId1 == MAKE_TAG_ID( UNIV, CONS, OCTETSTRING_TAG_CODE))))
    {
    elmtLen1 = BDecLen (b, &totalElmtsLen1, env);
    BDecAsnOctsContent( b, tagId1, elmtLen1, (&v->community), &totalElmtsLen1, env);
    tagId1 = BDecTag(b, &totalElmtsLen1, env);
    }
    else
        longjmp(env, -122);


    if ((( tagId1 == MAKE_TAG_ID( CNTX, CONS, 0)) ||
    ( tagId1 == MAKE_TAG_ID( CNTX, CONS, 1)) ||
    ( tagId1 == MAKE_TAG_ID( CNTX, CONS, 2)) ||
    ( tagId1 == MAKE_TAG_ID( CNTX, CONS, 3)) ||
    ( tagId1 == MAKE_TAG_ID( CNTX, CONS, 4))))
    {
        elmtLen1 = BDecLen (b, &totalElmtsLen1, env);
    (v->data) = (PDUs*) Asn1Alloc(sizeof(PDUs));
    CheckAsn1Alloc((v->data), env);
    BDecPDUsContent( b, tagId1, elmtLen1, (v->data), &totalElmtsLen1, env);
        seqDone = TRUE;
        if ( elmtLen0 == INDEFINITE_LEN )
            BDecEoc(b, &totalElmtsLen1, env);
        else if (totalElmtsLen1 != elmtLen0)
            longjmp(env, -123);
    }
    else
        longjmp(env, -124);


    if (!seqDone)
        longjmp(env, -125);

    (*bytesDecoded) += totalElmtsLen1;
}  /* BDecMessageContent */

void
PrintMessage PARAMS((f, v, indent),
FILE* f _AND_
Message* v _AND_
unsigned short int indent)
{
    if (v == NULL)
        return;

    fprintf(f,"{ -- SEQUENCE --\n");

    Indent(f, indent + stdIndentG);
    fprintf(f,"version ");
    PrintMessageInt(f, (&v->version), indent + stdIndentG);
    fprintf(f, ",\n");
    Indent(f, indent + stdIndentG);
    fprintf(f,"community ");
    PrintAsnOcts(f, (&v->community), indent + stdIndentG);
    fprintf(f, ",\n");
    Indent(f, indent + stdIndentG);
    fprintf(f,"data ");
    PrintPDUs(f, (v->data), indent + stdIndentG);
    fprintf(f,"\n");
    Indent(f, indent);
    fprintf(f,"}\n");
}  /* PrintMessage */





--- NEW FILE: rfc1157_snmp.h ---
/*
 *    rfc1157_snmp.h
 *
 *    "RFC1157-SNMP" ASN.1 module C type definitions and prototypes
 *
 *    This .h file was by snacc on Fri Jan 31 14:49:02 1997
 *
 *    UBC snacc written compiler by Mike Sample
 *
 *    NOTE: This is a machine generated file - editing not recommended
 */


#ifndef _rfc1157_snmp_h_
#define _rfc1157_snmp_h_





#define COLDSTART 0
#define WARMSTART 1
#define LINKDOWN 2
#define LINKUP 3
#define AUTHENTICATIONFAILURE 4
#define EGPNEIGHBORLOSS 5
#define ENTERPRISESPECIFIC 6

typedef AsnInt Trap_PDUInt; /* INTEGER { COLDSTART(0), WARMSTART(1), LINKDOWN(2), LINKUP(3), AUTHENTICATIONFAILURE(4), EGPNEIGHBORLOSS(5), ENTERPRISESPECIFIC(6) }  */

#define BEncTrap_PDUIntContent BEncAsnIntContent

#define BDecTrap_PDUIntContent BDecAsnIntContent

#define PrintTrap_PDUInt PrintAsnInt





#define NOERROR 0
#define TOOBIG 1
#define NOSUCHNAME 2
#define BADVALUE 3
#define READONLY 4
#define GENERR 5

typedef AsnInt PDUInt; /* INTEGER { NOERROR(0), TOOBIG(1), NOSUCHNAME(2), BADVALUE(3), READONLY(4), GENERR(5) }  */

#define BEncPDUIntContent BEncAsnIntContent

#define BDecPDUIntContent BDecAsnIntContent

#define PrintPDUInt PrintAsnInt





#define VERSION_1 0

typedef AsnInt MessageInt; /* INTEGER { VERSION_1(0) }  */

#define BEncMessageIntContent BEncAsnIntContent

#define BDecMessageIntContent BDecAsnIntContent

#define PrintMessageInt PrintAsnInt




typedef struct VarBind /* SEQUENCE */
{
    ObjectName name; /* ObjectName */
    struct ObjectSyntax* value; /* ObjectSyntax */
} VarBind;

AsnLen BEncVarBindContent PROTO((BUF_TYPE b, VarBind* v));

void BDecVarBindContent PROTO(( BUF_TYPE b, AsnTag tagId0, AsnLen elmtLen0, VarBind* v, AsnLen* bytesDecoded, ENV_TYPE env));


void PrintVarBind PROTO((FILE* f, VarBind* v, unsigned short int indent));



typedef AsnList VarBindList; /* SEQUENCE OF VarBind */

AsnLen BEncVarBindListContent PROTO((BUF_TYPE b, VarBindList* v));

void BDecVarBindListContent PROTO(( BUF_TYPE b, AsnTag tagId0, AsnLen elmtLen0, VarBindList* v, AsnLen* bytesDecoded, ENV_TYPE env));


void PrintVarBindList PROTO((FILE* f, VarBindList* v, unsigned short int indent));



typedef struct PDU /* SEQUENCE */
{
    AsnInt request_id; /* INTEGER */
    PDUInt error_status; /* PDUInt */
    AsnInt error_index; /* INTEGER */
    VarBindList* variable_bindings; /* VarBindList */
} PDU;

AsnLen BEncPDUContent PROTO((BUF_TYPE b, PDU* v));

void BDecPDUContent PROTO(( BUF_TYPE b, AsnTag tagId0, AsnLen elmtLen0, PDU* v, AsnLen* bytesDecoded, ENV_TYPE env));


void PrintPDU PROTO((FILE* f, PDU* v, unsigned short int indent));



typedef struct Trap_PDU /* [4] IMPLICIT SEQUENCE */
{
    AsnOid enterprise; /* OBJECT IDENTIFIER */
    struct NetworkAddress* agent_addr; /* NetworkAddress */
    Trap_PDUInt generic_trap; /* Trap-PDUInt */
    AsnInt specific_trap; /* INTEGER */
    TimeTicks time_stamp; /* TimeTicks */
    VarBindList* variable_bindings; /* VarBindList */
} Trap_PDU;

AsnLen BEncTrap_PDUContent PROTO((BUF_TYPE b, Trap_PDU* v));

void BDecTrap_PDUContent PROTO(( BUF_TYPE b, AsnTag tagId0, AsnLen elmtLen0, Trap_PDU* v, AsnLen* bytesDecoded, ENV_TYPE env));


void PrintTrap_PDU PROTO((FILE* f, Trap_PDU* v, unsigned short int indent));



typedef struct PDU GetRequest_PDU; /* [0] IMPLICIT PDU */

#define BEncGetRequest_PDUContent BEncPDUContent

#define BDecGetRequest_PDUContent BDecPDUContent

#define PrintGetRequest_PDU PrintPDU




typedef struct PDU GetNextRequest_PDU; /* [1] IMPLICIT PDU */

#define BEncGetNextRequest_PDUContent BEncPDUContent

#define BDecGetNextRequest_PDUContent BDecPDUContent

#define PrintGetNextRequest_PDU PrintPDU




typedef struct PDU GetResponse_PDU; /* [2] IMPLICIT PDU */

#define BEncGetResponse_PDUContent BEncPDUContent

#define BDecGetResponse_PDUContent BDecPDUContent

#define PrintGetResponse_PDU PrintPDU




typedef struct PDU SetRequest_PDU; /* [3] IMPLICIT PDU */

#define BEncSetRequest_PDUContent BEncPDUContent

#define BDecSetRequest_PDUContent BDecPDUContent

#define PrintSetRequest_PDU PrintPDU




typedef struct PDUs /* CHOICE */
{
    enum PDUsChoiceId
    {
        PDUS_GET_REQUEST,
        PDUS_GET_NEXT_REQUEST,
        PDUS_GET_RESPONSE,
        PDUS_SET_REQUEST,
        PDUS_TRAP
    } choiceId;
    union PDUsChoiceUnion
    {
    GetRequest_PDU* get_request; /* GetRequest-PDU */
    GetNextRequest_PDU* get_next_request; /* GetNextRequest-PDU */
    GetResponse_PDU* get_response; /* GetResponse-PDU */
    SetRequest_PDU* set_request; /* SetRequest-PDU */
    struct Trap_PDU* trap; /* Trap-PDU */
    } a;
} PDUs;

AsnLen BEncPDUsContent PROTO((BUF_TYPE b, PDUs* v));

void BDecPDUsContent PROTO(( BUF_TYPE b, AsnTag tagId0, AsnLen elmtLen0, PDUs* v, AsnLen* bytesDecoded, ENV_TYPE env));


void PrintPDUs PROTO((FILE* f, PDUs* v, unsigned short int indent));



typedef struct Message /* SEQUENCE */
{
    MessageInt version; /* MessageInt */
    AsnOcts community; /* OCTET STRING */
    struct PDUs* data; /* PDUs */
} Message;

AsnLen BEncMessage PROTO((BUF_TYPE b, Message* v));

void BDecMessage PROTO(( BUF_TYPE b, Message* result, AsnLen* bytesDecoded, ENV_TYPE env));
AsnLen BEncMessageContent PROTO((BUF_TYPE b, Message* v));

void BDecMessageContent PROTO(( BUF_TYPE b, AsnTag tagId0, AsnLen elmtLen0, Message* v, AsnLen* bytesDecoded, ENV_TYPE env));


void PrintMessage PROTO((FILE* f, Message* v, unsigned short int indent));




#endif /* conditional include of rfc1157_snmp.h */

--- NEW FILE: io.c ---
/*
 * io.c - Ilmi input/output routines
 *
 * Written by Scott W. Shumate
 * 
 * Copyright (c) 1995-97 All Rights Reserved.
 * 
 * Permission to use, copy, modify and distribute this
 * software and its documentation is hereby granted,
 * provided that both the copyright notice and this
 * permission notice appear in all copies of the software,
 * derivative works or modified versions, and any portions
 * thereof, that both notices appear in supporting
 * documentation, and that the use of this software is
 * acknowledged in any publications resulting from using
 * the software.
 * 
 * I ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION AND DISCLAIMS ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS
 * SOFTWARE.
 */

#if HAVE_CONFIG_H
#include <config.h>
#endif

#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/ioctl.h>
#include <errno.h>
#include <net/if.h>
#include <atm.h>
#include <linux/atmdev.h>
#include "io.h"
#include "atmd.h"
#include "atmf_uni.h"

#define SNMP_VCI 16
#define COMPONENT "IO"
#define MAX_EXTRA_ADDRS 4 /* maximum number of additional addresses that can
			     be manually configured (after ilmid has
			     registered the "official" address) - HACK */

static short atm_itf = -1; /* bad value */


AsnOid *get_esi(int fd, int itf)
{
  static AsnOid *name;
  struct atmif_sioc req;
  unsigned char esi[ESI_LEN];
  int m, n, size;

  req.number = itf;
  req.arg = esi;
  req.length = ESI_LEN;

  if(ioctl(fd, ATM_GETESI, &req) < 0)
    diag(COMPONENT, DIAG_FATAL, "ioctl ATM_GETESI: %s", strerror(errno));
 
  /* save esi to atmfMySystemIdentifierValue */
  if (!atmfMySystemIdentifierValue.octs) {
     atmfMySystemIdentifierValue.octs = alloc(6);
     memcpy(atmfMySystemIdentifierValue.octs, esi, 6);
  }
 
  /* Convert hex string to Object ID BER */
  for(m = 0, size = 0; m < ESI_LEN; esi[m++] & 0x80 ? size += 2 : size++);
  size++;
  name = alloc_t(AsnOid);
  name->octs = alloc(size);
  name->octetLen = size;
  
  for(m = 0, n = 0; m < ESI_LEN; m++, n++)
    {
      if(esi[m] & 0x80)
	name->octs[n++] = '\201';
      name->octs[n] = esi[m] & 0x7F;
    }
  
  /* Add the SEL */
  name->octs[n] = '\0';

  return name;
}

void update_nsap(int itf, AsnOid *netprefix, AsnOid *esi)
{
  struct atmif_sioc req;
  struct sockaddr_atmsvc addr, ouraddr[MAX_EXTRA_ADDRS+1];
  char buffer[MAX_ATM_ADDR_LEN+1];
  int fd, m, n;

  addr.sas_family = AF_ATMSVC;
  addr.sas_addr.pub[0] = 0;
  
  /* Convert net prefix BER to hex */
  for(m = 0, n = 0; m < netprefix->octetLen; m++, n++)
    if(netprefix->octs[m] & 0x80)
      addr.sas_addr.prv[n] = netprefix->octs[++m] | 0x80;
    else
      addr.sas_addr.prv[n] = netprefix->octs[m];

  /* Convert esi BER to hex */
  for(m = 0; m < esi->octetLen; m++, n++)
    if(esi->octs[m] & 0x80)
      addr.sas_addr.prv[n] = esi->octs[++m] | 0x80;
    else
      addr.sas_addr.prv[n] = esi->octs[m];

  if ((fd = socket(AF_ATMSVC, SOCK_DGRAM, 0)) < 0)
    diag(COMPONENT, DIAG_FATAL, "socket: %s", strerror(errno));
  
  req.number = itf;
  req.arg = &ouraddr;
  req.length = sizeof(ouraddr);

  /* Try to get our address on that interface */

  if (ioctl(fd, ATM_GETADDR, &req) <0)
    diag(COMPONENT, DIAG_FATAL, "ioctl ATM_GETADDR: %s", strerror(errno));

  n = 0;
  if (req.length && atm_equal((struct sockaddr *) &addr,
   (struct sockaddr *) &ouraddr[0], ATM_ESA_LEN, 0)) {
    diag(COMPONENT, DIAG_INFO, "Primary ATM Address did not change");
    n = 1;
  }

  if ((!(m = req.length)) || (!n)) {
  	  req.number = itf;
  	  req.arg = NULL;
  	  req.length = 0;

  	  if (ioctl(fd, ATM_RSTADDR, &req) < 0)
    	    diag(COMPONENT, DIAG_FATAL, "ioctl ATM_RSTADDR: %s", strerror(errno));

	  req.number = itf;
	  req.arg = &addr;
	  req.length = sizeof(addr); 

	  if (ioctl(fd, ATM_ADDADDR, &req) < 0)
	    diag(COMPONENT, DIAG_FATAL, "ioctl ATM_ADDADDR: %s", strerror(errno));

	  atm2text(buffer,MAX_ATM_ADDR_LEN+1,(struct sockaddr *) &addr, A2T_PRETTY);

	  diag(COMPONENT, DIAG_INFO, "Primary ATM Address %s added local", buffer);
	
	  for (n = 0; n < m/sizeof(addr); n++) {

		  if(n > MAX_EXTRA_ADDRS-1) break; /* We have already registered "primary" NSAP */

		  req.number = itf;
		  req.arg = &ouraddr[n];
		  req.length = sizeof(*ouraddr); 
	  
		  atm2text(buffer,MAX_ATM_ADDR_LEN+1,(struct sockaddr *) &ouraddr[n], A2T_PRETTY);

		  if (ioctl(fd, ATM_ADDADDR, &req) < 0)
		    diag(COMPONENT, DIAG_ERROR, "ioctl ATM_ADDADDR: %s", strerror(errno));
	          else	
		    diag(COMPONENT, DIAG_INFO, "Extra   ATM Address %s added local", buffer);

	  }
  }	     	
  close(fd);

}

int wait_for_message(int fd, struct timeval *timeout)
{
  int numfds;
  fd_set fdvar;

  FD_ZERO(&fdvar);
  FD_SET(fd, &fdvar);

  if((numfds = select(fd + 1, &fdvar, 0, 0, timeout)) < 0)
    diag(COMPONENT, DIAG_FATAL, "select: %s", strerror(errno));

  return numfds;
}


int read_message(int fd, Message *message)
{
  SBuf buffer;
  char data[MAX_ILMI_MSG];
  AsnLen length;
  jmp_buf env;

  if ((int) (length = read(fd, data, MAX_ILMI_MSG)) < 0)
    diag(COMPONENT, DIAG_FATAL, "read: %s", strerror(errno));

  SBufInstallData(&buffer, data, length);
  if (setjmp(env) == 0)
    {
      BDecMessage(&buffer, message, &length, env);
    }
  else
    {
      diag(COMPONENT, DIAG_ERROR, "message decoding error");
      return -1;
    }

  diag(COMPONENT, DIAG_DEBUG, "SNMP message received:");
  if(get_verbosity(NULL) == DIAG_DEBUG)
    PrintMessage(get_logfile(), message, 0);
  
  if(message->version != VERSION_1)
    {
      diag(COMPONENT, DIAG_ERROR, "received message with wrong version number");
      return -1;
    }

  if(message->community.octetLen != 4 || 
     memcmp(message->community.octs, "ILMI", 4))
    {
      diag(COMPONENT, DIAG_ERROR, "received message with wrong community");
      return -1;
    }

  return 0;
}

int send_message(int fd, Message *message)
{
  SBuf buffer;
  AsnLen length;
  char data[MAX_ILMI_MSG];

  SBufInit(&buffer, data, MAX_ILMI_MSG);
  SBufResetInWriteRvsMode(&buffer);
  
  if(!(length = BEncMessage(&buffer, message)))
  {
    diag(COMPONENT, DIAG_ERROR, "message encoding error");
    return -1;
  }

  if(write(fd, SBufDataPtr(&buffer), length) != length)
    diag(COMPONENT, DIAG_FATAL, "write: %s", strerror(errno));

  diag(COMPONENT, DIAG_DEBUG, "SNMP message sent:");
  if(get_verbosity(NULL) == DIAG_DEBUG)
    PrintMessage(get_logfile(), message, 0);
  
  return 0;
}


int open_ilmi(int itf,const char *qos_spec)
{
    struct sockaddr_atmpvc addr;
    struct atm_qos qos;
    int fd;

    if((fd = socket(PF_ATMPVC, SOCK_DGRAM, 0)) < 0)
      diag(COMPONENT, DIAG_FATAL, "socket: %s", strerror(errno));

    atm_itf = itf;
    memset(&qos, 0, sizeof(qos));
    qos.rxtp.max_sdu = MAX_ILMI_MSG;
    qos.txtp.max_sdu = MAX_ILMI_MSG;
    qos.aal = ATM_AAL5;
    if (!qos_spec) qos.rxtp.traffic_class = qos.txtp.traffic_class = ATM_UBR;
    else if (text2qos(qos_spec,&qos,T2Q_DEFAULTS) < 0)
	    diag(COMPONENT,DIAG_FATAL,"invalid qos: %s",qos_spec);
    if (setsockopt(fd, SOL_ATM, SO_ATMQOS, &qos, sizeof(qos)) < 0)
	diag(COMPONENT,DIAG_FATAL,"setsockopt SO_ATMQOS: %s",strerror(errno));

    memset(&addr, 0, sizeof(addr));
    addr.sap_family = AF_ATMPVC;
    addr.sap_addr.itf = itf;
    addr.sap_addr.vpi = 0;
    addr.sap_addr.vci = SNMP_VCI;

    if(bind(fd, (struct sockaddr *) &addr, sizeof(addr)) < 0)
      diag(COMPONENT, DIAG_FATAL, "bind: %s", strerror(errno));

    return fd;
}


int get_ci_range(struct atm_cirange *ci)
{
    struct atmif_sioc req;
    int fd,error;

    fd = socket(PF_ATMPVC,SOCK_DGRAM,0);
    if (fd < 0) diag(COMPONENT,DIAG_FATAL,"socket: %s",strerror(errno));
    req.number = atm_itf;
    req.length = sizeof(*ci);
    req.arg = ci;
    error = ioctl(fd,ATM_GETCIRANGE,&req);
    (void) close(fd);
    if (error < 0) {
	diag(COMPONENT,DIAG_ERROR,"ioctl ATM_GETCIRANGE: %s",strerror(errno));
	return error;
    }
}

--- NEW FILE: io.h ---
/*
 * io.h - Ilmi input/output routines
 *
 * Written by Scott W. Shumate
 * 
 * Copyright (c) 1995-97 All Rights Reserved.
 * 
 * Permission to use, copy, modify and distribute this
 * software and its documentation is hereby granted,
 * provided that both the copyright notice and this
 * permission notice appear in all copies of the software,
 * derivative works or modified versions, and any portions
 * thereof, that both notices appear in supporting
 * documentation, and that the use of this software is
 * acknowledged in any publications resulting from using
 * the software.
 * 
 * I ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION AND DISCLAIMS ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS
 * SOFTWARE.
 */

#ifndef IO_H
#define IO_H

#include <sys/time.h>
#include <atm.h>
#include <linux/atmdev.h>
#include "asn_incl.h"
#include "rfc1155_smi.h"
#include "rfc1157_snmp.h"

#define MAX_ILMI_MSG 484

AsnOid *get_esi(int fd, int itf);
void update_nsap(int itf, AsnOid *netprefix, AsnOid *esi);
int wait_for_message(int fd, struct timeval *timeout);
int read_message(int fd, Message *message);
int send_message(int fd, Message *message);
int open_ilmi(int itf,const char *qos_spec);
int get_ci_range(struct atm_cirange *ci);

#endif

--- NEW FILE: mib.c ---
/*
 * mib.c - MIB Primitives
 *
 * Written by Scott W. Shumate
 * 
 * Copyright (c) 1995-97 All Rights Reserved.
 * 
 * Permission to use, copy, modify and distribute this
 * software and its documentation is hereby granted,
 * provided that both the copyright notice and this
 * permission notice appear in all copies of the software,
 * derivative works or modified versions, and any portions
 * thereof, that both notices appear in supporting
 * documentation, and that the use of this software is
 * acknowledged in any publications resulting from using
 * the software.
 * 
 * I ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION AND DISCLAIM ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS
 * SOFTWARE.
 */

#if HAVE_CONFIG_H
#include <config.h>
#endif

#include "mib.h"
#include "sysgroup.h"
#include "atmf_uni.h"
#include "util.h"
#include "atmd.h"

#include <unistd.h>		/* gethostname()	*/
#include <netdb.h>		/* gethostbyname()	*/

#define COMPONENT "MIB"

static Variable variables[] =
/* keep this sorted by the value of entry.name */
{
  { &sysDescr, getString, NULL, NULL, &sysDescrValue },
  { &sysObjectID, getOid, NULL, NULL, &sysObjectIDValue },
  { &sysUpTime, getUpTime, NULL, NULL, NULL },
  { &sysContact, getString, NULL, NULL, &sysContactValue },
  { &sysName, getString, NULL, NULL, &sysNameValue },
  { &sysLocation, getString, NULL, NULL, &sysLocationValue },
  { &sysServices, getInteger, NULL, NULL, &sysServicesValue },
  { &atmfPortIndex, getInteger, NULL, NULL, &atmfPortIndexValue },
  { &atmfPortMyIdentifier, getInteger, NULL, NULL, &atmfPortIndexValue },
  { &atmfMyIpNmAddress, getIpAddr, NULL, NULL, &atmfMyIpNmAddressValue },
  { &atmfMySystemIdentifier, getString, NULL, NULL, &atmfMySystemIdentifierValue },
  { &atmfAtmLayerMaxVpiBits, getVpiRange, NULL, NULL, &atmfAtmLayerMaxVpiBitsValue },
  { &atmfAtmLayerMaxVciBits, getVciRange, NULL, NULL, &atmfAtmLayerMaxVciBitsValue },
  { &atmfAtmLayerUniVersion, getInteger, NULL, NULL,
     &atmfAtmLayerUniVersionValue },
  { &atmfNetPrefixStatus, getNetPrefix, getnextNetPrefix, setNetPrefix, NULL },
  { NULL }
};

void MIBget(VarBindList *list, PDUInt *status, AsnInt *index)
{
  VarBind *varbind;
  Variable *var;
  AsnOidResult result;
  
  *index = 1;
  FOR_EACH_LIST_ELMT(varbind, list)
  {
    /* Find the first MIB object not lexigraphically less than the *
     * requested OID                                               */
    var = variables;
    while(var->name != NULL)
    {
      result = AsnOidCompare(var->name, &varbind->name);
      if(result != AsnOidLess)
	break;
      var++;
    }

    /* Call get if the requested OID is equal to a simple MIB object */    
    /* OR if the requested OID is a leaf of a complex MIB object */
    if((result == AsnOidEqual && var->getnext == NULL) ||
       (result == AsnOidRoot && var->getnext != NULL))
      *status = var->get(varbind, var);
    /* else the object was not found */
    else
      *status = NOSUCHNAME;
    
    /* Check if the get failed */
    if(*status != NOERROR)
      return;
    
    (*index)++;
  }
  *index = 0;
  return;
}
  

void MIBgetnext(VarBindList *list, PDUInt *status, AsnInt *index)
{
  VarBind *varbind;
  Variable *var;
  AsnOidResult result;

  *index = 1;
  FOR_EACH_LIST_ELMT(varbind, list)
  {
    /* Find the first complex MIB object not lexigraphically less than *
     * or simple MIB object greater than the requested OID            */
    var = variables;
    while(var->name != NULL)
    {
      result = AsnOidCompare(var->name, &varbind->name);
      if(var->getnext == NULL)
      {
	if(result == AsnOidGreater)
	  break;
      } else if(result != AsnOidLess)
	break;
      var++;
    }

    /* Find the next valid MIB object */
    for(*status = NOSUCHNAME;
	var->name != NULL && *status == NOSUCHNAME;
	var++)
      if(var->getnext == NULL)
      {
	varbind->name.octs = Asn1Alloc(var->name->octetLen);
	AsnOidCopy(&varbind->name, var->name);
	*status = var->get(varbind, var);
      }
      else
	*status = var->getnext(varbind, var);

    /* Check if no valid MIB object found */
    if(*status != NOERROR)
      return;
      
    (*index)++;
  }
  *index = 0;
  return;
}

void MIBset(VarBindList *list, PDUInt *status, AsnInt *index)
{
  VarBind *varbind;
  Variable *var;
  AsnOidResult result;

  *index = 1;
  FOR_EACH_LIST_ELMT(varbind, list)
  {
    /* Find the first MIB object not lexigraphically less than the *
     * requested OID                                               */
    var = variables;
    while(var->name != NULL)
    {
      result = AsnOidCompare(var->name, &varbind->name);
      if(result != AsnOidLess)
	break;
      var++;
    }

    /* Call set if the requested variable is equal to a simple MIB object */    
    if((result == AsnOidEqual && var->getnext == NULL) ||
    /* OR if the request variable is a leaf of a complex MIB object */
      (result == AsnOidRoot && var->getnext != NULL))
      /* Return read only if no set function exists */
      if(var->set == NULL)
	*status = READONLY;
      else
	*status = var->set(varbind, var);
    else
    /* else the MIB object was not found */
      *status = NOSUCHNAME;

    /* Check if the set failed */
    if(*status != NOERROR)
      return;
      
    (*index)++;
  }
  *index = 0;
  return;
}

void *MIBdelete(AsnOid *oid)
{
  Variable *var;
  void *value;
  AsnOidResult result;

  /* Find the first MIB object not lexigraphically less than the *
   * requested variable                                          */
    var = variables;
    while(var->name != NULL)
    {
      result = AsnOidCompare(var->name, oid);
      if(result != AsnOidLess)
	break;
      var++;
    }

  /* Return NULL if the MIB object is not found */
  if(result != AsnOidEqual)
    return NULL;

  value = var->value;
  var->value = NULL;

  return value;
}

AsnInt getString(VarBind *varbind, Variable *var)
{
  varbind->value = Asn1Alloc(sizeof(struct ObjectSyntax));
  varbind->value->choiceId = OBJECTSYNTAX_SIMPLE;
  varbind->value->a.simple = Asn1Alloc(sizeof(struct SimpleSyntax));
  varbind->value->a.simple->choiceId = SIMPLESYNTAX_STRING;
  varbind->value->a.simple->a.string = (AsnOcts*) var->value;
  return NOERROR;
}

AsnInt getOid(VarBind *varbind, Variable *var)
{
  varbind->value = Asn1Alloc(sizeof(struct ObjectSyntax));
  varbind->value->choiceId = OBJECTSYNTAX_SIMPLE;
  varbind->value->a.simple = Asn1Alloc(sizeof(struct SimpleSyntax));
  varbind->value->a.simple->choiceId = SIMPLESYNTAX_OBJECT;
  varbind->value->a.simple->a.object = (AsnOid*) var->value;
  return NOERROR;
}

AsnInt getInteger(VarBind *varbind, Variable *var)
{
  varbind->value = Asn1Alloc(sizeof(struct ObjectSyntax));
  varbind->value->choiceId = OBJECTSYNTAX_SIMPLE;
  varbind->value->a.simple = Asn1Alloc(sizeof(struct SimpleSyntax));
  varbind->value->a.simple->choiceId = SIMPLESYNTAX_NUMBER;
  varbind->value->a.simple->a.number = *((AsnInt *) var->value);
  return NOERROR;
}


#include <stdint.h>
#include <string.h>
#include <ctype.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <netinet/in.h>


#define MAX_ITFS 500


static const char *itf_types[] = {
    "",					/* fallback */
    "slip*","ppp*","eth*","lec*",	/* candidates */
    "atm*",
    "!lo",				/* blacklist */
    NULL				/* the end */
};


static uint32_t get_local_ip(void)
{
    struct ifconf ifc;
    struct ifreq ifr[MAX_ITFS];
    const char **best;
    uint32_t best_ip;
    int s,i;

    s = socket(PF_INET,SOCK_DGRAM,0);
    if (s < 0) {
	perror("socket");
	return 0;
    }
    ifc.ifc_len = MAX_ITFS*sizeof(struct ifreq);
    ifc.ifc_req = ifr;
    if (ioctl(s,SIOCGIFCONF,&ifc) < 0) {
	perror("SIOCGIFCONF");
	return 0;
    }
    best = itf_types;
    best_ip = 0;
    for (i = 0; i < ifc.ifc_len/sizeof(struct ifreq); i++) {
	struct sockaddr_in *addr;
	const char **walk;
	uint32_t ip;

	addr = (struct sockaddr_in *) &ifr[i].ifr_addr;
	if (addr->sin_family != AF_INET) continue;
	ip = addr->sin_addr.s_addr;
	if (!ip) continue;
	if (ioctl(s,SIOCGIFFLAGS,&ifr[i]) < 0) {
	    perror("SIOCGIFFLAGS");
	    continue;
	}
	if (ifr[i].ifr_flags & IFF_LOOPBACK) continue;
	if (!(ifr[i].ifr_flags & IFF_UP)) continue;
	for (walk = best+1; *walk; walk++) {
	    const char *pos,*wc,*end;
	    int not;

	    if ((not = *(pos = *walk) == '!')) pos++;
	    if (*pos) {
		int len;

		wc = strchr(pos,'*');
		end = wc ? wc : strchr(pos,0);
		len = end-pos;
		if (strncmp(ifr[i].ifr_name,pos,end-pos)) continue;
		if (len < IFNAMSIZ && ifr[i].ifr_name[len])
		    if (!wc || !isdigit(ifr[i].ifr_name[len])) continue;
	    }
	    if (not) break;
	    best = walk;
	    best_ip = ip;
	}
    }
    return best_ip;
}


static uint32_t local_ip = 0;


void set_local_ip(uint32_t ip)
{
    local_ip = ip;
}


AsnInt getIpAddr(VarBind *varbind, Variable *var)
{
  if (!local_ip) {
      local_ip = get_local_ip();
      if (!local_ip) {
	struct hostent* h;
	char hostname[128];

	if (!gethostname(hostname, sizeof(hostname)-1)) {
	    h = (struct hostent*) gethostbyname(hostname);
	    if (!h) local_ip = 0; /* give up :-( */
	    else memcpy(&local_ip,h->h_addr_list[0],4);
	}
      }
  }
  if (!((IpAddress*) var->value)->octs) {
      unsigned char *p;

      ((IpAddress *) var->value)->octs = p = alloc(4);
      memcpy(((IpAddress *) var->value)->octs,&local_ip,4);
      diag(COMPONENT,DIAG_DEBUG,"Local IP address is %d.%d.%d.%d",p[0],p[1],
	p[2],p[3]);
  }
  varbind->value = Asn1Alloc(sizeof(ObjectSyntax));
  varbind->value->choiceId = OBJECTSYNTAX_APPLICATION_WIDE;
  varbind->value->a.application_wide = Asn1Alloc(sizeof(ApplicationSyntax));
  varbind->value->a.application_wide->choiceId = APPLICATIONSYNTAX_ADDRESS;
  varbind->value->a.application_wide->a.address = Asn1Alloc(sizeof(NetworkAddress));
  varbind->value->a.application_wide->a.address->choiceId = NETWORKADDRESS_INTERNET;
  varbind->value->a.application_wide->a.address->a.internet = (IpAddress*) var->value;
  return NOERROR;
}


#include <atm.h>
#include <linux/atmdev.h>


static AsnInt put_ci(VarBind *varbind,Variable *var,
  struct atm_cirange *ci,char *bits)
{
  if (get_ci_range(ci) < 0) return GENERR;
  diag(COMPONENT,DIAG_DEBUG,"VPI: %d bits, VCI: %d bits",ci->vpi_bits,
    ci->vci_bits);
  varbind->value = Asn1Alloc(sizeof(struct ObjectSyntax));
  varbind->value->choiceId = OBJECTSYNTAX_SIMPLE;
  varbind->value->a.simple = Asn1Alloc(sizeof(struct SimpleSyntax));
  varbind->value->a.simple->choiceId = SIMPLESYNTAX_NUMBER;
  varbind->value->a.simple->a.number = *((AsnInt *) var->value) = *bits;
  return NOERROR;
}


AsnInt getVpiRange(VarBind *varbind, Variable *var)
{
  struct atm_cirange ci;

  return put_ci(varbind,var,&ci,&ci.vpi_bits);
}


AsnInt getVciRange(VarBind *varbind, Variable *var)
{
  struct atm_cirange ci;

  return put_ci(varbind,var,&ci,&ci.vci_bits);
}

--- NEW FILE: mib.h ---
/*
 * mib.h - MIB Primitives
 *
 * Written by Scott W. Shumate
 * 
 * Copyright (c) 1995-97 All Rights Reserved.
 * 
 * Permission to use, copy, modify and distribute this
 * software and its documentation is hereby granted,
 * provided that both the copyright notice and this
 * permission notice appear in all copies of the software,
 * derivative works or modified versions, and any portions
 * thereof, that both notices appear in supporting
 * documentation, and that the use of this software is
 * acknowledged in any publications resulting from using
 * the software.
 * 
 * I ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION AND DISCLAIM ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS
 * SOFTWARE.
 */

#ifndef MIB_H
#define MIB_H

#include "atmd.h"

#include "asn_incl.h"
#include "rfc1155_smi.h"
#include "rfc1157_snmp.h"

typedef struct Variable
{
  AsnOid *name;
  AsnInt (*get)(VarBind *varbind, struct Variable *var);
  AsnInt (*getnext)(VarBind *varbind, struct Variable *var);
  AsnInt (*set)(VarBind *varbind, struct Variable *var);
  void *value;
} Variable;

void MIBget(VarBindList *list, PDUInt *status, AsnInt *index);
void MIBgetnext(VarBindList *list, PDUInt *status, AsnInt *index);
void MIBset(VarBindList *list, PDUInt *status, AsnInt *index);
void *MIBdelete(AsnOid *oid);

AsnInt getString(VarBind *varbind, Variable *var);
AsnInt getOid(VarBind *varbind, Variable *var);
AsnInt getInteger(VarBind *varbind, Variable *var);
AsnInt getIpAddr(VarBind *varbind, Variable *var);
AsnInt getVpiRange(VarBind *varbind, Variable *var);
AsnInt getVciRange(VarBind *varbind, Variable *var);

void set_local_ip(uint32_t ip);

#endif

--- NEW FILE: atmf_uni.c ---
/*
 * atmf_uni.c - ATM Forum UNI MIB
 *
 * Written by Scott W. Shumate
 * 
 * Copyright (c) 1995-97 All Rights Reserved.
 * 
 * Permission to use, copy, modify and distribute this
 * software and its documentation is hereby granted,
 * provided that both the copyright notice and this
 * permission notice appear in all copies of the software,
 * derivative works or modified versions, and any portions
 * thereof, that both notices appear in supporting
 * documentation, and that the use of this software is
 * acknowledged in any publications resulting from using
 * the software.
 * 
 * I ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION AND DISCLAIM ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS
 * SOFTWARE.
 */

#if HAVE_CONFIG_H
#include <config.h>
#endif

#include "atmf_uni.h"
#include "atmd.h"
#include "util.h"

#define COMPONENT "NETPREFIX"
#define NETPREFIX_LEN 12
#define NETPREFIX_STRINGLEN '\15'
#define INDEX_LEN 15
#define LOCALUNI '\0'
#define VALID 1
#define INVALID 2

AsnOid atmfPortIndex =          {13, "\53\06\01\04\01\202\141\02\01\01\01\01\00"};
AsnOid atmfPortMyIdentifier =   {13, "\53\06\01\04\01\202\141\02\01\01\01\10\00"};
AsnOid atmfMyIpNmAddress =      {11, "\53\06\01\04\01\202\141\02\01\02\00"};
AsnOid atmfMySystemIdentifier = {11, "\53\06\01\04\01\202\141\02\01\04\00"};
AsnOid atmfAtmLayerMaxVpiBits = {13, "\53\06\01\04\01\202\141\02\02\01\01\6\00"};
AsnOid atmfAtmLayerMaxVciBits = {13, "\53\06\01\04\01\202\141\02\02\01\01\7\00"};
AsnOid atmfAtmLayerUniVersion = {13, "\53\06\01\04\01\202\141\02\02\01\01\11\00"};
AsnOid atmfNetPrefixStatus = {NETPREFIX_LEN, "\53\06\01\04\01\202\141\02\07\01\01\03"};

AsnInt atmfPortIndexValue = 0;
AsnOcts atmfMySystemIdentifierValue = {6 , NULL};
IpAddress atmfMyIpNmAddressValue = {4 , NULL};

/* The following two values depend on the capabilities of both
   the switch AND the adapter - DO THEY ?? */
AsnInt atmfAtmLayerMaxVpiBitsValue;
AsnInt atmfAtmLayerMaxVciBitsValue;


#if defined(UNI30) || defined(DYNAMIC_UNI)
AsnInt atmfAtmLayerUniVersionValue = 2;		// version3point0(2)
#else
#ifdef UNI31
AsnInt atmfAtmLayerUniVersionValue = 3;		// version3point1(3)
#else
AsnInt atmfAtmLayerUniVersionValue = 4;		// version4point0(4)
#endif
#endif

static AsnOid atmNetPrefix = {0, NULL};

typedef struct NetPrefixNode
{
  AsnOid *name;
  struct NetPrefixNode *prev;
  struct NetPrefixNode *next;
} NetPrefixNode;

AsnOid *accessNetPrefix(void)
{
  if(atmNetPrefix.octs == NULL)
    return NULL;

  return(&atmNetPrefix);
}

void deleteNetPrefix(void)
{
  NetPrefixNode *prefix, *nextPrefix;

  for(prefix = (NetPrefixNode *) MIBdelete(&atmfNetPrefixStatus);
      prefix != NULL;
      prefix = nextPrefix)
    {
      nextPrefix = prefix->next;
      free(prefix->name->octs);
      free(prefix->name);
      free(prefix);
    }

  if(atmNetPrefix.octs != NULL)
    {
      free(atmNetPrefix.octs);
      atmNetPrefix.octs = NULL;
    }
}

AsnInt getNetPrefix(VarBind *varbind, Variable *var)
{
  int cmp;
  NetPrefixNode *prefix;
  AsnOid *varBindName;

  varBindName = &varbind->name;
  if(AsnOidSize(varBindName) != NETPREFIX_LEN + INDEX_LEN ||
     varbind->name.octs[NETPREFIX_LEN] != LOCALUNI ||
     varbind->name.octs[NETPREFIX_LEN + 1] != NETPREFIX_STRINGLEN)
    return NOSUCHNAME;

  for(prefix = (NetPrefixNode *) var->value, cmp = AsnOidLess;
      prefix != NULL && (cmp = AsnOidCompare(varBindName, prefix->name)) <
	AsnOidEqual;
      prefix = prefix->next);

  if(cmp != AsnOidEqual)
    return NOSUCHNAME;

  varbind->value = Asn1Alloc(sizeof(struct ObjectSyntax));
  varbind->value->choiceId = OBJECTSYNTAX_SIMPLE;
  varbind->value->a.simple = Asn1Alloc(sizeof(struct SimpleSyntax));
  varbind->value->a.simple->choiceId = SIMPLESYNTAX_NUMBER;
  varbind->value->a.simple->a.number = VALID;
  return NOERROR;
}


AsnInt getnextNetPrefix(VarBind *varbind, Variable *var)
{
  NetPrefixNode *prefix;
  AsnOid *varBindName;

  varBindName = &varbind->name;
  for(prefix = (NetPrefixNode *) var->value;
      prefix != NULL && AsnOidCompare(prefix->name, varBindName) != AsnOidGreater;
      prefix = prefix->next);

  if(prefix == NULL)
    return NOSUCHNAME;

  varbind->name.octs = Asn1Alloc(prefix->name->octetLen);
  AsnOidCopy(varBindName, prefix->name);

  varbind->value = Asn1Alloc(sizeof(struct ObjectSyntax));
  varbind->value->choiceId = OBJECTSYNTAX_SIMPLE;
  varbind->value->a.simple = Asn1Alloc(sizeof(struct SimpleSyntax));
  varbind->value->a.simple->choiceId = SIMPLESYNTAX_NUMBER;
  varbind->value->a.simple->a.number = VALID;

  return NOERROR;
}

AsnInt setNetPrefix(VarBind *varbind, Variable *var)
{
  int cmp;
  NetPrefixNode *prefix, *newPrefix;
  AsnOid *varBindName;

  varBindName = &varbind->name;
  if(varbind->value->choiceId != OBJECTSYNTAX_SIMPLE ||
     varbind->value->a.simple->choiceId != SIMPLESYNTAX_NUMBER ||
     (varbind->value->a.simple->a.number != VALID && 
      varbind->value->a.simple->a.number != INVALID))
    return BADVALUE;
      
  if(AsnOidSize(varBindName) != NETPREFIX_LEN + INDEX_LEN ||
     varBindName->octs[NETPREFIX_LEN] != LOCALUNI || 
     varBindName->octs[NETPREFIX_LEN + 1] != NETPREFIX_STRINGLEN)
    return NOSUCHNAME;

  for(prefix = (NetPrefixNode *) var->value, cmp = AsnOidLess;
      prefix != NULL && (cmp = AsnOidCompare(varBindName, prefix->name)) <
	AsnOidEqual;
      prefix = prefix->next);

  if(varbind->value->a.simple->a.number == VALID && cmp != AsnOidEqual)
    {
      newPrefix = alloc_t(NetPrefixNode);
      newPrefix->name = alloc_t(AsnOid);
      newPrefix->name->octs = alloc(varBindName->octetLen);
      AsnOidCopy(newPrefix->name, varBindName);
      Q_INSERT_BEFORE((NetPrefixNode *) var->value, newPrefix, prefix);
      if(atmNetPrefix.octs == NULL)
	{
	  atmNetPrefix.octetLen = varBindName->octetLen - NETPREFIX_LEN - 2;
	  atmNetPrefix.octs = alloc(atmNetPrefix.octetLen);
	  memcpy(atmNetPrefix.octs, &varBindName->octs[NETPREFIX_LEN + 2], atmNetPrefix.octetLen);
	}
    }
  else if (varbind->value->a.simple->a.number == INVALID && cmp == AsnOidEqual)
    {
      Q_REMOVE((NetPrefixNode *) var->value, prefix);
    }

  return NOERROR;
}

--- NEW FILE: atmf_uni.h ---
/*
 * atmf_uni.h - ATM Forum UNI MIB
 *
 * Written by Scott W. Shumate
 * 
 * Copyright (c) 1995-97 All Rights Reserved.
 * 
 * Permission to use, copy, modify and distribute this
 * software and its documentation is hereby granted,
 * provided that both the copyright notice and this
 * permission notice appear in all copies of the software,
 * derivative works or modified versions, and any portions
 * thereof, that both notices appear in supporting
 * documentation, and that the use of this software is
 * acknowledged in any publications resulting from using
 * the software.
 * 
 * I ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION AND DISCLAIM ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS
 * SOFTWARE.
 */

#ifndef ATMF_UNI_H
#define ATMF_UNI_H

#include "asn_incl.h"
#include "rfc1155_smi.h"
#include "rfc1157_snmp.h"
#include "mib.h"

extern AsnOid atmfPortIndex;
extern AsnOid atmfPortMyIdentifier;
extern AsnOid atmfMyIpNmAddress;
extern AsnOid atmfMySystemIdentifier;
extern AsnOid atmfNetPrefixStatus;
extern AsnOid atmfAtmLayerMaxVpiBits;
extern AsnOid atmfAtmLayerMaxVciBits;
extern AsnOid atmfAtmLayerUniVersion;

extern AsnInt atmfPortIndexValue;
extern IpAddress atmfMyIpNmAddressValue;
extern AsnOcts atmfMySystemIdentifierValue;
extern AsnInt atmfAtmLayerMaxVpiBitsValue;
extern AsnInt atmfAtmLayerMaxVciBitsValue;
extern AsnInt atmfAtmLayerUniVersionValue;

AsnOid *accessNetPrefix(void);
void deleteNetPrefix(void);
AsnInt getNetPrefix(VarBind *varbind, Variable *var);
AsnInt getnextNetPrefix(VarBind *varbind, Variable *var);
AsnInt setNetPrefix(VarBind *varbind, Variable *var);
AsnInt getMyIp(VarBind *varbind, Variable *var);

#endif

--- NEW FILE: Makefile.am ---
SUBDIRS = asn1

INCLUDES = -I$(top_builddir)/src/ilmid/asn1

sbin_PROGRAMS = ilmid

ilmid_SOURCES = rfc1157_snmp.c rfc1157_snmp.h rfc1155_smi.c rfc1155_smi.h \
			util.c util.h io.c io.h message.c message.h \
			atmf_uni.c atmf_uni.h mib.c mib.h \
			sysgroup.c sysgroup.h ilmid.c
ilmid_LDADD = $(top_builddir)/src/lib/libatmd.la \
		$(top_builddir)/src/lib/libatm.la \
		$(top_builddir)/src/ilmid/asn1/libasn1.a
ilmid_DEPENDENCIES = $(ilmid_LDADD)

EXTRA_DIST = COPYRIGHT


--- NEW FILE: sysgroup.c ---
/*
 * sysgroup.c - MIB-II system group
 *
 * Written by Scott W. Shumate
 * 
 * Copyright (c) 1995-97 All Rights Reserved.
 * 
 * Permission to use, copy, modify and distribute this
 * software and its documentation is hereby granted,
 * provided that both the copyright notice and this
 * permission notice appear in all copies of the software,
 * derivative works or modified versions, and any portions
 * thereof, that both notices appear in supporting
 * documentation, and that the use of this software is
 * acknowledged in any publications resulting from using
 * the software.
 * 
 * I ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS IS"
 * CONDITION AND DISCLAIM ANY LIABILITY OF ANY KIND FOR
 * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS
 * SOFTWARE.
 */

#if HAVE_CONFIG_H
#include <config.h>
#endif

#include <time.h>
#include "sysgroup.h"
#include "string.h"

AsnOid sysDescr = {8, "\53\06\01\02\01\01\01\00"};
AsnOid sysObjectID = {8, "\53\06\01\02\01\01\02\00"};
AsnOid sysUpTime = {8, "\53\06\01\02\01\01\03\00"};
AsnOid sysContact = {8, "\53\06\01\02\01\01\04\00"};
AsnOid sysName = {8, "\53\06\01\02\01\01\05\00"};
AsnOid sysLocation = {8, "\53\06\01\02\01\01\06\00"};
AsnOid sysServices = {8, "\53\06\01\02\01\01\07\00"};

AsnOcts sysDescrValue = {25, "ATM on Linux Version " VERSION};
AsnOid sysObjectIDValue = {8, "\53\06\01\04\01\03\01\01"};
AsnOcts sysContactValue = {14, "root@localhost"};
AsnOcts sysNameValue = {23, "local...
 
[truncated message content]