/*      $NetBSD: qop_cbq.c,v 1.13 2024/12/24 08:35:28 ozaki-r Exp $     */
/*      $KAME: qop_cbq.c,v 1.7 2002/05/31 06:03:35 kjc Exp $    */
/*
 * Copyright (c) Sun Microsystems, Inc. 1993-1998 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.
 *
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by the SMCC Technology
 *      Development Group at Sun Microsystems, Inc.
 *
 * 4. The name of the Sun Microsystems, Inc nor may not be used to endorse or
 *      promote products derived from this software without specific prior
 *      written permission.
 *
 * SUN MICROSYSTEMS DOES NOT CLAIM MERCHANTABILITY OF THIS SOFTWARE OR THE
 * SUITABILITY OF THIS SOFTWARE FOR ANY PARTICULAR PURPOSE.  The software is
 * provided "as is" without express or implied warranty of any kind.
 *  
 * These notices must be retained in any copies of any part of this software.
 */

#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 <math.h>

#include <altq/altq.h>
#include <altq/altq_cbq.h>
#include "altq_qop.h"
#include "qop_cbq.h"

static int qcmd_cbq_add_ctl_filters(const char *, const char *);

static int qop_cbq_enable_hook(struct ifinfo *);
static int qop_cbq_delete_class_hook(struct classinfo *);

static int cbq_class_spec(struct ifinfo *, u_long, u_long, u_int, int,
                          uint64_t, u_int, u_int, u_int, u_int,
                          u_int, cbq_class_spec_t *);

static int cbq_attach(struct ifinfo *);
static int cbq_detach(struct ifinfo *);
static int cbq_clear(struct ifinfo *);
static int cbq_enable(struct ifinfo *);
static int cbq_disable(struct ifinfo *);
static int cbq_add_class(struct classinfo *);
static int cbq_modify_class(struct classinfo *, void *);
static int cbq_delete_class(struct classinfo *);
static int cbq_add_filter(struct fltrinfo *);
static int cbq_delete_filter(struct fltrinfo *);

#define CTL_PBANDWIDTH  2
#define NS_PER_MS       (1000000.0)
#define NS_PER_SEC      (NS_PER_MS*1000.0)
#define PS_PER_MS       (1000000000.0)
#define PS_PER_SEC      (PS_PER_MS*1000.0)
#define RM_FILTER_GAIN  5

#define PSEC_TO_USEC(ps)        ((ps) / 1000.0 / 1000.0)

#define CBQ_DEVICE      "/dev/altq/cbq"

static int cbq_fd = -1;
static int cbq_refcount = 0;

static struct qdisc_ops cbq_qdisc = {
        ALTQT_CBQ,
        "cbq",
        cbq_attach,
        cbq_detach,
        cbq_clear,
        cbq_enable,
        cbq_disable,
        cbq_add_class,
        cbq_modify_class,
        cbq_delete_class,
        cbq_add_filter,
        cbq_delete_filter,
};

#define EQUAL(s1, s2)   (strcmp((s1), (s2)) == 0)

/*
 * parser interface
 */
int
cbq_interface_parser(const char *ifname, int argc, char **argv)
{
        uint64_t        bandwidth = 100000000;  /* 100Mbps */
        u_int   tbrsize = 0;
        u_int   is_efficient = 0;
        u_int   is_wrr = 1;     /* weighted round-robin is default */
        bool    no_control = false;
        bool    no_tbr = false;

        /*
         * process options
         */
        while (argc > 0) {
                if (EQUAL(*argv, "bandwidth")) {
                        argc--; argv++;
                        if (argc > 0)
                                bandwidth = atobps(*argv);
                } else if (EQUAL(*argv, "tbrsize")) {
                        argc--; argv++;
                        if (argc > 0)
                                tbrsize = atobytes(*argv);
                } else if (EQUAL(*argv, "efficient")) {
                        is_efficient = 1;
                } else if (EQUAL(*argv, "cbq")) {
                        /* just skip */
                } else if (EQUAL(*argv, "cbq-wrr")) {
                        is_wrr = 1;
                } else if (EQUAL(*argv, "cbq-prr")) {
                        is_wrr = 0;
                } else if (EQUAL(*argv, "no-tbr")) {
                        no_tbr = true;
                } else if (EQUAL(*argv, "no-control")) {
                        no_control = true;
                } else {
                        LOG(LOG_ERR, 0, "Unknown keyword '%s'", *argv);
                        return (0);
                }
                argc--; argv++;
        }

        if (!no_tbr) {
                if (qcmd_tbr_register(ifname, bandwidth, tbrsize) != 0)
                        return (0);
        }

        if (qcmd_cbq_add_if(ifname, bandwidth,
                            is_wrr, is_efficient, no_control) != 0)
                return (0);

        return (1);
}

