/*      $NetBSD: altq_afmap.c,v 1.25 2025/01/14 13:51:49 joe Exp $      */
/*      $KAME: altq_afmap.c,v 1.12 2005/04/13 03:44:24 suz Exp $        */

/*
* Copyright (C) 1997-2002
*      Sony Computer Science Laboratories Inc.  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 SONY CSL 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 SONY CSL 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.
*/

/*
* experimental:
* mapping an ip flow to atm vpi/vci.
* this module is not related to queueing at all, but uses the altq
* flowinfo mechanism.  it's just put in the altq framework since
* it is easy to add devices to altq.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: altq_afmap.c,v 1.25 2025/01/14 13:51:49 joe Exp $");

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

#ifdef ALTQ_AFMAP

#include <sys/param.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/uio.h>
#include <sys/socket.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/errno.h>
#include <sys/time.h>
#include <sys/kernel.h>
#include <sys/kauth.h>

#include <net/if.h>
#include <net/if_types.h>
#include <netinet/in.h>

#include <altq/altq.h>
#include <altq/altq_conf.h>
#include <altq/altq_afmap.h>

#ifdef ALTQ3_COMPAT

LIST_HEAD(, afm_head) afhead_chain;

static struct afm *afm_match4(struct afm_head *, struct flowinfo_in *);
#ifdef INET6
static struct afm *afm_match6(struct afm_head *, struct flowinfo_in6 *);
#endif

/*
* rules to block interrupts: afm_match can be called from a net
* level interrupt so that other routines handling the lists should
* be called in splnet().
*/
int
afm_alloc(struct ifnet *ifp)
{
       struct afm_head *head;

       head = malloc(sizeof(struct afm_head), M_DEVBUF, M_WAITOK|M_ZERO);
       if (head == NULL)
               panic("afm_alloc: malloc failed!");

       /* initialize per interface afmap list */
       LIST_INIT(&head->afh_head);

       head->afh_ifp = ifp;

       /* add this afm_head to the chain */
       LIST_INSERT_HEAD(&afhead_chain, head, afh_chain);

       return 0;
}

int
afm_dealloc(struct ifnet *ifp)
{
       struct afm_head *head;

       if ((head = afmhead_if(ifp)) == NULL)
               return -1 ;

       afm_removeall(ifp);

       LIST_REMOVE(head, afh_chain);

       free(head, M_DEVBUF);
       return 0;
}

struct afm *
afm_top(struct ifnet *ifp)
{
       struct afm_head *head;

       if ((head = afmhead_if(ifp)) == NULL)
               return NULL;

       return (head->afh_head.lh_first);
}

int
afm_add(struct ifnet *ifp, struct atm_flowmap *flowmap)
{
       struct afm_head *head;
       struct afm *afm;

       if ((head = afmhead_if(ifp)) == NULL)
               return -1;

       if (flowmap->af_flowinfo.fi_family == AF_INET) {
               if (flowmap->af_flowinfo.fi_len != sizeof(struct flowinfo_in))
                       return EINVAL;
#ifdef INET6
       } else if (flowmap->af_flowinfo.fi_family == AF_INET6) {
               if (flowmap->af_flowinfo.fi_len != sizeof(struct flowinfo_in6))
                       return EINVAL;
#endif
       } else
               return EINVAL;

       afm = malloc(sizeof(struct afm), M_DEVBUF, M_WAITOK|M_ZERO);
       if (afm == NULL)
               return ENOMEM;

       afm->afm_vci = flowmap->af_vci;
       afm->afm_vpi = flowmap->af_vpi;
       (void)memcpy(&afm->afm_flowinfo, &flowmap->af_flowinfo,
             flowmap->af_flowinfo.fi_len);

       LIST_INSERT_HEAD(&head->afh_head, afm, afm_list);
       return 0;
}

int
afm_remove(struct afm *afm)
{
       LIST_REMOVE(afm, afm_list);
       free(afm, M_DEVBUF);
       return 0;
}

int
afm_removeall(struct ifnet *ifp)
{
       struct afm_head *head;
       struct afm *afm;

       if ((head = afmhead_if(ifp)) == NULL)
               return -1;

       while ((afm = head->afh_head.lh_first) != NULL)
               afm_remove(afm);
       return 0;
}

struct afm *
afm_lookup(struct ifnet *ifp, int vpi, int vci)
{
       struct afm_head *head;
       struct afm *afm;

       if ((head = afmhead_if(ifp)) == NULL)
               return NULL;

       for (afm = head->afh_head.lh_first; afm != NULL;
            afm = afm->afm_list.le_next)
               if (afm->afm_vpi == vpi && afm->afm_vci == vci)
                       break;
       return afm;
}

