NetBSD/usr.sbin/altq/libaltq/qop_cdnr.c

/*	$NetBSD: qop_cdnr.c,v 1.4 2001/08/22 08:52:37 itojun Exp $	*/
/*	$KAME: qop_cdnr.c,v 1.9 2001/08/16 10:39:14 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 <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 <syslog.h>
#include <netdb.h>

#include <altq/altq.h>
#include <altq/altq_cdnr.h>
#include "altq_qop.h"
#include "qop_cdnr.h"
/*
 * diffserve traffic conditioner support
 *
 * we use the existing qop interface to support conditioner.
 */

static struct ifinfo *cdnr_ifname2ifinfo(const char *);
static int cdnr_attach(struct ifinfo *);
static int cdnr_detach(struct ifinfo *);
static int cdnr_enable(struct ifinfo *);
static int cdnr_disable(struct ifinfo *);
static int cdnr_add_class(struct classinfo *);
static int cdnr_modify_class(struct classinfo *, void *);
static int cdnr_delete_class(struct classinfo *);
static int cdnr_add_filter(struct fltrinfo *);
static int cdnr_delete_filter(struct fltrinfo *);
static int verify_tbprofile(struct tb_profile *, const char *);

#define CDNR_DEVICE	"/dev/altq/cdnr"

static int cdnr_fd = -1;
static int cdnr_refcount = 0;

static struct qdisc_ops cdnr_qdisc = {
	ALTQT_CDNR,
	"cdnr",
	cdnr_attach,
	cdnr_detach,
	NULL,			/* clear */
	cdnr_enable,
	cdnr_disable,
	cdnr_add_class,
	cdnr_modify_class,
	cdnr_delete_class,
	cdnr_add_filter,
	cdnr_delete_filter,
};

u_long
cdnr_name2handle(const char *ifname, const char *cdnr_name)
{
	struct ifinfo		*ifinfo;
	struct classinfo	*clinfo;

	if ((ifinfo = cdnr_ifname2ifinfo(ifname)) == NULL)
		return (CDNR_NULL_HANDLE);

	if ((clinfo = clname2clinfo(ifinfo, cdnr_name)) == NULL)
		return (CDNR_NULL_HANDLE);

	return (clinfo->handle);
}

static struct ifinfo *
cdnr_ifname2ifinfo(const char *ifname)
{
	struct ifinfo	*ifinfo;
	char input_ifname[64];

	/*
	 * search for an existing input interface
	 */
	if ((ifinfo = input_ifname2ifinfo(ifname)) != NULL)
		return (ifinfo);

	/*
	 * if there is a corresponding output interface,
	 * create an input interface by prepending "_" to
	 * its name.
	 */
	if ((ifinfo = ifname2ifinfo(ifname)) == NULL)
		return (NULL);

	input_ifname[0] = '_';
	strlcpy(input_ifname+1, ifname, sizeof(input_ifname)-1);
	if (qop_add_if(&ifinfo, input_ifname, 0, &cdnr_qdisc, NULL) != 0) {
		LOG(LOG_ERR, errno,
		    "cdnr_ifname2ifinfo: can't add a input interface %s",
		    ifname);
		return (NULL);
	}
	return (ifinfo);
}

int
qcmd_cdnr_add_element(struct tc_action *rp, const char *ifname,
		   const char *cdnr_name, struct tc_action *action)
{
	struct ifinfo		*ifinfo;
	struct classinfo	*clinfo;
	int error;

	if ((ifinfo = cdnr_ifname2ifinfo(ifname)) == NULL)
		return (QOPERR_BADIF);

	if ((error = qop_cdnr_add_element(&clinfo, cdnr_name, ifinfo,
					  action)) != 0) {
		LOG(LOG_ERR, errno, "%s: add element failed!",
		    qoperror(error));
		return (error);
	}

	if (rp != NULL) {
		rp->tca_code = TCACODE_HANDLE;
		rp->tca_handle = clinfo->handle;
	}
	return (0);
}

int
qcmd_cdnr_add_tbmeter(struct tc_action *rp, const char *ifname,
		      const char *cdnr_name, 
		      struct tb_profile *profile,
		      struct tc_action *in_action,
		      struct tc_action *out_action)
{
	struct ifinfo		*ifinfo;
	struct classinfo	*clinfo;
	int error;