int
cbq_class_parser(const char *ifname, const char *class_name,
                 const char *parent_name, int argc, char **argv)
{
        const char      *borrow = NULL;
        u_int   pri = 1;
        u_int   pbandwidth = 0;
        uint64_t        bandwidth = 0;
        u_int   maxdelay = 0;           /* 0 means default */
        u_int   maxburst = 0;           /* 0 means default */
        u_int   minburst = 0;           /* 0 means default */
        u_int   av_pkt_size = 0;  /* 0 means use if mtu as default */
        u_int   max_pkt_size = 0; /* 0 means use if mtu as default */
        int     flags = 0;
        cbq_tos_t       admission_type = CBQ_QOS_NONE;
        int     error;

        if (parent_name == NULL)
                flags |= CBQCLF_ROOTCLASS;

        while (argc > 0) {
                if (EQUAL(*argv, "priority")) {
                        argc--; argv++;
                        if (argc > 0)
                                pri = strtoul(*argv, NULL, 0);
                } else if (EQUAL(*argv, "default")) {
                        flags |= CBQCLF_DEFCLASS;
                } else if (EQUAL(*argv, "control")) {
                        flags |= CBQCLF_CTLCLASS;
                } else if (EQUAL(*argv, "admission")) {
                        argc--; argv++;
                        if (argc > 0) {
                                if (EQUAL(*argv, "guaranteed"))
                                        admission_type = CBQ_QOS_GUARANTEED;
                                else if (EQUAL(*argv, "predictive"))
                                        admission_type = CBQ_QOS_PREDICTIVE;
                                else if (EQUAL(*argv, "cntlload"))
                                        admission_type = CBQ_QOS_CNTR_LOAD;
                                else if (EQUAL(*argv, "cntldelay"))
                                        admission_type = CBQ_QOS_CNTR_DELAY;
                                else if (EQUAL(*argv, "none"))
                                        admission_type = CBQ_QOS_NONE;
                                else {
                                        LOG(LOG_ERR, 0,
                                            "unknown admission type - %s, line %d",
                                            *argv, line_no);
                                        return (0);
                                }
                        }
                } else if (EQUAL(*argv, "maxdelay")) {
                        argc--; argv++;
                        if (argc > 0)
                                maxdelay = strtoul(*argv, NULL, 0);
                } else if (EQUAL(*argv, "borrow")) {
                        borrow = parent_name;
#if 1
                        /* support old style "borrow [parent]" */
                        if (argc > 1 &&
                            EQUAL(*(argv + 1), parent_name)) {
                                /* old style, skip borrow_name */
                                argc--; argv++;
                        }
#endif
                } else if (EQUAL(*argv, "pbandwidth")) {
                        argc--; argv++;
                        if (argc > 0)
                                pbandwidth = strtoul(*argv, NULL, 0);
                        if (pbandwidth > 100) {
                                LOG(LOG_ERR, 0,
                                    "bad pbandwidth %d for %s!",
                                    pbandwidth, class_name);
                                return (0);
                        }
                } else if (EQUAL(*argv, "exactbandwidth")) {
                        argc--; argv++;
                        if (argc > 0)
                                bandwidth = atobps(*argv);
                } else if (EQUAL(*argv, "maxburst")) {
                        argc--; argv++;
                        if (argc > 0)
                                maxburst = strtoul(*argv, NULL, 0);
                } else if (EQUAL(*argv, "minburst")) {
                        argc--; argv++;
                        if (argc > 0)
                                minburst = strtoul(*argv, NULL, 0);
                } else if (EQUAL(*argv, "packetsize")) {
                        argc--; argv++;
                        if (argc > 0)
                                av_pkt_size = atobytes(*argv);
                } else if (EQUAL(*argv, "maxpacketsize")) {
                        argc--; argv++;
                        if (argc > 0)
                                max_pkt_size = atobytes(*argv);
                } else if (EQUAL(*argv, "red")) {
                        flags |= CBQCLF_RED;
                } else if (EQUAL(*argv, "ecn")) {
                        flags |= CBQCLF_ECN;
                } else if (EQUAL(*argv, "flowvalve")) {
                        flags |= CBQCLF_FLOWVALVE;
                } else if (EQUAL(*argv, "rio")) {
                        flags |= CBQCLF_RIO;
                } else if (EQUAL(*argv, "cleardscp")) {
                        flags |= CBQCLF_CLEARDSCP;
                } else {
                        LOG(LOG_ERR, 0,
                            "Unknown keyword '%s' in %s, line %d",
                            *argv, altqconfigfile, line_no);
                        return (0);
                }

                argc--; argv++;
        }

        if ((flags & (CBQCLF_RED|CBQCLF_RIO)) == (CBQCLF_RED|CBQCLF_RIO)) {
                LOG(LOG_ERR, 0,
                    "both red and rio defined on interface '%s'",
                    ifname);
                return (0);
        }
        if ((flags & (CBQCLF_ECN|CBQCLF_FLOWVALVE))
            && (flags & (CBQCLF_RED|CBQCLF_RIO)) == 0)
                flags |= CBQCLF_RED;

        if (strcmp("ctl_class", class_name) == 0)
                flags |= CBQCLF_CTLCLASS;

        if (bandwidth == 0 && pbandwidth != 0) {
                struct ifinfo   *ifinfo;

                if ((ifinfo = ifname2ifinfo(ifname)) != NULL)
                        bandwidth = ifinfo->bandwidth / 100 * pbandwidth;
        }

        error = qcmd_cbq_add_class(ifname, class_name, parent_name, borrow,
                                   pri, bandwidth,
                                   maxdelay, maxburst, minburst,
                                   av_pkt_size, max_pkt_size,
                                   admission_type, flags);
        if (error)
                return (0);
        return (1);
}

