/*

 * 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 <net-snmp/net-snmp-features.h>

#include <net-snmp/types.h>

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

#include <stdio.h>

#if HAVE_STRING_H

#include <string.h>

#else

#include <strings.h>

#endif

#include <sys/types.h>

#if HAVE_STDLIB_H

#include <stdlib.h>

#endif

#include <ctype.h>

#if HAVE_UNISTD_H

#include <unistd.h>

#endif

#if HAVE_DMALLOC_H

#include <dmalloc.h>

#endif

#include <net-snmp/output_api.h>

#include <net-snmp/utilities.h>

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

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

#ifdef NETSNMP_TRANSPORT_TLSBASE_DOMAIN

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

#endif

#ifdef NETSNMP_TRANSPORT_TLSTCP_DOMAIN

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

#endif

#ifdef NETSNMP_TRANSPORT_STD_DOMAIN

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

#endif

#ifdef NETSNMP_TRANSPORT_TCP_DOMAIN

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

#endif

#ifdef NETSNMP_TRANSPORT_DTLSUDP_DOMAIN

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

#endif

#ifdef NETSNMP_TRANSPORT_SSH_DOMAIN

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

#endif

#ifdef NETSNMP_TRANSPORT_ALIAS_DOMAIN

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

#endif

#ifdef NETSNMP_TRANSPORT_IPX_DOMAIN

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

#endif

#ifdef NETSNMP_TRANSPORT_UNIX_DOMAIN

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

#endif

#ifdef NETSNMP_TRANSPORT_AAL5PVC_DOMAIN

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

#endif

#ifdef NETSNMP_TRANSPORT_UDPIPV6_DOMAIN

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

#endif

#ifdef NETSNMP_TRANSPORT_TCPIPV6_DOMAIN

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

#endif

#ifdef NETSNMP_TRANSPORT_UDPSHARED_DOMAIN

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

#endif

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

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

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

netsnmp_feature_child_of(transport_all, libnetsnmp)

netsnmp_feature_child_of(tdomain_support, transport_all)

netsnmp_feature_child_of(tdomain_transport_oid, transport_all)

netsnmp_feature_child_of(sockaddr_size, transport_all)

netsnmp_feature_child_of(transport_cache, transport_all)

/*

 * Our list of supported transport domains.  

 */

static netsnmp_tdomain *domain_list = NULL;

/*

 * The standard SNMP domains.  

 */

oid             netsnmpUDPDomain[] = { 1, 3, 6, 1, 6, 1, 1 };

size_t          netsnmpUDPDomain_len = OID_LENGTH(netsnmpUDPDomain);

oid             netsnmpCLNSDomain[] = { 1, 3, 6, 1, 6, 1, 2 };

size_t          netsnmpCLNSDomain_len = OID_LENGTH(netsnmpCLNSDomain);

oid             netsnmpCONSDomain[] = { 1, 3, 6, 1, 6, 1, 3 };

size_t          netsnmpCONSDomain_len = OID_LENGTH(netsnmpCONSDomain);

oid             netsnmpDDPDomain[] = { 1, 3, 6, 1, 6, 1, 4 };

size_t          netsnmpDDPDomain_len = OID_LENGTH(netsnmpDDPDomain);

oid             netsnmpIPXDomain[] = { 1, 3, 6, 1, 6, 1, 5 };

size_t          netsnmpIPXDomain_len = OID_LENGTH(netsnmpIPXDomain);

static netsnmp_container *_container = NULL;

static void     netsnmp_tdomain_dump(void);

#if !defined(NETSNMP_FEATURE_REMOVE_FILTER_SOURCE)

static netsnmp_container * filtered = NULL;

void netsnmp_transport_parse_filter(const char *word, char *cptr);

#endif /* NETSNMP_FEATURE_REMOVE_FILTER_SOURCE */

void

init_snmp_transport(void)

{

    netsnmp_ds_register_config(ASN_BOOLEAN,

                               "snmp", "dontLoadHostConfig",

                               NETSNMP_DS_LIBRARY_ID,

                               NETSNMP_DS_LIB_DONT_LOAD_HOST_FILES);

#ifndef NETSNMP_FEATURE_REMOVE_FILTER_SOURCE

    register_app_config_handler("sourceFilterType",

                                netsnmp_transport_parse_filterType,

                                NULL, "none|whitelist|blacklist");

    register_app_config_handler("sourceFilterAddress",

                                netsnmp_transport_parse_filter,

                                netsnmp_transport_filter_cleanup,

                                "host");

#endif /* NETSNMP_FEATURE_REMOVE_FILTER_SOURCE */

}

