v3mt_tgt.c

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

           (SNMP_Target_Addr_Get_TAddress_Len(&temptaddr) !=
            SNMP_Target_Addr_Get_TMask_Len(&temptaddr)))))) ||
        ((rs_vbp->value_u.v_number == ETC_RS_ACTIVE) &&
         (((SNMP_Target_Addr_Get_TAddress_Len(&temptaddr) != 6) &&
           (oidcmp(SNMP_Target_Addr_Get_TDomain(&temptaddr)->num_components,
                   SNMP_Target_Addr_Get_TDomain(&temptaddr)->component_list,
                   sizeof_snmpUDPDomain,
                   snmpUDPDomain) == 1)) ||
          ((SNMP_Target_Addr_Get_TMask_Len(&temptaddr) != 0) &&
           (SNMP_Target_Addr_Get_TAddress_Len(&temptaddr) !=
            SNMP_Target_Addr_Get_TMask_Len(&temptaddr)))))) {
        testproc_error(pktp, rs_vbp, INCONSISTENT_VALUE);
        return;
        }
    }
else {
    /* This check tries to advance a row's status of notReady to
       notInService, provided the required conditions have been met:
       1) TDomain, TAddress, and Params must all be set.
       2) TAddress must be consistent with TDomain -- in this particular
          case, we're only concerning ourselves with cases where
          TDomain == snmpUdpDomain.  Other TDomains are ignored.
       3) The length of TMask must either be 0 or the same as the length
          of TAddress. */
    if ((SNMP_Target_Addr_Get_Status(&temptaddr) == ETC_RS_NREADY) &&
	((temptaddr.flags & ETC_TADDR_ALL_FLAGS) == ETC_TADDR_ALL_FLAGS) &&
        ((SNMP_Target_Addr_Get_TAddress_Len(&temptaddr) == 6) ||
         (oidcmp(SNMP_Target_Addr_Get_TDomain(&temptaddr)->num_components,
                 SNMP_Target_Addr_Get_TDomain(&temptaddr)->component_list,
                 sizeof_snmpUDPDomain,
                 snmpUDPDomain) == 0)) &&
        ((SNMP_Target_Addr_Get_TMask_Len(&temptaddr) == 0) ||
         (SNMP_Target_Addr_Get_TAddress_Len(&temptaddr) ==
          SNMP_Target_Addr_Get_TMask_Len(&temptaddr))))
        SNMP_Target_Addr_Set_Status(&temptaddr, 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 (taddr) {
    if ((SNMP_Target_Addr_Get_TDomain(taddr)->num_components !=
         SNMP_Target_Addr_Get_TDomain(&temptaddr)->num_components) ||
        ((SNMP_Target_Addr_Get_TDomain(taddr)->num_components > 0) &&
         (SNMP_Target_Addr_Get_TDomain(taddr)->component_list !=
          SNMP_Target_Addr_Get_TDomain(&temptaddr)->component_list) &&
         (oidcmp(SNMP_Target_Addr_Get_TDomain(taddr)->num_components,
                 SNMP_Target_Addr_Get_TDomain(taddr)->component_list,
                 SNMP_Target_Addr_Get_TDomain(&temptaddr)->num_components,
                 SNMP_Target_Addr_Get_TDomain(&temptaddr)->component_list)
          == 0))) {
        td_chg = 1;
        }

    if ((SNMP_Target_Addr_Get_TAddress(taddr) !=
	 SNMP_Target_Addr_Get_TAddress(&temptaddr)) &&
	((SNMP_Target_Addr_Get_TAddress_Len(taddr) !=
	  SNMP_Target_Addr_Get_TAddress_Len(&temptaddr)) ||
	 MEMCMP_NULLOK(SNMP_Target_Addr_Get_TAddress(taddr),
		       SNMP_Target_Addr_Get_TAddress(&temptaddr),
		       SNMP_Target_Addr_Get_TAddress_Len(taddr)))) {
        ta_chg = 1;
        }

    if ((SNMP_Target_Addr_Get_TMask(taddr) !=
	 SNMP_Target_Addr_Get_TMask(&temptaddr)) &&
	((SNMP_Target_Addr_Get_TMask_Len(taddr) !=
	  SNMP_Target_Addr_Get_TMask_Len(&temptaddr)) ||
	 MEMCMP_NULLOK(SNMP_Target_Addr_Get_TMask(taddr),
		       SNMP_Target_Addr_Get_TMask(&temptaddr),
		       SNMP_Target_Addr_Get_TMask_Len(taddr)))) {
        tm_chg = 1;
        }

    if ((SNMP_Target_Addr_Get_Tag_List(taddr) !=
	 SNMP_Target_Addr_Get_Tag_List(&temptaddr)) &&
	((SNMP_Target_Addr_Get_Tag_List_Len(taddr) !=
	  SNMP_Target_Addr_Get_Tag_List_Len(&temptaddr)) ||
	 MEMCMP_NULLOK(SNMP_Target_Addr_Get_Tag_List(taddr),
		       SNMP_Target_Addr_Get_Tag_List(&temptaddr),
		       SNMP_Target_Addr_Get_Tag_List_Len(taddr)))) {
        tl_chg = 1;
        }

    if ((SNMP_Target_Addr_Get_Params(taddr) !=
	 SNMP_Target_Addr_Get_Params(&temptaddr)) &&
	((SNMP_Target_Addr_Get_Params_Len(taddr) !=
	  SNMP_Target_Addr_Get_Params_Len(&temptaddr)) ||
	 MEMCMP_NULLOK(SNMP_Target_Addr_Get_Params(taddr),
		       SNMP_Target_Addr_Get_Params(&temptaddr),
		       SNMP_Target_Addr_Get_Params_Len(taddr)))) {
        tp_chg = 1;
        }

    if ((td_chg == 0) && (ta_chg == 0) &&
	(tl_chg == 0) && (tp_chg == 0) &&
        (tm_chg == 0) &&
	(SNMP_Target_Addr_Get_Timeout(taddr) ==
	 SNMP_Target_Addr_Get_Timeout(&temptaddr)) &&
	(SNMP_Target_Addr_Get_Retry_Count(taddr) ==
	 SNMP_Target_Addr_Get_Retry_Count(&temptaddr)) &&
        (SNMP_Target_Addr_Get_MMS(taddr) ==
         SNMP_Target_Addr_Get_MMS(&temptaddr)) &&
	(SNMP_Target_Addr_Get_Storage(taddr) ==
	 SNMP_Target_Addr_Get_Storage(&temptaddr)) &&
	(SNMP_Target_Addr_Get_Status(taddr) ==
	 SNMP_Target_Addr_Get_Status(&temptaddr))) {
        setproc_all_bits(pktp, vbp);
	return;
        }
    }
else {
    td_chg = 1;
    ta_chg = 1;
    tl_chg = 1;
    tp_chg = 1;
    tm_chg = 1;
    }

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

newtaddr = SNMP_Target_Addr_Create();
if (newtaddr == 0) {
    testproc_error(pktp, vbp, RESOURCE_UNAVAILABLE);
    return;
    }
SNMP_Target_Addr_Set_Flags(newtaddr, SNMP_Target_Addr_Get_Flags(&temptaddr));
SNMP_Target_Addr_Set_Status(newtaddr, SNMP_Target_Addr_Get_Status(&temptaddr));
SNMP_Target_Addr_Set_Storage(newtaddr, 
			     SNMP_Target_Addr_Get_Storage(&temptaddr));
SNMP_Target_Addr_Set_Retry_Count(newtaddr, 
				 SNMP_Target_Addr_Get_Retry_Count(&temptaddr));
SNMP_Target_Addr_Set_Timeout(newtaddr,
			     SNMP_Target_Addr_Get_Timeout(&temptaddr));
SNMP_Target_Addr_Set_MMS(newtaddr,
                         SNMP_Target_Addr_Get_MMS(&temptaddr));

if (tp_chg) {
    if (EBufferClone(&temptaddr.params, &newtaddr->params) != 0) {
        SNMP_Target_Addr_Destroy(newtaddr);
	testproc_error(pktp, vbp, RESOURCE_UNAVAILABLE);
	return;
        }
    }
else{
    EBufferPreLoad(BFL_IS_STATIC, &newtaddr->params,
		   SNMP_Target_Addr_Get_Params(taddr),
		   SNMP_Target_Addr_Get_Params_Len(taddr));
    }

if (tl_chg) {
    if (EBufferClone(&temptaddr.tag_list, &newtaddr->tag_list) != 0) {
        SNMP_Target_Addr_Destroy(newtaddr);
	testproc_error(pktp, vbp, RESOURCE_UNAVAILABLE);
	return;
        }
    }
else{
    EBufferPreLoad(BFL_IS_STATIC, &newtaddr->tag_list,
		   SNMP_Target_Addr_Get_Tag_List(taddr),
		   SNMP_Target_Addr_Get_Tag_List_Len(taddr));
    }

if (tm_chg) {
    if (EBufferClone(&temptaddr.tmask, &newtaddr->tmask) != 0) {
        SNMP_Target_Addr_Destroy(newtaddr);
	testproc_error(pktp, vbp, RESOURCE_UNAVAILABLE);
	return;
        }
    }
else{
    EBufferPreLoad(BFL_IS_STATIC, &newtaddr->tmask,
		   SNMP_Target_Addr_Get_TMask(taddr),
		   SNMP_Target_Addr_Get_TMask_Len(taddr));
    }

if (ta_chg) {
    if (EBufferClone(&temptaddr.taddress, &newtaddr->taddress) != 0) {
        SNMP_Target_Addr_Destroy(newtaddr);
	testproc_error(pktp, vbp, RESOURCE_UNAVAILABLE);
	return;
        }
    }
else{
    EBufferPreLoad(BFL_IS_STATIC, &newtaddr->taddress,
		   SNMP_Target_Addr_Get_TAddress(taddr),
		   SNMP_Target_Addr_Get_TAddress_Len(taddr));
    }

if (td_chg) {
    newtaddr->tdomain.component_list = temptaddr.tdomain.component_list;
    newtaddr->tdomain.num_components = temptaddr.tdomain.num_components;
    }
else{
    build_object_id(taddr->tdomain.num_components,
		    taddr->tdomain.component_list,
		    &(newtaddr->tdomain));
    if (temptaddr.tdomain.component_list != taddr->tdomain.component_list)
        Clean_Obj_ID(&(temptaddr.tdomain));
    }

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

if (taddr == 0) {
    if (SNMP_Target_Addr_Install(newtaddr, name, name_len)) {
	SNMP_Target_Addr_Destroy(newtaddr);
	testproc_error(pktp, vbp, RESOURCE_UNAVAILABLE);
	return;
	}
    ptret = SNMP_V3_TADDR_CREATE_TEST(pktp, vbp, 0, newtaddr);
    if (ptret != NO_ERROR) {
        SNMP_Target_Addr_Deinstall(newtaddr);
	SNMP_Target_Addr_Destroy(newtaddr);
	testproc_error(pktp, vbp, ptret);
	return;
        }
    vbp->vb_free_priv = taddrtable_create_cleanup;
    }
else {
    ptret = SNMP_V3_TADDR_UPDATE_TEST(pktp, vbp, taddr, newtaddr);
    if (ptret != NO_ERROR) {
	SNMP_Target_Addr_Destroy(newtaddr);
	testproc_error(pktp, vbp, ptret);
	return;
	}
    newtaddr->next = taddr;
    vbp->vb_free_priv = taddrtable_update_cleanup;
    }

if (cago)
    SNMP_Target_Addr_Set_Status(newtaddr, ETC_RS_CAGO);

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

void
  snmpTargetAddrEntry_set(OIDC_T      lastmatch,
                          int         tcount,
                          OIDC_T     *tlist,
                          SNMP_PKT_T *pktp,
                          VB_T       *vbp)
{
SNMP_TARGET_ADDR_T *old_taddr, *new_taddr;
bits16_t temp_value;
sbits32_t temp_val32;
EBUFFER_T temp_ebuf;
OBJ_ID_T temp_oid;

new_taddr = (SNMP_TARGET_ADDR_T *)vbp->vb_priv;

if (vbp->vb_free_priv == taddrtable_destroy_cleanup) {
    SNMP_V3_TADDR_DESTROY_SET(pktp, vbp, new_taddr, 0);
    SNMP_Target_Addr_Deinstall(new_taddr);
    vbp->vb_free_priv = taddrtable_set_cleanup;
    undoproc_set(pktp, vbp, taddrtable_destroy_undo);
    }
else if (vbp->vb_free_priv == taddrtable_create_cleanup) {
    if (SNMP_Target_Addr_Get_Status(new_taddr) == ETC_RS_CAGO)
        SNMP_Target_Addr_Set_Status(new_taddr, ETC_RS_ACTIVE);
    SNMP_V3_TADDR_CREATE_SET(pktp, vbp, 0, new_taddr);
    undoproc_set(pktp, vbp, taddrtable_create_undo);
    }
else {
    old_taddr = new_taddr->next;
    SNMP_V3_TADDR_UPDATE_SET(pktp, vbp, old_taddr, new_taddr);

    /* deal with status, storage and prefix information */
    temp_value = SNMP_Target_Addr_Get_Flags(old_taddr);
    SNMP_Target_Addr_Set_Flags(old_taddr, 
			       SNMP_Target_Addr_Get_Flags(new_taddr));
    SNMP_Target_Addr_Set_Flags(new_taddr, temp_value);

    temp_value = SNMP_Target_Addr_Get_Status(old_taddr);
    SNMP_Target_Addr_Set_Status(old_taddr, 
				SNMP_Target_Addr_Get_Status(new_taddr));
    SNMP_Target_Addr_Set_Status(new_taddr, temp_value);

    temp_value = SNMP_Target_Addr_Get_Storage(old_taddr);
    SNMP_Target_Addr_Set_Storage(old_taddr, 
				 SNMP_Target_Addr_Get_Storage(new_taddr));
    SNMP_Target_Addr_Set_Storage(new_taddr, temp_value);

    if (SNMP_Target_Addr_Get_Params(new_taddr) !=
	SNMP_Target_Addr_Get_Params(old_taddr)) {
        MEMCPY(&temp_ebuf, &old_taddr->params, sizeof(EBUFFER_T));
	MEMCPY(&old_taddr->params, &new_taddr->params, sizeof(EBUFFER_T));
	MEMCPY(&new_taddr->params, &temp_ebuf, sizeof(EBUFFER_T));
        }

    if (SNMP_Target_Addr_Get_Tag_List(new_taddr) !=
	SNMP_Target_Addr_Get_Tag_List(old_taddr)) {
        MEMCPY(&temp_ebuf, &old_taddr->tag_list, sizeof(EBUFFER_T));
	MEMCPY(&old_taddr->tag_list, &new_taddr->tag_list, sizeof(EBUFFER_T));
	MEMCPY(&new_taddr->tag_list, &temp_ebuf, sizeof(EBUFFER_T));
        }

    temp_value = SNMP_Target_Addr_Get_Retry_Count(old_taddr);
    SNMP_Target_Addr_Set_Retry_Count(old_taddr, 
				     SNMP_Target_Addr_Get_Retry_Count(new_taddr));
    SNMP_Target_Addr_Set_Retry_Count(new_taddr, temp_value);

    temp_val32 = SNMP_Target_Addr_Get_Timeout(old_taddr);
    SNMP_Target_Addr_Set_Timeout(old_taddr, 
				 SNMP_Target_Addr_Get_Timeout(new_taddr));
    SNMP_Target_Addr_Set_Timeout(new_taddr, temp_val32);

    temp_val32 = SNMP_Target_Addr_Get_MMS(old_taddr);
    SNMP_Target_Addr_Set_MMS(old_taddr,
                             SNMP_Target_Addr_Get_MMS(new_taddr));
    SNMP_Target_Addr_Set_MMS(new_taddr, temp_val32);

    if (SNMP_Target_Addr_Get_TMask(new_taddr) !=
	SNMP_Target_Addr_Get_TMask(old_taddr)) {
        MEMCPY(&temp_ebuf, &old_taddr->tmask, sizeof(EBUFFER_T));
	MEMCPY(&old_taddr->tmask, &new_taddr->tmask, sizeof(EBUFFER_T));
	MEMCPY(&new_taddr->tmask, &temp_ebuf, sizeof(EBUFFER_T));
        }

    if (SNMP_Target_Addr_Get_TAddress(new_taddr) !=
	SNMP_Target_Addr_Get_TAddress(old_taddr)) {
        MEMCPY(&temp_ebuf, &old_taddr->taddress, sizeof(EBUFFER_T));
	MEMCPY(&old_taddr->taddress, &new_taddr->taddress, sizeof(EBUFFER_T));
	MEMCPY(&new_taddr->taddress, &temp_ebuf, sizeof(EBUFFER_T));
        }

    if ((SNMP_Target_Addr_Get_TDomain(new_taddr)->component_list !=
	 SNMP_Target_Addr_Get_TDomain(old_taddr)->component_list) ||
	(SNMP_Target_Addr_Get_TDomain(new_taddr)->num_components !=
	 SNMP_Target_Addr_Get_TDomain(old_taddr)->num_components)) {
        MEMCPY(&temp_oid, &old_taddr->tdomain, sizeof(OBJ_ID_T));
	MEMCPY(&old_taddr->tdomain, &new_taddr->tdomain, sizeof(OBJ_ID_T));
	MEMCPY(&new_taddr->tdomain, &temp_oid, sizeof(OBJ_ID_T));
        }
    
    undoproc_set(pktp, vbp, taddrtable_update_undo);
    }

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


/*
 * Method routines for the snmpTargetParamsTable:
 *
 *   snmpTargetParamsName -- not-accessible
 * The locally arbitrary, but unique identifier associated
 * with this snmpTargetParamsEntry.
 *
 *   snmpTargetParamsMPModel -- read-create
 * The Message Processing Model to be used when generating
 * SNMP messages using this entry.
 *
 *   snmpTargetParamsSecurityModel -- read-create
 * The Security Model to be used when generating SNMP
 * messages using this entry.  An implementation may
 * choose to return an inconsistentValue error if an
 * attempt is made to set this variable to a value
 * for a security model which the implementation does
 * not support.
 *
 *   snmpTargetParamsSecurityName -- read-create
 * The securityName which identifies the Principal on
 * whose behalf SNMP messages will be generated using
 * this entry.
 *
 *   snmpTargetParamsSecurityLevel -- read-create
 * The Level of Security to be used when generating
 * SNMP messages using this entry.