21ic电子技术开发论坛 › 综合技术交流 › 通信技术 › SNMP：简单网络管理协议编程实现
返回列表 发新帖我要提问

[通信技术资料] SNMP：简单网络管理协议编程实现

[复制链接]
5030|1
 楼主| abner_ma 发表于 2023-1-31 16:38 | 显示全部楼层 |阅读模式
网络, 网络管理, 编程, 进程, ge
   SNMP：简单网络管理协议（Simple Network Management Protocol），是由互联网工程任务组定义的一套网络管理协议。SNMP可以使网络管理员通过一台工作站完成对计算机、路由器和其他网络设备的远程管理和监视。利用SNMP协议可以更好地管理和监控网络。管理工作站可以远程管理所有支持该协议的网络设备，如监视网络状态、修改网络设备配置、接收网络事件警告等。SNMP作为TCP/IP协议的一部分，其消息是被封装到UDP协议中进行传输的。SNMP协议主要由两大部分组成：网络管理站（也叫管理进程）和被管的网络单元（也叫被管设备），被管设备种类众多，比如：路由器、终端服务器、打印机等。在本文档中，国民技术的N32G457QEL_EVB V1.1全功能开发板就充当被管理设备。被管设备端和管理相关的软件叫代理程序（SNMP agent）或者代理进程，它是运行于设备上的代码或程序。管理进程和代理进程之间的通信可以有两种方式：一种是管理进程向代理进程发起的，询问其具体参数值（get操作）或者为其设置某个参数值（set操作）；另一种是代理进程主动向管理进程发起的，向其报告自身的某些重要事件的发生（trap操作）。
   到目前为止，SNMP共有三个版本：v1，v2和v3。V1和v2有很多共同的特征，v3在前面版本的基础上增强了安全性方面的功能。其各自的消息格式、操作命令等。
NMP系统基本组件
  SNMP系统基本组件包括网络管理系统NMS（Network Management System）、代理进程（Agent）、被管对象（Managed Object）和管理信息库MIB（Management Information Base）。如图所示他们共同构成SNMP的管理模型，在SNMP的体系结构中都起着至关重要的作用。
NMSNMS是网络中扮演管理者，是一个采用SNMP协议对网络设备进行管理/监视的系统，运行在NMS服务器上。
  • NMS可以向设备上的Agent发出请求，查询或修改一个或多个具体的参数值。
  • NMS可以接收设备上的Agent主动发送的Trap信息，以获知被管理设备当前的状态。


AgentAgent是被管理设备中的一个代理进程，用于维护被管理设备的信息数据并响应来自NMS的请求，把管理数据汇报给发送请求的NMS。
  • Agent接收到NMS的请求信息后，通过MIB表完成相应指令后，并把操作结果响应给NMS。
  • 当设备发生故障或者其它事件时，设备会通过Agent主动发送信息给NMS，向NMS报告设备当前的状态变化。


Managed Object
Managed Object指被管理对象。每一个设备可能包含多个被管理对象，被管理对象可以是设备中的某个硬件，也可以是在硬件、软件（如路由选择协议）上配置的参数集合。

MIBMIB是一个数据库，指明了被管理设备所维护的变量，是能够被Agent查询和设置的信息。MIB在数据库中定义了被管理设备的一系列属性：对象的名称、对象的状态、对象的访问权限和对象的数据类型等。通过MIB，可以完成以下功能：
  • Agent通过查询MIB，可以获知设备当前的状态信息。
  • Agent通过修改MIB，可以设置设备的状态参数。




SNMP嵌入式系统实现方法：
MCU选用Cotex M3系列STM32F103芯片，以太网控制芯片选用WIZnet的W5500。