void

shutdown_snmp_transport(void)

{

#ifndef NETSNMP_FEATURE_REMOVE_FILTER_SOURCE

    netsnmp_transport_filter_cleanup();

#endif

}

/*

 * Make a deep copy of an netsnmp_transport.  

 */

netsnmp_transport *

netsnmp_transport_copy(const netsnmp_transport *t)

{

    netsnmp_transport *n = NULL;

    if (t == NULL) {

        return NULL;

    }

    n = SNMP_MALLOC_TYPEDEF(netsnmp_transport);

    if (n == NULL) {

        return NULL;

    }

    if (t->domain != NULL) {

        n->domain = t->domain;

        n->domain_length = t->domain_length;

    } else {

        n->domain = NULL;

        n->domain_length = 0;

    }

    if (t->local != NULL) {

        n->local = netsnmp_memdup(t->local, t->local_length);

        if (n->local == NULL) {

            netsnmp_transport_free(n);

            return NULL;

        }

        n->local_length = t->local_length;

    } else {

        n->local = NULL;

        n->local_length = 0;

    }

    if (t->remote != NULL) {

        n->remote = netsnmp_memdup(t->remote, t->remote_length);

        if (n->remote == NULL) {

            netsnmp_transport_free(n);

            return NULL;

        }

        n->remote_length = t->remote_length;

    } else {

        n->remote = NULL;

        n->remote_length = 0;

    }

    if (t->data != NULL && t->data_length > 0) {

        n->data = netsnmp_memdup(t->data, t->data_length);

        if (n->data == NULL) {

            netsnmp_transport_free(n);

            return NULL;

        }

        n->data_length = t->data_length;

    } else {

        n->data = NULL;

        n->data_length = 0;

    }

    n->msgMaxSize = t->msgMaxSize;

    n->f_accept = t->f_accept;

    n->f_recv = t->f_recv;

    n->f_send = t->f_send;

    n->f_close = t->f_close;

    n->f_copy = t->f_copy;

    n->f_config = t->f_config;

    n->f_fmtaddr = t->f_fmtaddr;

    n->sock = t->sock;

    n->flags = t->flags;

    n->base_transport = netsnmp_transport_copy(t->base_transport);

    /* give the transport a chance to do "special things" */

    if (t->f_copy)

        t->f_copy(t, n);

    return n;

}

void

netsnmp_transport_free(netsnmp_transport *t)

{

    if (NULL == t)

        return;

#ifndef FEATURE_REMOVE_TRANSPORT_CACHE

    /** don't free a transport that is currently shared */

    if (netsnmp_transport_cache_remove(t) == 1)

        return;

#endif

    SNMP_FREE(t->local);

    SNMP_FREE(t->remote);

    SNMP_FREE(t->data);

    netsnmp_transport_free(t->base_transport);

    SNMP_FREE(t);

}

/*

 * netsnmp_transport_peer_string

 *

 * returns string representation of peer address.

 *

 * caller is responsible for freeing the allocated string.

 */

char *

netsnmp_transport_peer_string(netsnmp_transport *t, const void *data, int len)

{

    char           *str;

    if (NULL == t)

        return NULL;

    if (t->f_fmtaddr != NULL)

        str = t->f_fmtaddr(t, data, len);

    else

        str = strdup("<UNKNOWN>");

    return str;

}

#if !defined(NETSNMP_FEATURE_REMOVE_FILTER_SOURCE)

static int _transport_filter_init(void)

{

    if (filtered)

        return 0;

    filtered = netsnmp_container_find("transport_filter:cstring");

    if (NULL == filtered) {

        NETSNMP_LOGONCE((LOG_WARNING,

                         "couldn't allocate container for transport_filter list\n"));

        return -1;

    }

    filtered->container_name = strdup("transport_filter list");

    return 0;

}

int

netsnmp_transport_filter_add(const char *addrtxt)

{

    char *tmp;

    /*

     * create the container, if needed

     */

    if (!filtered && _transport_filter_init()) {

        snmp_log(LOG_ERR,"netsnmp_transport_filter_add %s failed\n",

                 addrtxt);

        return (-1);

    }

    tmp = strdup(addrtxt);

    if (NULL == tmp) {

        snmp_log(LOG_ERR,"netsnmp_transport_filter_add strdup failed\n");

        return(-1);

    }

    return CONTAINER_INSERT(filtered, tmp);

}

