/*

 * snmp_parse_args.c

 */

/* Portions of this file are subject to the following copyright(s).  See

 * the Net-SNMP's COPYING file for more details and other copyrights

 * that may apply:

 */

/*

 * Portions of this file are copyrighted by:

 * Copyright @ 2003 Sun Microsystems, Inc. All rights reserved.

 * Use is subject to license terms specified in the COPYING file

 * distributed with the Net-SNMP package.

 *

 * Portions of this file are copyrighted by:

 * Copyright (c) 2016 VMware, Inc. All rights reserved.

 * Use is subject to license terms specified in the COPYING file

 * distributed with the Net-SNMP package.

 */

#include <net-snmp/net-snmp-config.h>

#include <errno.h>

#if HAVE_STDLIB_H

#include <stdlib.h>

#endif

#if HAVE_UNISTD_H

#include <unistd.h>

#endif

#if HAVE_STRING_H

#include <string.h>

#else

#include <strings.h>

#endif

#include <sys/types.h>

#include <stdio.h>

#if HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <ctype.h>

#if HAVE_NETINET_IN_H

#include <netinet/in.h>

#endif

#if TIME_WITH_SYS_TIME

# include <sys/time.h>

# include <time.h>

#else

# if HAVE_SYS_TIME_H

#  include <sys/time.h>

# else

#  include <time.h>

# endif

#endif

#if HAVE_SYS_SELECT_H

#include <sys/select.h>

#endif

#if HAVE_NETDB_H

#include <netdb.h>

#endif

#if HAVE_ARPA_INET_H

#include <arpa/inet.h>

#endif

#include <net-snmp/net-snmp-includes.h>

#include <net-snmp/types.h>

#include <net-snmp/output_api.h>

#include <net-snmp/config_api.h>

#include <net-snmp/library/snmpv3.h>

#include <net-snmp/library/snmp_parse_args.h>   /* for "internal" definitions */

#include <net-snmp/utilities.h>

#include <net-snmp/library/snmp_api.h>

#include <net-snmp/library/snmp_client.h>

#include <net-snmp/library/mib.h>

#include <net-snmp/library/scapi.h>

#include <net-snmp/library/keytools.h>

#include <net-snmp/version.h>

#include <net-snmp/library/parse.h>

#include <net-snmp/library/snmpv3.h>

#include <net-snmp/library/transform_oids.h>

void

snmp_parse_args_usage(FILE * outf)

{

    fprintf(outf, "[OPTIONS] AGENT");

}

void

snmp_parse_args_descriptions(FILE * outf)

