/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/param.h>
#include <sys/atomic.h>
#include <sys/kmem.h>
#include <sys/rwlock.h>
#include <sys/errno.h>
#include <sys/queue.h>
#include <inet/common.h>
#include <inet/led.h>
#include <inet/ip.h>
#include <sys/neti.h>
#include <sys/zone.h>

static net_handle_t net_find(const char *protocol, neti_stack_t *ns);

static net_handle_t
net_find(const char *protocol, neti_stack_t *nts)
{
        struct net_data *n;

        ASSERT(protocol != NULL);
        ASSERT(nts != NULL);

        LIST_FOREACH(n, &nts->nts_netd_head, netd_list) {
                ASSERT(n->netd_info.netp_name != NULL);
                /*
                 * If they're trying to find a protocol that is being
                 * shutdown, just ignore it..
                 */
                if (n->netd_condemned != 0)
                        continue;
                if (strcmp(n->netd_info.netp_name, protocol) == 0) {
                        break;
                }
        }

        return (n);
}

net_handle_t
net_protocol_register(netid_t id, const net_protocol_t *info)
{
        struct net_data *n, *new;
        neti_stack_t *nts;

        ASSERT(info != NULL);

        nts = net_getnetistackbyid(id);
        if (nts == NULL)
                return (NULL);

        new = kmem_alloc(sizeof (*new), KM_SLEEP);
        new->netd_refcnt = 1;
        new->netd_hooks = NULL;
        new->netd_info = *info;
        new->netd_stack = nts;
        new->netd_condemned = 0;

        mutex_enter(&nts->nts_lock);
        n = net_find(info->netp_name, nts);
        if (n != NULL) {
                mutex_exit(&nts->nts_lock);
                kmem_free(new, sizeof (*new));
                return (NULL);
        }

        if (LIST_EMPTY(&nts->nts_netd_head)) {
                LIST_INSERT_HEAD(&nts->nts_netd_head, new, netd_list);
        } else {
                LIST_INSERT_AFTER(LIST_FIRST(&nts->nts_netd_head),
                    new, netd_list);
        }
        mutex_exit(&nts->nts_lock);

        return (new);
}

int
net_protocol_unregister(net_handle_t info)
{
        neti_stack_t *nts;

        ASSERT(info != NULL);

        nts = info->netd_stack;
        ASSERT(nts != NULL);

        mutex_enter(&nts->nts_lock);
        LIST_REMOVE(info, netd_list);
        info->netd_stack = NULL;
        mutex_exit(&nts->nts_lock);

        (void) net_protocol_release(info);

        return (0);
}

net_handle_t
net_protocol_lookup(netid_t netid, const char *protocol)
{
        neti_stack_t *nts;
        net_handle_t nd;

        ASSERT(protocol != NULL);

        nts = net_getnetistackbyid(netid);
        if (nts == NULL)
                return (NULL);

        mutex_enter(&nts->nts_lock);
        nd = net_find(protocol, nts);
        if (nd != NULL)
                atomic_inc_32((uint_t *)&nd->netd_refcnt);
        mutex_exit(&nts->nts_lock);
        return (nd);
}

/*
 * Note: the man page specifies "returns -1 if the value passed in is unknown
 * to this framework".  We are not doing a lookup in this function, just a
 * simply add to the netd_refcnt of the net_handle_t passed in, so -1 is never a
 * return value.
 */
int
net_protocol_release(net_handle_t info)
{

        ASSERT(info->netd_refcnt > 0);
        /*
         * Is this safe? No hold on nts_lock? Consider that if the caller
         * of net_protocol_release() is going to free this structure then
         * it is now the only owner (refcnt==1) and it will have been
         * removed from the nts_netd_head list on the neti_stack_t from a
         * call to net_protocol_unregister already, so it is thus an orphan.
         */
        if (atomic_dec_32_nv((uint_t *)&info->netd_refcnt) == 0) {
                ASSERT(info->netd_hooks == NULL);
                ASSERT(info->netd_stack == NULL);
                kmem_free(info, sizeof (struct net_data));
        }

        return (0);
}

