/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2015 Nexenta Systems, Inc. All rights reserved.
 */

#include <sys/types.h>
#include <sys/t_lock.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/sysmacros.h>
#include <sys/cmn_err.h>
#include <sys/list.h>
#include <sys/sunddi.h>

#include <sys/stropts.h>
#include <sys/socket.h>
#include <sys/socketvar.h>

#include <fs/sockfs/sockcommon.h>
#include <fs/sockfs/sockfilter_impl.h>
#include <fs/sockfs/socktpi.h>

/*
 * Socket Parameters
 *
 * Socket parameter (struct sockparams) entries represent the socket types
 * available on the system.
 *
 * Flags (sp_flags):
 *
 * SOCKPARAMS_EPHEMERAL: A temporary sockparams entry that will be deleted
 * as soon as its' ref count drops to zero. In addition, ephemeral entries will
 * never be hooked onto the global sockparams list. Ephemeral entries are
 * created when application requests to create a socket using an application
 * supplied device path, or when a socket is falling back to TPI.
 *
 * Lock order:
 *   The lock order is sockconf_lock -> sp_lock.
 */
extern int      kobj_path_exists(char *, int);

static int      sockparams_sdev_init(struct sockparams *, char *, int);
static void     sockparams_sdev_fini(struct sockparams *);

/*
 * Global sockparams list (populated via soconfig(8)).
 */
static list_t sphead;

/*
 * List of ephemeral sockparams.
 */
static list_t sp_ephem_list;

/* Global kstats for sockparams */
typedef struct sockparams_g_stats {
        kstat_named_t spgs_ephem_nalloc;
        kstat_named_t spgs_ephem_nreuse;
} sockparams_g_stats_t;

static sockparams_g_stats_t sp_g_stats;
static kstat_t *sp_g_kstat;


void
sockparams_init(void)
{
        list_create(&sphead, sizeof (struct sockparams),
            offsetof(struct sockparams, sp_node));
        list_create(&sp_ephem_list, sizeof (struct sockparams),
            offsetof(struct sockparams, sp_node));

        kstat_named_init(&sp_g_stats.spgs_ephem_nalloc, "ephemeral_nalloc",
            KSTAT_DATA_UINT64);
        kstat_named_init(&sp_g_stats.spgs_ephem_nreuse, "ephemeral_nreuse",
            KSTAT_DATA_UINT64);

        sp_g_kstat = kstat_create("sockfs", 0, "sockparams", "misc",
            KSTAT_TYPE_NAMED, sizeof (sp_g_stats) / sizeof (kstat_named_t),
            KSTAT_FLAG_VIRTUAL);
        if (sp_g_kstat == NULL)
                return;

        sp_g_kstat->ks_data = &sp_g_stats;

        kstat_install(sp_g_kstat);
}

static int
sockparams_kstat_update(kstat_t *ksp, int rw)
{
        struct sockparams *sp = ksp->ks_private;
        sockparams_stats_t *sps = ksp->ks_data;

        if (rw == KSTAT_WRITE)
                return (EACCES);

        sps->sps_nactive.value.ui64 = sp->sp_refcnt;

        return (0);
}

/*
 * Setup kstats for the given sockparams entry.
 */
static void
sockparams_kstat_init(struct sockparams *sp)
{
        char name[KSTAT_STRLEN];

        (void) snprintf(name, KSTAT_STRLEN, "socket_%d_%d_%d", sp->sp_family,
            sp->sp_type, sp->sp_protocol);

        sp->sp_kstat = kstat_create("sockfs", 0, name, "misc", KSTAT_TYPE_NAMED,
            sizeof (sockparams_stats_t) / sizeof (kstat_named_t),
            KSTAT_FLAG_VIRTUAL);

        if (sp->sp_kstat == NULL)
                return;

        sp->sp_kstat->ks_data = &sp->sp_stats;
        sp->sp_kstat->ks_update = sockparams_kstat_update;
        sp->sp_kstat->ks_private = sp;
        kstat_install(sp->sp_kstat);
}