/*
 * qcmd api
 */
int
qcmd_cbq_add_if(const char *ifname, uint64_t bandwidth, int is_wrr, int efficient,
    bool no_control)
{
        int error;
        
        error = qop_cbq_add_if(NULL, ifname, bandwidth, is_wrr, efficient,
            no_control);
        if (error != 0)
                LOG(LOG_ERR, errno, "%s: can't add cbq on interface '%s'",
                    qoperror(error), ifname);
        return (error);
}

int
qcmd_cbq_add_class(const char *ifname, const char *class_name,
                   const char *parent_name, const char *borrow_name,
                   u_int pri, uint64_t bandwidth,
                   u_int maxdelay, u_int maxburst, u_int minburst,
                   u_int av_pkt_size, u_int max_pkt_size,
                   int admission_type, int flags)
{
        struct ifinfo *ifinfo;
        struct cbq_ifinfo *cbq_ifinfo;
        struct classinfo *parent = NULL, *borrow = NULL;
        uint64_t ctl_bandwidth = 0;
        int     error = 0;

        if ((ifinfo = ifname2ifinfo(ifname)) == NULL)
                error = QOPERR_BADIF;
        cbq_ifinfo = ifinfo->private;

        if (error == 0 && parent_name != NULL &&
            (parent = clname2clinfo(ifinfo, parent_name)) == NULL)
                error = QOPERR_BADCLASS;

        if (error == 0 && borrow_name != NULL &&
            (borrow = clname2clinfo(ifinfo, borrow_name)) == NULL)
                error = QOPERR_BADCLASS;

        if (flags & CBQCLF_DEFCLASS && !cbq_ifinfo->no_control) {
                /*
                 * if this is a default class and no ctl_class is defined,
                 * we will create a ctl_class.
                 */
                if (cbq_ifinfo->ctl_class == NULL) {
                        /* reserve bandwidth for ctl_class */
                        ctl_bandwidth =
                                ifinfo->bandwidth / 100 * CTL_PBANDWIDTH;
                        if (bandwidth <= ctl_bandwidth)
                                LOG(LOG_ERR, 0,
                                    "bandwidth for default class too small!");
                        bandwidth -= ctl_bandwidth;
                }
        }

        if (error == 0)
                error = qop_cbq_add_class(NULL, class_name, ifinfo, parent,
                                          borrow, pri, bandwidth,
                                          maxdelay, maxburst, minburst,
                                          av_pkt_size, max_pkt_size,
                                          admission_type, flags);
        if (error != 0)
                LOG(LOG_ERR, errno,
                    "cbq: %s: can't add class '%s' on interface '%s'",
                    qoperror(error), class_name, ifname);

        if (ctl_bandwidth != 0) {
                /*
                 * If were adding the default traffic class and
                 * no ctl_class is defined, also add the ctl traffic class.
                 * This is for RSVP and IGMP packets.
                 */
                if (qcmd_cbq_add_class(ifname, "ctl_class", parent_name,
                      borrow_name, 6, ctl_bandwidth,
                      maxdelay, maxburst, minburst, av_pkt_size,
                      max_pkt_size, admission_type, CBQCLF_CTLCLASS) != 0) {
                        LOG(LOG_ERR, errno, "can't create ctl_class!");
                        return (QOPERR_CLASS);
                }
        }

        /*
         * if this is a ctl class, add the default filters for backward
         * compatibility
         */
        if (flags & CBQCLF_CTLCLASS)
                qcmd_cbq_add_ctl_filters(ifname, class_name);

        return (error);
}

int
qcmd_cbq_modify_class(const char *ifname, const char *class_name,
                      u_int pri, uint64_t bandwidth,
                      u_int maxdelay, u_int maxburst, u_int minburst,
                      u_int av_pkt_size, u_int max_pkt_size, int flags)
{
        struct ifinfo *ifinfo;
        struct classinfo *clinfo;

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

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

        return qop_cbq_modify_class(clinfo, pri, bandwidth,
                                    maxdelay, maxburst, minburst,
                                    av_pkt_size, max_pkt_size, flags);
}

/*
 * add the default filters for ctl_class (for backward compatibility).
 */
