snmp_e.c

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

        used = EBufferUsed(&(vbp->value_u.v_string));
        vbp->vb_data_length = A_SizeOfOctetString(used);
        break;
        }
    case VT_OBJECT:
        vbp->vb_data_length = A_SizeOfObjectId(&(vbp->value_u.v_object));
        break;
    case VT_NOSUCHINS:
    case VT_NOSUCHOBJ:
    case VT_ENDOFMIB:
    case VT_EMPTY:
        vbp->vb_data_length = 0;
        break;
    case VT_IPADDRESS:
        vbp->vb_data_length = 4;
        break;
/* We only include the following cases if v2 types are installed */
#if (ENVOY_USE_V2_TYPES)
    case VT_COUNTER64:
        DYNCFG_IFCFGVBL_BEGIN(envoy_use_v2_types)
        vbp->vb_data_length = A_SizeOfUnsignedInt64(
                                        &(vbp->value_u.v_counter64));
        break;
        DYNCFG_IFCFGVBL_END(envoy_use_v2_types)
#endif /* (ENVOY_USE_V2_TYPES) */
    default:
        break;
    }
  vbp->vb_seq_size = vb_size
                     + 1 /* The data tag is always 1 octet */
                     + A_SizeOfLength(vbp->vb_data_length)
                     + vbp->vb_data_length;

return (1 /* The sequence tag is always 1 octet */
       + A_SizeOfLength(vbp->vb_seq_size)
       + vbp->vb_seq_size);
}

/****************************************************************************
NAME:  set_vbl_sizes

PURPOSE:  Scan a VarBindList, setting the internal lengths and computing
          the total length.

PARAMETERS:
        VBL_T *         The VarBindList structure to be scanned and set

RETURNS:  ALENGTH_T     The number of octets the VarBindList contents would
                        use if ASN.1 encoded, including the list sequence
****************************************************************************/
static bits32_t
  set_vbl_sizes(VBL_T * vblp)
{
VB_T            *vbp;
bits32_t         vblist_size;
VBL_T           *cur_vblp;
int              i;

cur_vblp = vblp;
vblist_size = 0;

for (; cur_vblp != 0; cur_vblp = cur_vblp->vblp)
    if ((vbp = cur_vblp->vblist) != 0) {
        for (i = 0; i < cur_vblp->vbl_count; i++, vbp++) {
            vblist_size += vbsize(vbp);
	    }
        }

vblp->vbl_length = vblist_size;

return (1  /* Size of tag on VarBindList sequence */
        + A_SizeOfLength(vblist_size)
        + vblist_size);
}

/****************************************************************************
\NOMANUAL
NAME:  set_pdu_size

PURPOSE:  Set the length of the pdu, this will cause the var bind list
	  to be scanned and have it's lengths set as well

PARAMETERS:
        SNMP_PKT_T *    The packet to be scanned and set

RETURNS:  ALENGTH_T     The number of octets the pdu contents would
                        use if ASN.1 encoded, including the pdu sequence
****************************************************************************/
bits32_t
  set_pdu_size(SNMP_PKT_T *rp)
{
bits32_t pdu_length, pdu_needed; 

pdu_length = 2      /* Tag and length of request_id (an integer) */
             + A_SizeOfInt(rp->pdu.std_pdu.request_id)
             + 2     /* Tag and length of error_status (an integer) */
             + A_SizeOfInt(rp->pdu.std_pdu.error_status)
             + 2     /* Tag and length of error_index (an integer) */
             + A_SizeOfInt(rp->pdu.std_pdu.error_index)
             + set_vbl_sizes(&(rp->pdu.std_pdu.std_vbl));

pdu_needed = (1  /* Size of tag on pdu sequence */
             + A_SizeOfLength(pdu_length)
             + pdu_length);

if ((pdu_needed & 0xffff) == pdu_needed) {
    rp->pdu_length = pdu_length;
    return (pdu_needed);
    }

rp->pdu_length = 0;
return pdu_needed; 
}


#if (INSTALL_ENVOY_SNMP_VERSION_1 || INSTALL_ENVOY_SNMP_VERSION_2)
/****************************************************************************
        BUFSIZE_FOR_NORMAL_PKT
****************************************************************************/
static ALENGTH_T
  bufsize_for_normal_pkt(SNMP_PKT_T *rp)
{
ALENGTH_T       alength;
bits32_t        overall_length;
bits32_t        buffer_needed; 
 
alength = A_SizeOfOctetString(EBufferUsed(&(rp->community)));

overall_length = set_pdu_size(rp)
                 + 2    /* Tag and length of snmp_version (an integer) */
                 + A_SizeOfInt(rp->snmp_version)
                 + 1    /* Tag for the community octetstring */
                 + A_SizeOfLength(alength)
                 + alength;

buffer_needed = overall_length
                + 1 /* Size of tag for overall Message sequence */
                + A_SizeOfLength(overall_length);

if ((buffer_needed & 0xffff) == buffer_needed) {
    rp->overall_length = (ALENGTH_T) overall_length;
    rp->buffer_needed = (ALENGTH_T) buffer_needed;
    return rp->buffer_needed;
    }
rp->overall_length = 0;
rp->buffer_needed = 0;
return 0; 
 
}
#endif /* v1 or v2 */