	if ((ifinfo = cdnr_ifname2ifinfo(ifname)) == NULL)
		return (QOPERR_BADIF);

	verify_tbprofile(profile, cdnr_name);

	if ((error = qop_cdnr_add_tbmeter(&clinfo, cdnr_name, ifinfo,
				  profile, in_action, out_action)) != 0) {
		LOG(LOG_ERR, errno, "%s: add tbmeter failed!",
		    qoperror(error));
		return (error);
	}
	
	if (rp != NULL) {
		rp->tca_code = TCACODE_HANDLE;
		rp->tca_handle = clinfo->handle;
	}
	return (0);
}

int
qcmd_cdnr_add_trtcm(struct tc_action *rp, const char *ifname,
		    const char *cdnr_name, 
		    struct tb_profile *cmtd_profile,
		    struct tb_profile *peak_profile,
		    struct tc_action *green_action,
		    struct tc_action *yellow_action,
		    struct tc_action *red_action, int coloraware)
{
	struct ifinfo		*ifinfo;
	struct classinfo	*clinfo;
	int error;

	if ((ifinfo = cdnr_ifname2ifinfo(ifname)) == NULL)
		return (QOPERR_BADIF);

	verify_tbprofile(cmtd_profile, cdnr_name);
	verify_tbprofile(peak_profile, cdnr_name);

	if ((error = qop_cdnr_add_trtcm(&clinfo, cdnr_name, ifinfo,
			  cmtd_profile, peak_profile,
			  green_action, yellow_action, red_action,
	     		  coloraware)) != 0) {
		LOG(LOG_ERR, errno, "%s: add trtcm failed!",
		    qoperror(error));
		return (error);
	}
	
	if (rp != NULL) {
		rp->tca_code = TCACODE_HANDLE;
		rp->tca_handle = clinfo->handle;
	}
	return (0);
}

int
qcmd_cdnr_add_tswtcm(struct tc_action *rp, const char *ifname,
		     const char *cdnr_name, const u_int32_t cmtd_rate,
		     const u_int32_t peak_rate, const u_int32_t avg_interval,
		     struct tc_action *green_action,
		     struct tc_action *yellow_action,
		     struct tc_action *red_action)
{
	struct ifinfo		*ifinfo;
	struct classinfo	*clinfo;
	int error;

	if ((ifinfo = cdnr_ifname2ifinfo(ifname)) == NULL)
		return (QOPERR_BADIF);

	if (cmtd_rate > peak_rate) {
		LOG(LOG_ERR, 0,
		    "add tswtcm: cmtd_rate larger than peak_rate!");
		return (QOPERR_INVAL);
	}

	if ((error = qop_cdnr_add_tswtcm(&clinfo, cdnr_name, ifinfo,
					cmtd_rate, peak_rate, avg_interval,
					green_action, yellow_action,
					red_action)) != 0) {
		LOG(LOG_ERR, errno, "%s: add tswtcm failed!",
		    qoperror(error));
		return (error);
	}
	
	if (rp != NULL) {
		rp->tca_code = TCACODE_HANDLE;
		rp->tca_handle = clinfo->handle;
	}
	return (0);
}

int
qcmd_cdnr_delete(const char *ifname, const char *cdnr_name)
{
	struct ifinfo		*ifinfo;
	struct classinfo	*clinfo;

	if ((ifinfo = cdnr_ifname2ifinfo(ifname)) == NULL)
		return (QOPERR_BADIF);

	if ((clinfo = clname2clinfo(ifinfo, cdnr_name)) == NULL)
		return (QOPERR_BADCLASS);

	return qop_delete_cdnr(clinfo);
}

/*
 * class operations:
 *	class structure is used to hold conditioners.
 *	XXX
 *	conditioners has dependencies in the reverse order; parent nodes
 *	refere to child nodes, and thus, a child is created first and
 *	parents should be removed first.
 *	qop_add_cdnr() and qop_delete_cdnr() are wrapper functions
 *	of qop_add_class() and qop_delete_class(), and takes care
 *	of dependencies.
 *	1. when adding a conditioner, it is created as a child of a
 *	   dummy root class.  then, the child conditioners are made
 *	   as its children.
 *	2. when deleting a conditioner, its child conditioners are made
 *	   as children of the dummy root class.  then, the conditioner
 *	   is deleted.
 */

