/*      $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);
}

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.