static void
sockparams_kstat_fini(struct sockparams *sp)
{
        if (sp->sp_kstat != NULL) {
                kstat_delete(sp->sp_kstat);
                sp->sp_kstat = NULL;
        }
}

/*
 * sockparams_create(int family, int type, int protocol, char *modname,
 *     char *devpath, int devpathlen, int flags, int kmflags, int *errorp)
 *
 * Create a new sockparams entry.
 *
 * Arguments:
 *   family, type, protocol: specifies the socket type
 *   modname: Name of the module associated with the socket type. The
 *            module can be NULL if a device path is given, in which
 *            case the TPI module is used.
 *   devpath: Path to the STREAMS device. Must be NULL for non-STREAMS
 *            based transports.
 *   devpathlen: Length of the devpath string. The argument can be 0,
 *            indicating that devpath was allocated statically, and should
 *            not be freed when the sockparams entry is destroyed.
 *
 *   flags  : SOCKPARAMS_EPHEMERAL is the only flag that is allowed.
 *   kmflags: KM_{NO,}SLEEP
 *   errorp : Value-return argument, set when an error occurs.
 *
 * Returns:
 *   On success a new sockparams entry is returned, and *errorp is set
 *   to 0. On failure NULL is returned and *errorp is set to indicate the
 *   type of error that occured.
 *
 * Notes:
 *   devpath and modname are freed upon failure.
 */
struct sockparams *
sockparams_create(int family, int type, int protocol, char *modname,
    char *devpath, int devpathlen, int flags, int kmflags, int *errorp)
{
        struct sockparams *sp = NULL;
        size_t size;

        ASSERT((flags & ~SOCKPARAMS_EPHEMERAL) == 0);
        if (flags & ~SOCKPARAMS_EPHEMERAL) {
                *errorp = EINVAL;
                goto error;
        }

        /* either a module or device must be given, but not both */
        if (modname == NULL && devpath == NULL) {
                *errorp = EINVAL;
                goto error;
        }

        sp = kmem_zalloc(sizeof (*sp), kmflags);
        if (sp == NULL) {
                *errorp = ENOMEM;
                goto error;
        }
        sp->sp_family = family;
        sp->sp_type = type;
        sp->sp_protocol = protocol;
        sp->sp_refcnt = 0;
        sp->sp_flags = flags;

        list_create(&sp->sp_auto_filters, sizeof (sp_filter_t),
            offsetof(sp_filter_t, spf_node));
        list_create(&sp->sp_prog_filters, sizeof (sp_filter_t),
            offsetof(sp_filter_t, spf_node));

        kstat_named_init(&sp->sp_stats.sps_nfallback, "nfallback",
            KSTAT_DATA_UINT64);
        kstat_named_init(&sp->sp_stats.sps_nactive, "nactive",
            KSTAT_DATA_UINT64);
        kstat_named_init(&sp->sp_stats.sps_ncreate, "ncreate",
            KSTAT_DATA_UINT64);

        /*
         * Track how many ephemeral entries we have created.
         */
        if (sp->sp_flags & SOCKPARAMS_EPHEMERAL)
                sp_g_stats.spgs_ephem_nalloc.value.ui64++;

        if (modname != NULL) {
                sp->sp_smod_name = modname;
        } else {
                size = strlen(SOTPI_SMOD_NAME) + 1;
                modname = kmem_zalloc(size, kmflags);
                if (modname == NULL) {
                        *errorp = ENOMEM;
                        goto error;
                }
                sp->sp_smod_name = modname;
                (void) sprintf(sp->sp_smod_name, "%s", SOTPI_SMOD_NAME);
        }

        if (devpath != NULL) {
                /* Set up the device entry. */
                *errorp = sockparams_sdev_init(sp, devpath, devpathlen);
                if (*errorp != 0)
                        goto error;
        }

        mutex_init(&sp->sp_lock, NULL, MUTEX_DEFAULT, NULL);
        *errorp = 0;
        return (sp);
error:
        ASSERT(*errorp != 0);
        if (modname != NULL)
                kmem_free(modname, strlen(modname) + 1);
        if (devpathlen != 0)
                kmem_free(devpath, devpathlen);
        if (sp != NULL)
                kmem_free(sp, sizeof (*sp));
        return (NULL);
}