#ifndef IPPROTO_RSVP
#define IPPROTO_RSVP            46
#endif

static int 
qcmd_cbq_add_ctl_filters(const char *ifname, const char *clname)
{
        struct flow_filter      sfilt;
        u_int8_t ctl_protos[3] = {IPPROTO_ICMP, IPPROTO_IGMP, IPPROTO_RSVP};
#ifdef INET6
        struct flow_filter6     sfilt6;
        u_int8_t ctl6_protos[3] = {IPPROTO_ICMPV6, IPPROTO_IGMP, IPPROTO_RSVP};
#endif
        int error;
        size_t i;

        for (i = 0; i < sizeof(ctl_protos); i++) {
                memset(&sfilt, 0, sizeof(sfilt));
                sfilt.ff_flow.fi_family = AF_INET;
                sfilt.ff_flow.fi_proto = ctl_protos[i];

                filter_dontwarn = 1;            /* XXX */
                error = qcmd_add_filter(ifname, clname, NULL, &sfilt);
                filter_dontwarn = 0;            /* XXX */
                if (error) {
                        LOG(LOG_ERR, 0,
                            "can't add ctl class filter on interface '%s'",
                            ifname);
                        return (error);
                }
        }

#ifdef INET6
        for (i = 0; i < sizeof(ctl6_protos); i++) {
                memset(&sfilt6, 0, sizeof(sfilt6));
                sfilt6.ff_flow6.fi6_family = AF_INET6;
                sfilt6.ff_flow6.fi6_proto = ctl6_protos[i];

                error = qcmd_add_filter(ifname, clname, NULL,
                                        (struct flow_filter *)&sfilt6);
                if (error) {
                        LOG(LOG_WARNING, 0,
                            "can't add ctl class IPv6 filter on interface '%s'",
                            ifname);
                        return (error);
                }
        }
#endif
        return (0);
}

/*
 * qop api
 */
int 
qop_cbq_add_if(struct ifinfo **rp, const char *ifname,
               uint64_t bandwidth, int is_wrr, int efficient, bool no_control)
{
        struct ifinfo *ifinfo = NULL;
        struct cbq_ifinfo *cbq_ifinfo = NULL;
        int error;

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

        cbq_ifinfo->psPerByte =
                (1.0 / (double)bandwidth) * PS_PER_SEC * 8;
        cbq_ifinfo->is_wrr = is_wrr;
        cbq_ifinfo->is_efficient = efficient;
        cbq_ifinfo->no_control = no_control;

        error = qop_add_if(&ifinfo, ifname, bandwidth,
                           &cbq_qdisc, cbq_ifinfo);
        if (error != 0)
                goto err_ret;

        /* set enable hook */
        ifinfo->enable_hook = qop_cbq_enable_hook;

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

 err_ret:
        if (cbq_ifinfo != NULL) {
                free(cbq_ifinfo);
                if (ifinfo != NULL)
                        ifinfo->private = NULL;
        }
        return (error);
}

#define is_sc_null(sc)  (((sc) == NULL) || ((sc)->m1 == 0 && (sc)->m2 == 0))