int
qop_add_cdnr(struct classinfo **rp, const char *cdnr_name,
	     struct ifinfo *ifinfo, struct classinfo **childlist,
	     void *cdnr_private)
{
	struct classinfo	*clinfo, *root, *cl, *prev;
	int error;

	/*
	 * if there is no root cdnr, create one.
	 */
	if ((root = get_rootclass(ifinfo)) == NULL) {
		if ((error = qop_add_class(&root, "cdnr_root",
					   ifinfo, NULL, NULL)) != 0) {
			LOG(LOG_ERR, errno,
			    "cdnr: %s: can't create dummy root cdnr on %s!",
			    qoperror(error), ifinfo->ifname);
			return (QOPERR_CLASS);
		}
	}

	/*
	 * create a class as a child of a root class.
	 */
	if ((error = qop_add_class(&clinfo, cdnr_name,
				   ifinfo, root, cdnr_private)) != 0)
		return (error);
	/*
	 * move child nodes
	 */
	for (cl = *childlist; cl != NULL; cl = *++childlist) {
		if (cl->parent != root) {
			/*
			 * this conditioner already has a non-root parent.
			 * we can't track down a multi-parent node by a
			 * tree structure; leave it as it is.
			 * (we need a mechanism similar to a symbolic link
			 * in a file system)
			 */
			continue;
		}
		/* remove this child from the root */
		if (root->child == cl)
			root->child = cl->sibling;
		else for (prev = root->child;
			  prev->sibling != NULL; prev = prev->sibling)
			if (prev->sibling == cl) {
				prev->sibling = cl->sibling;
				break;
			}

		/* add as a child */
		cl->sibling = clinfo->child;
		clinfo->child = cl;
		cl->parent = clinfo;
	}
		
	if (rp != NULL)
		*rp = clinfo;
	return (0);
}

int
qop_delete_cdnr(struct classinfo *clinfo)
{
	struct classinfo *cl, *root;
	int error;

	if ((root = get_rootclass(clinfo->ifinfo)) == NULL) {
		LOG(LOG_ERR, 0, "qop_delete_cdnr: no root cdnr!");
		return (QOPERR_CLASS);
	}

	if (clinfo->parent != root)
		return (QOPERR_CLASS_PERM);

	if ((cl = clinfo->child) != NULL) {
		/* change child's parent to root, find the last child */
		while (cl->sibling != NULL) {
			cl->parent = root;
			cl = cl->sibling;
		}
		cl->parent = root;

		/* move children to siblings */
		cl->sibling = clinfo->sibling;
		clinfo->sibling = cl;
		clinfo->child = NULL;
	}

	error = qop_delete_class(clinfo);

	if (error) {
		/* ick! restore the class tree */
		if (cl != NULL) {
			clinfo->child = clinfo->sibling;
			clinfo->sibling = cl->sibling;
			cl->sibling = NULL;
			/* restore parent field */
			for (cl = clinfo->child; cl != NULL; cl = cl->sibling)
				cl->parent = clinfo;
		}
	}
	return (error);
}

int 
qop_cdnr_add_element(struct classinfo **rp, const char *cdnr_name,
		     struct ifinfo *ifinfo, struct tc_action *action)
{
	struct classinfo *clinfo, *clist[2];
	struct cdnrinfo *cdnrinfo = NULL;
	int error;

	if (action->tca_code == TCACODE_HANDLE) {
		clinfo = clhandle2clinfo(ifinfo, action->tca_handle);
		if (clinfo == NULL)
			return (QOPERR_BADCLASS);
		clist[0] = clinfo;
		clist[1] = NULL;
#if 1
		/*
		 * if the conditioner referred to doesn't have a name,
		 * this is called just to add a name to it.
		 * we can simply add the name to the existing conditioner
		 * and return it.
		 */
		if (cdnr_name != NULL &&
		    strcmp(clinfo->clname, "(null)") == 0) {
			free(clinfo->clname);
			clinfo->clname = strdup(cdnr_name);
			if (rp != NULL)
				*rp = clinfo;
			return (0);
		}
#endif
	} else
		clist[0] = NULL;

