bt-67xx_universal_hw/modules/Ethernet/private_mib.c

#include "stm32f4xx.h"  

#include "private_mib.h"
#include "lwip/snmp.h"
#include "lwip/snmp_msg.h"
#include "lwip/snmp_asn1.h"
#include "lwip/snmp_structs.h"

#include "parameters.h"
#include "web_params_api.h"
#include "snmp_api.h"
#include "trap_api.h"
#include "common_config.h"

#include "FreeRTOS.h"

#ifdef PRINTF_STDLIB
#include <stdio.h>
#endif
#ifdef PRINTF_CUSTOM
#include "tinystdio.h"
#endif

extern void ocstrncpy(u8_t *dst, u8_t *src, u16_t n);

char paramStr[255];
uint8_t paramLength = 0;
uint32_t paramInt = 0;

static void system_get_object_def_ee( u8_t ident_len, s32_t *ident, struct obj_def *od );
static void system_get_value_ee(struct obj_def *od, u16_t len, void *value);
static u8_t system_set_test_ee(struct obj_def *od, u16_t len, void *value);
static void system_set_value_ee(struct obj_def *od, u16_t len, void *value);

/* Функции для узла Signals */
static void signals_get_object_def (u8_t ident_len, s32_t *ident, struct obj_def *od);
static void signals_get_value (struct obj_def *od, u16_t len, void *value);
static u8_t signals_set_test (struct obj_def *od, u16_t len, void *value);
static void signals_set_value (struct obj_def *od, u16_t len, void *value);

/*------------------------------------------------------------------------------
 Описание узлов 
------------------------------------------------------------------------------*/
/* узел SYSTEM (операции с EEPROM) */
/*             0 1 2 3 4 5 6 */
/* system .1.3.6.1.2.1.1 */
const mib_scalar_node system_scalar_ee = {
  &system_get_object_def_ee,
  &system_get_value_ee,
  &system_set_test_ee,
  &system_set_value_ee,
  MIB_NODE_SC,
  0
};

// переменные узла SIGNALS ------------------------------------------

const mib_scalar_node signals_var = 
{
  &signals_get_object_def,
  &signals_get_value,
  &signals_set_test,
  &signals_set_value,
  MIB_NODE_SC,
  0
};

// узел SIGNALS -----------------------------------------------------

const s32_t signals_ids[27] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 };

struct mib_node* const signals_nodes[13] = 
{
  (struct mib_node* const)&signals_var,
  (struct mib_node* const)&signals_var,
  (struct mib_node* const)&signals_var,
  (struct mib_node* const)&signals_var,
  (struct mib_node* const)&signals_var,
  (struct mib_node* const)&signals_var,
  (struct mib_node* const)&signals_var,
  (struct mib_node* const)&signals_var,
  (struct mib_node* const)&signals_var,
  (struct mib_node* const)&signals_var,
  (struct mib_node* const)&signals_var,
  (struct mib_node* const)&signals_var,
  (struct mib_node* const)&signals_var
};

const struct mib_array_node signals = 
{
  &noleafs_get_object_def,
  &noleafs_get_value,
  &noleafs_set_test,
  &noleafs_set_value,
  MIB_NODE_AR,
  13,
  signals_ids,
  signals_nodes
};


// узел BT-6701 ------------------------------------------------------------

const s32_t bt6701_ids[1] = { 1 };

struct mib_node* const bt6701_nodes[1] = 
{
  (struct mib_node* const)&signals,
};

const struct mib_array_node bt6701 = 
{
  &noleafs_get_object_def,
  &noleafs_get_value,
  &noleafs_set_test,
  &noleafs_set_value,
  MIB_NODE_AR,
  1,
  bt6701_ids,
  bt6701_nodes
};

// узел swt ------------------------------------------------------------
const s32_t swt_ids[1] = { 
1
};

struct mib_node* const swt_nodes[1] = 
{
  (struct mib_node* const)&bt6701,
};

const struct mib_array_node swt = 
{
  &noleafs_get_object_def,
  &noleafs_get_value,
  &noleafs_set_test,
  &noleafs_set_value,
  MIB_NODE_AR,
  1,
  swt_ids,
  swt_nodes
};

// узел ROTEK ------------------------------------------------------------

const s32_t rotek_ids[1] = { 911 };

