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

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

SNMP编程

开发平台：

Unix_Linux

snmpv3.c：源码内容
  1. /*
  2.  * snmpv3.c
  3.  */
  5. #include <net-snmp/net-snmp-config.h>
  6. #ifdef HAVE_LIMITS_H
  7. #include <limits.h>
  8. #endif
  9. #include <stdio.h>
  10. #include <sys/types.h>
  12. #if TIME_WITH_SYS_TIME
  13. # ifdef WIN32
  14. #  include <sys/timeb.h>
  15. # else
  16. #  include <sys/time.h>
  17. # endif
  18. # include <time.h>
  19. #else
  20. # if HAVE_SYS_TIME_H
  21. #  include <sys/time.h>
  22. # else
  23. #  include <time.h>
  24. # endif
  25. #endif
  26. #if HAVE_SYS_TIMES_H
  27. #include <sys/times.h>
  28. #endif
  29. #if HAVE_STRING_H
  30. #include <string.h>
  31. #else
  32. #include <strings.h>
  33. #endif
  34. #include <ctype.h>
  35. #if HAVE_NETINET_IN_H
  36. #include <netinet/in.h>
  37. #endif
  38. #if HAVE_UNISTD_H
  39. #include <unistd.h>
  40. #endif
  41. #if HAVE_WINSOCK_H
  42. #include <winsock.h>
  43. #endif
  44. #if HAVE_SYS_SOCKET_H
  45. #include <sys/socket.h>
  46. #endif
  47. #if HAVE_NETDB_H
  48. #include <netdb.h>
  49. #endif
  50. #if HAVE_STDLIB_H
  51. #       include <stdlib.h>
  52. #endif
  54. /*
  55.  * Stuff needed for getHwAddress(...) 
  56.  */
  57. #ifdef HAVE_SYS_IOCTL_H
  58. # include <sys/ioctl.h>
  59. #endif
  60. #ifdef HAVE_NET_IF_H
  61. # include <net/if.h>
  62. #endif
  64. #if HAVE_DMALLOC_H
  65. #include <dmalloc.h>
  66. #endif
  68. #include <net-snmp/types.h>
  69. #include <net-snmp/output_api.h>
  70. #include <net-snmp/config_api.h>
  71. #include <net-snmp/utilities.h>
  73. #include <net-snmp/library/snmpv3.h>
  74. #include <net-snmp/library/callback.h>
  75. #include <net-snmp/library/snmp_api.h>
  76. #include <net-snmp/library/lcd_time.h>
  77. #include <net-snmp/library/scapi.h>
  78. #include <net-snmp/library/keytools.h>
  79. #include <net-snmp/library/lcd_time.h>
  80. #include <net-snmp/library/snmp_secmod.h>
  81. #include <net-snmp/library/snmpusm.h>
  82. #include <net-snmp/library/transform_oids.h>
  84. static u_long   engineBoots = 1;
  85. static unsigned int engineIDType = ENGINEID_TYPE_NETSNMP_RND;
  86. static unsigned char *engineID = NULL;
  87. static size_t   engineIDLength = 0;
  88. static unsigned char *engineIDNic = NULL;
  89. static unsigned int engineIDIsSet = 0;  /* flag if ID set by config */
  90. static unsigned char *oldEngineID = NULL;
  91. static size_t   oldEngineIDLength = 0;
  92. static struct timeval snmpv3starttime;
  94. /*
  95.  * Set up default snmpv3 parameter value storage.
  96.  */
  97. static const oid *defaultAuthType = NULL;
  98. static size_t   defaultAuthTypeLen = 0;
  99. static const oid *defaultPrivType = NULL;
  100. static size_t   defaultPrivTypeLen = 0;
  102. /* this is probably an over-kill ifdef, but why not */
  103. #if defined(HAVE_SYS_TIMES_H) && defined(HAVE_UNISTD_H) && defined(HAVE_TIMES) && defined(_SC_CLK_TCK) && defined(HAVE_SYSCONF) && defined(UINT_MAX)
  105. #define SNMP_USE_TIMES 1
  107. static clock_t snmpv3startClock;
  108. static long clockticks = 0;
  109. static unsigned int lastcalltime = 0;
  110. static unsigned int wrapcounter = 0;
  112. #endif /* times() tests */
  114. #if defined(IFHWADDRLEN) && defined(SIOCGIFHWADDR)
  115. static int      getHwAddress(const char *networkDevice, char *addressOut);
  116. #endif
  118. void
  119. snmpv3_authtype_conf(const char *word, char *cptr)
  120. {
  121. #ifndef DISABLE_MD5
  122.     if (strcasecmp(cptr, "MD5") == 0)
  123.         defaultAuthType = usmHMACMD5AuthProtocol;
  124.     else
  125. #endif
  126.         if (strcasecmp(cptr, "SHA") == 0)
  127.         defaultAuthType = usmHMACSHA1AuthProtocol;
  128.     else
  129.         config_perror("Unknown authentication type");
  130.     defaultAuthTypeLen = USM_LENGTH_OID_TRANSFORM;
  131.     DEBUGMSGTL(("snmpv3", "set default authentication type: %sn", cptr));
  132. }
  134. const oid      *
  135. get_default_authtype(size_t * len)
  136. {
  137.     if (defaultAuthType == NULL) {
  138.         defaultAuthType = SNMP_DEFAULT_AUTH_PROTO;
  139.         defaultAuthTypeLen = SNMP_DEFAULT_AUTH_PROTOLEN;
  140.     }
  141.     if (len)
  142.         *len = defaultAuthTypeLen;
  143.     return defaultAuthType;
  144. }
  146. void
  147. snmpv3_privtype_conf(const char *word, char *cptr)
  148. {
  149.     int testcase = 0;
  151. #ifndef DISABLE_DES
  152.     if (strcasecmp(cptr, "DES") == 0) {
  153.         testcase = 1;
  154.         defaultPrivType = usmDESPrivProtocol;
  155.     }
  156. #endif
  158. #if HAVE_AES
  159.     /* XXX AES: assumes oid length == des oid length */
  160.     if (strcasecmp(cptr, "AES128") == 0 ||
  161.         strcasecmp(cptr, "AES") == 0) {
  162.         testcase = 1;
  163.         defaultPrivType = usmAES128PrivProtocol;
  164.     }
  165. #endif
  166.     if (testcase == 0)
  167.         config_perror("Unknown privacy type");
  168.     defaultPrivTypeLen = SNMP_DEFAULT_PRIV_PROTOLEN;
  169.     DEBUGMSGTL(("snmpv3", "set default privacy type: %sn", cptr));
  170. }
  172. const oid      *
  173. get_default_privtype(size_t * len)
  174. {
  175.     if (defaultPrivType == NULL) {
  176. #ifndef DISABLE_DES
  177.         defaultPrivType = usmDESPrivProtocol;
  178. #else
  179.         defaultPrivType = usmAESPrivProtocol;
  180. #endif
  181.         defaultPrivTypeLen = USM_LENGTH_OID_TRANSFORM;
  182.     }
  183.     if (len)
  184.         *len = defaultPrivTypeLen;
  185.     return defaultPrivType;
  186. }
  188. /*******************************************************************-o-******
  189.  * snmpv3_secLevel_conf
  190.  *
  191.  * Parameters:
  192.  * *word
  193.  * *cptr
  194.  *
  195.  * Line syntax:
  196.  * defSecurityLevel "noAuthNoPriv" | "authNoPriv" | "authPriv"
  197.  */
  198. void
  199. snmpv3_secLevel_conf(const char *word, char *cptr)
  200. {
  201.     char            buf[1024];
  203.     if (strcasecmp(cptr, "noAuthNoPriv") == 0 || strcmp(cptr, "1") == 0 ||
  204. strcasecmp(cptr, "nanp") == 0) {
  205.         netsnmp_ds_set_int(NETSNMP_DS_LIBRARY_ID, 
  206.    NETSNMP_DS_LIB_SECLEVEL, SNMP_SEC_LEVEL_NOAUTH);
  207.     } else if (strcasecmp(cptr, "authNoPriv") == 0 || strcmp(cptr, "2") == 0 ||
  208.        strcasecmp(cptr, "anp") == 0) {
  209.         netsnmp_ds_set_int(NETSNMP_DS_LIBRARY_ID, 
  210.    NETSNMP_DS_LIB_SECLEVEL, SNMP_SEC_LEVEL_AUTHNOPRIV);
  211.     } else if (strcasecmp(cptr, "authPriv") == 0 || strcmp(cptr, "3") == 0 ||
  212.        strcasecmp(cptr, "ap") == 0) {
  213.         netsnmp_ds_set_int(NETSNMP_DS_LIBRARY_ID, 
  214.    NETSNMP_DS_LIB_SECLEVEL, SNMP_SEC_LEVEL_AUTHPRIV);
  215.     } else {
  216.         snprintf(buf, sizeof(buf), "Unknown security level: %s", cptr);
  217.         buf[ sizeof(buf)-1 ] = 0;
  218.         config_perror(buf);
  219.     }
  220.     DEBUGMSGTL(("snmpv3", "default secLevel set to: %s = %dn", cptr,
  221.                 netsnmp_ds_get_int(NETSNMP_DS_LIBRARY_ID, 
  222.    NETSNMP_DS_LIB_SECLEVEL)));
  223. }
  226. int
  227. snmpv3_options(char *optarg, netsnmp_session * session, char **Apsz,
  228.                char **Xpsz, int argc, char *const *argv)
  229. {
  230.     char           *cp = optarg;
  231.     int testcase;
  232.     optarg++;
  233.     /*
  234.      * Support '... -3x=value ....' syntax
  235.      */
  236.     if (*optarg == '=') {
  237.         optarg++;
  238.     }
  239.     /*
  240.      * and '.... "-3x value" ....'  (*with* the quotes)
  241.      */
  242.     while (*optarg && isspace(*optarg)) {
  243.         optarg++;
  244.     }
  245.     /*
  246.      * Finally, handle ".... -3x value ...." syntax
  247.      *   (*without* surrounding quotes)
  248.      */
  249.     if (!*optarg) {
  250.         /*
  251.          * We've run off the end of the argument
  252.          *  so move on the the next.
  253.          */
  254.         optarg = argv[optind++];
  255.         if (optind > argc) {
  256.             fprintf(stderr,
  257.                     "Missing argument after SNMPv3 '-3%c' option.n", *cp);
  258.             return (-1);
  259.         }
  260.     }
  262.     switch (*cp) {
  264.     case 'Z':
  265.         session->engineBoots = strtoul(optarg, NULL, 10);
  266.         if (session->engineBoots == 0 || !isdigit(optarg[0])) {
  267.             fprintf(stderr, "Need engine boots value after -3Z flag.n");
  268.             return (-1);
  269.         }
  270.         cp = strchr(optarg, ',');
  271.         if (cp && *(++cp) && isdigit(*cp))
  272.             session->engineTime = strtoul(cp, NULL, 10);
  273.         else {
  274.             fprintf(stderr, "Need engine time value after -3Z flag.n");
  275.             return (-1);
  276.         }
  277.         break;
  279.     case 'e':{
  280.             size_t          ebuf_len = 32, eout_len = 0;
  281.             u_char         *ebuf = (u_char *) malloc(ebuf_len);
  283.             if (ebuf == NULL) {
  284.                 fprintf(stderr, "malloc failure processing -3e flag.n");
  285.                 return (-1);
  286.             }
  287.             if (!snmp_hex_to_binary
  288.                 (&ebuf, &ebuf_len, &eout_len, 1, optarg)) {
  289.                 fprintf(stderr, "Bad engine ID value after -3e flag.n");
  290.                 SNMP_FREE(ebuf);
  291.                 return (-1);
  292.             }
  293.             session->securityEngineID = ebuf;
  294.             session->securityEngineIDLen = eout_len;
  295.             break;
  296.         }
  298.     case 'E':{
  299.             size_t          ebuf_len = 32, eout_len = 0;
  300.             u_char         *ebuf = (u_char *) malloc(ebuf_len);
  302.             if (ebuf == NULL) {
  303.                 fprintf(stderr, "malloc failure processing -3E flag.n");
  304.                 return (-1);
  305.             }
  306.             if (!snmp_hex_to_binary
  307.                 (&ebuf, &ebuf_len, &eout_len, 1, optarg)) {
  308.                 fprintf(stderr, "Bad engine ID value after -3E flag.n");
  309.                 SNMP_FREE(ebuf);
  310.                 return (-1);
  311.             }
  312.             session->contextEngineID = ebuf;
  313.             session->contextEngineIDLen = eout_len;
  314.             break;
  315.         }
  317.     case 'n':
  318.         session->contextName = optarg;
  319.         session->contextNameLen = strlen(optarg);
  320.         break;
  322.     case 'u':
  323.         session->securityName = optarg;
  324.         session->securityNameLen = strlen(optarg);
  325.         break;
  327.     case 'l':
  328.         if (!strcasecmp(optarg, "noAuthNoPriv") || !strcmp(optarg, "1") ||
  329.             !strcasecmp(optarg, "nanp")) {
  330.             session->securityLevel = SNMP_SEC_LEVEL_NOAUTH;
  331.         } else if (!strcasecmp(optarg, "authNoPriv")
  332.                    || !strcmp(optarg, "2") || !strcasecmp(optarg, "anp")) {
  333.             session->securityLevel = SNMP_SEC_LEVEL_AUTHNOPRIV;
  334.         } else if (!strcasecmp(optarg, "authPriv") || !strcmp(optarg, "3")
  335.                    || !strcasecmp(optarg, "ap")) {
  336.             session->securityLevel = SNMP_SEC_LEVEL_AUTHPRIV;
  337.         } else {
  338.             fprintf(stderr,
  339.                     "Invalid security level specified after -3l flag: %sn",
  340.                     optarg);
  341.             return (-1);
  342.         }
  344.         break;
  346.     case 'a':
  347. #ifndef DISABLE_MD5
  348.         if (!strcasecmp(optarg, "MD5")) {
  349.             session->securityAuthProto = usmHMACMD5AuthProtocol;
  350.             session->securityAuthProtoLen = USM_AUTH_PROTO_MD5_LEN;
  351.         } else
  352. #endif
  353.             if (!strcasecmp(optarg, "SHA")) {
  354.             session->securityAuthProto = usmHMACSHA1AuthProtocol;
  355.             session->securityAuthProtoLen = USM_AUTH_PROTO_SHA_LEN;
  356.         } else {
  357.             fprintf(stderr,
  358.                     "Invalid authentication protocol specified after -3a flag: %sn",
  359.                     optarg);
  360.             return (-1);
  361.         }
  362.         break;
  364.     case 'x':
  365.         testcase = 0;
  366. #ifndef DISABLE_DES
  367.         if (!strcasecmp(optarg, "DES")) {
  368.             session->securityPrivProto = usmDESPrivProtocol;
  369.             session->securityPrivProtoLen = USM_PRIV_PROTO_DES_LEN;
  370.             testcase = 1;
  371.         }
  372. #endif
  373. #ifdef HAVE_AES
  374.         if (!strcasecmp(optarg, "AES128") ||
  375.             strcasecmp(optarg, "AES")) {
  376.             session->securityPrivProto = usmAES128PrivProtocol;
  377.             session->securityPrivProtoLen = USM_PRIV_PROTO_AES128_LEN;
  378.             testcase = 1;
  379.         }
  380. #endif
  381.         if (testcase == 0) {
  382.             fprintf(stderr,
  383.                     "Invalid privacy protocol specified after -3x flag: %sn",
  384.                     optarg);
  385.             return (-1);
  386.         }
  387.         break;
  389.     case 'A':
  390.         *Apsz = optarg;
  391.         break;
  393.     case 'X':
  394.         *Xpsz = optarg;
  395.         break;
  397.     case 'm': {
  398.         size_t bufSize = sizeof(session->securityAuthKey);
  399.         u_char *tmpp = session->securityAuthKey;
  400.         if (!snmp_hex_to_binary(&tmpp, &bufSize,
  401.                                 &session->securityAuthKeyLen, 0, optarg)) {
  402.             fprintf(stderr, "Bad key value after -3m flag.n");
  403.             return (-1);
  404.         }
  405.         break;
  406.     }
  408.     case 'M': {
  409.         size_t bufSize = sizeof(session->securityPrivKey);
  410.         u_char *tmpp = session->securityPrivKey;
  411.         if (!snmp_hex_to_binary(&tmpp, &bufSize,
  412.              &session->securityPrivKeyLen, 0, optarg)) {
  413.             fprintf(stderr, "Bad key value after -3M flag.n");
  414.             return (-1);
  415.         }
  416.         break;
  417.     }
  419.     case 'k': {
  420.         size_t          kbuf_len = 32, kout_len = 0;
  421.         u_char         *kbuf = (u_char *) malloc(kbuf_len);
  423.         if (kbuf == NULL) {
  424.             fprintf(stderr, "malloc failure processing -3k flag.n");
  425.             return (-1);
  426.         }
  427.         if (!snmp_hex_to_binary
  428.             (&kbuf, &kbuf_len, &kout_len, 1, optarg)) {
  429.             fprintf(stderr, "Bad key value after -3k flag.n");
  430.             SNMP_FREE(kbuf);
  431.             return (-1);
  432.         }
  433.         session->securityAuthLocalKey = kbuf;
  434.         session->securityAuthLocalKeyLen = kout_len;
  435.         break;
  436.     }
  438.     case 'K': {
  439.         size_t          kbuf_len = 32, kout_len = 0;
  440.         u_char         *kbuf = (u_char *) malloc(kbuf_len);
  442.         if (kbuf == NULL) {
  443.             fprintf(stderr, "malloc failure processing -3K flag.n");
  444.             return (-1);
  445.         }
  446.         if (!snmp_hex_to_binary
  447.             (&kbuf, &kbuf_len, &kout_len, 1, optarg)) {
  448.             fprintf(stderr, "Bad key value after -3K flag.n");
  449.             SNMP_FREE(kbuf);
  450.             return (-1);
  451.         }
  452.         session->securityPrivLocalKey = kbuf;
  453.         session->securityPrivLocalKeyLen = kout_len;
  454.         break;
  455.     }
  456.         
  457.     default:
  458.         fprintf(stderr, "Unknown SNMPv3 option passed to -3: %c.n", *cp);
  459.         return -1;
  460.     }
  461.     return 0;
  462. }
  464. /*******************************************************************-o-******
  465.  * setup_engineID
  466.  *
  467.  * Parameters:
  468.  * **eidp
  469.  *  *text Printable (?) text to be plugged into the snmpEngineID.
  470.  *
  471.  * Return:
  472.  * Length of allocated engineID string in bytes,  -OR-
  473.  * -1 on error.
  474.  *
  475.  *
  476.  * Create an snmpEngineID using text and the local IP address.  If eidp
  477.  * is defined, use it to return a pointer to the newly allocated data.
  478.  * Otherwise, use the result to define engineID defined in this module.
  479.  *
  480.  * Line syntax:
  481.  * engineID <text> | NULL
  482.  *
  483.  * XXX What if a node has multiple interfaces?
  484.  * XXX What if multiple engines all choose the same address?
  485.  *      (answer:  You're screwed, because you might need a kul database
  486.  *       which is dependant on the current engineID.  Enumeration and other
  487.  *       tricks won't work). 
  488.  */
  489. int
  490. setup_engineID(u_char ** eidp, const char *text)
  491. {
  492.     int             enterpriseid = htonl(ENTERPRISE_OID),
  493.         netsnmpoid = htonl(NETSNMP_OID),
  494.         localsetup = (eidp) ? 0 : 1;
  496.     /*
  497.      * Use local engineID if *eidp == NULL.  
  498.      */
  499. #ifdef HAVE_GETHOSTNAME
  500.     u_char          buf[SNMP_MAXBUF_SMALL];
  501.     struct hostent *hent = NULL;
  502. #endif
  503.     u_char         *bufp = NULL;
  504.     size_t          len;
  505.     int             localEngineIDType = engineIDType;
  506.     int             tmpint;
  507.     time_t          tmptime;
  509.     engineIDIsSet = 1;
  511. #ifdef HAVE_GETHOSTNAME
  512. #ifdef AF_INET6
  513.     /*
  514.      * see if they selected IPV4 or IPV6 support 
  515.      */
  516.     if ((ENGINEID_TYPE_IPV6 == localEngineIDType) ||
  517.         (ENGINEID_TYPE_IPV4 == localEngineIDType)) {
  518.         /*
  519.          * get the host name and save the information 
  520.          */
  521.         gethostname((char *) buf, sizeof(buf));
  522.         hent = gethostbyname((char *) buf);
  523.         if (hent && hent->h_addrtype == AF_INET6) {
  524.             localEngineIDType = ENGINEID_TYPE_IPV6;
  525.         } else {
  526.             /*
  527.              * Not IPV6 so we go with default 
  528.              */
  529.             localEngineIDType = ENGINEID_TYPE_IPV4;
  530.         }
  531.     }
  532. #else
  533.     /*
  534.      * No IPV6 support.  Check if they selected IPV6 engineID type.
  535.      *  If so make it IPV4 instead 
  536.      */
  537.     if (ENGINEID_TYPE_IPV6 == localEngineIDType) {
  538.         localEngineIDType = ENGINEID_TYPE_IPV4;
  539.     }
  540.     if (ENGINEID_TYPE_IPV4 == localEngineIDType) {
  541.         /*
  542.          * get the host name and save the information 
  543.          */
  544.         gethostname((char *) buf, sizeof(buf));
  545.         hent = gethostbyname((char *) buf);
  546.     }
  547. #endif
  548. #endif                          /* HAVE_GETHOSTNAME */
  550.     /*
  551.      * Determine if we have text and if so setup our localEngineIDType
  552.      * * appropriately.  
  553.      */
  554.     if (NULL != text) {
  555.         engineIDType = localEngineIDType = ENGINEID_TYPE_TEXT;
  556.     }
  557.     /*
  558.      * Determine length of the engineID string. 
  559.      */
  560.     len = 5;                    /* always have 5 leading bytes */
  561.     switch (localEngineIDType) {
  562.     case ENGINEID_TYPE_TEXT:
  563.         len += strlen(text);    /* 5 leading bytes+text. No NULL char */
  564.         break;
  565. #if defined(IFHWADDRLEN) && defined(SIOCGIFHWADDR)
  566.     case ENGINEID_TYPE_MACADDR:        /* MAC address */
  567.         len += 6;               /* + 6 bytes for MAC address */
  568.         break;
  569. #endif
  570.     case ENGINEID_TYPE_IPV4:   /* IPv4 */
  571.         len += 4;               /* + 4 byte IPV4 address */
  572.         break;
  573.     case ENGINEID_TYPE_IPV6:   /* IPv6 */
  574.         len += 16;              /* + 16 byte IPV6 address */
  575.         break;
  576.     case ENGINEID_TYPE_NETSNMP_RND:        /* Net-SNMP specific encoding */
  577.         if (engineID)           /* already setup, keep current value */
  578.             return engineIDLength;
  579.         if (oldEngineID) {
  580.             len = oldEngineIDLength;
  581.         } else {
  582.             len += sizeof(int) + sizeof(time_t);
  583.         }
  584.         break;
  585.     default:
  586.         snmp_log(LOG_ERR,
  587.                  "Unknown EngineID type requested for setup (%d).  Using IPv4.n",
  588.                  localEngineIDType);
  589.         localEngineIDType = ENGINEID_TYPE_IPV4; /* make into IPV4 */
  590.         len += 4;               /* + 4 byte IPv4 address */
  591.         break;
  592.     }                           /* switch */
  595.     /*
  596.      * Allocate memory and store enterprise ID.
  597.      */
  598.     if ((bufp = (u_char *) malloc(len)) == NULL) {
  599.         snmp_log_perror("setup_engineID malloc");
  600.         return -1;
  601.     }
  602.     if (localEngineIDType == ENGINEID_TYPE_NETSNMP_RND)
  603.         /*
  604.          * we must use the net-snmp enterprise id here, regardless 
  605.          */
  606.         memcpy(bufp, &netsnmpoid, sizeof(netsnmpoid));    /* XXX Must be 4 bytes! */
  607.     else
  608.         memcpy(bufp, &enterpriseid, sizeof(enterpriseid));      /* XXX Must be 4 bytes! */
  610.     bufp[0] |= 0x80;
  613.     /*
  614.      * Store the given text  -OR-   the first found IP address
  615.      *  -OR-  the MAC address  -OR-  random elements
  616.      * (the latter being the recommended default)
  617.      */
  618.     switch (localEngineIDType) {
  619.     case ENGINEID_TYPE_NETSNMP_RND:
  620.         if (oldEngineID) {
  621.             /*
  622.              * keep our previous notion of the engineID 
  623.              */
  624.             memcpy(bufp, oldEngineID, oldEngineIDLength);
  625.         } else {
  626.             /*
  627.              * Here we've desigend our own ENGINEID that is not based on
  628.              * an address which may change and may even become conflicting
  629.              * in the future like most of the default v3 engineID types
  630.              * suffer from.
  631.              * 
  632.              * Ours is built from 2 fairly random elements: a random number and
  633.              * the current time in seconds.  This method suffers from boxes
  634.              * that may not have a correct clock setting and random number
  635.              * seed at startup, but few OSes should have that problem.
  636.              */
  637.             bufp[4] = ENGINEID_TYPE_NETSNMP_RND;
  638.             tmpint = random();
  639.             memcpy(bufp + 5, &tmpint, sizeof(tmpint));
  640.             tmptime = time(NULL);
  641.             memcpy(bufp + 5 + sizeof(tmpint), &tmptime, sizeof(tmptime));
  642.         }
  643.         break;
  644.     case ENGINEID_TYPE_TEXT:
  645.         bufp[4] = ENGINEID_TYPE_TEXT;
  646.         memcpy((char *) bufp + 5, text, strlen(text));
  647.         break;
  648. #ifdef HAVE_GETHOSTNAME
  649. #ifdef AF_INET6
  650.     case ENGINEID_TYPE_IPV6:
  651.         bufp[4] = ENGINEID_TYPE_IPV6;
  652.         memcpy(bufp + 5, hent->h_addr_list[0], hent->h_length);
  653.         break;
  654. #endif
  655. #endif
  656. #if defined(IFHWADDRLEN) && defined(SIOCGIFHWADDR)
  657.     case ENGINEID_TYPE_MACADDR:
  658.         {
  659.             int             x;
  660.             bufp[4] = ENGINEID_TYPE_MACADDR;
  661.             /*
  662.              * use default NIC if none provided 
  663.              */
  664.             if (NULL == engineIDNic) {
  665.                 x = getHwAddress(DEFAULT_NIC, &bufp[5]);
  666.             } else {
  667.                 x = getHwAddress(engineIDNic, &bufp[5]);
  668.             }
  669.             if (0 != x)
  670.                 /*
  671.                  * function failed fill MAC address with zeros 
  672.                  */
  673.             {
  674.                 memset(&bufp[5], 0, 6);
  675.             }
  676.         }
  677.         break;
  678. #endif
  679.     case ENGINEID_TYPE_IPV4:
  680.     default:
  681.         bufp[4] = ENGINEID_TYPE_IPV4;
  682. #ifdef HAVE_GETHOSTNAME
  683.         if (hent && hent->h_addrtype == AF_INET) {
  684.             memcpy(bufp + 5, hent->h_addr_list[0], hent->h_length);
  685.         } else {                /* Unknown address type.  Default to 127.0.0.1. */
  687.             bufp[5] = 127;
  688.             bufp[6] = 0;
  689.             bufp[7] = 0;
  690.             bufp[8] = 1;
  691.         }
  692. #else                           /* HAVE_GETHOSTNAME */
  693.         /*
  694.          * Unknown address type.  Default to 127.0.0.1. 
  695.          */
  696.         bufp[5] = 127;
  697.         bufp[6] = 0;
  698.         bufp[7] = 0;
  699.         bufp[8] = 1;
  700. #endif                          /* HAVE_GETHOSTNAME */
  701.         break;
  702.     }
  704.     /*
  705.      * Pass the string back to the calling environment, or use it for
  706.      * our local engineID.
  707.      */
  708.     if (localsetup) {
  709.         SNMP_FREE(engineID);
  710.         engineID = bufp;
  711.         engineIDLength = len;
  713.     } else {
  714.         *eidp = bufp;
  715.     }
  718.     return len;
  720. }                               /* end setup_engineID() */
  722. int
  723. free_engineID(int majorid, int minorid, void *serverarg,
  724.       void *clientarg)
  725. {
  726.     SNMP_FREE(engineID);
  727.     SNMP_FREE(engineIDNic);
  728.     SNMP_FREE(oldEngineID);
  729.     return 0;
  730. }
  732. int
  733. free_enginetime_on_shutdown(int majorid, int minorid, void *serverarg,
  734.     void *clientarg)
  735. {
  736.     DEBUGMSGTL(("snmpv3", "free enginetime callback calledn"));
  737.     if (engineID != NULL)
  738. free_enginetime(engineID, engineIDLength);
  739.     return 0;
  740. }
  742. void
  743. usm_parse_create_usmUser(const char *token, char *line)
  744. {
  745.     char           *cp;
  746.     char            buf[SNMP_MAXBUF_MEDIUM];
  747.     struct usmUser *newuser;
  748.     u_char          userKey[SNMP_MAXBUF_SMALL], *tmpp;
  749.     size_t          userKeyLen = SNMP_MAXBUF_SMALL;
  750.     size_t          privKeyLen = 0;
  751.     size_t          ret;
  752.     int             testcase;
  754.     newuser = usm_create_user();
  756.     /*
  757.      * READ: Security Name 
  758.      */
  759.     cp = copy_nword(line, buf, sizeof(buf));
  761.     /*
  762.      * might be a -e ENGINEID argument 
  763.      */
  764.     if (strcmp(buf, "-e") == 0) {
  765.         size_t          ebuf_len = 32, eout_len = 0;
  766.         u_char         *ebuf = (u_char *) malloc(ebuf_len);
  768.         if (ebuf == NULL) {
  769.             config_perror("malloc failure processing -e flag");
  770.             usm_free_user(newuser);
  771.             return;
  772.         }
  774.         /*
  775.          * Get the specified engineid from the line.  
  776.          */
  777.         cp = copy_nword(cp, buf, sizeof(buf));
  778.         if (!snmp_hex_to_binary(&ebuf, &ebuf_len, &eout_len, 1, buf)) {
  779.             config_perror("invalid EngineID argument to -e");
  780.             usm_free_user(newuser);
  781.             SNMP_FREE(ebuf);
  782.             return;
  783.         }
  785.         newuser->engineID = ebuf;
  786.         newuser->engineIDLen = eout_len;
  787.         cp = copy_nword(cp, buf, sizeof(buf));
  788.     } else {
  789.         newuser->engineID = snmpv3_generate_engineID(&ret);
  790.         if (ret == 0) {
  791.             usm_free_user(newuser);
  792.             return;
  793.         }
  794.         newuser->engineIDLen = ret;
  795.     }
  797.     newuser->secName = strdup(buf);
  798.     newuser->name = strdup(buf);
  800.     if (!cp)
  801.         goto add;               /* no authentication or privacy type */
  803.     /*
  804.      * READ: Authentication Type 
  805.      */
  806. #ifndef DISABLE_MD5
  807.     if (strncmp(cp, "MD5", 3) == 0) {
  808.         memcpy(newuser->authProtocol, usmHMACMD5AuthProtocol,
  809.                sizeof(usmHMACMD5AuthProtocol));
  810.     } else
  811. #endif
  812.         if (strncmp(cp, "SHA", 3) == 0) {
  813.         memcpy(newuser->authProtocol, usmHMACSHA1AuthProtocol,
  814.                sizeof(usmHMACSHA1AuthProtocol));
  815.     } else {
  816.         config_perror("Unknown authentication protocol");
  817.         usm_free_user(newuser);
  818.         return;
  819.     }
  821.     cp = skip_token(cp);
  823.     /*
  824.      * READ: Authentication Pass Phrase or key
  825.      */
  826.     if (!cp) {
  827.         config_perror("no authentication pass phrase");
  828.         usm_free_user(newuser);
  829.         return;
  830.     }
  831.     cp = copy_nword(cp, buf, sizeof(buf));
  832.     if (strcmp(buf,"-m") == 0) {
  833.         /* a master key is specified */
  834.         cp = copy_nword(cp, buf, sizeof(buf));
  835.         ret = sizeof(userKey);
  836.         tmpp = userKey;
  837.         userKeyLen = 0;
  838.         if (!snmp_hex_to_binary(&tmpp, &ret, &userKeyLen, 0, buf)) {
  839.             config_perror("invalid key value argument to -m");
  840.             usm_free_user(newuser);
  841.             return;
  842.         }
  843.     } else if (strcmp(buf,"-l") != 0) {
  844.         /* a password is specified */
  845.         userKeyLen = sizeof(userKey);
  846.         ret = generate_Ku(newuser->authProtocol, newuser->authProtocolLen,
  847.                           (u_char *) buf, strlen(buf), userKey, &userKeyLen);
  848.         if (ret != SNMPERR_SUCCESS) {
  849.             config_perror("could not generate the authentication key from the "
  850.                           "suppiled pass phrase.");
  851.             usm_free_user(newuser);
  852.             return;
  853.         }
  854.     }        
  855.         
  856.     /*
  857.      * And turn it into a localized key 
  858.      */
  859.     ret =
  860.         sc_get_properlength(newuser->authProtocol,
  861.                             newuser->authProtocolLen);
  862.     if (ret <= 0) {
  863.         config_perror("Could not get proper authentication protocol key length");
  864.         return;
  865.     }
  866.     newuser->authKey = (u_char *) malloc(ret);
  868.     if (strcmp(buf,"-l") == 0) {
  869.         /* a local key is directly specified */
  870.         cp = copy_nword(cp, buf, sizeof(buf));
  871.         newuser->authKeyLen = 0;
  872.         if (!snmp_hex_to_binary(&newuser->authKey, &ret,
  873.                                 &newuser->authKeyLen, 0, buf)) {
  874.             config_perror("invalid key value argument to -l");
  875.             usm_free_user(newuser);
  876.             return;
  877.         }
  878.         if (ret != newuser->authKeyLen) {
  879.             config_perror("improper key length to -l");
  880.             usm_free_user(newuser);
  881.             return;
  882.         }
  883.     } else {
  884.         newuser->authKeyLen = ret;
  885.         ret = generate_kul(newuser->authProtocol, newuser->authProtocolLen,
  886.                            newuser->engineID, newuser->engineIDLen,
  887.                            userKey, userKeyLen,
  888.                            newuser->authKey, &newuser->authKeyLen);
  889.         if (ret != SNMPERR_SUCCESS) {
  890.             config_perror("could not generate localized authentication key "
  891.                           "(Kul) from the master key (Ku).");
  892.             usm_free_user(newuser);
  893.             return;
  894.         }
  895.     }
  897.     if (!cp)
  898.         goto add;               /* no privacy type (which is legal) */
  900.     /*
  901.      * READ: Privacy Type 
  902.      */
  903.     testcase = 0;
  904. #ifndef DISABLE_DES
  905.     if (strncmp(cp, "DES", 3) == 0) {
  906.         memcpy(newuser->privProtocol, usmDESPrivProtocol,
  907.                sizeof(usmDESPrivProtocol));
  908.         testcase = 1;
  909. /* DES uses a 128 bit key, 64 bits of which is a salt */
  910. privKeyLen = 16;
  911.     }
  912. #endif
  913. #ifdef HAVE_AES
  914.     if (strncmp(cp, "AES128", 6) == 0 ||
  915.                strncmp(cp, "AES", 3) == 0) {
  916.         memcpy(newuser->privProtocol, usmAESPrivProtocol,
  917.                sizeof(usmAESPrivProtocol));
  918.         testcase = 1;
  919. privKeyLen = 16;
  920.     }
  921. #endif
  922.     if (testcase == 0) {
  923.         config_perror("Unknown privacy protocol");
  924.         usm_free_user(newuser);
  925.         return;
  926.     }
  928.     cp = skip_token(cp);
  929.     /*
  930.      * READ: Encryption Pass Phrase or key
  931.      */
  932.     if (!cp) {
  933.         /*
  934.          * assume the same as the authentication key 
  935.          */
  936.         memdup(&newuser->privKey, newuser->authKey, newuser->authKeyLen);
  937.         newuser->privKeyLen = newuser->authKeyLen;
  938.     } else {
  939.         cp = copy_nword(cp, buf, sizeof(buf));
  940.         
  941.         if (strcmp(buf,"-m") == 0) {
  942.             /* a master key is specified */
  943.             cp = copy_nword(cp, buf, sizeof(buf));
  944.             ret = sizeof(userKey);
  945.             tmpp = userKey;
  946.             userKeyLen = 0;
  947.             if (!snmp_hex_to_binary(&tmpp, &ret, &userKeyLen, 0, buf)) {
  948.                 config_perror("invalid key value argument to -m");
  949.                 usm_free_user(newuser);
  950.                 return;
  951.             }
  952.         } else if (strcmp(buf,"-l") != 0) {
  953.             /* a password is specified */
  954.             userKeyLen = sizeof(userKey);
  955.             ret = generate_Ku(newuser->authProtocol, newuser->authProtocolLen,
  956.                               (u_char *) buf, strlen(buf), userKey, &userKeyLen);
  957.             if (ret != SNMPERR_SUCCESS) {
  958.                 config_perror("could not generate the privacy key from the "
  959.                               "suppiled pass phrase.");
  960.                 usm_free_user(newuser);
  961.                 return;
  962.             }
  963.         }        
  964.         
  965.         /*
  966.          * And turn it into a localized key 
  967.          */
  968.         ret =
  969.             sc_get_properlength(newuser->authProtocol,
  970.                                 newuser->authProtocolLen);
  971.         if (ret < 0) {
  972.             config_perror("could not get proper key length to use for the "
  973.                           "privacy algorithm.");
  974.             usm_free_user(newuser);
  975.             return;
  976.         }
  977.         newuser->privKey = (u_char *) malloc(ret);
  979.         if (strcmp(buf,"-l") == 0) {
  980.             /* a local key is directly specified */
  981.             cp = copy_nword(cp, buf, sizeof(buf));
  982.             newuser->privKeyLen = 0;
  983.             if (!snmp_hex_to_binary(&newuser->privKey, &ret,
  984.                                     &newuser->privKeyLen, 0, buf)) {
  985.                 config_perror("invalid key value argument to -l");
  986.                 usm_free_user(newuser);
  987.                 return;
  988.             }
  989.         } else {
  990.             newuser->privKeyLen = ret;
  991.             ret = generate_kul(newuser->authProtocol, newuser->authProtocolLen,
  992.                                newuser->engineID, newuser->engineIDLen,
  993.                                userKey, userKeyLen,
  994.                                newuser->privKey, &newuser->privKeyLen);
  995.             if (ret != SNMPERR_SUCCESS) {
  996.                 config_perror("could not generate localized privacy key "
  997.                               "(Kul) from the master key (Ku).");
  998.                 usm_free_user(newuser);
  999.                 return;
  1000.             }
  1001.         }
  1002.     }
  1004.     if ((newuser->privKeyLen >= privKeyLen) || (privKeyLen == 0)){
  1005.       newuser->privKeyLen = privKeyLen;
  1006.     }
  1007.     else {
  1008.       /* The privKey length is smaller than required by privProtocol */
  1009.       usm_free_user(newuser);
  1010.       return;
  1011.     }
  1013.   add:
  1014.     usm_add_user(newuser);
  1015.     DEBUGMSGTL(("usmUser", "created a new user %s at ", newuser->secName));
  1016.     DEBUGMSGHEX(("usmUser", newuser->engineID, newuser->engineIDLen));
  1017.     DEBUGMSG(("usmUser", "n"));
  1018. }
  1020. /*******************************************************************-o-******
  1021.  * engineBoots_conf
  1022.  *
  1023.  * Parameters:
  1024.  * *word
  1025.  * *cptr
  1026.  *
  1027.  * Line syntax:
  1028.  * engineBoots <num_boots>
  1029.  */
  1030. void
  1031. engineBoots_conf(const char *word, char *cptr)
  1032. {
  1033.     engineBoots = atoi(cptr) + 1;
  1034.     DEBUGMSGTL(("snmpv3", "engineBoots: %dn", engineBoots));
  1035. }
  1037. /*******************************************************************-o-******
  1038.  * engineIDType_conf
  1039.  *
  1040.  * Parameters:
  1041.  * *word
  1042.  * *cptr
  1043.  *
  1044.  * Line syntax:
  1045.  * engineIDType <1 or 3>
  1046.  * 1 is default for IPv4 engine ID type.  Will automatically
  1047.  *     chose between IPv4 & IPv6 if either 1 or 2 is specified.
  1048.  * 2 is for IPv6.
  1049.  * 3 is hardware (MAC) address, currently supported under Linux
  1050.  */
  1051. void
  1052. engineIDType_conf(const char *word, char *cptr)
  1053. {
  1054.     engineIDType = atoi(cptr);
  1055.     /*
  1056.      * verify valid type selected 
  1057.      */
  1058.     switch (engineIDType) {
  1059.     case ENGINEID_TYPE_IPV4:   /* IPv4 */
  1060.     case ENGINEID_TYPE_IPV6:   /* IPv6 */
  1061.         /*
  1062.          * IPV? is always good 
  1063.          */
  1064.         break;
  1065. #if defined(IFHWADDRLEN) && defined(SIOCGIFHWADDR)
  1066.     case ENGINEID_TYPE_MACADDR:        /* MAC address */
  1067.         break;
  1068. #endif
  1069.     default:
  1070.         /*
  1071.          * unsupported one chosen 
  1072.          */
  1073.         config_perror("Unsupported enginedIDType, forcing IPv4");
  1074.         engineIDType = ENGINEID_TYPE_IPV4;
  1075.     }
  1076.     DEBUGMSGTL(("snmpv3", "engineIDType: %dn", engineIDType));
  1077. }
  1079. /*******************************************************************-o-******
  1080.  * engineIDNic_conf
  1081.  *
  1082.  * Parameters:
  1083.  * *word
  1084.  * *cptr
  1085.  *
  1086.  * Line syntax:
  1087.  * engineIDNic <string>
  1088.  * eth0 is default
  1089.  */
  1090. void
  1091. engineIDNic_conf(const char *word, char *cptr)
  1092. {
  1093.     /*
  1094.      * Make sure they haven't already specified the engineID via the
  1095.      * * configuration file 
  1096.      */
  1097.     if (0 == engineIDIsSet)
  1098.         /*
  1099.          * engineID has NOT been set via configuration file 
  1100.          */
  1101.     {
  1102.         /*
  1103.          * See if already set if so erase & release it 
  1104.          */
  1105.         if (NULL != engineIDNic) {
  1106.             SNMP_FREE(engineIDNic);
  1107.         }
  1108.         engineIDNic = (u_char *) malloc(strlen(cptr) + 1);
  1109.         if (NULL != engineIDNic) {
  1110.             strcpy((char *) engineIDNic, cptr);
  1111.             DEBUGMSGTL(("snmpv3", "Initializing engineIDNic: %sn",
  1112.                         engineIDNic));
  1113.         } else {
  1114.             DEBUGMSGTL(("snmpv3",
  1115.                         "Error allocating memory for engineIDNic!n"));
  1116.         }
  1117.     } else {
  1118.         DEBUGMSGTL(("snmpv3",
  1119.                     "NOT setting engineIDNic, engineID already setn"));
  1120.     }
  1121. }
  1123. /*******************************************************************-o-******
  1124.  * engineID_conf
  1125.  *
  1126.  * Parameters:
  1127.  * *word
  1128.  * *cptr
  1129.  *
  1130.  * This function reads a string from the configuration file and uses that
  1131.  * string to initialize the engineID.  It's assumed to be human readable.
  1132.  */
  1133. void
  1134. engineID_conf(const char *word, char *cptr)
  1135. {
  1136.     setup_engineID(NULL, cptr);
  1137.     DEBUGMSGTL(("snmpv3", "initialized engineID with: %sn", cptr));
  1138. }
  1140. void
  1141. version_conf(const char *word, char *cptr)
  1142. {
  1143.     int valid = 0;
  1144. #ifndef DISABLE_SNMPV1
  1145.     if ((strcmp(cptr,  "1") == 0) ||
  1146.         (strcmp(cptr, "v1") == 0)) {
  1147.         netsnmp_ds_set_int(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_SNMPVERSION, 
  1148.    NETSNMP_DS_SNMP_VERSION_1);       /* bogus value */
  1149.         valid = 1;
  1150.     }
  1151. #endif
  1152. #ifndef DISABLE_SNMPV2C
  1153.     if ((strcasecmp(cptr,  "2c") == 0) ||
  1154.                (strcasecmp(cptr, "v2c") == 0)) {
  1155.         netsnmp_ds_set_int(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_SNMPVERSION, 
  1156.    NETSNMP_DS_SNMP_VERSION_2c);
  1157.         valid = 1;
  1158.     }
  1159. #endif
  1160.     if ((strcasecmp(cptr,  "3" ) == 0) ||
  1161.                (strcasecmp(cptr, "v3" ) == 0)) {
  1162.         netsnmp_ds_set_int(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_SNMPVERSION, 
  1163.    NETSNMP_DS_SNMP_VERSION_3);
  1164.         valid = 1;
  1165.     }
  1166.     if (!valid) {
  1167.         config_perror("Unknown version specification");
  1168.         return;
  1169.     }
  1170.     DEBUGMSGTL(("snmpv3", "set default version to %dn",
  1171.                 netsnmp_ds_get_int(NETSNMP_DS_LIBRARY_ID, 
  1172.    NETSNMP_DS_LIB_SNMPVERSION)));
  1173. }
  1175. /*
  1176.  * engineID_old_conf(const char *, char *):
  1177.  * 
  1178.  * Reads a octet string encoded engineID into the oldEngineID and
  1179.  * oldEngineIDLen pointers.
  1180.  */
  1181. void
  1182. oldengineID_conf(const char *word, char *cptr)
  1183. {
  1184.     read_config_read_octet_string(cptr, &oldEngineID, &oldEngineIDLength);
  1185. }
  1187. /*
  1188.  * merely call 
  1189.  */
  1190. void
  1191. get_enginetime_alarm(unsigned int regnum, void *clientargs)
  1192. {
  1193.     /* we do this every so (rarely) often just to make sure we watch
  1194.        wrapping of the times() output */
  1195.     snmpv3_local_snmpEngineTime();
  1196. }
  1198. /*******************************************************************-o-******
  1199.  * init_snmpv3
  1200.  *
  1201.  * Parameters:
  1202.  * *type Label for the config file "type" used by calling entity.
  1203.  *      
  1204.  * Set time and engineID.
  1205.  * Set parsing functions for config file tokens.
  1206.  * Initialize SNMP Crypto API (SCAPI).
  1207.  */
  1208. void
  1209. init_snmpv3(const char *type)
  1210. {
  1211. #if SNMP_USE_TIMES
  1212.   struct tms dummy;
  1214.   /* fixme: -1 is fault code... */
  1215.   snmpv3startClock = times(&dummy);
  1217.   /* remember how many ticks per second there are, since times() returns this */
  1219.   clockticks = sysconf(_SC_CLK_TCK);
  1221. #endif /* SNMP_USE_TIMES */
  1223.     gettimeofday(&snmpv3starttime, NULL);
  1225.     if (!type)
  1226.         type = "__snmpapp__";
  1228.     /*
  1229.      * we need to be called back later 
  1230.      */
  1231.     snmp_register_callback(SNMP_CALLBACK_LIBRARY,
  1232.                            SNMP_CALLBACK_POST_READ_CONFIG,
  1233.                            init_snmpv3_post_config, NULL);
  1235.     snmp_register_callback(SNMP_CALLBACK_LIBRARY,
  1236.                            SNMP_CALLBACK_POST_PREMIB_READ_CONFIG,
  1237.                            init_snmpv3_post_premib_config, NULL);
  1238.     /*
  1239.      * we need to be called back later 
  1240.      */
  1241.     snmp_register_callback(SNMP_CALLBACK_LIBRARY, SNMP_CALLBACK_STORE_DATA,
  1242.                            snmpv3_store, (void *) strdup(type));
  1244.     /*
  1245.      * Free stuff at shutdown time
  1246.      */
  1247.     snmp_register_callback(SNMP_CALLBACK_LIBRARY,
  1248.                            SNMP_CALLBACK_SHUTDOWN,
  1249.                            free_enginetime_on_shutdown, NULL);
  1251.     /*
  1252.      * initialize submodules 
  1253.      */
  1254.     /*
  1255.      * NOTE: this must be after the callbacks are registered above,
  1256.      * since they need to be called before the USM callbacks. 
  1257.      */
  1258.     init_secmod();
  1260.     /*
  1261.      * register all our configuration handlers (ack, there's a lot) 
  1262.      */
  1264.     /*
  1265.      * handle engineID setup before everything else which may depend on it 
  1266.      */
  1267.     register_prenetsnmp_mib_handler(type, "engineID", engineID_conf, NULL,
  1268.                                     "string");
  1269.     register_prenetsnmp_mib_handler(type, "oldEngineID", oldengineID_conf,
  1270.                                     NULL, NULL);
  1271.     register_prenetsnmp_mib_handler(type, "engineIDType",
  1272.                                     engineIDType_conf, NULL, "num");
  1273.     register_prenetsnmp_mib_handler(type, "engineIDNic", engineIDNic_conf,
  1274.                                     NULL, "string");
  1275.     register_config_handler(type, "engineBoots", engineBoots_conf, NULL,
  1276.                             NULL);
  1278.     /*
  1279.      * default store config entries 
  1280.      */
  1281.     netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defSecurityName",
  1282.        NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_SECNAME);
  1283.     netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defContext", 
  1284.        NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_CONTEXT);
  1285.     netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defPassphrase",
  1286.                                NETSNMP_DS_LIBRARY_ID,
  1287.                                NETSNMP_DS_LIB_PASSPHRASE);
  1288.     netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defAuthPassphrase",
  1289.                                NETSNMP_DS_LIBRARY_ID,
  1290.                                NETSNMP_DS_LIB_AUTHPASSPHRASE);
  1291.     netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defPrivPassphrase",
  1292.                                NETSNMP_DS_LIBRARY_ID,
  1293.                                NETSNMP_DS_LIB_PRIVPASSPHRASE);
  1294.     netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defAuthMasterKey",
  1295.                                NETSNMP_DS_LIBRARY_ID,
  1296.                                NETSNMP_DS_LIB_AUTHMASTERKEY);
  1297.     netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defPrivMasterKey",
  1298.                                NETSNMP_DS_LIBRARY_ID,
  1299.                                NETSNMP_DS_LIB_PRIVMASTERKEY);
  1300.     netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defAuthLocalizedKey",
  1301.                                NETSNMP_DS_LIBRARY_ID,
  1302.                                NETSNMP_DS_LIB_AUTHLOCALIZEDKEY);
  1303.     netsnmp_ds_register_config(ASN_OCTET_STR, "snmp", "defPrivLocalizedKey",
  1304.                                NETSNMP_DS_LIBRARY_ID,
  1305.                                NETSNMP_DS_LIB_PRIVLOCALIZEDKEY);
  1306.     register_config_handler("snmp", "defVersion", version_conf, NULL,
  1307.                             "1|2c|3");
  1309.     register_config_handler("snmp", "defAuthType", snmpv3_authtype_conf,
  1310.                             NULL, "MD5|SHA");
  1311.     register_config_handler("snmp", "defPrivType", snmpv3_privtype_conf,
  1312.                             NULL,
  1313. #ifdef HAVE_AES
  1314.                             "DES|AES");
  1315. #else
  1316.                             "DES (AES support not available)");
  1317. #endif
  1318.     register_config_handler("snmp", "defSecurityLevel",
  1319.                             snmpv3_secLevel_conf, NULL,
  1320.                             "noAuthNoPriv|authNoPriv|authPriv");
  1321.     register_config_handler(type, "userSetAuthPass", usm_set_password,
  1322.                             NULL, NULL);
  1323.     register_config_handler(type, "userSetPrivPass", usm_set_password,
  1324.                             NULL, NULL);
  1325.     register_config_handler(type, "userSetAuthKey", usm_set_password, NULL,
  1326.                             NULL);
  1327.     register_config_handler(type, "userSetPrivKey", usm_set_password, NULL,
  1328.                             NULL);
  1329.     register_config_handler(type, "userSetAuthLocalKey", usm_set_password,
  1330.                             NULL, NULL);
  1331.     register_config_handler(type, "userSetPrivLocalKey", usm_set_password,
  1332.                             NULL, NULL);
  1333. }
  1335. /*
  1336.  * initializations for SNMPv3 to be called after the configuration files
  1337.  * have been read.
  1338.  */
  1340. int
  1341. init_snmpv3_post_config(int majorid, int minorid, void *serverarg,
  1342.                         void *clientarg)
  1343. {
  1345.     size_t          engineIDLen;
  1346.     u_char         *c_engineID;
  1348.     c_engineID = snmpv3_generate_engineID(&engineIDLen);
  1350.     if (engineIDLen == 0) {
  1351.         /*
  1352.          * Somethine went wrong - help! 
  1353.          */
  1354.         return SNMPERR_GENERR;
  1355.     }
  1357.     /*
  1358.      * if our engineID has changed at all, the boots record must be set to 1 
  1359.      */
  1360.     if (engineIDLen != (int) oldEngineIDLength ||
  1361.         oldEngineID == NULL || c_engineID == NULL ||
  1362.         memcmp(oldEngineID, c_engineID, engineIDLen) != 0) {
  1363.         engineBoots = 1;
  1364.     }
  1366.     /*
  1367.      * set our local engineTime in the LCD timing cache 
  1368.      */
  1369.     set_enginetime(c_engineID, engineIDLen,
  1370.                    snmpv3_local_snmpEngineBoots(),
  1371.                    snmpv3_local_snmpEngineTime(), TRUE);
  1373.     SNMP_FREE(c_engineID);
  1374.     return SNMPERR_SUCCESS;
  1375. }
  1377. int
  1378. init_snmpv3_post_premib_config(int majorid, int minorid, void *serverarg,
  1379.                                void *clientarg)
  1380. {
  1381.     if (!engineIDIsSet)
  1382.         setup_engineID(NULL, NULL);
  1384.     return SNMPERR_SUCCESS;
  1385. }
  1387. /*******************************************************************-o-******
  1388.  * store_snmpv3
  1389.  *
  1390.  * Parameters:
  1391.  * *type
  1392.  */
  1393. int
  1394. snmpv3_store(int majorID, int minorID, void *serverarg, void *clientarg)
  1395. {
  1396.     char            line[SNMP_MAXBUF_SMALL];
  1397.     u_char          c_engineID[SNMP_MAXBUF_SMALL];
  1398.     int             engineIDLen;
  1399.     const char     *type = (const char *) clientarg;
  1401.     if (type == NULL)           /* should never happen, since the arg is ours */
  1402.         type = "unknown";
  1404.     sprintf(line, "engineBoots %ld", engineBoots);
  1405.     read_config_store(type, line);
  1407.     engineIDLen = snmpv3_get_engineID(c_engineID, SNMP_MAXBUF_SMALL);
  1409.     if (engineIDLen) {
  1410.         /*
  1411.          * store the engineID used for this run 
  1412.          */
  1413.         sprintf(line, "oldEngineID ");
  1414.         read_config_save_octet_string(line + strlen(line), c_engineID,
  1415.                                       engineIDLen);
  1416.         read_config_store(type, line);
  1417.     }
  1418.     return SNMPERR_SUCCESS;
  1419. }                               /* snmpv3_store() */
  1421. u_long
  1422. snmpv3_local_snmpEngineBoots(void)
  1423. {
  1424.     return engineBoots;
  1425. }
  1428. /*******************************************************************-o-******
  1429.  * snmpv3_get_engineID
  1430.  *
  1431.  * Parameters:
  1432.  * *buf
  1433.  *  buflen
  1434.  *      
  1435.  * Returns:
  1436.  * Length of engineID On Success
  1437.  * SNMPERR_GENERR Otherwise.
  1438.  *
  1439.  *
  1440.  * Store engineID in buf; return the length.
  1441.  *
  1442.  */
  1443. size_t
  1444. snmpv3_get_engineID(u_char * buf, size_t buflen)
  1445. {
  1446.     /*
  1447.      * Sanity check.
  1448.      */
  1449.     if (!buf || (buflen < engineIDLength)) {
  1450.         return 0;
  1451.     }
  1453.     memcpy(buf, engineID, engineIDLength);
  1454.     return engineIDLength;
  1456. }                               /* end snmpv3_get_engineID() */
  1458. /*******************************************************************-o-******
  1459.  * snmpv3_clone_engineID
  1460.  *
  1461.  * Parameters:
  1462.  * **dest
  1463.  *       *dest_len
  1464.  *       src
  1465.  *  srclen
  1466.  *      
  1467.  * Returns:
  1468.  * Length of engineID On Success
  1469.  * 0         Otherwise.
  1470.  *
  1471.  *
  1472.  * Clones engineID, creates memory
  1473.  *
  1474.  */
  1475. int
  1476. snmpv3_clone_engineID(u_char ** dest, size_t * destlen, u_char * src,
  1477.                       size_t srclen)
  1478. {
  1479.     if (!dest || !destlen)
  1480.         return 0;
  1482.     if (*dest) {
  1483.         SNMP_FREE(*dest);
  1484.         *dest = NULL;
  1485.     }
  1486.     *destlen = 0;
  1488.     if (srclen && src) {
  1489.         *dest = (u_char *) malloc(srclen);
  1490.         if (*dest == NULL)
  1491.             return 0;
  1492.         memmove(*dest, src, srclen);
  1493.         *destlen = srclen;
  1494.     }
  1495.     return *destlen;
  1496. }                               /* end snmpv3_clone_engineID() */
  1499. /*******************************************************************-o-******
  1500.  * snmpv3_generate_engineID
  1501.  *
  1502.  * Parameters:
  1503.  * *length
  1504.  *      
  1505.  * Returns:
  1506.  * Pointer to copy of engineID On Success.
  1507.  * NULL If malloc() or snmpv3_get_engineID()
  1508.  * fail.
  1509.  *
  1510.  * Generates a malloced copy of our engineID.
  1511.  *
  1512.  * 'length' is set to the length of engineID  -OR-  < 0 on failure.
  1513.  */
  1514. u_char         *
  1515. snmpv3_generate_engineID(size_t * length)
  1516. {
  1517.     u_char         *newID;
  1518.     newID = (u_char *) malloc(engineIDLength);
  1520.     if (newID) {
  1521.         *length = snmpv3_get_engineID(newID, engineIDLength);
  1522.     }
  1524.     if (*length == 0) {
  1525.         SNMP_FREE(newID);
  1526.         newID = NULL;
  1527.     }
  1529.     return newID;
  1531. }                               /* end snmpv3_generate_engineID() */
  1533. /*
  1534.  * snmpv3_local_snmpEngineTime(): return the number of seconds since the
  1535.  * snmpv3 engine last incremented engine_boots 
  1536.  */
  1537. u_long
  1538. snmpv3_local_snmpEngineTime(void)
  1539. {
  1540. #ifdef SNMP_USE_TIMES
  1541.   struct tms dummy;
  1542.   clock_t now = times(&dummy);
  1543.   /* fixme: -1 is fault code... */
  1544.   unsigned int result;
  1546.   if (now < snmpv3startClock) {
  1547.       result = UINT_MAX - (snmpv3startClock - now);
  1548.   } else {
  1549.       result = now - snmpv3startClock;
  1550.   }
  1551.   if (result < lastcalltime) {
  1552.       /* wrapped */
  1553.       wrapcounter++;
  1554.   }
  1555.   lastcalltime = result;
  1556.   result =  (UINT_MAX/clockticks)*wrapcounter + result/clockticks;
  1558.   return result;
  1559. #else /* !SNMP_USE_TIMES */
  1560.     struct timeval  now;
  1562.     gettimeofday(&now, NULL);
  1563.     return calculate_sectime_diff(&now, &snmpv3starttime);
  1564. #endif /* HAVE_SYS_TIMES_H */
  1565. }
  1569. /*
  1570.  * Code only for Linux systems 
  1571.  */
  1572. #if defined(IFHWADDRLEN) && defined(SIOCGIFHWADDR)
  1573. static int
  1574. getHwAddress(const char *networkDevice, /* e.g. "eth0", "eth1" */
  1575.              char *addressOut)
  1576. {                               /* return address. Len=IFHWADDRLEN */
  1577.     /*
  1578.      * getHwAddress(...)
  1579.      * *
  1580.      * *  This function will return a Network Interfaces Card's Hardware
  1581.      * *  address (aka MAC address).
  1582.      * *
  1583.      * *  Input Parameter(s):
  1584.      * *      networkDevice - a null terminated string with the name of a network
  1585.      * *                      device.  Examples: eth0, eth1, etc...
  1586.      * *
  1587.      * *  Output Parameter(s):
  1588.      * *      addressOut -    This is the binary value of the hardware address.
  1589.      * *                      This value is NOT converted into a hexadecimal string.
  1590.      * *                      The caller must pre-allocate for a return value of
  1591.      * *                      length IFHWADDRLEN
  1592.      * *
  1593.      * *  Return value:   This function will return zero (0) for success.  If
  1594.      * *                  an error occurred the function will return -1.
  1595.      * *
  1596.      * *  Caveats:    This has only been tested on Ethernet networking cards.
  1597.      */
  1598.     int             sock;       /* our socket */
  1599.     struct ifreq    request;    /* struct which will have HW address */
  1601.     if ((NULL == networkDevice) || (NULL == addressOut)) {
  1602.         return -1;
  1603.     }
  1604.     /*
  1605.      * In order to find out the hardware (MAC) address of our system under
  1606.      * * Linux we must do the following:
  1607.      * * 1.  Create a socket
  1608.      * * 2.  Do an ioctl(...) call with the SIOCGIFHWADDRLEN operation.
  1609.      */
  1610.     sock = socket(AF_INET, SOCK_DGRAM, 0);
  1611.     if (sock < 0) {
  1612.         return -1;
  1613.     }
  1614.     /*
  1615.      * erase the request block 
  1616.      */
  1617.     memset(&request, 0, sizeof(request));
  1618.     /*
  1619.      * copy the name of the net device we want to find the HW address for 
  1620.      */
  1621.     strncpy(request.ifr_name, networkDevice, IFNAMSIZ - 1);
  1622.     /*
  1623.      * Get the HW address 
  1624.      */
  1625.     if (ioctl(sock, SIOCGIFHWADDR, &request)) {
  1626.         close(sock);
  1627.         return -1;
  1628.     }
  1629.     close(sock);
  1630.     memcpy(addressOut, request.ifr_hwaddr.sa_data, IFHWADDRLEN);
  1631.     return 0;
  1632. }
  1633. #endif
  1635. #ifdef SNMP_TESTING_CODE
  1636. /*
  1637.  * snmpv3_set_engineBootsAndTime(): this function does not exist.  Go away. 
  1638.  */
  1639. /*
  1640.  * It certainly should never be used, unless in a testing scenero,
  1641.  * which is why it was created 
  1642.  */
  1643. void
  1644. snmpv3_set_engineBootsAndTime(int boots, int ttime)
  1645. {
  1646.     engineBoots = boots;
  1647.     gettimeofday(&snmpv3starttime, NULL);
  1648.     snmpv3starttime.tv_sec -= ttime;
  1649. }
  1650. #endif