	if ((cdnrinfo = calloc(1, sizeof(*cdnrinfo))) == NULL)
		return (QOPERR_NOMEM);

	cdnrinfo->tce_type = TCETYPE_ELEMENT;
	cdnrinfo->tce_un.element.action = *action;

	if ((error = qop_add_cdnr(&clinfo, cdnr_name, ifinfo, clist,
				  cdnrinfo)) != 0)
		goto err_ret;

	if (rp != NULL)
		*rp = clinfo;
	return (0);

 err_ret:
	if (cdnrinfo != NULL)
		free(cdnrinfo);
	return (error);
}

int 
qop_cdnr_add_tbmeter(struct classinfo **rp, const char *cdnr_name,
		     struct ifinfo *ifinfo,
		     struct tb_profile *profile,
		     struct tc_action *in_action,
		     struct tc_action *out_action)
{
	struct classinfo *clinfo, *clist[3];
	struct cdnrinfo *cdnrinfo = NULL;
	int n, error;

	n = 0;
	if (in_action->tca_code == TCACODE_HANDLE) {
		clist[n] = clhandle2clinfo(ifinfo, in_action->tca_handle);
		if (clist[n] == NULL)
			return (QOPERR_BADCLASS);
		n++;
	}
	if (out_action->tca_code == TCACODE_HANDLE) {
		clist[n] = clhandle2clinfo(ifinfo, out_action->tca_handle);
		if (clist[n] == NULL)
			return (QOPERR_BADCLASS);
		n++;
	}
	clist[n] = NULL;

	if ((cdnrinfo = calloc(1, sizeof(*cdnrinfo))) == NULL)
		return (QOPERR_NOMEM);

	cdnrinfo->tce_type = TCETYPE_TBMETER;
	cdnrinfo->tce_un.tbmeter.profile = *profile;
	cdnrinfo->tce_un.tbmeter.in_action = *in_action;
	cdnrinfo->tce_un.tbmeter.out_action = *out_action;

	if ((error = qop_add_cdnr(&clinfo, cdnr_name, ifinfo, clist,
				   cdnrinfo)) != 0)
		goto err_ret;

	if (rp != NULL)
		*rp = clinfo;
	return (0);

 err_ret:
	if (cdnrinfo != NULL)
		free(cdnrinfo);
	return (error);
}

int 
qop_cdnr_modify_tbmeter(struct classinfo *clinfo, struct tb_profile *profile)
{
	struct cdnrinfo *cdnrinfo = clinfo->private;

	if (cdnrinfo->tce_type != TCETYPE_TBMETER)
		return (QOPERR_CLASS_INVAL);
	cdnrinfo->tce_un.tbmeter.profile = *profile;

	return qop_modify_class(clinfo, NULL);
}

int 
qop_cdnr_add_trtcm(struct classinfo **rp, const char *cdnr_name,
		   struct ifinfo *ifinfo,
		   struct tb_profile *cmtd_profile,
		   struct tb_profile *peak_profile,
		   struct tc_action *green_action,
		   struct tc_action *yellow_action,
		   struct tc_action *red_action, int coloraware)
{
	struct classinfo *clinfo, *clist[4];
	struct cdnrinfo *cdnrinfo = NULL;
	int n, error;

	n = 0;
	if (green_action->tca_code == TCACODE_HANDLE) {
		clist[n] = clhandle2clinfo(ifinfo, green_action->tca_handle);
		if (clist[n] == NULL)
			return (QOPERR_BADCLASS);
		n++;
	}
	if (yellow_action->tca_code == TCACODE_HANDLE) {
		clist[n] = clhandle2clinfo(ifinfo, yellow_action->tca_handle);
		if (clist[n] == NULL)
			return (QOPERR_BADCLASS);
		n++;
	}
	if (red_action->tca_code == TCACODE_HANDLE) {
		clist[n] = clhandle2clinfo(ifinfo, yellow_action->tca_handle);
		if (clist[n] == NULL)
			return (QOPERR_BADCLASS);
		n++;
	}
	clist[n] = NULL;