int

netsnmp_transport_filter_remove(const char *addrtxt)

{

    /*

     * create the container, if needed

     */

    if (NULL == filtered)

        return -1;

    return CONTAINER_REMOVE(filtered, addrtxt);

}

/*

 * netsnmp_transport_filter_check

 *

 * returns 1 if the specified address string is in the filter list

 */

int

netsnmp_transport_filter_check(const char *addrtxt)

{

    char *addr;

    if (NULL == filtered)

        return 0;

    addr = CONTAINER_FIND(filtered, addrtxt);

    return addr ? 1 : 0;

}

void

netsnmp_transport_parse_filterType(const char *word, char *cptr)

{

    int type = 42;

    if (strcmp(cptr,"whitelist") == 0)

        type = 1;

    else if (strcmp(cptr,"blacklist") == 0)

        type = -1;

    else if (strcmp(cptr,"none") == 0)

        type = 0;

    else

        netsnmp_config_error("unknown source filter type: %s", cptr);

    if (type != 42) {

        DEBUGMSGTL(("transport:filterType", "set to %d\n", type));

        netsnmp_ds_set_int(NETSNMP_DS_LIBRARY_ID,

                           NETSNMP_DS_LIB_FILTER_TYPE, type);

    }

}

void

netsnmp_transport_parse_filter(const char *word, char *cptr)

{

    if (netsnmp_transport_filter_add(cptr))

        netsnmp_config_error("cannot create source filter: %s", cptr);

}

void

netsnmp_transport_filter_cleanup(void)

{

    if (NULL == filtered)

        return;

    CONTAINER_CLEAR(filtered, filtered->free_item, NULL);

    CONTAINER_FREE(filtered);

    filtered = NULL;

}

#endif /* NETSNMP_FEATURE_REMOVE_FILTER_SOURCE */

#ifndef NETSNMP_FEATURE_REMOVE_SOCKADDR_SIZE

int

netsnmp_sockaddr_size(const struct sockaddr *sa)

{

    if (NULL == sa)

        return 0;

    switch (sa->sa_family) {

        case AF_INET:

            return sizeof(struct sockaddr_in);

        break;

#ifdef NETSNMP_ENABLE_IPV6

        case AF_INET6:

            return sizeof(struct sockaddr_in6);

            break;

#endif

    }

    return 0;

}

#endif /* NETSNMP_FEATURE_REMOVE_SOCKADDR_SIZE */

int

netsnmp_transport_send(netsnmp_transport *t, const void *packet, int length,

                       void **opaque, int *olength)

{

    int dumpPacket, debugLength;

    if ((NULL == t) || (NULL == t->f_send)) {

        DEBUGMSGTL(("transport:pkt:send", "NULL transport or send function\n"));

        return SNMPERR_GENERR;

    }

    dumpPacket = netsnmp_ds_get_boolean(NETSNMP_DS_LIBRARY_ID,

                                        NETSNMP_DS_LIB_DUMP_PACKET);

    debugLength = (SNMPERR_SUCCESS ==

                   debug_is_token_registered("transport:send"));

    if (dumpPacket | debugLength) {

        char *str = netsnmp_transport_peer_string(t,

                                                  opaque ? *opaque : NULL,

                                                  olength ? *olength : 0);

        if (debugLength)

            DEBUGMSGT_NC(("transport:send","%lu bytes to %s\n",

                          (unsigned long)length, str));

        if (dumpPacket)

            snmp_log(LOG_DEBUG, "\nSending %lu bytes to %s\n", 

                     (unsigned long)length, str);

        SNMP_FREE(str);

    }

    if (dumpPacket)

        xdump(packet, length, "");

    return t->f_send(t, packet, length, opaque, olength);

}

int

netsnmp_transport_recv(netsnmp_transport *t, void *packet, int length,

                       void **opaque, int *olength)

{

    int debugLength;

    if ((NULL == t) || (NULL == t->f_recv)) {

        DEBUGMSGTL(("transport:recv", "NULL transport or recv function\n"));

        return SNMPERR_GENERR;

    }

    length = t->f_recv(t, packet, length, opaque, olength);

    if (length <=0)

        return length; /* don't log timeouts/socket closed */

    debugLength = (SNMPERR_SUCCESS ==

                   debug_is_token_registered("transport:recv"));

    if (debugLength) {

        char *str = netsnmp_transport_peer_string(t,

                                                  opaque ? *opaque : NULL,

                                                  olength ? *olength : 0);

        if (debugLength)

            DEBUGMSGT_NC(("transport:recv","%d bytes from %s\n",

                          length, str));

        SNMP_FREE(str);

    }

    return length;

}

