snmp1473.c

这是全套的PPP协议的源码

/* snmp1473.c - snmp v1 RFC 1473 routines */

/* Copyright 1984-2000 Wind River Systems, Inc. */
#include "copyright_wrs.h"

/*
modification history
--------------------
01a,13apr00,abd created
*/

/*
DESCRIPTION
Method routines implementing RFC 1473:

Method routines for the pppIpTable:


pppIpOperStatus -- read-only
The operational status of the IP network
protocol. If the value of this object is up
then the finite state machine for the IP
network protocol has reached the Opened state.Make1473

pppIpLocalToRemoteCompressionProtocol -- read-only
The IP compression protocol that the local
PPP-IP entity uses when sending packets to the
remote PPP-IP entity. The value of this object
is meaningful only when the link has reached
the open state (pppIpOperStatus is opened).

pppIpRemoteToLocalCompressionProtocol -- read-only
The IP compression protocol that the remote
PPP-IP entity uses when sending packets to the
local PPP-IP entity. The value of this object
is meaningful only when the link has reached
the open state (pppIpOperStatus is opened).

pppIpRemoteMaxSlotId -- read-only
The Max-Slot-Id parameter that the remote node
has advertised and that is in use on the link.
If vj-tcp header compression is not in use on
the link then the value of this object shall be
0. The value of this object is meaningful only
when the link has reached the open state
(pppIpOperStatus is opened).

pppIpLocalMaxSlotId -- read-only
The Max-Slot-Id parameter that the local node
has advertised and that is in use on the link.
If vj-tcp header compression is not in use on
the link then the value of this object shall be
0. The value of this object is meaningful only
when the link has reached the open state
(pppIpOperStatus is opened).

Method routines for the pppIpConfigTable:

pppIpConfigAdminStatus -- read-write
The immediate desired status of the IP network
protocol. Setting this object to open will
inject an administrative open event into the IP
network protocol's finite state machine.
Setting this object to close will inject an
administrative close event into the IP network
protocol's finite state machine.

pppIpConfigCompression -- read-write
If none(1) then the local node will not
attempt to negotiate any IP Compression option.
Otherwise, the local node will attempt to
negotiate compression mode indicated by the
enumerated value. Changing this object will
have effect when the link is next restarted.

INCLUDE FILES: ppp/m2pppLib.h ppp/m2pppIpcpGroup.h 
ppp/interfaces/ipcpInterfaces.h ppp/pppInterfaces.h
*/

/* includes */

#include <asn1conf.h>
#include <asn1.h>
#include <buffer.h>
#include <mib.h>
#include <snmpdefs.h> 
#include <snmp.h>
#include <auxfuncs.h>
#include <leaf1473.h>
#include <snmp1473.h>
#include <wrn/wm/snmp/vxagent/snmpdLib.h>

#include "pfw/pfw.h"
#include "pfw/pfwStack.h"
#include "pfw/pfwTable.h"
#include "pfw/pfwMemory.h"
#include "ppp/m2pppLib.h"
#include "ppp/m2pppIpcpGroup.h"
#include "ppp/interfaces/ipcpInterfaces.h"
#include "ppp/pppInterfaces.h"

#include "stdio.h"
#include "vxWorks.h"

/* typedefs */

typedef struct pppIpConfigEntryPresetData
    {
    VB_T *                  pGroupHead;
    PPP_IPCP_ENTRY_DATA     referenceData;
    UINT8                   previousPppIpConfigAdminStatus;
    UINT8                   previousPppIpConfigCompression;
    }   PPP_IP_CONFIG_ENTRY_PRESET_DATA;
    
/* defines */

#define pppIpEntry_INSTANCE_LEN 1   /* Number of pppIpConfigEntry 
                                     * oid components 
                                     */
#define pppIpConfigEntry_INSTANCE_LEN 1   /* Number of pppIpConfigEntry 
                                           * oid components 
                                           */

/* locals */
/* externs */
/* forward declarations */

LOCAL void pppIpEntryInfoGet    
    (
    OIDC_T                   lastmatch,
    SNMP_PKT_T *             pktp,
    VB_T *                   vbp,
    PPP_IPCP_ENTRY_DATA *    pData
    );

LOCAL void pppIpConfigEntryInfoGet    
    (
    OIDC_T                   lastmatch,
    SNMP_PKT_T *             pktp,
    VB_T *                   vbp,
    PPP_IPCP_ENTRY_DATA *    pData
    );

LOCAL void pppIpConfigEntrySetUndo
    (
    OIDC_T          lastmatch, 
    int             compc,
    OIDC_T *        compl,
    SNMP_PKT_T *    pktp, 
    VB_T *          vbp   
    );