/*
 * Initialize the STREAMS device aspect of the sockparams entry.
 */
static int
sockparams_sdev_init(struct sockparams *sp, char *devpath, int devpathlen)
{
        vnode_t *vp = NULL;
        int error;

        ASSERT(devpath != NULL);

        if ((error = sogetvp(devpath, &vp, UIO_SYSSPACE)) != 0) {
                dprint(0, ("sockparams_sdev_init: vp %s failed with %d\n",
                    devpath, error));
                return (error);
        }

        ASSERT(vp != NULL);
        sp->sp_sdev_info.sd_vnode = vp;
        sp->sp_sdev_info.sd_devpath = devpath;
        sp->sp_sdev_info.sd_devpathlen = devpathlen;

        return (0);
}

/*
 * sockparams_destroy(struct sockparams *sp)
 *
 * Releases all the resources associated with the sockparams entry,
 * and frees the sockparams entry.
 *
 * Arguments:
 *   sp: the sockparams entry to destroy.
 *
 * Returns:
 *   Nothing.
 *
 * Locking:
 *   The sp_lock of the entry can not be held.
 */
void
sockparams_destroy(struct sockparams *sp)
{
        ASSERT(sp->sp_refcnt == 0);
        ASSERT(!list_link_active(&sp->sp_node));

        sockparams_sdev_fini(sp);

        if (sp->sp_smod_info != NULL)
                SMOD_DEC_REF(sp->sp_smod_info, sp->sp_smod_name);
        kmem_free(sp->sp_smod_name, strlen(sp->sp_smod_name) + 1);
        sp->sp_smod_name = NULL;
        sp->sp_smod_info = NULL;
        mutex_destroy(&sp->sp_lock);
        sockparams_kstat_fini(sp);

        sof_sockparams_fini(sp);
        list_destroy(&sp->sp_auto_filters);
        list_destroy(&sp->sp_prog_filters);

        kmem_free(sp, sizeof (*sp));
}

/*
 * Clean up the STREAMS device part of the sockparams entry.
 */
static void
sockparams_sdev_fini(struct sockparams *sp)
{
        sdev_info_t sd;

        /*
         * if the entry does not have a STREAMS device, then there
         * is nothing to do.
         */
        if (!SOCKPARAMS_HAS_DEVICE(sp))
                return;

        sd = sp->sp_sdev_info;
        if (sd.sd_vnode != NULL)
                VN_RELE(sd.sd_vnode);
        if (sd.sd_devpathlen != 0)
                kmem_free(sd.sd_devpath, sd.sd_devpathlen);

        sp->sp_sdev_info.sd_vnode = NULL;
        sp->sp_sdev_info.sd_devpath = NULL;
}

/*
 * Look for a matching sockparams entry on the given list.
 * The caller must hold the associated list lock.
 */
static struct sockparams *
sockparams_find(list_t *list, int family, int type, int protocol,
    boolean_t by_devpath, const char *name)
{
        struct sockparams *sp;

        for (sp = list_head(list); sp != NULL; sp = list_next(list, sp)) {
                if (sp->sp_family == family && sp->sp_type == type) {
                        if (sp->sp_protocol == protocol) {
                                if (name == NULL)
                                        break;
                                else if (by_devpath &&
                                    sp->sp_sdev_info.sd_devpath != NULL &&
                                    strcmp(sp->sp_sdev_info.sd_devpath,
                                    name) == 0)
                                        break;
                                else if (strcmp(sp->sp_smod_name, name) == 0)
                                        break;
                        }
                }
        }
        return (sp);
}

/*
 * sockparams_hold_ephemeral()
 *
 * Returns an ephemeral sockparams entry of the requested family, type and
 * protocol. The entry is returned held, and the caller is responsible for
 * dropping the reference using SOCKPARAMS_DEC_REF() once done.
 *
 * All ephemeral entries are on list (sp_ephem_list). If there is an
 * entry on the list that match the search criteria, then a reference is
 * placed on that entry. Otherwise, a new entry is created and inserted
 * in the list. The entry is removed from the list when the last reference
 * is dropped.
 *
 * The tpi flag is used to determine whether name refers to a device or
 * module name.
 */