#ifndef NETSNMP_FEATURE_REMOVE_TDOMAIN_SUPPORT

int

netsnmp_tdomain_support(const oid * in_oid,

                        size_t in_len,

                        const oid ** out_oid, size_t * out_len)

{

    netsnmp_tdomain *d = NULL;

    for (d = domain_list; d != NULL; d = d->next) {

        if (netsnmp_oid_equals(in_oid, in_len, d->name, d->name_length) == 0) {

            if (out_oid != NULL && out_len != NULL) {

                *out_oid = d->name;

                *out_len = d->name_length;

            }

            return 1;

        }

    }

    return 0;

}

#endif /* NETSNMP_FEATURE_REMOVE_TDOMAIN_SUPPORT */

void

netsnmp_tdomain_init(void)

{

    DEBUGMSGTL(("tdomain", "netsnmp_tdomain_init() called\n"));

/* include the configure generated list of constructor calls */

#include "transports/snmp_transport_inits.h"

    netsnmp_tdomain_dump();

}

void

netsnmp_clear_tdomain_list(void)

{

    netsnmp_tdomain *list = domain_list, *next = NULL;

    DEBUGMSGTL(("tdomain", "clear_tdomain_list() called\n"));

    while (list != NULL) {

	next = list->next;

	SNMP_FREE(list->prefix);

        /* attention!! list itself is not in the heap, so we must not free it! */

	list = next;

    }

    domain_list = NULL;

}

static void

netsnmp_tdomain_dump(void)

{

    netsnmp_tdomain *d;

    int i = 0;

    DEBUGMSGTL(("tdomain", "domain_list -> "));

    for (d = domain_list; d != NULL; d = d->next) {

        DEBUGMSG(("tdomain", "{ "));

        DEBUGMSGOID(("tdomain", d->name, d->name_length));

        DEBUGMSG(("tdomain", ", \""));

        for (i = 0; d->prefix[i] != NULL; i++) {

            DEBUGMSG(("tdomain", "%s%s", d->prefix[i],

		      (d->prefix[i + 1]) ? "/" : ""));

        }

        DEBUGMSG(("tdomain", "\" } -> "));

    }

    DEBUGMSG(("tdomain", "[NIL]\n"));

}

int

netsnmp_tdomain_register(netsnmp_tdomain *n)

{

    netsnmp_tdomain **prevNext = &domain_list, *d;

    if (n != NULL) {

        for (d = domain_list; d != NULL; d = d->next) {

            if (netsnmp_oid_equals(n->name, n->name_length,

                                d->name, d->name_length) == 0) {

                /*

                 * Already registered.  

                 */

                return 0;

            }

            prevNext = &(d->next);

        }

        n->next = NULL;

        *prevNext = n;

        return 1;

    } else {

        return 0;

    }

}

netsnmp_feature_child_of(tdomain_unregister, netsnmp_unused)

#ifndef NETSNMP_FEATURE_REMOVE_TDOMAIN_UNREGISTER

int

netsnmp_tdomain_unregister(netsnmp_tdomain *n)

{

    netsnmp_tdomain **prevNext = &domain_list, *d;

    if (n != NULL) {

        for (d = domain_list; d != NULL; d = d->next) {

            if (netsnmp_oid_equals(n->name, n->name_length,

                                d->name, d->name_length) == 0) {

                *prevNext = n->next;

		SNMP_FREE(n->prefix);

                return 1;

            }

            prevNext = &(d->next);

        }

        return 0;

    } else {

        return 0;

    }

}

#endif /* NETSNMP_FEATURE_REMOVE_TDOMAIN_UNREGISTER */

static netsnmp_tdomain *

find_tdomain(const char* spec)

{

    netsnmp_tdomain *d;

    for (d = domain_list; d != NULL; d = d->next) {

        int i;

        for (i = 0; d->prefix[i] != NULL; i++)

            if (strcasecmp(d->prefix[i], spec) == 0) {

                DEBUGMSGTL(("tdomain",

                            "Found domain \"%s\" from specifier \"%s\"\n",

                            d->prefix[0], spec));

                return d;

            }

    }

    DEBUGMSGTL(("tdomain", "Found no domain from specifier \"%s\"\n", spec));

    return NULL;

}

static int

netsnmp_is_fqdn(const char *thename)