struct mib_node* const rotek_nodes[1] = 
{
  (struct mib_node* const)&swt,
};

const struct mib_array_node rotek = 
{
  &noleafs_get_object_def,
  &noleafs_get_value,
  &noleafs_set_test,
  &noleafs_set_value,
  MIB_NODE_AR,
  1,
  rotek_ids,
  rotek_nodes
};

// узел ENTERPRISES -------------------------------------------------------

const s32_t enterprises_ids[1] = { 41752 };

struct mib_node* const enterprises_nodes[1] = 
{
  (struct mib_node* const)&rotek
};

const struct mib_array_node enterprises = 
{
  &noleafs_get_object_def,
  &noleafs_get_value,
  &noleafs_set_test,
  &noleafs_set_value,
  MIB_NODE_AR,
  1,
  enterprises_ids,
  enterprises_nodes
};

// узел PRIVATE -----------------------------------------------------------

const s32_t mib_private_ids[1] = { 1 };

struct mib_node* const mib_pivate_nodes[1] = 
{
  (struct mib_node* const)&enterprises
};

const struct mib_array_node mib_private = 
{
  &noleafs_get_object_def,
  &noleafs_get_value,
  &noleafs_set_test,
  &noleafs_set_value,
  MIB_NODE_AR,
  1,
  mib_private_ids,
  mib_pivate_nodes
};


/*------------------------------------------------------------------------------
 Функции
------------------------------------------------------------------------------*/

// Функции для узла SIGNALS

/**-----------------------------------------------------------------------------
 \fn     static void signals_get_object_def (u8_t ident_len, s32_t *ident, struct obj_def *od)
 \brief  функция получения свойств переменных узла Identification
 \param  ident_len - the address length. длина адреса
 \param  ident - points to objectname.0 (object id trailer) 
 \param  od - points to object definition. указатель на описание переменной
 \return нет
------------------------------------------------------------------------------*/
static void signals_get_object_def (u8_t ident_len, s32_t *ident, struct obj_def *od)
{
  u8_t id;
  
  /* return to object name, adding index depth (1) */
  ident_len += 1;
  ident -= 1;
  if (ident_len == 2)
  {
    od->id_inst_len = ident_len;
    od->id_inst_ptr = ident;

    id = ident[0];
    
    switch (id)
    {
      case 1: /* FWVersion */
		GetVersionStr(paramStr, &paramLength);
        od->instance = MIB_OBJECT_SCALAR;
        od->access = MIB_OBJECT_READ_ONLY;
        od->asn_type = SNMP_ASN1_OC_STR;
        od->v_len = paramLength;
        break;
	 case 2: /* RestoreSignal */
		GetRestore(paramStr, &paramLength);
        od->instance = MIB_OBJECT_SCALAR;
        od->access = MIB_OBJECT_READ_WRITE;
        od->asn_type = SNMP_ASN1_INTEG;
        od->v_len = sizeof(s32_t);
        break;
	  case 3: /* RebootSignal */
		GetReboot(paramStr, &paramLength);
		od->instance = MIB_OBJECT_SCALAR;
        od->access = MIB_OBJECT_READ_WRITE;
        od->asn_type = SNMP_ASN1_INTEG;
        od->v_len = sizeof(s32_t);
        break;
	  case 4: /* IntTemp */
		GetInternalTempStr(paramStr, &paramLength);
        od->instance = MIB_OBJECT_SCALAR;
        od->access = MIB_OBJECT_READ_ONLY;
        od->asn_type = SNMP_ASN1_OC_STR;
        od->v_len = paramLength;
        break;
      case 5: /* LineFailBit */
		GetLineFailBitStr(paramStr, &paramLength);
        od->instance = MIB_OBJECT_SCALAR;
        od->access = MIB_OBJECT_READ_ONLY;
        od->asn_type = SNMP_ASN1_OC_STR;
        od->v_len = paramLength;
        break;
      case 6: /* LowBatBit */
		GetLowBatteryBitStr(paramStr, &paramLength);
        od->instance = MIB_OBJECT_SCALAR;
        od->access = MIB_OBJECT_READ_ONLY;
        od->asn_type = SNMP_ASN1_OC_STR;
        od->v_len = paramLength;
        break;
	  case 7: /* InFreq */
		GetInputFreqStr(paramStr, &paramLength);
		od->instance = MIB_OBJECT_SCALAR;
        od->access = MIB_OBJECT_READ_ONLY;
        od->asn_type = SNMP_ASN1_OC_STR;
        od->v_len = paramLength;
		break;
	  case 8: /* OutFreq */
		GetOutputFreqStr(paramStr, &paramLength);
        od->instance = MIB_OBJECT_SCALAR;
        od->access = MIB_OBJECT_READ_ONLY;
        od->asn_type = SNMP_ASN1_OC_STR;
        od->v_len = paramLength;
		break;
	  case 9: /* InVoltVAC */
		GetInputVoltageStr(paramStr, &paramLength);
		od->instance = MIB_OBJECT_SCALAR;
        od->access = MIB_OBJECT_READ_ONLY;
        od->asn_type = SNMP_ASN1_OC_STR;
        od->v_len = paramLength;
		break;
	  case 10: /* OutVoltVAC */
		GetOutputVoltageStr(paramStr, &paramLength);
        od->instance = MIB_OBJECT_SCALAR;
        od->access = MIB_OBJECT_READ_ONLY;
        od->asn_type = SNMP_ASN1_OC_STR;
        od->v_len = paramLength;
        break;
	  case 11: /* Power */
		GetPowerStr(paramStr, &paramLength);
		od->instance = MIB_OBJECT_SCALAR;
        od->access = MIB_OBJECT_READ_ONLY;
        od->asn_type = SNMP_ASN1_OC_STR;
        od->v_len = paramLength;
		break;
	  case 12: /* BatCap */
		GetBatCapacityStr(paramStr, &paramLength);
        od->instance = MIB_OBJECT_SCALAR;
        od->access = MIB_OBJECT_READ_ONLY;
        od->asn_type = SNMP_ASN1_OC_STR;
        od->v_len = paramLength;
        break;	
      case 13: /* ConnectMonitor */
		GetConnectMonitorStr(paramStr, &paramLength);
        od->instance = MIB_OBJECT_SCALAR;
        od->access = MIB_OBJECT_READ_ONLY;
        od->asn_type = SNMP_ASN1_OC_STR;
        od->v_len = paramLength;
        break;	
      default:
        //LWIP_DEBUGF(SNMP_MIB_DEBUG,("planar_get_object_def: no such object\n"));
        od->instance = MIB_OBJECT_NONE;
        break;
    };
  }
  else
  {
    LWIP_DEBUGF(SNMP_MIB_DEBUG,("planar_get_object_def: no scalar\n"));
    od->instance = MIB_OBJECT_NONE;
  }
}