	if ((cdnrinfo = calloc(1, sizeof(*cdnrinfo))) == NULL)
		return (QOPERR_NOMEM);

	cdnrinfo->tce_type = TCETYPE_TRTCM;
	cdnrinfo->tce_un.trtcm.cmtd_profile = *cmtd_profile;
	cdnrinfo->tce_un.trtcm.peak_profile = *peak_profile;
	cdnrinfo->tce_un.trtcm.green_action = *green_action;
	cdnrinfo->tce_un.trtcm.yellow_action = *yellow_action;
	cdnrinfo->tce_un.trtcm.red_action = *red_action;
	cdnrinfo->tce_un.trtcm.coloraware = coloraware;

	if ((error = qop_add_cdnr(&clinfo, cdnr_name, ifinfo, clist,
				  cdnrinfo)) != 0)
		goto err_ret;

	if (rp != NULL)
		*rp = clinfo;
	return (0);

 err_ret:
	if (cdnrinfo != NULL)
		free(cdnrinfo);
	return (error);
}

int 
qop_cdnr_modify_trtcm(struct classinfo *clinfo,
		      struct tb_profile *cmtd_profile,
		      struct tb_profile *peak_profile, int coloraware)
{
	struct cdnrinfo *cdnrinfo = clinfo->private;

	if (cdnrinfo->tce_type != TCETYPE_TRTCM)
		return (QOPERR_CLASS_INVAL);
	cdnrinfo->tce_un.trtcm.cmtd_profile = *cmtd_profile;
	cdnrinfo->tce_un.trtcm.peak_profile = *peak_profile;
	cdnrinfo->tce_un.trtcm.coloraware = coloraware;

	return qop_modify_class(clinfo, NULL);
}

int 
qop_cdnr_add_tswtcm(struct classinfo **rp, const char *cdnr_name,
		    struct ifinfo *ifinfo, const u_int32_t cmtd_rate,
		    const u_int32_t peak_rate, const u_int32_t avg_interval,
		    struct tc_action *green_action,
		    struct tc_action *yellow_action,
		    struct tc_action *red_action)
{
	struct classinfo *clinfo, *clist[4];
	struct cdnrinfo *cdnrinfo = NULL;
	int n, error;

	n = 0;
	if (green_action->tca_code == TCACODE_HANDLE) {
		clist[n] = clhandle2clinfo(ifinfo, green_action->tca_handle);
		if (clist[n] == NULL)
			return (QOPERR_BADCLASS);
		n++;
	}
	if (yellow_action->tca_code == TCACODE_HANDLE) {
		clist[n] = clhandle2clinfo(ifinfo, yellow_action->tca_handle);
		if (clist[n] == NULL)
			return (QOPERR_BADCLASS);
		n++;
	}
	if (red_action->tca_code == TCACODE_HANDLE) {
		clist[n] = clhandle2clinfo(ifinfo, yellow_action->tca_handle);
		if (clist[n] == NULL)
			return (QOPERR_BADCLASS);
		n++;
	}
	clist[n] = NULL;

	if ((cdnrinfo = calloc(1, sizeof(*cdnrinfo))) == NULL)
		return (QOPERR_NOMEM);

	cdnrinfo->tce_type = TCETYPE_TSWTCM;
	cdnrinfo->tce_un.tswtcm.cmtd_rate = cmtd_rate;
	cdnrinfo->tce_un.tswtcm.peak_rate = peak_rate;
	cdnrinfo->tce_un.tswtcm.avg_interval = avg_interval;
	cdnrinfo->tce_un.tswtcm.green_action = *green_action;
	cdnrinfo->tce_un.tswtcm.yellow_action = *yellow_action;
	cdnrinfo->tce_un.tswtcm.red_action = *red_action;

	if ((error = qop_add_cdnr(&clinfo, cdnr_name, ifinfo, clist,
				  cdnrinfo)) != 0)
		goto err_ret;

	if (rp != NULL)
		*rp = clinfo;
	return (0);