{

    if (!thename)

        return 0;

    while(*thename) {

        if (*thename != '.' && !isupper((unsigned char)*thename) &&

            !islower((unsigned char)*thename) &&

            !isdigit((unsigned char)*thename) && *thename != '-') {

            return 0;

        }

        thename++;

    }

    return 1;

}

/*

 * Locate the appropriate transport domain and call the create function for

 * it.

 */

netsnmp_transport *

netsnmp_tdomain_transport_tspec(netsnmp_tdomain_spec *tspec)

{

    const char *application, *str, *default_domain, *default_target, *source;

    int local;

    netsnmp_tdomain    *match = NULL;

    const char         *addr = NULL;

    const char * const *spec = NULL;

    int                 any_found = 0;

    char buf[SNMP_MAXPATH];

    char **lspec = NULL;

    char *tokenized_domain = NULL;

    application = tspec->application;

    str = tspec->target;

    local = tspec->flags & NETSNMP_TSPEC_LOCAL;

    default_domain = tspec->default_domain;

    default_target = tspec->default_target;

    source = tspec->source;

    /** transport_config = tspec->transport_config; not used yet */

    DEBUGMSGTL(("tdomain",

                "tdomain_transport_spec(\"%s\", \"%s\", %d, \"%s\", \"%s\", \"%s\")\n",

                application, str ? str : "[NIL]", local,

                default_domain ? default_domain : "[NIL]",

                default_target ? default_target : "[NIL]",

                source ? source : "[NIL]"));

    /* see if we can load a host-name specific set of conf files */

    if (!netsnmp_ds_get_boolean(NETSNMP_DS_LIBRARY_ID,

                                NETSNMP_DS_LIB_DONT_LOAD_HOST_FILES) &&

        netsnmp_is_fqdn(str)) {

        static int have_added_handler = 0;

        char *newhost;

        struct config_line *config_handlers;

        struct config_files file_names;

        char *prev_hostname;

        /* register a "transport" specifier */

        if (!have_added_handler) {

            have_added_handler = 1;

            netsnmp_ds_register_config(ASN_OCTET_STR,

                                       "snmp", "transport",

                                       NETSNMP_DS_LIBRARY_ID,

                                       NETSNMP_DS_LIB_HOSTNAME);

        }

        /* we save on specific setting that we don't allow to change

           from one transport creation to the next; ie, we don't want

           the "transport" specifier to be a default.  It should be a

           single invocation use only */

        prev_hostname = netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID,

                                              NETSNMP_DS_LIB_HOSTNAME);

        if (prev_hostname)

            prev_hostname = strdup(prev_hostname);

        /* read in the hosts/STRING.conf files */

        config_handlers = read_config_get_handlers("snmp");

        snprintf(buf, sizeof(buf)-1, "hosts/%s", str);

        file_names.fileHeader = buf;

        file_names.start = config_handlers;

        file_names.next = NULL;

        DEBUGMSGTL(("tdomain", "checking for host specific config %s\n",

                    buf));

        read_config_files_of_type(EITHER_CONFIG, &file_names);

        if (NULL !=

            (newhost = netsnmp_ds_get_string(NETSNMP_DS_LIBRARY_ID,

                                             NETSNMP_DS_LIB_HOSTNAME))) {

            strlcpy(buf, newhost, sizeof(buf));

            str = buf;

        }

        netsnmp_ds_set_string(NETSNMP_DS_LIBRARY_ID,

                              NETSNMP_DS_LIB_HOSTNAME,

                              prev_hostname);

        SNMP_FREE(prev_hostname);

    }

    /* First try - assume that there is a domain in str (domain:target) */

    if (str != NULL) {

        const char *cp;

        if ((cp = strchr(str, ':')) != NULL) {

            char* mystring = (char*)malloc(cp + 1 - str);

            memcpy(mystring, str, cp - str);

            mystring[cp - str] = '\0';

            addr = cp + 1;

            match = find_tdomain(mystring);

            free(mystring);

        }

    }

    /*

     * Second try, if there is no domain in str (target), then try the

     * default domain

     */

    if (match == NULL) {

        addr = str;

        if (addr && *addr == '/') {

            DEBUGMSGTL(("tdomain",

                        "Address starts with '/', so assume \"unix\" "

                        "domain\n"));

            match = find_tdomain("unix");

        } else if (default_domain) {

            DEBUGMSGTL(("tdomain",

                        "Use user specified default domain \"%s\"\n",

                        default_domain));

            if (!strchr(default_domain, ','))

                match = find_tdomain(default_domain);

            else {

                int commas = 0;

                const char *cp = default_domain;

                char *ptr = NULL;

                tokenized_domain = strdup(default_domain);

                while (*++cp) if (*cp == ',') commas++;

                lspec = calloc(commas+2, sizeof(char *));

                commas = 1;

                lspec[0] = strtok_r(tokenized_domain, ",", &ptr);

                while ((lspec[commas++] = strtok_r(NULL, ",", &ptr)))

                    ;

                spec = (const char * const *)lspec;

            }

        } else {

            spec = netsnmp_lookup_default_domains(application);

            if (spec == NULL) {

                DEBUGMSGTL(("tdomain",

                            "No default domain found, assume \"udp\"\n"));

                match = find_tdomain("udp");

            } else {

                const char * const * r = spec;

                DEBUGMSGTL(("tdomain",

                            "Use application default domains"));

                while(*r) {

                    DEBUGMSG(("tdomain", " \"%s\"", *r));

                    ++r;

                }

                DEBUGMSG(("tdomain", "\n"));

            }

        }

    }

    for(;;) {

        if (match) {

            netsnmp_transport *t = NULL;

            const char* addr2;

            any_found = 1;

            /*

             * Ok, we know what domain to try, lets see what default data

             * should be used with it

             */

            if (default_target != NULL)

                addr2 = default_target;

            else

                addr2 = netsnmp_lookup_default_target(application,

                                                      match->prefix[0]);

            DEBUGMSGTL(("tdomain",

                        "trying domain \"%s\" address \"%s\" "

                        "default address \"%s\"\n",

                        match->prefix[0], addr ? addr : "[NIL]",

                        addr2 ? addr2 : "[NIL]"));

            if (match->f_create_from_tspec) {

                netsnmp_tdomain_spec tspec_tmp;

                memcpy(&tspec_tmp, tspec, sizeof(tspec_tmp));

                /** if we didn't have a default target but looked one up,

                 *  copy the spec and use the found default. */

                if ((default_target == NULL) && (addr2 != NULL))

                    tspec_tmp.default_target = addr2;

                if (addr != tspec_tmp.target)

                    tspec_tmp.target = addr;

                t = match->f_create_from_tspec(&tspec_tmp);

            }

            else {

#if 0 /** remove warning until all transports implement tspec */

                NETSNMP_LOGONCE((LOG_WARNING,

                                 "transport domain %s uses deprecated f_create function\n",

                                 match->prefix[0]));

#endif

                if (match->f_create_from_tstring) {

                    t = match->f_create_from_tstring(addr, local);

                }

                else

                    t = match->f_create_from_tstring_new(addr, local, addr2);

            }

            if (t) {

                if (lspec) {

                    free(tokenized_domain);

                    free(lspec);

                }

                return t;

            }

        }

        addr = str;

        if (spec && *spec)

            match = find_tdomain(*spec++);

        else

            break;

    }

    if (!any_found)

        snmp_log(LOG_ERR, "No support for any checked transport domain\n");

    if (lspec) {

        free(tokenized_domain);

        free(lspec);

    }

    return NULL;

}

