include/kernel.mk: enhance built-in/missing modules detection when packaging kmods

[openwrt.git] / package / iproute2 / patches / 000-debian_patches_3.patch

---
 Makefile                  |    4 
 doc/Makefile              |    8 
 doc/ip-cref.tex           |   16 +
 include/linux/pkt_sched.h |  518 ++++++++++++++++++++++++++++++++++++++++++++++
 ip/iptunnel.c             |    2 
 misc/Makefile             |    3 
 tc/Makefile               |    1 
 tc/q_htb.c                |  308 +++++++++++++++++++++++++++
 tc/q_wrr.c                |  322 ++++++++++++++++++++++++++++
 9 files changed, 1177 insertions(+), 5 deletions(-)

--- a/doc/ip-cref.tex
+++ b/doc/ip-cref.tex
@@ -1307,6 +1307,19 @@ peers are allowed to send to us.
 --- \threeonly the clamp for congestion window. It is ignored if the \verb|lock|
     flag is not used.
 
+\item \verb|hoplimit NUMBER|
+
+--- [2.5.74+ only] Hop limit on the path to this destination. If it is not
+    given, Linux uses the value selected with \verb|sysctl| variable
+    \verb|net/ipv4/ip_default_ttl|.
+
+\item \verb|initcwnd NUMBER|
+
+--- [2.5.70+ only] Initial congestion window size when establishing
+    connections to this destination. This value is multiplied with the
+    MSS (``Maximal Segment Size'') for the connection to get the actual
+    window size. If it is not given (or set to zero), Linux uses the
+    values specified in~\cite{RFC2414}.
 
 \item \verb|advmss NUMBER|
 
@@ -2665,6 +2678,9 @@ http://www.cisco.com/univercd/cc/td/doc/
 \bibitem{RFC2414}  M.~Allman, S.~Floyd, C.~Partridge.
 ``Increasing TCP's Initial Window'', RFC-2414.
 
+\bibitem{RFC2414}  M.~Allman, S.~Floyd, C.~Partridge.
+``Increasing TCP's Initial Window'', RFC-2414.
+
 \end{thebibliography}
 
 
--- a/doc/Makefile
+++ b/doc/Makefile
@@ -14,6 +14,7 @@ PAGESIZE=a4
 PAGESPERPAGE=2
 
 HTMLFILES=$(subst .sgml,.html,$(shell echo *.sgml))
+TXTFILES=$(subst .sgml,.txt,$(shell echo *.sgml))
 DVIFILES=$(subst .ps,.dvi,$(PSFILES))
 
 
@@ -23,6 +24,8 @@ pstwocol: $(PSFILES)
 
 html: $(HTMLFILES)
 
+txt: $(TXTFILES)
+
 dvi: $(DVIFILES)
 
 print: $(PSFILES)
@@ -47,9 +50,12 @@ print: $(PSFILES)
 %.html: %.sgml
        $(SGML2HTML) $<
 
+%.txt: %.html
+       lynx -nolist -dump $< > $@
+
 install:
        install -m 0644 $(shell echo *.tex) $(DESTDIR)$(DOCDIR)
        install -m 0644 $(shell echo *.sgml) $(DESTDIR)$(DOCDIR)
 
 clean:
-       rm -f *.aux *.log *.toc $(PSFILES) $(DVIFILES) *.html
+       rm -f *.aux *.log *.toc $(PSFILES) $(DVIFILES) *.html $(TXTFILES)
--- a/include/linux/pkt_sched.h
+++ b/include/linux/pkt_sched.h
@@ -1,3 +1,409 @@
+#if 0
+#ifndef __LINUX_PKT_SCHED_H
+#define __LINUX_PKT_SCHED_H
+
+/* Logical priority bands not depending on specific packet scheduler.
+   Every scheduler will map them to real traffic classes, if it has
+   no more precise mechanism to classify packets.
+
+   These numbers have no special meaning, though their coincidence
+   with obsolete IPv6 values is not occasional :-). New IPv6 drafts
+   preferred full anarchy inspired by diffserv group.
+
+   Note: TC_PRIO_BESTEFFORT does not mean that it is the most unhappy
+   class, actually, as rule it will be handled with more care than
+   filler or even bulk.
+ */
+
+#define TC_PRIO_BESTEFFORT             0
+#define TC_PRIO_FILLER                 1
+#define TC_PRIO_BULK                   2
+#define TC_PRIO_INTERACTIVE_BULK       4
+#define TC_PRIO_INTERACTIVE            6
+#define TC_PRIO_CONTROL                        7
+
+#define TC_PRIO_MAX                    15
+
+/* Generic queue statistics, available for all the elements.
+   Particular schedulers may have also their private records.
+ */
+
+struct tc_stats
+{
+       __u64   bytes;                  /* NUmber of enqueues bytes */
+       __u32   packets;                /* Number of enqueued packets   */
+       __u32   drops;                  /* Packets dropped because of lack of resources */
+       __u32   overlimits;             /* Number of throttle events when this
+                                        * flow goes out of allocated bandwidth */
+       __u32   bps;                    /* Current flow byte rate */
+       __u32   pps;                    /* Current flow packet rate */
+       __u32   qlen;
+       __u32   backlog;
+#ifdef __KERNEL__
+       spinlock_t *lock;
+#endif
+};
+
+struct tc_estimator
+{
+       char            interval;
+       unsigned char   ewma_log;
+};
+
+/* "Handles"
+   ---------
+
+    All the traffic control objects have 32bit identifiers, or "handles".
+
+    They can be considered as opaque numbers from user API viewpoint,
+    but actually they always consist of two fields: major and
+    minor numbers, which are interpreted by kernel specially,
+    that may be used by applications, though not recommended.
+
+    F.e. qdisc handles always have minor number equal to zero,
+    classes (or flows) have major equal to parent qdisc major, and
+    minor uniquely identifying class inside qdisc.
+
+    Macros to manipulate handles:
+ */
+
+#define TC_H_MAJ_MASK (0xFFFF0000U)
+#define TC_H_MIN_MASK (0x0000FFFFU)
+#define TC_H_MAJ(h) ((h)&TC_H_MAJ_MASK)
+#define TC_H_MIN(h) ((h)&TC_H_MIN_MASK)
+#define TC_H_MAKE(maj,min) (((maj)&TC_H_MAJ_MASK)|((min)&TC_H_MIN_MASK))
+
+#define TC_H_UNSPEC    (0U)
+#define TC_H_ROOT      (0xFFFFFFFFU)
+#define TC_H_INGRESS    (0xFFFFFFF1U)
+
+struct tc_ratespec
+{
+       unsigned char   cell_log;
+       unsigned char   __reserved;
+       unsigned short  feature;
+       short           addend;
+       unsigned short  mpu;
+       __u32           rate;
+};
+
+/* FIFO section */
+
+struct tc_fifo_qopt
+{
+       __u32   limit;  /* Queue length: bytes for bfifo, packets for pfifo */
+};
+
+/* PRIO section */
+
+#define TCQ_PRIO_BANDS 16
+
+struct tc_prio_qopt
+{
+       int     bands;                  /* Number of bands */
+       __u8    priomap[TC_PRIO_MAX+1]; /* Map: logical priority -> PRIO band */
+};
+
+/* CSZ section */
+
+struct tc_csz_qopt
+{
+       int             flows;          /* Maximal number of guaranteed flows */
+       unsigned char   R_log;          /* Fixed point position for round number */
+       unsigned char   delta_log;      /* Log of maximal managed time interval */
+       __u8            priomap[TC_PRIO_MAX+1]; /* Map: logical priority -> CSZ band */
+};
+
+struct tc_csz_copt
+{
+       struct tc_ratespec slice;
+       struct tc_ratespec rate;
+       struct tc_ratespec peakrate;
+       __u32           limit;
+       __u32           buffer;
+       __u32           mtu;
+};
+
+enum
+{
+       TCA_CSZ_UNSPEC,
+       TCA_CSZ_PARMS,
+       TCA_CSZ_RTAB,
+       TCA_CSZ_PTAB,
+};
+
+/* TBF section */
+
+struct tc_tbf_qopt
+{
+       struct tc_ratespec rate;
+       struct tc_ratespec peakrate;
+       __u32           limit;
+       __u32           buffer;
+       __u32           mtu;
+};
+
+enum
+{
+       TCA_TBF_UNSPEC,
+       TCA_TBF_PARMS,
+       TCA_TBF_RTAB,
+       TCA_TBF_PTAB,
+};
+
+
+/* TEQL section */
+
+/* TEQL does not require any parameters */
+
+/* SFQ section */
+
+struct tc_sfq_qopt
+{
+       unsigned        quantum;        /* Bytes per round allocated to flow */
+       int             perturb_period; /* Period of hash perturbation */
+       __u32           limit;          /* Maximal packets in queue */
+       unsigned        divisor;        /* Hash divisor  */
+       unsigned        flows;          /* Maximal number of flows  */
+};
+
+/*
+ *  NOTE: limit, divisor and flows are hardwired to code at the moment.
+ *
+ *     limit=flows=128, divisor=1024;
+ *
+ *     The only reason for this is efficiency, it is possible
+ *     to change these parameters in compile time.
+ */
+
+/* RED section */
+
+enum
+{
+       TCA_RED_UNSPEC,
+       TCA_RED_PARMS,
+       TCA_RED_STAB,
+};
+
+struct tc_red_qopt
+{
+       __u32           limit;          /* HARD maximal queue length (bytes)    */
+       __u32           qth_min;        /* Min average length threshold (bytes) */
+       __u32           qth_max;        /* Max average length threshold (bytes) */
+       unsigned char   Wlog;           /* log(W)               */
+       unsigned char   Plog;           /* log(P_max/(qth_max-qth_min)) */
+       unsigned char   Scell_log;      /* cell size for idle damping */
+       unsigned char   flags;
+#define TC_RED_ECN     1
+};
+
+struct tc_red_xstats
+{
+       __u32           early;          /* Early drops */
+       __u32           pdrop;          /* Drops due to queue limits */
+       __u32           other;          /* Drops due to drop() calls */
+       __u32           marked;         /* Marked packets */
+};
+
+/* GRED section */
+
+#define MAX_DPs 16
+
+enum
+{
+       TCA_GRED_UNSPEC,
+       TCA_GRED_PARMS,
+       TCA_GRED_STAB,
+       TCA_GRED_DPS,
+};
+
+#define TCA_SET_OFF TCA_GRED_PARMS
+struct tc_gred_qopt
+{
+       __u32           limit;          /* HARD maximal queue length (bytes)
+*/
+       __u32           qth_min;        /* Min average length threshold (bytes)
+*/
+       __u32           qth_max;        /* Max average length threshold (bytes)
+*/
+       __u32           DP;             /* upto 2^32 DPs */
+       __u32           backlog;
+       __u32           qave;
+       __u32           forced;
+       __u32           early;
+       __u32           other;
+       __u32           pdrop;
+
+       unsigned char   Wlog;           /* log(W)               */
+       unsigned char   Plog;           /* log(P_max/(qth_max-qth_min)) */
+       unsigned char   Scell_log;      /* cell size for idle damping */
+       __u8            prio;           /* prio of this VQ */
+       __u32   packets;
+       __u32   bytesin;
+};
+/* gred setup */
+struct tc_gred_sopt
+{
+       __u32           DPs;
+       __u32           def_DP;
+       __u8            grio;
+};
+
+/* HTB section */
+#define TC_HTB_NUMPRIO         8
+#define TC_HTB_MAXDEPTH                8
+#define TC_HTB_PROTOVER                3 /* the same as HTB and TC's major */
+
+struct tc_htb_opt
+{
+       struct tc_ratespec      rate;
+       struct tc_ratespec      ceil;
+       __u32   buffer;
+       __u32   cbuffer;
+       __u32   quantum;
+       __u32   level;          /* out only */
+       __u32   prio;
+};
+struct tc_htb_glob
+{
+       __u32 version;          /* to match HTB/TC */
+       __u32 rate2quantum;     /* bps->quantum divisor */
+       __u32 defcls;           /* default class number */
+       __u32 debug;            /* debug flags */
+
+       /* stats */
+       __u32 direct_pkts; /* count of non shapped packets */
+};
+enum
+{
+       TCA_HTB_UNSPEC,
+       TCA_HTB_PARMS,
+       TCA_HTB_INIT,
+       TCA_HTB_CTAB,
+       TCA_HTB_RTAB,
+};
+struct tc_htb_xstats
+{
+       __u32 lends;
+       __u32 borrows;
+       __u32 giants;   /* too big packets (rate will not be accurate) */
+       __u32 tokens;
+       __u32 ctokens;
+};
+
+/* CBQ section */
+
+#define TC_CBQ_MAXPRIO         8
+#define TC_CBQ_MAXLEVEL                8
+#define TC_CBQ_DEF_EWMA                5
+
+struct tc_cbq_lssopt
+{
+       unsigned char   change;
+       unsigned char   flags;
+#define TCF_CBQ_LSS_BOUNDED    1
+#define TCF_CBQ_LSS_ISOLATED   2
+       unsigned char   ewma_log;
+       unsigned char   level;
+#define TCF_CBQ_LSS_FLAGS      1
+#define TCF_CBQ_LSS_EWMA       2
+#define TCF_CBQ_LSS_MAXIDLE    4
+#define TCF_CBQ_LSS_MINIDLE    8
+#define TCF_CBQ_LSS_OFFTIME    0x10
+#define TCF_CBQ_LSS_AVPKT      0x20
+       __u32           maxidle;
+       __u32           minidle;
+       __u32           offtime;
+       __u32           avpkt;
+};
+
+struct tc_cbq_wrropt
+{
+       unsigned char   flags;
+       unsigned char   priority;
+       unsigned char   cpriority;
+       unsigned char   __reserved;
+       __u32           allot;
+       __u32           weight;
+};
+
+struct tc_cbq_ovl
+{
+       unsigned char   strategy;
+#define        TC_CBQ_OVL_CLASSIC      0
+#define        TC_CBQ_OVL_DELAY        1
+#define        TC_CBQ_OVL_LOWPRIO      2
+#define        TC_CBQ_OVL_DROP         3
+#define        TC_CBQ_OVL_RCLASSIC     4
+       unsigned char   priority2;
+       __u32           penalty;
+};
+
+struct tc_cbq_police
+{
+       unsigned char   police;
+       unsigned char   __res1;
+       unsigned short  __res2;
+};
+
+struct tc_cbq_fopt
+{
+       __u32           split;
+       __u32           defmap;
+       __u32           defchange;
+};
+
+struct tc_cbq_xstats
+{
+       __u32           borrows;
+       __u32           overactions;
+       __s32           avgidle;
+       __s32           undertime;
+};
+
+enum
+{
+       TCA_CBQ_UNSPEC,
+       TCA_CBQ_LSSOPT,
+       TCA_CBQ_WRROPT,
+       TCA_CBQ_FOPT,
+       TCA_CBQ_OVL_STRATEGY,
+       TCA_CBQ_RATE,
+       TCA_CBQ_RTAB,
+       TCA_CBQ_POLICE,
+};
+
+#define TCA_CBQ_MAX    TCA_CBQ_POLICE
+
+/* dsmark section */
+
+enum {
+       TCA_DSMARK_UNSPEC,
+       TCA_DSMARK_INDICES,
+       TCA_DSMARK_DEFAULT_INDEX,
+       TCA_DSMARK_SET_TC_INDEX,
+       TCA_DSMARK_MASK,
+       TCA_DSMARK_VALUE
+};
+
+#define TCA_DSMARK_MAX TCA_DSMARK_VALUE
+
+/* ATM  section */
+
+enum {
+       TCA_ATM_UNSPEC,
+       TCA_ATM_FD,             /* file/socket descriptor */
+       TCA_ATM_PTR,            /* pointer to descriptor - later */
+       TCA_ATM_HDR,            /* LL header */
+       TCA_ATM_EXCESS,         /* excess traffic class (0 for CLP)  */
+       TCA_ATM_ADDR,           /* PVC address (for output only) */
+       TCA_ATM_STATE           /* VC state (ATM_VS_*; for output only) */
+};
+
+#define TCA_ATM_MAX    TCA_ATM_STATE
+
+#endif
+#endif
 #ifndef __LINUX_PKT_SCHED_H
 #define __LINUX_PKT_SCHED_H
 