int 
qop_cbq_add_class(struct classinfo **rp, const char *class_name,
                  struct ifinfo *ifinfo, struct classinfo *parent, 
                  struct classinfo *borrow, u_int pri, uint64_t bandwidth,
                  u_int maxdelay, u_int maxburst, u_int minburst,
                  u_int av_pkt_size, u_int max_pkt_size,
                  int admission_type, int flags)
{
        struct classinfo *clinfo;
        struct cbq_ifinfo *cbq_ifinfo;
        struct cbq_classinfo *cbq_clinfo, *parent_clinfo;
        u_int parent_handle, borrow_handle;
        int error;

        cbq_ifinfo = ifinfo->private;

        if (parent == NULL) {
                if (cbq_ifinfo->root_class != NULL)
                        return (QOPERR_CLASS_INVAL);
                flags |= CBQCLF_ROOTCLASS;
        }
        if ((flags & CBQCLF_DEFCLASS) && cbq_ifinfo->default_class != NULL)
                return (QOPERR_CLASS_INVAL);
        if ((flags & CBQCLF_CTLCLASS) && cbq_ifinfo->ctl_class != NULL)
                return (QOPERR_CLASS_INVAL);

        /* admission control */
        if (parent != NULL) {
                parent_clinfo = parent->private;
                if (bandwidth >
                    parent_clinfo->bandwidth - parent_clinfo->allocated) {
#ifdef ALLOW_OVERCOMMIT
                        LOG(LOG_WARNING, 0,
                            "bandwidth overcommitted %uK requested but only %dK available (%uK already allocated)",
                            bandwidth / 1000,
                            ((int)parent_clinfo->bandwidth -
                             parent_clinfo->allocated) / 1000,
                            parent_clinfo->allocated / 1000);
#else /* !ALLOW_OVERCOMMIT */
                        LOG(LOG_ERR, 0,
                            "cbq admission failed! %uK requested but only %uK available (%uK already allocated)",
                            bandwidth / 1000,
                            (parent_clinfo->bandwidth -
                             parent_clinfo->allocated) / 1000,
                            parent_clinfo->allocated / 1000);
                        return (QOPERR_ADMISSION_NOBW);
#endif /* !ALLOW_OVERCOMMIT */
                }
        }
                
        if ((cbq_clinfo = calloc(1, sizeof(*cbq_clinfo))) == NULL)
                return (QOPERR_NOMEM);

        cbq_clinfo->bandwidth = bandwidth;
        cbq_clinfo->allocated = 0;

        /* if average packet size isn't specified, set if mtu. */
        if (av_pkt_size == 0) { /* use default */
                av_pkt_size = ifinfo->ifmtu;
                if (av_pkt_size > MCLBYTES)     /* do what TCP does */
                        av_pkt_size &= ~MCLBYTES;
        } else if (av_pkt_size > ifinfo->ifmtu)
                av_pkt_size = ifinfo->ifmtu;

        if (max_pkt_size == 0)  /* use default */
                max_pkt_size = ifinfo->ifmtu;
        else if (max_pkt_size > ifinfo->ifmtu)
                max_pkt_size = ifinfo->ifmtu;

        cbq_clinfo->maxdelay = maxdelay;
        cbq_clinfo->maxburst = maxburst;
        cbq_clinfo->minburst = minburst;
        cbq_clinfo->av_pkt_size = av_pkt_size;
        cbq_clinfo->max_pkt_size = max_pkt_size;

        parent_handle = parent != NULL ? parent->handle : NULL_CLASS_HANDLE;
        borrow_handle = borrow != NULL ? borrow->handle : NULL_CLASS_HANDLE;

        if (cbq_class_spec(ifinfo, parent_handle, borrow_handle, pri, flags,
                           bandwidth, maxdelay, maxburst, minburst,
                           av_pkt_size, max_pkt_size,
                           &cbq_clinfo->class_spec) < 0) {
                error = QOPERR_INVAL;
                goto err_ret;
        }

        clinfo = NULL;
        error = qop_add_class(&clinfo, class_name, ifinfo, parent, cbq_clinfo);
        if (error != 0)
                goto err_ret;

        /* set delete hook */
        clinfo->delete_hook = qop_cbq_delete_class_hook;
        
        if (parent == NULL)
                cbq_ifinfo->root_class = clinfo;
        else {
                parent_clinfo = parent->private;
                parent_clinfo->allocated += bandwidth;
        }
        if (flags & CBQCLF_DEFCLASS)
                cbq_ifinfo->default_class = clinfo;
        if (flags & CBQCLF_CTLCLASS)
                cbq_ifinfo->ctl_class = clinfo;

        switch (admission_type) {
        case CBQ_QOS_CNTR_LOAD:
        case CBQ_QOS_GUARANTEED:
        case CBQ_QOS_PREDICTIVE:
        case CBQ_QOS_CNTR_DELAY:
                if (ifinfo->resv_class != NULL) {
                        LOG(LOG_ERR, 0,
                            "%s: duplicate resv meta class", class_name);
                        return (QOPERR_CLASS);
                }
                ifinfo->resv_class = clinfo;
        }

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

 err_ret:
        if (cbq_clinfo != NULL) {
                free(cbq_clinfo);
                if (clinfo != NULL)
                    clinfo->private = NULL;
        }
        return (error);
}

/*
 * this is called from qop_delete_class() before a class is destroyed
 * for discipline specific cleanup.
 */
static int 
qop_cbq_delete_class_hook(struct classinfo *clinfo)
{
        struct cbq_classinfo *cbq_clinfo, *parent_clinfo;

        /* cancel admission control */
        if (clinfo->parent != NULL) {
                cbq_clinfo = clinfo->private;
                parent_clinfo = clinfo->parent->private;
                
                parent_clinfo->allocated -= cbq_clinfo->bandwidth;
        }
        return (0);
}