 err_ret:
	if (cdnrinfo != NULL)
		free(cdnrinfo);
	return (error);
}

int 
qop_cdnr_modify_tswtcm(struct classinfo *clinfo, const u_int32_t cmtd_rate,
		       const u_int32_t peak_rate, const u_int32_t avg_interval)
{
	struct cdnrinfo *cdnrinfo = clinfo->private;

	if (cdnrinfo->tce_type != TCETYPE_TSWTCM)
		return (QOPERR_CLASS_INVAL);
	cdnrinfo->tce_un.tswtcm.cmtd_rate = cmtd_rate;
	cdnrinfo->tce_un.tswtcm.peak_rate = peak_rate;
	cdnrinfo->tce_un.tswtcm.avg_interval = avg_interval;
	
	return qop_modify_class(clinfo, NULL);
}

/*
 *  system call interfaces for qdisc_ops
 */
static int
cdnr_attach(struct ifinfo *ifinfo)
{
	struct cdnr_interface iface;

	if (cdnr_fd < 0 &&
	    (cdnr_fd = open(CDNR_DEVICE, O_RDWR)) < 0 &&
	    (cdnr_fd = open_module(CDNR_DEVICE, O_RDWR)) < 0) {
		LOG(LOG_ERR, errno, "CDNR open");
		return (QOPERR_SYSCALL);
	}

	cdnr_refcount++;
	memset(&iface, 0, sizeof(iface));
	strncpy(iface.cdnr_ifname, ifinfo->ifname+1, IFNAMSIZ);

	if (ioctl(cdnr_fd, CDNR_IF_ATTACH, &iface) < 0)
		return (QOPERR_SYSCALL);
#if 1
	LOG(LOG_INFO, 0, "conditioner attached to %s", iface.cdnr_ifname);
#endif
	return (0);
}

static int
cdnr_detach(struct ifinfo *ifinfo)
{
	struct cdnr_interface iface;
	
	memset(&iface, 0, sizeof(iface));
	strncpy(iface.cdnr_ifname, ifinfo->ifname+1, IFNAMSIZ);

	if (ioctl(cdnr_fd, CDNR_IF_DETACH, &iface) < 0)
		return (QOPERR_SYSCALL);

	if (--cdnr_refcount == 0) {
		close(cdnr_fd);
		cdnr_fd = -1;
	}
	return (0);
}

static int
cdnr_enable(struct ifinfo *ifinfo)
{
	struct cdnr_interface iface;

	memset(&iface, 0, sizeof(iface));
	strncpy(iface.cdnr_ifname, ifinfo->ifname+1, IFNAMSIZ);

	if (ioctl(cdnr_fd, CDNR_ENABLE, &iface) < 0)
		return (QOPERR_SYSCALL);
	return (0);
}

static int
cdnr_disable(struct ifinfo *ifinfo)
{
	struct cdnr_interface iface;

	memset(&iface, 0, sizeof(iface));
	strncpy(iface.cdnr_ifname, ifinfo->ifname+1, IFNAMSIZ);

	if (ioctl(cdnr_fd, CDNR_DISABLE, &iface) < 0)
		return (QOPERR_SYSCALL);
	return (0);
}

