v3mt_pxy.c

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

                        cago = 1;
                        break;
                    case ETC_RS_CAWAIT:
                        if (createRow == 0)
                            {
                            testproc_error (pktp, pTVb, INCONSISTENT_VALUE);
                            return;
                            }
                        statValue = ETC_RS_NREADY;
                        break;
                    case ETC_RS_DESTROY:
                        if (SNMP_Proxy_Get_Storage (&tempProxy) >=
                            ETC_STO_PERM)
                            {
                            testproc_error (pktp, pTVb, WRONG_VALUE);
                            return;
                            }
                        break;
                    default:
                        testproc_error (pktp, pTVb, WRONG_VALUE);
                        return;
                    }

                if (SNMP_Proxy_Get_Status (&tempProxy) != ETC_RS_DESTROY)
                    {
                    SNMP_Proxy_Set_Status (&tempProxy, statValue);
                    pRsVb = pTVb;
                    }
                break;

            default:
                testproc_error (pktp, pTVb, GEN_ERR);
                return;
            }
        }

    /* The values are ok  */
    if (SNMP_Proxy_Get_Status (&tempProxy) == ETC_RS_DESTROY)
        {
        if (pProxy != 0)
            {
            ptRet = SNMP_V3_PROXY_DESTROY_TEST (pktp, vbp, pProxy, 0);
            if (ptRet != NO_ERROR)
                {
                testproc_error (pktp, vbp, ptRet);
                }
            else
                {
                vbp->vb_priv	  = (PTR_T)pProxy;
                vbp->vb_free_priv = proxyTableDestroyCleanup;
                }
            }
        else
            {
            /* We have a destroy request, but no proxy so we don't
             * have to do anything during the set and, if necessary,
             * the undo phases so we mark vbp as set and undone
             */
            setproc_all_bits (pktp, vbp);
            }
        return;
        }

    /* do consistency checks */
    if ((pProxy != 0) && ((pPtVb != 0) || (pCiVb != 0) || (pCnVb != 0) || 
                          (pTpiVb != 0) || (pStoVb != 0) || (pMtoVb != 0)) && 
        ((SNMP_Proxy_Get_Status (pProxy) == ETC_RS_ACTIVE) &&
         (SNMP_Proxy_Get_Status (&tempProxy) == ETC_RS_ACTIVE)))
        {
        if (pPtVb != 0)
            testproc_error (pktp, pPtVb, INCONSISTENT_VALUE);
        if (pCiVb != 0)
            testproc_error (pktp, pCiVb, INCONSISTENT_VALUE);
        if (pCnVb != 0)
            testproc_error (pktp, pCnVb, INCONSISTENT_VALUE);
        if (pTpiVb != 0)
            testproc_error (pktp, pTpiVb, INCONSISTENT_VALUE);
        if (pStoVb != 0)
            testproc_error (pktp, pStoVb, INCONSISTENT_VALUE);
        if (pMtoVb != 0)
            testproc_error (pktp, pMtoVb, INCONSISTENT_VALUE);
        return;
        }
    
    /* check on status */
    if ((pProxy == 0) || 
        (SNMP_Proxy_Get_Status (pProxy) == ETC_RS_NREADY))
        {
        if (SNMP_Proxy_Get_Status (&tempProxy) == ETC_RS_NREADY)
            SNMP_Proxy_Set_Status (&tempProxy, ETC_RS_NIS);
        }

    /* See if anything actually changed, if it didn't we can mark
     * the vbp as done and not have to do any more work.
     */
    if (pProxy != 0)
        {
        if ((SNMP_Proxy_Get_Context_Engine_ID (pProxy) !=
             SNMP_Proxy_Get_Context_Engine_ID (&tempProxy)) &&
            ((SNMP_Proxy_Get_Context_Engine_ID_Len (pProxy) !=
              SNMP_Proxy_Get_Context_Engine_ID_Len (&tempProxy)) ||
             MEMCMP_NULLOK (SNMP_Proxy_Get_Context_Engine_ID (pProxy),
                            SNMP_Proxy_Get_Context_Engine_ID (&tempProxy),
                            SNMP_Proxy_Get_Context_Engine_ID_Len (pProxy))))
            {
            ciChg = 1;
            }

        if ((SNMP_Proxy_Get_Context_Name (pProxy) !=
             SNMP_Proxy_Get_Context_Name (&tempProxy)) &&
            ((SNMP_Proxy_Get_Context_Name_Len (pProxy) !=
              SNMP_Proxy_Get_Context_Name_Len (&tempProxy)) ||
             MEMCMP_NULLOK (SNMP_Proxy_Get_Context_Name (pProxy),
                            SNMP_Proxy_Get_Context_Name (&tempProxy),
                            SNMP_Proxy_Get_Context_Name_Len (pProxy))))
            {
            cnChg = 1;
            }

        if ((SNMP_Proxy_Get_Target_Params_In (pProxy) !=
             SNMP_Proxy_Get_Target_Params_In (&tempProxy)) &&
            ((SNMP_Proxy_Get_Target_Params_In_Len (pProxy) !=
              SNMP_Proxy_Get_Target_Params_In_Len (&tempProxy)) ||
             MEMCMP_NULLOK (SNMP_Proxy_Get_Target_Params_In (pProxy),
                            SNMP_Proxy_Get_Target_Params_In (&tempProxy),
                            SNMP_Proxy_Get_Target_Params_In_Len (pProxy))))
            {
            tpiChg = 1;
            }

        if ((SNMP_Proxy_Get_Single_Target_Out (pProxy) !=
             SNMP_Proxy_Get_Single_Target_Out (&tempProxy)) &&
            ((SNMP_Proxy_Get_Single_Target_Out_Len (pProxy) !=
              SNMP_Proxy_Get_Single_Target_Out_Len (&tempProxy)) ||
             MEMCMP_NULLOK (SNMP_Proxy_Get_Single_Target_Out (pProxy),
                            SNMP_Proxy_Get_Single_Target_Out (&tempProxy),
                            SNMP_Proxy_Get_Single_Target_Out_Len (pProxy))))
            {
            stoChg = 1;
            }

        if ((SNMP_Proxy_Get_Multiple_Target_Out (pProxy) !=
             SNMP_Proxy_Get_Multiple_Target_Out (&tempProxy)) &&
            ((SNMP_Proxy_Get_Multiple_Target_Out_Len (pProxy) !=
              SNMP_Proxy_Get_Multiple_Target_Out_Len (&tempProxy)) ||
             MEMCMP_NULLOK (SNMP_Proxy_Get_Multiple_Target_Out (pProxy),
                            SNMP_Proxy_Get_Multiple_Target_Out (&tempProxy),
                            SNMP_Proxy_Get_Multiple_Target_Out_Len (pProxy))))
            {
            mtoChg = 1;
            }

        if ((ciChg == 0) && (cnChg == 0) &&
            (tpiChg == 0) && (stoChg == 0) &&
            (mtoChg == 0) &&
            (SNMP_Proxy_Get_Proxy_Type (pProxy) ==
             SNMP_Proxy_Get_Proxy_Type (&tempProxy)) &&
            (SNMP_Proxy_Get_Storage (pProxy) ==
             SNMP_Proxy_Get_Storage (&tempProxy)) &&
            (SNMP_Proxy_Get_Status (pProxy) ==
             SNMP_Proxy_Get_Status (&tempProxy)))
            {
            setproc_all_bits (pktp, vbp);
            return;
            }
        }
    else
        {
        ciChg = 1;
        cnChg = 1;
        tpiChg = 1;
        stoChg = 1;
        mtoChg = 1;
        }

    /* Because of how we do the backout stuff we always allocate a new
     * proxy and set it up
     */

    pNewProxy = SNMP_Proxy_Create();
    if (pNewProxy == 0)
        {
        testproc_error(pktp, vbp, RESOURCE_UNAVAILABLE);
        return;
        }
    SNMP_Proxy_Set_Status(pNewProxy, SNMP_Proxy_Get_Status (&tempProxy));
    SNMP_Proxy_Set_Storage(pNewProxy, SNMP_Proxy_Get_Storage (&tempProxy));
    SNMP_Proxy_Set_Proxy_Type (pNewProxy,
                                SNMP_Proxy_Get_Proxy_Type (&tempProxy));

    if (ciChg != 0)
        {
        if (EBufferClone (&tempProxy.context_engine_id, 
                          &pNewProxy->context_engine_id) != 0)
            {
            SNMP_Proxy_Destroy (pNewProxy);
            testproc_error (pktp, vbp, RESOURCE_UNAVAILABLE);
            return;
            }
        }
    else
        {
        EBufferPreLoad (BFL_IS_STATIC, &pNewProxy->context_engine_id,
                        SNMP_Proxy_Get_Context_Engine_ID (pProxy),
                        SNMP_Proxy_Get_Context_Engine_ID_Len (pProxy));
        }

    if (cnChg != 0)
        {
        if (EBufferClone (&tempProxy.context_name, 
                          &pNewProxy->context_name) != 0)
            {
            SNMP_Proxy_Destroy (pNewProxy);
            testproc_error (pktp, vbp, RESOURCE_UNAVAILABLE);
            return;
            }
        }
    else
        {
        EBufferPreLoad (BFL_IS_STATIC, &pNewProxy->context_name,
                        SNMP_Proxy_Get_Context_Name (pProxy),
                        SNMP_Proxy_Get_Context_Name_Len (pProxy));
        }

    if (tpiChg != 0)
        {
        if (EBufferClone (&tempProxy.target_params_in, 
                          &pNewProxy->target_params_in) != 0)
            {
            SNMP_Proxy_Destroy (pNewProxy);
            testproc_error (pktp, vbp, RESOURCE_UNAVAILABLE);
            return;
            }
        }
    else
        {
        EBufferPreLoad (BFL_IS_STATIC, &pNewProxy->target_params_in,
                        SNMP_Proxy_Get_Target_Params_In (pProxy),
                        SNMP_Proxy_Get_Target_Params_In_Len (pProxy));
        }

    if (stoChg != 0)
        {
        if (EBufferClone (&tempProxy.single_target_out, 
                          &pNewProxy->single_target_out) != 0)
            {
            SNMP_Proxy_Destroy (pNewProxy);
            testproc_error (pktp, vbp, RESOURCE_UNAVAILABLE);
            return;
            }
        }
    else
        {
        EBufferPreLoad (BFL_IS_STATIC, &pNewProxy->single_target_out,
                        SNMP_Proxy_Get_Single_Target_Out (pProxy),
                        SNMP_Proxy_Get_Single_Target_Out_Len (pProxy));
        }

    if (mtoChg != 0)
        {
        if (EBufferClone (&tempProxy.multiple_target_out, 
                          &pNewProxy->multiple_target_out) != 0)
            {
            SNMP_Proxy_Destroy (pNewProxy);
            testproc_error (pktp, vbp, RESOURCE_UNAVAILABLE);
            return;
            }
        }
    else
        {
        EBufferPreLoad (BFL_IS_STATIC, &pNewProxy->multiple_target_out,
                        SNMP_Proxy_Get_Multiple_Target_Out (pProxy),
                        SNMP_Proxy_Get_Multiple_Target_Out_Len(pProxy));
        }

    /* if we are creating a new proxy we need to install it and run
     * the create test, if we are updating an old proxy we just run
     * the update test
     */

    if (pProxy == 0)
        {
        if (SNMP_Proxy_Install (pNewProxy, name, nameLen))
            {
            SNMP_Proxy_Destroy (pNewProxy);
            testproc_error (pktp, vbp, RESOURCE_UNAVAILABLE);
            return;
            }
        ptRet = SNMP_V3_PROXY_CREATE_TEST (pktp, vbp, 0, pNewProxy);
        if (ptRet != NO_ERROR)
            {
            SNMP_Proxy_Deinstall (pNewProxy);
            SNMP_Proxy_Destroy (pNewProxy);
            testproc_error(pktp, vbp, ptRet);
            return;
            }
        vbp->vb_free_priv = proxyTableCreateCleanup;
        }
    else
        {
        ptRet = SNMP_V3_PROXY_UPDATE_TEST (pktp, vbp, pProxy, pNewProxy);
        if (ptRet != NO_ERROR)
            {
            SNMP_Proxy_Destroy (pNewProxy);
            testproc_error (pktp, vbp, ptRet);
            return;
            }
        pNewProxy->next = pProxy;
        vbp->vb_free_priv = proxyTableUpdateCleanup;
        }

    if (cago != 0)
        SNMP_Proxy_Set_Status (pNewProxy, ETC_RS_CAGO);

    vbp->vb_priv = (PTR_T)pNewProxy;
    return;
    }