/**-----------------------------------------------------------------------------
 \fn     static void Identification_get_value(struct obj_def *od, u16_t len, void *value)
 \brief  функция получения значения переменных узла Identification
 \param  obj_def - указатель на описание переменной
 \param  len - длина переменной в байтах 
 \param  value - указатель на значение переменной
 \return нет
------------------------------------------------------------------------------*/
static void signals_get_value (struct obj_def *od, u16_t len, void *value)
{
  u8_t id;
  
  id = od->id_inst_ptr[0];
  
  switch (id)
  {
    case 1: /* FWVersion */
	  ocstrncpy((u8_t*)value, (u8_t*)paramStr, len);
      break;
	case 2: /* RestoreSignal */
	  *((s32_t*)value) = 0;
      break;
	case 3: /* RebootSignal */
	  *((s32_t*)value) = 0;
      break;
	case 4: /* IntTemp */
	  ocstrncpy((u8_t*)value, (u8_t*)paramStr, len);
      break;  
	case 5: /* LineFailBit */
	  ocstrncpy((u8_t*)value, (u8_t*)paramStr, len);
      break;  
    case 6: /* LowBatBit */
	  ocstrncpy((u8_t*)value, (u8_t*)paramStr, len);
      break;
	case 7: /* InFreq */
	  ocstrncpy((u8_t*)value, (u8_t*)paramStr, len);
      break;  
	case 8: /* OutFreq */
	  ocstrncpy((u8_t*)value, (u8_t*)paramStr, len);
      break;  
	case 9: /* InVoltVAC */
	  ocstrncpy((u8_t*)value, (u8_t*)paramStr, len);
      break;
	case 10: /* OutVoltVAC */
	  ocstrncpy((u8_t*)value, (u8_t*)paramStr, len);
      break;
	case 11: /* Power */
      ocstrncpy((u8_t*)value, (u8_t*)paramStr, len);
      break;
	case 12: /* BatCap */
	  ocstrncpy((u8_t*)value, (u8_t*)paramStr, len);
      break;
    case 13: /* ConnectMonitor */
	  ocstrncpy((u8_t*)value, (u8_t*)paramStr, len);
      break;  
    default :
	  break;
  };
}

