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

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

SNMP编程

开发平台：

Unix_Linux

snmp_parse_args.c：源码内容
  1. /*
  2.  * snmp_parse_args.c
  3.  */
  4. /* Portions of this file are subject to the following copyright(s).  See
  5.  * the Net-SNMP's COPYING file for more details and other copyrights
  6.  * that may apply:
  7.  */
  8. /*
  9.  * Portions of this file are copyrighted by:
  10.  * Copyright @ 2003 Sun Microsystems, Inc. All rights reserved.
  11.  * Use is subject to license terms specified in the COPYING file
  12.  * distributed with the Net-SNMP package.
  13.  */
  15. #include <net-snmp/net-snmp-config.h>
  17. #if HAVE_STDLIB_H
  18. #include <stdlib.h>
  19. #endif
  20. #if HAVE_UNISTD_H
  21. #include <unistd.h>
  22. #endif
  23. #if HAVE_STRING_H
  24. #include <string.h>
  25. #else
  26. #include <strings.h>
  27. #endif
  28. #include <sys/types.h>
  29. #include <stdio.h>
  30. #if HAVE_UNISTD_H
  31. #include <unistd.h>
  32. #endif
  33. #include <ctype.h>
  34. #if HAVE_NETINET_IN_H
  35. #include <netinet/in.h>
  36. #endif
  37. #if TIME_WITH_SYS_TIME
  38. # ifdef WIN32
  39. #  include <sys/timeb.h>
  40. # else
  41. #  include <sys/time.h>
  42. # endif
  43. # include <time.h>
  44. #else
  45. # if HAVE_SYS_TIME_H
  46. #  include <sys/time.h>
  47. # else
  48. #  include <time.h>
  49. # endif
  50. #endif
  51. #if HAVE_SYS_SELECT_H
  52. #include <sys/select.h>
  53. #endif
  54. #if HAVE_WINSOCK_H
  55. #include <winsock.h>
  56. #endif
  57. #if HAVE_NETDB_H
  58. #include <netdb.h>
  59. #endif
  60. #if HAVE_ARPA_INET_H
  61. #include <arpa/inet.h>
  62. #endif
  64. #include <net-snmp/types.h>
  65. #include <net-snmp/output_api.h>
  66. #include <net-snmp/config_api.h>
  67. #include <net-snmp/library/snmp_parse_args.h>   /* for "internal" definitions */
  68. #include <net-snmp/utilities.h>
  70. #include <net-snmp/library/snmp_api.h>
  71. #include <net-snmp/library/snmp_client.h>
  72. #include <net-snmp/library/mib.h>
  73. #include <net-snmp/library/scapi.h>
  74. #include <net-snmp/library/keytools.h>
  76. #include <net-snmp/version.h>
  77. #include <net-snmp/library/parse.h>
  78. #include <net-snmp/library/snmpv3.h>
  79. #include <net-snmp/library/transform_oids.h>
  81. int             random_access = 0;
  83. void
  84. snmp_parse_args_usage(FILE * outf)
  85. {
  86.     fprintf(outf, "[OPTIONS] AGENT");
  87. }
  89. void
  90. snmp_parse_args_descriptions(FILE * outf)
  91. {
  92.     fprintf(outf, "  Version:  %sn", netsnmp_get_version());
  93.     fprintf(outf, "  Web:      http://www.net-snmp.org/n");
  94.     fprintf(outf,
  95.             "  Email:    net-snmp-coders@lists.sourceforge.netnnOPTIONS:n");
  96.     fprintf(outf, "  -h, --helpttdisplay this help messagen");
  97.     fprintf(outf,
  98.             "  -Htttdisplay configuration file directives understoodn");
  99.     fprintf(outf, "  -v 1|2c|3ttspecifies SNMP version to usen");
  100.     fprintf(outf, "  -V, --versionttdisplay package version numbern");
  101. #if !defined(DISABLE_SNMPV1) || !defined(DISABLE_SNMPV2C)
  102.     fprintf(outf, "SNMP Version 1 or 2c specificn");
  103.     fprintf(outf, "  -c COMMUNITYttset the community stringn");
  104. #endif /* support for community based SNMP */
  105.     fprintf(outf, "SNMP Version 3 specificn");
  106.     fprintf(outf,
  107.             "  -a PROTOCOLttset authentication protocol (MD5|SHA)n");
  108.     fprintf(outf,
  109.             "  -A PASSPHRASEttset authentication protocol pass phrasen");
  110.     fprintf(outf,
  111.             "  -e ENGINE-IDttset security engine ID (e.g. 800000020109840301)n");
  112.     fprintf(outf,
  113.             "  -E ENGINE-IDttset context engine ID (e.g. 800000020109840301)n");
  114.     fprintf(outf,
  115.             "  -l LEVELttset security level (noAuthNoPriv|authNoPriv|authPriv)n");
  116.     fprintf(outf, "  -n CONTEXTttset context name (e.g. bridge1)n");
  117.     fprintf(outf, "  -u USER-NAMEttset security name (e.g. bert)n");
  118. #ifdef HAVE_AES
  119.     fprintf(outf, "  -x PROTOCOLttset privacy protocol (DES|AES)n");
  120. #else
  121.     fprintf(outf, "  -x PROTOCOLttset privacy protocol (DES)n");
  122. #endif
  123.     fprintf(outf, "  -X PASSPHRASEttset privacy protocol pass phrasen");
  124.     fprintf(outf,
  125.             "  -Z BOOTS,TIMEttset destination engine boots/timen");
  126.     fprintf(outf, "General communication optionsn");
  127.     fprintf(outf, "  -r RETRIESttset the number of retriesn");
  128.     fprintf(outf,
  129.             "  -t TIMEOUTttset the request timeout (in seconds)n");
  130.     fprintf(outf, "Debuggingn");
  131.     fprintf(outf, "  -dtttdump input/output packets in hexadecimaln");
  132.     fprintf(outf,
  133.             "  -D TOKEN[,...]tturn on debugging output for the specified TOKENsnttt   (ALL gives extremely verbose debugging output)n");
  134.     fprintf(outf, "General optionsn");
  135.     fprintf(outf,
  136.             "  -m MIB[:...]ttload given list of MIBs (ALL loads everything)n");
  137.     fprintf(outf,
  138.             "  -M DIR[:...]ttlook in given list of directories for MIBsn");
  139. #ifndef DISABLE_MIB_LOADING
  140.     fprintf(outf,
  141.             "  -P MIBOPTSttToggle various defaults controlling MIB parsing:n");
  142.     snmp_mib_toggle_options_usage("ttt  ", outf);
  143. #endif
  144.     fprintf(outf,
  145.             "  -O OUTOPTSttToggle various defaults controlling output display:n");
  146.     snmp_out_toggle_options_usage("ttt  ", outf);
  147.     fprintf(outf,
  148.             "  -I INOPTSttToggle various defaults controlling input parsing:n");
  149.     snmp_in_toggle_options_usage("ttt  ", outf);
  150.     fprintf(outf,
  151.             "  -L LOGOPTSttToggle various defaults controlling logging:n");
  152.     snmp_log_options_usage("ttt  ", outf);
  153.     fflush(outf);
  154. }
  156. #define BUF_SIZE 512
  158. void
  159. handle_long_opt(const char *myoptarg)
  160. {
  161.     char           *cp, *cp2;
  162.     /*
  163.      * else it's a long option, so process it like name=value 
  164.      */
  165.     cp = malloc(strlen(myoptarg) + 3);
  166.     if (!cp)
  167.         return;
  168.     strcpy(cp, myoptarg);
  169.     cp2 = strchr(cp, '=');
  170.     if (!cp2 && !strchr(cp, ' ')) {
  171.         /*
  172.          * well, they didn't specify an argument as far as we
  173.          * can tell.  Give them a '1' as the argument (which
  174.          * works for boolean tokens and a few others) and let
  175.          * them suffer from there if it's not what they
  176.          * wanted 
  177.          */
  178.         strcat(cp, " 1");
  179.     } else {
  180.         /*
  181.          * replace the '=' with a ' ' 
  182.          */
  183.         if (cp2)
  184.             *cp2 = ' ';
  185.     }
  186.     netsnmp_config(cp);
  187.     free(cp);
  188. }
  190. extern int      snmpv3_options(char *optarg, netsnmp_session * session,
  191.                                char **Apsz, char **Xpsz, int argc,
  192.                                char *const *argv);
  194. /*
  195.  * This method does the real work for snmp_parse_args.  It takes an
  196.  * extra argument, proxy, and uses this to decide how to handle the lack of
  197.  * of a community string.
  198.  */
  199. int
  200. snmp_parse_args(int argc,
  201.                 char **argv,
  202.                 netsnmp_session * session, const char *localOpts,
  203.                 void (*proc) (int, char *const *, int))
  204. {
  205.     static char    *sensitive[4] = { NULL, NULL, NULL, NULL };
  206.     int             arg, sp = 0, zero_sensitive = 1, testcase = 0;
  207.     char           *cp;
  208.     char           *Apsz = NULL;
  209.     char           *Xpsz = NULL;
  210.     char           *Cpsz = NULL;
  211.     char            Opts[BUF_SIZE];
  212.     int             logopt = 0;
  214.     /*
  215.      * initialize session to default values 
  216.      */
  217.     snmp_sess_init(session);
  218.     strcpy(Opts, "Y:VhHm:M:O:I:P:D:dv:r:t:c:Z:e:E:n:u:l:x:X:a:A:p:T:-:3:s:S:L:");
  219.     if (localOpts)
  220.         strcat(Opts, localOpts);
  222.     if (strcmp(argv[0], "snmpd-trapsess") == 0 ||
  223. strcmp(argv[0], "snmpd-proxy")    == 0) {
  224. /*  Don't worry about zeroing sensitive parameters as they are not
  225.     on the command line anyway (called from internal config-line
  226.     handler).  */
  227. zero_sensitive = 0;
  228.     }
  230.     /*
  231.      * get the options 
  232.      */
  233.     DEBUGMSGTL(("snmp_parse_args", "starting: %d/%dn", optind, argc));
  234.     for (arg = 0; arg < argc; arg++) {
  235.         DEBUGMSGTL(("snmp_parse_args", " arg %d = %sn", arg, argv[arg]));
  236.     }
  238.     optind = 1;
  239.     while ((arg = getopt(argc, argv, Opts)) != EOF) {
  240.         DEBUGMSGTL(("snmp_parse_args", "handling (#%d): %cn", optind, arg));
  241.         switch (arg) {
  242.         case '-':
  243.             if (strcasecmp(optarg, "help") == 0) {
  244.                 return (-1);
  245.             }
  246.             if (strcasecmp(optarg, "version") == 0) {
  247.                 fprintf(stderr,"NET-SNMP version: %sn",netsnmp_get_version());
  248.                 return (-2);
  249.             }
  251.             handle_long_opt(optarg);
  252.             break;
  254.         case 'V':
  255.             fprintf(stderr, "NET-SNMP version: %sn", netsnmp_get_version());
  256.             return (-2);
  258.         case 'h':
  259.             return (-1);
  260.             break;
  262.         case 'H':
  263.             init_snmp("snmpapp");
  264.             fprintf(stderr, "Configuration directives understood:n");
  265.             read_config_print_usage("  ");
  266.             return (-2);
  268.         case 'Y':
  269.             netsnmp_config_remember(optarg);
  270.             break;
  272. #ifndef DISABLE_MIB_LOADING
  273.         case 'm':
  274.             setenv("MIBS", optarg, 1);
  275.             break;
  277.         case 'M':
  278.             netsnmp_set_mib_directory(optarg);
  279.             break;
  280. #endif /* DISABLE_MIB_LOADING */
  282.         case 'O':
  283.             cp = snmp_out_toggle_options(optarg);
  284.             if (cp != NULL) {
  285.                 fprintf(stderr, "Unknown output option passed to -O: %c.n", 
  286. *cp);
  287.                 return (-1);
  288.             }
  289.             break;
  291.         case 'I':
  292.             cp = snmp_in_options(optarg, argc, argv);
  293.             if (cp != NULL) {
  294.                 fprintf(stderr, "Unknown input option passed to -I: %c.n",
  295. *cp);
  296.                 return (-1);
  297.             }
  298.             break;
  300. #ifndef DISABLE_MIB_LOADING
  301.         case 'P':
  302.             cp = snmp_mib_toggle_options(optarg);
  303.             if (cp != NULL) {
  304.                 fprintf(stderr,
  305.                         "Unknown parsing option passed to -P: %c.n", *cp);
  306.                 return (-1);
  307.             }
  308.             break;
  309. #endif /* DISABLE_MIB_LOADING */
  311.         case 'D':
  312.             debug_register_tokens(optarg);
  313.             snmp_set_do_debugging(1);
  314.             break;
  316.         case 'd':
  317.             netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID, 
  318.    NETSNMP_DS_LIB_DUMP_PACKET, 1);
  319.             break;
  321.         case 'v':
  322.             session->version = -1;
  323. #ifndef DISABLE_SNMPV1
  324.             if (!strcmp(optarg, "1")) {
  325.                 session->version = SNMP_VERSION_1;
  326.             }
  327. #endif
  328. #ifndef DISABLE_SNMPV2C
  329.             if (!strcasecmp(optarg, "2c")) {
  330.                 session->version = SNMP_VERSION_2c;
  331.             }
  332. #endif
  333.             if (!strcasecmp(optarg, "3")) {
  334.                 session->version = SNMP_VERSION_3;
  335.             }
  336.             if (session->version == -1) {
  337.                 fprintf(stderr,
  338.                         "Invalid version specified after -v flag: %sn",
  339.                         optarg);
  340.                 return (-1);
  341.             }
  342.             break;
  344.         case 'p':
  345.             fprintf(stderr, "Warning: -p option is no longer used - ");
  346.             fprintf(stderr, "specify the remote host as HOST:PORTn");
  347.             return (-1);
  348.             break;
  350.         case 'T':
  351.             fprintf(stderr, "Warning: -T option is no longer used - ");
  352.             fprintf(stderr, "specify the remote host as TRANSPORT:HOSTn");
  353.             return (-1);
  354.             break;
  356.         case 't':
  357.             session->timeout = atoi(optarg) * 1000000L;
  358.             if (session->timeout < 0 || !isdigit(optarg[0])) {
  359.                 fprintf(stderr, "Invalid timeout in seconds after -t flag.n");
  360.                 return (-1);
  361.             }
  362.             break;
  364.         case 'r':
  365.             session->retries = atoi(optarg);
  366.             if (session->retries < 0 || !isdigit(optarg[0])) {
  367.                 fprintf(stderr, "Invalid number of retries after -r flag.n");
  368.                 return (-1);
  369.             }
  370.             break;
  372.         case 'c':
  373.     if (zero_sensitive) {
  374. if ((sensitive[sp] = strdup(optarg)) != NULL) {
  375.     Cpsz = sensitive[sp];
  376.     memset(optarg, '', strlen(optarg));
  377.     sp++;
  378. } else {
  379.     fprintf(stderr, "malloc failure processing -c flag.n");
  380.     return -1;
  381. }
  382.     } else {
  383. Cpsz = optarg;
  384.     }
  385.             break;
  387.         case '3':
  388.     /*  TODO: This needs to zero things too.  */
  389.             if (snmpv3_options(optarg, session, &Apsz, &Xpsz, argc, argv) < 0){
  390.                 return (-1);
  391.             }
  392.             break;
  394.         case 'L':
  395.             if (snmp_log_options(optarg, argc, argv) < 0) {
  396.                 return (-1);
  397.             }
  398.     logopt = 1;
  399.             break;
  401. #define SNMPV3_CMD_OPTIONS
  402. #ifdef  SNMPV3_CMD_OPTIONS
  403.         case 'Z':
  404.             session->engineBoots = strtoul(optarg, NULL, 10);
  405.             if (session->engineBoots == 0 || !isdigit(optarg[0])) {
  406.                 fprintf(stderr, "Need engine boots value after -Z flag.n");
  407.                 return (-1);
  408.             }
  409.             cp = strchr(optarg, ',');
  410.             if (cp && *(++cp) && isdigit(*cp))
  411.                 session->engineTime = strtoul(cp, NULL, 10);
  412.             /*
  413.              * Handle previous '-Z boot time' syntax 
  414.              */
  415.             else if ((optind < argc) && isdigit(argv[optind][0]))
  416.                 session->engineTime = strtoul(argv[optind], NULL, 10);
  417.             else {
  418.                 fprintf(stderr, "Need engine time value after -Z flag.n");
  419.                 return (-1);
  420.             }
  421.             break;
  423.         case 'e':{
  424.                 size_t ebuf_len = 32, eout_len = 0;
  425.                 u_char *ebuf = (u_char *)malloc(ebuf_len);
  427.                 if (ebuf == NULL) {
  428.                     fprintf(stderr, "malloc failure processing -e flag.n");
  429.                     return (-1);
  430.                 }
  431.                 if (!snmp_hex_to_binary
  432.                     (&ebuf, &ebuf_len, &eout_len, 1, optarg)) {
  433.                     fprintf(stderr, "Bad engine ID value after -e flag.n");
  434.                     free(ebuf);
  435.                     return (-1);
  436.                 }
  437.                 session->securityEngineID = ebuf;
  438.                 session->securityEngineIDLen = eout_len;
  439.                 break;
  440.             }
  442.         case 'E':{
  443.                 size_t ebuf_len = 32, eout_len = 0;
  444.                 u_char *ebuf = (u_char *)malloc(ebuf_len);
  446.                 if (ebuf == NULL) {
  447.                     fprintf(stderr, "malloc failure processing -E flag.n");
  448.                     return (-1);
  449.                 }
  450.                 if (!snmp_hex_to_binary(&ebuf, &ebuf_len,
  451. &eout_len, 1, optarg)) {
  452.                     fprintf(stderr, "Bad engine ID value after -E flag.n");
  453.                     free(ebuf);
  454.                     return (-1);
  455.                 }
  456.                 session->contextEngineID = ebuf;
  457.                 session->contextEngineIDLen = eout_len;
  458.                 break;
  459.             }
  461.         case 'n':
  462.             session->contextName = optarg;
  463.             session->contextNameLen = strlen(optarg);
  464.             break;
  466.         case 'u':
  467.     if (zero_sensitive) {
  468. if ((sensitive[sp] = strdup(optarg)) != NULL) {
  469.     session->securityName = sensitive[sp];
  470.     session->securityNameLen = strlen(sensitive[sp]);
  471.     memset(optarg, '', strlen(optarg));
  472.     sp++;
  473. } else {
  474.     fprintf(stderr, "malloc failure processing -u flag.n");
  475.     return -1;
  476. }
  477.     } else {
  478. session->securityName = optarg;
  479. session->securityNameLen = strlen(optarg);
  480.     }
  481.             break;
  483.         case 'l':
  484.             if (!strcasecmp(optarg, "noAuthNoPriv") || !strcmp(optarg, "1")
  485.                 || !strcasecmp(optarg, "noauth")
  486.                 || !strcasecmp(optarg, "nanp")) {
  487.                 session->securityLevel = SNMP_SEC_LEVEL_NOAUTH;
  488.             } else if (!strcasecmp(optarg, "authNoPriv")
  489.                        || !strcmp(optarg, "2")
  490.                        || !strcasecmp(optarg, "auth")
  491.                        || !strcasecmp(optarg, "anp")) {
  492.                 session->securityLevel = SNMP_SEC_LEVEL_AUTHNOPRIV;
  493.             } else if (!strcasecmp(optarg, "authPriv")
  494.                        || !strcmp(optarg, "3")
  495.                        || !strcasecmp(optarg, "priv")
  496.                        || !strcasecmp(optarg, "ap")) {
  497.                 session->securityLevel = SNMP_SEC_LEVEL_AUTHPRIV;
  498.             } else {
  499.                 fprintf(stderr,
  500.                         "Invalid security level specified after -l flag: %sn",
  501.                         optarg);
  502.                 return (-1);
  503.             }
  505.             break;
  507.         case 'a':
  508. #ifndef DISABLE_MD5
  509.             if (!strcasecmp(optarg, "MD5")) {
  510.                 session->securityAuthProto = usmHMACMD5AuthProtocol;
  511.                 session->securityAuthProtoLen = USM_AUTH_PROTO_MD5_LEN;
  512.             } else
  513. #endif
  514.                 if (!strcasecmp(optarg, "SHA")) {
  515.                 session->securityAuthProto = usmHMACSHA1AuthProtocol;
  516.                 session->securityAuthProtoLen = USM_AUTH_PROTO_SHA_LEN;
  517.             } else {
  518.                 fprintf(stderr,
  519.                         "Invalid authentication protocol specified after -a flag: %sn",
  520.                         optarg);
  521.                 return (-1);
  522.             }
  523.             break;
  525.         case 'x':
  526.             testcase = 0;
  527. #ifndef DISABLE_DES
  528.             if (!strcasecmp(optarg, "DES")) {
  529.                 testcase = 1;
  530.                 session->securityPrivProto = usmDESPrivProtocol;
  531.                 session->securityPrivProtoLen = USM_PRIV_PROTO_DES_LEN;
  532.             }
  533. #endif
  534. #ifdef HAVE_AES
  535.             if (!strcasecmp(optarg, "AES128") ||
  536.                 !strcasecmp(optarg, "AES")) {
  537.                 testcase = 1;
  538.                 session->securityPrivProto = usmAESPrivProtocol;
  539.                 session->securityPrivProtoLen = USM_PRIV_PROTO_AES_LEN;
  540.             }
  541. #endif
  542.             if (testcase == 0) {
  543.                 fprintf(stderr,
  544.                       "Invalid privacy protocol specified after -x flag: %sn",
  545.                         optarg);
  546.                 return (-1);
  547.             }
  548.             break;
  550.         case 'A':
  551.     if (zero_sensitive) {
  552. if ((sensitive[sp] = strdup(optarg)) != NULL) {
  553.     Apsz = sensitive[sp];
  554.     memset(optarg, '', strlen(optarg));
  555.     sp++;
  556. } else {
  557.     fprintf(stderr, "malloc failure processing -A flag.n");
  558.     return -1;
  559. }
  560.     } else {
  561. Apsz = optarg;
  562.     }
  563.             break;
  565.         case 'X':
  566.     if (zero_sensitive) {
  567. if ((sensitive[sp] = strdup(optarg)) != NULL) {
  568.     Xpsz = sensitive[sp];
  569.     memset(optarg, '', strlen(optarg));
  570.     sp++;
  571. } else {
  572.     fprintf(stderr, "malloc failure processing -X flag.n");
  573.     return -1;
  574. }
  575.     } else {
  576. Xpsz = optarg;
  577.     }
  578.             break;
  579. #endif                          /* SNMPV3_CMD_OPTIONS */
  581.         case '?':
  582.             return (-1);
  583.             break;
  585.         default:
  586.             proc(argc, argv, arg);
  587.             break;
  588.         }
  589.     }
  590.     DEBUGMSGTL(("snmp_parse_args", "finished: %d/%dn", optind, argc));
  591.     
  592.     if (!logopt)
  593. snmp_enable_stderrlog();
  595.     /*
  596.      * read in MIB database and initialize the snmp library
  597.      */
  598.     init_snmp("snmpapp");
  600.     /*
  601.      * session default version 
  602.      */
  603.     if (session->version == SNMP_DEFAULT_VERSION) {
  604.         /*
  605.          * run time default version 
  606.          */
  607.         session->version = netsnmp_ds_get_int(NETSNMP_DS_LIBRARY_ID, 
  608.       NETSNMP_DS_LIB_SNMPVERSION);
  610.         /*
  611.          * compile time default version 
  612.          */
  613.         if (!session->version) {
  614.             switch (DEFAULT_SNMP_VERSION) {
  615. #ifndef DISABLE_SNMPV1
  616.             case 1:
  617.                 session->version = SNMP_VERSION_1;
  618.                 break;
  619. #endif
  621. #ifndef DISABLE_SNMPV2C
  622.             case 2:
  623.                 session->version = SNMP_VERSION_2c;
  624.                 break;
  625. #endif
  627.             case 3:
  628.                 session->version = SNMP_VERSION_3;
  629.                 break;
  631.             default:
  632.                 snmp_log(LOG_ERR, "Can't determine a valid SNMP version for the sessionn");
  633.                 return(-2);
  634.             }
  635.         } else {
  636. #ifndef DISABLE_SNMPV1
  637.             if (session->version == NETSNMP_DS_SNMP_VERSION_1)  /* bogus value.  version 1 actually = 0 */
  638.                 session->version = SNMP_VERSION_1;
  639. #endif
  640.         }
  641.     }
  643.     /*
  644.      * make master key from pass phrases 
  645.      */
  646.     if (Apsz) {
  647.         session->securityAuthKeyLen = USM_AUTH_KU_LEN;
  648.         if (session->securityAuthProto == NULL) {
  649.             /*
  650.              * get .conf set default 
  651.              */
  652.             const oid      *def =
  653.                 get_default_authtype(&session->securityAuthProtoLen);
  654.             session->securityAuthProto =
  655.                 snmp_duplicate_objid(def, session->securityAuthProtoLen);
  656.         }
  657.         if (session->securityAuthProto == NULL) {
  658. #ifndef DISABLE_MD5
  659.             /*
  660.              * assume MD5
  661.              */
  662.             session->securityAuthProto =
  663.                 snmp_duplicate_objid(usmHMACMD5AuthProtocol,
  664.                                      USM_AUTH_PROTO_MD5_LEN);
  665.             session->securityAuthProtoLen = USM_AUTH_PROTO_MD5_LEN;
  666. #else
  667.             session->securityAuthProto =
  668.                 snmp_duplicate_objid(usmHMACSHA1AuthProtocol,
  669.                                      USM_AUTH_PROTO_SHA_LEN);
  670.             session->securityAuthProtoLen = USM_AUTH_PROTO_SHA_LEN;
  671. #endif
  672.         }
  673.         if (generate_Ku(session->securityAuthProto,
  674.                         session->securityAuthProtoLen,
  675.                         (u_char *) Apsz, strlen(Apsz),
  676.                         session->securityAuthKey,
  677.                         &session->securityAuthKeyLen) != SNMPERR_SUCCESS) {
  678.             snmp_perror(argv[0]);
  679.             fprintf(stderr,
  680.                     "Error generating a key (Ku) from the supplied authentication pass phrase. n");
  681.             return (-2);
  682.         }
  683.     }
  684.     if (Xpsz) {
  685.         session->securityPrivKeyLen = USM_PRIV_KU_LEN;
  686.         if (session->securityPrivProto == NULL) {
  687.             /*
  688.              * get .conf set default 
  689.              */
  690.             const oid      *def =
  691.                 get_default_privtype(&session->securityPrivProtoLen);
  692.             session->securityPrivProto =
  693.                 snmp_duplicate_objid(def, session->securityPrivProtoLen);
  694.         }
  695.         if (session->securityPrivProto == NULL) {
  696.             /*
  697.              * assume DES 
  698.              */
  699. #ifndef DISABLE_DES
  700.             session->securityPrivProto =
  701.                 snmp_duplicate_objid(usmDESPrivProtocol,
  702.                                      USM_PRIV_PROTO_DES_LEN);
  703.             session->securityPrivProtoLen = USM_PRIV_PROTO_DES_LEN;
  704. #else
  705.             session->securityPrivProto =
  706.                 snmp_duplicate_objid(usmAESPrivProtocol,
  707.                                      USM_PRIV_PROTO_AES_LEN);
  708.             session->securityPrivProtoLen = USM_PRIV_PROTO_AES_LEN;
  709. #endif
  711.         }
  712.         if (generate_Ku(session->securityAuthProto,
  713.                         session->securityAuthProtoLen,
  714.                         (u_char *) Xpsz, strlen(Xpsz),
  715.                         session->securityPrivKey,
  716.                         &session->securityPrivKeyLen) != SNMPERR_SUCCESS) {
  717.             snmp_perror(argv[0]);
  718.             fprintf(stderr,
  719.                     "Error generating a key (Ku) from the supplied privacy pass phrase. n");
  720.             return (-2);
  721.         }
  722.     }
  723.     /*
  724.      * get the hostname 
  725.      */
  726.     if (optind == argc) {
  727.         fprintf(stderr, "No hostname specified.n");
  728.         return (-1);
  729.     }
  730.     session->peername = argv[optind++]; /* hostname */
  732. #if !defined(DISABLE_SNMPV1) || !defined(DISABLE_SNMPV2C)
  733.     /*
  734.      * If v1 or v2c, check community has been set, either by a -c option above,
  735.      * or via a default token somewhere.  
  736.      * If neither, it will be taken from the incoming request PDU.
  737.      */
  739.     if (session->version == SNMP_VERSION_1 ||
  740. session->version == SNMP_VERSION_2c) {
  741.         if (Cpsz == NULL) {
  742.             Cpsz = netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID, 
  743.  NETSNMP_DS_LIB_COMMUNITY);
  744.     if (Cpsz == NULL) {
  745.                 if (netsnmp_ds_get_boolean(NETSNMP_DS_LIBRARY_ID,
  746.                                            NETSNMP_DS_LIB_IGNORE_NO_COMMUNITY)){
  747.                     DEBUGMSGTL(("snmp_parse_args",
  748.                                 "ignoring that the community string is not presentn"));
  749.                     session->community = NULL;
  750.                     session->community_len = 0;
  751.                 } else {
  752.                     fprintf(stderr, "No community name specified.n");
  753.                     return (-1);
  754.                 }
  755.     }
  756. } else {
  757.             session->community = (unsigned char *)Cpsz;
  758.             session->community_len = strlen(Cpsz);
  759.         }
  760.     }
  761. #endif /* support for community based SNMP */
  763.     return optind;
  764. }