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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
client.c
资源名称：net-snmp-5.2.2.rar　[点击查看]
上传用户：wxp200602
上传日期：2007-10-30
资源大小：4028k
文件大小：13k
源码类别：

SNMP编程

开发平台：

Unix_Linux

client.c：源码内容
  1. /*
  2.  *   AgentX utility routines
  3.  */
  5. #include <net-snmp/net-snmp-config.h>
  7. #include <stdio.h>
  8. #include <errno.h>
  9. #if HAVE_STDLIB_H
  10. #include <stdlib.h>
  11. #endif
  12. #if HAVE_STRING_H
  13. #include <string.h>
  14. #else
  15. #include <strings.h>
  16. #endif
  17. #if HAVE_UNISTD_H
  18. #include <unistd.h>
  19. #endif
  20. #include <sys/types.h>
  21. #if TIME_WITH_SYS_TIME
  22. # ifdef WIN32
  23. #  include <sys/timeb.h>
  24. # else
  25. #  include <sys/time.h>
  26. # endif
  27. # include <time.h>
  28. #else
  29. # if HAVE_SYS_TIME_H
  30. #  include <sys/time.h>
  31. # else
  32. #  include <time.h>
  33. # endif
  34. #endif
  36. #if HAVE_NETINET_IN_H
  37. #include <netinet/in.h>
  38. #endif
  39. #if HAVE_WINSOCK_H
  40. #include <winsock.h>
  41. #endif
  43. #if HAVE_DMALLOC_H
  44. #include <dmalloc.h>
  45. #endif
  47. #include <net-snmp/net-snmp-includes.h>
  48. #include <net-snmp/agent/net-snmp-agent-includes.h>
  49. #include <net-snmp/agent/agent_index.h>
  51. #include "agentx/protocol.h"
  52. #include "agentx/client.h"
  53. #include "agentx/subagent.h"
  55. extern struct timeval starttime;
  57.         /*
  58.          * AgentX handling utility routines
  59.          *
  60.          * Mostly wrappers round, or re-writes of
  61.          *   the SNMP equivalents
  62.          */
  64. int
  65. agentx_synch_input(int op,
  66.                    netsnmp_session * session,
  67.                    int reqid, netsnmp_pdu *pdu, void *magic)
  68. {
  69.     struct synch_state *state = (struct synch_state *) magic;
  70.     struct timeval  now, diff;
  72.     if (reqid != state->reqid) {
  73.         return handle_agentx_packet(op, session, reqid, pdu, magic);
  74.     }
  76.     DEBUGMSGTL(("agentx/subagent", "synching input, op 0x%02xn", op));
  77.     state->waiting = 0;
  78.     if (op == NETSNMP_CALLBACK_OP_RECEIVED_MESSAGE) {
  79.         if (pdu->command == AGENTX_MSG_RESPONSE) {
  80.             state->pdu = snmp_clone_pdu(pdu);
  81.             state->status = STAT_SUCCESS;
  82.             session->s_snmp_errno = SNMPERR_SUCCESS;
  84.             /*
  85.              * Synchronise sysUpTime with the master agent
  86.              */
  87.             gettimeofday(&now, NULL);
  88.             now.tv_sec--;
  89.             now.tv_usec += 1000000L;
  90.             diff.tv_sec = pdu->time / 100;
  91.             diff.tv_usec = (pdu->time - (diff.tv_sec * 100)) * 10000;
  92.             starttime.tv_sec = now.tv_sec - diff.tv_sec;
  93.             starttime.tv_usec = now.tv_usec - diff.tv_usec;
  94.             if (starttime.tv_usec > 1000000L) {
  95.                 starttime.tv_usec -= 1000000L;
  96.                 starttime.tv_sec++;
  97.             }
  98.         }
  99.     } else if (op == NETSNMP_CALLBACK_OP_TIMED_OUT) {
  100.         state->pdu = NULL;
  101.         state->status = STAT_TIMEOUT;
  102.         session->s_snmp_errno = SNMPERR_TIMEOUT;
  103.     } else if (op == NETSNMP_CALLBACK_OP_DISCONNECT) {
  104.         return handle_agentx_packet(op, session, reqid, pdu, magic);
  105.     }
  107.     return 1;
  108. }
  112. int
  113. agentx_synch_response(netsnmp_session * ss, netsnmp_pdu *pdu,
  114.                       netsnmp_pdu **response)
  115. {
  116.     return snmp_synch_response_cb(ss, pdu, response, agentx_synch_input);
  117. }
  120.         /*
  121.          * AgentX PofE convenience functions
  122.          */
  124. int
  125. agentx_open_session(netsnmp_session * ss)
  126. {
  127.     netsnmp_pdu    *pdu, *response;
  128.     extern oid      version_sysoid[];
  129.     extern int      version_sysoid_len;
  131.     DEBUGMSGTL(("agentx/subagent", "opening session n"));
  132.     if (ss == NULL || !IS_AGENTX_VERSION(ss->version)) {
  133.         return 0;
  134.     }
  136.     pdu = snmp_pdu_create(AGENTX_MSG_OPEN);
  137.     if (pdu == NULL)
  138.         return 0;
  139.     pdu->time = 0;
  140.     snmp_add_var(pdu, version_sysoid, version_sysoid_len,
  141.  's', "Net-SNMP AgentX sub-agent");
  143.     if (agentx_synch_response(ss, pdu, &response) != STAT_SUCCESS)
  144.         return 0;
  146.     if (response->errstat != SNMP_ERR_NOERROR) {
  147.         snmp_free_pdu(response);
  148.         return 0;
  149.     }
  151.     ss->sessid = response->sessid;
  152.     snmp_free_pdu(response);
  154.     DEBUGMSGTL(("agentx/subagent", "open n"));
  155.     return 1;
  156. }
  158. int
  159. agentx_close_session(netsnmp_session * ss, int why)
  160. {
  161.     netsnmp_pdu    *pdu, *response;
  162.     DEBUGMSGTL(("agentx/subagent", "closing sessionn"));
  164.     if (ss == NULL || !IS_AGENTX_VERSION(ss->version)) {
  165.         return 0;
  166.     }
  168.     pdu = snmp_pdu_create(AGENTX_MSG_CLOSE);
  169.     if (pdu == NULL)
  170.         return 0;
  171.     pdu->time = 0;
  172.     pdu->errstat = why;
  173.     pdu->sessid = ss->sessid;
  175.     (void) agentx_synch_response(ss, pdu, &response);
  176.     snmp_free_pdu(response);
  177.     DEBUGMSGTL(("agentx/subagent", "closedn"));
  179.     return 1;
  180. }
  182. int
  183. agentx_register(netsnmp_session * ss, oid start[], size_t startlen,
  184.                 int priority, int range_subid, oid range_ubound,
  185.                 int timeout, u_char flags, const char *contextName)
  186. {
  187.     netsnmp_pdu    *pdu, *response;
  189.     DEBUGMSGTL(("agentx/subagent", "registering: "));
  190.     DEBUGMSGOIDRANGE(("agentx/subagent", start, startlen, range_subid,
  191.                       range_ubound));
  192.     DEBUGMSG(("agentx/subagent", "n"));
  194.     if (ss == NULL || !IS_AGENTX_VERSION(ss->version)) {
  195.         return 0;
  196.     }
  198.     pdu = snmp_pdu_create(AGENTX_MSG_REGISTER);
  199.     if (pdu == NULL) {
  200.         return 0;
  201.     }
  202.     pdu->time = timeout;
  203.     pdu->priority = priority;
  204.     pdu->sessid = ss->sessid;
  205.     pdu->range_subid = range_subid;
  206.     if (contextName) {
  207.         pdu->flags |= AGENTX_MSG_FLAG_NON_DEFAULT_CONTEXT;
  208.         pdu->community = strdup(contextName);
  209.         pdu->community_len = strlen(contextName);
  210.     }
  212.     if (flags & FULLY_QUALIFIED_INSTANCE) {
  213.         pdu->flags |= AGENTX_MSG_FLAG_INSTANCE_REGISTER;
  214.     }
  216.     if (range_subid) {
  217.         snmp_pdu_add_variable(pdu, start, startlen, ASN_OBJECT_ID,
  218.                               (u_char *) start, startlen * sizeof(oid));
  219.         pdu->variables->val.objid[range_subid - 1] = range_ubound;
  220.     } else {
  221.         snmp_add_null_var(pdu, start, startlen);
  222.     }
  224.     if (agentx_synch_response(ss, pdu, &response) != STAT_SUCCESS) {
  225.         DEBUGMSGTL(("agentx/subagent", "registering failed!n"));
  226.         return 0;
  227.     }
  229.     if (response->errstat != SNMP_ERR_NOERROR) {
  230.         snmp_log(LOG_ERR,"registering pdu failed: %ld!n", response->errstat);
  231.         snmp_free_pdu(response);
  232.         return 0;
  233.     }
  235.     snmp_free_pdu(response);
  236.     DEBUGMSGTL(("agentx/subagent", "registeredn"));
  237.     return 1;
  238. }
  240. int
  241. agentx_unregister(netsnmp_session * ss, oid start[], size_t startlen,
  242.                   int priority, int range_subid, oid range_ubound,
  243.                   const char *contextName)
  244. {
  245.     netsnmp_pdu    *pdu, *response;
  247.     if (ss == NULL || !IS_AGENTX_VERSION(ss->version)) {
  248.         return 0;
  249.     }
  251.     DEBUGMSGTL(("agentx/subagent", "unregistering: "));
  252.     DEBUGMSGOIDRANGE(("agentx/subagent", start, startlen, range_subid,
  253.                       range_ubound));
  254.     DEBUGMSG(("agentx/subagent", "n"));
  255.     pdu = snmp_pdu_create(AGENTX_MSG_UNREGISTER);
  256.     if (pdu == NULL) {
  257.         return 0;
  258.     }
  259.     pdu->time = 0;
  260.     pdu->priority = priority;
  261.     pdu->sessid = ss->sessid;
  262.     pdu->range_subid = range_subid;
  263.     if (contextName) {
  264.         pdu->flags |= AGENTX_MSG_FLAG_NON_DEFAULT_CONTEXT;
  265.         pdu->community = strdup(contextName);
  266.         pdu->community_len = strlen(contextName);
  267.     }
  269.     if (range_subid) {
  270.         snmp_pdu_add_variable(pdu, start, startlen, ASN_OBJECT_ID,
  271.                               (u_char *) start, startlen * sizeof(oid));
  272.         pdu->variables->val.objid[range_subid - 1] = range_ubound;
  273.     } else {
  274.         snmp_add_null_var(pdu, start, startlen);
  275.     }
  277.     if (agentx_synch_response(ss, pdu, &response) != STAT_SUCCESS)
  278.         return 0;
  280.     if (response->errstat != SNMP_ERR_NOERROR) {
  281.         snmp_free_pdu(response);
  282.         return 0;
  283.     }
  285.     snmp_free_pdu(response);
  286.     DEBUGMSGTL(("agentx/subagent", "unregisteredn"));
  287.     return 1;
  288. }
  290. netsnmp_variable_list *
  291. agentx_register_index(netsnmp_session * ss,
  292.                       netsnmp_variable_list * varbind, int flags)
  293. {
  294.     netsnmp_pdu    *pdu, *response;
  295.     netsnmp_variable_list *varbind2;
  297.     if (ss == NULL || !IS_AGENTX_VERSION(ss->version)) {
  298.         return NULL;
  299.     }
  301.     /*
  302.      * Make a copy of the index request varbind
  303.      *    for the AgentX request PDU
  304.      *    (since the pdu structure will be freed)
  305.      */
  306.     varbind2 =
  307.         (netsnmp_variable_list *) malloc(sizeof(netsnmp_variable_list));
  308.     if (varbind2 == NULL)
  309.         return NULL;
  310.     if (snmp_clone_var(varbind, varbind2)) {
  311.         snmp_free_varbind(varbind2);
  312.         return NULL;
  313.     }
  314.     if (varbind2->val.string == NULL)
  315.         varbind2->val.string = varbind2->buf;   /* ensure it points somewhere */
  317.     pdu = snmp_pdu_create(AGENTX_MSG_INDEX_ALLOCATE);
  318.     if (pdu == NULL) {
  319.         snmp_free_varbind(varbind2);
  320.         return NULL;
  321.     }
  322.     pdu->time = 0;
  323.     pdu->sessid = ss->sessid;
  324.     if (flags == ALLOCATE_ANY_INDEX)
  325.         pdu->flags |= AGENTX_MSG_FLAG_ANY_INSTANCE;
  326.     if (flags == ALLOCATE_NEW_INDEX)
  327.         pdu->flags |= AGENTX_MSG_FLAG_NEW_INSTANCE;
  329.     /*
  330.      *  Just send a single index request varbind.
  331.      *  Although the AgentX protocol supports
  332.      *    multiple index allocations in a single
  333.      *    request, the model used in the net-snmp agent
  334.      *    doesn't currently take advantage of this.
  335.      *  I believe this is our prerogative - just as
  336.      *    long as the master side Index request handler
  337.      *    can cope with multiple index requests.
  338.      */
  339.     pdu->variables = varbind2;
  341.     if (agentx_synch_response(ss, pdu, &response) != STAT_SUCCESS)
  342.         return NULL;
  344.     if (response->errstat != SNMP_ERR_NOERROR) {
  345.         snmp_free_pdu(response);
  346.         return NULL;
  347.     }
  349.     /*
  350.      * Unlink the (single) response varbind to return
  351.      *  to the main driving index request routine.
  352.      *
  353.      * This is a memory leak, as nothing will ever
  354.      *  release this varbind.  If this becomes a problem,
  355.      *  we'll need to keep a list of these here, and
  356.      *  free the memory in the "index release" routine.
  357.      * But the master side never frees these either (by
  358.      *  design, since it still needs them), so expecting
  359.      *  the subagent to is discrimination, pure & simple :-)
  360.      */
  361.     varbind2 = response->variables;
  362.     response->variables = NULL;
  363.     snmp_free_pdu(response);
  364.     return varbind2;
  365. }
  367. int
  368. agentx_unregister_index(netsnmp_session * ss,
  369.                         netsnmp_variable_list * varbind)
  370. {
  371.     netsnmp_pdu    *pdu, *response;
  372.     netsnmp_variable_list *varbind2;
  374.     if (ss == NULL || !IS_AGENTX_VERSION(ss->version)) {
  375.         return -1;
  376.     }
  378.     /*
  379.      * Make a copy of the index request varbind
  380.      *    for the AgentX request PDU
  381.      *    (since the pdu structure will be freed)
  382.      */
  383.     varbind2 =
  384.         (netsnmp_variable_list *) malloc(sizeof(netsnmp_variable_list));
  385.     if (varbind2 == NULL)
  386.         return -1;
  387.     if (snmp_clone_var(varbind, varbind2)) {
  388.         snmp_free_varbind(varbind2);
  389.         return -1;
  390.     }
  392.     pdu = snmp_pdu_create(AGENTX_MSG_INDEX_DEALLOCATE);
  393.     if (pdu == NULL) {
  394.         snmp_free_varbind(varbind2);
  395.         return -1;
  396.     }
  397.     pdu->time = 0;
  398.     pdu->sessid = ss->sessid;
  400.     /*
  401.      *  Just send a single index release varbind.
  402.      *      (as above)
  403.      */
  404.     pdu->variables = varbind2;
  406.     if (agentx_synch_response(ss, pdu, &response) != STAT_SUCCESS)
  407.         return -1;
  409.     if (response->errstat != SNMP_ERR_NOERROR) {
  410.         snmp_free_pdu(response);
  411.         return -1;              /* XXX - say why */
  412.     }
  414.     snmp_free_pdu(response);
  415.     return SNMP_ERR_NOERROR;
  416. }
  418. int
  419. agentx_add_agentcaps(netsnmp_session * ss,
  420.                      oid * agent_cap, size_t agent_caplen,
  421.                      const char *descr)
  422. {
  423.     netsnmp_pdu    *pdu, *response;
  425.     if (ss == NULL || !IS_AGENTX_VERSION(ss->version)) {
  426.         return 0;
  427.     }
  429.     pdu = snmp_pdu_create(AGENTX_MSG_ADD_AGENT_CAPS);
  430.     if (pdu == NULL)
  431.         return 0;
  432.     pdu->time = 0;
  433.     pdu->sessid = ss->sessid;
  434.     snmp_add_var(pdu, agent_cap, agent_caplen, 's', descr);
  436.     if (agentx_synch_response(ss, pdu, &response) != STAT_SUCCESS)
  437.         return 0;
  439.     if (response->errstat != SNMP_ERR_NOERROR) {
  440.         snmp_free_pdu(response);
  441.         return 0;
  442.     }
  444.     snmp_free_pdu(response);
  445.     return 1;
  446. }
  448. int
  449. agentx_remove_agentcaps(netsnmp_session * ss,
  450.                         oid * agent_cap, size_t agent_caplen)
  451. {
  452.     netsnmp_pdu    *pdu, *response;
  454.     if (ss == NULL || !IS_AGENTX_VERSION(ss->version)) {
  455.         return 0;
  456.     }
  458.     pdu = snmp_pdu_create(AGENTX_MSG_REMOVE_AGENT_CAPS);
  459.     if (pdu == NULL)
  460.         return 0;
  461.     pdu->time = 0;
  462.     pdu->sessid = ss->sessid;
  463.     snmp_add_null_var(pdu, agent_cap, agent_caplen);
  465.     if (agentx_synch_response(ss, pdu, &response) != STAT_SUCCESS)
  466.         return 0;
  468.     if (response->errstat != SNMP_ERR_NOERROR) {
  469.         snmp_free_pdu(response);
  470.         return 0;
  471.     }
  473.     snmp_free_pdu(response);
  474.     return 1;
  475. }
  477. int
  478. agentx_send_ping(netsnmp_session * ss)
  479. {
  480.     netsnmp_pdu    *pdu, *response;
  482.     if (ss == NULL || !IS_AGENTX_VERSION(ss->version)) {
  483.         return 0;
  484.     }
  486.     pdu = snmp_pdu_create(AGENTX_MSG_PING);
  487.     if (pdu == NULL)
  488.         return 0;
  489.     pdu->time = 0;
  490.     pdu->sessid = ss->sessid;
  492.     if (agentx_synch_response(ss, pdu, &response) != STAT_SUCCESS)
  493.         return 0;
  495.     if (response->errstat != SNMP_ERR_NOERROR) {
  496.         snmp_free_pdu(response);
  497.         return 0;
  498.     }
  500.     snmp_free_pdu(response);
  501.     return 1;
  502. }