/****************************************************************************
NAME:  encode_var_bind_list

PURPOSE:  Encode a VarBindList

PARAMETERS:
        VBL_T *         The VarBindList to be encoded

RETURNS:  Nothing
****************************************************************************/
static void
  encode_var_bind_list(VBL_T     *vblp,
                       EBUFFER_T *ebuffp)
{
VB_T            *vbp;

/* Generate the VarBindList sequence header */
A_EncodeType(A_SEQUENCE, A_UNIVERSAL | A_CONSTRUCTOR,
             A_EncodeHelper, (OCTET_T *)ebuffp);
A_EncodeLength(vblp->vbl_length, A_EncodeHelper, (OCTET_T *)ebuffp);

for (; vblp != (VBL_T *)0; vblp = vblp->vblp)
    if ((vbp = vblp->vblist) != (VB_T *)0) {
        int i;
        for (i = 0; i < vblp->vbl_count; i++, vbp++) {
            A_EncodeType(A_SEQUENCE, A_UNIVERSAL | A_CONSTRUCTOR,
                         A_EncodeHelper, (OCTET_T *)ebuffp);

            A_EncodeLength(vbp->vb_seq_size,
                           A_EncodeHelper, (OCTET_T *)ebuffp);

            A_EncodeObjectId(A_OBJECTID, A_UNIVERSAL | A_PRIMITIVE,
                             &(vbp->vb_obj_id),
                             A_EncodeHelper, (OCTET_T *)ebuffp);

            switch (vbp->vb_data_flags_n_type) {
              case VT_NUMBER:
                   A_EncodeInt(VT_NUMBER & ~A_IDCF_MASK,
                               VT_NUMBER & A_IDCF_MASK,
                               vbp->value_u.v_number,
                               A_EncodeHelper, (OCTET_T *)ebuffp);
                   break;
              case VT_COUNTER:
                   A_EncodeUnsignedInt(VT_COUNTER & ~A_IDCF_MASK,
                                       VT_COUNTER & A_IDCF_MASK,
                                       vbp->value_u.v_counter,
                                       A_EncodeHelper, (OCTET_T *)ebuffp);
                   break;
              case VT_GAUGE:
                   A_EncodeUnsignedInt(VT_GAUGE & ~A_IDCF_MASK,
                                       VT_GAUGE & A_IDCF_MASK,
                                       vbp->value_u.v_gauge,
                                       A_EncodeHelper, (OCTET_T *)ebuffp);
                   break;
              case VT_TIMETICKS:
                   A_EncodeUnsignedInt(VT_TIMETICKS & ~A_IDCF_MASK,
                                       VT_TIMETICKS & A_IDCF_MASK,
                                       vbp->value_u.v_timeticks,
                                       A_EncodeHelper, (OCTET_T *)ebuffp);
                   break;
              case VT_STRING:
                   A_EncodeOctetString(VT_STRING & ~A_IDCF_MASK,
                                       VT_STRING & A_IDCF_MASK,
                                       vbp->value_u.v_string.start_bp,
                                       EBufferUsed(&(vbp->value_u.v_string)),
                                       A_EncodeHelper, (OCTET_T *)ebuffp);
                   break;
              case VT_OPAQUE:
                    A_EncodeOctetString(VT_OPAQUE & ~A_IDCF_MASK,
                                       VT_OPAQUE & A_IDCF_MASK,
                                       vbp->value_u.v_string.start_bp,
                                       EBufferUsed(&(vbp->value_u.v_string)),
                                       A_EncodeHelper, (OCTET_T *)ebuffp);
                   break;
              case VT_OBJECT:
                    A_EncodeObjectId(A_OBJECTID, A_UNIVERSAL | A_PRIMITIVE,
                                     &(vbp->value_u.v_object),
                                     A_EncodeHelper, (OCTET_T *)ebuffp);
                   break;
              case VT_EMPTY:
                   A_EncodeType(VT_EMPTY & ~A_IDCF_MASK,
                                VT_EMPTY & A_IDCF_MASK,
                                A_EncodeHelper, (OCTET_T *)ebuffp);     
                   A_EncodeLength(0, A_EncodeHelper, (OCTET_T *)ebuffp);
                   break;
              case VT_IPADDRESS:
                    A_EncodeOctetString(VT_IPADDRESS & ~A_IDCF_MASK,
                                       VT_IPADDRESS & A_IDCF_MASK,
                                       vbp->value_u.v_network_address,
                                       4,
                                       A_EncodeHelper, (OCTET_T *)ebuffp);
                   break;

              case VT_NOSUCHOBJ:
              case VT_NOSUCHINS:
              case VT_ENDOFMIB:
                   A_EncodeType(
			(ATVALUE_T)(vbp->vb_data_flags_n_type & ~A_IDCF_MASK),
                        (OCTET_T)(vbp->vb_data_flags_n_type & A_IDCF_MASK),
                         A_EncodeHelper, (OCTET_T *)ebuffp);  
                   A_EncodeLength(0, A_EncodeHelper, (OCTET_T *)ebuffp);
                   break;

/* We only do include the following cases if v2 types are installed */
#if (ENVOY_USE_V2_TYPES)
              case VT_COUNTER64:
                   DYNCFG_IFCFGVBL_BEGIN(envoy_use_v2_types)
                   A_EncodeUnsignedInt64(VT_COUNTER64 & ~A_IDCF_MASK,
                                         VT_COUNTER64 & A_IDCF_MASK,
                                         &(vbp->value_u.v_counter64),
                                         A_EncodeHelper, (OCTET_T *)ebuffp);
                   break;
                   DYNCFG_IFCFGVBL_END(envoy_use_v2_types)
#endif /* (ENVOY_USE_V2_TYPES) */
              default:
                   break;
              }
            }
        }
}