/**-----------------------------------------------------------------------------
 \fn     static void Identification_set_value (struct obj_def *od, u16_t len, void *value)
 \brief  функция записи значений переменных узла Identification
 \param  obj_def - указатель на описание переменной
 \param  len - длина переменной в байтах 
 \param  value - указатель на значение переменной
 \return нет
------------------------------------------------------------------------------*/
static void signals_set_value (struct obj_def *od, u16_t len, void *value)
{
  u8_t id;
  uint32_t val;
  
  id = od->id_inst_ptr[0];

  val = *((s32_t*)value);
  
  switch (id)
  {
    case 2: /* RestoreSignal */
      if (val == 1) {
        SNMP_SendUserTrap(DEVICE_RESTORED);
        HTTP_ResetSettings();
      }
    break;
    case 3: /* RebootSignal */
      if (val == 1)
        HTTP_StartResetTask(false);
    break;
    default :
    break;
  };
  
}

/**-----------------------------------------------------------------------------
 \fn     static u8_t Identification_set_test (struct obj_def *od, u16_t len, void *value)
 \brief  функция проверки записываемых значений переменных узла Identification
 \param  obj_def - указатель на описание переменной
 \param  len - длина переменной в байтах 
 \param  value - указатель на значение переменной
 \return 0 - некорректное значение
         1 - корректное значение
------------------------------------------------------------------------------*/
static u8_t signals_set_test (struct obj_def *od, u16_t len, void *value)
{
  u8_t id, set_ok;

  LWIP_UNUSED_ARG(value);
  set_ok = 0;
  id = od->id_inst_ptr[0];
  
  switch (id)
  {
    case 2: 
      if ( len == sizeof(s32_t) )
      {
        set_ok = 1;
      }
      break;  
	  
    case 3: 
      if ( len == sizeof(s32_t) )
      {
        set_ok = 1;
      }
      break; 
  };
  
  return set_ok;
}

/**
 * Returns systems object definitions (eeprom).
 *
 * @param ident_len the address length (2)
 * @param ident points to objectname.0 (object id trailer)
 * @param od points to object definition.
 */
static void
system_get_object_def_ee(u8_t ident_len, s32_t *ident, struct obj_def *od)
{
  u8_t id;

  /* return to object name, adding index depth (1) */
  ident_len += 1;
  ident -= 1;
  if (ident_len == 2)
  {
    od->id_inst_len = ident_len;
    od->id_inst_ptr = ident;

    id = ident[0];
    //LWIP_DEBUGF(SNMP_MIB_DEBUG,("get_object_def_ee system.%"U16_F".0\n",(u16_t)id));
    switch (id)
    {
      case 4: /* sysContact */
        od->instance = MIB_OBJECT_SCALAR;
        od->access = MIB_OBJECT_READ_WRITE;
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OC_STR);
        od->v_len = 1 /*GetSnmpStringLen(SNMP_SYSCONTACT_TYPE)*/;
        break;
      case 5: /* sysName */
        od->instance = MIB_OBJECT_SCALAR;
        od->access = MIB_OBJECT_READ_WRITE;
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OC_STR);
        od->v_len = 1 /*GetSnmpStringLen(SNMP_SYSNAME_TYPE)*/;
        break;
      case 6: /* sysLocation */
        od->instance = MIB_OBJECT_SCALAR;
        od->access = MIB_OBJECT_READ_WRITE;
        od->asn_type = (SNMP_ASN1_UNIV | SNMP_ASN1_PRIMIT | SNMP_ASN1_OC_STR);
        od->v_len = 1 /*GetSnmpStringLen(SNMP_SYSLOCATION_TYPE)*/;
        break;
      default:
        //LWIP_DEBUGF(SNMP_MIB_DEBUG,("system_get_object_def_ee: no such object\n"));
        od->instance = MIB_OBJECT_NONE;
        break;
    };
  }
  else
  {
    LWIP_DEBUGF(SNMP_MIB_DEBUG,("system_get_object_def_ee: no scalar\n"));
    od->instance = MIB_OBJECT_NONE;
  }
}
// ----------------------------------------------------------------------------


