snmpnat.c

nat PNE 3.3 source code, running at more than vxworks6.x version.

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

    /* Get the instance portion of the OID */

    snmpOidToIpHostOrder (IP_ADDR_LEN, tlist , &data.natBindLocalAddress);
    snmpOidToIpHostOrder (IP_ADDR_LEN, tlist + 
                          NAT_BINDTBL_REMOTE_ADDRESS_OFFSET, 
                          &data.natBindRemAddress);
    data.natBindLocalPort = *(tlist + IP_ADDR_LEN);
    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;
            }
        }

    vbp->undoproc = (UNDOPROC_T *) natBindEntryUndo;

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

    if (m2NatBindTblEntrySet (&data , varToSet) != OK)
        {
        /*
         * Commit failed so we should remove the undo buffer, else when
         * the undo is done we might end up with an undo failed error
         * instead of commit failed.
         */
        snmpVbPrivFree (vbp);
        setproc_error (pktp, vbp, COMMIT_FAILED);
        DBG_PRINT (("natBindEntrySet: Commit failed"));
        return;
        }

    setproc_good (pktp, vbp);
    return;
    }

/******************************************************************************
*  natBindEntryUndo -
*
*  Undo routine for natBindEntry table 
*
*  Parameters to this routine are
* 
*  <lastmatch> - the last oid component that was matched to get to this leaf.
*  <tlist>     - 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
*/

LOCAL void natBindEntryUndo
    (
    OIDC_T              lastmatch,
    int                 tcount,
    OIDC_T *            tlist,
    SNMP_PKT_T *        pktp,
    VB_T *              vbp
    )
    {
    undoproc_good (pktp, vbp);
    DBG_PRINT(("natBindEntryUndo returns ok\n"));
    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;
    OIDC_T     *tlistTemp;

    /* Check if the instance len is correct */

    if (tcount != NAT_SESSTBL_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.
     */
    if ( (unsigned int)(*(tlist + IP_ADDR_LEN)) > 0xffff ||
         (unsigned int)(*(tlist + NAT_SESSTBL_REMOTE_PORT_OFFSET)) > 0xffff)
        {
        for ( ; vbp; vbp = vbp->vb_link)
            {
            getproc_nosuchins(pktp, vbp);
	    }
        DBG_PRINT(("natSessionEntryGet: Error local port %d, remote port %d\n", 
             (unsigned int)(*(tlist + IP_ADDR_LEN)),
             (unsigned int)(*(tlist + NAT_SESSTBL_REMOTE_PORT_OFFSET)) ));
        return;
        }
        
    for (tlistTemp = tlist; tlistTemp < (tlist + IP_ADDR_LEN); tlistTemp++)
        {
        if ( (unsigned int)(*tlistTemp) > 0xff )
            {
            for ( ; vbp; vbp = vbp->vb_link)
	        {
                getproc_nosuchins(pktp, vbp);
	        }
	    DBG_PRINT(("natSessionEntryGet: Error local addr: 0x%x\n", 
	             (unsigned int)(*tlistTemp)));
            return;
            }
        }

    for (tlistTemp = (tlist + NAT_SESSTBL_REMOTE_ADDRESS_OFFSET); 
         tlistTemp < (tlist + NAT_SESSTBL_REMOTE_ADDRESS_OFFSET + IP_ADDR_LEN);
         tlistTemp++)
        {
        if ((unsigned int)(*tlistTemp)> 0xff )
            {
            for ( ; vbp; vbp = vbp->vb_link)
	        {
                getproc_nosuchins(pktp, vbp);
	        }
	    DBG_PRINT(("natSessionEntryGet: Error remote addr: 0x%x\n", 
	            (unsigned int)(*tlistTemp) ));
            return;
            }
        }

    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; 
    OIDC_T *tlistTemp;
    BOOL       overFlow = FALSE;
                   

   /* 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
        {
        if ( (unsigned int)(*(tlist + IP_ADDR_LEN)) <= 0xffff )     
            data.natSessionLocalPort = *(tlist + IP_ADDR_LEN);
        else
            {
            data.natSessionLocalPort = 0xffff;
            overFlow = TRUE;
            }
            
        if ( (unsigned int)(*(tlist + NAT_SESSTBL_REMOTE_PORT_OFFSET)) 
               <= 0xffff)    
            data.natSessionRemPort = *(tlist + NAT_SESSTBL_REMOTE_PORT_OFFSET);
        else
            {
            data.natSessionRemPort = 0xffff;
            overFlow = TRUE;
            }
           
        for (tlistTemp = tlist; tlistTemp < (tlist + IP_ADDR_LEN); tlistTemp++)
            {
            if ((unsigned int)(*tlistTemp) > 0xff)
                {
                *tlistTemp = 0xff;
                overFlow = TRUE;
                }
            }

        snmpOidToIpHostOrder (IP_ADDR_LEN, tlist , 
            &data.natSessionLocalAddress);

        for (tlistTemp = (tlist + NAT_SESSTBL_REMOTE_ADDRESS_OFFSET); 
             tlistTemp < (tlist + NAT_SESSTBL_REMOTE_ADDRESS_OFFSET + 
             IP_ADDR_LEN); tlistTemp++)
            {
            if ((unsigned int)(*tlistTemp) > 0xff)
                {
                *tlistTemp = 0xff;
                overFlow = TRUE;
                }
            }

        snmpOidToIpHostOrder (IP_ADDR_LEN, tlist + 
                              NAT_SESSTBL_REMOTE_ADDRESS_OFFSET, 
                              &data.natSessionRemAddress);

        DBG_PRINT(("natSessionEntryNext: processed session local addr:"
            "0x%x, remote addr: 0x%x, localport %d, remport %d\n", 
            (unsigned int)data.natSessionLocalAddress, 
            (unsigned int)data.natSessionRemAddress,
            data.natSessionLocalPort,data.natSessionRemPort));
        }

    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;

    if (overFlow)
        {
        /* the current oid is greater or eaqual to the result oid, wrong*/
        while (oidcmp2(NAT_SESSTBL_INDEX_LEN, tlist, NAT_SESSTBL_INDEX_LEN,
               natSessionIndex) >=0 )
            {
            DBG_PRINT(("natSessionEntryNext: search next when overflow\n"));

	    /* IP addresses in data are in network order after the last
             * m2NatSessTblEntryGet call. But must call m2NatSessTblEntryGet
             * with data in host order 
             */
            data.natSessionLocalAddress = ntohl(data.natSessionLocalAddress);
            data.natSessionRemAddress = ntohl(data.natSessionRemAddress);

            if ( m2NatSessTblEntryGet (&data, NEXT_VALUE ) != OK)
	            {
	            for ( ; vbp != NULL; vbp = vbp->vb_link)
	                {
	                snmpNextError (pktp, vbp);
                    }
                    DBG_PRINT(("natSessionEntryNext: next not found\n"));
	            return;
	            }
        
            (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;
            }
        }

    DBG_PRINT(("natSessionEntryNext: got next local addr: 0x%x, remote addr:"
        "0x%x, localport %d, remport %d\n", 
        (unsigned int)data.natSessionLocalAddress, 
        (unsigned int)data.natSessionRemAddress,
        data.natSessionLocalPort,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);
        }
    }