{

    fprintf(outf, "  Version:  %s\n", netsnmp_get_version());

    fprintf(outf, "  Web:      http://www.net-snmp.org/\n");

    fprintf(outf,

            "  Email:    net-snmp-coders@lists.sourceforge.net\n\nOPTIONS:\n");

    fprintf(outf, "  -h, --help\t\tdisplay this help message\n");

    fprintf(outf,

            "  -H\t\t\tdisplay configuration file directives understood\n");

    fprintf(outf, "  -v 1|2c|3\t\tspecifies SNMP version to use\n");

    fprintf(outf, "  -V, --version\t\tdisplay package version number\n");

#if !defined(NETSNMP_DISABLE_SNMPV1) || !defined(NETSNMP_DISABLE_SNMPV2C)

    fprintf(outf, "SNMP Version 1 or 2c specific\n");

    fprintf(outf, "  -c COMMUNITY\t\tset the community string\n");

#endif /* support for community based SNMP */

    fprintf(outf, "SNMP Version 3 specific\n");

    fprintf(outf,

            "  -a PROTOCOL\t\tset authentication protocol (MD5|SHA|SHA-224|SHA-256|SHA-384|SHA-512)\n");

    fprintf(outf,

            "  -A PASSPHRASE\t\tset authentication protocol pass phrase\n");

    fprintf(outf,

            "  -e ENGINE-ID\t\tset security engine ID (e.g. 800000020109840301)\n");

    fprintf(outf,

            "  -E ENGINE-ID\t\tset context engine ID (e.g. 800000020109840301)\n");

    fprintf(outf,

            "  -l LEVEL\t\tset security level (noAuthNoPriv|authNoPriv|authPriv)\n");

    fprintf(outf, "  -n CONTEXT\t\tset context name (e.g. bridge1)\n");

    fprintf(outf, "  -u USER-NAME\t\tset security name (e.g. bert)\n");

#ifdef HAVE_AES

    fprintf(outf, "  -x PROTOCOL\t\tset privacy protocol (DES|AES"

#ifdef NETSNMP_DRAFT_BLUMENTHAL_AES_04

            "|AES-192|AES-256"

#endif

            ")\n");

#else

    fprintf(outf, "  -x PROTOCOL\t\tset privacy protocol (DES)\n");

#endif

    fprintf(outf, "  -X PASSPHRASE\t\tset privacy protocol pass phrase\n");

    fprintf(outf,

            "  -Z BOOTS,TIME\t\tset destination engine boots/time\n");

    fprintf(outf, "General communication options\n");

    fprintf(outf, "  -r RETRIES\t\tset the number of retries\n");

    fprintf(outf,

            "  -t TIMEOUT\t\tset the request timeout (in seconds)\n");

    fprintf(outf, "Debugging\n");

    fprintf(outf, "  -d\t\t\tdump input/output packets in hexadecimal\n");

#ifndef NETSNMP_DISABLE_DEBUGGING

    fprintf(outf,

            "  -D[TOKEN[,...]]\tturn on debugging output for the specified TOKENs\n\t\t\t   (ALL gives extremely verbose debugging output)\n");

#endif

    fprintf(outf, "General options\n");

    fprintf(outf,

            "  -m MIB[" ENV_SEPARATOR "...]\t\tload given list of MIBs (ALL loads everything)\n");

    fprintf(outf,

            "  -M DIR[" ENV_SEPARATOR "...]\t\tlook in given list of directories for MIBs\n");

#ifndef NETSNMP_DISABLE_MIB_LOADING

    fprintf(outf,

            "    (default: %s)\n", netsnmp_get_mib_directory());

    fprintf(outf,

            "  -P MIBOPTS\t\tToggle various defaults controlling MIB parsing:\n");

    snmp_mib_toggle_options_usage("\t\t\t  ", outf);

#endif

    fprintf(outf,

            "  -O OUTOPTS\t\tToggle various defaults controlling output display:\n");

    snmp_out_toggle_options_usage("\t\t\t  ", outf);

    fprintf(outf,

            "  -I INOPTS\t\tToggle various defaults controlling input parsing:\n");

    snmp_in_toggle_options_usage("\t\t\t  ", outf);

    fprintf(outf,

            "  -L LOGOPTS\t\tToggle various defaults controlling logging:\n");

    snmp_log_options_usage("\t\t\t  ", outf);

    fflush(outf);

}

#define BUF_SIZE 512

void

handle_long_opt(const char *myoptarg)

{

    char           *cp, *cp2;

    /*

     * else it's a long option, so process it like name=value 

     */

    cp = (char *)malloc(strlen(myoptarg) + 3);

    if (!cp)

        return;

    strcpy(cp, myoptarg);

    cp2 = strchr(cp, '=');

    if (!cp2 && !strchr(cp, ' ')) {

        /*

         * well, they didn't specify an argument as far as we

         * can tell.  Give them a '1' as the argument (which

         * works for boolean tokens and a few others) and let

         * them suffer from there if it's not what they

         * wanted 

         */

        strcat(cp, " 1");

    } else {

        /*

         * replace the '=' with a ' ' 

         */

        if (cp2)

            *cp2 = ' ';

    }

    netsnmp_config(cp);

    free(cp);

}

int

netsnmp_parse_args(int argc,

                   char **argv,

                   netsnmp_session * session, const char *localOpts,

                   void (*proc) (int, char *const *, int),

                   int flags)