@@ -481,4 +887,116 @@ struct tc_drr_stats {
        __u32   deficit;
 };
 
+/* WRR section */
+
+/* Other includes */
+#include <linux/if_ether.h>
+
+// A sub weight and of a class
+// All numbers are represented as parts of (2^64-1).
+struct tc_wrr_class_weight {
+       __u64 val;      // Current value                        (0 is not valid)
+       __u64 decr;     // Value pr bytes                       (2^64-1 is not valid)
+       __u64 incr;     // Value pr seconds                     (2^64-1 is not valid)
+       __u64 min;      // Minimal value                        (0 is not valid)
+       __u64 max;      // Minimal value                        (0 is not valid)
+
+// The time where the above information was correct:
+       time_t tim;
+};
+
+// Packet send when modifying a class:
+struct tc_wrr_class_modf {
+       // Not-valid values are ignored.
+       struct tc_wrr_class_weight weight1;
+       struct tc_wrr_class_weight weight2;
+};
+
+// Packet returned when quering a class:
+struct tc_wrr_class_stats {
+       char used;      // If this is false the information below is invalid
+
+       struct tc_wrr_class_modf class_modf;
+
+       unsigned char addr[ETH_ALEN];
+       char usemac;    // True if addr is a MAC address, else it is an IP address
+                       // (this value is only for convience, it is always the same
+                       //  value as in the qdisc)
+       int heappos;    // Current heap position or 0 if not in heap
+       __u64 penal_ls; // Penalty value in heap (ls)
+       __u64 penal_ms; // Penalty value in heap (ms)
+};
+
+// Qdisc-wide penalty information (boolean values - 2 not valid)
+struct tc_wrr_qdisc_weight {
+       char weight_mode;       // 0=No automatic change to weight
+                               // 1=Decrease normally
+                               // 2=Also multiply with number of machines
+                               // 3=Instead multiply with priority divided
+                               //   with priority of the other.
+                               // -1=no change
+};
+
+// Packet send when modifing a qdisc:
+struct tc_wrr_qdisc_modf {
+       // Not-valid values are ignored:
+       struct tc_wrr_qdisc_weight weight1;
+       struct tc_wrr_qdisc_weight weight2;
+};
+
+// Packet send when creating a qdisc:
+struct tc_wrr_qdisc_crt {
+       struct tc_wrr_qdisc_modf qdisc_modf;
+
+       char srcaddr;   // 1=lookup source, 0=lookup destination
+       char usemac;    // 1=Classify on MAC addresses, 0=classify on IP
+       char usemasq;   // 1=Classify based on masqgrading - only valid
+                       //   if usemac is zero
+       int bands_max;  // Maximal number of bands (i.e.: classes)
+       int proxy_maxconn;// If differnt from 0 then we support proxy remapping
+                       // of packets. And this is the number of maximal
+                       // concurrent proxy connections.
+};
+
+// Packet returned when quering a qdisc:
+struct tc_wrr_qdisc_stats {
+       struct tc_wrr_qdisc_crt qdisc_crt;
+       int proxy_curconn;
+       int nodes_in_heap;      // Current number of bands wanting to send something
+       int bands_cur;          // Current number of bands used (i.e.: MAC/IP addresses seen)
+       int bands_reused;       // Number of times this band has been reused.
+       int packets_requed;     // Number of times packets have been requeued.
+       __u64 priosum;          // Sum of priorities in heap where 1 is 2^32
+};
+
+struct tc_wrr_qdisc_modf_std {
+       // This indicates which of the tc_wrr_qdisc_modf structers this is:
+       char proxy; // 0=This struct
+
+       // Should we also change a class?
+       char change_class;
+
+       // Only valid if change_class is false
+       struct tc_wrr_qdisc_modf qdisc_modf;
+
+       // Only valid if change_class is true:
+       unsigned char addr[ETH_ALEN]; // Class to change (non-used bytes should be 0)
+       struct tc_wrr_class_modf class_modf; // The change
+};
+
+// Used for proxyrempping:
+struct tc_wrr_qdisc_modf_proxy {
+       // This indicates which of the tc_wrr_qdisc_modf structers this is:
+       char proxy;     // 1=This struct
+
+       // This is 1 if the proxyremap information should be reset
+       char reset;
+
+       // changec is the number of elements in changes.
+       int changec;
+
+       // This is an array of type ProxyRemapBlock:
+       long changes[0];
+};
+
 #endif