net_handle_t
net_protocol_walk(netid_t netid, net_handle_t info)
{
        struct net_data *n = NULL;
        boolean_t found = B_FALSE;
        neti_stack_t *nts;

        nts = net_getnetistackbyid(netid);
        ASSERT(nts != NULL);

        if (info == NULL)
                found = B_TRUE;

        mutex_enter(&nts->nts_lock);
        LIST_FOREACH(n, &nts->nts_netd_head, netd_list) {
                if (found) {
                        /*
                         * We are only interested in finding protocols that
                         * are not in some sort of shutdown state.  There is
                         * no need to check for netd_stack==NULL because
                         * that implies it is no longer on this list.
                         */
                        if (n->netd_condemned == 0)
                                continue;
                        break;
                }

                if (n == info)
                        found = B_TRUE;
        }

        if (info != NULL)
                (void) net_protocol_release(info);

        if (n != NULL)
                atomic_inc_32((uint_t *)&n->netd_refcnt);

        mutex_exit(&nts->nts_lock);

        return (n);
}

/*
 * Public accessor functions
 */
int
net_getifname(net_handle_t info, phy_if_t nic, char *buffer,
    const size_t buflen)
{

        ASSERT(info != NULL);

        if (info->netd_condemned != 0 || info->netd_stack == NULL)
                return (-1);

        return (info->netd_info.netp_getifname(info, nic, buffer, buflen));
}

int
net_getmtu(net_handle_t info, phy_if_t nic, lif_if_t ifdata)
{

        ASSERT(info != NULL);

        if (info->netd_condemned != 0 || info->netd_stack == NULL)
                return (-1);

        return (info->netd_info.netp_getmtu(info, nic, ifdata));
}

int
net_getpmtuenabled(net_handle_t info)
{

        ASSERT(info != NULL);

        if (info->netd_condemned != 0 || info->netd_stack == NULL)
                return (-1);

        return (info->netd_info.netp_getpmtuenabled(info));
}

int
net_getlifaddr(net_handle_t info, phy_if_t nic, lif_if_t ifdata,
    int nelem, net_ifaddr_t type[], void *storage)
{

        ASSERT(info != NULL);

        if (info->netd_condemned != 0 || info->netd_stack == NULL)
                return (-1);

        return (info->netd_info.netp_getlifaddr(info, nic, ifdata,
            nelem, type, storage));
}

int
net_getlifzone(net_handle_t info, phy_if_t phy_ifdata, lif_if_t ifdata,
    zoneid_t *zoneid)
{
        ASSERT(info != NULL);

        if (info->netd_condemned != 0 || info->netd_stack == NULL)
                return (-1);

        return (info->netd_info.neti_getlifzone(info, phy_ifdata, ifdata,
            zoneid));
}

int
net_getlifflags(net_handle_t info, phy_if_t phy_ifdata, lif_if_t ifdata,
    uint64_t *flags)
{
        ASSERT(info != NULL);

        if (info->netd_condemned != 0 || info->netd_stack == NULL)
                return (-1);

        return (info->netd_info.neti_getlifflags(info, phy_ifdata, ifdata,
            flags));
}

phy_if_t
net_phygetnext(net_handle_t info, phy_if_t nic)
{

        ASSERT(info != NULL);

        if (info->netd_condemned != 0 || info->netd_stack == NULL)
                return ((phy_if_t)-1);

        return (info->netd_info.netp_phygetnext(info, nic));
}

phy_if_t
net_phylookup(net_handle_t info, const char *name)
{

        ASSERT(info != NULL);

        if (info->netd_condemned != 0 || info->netd_stack == NULL)
                return ((phy_if_t)-1);

        return (info->netd_info.netp_phylookup(info, name));
}

lif_if_t
net_lifgetnext(net_handle_t info, phy_if_t ifidx, lif_if_t ifdata)
{

        ASSERT(info != NULL);

        if (info->netd_condemned != 0 || info->netd_stack == NULL)
                return ((lif_if_t)-1);

        return (info->netd_info.netp_lifgetnext(info, ifidx, ifdata));
}

int
net_inject(net_handle_t info, inject_t style, net_inject_t *packet)
{

        ASSERT(info != NULL);

        if (info->netd_condemned != 0 || info->netd_stack == NULL)
                return (-1);

        return (info->netd_info.netp_inject(info, style, packet));
}

