/*-
* Copyright (c) 2019 Mindaugas Rasiukevicius <rmind at noxt eu>
* Copyright (c) 2013 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Mindaugas Rasiukevicius.
*
* 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
*/

/*
* NPF network interface handling.
*
* NPF uses its own interface IDs (npf-if-id).  These IDs start from 1.
* Zero is reserved to indicate "no interface" case or an interface of
* no interest (i.e. not registered).
*
* This module provides an interface to primarily handle the following:
*
* - Bind a symbolic interface name to NPF interface ID.
* - Associate NPF interface ID when the network interface is attached.
*
* When NPF configuration is (re)loaded, each referenced network interface
* name is registered with a unique ID.  If the network interface is already
* attached, then the ID is associated with it immediately; otherwise, IDs
* are associated/disassociated on interface events which are monitored
* using pfil(9) hooks.
*
* To avoid race conditions when an active NPF configuration is updated or
* interfaces are detached/attached, the interface names are never removed
* and therefore IDs are never re-assigned.  The only point when interface
* names and IDs are cleared is when the configuration is flushed.
*
* A linear counter is used for IDs.
*/

#ifdef _KERNEL
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: npf_if.c,v 1.13 2020/05/30 14:16:56 rmind Exp $");

#include <sys/param.h>
#include <sys/types.h>
#include <sys/kmem.h>
#include <net/if.h>
#endif

#include "npf_impl.h"

typedef struct npf_ifmap {
       char            ifname[IFNAMSIZ + 1];
} npf_ifmap_t;

#define NPF_IFMAP_NOID                  (0U)
#define NPF_IFMAP_SLOT2ID(npf, slot)    ((npf)->ifmap_off + (slot) + 1)
#define NPF_IFMAP_ID2SLOT(npf, id)      \
   ((id) - atomic_load_relaxed(&(npf)->ifmap_off) - 1)

void
npf_ifmap_init(npf_t *npf, const npf_ifops_t *ifops)
{
       const size_t nbytes = sizeof(npf_ifmap_t) * NPF_MAX_IFMAP;

       KASSERT(ifops != NULL);
       ifops->flush(npf, (void *)(uintptr_t)0);

       mutex_init(&npf->ifmap_lock, MUTEX_DEFAULT, IPL_SOFTNET);
       npf->ifmap = kmem_zalloc(nbytes, KM_SLEEP);
       npf->ifmap_cnt = 0;
       npf->ifmap_off = 0;
       npf->ifops = ifops;
}

void
npf_ifmap_fini(npf_t *npf)
{
       const size_t nbytes = sizeof(npf_ifmap_t) * NPF_MAX_IFMAP;
       mutex_destroy(&npf->ifmap_lock);
       kmem_free(npf->ifmap, nbytes);
}

static unsigned
npf_ifmap_lookup(npf_t *npf, const char *ifname)
{
       KASSERT(mutex_owned(&npf->ifmap_lock));

       for (unsigned i = 0; i < npf->ifmap_cnt; i++) {
               npf_ifmap_t *ifmap = &npf->ifmap[i];

               if (strcmp(ifmap->ifname, ifname) == 0) {
                       return NPF_IFMAP_SLOT2ID(npf, i);
               }
       }
       return NPF_IFMAP_NOID;
}

