/*      $NetBSD: if_agrsubr.c,v 1.13 2019/11/10 21:16:38 chs Exp $      */

/*-
 * Copyright (c)2005 YAMAMOTO Takashi,
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: if_agrsubr.c,v 1.13 2019/11/10 21:16:38 chs Exp $");

#ifdef _KERNEL_OPT
#include "opt_inet.h"
#endif

#include <sys/param.h>
#include <sys/callout.h>
#include <sys/malloc.h>
#include <sys/systm.h>
#include <sys/types.h>
#include <sys/queue.h>
#include <sys/sockio.h>

#include <net/if.h>
#include <net/if_ether.h>

#include <net/agr/if_agrvar_impl.h>
#include <net/agr/if_agrsubr.h>

struct agr_mc_entry {
        TAILQ_ENTRY(agr_mc_entry) ame_q;
        int ame_refcnt;
        struct agr_ifreq ame_ifr; /* XXX waste */
};

static struct agr_mc_entry *agr_mc_lookup(struct agr_multiaddrs *,
    const struct sockaddr *);
static int agrport_mc_add_callback(struct agr_port *, void *);
static int agrport_mc_del_callback(struct agr_port *, void *);
static int agrmc_mc_add_callback(struct agr_mc_entry *, void *);
static int agrmc_mc_del_callback(struct agr_mc_entry *, void *);

static int agr_mc_add(struct agr_multiaddrs *, const struct sockaddr *);
static int agr_mc_del(struct agr_multiaddrs *, const struct sockaddr *);

int
agr_mc_purgeall(struct agr_softc *sc, struct agr_multiaddrs *ama)
{
        struct agr_mc_entry *ame;
        int error = 0;

        while ((ame = TAILQ_FIRST(&ama->ama_addrs)) != NULL) {
                error = agr_port_foreach(sc,
                    agrport_mc_del_callback, &ame->ame_ifr);
                if (error) {
                        /* XXX XXX */
                        printf("%s: error %d\n", __func__, error);
                }
                TAILQ_REMOVE(&ama->ama_addrs, ame, ame_q);
                free(ame, M_DEVBUF);
        }

        return error;
}

int
agr_mc_init(struct agr_softc *sc, struct agr_multiaddrs *ama)
{

        TAILQ_INIT(&ama->ama_addrs);

        return 0;
}

/* ==================== */

static struct agr_mc_entry *
agr_mc_lookup(struct agr_multiaddrs *ama, const struct sockaddr *sa)
{
        struct agr_mc_entry *ame;

        TAILQ_FOREACH(ame, &ama->ama_addrs, ame_q) {
                if (!memcmp(&ame->ame_ifr.ifr_ss, sa, sa->sa_len))
                        return ame;
        }

        return NULL;
}

int
agr_mc_foreach(struct agr_multiaddrs *ama,
    int (*func)(struct agr_mc_entry *, void *), void *arg)
{
        struct agr_mc_entry *ame;
        int error = 0;

        TAILQ_FOREACH(ame, &ama->ama_addrs, ame_q) {
                error = (*func)(ame, arg);
                if (error) {
                        /*
                         * XXX how to recover?
                         * we can try to restore setting, but it can also fail..
                         */
                        break;
                }
        }

        return error;
}

static int
agr_mc_add(struct agr_multiaddrs *ama, const struct sockaddr *sa)
{
        struct agr_mc_entry *ame;

        ame = agr_mc_lookup(ama, sa);
        if (ame) {
                ame->ame_refcnt++;
                return 0;
        }

        ame = malloc(sizeof(*ame), M_DEVBUF, M_WAITOK | M_ZERO);
        memcpy(&ame->ame_ifr.ifr_ss, sa, sa->sa_len);
        ame->ame_refcnt = 1;
        TAILQ_INSERT_TAIL(&ama->ama_addrs, ame, ame_q);

        return ENETRESET;
}

static int
agr_mc_del(struct agr_multiaddrs *ama, const struct sockaddr *sa)
{
        struct agr_mc_entry *ame;

        ame = agr_mc_lookup(ama, sa);
        if (ame == NULL)
                return ENOENT;

        ame->ame_refcnt--;
        if (ame->ame_refcnt > 0)
                return 0;

        TAILQ_REMOVE(&ama->ama_addrs, ame, ame_q);
        free(ame, M_DEVBUF);

        return ENETRESET;
}

/* ==================== */