{

    int             arg, sp = 0;

    char           *cp;

    char           *Apsz = NULL;

    char           *Xpsz = NULL;

    char           *Cpsz = NULL;

    char            Opts[BUF_SIZE];

    int             zero_sensitive = !( flags & NETSNMP_PARSE_ARGS_NOZERO );

    char           *backup_NETSNMP_DS_LIB_OUTPUT_PRECISION = NULL;

    /*

     * initialize session to default values 

     */

    snmp_sess_init(session);

    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:L:s:");

    if (localOpts) {

        if (strlen(localOpts) + strlen(Opts) >= sizeof(Opts)) {

            snmp_log(LOG_ERR, "Too many localOpts in snmp_parse_args()\n");

            return -1;

        }

        strcat(Opts, localOpts);

    }

    /*

     * get the options 

     */

    DEBUGMSGTL(("snmp_parse_args", "starting: %d/%d\n", optind, argc));

    for (arg = 0; arg < argc; arg++) {

        DEBUGMSGTL(("snmp_parse_args", " arg %d = %s\n", arg, argv[arg]));

    }

    optind = 1;

    while ((arg = getopt(argc, argv, Opts)) != EOF) {

        DEBUGMSGTL(("snmp_parse_args", "handling (#%d): %c (optarg %s) (sp %d)\n",

                    optind, arg, optarg, sp));

        switch (arg) {

        case '-':

            if (strcasecmp(optarg, "help") == 0) {

                return (NETSNMP_PARSE_ARGS_ERROR_USAGE);

            }

            if (strcasecmp(optarg, "version") == 0) {

                fprintf(stderr,"NET-SNMP version: %s\n",netsnmp_get_version());

                return (NETSNMP_PARSE_ARGS_SUCCESS_EXIT);

            }

            handle_long_opt(optarg);

            break;

        case 'V':

            fprintf(stderr, "NET-SNMP version: %s\n", netsnmp_get_version());

            return (NETSNMP_PARSE_ARGS_SUCCESS_EXIT);

        case 'h':

            return (NETSNMP_PARSE_ARGS_ERROR_USAGE);

            break;

        case 'H':

            init_snmp(NETSNMP_APPLICATION_CONFIG_TYPE);

            fprintf(stderr, "Configuration directives understood:\n");

            read_config_print_usage("  ");

            return (NETSNMP_PARSE_ARGS_SUCCESS_EXIT);

        case 'Y':

            netsnmp_config_remember(optarg);

            break;

#ifndef NETSNMP_DISABLE_MIB_LOADING

        case 'm':

            setenv("MIBS", optarg, 1);

            break;

        case 'M':

            netsnmp_get_mib_directory(); /* prepare the default directories */

            netsnmp_set_mib_directory(optarg);

            break;

#endif /* NETSNMP_DISABLE_MIB_LOADING */

        case 'O':

            cp = snmp_out_options(optarg, argc, argv);

            if (cp != NULL) {

                fprintf(stderr, "Unknown output option passed to -O: %c.\n", 

			*cp);

                return (NETSNMP_PARSE_ARGS_ERROR_USAGE);

            }

            break;

        case 'I':

            cp = snmp_in_options(optarg, argc, argv);

            if (cp != NULL) {

                fprintf(stderr, "Unknown input option passed to -I: %c.\n",

			*cp);

                return (NETSNMP_PARSE_ARGS_ERROR_USAGE);

            }

            break;

#ifndef NETSNMP_DISABLE_MIB_LOADING

        case 'P':

            cp = snmp_mib_toggle_options(optarg);

            if (cp != NULL) {

                fprintf(stderr,

                        "Unknown parsing option passed to -P: %c.\n", *cp);

                return (NETSNMP_PARSE_ARGS_ERROR_USAGE);

            }

            break;

#endif /* NETSNMP_DISABLE_MIB_LOADING */

        case 'D':

#ifdef NETSNMP_NO_DEBUGGING

            fprintf(stderr, "Debug not configured in\n");

            return (NETSNMP_PARSE_ARGS_ERROR_USAGE);

#else

            debug_register_tokens(optarg);

            snmp_set_do_debugging(1);

#endif

            break;

        case 'd':

            netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID, 

				   NETSNMP_DS_LIB_DUMP_PACKET, 1);

            break;

        case 's':

            session->localname = strdup(optarg);

            break;

        case 'v':

            session->version = -1;

#ifndef NETSNMP_DISABLE_SNMPV1

            if (!strcmp(optarg, "1")) {

                session->version = SNMP_VERSION_1;

            }

#endif

#ifndef NETSNMP_DISABLE_SNMPV2C

            if (!strcasecmp(optarg, "2c")) {

                session->version = SNMP_VERSION_2c;

            }

#endif

            if (!strcasecmp(optarg, "3")) {

                session->version = SNMP_VERSION_3;

            }

            if (session->version == -1) {

                fprintf(stderr,

                        "Invalid version specified after -v flag: %s\n",

                        optarg);

                return (NETSNMP_PARSE_ARGS_ERROR_USAGE);

            }

            break;

        case 'p':

            fprintf(stderr, "Warning: -p option is no longer used - ");

            fprintf(stderr, "specify the remote host as HOST:PORT\n");

            return (NETSNMP_PARSE_ARGS_ERROR_USAGE);

            break;

        case 'T':

        {

            char leftside[SNMP_MAXBUF_MEDIUM], rightside[SNMP_MAXBUF_MEDIUM];

            char *tmpcp, *tmpopt;

            /* ensure we have a proper argument */

            tmpopt = strdup(optarg);

            tmpcp = strchr(tmpopt, '=');

            if (!tmpcp) {

                fprintf(stderr, "-T expects a NAME=VALUE pair.\n");

                free(tmpopt);

                return (NETSNMP_PARSE_ARGS_ERROR_USAGE);

            }

            *tmpcp++ = '\0';

            /* create the transport config container if this is the first */

            if (!session->transport_configuration) {

                netsnmp_container_init_list();

                session->transport_configuration =

                    netsnmp_container_find("transport_configuration:fifo");

                if (!session->transport_configuration) {

                    fprintf(stderr, "failed to initialize the transport configuration container\n");

                    free(tmpopt);

                    return (NETSNMP_PARSE_ARGS_ERROR);

                }

                session->transport_configuration->compare =

                    (netsnmp_container_compare*)

                    netsnmp_transport_config_compare;

            }

            /* set the config */

            strlcpy(leftside, tmpopt, sizeof(leftside));

            strlcpy(rightside, tmpcp, sizeof(rightside));

            CONTAINER_INSERT(session->transport_configuration,

                             netsnmp_transport_create_config(leftside,

                                                             rightside));

            free(tmpopt);

        }

        break;

        case 't':

            session->timeout = (long)(atof(optarg) * 1000000L);

            if (session->timeout <= 0) {

                fprintf(stderr, "Invalid timeout in seconds after -t flag.\n");

                return (NETSNMP_PARSE_ARGS_ERROR_USAGE);

            }

            break;

        case 'r':

            session->retries = atoi(optarg);

            if (session->retries < 0 || !isdigit((unsigned char)(optarg[0]))) {

                fprintf(stderr, "Invalid number of retries after -r flag.\n");

                return (NETSNMP_PARSE_ARGS_ERROR_USAGE);

            }

            break;

        case 'c':

	    if (zero_sensitive) {

                SNMP_FREE(Cpsz); /* free any previous value */

		if ((Cpsz = strdup(optarg)) != NULL) {

		    memset(optarg, '\0', strlen(optarg));

		} else {

		    fprintf(stderr, "malloc failure processing -c flag.\n");

		    return NETSNMP_PARSE_ARGS_ERROR;

		}

	    } else {

		Cpsz = optarg;

	    }

            break;

        case '3':

            if (snmpv3_parse_args(optarg, session, &Apsz, &Xpsz, argc, argv,

                                  flags) < 0){

                return (NETSNMP_PARSE_ARGS_ERROR_USAGE);

            }

            break;

        case 'L':

            if (snmp_log_options(optarg, argc, argv) < 0) {

                return (NETSNMP_PARSE_ARGS_ERROR_USAGE);

            }

            break;

#define SNMPV3_CMD_OPTIONS

#ifdef  SNMPV3_CMD_OPTIONS

        case 'Z':

        case 'e':

        case 'E':

        case 'n':

        case 'l':

        case 'u':

#ifdef NETSNMP_SECMOD_USM

        case 'a':

        case 'x':

        case 'A':

        case 'X':

#endif             /* NETSNMP_SECMOD_USM */

            if (snmpv3_parse_arg(arg, optarg, session, &Apsz, &Xpsz, argc,

                                 argv, flags) < 0){

                return (NETSNMP_PARSE_ARGS_ERROR_USAGE);

            }

            break;

#endif                          /* SNMPV3_CMD_OPTIONS */

        case '?':

            return (NETSNMP_PARSE_ARGS_ERROR_USAGE);

            break;

        default:

            proc(argc, argv, arg);

            break;

        }

    }

    DEBUGMSGTL(("snmp_parse_args", "finished: %d/%d\n", optind, argc));

    /*

     * save command line parameters which should have precedence above config file settings

     *    (There ought to be a more scalable approach than this....)

     */

    if (netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_OUTPUT_PRECISION)) {

        backup_NETSNMP_DS_LIB_OUTPUT_PRECISION = 

            strdup(netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_OUTPUT_PRECISION));

    }

    /*

     * read in MIB database and initialize the snmp library, read the config file

     */

    init_snmp(NETSNMP_APPLICATION_CONFIG_TYPE);

    /*

     * restore command line parameters which should have precedence above config file settings

     */

    if(backup_NETSNMP_DS_LIB_OUTPUT_PRECISION) {

        netsnmp_ds_set_string(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_OUTPUT_PRECISION, backup_NETSNMP_DS_LIB_OUTPUT_PRECISION);

        free(backup_NETSNMP_DS_LIB_OUTPUT_PRECISION);

    }

    /*

     * session default version 

     */

    if (session->version == SNMP_DEFAULT_VERSION) {

        /*

         * run time default version 

         */

        session->version = netsnmp_ds_get_int(NETSNMP_DS_LIBRARY_ID, 

					      NETSNMP_DS_LIB_SNMPVERSION);

        /*

         * compile time default version 

         */

        if (!session->version) {

            switch (NETSNMP_DEFAULT_SNMP_VERSION) {

#ifndef NETSNMP_DISABLE_SNMPV1

            case 1:

                session->version = SNMP_VERSION_1;

                break;

#endif

#ifndef NETSNMP_DISABLE_SNMPV2C

            case 2:

                session->version = SNMP_VERSION_2c;

                break;

#endif

            case 3:

                session->version = SNMP_VERSION_3;

                break;

            default:

                snmp_log(LOG_ERR, "Can't determine a valid SNMP version for the session\n");

                return(NETSNMP_PARSE_ARGS_ERROR);

            }

        } else {

#ifndef NETSNMP_DISABLE_SNMPV1

            if (session->version == NETSNMP_DS_SNMP_VERSION_1)  /* bogus value.  version 1 actually = 0 */

                session->version = SNMP_VERSION_1;

#endif

        }

    }

