Aren/NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
045091aa8f
NetBSD/usr.sbin/altq/libaltq/qop.c
thorpej 95a6556014 Import the altq library.
2000-12-16 17:38:07 +00:00

1438 lines
35 KiB
C
Raw Blame History

/* $KAME: qop.c,v 1.6 2000/10/18 09:15:18 kjc Exp $ */
/*
* Copyright (C) 1999-2000
* 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.
*/
#include <sys/param.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <sys/ioctl.h>
#include <sys/fcntl.h>
#include <sys/stat.h>
#if defined(__FreeBSD__) && (__FreeBSD_version > 300000)
#include <sys/linker.h>
#endif
#include <net/if.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <stddef.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <err.h>
#include <syslog.h>
#include <altq/altq.h>
#include <altq/altq_red.h>
#include <altq/altq_rio.h>
#include <altq/altq_cdnr.h>
#include "altq_qop.h"
#include "qop_cdnr.h"
#define ALTQ_DEVICE "/dev/altq/altq"
#define RED_DEVICE "/dev/altq/red"
#define RIO_DEVICE "/dev/altq/rio"
#define CDNR_DEVICE "/dev/altq/cdnr"
#ifndef LIST_HEAD_INITIALIZER
#define LIST_HEAD_INITIALIZER(head) { NULL }
#endif
/*
* token bucket regulator information
*/
struct tbrinfo {
LIST_ENTRY(tbrinfo) link;
char ifname[IFNAMSIZ]; /* if name, e.g. "en0" */
struct tb_profile tb_prof, otb_prof;
int installed;
};
/*
* Static globals
*/
/* a list of configured interfaces */
LIST_HEAD(qop_iflist, ifinfo) qop_iflist = LIST_HEAD_INITIALIZER(&iflist);
/* a list of configured token bucket regulators */
LIST_HEAD(tbr_list, tbrinfo) tbr_list = LIST_HEAD_INITIALIZER(&tbr_list);
int Debug_mode = 0; /* nosched (dummy mode) */
/*
* internal functions
*/
static int get_ifmtu(const char *ifname);
static void tbr_install(const char *ifname);
static void tbr_deinstall(const char *ifname);
static int add_filter_rule(struct ifinfo *ifinfo, struct fltrinfo *fltrinfo,
struct fltrinfo **conflict);
static int remove_filter_rule(struct ifinfo *ifinfo,
struct fltrinfo *fltrinfo);
static int filt_check_relation(struct flow_filter *front,
struct flow_filter *back);
static int filt_disjoint(struct flow_filter *front, struct flow_filter *back);
static int filt_subset(struct flow_filter *front, struct flow_filter *back);
/*
* QCMD (Queue Command) API
*/
int
qcmd_init(void)
{
int error;
/* read config file and execute commands */
error = qcmd_config();
if (error == 0)
error = qcmd_enableall();
if (error != 0)
LOG(LOG_ERR, errno, "%s: qcmd_init failed.\n",
qoperror(error));
return (error);
}
int
qcmd_enable(const char *ifname)
{
struct ifinfo *ifinfo;
int error = 0;
if ((ifinfo = ifname2ifinfo(ifname)) == NULL)
error = QOPERR_BADIF;
if (error == 0)
error = qop_enable(ifinfo);
if (error == 0) {
LOG(LOG_INFO, 0, "%s enabled on interface %s (mtu:%d)\n",
ifinfo->qdisc->qname, ifname, ifinfo->ifmtu);
} else
LOG(LOG_ERR, errno, "%s: enable failed!\n", qoperror(error));
return (error);
}
int
qcmd_disable(const char *ifname)
{
struct ifinfo *ifinfo;
int error = 0;
if ((ifinfo = ifname2ifinfo(ifname)) == NULL)
error = QOPERR_BADIF;
if (error == 0)
error = qop_disable(ifinfo);
if (error != 0)
LOG(LOG_ERR, errno, "%s: disable failed!\n", qoperror(error));
return (error);
}
int
qcmd_enableall()
{
struct ifinfo *ifinfo;
int error;
LIST_FOREACH(ifinfo, &qop_iflist, next) {
if ((error = qop_enable(ifinfo)) != 0)
return (error);
LOG(LOG_INFO, 0, "%s enabled on interface %s (mtu:%d)\n",
ifinfo->qdisc->qname, ifinfo->ifname, ifinfo->ifmtu);
}
return (0);
}
int
qcmd_disableall()
{
struct ifinfo *ifinfo;
int err, error = 0;
LIST_FOREACH(ifinfo, &qop_iflist, next)
if ((err = qop_disable(ifinfo)) != 0)
if (error == 0)
error = err;
return (error);
}
int
qcmd_clear(const char *ifname)
{
struct ifinfo *ifinfo;
int error = 0;
if ((ifinfo = ifname2ifinfo(ifname)) == NULL)
error = QOPERR_BADIF;
if (error == 0)
error = qop_clear(ifinfo);
if (error != 0)
LOG(LOG_ERR, errno, "%s: clear failed!\n", qoperror(error));
return (error);
}
int
qcmd_destroyall(void)
{
while (!LIST_EMPTY(&qop_iflist))
(void)qop_delete_if(LIST_FIRST(&qop_iflist));
return (0);
}
int
qcmd_restart(void)
{
qcmd_destroyall();
return qcmd_init();
}
int
qcmd_delete_class(const char *ifname, const char *clname)
{
struct ifinfo *ifinfo;
struct classinfo *clinfo;
int error = 0;
if ((ifinfo = ifname2ifinfo(ifname)) == NULL)
error = QOPERR_BADIF;
if (error == 0 &&
(clinfo = clname2clinfo(ifinfo, clname)) == NULL)
error = QOPERR_BADCLASS;
if (error == 0)
error = qop_delete_class(clinfo);
if (error != 0)
LOG(LOG_ERR, errno, "%s: delete_class failed\n",
qoperror(error));
return (error);
}
int
qcmd_add_filter(const char *ifname, const char *clname, const char *flname,
const struct flow_filter *fltr)
{
struct ifinfo *ifinfo;
struct classinfo *clinfo;
int error = 0;
if ((ifinfo = ifname2ifinfo(ifname)) == NULL)
error = QOPERR_BADIF;
if (error == 0 &&
(clinfo = clname2clinfo(ifinfo, clname)) == NULL) {
/*
* there is no matching class.
* check if it is for a traffic conditioner
*/
if ((ifinfo = input_ifname2ifinfo(ifname)) == NULL ||
(clinfo = clname2clinfo(ifinfo, clname)) == NULL)
error = QOPERR_BADCLASS;
}
if (error == 0)
error = qop_add_filter(NULL, clinfo, flname, fltr, NULL);
if (error != 0)
LOG(LOG_ERR, errno, "%s: add filter failed!\n",
qoperror(error));
else if (IsDebug(DEBUG_ALTQ)) {
LOG(LOG_DEBUG, 0, "%s: add a filter %s to class %s\n",
ifname, flname ? flname : "(null)",
clname ? clname : "(null)");
print_filter(fltr);
}
return (error);
}
int
qcmd_delete_filter(const char *ifname, const char *clname, const char *flname)
{
struct ifinfo *ifinfo;
struct classinfo *clinfo;
struct fltrinfo *fltrinfo;
int error = 0;
if ((ifinfo = ifname2ifinfo(ifname)) == NULL)
error = QOPERR_BADIF;
if (error == 0 &&
(clinfo = clname2clinfo(ifinfo, clname)) == NULL) {
/*
* there is no matching class.
* check if it is for a traffic conditioner
*/
if ((ifinfo = input_ifname2ifinfo(ifname)) == NULL ||
(clinfo = clname2clinfo(ifinfo, clname)) == NULL)
error = QOPERR_BADCLASS;
}
if (error == 0 &&
(fltrinfo = flname2flinfo(clinfo, flname)) == NULL)
error = QOPERR_BADFILTER;
if (error == 0)
error = qop_delete_filter(fltrinfo);
if (error != 0)
LOG(LOG_ERR, errno, "%s: delete filter failed!\n",
qoperror(error));
return (error);
}
int
qcmd_tbr_register(const char *ifname, u_int rate, u_int size)
{
struct tbrinfo *info;
if ((info = calloc(1, sizeof(struct tbrinfo))) == NULL)
return (QOPERR_NOMEM);
strcpy(info->ifname, ifname);
info->tb_prof.rate = rate;
info->tb_prof.depth = size;
info->installed = 0;
LIST_INSERT_HEAD(&tbr_list, info, link);
return (0);
}
/*
* QOP (Queue Operation) API
*/
int
qop_add_if(struct ifinfo **rp, const char *ifname, u_int bandwidth,
struct qdisc_ops *qdisc_ops, void *if_private)
{
struct ifinfo *ifinfo;
int error;
if (ifname2ifinfo(ifname) != NULL) {
LOG(LOG_ERR, 0, "qop_add_if: %s already exists!\n", ifname);
return (QOPERR_BADIF);
}
if ((ifinfo = calloc(1, sizeof(struct ifinfo))) == NULL)
return (QOPERR_NOMEM);
ifinfo->ifname = strdup(ifname);
ifinfo->bandwidth = bandwidth;
ifinfo->enabled = 0;
if (ifname[0] == '_')
/* input interface */
ifname += 1;
ifinfo->ifindex = get_ifindex(ifname);
ifinfo->ifmtu = get_ifmtu(ifname);
if (qdisc_ops == NULL || Debug_mode)
ifinfo->qdisc = &nop_qdisc; /* replace syscalls by nops */
else
ifinfo->qdisc = qdisc_ops;
ifinfo->private = if_private;
LIST_INIT(&ifinfo->cllist);
LIST_INIT(&ifinfo->fltr_rules);
/* Link the interface info structure */
LIST_INSERT_HEAD(&qop_iflist, ifinfo, next);
/* install token bucket regulator, if necessary */
tbr_install(ifname);
/* attach the discipline to the interface */
if ((error = (*ifinfo->qdisc->attach)(ifinfo)) != 0)
goto err_ret;
/* disable and clear the interface */
if (ifinfo->qdisc->disable != NULL)
if ((error = (*ifinfo->qdisc->disable)(ifinfo)) != 0)
goto err_ret;
if (ifinfo->qdisc->clear != NULL)
if ((error = (*ifinfo->qdisc->clear)(ifinfo)) != 0)
goto err_ret;
if (rp != NULL)
*rp = ifinfo;
return (0);
err_ret:
if (ifinfo != NULL) {
LIST_REMOVE(ifinfo, next);
if (ifinfo->ifname != NULL)
free(ifinfo->ifname);
free(ifinfo);
}
return (error);
}
int
qop_delete_if(struct ifinfo *ifinfo)
{
(void)qop_disable(ifinfo);
(void)qop_clear(ifinfo);
if (ifinfo->delete_hook != NULL)
(*ifinfo->delete_hook)(ifinfo);
/* remove this entry from qop_iflist */
LIST_REMOVE(ifinfo, next);
(void)(*ifinfo->qdisc->detach)(ifinfo);
/* deinstall token bucket regulator, if necessary */
tbr_deinstall(ifinfo->ifname);
if (ifinfo->private != NULL)
free(ifinfo->private);
if (ifinfo->ifname != NULL)
free(ifinfo->ifname);
free(ifinfo);
return (0);
}
int
qop_enable(struct ifinfo *ifinfo)
{
int error;
if (ifinfo->enable_hook != NULL)
if ((error = (*ifinfo->enable_hook)(ifinfo)) != 0)
return (error);
if (ifinfo->qdisc->enable != NULL)
if ((error = (*ifinfo->qdisc->enable)(ifinfo)) != 0)
return (error);
ifinfo->enabled = 1;
return (0);
}
int
qop_disable(struct ifinfo *ifinfo)
{
int error;
if (ifinfo->qdisc->disable != NULL)
if ((error = (*ifinfo->qdisc->disable)(ifinfo)) != 0)
return (error);
ifinfo->enabled = 0;
return (0);
}
int
qop_clear(struct ifinfo *ifinfo)
{
struct classinfo *clinfo;
/* free all classes and filters */
if (ifinfo->ifname[0] != '_') {
/* output interface. delete from leaf classes */
while (!LIST_EMPTY(&ifinfo->cllist)) {
LIST_FOREACH(clinfo, &ifinfo->cllist, next) {
if (clinfo->child != NULL)
continue;
qop_delete_class(clinfo);
/*
* the list has been changed,
* restart from the head
*/
break;
}
}
} else {
/* input interface. delete from parents */
struct classinfo *root = get_rootclass(ifinfo);
while (!LIST_EMPTY(&ifinfo->cllist)) {
LIST_FOREACH(clinfo, &ifinfo->cllist, next)
if (clinfo->parent == root) {
qop_delete_cdnr(clinfo);
break;
}
if (root->child == NULL)
qop_delete_class(root);
}
}
/* clear the interface */
if (ifinfo->qdisc->clear != NULL)
return (*ifinfo->qdisc->clear)(ifinfo);
return (0);
}
int
qop_add_class(struct classinfo **rp, const char *clname,
struct ifinfo *ifinfo, struct classinfo *parent,
void *class_private)
{
struct classinfo *clinfo;
int error;
if ((clinfo = calloc(1, sizeof(*clinfo))) == NULL)
return (QOPERR_NOMEM);
if (clname != NULL)
clinfo->clname = strdup(clname);
else
clinfo->clname = strdup("(null)"); /* dummy name */
clinfo->ifinfo = ifinfo;
clinfo->private = class_private;
clinfo->parent = parent;
clinfo->child = NULL;
LIST_INIT(&clinfo->fltrlist);
if ((error = (*ifinfo->qdisc->add_class)(clinfo)) != 0)
goto err_ret;
/* link classinfo in lists */
LIST_INSERT_HEAD(&ifinfo->cllist, clinfo, next);
if (parent != NULL) {
clinfo->sibling = parent->child;
clinfo->parent->child = clinfo;
}
if (rp != NULL)
*rp = clinfo;
return (0);
err_ret:
if (clinfo != NULL) {
if (clinfo->clname != NULL)
free(clinfo->clname);
free(clinfo);
}
return (error);
}
int
qop_modify_class(struct classinfo *clinfo, void *arg)
{
return (*clinfo->ifinfo->qdisc->modify_class)(clinfo, arg);
}
int
qop_delete_class(struct classinfo *clinfo)
{
struct ifinfo *ifinfo = clinfo->ifinfo;
struct classinfo *prev;
int error;
/* a class to be removed should not have a child */
if (clinfo->child != NULL)
return (QOPERR_CLASS_PERM);
/* remove filters associated to this class */
while (!LIST_EMPTY(&clinfo->fltrlist))
(void)qop_delete_filter(LIST_FIRST(&clinfo->fltrlist));
if (clinfo->delete_hook != NULL)
(*clinfo->delete_hook)(clinfo);
/* remove class info from the interface */
LIST_REMOVE(clinfo, next);
/* remove this class from the child list */
if (clinfo->parent != NULL) {
if (clinfo->parent->child == clinfo)
clinfo->parent->child = clinfo->sibling;
else for (prev = clinfo->parent->child; prev->sibling != NULL;
prev = prev->sibling)
if (prev->sibling == clinfo) {
prev->sibling = clinfo->sibling;
break;
}
}
/* delete class from kernel */
if ((error = (*ifinfo->qdisc->delete_class)(clinfo)) != 0)
return (error);
if (clinfo->private != NULL)
free(clinfo->private);
if (clinfo->clname != NULL)
free(clinfo->clname);
free(clinfo);
return (0);
}
int
qop_add_filter(struct fltrinfo **rp, struct classinfo *clinfo,
const char *flname, const struct flow_filter *fltr,
struct fltrinfo **conflict)
{
struct ifinfo *ifinfo;
struct fltrinfo *fltrinfo;
int error;
if ((fltrinfo = calloc(1, sizeof(*fltrinfo))) == NULL)
return (QOPERR_NOMEM);
fltrinfo->clinfo = clinfo;
fltrinfo->fltr = *fltr;
#if 1
/* fix this */
fltrinfo->line_no = line_no; /* XXX */
fltrinfo->dontwarn = filter_dontwarn; /* XXX */
#endif
if (flname != NULL)
fltrinfo->flname = strdup(flname);
else
fltrinfo->flname = strdup("(null)"); /* dummy name */
/* check and save the filter */
ifinfo = clinfo->ifinfo;
if ((error = add_filter_rule(ifinfo, fltrinfo, conflict)) != 0)
goto err_ret;
/* install the filter to the kernel */
if ((error = (*ifinfo->qdisc->add_filter)(fltrinfo)) != 0) {
remove_filter_rule(ifinfo, fltrinfo);
goto err_ret;
}
/* link fltrinfo onto fltrlist of the class */
LIST_INSERT_HEAD(&clinfo->fltrlist, fltrinfo, next);
if (rp != NULL)
*rp = fltrinfo;
return (0);
err_ret:
if (fltrinfo != NULL) {
if (fltrinfo->flname != NULL)
free(fltrinfo->flname);
free(fltrinfo);
}
return (error);
}
int
qop_delete_filter(struct fltrinfo *fltrinfo)
{
struct ifinfo *ifinfo;
struct classinfo *clinfo;
int error;
/* remove filter info from the class */
clinfo = fltrinfo->clinfo;
ifinfo = clinfo->ifinfo;
/* remove the entry from fltrlist of the class */
LIST_REMOVE(fltrinfo, next);
remove_filter_rule(ifinfo, fltrinfo);
/* delete filter from kernel */
if ((error = (*ifinfo->qdisc->delete_filter)(fltrinfo)) != 0)
return (error);
if (fltrinfo->flname)
free(fltrinfo->flname);
free(fltrinfo);
return (0);
}
const char *
qoperror(int qoperrno)
{
static char buf[64];
if (qoperrno <= QOPERR_MAX)
return (qop_errlist[qoperrno]);
sprintf(buf, "unknown error %d", qoperrno);
return (buf);
}
/*
* misc functions
*/
struct ifinfo *
ifname2ifinfo(const char *ifname)
{
struct ifinfo *ifinfo;
LIST_FOREACH(ifinfo, &qop_iflist, next)
if (ifinfo->ifname != NULL &&
strcmp(ifinfo->ifname, ifname) == 0)
return (ifinfo);
return (NULL);
}
struct ifinfo *
input_ifname2ifinfo(const char *ifname)
{
struct ifinfo *ifinfo;
LIST_FOREACH(ifinfo, &qop_iflist, next)
if (ifinfo->ifname[0] == '_' &&
strcmp(ifinfo->ifname+1, ifname) == 0)
return (ifinfo);
return (NULL);
}
struct classinfo *
clname2clinfo(const struct ifinfo *ifinfo, const char *clname)
{
struct classinfo *clinfo;
LIST_FOREACH(clinfo, &ifinfo->cllist, next)
if (clinfo->clname != NULL &&
strcmp(clinfo->clname, clname) == 0)
return (clinfo);
return (NULL);
}
struct classinfo *
clhandle2clinfo(struct ifinfo *ifinfo, u_long handle)
{
struct classinfo *clinfo;
LIST_FOREACH(clinfo, &ifinfo->cllist, next)
if (clinfo->handle == handle)
return (clinfo);
return (NULL);
}
struct fltrinfo *
flname2flinfo(const struct classinfo *clinfo, const char *flname)
{
struct fltrinfo *fltrinfo;
LIST_FOREACH(fltrinfo, &clinfo->fltrlist, next)
if (fltrinfo->flname != NULL &&
strcmp(fltrinfo->flname, flname) == 0)
return (fltrinfo);
return (NULL);
}
struct fltrinfo *
flhandle2fltrinfo(struct ifinfo *ifinfo, u_long handle)
{
struct fltrinfo *fltrinfo;
LIST_FOREACH(fltrinfo, &ifinfo->fltr_rules, nextrule)
if (fltrinfo->handle == handle)
return (fltrinfo);
return (NULL);
}
int
is_q_enabled(const char *ifname)
{
struct ifinfo *ifinfo;
if ((ifinfo = ifname2ifinfo(ifname)) == NULL)
return (0);
return (ifinfo->enabled);
}
/*
* functions to walk through a class tree:
*
* for (clinfo = get_rootclass(ifinfo);
* clinfo != NULL; clinfo = get_nextclass(clinfo)) {
* do_something;
* }
*/
struct classinfo *get_rootclass(struct ifinfo *ifinfo)
{
struct classinfo *clinfo;
/* find a class without parent */
LIST_FOREACH(clinfo, &ifinfo->cllist, next)
if (clinfo->parent == NULL)
return (clinfo);
return (NULL);
}
/* return next class in the tree */
struct classinfo *get_nextclass(struct classinfo *clinfo)
{
struct classinfo *next;
if (clinfo->child != NULL)
next = clinfo->child;
else if (clinfo->sibling != NULL)
next = clinfo->sibling;
else {
next = clinfo;
while ((next = next->parent) != NULL)
if (next->sibling) {
next = next->sibling;
break;
}
}
return (next);
}
u_long
atobps(const char *s)
{
u_long bandwidth;
char *cp;
bandwidth = strtoul(s, &cp, 0);
if (cp != NULL) {
if (*cp == 'K' || *cp == 'k')
bandwidth *= 1000;
else if (*cp == 'M' || *cp == 'm')
bandwidth *= 1000000;
else if (*cp == 'G' || *cp == 'g')
bandwidth *= 1000000000;
}
return (bandwidth);
}
u_long
atobytes(const char *s)
{
u_long bytes;
char *cp;
bytes = strtoul(s, &cp, 0);
if (cp != NULL) {
if (*cp == 'K' || *cp == 'k')
bytes *= 1024;
else if (*cp == 'M' || *cp == 'm')
bytes *= 1024 * 1024;
else if (*cp == 'G' || *cp == 'g')
bytes *= 1024 * 1024 * 1024;
}
return (bytes);
}
static int
get_ifmtu(const char *ifname)
{
int s, mtu;
struct ifreq ifr;
#ifdef __OpenBSD__
struct if_data ifdata;
#endif
mtu = 512; /* default MTU */
if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
return (mtu);
strncpy(ifr.ifr_name, ifname, sizeof ifr.ifr_name);
#ifdef __OpenBSD__
ifr.ifr_data = (caddr_t)&ifdata;
if (ioctl(s, SIOCGIFDATA, (caddr_t)&ifr) == 0)
mtu = ifdata.ifi_mtu;
#else
if (ioctl(s, SIOCGIFMTU, (caddr_t)&ifr) == 0)
mtu = ifr.ifr_mtu;
#endif
close(s);
return (mtu);
}
static void
tbr_install(const char *ifname)
{
struct tbrinfo *info;
struct tbrreq req;
int fd;
LIST_FOREACH(info, &tbr_list, link)
if (strcmp(info->ifname, ifname) == 0)
break;
if (info == NULL)
return;
if (info->tb_prof.rate == 0 || info->installed)
return;
/* get the current token bucket regulator */
if ((fd = open(ALTQ_DEVICE, O_RDWR)) < 0)
err(1, "can't open altq device");
strncpy(req.ifname, ifname, IFNAMSIZ-1);
if (ioctl(fd, ALTQTBRGET, &req) < 0)
err(1, "ALTQTBRGET for interface %s", req.ifname);
/* save the current values */
info->otb_prof.rate = req.tb_prof.rate;
info->otb_prof.depth = req.tb_prof.depth;
/*
* if tbr is not specified in the config file and tbr is already
* configured, do not change.
*/
if (req.tb_prof.rate != 0) {
LOG(LOG_INFO, 0,
"tbr is already installed on %s,\n"
" using the current setting (rate:%.2fM size:%.2fK).\n",
info->ifname,
(double)req.tb_prof.rate/1000000.0,
(double)req.tb_prof.depth/1024.0);
close (fd);
return;
}
/* if the new size is not specified, use heuristics */
if (info->tb_prof.depth == 0) {
u_int rate, size;
rate = info->tb_prof.rate;
if (rate <= 1*1000*1000)
size = 1;
else if (rate <= 10*1000*1000)
size = 4;
else if (rate <= 200*1000*1000)
size = 8;
else
size = 24;
size = size * 1500; /* assume the default mtu is 1500 */
info->tb_prof.depth = size;
}
/* install the new tbr */
strncpy(req.ifname, ifname, IFNAMSIZ-1);
req.tb_prof.rate = info->tb_prof.rate;
req.tb_prof.depth = info->tb_prof.depth;
if (ioctl(fd, ALTQTBRSET, &req) < 0)
err(1, "ALTQTBRSET for interface %s", req.ifname);
LOG(LOG_INFO, 0,
"tbr installed on %s (rate:%.2fM size:%.2fK)\n",
info->ifname,
(double)info->tb_prof.rate/1000000.0,
(double)info->tb_prof.depth/1024.0);
close(fd);
info->installed = 1;
}
static void
tbr_deinstall(const char *ifname)
{
struct tbrinfo *info;
struct tbrreq req;
int fd;
LIST_FOREACH(info, &tbr_list, link)
if (strcmp(info->ifname, ifname) == 0)
break;
if (info == NULL)
return;
/* if we installed tbr, restore the old values */
if (info->installed != 0) {
strncpy(req.ifname, ifname, IFNAMSIZ-1);
req.tb_prof.rate = info->otb_prof.rate;
req.tb_prof.depth = info->otb_prof.depth;
if ((fd = open(ALTQ_DEVICE, O_RDWR)) < 0)
err(1, "can't open altq device");
if (ioctl(fd, ALTQTBRSET, &req) < 0)
err(1, "ALTQTBRSET for interface %s", req.ifname);
close(fd);
}
LIST_REMOVE(info, link);
free(info);
}
void
print_filter(const struct flow_filter *filt)
{
if (filt->ff_flow.fi_family == AF_INET) {
struct in_addr in_addr;
in_addr.s_addr = filt->ff_flow.fi_dst.s_addr;
LOG(LOG_DEBUG, 0,
" Filter Dest Addr: %s (mask %#x) Port: %d\n",
inet_ntoa(in_addr), ntoh32(filt->ff_mask.mask_dst.s_addr),
ntoh16(filt->ff_flow.fi_dport));
in_addr.s_addr = filt->ff_flow.fi_src.s_addr;
LOG(LOG_DEBUG, 0,
" Src Addr: %s (mask %#x) Port: %d\n",
inet_ntoa(in_addr), ntoh32(filt->ff_mask.mask_src.s_addr),
ntoh16(filt->ff_flow.fi_sport));
LOG(LOG_DEBUG, 0, " Protocol: %d TOS %#x (mask %#x)\n",
filt->ff_flow.fi_proto, filt->ff_flow.fi_tos,
filt->ff_mask.mask_tos);
}
#ifdef INET6
else if (filt->ff_flow.fi_family == AF_INET6) {
char str1[INET6_ADDRSTRLEN], str2[INET6_ADDRSTRLEN];
const struct flow_filter6 *sfilt6;
sfilt6 = (const struct flow_filter6 *)filt;
LOG(LOG_DEBUG, 0, "Filter6 Dest Addr: %s (mask %s) Port: %d",
inet_ntop(AF_INET6, &sfilt6->ff_flow6.fi6_dst,
str1, sizeof(str1)),
inet_ntop(AF_INET6, &sfilt6->ff_mask6.mask6_dst,
str2, sizeof(str2)),
ntoh16(sfilt6->ff_flow6.fi6_dport));
LOG(LOG_DEBUG, 0, " Src Addr: %s (mask %s) Port: %d",
inet_ntop(AF_INET6, &sfilt6->ff_flow6.fi6_src,
str1, sizeof(str1)),
inet_ntop(AF_INET6, &sfilt6->ff_mask6.mask6_src,
str2, sizeof(str2)),
ntoh16(sfilt6->ff_flow6.fi6_sport));
LOG(LOG_DEBUG, 0, " Protocol: %d TCLASS %#x (mask %#x)\n",
sfilt6->ff_flow6.fi6_proto, sfilt6->ff_flow6.fi6_tclass,
sfilt6->ff_mask6.mask6_tclass);
}
#endif /* INET6 */
}
/*
* functions to check the filter-rules.
* when a new filter is added, we check the relation to the existing filters
* and if some inconsistency is found, produce an error or a warning message.
*
* filter matching is performed from the head of the list.
* let
* S: a set of packets that filter s matches
* T: a set of packets that filter t matches
* filter relations are:
* disjoint: S ^ T = empty
* subset: S <= T
* intersect: S ^ T = not empty
*
* a new filter is disjoint or subset of the existing filters --> ok
* a new filter is superset of an existing filter --> order problem
* a new filter intersect an existing filter --> warning
*
* port-intersect: a special case we don't make warning
* - intersection is only port numbers
* - one specifies src port and the other specifies dst port
* there must be no packet with well-known port numbers in
* both src and dst ports. so this is ok.
*/
#define FILT_DISJOINT 1
#define FILT_SUBSET 2
#define FILT_SUPERSET 3
#define FILT_INTERSECT 4
#define FILT_PORTINTERSECT 5
static int
add_filter_rule(struct ifinfo *ifinfo, struct fltrinfo *fltrinfo,
struct fltrinfo **conflict)
{
struct fltrinfo *fp, *front, *back, *prev = NULL;
int relation;
LIST_FOREACH(fp, &ifinfo->fltr_rules, nextrule) {
if (fp->fltr.ff_ruleno > fltrinfo->fltr.ff_ruleno) {
front = fp;
back = fltrinfo;
prev = fp;
} else {
front = fltrinfo;
back = fp;
}
relation = filt_check_relation(&front->fltr, &back->fltr);
switch (relation) {
case FILT_SUBSET:
case FILT_DISJOINT:
/* OK */
break;
case FILT_SUPERSET:
if (front->dontwarn == 0 && back->dontwarn == 0)
LOG(LOG_ERR, 0,
"filters for \"%s\" at line %d and for \"%s\" at line %d has an order problem!\n",
front->clinfo->clname, front->line_no,
back->clinfo->clname, back->line_no);
if (conflict != NULL)
*conflict = fp;
return (QOPERR_FILTER_SHADOW);
case FILT_PORTINTERSECT:
break;
case FILT_INTERSECT:
/*
* if the intersecting two filters beloging to the
* same class, it's ok.
*/
if (front->clinfo == back->clinfo)
break;
if (front->dontwarn == 0 && back->dontwarn == 0)
LOG(LOG_WARNING, 0,
"warning: filter for \"%s\" at line %d could override filter for \"%s\" at line %d\n",
front->clinfo->clname, front->line_no,
back->clinfo->clname, back->line_no);
break;
}
}
if (prev == NULL)
LIST_INSERT_HEAD(&ifinfo->fltr_rules, fltrinfo, nextrule);
else
LIST_INSERT_AFTER(prev, fltrinfo, nextrule);
return (0);
}
static int
remove_filter_rule(struct ifinfo *ifinfo, struct fltrinfo *fltrinfo)
{
LIST_REMOVE(fltrinfo, nextrule);
return (0);
}
static int
filt_check_relation(struct flow_filter *front, struct flow_filter *back)
{
int rval;
if (front->ff_flow.fi_family != back->ff_flow.fi_family)
return (FILT_DISJOINT);
if (filt_disjoint(front, back))
return (FILT_DISJOINT);
if ((rval = filt_subset(front, back)) == 1)
return (FILT_SUBSET);
if (filt_subset(back, front) == 1)
return (FILT_SUPERSET);
if (rval == 2)
return (FILT_PORTINTERSECT);
return (FILT_INTERSECT);
}
static int
filt_disjoint(struct flow_filter *front, struct flow_filter *back)
{
u_int32_t mask;
u_int8_t tosmask;
if (front->ff_flow.fi_family == AF_INET) {
if (front->ff_flow.fi_proto != 0 && back->ff_flow.fi_proto != 0
&& front->ff_flow.fi_proto != back->ff_flow.fi_proto)
return (1);
if (front->ff_flow.fi_sport != 0 && back->ff_flow.fi_sport != 0
&& front->ff_flow.fi_sport != back->ff_flow.fi_sport)
return (1);
if (front->ff_flow.fi_dport != 0 && back->ff_flow.fi_dport != 0
&& front->ff_flow.fi_dport != back->ff_flow.fi_dport)
return (1);
if (front->ff_flow.fi_gpi != 0 && back->ff_flow.fi_gpi != 0
&& front->ff_flow.fi_gpi != back->ff_flow.fi_gpi)
return (1);
if (front->ff_flow.fi_src.s_addr != 0 &&
back->ff_flow.fi_src.s_addr != 0) {
mask = front->ff_mask.mask_src.s_addr &
back->ff_mask.mask_src.s_addr;
if ((front->ff_flow.fi_src.s_addr & mask) !=
(back->ff_flow.fi_src.s_addr & mask))
return (1);
}
if (front->ff_flow.fi_dst.s_addr != 0 &&
back->ff_flow.fi_dst.s_addr != 0) {
mask = front->ff_mask.mask_dst.s_addr &
back->ff_mask.mask_dst.s_addr;
if ((front->ff_flow.fi_dst.s_addr & mask) !=
(back->ff_flow.fi_dst.s_addr & mask))
return (1);
}
if (front->ff_flow.fi_tos != 0 && back->ff_flow.fi_tos != 0) {
tosmask = front->ff_mask.mask_tos &
back->ff_mask.mask_tos;
if ((front->ff_flow.fi_tos & tosmask) !=
(back->ff_flow.fi_tos & tosmask))
return (1);
}
return (0);
}
#ifdef INET6
else if (front->ff_flow.fi_family == AF_INET6) {
struct flow_filter6 *front6, *back6;
int i;
front6 = (struct flow_filter6 *)front;
back6 = (struct flow_filter6 *)back;
if (front6->ff_flow6.fi6_proto != 0 &&
back6->ff_flow6.fi6_proto != 0 &&
front6->ff_flow6.fi6_proto != back6->ff_flow6.fi6_proto)
return (1);
if (front6->ff_flow6.fi6_flowlabel != 0 &&
back6->ff_flow6.fi6_flowlabel != 0 &&
front6->ff_flow6.fi6_flowlabel !=
back6->ff_flow6.fi6_flowlabel)
return (1);
if (front6->ff_flow6.fi6_sport != 0 &&
back6->ff_flow6.fi6_sport != 0 &&
front6->ff_flow6.fi6_sport != back6->ff_flow6.fi6_sport)
return (1);
if (front6->ff_flow6.fi6_dport != 0 &&
back6->ff_flow6.fi6_dport != 0 &&
front6->ff_flow6.fi6_dport != back6->ff_flow6.fi6_dport)
return (1);
if (front6->ff_flow6.fi6_gpi != 0 &&
back6->ff_flow6.fi6_gpi != 0 &&
front6->ff_flow6.fi6_gpi != back6->ff_flow6.fi6_gpi)
return (1);
if (!IN6_IS_ADDR_UNSPECIFIED(&front6->ff_flow6.fi6_src) &&
!IN6_IS_ADDR_UNSPECIFIED(&back6->ff_flow6.fi6_src)) {
for (i=0; i<4; i++) {
mask = IN6ADDR32(&front6->ff_mask6.mask6_src, i)
& IN6ADDR32(&back6->ff_mask6.mask6_src, i);
if ((IN6ADDR32(&front6->ff_flow6.fi6_src, i) & mask) !=
(IN6ADDR32(&back6->ff_flow6.fi6_src, i) & mask))
return (1);
}
}
if (!IN6_IS_ADDR_UNSPECIFIED(&front6->ff_flow6.fi6_dst) &&
!IN6_IS_ADDR_UNSPECIFIED(&back6->ff_flow6.fi6_dst)) {
for (i=0; i<4; i++) {
mask = IN6ADDR32(&front6->ff_mask6.mask6_dst, i)
& IN6ADDR32(&back6->ff_mask6.mask6_dst, i);
if ((IN6ADDR32(&front6->ff_flow6.fi6_dst, i) & mask) !=
(IN6ADDR32(&back6->ff_flow6.fi6_dst, i) & mask))
return (1);
}
}
if (front6->ff_flow6.fi6_tclass != 0 &&
back6->ff_flow6.fi6_tclass != 0) {
tosmask = front6->ff_mask6.mask6_tclass &
back6->ff_mask6.mask6_tclass;
if ((front6->ff_flow6.fi6_tclass & tosmask) !=
(back6->ff_flow6.fi6_tclass & tosmask))
return (1);
}
return (0);
}
#endif /* INET6 */
return (0);
}
/*
* check if "front" is a subset of "back". assumes they are not disjoint
* return value 0: not a subset
* 1: subset
* 2: subset except src & dst ports
* (possible port-intersect)
*/
static int
filt_subset(struct flow_filter *front, struct flow_filter *back)
{
u_int16_t srcport, dstport;
if (front->ff_flow.fi_family == AF_INET) {
if (front->ff_flow.fi_proto == 0 &&
back->ff_flow.fi_proto != 0)
return (0);
if (front->ff_flow.fi_gpi == 0 && back->ff_flow.fi_gpi != 0)
return (0);
if (front->ff_flow.fi_src.s_addr == 0) {
if (back->ff_flow.fi_src.s_addr != 0)
return (0);
} else if (back->ff_flow.fi_src.s_addr != 0 &&
(~front->ff_mask.mask_src.s_addr &
back->ff_mask.mask_src.s_addr))
return (0);
if (front->ff_flow.fi_dst.s_addr == 0) {
if (back->ff_flow.fi_dst.s_addr != 0)
return (0);
} else if (back->ff_flow.fi_dst.s_addr != 0 &&
(~front->ff_mask.mask_dst.s_addr &
back->ff_mask.mask_dst.s_addr))
return (0);
if (~front->ff_mask.mask_tos & back->ff_mask.mask_tos)
return (0);
if (front->ff_flow.fi_sport == 0 &&
back->ff_flow.fi_sport != 0) {
srcport = ntohs(back->ff_flow.fi_sport);
dstport = ntohs(front->ff_flow.fi_dport);
if (dstport > 0 /* && dstport < 1024 */ &&
srcport > 0 /* && srcport < 1024 */)
return (2);
return (0);
}
if (front->ff_flow.fi_dport == 0 &&
back->ff_flow.fi_dport != 0) {
dstport = ntohs(back->ff_flow.fi_dport);
srcport = ntohs(front->ff_flow.fi_sport);
if (srcport > 0 /* && srcport < 1024 */ &&
dstport > 0 /* && dstport < 1024 */)
return (2);
return (0);
}
return (1);
}
#ifdef INET6
else if (front->ff_flow.fi_family == AF_INET6) {
struct flow_filter6 *front6, *back6;
int i;
front6 = (struct flow_filter6 *)front;
back6 = (struct flow_filter6 *)back;
if (front6->ff_flow6.fi6_proto == 0 &&
back6->ff_flow6.fi6_proto != 0)
return (0);
if (front6->ff_flow6.fi6_flowlabel == 0 &&
back6->ff_flow6.fi6_flowlabel != 0)
return (0);
if (front6->ff_flow6.fi6_gpi == 0 &&
back6->ff_flow6.fi6_gpi != 0)
return (0);
if (IN6_IS_ADDR_UNSPECIFIED(&front6->ff_flow6.fi6_src)) {
if (!IN6_IS_ADDR_UNSPECIFIED(&back6->ff_flow6.fi6_src))
return (0);
} else if (!IN6_IS_ADDR_UNSPECIFIED(&back6->ff_flow6.fi6_src))
for (i=0; i<4; i++)
if (~IN6ADDR32(&front6->ff_mask6.mask6_src, i) &
IN6ADDR32(&back6->ff_mask6.mask6_src, i))
return (0);
if (IN6_IS_ADDR_UNSPECIFIED(&front6->ff_flow6.fi6_dst)) {
if (!IN6_IS_ADDR_UNSPECIFIED(&back6->ff_flow6.fi6_dst))
return (0);
} else if (!IN6_IS_ADDR_UNSPECIFIED(&back6->ff_flow6.fi6_dst))
for (i=0; i<4; i++)
if (~IN6ADDR32(&front6->ff_mask6.mask6_dst, i) &
IN6ADDR32(&back6->ff_mask6.mask6_dst, i))
return (0);
if (~front6->ff_mask6.mask6_tclass &
back6->ff_mask6.mask6_tclass)
return (0);
if (front6->ff_flow6.fi6_sport == 0 &&
back6->ff_flow6.fi6_sport != 0) {
srcport = ntohs(back6->ff_flow6.fi6_sport);
dstport = ntohs(front6->ff_flow6.fi6_dport);
if (dstport > 0 /* && dstport < 1024 */ &&
srcport > 0 /* && srcport < 1024 */)
return (2);
return (0);
}
if (front6->ff_flow6.fi6_dport == 0 &&
back6->ff_flow6.fi6_dport != 0) {
dstport = ntohs(back6->ff_flow6.fi6_dport);
srcport = ntohs(front6->ff_flow6.fi6_sport);
if (srcport > 0 /* && srcport < 1024 */ &&
dstport > 0 /* && dstport < 1024 */)
return (2);
return (0);
}
}
#endif /* INET6 */
return (1);
}
/*
* setting RED or RIO default parameters
*/
int
qop_red_set_defaults(int th_min, int th_max, int inv_pmax)
{
struct redparams params;
int fd;
if ((fd = open(RED_DEVICE, O_RDWR)) < 0) {
LOG(LOG_ERR, errno, "RED open\n");
return (QOPERR_SYSCALL);
}
params.th_min = th_min;
params.th_max = th_max;
params.inv_pmax = inv_pmax;
if (ioctl(fd, RED_SETDEFAULTS, &params) < 0) {
LOG(LOG_ERR, errno, "RED_SETDEFAULTS\n");
return (QOPERR_SYSCALL);
}
(void)close(fd);
return (0);
}
int
qop_rio_set_defaults(struct redparams *params)
{
int i, fd;
/* sanity check */
for (i = 1; i < RIO_NDROPPREC; i++) {
if (params[i].th_max > params[i-1].th_min)
LOG(LOG_WARNING, 0,
"warning: overlap found in RIO thresholds\n");
}
if ((fd = open(RIO_DEVICE, O_RDWR)) < 0) {
LOG(LOG_ERR, errno, "RIO open\n");
return (QOPERR_SYSCALL);
}
if (ioctl(fd, RIO_SETDEFAULTS, params) < 0) {
LOG(LOG_ERR, errno, "RIO_SETDEFAULTS\n");
return (QOPERR_SYSCALL);
}
(void)close(fd);
return (0);
}
/*
* try to load and open KLD module
*/
int
open_module(const char *devname, int flags)
{
#if defined(__FreeBSD__) && (__FreeBSD_version > 300000)
char modname[64], filename[256], *cp;
int fd;
struct stat sbuf;
/* turn discipline name into module name */
strcpy(modname, "altq_");
if ((cp = strrchr(devname, '/')) == NULL)
return (-1);
strcat(modname, cp+1);
/* check if the kld module exists */
sprintf(filename, "/modules/%s.ko", modname);
if (stat(filename, &sbuf) < 0) {
/* module file doesn't exist */
return (-1);
}
if (kldload(modname) < 0) {
LOG(LOG_ERR, errno, "kldload %s failed!\n", modname);
return (-1);
}
/* successfully loaded, open the device */
LOG(LOG_INFO, 0, "kld module %s loaded\n", modname);
fd = open(devname, flags);
return (fd);
#else
return (-1);
#endif
}
Reference in New Issue View Git Blame Copy Permalink