/*
* npf_ifmap_register: register an interface name; return an assigned
* NPF network ID on success (non-zero).
*
* This routine is mostly called on NPF configuration (re)load for the
* interfaces names referenced by the rules.
*/
unsigned
npf_ifmap_register(npf_t *npf, const char *ifname)
{
       npf_ifmap_t *ifmap;
       unsigned id, i;
       ifnet_t *ifp;

       mutex_enter(&npf->ifmap_lock);
       if ((id = npf_ifmap_lookup(npf, ifname)) != NPF_IFMAP_NOID) {
               goto out;
       }
       if (npf->ifmap_cnt == NPF_MAX_IFMAP) {
               printf("npf_ifmap_new: out of slots; bump NPF_MAX_IFMAP\n");
               id = NPF_IFMAP_NOID;
               goto out;
       }
       KASSERT(npf->ifmap_cnt < NPF_MAX_IFMAP);

       /* Allocate a new slot and convert and assign an ID. */
       i = npf->ifmap_cnt++;
       ifmap = &npf->ifmap[i];
       strlcpy(ifmap->ifname, ifname, IFNAMSIZ);
       id = NPF_IFMAP_SLOT2ID(npf, i);

       if ((ifp = npf->ifops->lookup(npf, ifname)) != NULL) {
               npf->ifops->setmeta(npf, ifp, (void *)(uintptr_t)id);
       }
out:
       mutex_exit(&npf->ifmap_lock);
       return id;
}

void
npf_ifmap_flush(npf_t *npf)
{
       mutex_enter(&npf->ifmap_lock);
       npf->ifops->flush(npf, (void *)(uintptr_t)NPF_IFMAP_NOID);
       for (unsigned i = 0; i < npf->ifmap_cnt; i++) {
               npf->ifmap[i].ifname[0] = '\0';
       }
       npf->ifmap_cnt = 0;

       /*
        * Reset the ID counter if reaching the overflow; this is not
        * realistic, but we maintain correctness.
        */
       if (npf->ifmap_off < (UINT_MAX - NPF_MAX_IFMAP)) {
               npf->ifmap_off += NPF_MAX_IFMAP;
       } else {
               npf->ifmap_off = 0;
       }
       mutex_exit(&npf->ifmap_lock);
}

/*
* npf_ifmap_getid: get the ID for the given network interface.
*
* => This routine is typically called from the packet handler when
*    matching whether the packet is on particular network interface.
*
* => This routine is lock-free; if the NPF configuration is flushed
*    while the packet is in-flight, the ID will not match because we
*    keep the IDs linear.
*/
unsigned
npf_ifmap_getid(npf_t *npf, const ifnet_t *ifp)
{
       const unsigned id = (uintptr_t)npf->ifops->getmeta(npf, ifp);
       return id;
}

/*
* npf_ifmap_copylogname: this function is toxic; it can return garbage
* as we don't lock, but it is only used temporarily and only for logging.
*/
void
npf_ifmap_copylogname(npf_t *npf, unsigned id, char *buf, size_t len)
{
       const unsigned i = NPF_IFMAP_ID2SLOT(npf, id);

       membar_consumer();

       if (id != NPF_IFMAP_NOID && i < NPF_MAX_IFMAP) {
               /*
                * Lock-free access is safe as there is an extra byte
                * with a permanent NUL terminator at the end.
                */
               const npf_ifmap_t *ifmap = &npf->ifmap[i];
               strlcpy(buf, ifmap->ifname, MIN(len, IFNAMSIZ));
       } else {
               strlcpy(buf, "???", len);
       }
}

void
npf_ifmap_copyname(npf_t *npf, unsigned id, char *buf, size_t len)
{
       mutex_enter(&npf->ifmap_lock);
       npf_ifmap_copylogname(npf, id, buf, len);
       mutex_exit(&npf->ifmap_lock);
}

__dso_public void
npfk_ifmap_attach(npf_t *npf, ifnet_t *ifp)
{
       const npf_ifops_t *ifops = npf->ifops;
       unsigned id;

       mutex_enter(&npf->ifmap_lock);
       id = npf_ifmap_lookup(npf, ifops->getname(npf, ifp));
       ifops->setmeta(npf, ifp, (void *)(uintptr_t)id);
       mutex_exit(&npf->ifmap_lock);
}

__dso_public void
npfk_ifmap_detach(npf_t *npf, ifnet_t *ifp)
{
       /* Diagnostic. */
       mutex_enter(&npf->ifmap_lock);
       npf->ifops->setmeta(npf, ifp, (void *)(uintptr_t)NPF_IFMAP_NOID);
       mutex_exit(&npf->ifmap_lock);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.