static struct afm *
afm_match4(struct afm_head *head, struct flowinfo_in *fp)
{
       struct afm *afm;

       for (afm = head->afh_head.lh_first; afm != NULL;
            afm = afm->afm_list.le_next) {
               if (afm->afm_flowinfo4.fi_dst.s_addr != 0 &&
                   afm->afm_flowinfo4.fi_dst.s_addr != fp->fi_dst.s_addr)
                       continue;
               if (afm->afm_flowinfo4.fi_dport != 0 &&
                   afm->afm_flowinfo4.fi_dport != fp->fi_dport)
                       continue;
               if (afm->afm_flowinfo4.fi_src.s_addr != 0 &&
                   afm->afm_flowinfo4.fi_src.s_addr != fp->fi_src.s_addr)
                       continue;
               if (afm->afm_flowinfo4.fi_sport != 0 &&
                   afm->afm_flowinfo4.fi_sport != fp->fi_sport)
                       continue;
               if (afm->afm_flowinfo4.fi_proto != 0 &&
                   afm->afm_flowinfo4.fi_proto != fp->fi_proto)
                       continue;
               /* match found! */
               return afm;
       }
       return NULL;
}

#ifdef INET6
static struct afm *
afm_match6(struct afm_head *head, struct flowinfo_in6 *fp)
{
       struct afm *afm;

       for (afm = head->afh_head.lh_first; afm != NULL;
            afm = afm->afm_list.le_next) {
               if (afm->afm_flowinfo6.fi6_flowlabel != 0 &&
                   afm->afm_flowinfo6.fi6_flowlabel != fp->fi6_flowlabel)
                       continue;
#ifdef notyet
               if (!IN6_IS_ADDR_UNSPECIFIED(&afm->afm_flowinfo6.fi6_dst) &&
                   !IN6_ARE_ADDR_EQUAL(&afm->afm_flowinfo6.fi6_dst,
                                       &fp->fi6_dst))
                       continue;
               if (afm->afm_flowinfo6.fi6_dport != 0 &&
                   afm->afm_flowinfo6.fi6_dport != fp->fi6_dport)
                       continue;
#endif
               if (!IN6_IS_ADDR_UNSPECIFIED(&afm->afm_flowinfo6.fi6_src) &&
                   !IN6_ARE_ADDR_EQUAL(&afm->afm_flowinfo6.fi6_src,
                                       &fp->fi6_src))
                       continue;
#ifdef notyet
               if (afm->afm_flowinfo6.fi6_sport != 0 &&
                   afm->afm_flowinfo6.fi6_sport != fp->fi6_sport)
                       continue;
#endif
               if (afm->afm_flowinfo6.fi6_proto != 0 &&
                   afm->afm_flowinfo6.fi6_proto != fp->fi6_proto)
                       continue;
               /* match found! */
               return (afm);
       }
       return NULL;
}
#endif

/* should be called in splnet() */
struct afm *
afm_match(struct ifnet *ifp, struct flowinfo *flow)
{
       struct afm_head *head;

       if ((head = afmhead_if(ifp)) == NULL)
               return NULL;

       switch (flow->fi_family) {
       case AF_INET:
               return (afm_match4(head, (struct flowinfo_in *)flow));

#ifdef INET6
       case AF_INET6:
               return (afm_match6(head, (struct flowinfo_in6 *)flow));
#endif

       default:
               return NULL;
       }
}

/* find the address family node on the current interface */
struct afm_head *
afmhead_if(struct ifnet *ifp)
{
       struct afm_head *head;
       for (head = afhead_chain.lh_first; head != NULL;
           head = head->afh_chain.le_next)
               if (head->afh_ifp == ifp)
                       return head;
       return NULL;
}

/*
* afm device interface
*/
altqdev_decl(afm);

int
afmopen(dev_t dev, int flag, int fmt,
   struct lwp *l)
{
       return 0;
}

int
afmclose(dev_t dev, int flag, int fmt, struct lwp *l)
{
       int err, error = 0;
       struct atm_flowmap fmap;
       struct afm_head *head;

       for (head = afhead_chain.lh_first; head != NULL;
            head = head->afh_chain.le_next) {

               /* call interface to clean up maps */
               snprintf(fmap.af_ifname, sizeof(fmap.af_ifname),
                   "%s", head->afh_ifp->if_xname);
               err = afmioctl(dev, AFM_CLEANFMAP, (void *)&fmap, flag, l);
               if (err && error == 0)
                       error = err;
       }

       return error;
}

int
afmioctl(dev_t dev, ioctlcmd_t cmd, void *addr, int flag,
   struct lwp *l)
{
       int     error = 0;
       struct atm_flowmap *flowmap;
       struct ifnet *ifp;

       /* check cmd for superuser only */
       switch (cmd) {
       case AFM_GETFMAP:
               break;
       default:
               error = kauth_authorize_network(l->l_cred,
                   KAUTH_NETWORK_ALTQ, KAUTH_REQ_NETWORK_ALTQ_AFMAP, NULL,
                   NULL, NULL);
               if (error)
                       return error;
               break;
       }

       /* lookup interface */
       flowmap = (struct atm_flowmap *)addr;
       flowmap->af_ifname[IFNAMSIZ-1] = '\0';
       ifp = ifunit(flowmap->af_ifname);
       if (ifp == NULL)
               return ENXIO;

       IFNET_LOCK(ifp);
       if ((ifp->if_flags & IFF_RUNNING) == 0)
               error = ENXIO;
       else
               error = if_ioctl(ifp, cmd, addr);
       IFNET_UNLOCK(ifp);

       return error;
}

#endif /* ALTQ3_COMPAT */
#endif /* ALTQ_AFMAP */

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.