pxy3_chk.c

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

                     agentIp,
                     generic,
                     specific,
                     timeStamp,
                     vbCount);

                if (pNewPkt == 0)
                    {
                    proxyBlockClean (pProxyBlock);
                    return (ENVOY_ERR_UNKNOWN);
                    }

                pTargList->pktp = pNewPkt;

                if (ENVOY_TADDRESS_TO_SNMPADDR (&(pTargList->for_addr),
                                                &(pTargList->tdomain),
                                                &(pTargList->taddress)) != 0)
                    {
                    proxyBlockClean (pProxyBlock);
                    return (ENVOY_ERR_UNKNOWN);
                    }

                if (oidcmp (pTargList->tdomain.num_components,
                            pTargList->tdomain.component_list,
                            sizeof_snmpUDPDomain,
                            snmpUDPDomain) == 0)
                    {
                    /*
                     * This trap is not being sent via UDP, so we
                     * need to leave the agent IP address blank.
                     */
                    MEMSET (pNewPkt->pdu.trap_pdu.net_address, 0, 4);
                    }

                break;
#endif
#if INSTALL_ENVOY_SNMP_VERSION_2
            case SNMP_VERSION_2:
                if (pPkt->snmp_version == SNMP_VERSION_1)
                    vbCount = pPkt->pdu.trap_pdu.trap_vbl.vbl_count + 5;
                else
                    vbCount = pPkt->pdu.std_pdu.std_vbl.vbl_count;
                pNewPkt = SNMP_Create_Request2
                    ((pPkt->pdu_type == TRAP_PDU ? TRAP2_PDU : pPkt->pdu_type),
                     pTargList->mp_model,
                     EBufferUsed (&pTargList->context),
                     (sbits8_t *) EBufferStart (&pTargList->context),
                     pProxyBlock->msgID,
                     vbCount, 0, 0);

                if (pNewPkt == 0)
                    {
                    proxyBlockClean (pProxyBlock);
                    return (ENVOY_ERR_UNKNOWN);
                    }

                pTargList->pktp = pNewPkt;

                if (ENVOY_TADDRESS_TO_SNMPADDR (&(pTargList->for_addr),
                                                &(pTargList->tdomain),
                                                &(pTargList->taddress)) != 0)
                    {
                    proxyBlockClean (pProxyBlock);
                    return (ENVOY_ERR_UNKNOWN);
                    }

                break;
