v3mt_tgt.c

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

SNMP_Target_Addr_Set_Flags(cur_taddr, 
			   SNMP_Target_Addr_Get_Flags(sav_taddr));

SNMP_Target_Addr_Destroy(sav_taddr);
return;
}


/****************************************************************************
NAME: taddrtable_set_cleanup

PURPOSE: Free the saved target_addr and indicate that we are finished.

PARAMETERS: 
	ptr_t   A pointer to the vb that points to the target_addr
	        that contained the update information,
		cast as a ptr_t

RETURNS: Nothing
****************************************************************************/

static void
  taddrtable_set_cleanup(ptr_t taddrptr)
{
if (((VB_T *)taddrptr)->vb_priv) {
    if (((VB_T *)taddrptr)->undoproc == taddrtable_create_undo)
        ((VB_T *)taddrptr)->vb_priv = 0;
    else
        SNMP_Target_Addr_Destroy(((VB_T *)taddrptr)->vb_priv);
    }
SNMP_V3_TADDR_FINISHED();
}

/****************************************************************************
NAME:  validate_tag_list

PURPOSE:  This routine checks a tag_list to make sure that it's valid.  
          Specifically, this means:  No leading or trailing delimiters,
	  no multiple adjacent delimiters.

PARAMETERS:
        bits8_t         The taglist to be verified
	ALENGTH_T       The length of the taglist

RETURNS:  0 if taglist is valid, 1 otherwise
****************************************************************************/
static int
  validate_tag_list(bits8_t   *taglist,
		    ALENGTH_T  taglist_len)
{
bits8_t *tl = taglist;
int len, ws = 0;

if ((taglist == (bits8_t *) 0) || (taglist_len == 0))
    return 0;

if (tag_whitespace(*tl) || tag_whitespace(*(tl + taglist_len - 1)))
    return 1;

for (len = 0; len < taglist_len; (len++, tl++)) {
    if (tag_whitespace(*tl)) {
        if (ws == 1)
	    return 1;
        else
            ws = 1;
        }
    else
        ws = 0;
    }
return 0;
}