phy_if_t
net_routeto(net_handle_t info, struct sockaddr *address, struct sockaddr *next)
{

        ASSERT(info != NULL);

        if (info->netd_condemned != 0 || info->netd_stack == NULL)
                return ((phy_if_t)-1);

        return (info->netd_info.netp_routeto(info, address, next));
}

int
net_ispartialchecksum(net_handle_t info, mblk_t *mp)
{

        ASSERT(info != NULL);
        ASSERT(mp != NULL);

        if (info->netd_condemned != 0 || info->netd_stack == NULL)
                return (-1);

        return (info->netd_info.netp_ispartialchecksum(info, mp));
}

int
net_isvalidchecksum(net_handle_t info, mblk_t *mp)
{

        ASSERT(info != NULL);
        ASSERT(mp != NULL);

        if (info->netd_condemned != 0 || info->netd_stack == NULL)
                return (-1);

        return (info->netd_info.netp_isvalidchecksum(info, mp));
}

/*
 * Hooks related functions
 */

/*
 * Function:    net_family_register
 * Returns:     int - 0 = Succ, Else = Fail
 * Parameters:  info(I) - protocol
 *              hf(I) - family pointer
 *
 * Call hook_family_add to register family
 *
 * There is no need to bump netd_refcnt in the two functions
 * net_family_register and net_family_unregister because the caller of these
 * two functions is assumed to "own" a reference on 'info' via an earlier
 * call to net_protocol_register().  Thus the owner is expected to do a
 * call to net_protocol_unregister() after having done a
 * net_family_unregister() to make sure things are properly cleaned up.
 * Passing a pointer to info->netd_hooks into hook_family_add is required
 * so that this can be set before the notify functions are called. If this
 * does not happen, the notify function may do something that seems fine,
 * like add a notify function to the family but cause a panic because
 * netd_hooks is NULL when we get to hook_family_notify_register.
 */
int
net_family_register(net_handle_t info, hook_family_t *hf)
{
        netstack_t *ns;

        ASSERT(info != NULL);
        ASSERT(hf != NULL);

        if (info->netd_condemned != 0 || info->netd_stack == NULL)
                return (ESHUTDOWN);

        if (info->netd_hooks != NULL)
                return (EEXIST);

        ns = info->netd_stack->nts_netstack;
        ASSERT(ns != NULL);
        if (hook_family_add(hf, ns->netstack_hook,
            (void **)&info->netd_hooks) == NULL)
                return (EEXIST);

        return (0);
}

/*
 * Function:    net_family_unregister
 * Returns:     int - transparent value, explained by caller
 * Parameters:  info(I) - protocol
 *              hf(I) - family pointer
 *
 * Call hook_family_remove to unregister family
 */
int
net_family_unregister(net_handle_t info, hook_family_t *hf)
{
        int ret;

        ASSERT(info != NULL);
        ASSERT(hf != NULL);

        if (info->netd_hooks == NULL)
                return (ENXIO);

        if (strcmp(info->netd_hooks->hfi_family.hf_name,
            hf->hf_name) != 0)
                return (EINVAL);

        ret = hook_family_remove(info->netd_hooks);
        if (ret == 0)
                info->netd_hooks = NULL;

        return (ret);
}

int
net_family_shutdown(net_handle_t info, hook_family_t *hf)
{

        ASSERT(info != NULL);
        ASSERT(hf != NULL);

        if (info->netd_hooks == NULL)
                return (ENXIO);

        if (strcmp(info->netd_hooks->hfi_family.hf_name,
            hf->hf_name) != 0)
                return (EINVAL);

        return (hook_family_shutdown(info->netd_hooks));
}

/*
 * Function:    net_event_register
 * Returns:     internal event pointer - NULL = Fail
 * Parameters:  info(I) - protocol
 *              he(I) - event pointer
 *
 * Call hook_event_add to register event on specific family
 *      Internal event pointer is returned so caller can get
 *      handle to run hooks
 */
hook_event_token_t
net_event_register(net_handle_t info, hook_event_t *he)
{
        hook_event_int_t *hei;

        ASSERT(info != NULL);
        ASSERT(he != NULL);

        if (info->netd_hooks == NULL || info->netd_condemned != 0 ||
            info->netd_stack == NULL)
                return (NULL);

        hei = hook_event_add(info->netd_hooks, he);
        return ((hook_event_token_t)hei);
}