static struct sockparams *
sockparams_hold_ephemeral(int family, int type, int protocol,
    const char *name, boolean_t by_devpath, int kmflag, int *errorp)
{
        struct sockparams *sp = NULL;
        *errorp = 0;

        /*
         * First look for an existing entry
         */
        rw_enter(&sockconf_lock, RW_READER);
        sp = sockparams_find(&sp_ephem_list, family, type, protocol,
            by_devpath, name);
        if (sp != NULL) {
                SOCKPARAMS_INC_REF(sp);
                rw_exit(&sockconf_lock);
                sp_g_stats.spgs_ephem_nreuse.value.ui64++;

                return (sp);
        } else {
                struct sockparams *newsp = NULL;
                char *namebuf = NULL;
                int namelen = 0;

                rw_exit(&sockconf_lock);

                namelen = strlen(name) + 1;
                namebuf = kmem_alloc(namelen, kmflag);
                if (namebuf == NULL) {
                        *errorp = ENOMEM;
                        return (NULL);
                }

                (void *)strncpy(namebuf, name, namelen);
                if (by_devpath) {
                        newsp = sockparams_create(family, type,
                            protocol, NULL, namebuf, namelen,
                            SOCKPARAMS_EPHEMERAL, kmflag, errorp);
                } else {
                        newsp = sockparams_create(family, type,
                            protocol, namebuf, NULL, 0,
                            SOCKPARAMS_EPHEMERAL, kmflag, errorp);
                }

                if (newsp == NULL) {
                        ASSERT(*errorp != 0);
                        return (NULL);
                }

                /*
                 * Time to load the socket module.
                 */
                ASSERT(newsp->sp_smod_info == NULL);
                newsp->sp_smod_info =
                    smod_lookup_byname(newsp->sp_smod_name);
                if (newsp->sp_smod_info == NULL) {
                        /* Failed to load */
                        sockparams_destroy(newsp);
                        *errorp = ENXIO;
                        return (NULL);
                }

                /*
                 * The sockparams entry was created, now try to add it
                 * to the list. We need to hold the lock as a WRITER.
                 */
                rw_enter(&sockconf_lock, RW_WRITER);
                sp = sockparams_find(&sp_ephem_list, family, type, protocol,
                    by_devpath, name);
                if (sp != NULL) {
                        /*
                         * Someone has requested a matching entry, so just
                         * place a hold on it and release the entry we alloc'ed.
                         */
                        SOCKPARAMS_INC_REF(sp);
                        rw_exit(&sockconf_lock);

                        sockparams_destroy(newsp);
                } else {
                        *errorp = sof_sockparams_init(newsp);
                        if (*errorp != 0) {
                                rw_exit(&sockconf_lock);
                                sockparams_destroy(newsp);
                                return (NULL);
                        }
                        SOCKPARAMS_INC_REF(newsp);
                        list_insert_tail(&sp_ephem_list, newsp);
                        rw_exit(&sockconf_lock);

                        sp = newsp;
                }
                ASSERT(*errorp == 0);

                return (sp);
        }
}

struct sockparams *
sockparams_hold_ephemeral_bydev(int family, int type, int protocol,
    const char *dev, int kmflag, int *errorp)
{
        return (sockparams_hold_ephemeral(family, type, protocol, dev, B_TRUE,
            kmflag, errorp));
}

struct sockparams *
sockparams_hold_ephemeral_bymod(int family, int type, int protocol,
    const char *mod, int kmflag, int *errorp)
{
        return (sockparams_hold_ephemeral(family, type, protocol, mod, B_FALSE,
            kmflag, errorp));
}

/*
 * Called when the last socket using the ephemeral entry is dropping
 * its' reference. To maintain lock order we must drop the sockparams
 * lock before calling this function. As a result, a new reference
 * might be placed on the entry, in which case there is nothing to
 * do. However, if ref count goes to zero, we delete the entry.
 */