--- a/ip/iptunnel.c
+++ b/ip/iptunnel.c
@@ -130,7 +130,7 @@ static int parse_args(int argc, char **a
                        NEXT_ARG();
                        p->o_flags |= GRE_KEY;
                        if (strchr(*argv, '.'))
-                               p->o_key = get_addr32(*argv);
+                               p->i_key = get_addr32(*argv);
                        else {
                                if (get_unsigned(&uval, *argv, 0)<0) {
                                        fprintf(stderr, "invalid value of \"okey\"\n");
--- a/Makefile
+++ b/Makefile
@@ -57,7 +57,7 @@ install: all
                $(DESTDIR)$(DOCDIR)/examples
        install -m 0644 $(shell find examples/diffserv -maxdepth 1 -type f) \
                $(DESTDIR)$(DOCDIR)/examples/diffserv
-       @for i in $(SUBDIRS) doc; do $(MAKE) -C $$i install; done
+       @set -e; for i in $(SUBDIRS) doc; do $(MAKE) -C $$i install; done
        install -m 0644 $(shell find etc/iproute2 -maxdepth 1 -type f) $(DESTDIR)$(CONFDIR)
        install -m 0755 -d $(DESTDIR)$(MANDIR)/man8
        install -m 0644 $(shell find man/man8 -maxdepth 1 -type f) $(DESTDIR)$(MANDIR)/man8
@@ -75,7 +75,7 @@ snapshot:
 
 clean:
        rm -f cscope.*
-       @for i in $(SUBDIRS) doc; \
+       @set -e; for i in $(SUBDIRS) doc; \
        do $(MAKE) $(MFLAGS) -C $$i clean; done
 
 clobber: clean
--- a/misc/Makefile
+++ b/misc/Makefile
@@ -1,7 +1,8 @@
 SSOBJ=ss.o ssfilter.o
 LNSTATOBJ=lnstat.o lnstat_util.o
 
-TARGETS=ss nstat ifstat rtacct arpd lnstat
+#TARGETS=ss nstat ifstat rtacct arpd lnstat
+TARGETS=ss nstat rtacct lnstat
 
 include ../Config
 
--- a/tc/Makefile
+++ b/tc/Makefile
@@ -15,6 +15,7 @@ TCMODULES += q_cbq.o
 TCMODULES += q_rr.o
 TCMODULES += q_multiq.o
 TCMODULES += q_netem.o
+TCMODULES += q_wrr.o
 TCMODULES += q_choke.o
 TCMODULES += f_rsvp.o
 TCMODULES += f_u32.o
--- a/tc/q_htb.c
+++ b/tc/q_htb.c
@@ -1,3 +1,311 @@
+#if 0
+/*
+ * q_htb.c             HTB.
+ *
+ *             This program is free software; you can redistribute it and/or
+ *             modify it under the terms of the GNU General Public License
+ *             as published by the Free Software Foundation; either version
+ *             2 of the License, or (at your option) any later version.
+ *
+ * Authors:    Martin Devera, devik@cdi.cz
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <syslog.h>
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <string.h>
+
+#include "utils.h"
+#include "tc_util.h"
+
+#define HTB_TC_VER 0x30003
+#if HTB_TC_VER >> 16 != TC_HTB_PROTOVER
+#error "Different kernel and TC HTB versions"
+#endif
+
+static void explain(void)
+{
+       fprintf(stderr, "Usage: ... qdisc add ... htb [default N] [r2q N]\n"
+               " default  minor id of class to which unclassified packets are sent {0}\n"
+               " r2q      DRR quantums are computed as rate in Bps/r2q {10}\n"
+               " debug    string of 16 numbers each 0-3 {0}\n\n"
+               "... class add ... htb rate R1 burst B1 [prio P] [slot S] [pslot PS]\n"
+               "                      [ceil R2] [cburst B2] [mtu MTU] [quantum Q]\n"
+               " rate     rate allocated to this class (class can still borrow)\n"
+               " burst    max bytes burst which can be accumulated during idle period {computed}\n"
+               " ceil     definite upper class rate (no borrows) {rate}\n"
+               " cburst   burst but for ceil {computed}\n"
+               " mtu      max packet size we create rate map for {1600}\n"
+               " prio     priority of leaf; lower are served first {0}\n"
+               " quantum  how much bytes to serve from leaf at once {use r2q}\n"
+               "\nTC HTB version %d.%d\n",HTB_TC_VER>>16,HTB_TC_VER&0xffff
+               );
+}
+
+static void explain1(char *arg)
+{
+    fprintf(stderr, "Illegal \"%s\"\n", arg);
+    explain();
+}
+
+
+#define usage() return(-1)
+
+static int htb_parse_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n)
+{
+       struct tc_htb_glob opt;
+       struct rtattr *tail;
+       unsigned i; char *p;
+       memset(&opt,0,sizeof(opt));
+       opt.rate2quantum = 10;
+       opt.version = 3;
+
+       while (argc > 0) {
+               if (matches(*argv, "r2q") == 0) {
+                   NEXT_ARG();
+                   if (get_u32(&opt.rate2quantum, *argv, 10)) {
+                       explain1("r2q"); return -1;
+                   }
+               } else if (matches(*argv, "default") == 0) {
+                   NEXT_ARG();
+                   if (get_u32(&opt.defcls, *argv, 16)) {
+                       explain1("default"); return -1;
+                   }
+               } else if (matches(*argv, "debug") == 0) {
+                   NEXT_ARG(); p = *argv;
+                   for (i=0; i<16; i++,p++) {
+                       if (*p<'0' || *p>'3') break;
+                       opt.debug |= (*p-'0')<<(2*i);
+                   }
+               } else {
+                       fprintf(stderr, "What is \"%s\"?\n", *argv);
+                       explain();
+                       return -1;
+               }
+               argc--; argv++;
+       }
+       tail = (struct rtattr*)(((void*)n)+NLMSG_ALIGN(n->nlmsg_len));
+       addattr_l(n, 1024, TCA_OPTIONS, NULL, 0);
+       addattr_l(n, 2024, TCA_HTB_INIT, &opt, NLMSG_ALIGN(sizeof(opt)));
+       tail->rta_len = (((void*)n)+NLMSG_ALIGN(n->nlmsg_len)) - (void*)tail;
+       return 0;
+}
+
+static int htb_parse_class_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n)
+{
+       int ok=0;
+       struct tc_htb_opt opt;
+       __u32 rtab[256],ctab[256];
+       unsigned buffer=0,cbuffer=0;
+       int cell_log=-1,ccell_log = -1,mtu;
+       struct rtattr *tail;
+
+       memset(&opt, 0, sizeof(opt)); mtu = 1600; /* eth packet len */
+
+       while (argc > 0) {
+               if (matches(*argv, "prio") == 0) {
+                       NEXT_ARG();
+                       if (get_u32(&opt.prio, *argv, 10)) {
+                               explain1("prio"); return -1;
+                       }
+                       ok++;
+               } else if (matches(*argv, "mtu") == 0) {
+                       NEXT_ARG();
+                       if (get_u32(&mtu, *argv, 10)) {
+                               explain1("mtu"); return -1;
+                       }
+               } else if (matches(*argv, "quantum") == 0) {
+                       NEXT_ARG();
+                       if (get_u32(&opt.quantum, *argv, 10)) {
+                               explain1("quantum"); return -1;
+                       }
+               } else if (matches(*argv, "burst") == 0 ||
+                       strcmp(*argv, "buffer") == 0 ||
+                       strcmp(*argv, "maxburst") == 0) {
+                       NEXT_ARG();
+                       if (get_size_and_cell(&buffer, &cell_log, *argv) < 0) {
+                               explain1("buffer");
+                               return -1;
+                       }
+                       ok++;
+               } else if (matches(*argv, "cburst") == 0 ||
+                       strcmp(*argv, "cbuffer") == 0 ||
+                       strcmp(*argv, "cmaxburst") == 0) {
+                       NEXT_ARG();
+                       if (get_size_and_cell(&cbuffer, &ccell_log, *argv) < 0) {
+                               explain1("cbuffer");
+                               return -1;
+                       }
+                       ok++;
+               } else if (strcmp(*argv, "ceil") == 0) {
+                       NEXT_ARG();
+                       if (opt.ceil.rate) {
+                               fprintf(stderr, "Double \"ceil\" spec\n");
+                               return -1;
+                       }
+                       if (get_rate(&opt.ceil.rate, *argv)) {
+                               explain1("ceil");
+                               return -1;
+                       }
+                       ok++;
+               } else if (strcmp(*argv, "rate") == 0) {
+                       NEXT_ARG();
+                       if (opt.rate.rate) {
+                               fprintf(stderr, "Double \"rate\" spec\n");
+                               return -1;
+                       }
+                       if (get_rate(&opt.rate.rate, *argv)) {
+                               explain1("rate");
+                               return -1;
+                       }
+                       ok++;
+               } else if (strcmp(*argv, "help") == 0) {
+                       explain();
+                       return -1;
+               } else {
+                       fprintf(stderr, "What is \"%s\"?\n", *argv);
+                       explain();
+                       return -1;
+               }
+               argc--; argv++;
+       }
+
+/*     if (!ok)
+               return 0;*/
+
+       if (opt.rate.rate == 0) {
+               fprintf(stderr, "\"rate\" is required.\n");
+               return -1;
+       }
+       /* if ceil params are missing, use the same as rate */
+       if (!opt.ceil.rate) opt.ceil = opt.rate;
+
+       /* compute minimal allowed burst from rate; mtu is added here to make
+          sute that buffer is larger than mtu and to have some safeguard space */
+       if (!buffer) buffer = opt.rate.rate / HZ + mtu;
+       if (!cbuffer) cbuffer = opt.ceil.rate / HZ + mtu;
+
+       if ((cell_log = tc_calc_rtable(opt.rate.rate, rtab, cell_log, mtu, 0)) < 0) {
+               fprintf(stderr, "htb: failed to calculate rate table.\n");
+               return -1;
+       }
+       opt.buffer = tc_calc_xmittime(opt.rate.rate, buffer);
+       opt.rate.cell_log = cell_log;
+
+       if ((ccell_log = tc_calc_rtable(opt.ceil.rate, ctab, cell_log, mtu, 0)) < 0) {
+               fprintf(stderr, "htb: failed to calculate ceil rate table.\n");
+               return -1;
+       }
+       opt.cbuffer = tc_calc_xmittime(opt.ceil.rate, cbuffer);
+       opt.ceil.cell_log = ccell_log;
+
+       tail = (struct rtattr*)(((void*)n)+NLMSG_ALIGN(n->nlmsg_len));
+       addattr_l(n, 1024, TCA_OPTIONS, NULL, 0);
+       addattr_l(n, 2024, TCA_HTB_PARMS, &opt, sizeof(opt));
+       addattr_l(n, 3024, TCA_HTB_RTAB, rtab, 1024);
+       addattr_l(n, 4024, TCA_HTB_CTAB, ctab, 1024);
+       tail->rta_len = (((void*)n)+NLMSG_ALIGN(n->nlmsg_len)) - (void*)tail;
+       return 0;
+}
+
+static int htb_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt)
+{
+       struct rtattr *tb[TCA_HTB_RTAB+1];
+       struct tc_htb_opt *hopt;
+       struct tc_htb_glob *gopt;
+       double buffer,cbuffer;
+       SPRINT_BUF(b1);
+       SPRINT_BUF(b2);
+
+       if (opt == NULL)
+               return 0;
+
+       memset(tb, 0, sizeof(tb));
+       parse_rtattr(tb, TCA_HTB_RTAB, RTA_DATA(opt), RTA_PAYLOAD(opt));
+
+       if (tb[TCA_HTB_PARMS]) {
+
+           hopt = RTA_DATA(tb[TCA_HTB_PARMS]);
+           if (RTA_PAYLOAD(tb[TCA_HTB_PARMS])  < sizeof(*hopt)) return -1;
+
+               if (!hopt->level) {
+                       fprintf(f, "prio %d ", (int)hopt->prio);
+                       if (show_details)
+                               fprintf(f, "quantum %d ", (int)hopt->quantum);
+               }
+           fprintf(f, "rate %s ", sprint_rate(hopt->rate.rate, b1));
+           buffer = ((double)hopt->rate.rate*tc_core_tick2usec(hopt->buffer))/1000000;
+           fprintf(f, "ceil %s ", sprint_rate(hopt->ceil.rate, b1));
+           cbuffer = ((double)hopt->ceil.rate*tc_core_tick2usec(hopt->cbuffer))/1000000;
+           if (show_details) {
+               fprintf(f, "burst %s/%u mpu %s ", sprint_size(buffer, b1),
+                       1<<hopt->rate.cell_log, sprint_size(hopt->rate.mpu, b2));
+               fprintf(f, "cburst %s/%u mpu %s ", sprint_size(cbuffer, b1),
+                       1<<hopt->ceil.cell_log, sprint_size(hopt->ceil.mpu, b2));
+               fprintf(f, "level %d ", (int)hopt->level);
+           } else {
+               fprintf(f, "burst %s ", sprint_size(buffer, b1));
+               fprintf(f, "cburst %s ", sprint_size(cbuffer, b1));
+           }
+           if (show_raw)
+               fprintf(f, "buffer [%08x] cbuffer [%08x] ",
+                       hopt->buffer,hopt->cbuffer);
+       }
+       if (tb[TCA_HTB_INIT]) {
+           gopt = RTA_DATA(tb[TCA_HTB_INIT]);
+           if (RTA_PAYLOAD(tb[TCA_HTB_INIT])  < sizeof(*gopt)) return -1;
+
+           fprintf(f, "r2q %d default %x direct_packets_stat %u",
+                   gopt->rate2quantum,gopt->defcls,gopt->direct_pkts);
+               if (show_details)
+                       fprintf(f," ver %d.%d",gopt->version >> 16,gopt->version & 0xffff);
+       }
+       return 0;
+}
+
+static int htb_print_xstats(struct qdisc_util *qu, FILE *f, struct rtattr *xstats)
+{
+       struct tc_htb_xstats *st;
+       if (xstats == NULL)
+               return 0;
+
+       if (RTA_PAYLOAD(xstats) < sizeof(*st))
+               return -1;
+
+       st = RTA_DATA(xstats);
+       fprintf(f, " lended: %u borrowed: %u giants: %u\n",
+               st->lends,st->borrows,st->giants);
+       fprintf(f, " tokens: %d ctokens: %d\n", st->tokens,st->ctokens);
+       return 0;
+}
+
+struct qdisc_util htb_util = {
+       NULL,
+       "htb",
+       htb_parse_opt,
+       htb_print_opt,
+       htb_print_xstats,
+       htb_parse_class_opt,
+       htb_print_opt,
+};
+
+/* for testing of old one */
+struct qdisc_util htb2_util = {
+       NULL,
+       "htb2",
+       htb_parse_opt,
+       htb_print_opt,
+       htb_print_xstats,
+       htb_parse_class_opt,
+       htb_print_opt,
+};
+#endif
 /*
  * q_htb.c             HTB.
  *
--- /dev/null
+++ b/tc/q_wrr.c
@@ -0,0 +1,322 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <syslog.h>
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <string.h>
+#include <math.h>
+
+#include "utils.h"
+#include "tc_util.h"
+
+#define usage() return(-1)
+
+// Returns -1 on error
+static int wrr_parse_qdisc_weight(int argc, char** argv,
+                              struct tc_wrr_qdisc_modf* opt) {
+  int i;
+
+  opt->weight1.weight_mode=-1;
+  opt->weight2.weight_mode=-1;
+
+  for(i=0; i<argc; i++) {
+    if(!memcmp(argv[i],"wmode1=",7)) {
+      opt->weight1.weight_mode=atoi(argv[i]+7);
+    } else if(!memcmp(argv[i],"wmode2=",7)) {
+      opt->weight2.weight_mode=atoi(argv[i]+7);
+    } else {
+      printf("Usage: ... [wmode1=0|1|2|3] [wmode2=0|1|2|3]\n");
+      return -1;
+    }
+  }
+  return 0;
+}
+
+static int wrr_parse_class_modf(int argc, char** argv,
+                                struct tc_wrr_class_modf* modf) {
+  int i;
+
+  if(argc<1) {
+    fprintf(stderr, "Usage: ... [weight1=val] [decr1=val] [incr1=val] [min1=val] [max1=val] [val2=val] ...\n");
+    fprintf(stderr, "  The values can be floating point like 0.42 or divisions like 42/100\n");
+    return -1;
+  }
+
+  // Set meaningless values:
+  modf->weight1.val=0;
+  modf->weight1.decr=(__u64)-1;
+  modf->weight1.incr=(__u64)-1;
+  modf->weight1.min=0;
+  modf->weight1.max=0;
+  modf->weight2.val=0;
+  modf->weight2.decr=(__u64)-1;
+  modf->weight2.incr=(__u64)-1;
+  modf->weight2.min=0;
+  modf->weight2.max=0;
+
+  // And read values:
+  for(i=0; i<argc; i++) {
+    char arg[80];
+    char* name,*value1=0,*value2=0;
+    long double f_val1,f_val2=1,value;
+    if(strlen(argv[i])>=sizeof(arg)) {
+      fprintf(stderr,"Argument too long: %s\n",argv[i]);
+      return -1;
+    }
+    strcpy(arg,argv[i]);
+
+    name=strtok(arg,"=");
+    if(name) value1=strtok(0,"/");
+    if(value1) value2=strtok(0,"");
+
+    if(!value1) {
+      fprintf(stderr,"No = found in argument: %s\n",argv[i]);
+      return -1;
+    }
+
+    f_val1=atof(value1);
+    if(value2) f_val2=atof(value2);
+
+    if(f_val2==0)  {
+      fprintf(stderr,"Division by 0\n");
+      return -1;
+    }
+
+    value=f_val1/f_val2;
+    if(value>1) value=1;
+    if(value<0) value=0;
+    value*=((__u64)-1);
+
+    // And find the value set
+    if(!strcmp(name,"weight1"))    modf->weight1.val=value;
+    else if(!strcmp(name,"decr1")) modf->weight1.decr=value;
+    else if(!strcmp(name,"incr1")) modf->weight1.incr=value;
+    else if(!strcmp(name,"min1"))  modf->weight1.min=value;
+    else if(!strcmp(name,"max1"))  modf->weight1.max=value;
+    else if(!strcmp(name,"weight2")) modf->weight2.val=value;
+    else if(!strcmp(name,"decr2")) modf->weight2.decr=value;
+    else if(!strcmp(name,"incr2")) modf->weight2.incr=value;
+    else if(!strcmp(name,"min2"))  modf->weight2.min=value;
+    else if(!strcmp(name,"max2"))  modf->weight2.max=value;
+    else {
+      fprintf(stderr,"illegal value: %s\n",name);
+      return -1;
+    }
+  }
+
+  return 0;
+}
+
+static int wrr_parse_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n)
+{
+  if(n->nlmsg_flags & NLM_F_CREATE) {
+    // This is a create request:
+    struct tc_wrr_qdisc_crt opt;
+
+    int sour,dest,ip,mac,masq;
+
+    if(argc<4) {
+      fprintf(stderr, "Usage: ... wrr sour|dest ip|masq|mac maxclasses proxymaxcon [penalty-setup]\n");
+      return -1;
+    }
+
+    // Read sour/dest:
+    memset(&opt,0,sizeof(opt));
+    sour=!strcmp(argv[0],"sour");
+    dest=!strcmp(argv[0],"dest");
+
+    if(!sour && !dest) {
+      fprintf(stderr,"sour or dest must be specified\n");
+      return -1;
+    }
+
+    // Read ip/mac
+    ip=!strcmp(argv[1],"ip");
+    mac=!strcmp(argv[1],"mac");
+    masq=!strcmp(argv[1],"masq");
+
+    if(!ip && !mac && !masq) {
+      fprintf(stderr,"ip, masq or mac must be specified\n");
+      return -1;
+    }
+
+    opt.srcaddr=sour;
+    opt.usemac=mac;
+    opt.usemasq=masq;
+    opt.bands_max=atoi(argv[2]);
+
+    opt.proxy_maxconn=atoi(argv[3]);
+
+    // Read weights:
+    if(wrr_parse_qdisc_weight(argc-4,argv+4,&opt.qdisc_modf)<0) return -1;
+    if(opt.qdisc_modf.weight1.weight_mode==-1) opt.qdisc_modf.weight1.weight_mode=0;
+    if(opt.qdisc_modf.weight2.weight_mode==-1) opt.qdisc_modf.weight2.weight_mode=0;
+
+    addattr_l(n, 1024, TCA_OPTIONS, &opt, sizeof(opt));
+  } else {
+    struct tc_wrr_qdisc_modf_std opt;
+    char qdisc,class;
+
+    // This is a modify request:
+    if(argc<1) {
+      fprintf(stderr,"... qdisc ... or ... class ...\n");
+      return -1;
+    }
+
+    qdisc=!strcmp(argv[0],"qdisc");
+    class=!strcmp(argv[0],"class");
+
+    if(!qdisc && !class) {
+      fprintf(stderr,"qdisc or class must be specified\n");
+      return -1;
+    }
+
+    argc--;
+    argv++;
+
+    opt.proxy=0;
+
+    if(qdisc) {
+      opt.change_class=0;
+      if(wrr_parse_qdisc_weight(argc, argv, &opt.qdisc_modf)<0) return -1;
+    } else {
+      int a0,a1,a2,a3,a4=0,a5=0;
+
+      opt.change_class=1;
+
+      if(argc<1) {
+        fprintf(stderr,"... <mac>|<ip>|<masq> ...\n");
+        return -1;
+      }
+      memset(opt.addr,0,sizeof(opt.addr));
+
+      if((sscanf(argv[0],"%i.%i.%i.%i",&a0,&a1,&a2,&a3)!=4) &&
+         (sscanf(argv[0],"%x:%x:%x:%x:%x:%x",&a0,&a1,&a2,&a3,&a4,&a5)!=6)) {
+       fprintf(stderr,"Wrong format of mac or ip address\n");
+       return -1;
+      }
+
+      opt.addr[0]=a0; opt.addr[1]=a1; opt.addr[2]=a2;
+      opt.addr[3]=a3; opt.addr[4]=a4; opt.addr[5]=a5;
+
+      if(wrr_parse_class_modf(argc-1, argv+1, &opt.class_modf)<0) return -1;
+    }
+
+    addattr_l(n, 1024, TCA_OPTIONS, &opt, sizeof(opt));
+  }
+  return 0;
+}
+
+static int wrr_parse_copt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n) {
+  struct tc_wrr_class_modf opt;
+
+  memset(&opt,0,sizeof(opt));
+  if(wrr_parse_class_modf(argc,argv,&opt)<0) return -1;
+
+  addattr_l(n, 1024, TCA_OPTIONS, &opt, sizeof(opt));
+  return 0;
+}
+
+static int wrr_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt)
+{
+       struct tc_wrr_qdisc_stats *qopt;
+
+       if (opt == NULL)
+               return 0;
+
+       if (RTA_PAYLOAD(opt)  < sizeof(*qopt))
+               return -1;
+       qopt = RTA_DATA(opt);
+
+       fprintf(f,"\n  (%s/%s) (maxclasses %i) (usedclasses %i) (reused classes %i)\n",
+         qopt->qdisc_crt.srcaddr ? "sour" : "dest",
+         qopt->qdisc_crt.usemac  ? "mac"  : (qopt->qdisc_crt.usemasq ? "masq" : "ip"),
+         qopt->qdisc_crt.bands_max,
+         qopt->bands_cur,
+         qopt->bands_reused
+         );
+
+       if(qopt->qdisc_crt.proxy_maxconn) {
+         fprintf(f,"  (proxy maxcon %i) (proxy curcon %i)\n",
+           qopt->qdisc_crt.proxy_maxconn,qopt->proxy_curconn);
+       }
+
+       fprintf(f,"  (waiting classes %i) (packets requeued %i) (priosum: %Lg)\n",
+         qopt->nodes_in_heap,
+         qopt->packets_requed,
+         qopt->priosum/((long double)((__u32)-1))
+         );
+
+       fprintf(f,"  (wmode1 %i) (wmode2 %i) \n",
+         qopt->qdisc_crt.qdisc_modf.weight1.weight_mode,
+         qopt->qdisc_crt.qdisc_modf.weight2.weight_mode);
+
+       return 0;
+}
+
+static int wrr_print_copt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) {
+  struct tc_wrr_class_stats *copt;
+  long double d=(__u64)-1;
+
+  if (opt == NULL) return 0;
+
+  if (RTA_PAYLOAD(opt)  < sizeof(*copt))
+    return -1;
+  copt = RTA_DATA(opt);
+
+  if(!copt->used) {
+    fprintf(f,"(unused)");
+    return 0;
+  }
+
+  if(copt->usemac) {
+    fprintf(f,"\n  (address: %.2X:%.2X:%.2X:%.2X:%.2X:%.2X)\n",
+      copt->addr[0],copt->addr[1],copt->addr[2],
+      copt->addr[3],copt->addr[4],copt->addr[5]);
+  } else {
+    fprintf(f,"\n  (address: %i.%i.%i.%i)\n",copt->addr[0],copt->addr[1],copt->addr[2],copt->addr[3]);
+  }
+
+  fprintf(f,"  (total weight: %Lg) (current position: %i) (counters: %u %u : %u %u)\n",
+    (copt->class_modf.weight1.val/d)*(copt->class_modf.weight2.val/d),
+    copt->heappos,
+    (unsigned)(copt->penal_ms>>32),
+    (unsigned)(copt->penal_ms & 0xffffffffU),
+    (unsigned)(copt->penal_ls>>32),
+    (unsigned)(copt->penal_ls & 0xffffffffU)
+    );
+
+  fprintf(f,"  Pars 1: (weight %Lg) (decr: %Lg) (incr: %Lg) (min: %Lg) (max: %Lg)\n",
+    copt->class_modf.weight1.val/d,
+    copt->class_modf.weight1.decr/d,
+    copt->class_modf.weight1.incr/d,
+    copt->class_modf.weight1.min/d,
+    copt->class_modf.weight1.max/d);
+
+  fprintf(f,"  Pars 2: (weight %Lg) (decr: %Lg) (incr: %Lg) (min: %Lg) (max: %Lg)",
+    copt->class_modf.weight2.val/d,
+    copt->class_modf.weight2.decr/d,
+    copt->class_modf.weight2.incr/d,
+    copt->class_modf.weight2.min/d,
+    copt->class_modf.weight2.max/d);
+
+  return 0;
+}
+
+static int wrr_print_xstats(struct qdisc_util *qu, FILE *f, struct rtattr *xstats)
+{
+       return 0;
+}
+
+
+struct qdisc_util wrr_qdisc_util = {
+       .id = "wrr",
+       .parse_qopt = wrr_parse_opt,
+       .print_qopt = wrr_print_opt,
+       .print_xstats = wrr_print_xstats,
+       .parse_copt = wrr_parse_copt,
+       .print_copt = wrr_print_copt
+};