/*
 * Function:    net_event_unregister
 * Returns:     int - transparent value, explained by caller
 * Parameters:  info(I) - protocol
 *              he(I) - event pointer
 *
 * Call hook_event_remove to unregister event on specific family
 */
int
net_event_unregister(net_handle_t info, hook_event_t *he)
{

        ASSERT(info != NULL);
        ASSERT(he != NULL);

        if (info->netd_hooks == NULL)
                return (ENXIO);

        return (hook_event_remove(info->netd_hooks, he));
}

int
net_event_shutdown(net_handle_t info, hook_event_t *he)
{

        ASSERT(info != NULL);
        ASSERT(he != NULL);

        if (info->netd_hooks == NULL)
                return (ENXIO);

        return (hook_event_shutdown(info->netd_hooks, he));
}

/*
 * Function:    net_hook_register
 * Returns:     int - transparent value, explained by caller
 * Parameters:  info(I) - protocol
 *              event(I) - event name
 *              h(I) - hook pointer
 *
 * Call hook_register to add hook on specific family/event
 */
int
net_hook_register(net_handle_t info, char *event, hook_t *h)
{

        ASSERT(info != NULL);
        ASSERT(event != NULL);
        ASSERT(h != NULL);

        if (info->netd_condemned != 0 || info->netd_stack == NULL)
                return (ESHUTDOWN);

        if (info->netd_hooks == NULL)
                return (ENXIO);

        return (hook_register(info->netd_hooks, event, h));
}

/*
 * Function:    net_hook_unregister
 * Returns:     int - transparent value, explained by caller
 * Parameters:  info(I) - protocol
 *              event(I) - event name
 *              h(I) - hook pointer
 *
 * Call hook_unregister to remove hook on specific family/event
 */
int
net_hook_unregister(net_handle_t info, char *event, hook_t *h)
{

        ASSERT(info != NULL);
        ASSERT(event != NULL);
        ASSERT(h != NULL);

        if (info->netd_hooks == NULL)
                return (ENXIO);

        return (hook_unregister(info->netd_hooks, event, h));
}

netid_t
net_getnetid(net_handle_t netd)
{

        if (netd->netd_stack == NULL)
                return (-1);
        return (netd->netd_stack->nts_id);
}

net_inject_t *
net_inject_alloc(const int version)
{
        net_inject_t *ni;

        ni = kmem_zalloc(sizeof (*ni), KM_NOSLEEP);
        if (ni == NULL)
                return (NULL);

        ni->ni_version = version;
        return (ni);
}

void
net_inject_free(net_inject_t *ni)
{
        kmem_free(ni, sizeof (*ni));
}

kstat_t *
net_kstat_create(netid_t netid, char *module, int instance, char *name,
    char *class, uchar_t type, ulong_t ndata, uchar_t ks_flag)
{
        netstackid_t stackid = net_getnetstackidbynetid(netid);

        if (stackid == -1)
                return (NULL);

        return (kstat_create_netstack(module, instance, name, class, type,
            ndata, ks_flag, stackid));
}

void
net_kstat_delete(netid_t netid, kstat_t *ks)
{
        netstackid_t stackid = net_getnetstackidbynetid(netid);

        if (stackid != -1)
                kstat_delete_netstack(ks, stackid);
}

int
net_event_notify_register(net_handle_t family, char *event,
    hook_notify_fn_t callback, void *arg)
{
        int error;

        if (family->netd_condemned != 0 || family->netd_stack == NULL)
                return (ESHUTDOWN);

        error = hook_event_notify_register(family->netd_hooks, event,
            callback, arg);

        return (error);
}

int
net_event_notify_unregister(net_handle_t family, char *event,
    hook_notify_fn_t callback)
{
        int error;

        error = hook_event_notify_unregister(family->netd_hooks, event,
            callback);

        return (error);
}

int
net_protocol_notify_register(net_handle_t family, hook_notify_fn_t callback,
    void *arg)
{
        int error;

        if (family->netd_condemned != 0 || family->netd_stack == NULL)
                return (ESHUTDOWN);

        error = hook_family_notify_register(family->netd_hooks, callback,
            arg);

        return (error);
}

int
net_protocol_notify_unregister(net_handle_t family, hook_notify_fn_t callback)
{
        int error;

        error = hook_family_notify_unregister(family->netd_hooks, callback);

        return (error);
}