#endif
#endif /* #if INSTALL_ENVOY_SNMP_COEXISTENCE */
                
            case SNMP_VERSION_3:
                if (pPkt->snmp_version == SNMP_VERSION_1)
                    vbCount = pPkt->pdu.trap_pdu.trap_vbl.vbl_count + 5;
                else
                    vbCount = pPkt->pdu.std_pdu.std_vbl.vbl_count;
                
                msgFlags = 0;
                switch (pTargList->sec_level)
                    {
                    case ETC_SEC_LEVEL_PRIV:
                        msgFlags |= ETC_V3_PRIV;
                        /* fall through... */
                    case ETC_SEC_LEVEL_AUTH:
                        msgFlags |= ETC_V3_AUTH;
                        /* fall through... */
                    default:
                        break;
                    }

                /*
                 * We have to look up the security engine id -- we
                 * can't assume that the security engine id will
                 * match the context engine id -- there could be a
                 * proxy chain...
                 */
                secID = 0;
                secIDLen = 0;
                if (pPkt->pdu_type == TRAP2_PDU)
                    {
                    secID = SNMP_Engine_Get_My_ID();
                    secIDLen = SNMP_Engine_Get_My_ID_Length();
                    }
                else
                    {
                    SNMP_Find_Matching_Engine_ID(&(pTargList->tdomain),
                                                 &(pTargList->taddress),
                                                 &secID,
                                                 &secIDLen);
                    }
                
                if (secID == 0)
                    {
                    /*
                     * We can't proceed yet as we don't have
                     * a securityEngineID to build the
                     * packet with.  This means we have to
                     * send a probe to the target in
                     * question and wait for a response.
                     */
                    pNewPkt = SNMP_Create_Request_V3
                        (pPkt->pdu_type,
                         pTargList->mp_model,
                         pProxyBlock->msgID,
                         0, 0,
                         pTargList->sec_model,
                         EBufferStart (&pProxyBlock->contextEngineID),
                         EBufferUsed (&pProxyBlock->contextEngineID),
                         EBufferStart (&pProxyBlock->contextName),
                         EBufferUsed (&pProxyBlock->contextName),
                         0, 0, 0, 0,
                         pProxyBlock->msgID,
                         0, 0, 0);

                    pTargList->flags |= SNMP_TARGET_LIST_SEND_PROXY_PROBE;
                    saveList = 1;
                    }
                else
                    {
                    pNewPkt = SNMP_Create_Request_V3
                        (pPkt->pdu_type,
                         pTargList->mp_model,
                         pProxyBlock->msgID,
                         pPkt->msg_max_size,
                         msgFlags,
                         pTargList->sec_model,
                         EBufferStart (&pProxyBlock->contextEngineID),
                         EBufferUsed (&pProxyBlock->contextEngineID),
                         EBufferStart (&pProxyBlock->contextName),
                         EBufferUsed (&pProxyBlock->contextName),
                         secID,
                         secIDLen,
                         EBufferStart (&pTargList->sec_name),
                         EBufferUsed (&pTargList->sec_name),
                         pProxyBlock->msgID,
                         vbCount, 0, 0);
                    }

                if (pNewPkt == 0)
                    {
                    proxyBlockClean (pProxyBlock);
                    return (ENVOY_ERR_UNKNOWN);
                    }

                pTargList->pktp = pNewPkt;

                if (ENVOY_TADDRESS_TO_SNMPADDR (&(pTargList->for_addr),
                                                &(pTargList->tdomain),
                                                &(pTargList->taddress)) != 0)
                    {
                    proxyBlockClean (pProxyBlock);
                    return (ENVOY_ERR_UNKNOWN);
                    }
                break;
            default:
                continue;
            }

        /*
         * Since we're proxying multiple versions of SNMP, we can't simply
         * copy the pointers from the original varbind list as notification
         * forwarding has all sorts of translation rules.
         */

        if (pTargList->flags & SNMP_TARGET_LIST_SEND_PROXY_PROBE)
            continue;

        if ((errorCode = copyNotifyVarBindList (pPkt, pNewPkt)) !=
            ENVOY_ERR_NOERR)
            {
            proxyBlockClean (pProxyBlock);
            return (errorCode);
            }
        }

    MEMSET (&locAddr, 0, sizeof (SNMPADDR_T));

    if ((saveList == 1) || (pPkt->pdu_type == INFORM_REQUEST_PDU))
        {
        /*
         * We're going to need to watch for a response.
         * So, grab the lock and put this proxy block on the list.
         */
#if (INSTALL_ENVOY_SNMP_LOCK)
        if (ENVOY_SNMP_GET_WRITE_LOCK (SNMP_V3_Retrans_Lock))
            {
            BUG (BUG_ENVOY_LOCKING, BUG_CONTINUABLE, 0,
                 (BUG_OUT, "snmpProxyV3Notify: retrans lock broken", 0));
            proxyBlockClean (pProxyBlock);
            return (ENVOY_ERR_LOCK_FAILED);
            }
#endif /* #if (INSTALL_ENVOY_SNMP_LOCK) */

        pProxyBlock->originalPkt = pPkt;
        pProxyBlock->next = root_proxy_block.pcb;
        root_proxy_block.pcb = pProxyBlock;

#if (INSTALL_ENVOY_SNMP_LOCK)
        ENVOY_SNMP_RELEASE_WRITE_LOCK (SNMP_V3_Retrans_Lock);
#endif /* #if (INSTALL_ENVOY_SNMP_LOCK) */
        }

    for (ppTargList = &(pProxyBlock->targetList); *ppTargList != 0;
         ppTargList = ppNextTargList)
        {
        ppNextTargList = &(*ppTargList)->next;
        /* Forward the packet. */
        ENVOY_SNMP_SEND_PROXY (&((*ppTargList)->for_addr), &locAddr,
                               (*ppTargList)->pktp,
                               SNMP_Bufsize_For_Packet ((*ppTargList)->pktp));

        /* If this isn't an inform and we're not sending a probe,
         * we can just forget about this packet.
         */
        if ((pPkt->pdu_type != INFORM_REQUEST_PDU) &&
            (((*ppTargList)->flags & SNMP_TARGET_LIST_SEND_PROXY_PROBE) == 0))
            {
            pTargList = *ppTargList;
            *ppTargList = (*ppTargList)->next;
            ppNextTargList = ppTargList;
            SNMP_Free (pTargList->pktp);
            pTargList->next = 0;
            clean_target_list (pTargList);
            }
        else
            longestTimeout = max (longestTimeout, (*ppTargList)->timeout);
        }

    /* And now we're done.  Clean the proxy block, if appropriate. */
    if ((saveList == 0) && (pPkt->pdu_type != INFORM_REQUEST_PDU))
        {
        pProxyBlock->originalPkt = 0;
        proxyBlockClean (pProxyBlock);
        }
    else
        {
#if (INSTALL_ENVOY_SNMP_LOCK)
        if (ENVOY_SNMP_GET_WRITE_LOCK (SNMP_V3_Retrans_Lock))
            {
            BUG (BUG_ENVOY_LOCKING, BUG_CONTINUABLE, 0,
                 (BUG_OUT, "snmpProxyV3Notify: retrans lock broken", 0));
            proxyBlockClean (pProxyBlock);
            return (ENVOY_ERR_LOCK_FAILED);
            }
#endif /* #if (INSTALL_ENVOY_SNMP_LOCK) */

        pProxyBlock->expires = ENVOY_NOW() + (longestTimeout * 10);

        /* kick the timer */
        proxy_timer_update();

#if (INSTALL_ENVOY_SNMP_LOCK)
        ENVOY_SNMP_RELEASE_WRITE_LOCK (SNMP_V3_Retrans_Lock);
#endif
        }
    
    return (ENVOY_ERR_NOERR);
    }

