开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
agent_trap.c
资源名称：snmp.src.rar　[点击查看]
上传用户：cxs890
上传日期：2021-05-22
资源大小：347k
文件大小：49k
源码类别：

SNMP编程

开发平台：

C/C++

agent_trap.c：源码内容
  1. /* agent_trap.c: define trap generation routines for mib modules, etc,
  2.    to use */
  4. #include <config.h>
  5. #include <assert.h>
  7. #if HAVE_UNISTD_H
  8. #include <unistd.h>
  9. #endif
  10. #if HAVE_STDLIB_H
  11. #include <stdlib.h>
  12. #endif
  13. #if HAVE_STRING_H
  14. #include <string.h>
  15. #else
  16. #include <strings.h>
  17. #endif
  18. #if TIME_WITH_SYS_TIME
  19. # ifdef WIN32
  20. #  include <sys/timeb.h>
  21. # else
  22. #  include <time.h>
  23. # endif
  24. # include <time.h>
  25. #else
  26. # if HAVE_SYS_TIME_H
  27. #  include <sys/time.h>
  28. # else
  29. #  include <time.h>
  30. # endif
  31. #endif
  32. #ifdef OS_VXWORKS
  33. #include <sys/times.h>
  34. #endif
  35. #if HAVE_SYS_SOCKET_H
  36. #include <sys/socket.h>
  37. #elif HAVE_WINSOCK_H
  38. #include <ip/socket.h>
  39. #endif
  40. #if HAVE_NETINET_IN_H
  41. #include <netinet/in.h>
  42. #endif
  43. #include <ip/in.h>
  44. #include <ip/ip_var.h>
  45. #include <ip/ip_externs.h>
  46. #include <ip/inet.h>
  47. #include <libsys/timer.h>
  48. #ifdef OS_VXWORKS
  49. #include "asn1.h"
  50. #endif
  51. #include <snmplib/tools.h>
  52. #include <snmplib/snmpv3.h>
  53. #include "snmp_api.h"
  54. #include "snmp_impl.h"
  55. #include "snmp_client.h"
  56. #include "snmp.h"
  57. #include "system.h"
  58. #include "read_config.h"
  59. #include "snmp_debug.h"
  60. #include "system.h"
  61. #include "config_struct.h"
  63. #define SET_SNMP_TRAP_QUEUELEN 0
  64. #define SET_SNMP_TRAP_TIMEOUT 1
  65. #define SET_SNMP_TRAP_SOURCE 2
  66. #define SNMP_AUTH_TRAP 0x0001
  67. #define SNMP_CONFIG_TRAP 0x0002
  68. #define SNMP_SNMPTYPE_TRAP 0x0004
  69. extern oid default_enterprise[10];
  70. extern struct timeval starttime;
  71. struct trap_pdu_list {
  72. struct snmp_pdu  *pdu;
  73. struct trap_pdu_list *next;
  74. };
  76. struct trap_sink {
  77.     struct snmp_session *sesp;
  78.     struct trap_sink *next;
  79. struct trap_pdu_list *pduHead;
  80. int pduCount;
  81.     int pdutype;
  82.     int version;
  83. unsigned short trapflags;
  84. };
  86. struct trap_sink *sinks   = NULL;
  87. extern char *strdup(char*);
  88. extern void get_trapsrc_ip(unsigned long *ipaddr);
  90. #define OID_LENGTH(x)  (sizeof(x)/sizeof(x[0]))
  91. #ifndef SNMP_TRAP_PORT
  92. #define SNMP_TRAP_PORT 162
  93. #endif
  94. oid objid_enterprisetrap[] = { EXTENSIBLEMIB, 251 };
  95. /*oid version_id[]    = { EXTENSIBLEMIB, AGENTID, OSTYPE };*/
  96. oid version_id[]    = { EXTENSIBLEMIB, PRODUCEID};
  97. int enterprisetrap_len = OID_LENGTH( objid_enterprisetrap );
  98. int version_id_len     = OID_LENGTH( version_id );
  100. #define SNMPV2_TRAPS_PREFIX SNMP_OID_SNMPMODULES,1,1,5
  101. oid             trap_prefix[]    = { SNMPV2_TRAPS_PREFIX };
  102. oid  cold_start_oid[] = { SNMPV2_TRAPS_PREFIX, 1 }; /* SNMPv2-MIB */
  103. oid  warm_start_oid[] = { SNMPV2_TRAPS_PREFIX, 2 }; /* SNMPv2-MIB */
  104. oid  link_down_oid[] = { SNMPV2_TRAPS_PREFIX, 3 }; /* IF-MIB */
  105. oid  link_up_oid[] = { SNMPV2_TRAPS_PREFIX, 4 }; /* IF-MIB */
  106. oid  auth_fail_oid[] = { SNMPV2_TRAPS_PREFIX, 5 }; /* SNMPv2-MIB */
  107. oid  egp_xxx_oid[] = { SNMPV2_TRAPS_PREFIX, 99 }; /* ??? */
  109. #define SNMPV2_TRAP_OBJS_PREFIX SNMP_OID_SNMPMODULES,1,1,4
  110. oid  snmptrap_oid[]        = { SNMPV2_TRAP_OBJS_PREFIX, 1, 0 };
  111. oid  snmptrapenterprise_oid[] = { SNMPV2_TRAP_OBJS_PREFIX, 3, 0 };
  112. oid  sysuptime_oid[]        = { SNMP_OID_MIB2,1,3,0 };
  113. int  snmptrap_oid_len        = OID_LENGTH(snmptrap_oid);
  114. int  snmptrapenterprise_oid_len = OID_LENGTH(snmptrapenterprise_oid);
  115. int  sysuptime_oid_len        = OID_LENGTH(sysuptime_oid);
  116. static void free_trap_session (struct trap_sink *sp);
  118. #define SNMP_AUTHENTICATED_TRAPS_ENABLED 1
  119. #define SNMP_AUTHENTICATED_TRAPS_DISABLED 2
  120. extern void snmp_delete_targetAddr (char *host_name, char *community);
  121. extern void snmp_add_targetAddr (char *host_name, char *community, int timeout, int retry);
  122. extern void snmp_add_targetParam (char *host_name, char *community, int model, 
  123.    int secModel, char *secName, int secLevel);
  124. extern void snmp_delete_targetParam (char *host_name, char *community);
  126. int  snmp_enableauthentraps = SNMP_AUTHENTICATED_TRAPS_ENABLED;
  127. char *snmp_trapcommunity = NULL;
  128. int verbose;
  129. /* Prototypes */
  130.  /*
  131. static int create_v1_trap_session (const char *, u_short, const char *);
  132. static int create_v2_trap_session (const char *, u_short, const char *);
  133. static int create_v2_inform_session (const char *, u_short, const char *);
  134. static void free_trap_session (struct trap_sink *sp);
  135. static void send_v1_trap (struct snmp_session *, int, int);
  136. static void send_v2_trap (struct snmp_session *, int, int, int);
  137.  */
  138. void show_snmp_host (void)
  139. {
  140. struct trap_sink *trapsink;
  141. if (sinks == NULL)
  142. {
  143. vty_printf ("Nonen");
  144. vty_printf_end(1);
  145. return;
  146. }
  147. for(trapsink=sinks;trapsink!=NULL;trapsink=trapsink->next){
  148. vty_printf("Notification host: %s udp-port: 162 type: ", trapsink->sesp->peername);
  149. switch (trapsink->pdutype) {
  150. case SNMP_MSG_TRAP:
  151.     vty_printf("trapn");
  152.     break;
  153.     case SNMP_MSG_TRAP2:
  154.         vty_printf("trap version 2n");
  155.         break;
  156.         case SNMP_MSG_INFORM:
  157.             vty_printf("informn");
  158.             break;
  159.         default:
  160.             assert(0);
  161. }
  163. switch (trapsink->version) {
  164. case SNMP_VERSION_1:
  165.     vty_printf("community: %s    security model: v1nn", trapsink->sesp->community);
  166.     break;
  167. case SNMP_VERSION_2c:
  168.     vty_printf("community: %s    security model: v2cnn", trapsink->sesp->community);
  169.     break;
  170. case SNMP_VERSION_3:
  171.     vty_printf("user:      %s    security model: USMnn", trapsink->sesp->securityName);
  172.     break;
  173.     default:
  174.         assert(0);
  175. }
  176. }
  177. vty_printf_end(1);
  178. }
  179. int deleteTrapSessionNoRem (char *peer, char *community, int version, int pdutype, char *vrfname)
  180. {
  181. struct trap_sink *trapsink,*lasttrapsink;
  183. lasttrapsink=NULL;
  184. SNMP_DEBUG_ROUTINES("delete_v1_trap_session()");
  185. if (version == SNMP_VERSION_3) {
  186.      for(trapsink=sinks;trapsink!=NULL;trapsink=trapsink->next){
  187.      if(!strcmp(trapsink->sesp->peername,peer) && 
  188.      !strcmp (trapsink->sesp->securityName, community) &&
  189.                  trapsink->pdutype == pdutype &&
  190.                  trapsink->version == SNMP_VERSION_3 &&
  191.                  !strcmp(trapsink->sesp->vrfname, vrfname)){
  192.      break;
  193.      }
  194.      lasttrapsink=trapsink;
  195.      }
  196. }else{
  197.      for(trapsink=sinks;trapsink!=NULL;trapsink=trapsink->next){
  198.      if(!strcmp(trapsink->sesp->peername,peer) && 
  199.      !strcmp (trapsink->sesp->community, community) &&
  200.                  trapsink->pdutype == pdutype &&
  201.                  trapsink->version == version &&
  202.                  !strcmp(trapsink->sesp->vrfname, vrfname)){
  203.      break;
  204.      }
  205.      lasttrapsink=trapsink;
  206.      }
  207. }
  208. if(trapsink!=NULL){
  209. if(lasttrapsink){
  210. lasttrapsink->next=trapsink->next;
  211. }else{
  212. sinks=trapsink->next;
  213. }
  214. free_trap_session (trapsink);
  215. return 1;
  216. }
  217. return 0;
  218. }
  220. int deleteTrapSession(char *peer, char *community, int version, int pdutype, char *vrfname)
  221. {
  222. if (deleteTrapSessionNoRem (peer, community, version, pdutype, vrfname))
  223. {
  224. snmp_delete_targetAddr (peer, community);
  225. snmp_delete_targetParam (peer, community);
  226. #ifdef INCLUDE_SNMPV3
  227. if (version == SNMP_VERSION_3) {
  228.             snmpv3_dec_remote_engineID_reference(peer, SNMP_TRAP_PORT);
  229. }
  230. #endif /* INCLUDE_SNMPV3*/
  231. return 1;
  232. }
  233. return 0;
  234. }
  235. /*******************
  236.  *
  237.  * Trap session handling
  238.  *
  239.  *******************/
  240. int add_trap_session( struct snmp_session *ss, int pdutype, int version )
  241. {
  242.     struct trap_sink *new_sink =
  243.       (struct trap_sink *) malloc (sizeof (*new_sink));
  244.     if ( new_sink == NULL )
  245. return 0;
  247. new_sink->pduHead = NULL;
  248. new_sink->pduCount = 0;
  249.     new_sink->sesp    = ss;
  250.     new_sink->pdutype = pdutype;
  251.     new_sink->version = version;
  252.     new_sink->next    = sinks;
  253.     new_sink->trapflags = 0xFFFF;
  254.     sinks = new_sink;
  255.     return 1;
  256. }
  257. int createTrapSessionNoAdd (char *sink,char * com,int timeout,int queuelen,unsigned short trapflags, int version, int pdutype, char *vrfname)
  258. {
  259. struct snmp_session  session, *sesp;
  260. int return_val = 0;
  261. struct trap_sink *new_sink;
  263.     memset (&session, 0, sizeof (struct snmp_session));
  264.     session.peername = strdup(sink);
  265. if (session.peername == NULL)
  266. return 0;
  267.     session.version = version;
  268.     session.community = strdup (com);
  269. if (session.community == NULL)
  270. {
  271. free (session.peername);
  272. return 0;
  273. }
  274.     session.community_len = strlen (com);
  275.     session.remote_port = SNMP_TRAP_PORT;
  276. session.securityAuthProtoLen = 0;
  277. session.contextName = NULL;
  278. session.securityEngineID = NULL;
  279. session.securityName = NULL;
  280. session.securityAuthProto = NULL;
  281. session.securityPrivProto = NULL;
  283. strcpy(session.vrfname,vrfname);
  285. sesp = snmp_open (&session);
  287.     if (sesp) {
  288.     sesp->timeout=timeout*1000000L; 
  289. sesp->retries=queuelen;
  290. new_sink = (struct trap_sink *) malloc (sizeof (struct trap_sink));
  291. if ( new_sink == NULL )
  292. {
  293. snmp_close(sesp);
  294. return_val = 0;
  295. }
  296. else
  297. {
  298. return_val = 1;
  300. new_sink->pduHead = NULL;
  301. new_sink->pduCount = 0;
  302. new_sink->sesp    = sesp;
  303. new_sink->pdutype = pdutype;
  304. new_sink->version = version;
  305. new_sink->trapflags = trapflags;
  306. new_sink->next    = sinks;
  307. sinks = new_sink;
  308. }
  309.     }
  310. if (session.peername)
  311. free (session.peername);
  312. if (session.community)
  313. free (session.community);
  314.     /* diagnose snmp_open errors with the input struct snmp_session pointer */
  315. if (!return_val)
  316. {
  317. snmp_sess_perror("snmpd: create_trap_session", &session);
  318. }
  319. return return_val;
  320. }
  323. int createV1TrapSession (char *sink,char * com,unsigned short trapflags, char *vrfname)
  324. {
  325. int return_val;
  326. if ((return_val = createTrapSessionNoAdd (sink, com, snmp_para.timeout, snmp_para.queuelen, trapflags, SNMP_VERSION_1, SNMP_MSG_TRAP,vrfname)))
  327. {
  328. snmp_add_targetAddr (sink, com, 1500, 3);
  329. snmp_add_targetParam (sink, com, SNMP_MP_MODEL_SNMPv1, SNMP_SEC_MODEL_SNMPv1, com, 
  330. SNMP_SEC_LEVEL_NOAUTH);
  331. }
  332. return return_val;
  333. }
  335. int createV2TrapSession (char *sink,char * com,unsigned short trapflags, int pdutype,char *vrfname)
  336. {
  337. int return_val;
  338. if ((return_val = createTrapSessionNoAdd (sink, com, snmp_para.timeout, snmp_para.queuelen, trapflags, SNMP_VERSION_2c, pdutype,vrfname)))
  339. {
  340. snmp_add_targetAddr (sink, com, 1500, 3);
  341. snmp_add_targetParam (sink, com, SNMP_MP_MODEL_SNMPv2c, SNMP_SEC_MODEL_SNMPv2c, com, 
  342. SNMP_SEC_LEVEL_NOAUTH);
  343. }
  344. return return_val;
  345. }
  347. #ifdef INCLUDE_SNMPV3
  348. /*Sunxi added, 26 Feb, 2004*/
  349. int createV3TrapSession(char *sink,char * user, int authtype, int pdutype, unsigned short trapflags,char*vrfname)
  350. {
  351.     struct snmp_session  session, *sesp;
  352.     char *engineid;
  354.     memset (&session, 0, sizeof (struct snmp_session));
  355.     session.peername = sink;
  356.     session.version = SNMP_VERSION_3;
  357.     session.community = NULL;
  358.     session.community_len = 0;
  359.     /* by yangyuhua 2006-4-7*/
  360.     strcpy(session.vrfname, vrfname);
  362.     session.remote_port = SNMP_TRAP_PORT;
  363.     engineid = snmpv3_get_remote_engineID(sink, SNMP_TRAP_PORT);
  364.     if (engineid != NULL) {
  365.         snmp_memdup(&session.contextEngineID, engineid, SNMP_MAX_ENG_SIZE);
  366.         snmp_memdup(&session.securityEngineID, engineid, SNMP_MAX_ENG_SIZE);
  367.         session.contextEngineIDLen = SNMP_MAX_ENG_SIZE;
  368.         session.securityEngineIDLen = SNMP_MAX_ENG_SIZE;
  369.     } else {
  370.         vty_output("%%Error: No snmpEngineID configured for remote host %s port %dn", sink, SNMP_TRAP_PORT);
  371.         return -1;
  372.     }
  373.     session.securityName = strdup(user);
  374.     session.securityNameLen = strlen(user);
  375.     session.securityModel = SNMP_SEC_MODEL_USM;
  376.     session.securityLevel = authtype;
  377.     session.timeout = snmp_para.timeout * 1000000L;
  378.     session.retries = SNMP_DEFAULT_RETRIES;
  379.     sesp = snmp_open (&session);
  381.     if (sesp) {
  382. snmp_add_targetAddr (sink, user, 1500, 3);
  383. snmp_add_targetParam (sink, user, SNMP_MP_MODEL_SNMPv3, SNMP_SEC_MODEL_USM, user, authtype);
  384. snmpv3_inc_remote_engineID_reference(sink, SNMP_TRAP_PORT);
  385.      return( add_trap_session( sesp, pdutype, SNMP_VERSION_3 ));
  386.     }
  388.     /* diagnose snmp_open errors with the input struct snmp_session pointer */
  389.     snmp_sess_perror("snmpd: createV3TrapSession", &session);
  390.     return 0;
  391. }
  393. int destroyV3TrapSession(char *sink, char *user, int pdutype)
  394. {
  395. struct trap_sink *trapsink,*lasttrapsink;
  397. lasttrapsink=NULL;
  398. SNMP_DEBUG_ROUTINES("destroyV3TrapSession()");
  399. for(trapsink=sinks;trapsink!=NULL;trapsink=trapsink->next){
  400. if(!strcmp(trapsink->sesp->peername,sink) && 
  401. !strcmp (trapsink->sesp->securityName, user) && 
  402. trapsink->pdutype == pdutype &&
  403. trapsink->version == SNMP_VERSION_3){
  404. /*found it !!!*/
  405. break;
  406. }
  407. lasttrapsink=trapsink;
  408. }
  409. if(trapsink!=NULL){
  410. if(lasttrapsink){
  411. lasttrapsink->next=trapsink->next;
  412. }else{
  413. sinks=trapsink->next;
  414. }
  415. /*They will be freed in snmp_close --sxf 2k-12-27
  416. if (trapsink->sesp->peername != NULL)
  417. sys_mem_free (trapsink->sesp->peername);
  418. if (trapsink->sesp->community != NULL)
  419. sys_mem_free (trapsink->sesp->community);
  420. */
  421. free_trap_session (trapsink);
  422. snmp_delete_targetAddr (sink, user);
  423. snmp_delete_targetParam (sink, user);
  424. snmpv3_dec_remote_engineID_reference(sink, SNMP_TRAP_PORT);
  425. return 1;
  426. }
  427. return 0;
  428. }
  430. int refreshV3TrapSession(char *sink, char *engineID, size_t engineIDLen)
  431. {
  432. struct trap_sink *trapsink,*lasttrapsink;
  434. lasttrapsink=NULL;
  435. SNMP_DEBUG_ROUTINES("refreshV3TrapSession()");
  436. for(trapsink=sinks;trapsink!=NULL;trapsink=trapsink->next){
  437. if(!strcmp(trapsink->sesp->peername,sink) && 
  438. trapsink->version == SNMP_VERSION_3){
  439. /*found it !!!*/
  440.             SNMP_FREE(trapsink->sesp->contextEngineID);
  441.             SNMP_FREE(trapsink->sesp->securityEngineID);
  442.             snmp_memdup((u_char**)(&trapsink->sesp->contextEngineID), engineID, SNMP_MAX_ENG_SIZE);
  443.             snmp_memdup((u_char**)(&trapsink->sesp->securityEngineID), engineID, SNMP_MAX_ENG_SIZE);/*by yangyuhua 2005-12-6*/
  444.             trapsink->sesp->contextEngineIDLen = SNMP_MAX_ENG_SIZE;
  445.             trapsink->sesp->securityEngineIDLen = SNMP_MAX_ENG_SIZE;
  446. }
  447. lasttrapsink=trapsink;
  448. }
  449. return 0;
  450. }
  451. /*end add*/
  452. #endif /*INCLUDE_SNMPV3*/
  454. int create_trap_session (char *sink, u_short sinkport,
  455. char *com,
  456. int version, int pdutype)
  457. {
  458.     struct snmp_session  session, *sesp;
  460.     memset (&session, 0, sizeof (struct snmp_session));
  461.     session.peername = sink;
  462.     session.version = version;
  463.     if (com) {
  464.         session.community = (u_char *)com;
  465.         session.community_len = strlen (com);
  466.     }
  467.     session.remote_port = sinkport;
  468.     sesp = snmp_open (&session);
  470.     if (sesp) {
  471. return( add_trap_session( sesp, pdutype, version ));
  472.     }
  474.     /* diagnose snmp_open errors with the input struct snmp_session pointer */
  475.     snmp_sess_perror("snmpd: create_trap_session", &session);
  476.     return 0;
  477. }
  479. static int create_v1_trap_session (char *sink, u_short sinkport,
  480.    char *com)
  481. {
  482.     return create_trap_session( sink, sinkport, com,
  483. SNMP_VERSION_1, SNMP_MSG_TRAP );
  484. }
  486. static int create_v2_trap_session (char *sink,  u_short sinkport,
  487.    char *com)
  488. {
  489.     return create_trap_session( sink, sinkport, com,
  490. SNMP_VERSION_2c, SNMP_MSG_TRAP2 );
  491. }
  493. static int create_v2_inform_session (char *sink,  u_short sinkport,
  494.      char *com)
  495. {
  496.     return create_trap_session( sink, sinkport, com,
  497. SNMP_VERSION_2c, SNMP_MSG_INFORM );
  498. }
  501. static void free_trap_session (struct trap_sink *sp)
  502. {
  503.     snmp_close(sp->sesp);
  504.     free (sp);
  505. }
  508. void snmpd_free_trapsinks (void)
  509. {
  510.     struct trap_sink *sp = sinks;
  511.     while (sp) {
  512. sinks = sinks->next;
  513. free_trap_session(sp);
  514. sp = sinks;
  515.     }
  516. }
  518. /*******************
  519.  *
  520.  * Trap handling
  521.  *
  522.  *******************/
  523. #if 0
  524. void send_enterprise_trap_vars (int trap, 
  525.      int specific,
  526.      oid *enterprise, int enterprise_length,
  527.      struct variable_list *vars)
  528. {
  529.     struct variable_list uptime_var, snmptrap_var, enterprise_var;
  530.     struct variable_list *v2_vars, *last_var;
  531.     struct snmp_pdu *template_pdu, *pdu=NULL;
  532.     struct timeval  now;
  533.     long uptime;
  534.     struct soaddr_in *pduIp;
  535.     struct trap_sink *sink;
  536.     oid temp_oid[MAX_OID_LEN];
  537.     u_long addr;
  539. /*
  540.  * Initialise SNMPv2 required variables
  541.  */
  542.     gettimeofday(&now, NULL);
  543.     uptime = calculate_time_diff(&now, &starttime);
  544.     memset (&uptime_var, 0, sizeof (struct variable_list));
  545.     snmp_set_var_objid( &uptime_var, sysuptime_oid, OID_LENGTH(sysuptime_oid));
  546.     snmp_set_var_value( &uptime_var, (u_char *)&uptime, sizeof(uptime) );
  547.     uptime_var.type           = ASN_TIMETICKS;
  548.     uptime_var.next_variable  = &snmptrap_var;
  550.     memset (&snmptrap_var, 0, sizeof (struct variable_list));
  551.     snmp_set_var_objid( &snmptrap_var, snmptrap_oid, OID_LENGTH(snmptrap_oid));
  552. /* value set later .... */
  553.     snmptrap_var.type           = ASN_OBJECT_ID;
  555.     if ( vars )
  556. snmptrap_var.next_variable  = vars;
  557.     else
  558. snmptrap_var.next_variable  = &enterprise_var;
  560. /* find end of provided varbind list,
  561.    ready to append the enterprise info if necessary */
  562.     last_var = vars;
  563.     while ( last_var && last_var->next_variable )
  564. last_var = last_var->next_variable;
  566.     memset (&enterprise_var, 0, sizeof (struct variable_list));
  567.     snmp_set_var_objid( &enterprise_var,
  568.  snmptrapenterprise_oid, OID_LENGTH(snmptrapenterprise_oid));
  569.     snmp_set_var_value( &enterprise_var, (u_char *)enterprise, enterprise_length*sizeof(oid));
  570.     enterprise_var.type           = ASN_OBJECT_ID;
  571.     enterprise_var.next_variable  = NULL;
  573.     v2_vars = &uptime_var;
  575. /*
  576.  *  Create a template PDU, ready for sending
  577.  */
  578.     template_pdu = snmp_pdu_create( SNMP_MSG_TRAP );
  579.     if ( template_pdu == NULL )
  580.      {
  581.       if ( vars ) snmp_free_var(&enterprise_var);
  582. snmp_free_varbind(v2_vars);
  583. return;
  584.      }
  585.     template_pdu->trap_type     = trap;
  586.     template_pdu->specific_type = specific;
  587.     if ( snmp_clone_mem((void **)&template_pdu->enterprise,
  588. enterprise, enterprise_length*sizeof(oid))) {
  589. snmp_free_pdu( template_pdu );
  590. if ( vars ) snmp_free_varbind(&enterprise_var);
  591. snmp_free_varbind(v2_vars);
  592. return;
  593.     }
  594.     template_pdu->enterprise_length = enterprise_length;
  595.     template_pdu->flags |= UCD_MSG_FLAG_FORCE_PDU_COPY;
  596.     pduIp = (struct soaddr_in *)&template_pdu->agent_addr;
  597.     pduIp->sin_family  = AF_INET;
  598. get_trapsrc_ip(&addr);
  599. if(addr)
  600. pduIp->sin_addr.s_addr = addr;
  601. else
  602. pduIp->sin_addr.s_addr = get_myaddr();
  604.     template_pdu->time    = uptime;
  606. /*
  607.  *  Now use the parameters to determine
  608.  *    which v2 variables are needed,
  609.  *    and what values they should take.
  610.  */
  611.     switch ( trap ) {
  612. case -1: /*
  613.  * SNMPv2 only
  614.  *  Check to see whether the variables provided
  615.  *    are sufficient for SNMPv2 notifications
  616.  */
  617. if (vars && snmp_oid_compare(vars->name, vars->name_length,
  618. sysuptime_oid, OID_LENGTH(sysuptime_oid)) == 0 )
  619. v2_vars = vars;
  620. else
  621. if (vars && snmp_oid_compare(vars->name, vars->name_length,
  622. snmptrap_oid, OID_LENGTH(snmptrap_oid)) == 0 )
  623. uptime_var.next_variable = vars;
  624. else {
  625. /* Hmmm... we don't seem to have a value - oops! */
  626. snmptrap_var.next_variable = vars;
  627. }
  628. last_var = NULL; /* Don't need enterprise info */
  629. break;
  631. /* "Standard" SNMPv1 traps */
  633. case SNMP_TRAP_COLDSTART:
  634. snmp_set_var_value( &snmptrap_var,
  635.     (u_char *)cold_start_oid,
  636.     sizeof(cold_start_oid));
  637. break;
  638. case SNMP_TRAP_WARMSTART:
  639. snmp_set_var_value( &snmptrap_var,
  640.     (u_char *)warm_start_oid,
  641.     sizeof(warm_start_oid));
  642. break;
  643. case SNMP_TRAP_LINKDOWN:
  644. snmp_set_var_value( &snmptrap_var,
  645.     (u_char *)link_down_oid,
  646.     sizeof(link_down_oid));
  647. break;
  648. case SNMP_TRAP_LINKUP:
  649. snmp_set_var_value( &snmptrap_var,
  650.     (u_char *)link_up_oid,
  651.     sizeof(link_up_oid));
  652. break;
  653. case SNMP_TRAP_AUTHFAIL:
  654. if (snmp_enableauthentraps == SNMP_AUTHENTICATED_TRAPS_DISABLED)
  655. {
  656. snmp_free_pdu( template_pdu );
  657. snmp_free_varbind(v2_vars);
  658.     return;
  659. }
  660. snmp_set_var_value( &snmptrap_var,
  661.     (u_char *)auth_fail_oid,
  662.     sizeof(auth_fail_oid));
  663. break;
  664. case SNMP_TRAP_EGPNEIGHBORLOSS:
  665. snmp_set_var_value( &snmptrap_var,
  666.     (u_char *)egp_xxx_oid,
  667.     sizeof(egp_xxx_oid));
  668. break;
  670. case SNMP_TRAP_ENTERPRISESPECIFIC:
  671. memcpy( &temp_oid,
  672.     (char *)enterprise,
  673.     (enterprise_length)*sizeof(oid));
  674. temp_oid[ enterprise_length   ] = 0;
  675. temp_oid[ enterprise_length+1 ] = specific;
  676. snmp_set_var_value( &snmptrap_var,
  677.     (u_char *)&temp_oid,
  678.     (enterprise_length+2)*sizeof(oid));
  679. snmptrap_var.next_variable  = vars;
  680. last_var = NULL; /* Don't need version info */
  681. break;
  682.     }
  683.     
  685. /*
  686.  *  Now loop through the list of trap sinks,
  687.  *   sending an appropriately formatted PDU to each
  688.  */
  689. for ( sink = sinks ; sink ; sink=sink->next ) 
  690. {
  691. BOOL bContinue;
  692. if ( sink->version == SNMP_VERSION_1 && trap == -1 )
  693. continue; /* Skip v1 sinks for v2 only traps */
  694. bContinue = TRUE;
  695. switch ( trap )
  696. {
  697. case SNMP_TRAP_COLDSTART:
  698. case SNMP_TRAP_WARMSTART:
  699. case SNMP_TRAP_LINKDOWN:
  700. case SNMP_TRAP_LINKUP:
  701. if(sink->trapflags&SNMP_SNMPTYPE_TRAP)
  702. bContinue = FALSE;
  703. break;
  704. case SNMP_TRAP_AUTHFAIL:
  705. if(sink->trapflags&SNMP_AUTH_TRAP)
  706. bContinue = FALSE;
  707. break;
  708. default:
  709. bContinue = FALSE;
  710. break;
  712. }
  713. if (bContinue)
  714. continue;
  716. template_pdu->version = sink->version;
  717. template_pdu->command = sink->pdutype;
  718. if ( sink->version != SNMP_VERSION_1 )
  719. {
  720. template_pdu->variables = v2_vars;
  721. if ( last_var )
  722. last_var->next_variable = &enterprise_var;
  723. }
  724. else
  725. template_pdu->variables = vars;
  727. pdu = snmp_clone_pdu( template_pdu );
  728. if (pdu == NULL)
  729. continue;
  730. if (!addr)
  731. {
  732. IP_ADDR dest_addr, src_addr;
  733. if (sink->sesp->peername != NULL)
  734. {
  735. dest_addr = inet_addr (sink->sesp->peername);
  736. if (ipof_iffordest(dest_addr, &src_addr) == 0) /*success*/
  737. {
  738. pduIp = (struct soaddr_in *)&pdu->agent_addr;
  739. pduIp->sin_family  = AF_INET;
  740. pduIp->sin_addr.s_addr = src_addr;
  741. }
  742. }
  743. }
  744. pdu->sessid = sink->sesp->sessid; /* AgentX only ? */
  745. if ( snmp_send( sink->sesp, pdu) == 0 ) 
  746. {
  747. if (sink->sesp->s_snmp_errno == SNMPERR_BAD_SENDTO)
  748. {
  749. if (sink->pduCount+1 < snmp_para.queuelen)
  750. {
  751. struct trap_pdu_list *pPduList, *pTemp;
  753. pPduList = (struct trap_pdu_list *) malloc (sizeof (struct trap_pdu_list));
  754. if (pPduList == NULL)
  755. {
  756. snmp_sess_perror ("snmpd: send_trap", sink->sesp);
  757. snmp_free_pdu( pdu );
  758. }
  759. pPduList->pdu = pdu;
  760. if (sink->pduHead == NULL)
  761. {
  762. pPduList->next = NULL;
  763. sink->pduHead = pPduList;
  764. }
  765. else
  766. {
  767. for (pTemp = sink->pduHead; pTemp->next != NULL; pTemp = pTemp->next)
  768. ;
  769. pTemp->next = pPduList;
  770. pPduList->next = NULL;
  771. }
  772. sink->pduCount++;
  773. }
  774. }
  775. else
  776. {
  777. snmp_sess_perror ("snmpd: send_trap", sink->sesp);
  778. snmp_free_pdu( pdu );
  779. }
  780. }
  781. else 
  782. {
  783. snmp_increment_statistic(STAT_SNMPOUTTRAPS);
  784. snmp_increment_statistic(STAT_SNMPOUTPKTS);
  785. }
  787. if ( sink->version != SNMP_VERSION_1 && last_var )
  788. last_var->next_variable = NULL;
  789. }
  791. /* Ensure we don't free anything we shouldn't */
  792.     if ( last_var )
  793. last_var->next_variable = NULL;
  794.   /*  template_pdu->variables = NULL;*/
  795.     snmp_free_pdu( template_pdu );
  796.     snmp_free_pdu( pdu );
  797. }
  798. #else
  800. struct variable_list *
  801. find_varbind_in_list( struct variable_list *vblist,
  802.                       oid *name, size_t len)
  803. {
  804.     struct variable_list  *v;
  806.     for (v=vblist; v; v=v->next_variable)
  807.         if (!snmp_oid_compare(v->name, v->name_length,
  808.                               name,    len))
  809.             return v;
  811.     return NULL;
  812. }
  814. static struct variable_list *
  815. _copy_varlist(struct variable_list *var,      /* source varList */
  816.               int errindex,     /* index of variable to drop (if any) */
  817.               int copy_count)
  818. {                               /* !=0 number variables to copy */
  819.     struct variable_list *newhead, *newvar, *oldvar;
  820.     int             ii = 0;
  822.     newhead = NULL;
  823.     oldvar = NULL;
  825.     while (var && (copy_count-- > 0)) {
  826.         /*
  827.          * Drop the specified variable (if applicable) 
  828.          */
  829.         if (++ii == errindex) {
  830.             var = var->next_variable;
  831.             continue;
  832.         }
  834.         /*
  835.          * clone the next variable. Cleanup if alloc fails 
  836.          */
  837.         newvar = (struct variable_list *)
  838.             malloc(sizeof(struct variable_list));
  839.         if (snmp_clone_var(var, newvar)) {
  840.             if (newvar)
  841.                 free((char *) newvar);
  842.             snmp_free_varbind(newhead);
  843.             return 0;
  844.         }
  846.         /*
  847.          * add cloned variable to new list  
  848.          */
  849.         if (0 == newhead)
  850.             newhead = newvar;
  851.         if (oldvar)
  852.             oldvar->next_variable = newvar;
  853.         oldvar = newvar;
  855.         var = var->next_variable;
  856.     }
  857.     return newhead;
  858. }
  861. struct variable_list *
  862. snmp_clone_varbind(struct variable_list * varlist)
  863. {
  864.     return _copy_varlist(varlist, 0, 10000);    /* skip none, copy all */
  865. }
  867. struct snmp_pdu*
  868. convert_v2pdu_to_v1( struct snmp_pdu* template_v2pdu )
  869. {
  870.     struct snmp_pdu           *template_v1pdu;
  871.     struct variable_list *first_vb, *vblist;
  872.     struct variable_list *var;
  873.     size_t                 len;
  875.     /*
  876.      * Make a copy of the v2 Trap PDU
  877.      *   before starting to convert this
  878.      *   into a v1 Trap PDU.
  879.      */
  880.     template_v1pdu = snmp_clone_pdu( template_v2pdu);
  881.     if (!template_v1pdu) {
  882.         return NULL;
  883.     }
  884.     template_v1pdu->command = SNMP_MSG_TRAP;
  885.     first_vb = template_v1pdu->variables;
  886.     vblist   = template_v1pdu->variables;
  888.     /*
  889.      * The first varbind should be the system uptime.
  890.      */
  891.     if (!vblist ||
  892.         snmp_oid_compare(vblist->name,  vblist->name_length,
  893.                          sysuptime_oid, sysuptime_oid_len)) {
  894.         snmp_free_pdu(template_v1pdu);
  895.         return NULL;
  896.     }
  897.     template_v1pdu->time = *vblist->val.integer;
  898.     vblist = vblist->next_variable;
  899.             
  900.     /*
  901.      * The second varbind should be the snmpTrapOID.
  902.      */
  903.     if (!vblist ||
  904.         snmp_oid_compare(vblist->name, vblist->name_length,
  905.                          snmptrap_oid, snmptrap_oid_len)) {
  906.         snmp_free_pdu(template_v1pdu);
  907.         return NULL;
  908.     }
  910.     /*
  911.      * Set the generic & specific trap types,
  912.      *    and the enterprise field from the v2 varbind list.
  913.      * If there's an agentIPAddress varbind, set the agent_addr too
  914.      */
  915.     if (!snmp_oid_compare(vblist->val.objid, OID_LENGTH(trap_prefix),
  916.                           trap_prefix,       OID_LENGTH(trap_prefix))) {
  917.         /*
  918.          * For 'standard' traps, extract the generic trap type
  919.          *   from the snmpTrapOID value, and take the enterprise
  920.          *   value from the 'snmpEnterprise' varbind.
  921.          */
  922.         template_v1pdu->trap_type =
  923.             vblist->val.objid[OID_LENGTH(trap_prefix)] - 1;
  924.         template_v1pdu->specific_type = 0;
  926.         var = find_varbind_in_list( vblist,
  927.                              snmptrapenterprise_oid,
  928.                              snmptrapenterprise_oid_len);
  929.         if (var) {
  930.             snmp_memdup((u_char**)&template_v1pdu->enterprise,
  931.                    (const u_char*)var->val.objid, var->val_len);
  932.             template_v1pdu->enterprise_length = var->val_len/sizeof(oid);
  933.         } else {
  934.             template_v1pdu->enterprise        = NULL;
  935.             template_v1pdu->enterprise_length = 0; /* XXX ??? */
  936.         }
  937.     } else {
  938.         /*
  939.          * For enterprise-specific traps, split the snmpTrapOID value
  940.          *   into enterprise and specific trap
  941.          */
  942.         len = vblist->val_len / sizeof(oid);
  943.         template_v1pdu->trap_type     = SNMP_TRAP_ENTERPRISESPECIFIC;
  944.         template_v1pdu->specific_type = vblist->val.objid[len - 1];
  945.         len--;
  946.         if (vblist->val.objid[len-1] == 0)
  947.             len--;
  948.         SNMP_FREE(template_v1pdu->enterprise);
  949.         snmp_memdup((u_char**)&template_v1pdu->enterprise,
  950.                (u_char *)vblist->val.objid, len*sizeof(oid));
  951.         template_v1pdu->enterprise_length = len;
  952.     }
  953. #if 0
  954.     var = find_varbind_in_list( vblist, agentaddr_oid,
  955.                                         agentaddr_oid_len);
  956.     if (var) {
  957.         memcpy(template_v1pdu->agent_addr,
  958.                var->val.string, 4);
  959.     }
  960. #endif
  961.     /*
  962.      * The remainder of the v2 varbind list is kept
  963.      * as the v2 varbind list.  Update the PDU and
  964.      * free the two redundant varbinds.
  965.      */
  966.     template_v1pdu->variables = vblist->next_variable;
  967.     vblist->next_variable = NULL;
  968.     snmp_free_varbind( first_vb );
  969.             
  970.     return template_v1pdu;
  971. }
  973. struct snmp_pdu*
  974. convert_v1pdu_to_v2( struct snmp_pdu* template_v1pdu )
  975. {
  976.     struct snmp_pdu           *template_v2pdu;
  977.     struct variable_list *first_vb;
  978.     struct variable_list *var;
  979.     oid                    enterprise[MAX_OID_LEN];
  980.     size_t                 enterprise_len;
  982.     /*
  983.      * Make a copy of the v1 Trap PDU
  984.      *   before starting to convert this
  985.      *   into a v2 Trap PDU.
  986.      */
  987.     template_v2pdu = snmp_clone_pdu( template_v1pdu);
  988.     if (!template_v2pdu) {
  989.         return NULL;
  990.     }
  991.     template_v2pdu->command = SNMP_MSG_TRAP2;
  992.     first_vb = template_v2pdu->variables;
  994.     /*
  995.      * Insert an snmpTrapOID varbind before the original v1 varbind list
  996.      *   either using one of the standard defined trap OIDs,
  997.      *   or constructing this from the PDU enterprise & specific trap fields
  998.      */
  999.     if (template_v1pdu->trap_type == SNMP_TRAP_ENTERPRISESPECIFIC) {
  1000.         memcpy(enterprise, template_v1pdu->enterprise,
  1001.                            template_v1pdu->enterprise_length*sizeof(oid));
  1002.         enterprise_len               = template_v1pdu->enterprise_length;
  1003.         enterprise[enterprise_len++] = 0;
  1004.         enterprise[enterprise_len++] = template_v1pdu->specific_type;
  1005.     } else {
  1006.         memcpy(enterprise, cold_start_oid, sizeof(cold_start_oid));
  1007. enterprise[9]  = template_v1pdu->trap_type+1;
  1008.         enterprise_len = sizeof(cold_start_oid)/sizeof(oid);
  1009.     }
  1011.     var = NULL;
  1012.     if (!snmp_varlist_add_variable( &var,
  1013.              snmptrap_oid, snmptrap_oid_len,
  1014.              ASN_OBJECT_ID,
  1015.              (u_char*)enterprise, enterprise_len*sizeof(oid))) {
  1016.         snmp_free_pdu(template_v2pdu);
  1017.         return NULL;
  1018.     }
  1019.     var->next_variable        = template_v2pdu->variables;
  1020.     template_v2pdu->variables = var;
  1022.     /*
  1023.      * Insert a sysUptime varbind at the head of the v2 varbind list
  1024.      */
  1025.     var = NULL;
  1026.     if (!snmp_varlist_add_variable( &var,
  1027.              sysuptime_oid, sysuptime_oid_len,
  1028.              ASN_TIMETICKS,
  1029.              (u_char*)&(template_v1pdu->time), 
  1030.              sizeof(template_v1pdu->time))) {
  1031.         snmp_free_pdu(template_v2pdu);
  1032.         return NULL;
  1033.     }
  1034.     var->next_variable        = template_v2pdu->variables;
  1035.     template_v2pdu->variables = var;
  1037.     /*
  1038.      * Append the other three conversion varbinds,
  1039.      *  (snmpTrapAgentAddr, snmpTrapCommunity & snmpTrapEnterprise)
  1040.      *  if they're not already present.
  1041.      *  But don't bomb out completely if there are problems.
  1042.      */
  1043.      #if 0
  1044.     var = find_varbind_in_list( template_v2pdu->variables,
  1045.                                 agentaddr_oid, agentaddr_oid_len);
  1046.     if (!var && template_v1pdu->agent_addr[0]
  1047.              && template_v1pdu->agent_addr[1]
  1048.              && template_v1pdu->agent_addr[2]
  1049.              && template_v1pdu->agent_addr[3]) {
  1050.         if (!snmp_varlist_add_variable( &(template_v2pdu->variables),
  1051.                  agentaddr_oid, agentaddr_oid_len,
  1052.                  ASN_IPADDRESS,
  1053.                  (u_char*)&(template_v1pdu->agent_addr), 
  1054.                  sizeof(template_v1pdu->agent_addr)))
  1055.             snmp_log(LOG_WARNING,
  1056.                  "send_trap: failed to append snmpTrapAddr varbindn");
  1057.     }
  1058.     var = find_varbind_in_list( template_v2pdu->variables,
  1059.                                 community_oid, community_oid_len);
  1060.     if (!var && template_v1pdu->community) {
  1061.         if (!snmp_varlist_add_variable( &(template_v2pdu->variables),
  1062.                  community_oid, community_oid_len,
  1063.                  ASN_OCTET_STR,
  1064.                  template_v1pdu->community, 
  1065.                  strlen(template_v1pdu->community)))
  1066.             snmp_log(LOG_WARNING,
  1067.                  "send_trap: failed to append snmpTrapCommunity varbindn");
  1068.     }
  1069.    #endif
  1070.     var = find_varbind_in_list( template_v2pdu->variables,
  1071.                                 snmptrapenterprise_oid,
  1072.                                 snmptrapenterprise_oid_len);
  1073.     if (!var && 
  1074.         template_v1pdu->trap_type != SNMP_TRAP_ENTERPRISESPECIFIC) {
  1075.         if (!snmp_varlist_add_variable( &(template_v2pdu->variables),
  1076.                  snmptrapenterprise_oid, snmptrapenterprise_oid_len,
  1077.                  ASN_OBJECT_ID,
  1078.                  (u_char*)template_v1pdu->enterprise, 
  1079.                  template_v1pdu->enterprise_length*sizeof(oid)))
  1080.             snmp_log(LOG_WARNING,
  1081.                  "send_trap: failed to append snmpEnterprise varbindn");
  1082.     }
  1083.     return template_v2pdu;
  1084. }
  1086. void
  1087. send_trap_to_sess(struct trap_sink *sink, struct snmp_pdu *template_pdu)
  1088. {
  1089.     struct snmp_pdu    *pdu;
  1091.     struct soaddr_in *pduIp;
  1092.     u_long addr;
  1094.     if (!sink->sesp || !template_pdu)
  1095.         return;
  1097.    template_pdu->version = sink->sesp->version;
  1098.    template_pdu->command = sink->pdutype;
  1100.    if (sink->sesp->version == SNMP_VERSION_1 &&
  1101.         (template_pdu->command == SNMP_MSG_TRAP2 ||
  1102.          template_pdu->command == SNMP_MSG_INFORM))
  1103.         return;                 /* Skip v1 sinks for v2 only traps */
  1104.   
  1105.     pdu = snmp_clone_pdu(template_pdu);
  1107.     pduIp = (struct soaddr_in *)&pdu->agent_addr;/*by yangyuhua 2006-8-29*/
  1108.     pduIp->sin_family  = AF_INET;
  1109. get_trapsrc_ip(&addr);
  1110. if(addr)
  1111. pduIp->sin_addr.s_addr = addr;
  1112. else
  1113. pduIp->sin_addr.s_addr = get_myaddr();
  1114.     if (!addr)
  1115. {
  1116. IP_ADDR dest_addr, src_addr;
  1117. if (sink->sesp->peername != NULL)
  1118. {
  1119. dest_addr = inet_addr (sink->sesp->peername);
  1120. if (ipof_iffordest(dest_addr, &src_addr) == 0) /*success*/
  1121. {
  1122. pduIp = (struct soaddr_in *)&pdu->agent_addr;
  1123. pduIp->sin_family  = AF_INET;
  1124. pduIp->sin_addr.s_addr = src_addr;
  1125. }
  1126. }
  1127. }
  1129.     pdu->sessid = sink->sesp->sessid; /* AgentX only ? */
  1130.     if ( snmp_send( sink->sesp, pdu) == 0 ) 
  1131. {
  1132. if (sink->sesp->s_snmp_errno == SNMPERR_BAD_SENDTO)
  1133. {
  1134. if (sink->pduCount+1 < snmp_para.queuelen)
  1135. {
  1136. struct trap_pdu_list *pPduList, *pTemp;
  1138. pPduList = (struct trap_pdu_list *) malloc (sizeof (struct trap_pdu_list));
  1139. if (pPduList == NULL)
  1140. {
  1141. snmp_sess_perror ("snmpd: send_trap", sink->sesp);
  1142. snmp_free_pdu( pdu );
  1143. }
  1144. pPduList->pdu = pdu;
  1145. if (sink->pduHead == NULL)
  1146. {
  1147. pPduList->next = NULL;
  1148. sink->pduHead = pPduList;
  1149. }
  1150. else
  1151. {
  1152. for (pTemp = sink->pduHead; pTemp->next != NULL; pTemp = pTemp->next)
  1153. ;
  1154. pTemp->next = pPduList;
  1155. pPduList->next = NULL;
  1156. }
  1157. sink->pduCount++;
  1158. }
  1159. }
  1160. else
  1161. {
  1162. snmp_sess_perror ("snmpd: send_trap", sink->sesp);
  1163. snmp_free_pdu( pdu );
  1164. }
  1165. }
  1166. else 
  1167. {
  1168. snmp_increment_statistic(STAT_SNMPOUTTRAPS);
  1169. snmp_increment_statistic(STAT_SNMPOUTPKTS);
  1170. }
  1171. }
  1172. void send_enterprise_trap_vars (int trap, 
  1173.      int specific,
  1174.      oid *enterprise, int enterprise_length,
  1175.      struct variable_list *vars)
  1176. {
  1177.   /*  struct variable_list uptime_var, snmptrap_var, enterprise_var;
  1178.     oid temp_oid[MAX_OID_LEN];*/
  1179.     struct variable_list *trap_vb, *var;
  1180.     struct snmp_pdu           *template_v1pdu;
  1181.     struct snmp_pdu           *template_v2pdu;
  1182.     struct timeval  now;
  1183.     long uptime;
  1184.     struct trap_sink *sink;
  1185.     struct variable_list *vblist = NULL;
  1186.     if (vars) {
  1187.         vblist = snmp_clone_varbind( vars );
  1188.         if (!vblist) {
  1189.             snmp_log(LOG_WARNING,
  1190.                      "send_trap: failed to clone varbind listn");
  1191.             return;
  1192.         }
  1193.     }
  1195.     gettimeofday(&now, NULL);
  1196.     uptime = calculate_time_diff(&now, &starttime);
  1198.     if ( trap == -1 ) {
  1199.         /*
  1200.          * Construct the SNMPv2-style notification PDU
  1201.          */
  1202.         if (!vblist)  return;
  1204.         template_v2pdu = snmp_pdu_create(SNMP_MSG_TRAP2);
  1205.         if (!template_v2pdu) {
  1206.            snmp_free_varbind(vblist);
  1207.             return;
  1208.         }
  1210.         /*
  1211.          * Check the varbind list we've been given.
  1212.          * If it starts with a 'sysUptime.0' varbind, then use that.
  1213.          * Otherwise, prepend a suitable 'sysUptime.0' varbind.
  1214.          */
  1215.         if (!snmp_oid_compare( vblist->name,    vblist->name_length,
  1216.                                sysuptime_oid, sysuptime_oid_len )) {
  1217.             template_v2pdu->variables = vblist;
  1218.             trap_vb  = vblist->next_variable;
  1219.         } else {
  1220.             var = NULL;
  1221.             snmp_varlist_add_variable( &var,
  1222.                            sysuptime_oid, sysuptime_oid_len,
  1223.                            ASN_TIMETICKS, (u_char*)&uptime, sizeof(uptime));
  1224.             if (!var) {
  1225.   snmp_free_varbind(vblist);
  1226.                 snmp_free_pdu(template_v2pdu);
  1227.                 return ;
  1228.             }
  1229.             template_v2pdu->variables = var;
  1230.             var->next_variable        = vblist;
  1231.             trap_vb  = vblist;
  1232.         }
  1234.         /*
  1235.          * 'trap_vb' should point to the snmpTrapOID.0 varbind,
  1236.          *   identifying the requested trap.  If not then bomb out.
  1237.          * If it's a 'standard' trap, then we need to append an
  1238.          *   snmpEnterprise varbind (if there isn't already one).
  1239.          */
  1240.         if (!trap_vb ||
  1241.             snmp_oid_compare(trap_vb->name, trap_vb->name_length,
  1242.                              snmptrap_oid,  snmptrap_oid_len)) {
  1243.             snmp_free_pdu(template_v2pdu);
  1244.             return;
  1245.         }
  1246.         if (!snmp_oid_compare(vblist->val.objid, OID_LENGTH(trap_prefix),
  1247.                               trap_prefix,       OID_LENGTH(trap_prefix))) {/*查看warm_start_oid等有没有定义*/
  1248.             var = find_varbind_in_list( template_v2pdu->variables,
  1249.                                         snmptrapenterprise_oid,
  1250.                                         snmptrapenterprise_oid_len);
  1251.             if (!var &&
  1252.                 !snmp_varlist_add_variable( &(template_v2pdu->variables),
  1253.                      snmptrapenterprise_oid, snmptrapenterprise_oid_len,
  1254.                      ASN_OBJECT_ID,
  1255.                      (char*)enterprise, enterprise_length*sizeof(oid))) {
  1256.                 snmp_free_pdu(template_v2pdu);
  1257.                 return ;
  1258.             }
  1259.         }
  1261.         /*
  1262.          * If everything's OK, convert the v2 template into an SNMPv1 trap PDU.
  1263.          */
  1264.         template_v1pdu = convert_v2pdu_to_v1( template_v2pdu );
  1265.         if (!template_v1pdu) {
  1266.             snmp_free_pdu(template_v2pdu);
  1267.             return;
  1268.         }
  1270.     }else {
  1271.         /*
  1272.          * Construct the SNMPv1 trap PDU....
  1273.          */
  1274.         template_v1pdu = snmp_pdu_create(SNMP_MSG_TRAP);
  1275.         if (!template_v1pdu) {
  1276.      snmp_free_varbind(vblist);
  1277.             return ;
  1278.         }
  1279.         template_v1pdu->trap_type     = trap;
  1280.         template_v1pdu->specific_type = specific;
  1281.         template_v1pdu->time          = uptime;
  1283.         if (snmp_clone_mem((void **) &template_v1pdu->enterprise,
  1284.                        enterprise, enterprise_length * sizeof(oid))) {
  1285.             snmp_free_varbind(vblist);
  1286.             snmp_free_pdu(template_v1pdu);
  1287.             return;
  1288.         }
  1289.         template_v1pdu->enterprise_length = enterprise_length;
  1291.         template_v1pdu->flags    |= UCD_MSG_FLAG_FORCE_PDU_COPY;
  1292.         template_v1pdu->variables = vblist;
  1294.         /*
  1295.          * ... and convert it into an SNMPv2-style notification PDU.
  1296.          */
  1298.         template_v2pdu = convert_v1pdu_to_v2( template_v1pdu );
  1299.         if (!template_v2pdu) {
  1300.             snmp_free_pdu(template_v1pdu);
  1301.             return ;
  1302.         }
  1303.     }
  1304. /*
  1305.  *  Now loop through the list of trap sinks,
  1306.  *   sending an appropriately formatted PDU to each
  1307.  */
  1308. for ( sink = sinks ; sink ; sink=sink->next ) 
  1309. {
  1310. BOOL bContinue;
  1311. if ( sink->version == SNMP_VERSION_1 && trap == -1 )
  1312. continue; /* Skip v1 sinks for v2 only traps */
  1313. bContinue = TRUE;
  1314. switch ( trap )
  1315. {
  1316. case SNMP_TRAP_COLDSTART:
  1317. case SNMP_TRAP_WARMSTART:
  1318. case SNMP_TRAP_LINKDOWN:
  1319. case SNMP_TRAP_LINKUP:
  1320. if(sink->trapflags&SNMP_SNMPTYPE_TRAP)
  1321. bContinue = FALSE;
  1322. break;
  1323. case SNMP_TRAP_AUTHFAIL:
  1324. if(sink->trapflags&SNMP_AUTH_TRAP)
  1325. bContinue = FALSE;
  1326. break;
  1327. default:
  1328. bContinue = FALSE;
  1329. break;
  1331. }
  1332. if (bContinue)
  1333. continue;
  1335.  if (sink->version == SNMP_VERSION_1) {
  1336.             send_trap_to_sess(sink, template_v1pdu);
  1337.         } else {
  1338.             send_trap_to_sess(sink, template_v2pdu);
  1339.         }
  1341. }
  1343. /* Ensure we don't free anything we shouldn't */
  1345.     snmp_free_pdu( template_v1pdu );
  1346.     snmp_free_pdu( template_v2pdu );
  1347. }
  1349. #endif
  1350. void send_trap_vars (int trap, 
  1351.      int specific,
  1352.      struct variable_list *vars)
  1353. {
  1354.     if ( trap == SNMP_TRAP_ENTERPRISESPECIFIC )
  1355.         send_enterprise_trap_vars( trap, specific, default_enterprise,
  1356. OID_LENGTH(default_enterprise), vars );
  1357.     else
  1358.         send_enterprise_trap_vars( trap, specific, default_enterprise,
  1359. OID_LENGTH(default_enterprise), vars );
  1360. }
  1362. void send_easy_trap (int trap, 
  1363.      int specific)
  1364. {
  1365.     send_trap_vars( trap, specific, NULL );
  1366. }
  1368. void send_v2trap ( struct variable_list *vars)
  1369. {
  1370.     send_trap_vars( -1, -1, vars );
  1371. }
  1373. void
  1374. send_trap_pdu(struct snmp_pdu *pdu)
  1375. {
  1376.     send_trap_vars( -1, -1, pdu->variables );
  1377. }
  1381. /*******************
  1382.  *
  1383.  * Config file handling
  1384.  *
  1385.  *******************/
  1387. void snmpd_parse_config_authtrap(const char *token, 
  1388.  char *cptr)
  1389. {
  1390.     int i;
  1392.     i = atoi(cptr);
  1393.     if ( i == 0 ) {
  1394. if ( !strcmp( cptr, "enable" ))
  1395.     i = SNMP_AUTHENTICATED_TRAPS_ENABLED;
  1396. else if ( !strcmp( cptr, "disable" ))
  1397.     i = SNMP_AUTHENTICATED_TRAPS_DISABLED;
  1398.     }
  1399.     if (i < 1 || i > 2)
  1400. config_perror("authtrapenable must be 1 or 2");
  1401.     else
  1402. snmp_enableauthentraps = i;
  1403. }
  1405. void snmpd_parse_config_trapsink(const char *token, 
  1406.  char *cptr)
  1407. {
  1408.     char tmpbuf[1024];
  1409.     char *sp, *cp, *pp = NULL;
  1410.     u_short sinkport;
  1411.     
  1412.     if (!snmp_trapcommunity) snmp_trapcommunity = strdup("public");
  1413.     sp = strtok(cptr, " tn");
  1414.     cp = strtok(NULL, " tn");
  1415.     if (cp) pp = strtok(NULL, " tn");
  1416.     if (cp && pp) {
  1417. sinkport = (u_short) atoi(pp);
  1418. if ((sinkport < 1) || (sinkport > 0xffff)) {
  1419.     config_perror("trapsink port out of range");
  1420.     sinkport = SNMP_TRAP_PORT;
  1421. }
  1422.     } else {
  1423. sinkport = SNMP_TRAP_PORT;
  1424.     }
  1425.     if (create_v1_trap_session(sp, sinkport,
  1426.        cp ? cp : snmp_trapcommunity) == 0) {
  1427. sprintf(tmpbuf,"cannot create trapsink: %s", cptr);
  1428. config_perror(tmpbuf);
  1429.     }
  1430. }
  1433. void
  1434. snmpd_parse_config_trap2sink(const char *word, char *cptr)
  1435. {
  1436.     char tmpbuf[1024];
  1437.     char *sp, *cp, *pp = NULL;
  1438.     u_short sinkport;
  1439.   
  1440.     if (!snmp_trapcommunity) snmp_trapcommunity = strdup("public");
  1441.     sp = strtok(cptr, " tn");
  1442.     cp = strtok(NULL, " tn");
  1443.     if (cp) pp = strtok(NULL, " tn");
  1444.     if (cp && pp) {
  1445. sinkport = (u_short)atoi(pp);
  1446. if ((sinkport < 1) || (sinkport > 0xffff)) {
  1447.     config_perror("trapsink port out of range");
  1448.     sinkport = SNMP_TRAP_PORT;
  1449. }
  1450.     } else {
  1451. sinkport = SNMP_TRAP_PORT;
  1452.     }
  1453.     if (create_v2_trap_session(sp, sinkport,
  1454.        cp ? cp : snmp_trapcommunity) == 0) {
  1455. sprintf(tmpbuf,"cannot create trap2sink: %s", cptr);
  1456. config_perror(tmpbuf);
  1457.     }
  1458. }
  1460. void
  1461. snmpd_parse_config_informsink(const char *word, char *cptr)
  1462. {
  1463.     char tmpbuf[1024];
  1464.     char *sp, *cp, *pp = NULL;
  1465.     u_short sinkport;
  1466.   
  1467.     if (!snmp_trapcommunity) snmp_trapcommunity = strdup("public");
  1468.     sp = strtok(cptr, " tn");
  1469.     cp = strtok(NULL, " tn");
  1470.     if (cp) pp = strtok(NULL, " tn");
  1471.     if (cp && pp) {
  1472. sinkport = (u_short)atoi(pp);
  1473. if ((sinkport < 1) || (sinkport > 0xffff)) {
  1474.     config_perror("trapsink port out of range");
  1475.     sinkport = SNMP_TRAP_PORT;
  1476. }
  1477.     } else {
  1478. sinkport = SNMP_TRAP_PORT;
  1479.     }
  1480.     if (create_v2_inform_session(sp, sinkport,
  1481.  cp ? cp : snmp_trapcommunity) == 0) {
  1482. sprintf(tmpbuf,"cannot create informsink: %s", cptr);
  1483. config_perror(tmpbuf);
  1484.     }
  1485. }
  1487. void
  1488. snmpd_parse_config_trapcommunity(const char *word, char *cptr)
  1489. {
  1490.     if (snmp_trapcommunity) free(snmp_trapcommunity);
  1491.     snmp_trapcommunity = malloc (strlen(cptr)+1);
  1492.     copy_word(cptr, snmp_trapcommunity);
  1493. }
  1495. void snmpd_free_trapcommunity (void)
  1496. {
  1497.     if (snmp_trapcommunity) {
  1498. free(snmp_trapcommunity);
  1499. snmp_trapcommunity = NULL;
  1500.     }
  1501. }
  1502. #define MIB 1, 3, 6, 1, 2, 1
  1504. oid objid_ifIndex[]   = {MIB, 2, 2,1,1, 0};
  1505. static oid objid_ifDescr[]   = {MIB, 2,2,1, 2, 0};
  1506. static oid objid_ifType[]   = {MIB, 2,2,1, 3, 0};
  1507. static oid objid_ifAdminStatus[]   = {MIB, 2,2,1, 7, 0};
  1508. static oid objid_ifOpenStatus[]   = {MIB, 2,2,1, 8, 0};
  1509. static long ltmp;
  1511. void send_v1_link_trap(int trap_type,int if_index,int if_type,unsigned char *if_desr)
  1512. {
  1513. struct variable_list *vl = NULL;
  1514. int namelen;
  1515. UINT16 iAdminTemp=0;
  1516. namelen=sizeof (objid_ifIndex)/sizeof(oid);
  1517. objid_ifIndex[namelen-1]=if_index;
  1518. ltmp = if_index;
  1519. snmp_varlist_add_variable(&vl, objid_ifIndex, namelen, ASN_INTEGER,
  1520. (char*)&ltmp, sizeof (long));
  1522. namelen=sizeof (objid_ifDescr)/sizeof(oid);
  1523. objid_ifDescr[namelen-1]=if_index;
  1524. snmp_varlist_add_variable(&vl, objid_ifDescr, namelen, ASN_OCTET_STR,
  1525. (char*)if_desr, strlen (if_desr));
  1527. namelen=sizeof (objid_ifType)/sizeof(oid);
  1528. objid_ifType[namelen-1]=if_index;
  1529. ltmp = if_type;
  1530. snmp_varlist_add_variable(&vl, objid_ifType, namelen, ASN_INTEGER,
  1531. (char*)&ltmp, sizeof (long));
  1533. interface_omnivorous_callback_getshutdown(if_index, (UINT16 *)&iAdminTemp);
  1534. if (iAdminTemp & 1)
  1535. {
  1536. ltmp = 2;
  1537. } 
  1538. else 
  1539. {
  1540. ltmp = 1;
  1541. }
  1542. namelen=sizeof (objid_ifAdminStatus)/sizeof(oid);
  1543. objid_ifAdminStatus[namelen-1]=if_index;
  1544. snmp_varlist_add_variable(&vl, objid_ifAdminStatus, namelen, ASN_INTEGER,
  1545. (char*)&ltmp, sizeof (long));
  1547. switch ( trap_type )
  1548. {
  1550. case SNMP_TRAP_LINKDOWN:
  1551. namelen=sizeof (objid_ifOpenStatus)/sizeof(oid);
  1552. objid_ifOpenStatus[namelen-1]=if_index;
  1553. ltmp = trap_type;
  1554. snmp_varlist_add_variable(&vl, objid_ifOpenStatus, namelen, ASN_INTEGER,
  1555. (char*)&ltmp, sizeof (long));
  1556. break;
  1557. case SNMP_TRAP_LINKUP:
  1558. namelen=sizeof (objid_ifOpenStatus)/sizeof(oid);
  1559. objid_ifOpenStatus[namelen-1]=if_index;
  1560. ltmp = 1;
  1561. snmp_varlist_add_variable(&vl, objid_ifOpenStatus, namelen, ASN_INTEGER,
  1562. (char*)&ltmp, sizeof (long));
  1563. break;
  1564. default:
  1565. break;
  1566. }
  1567.    
  1568. send_trap_vars (trap_type, -1, vl);
  1569. snmp_free_varbind (vl);
  1571. }
  1572. void send_link_trap(int version,int trap_type,int if_index,int if_type,unsigned char *if_desr)
  1573. {
  1574. send_v1_link_trap(trap_type,if_index,if_type,if_desr);
  1576. }
  1577. #ifndef OS_VXWORKS
  1578. static ULONG trapTimerID = 0;
  1579. #endif
  1580. static void retry_send_trap(ULONG arg)
  1581. {
  1582. struct trap_sink *sinkPtr;
  1583. struct trap_pdu_list *prevPtr, *curPtr;
  1585. for ( sinkPtr = sinks ; sinkPtr != NULL; sinkPtr=sinkPtr->next )
  1586. {
  1587. prevPtr = NULL;
  1588. for (curPtr = sinkPtr->pduHead; curPtr != NULL; )
  1589. {
  1590. IP_ADDR dest_addr, src_addr;
  1591. struct soaddr_in *pduIp;
  1592. if (sinkPtr->sesp->peername != NULL)
  1593. {
  1594. dest_addr = inet_addr (sinkPtr->sesp->peername);
  1595. if (ipof_iffordest(dest_addr, &src_addr) == 0) /*success*/
  1596. {
  1597. pduIp = (struct soaddr_in *)&(curPtr->pdu->agent_addr);
  1598. pduIp->sin_family  = AF_INET;
  1599. pduIp->sin_addr.s_addr = src_addr;
  1600. }
  1601. }
  1603. if (snmp_send( sinkPtr->sesp, curPtr->pdu) != 0)
  1604. {
  1605. if (prevPtr == NULL)
  1606. {
  1607. sinkPtr->pduHead = curPtr->next;
  1608. free (curPtr);
  1609. curPtr = sinkPtr->pduHead;
  1610. }
  1611. else
  1612. {
  1613. prevPtr->next = curPtr->next;
  1614. free (curPtr);
  1615. curPtr = prevPtr->next;
  1616. }
  1617. sinkPtr->pduCount --;
  1618. snmp_increment_statistic(STAT_SNMPOUTTRAPS);
  1619. snmp_increment_statistic(STAT_SNMPOUTPKTS);
  1620. }
  1621. else
  1622. {
  1623. prevPtr = curPtr;
  1624. curPtr = curPtr->next;
  1625. }
  1626. }
  1627. }
  1629. #ifndef OS_VXWORKS
  1630. sys_start_timer(trapTimerID,snmp_para.timeout);
  1631. #endif
  1632. }
  1633. #ifdef OS_VXWORKS
  1634. void snmp_retry_send_trap()
  1635. {
  1636.     while (1)
  1637.     {
  1638.         sys_task_delay(snmp_para.timeout * SYS_CLK_RATE);
  1639.         retry_send_trap(0);
  1640.     }
  1641. }
  1642. #endif
  1644. void init_trap_retry_timer(void)
  1645. {
  1646. #ifndef OS_VXWORKS
  1647. TIMER_USER_DATA user_data;
  1649. user_data.cb.fun=retry_send_trap;
  1650. user_data.cb.arg=0;
  1651. sys_add_timer(TIMER_CALLBACK_METHOD,&user_data,&trapTimerID);
  1652. sys_start_timer(trapTimerID,snmp_para.timeout);
  1653. #else
  1654.     sys_task_spawn("SNMT", SYS_TASK_PRI_NORMAL, T_OP_NOPREEMPT, 16*1024, snmp_retry_send_trap, NULL, 0);
  1655. #endif
  1656. }
  1658. void set_trapsinks(int cmd,long long value)
  1659. {
  1660. struct trap_sink *trapsink;
  1661. SNMP_DEBUG_ROUTINES("set_trapsinks()");
  1662. for(trapsink=sinks;trapsink!=NULL;trapsink=trapsink->next){
  1663. switch(cmd){
  1664. case SET_SNMP_TRAP_QUEUELEN:
  1665. trapsink->sesp->retries=(int)value;
  1666. break;
  1667. case SET_SNMP_TRAP_TIMEOUT:
  1668. trapsink->sesp->timeout=(int)value;
  1669. #ifndef OS_VXWORKS
  1670. sys_stop_timer (trapTimerID);
  1671. sys_start_timer(trapTimerID,snmp_para.timeout);
  1672. #endif
  1673. break;
  1674. case SET_SNMP_TRAP_SOURCE:
  1675. change_session_localaddr(trapsink->sesp,(DEVICE_ETERNAL_ID)value);
  1677. break;
  1678. }
  1679. }
  1680. }