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

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

SNMP编程

开发平台：

C/C++

snmp_agent.c：源码内容
  1. /*
  2.  * snmp_agent.c
  3.  *
  4.  * Simple Network Management Protocol (RFC 1067).
  5.  */
  6. /***********************************************************
  7. Copyright 1988, 1989 by Carnegie Mellon University
  9.                       All Rights Reserved
  11. Permission to use, copy, modify, and distribute this software and its 
  12. documentation for any purpose and without fee is hereby granted, 
  13. provided that the above copyright notice appear in all copies and that
  14. both that copyright notice and this permission notice appear in 
  15. supporting documentation, and that the name of CMU not be
  16. used in advertising or publicity pertaining to distribution of the
  17. software without specific, written prior permission.  
  19. CMU DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  20. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  21. CMU BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  22. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  23. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  24. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  25. SOFTWARE.
  26. ******************************************************************/
  28. #include <config.h>
  30. #include <sys/types.h>
  31. #ifdef HAVE_STDLIB_H
  32. #include <stdlib.h>
  33. #endif
  34. #if HAVE_UNISTD_H
  35. #include <unistd.h>
  36. #endif
  37. #if HAVE_STRING_H
  38. #include <string.h>
  39. #endif
  40. #if TIME_WITH_SYS_TIME
  41. # ifdef WIN32
  42. #  include <timeb.h>
  43. # else
  44. #  include <time.h>
  45. # endif
  46. # include <time.h>
  47. #else
  48. # if HAVE_SYS_TIME_H
  49. #  include <sys/time.h>
  50. # else
  51. #  include <time.h>
  52. # endif
  53. #endif
  54. #ifdef OS_VXWORKS
  55. #include <sys/times.h>
  56. #endif
  57. #if HAVE_SYS_SELECT_H
  58. #include <sys/select.h>
  59. #endif
  60. #if HAVE_NETINET_IN_H
  61. #include <netinet/in.h>
  62. #endif
  63. #include <errno.h>
  64. #if HAVE_WINSOCK_H
  65. #include <ip/socket.h>
  66. #endif
  68. #if HAVE_DMALLOC_H
  69. #include <dmalloc.h>
  70. #endif
  72. #include "asn1.h"
  73. #define SNMP_NEED_REQUEST_LIST
  74. #include "snmp_api.h"
  75. #include "snmp_impl.h"
  76. #include "snmp.h"
  77. #include "mib.h"
  78. #include "snmp_client.h"
  80. #include "snmp_vars.h"
  81. #include "snmpd.h"
  82. #include "mibgroup/struct.h"
  83. #include "mibgroup/util_funcs.h"
  84. #include "var_struct.h"
  85. #include "read_config.h"
  86. #include "snmp_logging.h"
  87. #include "snmp_debug.h"
  88. #include "mib_module_config.h"
  90. #include "default_store.h"
  91. #include "ds_agent.h"
  92. #include "snmp_agent.h"
  93. #include "agent_trap.h"
  95. static int snmp_vars_inc;
  97. static struct agent_snmp_session *agent_session_list = NULL;
  100. static void dump_var(oid *, size_t, int, void *, size_t);
  101. static int goodValue(u_char, size_t, u_char, size_t);
  102. static void setVariable(u_char *, u_char, size_t, u_char *, size_t);
  103. #ifdef AGENT_USE_STATIC
  104. static struct agent_snmp_session agent_static;
  105. #endif
  106. static void dump_var (
  107.     oid *var_name,
  108.     size_t var_name_len,
  109.     int statType,
  110.     void *statP,
  111.     size_t statLen)
  112. {
  113.     char buf [SPRINT_MAX_LEN];
  114.     struct variable_list temp_var;
  116.     temp_var.type = (unsigned char)statType;
  117.     temp_var.val.string = (u_char *)statP;
  118.     temp_var.val_len = statLen;
  119.     sprint_variable (buf, var_name, var_name_len, &temp_var);
  120.     snmp_trace("    >> %sn", buf);
  121. }
  124. int getNextSessID()
  125. {
  126.     static int SessionID = 0;
  128.     return ++SessionID;
  129. }
  131. int
  132. agent_check_and_process(int block) {
  133.   int numfds;
  134.   fd_set fdset;
  135.   struct timeval timeout, *tvp;
  136.   int count;
  137.   int fakeblock=0;
  138.   
  139.   tvp =  &timeout;
  140.   tvp->tv_sec  = 0;
  141.   tvp->tv_usec = 0;
  143.   numfds = 0;
  144.   FD_ZERO(&fdset);
  145.   snmp_select_info(&numfds, &fdset, tvp, &fakeblock);
  146.   if (block == 1 && fakeblock == 1)
  147.     tvp = NULL; /* block without timeout */
  148.   else if (block == 0) {
  149.       tvp->tv_sec = 0;
  150.       tvp->tv_usec = 0;
  151.   }
  153.   count = so_select(numfds, &fdset, 0, 0, tvp);
  155.   if (count > 0){
  156.     /* packets found, process them */
  157.     snmp_read(&fdset);
  158.   } else switch(count){
  159.     case 0:
  160.       snmp_timeout();
  161.       break;
  162.     case -1:
  163.       if (errno == EINTR){
  164.         return -1;
  165.       } else {
  166.         snmp_log_perror("select");
  167.       }
  168.       return -1;
  169.     default:
  170.       snmp_trace( "select returned %dn", count);
  171.       return -1;
  172.   }  /* endif -- count>0 */
  173.   return count;
  174. }
  177. /*
  178.  * The session is created using the "traditional API" routine snmp_open()
  179.  * so is linked into the global library Sessions list.  It also opens a
  180.  * socket that listens for incoming requests.
  181.  * 
  182.  *   The agent runs in an infinite loop (in the 'receive()' routine),
  183.  * which calls snmp_read() when such a request is received on this socket.
  184.  * This routine then traverses the library 'Sessions' list to identify the
  185.  * relevant session and eventually invokes '_sess_read'.
  186.  *   This then processes the incoming packet, calling the pre_parse, parse,
  187.  * post_parse and callback routines in turn.
  188.  */
  190. /* Global access to the primary session structure for this agent.
  191. for Index Allocation use initially. */
  192. struct snmp_session *main_session;
  194. int
  195. init_master_agent(int dest_port, 
  196.                   int (*pre_parse) (struct snmp_session *, struct soaddr),
  197.                   int (*post_parse) (struct snmp_session *, struct snmp_pdu *,int))
  198. {
  199.     struct snmp_session sess, *session;
  201.     if ( ds_get_boolean(DS_APPLICATION_ID, DS_AGENT_ROLE) != MASTER_AGENT )
  202. return 0; /* no error if ! MASTER_AGENT */
  204.     DEBUGMSGTL(("snmpd","installing master agent on port %dn", dest_port));
  206.     snmp_sess_init( &sess );
  207.     
  208.     sess.version = SNMP_DEFAULT_VERSION;
  209.     sess.peername = SNMP_DEFAULT_PEERNAME;
  210.     sess.community_len = SNMP_DEFAULT_COMMUNITY_LEN;
  211.      
  212.     sess.local_port = (unsigned char)dest_port;
  213.     sess.callback = handle_snmp_packet;
  214.     sess.authenticator = NULL;
  215.     sess.flags = ds_get_int(DS_APPLICATION_ID, DS_AGENT_FLAGS);
  216.     session = snmp_open_ex( &sess, pre_parse, 0, post_parse, 0, 0 );
  218.     if ( session == NULL ) {
  219.       /* diagnose snmp_open errors with the input struct snmp_session pointer */
  220. snmp_sess_perror("init_master_agent", &sess);
  221. return 1;
  222.     }
  223.     main_session = session;
  224. return 0;
  225. }
  227. struct agent_snmp_session  *
  228. init_agent_snmp_session( struct snmp_session *session, struct snmp_pdu *pdu )
  229. {
  230.     struct agent_snmp_session  *asp;
  231. #ifdef AGENT_USE_STATIC
  232. asp = &agent_static;
  233. memset (asp, 0, sizeof (struct agent_snmp_session));
  234. #else
  235.     asp = malloc( sizeof( struct agent_snmp_session ));
  236.     if ( asp == NULL )
  237. return NULL;
  238. #endif
  239.     asp->start = pdu->variables;
  240.     asp->end   = pdu->variables;
  241.     if ( asp->end != NULL )
  242. while ( asp->end->next_variable != NULL )
  243.     asp->end = asp->end->next_variable;
  244.     asp->session = session;
  245.     asp->pdu     = pdu;
  246.     asp->rw      = READ;
  247.     asp->exact   = TRUE;
  248.     asp->outstanding_requests = NULL;
  249.     asp->next    = NULL;
  250.     asp->mode    = RESERVE1;
  251.     asp->status  = SNMP_ERR_NOERROR;
  253.     return asp;
  254. }
  256. int
  257. count_varbinds( struct snmp_pdu *pdu )
  258. {
  259.   int count = 0;
  260.   struct variable_list *var_ptr;
  261.   
  262.   for ( var_ptr = pdu->variables ; var_ptr != NULL ;
  263.    var_ptr = var_ptr->next_variable )
  264. count++;
  266.   return count;
  267. }
  268. int
  269. handle_snmp_packet(int operation, struct snmp_session *session, int reqid,
  270.                    struct snmp_pdu *pdu, void *magic)
  271. {
  272.     struct agent_snmp_session  *asp;
  273. struct snmp_pdu *ptrPdu;
  274.     int status, allDone, i;
  275.     struct variable_list *var_ptr, *var_ptr2;
  277.     if ( magic == NULL ) {
  278. ptrPdu = snmp_clone_pdu(pdu);
  279. if (ptrPdu == NULL)
  280. /* return NULL;  by yangyuhua 2005-12-5*/
  281. return 0;
  282. asp = init_agent_snmp_session( session, ptrPdu);
  283. if (asp == NULL)
  284. {
  285. snmp_free_pdu (ptrPdu);
  286. return 0;
  287. }
  288. status = SNMP_ERR_NOERROR;
  289.     }
  290.     else {
  291. asp = (struct agent_snmp_session *)magic;
  292.         status =   asp->status;
  293.     }
  295.     if (asp->outstanding_requests != NULL)
  296. {
  297. snmp_free_pdu (asp->pdu);
  298. #ifndef AGENT_USE_STATIC
  299. free (asp);
  300. #endif
  301. return 1;
  302. }
  304.     if ( snmp_check_access(pdu) != 0) {
  305.         /* access control setup is incorrect */
  306. send_easy_trap(SNMP_TRAP_AUTHFAIL, 0);
  307.         if (asp->pdu->version != SNMP_VERSION_1 && asp->pdu->version != SNMP_VERSION_2c) {
  308.             asp->pdu->errstat = SNMP_ERR_AUTHORIZATIONERROR;
  309.             asp->pdu->command = SNMP_MSG_RESPONSE;
  310.             snmp_increment_statistic(STAT_SNMPOUTPKTS);
  311.             if (!snmp_send( asp->session, asp->pdu ))
  312.      snmp_free_pdu (asp->pdu);
  313. #ifndef AGENT_USE_STATIC
  314. free (asp);
  315. #endif
  316.             return 1;
  317.         } else {
  318.             /* drop the request */
  319. snmp_free_pdu (asp->pdu);
  320. #ifndef AGENT_USE_STATIC
  321.             free( asp );
  322. #endif
  323.             return 0;
  324.         }
  325.     }
  326.     switch (pdu->command) {
  327.     case SNMP_MSG_GET:
  328. if ( asp->mode != RESERVE1 )
  329.     break; /* Single pass */
  330.         snmp_increment_statistic(STAT_SNMPINGETREQUESTS);
  331. status = handle_next_pass( asp );
  332. asp->mode = RESERVE2;
  333. break;
  335.     case SNMP_MSG_GETNEXT:
  336. if ( asp->mode != RESERVE1 )
  337.     break; /* Single pass */
  338.         snmp_increment_statistic(STAT_SNMPINGETNEXTS);
  339. asp->exact   = FALSE;
  340. status = handle_next_pass( asp );
  341. asp->mode = RESERVE2;
  342. break;
  344.     case SNMP_MSG_GETBULK:
  345.     /*
  346.      * GETBULKS require multiple passes. The first pass handles the
  347.      * explicitly requested varbinds, and subsequent passes append
  348.      * to the existing var_op_list.  Each pass (after the first)
  349.      * uses the results of the preceeding pass as the input list
  350.      * (delimited by the start & end pointers.
  351.      * Processing is terminated if all entries in a pass are
  352.      * EndOfMib, or the maximum number of repetitions are made.
  353.      */
  354. if ( asp->mode == RESERVE1 ) {
  355.             snmp_increment_statistic(STAT_SNMPINGETREQUESTS);
  356.     asp->exact   = FALSE;
  357.     /*
  358.      * Limit max repetitions to something reasonable
  359.      * XXX: We should figure out what will fit somehow...
  360.      */
  361.     if ( asp->pdu->errindex > 100 )
  362.         asp->pdu->errindex = 100;
  363.     
  364.     status = handle_next_pass( asp ); /* First pass */
  365.     asp->mode = RESERVE2;
  366.     if ( status != SNMP_ERR_NOERROR )
  367.         break;
  368.     
  369.     while ( asp->pdu->errstat-- > 0 ) /* Skip non-repeaters */
  370.         asp->start = asp->start->next_variable;
  371.     asp->pdu->errindex--;           /* Handled first repetition */
  373.     if ( asp->outstanding_requests != NULL )
  374. {
  375. snmp_free_pdu (asp->pdu);
  376. #ifndef AGENT_USE_STATIC
  377. free (asp);
  378. #endif
  379. return 1;
  380. }
  381. }
  382. /*Added by sxf 11-29-2k
  383. * Before, when run snmpbulkget_d -v2c 192.2.2.54 public,
  384. * there is an access violation
  385. */
  386. if (pdu->variables == NULL)
  387. {
  388. snmp_free_pdu (asp->pdu);
  389. #ifndef AGENT_USE_STATIC
  390. free (asp);
  391. #endif
  392. return 1;
  393. }
  394. while ( asp->pdu->errindex-- > 0 ) { /* Process repeaters */
  395. /*
  396.  * Add new variable structures for the
  397.  * repeating elements, ready for the next pass.
  398.  * Also check that these are not all EndOfMib
  399.  */
  400.     allDone = TRUE; /* Check for some content */
  401.     for ( var_ptr = asp->start;
  402.   var_ptr != asp->end->next_variable;
  403.   var_ptr = var_ptr->next_variable ) {
  404. /* XXX: we don't know the size of the next
  405. OID, so assume the maximum length */
  406. if ( var_ptr->type != SNMP_ENDOFMIBVIEW )
  407. {
  408. var_ptr2 = snmp_add_null_var(asp->pdu, var_ptr->name, MAX_OID_LEN);
  409. for ( i=var_ptr->name_length ; i<MAX_OID_LEN ; i++)
  410.     var_ptr2->name[i] = 0;
  411. var_ptr2->name_length = var_ptr->name_length;
  413.     allDone = FALSE;
  414. }
  415.     }
  416.     if ( allDone )
  417. break;
  419.     asp->start = asp->end->next_variable;
  420.     while ( asp->end->next_variable != NULL )
  421. asp->end = asp->end->next_variable;
  422.     
  423.     status = handle_next_pass( asp );
  424.     if ( status != SNMP_ERR_NOERROR )
  425. break;
  426.     if ( asp->outstanding_requests != NULL )
  427. {
  428. snmp_free_pdu (asp->pdu);
  429. #ifndef AGENT_USE_STATIC
  430. free (asp);
  431. #endif
  432. return 1;
  433. }
  434. }
  435. break;
  437.     case SNMP_MSG_SET:
  438.          /*
  439.      * SETS require 3-4 passes through the var_op_list.  The first two
  440.      * passes verify that all types, lengths, and values are valid
  441.      * and may reserve resources and the third does the set and a
  442.      * fourth executes any actions.  Then the identical GET RESPONSE
  443.      * packet is returned.
  444.      * If either of the first two passes returns an error, another
  445.      * pass is made so that any reserved resources can be freed.
  446.      * If the third pass returns an error, another pass is made so that
  447.      * any changes can be reversed.
  448.      * If the fourth pass (or any of the error handling passes)
  449.      * return an error, we'd rather not know about it!
  450.      */
  451. if ( asp->mode == RESERVE1 ) {
  452.             snmp_increment_statistic(STAT_SNMPINSETREQUESTS);
  453.     asp->rw      = WRITE;
  455.     status = handle_next_pass( asp );
  457.     if ( status != SNMP_ERR_NOERROR )
  458.         asp->mode = ACTION_FREE;
  459.     else
  460.         asp->mode = RESERVE2;
  462.     if ( asp->outstanding_requests != NULL )
  463. {
  464. snmp_free_pdu (asp->pdu);
  465. #ifndef AGENT_USE_STATIC
  466. free (asp);
  467. #endif
  468. return 1;
  469. }
  470. }
  472. if ( asp->mode == RESERVE2 ) {
  473.     status = handle_next_pass( asp );
  475.     if ( status != SNMP_ERR_NOERROR )
  476.         asp->mode = ACTION_FREE;
  477.     else
  478.         asp->mode = ACTION;
  480.     if ( asp->outstanding_requests != NULL )
  481. {
  482. snmp_free_pdu (asp->pdu);
  483. #ifndef AGENT_USE_STATIC
  484. free (asp);
  485. #endif
  486.   return 1;
  487. }
  488. }
  490. if ( asp->mode == ACTION ) {
  491.     status = handle_next_pass( asp );
  493.     if ( status != SNMP_ERR_NOERROR )
  494.         asp->mode = UNDO;
  495.     else
  496.         asp->mode = COMMIT;
  498.     if ( asp->outstanding_requests != NULL )
  499. {
  500. snmp_free_pdu (asp->pdu);
  501. #ifndef AGENT_USE_STATIC
  502. free (asp);
  503. #endif
  504. return 1;
  505. }
  506. }
  508. if ( asp->mode == COMMIT ) {
  509.     status = handle_next_pass( asp );
  511.     if ( status != SNMP_ERR_NOERROR ) {
  512. status    = SNMP_ERR_COMMITFAILED;
  513.         asp->mode = FINISHED_FAILURE;
  514.     }
  515.     else
  516.         asp->mode = FINISHED_SUCCESS;
  518.     if ( asp->outstanding_requests != NULL )
  519. {
  520. snmp_free_pdu (asp->pdu);
  521. #ifndef AGENT_USE_STATIC
  522. free (asp);
  523. #endif
  524. return 1;
  525. }
  526. }
  528. if ( asp->mode == UNDO ) {
  529.     if (handle_next_pass( asp ) != SNMP_ERR_NOERROR )
  530. status = SNMP_ERR_UNDOFAILED;
  532.     asp->mode = FINISHED_FAILURE;
  533.     break;
  534. }
  536. if ( asp->mode == ACTION_FREE ) {
  537.     (void) handle_next_pass( asp );
  538.     break;
  539. }
  541. break;
  543.     case SNMP_MSG_RESPONSE:
  544.         snmp_increment_statistic(STAT_SNMPINGETRESPONSES);
  545. snmp_free_pdu (asp->pdu);
  546. #ifndef AGENT_USE_STATIC
  547. free( asp );
  548. #endif
  549. return 0;
  550.     case SNMP_MSG_TRAP:
  551.     case SNMP_MSG_TRAP2:
  552.         snmp_increment_statistic(STAT_SNMPINTRAPS);
  553. snmp_free_pdu (asp->pdu);
  554. #ifndef AGENT_USE_STATIC
  555. free( asp );
  556. #endif
  557. return 0;
  558.     default:
  559.         snmp_increment_statistic(STAT_SNMPINASNPARSEERRS);
  560. snmp_free_pdu (asp->pdu);
  561. #ifndef AGENT_USE_STATIC
  562. free( asp );
  563. #endif
  564. return 0;
  565.     }
  567.     if ( asp->outstanding_requests != NULL ) {
  568. asp->status = status;
  569. asp->next = agent_session_list;
  570. agent_session_list = asp;
  571. #ifdef AGENT_USE_STATIC
  572. #endif
  573.     }
  574.     else {
  575. /*
  576.  * May need to "dumb down" a SET error status for a
  577.  *  v1 query.  See RFC2576 - section 4.3
  578.  */
  579. if (( asp->pdu->command == SNMP_MSG_SET ) &&
  580.     ( asp->pdu->version == SNMP_VERSION_1 )) {
  581.     switch ( status ) {
  582. case SNMP_ERR_WRONGVALUE:
  583. case SNMP_ERR_WRONGENCODING:
  584. case SNMP_ERR_WRONGTYPE:
  585. case SNMP_ERR_WRONGLENGTH:
  586. case SNMP_ERR_INCONSISTENTVALUE:
  587. status = SNMP_ERR_BADVALUE;
  588. break;
  589. case SNMP_ERR_NOACCESS:
  590. case SNMP_ERR_NOTWRITABLE:
  591. case SNMP_ERR_NOCREATION:
  592. case SNMP_ERR_INCONSISTENTNAME:
  593. case SNMP_ERR_AUTHORIZATIONERROR:
  594. status = SNMP_ERR_NOSUCHNAME;
  595. break;
  596. case SNMP_ERR_RESOURCEUNAVAILABLE:
  597. case SNMP_ERR_COMMITFAILED:
  598. case SNMP_ERR_UNDOFAILED:
  599. status = SNMP_ERR_GENERR;
  600. break;
  601.     }
  602. }
  603. /*
  604.  * Similarly we may need to "dumb down" v2 exception
  605.  *  types to throw an error for a v1 query.
  606.  *  See RFC2576 - section 4.1.2.3
  607.  */
  608. if (( asp->pdu->command != SNMP_MSG_SET ) &&
  609.     ( asp->pdu->version == SNMP_VERSION_1 )) {
  610. for ( var_ptr = asp->pdu->variables, i=0 ;
  611. var_ptr != NULL ;
  612. var_ptr = var_ptr->next_variable, i++ ) {
  613.     switch ( var_ptr->type ) {
  614. case SNMP_NOSUCHOBJECT:
  615. case SNMP_NOSUCHINSTANCE:
  616. case SNMP_ENDOFMIBVIEW:
  617. case ASN_COUNTER64:
  618. status = SNMP_ERR_NOSUCHNAME;
  619. asp->pdu->errindex=i;
  620. break;
  621.     }
  622. }
  623. }
  624. if ( status == SNMP_ERR_NOERROR ) {
  625.     snmp_increment_statistic_by(
  626. (asp->pdu->command == SNMP_MSG_SET ?
  627. STAT_SNMPINTOTALSETVARS : STAT_SNMPINTOTALREQVARS ),
  628.      count_varbinds( asp->pdu ));
  629. }
  630. else {
  631. /*
  632.  * Use a copy of the original request
  633.  *   to report failures.
  634.  */
  635. /*
  636. * --sxf 2001-1-4
  637. */
  638. if (status == SNMP_ERR_NOSUCHNAME)
  639. snmp_increment_statistic (STAT_SNMPOUTNOSUCHNAMES);
  640. else if (status == SNMP_ERR_BADVALUE)
  641. snmp_increment_statistic (STAT_SNMPOUTBADVALUES);
  642. else if (status == SNMP_ERR_GENERR)
  643. snmp_increment_statistic (STAT_SNMPOUTGENERRS);
  644. else if (status == SNMP_ERR_NOTWRITABLE)
  645. snmp_increment_statistic (STAT_SNMPINREADONLYS);
  647.     i = asp->pdu->errindex;
  648.     snmp_free_pdu( asp->pdu );
  649.     asp->pdu = snmp_clone_pdu( pdu );/*find a problem by yangyuhua 2005-12-5 */
  650. if (asp->pdu == NULL)
  651. {
  652. free (asp);
  653. return 0;
  654. }
  655.     asp->pdu->errindex = i;
  656. }
  657. asp->pdu->command = SNMP_MSG_RESPONSE;
  658. asp->pdu->errstat = status;
  659. if (snmp_send( asp->session, asp->pdu ) == 0)
  660. {
  661. snmp_free_pdu (asp->pdu);
  662. }
  663. else
  664. {
  665. snmp_increment_statistic(STAT_SNMPOUTPKTS);
  666. snmp_increment_statistic(STAT_SNMPOUTGETRESPONSES);
  667. }
  668. #ifndef AGENT_USE_STATIC
  669. free( asp );
  670. #endif
  671.     }
  673.     return 1;
  674. }
  677. int
  678. handle_next_pass(struct agent_snmp_session  *asp)
  679. {
  680.     int status;
  681.     struct snmp_pdu *pdu = asp->pdu;
  682.     struct request_list *req_p, *next_req;
  685.         if ( asp->outstanding_requests != NULL )
  686.     return SNMP_ERR_NOERROR;
  688. status = handle_var_list( asp );
  689.         if ( asp->outstanding_requests != NULL ) {
  690.     if ( status == SNMP_ERR_NOERROR ) {
  691. /* Send out any subagent requests */
  692. for ( req_p = asp->outstanding_requests ;
  693. req_p != NULL ; req_p = req_p->next_request ) {
  695.     snmp_async_send( req_p->session,  req_p->pdu,
  696.       req_p->callback, req_p->cb_data );
  697. }
  698. asp->pdu = snmp_clone_pdu( pdu );
  699. if (asp->pdu == NULL)
  700. return SNMP_ERR_GENERR;
  701. asp->pdu->variables = pdu->variables;
  702. pdu->variables = NULL;
  703.     }
  704.     else {
  705.      /* discard outstanding requests */
  706. for ( req_p = asp->outstanding_requests ;
  707. req_p != NULL ; req_p = next_req ) {
  709. next_req = req_p->next_request;
  710. free( req_p );
  711. }
  712. asp->outstanding_requests = NULL;
  713.     }
  714. }
  715. return status;
  716. }
  719. int
  720. handle_var_list(struct agent_snmp_session  *asp)
  721. {
  722.     struct variable_list *varbind_ptr;
  723.     u_char  statType;
  724.     u_char *statP;
  725.     size_t  statLen;
  726.     u_short acl;
  727.     WriteMethod *write_method;
  728.     AddVarMethod *add_method;
  729.     int     noSuchObject = TRUE;
  730.     int     count, view;
  731.     
  732.     count = 0;
  733.     varbind_ptr = asp->start;
  734.     if ( !varbind_ptr ) {
  735. return SNMP_ERR_NOERROR;
  736.     }
  738. if (ds_get_boolean(DS_APPLICATION_ID, DS_AGENT_VERBOSE))
  739. snmp_log (LOG_DEBUG, "  SNMP: Responsen");
  740.     while (1) {
  741.     
  742. count++;
  743. statp_loop:
  745. statP = getStatPtr(  varbind_ptr->name,
  746.    &varbind_ptr->name_length,
  747.    &statType, &statLen, &acl,
  748.    asp->exact, &write_method, asp->pdu, &noSuchObject);
  749.     
  750.    
  751. if (statP == NULL && (asp->rw != WRITE || write_method == NULL)) {
  752.      varbind_ptr->val.integer   = NULL;
  753.      varbind_ptr->val_len = 0;
  754. if ( asp->exact ) {
  755.             if ( noSuchObject == TRUE ){
  756.         statType = SNMP_NOSUCHOBJECT;
  757.     } else {
  758.         statType = SNMP_NOSUCHINSTANCE;
  759.     }
  760. } else {
  761.             statType = SNMP_ENDOFMIBVIEW;
  762. }
  764. /* dump verbose info */
  765.     if (ds_get_boolean(DS_APPLICATION_ID, DS_AGENT_VERBOSE))
  766.         dump_var(varbind_ptr->name, varbind_ptr->name_length,
  767. statType, statP, 0);
  769. if (asp->pdu->version == SNMP_VERSION_1) {
  770.     asp->pdu->errstat = SNMP_ERR_NOSUCHNAME;
  771.     asp->pdu->errindex = count;
  772.     return SNMP_ERR_NOSUCHNAME;
  773. }
  774. else if (asp->rw == WRITE) {
  775.     asp->pdu->errstat =
  776. ( noSuchObject ? SNMP_ERR_NOTWRITABLE
  777. : SNMP_ERR_NOCREATION );
  778.     asp->pdu->errindex = count;
  779.     return asp->pdu->errstat;
  780. }
  781. else
  782.     varbind_ptr->type = statType;
  783.    
  785. }
  786.                 /* Delegated variables should be added to the
  787.                    relevant outgoing request */
  788.         else if ( IS_DELEGATED(statType)) {
  789.                 add_method = (AddVarMethod*)statP;
  790.                 statType = (unsigned char)(*add_method)( asp, varbind_ptr );
  791.         }
  792. /* GETNEXT/GETBULK should just skip inaccessible entries */
  793. else if ((view = in_a_view(varbind_ptr->name, &varbind_ptr->name_length,
  794.    asp->pdu, varbind_ptr->type))
  795.  && !asp->exact) {
  796. if (view != 5) send_easy_trap(SNMP_TRAP_AUTHFAIL, 0);
  797. goto statp_loop;
  798. }
  799. /* Other access problems are permanent */
  800. else if (( asp->rw == WRITE && !(acl & 2)) || view) {
  801.     if (asp->pdu->version == SNMP_VERSION_1 || asp->rw != WRITE) {
  802. if (ds_get_boolean(DS_APPLICATION_ID, DS_AGENT_VERBOSE))
  803.                   DEBUGMSGTL(("snmp_agent", "    >> noSuchName (read-only)n"));
  804. ERROR_MSG("read-only");
  805. statType = SNMP_ERR_NOSUCHNAME;
  806.     }
  807.     else {
  808. if (ds_get_boolean(DS_APPLICATION_ID, DS_AGENT_VERBOSE))
  809.                   DEBUGMSGTL(("snmp_agent", "    >> notWritablen"));
  810. ERROR_MSG("Not Writable");
  811. statType = SNMP_ERR_NOTWRITABLE;
  812.     }
  813.     asp->pdu->errstat = statType;
  814.     asp->pdu->errindex = count;
  815.     send_easy_trap(SNMP_TRAP_AUTHFAIL, 0);
  816.     return statType;
  817.         }
  818. else {
  819.             /* dump verbose info */
  820.     if (ds_get_boolean(DS_APPLICATION_ID, DS_AGENT_VERBOSE) && statP)
  821.         dump_var(varbind_ptr->name, varbind_ptr->name_length,
  822. statType, statP, statLen);
  824. /*  FINALLY we can act on SET requests ....*/
  825.     if ( asp->rw == WRITE ) {
  826.         if ( write_method != NULL ) {
  827.     statType = (unsigned char)(*write_method)(asp->mode,
  828.                                                varbind_ptr->val.string,
  829.                                                varbind_ptr->type,
  830.                                                varbind_ptr->val_len, statP,
  831.                                                varbind_ptr->name,
  832.                                                varbind_ptr->name_length);
  833.                     if (statType != SNMP_ERR_NOERROR) {
  834.                       asp->pdu->errstat = statType;
  835.                       asp->pdu->errindex = count;
  836.                       return statType;
  837.                     }
  838. }
  839. else {
  840.                     if (!goodValue(varbind_ptr->type, varbind_ptr->val_len,
  841.                                     statType, statLen)){
  842.                         if (asp->pdu->version == SNMP_VERSION_1)
  843.                             statType = SNMP_ERR_BADVALUE;
  844.                         else
  845.                             statType = SNMP_ERR_WRONGTYPE; /* poor approximation */
  846. asp->pdu->errstat = statType;
  847. asp->pdu->errindex = count;
  848. return statType;
  849.                     }
  850.                     /* actually do the set if necessary */
  851.                     if (asp->mode == COMMIT)
  852.                         setVariable(varbind_ptr->val.string, varbind_ptr->type,
  853.                                     varbind_ptr->val_len, statP, statLen);
  854.                 }
  855.     }
  856. /* ... or save the results from assorted GETs */
  857.     else {
  858.      snmp_set_var_value(varbind_ptr, statP, statLen);
  859.      varbind_ptr->type = statType;
  860.     }
  861. }
  863. if ( varbind_ptr == asp->end )
  864.      return SNMP_ERR_NOERROR;
  865. varbind_ptr = varbind_ptr->next_variable;
  866. if ( asp->mode == RESERVE1 )
  867.     snmp_vars_inc++;
  868.     }
  869. }
  873. static int
  874. goodValue(u_char inType, 
  875.   size_t inLen,
  876.   u_char actualType,
  877.   size_t actualLen)
  878. {
  879.     if (inLen > actualLen)
  880. return FALSE;
  881.     return (inType == actualType);
  882. }
  884. static void
  885. setVariable(u_char *var_val,
  886.     u_char var_val_type,
  887.     size_t var_val_len,
  888.     u_char *statP,
  889.     size_t statLen)
  890. {
  891.     size_t buffersize = 1000;
  893.     switch(var_val_type){
  894. case ASN_INTEGER:
  895.     asn_parse_int(var_val, &buffersize, &var_val_type, (long *)statP, statLen);
  896.     break;
  897. case ASN_COUNTER:
  898. case ASN_GAUGE:
  899. case ASN_TIMETICKS:
  900.     asn_parse_unsigned_int(var_val, &buffersize, &var_val_type, (u_long *)statP, statLen);
  901.     break;
  902. case ASN_COUNTER64:
  903.     asn_parse_unsigned_int64(var_val, &buffersize, &var_val_type,
  904.      (struct counter64 *)statP, statLen);
  905.     break;
  906. case ASN_OCTET_STR:
  907. case ASN_IPADDRESS:
  908. case ASN_OPAQUE:
  909. case ASN_NSAP:
  910.     asn_parse_string(var_val, &buffersize, &var_val_type, statP, &statLen);
  911.     break;
  912. case ASN_OBJECT_ID:
  913.     asn_parse_objid(var_val, &buffersize, &var_val_type, (oid *)statP, &statLen);
  914.     break;
  915. case ASN_BIT_STR:
  916.     asn_parse_bitstring(var_val, &buffersize, &var_val_type, statP, &statLen);
  917.     break;
  918.     }
  919. }