#ifdef NETSNMP_SECMOD_USM

    /* XXX: this should ideally be moved to snmpusm.c somehow */

    /*

     * make master key from pass phrases 

     */

    if (Apsz) {

        session->securityAuthKeyLen = USM_AUTH_KU_LEN;

        if (session->securityAuthProto == NULL) {

            /*

             * get .conf set default 

             */

            const oid      *def =

                get_default_authtype(&session->securityAuthProtoLen);

            session->securityAuthProto =

                snmp_duplicate_objid(def, session->securityAuthProtoLen);

        }

        if (session->securityAuthProto == NULL) {

            session->securityAuthProto =

                snmp_duplicate_objid(SNMP_DEFAULT_AUTH_PROTO,

                                     SNMP_DEFAULT_AUTH_PROTOLEN);

            session->securityAuthProtoLen = SNMP_DEFAULT_AUTH_PROTOLEN;

        }

        if (generate_Ku(session->securityAuthProto,

                        session->securityAuthProtoLen,

                        (u_char *) Apsz, strlen(Apsz),

                        session->securityAuthKey,

                        &session->securityAuthKeyLen) != SNMPERR_SUCCESS) {

            snmp_perror(argv[0]);

            fprintf(stderr,

                    "Error generating a key (Ku) from the supplied authentication pass phrase. \n");

            return (NETSNMP_PARSE_ARGS_ERROR);

        }

        free(Apsz);

    }

    if (Xpsz) {

        session->securityPrivKeyLen = USM_PRIV_KU_LEN;

        if (session->securityPrivProto == NULL) {

            /*

             * get .conf set default 

             */

            const oid      *def =

                get_default_privtype(&session->securityPrivProtoLen);

            session->securityPrivProto =

                snmp_duplicate_objid(def, session->securityPrivProtoLen);

        }

        if (session->securityPrivProto == NULL) {

            session->securityPrivProto =

                snmp_duplicate_objid(SNMP_DEFAULT_PRIV_PROTO,

                                     SNMP_DEFAULT_PRIV_PROTOLEN);

            session->securityPrivProtoLen = SNMP_DEFAULT_PRIV_PROTOLEN;

        }

        if (generate_Ku(session->securityAuthProto,

                        session->securityAuthProtoLen,

                        (u_char *) Xpsz, strlen(Xpsz),

                        session->securityPrivKey,

                        &session->securityPrivKeyLen) != SNMPERR_SUCCESS) {

            snmp_perror(argv[0]);

            fprintf(stderr,

                    "Error generating a key (Ku) from the supplied privacy pass phrase. \n");

            return (NETSNMP_PARSE_ARGS_ERROR);

        }

        free(Xpsz);

    }

