/************************************************************************************* ospf_envoy_snmpdTreeAdd - dynamically add a subtree to the SNMP agent MIB tree** This routine adds the specified MIB subtree, located in memory at the address* <pTreeAddr>, to the agent's MIB data tree at the node with the object identifier* specified by <pTreeOidStr>.** RETURNS: OK or ERROR.** ERRNO: N/A*/STATUS  ospf_envoy_snmpdTreeAdd( char *pTreeOidStr, MIBNODE_T *pTreeAddr,                                 SEM_ID ospf_envoyBSem ){    int        status = 0;    MIBNODE_T  *pReplacedNode;    OBJ_ID_T   treeOid;    OIDC_T     oidArray [MAX_OSPF_OID_LEN];   treeOid.num_components = ospf_envoy_oidStrToArray(pTreeOidStr, oidArray);   if (treeOid.num_components > 0)   {       treeOid.component_list = oidArray;       semTake( ospf_envoyBSem, WAIT_FOREVER );       status = Add_Node_From_Root (NULL,  &treeOid, pTreeAddr, &pReplacedNode);       semGive( ospf_envoyBSem );       if ( status == 0 )       {           ospfEnvoyPrintf(("ospf_envoy_snmpdTreeAdd:%s successful\n", pTreeOidStr));       }       else       {           ospfEnvoyPrintf(("ospf_envoy_snmpdTreeAdd:%s failed\n", pTreeOidStr));       }   }   return ((status == 0) ? OK : ERROR);}/**************************************************************************************** ospfEnvoy_undo - undo routine for ospf method routines.** This is the generic undo routine that will be invoked by Envoy SNMP if failure occured* within the testproc or setproc.** NOTE: The MIB API doesn't support undo. The undo capability will be provided in the*       next release. For now, this generic undo routine is used to satisfy Envoy*       SNMP.** RETURNS: N/A** NOMANUAL*/void ospfEnvoy_undo( OIDC_T lastmatch, int tcount, OIDC_T *tlist,                     SNMP_PKT_T *pktp, VB_T *vbp ){    /* tell envoy snmp that the undo process has just begun */    undoproc_started( pktp, vbp );    undoproc_error( pktp, vbp, UNDO_FAILED );  /* always failed for now... */    return;}/**************************************************************************************** ospf_envoy_setGenError - set varbinds with Envoy SNMP GEN_ERR error** This routine sets the varbind with the Envoy SNMP GEN_ERR.** RETURNS: N/A*/void ospf_envoy_setGenError( SNMP_PKT_T *pktp, VB_T *vbp, mApiReqType_t reqType ){    for ( ; vbp ; vbp = vbp->vb_link )    {        if ( reqType == MAPI_GET_NEXT )            nextproc_error(pktp, vbp, GEN_ERR );        else  if ( reqType == MAPI_GET )            getproc_error( pktp, vbp, GEN_ERR );        else if ( reqType == MAPI_TEST )        {            vbp->vb_priv = NULL;            testproc_error( pktp, vbp, GEN_ERR );        }        else if ( reqType == MAPI_COMMIT )        {            vbp->vb_priv = NULL;            setproc_error( pktp, vbp, GEN_ERR );        }    }    return;}/**************************************************************************************** ospf_envoy_setNoSuchNameError - set varbinds with Envoy SNMP NO_SUCH_NAME error** This routine sets the varbinds with the Envoy SNMP NO_SUCH_NAME error** RETURNS: N/A*/void ospf_envoy_setNoSuchNameError( SNMP_PKT_T *pktp, VB_T *vbp, mApiReqType_t reqType ){    for ( ; vbp != NULL; vbp = vbp->vb_link )    {        if ( reqType == MAPI_TEST )        {            vbp->vb_priv = NULL;            testproc_error( pktp, vbp, NO_SUCH_NAME );        }        else if ( reqType == MAPI_COMMIT )        {            vbp->vb_priv = NULL;            setproc_error( pktp, vbp, NO_SUCH_NAME );        }    }    return;}/***************************************************************************************** ospf_envoy_processGetRespError - process MIB API response error** This routine process the MIB API response error and set the varbinds with the* appropriate Envoy SNMP error code.** RETURNS: N/A*/void ospf_envoy_processGetRespError( SNMP_PKT_T *pktp, VB_T *vbp, mApiReqType_t reqType,                                     int mApiErr ){    for ( ; vbp ; vbp = vbp->vb_link )    {        if ( mApiErr == MAPI_INVALID_INSTANCE )        {            if ( reqType == MAPI_GET_NEXT )                nextproc_no_next( pktp, vbp );            else                getproc_nosuchins( pktp, vbp );        }        else        {            if ( reqType == MAPI_GET_NEXT )                nextproc_error( pktp, vbp, mApi2EnvoyErrorGet( (mApiError_t)mApiErr) );            else                getproc_error( pktp, vbp, mApi2EnvoyErrorGet( (mApiError_t)mApiErr) );        }    }    return;}/************************************************************************************** ospf_envoy_buildSetReq - build MIB API TEST/COMMIT request** This routine build the MIB API request message for testproc, setproc and/or undoproc.* The routine copy the data from varbind to the pointer pointed to by the pValueBuf* array if the data type is VT_NUMBER, VT_COUNTER, VT_GAUGE or VT_IPADDRESS. For* VT_STRING and VT_OPAQUE, data is copied into memory that is dynamically allocated using* SNMP_memory_alloc() and the pOctetBuf pointer  will be initialized to pointed to the* allocated memory. It is the caller responsibility to call ospf_envoy_clearBuffer()* to reinitialize the memory pointed to by the pValueBuf pointer and to free the* dynamically allocated memory if the <dynamic> boolean flag is set.** RETURNS: OK or ERROR** ERRNO: N/A*/STATUS ospf_envoy_buildSetReq( int tcount, OIDC_T *tlist, SNMP_PKT_T *pktp, VB_T *vbp,                               envoyRequest_t *pEnvoyReq, mApiRequest_t *pRequest,                               mApiReqType_t reqType, int mApiOidOffset ){    VB_T *group_vbp = vbp;    mApiObject_t *pObject;    unsigned char         *envBuffer;    int          vbcount;    int          bufCnt;    if ( pEnvoyReq == NULL || pRequest == NULL )    {        ospfEnvoyPrintf(("ospf_envoy_getVbBuf:bogus pointer\n"));        return ERROR;    }    /* find all the varbinds that share the same getproc and instance and group     * them together. Although the varbinds don't change in any significant way between     * the calling of the testproc, setproc and undoproc (the flag field may changed),     * it is still necessary to call group_by_getproc_and_instance to group all     * varbinds that share the same instance each time this routine is invoked. This     * is because the pointer to the pValueBuf envoyReqest_t may have been reused     * especially if there have been multiple testprocs before the setprocs.     */    group_by_getproc_and_instance(pktp, vbp, tcount, tlist);    /* retrive the cookie stash by the testproc if tcount is not 1 (scalar objects).     * The varbinds don't change in any signification way between the calling of the      * testproc, setproc and undoproc ( the flags field may change). The important      * thing is the sequence of varbinds as arranged in the linked list remains the      * same. Although the cookie is stashed in each varbinds during testproc, we      * just need to retrieve the cookie that is is available in the first varbind      * (don't need to go thru every varbind). MIB API only allow one cookie per      * request anyhow...     */    if ( (reqType == MAPI_COMMIT) && (tcount != 1 ) )    {        if ( vbp->vb_priv == NULL )        {            ospfEnvoyPrintf(("ospf_envoy_buildSetReq:No cookie found!\n"));            return ERROR;        }        pRequest->pReqCookie = vbp->vb_priv;    }    /* get number of varbinds */    pRequest->numObjects = ospf_envoy_getVbCount( vbp );    /* if number of varbinds are more than what we can handle, return ERROR */    if ( pRequest->numObjects > pEnvoyReq->numValueBuf )    {        ospfEnvoyPrintf(("ospf_build_mApiSetRequest: vbcount(%i) exceed max(%i)\n",                         pRequest->numObjects, pEnvoyReq->numValueBuf));        return ERROR;    }    /* build the mApiRequest_t structure */    pRequest->pInstance = (ulong_t *)tlist;    pRequest->instanceLen = (ushort_t)tcount;    pRequest->pObjectList = pEnvoyReq->pObjectList;    /* get the data from varbinds. Ideally we want to be able to use the data     * from varbinds directly without first copying to a local buffer. Because     * of future compatibility concern, we discard that idea...     */    for ( bufCnt = 0, vbcount = 0; group_vbp != NULL && vbcount < pRequest->numObjects          && bufCnt < pEnvoyReq->numValueBuf; vbcount++, group_vbp = group_vbp->vb_link )    {        pObject = &pRequest->pObjectList[vbcount];        pObject->oidPrefixEnum = group_vbp->vb_ml.ml_last_match + mApiOidOffset;        pObject->pObjCookie = &pEnvoyReq->pObjCookie[vbcount];        /* set the object cookie in the envoyRequest_t to true if this is the last          * object in the varbind list. This is needed so that the rowStatus library         * used by the MIB API will know when to manipulate the rowStatus object for         * the row instance. Since vbcount is zero-based, it is necessary to decrement         * the numObjects by 1 in order to determine if this is the last object in         * the varbind list.         */         if ( vbcount == (pRequest->numObjects - 1) )            pEnvoyReq->pObjCookie[vbcount] = TRUE;         else            pEnvoyReq->pObjCookie[vbcount] = FALSE;        switch( group_vbp->vb_ml.ml_leaf->expected_tag)        {            case VT_NUMBER:            case VT_COUNTER:            case VT_GAUGE:                pEnvoyReq->pValueBuf[bufCnt] = VB_GET_INT32(group_vbp);                pObject->pValueBuf = &pEnvoyReq->pValueBuf[bufCnt];                pObject->valueLen = sizeof(VB_GET_INT32(group_vbp));                bufCnt++;                break;            case VT_STRING:            case VT_OPAQUE:                envBuffer = EBufferStart(VB_GET_STRING(group_vbp));                pEnvoyReq->octetBufLen = EBufferUsed(VB_GET_STRING(group_vbp));                pEnvoyReq->pOctetBuf = SNMP_memory_alloc( pEnvoyReq->octetBufLen );                if ( pEnvoyReq->pOctetBuf == NULL )                {                    ospfEnvoyPrintf(("ospf_envoy_buildSetReq:octetBuf calloc failed\n"));                    return ERROR;                }                /* mark this buffer as dynamic so the caller knows to free it later */                pEnvoyReq->dynamic = TRUE;                /* copy data from varbind */                memcpy(  pEnvoyReq->pOctetBuf, envBuffer, pEnvoyReq->octetBufLen );                pObject->pValueBuf = pEnvoyReq->pOctetBuf;                pObject->valueLen = pEnvoyReq->octetBufLen ;                break;            case VT_IPADDRESS:                pObject->valueLen = 4;                memcpy( (char *)&pEnvoyReq->pValueBuf[bufCnt],                        VB_GET_IP_ADDRESS(group_vbp), pObject->valueLen );                pObject->pValueBuf = &pEnvoyReq->pValueBuf[bufCnt];                bufCnt++;                break;            case VT_COUNTER64:            case VT_OBJECT:            case VT_EMPTY:            default:                return ERROR;        }    }    return OK;}/**************************************************************************************** ospf_envoy_markVarbind - mark the varbind with the appropriate status** This routine mark the varbind as being done base on the request type. This routine* must be called before each testproc() and setproc() exit.** RETURNS: N/A** ERRNO: N/A*/void ospf_envoy_markVarbind( VB_T *vbp, SNMP_PKT_T *pktp,                             mApiRequest_t *pRequest, mApiReqType_t reqType ){    VB_T *group_vbp;    mApiObject_t *pObj;    int vbcount = 0;    for ( group_vbp = vbp; group_vbp != NULL && vbcount < pRequest->numObjects;          vbcount++, group_vbp = group_vbp->vb_link )    {        pObj = &pRequest->pObjectList[vbcount];        if ( pObj->exception == MAPI_NO_EXCEPTION )        {            /* tell 'em that this varbind has been processed */            if ( reqType == MAPI_TEST )                testproc_good( pktp, group_vbp );            if ( reqType == MAPI_COMMIT )                setproc_good( pktp, group_vbp );            if ( reqType == MAPI_UNDO )                undoproc_good( pktp, group_vbp );        }        else        {            if ( pObj->exception == MAPI_NO_SUCH_OBJECT )                getproc_nosuchobj( pktp, group_vbp );            if ( pObj->exception == MAPI_NO_SUCH_INSTANCE )                getproc_nosuchins (pktp, group_vbp );        }    }}/***************************************************************************************** ospf_envoy_processScalarGetResp - process MIB API GET/GET NEXT scalar objects response** This is a generic routine to process all the MIB API GET/GET_NEXT response for the* scalar objects. It is invoked by getproc or nextproc after retreiving the values of* requested objects from the MIB API. The value of the objects will be copied into the* appropriate varbind. If exceptions reported by MIB API, the appropriate envoy snmp* exception will be raised. This routine should not be used to process the GET/GET_NEXT* response for table rows. This is because the nextproc_next_instance() needs to be* treated differently for scalar objects.** RETURNS: N/A** ERRNO: N/A*/void ospf_envoy_processScalarGetResp( VB_T *vbp, SNMP_PKT_T *pktp,                                      envoyRequest_t *pEnvoyReq, mApiRequest_t *pRequest,                                      mApiReqType_t reqType, int mApiOidOffset ){    mApiObject_t   *pObject;    STATUS         rc;    int            vbcount;    OIDC_T         instance;    vbcount = 0;    instance = 0;    for ( ; vbp != NULL && vbcount < pRequest->numObjects; vbp = vbp->vb_link, vbcount++ )    {        pObject = &pRequest->pObjectList[vbcount];        /* assumed the varbind is serailize with the request message */        if ( vbp->vb_ml.ml_last_match != pObject->oidPrefixEnum - mApiOidOffset )