void
sockparams_ephemeral_drop_last_ref(struct sockparams *sp)
{
        ASSERT(sp->sp_flags & SOCKPARAMS_EPHEMERAL);
        ASSERT(MUTEX_NOT_HELD(&sp->sp_lock));

        rw_enter(&sockconf_lock, RW_WRITER);
        mutex_enter(&sp->sp_lock);

        if (--sp->sp_refcnt == 0) {
                list_remove(&sp_ephem_list, sp);
                mutex_exit(&sp->sp_lock);
                rw_exit(&sockconf_lock);

                sockparams_destroy(sp);
        } else {
                mutex_exit(&sp->sp_lock);
                rw_exit(&sockconf_lock);
        }
}

/*
 * sockparams_add(struct sockparams *sp)
 *
 * Tries to add the given sockparams entry to the global list.
 *
 * Arguments:
 *   sp: the sockparms entry to add
 *
 * Returns:
 *   On success 0, but if an entry already exists, then EEXIST
 *   is returned.
 *
 * Locking:
 *   The caller can not be holding sockconf_lock.
 */
int
sockparams_add(struct sockparams *sp)
{
        int error;

        ASSERT(!(sp->sp_flags & SOCKPARAMS_EPHEMERAL));

        rw_enter(&sockconf_lock, RW_WRITER);
        if (sockparams_find(&sphead, sp->sp_family, sp->sp_type,
            sp->sp_protocol, B_TRUE, NULL) != 0) {
                rw_exit(&sockconf_lock);
                return (EEXIST);
        } else {
                /*
                 * Unique sockparams entry, so init the kstats.
                 */
                sockparams_kstat_init(sp);

                /*
                 * Before making the socket type available we must make
                 * sure that interested socket filters are aware of it.
                 */
                error = sof_sockparams_init(sp);
                if (error != 0) {
                        rw_exit(&sockconf_lock);
                        return (error);
                }
                list_insert_tail(&sphead, sp);
                rw_exit(&sockconf_lock);
                return (0);
        }
}

/*
 * sockparams_delete(int family, int type, int protocol)
 *
 * Marks the sockparams entry for a specific family, type and protocol
 * for deletion. The entry is removed from the list and destroyed
 * if no one is holding a reference to it.
 *
 * Arguments:
 *   family, type, protocol: the socket type that should be removed.
 *
 * Returns:
 *   On success 0, otherwise ENXIO.
 *
 * Locking:
 *   Caller can not be holding sockconf_lock or the sp_lock of
 *   any sockparams entry.
 */
int
sockparams_delete(int family, int type, int protocol)
{
        struct sockparams *sp;

        rw_enter(&sockconf_lock, RW_WRITER);
        sp = sockparams_find(&sphead, family, type, protocol, B_TRUE, NULL);

        if (sp != NULL) {
                /*
                 * If no one is holding a reference to the entry, then
                 * we go ahead and remove it from the list and then
                 * destroy it.
                 */
                mutex_enter(&sp->sp_lock);
                if (sp->sp_refcnt != 0) {
                        mutex_exit(&sp->sp_lock);
                        rw_exit(&sockconf_lock);
                        return (EBUSY);
                }
                mutex_exit(&sp->sp_lock);
                /* Delete the sockparams entry. */
                list_remove(&sphead, sp);
                rw_exit(&sockconf_lock);

                sockparams_destroy(sp);
                return (0);
        } else {
                rw_exit(&sockconf_lock);
                return (ENXIO);
        }
}


/*
 * solookup(int family, int type, int protocol, struct sockparams **spp)
 *
 * Lookup an entry in the sockparams list based on the triple. The returned
 * entry either exactly match the given tuple, or it is the 'default' entry
 * for the given <family, type>. A default entry is on with a protocol
 * value of zero.
 *
 * Arguments:
 *   family, type, protocol: tuple to search for
 *   spp: Value-return argument
 *
 * Returns:
 *   If an entry is found, 0 is returned and *spp is set to point to the
 *   entry. In case an entry is not found, *spp is set to NULL, and an
 *   error code is returned. The errors are (in decreasing precedence):
 *      EAFNOSUPPORT - address family not in list
 *      EPROTONOSUPPORT - address family supported but not protocol.
 *      EPROTOTYPE - address family and protocol supported but not socket type.
 *
 * TODO: should use ddi_modopen()/ddi_modclose()
 */