void
  snmpTargetAddrEntry_test(OIDC_T      lastmatch,
                           int         tcount,
                           OIDC_T     *tlist,
                           SNMP_PKT_T *pktp,
                           VB_T       *vbp)
{
SNMP_TARGET_ADDR_T *taddr, temptaddr, *newtaddr;
sbits32_t value, ptret;
int cago = 0, create_row = 0, td_chg = 0, ta_chg = 0, tl_chg = 0, tp_chg = 0;
int tm_chg = 0;
ALENGTH_T nlen = 0;
VB_T *tvbp, *td_vbp = 0, *ta_vbp = 0, *tp_vbp = 0, *rs_vbp = 0, *tm_vbp = 0;
bits8_t name[ETC_TARGET_ADDR_MAX];
ALENGTH_T name_len = ETC_TARGET_ADDR_MAX;
OIDC_T snmpUDPDomain[] = { 1, 3, 6, 1, 6, 1, 1 };
ALENGTH_T sizeof_snmpUDPDomain = 7;

/* get the list of var binds that may go into this structure
   then mark all the vbs except the first one as having been
   tested, set and done.  This means that vbp is taking
   responsibility for all of the other vbs in the row.  Then
   mark vbp as having it's test started & done so we don't
   have to worry about it later.  We can do this because
   the routine will run to completion */
group_by_getproc_and_instance(pktp, vbp, tcount, tlist);
for(tvbp = vbp->vb_link; tvbp; tvbp = tvbp->vb_link)
    setproc_all_bits(pktp, tvbp);
testproc_good(pktp, vbp);

/* gather the indexing information, the index will be of the form:
   <name>
   first we do some minor checks then we attempt to find the target_addr */
if ((tcount > ETC_TARGET_ADDR_MAX)                     ||
    oid_to_string(tcount, tlist, &name_len, name, 1)   ||
    (name_len == 0) || ((bits32_t)name_len != (bits32_t) tcount)) {
    testproc_error(pktp, vbp, NO_CREATION);
    return;
    }

taddr = SNMP_Target_Addr_Lookup(name, name_len);

/* is the leaf writable, (if it's read only it isn't writable) */
if (taddr != 0) {
    if (SNMP_Target_Addr_Get_Storage(taddr) == ETC_STO_RONLY) {
	testproc_error(pktp, vbp, NOT_WRITABLE);      
	return;
	}

    MEMCPY(&temptaddr, taddr, sizeof(SNMP_TARGET_ADDR_T));
    }
else {
    SNMP_Target_Addr_Set_Defaults(&temptaddr);
    create_row = 1;
    }
    
for (tvbp = vbp; tvbp; tvbp = tvbp->vb_link) {
    if (STRCMP(VB_TO_COOKIE(tvbp), "_snmpTargetAddrTable") == 0) {
        switch(tvbp->vb_ml.ml_last_match) {
            case LEAF_snmpTargetAddrTDomain:
                if ((tvbp->value_u.v_object.num_components < 2) ||
                    (build_object_id(tvbp->value_u.v_object.num_components,
                                     tvbp->value_u.v_object.component_list,
                                     &temptaddr.tdomain))) {
                    testproc_error(pktp, tvbp, GEN_ERR);
                    return;
                    }
                td_vbp = tvbp;
                break;
                
            case LEAF_snmpTargetAddrTAddress:
                nlen = EBufferUsed(&tvbp->value_u.v_string);
                if ((nlen < MINSIZE_snmpTargetAddrTAddress) ||
                    (nlen > MAXSIZE_snmpTargetAddrTAddress)) {
                    testproc_error(pktp, tvbp, WRONG_VALUE);
                    return;
                    }
                EBufferPreLoad(BFL_IS_STATIC, &temptaddr.taddress,
                               EBufferStart(&tvbp->value_u.v_string), nlen);
                ta_vbp = tvbp;
                break;
                
            case LEAF_snmpTargetAddrTimeout:
                value = tvbp->value_u.v_number;
                if ((value < MIN_snmpTargetAddrTimeout) ||
                    (value > MAX_snmpTargetAddrTimeout)) {
                    testproc_error(pktp, tvbp, WRONG_VALUE);
                    return;
                    }
                SNMP_Target_Addr_Set_Timeout(&temptaddr, (bits32_t)value);
                break;
                
            case LEAF_snmpTargetAddrRetryCount:
                value = tvbp->value_u.v_number;
                if ((value < MIN_snmpTargetAddrRetryCount) ||
                    (value > MAX_snmpTargetAddrRetryCount)) {
                    testproc_error(pktp, tvbp, WRONG_VALUE);
                    return;
                    }
                SNMP_Target_Addr_Set_Retry_Count(&temptaddr, (bits32_t)value);
                break;
                
            case LEAF_snmpTargetAddrTagList:
                nlen = EBufferUsed(&tvbp->value_u.v_string);
                if (nlen > MAXSIZE_snmpTargetAddrTagList) {
                    testproc_error(pktp, tvbp, WRONG_LENGTH);
                    return;
                    }
                else if (validate_tag_list(EBufferStart(&tvbp->value_u.v_string),
                                           nlen)) {
                    testproc_error(pktp, tvbp, WRONG_VALUE);
                    return;
                    }
                EBufferPreLoad(BFL_IS_STATIC, &temptaddr.tag_list,
                               EBufferStart(&tvbp->value_u.v_string), nlen);
                break;
                
            case LEAF_snmpTargetAddrParams:
                nlen = EBufferUsed(&tvbp->value_u.v_string);
                if ((nlen < MINSIZE_snmpTargetAddrParams) ||
                    (nlen > MAXSIZE_snmpTargetAddrParams)) {
                    testproc_error(pktp, tvbp, WRONG_LENGTH);
                    return;
                    }
                EBufferPreLoad(BFL_IS_STATIC, &temptaddr.params,
                               EBufferStart(&tvbp->value_u.v_string), nlen);
                tp_vbp = tvbp;
                break;
                
            case LEAF_snmpTargetAddrStorageType:
                value = tvbp->value_u.v_number;
                if ((value < ETC_STO_OTHER) ||
                    (value > ETC_STO_RONLY) ||
                    ((taddr != 0) && (value > ETC_STO_NONVOL)) ||
                    (SNMP_Target_Addr_Get_Storage(&temptaddr) >= ETC_STO_PERM)) {
                    testproc_error(pktp, tvbp, WRONG_VALUE);
                    return;
                    }
                SNMP_Target_Addr_Set_Storage(&temptaddr, (bits16_t)value);
                break;

            case LEAF_snmpTargetAddrRowStatus:
                value = tvbp->value_u.v_number;
                switch (value) {
                    case ETC_RS_ACTIVE:
                    case ETC_RS_NIS:
                        if (create_row) {
                            testproc_error(pktp, tvbp, INCONSISTENT_VALUE);
                            return;
                            }
                        break;
                    case ETC_RS_CAGO:
                        if (create_row == 0) {
                            testproc_error(pktp, tvbp, INCONSISTENT_VALUE);
                            return;
                            }
                        value = ETC_RS_ACTIVE;
                        cago = 1;
                        break;
                    case ETC_RS_CAWAIT:
                        if (create_row == 0) {
                            testproc_error(pktp, tvbp, INCONSISTENT_VALUE);
                            return;
                            }
                        value = ETC_RS_NREADY;
                        break;
                    case ETC_RS_DESTROY:
                        if (SNMP_Target_Addr_Get_Storage(&temptaddr) >=
                            ETC_STO_PERM) {
                            testproc_error(pktp, tvbp, WRONG_VALUE);
                            return;
                            }
                        break;
                    default:
                        testproc_error(pktp, tvbp, WRONG_VALUE);
                        return;
                    }

                if (SNMP_Target_Addr_Get_Status(&temptaddr) != ETC_RS_DESTROY) {
                    SNMP_Target_Addr_Set_Status(&temptaddr, (bits16_t)value);
                    rs_vbp = tvbp;
                    }
                break;

            default:
                testproc_error(pktp, tvbp, GEN_ERR);
                return;
            }
        }
#if INSTALL_ENVOY_SNMP_COEXISTENCE
    else if (STRCMP(VB_TO_COOKIE(tvbp), "_snmpTargetAddrExtTable") == 0) {
        switch(tvbp->vb_ml.ml_last_match) {
            case LEAF_snmpTargetAddrTMask:
                nlen = EBufferUsed(&tvbp->value_u.v_string);
                if (nlen > MAXSIZE_snmpTargetAddrTMask) {
                    testproc_error(pktp, tvbp, WRONG_LENGTH);
                    return;
                    }
                EBufferPreLoad(BFL_IS_STATIC, &temptaddr.tmask,
                               EBufferStart(&tvbp->value_u.v_string), nlen);
                tm_vbp = tvbp;
                break;
            case LEAF_snmpTargetAddrMMS:
                value = tvbp->value_u.v_number;
                if ((value != 0) &&
                    ((value < MIN_snmpTargetAddrMMS) ||
                     (value > MAX_snmpTargetAddrMMS))) {
                    testproc_error(pktp, tvbp, WRONG_VALUE);
                    return;
                    }
                SNMP_Target_Addr_Set_MMS(&temptaddr, (bits32_t)value);
                break;
            default:
                testproc_error(pktp, tvbp, GEN_ERR);
                return;
            }
        }
#endif /* #if INSTALL_ENVOY_SNMP_COEXISTENCE */
    else {
        testproc_error(pktp, tvbp, GEN_ERR);
        return;
        }
    }

/* The values are ok  */
if (SNMP_Target_Addr_Get_Status(&temptaddr) == ETC_RS_DESTROY) {
    if (taddr != 0) {
	ptret = SNMP_V3_TADDR_DESTROY_TEST(pktp, vbp, taddr, 0);
	if (ptret != NO_ERROR) {
	    testproc_error(pktp, vbp, ptret);
	    }
	else {
	    vbp->vb_priv	 = (PTR_T)taddr;
	    vbp->vb_free_priv = taddrtable_destroy_cleanup;
	    }
        }
    else {
        /* We have a destroy request, but no target_addr 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 ((taddr) && ((td_vbp) || (ta_vbp) || (tm_vbp)) && 
    ((SNMP_Target_Addr_Get_Status(taddr) == ETC_RS_ACTIVE) &&
     (SNMP_Target_Addr_Get_Status(&temptaddr) == ETC_RS_ACTIVE))) {
    if (td_vbp)
        testproc_error(pktp, td_vbp, INCONSISTENT_VALUE);
    if (ta_vbp)
        testproc_error(pktp, ta_vbp, INCONSISTENT_VALUE);
    if (tm_vbp)
        testproc_error(pktp, tm_vbp, INCONSISTENT_VALUE);
    return;
    }
    
#if INSTALL_ENVOY_SNMP_COEXISTENCE
if ((tm_vbp) &&
    (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, tm_vbp, INCONSISTENT_VALUE);
    return;
    }
#endif /* #if INSTALL_ENVOY_SNMP_COEXISTENCE */
    
if (td_vbp)
    temptaddr.flags |= ETC_TADDR_TDOMAIN;

if (ta_vbp)
    temptaddr.flags |= ETC_TADDR_TADDRESS;

if (tp_vbp)
    temptaddr.flags |= ETC_TADDR_PARAMS;

    
/* check on status */
if ((rs_vbp) && (rs_vbp->value_u.v_number != ETC_RS_CAWAIT)) {
    /* This check tries to make sure that the attempt to change the
       row's status is valid.  We check several things:
       1)  If the row is being created by setting the status to createAndGo
           or the row's status is notReady, then
           A)  all required fields must be set
           B)  the TAddress must be the correct length.  This restriction
               only holds if TDomain is snmpUdpDomain -- other domains
               aren't currently checked.
           C)  TMask must be the same length as TAddress
       2)  If the row is being set to active status, then only B and C
           above are checked. */           
    if ((((cago) ||
          ((taddr) &&
           (SNMP_Target_Addr_Get_Status(taddr) == 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) == 1)) ||
          ((SNMP_Target_Addr_Get_TMask_Len(&temptaddr) != 0) &&