vb_rtns.c

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

/****************************************************************************
NAME:  Clean_Pkt

PURPOSE:  Clean up any dynamically allocated memory which may be attached
          to an SNMP packet structure.

PARAMETERS:
        SNMP_PKT_T *    The packet structure to be cleaned

RETURNS:  nothing
****************************************************************************/
static void
  Clean_Pkt(SNMP_PKT_T *        rp)
{
#if defined(SNMP_release_private)
SNMP_release_private(rp);
#endif

/* Decide what we need to clean up.  If we have v1 installed we check if
   this is a trap type pdu in which case we clean the trap vbl, otherwise
   we clean the standard and saved vbls */

EBufferClean(&(rp->community));

#if (INSTALL_ENVOY_SNMP_RFC2275_VIEWS)
EBufferClean(&(rp->view_name));
#endif

#if INSTALL_ENVOY_SNMP_VERSION_1
if (rp->pdu_type == TRAP_PDU) { /* Its a trap form of pdu */
    Clean_Obj_ID(&(rp->pdu.trap_pdu.enterprise_objid));
    Clean_vb_list(&(rp->pdu.trap_pdu.trap_vbl));
    }
else {
    Clean_vb_list(&(rp->pdu.std_pdu.std_vbl));
    Clean_vb_list(&(rp->pdu.std_pdu.saved_vbl));
    }
#else
Clean_vb_list(&(rp->pdu.std_pdu.std_vbl));
Clean_vb_list(&(rp->pdu.std_pdu.saved_vbl));
#endif /* INSTALL_ENVOY_SNMP_VERSION_1 */

#if INSTALL_ENVOY_SNMP_VERSION_3
DYNCFG_IFCFGVBL_BEGIN(snmpv3_component)
EBufferClean(&(rp->msg_con_id));
EBufferClean(&(rp->msg_sec_id));
EBufferClean(&(rp->msg_sec_name));

#if INSTALL_ENVOY_SNMP_COEXISTENCE
EBufferClean(&(rp->comm_entry));
#endif

DYNCFG_IFCFGVBL_END(snmpv3_component)
#endif

#if INSTALL_ENVOY_SNMP_LOCK
if (rp->coarse_lock) {
    switch (rp->lockflags) {
        case LOCK_READ:
	    ENVOY_SNMP_RELEASE_READ_LOCK((*rp->coarse_lock));
	    break;
        case LOCK_WRITE:
	    ENVOY_SNMP_RELEASE_WRITE_LOCK((*rp->coarse_lock));
	    break;
        case LOCK_NOLOCK:
        default:
	    break;
        }
    }

#if INSTALL_ENVOY_CONTINUE_REENTRANT
ENVOY_SNMP_FREE_LOCK_TAG(rp->continue_lock, ENVOY_CONTINUELOCK_TAG);
#endif
#endif
}

/*******************************************************************************
*
* SNMP_Free - release dynamic memory associated with an SNMP packet
* SYNOPSIS
*
* \cs
* void SNMP_Free
*     (
*     SNMP_PKT_T *  rp 
*     )
* \ce
*
* DESCRIPTION
*
* This routine releases any dynamic memory associated with an SNMP packet 
* structure.
*
* Parameters:
* \is
* \i <*rp>
* Point to the packet to be freed.
* \ie
*
* \&NOTE: The pointer <*rp> is invalid after you call SNMP_Free().
*
* RETURNS: None.
*
* ERRNO: N/A
*
* SEE ALSO: None.
*/
void
  SNMP_Free(SNMP_PKT_T *rp)
{

if (rp != 0) {
#if (INSTALL_ENVOY_MAIN_AGENT && INSTALL_ENVOY_SNMP_SERIALIZE)
  /* If we are serializing packets we need to adjust the
     reader/writer counts */
  GateDecrement(rp);
#endif /* (INSTALL_ENVOY_SNMP_SERIALIZE) */
  Clean_Pkt(rp);
  SNMP_memory_free((char *)rp);
  }
}

/****************************************************************************
\NOMANUAL
NAME:  VarBindList_Allocate

PURPOSE:  Allocate a fresh set of VarBind structures

PARAMETERS:     Number of VarBind entries

RETURNS:  VB_T *        List of VarBind structures, (VB_T *)0 on failure
****************************************************************************/
VB_T *
  VarBindList_Allocate(int elements)
{
  VB_T  *vbp;
  int    need;

  need = sizeof(VB_T) * elements;
  if (need != 0) {
    if ((vbp = (VB_T *)SNMP_memory_alloc((unsigned int)need)) != 0)
      MEMSET(vbp, 0, need);
    return vbp;
  }
  return 0;
}