#if INSTALL_ENVOY_SNMP_COEXISTENCE
/****************************************************************************
* snmpCreateRetransRequest - construct a new SNMP request to be sent
*                            to a target
*
* This function will attempt to create a new request that skips over any
* received Counter64 objects.  
*
* RETURNS:  A pointer to the newly-created request, or 0 if an error
*           occurred.
*
*/
static SNMP_PKT_T * snmpCreateRetransRequest
    (
    SNMP_PKT_T      * pOriginalPkt,
    SNMP_PKT_T      * pReceivedPkt,
    SNMP_PROXY_CB_T * pProxyBlock
    )
    {
    SNMP_PKT_T      * pNewPkt;
    bits8_t           msgFlags;
    bits8_t         * secID;
    ALENGTH_T         secIDLen;
    int               vbCount;
    VB_T            * pVb;
    VB_T            * pNewVb;
    OBJ_ID_T          skipOid;
    
    switch (pProxyBlock->targetList->mp_model)
        {
#if INSTALL_ENVOY_SNMP_VERSION_2
        case SNMP_VERSION_2:
            pNewPkt = SNMP_Create_Request2
                (pOriginalPkt->pdu_type,
                 SNMP_VERSION_2,
                 EBufferUsed (&pProxyBlock->targetList->context),
                 (sbits8_t *) EBufferStart (&pProxyBlock->targetList->context),
                 pProxyBlock->msgID,
                 pOriginalPkt->pdu.std_pdu.std_vbl.vbl_count,
                 0, 0);
            break;
#endif
        case SNMP_VERSION_3:
            msgFlags = 0;
            switch (pProxyBlock->targetList->sec_level)
                {
                case ETC_SEC_LEVEL_PRIV:
                    msgFlags |= ETC_V3_PRIV;
                    /* fall through... */
                case ETC_SEC_LEVEL_AUTH:
                    msgFlags |= ETC_V3_AUTH;
                    /* fall through... */
                default:
                    break;
                }

            secID = 0;
            secIDLen = 0;
            SNMP_Find_Matching_Engine_ID
                (&(pProxyBlock->targetList->tdomain),
                 &(pProxyBlock->targetList->taddress),
                 &secID,
                 &secIDLen);

            if (secID == 0)
                {
                /*
                 * We're not going to mess with sending probes at this
                 * stage.  We got a valid response -- we either have the
                 * engine ID or something has gone wrong.
                 */
                return 0;
                }
            
            pNewPkt = S