/***************************************************************************
* pppIpEntryInfoGet - populate packet pppIpTable varbinds
*
* RETURNS N/A
*
* NOMANUAL
*/
LOCAL void pppIpEntryInfoGet
    (
    OIDC_T                   lastmatch, /* leaf subidentifier               */
    SNMP_PKT_T *             pktp,      /* packet pointer                   */
    VB_T *                   vbp,       /* varbind pointer                  */
    PPP_IPCP_ENTRY_DATA *    pData      /* internal data structure pointer  */
    ) 
    {
    switch(lastmatch) 
        {
        case LEAF_pppIpOperStatus:
            getproc_got_int32(pktp, 
                              vbp, 
                              (*((pData->interface)->
                                 ipcpOperStatusGet))
                              (pData->state));
                              /* Values:
                               * opened(1)
                               * not-opened(2)
                               */
            return;
        case LEAF_pppIpLocalToRemoteCompressionProtocol:
            getproc_got_int32(pktp, 
                              vbp, 
                              (*((pData->interface)->
                                 ipcpLocalToRemoteCompressionProtocolGet))
                              (pData->state));
                              /* Values:
                               * none(1)
                               * vj-tcp(2)
                               */
            return;
        case LEAF_pppIpRemoteToLocalCompressionProtocol:
            getproc_got_int32(pktp, 
                              vbp, 
                              (*((pData->interface)->
                                 ipcpRemoteToLocalCompressionProtocolGet))
                              (pData->state));
                              /* Values:
                               * none(1)
                               * vj-tcp(2)
                               */
            return;
        case LEAF_pppIpRemoteMaxSlotId:
            getproc_got_int32(pktp, 
                              vbp, 
                              (*((pData->interface)->
                                 ipcpRemoteMaxSlotIdGet))
                              (pData->state));
                              /* Values:
                               * integer 0..255
                               */
            return;
        case LEAF_pppIpLocalMaxSlotId:
            getproc_got_int32(pktp, 
                              vbp, 
                              (*((pData->interface)->
                                 ipcpLocalMaxSlotIdGet))
                              (pData->state));
                              /* Values:
                               * integer 0..255
                               */
            return;
        default:
            getproc_error(pktp, vbp, GEN_ERR);
            return;
        }
    }

/***************************************************************************
* pppIpEntryGet - Get routine for pppIpEntry columnar objects
*
* A columnar object instance is identified by an instance identifier.
* An instance identifier consists of the object identifier and the sequence of
* index values. The object identifier consists of the object identifier
* of the tabular entry (in this case the OID for pppIpEntry) and the 
* leaf subindentifier. In our case the table pppIpTable is indexed by
* only one index, the index being ifIndex which is not a leaf value.
* OIDC stands for Object Identifier Component. Compc stands for component
* count and it counts the number of components that comprise the index
* values part of the instance identifier. Compl stands for components left 
* and it is the index values array.
*
* RETURNS N/A
*/
void pppIpEntryGet
    (
    OIDC_T          lastmatch,  /* leaf subindentifier  */
    int             compc,      /* should be 1          */
    OIDC_T *        compl,      /* pointer to ifIndex   */
    SNMP_PKT_T *    pktp,       /* packet pointer       */
    VB_T *          vbp         /* varbind list head    */
    )
    {
    PPP_IPCP_ENTRY_DATA data;  
    UINT32 ifIndex;

    /* find all the varbinds that share the same getproc and instance */
    snmpdGroupByGetprocAndInstance(pktp, vbp, compc, compl);

    if  ((compc != 1) || (NULL == compl))
        {
        for ( ; vbp; vbp = vbp->vb_link)
            {
            getproc_nosuchins(pktp, vbp);
            }
        return;
        }

    ifIndex = *compl;
    /* so that *compl will be const i.e. unaltered after the call */

    if  (m2pppIpcpEntryLookup(compc, &ifIndex, &data, M2_PPP_ENTRY_EXACT_MATCH) 
         /* use the instance (compc and compl) to look up the entry */
         != OK) 
        {
        for ( ; vbp; vbp = vbp->vb_link)
            {
            getproc_nosuchins(pktp, vbp);
            }
        }
    else 
        {
        /* retrieve all the values from the same data structure */
        for ( ; vbp; vbp = vbp->vb_link) 
            {
            pppIpEntryInfoGet(vbp->vb_ml.ml_last_match, pktp, vbp, &data);
            }
        }
    return;
    }

/***************************************************************************
* pppIpEntryNext - GetNext routine for pppIpEntry columnar objects
*
* A columnar object instance is identified by an instance identifier.
* An instance identifier consists of the object identifier and the sequence of
* index values. The object identifier consists of the object identifier
* of the tabular entry (in this case the OID for pppIpEntry) and the 
* leaf subindentifier. In our case the table pppIpTable is indexed by
* only one index, the index being ifIndex which is not a leaf value.
* OIDC stands for Object Identifier Component. Compc stands for component
* count and it counts the number of components that comprise the index
* values part of the instance identifier. Compl stands for components left