snmpnat.c

vxworks下ppp的实现源码

                
                    default:
                        errorStatus = WRONG_VALUE;
                        goto errorReturn;
                    }
                break;
        
            case LEAF_natBindAction:
                switch (VB_GET_INT32(pVbpTemp)) 
                    {
                    case VAL_natBindAction_active:
                    case VAL_natBindAction_notInService:
                    case VAL_natBindAction_notReady:
                    case VAL_natBindAction_createAndGo:
                    case VAL_natBindAction_createAndWait:
                    case VAL_natBindAction_destroy:
                        break;

                    default:
                        errorStatus = WRONG_VALUE;
                        goto errorReturn;
                    }
                break;
            
            default:
                errorStatus = WRONG_VALUE;
                goto errorReturn;
            }
        }

    testproc_good (pktp, vbp);
    return;


errorReturn:
    testproc_error (pktp, vbp, errorStatus);
    return;
    }


/******************************************************************************
*  natBindEntrySet -  Set method routine for natBindTable.
*
*  Parameters to this routine are
*
*  <lastmatch> - the last oid component that was matched to get to this leaf.
*  <tcount>     - count of components remaining in the unmatched portion i.e.
*                the length of the instance portion.
*  <tlist>     - ptr to the oid sequence remaining, i.e. the instance portion.
*  <pktp>      - ptr to internal representation of the snmp pkt.
*  <vbp>       - ptr to var bind being processed.
*
*  NOMANUAL
*
*  RETURNS: N/A
*/


void natBindEntrySet
    (
    OIDC_T      lastmatch,
    int         tcount,
    OIDC_T     *tlist,
    SNMP_PKT_T *pktp,
    VB_T       *vbp
    )
    {
    NAT_BINDTBL_ENTRY data;  
    int               varToSet = 0;                  
    VB_T *            pVbpTemp = vbp;

    /* Copy the data from the varbind fields */

    bzero ((char *)&data, sizeof (NAT_BINDTBL_ENTRY));

    /* Get the instance portion of the OID */

    snmpOidToIpHostOrder (IP_ADDR_LEN, tlist , &data.natBindLocalAddress);
    data.natBindLocalPort = *(tlist + IP_ADDR_LEN);
    snmpOidToIpHostOrder (IP_ADDR_LEN, tlist + 
                          NAT_BINDTBL_REMOTE_ADDRESS_OFFSET, 
                          &data.natBindRemAddress);
    data.natBindRemPort = *(tlist + NAT_BINDTBL_REMOTE_PORT_OFFSET);

    for ( ; pVbpTemp; pVbpTemp = pVbpTemp->vb_link) 
        {
        switch (pVbpTemp->vb_ml.ml_last_match) 
	    {
            case LEAF_natBindProto:
                data.natBindProto = VB_GET_INT32(pVbpTemp);            
                varToSet |= NAT_BIND_PROTO;
                break;

            case LEAF_natBindAction:
                data.natBindAction = VB_GET_INT32(pVbpTemp);          
                varToSet |= NAT_BIND_ACTION;
                break;

            default:
                setproc_error(pktp, pVbpTemp, COMMIT_FAILED);
                return;
            }
        }

    /* Call the m2 routine to do the commit */

    if (m2NatBindTblEntrySet (&data , varToSet) != OK)
        {
        setproc_error (pktp, vbp, COMMIT_FAILED);
        return;
        }

    setproc_good (pktp, vbp);
    return;
    }


 
 /******************************************************************************
 *  natSessionEntryGetValue -  Routine to extract info from natSession table
 *
 *  <lastmatch> - the last oid component that was matched to get to this leaf.
 *  <pktp>      - ptr to internal representation of the snmp pkt.
 *  <vbp>       - ptr to var bind being processed.
 *  <pData>     - ptr to NAT_SESSTBL_ENTRY structure containing the info 
 *                required for this instance.
 *
 *  RETURNS: N/A
 */