/**
 * Returns system object value.
 *
 * @param ident_len the address length (2)
 * @param ident points to objectname.0 (object id trailer)
 * @param len return value space (in bytes)
 * @param value points to (varbind) space to copy value into.
 */
static void
system_get_value_ee(struct obj_def *od, u16_t len, void *value)
{
  u8_t id;

  id = od->id_inst_ptr[0];
  switch (id)
  {
    case 4: /* sysContact */
      //GetSnmpString(SNMP_SYSCONTACT_TYPE, value, len );
      break;
    case 5: /* sysName */
      //GetSnmpString(SNMP_SYSNAME_TYPE, value, len );
      break;
    case 6: /* sysLocation */
      //GetSnmpString(SNMP_SYSLOCATION_TYPE, value, len );
      break;
  };
}
// ----------------------------------------------------------------------------


static u8_t
system_set_test_ee(struct obj_def *od, u16_t len, void *value)
{
  u8_t id, set_ok;

  LWIP_UNUSED_ARG(value);
  set_ok = 0;
  id = od->id_inst_ptr[0];
  switch (id)
  {
    case 4: /* sysContact */
      if ( len <= 255 )
      {
        set_ok = 1;
      }
      break;
    case 5: /* sysName */
      if ( len <= 255 )
      {
        set_ok = 1;
      }
      break;
    case 6: /* sysLocation */
      if ( len <= 255 )
      {
        set_ok = 1;
      }
      break;
  };
  return set_ok;
}
// ----------------------------------------------------------------------------


static void
system_set_value_ee(struct obj_def *od, u16_t len, void *value)
{
  u8_t id;

  id = od->id_inst_ptr[0];
  switch (id)
  {
    case 4: /* sysContact */
      //SetSnmpString(SNMP_SYSCONTACT_TYPE, value, len );
      //*syscontact_len_ptr = len;
    break;
    case 5: /* sysName */
      //SetSnmpString(SNMP_SYSNAME_TYPE, value, len );
      //*sysname_len_ptr = len;
    break;
    case 6: /* sysLocation */
      //SetSnmpString(SNMP_SYSLOCATION_TYPE, value, len );
      //*syslocation_len_ptr = len;
    break;
  };
}
// ----------------------------------------------------------------------------