int
agr_port_foreach(struct agr_softc *sc,
    int (*func)(struct agr_port *, void *), void *arg)
{
        struct agr_port *port;
        int error = 0;

        TAILQ_FOREACH(port, &sc->sc_ports, port_q) {
                if ((port->port_flags & (AGRPORT_LARVAL | AGRPORT_DETACHING))) {
                        continue;
                }
                error = (func)(port, arg);
                if (error) {
                        /*
                         * XXX how to recover?
                         * we can try to restore setting, but it can also fail..
                         */
                        break;
                }
        }

        return error;
}

/* ==================== */

static int
agrmc_mc_add_callback(struct agr_mc_entry *ame, void *arg)
{

        return agrport_mc_add_callback(arg, &ame->ame_ifr);
}

static int
agrmc_mc_del_callback(struct agr_mc_entry *ame, void *arg)
{

        return agrport_mc_del_callback(arg, &ame->ame_ifr);
}

int
agr_configmulti_port(struct agr_multiaddrs *ama, struct agr_port *port,
    bool add)
{

        return agr_mc_foreach(ama,
            add ? agrmc_mc_add_callback : agrmc_mc_del_callback, port);
}

/* -------------------- */

static int
agrport_mc_add_callback(struct agr_port *port, void *arg)
{

        return agrport_ioctl(port, SIOCADDMULTI, arg);
}

static int
agrport_mc_del_callback(struct agr_port *port, void *arg)
{

        return agrport_ioctl(port, SIOCDELMULTI, arg);
}

int
agr_configmulti_ifreq(struct agr_softc *sc, struct agr_multiaddrs *ama,
    struct ifreq *ifr, bool add)
{
        int error;

        if (add)
                error = agr_mc_add(ama, ifreq_getaddr(SIOCADDMULTI, ifr));
        else
                error = agr_mc_del(ama, ifreq_getaddr(SIOCDELMULTI, ifr));

        if (error != ENETRESET)
                return error;

        return agr_port_foreach(sc,
            add ? agrport_mc_add_callback : agrport_mc_del_callback, ifr);
}

/* ==================== */

int
agr_port_getmedia(struct agr_port *port, u_int *media, u_int *status)
{
        struct ifmediareq ifmr;
        int error;

        memset(&ifmr, 0, sizeof(ifmr));
        ifmr.ifm_count = 0;
        error = agrport_ioctl(port, SIOCGIFMEDIA, (void *)&ifmr);

        if (error == 0) {
                *media = ifmr.ifm_active;
                *status = ifmr.ifm_status;
        }

        return error;
}

/* ==================== */

/*
 * Enable vlan hardware assist for the specified port.
 */
int
agr_vlan_add(struct agr_port *port, void *arg)
{
        struct ifnet *ifp = port->port_ifp;
        struct ethercom *ec_port = (void *)ifp;
        int error=0;

        if (ec_port->ec_nvlans++ == 0 &&
            (ec_port->ec_capabilities & ETHERCAP_VLAN_MTU) != 0) {
                struct ifnet *p = port->port_ifp;
                /*
                 * Enable Tx/Rx of VLAN-sized frames.
                 */
                ec_port->ec_capenable |= ETHERCAP_VLAN_MTU;
                if (p->if_flags & IFF_UP) {
                        IFNET_LOCK(p);
                        error = if_flags_set(p, p->if_flags);
                        IFNET_UNLOCK(p);
                        if (error) {
                                if (ec_port->ec_nvlans-- == 1)
                                        ec_port->ec_capenable &=
                                            ~ETHERCAP_VLAN_MTU;
                                return (error);
                        }
                }
        }

        return error;
}

/*
 * Disable vlan hardware assist for the specified port.
 */
int
agr_vlan_del(struct agr_port *port, void *arg)
{
        struct ethercom *ec_port = (void *)port->port_ifp;
        bool *force_zero = (bool *)arg;

        KASSERT(force_zero != NULL);

        /* Disable vlan support */
        if ((*force_zero && ec_port->ec_nvlans > 0) ||
            ec_port->ec_nvlans-- == 1) {
                struct ifnet *p = port->port_ifp;
                if (*force_zero)
                        ec_port->ec_nvlans = 0;
                /*
                 * Disable Tx/Rx of VLAN-sized frames.
                 */
                ec_port->ec_capenable &= ~ETHERCAP_VLAN_MTU;
                if (p->if_flags & IFF_UP) {
                        IFNET_LOCK(p);
                        (void)if_flags_set(p, p->if_flags);
                        IFNET_UNLOCK(p);
                }
        }

        return 0;
}