static int natSessionEntryGetValue
    (
    OIDC_T      lastmatch,
    SNMP_PKT_T *pktp,
    VB_T       *vbp,
    NAT_SESSTBL_ENTRY *pData
    )
    {
    switch(lastmatch) {
         case LEAF_natSessionProto:
             /* Values:
              *  tcp(1)  = VAL_natSessionProto_tcp
              *  udp(2)  = VAL_natSessionProto_udp
              *  icmp(3) = VAL_natSessionProto_icmp
              */
             getproc_got_int32(pktp, vbp, pData->natSessionProto);   
             break;
         
         case LEAF_natSessionLocalAddress:
             getproc_got_ip_address(pktp, vbp, pData->natSessionLocalAddress); 
             break;
             
         case LEAF_natSessionLocalPort:
             getproc_got_int32(pktp, vbp, pData->natSessionLocalPort);    
             break;
             
         case LEAF_natSessionRemAddress:
             getproc_got_ip_address(pktp, vbp, pData->natSessionRemAddress);    
             break;
            
         case LEAF_natSessionRemPort:
             getproc_got_int32(pktp, vbp, pData->natSessionRemPort);    
             break;
             
         case LEAF_natXSessionLocalAddress:
             getproc_got_ip_address(pktp, vbp, pData->natXSessionLocalAddress);
             break;
             
         case LEAF_natXSessionLocalPort:
             getproc_got_int32(pktp, vbp, pData->natXSessionLocalPort);    
             break;
             
         case LEAF_natXSessionRemAddress:
             getproc_got_ip_address(pktp, vbp, pData->natXSessionRemAddress);    
             break;
             
         case LEAF_natXSessionRemPort:
             getproc_got_int32(pktp, vbp, pData->natXSessionRemPort);    
             break;
             
         case LEAF_natSessionEnd:
             /* Values:
              *  other(1)       = VAL_natSessionEnd_other
              *  noheuristic(2) = VAL_natSessionEnd_noheuristic
              *  idletime(3)    = VAL_natSessionEnd_idletime
              *  extagent(4)    = VAL_natSessionEnd_extagent
              */
              getproc_got_int32(pktp, vbp, pData->natSessionEnd);    
              break;
              
         case LEAF_natSessionIdleTimeLeft:
             getproc_got_int32(pktp, vbp, pData->natSessionIdleTimeLeft);    
             break;
              
         case LEAF_natSessionPacketModifier:
             /* Values:
              *  noModifier(1) = VAL_natSessionPacketModifier_noModifier
              *  ipModifier(2) = VAL_natSessionPacketModifier_ipModifier
              */
             getproc_got_int32(pktp, vbp, pData->natSessionPacketModifier);    
             break;
             
         case LEAF_natSessionDirection:
             /* Values:
              *  outbound(1) = VAL_natSessionDirection_outbound
              *  inbound(2)  = VAL_natSessionDirection_inbound
              */
             getproc_got_int32(pktp, vbp, pData->natSessionDirection);    
             break;
             
         case LEAF_natSessionContrAgent:
             getproc_got_int32(pktp, vbp, pData->natSessionContrAgent);    
             break;
             
         default:
             return GEN_ERR;
    }
    return NO_ERROR;
    }


/******************************************************************************
*  natSessionEntryGet -   Get method routine for  natSessionTable.
* 
*  Parameters to this routine are
* 
*  <lastmatch> - the last oid component that was matched to get to this leaf.
*  <tcount>     - count of components remaining in the unmatched portion i.e.
*                the length of the instance portion.
*  <tlist>     - ptr to the oid sequence remaining, i.e. the instance portion.
*  <pktp>      - ptr to internal representation of the snmp pkt.
*  <vbp>       - ptr to var bind being processed.
*
*  NOMANUAL
*
*  RETURNS: N/A
*/
   