static int
cdnr_add_class(struct classinfo *clinfo)
{
	struct cdnr_add_element element_add;
	struct cdnr_add_tbmeter tbmeter_add;
	struct cdnr_add_trtcm   trtcm_add;
	struct cdnr_add_tswtcm  tswtcm_add;
	struct cdnrinfo *cdnrinfo;
	
	cdnrinfo = clinfo->private;

	/* root class is a dummy class */
	if (clinfo->parent == NULL) {
		clinfo->handle = 0;
		return (0);
	}

	switch (cdnrinfo->tce_type) {
	case TCETYPE_ELEMENT:
		memset(&element_add, 0, sizeof(element_add));
		strncpy(element_add.iface.cdnr_ifname,
			clinfo->ifinfo->ifname+1, IFNAMSIZ);
		element_add.action = cdnrinfo->tce_un.element.action;
		if (ioctl(cdnr_fd, CDNR_ADD_ELEM, &element_add) < 0) {
			clinfo->handle = CDNR_NULL_HANDLE;
			return (QOPERR_SYSCALL);
		}
		clinfo->handle = element_add.cdnr_handle;
		break;

	case TCETYPE_TBMETER:
		memset(&tbmeter_add, 0, sizeof(tbmeter_add));
		strncpy(tbmeter_add.iface.cdnr_ifname,
			clinfo->ifinfo->ifname+1, IFNAMSIZ);
		tbmeter_add.profile = cdnrinfo->tce_un.tbmeter.profile;
		tbmeter_add.in_action = cdnrinfo->tce_un.tbmeter.in_action;
		tbmeter_add.out_action = cdnrinfo->tce_un.tbmeter.out_action;
		if (ioctl(cdnr_fd, CDNR_ADD_TBM, &tbmeter_add) < 0) {
			clinfo->handle = CDNR_NULL_HANDLE;
			return (QOPERR_SYSCALL);
		}
		clinfo->handle = tbmeter_add.cdnr_handle;
		break;

	case TCETYPE_TRTCM:
		memset(&trtcm_add, 0, sizeof(trtcm_add));
		strncpy(trtcm_add.iface.cdnr_ifname,
			clinfo->ifinfo->ifname+1, IFNAMSIZ);
		trtcm_add.cmtd_profile = cdnrinfo->tce_un.trtcm.cmtd_profile;
		trtcm_add.peak_profile = cdnrinfo->tce_un.trtcm.peak_profile;
		trtcm_add.green_action = cdnrinfo->tce_un.trtcm.green_action;
		trtcm_add.yellow_action = cdnrinfo->tce_un.trtcm.yellow_action;
		trtcm_add.red_action = cdnrinfo->tce_un.trtcm.red_action;
		trtcm_add.coloraware = cdnrinfo->tce_un.trtcm.coloraware;
		if (ioctl(cdnr_fd, CDNR_ADD_TCM, &trtcm_add) < 0) {
			clinfo->handle = CDNR_NULL_HANDLE;
			return (QOPERR_SYSCALL);
		}
		clinfo->handle = trtcm_add.cdnr_handle;
		break;

	case TCETYPE_TSWTCM:
		memset(&tswtcm_add, 0, sizeof(tswtcm_add));
		strncpy(tswtcm_add.iface.cdnr_ifname,
			clinfo->ifinfo->ifname+1, IFNAMSIZ);
		tswtcm_add.cmtd_rate = cdnrinfo->tce_un.tswtcm.cmtd_rate;
		tswtcm_add.peak_rate = cdnrinfo->tce_un.tswtcm.peak_rate;
		tswtcm_add.avg_interval = cdnrinfo->tce_un.tswtcm.avg_interval;
		tswtcm_add.green_action = cdnrinfo->tce_un.tswtcm.green_action;
		tswtcm_add.yellow_action = cdnrinfo->tce_un.tswtcm.yellow_action;
		tswtcm_add.red_action = cdnrinfo->tce_un.tswtcm.red_action;
		if (ioctl(cdnr_fd, CDNR_ADD_TSW, &tswtcm_add) < 0) {
			clinfo->handle = CDNR_NULL_HANDLE;
			return (QOPERR_SYSCALL);
		}
		clinfo->handle = tswtcm_add.cdnr_handle;
		break;

	default:
		return (QOPERR_CLASS_INVAL);
	}
	return (0);
}

