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

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

SNMP编程

开发平台：

C/C++

snmpv3.c：源码内容
  1. /*
  2.  * snmpv3.c
  3.  */
  5. #include <config.h>
  6. #include <assert.h>
  8. #include <stdio.h>
  9. #include <sys/types.h>
  10. #if TIME_WITH_SYS_TIME
  11. # ifdef WIN32
  12. #  include <sys/timeb.h>
  13. # else
  14. #  include <time.h>
  15. # endif
  16. # include <time.h>
  17. #else
  18. # if HAVE_SYS_TIME_H
  19. #  include <sys/time.h>
  20. # else
  21. #  include <time.h>
  22. # endif
  23. #endif
  24. #ifdef OS_VXWORKS
  25. #include <sys/times.h>
  26. #endif
  27. #if HAVE_STRING_H
  28. #include <string.h>
  29. #else
  30. #include <strings.h>
  31. #endif
  32. #if HAVE_NETINET_IN_H
  33. #include <netinet/in.h>
  34. #endif
  35. #if HAVE_UNISTD_H
  36. #include <unistd.h>
  37. #endif
  38. #if HAVE_WINSOCK_H
  39. #include <ip/socket.h>
  40. #endif
  41. #if HAVE_SYS_SOCKET_H
  42. #include <sys/socket.h>
  43. #endif
  44. #if HAVE_NETDB_H
  45. #include <netdb.h>
  46. #endif
  47. #if HAVE_STDLIB_H
  48. #       include <stdlib.h>
  49. #endif
  51. #if HAVE_DMALLOC_H
  52. #include <dmalloc.h>
  53. #endif
  55. #include "system.h"
  56. #include "asn1.h"
  57. #include "snmpv3.h"
  58. #include "callback.h"
  59. #include "snmpusm.h"
  60. #include "snmp.h"
  61. #include "parse.h"
  62. #include "snmp_api.h"
  63. #include "snmp_impl.h"
  64. #include "read_config.h"
  65. #include "lcd_time.h"
  66. #include "scapi.h"
  67. #include "tools.h"
  68. #include "keytools.h"
  69. #include "lcd_time.h"
  70. #include "snmp_debug.h"
  71. #include "snmp_logging.h"
  72. #include "default_store.h"
  73. #include <ip/netdb.h>
  74. #include "transform_oids.h"
  75. #include <snmp/agent_trap.h>
  76. #include <snmp/snmp_command.h>
  77. #include <boot/convert.h>
  79. #include <libvty/log.h>
  81. static u_long  engineBoots    = 1;
  82. static unsigned char *engineID    = NULL;
  83. static size_t  engineIDLength    = 0;
  84. static unsigned char *oldEngineID    = NULL;
  85. static size_t  oldEngineIDLength = 0;
  86. static struct timeval  snmpv3starttime;
  87. extern char *strdup (char*);
  88. extern int strcasecmp(const char*, const char*);
  89. /* 
  90.  * Set up default snmpv3 parameter value storage.
  91.  */
  92. static oid *defaultAuthType = NULL;
  93. static size_t  defaultAuthTypeLen = 0;
  94. static oid *defaultPrivType = NULL;
  95. static size_t  defaultPrivTypeLen = 0;
  96. void
  97. snmpv3_authtype_conf(const char *word, char *cptr)
  98. {
  99.   if (strcasecmp(cptr,"MD5") == 0)
  100.     defaultAuthType = usmHMACMD5AuthProtocol;
  101.   else if (strcasecmp(cptr,"SHA") == 0)
  102.     defaultAuthType = usmHMACMD5AuthProtocol;
  103.   else
  104.     config_perror("Unknown authentication type");
  105.   defaultAuthTypeLen = USM_LENGTH_OID_TRANSFORM;
  106.   DEBUGMSGTL(("snmpv3","set default authentication type: %sn", cptr));
  107. }
  109. oid *
  110. get_default_authtype(size_t *len)
  111. {
  112.   if (defaultAuthType == NULL) {
  113.     defaultAuthType = SNMP_DEFAULT_AUTH_PROTO;
  114.     defaultAuthTypeLen = SNMP_DEFAULT_AUTH_PROTOLEN;
  115.   }
  116.   if (len)
  117.     *len = defaultAuthTypeLen;
  118.   return defaultAuthType;
  119. }
  121. void
  122. snmpv3_privtype_conf(const char *word, char *cptr)
  123. {
  124.   if (strcasecmp(cptr,"DES") == 0)
  125.     defaultPrivType = SNMP_DEFAULT_PRIV_PROTO;
  126.   else
  127.     config_perror("Unknown privacy type");
  128.   defaultPrivTypeLen = SNMP_DEFAULT_PRIV_PROTOLEN;
  129.   DEBUGMSGTL(("snmpv3","set default privacy type: %sn", cptr));
  130. }
  132. oid *
  133. get_default_privtype(size_t *len)
  134. {
  135.   if (defaultAuthType == NULL) {
  136.     defaultAuthType = usmDESPrivProtocol;
  137.     defaultPrivTypeLen = USM_LENGTH_OID_TRANSFORM;
  138.   }
  139.   if (len)
  140.     *len = defaultPrivTypeLen;
  141.   return defaultPrivType;
  142. }
  144. /*******************************************************************-o-******
  145.  * snmpv3_secLevel_conf
  146.  *
  147.  * Parameters:
  148.  * *word
  149.  * *cptr
  150.  *
  151.  * Line syntax:
  152.  * defSecurityLevel "noAuthNoPriv" | "authNoPriv" | "authPriv"
  153.  */
  154. void
  155. snmpv3_secLevel_conf(const char *word, char *cptr)
  156. {
  157.   char buf[1024];
  158.   
  159.   if (strcasecmp(cptr,"noAuthNoPriv") == 0 || strcmp(cptr, "1") == 0
  160. || strcasecmp(cptr, "nanp") == 0)
  161.     ds_set_int(DS_LIBRARY_ID, DS_LIB_SECLEVEL, SNMP_SEC_LEVEL_NOAUTH);
  162.   else if (strcasecmp(cptr,"authNoPriv") == 0 || strcmp(cptr, "2") == 0
  163. || strcasecmp(cptr, "anp") == 0)
  164.     ds_set_int(DS_LIBRARY_ID, DS_LIB_SECLEVEL, SNMP_SEC_LEVEL_AUTHNOPRIV);
  165.   else if (strcasecmp(cptr,"authPriv") == 0 || strcmp(cptr, "3") == 0
  166. || strcasecmp(cptr, "ap") == 0)
  167.     ds_set_int(DS_LIBRARY_ID, DS_LIB_SECLEVEL, SNMP_SEC_LEVEL_AUTHPRIV);
  168.   else {
  169.     sprintf(buf,"Unknown security level: %s", cptr);
  170.     config_perror(buf);
  171.   }
  172.   DEBUGMSGTL(("snmpv3","default secLevel set to: %s = %dn", cptr,
  173.               ds_get_int(DS_LIBRARY_ID, DS_LIB_SECLEVEL)));
  174. }
  176. /*******************************************************************-o-******
  177.  * setup_engineID
  178.  *
  179.  * Parameters:
  180.  * **eidp
  181.  *  *text Printable (?) text to be plugged into the snmpEngineID.
  182.  *
  183.  * Return:
  184.  * Length of allocated engineID string in bytes,  -OR-
  185.  * -1 on error.
  186.  *
  187.  *
  188.  * Create an snmpEngineID using text and the local IP address.  If eidp
  189.  * is defined, use it to return a pointer to the newly allocated data.
  190.  * Otherwise, use the result to define engineID defined in this module.
  191.  *
  192.  * Line syntax:
  193.  * engineID <text> | NULL
  194.  *
  195.  * XXX What if a node has multiple interfaces?
  196.  * XXX What if multiple engines all choose the same address?
  197.  *      (answer:  You're screwed, because you might need a kul database
  198.  *       which is dependant on the current engineID.  Enumeration and other
  199.  *       tricks won't work). 
  200.  */
  201. int
  202. setup_engineID(u_char **eidp, const char *text)
  203. {
  204.   int   enterpriseid = htonl(default_enterprise[6]),
  205.   localsetup = (eidp) ? 0 : 1;
  206. /* Use local engineID if *eidp == NULL.  */
  207. #ifdef HAVE_GETHOSTNAME
  208.   u_char   buf[SNMP_MAXBUF_SMALL];
  209.   struct hostent *hent;
  210. #endif
  211.   u_char     *bufp = NULL;
  212.   size_t   len;
  213. #if 0
  214.   if (eprom_extend()&&eprom_oem())
  215.   {
  216.      char company_name[100];
  217.      
  218.   if (!get_extend_info_string(INFO_COMPANY_NAME,company_name))
  219.   {
  220.   if (!strcasecmp(company_name,DIGITAL_CHINA_VENDOR_NAME))
  221.   {
  222.    enterpriseid = htonl(DIGITAL_CHINA_ENTERPRISE_NUMBER);
  223.    default_enterprise[6]=DIGITAL_CHINA_ENTERPRISE_NUMBER;
  224.   }
  225.   if (!strcasecmp(company_name,DLINK_VENDOR_NAME))
  226.   {
  227.    enterpriseid = htonl(DLINK_ENTERPRISE_NUMBER);
  228.    default_enterprise[6]=DLINK_ENTERPRISE_NUMBER;
  229.   }
  230.      }
  231.   }
  232. #endif
  233.   /*
  234.    * Determine length of the engineID string.
  235.    */
  236.   if (text) {
  237.     len = 5+strlen(text); /* 5 leading bytes+text. */
  239.   } else {
  240.     len = 5 + 4; /* 5 leading bytes + four byte IPv4 address */
  241. #ifdef HAVE_GETHOSTNAME
  242.     gethostname((char *)buf, sizeof(buf));
  243.     hent = gethostbyname((char *)buf);
  244. #ifdef AF_INET6
  245.     if (hent && hent->h_addrtype == AF_INET6)
  246.       len += 12; /* 16 bytes total for IPv6 address. */
  247. #endif
  248. #endif /* HAVE_GETHOSTNAME */
  249.   }  /* endif -- text (1) */
  252.   /*
  253.    * Allocate memory and store enterprise ID.
  254.    */
  255.   if ((bufp = (u_char *) malloc(len)) == NULL) {
  256.     snmp_log_perror("setup_engineID malloc");
  257.     return -1;
  258.   }
  260.   memcpy(bufp, &enterpriseid, sizeof(enterpriseid)); /* XXX Must be 4 bytes! */
  261.   bufp[0] |= 0x80;
  262.   
  264.   /*
  265.    * Store the given text  -OR-   the first found IP address.
  266.    */
  267.   if (text) {
  268.     bufp[4] = 4;
  269.     memcpy((char *)bufp+5, text, strlen(text));
  271.   } else {
  272.     bufp[4] = 1;
  273. #ifdef HAVE_GETHOSTNAME
  274.     gethostname((char *)buf, sizeof(buf));
  275.     hent = gethostbyname((char *)buf);
  277.     if (hent && hent->h_addrtype == AF_INET) {
  278.       memcpy(bufp+5, hent->h_addr_list[0], hent->h_length);
  280. #ifdef AF_INET6
  281.     } else if (hent && hent->h_addrtype == AF_INET6) {
  282.       bufp[4] = 2;
  283.       memcpy(bufp+5, hent->h_addr_list[0], hent->h_length);
  284. #endif
  286.     } else { /* Unknown address type.  Default to 127.0.0.1. */
  288.       bufp[5] = 127;
  289.       bufp[6] = 0;
  290.       bufp[7] = 0;
  291.       bufp[8] = 1;
  292.     }
  293. #else /* HAVE_GETHOSTNAME */
  294.     /* Unknown address type.  Default to 127.0.0.1. */
  295.     
  296.     bufp[5] = 127;
  297.     bufp[6] = 0;
  298.     bufp[7] = 0;
  299.     bufp[8] = 1;
  300. #endif /* HAVE_GETHOSTNAME */
  301.     
  302.   }  /* endif -- text (2) */
  305.   /*
  306.    * Pass the string back to the calling environment, or use it for
  307.    * our local engineID.
  308.    */
  309.   if (localsetup) {
  310. SNMP_FREE(engineID);
  311. engineID = bufp;
  312. engineIDLength = len;
  314.   } else {
  315. *eidp = bufp;
  316.   }
  319.   return len;
  321. }  /* end setup_engineID() */
  323. void
  324. usm_parse_create_usmUser(const char *token, char *line) {
  325.   char *cp;
  326.   char buf[SNMP_MAXBUF_MEDIUM];
  327.   struct usmUser *newuser;
  328.   u_char   userKey[SNMP_MAXBUF_SMALL];
  329.   size_t   userKeyLen = SNMP_MAXBUF_SMALL;
  330.   size_t ret;
  332.   newuser = usm_create_user();
  334.   /* READ: Security Name */
  335.   cp = copy_word(line, buf);
  336.   newuser->secName = strdup(buf);
  337.   newuser->name = strdup(buf);
  339.   newuser->engineID = snmpv3_generate_engineID(&ret);
  340.   if ( ret < 0 ) {
  341.     usm_free_user(newuser);
  342.     return;
  343.   }
  344.   newuser->engineIDLen = ret;
  346.   if (!cp)
  347.     goto add; /* no authentication or privacy type */
  349.   /* READ: Authentication Type */
  350.   if (strncmp(cp, "MD5", 3) == 0) {
  351.     memcpy(newuser->authProtocol, usmHMACMD5AuthProtocol,
  352.            sizeof(usmHMACMD5AuthProtocol));
  353.   } else if (strncmp(cp, "SHA", 3) == 0) {
  354.     memcpy(newuser->authProtocol, usmHMACSHA1AuthProtocol,
  355.            sizeof(usmHMACSHA1AuthProtocol));
  356.   } else {
  357.     config_perror("Unknown authentication protocol");
  358.     usm_free_user(newuser);
  359.     return;
  360.   }
  362.   cp = skip_token(cp);
  364.   /* READ: Authentication Pass Phrase */
  365.   if (!cp) {
  366.     config_perror("no authentication pass phrase");
  367.     usm_free_user(newuser);
  368.     return;
  369.   }
  370.   cp = copy_word(cp, buf);
  371.   /* And turn it into a localized key */
  372.   ret = generate_Ku(newuser->authProtocol, newuser->authProtocolLen,
  373.     (u_char *)buf, strlen(buf),
  374.     userKey, &userKeyLen );
  375.   if (ret != SNMPERR_SUCCESS) {
  376.     config_perror("Error generating auth key from pass phrase.");
  377.     usm_free_user(newuser);
  378.     return;
  379.   }
  380.   newuser->authKeyLen =
  381.     sc_get_properlength(newuser->authProtocol, newuser->authProtocolLen);
  382.   newuser->authKey = (u_char *) malloc(newuser->authKeyLen);
  383.   ret = generate_kul(newuser->authProtocol, newuser->authProtocolLen,
  384.      newuser->engineID, newuser->engineIDLen,
  385.      userKey, userKeyLen,
  386.      newuser->authKey, &newuser->authKeyLen );
  387.   if (ret != SNMPERR_SUCCESS) {
  388.     config_perror("Error generating localized auth key (Kul) from Ku.");
  389.     usm_free_user(newuser);
  390.     return;
  391.   }
  393.   if (!cp)
  394.     goto add; /* no privacy type (which is legal) */
  395.   
  396.   /* READ: Privacy Type */
  397.   if (strncmp(cp, "DES", 3) == 0) {
  398.     memcpy(newuser->privProtocol, usmDESPrivProtocol,
  399.            sizeof(usmDESPrivProtocol));
  400.   } else {
  401.     config_perror("Unknown privacy protocol");
  402.     usm_free_user(newuser);
  403.     return;
  404.   }
  406.   cp = skip_token(cp);
  407.   /* READ: Authentication Pass Phrase */
  408.   if (!cp) {
  409.     /* assume the same as the authentication key */
  410.     snmp_memdup(&newuser->privKey, newuser->authKey, newuser->authKeyLen);
  411.   } else {
  412.     cp = copy_word(cp, buf);
  413.     /* And turn it into a localized key */
  414.     ret = generate_Ku(newuser->authProtocol, newuser->authProtocolLen,
  415.                       (u_char *)buf, strlen(buf),
  416.                       userKey, &userKeyLen );
  417.     if (ret != SNMPERR_SUCCESS) {
  418.       config_perror("Error generating priv key from pass phrase.");
  419.       usm_free_user(newuser);
  420.       return;
  421.     }
  423.     ret = sc_get_properlength(newuser->authProtocol, newuser->authProtocolLen);
  424.     if (ret < 0) {
  425.       config_perror("Error getting proper key length for priv algorithm.");
  426.       usm_free_user(newuser);
  427.       return;
  428.     }
  429.     newuser->privKeyLen = ret;
  430.       
  431.     newuser->privKey = (u_char *) malloc(newuser->privKeyLen);
  432.     ret = generate_kul(newuser->authProtocol, newuser->authProtocolLen,
  433.                        newuser->engineID, newuser->engineIDLen,
  434.                        userKey, userKeyLen,
  435.                        newuser->privKey, &newuser->privKeyLen );
  436.     if (ret != SNMPERR_SUCCESS) {
  437.       config_perror("Error generating localized priv key (Kul) from Ku.");
  438.       usm_free_user(newuser);
  439.       return;
  440.     }
  441.   }
  442. add:
  443.   usm_add_user(newuser);
  444.   DEBUGMSGTL(("usmUser","created a new user %sn", newuser->secName));
  445. }
  447. /*******************************************************************-o-******
  448.  * engineBoots_conf
  449.  *
  450.  * Parameters:
  451.  * *word
  452.  * *cptr
  453.  *
  454.  * Line syntax:
  455.  * engineBoots <num_boots>
  456.  */
  457. void
  458. engineBoots_conf(const char *word, char *cptr)
  459. {
  460.   engineBoots = atoi(cptr)+1;
  461.   DEBUGMSGTL(("snmpv3","engineBoots: %dn",engineBoots));
  462. }
  466. /*******************************************************************-o-******
  467.  * engineID_conf
  468.  *
  469.  * Parameters:
  470.  * *word
  471.  * *cptr
  472.  *
  473.  * This function reads a string from the configuration file and uses that
  474.  * string to initialize the engineID.  It's assumed to be human readable.
  475.  */
  476. void
  477. engineID_conf(const char *word, char *cptr)
  478. {
  479.   setup_engineID(NULL, cptr);
  480.   DEBUGMSGTL(("snmpv3","initialized engineID with: %sn",cptr));
  481. }
  483. void
  484. version_conf(const char *word, char *cptr)
  485. {
  486.   if (strcmp(cptr,"1") == 0) {
  487.     ds_set_int(DS_LIBRARY_ID, DS_LIB_SNMPVERSION, SNMP_VERSION_1);
  488.   } else if (strcasecmp(cptr,"2c") == 0) {
  489.     ds_set_int(DS_LIBRARY_ID, DS_LIB_SNMPVERSION, SNMP_VERSION_2c);
  490.   } else if (strcmp(cptr,"3") == 0) {
  491.     ds_set_int(DS_LIBRARY_ID, DS_LIB_SNMPVERSION, SNMP_VERSION_3);
  492.   } else {
  493.     config_perror("Unknown version specification");
  494.     return;
  495.   }
  496.   DEBUGMSGTL(("snmpv3","set default version to %dn",
  497.               ds_get_int(DS_LIBRARY_ID, DS_LIB_SNMPVERSION)));
  498. }
  500. /* engineID_old_conf(const char *, char *):
  502.    Reads a octet string encoded engineID into the oldEngineID and
  503.    oldEngineIDLen pointers.
  504. */
  505. void
  506. oldengineID_conf(const char *word, char *cptr)
  507. {
  508.   read_config_read_octet_string(cptr, &oldEngineID, &oldEngineIDLength);
  509. }
  512. /*******************************************************************-o-******
  513.  * init_snmpv3
  514.  *
  515.  * Parameters:
  516.  * *type Label for the config file "type" used by calling entity.
  517.  *      
  518.  * Set time and engineID.
  519.  * Set parsing functions for config file tokens.
  520.  * Initialize SNMP Crypto API (SCAPI).
  521.  */
  522. void
  523. init_snmpv3(const char *type) {
  524.   gettimeofday(&snmpv3starttime, NULL);
  526.   if (type == NULL)
  527.      type = "snmpapp";
  529.   if (type && !strcmp(type,"snmpapp")) {
  530.      setup_engineID(NULL,"__snmpapp__");
  531.   } else {
  532.      setup_engineID(NULL, NULL);
  533.   }
  535.   /* initialize submodules */
  536.   init_usm();
  538.   /* we need to be called back later */
  539.   snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_POST_READ_CONFIG,
  540.                          init_snmpv3_post_config, NULL);
  541.   /* we need to be called back later */
  542.   snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
  543.                          snmpv3_store, (void *) type);
  546. #if !defined(USE_INTERNAL_MD5)
  547.   /* doesn't belong here at all */
  548.   sc_init();
  549. #endif /* !USE_INTERNAL_MD5 */
  551.   /* register all our configuration handlers (ack, there's a lot) */
  553.   /* handle engineID setup before everything else which may depend on it */
  554.   register_premib_handler(type,"engineID", engineID_conf, NULL, "string");
  555.   register_premib_handler(type,"oldEngineID", oldengineID_conf, NULL, NULL);
  556.   register_config_handler(type,"engineBoots", engineBoots_conf, NULL, NULL);
  558.   /* default store config entries */
  559.   ds_register_config(ASN_OCTET_STR, "snmp", "defSecurityName", DS_LIBRARY_ID,
  560.                      DS_LIB_SECNAME);
  561.   ds_register_config(ASN_OCTET_STR, "snmp", "defContext", DS_LIBRARY_ID,
  562.                      DS_LIB_CONTEXT);
  563.   ds_register_config(ASN_OCTET_STR, "snmp", "defPassphrase", DS_LIBRARY_ID,
  564.                      DS_LIB_PASSPHRASE);
  565.   ds_register_config(ASN_OCTET_STR, "snmp", "defAuthPassphrase", DS_LIBRARY_ID,
  566.                      DS_LIB_AUTHPASSPHRASE);
  567.   ds_register_config(ASN_OCTET_STR, "snmp", "defPrivPassphrase", DS_LIBRARY_ID,
  568.                      DS_LIB_PRIVPASSPHRASE);
  569.   register_config_handler("snmp","defVersion", version_conf, NULL, "1|2c|3");
  571.   register_config_handler("snmp","defAuthType", snmpv3_authtype_conf, NULL,
  572.                           "MD5|SHA");
  573.   register_config_handler("snmp","defPrivType", snmpv3_privtype_conf, NULL,
  574.                           "DES (currently the only possible value)");
  575.   register_config_handler("snmp","defSecurityLevel", snmpv3_secLevel_conf,
  576.                           NULL, "noAuthNoPriv|authNoPriv|authPriv");
  577.   register_config_handler(type,"userSetAuthPass", usm_set_password, NULL,
  578.                           "secname engineIDLen engineID pass");
  579.   register_config_handler(type,"userSetPrivPass", usm_set_password, NULL,
  580.                           "secname engineIDLen engineID pass");
  581.   register_config_handler(type,"userSetAuthKey", usm_set_password, NULL,
  582.                           "secname engineIDLen engineID KuLen Ku");
  583.   register_config_handler(type,"userSetPrivKey", usm_set_password, NULL,
  584.                           "secname engineIDLen engineID KuLen Ku");
  585.   register_config_handler(type,"userSetAuthLocalKey", usm_set_password, NULL,
  586.                           "secname engineIDLen engineID KulLen Kul");
  587.   register_config_handler(type,"userSetPrivLocalKey", usm_set_password, NULL,
  588.                           "secname engineIDLen engineID KulLen Kul");
  589. }
  591. /*
  592.  * initializations for SNMPv3 to be called after the configuration files
  593.  * have been read.
  594.  */
  596. int
  597. init_snmpv3_post_config(int majorid, int minorid, void *serverarg,
  598.                         void *clientarg) {
  600.   size_t engineIDLen;
  601.   u_char *c_engineID;
  603.   c_engineID = snmpv3_generate_engineID(&engineIDLen);
  605.   if ( engineIDLen < 0 ) {
  606.     /* Somethine went wrong - help! */
  607.     return SNMPERR_GENERR;
  608.   }
  610.   /* if our engineID has changed at all, the boots record must be set to 1 */
  611.   if (engineIDLen != (int)oldEngineIDLength ||
  612.       oldEngineID == NULL || c_engineID == NULL ||
  613.       memcmp(oldEngineID, c_engineID, engineIDLen) != 0) {
  614.     engineBoots = 1;
  615.   }
  617.   /* set our local engineTime in the LCD timing cache */
  618.   set_enginetime(c_engineID, engineIDLen, 
  619.                  snmpv3_local_snmpEngineBoots(), 
  620.                  snmpv3_local_snmpEngineTime(),
  621.                  TRUE);
  623.   free(c_engineID);
  624.   return SNMPERR_SUCCESS;
  625. }
  627. /*******************************************************************-o-******
  628.  * store_snmpv3
  629.  *
  630.  * Parameters:
  631.  * *type
  632.  */
  633. int
  634. snmpv3_store(int majorID, int minorID, void *serverarg, void *clientarg) {
  635.   char line[SNMP_MAXBUF_SMALL];
  636.   u_char c_engineID[SNMP_MAXBUF_SMALL];
  637.   int  engineIDLen;
  638.   const char *type = (const char *) clientarg;
  640.   if (type == NULL)  /* should never happen, since the arg is ours */
  641.     type = "unknown";
  643.   sprintf(line, "engineBoots %ld", engineBoots);
  644.   read_config_store(type, line);
  646.   engineIDLen = snmpv3_get_engineID(c_engineID, SNMP_MAXBUF_SMALL);
  648.   if (engineIDLen) {
  649.     /* store the engineID used for this run */
  650.     sprintf(line, "oldEngineID ");
  651.     read_config_save_octet_string(line+strlen(line), c_engineID,
  652.                                   engineIDLen);
  653.     read_config_store(type, line);
  654.   }
  655.   return SNMPERR_SUCCESS;
  656. }  /* snmpv3_store() */
  658. u_long
  659. snmpv3_local_snmpEngineBoots(void)
  660. {
  661.   return engineBoots;
  662. }
  665. /*******************************************************************-o-******
  666.  * snmpv3_get_engineID
  667.  *
  668.  * Parameters:
  669.  * *buf
  670.  *  buflen
  671.  *      
  672.  * Returns:
  673.  * Length of engineID On Success
  674.  * SNMPERR_GENERR Otherwise.
  675.  *
  676.  *
  677.  * Store engineID in buf; return the length.
  678.  *
  679.  */
  680. int
  681. snmpv3_get_engineID(u_char *buf, size_t buflen)
  682. {
  683.   /*
  684.    * Sanity check.
  685.    */
  686.   if ( !buf || (buflen < engineIDLength) ) {
  687.     return SNMPERR_GENERR;
  688.   }
  690.   memcpy(buf,engineID,engineIDLength);
  691.   return engineIDLength;
  693. }  /* end snmpv3_get_engineID() */
  695. /*******************************************************************-o-******
  696.  * snmpv3_clone_engineID
  697.  *
  698.  * Parameters:
  699.  * **dest
  700.  *       *dest_len
  701.  *       src
  702.  *  srclen
  703.  *      
  704.  * Returns:
  705.  * Length of engineID On Success
  706.  * 0         Otherwise.
  707.  *
  708.  *
  709.  * Clones engineID, creates memory
  710.  *
  711.  */
  712. int
  713. snmpv3_clone_engineID(u_char **dest, size_t* destlen, u_char*src, size_t srclen)
  714. {
  715.   if ( !dest || !destlen ) return 0;
  717.   *dest = NULL; *destlen = 0;
  719.   if (srclen && src) {
  720.     *dest = (u_char*)malloc((unsigned)srclen * sizeof(u_char));
  721.     if (*dest == NULL) return 0;
  722.     memmove(*dest, src, srclen * sizeof(u_char));
  723.     *destlen = srclen;
  724.   }
  725.   return *destlen;
  726. }  /* end snmpv3_clone_engineID() */
  729. /*******************************************************************-o-******
  730.  * snmpv3_generate_engineID
  731.  *
  732.  * Parameters:
  733.  * *length
  734.  *      
  735.  * Returns:
  736.  * Pointer to copy of engineID On Success.
  737.  * NULL If malloc() or snmpv3_get_engineID()
  738.  * fail.
  739.  *
  740.  * Generates a malloced copy of our engineID.
  741.  *
  742.  * 'length' is set to the length of engineID  -OR-  < 0 on failure.
  743.  */
  744. u_char *
  745. snmpv3_generate_engineID(size_t *length)
  746. {
  747.   u_char *newID;
  748.   newID = (u_char *) malloc(engineIDLength);
  750.   if (newID) {
  751.     *length = snmpv3_get_engineID(newID, engineIDLength);
  752.   }
  754.   if (*length < 0) {
  755.     SNMP_FREE(newID);
  756.     newID = NULL;
  757.   }
  759.   return newID;
  761. }  /* end snmpv3_generate_engineID() */
  763. /* snmpv3_local_snmpEngineTime(): return the number of seconds since the
  764.    snmpv3 engine last incremented engine_boots */
  765. u_long
  766. snmpv3_local_snmpEngineTime(void)
  767. {
  768.   struct timeval now;
  770.   gettimeofday(&now, NULL);
  771.   return calculate_time_diff(&now, &snmpv3starttime)/100;
  772. }
  774. #ifdef SNMP_TESTING_CODE
  775. /* snmpv3_set_engineBootsAndTime(): this function does not exist.  Go away. */
  776. /*   It certainly should never be used, unless in a testing scenero,
  777.      which is why it was created */
  778. void
  779. snmpv3_set_engineBootsAndTime(int boots, int ttime) {
  780.   engineBoots = boots;
  781.   gettimeofday(&snmpv3starttime, NULL);
  782.   snmpv3starttime.tv_sec -= ttime;
  783. }
  784. #endif
  786. #ifdef INCLUDE_SNMPV3
  787. /*Sunxi, 26, Feb 2004 */
  788. /*the flowing code is to manage snmpEngineIDs on remote hosts*/
  789. struct snmp_remote_engineID{
  790.     u_char remote_addr[16];/*SNMP engine on which host*/
  791.     u_short remote_port;/*on which port received SNMP messages(specially notification messages)*/
  792.     u_char remote_engineID[SNMP_MAX_ENG_SIZE];/*snmpEngineID*/
  793.     u_int reference_count;
  794.     struct snmp_remote_engineID *next;
  795. };
  797. struct snmp_remote_engineID *snmp_remote_engineID_list = NULL;
  799. #define FOREACH_ENGINE(pe) 
  800.     for(pe = snmp_remote_engineID_list; pe != NULL; pe = pe->next)
  802. /*is engineID Greater/Equal*/
  803. #define COMPARE_EID(eid1, eid2, op) 
  804.     (strcmp(eid1->remote_addr, eid2->remote_addr) op 0)
  806. void snmpv3_add_remote_engineID(u_char* ipaddr, u_short port, u_char *engineID, size_t engineIDLen)
  807. {
  808.     struct snmp_remote_engineID *eID = malloc(sizeof(struct snmp_remote_engineID)), *ptr, *prev = NULL;
  809.     if (eID == NULL)
  810.         return;
  812.     memset((void *)eID, 0, sizeof(struct snmp_remote_engineID));
  814.     strncpy(eID->remote_addr, ipaddr, sizeof(eID->remote_addr));
  815.     eID->remote_port = port;
  816.     memcpy(eID->remote_engineID, engineID, engineIDLen);
  818.     if (snmp_remote_engineID_list == NULL) {
  819.         snmp_remote_engineID_list = eID;
  820.         return;
  821.     }
  823.     FOREACH_ENGINE(ptr) {
  824.         if (COMPARE_EID(ptr, eID, >)) {
  825.             prev = ptr;
  826.             continue;
  827.         }
  828.         if (COMPARE_EID(ptr, eID, ==)) {
  829.             if (ptr->remote_port == eID->remote_port) {
  830.                 /*duplicate remote engine ID*/
  831.                 /*update remote user list and host list*/
  832.                 refreshV3TrapSession(ipaddr, engineID, engineIDLen);
  833.                 refresh_snmp_user_engineID(ptr->remote_engineID, SNMP_MAX_ENG_SIZE, engineID, engineIDLen);
  835.                 /*replace the old one*/
  836.                 memset((void*)ptr->remote_engineID, 0, sizeof(ptr->remote_engineID));
  837.                 memcpy(ptr->remote_engineID, engineID, engineIDLen);
  838.                 free(eID);
  839.                 return;
  840.             }
  841.         } else /*ptr < eID*/
  842.             break;
  843.     }
  844.     if (ptr == NULL) {
  845.         /*add to tail*/
  846.         prev->next = eID;
  847.     } else if (prev == NULL) {
  848.         /*add to head*/
  849.         eID->next = snmp_remote_engineID_list;
  850.         snmp_remote_engineID_list = eID;
  851.     } else {
  852.         eID->next = prev->next;
  853.         prev->next = eID;
  854.     }
  855. }
  857. void snmpv3_delete_remote_engineID(u_char *ipaddr, u_short port)
  858. {
  859.     struct snmp_remote_engineID *ptr, *prev = NULL, temp;
  861.     strncpy(temp.remote_addr, ipaddr, sizeof(temp.remote_addr));
  862.     temp.remote_port = port;
  863.     FOREACH_ENGINE(ptr) {
  864.         if (COMPARE_EID(ptr, (&temp), >)) {
  865.             prev = ptr;
  866.             continue;
  867.         }
  868.         if (COMPARE_EID(ptr, (&temp), ==)) {
  869.             if (ptr->remote_port == port) {
  870.                 /*found it!!!*/
  871.                 if (ptr->reference_count != 0) {
  872.                     syslog(LOG_WARNING, "%%SNMP-%d-ENGINEID: The engineID is used by SNMP-hosts or SNMP users. It can't be deletedn", LOG_WARNING);
  873.                     return;
  874.                 }
  875.                 if (prev == NULL) {
  876.                     /*first remote engine ID to be removed*/
  877.                     snmp_remote_engineID_list = ptr->next;
  878.                 } else
  879.                     prev->next = ptr->next;
  880.                 free(ptr);
  881.                 return;
  882.             }
  883.         } else /*not found*/
  884.             return;
  885.     }
  886. }
  888. char *snmpv3_get_remote_engineID(u_char *ipaddr, u_short port)
  889. {
  890.     struct snmp_remote_engineID *ptr, temp;
  892.     strncpy(temp.remote_addr, ipaddr, sizeof(temp.remote_addr));
  893.     temp.remote_port = port;
  894.     FOREACH_ENGINE(ptr) {
  895.         if (COMPARE_EID(ptr, (&temp), >))
  896.             continue;
  897.         if (COMPARE_EID(ptr, (&temp), ==)) {
  898.             if (ptr->remote_port == port) {
  899.                 /*found it!!!*/
  900.                 return ptr->remote_engineID;
  901.             }
  902.         } else /*not found*/
  903.             return NULL;
  904.     }
  905.     return NULL;
  906. }
  908. void snmpv3_get_remote_host_info_by_engineID(u_char *snmpEngineID, u_char **addr, u_short *port)
  909. {
  910.     struct snmp_remote_engineID *ptr;
  912.     assert(snmpEngineID && addr && port);
  914.     *addr = NULL;
  915.     *port = 0;
  916.     FOREACH_ENGINE(ptr) {
  917.         if (memcmp(snmpEngineID, ptr->remote_engineID, sizeof(ptr->remote_engineID)) == 0) {
  918.             *addr = ptr->remote_addr;
  919.             *port = ptr->remote_port;
  920.             return;
  921.         }
  922.     }
  923. }
  925. void snmpv3_inc_remote_engineID_reference(u_char *ipaddr, u_short port)
  926. {
  927.     struct snmp_remote_engineID *ptr, temp;
  929.     strncpy(temp.remote_addr, ipaddr, sizeof(temp.remote_addr));
  930.     temp.remote_port = port;
  931.     FOREACH_ENGINE(ptr) {
  932.         if (COMPARE_EID(ptr, (&temp), >))
  933.             continue;
  934.         if (COMPARE_EID(ptr, (&temp), ==)) {
  935.             if (ptr->remote_port == port) {
  936.                 /*found it!!!*/
  937.                 ptr->reference_count++;
  938.                 return;
  939.             }
  940.         } else /*not found*/
  941.             return;
  942.     }
  943.     return ;
  944. }
  946. void snmpv3_dec_remote_engineID_reference(u_char *ipaddr, u_short port)
  947. {
  948.     struct snmp_remote_engineID *ptr, temp;
  950.     strncpy(temp.remote_addr, ipaddr, sizeof(temp.remote_addr));
  951.     temp.remote_port = port;
  952.     FOREACH_ENGINE(ptr) {
  953.         if (COMPARE_EID(ptr, (&temp), >))
  954.             continue;
  955.         if (COMPARE_EID(ptr, (&temp), ==)) {
  956.             if (ptr->remote_port == port) {
  957.                 /*found it!!!*/
  958.                 ptr->reference_count--;
  959.                 return;
  960.             }
  961.         } else /*not found*/
  962.             return;
  963.     }
  964.     return ;
  965. }
  967. void snmpv3_engineID2str(char *engineID, size_t engineIDLen, char *dest)
  968. {
  969.     int i;
  971.     assert(engineID && dest);
  972.     for(i=0;i<engineIDLen;i++)
  973.         sprintf(dest + i * 2, "%02x", (int)(engineID[i]));
  975.     /*trunc endding zeros'*/
  976.     for(i=engineIDLen * 2 - 1;i>=0;i--)
  977.         if (dest[i] == '0')
  978.             dest[i] = 0;
  979.         else
  980.             return;
  981. }
  983. void do_show_snmpv3_remote_engineID()
  984. {
  985.     struct snmp_remote_engineID *ptr;
  986.     char engineIDstr[SNMP_MAX_ENG_SIZE * 2 + 1];
  988.     vty_printf("Remote Engine ID                IP-addr    Portn");
  989.     FOREACH_ENGINE(ptr) {
  990.         memset((void *)engineIDstr, 0, sizeof(engineIDstr));
  991.         snmpv3_engineID2str(ptr->remote_engineID, SNMP_MAX_ENG_SIZE, engineIDstr);
  993.         if (strlen(engineIDstr) <= 32)
  994.             vty_printf("%.32s %.16s     %dn",
  995.                 engineIDstr, ptr->remote_addr, ptr->remote_port);
  996.         else
  997.             vty_printf("%s n                                  %.16s     %dn",
  998.                 engineIDstr, ptr->remote_addr, ptr->remote_port);
  999.     }
  1000. }
  1002. BOOL do_showrunning_snmpv3_remote_engineID()
  1003. {
  1004.     struct snmp_remote_engineID *ptr;
  1005.     char engineIDstr[SNMP_MAX_ENG_SIZE * 2 + 1];
  1007.     if (snmp_remote_engineID_list == NULL)
  1008.         return FALSE;
  1009.     FOREACH_ENGINE(ptr) {
  1010.         memset((void *)engineIDstr, 0, sizeof(engineIDstr));
  1011.         snmpv3_engineID2str(ptr->remote_engineID, SNMP_MAX_ENG_SIZE, engineIDstr);
  1012.         vty_printf("snmp-server engineID remote %s ", ptr->remote_addr);
  1013.         if (ptr->remote_port != SNMP_TRAP_PORT)
  1014.             vty_printf("udp-port %d ", ptr->remote_port);
  1015.         vty_printf("%sn", engineIDstr);
  1016.     }
  1017.     return TRUE;
  1018. }
  1020. /*end add*/
  1021. #endif /*INCLUDE_SNMPV3*/