/**-----------------------------------------------------------------------------
 \fn     err_t snmp_send_trap_ex (s8_t generic_trap, 
                         struct snmp_obj_id *eoid, 
                         s32_t specific_trap, 
                         struct snmp_obj_id* varbinds, 
                         u8_t varbinds_num)
 \brief  функция посылки трапа с возможностью пристыковывать переменные
 \param  generic_trap  - код трапа
 \param  eoid          - указатель на enterprise object identifier
 \param  specific_trap - used for enterprise traps when generic_trap == 6
 \param  varbinds      - указатель на переменные
 \param  varbinds_num  - число переменных
 \return код ошибки
------------------------------------------------------------------------------*/
err_t snmp_send_trap_ex (s8_t generic_trap, 
                         struct snmp_obj_id *eoid, 
                         s32_t specific_trap, 
                         struct snmp_obj_id* varbinds, 
                         u8_t varbinds_num)
{
	uint8_t bSnmpActive = 1;
	
	struct snmp_varbind** vb_list;
	struct mib_node* node;
	struct obj_def obj;
	err_t tResult;
	s32_t* VarNum;
    struct snmp_name_ptr np;
	

	/* SNMP не готово - ничего не отправляем */
	if( !bSnmpActive )
	{
		return ERR_MEM;
	}
	
	/* создаем таблицу указателей переменных */
	pvPortMalloc( varbinds_num * sizeof(struct snmp_varbind*) );
	/*
	if(vb_list == NULL)
	{
		return ERR_MEM;
	}
	*/
	/* создаем сами переменные */
	for(u8_t i = 0; i < varbinds_num; i++)
	{
		/* ищем узел в дереве*/
		node = snmp_search_tree( (struct mib_node*)&internet, varbinds[i].len - 3, 
										 &varbinds[i].id[4], &np );
		
		//node = snmp_search_tree( (struct mib_node*)&internet, varbinds[i].len, 
		//								 &varbinds[i].id[0], &np );
		
		if(node != NULL)
		{
			/* получаем информацию о переменной узла */
			VarNum = &varbinds[i].id[ varbinds[i].len - 1 ];
			
			if( node->node_type == MIB_NODE_EX)
			{
				struct mib_external_node* node_ex;
				node_ex = (struct mib_external_node*)node;
				/* TODO: подставить правильный rid вместо 0 */
				node_ex->get_object_def_a(0, 1, VarNum, &obj);
			}
			else
			{
				node->get_object_def(1, VarNum, &obj);
			}
			
			/* создаем переменную */
			vb_list[i] = snmp_varbind_alloc(&varbinds[i], obj.asn_type, obj.v_len);
			if( vb_list[i] != NULL )
			{
				{
					/* получаем значение переменной */
					if( node->node_type == MIB_NODE_EX)
					{
						struct mib_external_node* node_ex;
						node_ex = (struct mib_external_node*)node;
						/* TODO: подставить правильный rid вместо 0 */
						node_ex->get_value_a(0, &obj, obj.v_len, vb_list[i]->value);
					}
					else
					{
						node->get_value(&obj, obj.v_len, vb_list[i]->value);
					}
					/* добавляем переменную в ловушку */
					snmp_varbind_tail_add(&trap_msg.outvb, vb_list[i]);
				}
			}
		}
	}

	/* посылаем ловушку */
	tResult = snmp_send_trap(generic_trap, eoid, specific_trap);
	
	/* удаляем переменные из списка */
	snmp_varbind_list_free(&trap_msg.outvb);
	
	/* удаляем указатели переменных */
	vPortFree(vb_list);
	
	return tResult;
}

void SNMP_SendTestTrap(void)
{
/*  
  struct snmp_varbind *vb;
  struct snmp_obj_id objid = {11, {1, 3, 6, 1, 4, 1, 41752, 5, 16, 2, 1}};
  unsigned char msg[] = "Sex, drugs and LwIP";
  unsigned char msglen = 19;
  
  vb = snmp_varbind_alloc(&objid, SNMP_ASN1_OPAQUE, msglen);
  
  vb->value = &msg;
           
  trap_msg.outvb.head = vb;
  trap_msg.outvb.tail = vb;
  trap_msg.outvb.count = 1;
  
  snmp_send_trap(SNMP_GENTRAP_ENTERPRISESPC, &objid, 0);
     
  trap_msg.outvb.head = NULL;
  trap_msg.outvb.tail = NULL;
  trap_msg.outvb.count = 0;
  //vb->value = NULL;
     
  snmp_varbind_free(vb);
*/  
  static struct snmp_obj_id trapObjId = {11, {1, 3, 6, 1, 4, 1, 41752, 5, 16, 2, 1}};
  static struct snmp_obj_id varObjId  = {11, {1, 3, 6, 1, 4, 1, 41752, 5, 16, 1, 1}};
  
  struct snmp_varbind* vb;
  u32_t *u32ptr;
  
  vb = snmp_varbind_alloc(&varObjId, MIB_NODE_SC, 4);
  
  vb->value_len = 4;
  vb->value_type = 0x02;
  u32ptr = vb->value; 	
  *u32ptr = 23;
  
  if( vb != NULL )
	snmp_varbind_tail_add(&trap_msg.outvb, vb);
			
  snmp_send_trap(SNMP_GENTRAP_ENTERPRISESPC, &trapObjId, 0);
	
  /* удаляем переменные из списка */
  snmp_varbind_list_free(&trap_msg.outvb);
  
  //snmp_send_trap_ex(SNMP_GENTRAP_ENTERPRISESPC, &trapObjId, 0, &varObjId, 1);
  
  
#if 0	
	struct snmp_varbind** vb_list;
	struct mib_node* node;
	struct obj_def obj;
	err_t tResult;
	s32_t* VarNum;
    struct snmp_name_ptr np;
	

	/* создаем указатель на переменную */
	pvPortMalloc(sizeof(struct snmp_varbind*) );

	/* создаем сами переменные */
	for(u8_t i = 0; i < varbinds_num; i++)
	{
		/* ищем узел в дереве*/
		node = snmp_search_tree( (struct mib_node*)&internet, varbinds[i].len - 4, 
										 &varbinds[i].id[4], &np );
		
		//node = snmp_search_tree( (struct mib_node*)&internet, varbinds[i].len, 
		//								 &varbinds[i].id[0], &np );
		
		if(node != NULL)
		{
			/* получаем информацию о переменной узла */
			VarNum = &varbinds[i].id[ varbinds[i].len - 1 ];
			
			if( node->node_type == MIB_NODE_EX)
			{
				struct mib_external_node* node_ex;
				node_ex = (struct mib_external_node*)node;
				/* TODO: подставить правильный rid вместо 0 */
				node_ex->get_object_def_a(0, 1, VarNum, &obj);
			}
			else
			{
				node->get_object_def(1, VarNum, &obj);
			}
			
			/* создаем переменную */
			vb_list[i] = snmp_varbind_alloc(&varbinds[i], obj.asn_type, obj.v_len);
			if( vb_list[i] != NULL )
			{
				{
					/* получаем значение переменной */
					if( node->node_type == MIB_NODE_EX)
					{
						struct mib_external_node* node_ex;
						node_ex = (struct mib_external_node*)node;
						/* TODO: подставить правильный rid вместо 0 */
						node_ex->get_value_a(0, &obj, obj.v_len, vb_list[i]->value);
					}
					else
					{
						node->get_value(&obj, obj.v_len, vb_list[i]->value);
					}
					/* добавляем переменную в ловушку */
					snmp_varbind_tail_add(&trap_msg.outvb, vb_list[i]);
				}
			}
		}
	}

	/* посылаем ловушку */
	tResult = snmp_send_trap(generic_trap, eoid, specific_trap);
	
	/* удаляем переменные из списка */
	snmp_varbind_list_free(&trap_msg.outvb);
	
	/* удаляем указатели переменных */
	vPortFree(vb_list);
	
	return tResult;
#endif	
}