static int
cdnr_modify_class(struct classinfo *clinfo, void *arg)
{
	struct cdnr_modify_tbmeter tbmeter_modify;
	struct cdnr_modify_trtcm   trtcm_modify;
	struct cdnr_modify_tswtcm  tswtcm_modify;
	struct cdnrinfo *cdnrinfo;

	cdnrinfo = clinfo->private;

	switch (cdnrinfo->tce_type) {
	case TCETYPE_TBMETER:
		memset(&tbmeter_modify, 0, sizeof(tbmeter_modify));
		strncpy(tbmeter_modify.iface.cdnr_ifname,
			clinfo->ifinfo->ifname+1, IFNAMSIZ);
		tbmeter_modify.cdnr_handle = clinfo->handle;
		tbmeter_modify.profile = cdnrinfo->tce_un.tbmeter.profile;
		if (ioctl(cdnr_fd, CDNR_MOD_TBM, &tbmeter_modify) < 0)
			return (QOPERR_SYSCALL);
		break;

	case TCETYPE_TRTCM:
		memset(&trtcm_modify, 0, sizeof(trtcm_modify));
		strncpy(trtcm_modify.iface.cdnr_ifname,
			clinfo->ifinfo->ifname+1, IFNAMSIZ);
		trtcm_modify.cdnr_handle = clinfo->handle;
		trtcm_modify.cmtd_profile =
			cdnrinfo->tce_un.trtcm.cmtd_profile;
		trtcm_modify.peak_profile =
			cdnrinfo->tce_un.trtcm.peak_profile;
		trtcm_modify.coloraware = cdnrinfo->tce_un.trtcm.coloraware;
		if (ioctl(cdnr_fd, CDNR_MOD_TCM, &trtcm_modify) < 0)
			return (QOPERR_SYSCALL);
		break;

	case TCETYPE_TSWTCM:
		memset(&tswtcm_modify, 0, sizeof(tswtcm_modify));
		strncpy(tswtcm_modify.iface.cdnr_ifname,
			clinfo->ifinfo->ifname+1, IFNAMSIZ);
		tswtcm_modify.cdnr_handle = clinfo->handle;
		tswtcm_modify.cmtd_rate = cdnrinfo->tce_un.tswtcm.cmtd_rate;
		tswtcm_modify.peak_rate = cdnrinfo->tce_un.tswtcm.peak_rate;
		tswtcm_modify.avg_interval = cdnrinfo->tce_un.tswtcm.avg_interval;
		if (ioctl(cdnr_fd, CDNR_MOD_TSW, &tswtcm_modify) < 0)
			return (QOPERR_SYSCALL);
		break;

	default:
		return (QOPERR_CLASS_INVAL);
	}
	return (0);
}

static int
cdnr_delete_class(struct classinfo *clinfo)
{
	struct cdnr_delete_element element_delete;

	if (clinfo->handle == CDNR_NULL_HANDLE)
		return (0);

	memset(&element_delete, 0, sizeof(element_delete));
	strncpy(element_delete.iface.cdnr_ifname, clinfo->ifinfo->ifname+1,
		IFNAMSIZ);
	element_delete.cdnr_handle = clinfo->handle;

	if (ioctl(cdnr_fd, CDNR_DEL_ELEM, &element_delete) < 0)
		return (QOPERR_SYSCALL);
	return (0);
}

static int
cdnr_add_filter(struct fltrinfo *fltrinfo)
{
	struct cdnr_add_filter fltr_add;
	
	memset(&fltr_add, 0, sizeof(fltr_add));
	strncpy(fltr_add.iface.cdnr_ifname,
		fltrinfo->clinfo->ifinfo->ifname+1, IFNAMSIZ);
	fltr_add.cdnr_handle = fltrinfo->clinfo->handle;
	fltr_add.filter = fltrinfo->fltr;

	if (ioctl(cdnr_fd, CDNR_ADD_FILTER, &fltr_add) < 0)
		return (QOPERR_SYSCALL);
	fltrinfo->handle = fltr_add.filter_handle;
	return (0);
}

static int
cdnr_delete_filter(struct fltrinfo *fltrinfo)
{
	struct cdnr_delete_filter fltr_del;

	memset(&fltr_del, 0, sizeof(fltr_del));
	strncpy(fltr_del.iface.cdnr_ifname,
		fltrinfo->clinfo->ifinfo->ifname+1, IFNAMSIZ);
	fltr_del.filter_handle = fltrinfo->handle;

	if (ioctl(cdnr_fd, CDNR_DEL_FILTER, &fltr_del) < 0)
		return (QOPERR_SYSCALL);
	return (0);
}


static int 
verify_tbprofile(struct tb_profile *profile, const char *cdnr_name)
{
	if (profile->depth < 1500) {
		LOG(LOG_WARNING, 0,
		    "warning: token bucket depth for %s is too small (%d)",
		    cdnr_name, profile->depth);
		return (-1);
	}
	return (0);
}