/****************************************************************************
\NOMANUAL
        ENCODE_SNMP_NORMAL_PDU
****************************************************************************/
void
  encode_snmp_normal_pdu(SNMP_PKT_T *rp,
                         EBUFFER_T  *ebuffp)
{
/* Generate the PDU header */
A_EncodeType(rp->pdu_type, A_DEFAULT_SCOPE | A_CONSTRUCTOR,
             A_EncodeHelper, (OCTET_T *)ebuffp);
A_EncodeLength(rp->pdu_length, A_EncodeHelper, (OCTET_T *)ebuffp);

/* Encode request-id */
A_EncodeInt(A_INTEGER, A_UNIVERSAL | A_PRIMITIVE, rp->pdu.std_pdu.request_id,
            A_EncodeHelper, (OCTET_T *)ebuffp);

/* Encode error-status */
A_EncodeInt(A_INTEGER, A_UNIVERSAL | A_PRIMITIVE,rp->pdu.std_pdu.error_status,
            A_EncodeHelper, (OCTET_T *)ebuffp);

/* Encode error-index */
A_EncodeInt(A_INTEGER, A_UNIVERSAL | A_PRIMITIVE, rp->pdu.std_pdu.error_index,
            A_EncodeHelper, (OCTET_T *)ebuffp);

encode_var_bind_list(&(rp->pdu.std_pdu.std_vbl), ebuffp);
}

#if (INSTALL_ENVOY_SNMP_VERSION_1 || INSTALL_ENVOY_SNMP_VERSION_2)
/****************************************************************************
        ENCODE_SNMP_COMMON
****************************************************************************/
static void
  encode_snmp_common(EBUFFER_T *ebuffp,
                     ALENGTH_T  overall_length,
                     INT_32_T   snmp_version,
                     EBUFFER_T *community)
{               
/* Generate the Message sequence header */
A_EncodeType(A_SEQUENCE, A_UNIVERSAL | A_CONSTRUCTOR,
             A_EncodeHelper, (OCTET_T *)ebuffp);
A_EncodeLength(overall_length, A_EncodeHelper, (OCTET_T *)ebuffp);

A_EncodeInt(A_INTEGER, A_UNIVERSAL | A_PRIMITIVE, snmp_version,
            A_EncodeHelper, (OCTET_T *)ebuffp);
A_EncodeOctetString(A_OCTETSTRING, A_UNIVERSAL | A_PRIMITIVE,
                    community->start_bp, EBufferUsed(community),
                    A_EncodeHelper, (OCTET_T *)ebuffp);
}
#endif /* v1 or v2 */

#if (INSTALL_ENVOY_SNMP_VERSION_1)
/****************************************************************************
        BUFSIZE_FOR_TRAP_PKT
****************************************************************************/
static ALENGTH_T
  bufsize_for_trap_pkt(SNMP_PKT_T *rp)
{