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

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

SNMP编程

开发平台：

C/C++

snmpd.c：源码内容
  1. /*
  2.  * snmpd.c - rrespond to SNMP queries from management stations
  3.  *
  4.  */
  5. /***********************************************************
  6. Copyright 1988, 1989 by Carnegie Mellon University
  8.                       All Rights Reserved
  10. Permission to use, copy, modify, and distribute this software and its 
  11. documentation for any purpose and without fee is hereby granted, 
  12. provided that the above copyright notice appear in all copies and that
  13. both that copyright notice and this permission notice appear in 
  14. supporting documentation, and that the name of CMU not be
  15. used in advertising or publicity pertaining to distribution of the
  16. software without specific, written prior permission.  
  18. CMU DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  19. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  20. CMU BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  21. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  22. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  23. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  24. SOFTWARE.
  25. ******************************************************************/
  26. #ifdef OS_VXWORKS
  27. #include <libsys/vos/vos_rtos.h>
  28. #include <global.h>
  29. #endif
  31. #include <ip/socket.h>
  32. #include <config.h>
  34. #include <stdio.h>
  35. #include <errno.h>
  36. #if HAVE_STRING_H
  37. #include <string.h>
  38. #else
  39. #include <strings.h>
  40. #endif
  41. #if HAVE_STDLIB_H
  42. #include <stdlib.h>
  43. #endif
  44. #if HAVE_UNISTD_H
  45. #include <unistd.h>
  46. #endif
  47. #include <sys/types.h>
  48. #if HAVE_NETINET_IN_H
  49. #include <netinet/in.h>
  50. #endif
  51. #if HAVE_ARPA_INET_H
  52. #include <arpa/inet.h>
  53. #endif
  54. #if TIME_WITH_SYS_TIME
  55. # ifdef WIN32
  56. #  include <sys/timeb.h>
  57. # else
  58. #  include <time.h>
  59. # endif
  60. # include <time.h>
  61. #else
  62. # if HAVE_SYS_TIME_H
  63. #  include <sys/time.h>
  64. # else
  65. #  include <time.h>
  66. # endif
  67. #endif
  68. #if HAVE_SYS_SELECT_H
  69. #include <sys/select.h>
  70. #endif
  71. #if HAVE_SYS_SOCKET_H
  72. #include <sys/socket.h>
  73. #elif HAVE_WINSOCK_H
  74. #endif
  75. #if HAVE_NET_IF_H
  76. #include <net/if.h>
  77. #endif
  78. #if HAVE_INET_MIB2_H
  79. #include <inet/mib2.h>
  80. #endif
  81. #if HAVE_SYS_IOCTL_H
  82. #include <sys/ioctl.h>
  83. #endif
  84. #if HAVE_SYS_FILE_H
  85. #include <sys/file.h>
  86. #endif
  87. #ifdef HAVE_FCNTL_H
  88. #include <fcntl.h>
  89. #endif
  90. #if HAVE_SYS_WAIT_H
  91. #include <sys/wait.h>
  92. #endif
  93. #include <signal.h>
  94. #ifdef HAVE_SYS_PARAM_H
  95. #include <sys/param.h>
  96. #endif
  97. #include <ip/inet.h>
  98. #ifndef FD_SET
  99. typedef long    fd_mask;
  100. #define NFDBITS (sizeof(fd_mask) * NBBY)        /* bits per mask */
  101. #define FD_SET(n, p)    ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
  102. #define FD_CLR(n, p)    ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
  103. #define FD_ISSET(n, p)  ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
  104. #define FD_ZERO(p)      memset((p), 0, sizeof(*(p)))
  105. #endif
  107. #if HAVE_DMALLOC_H
  108. #include <dmalloc.h>
  109. #endif
  111. #include "asn1.h"
  112. #include "snmp_api.h"
  113. #include "snmp_impl.h"
  114. #include "read_config.h"
  115. #include "snmp.h"
  116. #include "mib.h"
  117. #include "m2m.h"
  118. #include "snmp_vars.h"
  119. #include "agent_read_config.h"
  120. #include "snmpv3.h"
  121. #include "callback.h"
  122. #include "snmp_alarm.h"
  123. #include "default_store.h"
  124. #include "mib_module_config.h"
  126. #include "snmp_client.h"
  127. #include "snmpd.h"
  128. #include "var_struct.h"
  129. #include "mibgroup/struct.h"
  130. #include "mibgroup/util_funcs.h"
  131. #include "snmp_debug.h"
  132. #include "mib_modules.h"
  134. #include "snmpusm.h"
  135. #include "tools.h"
  136. #include "lcd_time.h"
  138. #include "snmp_agent.h"
  139. #include "agent_trap.h"
  140. #include "ds_agent.h"
  141. #include "agent_read_config.h"
  142. #include "snmp_logging.h"
  143. #include "version.h"
  144. #include "mib_module_includes.h"
  145. #include "system.h"
  147. /*
  148.  * Globals.
  149.  */
  150. #ifdef USE_LIBWRAP
  151. #include <tcpd.h>
  153. int allow_severity  = LOG_INFO;
  154. int deny_severity  = LOG_WARNING;
  155. #endif  /* USE_LIBWRAP */
  157. #define TIMETICK         500000L
  158. #define ONE_SEC         1000000L
  160. int  log_addresses  = 0;
  161. int  snmp_dump_packet;
  162. int             running          = 1;
  163. int reconfig  = 0;
  165. struct addrCache {
  166.     in_addr_t addr;
  167.     int status;
  168. #define UNUSED 0
  169. #define USED 1
  170. #define OLD 2
  171. };
  173. #define ADDRCACHE 10
  175. static struct addrCache addrCache[ADDRCACHE];
  176. static int lastAddrAge = 0;
  178. #define NUM_SOCKETS 32
  180. #ifdef USING_SMUX_MODULE
  181. static int sdlist[NUM_SOCKETS], sdlen = 0;
  182. int smux_listen_sd;
  183. #endif /* USING_SMUX_MODULE */
  185. /*
  186.  * Prototypes.
  187.  */
  188. int snmp_read_packet (int);
  189. int snmp_input (int, struct snmp_session *, int, struct snmp_pdu *, void *);
  190. int main (int, char **);
  191. static void SnmpTrapNodeDown (void);
  192. int receive(void);
  193. int snmp_check_packet(struct snmp_session*, struct soaddr);
  194. int snmp_check_parse(struct snmp_session*, struct snmp_pdu*, int);
  195. extern int  gettimeofday(struct timeval *tp,struct timezone *tzp);
  196. extern void set_trapd_session_ptr (void);
  197. extern void init_trap_retry_timer(void);
  200. #ifdef SIGHUP
  201. RETSIGTYPE
  202. SnmpdReconfig(int a)
  203. {
  204. reconfig = 1;
  205. signal(SIGHUP, SnmpdReconfig);
  206. }
  207. #endif
  209. #ifdef SIGUSR1
  210. extern void dump_registry( void );
  211. RETSIGTYPE
  212. SnmpdDump(int a)
  213. {
  214. dump_registry();
  215. signal(SIGUSR1, SnmpdDump);
  216. }
  217. #endif
  220. static void
  221. SnmpTrapNodeDown(void)
  222. {
  223.     send_easy_trap (SNMP_TRAP_ENTERPRISESPECIFIC, 2);
  224.     /* XXX  2 - Node Down #define it as NODE_DOWN_TRAP */
  225. }
  226. void snmp_set_dump_verbose (int value)
  227. {
  228. ds_set_boolean(DS_APPLICATION_ID, DS_AGENT_VERBOSE, value);
  229. }
  231. /*******************************************************************-o-******
  232.  * main
  233.  *
  234.  * Parameters:
  235.  *  argc
  236.  * *argv[]
  237.  *      
  238.  * Returns:
  239.  * 0 Always succeeds.  (?)
  240.  *
  241.  *
  242.  * Setup and start the agent daemon.
  243.  *
  244.  * Also successfully EXITs with zero for some options.
  245.  */
  246. extern ULONG snmp_source_ip;
  247. extern int output_error;
  248. int
  249. snmpd_init(void)
  250. {
  251. int             ret;
  252. u_short         dest_port = SNMP_PORT;
  253. #if HAVE_GETPID
  254. FILE           *PID;
  255. #endif
  259.     init_agent("snmpd"); /* do what we need to do first. */
  260.     init_mib_modules();
  261. init_start_time();
  263.    /* start library */
  264.     init_snmp("snmpd");
  265.     snmp_source_ip= INADDR_ANY;
  266.     ret = init_master_agent( dest_port,
  267.                        snmp_check_packet,
  268.                        snmp_check_parse );
  269. if( ret != 0 )
  270. {
  271. snmp_trace ("Create socket failn");
  272. return 0;
  273. }
  274. init_start_time ();
  277. memset(addrCache, 0, sizeof(addrCache));
  278. /* 
  279.  * Forever monitor the dest_port for incoming PDUs.
  280.  */
  281. init_mib_system();
  282. ds_set_boolean(DS_LIBRARY_ID, DS_LIB_PRINT_FULL_OID, 0);
  283. output_error = 0;
  284. set_trapd_session_ptr();
  285. init_trap_retry_timer();
  286. return 0;
  288. }  /* End main() -- snmpd */
  290. /*******************************************************************-o-******
  291.  * receive
  292.  *
  293.  * Parameters:
  294.  *      
  295.  * Returns:
  296.  * 0 On success.
  297.  * -1 System error.
  298.  *
  299.  * Infinite while-loop which monitors incoming messges for the agent.
  300.  * Invoke the established message handlers for incoming messages on a per
  301.  * port basis.  Handle timeouts.
  302.  */
  303. int
  304. receive(void)
  305. {
  306.     int numfds;
  307.     fd_set fdset;
  308.     struct timeval timeout, *tvp;
  309.     struct timeval sched,   *svp = &sched,
  310. now,     *nvp = &now;
  311.     int count, block;
  312. #ifdef USING_SMUX_MODULE
  313.     int i, sd;
  314. #endif /* USING_SMUX_MODULE */
  315.     /*
  316.      * Set the 'sched'uled timeout to the current time + one TIMETICK.
  317.      */
  318.     gettimeofday(nvp, (struct timezone *) NULL);
  319.     svp->tv_usec = nvp->tv_usec + TIMETICK;
  320.     svp->tv_sec = nvp->tv_sec;
  321.     
  322.     while (svp->tv_usec >= ONE_SEC){
  323. svp->tv_usec -= ONE_SEC;
  324. svp->tv_sec++;
  325.     }
  327.     /*
  328.      * Loop-forever: execute message handlers for sockets with data,
  329.      * reset the 'sched'uler.
  330.      */
  331.     while (running) {
  332. tvp =  &timeout;
  333. tvp->tv_sec = 0;
  334. tvp->tv_usec = TIMETICK;
  336. numfds = 0;
  337. FD_ZERO(&fdset);
  338.         block = 0;
  339. /*        snmp_select_info(&numfds, &fdset, tvp, &block);*/
  340.         snmp_sess_select_info(NULL, &numfds, &fdset, tvp, &block);
  341.         if (block == 1)
  342.             tvp = NULL; /* block without timeout */
  344. #ifdef USING_SMUX_MODULE
  345. if (smux_listen_sd >= 0) {
  346. FD_SET(smux_listen_sd, &fdset);
  347. numfds = smux_listen_sd >= numfds ? smux_listen_sd + 1 : numfds;
  348. for (i = 0; i < sdlen; i++) {
  349. FD_SET(sdlist[i], &fdset);
  350. numfds = sdlist[i] >= numfds ? sdlist[i] + 1 : numfds;
  351. }
  352. }
  353. #endif /* USING_SMUX_MODULE */
  355. count = so_select(numfds, &fdset, 0, 0, tvp);
  357. if (count > 0){
  359.     snmp_read(&fdset);
  360. } else switch(count){
  361. case 0:
  362.                 snmp_timeout();
  363.                 break;
  364.     case -1:
  365.      tm_wkafter(1);
  366.      break;
  367. /* if (errno == EINTR){
  368.     continue;
  369. } else {
  370.                     snmp_trace("socket select err");
  371. }
  372. return -1;*/
  373.     default:
  374. snmp_trace("select returned %dn", count);
  375. /*return -1;*/
  376. tm_wkafter(1);
  377. break;
  378. }  /* endif -- count>0 */
  380. #ifdef USING_SMUX_MODULE
  381. /* handle the SMUX sd's */
  383. if (smux_listen_sd >= 0) {
  384. for (i = 0; i < sdlen; i++) {
  385. if (FD_ISSET(sdlist[i], &fdset)) {
  386. if (smux_process(sdlist[i]) < 0) {
  387. for (; i < (sdlen - 1); i++) {
  388. sdlist[i] = sdlist[i+1];
  389. }
  390. sdlen--;
  391. }
  392. }
  393. }
  394. /* new connection */
  395. if (FD_ISSET(smux_listen_sd, &fdset)) {
  396. if ((sd = smux_accept(smux_listen_sd)) >= 0) {
  397. sdlist[sdlen++] = sd;
  398. }
  399. }
  400. }
  401. #endif /* USING_SMUX_MODULE */
  405.         /*
  406.          * If the time 'now' is greater than the 'sched'uled time, then:
  407.          *
  408.          *    Check alarm and event timers.
  409.          *    Reset the 'sched'uled time to current time + one TIMETICK.
  410.          *    Age the cache network addresses (from whom messges have
  411.          *        been received).
  412.          */
  413.         gettimeofday(nvp, (struct timezone *) NULL);
  415.         if (nvp->tv_sec > svp->tv_sec
  416.                 || (nvp->tv_sec == svp->tv_sec && nvp->tv_usec > svp->tv_usec)){
  417.             svp->tv_usec = nvp->tv_usec + TIMETICK;
  418.             svp->tv_sec = nvp->tv_sec;
  420.             while (svp->tv_usec >= ONE_SEC){
  421.                 svp->tv_usec -= ONE_SEC;
  422.                 svp->tv_sec++;
  423.             }
  424.             if (log_addresses && lastAddrAge++ > 600){
  426.                 lastAddrAge = 0;
  427.                 for(count = 0; count < ADDRCACHE; count++){
  428.                     if (addrCache[count].status == OLD)
  429.                         addrCache[count].status = UNUSED;
  430.                     if (addrCache[count].status == USED)
  431.                         addrCache[count].status = OLD;
  432.                 }
  433.             }
  434.         }  /* endif -- now>sched */
  436.         /* run requested alarms */
  437.         run_alarms();
  438.         
  439.     }  /* endwhile */
  441.     snmp_trace("Received TERM or STOP signal...  shutting down...n");
  442.     return 0;
  444. }  /* end receive() */
  449. /*******************************************************************-o-******
  450.  * snmp_check_packet
  451.  *
  452.  * Parameters:
  453.  * session, from
  454.  *      
  455.  * Returns:
  456.  * 1 On success.
  457.  * 0 On error.
  458.  *
  459.  * Handler for all incoming messages (a.k.a. packets) for the agent.  If using
  460.  * the libwrap utility, log the connection and deny/allow the access. Print
  461.  * output when appropriate, and increment the incoming counter.
  462.  *
  463.  */
  464. int
  465. snmp_check_packet(struct snmp_session *session,
  466.   struct soaddr from)
  467. {
  468.     struct soaddr_in *fromIp = (struct soaddr_in *)&from;
  470. #ifdef USE_LIBWRAP
  471.     const char *addr_string;
  472.     /*
  473.      * Log the message and/or dump the message.
  474.      * Optionally cache the network address of the sender.
  475.      */
  476.     addr_string = inet_ntoa(fromIp->sin_addr);
  478.     if(!addr_string) {
  479.       addr_string = STRING_UNKNOWN;
  480.     }
  481.     if(hosts_ctl("snmpd", addr_string, addr_string, STRING_UNKNOWN)) {
  482.       snmp_trace( "Connection from %sn", addr_string);
  483.     } else {
  484.       snmp_trace("Connection from %s REFUSEDn", addr_string);
  485.       return(0);
  486.     }
  487. #endif /* USE_LIBWRAP */
  489.     snmp_increment_statistic(STAT_SNMPINPKTS);
  491.     if (log_addresses || ds_get_boolean(DS_APPLICATION_ID, DS_AGENT_VERBOSE)){
  492. int count;
  494. for(count = 0; count < ADDRCACHE; count++){
  495.     if (addrCache[count].status > UNUSED /* used or old */
  496. && fromIp->sin_addr.s_addr == addrCache[count].addr)
  497. break;
  498. }
  500. if (count >= ADDRCACHE ||
  501.             ds_get_boolean(DS_APPLICATION_ID, DS_AGENT_VERBOSE)){
  502.     snmp_trace("nReceived SNMP packet(s) from %sn",
  503.                         inet_ntoa(fromIp->sin_addr));
  504.     for(count = 0; count < ADDRCACHE; count++){
  505. if (addrCache[count].status == UNUSED){
  506.     addrCache[count].addr = fromIp->sin_addr.s_addr;
  507.     addrCache[count].status = USED;
  508.     break;
  509. }
  510.     }
  511. } else {
  512.     addrCache[count].status = USED;
  513. }
  514.     }
  516.     return ( 1 );
  517. }
  519. int snmp_get_do_logging (void)
  520. {
  521. return 0;
  522. }
  523. int
  524. snmp_check_parse( struct snmp_session *session,
  525.     struct snmp_pdu     *pdu,
  526.     int    result)
  527. {
  528.     if ( result == 0 ) {
  529.         if ( ds_get_boolean(DS_APPLICATION_ID, DS_AGENT_VERBOSE)) 
  530. {
  531.      char c_oid [SPRINT_MAX_LEN];
  532.      struct variable_list *var_ptr;
  533.     
  534.     switch (pdu->command) {
  535.     case SNMP_MSG_GET:
  536.      snmp_trace("  SNMP: GET requestn"); break;
  537.     case SNMP_MSG_GETNEXT:
  538.      snmp_trace("  SNMP: GETNEXT requestn"); break;
  539.     case SNMP_MSG_RESPONSE:
  540.      snmp_trace("  SNMP: RESPONSE messagen"); break;
  541.     case SNMP_MSG_SET:
  542.      snmp_trace("  SNMP: SET requestn"); break;
  543.     case SNMP_MSG_TRAP:
  544.      snmp_trace("  SNMP: TRAP messagen"); break;
  545.     case SNMP_MSG_GETBULK:
  546.      snmp_trace("  SNMP: GETBULK request, non-rep=%d, max_rep=%dn",
  547. pdu->errstat, pdu->errindex); break;
  548.     case SNMP_MSG_INFORM:
  549.      snmp_trace("  SNMP: INFORM messagen"); break;
  550.     case SNMP_MSG_TRAP2:
  551.      snmp_trace("  SNMP: TRAP2 messagen"); break;
  552.     case SNMP_MSG_REPORT:
  553.      snmp_trace("  SNMP: REPORT messagen"); break;
  554.     }
  555.      
  556.     for ( var_ptr = pdu->variables ;
  557.         var_ptr != NULL ; var_ptr=var_ptr->next_variable )
  558.     {
  559.                 sprint_objid (c_oid, var_ptr->name, var_ptr->name_length);
  560.                 snmp_trace("    -- %sn", c_oid);
  561.     }
  562. }
  563.      return 1;
  564.     }
  565.     return 0; /* XXX: does it matter what the return value is? */
  566. }
  568. /*******************************************************************-o-******
  569.  * snmp_input
  570.  *
  571.  * Parameters:
  572.  *  op
  573.  * *session
  574.  *  requid
  575.  * *pdu
  576.  * *magic
  577.  *      
  578.  * Returns:
  579.  * 1 On success -OR-
  580.  * Passes through Return from alarmGetResponse() when 
  581.  *      USING_V2PARTY_ALARM_MODULE is defined.
  582.  *
  583.  * Call-back function to manage responses to traps (informs) and alarms.
  584.  * Not used by the agent to process other Response PDUs.
  585.  */
  586. int
  587. snmp_input(int op,
  588.    struct snmp_session *session,
  589.    int reqid,
  590.    struct snmp_pdu *pdu,
  591.    void *magic)
  592. {
  593.     struct get_req_state *state = (struct get_req_state *)magic;
  594.     
  595.     if (op == RECEIVED_MESSAGE) {
  596. if (pdu->command == SNMP_MSG_GET) {
  597.     if (state->type == EVENT_GET_REQ) {
  598. /* this is just the ack to our inform pdu */
  599. return 1;
  600.     }
  601. }
  602.     }
  603.     else if (op == TIMED_OUT) {
  604. if (state->type == ALARM_GET_REQ) {
  605. /* Need a mechanism to replace obsolete SNMPv2p alarm */
  606. }
  607.     }
  608.     return 1;
  610. }  /* end snmp_input() */