int
solookup(int family, int type, int protocol, struct sockparams **spp)
{
        struct sockparams *sp = NULL;
        int error = 0;

        *spp = NULL;
        rw_enter(&sockconf_lock, RW_READER);

        /*
         * Search the sockparams list for an appropiate entry.
         * Hopefully we find an entry that match the exact family,
         * type and protocol specified by the user, in which case
         * we return that entry. However, we also keep track of
         * the default entry for a specific family and type, the
         * entry of which would have a protocol value of 0.
         */
        sp = sockparams_find(&sphead, family, type, protocol, B_TRUE, NULL);

        if (sp == NULL) {
                int found = 0;

                /* Determine correct error code */
                for (sp = list_head(&sphead); sp != NULL;
                    sp = list_next(&sphead, sp)) {
                        if (sp->sp_family == family && found < 1)
                                found = 1;
                        if (sp->sp_family == family &&
                            sp->sp_protocol == protocol && found < 2)
                                found = 2;
                }
                rw_exit(&sockconf_lock);
                switch (found) {
                case 0:
                        error = EAFNOSUPPORT;
                        break;
                case 1:
                        error = EPROTONOSUPPORT;
                        break;
                case 2:
                        error = EPROTOTYPE;
                        break;
                }
                return (error);
        }

        /*
         * An entry was found.
         *
         * We put a hold on the entry early on, so if the
         * sockmod is not loaded, and we have to exit
         * sockconf_lock to call modload(), we know that the
         * sockparams entry wont go away. That way we don't
         * have to look up the entry once we come back from
         * modload().
         */
        SOCKPARAMS_INC_REF(sp);
        rw_exit(&sockconf_lock);

        if (sp->sp_smod_info == NULL) {
                smod_info_t *smod = smod_lookup_byname(sp->sp_smod_name);

                if (smod == NULL) {
                        /*
                         * We put a hold on the sockparams entry
                         * earlier, hoping everything would work out.
                         * That obviously did not happen, so release
                         * the hold here.
                         */
                        SOCKPARAMS_DEC_REF(sp);
                        /*
                         * We should probably mark the sockparams as
                         * "bad", and redo the lookup skipping the
                         * "bad" entries. I.e., sp->sp_mod_state |= BAD,
                         * return (solookup(...))
                         */
                        return (ENXIO);
                }
                /*
                 * Another thread might have already looked up the socket
                 * module for this entry. In that case we need to drop our
                 * reference to `smod' to ensure that the sockparams entry
                 * only holds one reference.
                 */
                mutex_enter(&sp->sp_lock);
                if (sp->sp_smod_info == NULL)
                        sp->sp_smod_info = smod;
                else
                        SMOD_DEC_REF(smod, sp->sp_smod_name);
                mutex_exit(&sp->sp_lock);
        }

        /*
         * Alright, we have a valid sockparams entry.
         */
        *spp = sp;
        return (0);
}

/*
 * Called when filter entry `ent' is going away. All sockparams remove
 * their references to `ent'.
 */
static void
sockparams_filter_cleanup_impl(sof_entry_t *ent, list_t *list)
{
        struct sockparams *sp;
        sp_filter_t *fil;
        list_t *flist;

        ASSERT(RW_WRITE_HELD(&sockconf_lock));

        for (sp = list_head(list); sp != NULL;
            sp = list_next(list, sp)) {
                flist = (ent->sofe_flags & SOFEF_AUTO) ?
                    &sp->sp_auto_filters : &sp->sp_prog_filters;
                for (fil = list_head(flist); fil != NULL;
                    fil = list_next(flist, fil)) {
                        if (fil->spf_filter == ent) {
                                list_remove(flist, fil);
                                kmem_free(fil, sizeof (sp_filter_t));
                                break;
                        }
                }
        }
}
void
sockparams_filter_cleanup(sof_entry_t *ent)
{
        sockparams_filter_cleanup_impl(ent, &sphead);
        sockparams_filter_cleanup_impl(ent, &sp_ephem_list);
}