/***************************************************************************
* snmpProxyEntry_set - the setproc for the snmpProxyTable
*
* This function handles the set portion of set requests.  It is never
* called directly, only by the Envoy engine.
*
* Returns: N/A
*/

void snmpProxyEntry_set
    (
    OIDC_T       lastmatch,
    int          tcount,
    OIDC_T     * tlist,
    SNMP_PKT_T * pktp,
    VB_T       * vbp
    )
    {
    SNMP_PROXY_T * pOldProxy;
    SNMP_PROXY_T * pNewProxy;
    sbits32_t tempVal32;
    EBUFFER_T tempEbuf;
    ETC_STORAGE_T tempStorage;
    ETC_STATUS_T tempStatus;
    
    pNewProxy = (SNMP_PROXY_T *) vbp->vb_priv;
    
    if (vbp->vb_free_priv == proxyTableDestroyCleanup)
        {
        SNMP_V3_PROXY_DESTROY_SET (pktp, vbp, pNewProxy, 0);
        SNMP_Proxy_Deinstall (pNewProxy);
        vbp->vb_free_priv = proxyTableSetFinished;
        undoproc_set (pktp, vbp, proxyTableDestroyUndo);
        }
    else if (vbp->vb_free_priv == proxyTableCreateCleanup)
        {
        if (SNMP_Proxy_Get_Status (pNewProxy) == ETC_RS_CAGO)
            SNMP_Proxy_Set_Status (pNewProxy, ETC_RS_ACTIVE);
        SNMP_V3_PROXY_CREATE_SET (pktp, vbp, 0, pNewProxy);
        undoproc_set (pktp, vbp, proxyTableCreateUndo);
        }
    else
        {
        pOldProxy = pNewProxy->next;
        SNMP_V3_PROXY_UPDATE_SET (pktp, vbp, pOldProxy, pNewProxy);

        /* deal with status, storage and prefix information */
        tempStatus = SNMP_Proxy_Get_Status (pOldProxy);
        SNMP_Proxy_Set_Status (pOldProxy, 
                               SNMP_Proxy_Get_Status (pNewProxy));
        SNMP_Proxy_Set_Status (pNewProxy, tempStatus);

        tempStorage = SNMP_Proxy_Get_Storage (pOldProxy);
        SNMP_Proxy_Set_Storage (pOldProxy, 
                                SNMP_Proxy_Get_Storage (pNewProxy));
        SNMP_Proxy_Set_Storage (pNewProxy, tempStorage);

        if (SNMP_Proxy_Get_Multiple_Target_Out (pNewProxy) !=
            SNMP_Proxy_Get_Multiple_Target_Out (pOldProxy))
            {
            MEMCPY (&tempEbuf, &pOldProxy->multiple_target_out,
                    sizeof (EBUFFER_T));
            MEMCPY (&pOldProxy->multiple_target_out,
                    &pNewProxy->multiple_target_out, sizeof (EBUFFER_T));
            MEMCPY (&pNewProxy->multiple_target_out, &tempEbuf,
                    sizeof (EBUFFER_T));
            }

        if (SNMP_Proxy_Get_Single_Target_Out (pNewProxy) !=
            SNMP_Proxy_Get_Single_Target_Out (pOldProxy))
            {
            MEMCPY (&tempEbuf, &pOldProxy->single_target_out,
                    sizeof (EBUFFER_T));
            MEMCPY (&pOldProxy->single_target_out,
                    &pNewProxy->single_target_out, sizeof (EBUFFER_T));
            MEMCPY (&pNewProxy->single_target_out, &tempEbuf,
                    sizeof (EBUFFER_T));
            }

        if (SNMP_Proxy_Get_Target_Params_In (pNewProxy) !=
            SNMP_Proxy_Get_Target_Params_In (pOldProxy))
            {
            MEMCPY (&tempEbuf, &pOldProxy->target_params_in,
                    sizeof (EBUFFER_T));
            MEMCPY (&pOldProxy->target_params_in,
                    &pNewProxy->target_params_in, sizeof (EBUFFER_T));
            MEMCPY (&pNewProxy->target_params_in, &tempEbuf,
                    sizeof (EBUFFER_T));
            }

        if (SNMP_Proxy_Get_Context_Name (pNewProxy) !=
            SNMP_Proxy_Get_Context_Name (pOldProxy))
            {
            MEMCPY (&tempEbuf, &pOldProxy->context_name, sizeof (EBUFFER_T));
            MEMCPY (&pOldProxy->context_name, &pNewProxy->context_name,
                    sizeof (EBUFFER_T));
            MEMCPY (&pNewProxy->context_name, &tempEbuf, sizeof (EBUFFER_T));
            }

        if (SNMP_Proxy_Get_Context_Engine_ID (pNewProxy) !=
            SNMP_Proxy_Get_Context_Engine_ID (pOldProxy))
            {
            MEMCPY (&tempEbuf, &pOldProxy->context_engine_id,
                    sizeof (EBUFFER_T));
            MEMCPY (&pOldProxy->context_engine_id,
                    &pNewProxy->context_engine_id, sizeof (EBUFFER_T));
            MEMCPY (&pNewProxy->context_engine_id, &tempEbuf,
                    sizeof (EBUFFER_T));
            }

        tempVal32 = SNMP_Proxy_Get_Proxy_Type (pOldProxy);
        SNMP_Proxy_Set_Proxy_Type (pOldProxy, 
                                   SNMP_Proxy_Get_Proxy_Type (pNewProxy));
        SNMP_Proxy_Set_Proxy_Type (pNewProxy, tempVal32);

        undoproc_set (pktp, vbp, proxyTableUpdateUndo);
        }

    vbp->vb_free_priv = proxyTableSetFinished;
    setproc_good (pktp, vbp);
    return;
    }