int
qop_cbq_modify_class(struct classinfo *clinfo, u_int pri, uint64_t bandwidth,
                     u_int maxdelay, u_int maxburst, u_int minburst,
                     u_int av_pkt_size, u_int max_pkt_size, int flags)
{
        struct ifinfo *ifinfo;
        struct cbq_classinfo *cbq_clinfo, *parent_clinfo;
        u_int   parent_handle, borrow_handle;
        uint64_t        old_bandwidth;
        int     error;

        ifinfo = clinfo->ifinfo;
        cbq_clinfo = clinfo->private;

        /* admission control */
        old_bandwidth = cbq_clinfo->bandwidth;
        if (clinfo->parent != NULL) {
                parent_clinfo = clinfo->parent->private;
                if (bandwidth > old_bandwidth) {
                        /* increase bandwidth */
                        if (bandwidth - old_bandwidth >
                            parent_clinfo->bandwidth
                            - parent_clinfo->allocated)
                                return (QOPERR_ADMISSION_NOBW);
                } else if (bandwidth < old_bandwidth) {
                        /* decrease bandwidth */
                        if (bandwidth < cbq_clinfo->allocated)
                                return (QOPERR_ADMISSION);
                }
        }

        /* if average packet size isn't specified, set if mtu. */
        if (av_pkt_size == 0) { /* use default */
                av_pkt_size = ifinfo->ifmtu;
                if (av_pkt_size > MCLBYTES)     /* do what TCP does */
                        av_pkt_size &= ~MCLBYTES;
        } else if (av_pkt_size > ifinfo->ifmtu)
                av_pkt_size = ifinfo->ifmtu;

        if (max_pkt_size == 0)  /* use default */
                max_pkt_size = ifinfo->ifmtu;
        else if (max_pkt_size > ifinfo->ifmtu)
                max_pkt_size = ifinfo->ifmtu;

        cbq_clinfo->maxdelay = maxdelay;
        cbq_clinfo->maxburst = maxburst;
        cbq_clinfo->minburst = minburst;
        cbq_clinfo->av_pkt_size = av_pkt_size;
        cbq_clinfo->max_pkt_size = max_pkt_size;

        parent_handle = cbq_clinfo->class_spec.parent_class_handle;
        borrow_handle = cbq_clinfo->class_spec.borrow_class_handle;

        if (cbq_class_spec(ifinfo, parent_handle, borrow_handle, pri, flags,
                           bandwidth, maxdelay, maxburst, minburst,
                           av_pkt_size, max_pkt_size,
                           &cbq_clinfo->class_spec) < 0) {
                return (QOPERR_INVAL);
        }

        error = qop_modify_class(clinfo, NULL);

        if (error == 0) {
                if (clinfo->parent != NULL) {
                        parent_clinfo = clinfo->parent->private;
                        parent_clinfo->allocated -= old_bandwidth;
                        parent_clinfo->allocated += bandwidth;
                }
                cbq_clinfo->bandwidth = bandwidth;
        }
        return (error);
}

/*
 * sanity check at enabling cbq:
 *  there must one root class and one default class for an interface
 */
static int
qop_cbq_enable_hook(struct ifinfo *ifinfo)
{
        struct cbq_ifinfo *cbq_ifinfo;
        
        cbq_ifinfo = ifinfo->private;
        if (cbq_ifinfo->root_class == NULL) {
                LOG(LOG_ERR, 0, "cbq: no root class on interface %s!",
                    ifinfo->ifname);
                return (QOPERR_CLASS);
        }
        if (cbq_ifinfo->default_class == NULL) {
                LOG(LOG_ERR, 0, "cbq: no default class on interface %s!",
                    ifinfo->ifname);
                return (QOPERR_CLASS);
        }
        return (0);
}