netsnmp_transport *

netsnmp_tdomain_transport_full(const char *application,

                               const char *str, int local,

                               const char *default_domain,

                               const char *default_target)

{

    netsnmp_tdomain_spec tspec;

    memset(&tspec, 0x0, sizeof(tspec));

    tspec.application = application;

    tspec.target = str;

    if (local)

        tspec.flags |= NETSNMP_TSPEC_LOCAL;

    tspec.default_domain = default_domain;

    tspec.default_target = default_target;

    tspec.source = NULL;

    tspec.transport_config = NULL;

    return netsnmp_tdomain_transport_tspec(&tspec);

}

netsnmp_transport *

netsnmp_tdomain_transport(const char *str, int local,

			  const char *default_domain)

{

    netsnmp_tdomain_spec tspec;

    memset(&tspec, 0x0, sizeof(tspec));

    tspec.application = "snmp";

    tspec.target = str;

    if (local)

        tspec.flags |= NETSNMP_TSPEC_LOCAL;

    tspec.default_domain = default_domain;

    tspec.default_target = NULL;

    tspec.source = NULL;

    tspec.transport_config = NULL;

    return netsnmp_tdomain_transport_tspec(&tspec);

}

#ifndef NETSNMP_FEATURE_REMOVE_TDOMAIN_TRANSPORT_OID

netsnmp_transport *

netsnmp_tdomain_transport_oid(const oid * dom,