#endif /* NETSNMP_SECMOD_USM */

    /*

     * get the hostname 

     */

    if (optind == argc) {

        fprintf(stderr, "No hostname specified.\n");

        return (NETSNMP_PARSE_ARGS_ERROR_USAGE);

    }

    session->peername = argv[optind++]; /* hostname */

#if !defined(NETSNMP_DISABLE_SNMPV1) || !defined(NETSNMP_DISABLE_SNMPV2C)

    /*

     * If v1 or v2c, check community has been set, either by a -c option above,

     * or via a default token somewhere.  

     * If neither, it will be taken from the incoming request PDU.

     */

#if defined(NETSNMP_DISABLE_SNMPV1)

    if (session->version == SNMP_VERSION_2c)

#else 

#if defined(NETSNMP_DISABLE_SNMPV2C)

    if (session->version == SNMP_VERSION_1)

#else

    if (session->version == SNMP_VERSION_1 ||

	session->version == SNMP_VERSION_2c)

#endif

#endif

    {

        if (Cpsz == NULL) {

            Cpsz = netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID, 

					 NETSNMP_DS_LIB_COMMUNITY);

	    if (Cpsz == NULL) {

                if (netsnmp_ds_get_boolean(NETSNMP_DS_LIBRARY_ID,

                                           NETSNMP_DS_LIB_IGNORE_NO_COMMUNITY)){

                    DEBUGMSGTL(("snmp_parse_args",

                                "ignoring that the community string is not present\n"));

                    session->community = NULL;

                    session->community_len = 0;

                } else {

                    fprintf(stderr, "No community name specified.\n");

                    return (NETSNMP_PARSE_ARGS_ERROR_USAGE);

                }

	    }

	} else {

            session->community = (unsigned char *)Cpsz;

            session->community_len = strlen(Cpsz);

        }

    }

#endif /* support for community based SNMP */

    return optind;

}

int

snmp_parse_args(int argc,

                char **argv,

                netsnmp_session * session, const char *localOpts,

                void (*proc) (int, char *const *, int))

{

    return netsnmp_parse_args(argc, argv, session, localOpts, proc, 0);

}