/*******************************************************************************
*
* VBList_Allocate - allocate a 'VBL_T' structure
* SYNOPSIS
*
* \cs
* VBL_T *  VBList_Allocate
*     (
*     int elements 
*     )
* \ce
*
* DESCRIPTION
*
* This routine allocates a 'VBL_T' structure containing the number of 
* 'VarBinds' equal to <elements>.
*
* Parameters:
* \is
* \i <elements>
* Specify the number of <elements> in a 'VBL_T' structure.
* \ie
*
* RETURNS: If successful, this routine returns a pointer to a 'VBL_T' 
* structure. Otherwise, it returns 0.
*
* ERRNO: N/A
*
* SEE ALSO: VBL_Bind_Counter(), VBL_Bind_Gauge(), VBL_Bind_Integer(), 
* VBL_Bind_IP_Address(), VBL_Bind_Null(), VBL_Bind_Object_ID(), 
* VBL_Bind_Opaque(), VBL_Bind_String(), VBL_Bind_64_Unsigned_Integer(), 
* VBL_Bind_Timeticks(), VBL_Bind_Unsigned_Integer()
*/
VBL_T *
  VBList_Allocate(int elements)
{
  VBL_T *vblp;

  if ((vblp = (VBL_T *)SNMP_memory_alloc(sizeof(VBL_T))) != 0) {
      MEMSET(vblp, 0, sizeof(VBL_T));
      if ((vblp->vblist = VarBindList_Allocate(elements)) != 0) {
          vblp->vbl_count = elements;
          return vblp;
          }
      }
  SNMP_memory_free((char *)vblp);
  return 0;
}

/*******************************************************************************
*
* VBList_Free - release dynamic memory associated with a 'VarBindList'
* SYNOPSIS
*
* \cs
* void VBList_Free
*     (
*     VBL_T *  rp 
*     )
* \ce
*
* DESCRIPTION
*
* This routine releases any dynamic memory associated with a 'VarBindList''' 
* structure.
*
* Parameters:
* \is
* \i <*rp>
* Indicate a 'VarBindList''' structure.
* \ie
*
* \&NOTE: The pointer <*rp> is invalid after you call VBL_Free().
*
* RETURNS: None.
*
* ERRNO: N/A
*
* SEE ALSO: VBList_Allocate()
*/
void 
  VBList_Free(VBL_T *vblp)
{
Clean_vb_list(vblp);
SNMP_memory_free((char *)vblp);
}

/****************************************************************************
\NOMANUAL
NAME:  Initialize_Pkt

PURPOSE:  Initialize an SNMP packet structure.

PARAMETERS:
        SNMP_PKT_T *    The packet structure to be initialized

RETURNS:  nothing
****************************************************************************/
void
  Initialize_Pkt(SNMP_PKT_T *rp)
{
  MEMSET(rp, 0, sizeof(SNMP_PKT_T));
  rp->pdu_type = NO_PDU;
  rp->maxpkt = SNMP_MAX_PACKET_SIZE;

  EBufferInitialize(&rp->community);

#if (INSTALL_ENVOY_SNMP_RFC2275_VIEWS)
  EBufferInitialize(&rp->view_name);
#endif

#if INSTALL_ENVOY_SNMP_VERSION_3
  DYNCFG_IFCFGVBL_BEGIN(snmpv3_component)
  EBufferInitialize(&(rp->msg_con_id));
  EBufferInitialize(&(rp->msg_sec_id));
  EBufferInitialize(&(rp->msg_sec_name));
  rp->msg_max_size = SNMP_MAX_PACKET_SIZE;
#if INSTALL_ENVOY_SNMP_COEXISTENCE
  EBufferInitialize(&(rp->comm_entry));
#endif

  DYNCFG_IFCFGVBL_END(snmpv3_component)
#endif
    
  rp->lockflags = LOCK_NOLOCK;
  rp->gate_decr = 0;
#if INSTALL_ENVOY_CONTINUE_REENTRANT
  ENVOY_SNMP_INIT_LOCK_TAG(rp->continue_lock, ENVOY_CONTINUELOCK_TAG);
#endif
}

/****************************************************************************
\NOMANUAL
NAME:  SNMP_Allocate

PURPOSE:  Allocate a fresh SNMP packet structure and get the world read lock.
          The world read lock will be freed in SNMP_Free.

PARAMETERS:     None

RETURNS:  SNMP_PKT_T *  SNMP Packet structure, (SNMP_PKT_T *)0 on failure
****************************************************************************/
SNMP_PKT_T *
  SNMP_Allocate()
{
  SNMP_PKT_T    *rp;

  rp = (SNMP_PKT_T *)SNMP_memory_alloc(sizeof(SNMP_PKT_T));
  if (rp == 0)
    return 0;

  Initialize_Pkt(rp);

  return rp;
}