static int
cbq_class_spec(struct ifinfo *ifinfo, u_long parent_class,
               u_long borrow_class, u_int pri, int flags,
               uint64_t bandwidth, u_int maxdelay, u_int maxburst,
               u_int minburst, u_int av_pkt_size, u_int max_pkt_size,
               cbq_class_spec_t *cl_spec)
{
        struct cbq_ifinfo *cbq_ifinfo = ifinfo->private;
        double          maxq, maxidle_s, maxidle, minidle,
                        lofftime, psPerByte, ptime, cptime;
        double          z = (double)(1 << RM_FILTER_GAIN);
        double          g = (1.0 - 1.0 / z);
        double          f;
        double          gton;
        double          gtom;

        /* Compute other class parameters */
        if (bandwidth == 0)
                f = 0.0001;     /* small enough? */
        else
                f = ((double) bandwidth / (double) ifinfo->bandwidth);

        if (av_pkt_size == 0) { /* use default */
                av_pkt_size = ifinfo->ifmtu;
                if (av_pkt_size > MCLBYTES)     /* do what TCP does */
                        av_pkt_size &= ~MCLBYTES;
        } else if (av_pkt_size > ifinfo->ifmtu)
                av_pkt_size = ifinfo->ifmtu;
        if (max_pkt_size == 0)  /* use default */
                max_pkt_size = ifinfo->ifmtu;
        else if (max_pkt_size > ifinfo->ifmtu)
                max_pkt_size = ifinfo->ifmtu;

        psPerByte = cbq_ifinfo->psPerByte / f;
        ptime = (double) av_pkt_size * (double)cbq_ifinfo->psPerByte;
        cptime = ptime * (1.0 - f) / f;

        if (maxburst == 0) {  /* use default */
                if (cptime > 10.0 * PS_PER_MS)
                        maxburst = 4;
                else
                        maxburst = 16;
        }
        if (minburst == 0)  /* use default */
                minburst = 2;
        if (minburst > maxburst)
                minburst = maxburst;

        if (IsDebug(DEBUG_ALTQ)) {
                int packet_time;
                LOG(LOG_DEBUG, 0,
                    "cbq_flowspec: maxburst=%d,minburst=%d,pkt_size=%d",
                    maxburst, minburst, av_pkt_size);
                LOG(LOG_DEBUG, 0,
                    "  psPerByte=%.2f ps, link's psPerByte=%.2f, f=%.3f",
                    psPerByte, cbq_ifinfo->psPerByte, f);
                packet_time = av_pkt_size * (int)PSEC_TO_USEC(psPerByte);
                LOG(LOG_DEBUG, 0,
                    "  packet time=%d [us]\n", packet_time);
                if (maxburst * packet_time < 20000) {
                        LOG(LOG_WARNING, 0,
                          "warning: maxburst smaller than timer granularity!");
                        LOG(LOG_WARNING, 0,
                            "         maxburst=%d, packet_time=%d [us]",
                            maxburst, packet_time);
                }
        }
        gton = pow(g, (double)maxburst);
        gtom = pow(g, (double)(minburst-1));
        maxidle = ((1.0 / f - 1.0) * ((1.0 - gton) / gton));
        maxidle_s = (1.0 - g);
        if (maxidle > maxidle_s)
                maxidle = ptime * maxidle;
        else
                maxidle = ptime * maxidle_s;
        if (IsDebug(DEBUG_ALTQ))
                LOG(LOG_DEBUG, 0, "  maxidle=%.2f us", PSEC_TO_USEC(maxidle));
        if (minburst)
                lofftime = cptime * (1.0 + 1.0/(1.0 - g) * (1.0 - gtom) / gtom);
        else
                lofftime = cptime;
        minidle = -((double)max_pkt_size * (double)psPerByte);
        if (IsDebug(DEBUG_ALTQ))
                LOG(LOG_DEBUG, 0, "  lofftime=%.2f us minidle=%.2f us",
                    PSEC_TO_USEC(lofftime), PSEC_TO_USEC(minidle));

        maxidle = ((maxidle * 8.0) / psPerByte) * pow(2, RM_FILTER_GAIN);
#if 1 /* ALTQ */
        /* also scale lofftime and minidle */
        lofftime = (lofftime * 8.0) / psPerByte * pow(2, RM_FILTER_GAIN);
        minidle = ((minidle * 8.0) / psPerByte) * pow(2, RM_FILTER_GAIN);
#endif
        maxidle = maxidle / 1000.0;
        lofftime = lofftime / 1000.0;
        minidle = minidle / 1000.0;
        /* adjust queue size when maxdelay is specified.
           queue size should be relative to its share */
        if (maxdelay == 0) {
                if (flags & (CBQCLF_RED|CBQCLF_RIO))
                        maxq = 60.0;
                else
                        maxq = 30.0;
        } else {
                maxq = ((double) maxdelay * PS_PER_MS) / (psPerByte * av_pkt_size);
                if (maxq < 4) {
                        LOG(LOG_WARNING, 0,
                            "warning: maxq (%d) is too small. set to %d",
                            (int)maxq, 4);
                        maxq = 4;
                }
        }
        if (bandwidth == 0 && borrow_class == NULL_CLASS_HANDLE)
                /* filter out this class by setting queue size to zero */
                maxq = 0;
        if (IsDebug(DEBUG_ALTQ)) {
                if ((u_int)maxq < maxburst)
                        LOG(LOG_WARNING, 0,
                           "warning: maxq (%d) is smaller than maxburst(%d)",
                            (int)maxq, maxburst);
                else if (maxq > 100.0)
                        LOG(LOG_WARNING, 0,
                            "warning: maxq %d too large\n", (int)maxq);
                LOG(LOG_DEBUG, 0, "  maxq=%d", (int)maxq);
        }

        if (parent_class == NULL_CLASS_HANDLE) {
                if ((flags & CBQCLF_ROOTCLASS) == 0)
                        flags |= CBQCLF_ROOTCLASS;
                if (cbq_ifinfo->is_wrr)
                        flags |= CBQCLF_WRR;
                if (cbq_ifinfo->is_efficient)
                        flags |= CBQCLF_EFFICIENT;
        }

        memset((void *)cl_spec, 0, sizeof(cbq_class_spec_t));
        cl_spec->priority = pri;
        cl_spec->pico_sec_per_byte = (u_long) psPerByte;
        cl_spec->maxq = (u_int) maxq;
        cl_spec->maxidle = (u_int) fabs(maxidle);
        cl_spec->minidle = (int)minidle;
        cl_spec->offtime = (u_int) fabs(lofftime);

        cl_spec->parent_class_handle = parent_class;
        cl_spec->borrow_class_handle = borrow_class;

        cl_spec->pktsize = av_pkt_size;
        cl_spec->flags = flags;

        return (0);
}


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

        if (cbq_fd < 0 &&
            (cbq_fd = open(CBQ_DEVICE, O_RDWR)) < 0 &&
            (cbq_fd = open_module(CBQ_DEVICE, O_RDWR)) < 0) {
                LOG(LOG_ERR, errno, "CBQ open");
                return (QOPERR_SYSCALL);
        }

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

        if (ioctl(cbq_fd, CBQ_IF_ATTACH, &iface) < 0)
                return (QOPERR_SYSCALL);
        return (0);
}