void natSessionEntryGet
    (
    OIDC_T      lastmatch,
    int         tcount,
    OIDC_T     *tlist,
    SNMP_PKT_T *pktp,
    VB_T       *vbp
    )
    {
    NAT_SESSTBL_ENTRY data;                          
    int               error;

    /* Check if the instance len is correct */

    if (tcount != NAT_BINDTBL_INSTANCE_LEN)
	{
        for ( ; vbp; vbp = vbp->vb_link)
            {
            getproc_nosuchins(pktp, vbp);
	    }
        return;
	}

    /* find all the varbinds that share the same getproc and instance */
    
    group_by_getproc_and_instance(pktp, vbp, tcount, tlist);

    /* use the instance (tcount and tlist) to look up the entry in the
     * table.
     */

    bzero ((char *)&data, sizeof (data));

    data.natSessionLocalPort = *(tlist + IP_ADDR_LEN);
    data.natSessionRemPort = *(tlist + NAT_SESSTBL_REMOTE_PORT_OFFSET);
    
    if ( snmpOidToIpHostOrder (IP_ADDR_LEN, tlist ,
                              &data.natSessionLocalAddress) || 
        snmpOidToIpHostOrder (IP_ADDR_LEN, tlist + 
                              NAT_SESSTBL_REMOTE_ADDRESS_OFFSET, 
                              &data.natSessionRemAddress) || 
        (m2NatSessTblEntryGet  (&data , GET_VALUE) != OK) )
	{
        for ( ; vbp; vbp = vbp->vb_link)
	    {
            getproc_nosuchins(pktp, vbp);
	    }
        return;
        }
     else 
	{
        /* retrieve all the values from the same data structure */

        for ( ; vbp; vbp = vbp->vb_link) 
	    {
            if ((error = natSessionEntryGetValue (vbp->vb_ml.ml_last_match,
                                                  pktp, vbp, &data)) 
                                                  != NO_ERROR)
                getproc_error(pktp, vbp, error);
            }
        }
    }
    

/******************************************************************************
*  natSessionEntryNext -
*
*  Next method routine for  nat session group tabular variables.
*
*  Parameters to this routine are
* 
*  <lastmatch> - the last oid component that was matched to get to this leaf.
*  <tcount>     - count of components remaining in the unmatched portion i.e.
*                the length of the instance portion.
*  <tlist>     - ptr to the oid sequence remaining, i.e. the instance portion.
*  <pktp>      - ptr to internal representation of the snmp pkt.
*  <vbp>       - ptr to var bind being processed.
*
*
*  RETURNS: N/A
* 
*/
   
void natSessionEntryNext
    (
    OIDC_T      lastmatch,
    int         tcount,
    OIDC_T     *tlist,
    SNMP_PKT_T *pktp,
    VB_T       *vbp
    )
    {

    OIDC_T             natSessionIndex[NAT_SESSTBL_INDEX_LEN]; 
    NAT_SESSTBL_ENTRY  data;                    

   /* find all the varbinds that share the same getproc and instance */

    group_by_getproc_and_instance(pktp, vbp, tcount, tlist);
            
            
    if (tcount == 0 )
        {
        bzero((char *)&data, sizeof(data));
        }
    else
        {
        snmpOidToIpHostOrder (IP_ADDR_LEN, tlist,
                              &data.natSessionLocalAddress);
        data.natSessionLocalPort = *(tlist + IP_ADDR_LEN);
        snmpOidToIpHostOrder (IP_ADDR_LEN, tlist + 
                              NAT_SESSTBL_REMOTE_ADDRESS_OFFSET, 
                              &data.natSessionRemAddress);
        data.natSessionRemPort = *(tlist + NAT_SESSTBL_REMOTE_PORT_OFFSET);
        }

    if ( m2NatSessTblEntryGet (&data, NEXT_VALUE ) != OK)
	{
	for ( ; vbp != NULL; vbp = vbp->vb_link)
	    {
	    snmpNextError (pktp, vbp);
            }
	    return;
	}

    /* Create oid sequence for nat index retrieved */
    

    (void) ip_to_rlist (data.natSessionLocalAddress, natSessionIndex);
    (void) ip_to_rlist (data.natSessionRemAddress, 
                        natSessionIndex + NAT_SESSTBL_REMOTE_ADDRESS_OFFSET) ;

    *(natSessionIndex + IP_ADDR_LEN) = data.natSessionLocalPort;
    *(natSessionIndex + NAT_SESSTBL_REMOTE_PORT_OFFSET) = data.natSessionRemPort;

    for (    ; vbp; vbp = vbp->vb_link)
        {   
        /* install instance part of next instance found */

        nextproc_next_instance (pktp, vbp, NAT_SESSTBL_INDEX_LEN, 
                                natSessionIndex); 

        natSessionEntryGetValue (vbp->vb_ml.ml_last_match, pktp, vbp, &data);
        }
    }