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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 代理服务器 > 查看源码
snmp_api.c
资源名称：squid-2.2.devel3-src.tar.gz　[点击查看]
上传用户：liugui
上传日期：2007-01-04
资源大小：822k
文件大小：25k
源码类别：

代理服务器

开发平台：

Unix_Linux

snmp_api.c：源码内容
  3. /**********************************************************************
  4.  *
  5.  *           Copyright 1997 by Carnegie Mellon University
  6.  * 
  7.  *                       All Rights Reserved
  8.  * 
  9.  * Permission to use, copy, modify, and distribute this software and its
  10.  * documentation for any purpose and without fee is hereby granted,
  11.  * provided that the above copyright notice appear in all copies and that
  12.  * both that copyright notice and this permission notice appear in
  13.  * supporting documentation, and that the name of CMU not be
  14.  * used in advertising or publicity pertaining to distribution of the
  15.  * software without specific, written prior permission.
  16.  * 
  17.  * CMU DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  18.  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  19.  * CMU BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  20.  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  21.  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  22.  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  23.  * SOFTWARE.
  24.  * 
  25.  **********************************************************************/
  27. #include "config.h"
  29. #include <stdio.h>
  31. #if HAVE_UNISTD_H
  32. #include <unistd.h>
  33. #endif
  34. #if HAVE_STDLIB_H
  35. #include <stdlib.h>
  36. #endif
  37. #if HAVE_SYS_TYPES_H
  38. #include <sys/types.h>
  39. #endif
  40. #if HAVE_CTYPE_H
  41. #include <ctype.h>
  42. #endif
  43. #if HAVE_GNUMALLOC_H
  44. #include <gnumalloc.h>
  45. #elif HAVE_MALLOC_H && !defined(_SQUID_FREEBSD_) && !defined(_SQUID_NEXT_)
  46. #include <malloc.h>
  47. #endif
  48. #if HAVE_MEMORY_H
  49. #include <memory.h>
  50. #endif
  51. #ifdef HAVE_STRING_H
  52. #include <string.h>
  53. #endif
  54. #ifdef HAVE_STRINGS_H
  55. #include <strings.h>
  56. #endif
  57. #if HAVE_BSTRING_H
  58. #include <bstring.h>
  59. #endif
  60. #if HAVE_SYS_SOCKET_H
  61. #include <sys/socket.h>
  62. #endif
  63. #if HAVE_NETINET_IN_H
  64. #include <netinet/in.h>
  65. #endif
  66. #if HAVE_ARPA_INET_H
  67. #include <arpa/inet.h>
  68. #endif
  69. #if HAVE_SYS_TIME_H
  70. #include <sys/time.h>
  71. #endif
  72. #if HAVE_NETDB_H
  73. #include <netdb.h>
  74. #endif
  76. #include "asn1.h"
  77. #include "snmp.h"
  79. #include "snmp-internal.h"
  80. #include "snmp_impl.h"
  81. #include "snmp_session.h"
  82. #if 0
  83. #include "mibii.h"
  84. #include "snmp_dump.h"
  85. #endif
  86. #include "snmp_error.h"
  87. #include "snmp_vars.h"
  88. #include "snmp_pdu.h"
  89. #include "snmp_msg.h"
  91. #include "snmp_api.h"
  92. #if 0
  93. #include "snmp_client.h"
  94. #endif
  95. #include "snmp_api_error.h"
  96. #include "snmp_api_util.h"
  98. #include "util.h"
  100. extern int snmp_errno;
  103. /*#define DEBUG_API 1 */
  105. /*
  106.  * RFC 1906: Transport Mappings for SNMPv2
  107.  */
  110. oid default_enterprise[] =
  111. {1, 3, 6, 1, 4, 1, 3, 1, 1}; /* enterprises.cmu.systems.cmuSNMP */
  113. #define DEFAULT_COMMUNITY   "public"
  114. #define DEFAULT_RETRIES     4
  115. #define DEFAULT_TIMEOUT     1000000L
  116. #define DEFAULT_REMPORT     SNMP_PORT
  117. #define DEFAULT_ENTERPRISE  default_enterprise
  118. #define DEFAULT_TIME     0
  120. extern int snmp_errno;
  123. struct session_list *Sessions = NULL;
  125. #if 0
  126. /*
  127.  * Get initial request ID for all transactions.
  128.  */
  129. static int Reqid = 0;
  131. static void 
  132. init_snmp(void)
  133. {
  134.     struct timeval tv;
  136.     gettimeofday(&tv, (struct timezone *) 0);
  137.     squid_srandom(tv.tv_sec ^ tv.tv_usec);
  138.     Reqid = squid_random();
  139. }
  142. /*
  143.  * Free each element in the input request list.
  144.  */
  145. static void 
  146. free_request_list(rp)
  147.      struct request_list *rp;
  148. {
  149.     struct request_list *orp;
  151.     while (rp) {
  152. orp = rp;
  153. rp = rp->next_request;
  154. if (orp->pdu != NULL)
  155.     snmp_free_pdu(orp->pdu);
  156. xfree((char *) orp);
  157.     }
  158. }
  160. #endif
  162. /**********************************************************************/
  164. /*
  165.  * Sets up the session with the snmp_session information provided
  166.  * by the user.  Then opens and binds the necessary UDP port.
  167.  * A handle to the created session is returned (this is different than
  168.  * the pointer passed to snmp_open()).  On any error, NULL is returned
  169.  * and snmp_errno is set to the appropriate error code.
  170.  */
  171. #if 0
  172. struct snmp_session *
  173. snmp_open(struct snmp_session *session)
  174. {
  175.     struct session_list *slp;
  176.     struct snmp_internal_session *isp;
  177.     u_char *cp;
  178.     int sd;
  179.     u_int addr;
  180.     struct sockaddr_in me;
  181.     struct hostent *hp;
  182.     struct servent *servp;
  184.     if (Reqid == 0)
  185. init_snmp();
  187.     /* Copy session structure and link into list */
  188.     slp = (struct session_list *) xmalloc(sizeof(struct session_list));
  189.     if (slp == NULL) {
  190. snmp_set_api_error(SNMPERR_OS_ERR);
  191. return (NULL);
  192.     }
  193.     /* Internal session */
  194.     isp = (struct snmp_internal_session *) xmalloc(sizeof(struct snmp_internal_session));
  195.     if (isp == NULL) {
  196. xfree(slp);
  197. snmp_set_api_error(SNMPERR_OS_ERR);
  198. return (NULL);
  199.     }
  200.     slp->internal = isp;
  201.     memset((char *) isp, '', sizeof(struct snmp_internal_session));
  202.     slp->internal->sd = -1; /* mark it not set */
  204.     /* The actual session */
  205.     slp->session = (struct snmp_session *) xmalloc(sizeof(struct snmp_session));
  206.     if (slp->session == NULL) {
  207. xfree(isp);
  208. xfree(slp);
  209. snmp_set_api_error(SNMPERR_OS_ERR);
  210. return (NULL);
  211.     }
  212.     xmemcpy((char *) slp->session, (char *) session, sizeof(struct snmp_session));
  213.     session = slp->session;
  214.     /* now link it in. */
  215.     slp->next = Sessions;
  216.     Sessions = slp;
  218.     /*
  219.      * session now points to the new structure that still contains pointers to
  220.      * data allocated elsewhere.  Some of this data is copied to space malloc'd
  221.      * here, and the pointer replaced with the new one.
  222.      */
  224.     if (session->peername != NULL) {
  225. cp = (u_char *) xmalloc((unsigned) strlen(session->peername) + 1);
  226. if (cp == NULL) {
  227.     xfree(slp->session);
  228.     xfree(isp);
  229.     xfree(slp);
  230.     snmp_set_api_error(SNMPERR_OS_ERR);
  231.     return (NULL);
  232. }
  233. strcpy((char *) cp, session->peername);
  234. session->peername = (char *) cp;
  235.     }
  236.     /* Fill in defaults if necessary */
  237.     if (session->community_len != SNMP_DEFAULT_COMMUNITY_LEN) {
  238. cp = (u_char *) xmalloc((unsigned) session->community_len);
  239. if (cp)
  240.     xmemcpy((char *) cp, (char *) session->community, session->community_len);
  241.     } else {
  242. session->community_len = strlen(DEFAULT_COMMUNITY);
  243. cp = (u_char *) xmalloc((unsigned) session->community_len);
  244. if (cp)
  245.     xmemcpy((char *) cp, (char *) DEFAULT_COMMUNITY,
  246. session->community_len);
  247.     }
  248.     if (cp == NULL) {
  249. xfree(session->peername);
  250. xfree(slp->session);
  251. xfree(isp);
  252. xfree(slp);
  253. snmp_set_api_error(SNMPERR_OS_ERR);
  254. return (NULL);
  255.     }
  256.     session->community = cp; /* replace pointer with pointer to new data */
  258.     if (session->retries == SNMP_DEFAULT_RETRIES)
  259. session->retries = DEFAULT_RETRIES;
  260.     if (session->timeout == SNMP_DEFAULT_TIMEOUT)
  261. session->timeout = DEFAULT_TIMEOUT;
  262.     isp->requests = NULL;
  264.     /* Set up connections */
  265.     sd = socket(AF_INET, SOCK_DGRAM, 0);
  266.     if (sd < 0) {
  267. perror("socket");
  268. snmp_set_api_error(SNMPERR_OS_ERR);
  269. if (!snmp_close(session)) {
  270.     snmplib_debug(5, "Couldn't abort session: %s. Exitingn",
  271. api_errstring(snmp_errno));
  272.     exit(1);
  273. }
  274. return (NULL);
  275.     }
  276. #ifdef SO_BSDCOMPAT
  277.     /* Patch for Linux.  Without this, UDP packets that fail get an ICMP
  278.      * response.  Linux turns the failed ICMP response into an error message
  279.      * and return value, unlike all other OS's.
  280.      */
  281.     {
  282. int one = 1;
  283. setsockopt(sd, SOL_SOCKET, SO_BSDCOMPAT, &one, sizeof(one));
  284.     }
  285. #endif /* SO_BSDCOMPAT */
  287.     isp->sd = sd;
  288.     if (session->peername != SNMP_DEFAULT_PEERNAME) {
  289. if ((addr = inet_addr(session->peername)) != -1) {
  290.     xmemcpy((char *) &isp->addr.sin_addr, (char *) &addr,
  291. sizeof(isp->addr.sin_addr));
  292. } else {
  293.     hp = gethostbyname(session->peername);
  294.     if (hp == NULL) {
  295. snmplib_debug(3, "unknown host: %sn", session->peername);
  296. snmp_errno = SNMPERR_BAD_ADDRESS;
  297. if (!snmp_close(session)) {
  298.     snmplib_debug(3, "Couldn't abort session: %s. Exitingn",
  299. api_errstring(snmp_errno));
  300.     exit(2);
  301. }
  302. return (NULL);
  303.     } else {
  304. xmemcpy((char *) &isp->addr.sin_addr, (char *) hp->h_addr,
  305.     hp->h_length);
  306.     }
  307. }
  309. isp->addr.sin_family = AF_INET;
  310. if (session->remote_port == SNMP_DEFAULT_REMPORT) {
  311.     servp = getservbyname("snmp", "udp");
  312.     if (servp != NULL) {
  313. isp->addr.sin_port = servp->s_port;
  314.     } else {
  315. isp->addr.sin_port = htons(SNMP_PORT);
  316.     }
  317. } else {
  318.     isp->addr.sin_port = htons(session->remote_port);
  319. }
  320.     } else {
  321. isp->addr.sin_addr.s_addr = SNMP_DEFAULT_ADDRESS;
  322.     }
  324.     memset(&me, '', sizeof(me));
  325.     me.sin_family = AF_INET;
  326.     me.sin_addr.s_addr = INADDR_ANY;
  327.     me.sin_port = htons(session->local_port);
  328.     if (bind(sd, (struct sockaddr *) &me, sizeof(me)) != 0) {
  329. perror("bind");
  330. snmp_errno = SNMPERR_BAD_LOCPORT;
  331. if (!snmp_close(session)) {
  332.     snmplib_debug(3, "Couldn't abort session: %s. Exitingn",
  333. api_errstring(snmp_errno));
  334.     exit(3);
  335. }
  336. return (NULL);
  337.     }
  338.     return (session);
  339. }
  342. /*
  343.  * Close the input session.  Frees all data allocated for the session,
  344.  * dequeues any pending requests, and closes any sockets allocated for
  345.  * the session.  Returns 0 on error, 1 otherwise.
  346.  */
  347. int 
  348. snmp_close(struct snmp_session *session)
  349. {
  350.     struct session_list *slp = NULL, *oslp = NULL;
  352.     if (Sessions->session == session) { /* If first entry */
  353. slp = Sessions;
  354. Sessions = slp->next;
  355.     } else {
  356. for (slp = Sessions; slp; slp = slp->next) {
  357.     if (slp->session == session) {
  358. if (oslp) /* if we found entry that points here */
  359.     oslp->next = slp->next; /* link around this entry */
  360. break;
  361.     }
  362.     oslp = slp;
  363. }
  364.     }
  366.     /* If we found the session, free all data associated with it */
  367.     if (slp) {
  368. if (slp->session->community != NULL)
  369.     xfree((char *) slp->session->community);
  370. if (slp->session->peername != NULL)
  371.     xfree((char *) slp->session->peername);
  372. xfree((char *) slp->session);
  373. if (slp->internal->sd != -1)
  374.     close(slp->internal->sd);
  375. free_request_list(slp->internal->requests);
  376. xfree((char *) slp->internal);
  377. xfree((char *) slp);
  378.     } else {
  379. snmp_errno = SNMPERR_BAD_SESSION;
  380. return (0);
  381.     }
  382.     return (1);
  383. }
  384. #endif
  386. /*
  387.  * Takes a session and a pdu and serializes the ASN PDU into the area
  388.  * pointed to by packet.  out_length is the size of the data area available.
  389.  * Returns the length of the encoded packet in out_length.  If an error
  390.  * occurs, -1 is returned.  If all goes well, 0 is returned.
  391.  */
  392. int
  393. snmp_build(session, pdu, packet, out_length)
  394.      struct snmp_session *session;
  395.      struct snmp_pdu *pdu;
  396.      u_char *packet;
  397.      int *out_length;
  398. {
  399.     u_char *bufp;
  401.     bufp = snmp_msg_Encode(packet, out_length,
  402. session->community, session->community_len,
  403. session->Version,
  404. pdu);
  405.     snmplib_debug(8, "LIBSNMP: snmp_build():  Packet len %d (requid %d)n",
  406. *out_length, pdu->reqid);
  408.     if (bufp == NULL)
  409. return (-1);
  411.     return (0);
  412. }
  414. /*
  415.  * Parses the packet recieved on the input session, and places the data into
  416.  * the input pdu.  length is the length of the input packet.  If any errors
  417.  * are encountered, NULL is returned.  If not, the community is.
  418.  */
  419. u_char *
  420. snmp_parse(struct snmp_session * session,
  421.     struct snmp_pdu * pdu,
  422.     u_char * data,
  423.     int length)
  424. {
  425.     u_char Community[128];
  426.     u_char *bufp;
  427.     int CommunityLen = 128;
  429.     /* Decode the entire message. */
  430.     data = snmp_msg_Decode(data, &length,
  431. Community, &CommunityLen,
  432. &session->Version, pdu);
  433.     if (data == NULL)
  434. return (NULL);
  436.     bufp = (u_char *) xmalloc(CommunityLen + 1);
  437.     if (bufp == NULL)
  438. return (NULL);
  440.     strcpy((char *) bufp, (char *) Community);
  441.     return (bufp);
  442. }
  444. /*
  445.  * Sends the input pdu on the session after calling snmp_build to create
  446.  * a serialized packet.  If necessary, set some of the pdu data from the
  447.  * session defaults.  Add a request corresponding to this pdu to the list
  448.  * of outstanding requests on this session, then send the pdu.
  449.  * Returns the request id of the generated packet if applicable, otherwise 1.
  450.  * On any error, 0 is returned.
  451.  * The pdu is freed by snmp_send() unless a failure occured.
  452.  */
  453. #if 0
  454. int 
  455. snmp_send(struct snmp_session *session, struct snmp_pdu *pdu)
  456. {
  457.     struct session_list *slp;
  458.     struct snmp_internal_session *isp = NULL;
  459.     u_char packet[PACKET_LENGTH];
  460.     int length = PACKET_LENGTH;
  461.     struct request_list *rp;
  462.     struct timeval tv;
  464.     if (Reqid == 0)
  465. init_snmp();
  467.     for (slp = Sessions; slp; slp = slp->next) {
  468. if (slp->session == session) {
  469.     isp = slp->internal;
  470.     break;
  471. }
  472.     }
  473.     if (isp == NULL) {
  474. snmp_errno = SNMPERR_BAD_SESSION;
  475. return 0;
  476.     }
  477.     if (pdu->command == SNMP_PDU_GET ||
  478. pdu->command == SNMP_PDU_GETNEXT ||
  479. pdu->command == SNMP_PDU_RESPONSE ||
  480. pdu->command == SNMP_PDU_SET) {
  482. if (pdu->reqid == SNMP_DEFAULT_REQID)
  483.     pdu->reqid = ++Reqid;
  484. if (pdu->errstat == SNMP_DEFAULT_ERRSTAT)
  485.     pdu->errstat = 0;
  486. if (pdu->errindex == SNMP_DEFAULT_ERRINDEX)
  487.     pdu->errindex = 0;
  489.     } else if (pdu->command == SNMP_PDU_INFORM ||
  490.     pdu->command == SNMP_PDU_GETBULK ||
  491. pdu->command == SNMP_PDU_V2TRAP) {
  493. if (session->Version != SNMP_VERSION_2) {
  494.     snmplib_debug(3, "Cant send SNMPv2 PDU's in SNMP message.n");
  495.     snmp_errno = SNMPERR_GENERR; /* Fix this XXXXX */
  496.     return 0;
  497. }
  498. if (pdu->reqid == SNMP_DEFAULT_REQID)
  499.     pdu->reqid = ++Reqid;
  500. if (pdu->errstat == SNMP_DEFAULT_ERRSTAT)
  501.     pdu->errstat = 0;
  502. if (pdu->errindex == SNMP_DEFAULT_ERRINDEX)
  503.     pdu->errindex = 0;
  505.     } else {
  506. /* fill in trap defaults */
  507. pdu->reqid = 1; /* give a bogus non-error reqid for traps */
  508. if (pdu->enterprise_length == SNMP_DEFAULT_ENTERPRISE_LENGTH) {
  509.     pdu->enterprise = (oid *) xmalloc(sizeof(DEFAULT_ENTERPRISE));
  510.     xmemcpy((char *) pdu->enterprise, (char *) DEFAULT_ENTERPRISE,
  511. sizeof(DEFAULT_ENTERPRISE));
  512.     pdu->enterprise_length = sizeof(DEFAULT_ENTERPRISE) / sizeof(oid);
  513. }
  514. if (pdu->time == SNMP_DEFAULT_TIME)
  515.     pdu->time = DEFAULT_TIME;
  516.     }
  518.     if (pdu->address.sin_addr.s_addr == SNMP_DEFAULT_ADDRESS) {
  519. if (isp->addr.sin_addr.s_addr != SNMP_DEFAULT_ADDRESS) {
  520.     xmemcpy((char *) &pdu->address, (char *) &isp->addr,
  521. sizeof(pdu->address));
  522. } else {
  523.     snmplib_debug(3, "No remote IP address specifiedn");
  524.     snmp_errno = SNMPERR_BAD_ADDRESS;
  525.     return 0;
  526. }
  527.     }
  528.     if (snmp_build(session, pdu, packet, &length) < 0) {
  529. snmplib_debug(3, "Error building packetn");
  530. snmp_errno = SNMPERR_GENERR;
  531. return 0;
  532.     }
  533.     snmp_dump(packet, length, "sending", pdu->address.sin_addr);
  535.     gettimeofday(&tv, (struct timezone *) 0);
  536.     if (sendto(isp->sd, (char *) packet, length, 0,
  537.     (struct sockaddr *) &pdu->address, sizeof(pdu->address)) < 0) {
  538. perror("sendto");
  539. snmp_errno = SNMPERR_GENERR;
  540. return 0;
  541.     }
  542.     snmplib_debug(6, "LIBSNMP:  Sent PDU %s, Reqid %dn",
  543. snmp_pdu_type(pdu), pdu->reqid);
  545.     if (pdu->command == SNMP_PDU_GET ||
  546. pdu->command == SNMP_PDU_GETNEXT ||
  547. pdu->command == SNMP_PDU_SET ||
  548. pdu->command == SNMP_PDU_GETBULK ||
  549. pdu->command == SNMP_PDU_INFORM) {
  551. snmplib_debug(6, "LIBSNMP:  Setting up to recieve a response for reqid %dn",
  552.     pdu->reqid);
  554. /* set up to expect a response */
  555. rp = (struct request_list *) xmalloc(sizeof(struct request_list));
  556. rp->next_request = isp->requests;
  557. isp->requests = rp;
  559. rp->pdu = pdu;
  560. rp->request_id = pdu->reqid;
  562. rp->retries = 1;
  563. rp->timeout = session->timeout;
  564. rp->time = tv;
  565. tv.tv_usec += rp->timeout;
  566. tv.tv_sec += tv.tv_usec / 1000000L;
  567. tv.tv_usec %= 1000000L;
  568. rp->expire = tv;
  569.     }
  570.     return (pdu->reqid);
  571. }
  573. /*
  574.  * Checks to see if any of the fd's set in the fdset belong to
  575.  * snmp.  Each socket with it's fd set has a packet read from it
  576.  * and snmp_parse is called on the packet received.  The resulting pdu
  577.  * is passed to the callback routine for that session.  If the callback
  578.  * routine returns successfully, the pdu and it's request are deleted.
  579.  */
  580. void
  581. snmp_read(fdset)
  582.      fd_set *fdset;
  583. {
  584.     struct session_list *slp;
  585.     struct snmp_session *sp;
  586.     struct snmp_internal_session *isp;
  587.     u_char packet[PACKET_LENGTH];
  588.     struct sockaddr_in from;
  589.     int length, fromlength;
  590.     struct snmp_pdu *pdu;
  591.     struct request_list *rp, *orp;
  592.     u_char *bufp;
  594.     for (slp = Sessions; slp; slp = slp->next) {
  595. if (FD_ISSET(slp->internal->sd, fdset)) {
  596.     sp = slp->session;
  597.     isp = slp->internal;
  598.     fromlength = sizeof from;
  599.     length = recvfrom(isp->sd, (char *) packet,
  600. PACKET_LENGTH, 0, (struct sockaddr *) &from,
  601. &fromlength);
  602.     if (length == -1)
  603. perror("recvfrom");
  605.     snmp_dump(packet, length, "received", from.sin_addr);
  607.     pdu = snmp_pdu_create(0);
  608.     pdu->address = from;
  609.     pdu->reqid = 0;
  611.     /* Parse the incoming packet */
  612.     bufp = snmp_parse(sp, pdu, packet, length);
  613.     if (bufp == NULL) {
  614. snmplib_debug(3, "Mangled packetn");
  615. snmp_free_pdu(pdu);
  616. return;
  617.     }
  618.     if (sp->community)
  619. xfree(sp->community);
  620.     sp->community = bufp;
  621.     sp->community_len = strlen((char *) bufp);
  623.     snmplib_debug(6, "LIBSNMP:  Read PDU %s, ReqId %dn", snmp_pdu_type(pdu), pdu->reqid);
  625.     if (pdu->command == SNMP_PDU_RESPONSE) {
  626. for (rp = isp->requests; rp; rp = rp->next_request) {
  627.     if (rp->request_id == pdu->reqid) {
  628. snmplib_debug(6, "LIBSNMP:  ReqId %d:  Calling callbackn", pdu->reqid);
  629. if (sp->callback(RECEIVED_MESSAGE, sp,
  630. pdu->reqid, pdu,
  631. sp->callback_magic) == 1) {
  632.     /* successful, so delete request */
  633.     snmplib_debug(6, "LIBSNMP:  ReqId %d:  Success.  Removing ReqId.n", pdu->reqid);
  634.     orp = rp;
  635.     if (isp->requests == orp) {
  636. /* first in list */
  637. isp->requests = orp->next_request;
  638.     } else {
  639. for (rp = isp->requests; rp; rp = rp->next_request) {
  640.     if (rp->next_request == orp) {
  641. /* link around it */
  642. rp->next_request = orp->next_request;
  643. break;
  644.     }
  645. }
  646.     }
  647.     snmp_free_pdu(orp->pdu);
  648.     xfree((char *) orp);
  649.     /* there shouldn't be another req with the same reqid */
  650.     break;
  651. }
  652.     }
  653. }
  654.     } else if (pdu->command == SNMP_PDU_GET ||
  655.     pdu->command == SNMP_PDU_GETNEXT ||
  656.     pdu->command == TRP_REQ_MSG ||
  657.     pdu->command == SNMP_PDU_SET ||
  658.     pdu->command == SNMP_PDU_GETBULK ||
  659.     pdu->command == SNMP_PDU_INFORM ||
  660. pdu->command == SNMP_PDU_V2TRAP) {
  661. sp->callback(RECEIVED_MESSAGE, sp, pdu->reqid,
  662.     pdu, sp->callback_magic);
  663.     }
  664.     snmp_free_pdu(pdu);
  665. }
  666.     }
  667. }
  669. /*
  670.  * Returns info about what snmp requires from a select statement.
  671.  * numfds is the number of fds in the list that are significant.
  672.  * All file descriptors opened for SNMP are OR'd into the fdset.
  673.  * If activity occurs on any of these file descriptors, snmp_read
  674.  * should be called with that file descriptor set
  675.  *
  676.  * The timeout is the latest time that SNMP can wait for a timeout.  The
  677.  * select should be done with the minimum time between timeout and any other
  678.  * timeouts necessary.  This should be checked upon each invocation of select.
  679.  * If a timeout is received, snmp_timeout should be called to check if the
  680.  * timeout was for SNMP.  (snmp_timeout is idempotent)
  681.  *
  682.  * Block is 1 if the select is requested to block indefinitely, rather than time out.
  683.  * If block is input as 1, the timeout value will be treated as undefined, but it must
  684.  * be available for setting in snmp_select_info.  On return, if block is true, the value
  685.  * of timeout will be undefined.
  686.  *
  687.  * snmp_select_info returns the number of open sockets.  (i.e. The number of sessions open)
  688.  */
  689. int
  690. snmp_select_info(numfds, fdset, timeout, block)
  691.      int *numfds;
  692.      fd_set *fdset;
  693.      struct timeval *timeout;
  694.      int *block; /* should the select block until input arrives (i.e. no input) */
  695. {
  696.     struct session_list *slp;
  697.     struct snmp_internal_session *isp;
  698.     struct request_list *rp;
  699.     struct timeval now, earliest;
  700.     int active = 0, requests = 0;
  702.     timerclear(&earliest);
  703.     /*
  704.      * For each request outstanding, add it's socket to the fdset,
  705.      * and if it is the earliest timeout to expire, mark it as lowest.
  706.      */
  707.     for (slp = Sessions; slp; slp = slp->next) {
  709. active++;
  710. isp = slp->internal;
  711. if ((isp->sd + 1) > *numfds)
  712.     *numfds = (isp->sd + 1);
  713. FD_SET(isp->sd, fdset);
  714. snmplib_debug(6, "LIBSNMP:  select():  Adding port %dn", isp->sd);
  715. if (isp->requests) {
  716.     /* found another session with outstanding requests */
  717.     requests++;
  718.     for (rp = isp->requests; rp; rp = rp->next_request) {
  719. if (!timerisset(&earliest) ||
  720.     timercmp(&rp->expire, &earliest, <))
  721.     earliest = rp->expire;
  722.     }
  723. }
  724.     }
  725.     snmplib_debug(6, "LIBSNMP:  Select Info:  %d active, %d requests pending.n",
  726. active, requests);
  728.     if (requests == 0) /* if none are active, skip arithmetic */
  729. return active;
  731.     /*
  732.      * Now find out how much time until the earliest timeout.  This
  733.      * transforms earliest from an absolute time into a delta time, the
  734.      * time left until the select should timeout.
  735.      */
  736.     gettimeofday(&now, (struct timezone *) 0);
  737.     earliest.tv_sec--; /* adjust time to make arithmetic easier */
  738.     earliest.tv_usec += 1000000L;
  739.     earliest.tv_sec -= now.tv_sec;
  740.     earliest.tv_usec -= now.tv_usec;
  741.     while (earliest.tv_usec >= 1000000L) {
  742. earliest.tv_usec -= 1000000L;
  743. earliest.tv_sec += 1;
  744.     }
  745.     if (earliest.tv_sec < 0) {
  746. earliest.tv_sec = 0;
  747. earliest.tv_usec = 0;
  748.     }
  749.     /* if it was blocking before or our delta time is less, reset timeout */
  750.     if (*block == 1 || timercmp(&earliest, timeout, <)) {
  751. *timeout = earliest;
  752. *block = 0;
  753.     }
  754.     return active;
  755. }
  757. /*
  758.  * snmp_timeout should be called whenever the timeout from snmp_select_info 
  759.  * expires, but it is idempotent, so snmp_timeout can be polled (probably a 
  760.  * cpu expensive proposition).  snmp_timeout checks to see if any of the 
  761.  * sessions have an outstanding request that has timed out.  If it finds one 
  762.  * (or more), and that pdu has more retries available, a new packet is formed
  763.  * from the pdu and is resent.  If there are no more retries available, the 
  764.  * callback for the session is used to alert the user of the timeout.
  765.  */
  766. void 
  767. snmp_timeout(void)
  768. {
  769.     struct session_list *slp;
  770.     struct snmp_session *sp;
  771.     struct snmp_internal_session *isp;
  772.     struct request_list *rp, *orp, *freeme = NULL;
  773.     struct timeval now;
  775.     gettimeofday(&now, (struct timezone *) 0);
  777.     /*
  778.      * For each request outstanding, check to see if it has expired.
  779.      */
  780.     for (slp = Sessions; slp; slp = slp->next) {
  781. sp = slp->session;
  782. isp = slp->internal;
  783. orp = NULL;
  784. snmplib_debug(6, "LIBSNMP:  Checking session %sn",
  785.     (sp->peername != NULL) ? sp->peername : "<NULL>");
  786. for (rp = isp->requests; rp; rp = rp->next_request) {
  787.     snmplib_debug(6, "LIBSNMP:  Checking session request %d, expire at %u, Retry %d/%dn",
  788. rp->request_id, rp->expire.tv_sec, rp->retries, sp->retries);
  790.     if (freeme != NULL) {
  791. /* frees rp's after the for loop goes on to the next_request */
  792. xfree((char *) freeme);
  793. freeme = NULL;
  794.     }
  795.     if (timercmp(&rp->expire, &now, <)) {
  797. snmplib_debug(6, "LIBSNMP:  Expired.n");
  799. /* this timer has expired */
  800. if (rp->retries >= sp->retries) {
  801.     /* No more chances, delete this entry */
  802.     sp->callback(TIMED_OUT, sp, rp->pdu->reqid,
  803. rp->pdu, sp->callback_magic);
  804.     if (orp == NULL) {
  805. isp->requests = rp->next_request;
  806.     } else {
  807. orp->next_request = rp->next_request;
  808.     }
  809.     snmp_free_pdu(rp->pdu);
  810.     freeme = rp;
  811.     continue; /* don't update orp below */
  812. } else {
  813.     u_char packet[PACKET_LENGTH];
  814.     int length = PACKET_LENGTH;
  815.     struct timeval tv;
  817.     snmplib_debug(6, "LIBSNMP:  Retransmitting.n");
  818.     /* retransmit this pdu */
  819.     rp->retries++;
  820.     rp->timeout <<= 1;
  821.     if (snmp_build(sp, rp->pdu, packet, &length) < 0) {
  822. snmplib_debug(3, "Error building packetn");
  823.     }
  824.     snmp_dump(packet, length,
  825. "sending", rp->pdu->address.sin_addr);
  827.     gettimeofday(&tv, (struct timezone *) 0);
  828.     if (sendto(isp->sd, (char *) packet, length, 0, (struct sockaddr *) &rp->pdu->address, sizeof(rp->pdu->address)) < 0) {
  829. perror("sendto");
  830.     }
  831.     rp->time = tv;
  832.     tv.tv_usec += rp->timeout;
  833.     tv.tv_sec += tv.tv_usec / 1000000L;
  834.     tv.tv_usec %= 1000000L;
  835.     rp->expire = tv;
  836. }
  837.     }
  838.     orp = rp;
  839. }
  840. if (freeme != NULL) {
  841.     xfree((char *) freeme);
  842.     freeme = NULL;
  843. }
  844.     }
  845. }
  848. /* Print some API stats */
  849. void 
  850. snmp_api_stats(void *outP)
  851. {
  852.     struct session_list *slp;
  853.     struct request_list *rp;
  854.     struct snmp_internal_session *isp;
  855.     FILE *out = (FILE *) outP;
  857.     int active = 0;
  858.     int requests = 0;
  859.     int count = 0;
  860.     int rcount = 0;
  862.     fprintf(out, "LIBSNMP: Session List Dumpn");
  863.     fprintf(out, "LIBSNMP: ----------------------------------------n");
  864.     for (slp = Sessions; slp; slp = slp->next) {
  866. isp = slp->internal;
  867. active++;
  868. count++;
  869. fprintf(out, "LIBSNMP: %2d: Host %sn", count,
  870.     (slp->session->peername == NULL) ? "NULL" : slp->session->peername);
  872. if (isp->requests) {
  873.     /* found another session with outstanding requests */
  874.     requests++;
  875.     rcount = 0;
  876.     for (rp = isp->requests; rp; rp = rp->next_request) {
  877. rcount++;
  878. {
  879.     struct hostent *hp;
  880.     hp = gethostbyaddr((char *) &(rp->pdu->address),
  881. sizeof(u_int), AF_INET);
  882.     fprintf(out, "LIBSNMP: %2d: ReqId %d (%s) (%s)n",
  883. rcount, rp->request_id, snmp_pdu_type(rp->pdu),
  884. (hp == NULL) ? "NULL" : hp->h_name);
  885. }
  886.     }
  887. }
  888. fprintf(out, "LIBSNMP: ----------------------------------------n");
  889.     }
  890.     fprintf(out, "LIBSNMP: Session List: %d active, %d have requests pending.n",
  891. active, requests);
  892. }
  893. #endif