#define NUM_PRIVATE_TRAP 10
 
//static unsigned char SNMP_TRAP_0_FLAG = 1;
//static struct ip_addr SNMP_TRAP_0_ADDR;
 
extern struct snmp_msg_trap trap_msg;
 
struct private_trap
{
  /* source enterprise ID (sysObjectID) */
  struct snmp_obj_id *enterprise; 
  /* trap ID */
  struct snmp_obj_id *trap_oid;
 
  /* specific trap code */
  u32_t spc_trap;
 
  /* object value ASN1 type */
  u8_t value_type;
  /* object value length (in u8_t) */
  u8_t value_len;
  /* object value */
  void *value;
  /* indicate that the trap is sent */
  u8_t in_use;
};
 
struct private_trap trap_bank[NUM_PRIVATE_TRAP];
 
struct private_trap * getNextFreePrivateTrap()
{
   u8_t index;
   void * result = NULL;
  
   for(index = 0; index < NUM_PRIVATE_TRAP; index++)
   {
      if(!trap_bank[index].in_use)
      {
         trap_bank[index].in_use = 1;
         result = &trap_bank[index];        
         break;
      }
   }
  
   return result; 
}
 
void freePrivateTrap(struct private_trap * trap)
{
   trap->enterprise = NULL;
   trap->trap_oid = NULL;
   trap->value = NULL;
   trap->in_use = 0;  
}
 
void vSendTrapCallback( void * parameters )
{
   struct private_trap * trapToSend;
   struct snmp_varbind * vb;
  
   if( parameters != NULL )
   {
      trapToSend = (struct private_trap *) parameters;
     
      vb = snmp_varbind_alloc(trapToSend->enterprise,
                              trapToSend->value_type,
                              trapToSend->value_len);
                             
      vb->value = trapToSend->value;
           
      trap_msg.outvb.head = vb;
      trap_msg.outvb.tail = vb;
      trap_msg.outvb.count = 1;
     
      snmp_send_trap(SNMP_GENTRAP_ENTERPRISESPC, trapToSend->trap_oid, trapToSend->spc_trap);
     
      trap_msg.outvb.head = NULL;
      trap_msg.outvb.tail = NULL;
      trap_msg.outvb.count = 0;
     
      vb->value = NULL;
     
      snmp_varbind_free(vb);
     
      freePrivateTrap(trapToSend);
   }  
}