/*
 * New filter is being added; walk the list of sockparams to see if
 * the filter is interested in any of the sockparams.
 */
static int
sockparams_new_filter_impl(sof_entry_t *ent, list_t *list)
{
        struct sockparams *sp;
        int err;

        ASSERT(RW_WRITE_HELD(&sockconf_lock));

        for (sp = list_head(list); sp != NULL;
            sp = list_next(list, sp)) {
                if ((err = sof_entry_proc_sockparams(ent, sp)) != 0) {
                        sockparams_filter_cleanup(ent);
                        return (err);
                }
        }
        return (0);
}

int
sockparams_new_filter(sof_entry_t *ent)
{
        int error;

        if ((error = sockparams_new_filter_impl(ent, &sphead)) != 0)
                return (error);

        if ((error = sockparams_new_filter_impl(ent, &sp_ephem_list)) != 0)
                sockparams_filter_cleanup_impl(ent, &sphead);
        return (error);
}

/*
 * Setup and return socket configuration table.
 */
int
sockparams_copyout_socktable(uintptr_t socktable)
{
        STRUCT_DECL(sockconfig_socktable, st);
        struct sockparams *sp;
        uint_t count;
        uint_t i = 0;
        int ret = 0;
        sockconfig_socktable_entry_t *se;

        STRUCT_INIT(st, get_udatamodel());
        if (ddi_copyin((void *)socktable, STRUCT_BUF(st),
            STRUCT_SIZE(st), 0) != 0)
                return (EFAULT);

        rw_enter(&sockconf_lock, RW_READER);

        count = STRUCT_FGET(st, num_of_entries);
        /*
         * If the output buffer is size zero, just copy out the count.
         */
        if (count == 0) {
                for (sp = list_head(&sphead); sp != NULL;
                    sp = list_next(&sphead, sp)) {
                        count++;
                }
                STRUCT_FSET(st, num_of_entries, count);

                rw_exit(&sockconf_lock);
                if (ddi_copyout(STRUCT_BUF(st), (void *)socktable,
                    STRUCT_SIZE(st), 0) != 0)
                        return (EFAULT);

                return (0);
        }

        se = kmem_alloc(count * sizeof (sockconfig_socktable_entry_t),
            KM_SLEEP);
        for (sp = list_head(&sphead); sp != NULL;
            sp = list_next(&sphead, sp)) {
                if (i >= count) {
                        /*
                         * Return if the number of entries has changed.
                         */
                        rw_exit(&sockconf_lock);
                        kmem_free(se,
                            count * sizeof (sockconfig_socktable_entry_t));
                        return (EAGAIN);
                }
                se[i].se_family = sp->sp_family;
                se[i].se_type = sp->sp_type;
                se[i].se_protocol = sp->sp_protocol;
                (void) strncpy(se[i].se_modname, sp->sp_smod_name,
                    MODMAXNAMELEN);
                if (sp->sp_sdev_info.sd_devpath != NULL)
                        (void) strncpy(se[i].se_strdev,
                            sp->sp_sdev_info.sd_devpath, MAXPATHLEN);
                se[i].se_refcnt = sp->sp_refcnt;
                se[i].se_flags = sp->sp_flags;
                i++;
        }
        rw_exit(&sockconf_lock);
        if (ddi_copyout(se, STRUCT_FGETP(st, st_entries),
            i * sizeof (sockconfig_socktable_entry_t), 0) != 0)
                ret = EFAULT;

        STRUCT_FSET(st, num_of_entries, i);
        kmem_free(se, count * sizeof (sockconfig_socktable_entry_t));

        if (ddi_copyout(STRUCT_BUF(st), (void *)socktable,
            STRUCT_SIZE(st), 0) != 0)
                ret = EFAULT;

        return (ret);
}