主要代码:(附件为整个代码)
复制
  1. #include <stdio.h>
    

  2. #include <string.h>
    

  3. #include <stdlib.h>
    

  4. #include <stdarg.h>
    


  5. 

  6. #include "ctype.h"
    

  7. #include "w5500.h"
    

  8. #include "socket.h"
    

  9. #include "config.h"
    

  10. #include "mcu_int.h" 
    

  11. #include "snmpLib.h"
    

  12. #include "snmpDemo.h"
    


  13. 

  14. struct messageStruct request_msg;
    

  15. struct messageStruct response_msg;
    


  16. 

  17. uint8 errorStatus, errorIndex;
    


  18. 

  19. #define COPY_SEGMENT_TEMP20110929(x) \
    

  20. { \
    

  21.         request_msg.index += seglen; \
    

  22.         memcpy(&response_msg.buffer[response_msg.index], &request_msg.buffer[x.start], seglen ); \
    

  23.         response_msg.index += seglen; \
    

  24. }
    


  25. 

  26. void WDEBUG(char *fmt, ...)
    

  27. {
    

  28.         char zlog_string[100];
    

  29.         va_list ap;        
    


  30. 

  31.         va_start(ap, fmt);
    

  32.         vsprintf(zlog_string, fmt, ap);
    

  33.         strcat(zlog_string, "\r\n");
    

  34.         printf(zlog_string);        
    

  35.         va_end(ap);        
    

  36. }
    


  37. 

  38. int32 findEntry(uint8 *oid, int32 len)
    

  39. {
    

  40.         int32 i;
    


  41. 

  42.         for (i = 0 ; i < maxData ; i++)
    

  43.         {
    

  44.                 if (len == snmpData[i].oidlen)
    

  45.                 {
    

  46.                         if (!memcmp(snmpData[i].oid, oid, len)) return(i);
    

  47.                 }
    

  48.         }
    


  49. 

  50.         return OID_NOT_FOUND;
    

  51. }
    


  52. 


  53. 

  54. int32 getOID(int32 id, uint8 *oid, uint8 *len)
    

  55. {
    

  56.         int32 j;
    


  57. 

  58.         if (!((id >= 0) && (id < maxData))) return INVALID_ENTRY_ID;
    


  59. 

  60.         *len = snmpData[id].oidlen;
    


  61. 

  62.         for (j = 0 ; j < *len ; j++)
    

  63.         {
    

  64.                 oid[j] = snmpData[id].oid[j];
    

  65.         }
    


  66. 

  67.         return SUCCESS;
    

  68. }
    


  69. 


  70. 

  71. int32 getValue( uint8 *vptr, int32 vlen)
    

  72. {
    

  73.         int32 index = 0;
    

  74.         int32 value = 0;
    


  75. 

  76.         while (index < vlen)
    

  77.         {
    

  78.                 if (index != 0) value <<= 8;
    

  79.                 value |= vptr[index++];
    

  80.         }
    


  81. 

  82.         return value;
    

  83. }
    


  84. 


  85. 

  86. int32 getEntry(int32 id, uint8 *dataType, void *ptr, int32 *len)
    

  87. {
    

  88.         if (!((id >= 0) && (id < maxData))) return INVALID_ENTRY_ID;
    


  89. 

  90.         *dataType = snmpData[id].dataType;
    


  91. 

  92.         switch(*dataType)
    

  93.         {
    

  94.         case SNMPDTYPE_OCTET_STRING :
    

  95.         case SNMPDTYPE_OBJ_ID :
    

  96.                 {
    

  97.                         uint8 *string = ptr;
    

  98.                         int32 j;
    


  99. 

  100.                         if (snmpData[id].getfunction != NULL)
    

  101.                         {
    

  102.                                 snmpData[id].getfunction( (void *)&snmpData[id].u.octetstring, &snmpData[id].dataLen );
    

  103.                         }
    


  104. 

  105.                         if ( (*dataType)==SNMPDTYPE_OCTET_STRING )
    

  106.                         {
    

  107.                                 snmpData[id].dataLen = (uint8)strlen((int8*)&snmpData[id].u.octetstring);
    

  108.                         }
    


  109. 


  110. 

  111.                         *len = snmpData[id].dataLen;
    

  112.                         for (j = 0 ; j < *len ; j++)
    

  113.                         {
    

  114.                                 string[j] = snmpData[id].u.octetstring[j];
    

  115.                         }
    

  116.                 }
    

  117.                 break;
    


  118. 

  119.         case SNMPDTYPE_INTEGER :
    

  120.         case SNMPDTYPE_TIME_TICKS :
    

  121.         case SNMPDTYPE_COUNTER :
    

  122.         case SNMPDTYPE_GAUGE :
    

  123.                 {
    

  124.                         int32 *value = ( int32 * )ptr;
    


  125. 

  126.                         if (snmpData[id].getfunction != NULL)
    

  127.                         {
    

  128.                                 snmpData[id].getfunction( (void *)&snmpData[id].u.intval, &snmpData[id].dataLen );
    

  129.                         }
    


  130. 

  131.                         *len = sizeof(uint32);
    

  132.                         *value = HTONL(snmpData[id].u.intval);
    

  133.                 }
    

  134.                 break;
    


  135. 

  136.         default : 
    

  137.                 return INVALID_DATA_TYPE;
    

  138.         }
    


  139. 

  140.         return SUCCESS;
    

  141. }
    


  142. 


  143. 

  144. int32 setEntry(int32 id, void *val, int32 vlen, uint8 dataType, int32 index)
    

  145. {
    


  146. 

  147.         int32 retStatus=OID_NOT_FOUND;
    

  148.         int32 j;
    


  149. 

  150.         if (snmpData[id].dataType != dataType)
    

  151.         {
    

  152.                 errorStatus = BAD_VALUE; 
    

  153.                 errorIndex = index;
    

  154.                 return INVALID_DATA_TYPE;
    

  155.         }
    


  156. 

  157.         switch(snmpData[id].dataType)
    

  158.         {
    

  159.         case SNMPDTYPE_OCTET_STRING :
    

  160.         case SNMPDTYPE_OBJ_ID :
    

  161.                 {
    

  162.                         uint8 *string = val;
    

  163.                         for (j = 0 ; j < vlen ; j++)
    

  164.                         {
    

  165.                                 snmpData[id].u.octetstring[j] = string[j];
    

  166.                         }
    

  167.                         snmpData[id].dataLen = vlen;
    

  168.                 }
    

  169.                 retStatus = SUCCESS;
    

  170.                 break;
    


  171. 

  172.         case SNMPDTYPE_INTEGER :
    

  173.         case SNMPDTYPE_TIME_TICKS :
    

  174.         case SNMPDTYPE_COUNTER :
    

  175.         case SNMPDTYPE_GAUGE :
    

  176.                 {
    

  177.                         snmpData[id].u.intval = getValue( (uint8 *)val, vlen);
    

  178.                         snmpData[id].dataLen = vlen;
    


  179. 

  180.                         if (snmpData[id].setfunction != NULL)
    

  181.                         {
    

  182.                                 snmpData[id].setfunction(snmpData[id].u.intval);
    

  183.                         }
    


  184. 

  185.                 }
    

  186.                 retStatus = SUCCESS;
    

  187.                 break;
    


  188. 

  189.         default : 
    

  190.                 retStatus = INVALID_DATA_TYPE;
    

  191.                 break;
    


  192. 

  193.         }
    


  194. 

  195.         return retStatus;
    

  196. }
    


  197. 


  198. 

  199. int32 parseLength(const uint8 *msg, int32 *len)
    

  200. {
    

  201.         int32 i=1;
    


  202. 

  203.         if (msg[0] & 0x80)
    

  204.         {
    

  205.                 int32 tlen = (msg[0] & 0x7f) - 1;
    

  206.                 *len = msg[i++];
    


  207. 

  208.                 while (tlen--)
    

  209.                 {
    

  210.                         *len <<= 8;
    

  211.                         *len |= msg[i++];
    

  212.                 }
    

  213.         }
    

  214.         else
    

  215.         {
    

  216.                 *len = msg[0];
    

  217.         }
    


  218. 

  219.         return i;
    

  220. }
    


  221. 


  222. 

  223. int32 parseTLV(const uint8 *msg, int32 index, tlvStructType *tlv)
    

  224. {
    

  225.         int32 Llen = 0;
    


  226. 

  227.         tlv->start = index;
    


  228. 

  229.         Llen = parseLength((const uint8 *)&msg[index+1], &tlv->len );
    


  230. 

  231.         tlv->vstart = index + Llen + 1;
    


  232. 

  233.         switch (msg[index])
    

  234.         {
    

  235.         case SNMPDTYPE_SEQUENCE:
    

  236.         case GET_REQUEST:
    

  237.         case GET_NEXT_REQUEST:
    

  238.         case SET_REQUEST:
    

  239.                 tlv->nstart = tlv->vstart;
    

  240.                 break;
    

  241.         default:
    

  242.                 tlv->nstart = tlv->vstart + tlv->len;
    

  243.                 break;
    

  244.         }
    


  245. 

  246.         return 0;
    

  247. }
    


  248. 


  249. 

  250. void insertRespLen(int32 reqStart, int32 respStart, int32 size)
    

  251. {
    

  252.         int32 indexStart, lenLength;
    

  253.         uint32 mask = 0xff;
    

  254.         int32 shift = 0;
    


  255. 

  256.         if (request_msg.buffer[reqStart+1] & 0x80)
    

  257.         {
    

  258.                 lenLength = request_msg.buffer[reqStart+1] & 0x7f;
    

  259.                 indexStart = respStart+2;
    


  260. 

  261.                 while (lenLength--)
    

  262.                 {
    

  263.                         response_msg.buffer[indexStart+lenLength] = 
    

  264.                                 (uint8)((size & mask) >> shift);
    

  265.                         shift+=8;
    

  266.                         mask <<= shift;
    

  267.                 }
    

  268.         }
    

  269.         else
    

  270.         {
    

  271.                 response_msg.buffer[respStart+1] = (uint8)(size & 0xff);
    

  272.         }
    

  273. }
    


  274. 


  275. 

  276. int32 parseVarBind(int32 reqType, int32 index)
    

  277. {
    

  278.         int32 seglen = 0, id;
    

  279.         tlvStructType name, value;
    

  280.         int32 size = 0;
    

  281.         
    

  282.         extern const int32 maxData;
    


  283. 

  284.         parseTLV(request_msg.buffer, request_msg.index, &name);
    


  285. 

  286.         if ( request_msg.buffer[name.start] != SNMPDTYPE_OBJ_ID ) return -1;
    


  287. 

  288.         id = findEntry(&request_msg.buffer[name.vstart], name.len);
    


  289. 

  290.         if ((reqType == GET_REQUEST) || (reqType == SET_REQUEST))
    

  291.         {
    

  292.                 seglen = name.nstart - name.start;
    

  293.                 COPY_SEGMENT_TEMP20110929(name);
    

  294.                 size = seglen;
    

  295.         }
    

  296.         else if (reqType == GET_NEXT_REQUEST)
    

  297.         {
    

  298.                 response_msg.buffer[response_msg.index] = request_msg.buffer[name.start];
    


  299. 

  300.                 if (++id >= maxData)
    

  301.                 {
    

  302.                         id = OID_NOT_FOUND;
    

  303.                         seglen = name.nstart - name.start;
    

  304.                         COPY_SEGMENT_TEMP20110929(name);
    

  305.                         size = seglen;
    

  306.                 }
    

  307.                 else
    

  308.                 {
    

  309.                         request_msg.index += name.nstart - name.start;
    


  310. 

  311.                         getOID(id, &response_msg.buffer[response_msg.index+2], &response_msg.buffer[response_msg.index+1]);
    


  312. 

  313.                         seglen = response_msg.buffer[response_msg.index+1]+2;
    

  314.                         response_msg.index += seglen ;
    

  315.                         size = seglen;
    

  316.                 }
    

  317.         }
    


  318. 

  319.         parseTLV(request_msg.buffer, request_msg.index, &value);
    


  320. 

  321.         if (id != OID_NOT_FOUND)
    

  322.         {
    

  323.                 uint8 dataType;
    

  324.                 int32 len;
    


  325. 

  326.                 if ((reqType == GET_REQUEST) || (reqType == GET_NEXT_REQUEST))
    

  327.                 {
    

  328.                         getEntry(id, &dataType, &response_msg.buffer[response_msg.index+2], &len);
    


  329. 

  330.                         response_msg.buffer[response_msg.index] = dataType;
    

  331.                         response_msg.buffer[response_msg.index+1] = len;
    

  332.                         seglen = (2 + len);
    

  333.                         response_msg.index += seglen;
    


  334. 

  335.                         request_msg.index += (value.nstart - value.start);
    


  336. 

  337.                 }
    

  338.                 else if (reqType == SET_REQUEST)
    

  339.                 {
    

  340.                         setEntry(id, &request_msg.buffer[value.vstart], value.len, request_msg.buffer[value.start], index);
    

  341.                         seglen = value.nstart - value.start;
    

  342.                         COPY_SEGMENT_TEMP20110929(value);
    

  343.                 }
    

  344.         }
    

  345.         else
    

  346.         {
    

  347.                 seglen = value.nstart - value.start;
    

  348.                 COPY_SEGMENT_TEMP20110929(value);
    


  349. 

  350.                 errorIndex = index;
    

  351.                 errorStatus = NO_SUCH_NAME;
    

  352.         }
    


  353. 

  354.         size += seglen;
    


  355. 

  356.         return size;
    

  357. }
    


  358. 


  359. 

  360. int32 parseSequence(int32 reqType, int32 index)
    

  361. {
    

  362.         int32 seglen;
    

  363.         tlvStructType seq;
    

  364.         int32 size = 0, respLoc;
    


  365. 

  366.         parseTLV(request_msg.buffer, request_msg.index, &seq);
    


  367. 

  368.         if ( request_msg.buffer[seq.start] != SNMPDTYPE_SEQUENCE ) return -1;
    


  369. 

  370.         seglen = seq.vstart - seq.start;
    

  371.         respLoc = response_msg.index;
    

  372.         COPY_SEGMENT_TEMP20110929(seq);
    


  373. 

  374.         size = parseVarBind( reqType, index );
    

  375.         insertRespLen(seq.start, respLoc, size);
    

  376.         size += seglen;
    


  377. 

  378.         return size;
    

  379. }
    


  380. 


  381. 

  382. int32 parseSequenceOf(int32 reqType)
    

  383. {
    

  384.         int32 seglen;
    

  385.         tlvStructType seqof;
    

  386.         int32 size = 0, respLoc;
    

  387.         int32 index = 0;
    


  388. 

  389.         parseTLV(request_msg.buffer, request_msg.index, &seqof);
    


  390. 

  391.         if ( request_msg.buffer[seqof.start] != SNMPDTYPE_SEQUENCE_OF ) return -1;
    


  392. 

  393.         seglen = seqof.vstart - seqof.start;
    

  394.         respLoc = response_msg.index;
    

  395.         COPY_SEGMENT_TEMP20110929(seqof);
    


  396. 

  397.         while (request_msg.index < request_msg.len)
    

  398.         {
    

  399.                 size += parseSequence( reqType, index++ );
    

  400.         }
    


  401. 

  402.         insertRespLen(seqof.start, respLoc, size);
    


  403. 

  404.         return size;
    

  405. }
    


  406. 


  407. 

  408. int32 parseRequest()
    

  409. {
    

  410.         int32 ret, seglen;
    

  411.         tlvStructType snmpreq, requestid, errStatus, errIndex;
    

  412.         int32 size = 0, respLoc, reqType;
    


  413. 

  414.         parseTLV(request_msg.buffer, request_msg.index, &snmpreq);
    


  415. 

  416.         reqType = request_msg.buffer[snmpreq.start];
    


  417. 

  418.         if ( !VALID_REQUEST(reqType) ) return -1;
    


  419. 

  420.         seglen = snmpreq.vstart - snmpreq.start;
    

  421.         respLoc = snmpreq.start;
    

  422.         size += seglen;
    

  423.         COPY_SEGMENT_TEMP20110929(snmpreq);
    


  424. 

  425.         response_msg.buffer[snmpreq.start] = GET_RESPONSE;
    


  426. 

  427.         parseTLV(request_msg.buffer, request_msg.index, &requestid);
    

  428.         seglen = requestid.nstart - requestid.start;
    

  429.         size += seglen;
    

  430.         COPY_SEGMENT_TEMP20110929(requestid);
    


  431. 

  432.         parseTLV(request_msg.buffer, request_msg.index, &errStatus);
    

  433.         seglen = errStatus.nstart - errStatus.start;
    

  434.         size += seglen;
    

  435.         COPY_SEGMENT_TEMP20110929(errStatus);
    


  436. 

  437.         parseTLV(request_msg.buffer, request_msg.index, &errIndex);
    

  438.         seglen = errIndex.nstart - errIndex.start;
    

  439.         size += seglen;
    

  440.         COPY_SEGMENT_TEMP20110929(errIndex);
    


  441. 

  442.         ret = parseSequenceOf(reqType);
    

  443.         if (ret == -1) return -1;
    

  444.         else size += ret;
    


  445. 

  446.         insertRespLen(snmpreq.start, respLoc, size);
    


  447. 

  448.         if (errorStatus)
    

  449.         {
    

  450.                 response_msg.buffer[errStatus.vstart] = errorStatus;
    

  451.                 response_msg.buffer[errIndex.vstart] = errorIndex + 1;
    

  452.         }
    


  453. 

  454.         return size;
    

  455. }
    


  456. 


  457. 

  458. int32 parseCommunity()
    

  459. {
    

  460.         int32 seglen;
    

  461.         tlvStructType community;
    

  462.         int32 size=0;
    


  463. 

  464.         parseTLV(request_msg.buffer, request_msg.index, &community);
    


  465. 

  466.         if (!((request_msg.buffer[community.start] == SNMPDTYPE_OCTET_STRING) && (community.len == COMMUNITY_SIZE))) 
    

  467.         {
    

  468.                 return -1;
    

  469.         }
    


  470. 

  471.         if (!memcmp(&request_msg.buffer[community.vstart], (int8 *)COMMUNITY, COMMUNITY_SIZE))
    

  472.         {
    

  473.                 seglen = community.nstart - community.start;
    

  474.                 size += seglen;
    

  475.                 COPY_SEGMENT_TEMP20110929(community);
    


  476. 

  477.                 size += parseRequest();
    

  478.         }
    

  479.         else
    

  480.         {
    

  481.                 return -1;
    

  482.         }
    


  483. 

  484.         return size;
    

  485. }
    


  486. 


  487. 

  488. int32 parseVersion()
    

  489. {
    

  490.         int32 size = 0, seglen;
    

  491.         tlvStructType tlv;
    


  492. 

  493.         size = parseTLV(request_msg.buffer, request_msg.index, &tlv);
    


  494. 

  495.         if (!((request_msg.buffer[tlv.start] == SNMPDTYPE_INTEGER) && (request_msg.buffer[tlv.vstart] == SNMP_V1)))
    

  496.                 return -1;
    


  497. 

  498.         seglen = tlv.nstart - tlv.start;
    

  499.         size += seglen;
    

  500.         COPY_SEGMENT_TEMP20110929(tlv);
    

  501.         size = parseCommunity();
    


  502. 

  503.         if (size == -1) return size;
    

  504.         else return (size + seglen);
    

  505. }
    


  506. 


  507. 

  508. int32 parseSNMPMessage()
    

  509. {
    

  510.         int32 size = 0, seglen, respLoc;
    

  511.         tlvStructType tlv;
    


  512. 

  513.         parseTLV(request_msg.buffer, request_msg.index, &tlv);
    


  514. 

  515.         if (request_msg.buffer[tlv.start] != SNMPDTYPE_SEQUENCE_OF) return -1;
    


  516. 

  517.         seglen = tlv.vstart - tlv.start;
    

  518.         respLoc = tlv.start;
    

  519.         COPY_SEGMENT_TEMP20110929(tlv);
    


  520. 

  521.         size = parseVersion();
    


  522. 

  523.         if (size == -1) return -1;
    

  524.         else size += seglen;
    


  525. 

  526.         insertRespLen(tlv.start, respLoc, size);
    


  527. 

  528.         return 0;
    

  529. }
    


  530. 


  531. 

  532. void dumpCode(int8* header, int8* tail, unsigned char *buff, int len) 
    

  533. { 
    

  534.         int i;
    


  535. 

  536.         printf(header);
    


  537. 

  538.         for (i=0; i<len; i++) 
    

  539.         { 
    

  540.                 if ( i%16==0 )        printf("0x%04x : ", i); 
    

  541.                 printf("%02x ",buff[i]); 
    


  542. 

  543.                 if ( i%16-15==0 )
    

  544.                 {
    

  545.                         int j; 
    

  546.                         printf("  "); 
    

  547.                         for (j=i-15; j<=i; j++)
    

  548.                         {
    

  549.                                 if ( isprint(buff[j]) )        printf("%c", buff[j]);
    

  550.                                 else                                        printf(".");
    

  551.                         }
    

  552.                         printf("\r\n"); 
    

  553.                 } 
    

  554.         }
    


  555. 

  556.         if ( i%16!=0 ) 
    

  557.         { 
    

  558.                 int j; 
    

  559.                 int spaces=(len-i+16-i%16)*3+2; 
    

  560.                 for (j=0; j<spaces; j++)         printf(" ");
    

  561.                 for (j=i-i%16; j<len; j++) 
    

  562.                 {
    

  563.                         if ( isprint(buff[j]) )        printf("%c", buff[j]);
    

  564.                         else                                        printf(".");
    

  565.                 }
    

  566.         } 
    

  567.         printf(tail);
    

  568. } 
    


  569. 

  570. void ipToByteArray(int8 *ip, uint8 *pDes)
    

  571. {
    

  572.         uint32 i, ip1=0, ip2=0, ip3=0, ip4=0;
    

  573.         int8 buff[32];
    

  574.         uint32 len = (uint32)strlen(ip);
    

  575.         strcpy(buff, ip);
    


  576. 

  577.         for (i=0; i<len; i++)
    

  578.         {
    

  579.                 if ( buff[i]=='.' )                buff[i] = ' ';
    

  580.         }
    


  581. 

  582.         sscanf(buff, "%u %u %u %u", &ip1, &ip2, &ip3, &ip4);
    

  583.         pDes[0] = ip1; pDes[1] = ip2; pDes[2] = ip3; pDes[3] = ip4;
    

  584. }
    


  585. 


  586. 

  587. int32 makeTrapVariableBindings(dataEntryType *oid_data, void *ptr, uint32 *len)
    

  588. {
    

  589.         uint32 j;
    


  590. 

  591.         ((uint8*)ptr)[0] = 0x30;
    

  592.         ((uint8*)ptr)[1] = 0xff;
    

  593.         ((uint8*)ptr)[2] = 0x06;
    

  594.         ((uint8*)ptr)[3] = oid_data->oidlen;
    


  595. 

  596.         for (j = 0 ; j < oid_data->oidlen ; j++)
    

  597.         {
    

  598.                 ((uint8*)ptr)[j+4] = oid_data->oid[j];
    

  599.         }
    


  600. 

  601.         switch(oid_data->dataType)
    

  602.         {
    

  603.         case SNMPDTYPE_OCTET_STRING :
    

  604.         case SNMPDTYPE_OBJ_ID :
    

  605.                 {
    

  606.                         uint8 *string = &((uint8*)ptr)[4+oid_data->oidlen+2];
    


  607. 

  608.                         if ( oid_data->dataType==SNMPDTYPE_OCTET_STRING )
    

  609.                         {
    

  610.                                 oid_data->dataLen = (uint8)strlen((int8*)&oid_data->u.octetstring);
    

  611.                         }
    

  612.                         for (j = 0 ; j < oid_data->dataLen ; j++)
    

  613.                         {
    

  614.                                 string[j] = oid_data->u.octetstring[j];
    

  615.                         }
    


  616. 

  617.                         ((uint8*)ptr)[4+oid_data->oidlen] = oid_data->dataType;
    

  618.                         ((uint8*)ptr)[4+oid_data->oidlen+1] = oid_data->dataLen;
    

  619.                         ((uint8*)ptr)[1] = 2 + oid_data->oidlen + 2 + oid_data->dataLen;
    

  620.                         *len = 4 + oid_data->oidlen + 2 + oid_data->dataLen;
    

  621.                 }
    

  622.                 break;
    


  623. 

  624.         case SNMPDTYPE_INTEGER :
    

  625.         case SNMPDTYPE_TIME_TICKS :
    

  626.         case SNMPDTYPE_COUNTER :
    

  627.         case SNMPDTYPE_GAUGE :
    

  628.                 {
    

  629.                         oid_data->dataLen = 4;
    


  630. 

  631.                         *(int32*)(&((uint8*)ptr)[4+oid_data->oidlen+2]) = HTONL(oid_data->u.intval);
    


  632. 

  633.                         ((uint8*)ptr)[4+oid_data->oidlen] = oid_data->dataType;
    

  634.                         ((uint8*)ptr)[4+oid_data->oidlen+1] = oid_data->dataLen;
    

  635.                         ((uint8*)ptr)[1] = 2 + oid_data->oidlen + 2 + oid_data->dataLen;
    

  636.                         *len = 4 + oid_data->oidlen + 2 + oid_data->dataLen;
    

  637.                 }
    

  638.                 break;
    


  639. 

  640.         default : 
    

  641.                 return INVALID_DATA_TYPE;
    

  642.         }
    


  643. 

  644.         return SUCCESS;
    

  645. }
    


  646. 

  647. int32 SnmpXInit()
    

  648. {
    

  649.         
    

  650. //        initTable();
    

  651. //        LED3=0;
    

  652.         return 0;
    

  653. }
    


  654. 

  655. uint8 packet_trap[1024] = {0,};
    

  656. int32 SnmpXTrapSend(int8* managerIP, int8* agentIP, int8* community, dataEntryType enterprise_oid, uint32 genericTrap, uint32 specificTrap, uint32 va_count, ...)
    

  657. {
    

  658.         uint32 i;
    

  659.         int32 packet_index = 0;
    

  660.         int32 packet_buff1 = 0;
    

  661.         int32 packet_buff2 = 0;
    

  662.         int32 packet_buff3 = 0;
    

  663.         uint8 trap_agentip[4] = {0,};
    

  664.         
    

  665.         ipToByteArray(agentIP, trap_agentip);
    


  666. 

  667.         packet_trap[packet_index++] = 0x30; // ASN.1 Header
    


  668. 

  669.         packet_trap[packet_index] = 0xff; // pdu_length, temp
    

  670.         packet_buff1 = packet_index++;
    


  671. 

  672.         packet_trap[packet_index++] = 0x02; // Version
    

  673.         packet_trap[packet_index++] = 0x01;
    

  674.         packet_trap[packet_index++] = 0x00;
    

  675.         
    

  676.         packet_trap[packet_index++] = 0x04; // Community
    

  677.         packet_trap[packet_index++] = (uint8)strlen(community);
    

  678.         memcpy(&(packet_trap[packet_index]), community, strlen(community));
    


  679. 

  680.         packet_index = packet_index + (uint8)strlen(community);
    


  681. 

  682.         packet_trap[packet_index++] = 0xa4; // trap
    

  683.         packet_trap[packet_index] = 0xff; // length, temp
    

  684.         packet_buff2 = packet_index++;
    


  685. 

  686.         packet_trap[packet_index++] = 0x06; // enterprise_oid
    

  687.         packet_trap[packet_index++] = enterprise_oid.oidlen;
    

  688.         for (i=0; i<enterprise_oid.oidlen; i++)
    

  689.         {
    

  690.                 packet_trap[packet_index++] = enterprise_oid.oid[i];
    

  691.         }
    

  692.         
    

  693.         packet_trap[packet_index++] = 0x40; // agent ip
    

  694.         packet_trap[packet_index++] = 0x04;
    

  695.         packet_trap[packet_index++] = trap_agentip[0];
    

  696.         packet_trap[packet_index++] = trap_agentip[1];
    

  697.         packet_trap[packet_index++] = trap_agentip[2];
    

  698.         packet_trap[packet_index++] = trap_agentip[3];
    


  699. 

  700.         packet_trap[packet_index++] = 0x02; // Generic Trap
    

  701.         packet_trap[packet_index++] = 0x01;
    

  702.         packet_trap[packet_index++] = (uint8)genericTrap;
    


  703. 

  704.         packet_trap[packet_index++] = 0x02; // Specific Trap
    

  705.         packet_trap[packet_index++] = 0x01;
    

  706.         packet_trap[packet_index++] = (uint8)specificTrap;
    


  707. 

  708.         packet_trap[packet_index++] = 0x43; // Timestamp
    

  709.         packet_trap[packet_index++] = 0x01;
    

  710.         packet_trap[packet_index++] = 0x00;
    


  711. 

  712.         packet_trap[packet_index++] = 0x30; // Sequence of variable-bindings
    

  713.         packet_trap[packet_index] = 0xff;
    

  714.         packet_buff3 = packet_index++;
    

  715.         
    

  716.         // variable-bindings
    

  717.         {
    

  718.                 va_list ap;
    

  719.                 uint32 length_var_bindings = 0;
    

  720.                 uint32 length_buff = 0;
    


  721. 

  722.                 va_start (ap, va_count); 
    


  723. 

  724.                 for (i=0; i<va_count; i++) 
    

  725.                 {
    

  726.                         dataEntryType* fff = va_arg(ap, dataEntryType*);
    

  727.                         makeTrapVariableBindings(fff, &(packet_trap[packet_index]), &length_buff);
    

  728.                         packet_index = packet_index + length_buff;
    

  729.                         length_var_bindings = length_var_bindings + length_buff;
    

  730.                 }
    


  731. 

  732.                 packet_trap[packet_buff3] = length_var_bindings;
    


  733. 

  734.                 va_end (ap);
    

  735.         }
    

  736.         packet_trap[packet_buff1] = packet_index - 2;
    

  737.         packet_trap[packet_buff2] = packet_index - (9 + (uint8)strlen(community));
    


  738. 

  739.         // Send Packet
    

  740.         {
    

  741.                 uint8 svr_addr[6];
    


  742. 

  743.                 //UDPOpen(SOCK_SNMP, 162);
    

  744.         socket(SOCK_SNMP,Sn_MR_UDP,162,0);
    

  745.                 ipToByteArray(managerIP, svr_addr);
    

  746.                 sendto(SOCK_SNMP, packet_trap, packet_index, svr_addr, 162);
    

  747.                 
    

  748.                 close(SOCK_SNMP);                
    

  749.                 return 0;
    

  750.         }
    

  751. }
    


  752. 


  753. 

  754. int32 SnmpXDaemon()
    

  755. {
    

  756.         int32 snmpfd = 0;
    

  757.         int32 fromlen = 0;
    

  758.         int32 retStatus = 0;
    

  759.         int32 len = 0;
    

  760.         uint8 loopsnmpd = 1;
    

  761.     uint8 svr_addr[6];
    

  762.         uint16  svr_port;
    

  763.         UNUSED(snmpfd);
    

  764.         UNUSED(fromlen);
    

  765.         UNUSED(retStatus);
    

  766. //        UDPOpen(SOCK_SNMP, 161);
    

  767.     socket(SOCK_SNMP,Sn_MR_UDP,161,0);
    

  768.         WDEBUG("Start SNMP Daemon(Agent) ");
    


  769. 

  770.         while(loopsnmpd)
    

  771.         {
    


  772. 

  773.                 if ( (len = getSn_RX_RSR(SOCK_SNMP))>0 )
    

  774.                 {
    

  775.                 request_msg.len= recvfrom(SOCK_SNMP, (uint8 *)&request_msg.buffer[0], len, svr_addr, &svr_port);
    

  776.                 }
    

  777.                 else
    

  778.                 {
    

  779.                 request_msg.len = 0;
    

  780.                 continue;
    

  781.                 }
    

  782.                 if (request_msg.len > 0)
    

  783.                 {
    

  784.                             dumpCode("\r\n[Request]\r\n", "\r\n", request_msg.buffer, request_msg.len);
    

  785.     
    

  786.                             request_msg.index = 0;
    

  787.                             response_msg.index = 0;
    

  788.                             errorStatus = errorIndex = 0;
    

  789.     
    

  790.                             if (parseSNMPMessage() != -1)
    

  791.                             {
    

  792.                             sendto(SOCK_SNMP, response_msg.buffer, response_msg.index, svr_addr, svr_port);
    

  793.                             }
    

  794.     
    

  795.                             dumpCode("\r\n[Response]\r\n", "\r\n", response_msg.buffer, response_msg.index);
    

  796.                          } 
    

  797.             }           
    

  798.            close(SOCK_SNMP);
    

  799.          return(0);
    

  800. }
    


  801.






本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏 举报

相关帖子
lightour7788 发表于 2025-3-28 10:00 | 显示全部楼层
谢楼主，正在做snmp，参考一下
回复

收藏 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

abner_ma Image
认证：项目经理
简介：资深嵌入式开发工程师

104

主题

191

帖子

3

粉丝
快速回复 在线客服 返回列表 返回顶部