static int
cbq_detach(struct ifinfo *ifinfo)
{
        struct cbq_interface iface;
        
        memset(&iface, 0, sizeof(iface));
        strncpy(iface.cbq_ifacename, ifinfo->ifname, IFNAMSIZ);

        if (ioctl(cbq_fd, CBQ_IF_DETACH, &iface) < 0)
                return (QOPERR_SYSCALL);

        if (--cbq_refcount == 0) {
                close(cbq_fd);
                cbq_fd = -1;
        }
        return (0);
}

static int
cbq_clear(struct ifinfo *ifinfo)
{
        struct cbq_interface iface;

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

        if (ioctl(cbq_fd, CBQ_CLEAR_HIERARCHY, &iface) < 0)
                return (QOPERR_SYSCALL);
        return (0);
}

static int
cbq_enable(struct ifinfo *ifinfo)
{
        struct cbq_interface iface;

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

        if (ioctl(cbq_fd, CBQ_ENABLE, &iface) < 0)
                return (QOPERR_SYSCALL);
        return (0);
}

static int
cbq_disable(struct ifinfo *ifinfo)
{
        struct cbq_interface iface;

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

        if (ioctl(cbq_fd, CBQ_DISABLE, &iface) < 0)
                return (QOPERR_SYSCALL);
        return (0);
}

static int
cbq_add_class(struct classinfo *clinfo)
{
        struct cbq_add_class class_add;
        struct cbq_classinfo *cbq_clinfo;

        cbq_clinfo = clinfo->private;
        
        memset(&class_add, 0, sizeof(class_add));
        strncpy(class_add.cbq_iface.cbq_ifacename,
                clinfo->ifinfo->ifname, IFNAMSIZ);

        class_add.cbq_class = cbq_clinfo->class_spec;

        if (ioctl(cbq_fd, CBQ_ADD_CLASS, &class_add) < 0)
                return (QOPERR_SYSCALL);

        clinfo->handle = class_add.cbq_class_handle;
        return (0);
}

static int
cbq_modify_class(struct classinfo *clinfo, void *arg)
{
        struct cbq_modify_class class_mod;
        struct cbq_classinfo *cbq_clinfo;

        cbq_clinfo = clinfo->private;

        memset(&class_mod, 0, sizeof(class_mod));
        strncpy(class_mod.cbq_iface.cbq_ifacename,
                clinfo->ifinfo->ifname, IFNAMSIZ);
        class_mod.cbq_class_handle = clinfo->handle;
        class_mod.cbq_class = cbq_clinfo->class_spec;

        if (ioctl(cbq_fd, CBQ_MODIFY_CLASS, &class_mod) < 0)
                return (QOPERR_SYSCALL);
        return (0);
}

static int
cbq_delete_class(struct classinfo *clinfo)
{
        struct cbq_delete_class class_delete;

        memset(&class_delete, 0, sizeof(class_delete));
        strncpy(class_delete.cbq_iface.cbq_ifacename,
                clinfo->ifinfo->ifname, IFNAMSIZ);
        class_delete.cbq_class_handle = clinfo->handle;

        if (ioctl(cbq_fd, CBQ_DEL_CLASS, &class_delete) < 0)
                return (QOPERR_SYSCALL);
        return (0);
}

static int
cbq_add_filter(struct fltrinfo *fltrinfo)
{
        struct cbq_add_filter fltr_add;
        
        memset(&fltr_add, 0, sizeof(fltr_add));
        strncpy(fltr_add.cbq_iface.cbq_ifacename,
                fltrinfo->clinfo->ifinfo->ifname, IFNAMSIZ);
        fltr_add.cbq_class_handle = fltrinfo->clinfo->handle;
        fltr_add.cbq_filter = fltrinfo->fltr;

        if (ioctl(cbq_fd, CBQ_ADD_FILTER, &fltr_add) < 0)
                return (QOPERR_SYSCALL);
        fltrinfo->handle = fltr_add.cbq_filter_handle;
        return (0);
}

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

        memset(&fltr_del, 0, sizeof(fltr_del));
        strncpy(fltr_del.cbq_iface.cbq_ifacename,
                fltrinfo->clinfo->ifinfo->ifname, IFNAMSIZ);
        fltr_del.cbq_filter_handle = fltrinfo->handle;

        if (ioctl(cbq_fd, CBQ_DEL_FILTER, &fltr_del) < 0)
                return (QOPERR_SYSCALL);
        return (0);
}