package/iproute2/patches/000-debian_patches_3.patch

   1 --- a/doc/ip-cref.tex
   2 +++ b/doc/ip-cref.tex
   3 @@ -1324,6 +1324,19 @@ peers are allowed to send to us.
   4      If it is not given, Linux uses the value selected with \verb|sysctl|
   5      variable \verb|net/ipv4/tcp_reordering|.
   6
   7 +\item \verb|hoplimit NUMBER|
   8 +
   9 +--- [2.5.74+ only] Hop limit on the path to this destination. If it is not
  10 +    given, Linux uses the value selected with \verb|sysctl| variable
  11 +    \verb|net/ipv4/ip_default_ttl|.
  12 +
  13 +\item \verb|initcwnd NUMBER|
  14 +
  15 +--- [2.5.70+ only] Initial congestion window size when establishing
  16 +    connections to this destination. This value is multiplied with the
  17 +    MSS (``Maximal Segment Size'') for the connection to get the actual
  18 +    window size. If it is not given (or set to zero), Linux uses the
  19 +    values specified in~\cite{RFC2414}.
  20
  21
  22  \item \verb|nexthop NEXTHOP|
  23 @@ -2653,6 +2666,9 @@ http://www.cisco.com/univercd/cc/td/doc/
  24  \bibitem{RFC-DHCP} R.~Droms.
  25  ``Dynamic Host Configuration Protocol.'', RFC-2131
  26
  27 +\bibitem{RFC2414}  M.~Allman, S.~Floyd, C.~Partridge.
  28 +``Increasing TCP's Initial Window'', RFC-2414.
  29 +
  30  \end{thebibliography}
  31
  32
  33 --- a/doc/Makefile
  34 +++ b/doc/Makefile
  35 @@ -14,6 +14,7 @@ PAGESIZE=a4
  36  PAGESPERPAGE=2
  37
  38  HTMLFILES=$(subst .sgml,.html,$(shell echo *.sgml))
  39 +TXTFILES=$(subst .sgml,.txt,$(shell echo *.sgml))
  40  DVIFILES=$(subst .ps,.dvi,$(PSFILES))
  41
  42
  43 @@ -23,6 +24,8 @@ pstwocol: $(PSFILES)
  44
  45  html: $(HTMLFILES)
  46
  47 +txt: $(TXTFILES)
  48 +
  49  dvi: $(DVIFILES)
  50
  51  print: $(PSFILES)
  52 @@ -47,9 +50,12 @@ print: $(PSFILES)
  53  %.html: %.sgml
  54         $(SGML2HTML) $<
  55
  56 +%.txt: %.html
  57 +       lynx -nolist -dump $< > $@
  58 +
  59  install:
  60         install -m 0644 $(shell echo *.tex) $(DESTDIR)$(DOCDIR)
  61         install -m 0644 $(shell echo *.sgml) $(DESTDIR)$(DOCDIR)
  62
  63  clean:
  64 -       rm -f *.aux *.log *.toc $(PSFILES) $(DVIFILES) *.html
  65 +       rm -f *.aux *.log *.toc $(PSFILES) $(DVIFILES) *.html $(TXTFILES)
  66 --- a/include/linux/pkt_sched.h
  67 +++ b/include/linux/pkt_sched.h
  68 @@ -1,3 +1,409 @@
  69 +#if 0
  70 +#ifndef __LINUX_PKT_SCHED_H
  71 +#define __LINUX_PKT_SCHED_H
  72 +
  73 +/* Logical priority bands not depending on specific packet scheduler.
  74 +   Every scheduler will map them to real traffic classes, if it has
  75 +   no more precise mechanism to classify packets.
  76 +
  77 +   These numbers have no special meaning, though their coincidence
  78 +   with obsolete IPv6 values is not occasional :-). New IPv6 drafts
  79 +   preferred full anarchy inspired by diffserv group.
  80 +
  81 +   Note: TC_PRIO_BESTEFFORT does not mean that it is the most unhappy
  82 +   class, actually, as rule it will be handled with more care than
  83 +   filler or even bulk.
  84 + */
  85 +
  86 +#define TC_PRIO_BESTEFFORT             0
  87 +#define TC_PRIO_FILLER                 1
  88 +#define TC_PRIO_BULK                   2
  89 +#define TC_PRIO_INTERACTIVE_BULK       4
  90 +#define TC_PRIO_INTERACTIVE            6
  91 +#define TC_PRIO_CONTROL                        7
  92 +
  93 +#define TC_PRIO_MAX                    15
  94 +
  95 +/* Generic queue statistics, available for all the elements.
  96 +   Particular schedulers may have also their private records.
  97 + */
  98 +
  99 +struct tc_stats
 100 +{
 101 +       __u64   bytes;                  /* NUmber of enqueues bytes */
 102 +       __u32   packets;                /* Number of enqueued packets   */
 103 +       __u32   drops;                  /* Packets dropped because of lack of resources */
 104 +       __u32   overlimits;             /* Number of throttle events when this
 105 +                                        * flow goes out of allocated bandwidth */
 106 +       __u32   bps;                    /* Current flow byte rate */
 107 +       __u32   pps;                    /* Current flow packet rate */
 108 +       __u32   qlen;
 109 +       __u32   backlog;
 110 +#ifdef __KERNEL__
 111 +       spinlock_t *lock;
 112 +#endif
 113 +};
 114 +
 115 +struct tc_estimator
 116 +{
 117 +       char            interval;
 118 +       unsigned char   ewma_log;
 119 +};
 120 +
 121 +/* "Handles"
 122 +   ---------
 123 +
 124 +    All the traffic control objects have 32bit identifiers, or "handles".
 125 +
 126 +    They can be considered as opaque numbers from user API viewpoint,
 127 +    but actually they always consist of two fields: major and
 128 +    minor numbers, which are interpreted by kernel specially,
 129 +    that may be used by applications, though not recommended.
 130 +
 131 +    F.e. qdisc handles always have minor number equal to zero,
 132 +    classes (or flows) have major equal to parent qdisc major, and
 133 +    minor uniquely identifying class inside qdisc.
 134 +
 135 +    Macros to manipulate handles:
 136 + */
 137 +
 138 +#define TC_H_MAJ_MASK (0xFFFF0000U)
 139 +#define TC_H_MIN_MASK (0x0000FFFFU)
 140 +#define TC_H_MAJ(h) ((h)&TC_H_MAJ_MASK)
 141 +#define TC_H_MIN(h) ((h)&TC_H_MIN_MASK)
 142 +#define TC_H_MAKE(maj,min) (((maj)&TC_H_MAJ_MASK)|((min)&TC_H_MIN_MASK))
 143 +
 144 +#define TC_H_UNSPEC    (0U)
 145 +#define TC_H_ROOT      (0xFFFFFFFFU)
 146 +#define TC_H_INGRESS    (0xFFFFFFF1U)
 147 +
 148 +struct tc_ratespec
 149 +{
 150 +       unsigned char   cell_log;
 151 +       unsigned char   __reserved;
 152 +       unsigned short  feature;
 153 +       short           addend;
 154 +       unsigned short  mpu;
 155 +       __u32           rate;
 156 +};
 157 +
 158 +/* FIFO section */
 159 +
 160 +struct tc_fifo_qopt
 161 +{
 162 +       __u32   limit;  /* Queue length: bytes for bfifo, packets for pfifo */
 163 +};
 164 +
 165 +/* PRIO section */
 166 +
 167 +#define TCQ_PRIO_BANDS 16
 168 +
 169 +struct tc_prio_qopt
 170 +{
 171 +       int     bands;                  /* Number of bands */
 172 +       __u8    priomap[TC_PRIO_MAX+1]; /* Map: logical priority -> PRIO band */
 173 +};
 174 +
 175 +/* CSZ section */
 176 +
 177 +struct tc_csz_qopt
 178 +{
 179 +       int             flows;          /* Maximal number of guaranteed flows */
 180 +       unsigned char   R_log;          /* Fixed point position for round number */
 181 +       unsigned char   delta_log;      /* Log of maximal managed time interval */
 182 +       __u8            priomap[TC_PRIO_MAX+1]; /* Map: logical priority -> CSZ band */
 183 +};
 184 +
 185 +struct tc_csz_copt
 186 +{
 187 +       struct tc_ratespec slice;
 188 +       struct tc_ratespec rate;
 189 +       struct tc_ratespec peakrate;
 190 +       __u32           limit;
 191 +       __u32           buffer;
 192 +       __u32           mtu;
 193 +};
 194 +
 195 +enum
 196 +{
 197 +       TCA_CSZ_UNSPEC,
 198 +       TCA_CSZ_PARMS,
 199 +       TCA_CSZ_RTAB,
 200 +       TCA_CSZ_PTAB,
 201 +};
 202 +
 203 +/* TBF section */
 204 +
 205 +struct tc_tbf_qopt
 206 +{
 207 +       struct tc_ratespec rate;
 208 +       struct tc_ratespec peakrate;
 209 +       __u32           limit;
 210 +       __u32           buffer;
 211 +       __u32           mtu;
 212 +};
 213 +
 214 +enum
 215 +{
 216 +       TCA_TBF_UNSPEC,
 217 +       TCA_TBF_PARMS,
 218 +       TCA_TBF_RTAB,
 219 +       TCA_TBF_PTAB,
 220 +};
 221 +
 222 +
 223 +/* TEQL section */
 224 +
 225 +/* TEQL does not require any parameters */
 226 +
 227 +/* SFQ section */
 228 +
 229 +struct tc_sfq_qopt
 230 +{
 231 +       unsigned        quantum;        /* Bytes per round allocated to flow */
 232 +       int             perturb_period; /* Period of hash perturbation */
 233 +       __u32           limit;          /* Maximal packets in queue */
 234 +       unsigned        divisor;        /* Hash divisor  */
 235 +       unsigned        flows;          /* Maximal number of flows  */
 236 +};
 237 +
 238 +/*
 239 + *  NOTE: limit, divisor and flows are hardwired to code at the moment.
 240 + *
 241 + *     limit=flows=128, divisor=1024;
 242 + *
 243 + *     The only reason for this is efficiency, it is possible
 244 + *     to change these parameters in compile time.
 245 + */
 246 +
 247 +/* RED section */
 248 +
 249 +enum
 250 +{
 251 +       TCA_RED_UNSPEC,
 252 +       TCA_RED_PARMS,
 253 +       TCA_RED_STAB,
 254 +};
 255 +
 256 +struct tc_red_qopt
 257 +{
 258 +       __u32           limit;          /* HARD maximal queue length (bytes)    */
 259 +       __u32           qth_min;        /* Min average length threshold (bytes) */
 260 +       __u32           qth_max;        /* Max average length threshold (bytes) */
 261 +       unsigned char   Wlog;           /* log(W)               */
 262 +       unsigned char   Plog;           /* log(P_max/(qth_max-qth_min)) */
 263 +       unsigned char   Scell_log;      /* cell size for idle damping */
 264 +       unsigned char   flags;
 265 +#define TC_RED_ECN     1
 266 +};
 267 +
 268 +struct tc_red_xstats
 269 +{
 270 +       __u32           early;          /* Early drops */
 271 +       __u32           pdrop;          /* Drops due to queue limits */
 272 +       __u32           other;          /* Drops due to drop() calls */
 273 +       __u32           marked;         /* Marked packets */
 274 +};
 275 +
 276 +/* GRED section */
 277 +
 278 +#define MAX_DPs 16
 279 +
 280 +enum
 281 +{
 282 +       TCA_GRED_UNSPEC,
 283 +       TCA_GRED_PARMS,
 284 +       TCA_GRED_STAB,
 285 +       TCA_GRED_DPS,
 286 +};
 287 +
 288 +#define TCA_SET_OFF TCA_GRED_PARMS
 289 +struct tc_gred_qopt
 290 +{
 291 +       __u32           limit;          /* HARD maximal queue length (bytes)
 292 +*/
 293 +       __u32           qth_min;        /* Min average length threshold (bytes)
 294 +*/
 295 +       __u32           qth_max;        /* Max average length threshold (bytes)
 296 +*/
 297 +       __u32           DP;             /* upto 2^32 DPs */
 298 +       __u32           backlog;
 299 +       __u32           qave;
 300 +       __u32           forced;
 301 +       __u32           early;
 302 +       __u32           other;
 303 +       __u32           pdrop;
 304 +
 305 +       unsigned char   Wlog;           /* log(W)               */
 306 +       unsigned char   Plog;           /* log(P_max/(qth_max-qth_min)) */
 307 +       unsigned char   Scell_log;      /* cell size for idle damping */
 308 +       __u8            prio;           /* prio of this VQ */
 309 +       __u32   packets;
 310 +       __u32   bytesin;
 311 +};
 312 +/* gred setup */
 313 +struct tc_gred_sopt
 314 +{
 315 +       __u32           DPs;
 316 +       __u32           def_DP;
 317 +       __u8            grio;
 318 +};
 319 +
 320 +/* HTB section */
 321 +#define TC_HTB_NUMPRIO         8
 322 +#define TC_HTB_MAXDEPTH                8
 323 +#define TC_HTB_PROTOVER                3 /* the same as HTB and TC's major */
 324 +
 325 +struct tc_htb_opt
 326 +{
 327 +       struct tc_ratespec      rate;
 328 +       struct tc_ratespec      ceil;
 329 +       __u32   buffer;
 330 +       __u32   cbuffer;
 331 +       __u32   quantum;
 332 +       __u32   level;          /* out only */
 333 +       __u32   prio;
 334 +};
 335 +struct tc_htb_glob
 336 +{
 337 +       __u32 version;          /* to match HTB/TC */
 338 +       __u32 rate2quantum;     /* bps->quantum divisor */
 339 +       __u32 defcls;           /* default class number */
 340 +       __u32 debug;            /* debug flags */
 341 +
 342 +       /* stats */
 343 +       __u32 direct_pkts; /* count of non shapped packets */
 344 +};
 345 +enum
 346 +{
 347 +       TCA_HTB_UNSPEC,
 348 +       TCA_HTB_PARMS,
 349 +       TCA_HTB_INIT,
 350 +       TCA_HTB_CTAB,
 351 +       TCA_HTB_RTAB,
 352 +};
 353 +struct tc_htb_xstats
 354 +{
 355 +       __u32 lends;
 356 +       __u32 borrows;
 357 +       __u32 giants;   /* too big packets (rate will not be accurate) */
 358 +       __u32 tokens;
 359 +       __u32 ctokens;
 360 +};
 361 +
 362 +/* CBQ section */
 363 +
 364 +#define TC_CBQ_MAXPRIO         8
 365 +#define TC_CBQ_MAXLEVEL                8
 366 +#define TC_CBQ_DEF_EWMA                5
 367 +
 368 +struct tc_cbq_lssopt
 369 +{
 370 +       unsigned char   change;
 371 +       unsigned char   flags;
 372 +#define TCF_CBQ_LSS_BOUNDED    1
 373 +#define TCF_CBQ_LSS_ISOLATED   2
 374 +       unsigned char   ewma_log;
 375 +       unsigned char   level;
 376 +#define TCF_CBQ_LSS_FLAGS      1
 377 +#define TCF_CBQ_LSS_EWMA       2
 378 +#define TCF_CBQ_LSS_MAXIDLE    4
 379 +#define TCF_CBQ_LSS_MINIDLE    8
 380 +#define TCF_CBQ_LSS_OFFTIME    0x10
 381 +#define TCF_CBQ_LSS_AVPKT      0x20
 382 +       __u32           maxidle;
 383 +       __u32           minidle;
 384 +       __u32           offtime;
 385 +       __u32           avpkt;
 386 +};
 387 +
 388 +struct tc_cbq_wrropt
 389 +{
 390 +       unsigned char   flags;
 391 +       unsigned char   priority;
 392 +       unsigned char   cpriority;
 393 +       unsigned char   __reserved;
 394 +       __u32           allot;
 395 +       __u32           weight;
 396 +};
 397 +
 398 +struct tc_cbq_ovl
 399 +{
 400 +       unsigned char   strategy;
 401 +#define        TC_CBQ_OVL_CLASSIC      0
 402 +#define        TC_CBQ_OVL_DELAY        1
 403 +#define        TC_CBQ_OVL_LOWPRIO      2
 404 +#define        TC_CBQ_OVL_DROP         3
 405 +#define        TC_CBQ_OVL_RCLASSIC     4
 406 +       unsigned char   priority2;
 407 +       __u32           penalty;
 408 +};
 409 +
 410 +struct tc_cbq_police
 411 +{
 412 +       unsigned char   police;
 413 +       unsigned char   __res1;
 414 +       unsigned short  __res2;
 415 +};
 416 +
 417 +struct tc_cbq_fopt
 418 +{
 419 +       __u32           split;
 420 +       __u32           defmap;
 421 +       __u32           defchange;
 422 +};
 423 +
 424 +struct tc_cbq_xstats
 425 +{
 426 +       __u32           borrows;
 427 +       __u32           overactions;
 428 +       __s32           avgidle;
 429 +       __s32           undertime;
 430 +};
 431 +
 432 +enum
 433 +{
 434 +       TCA_CBQ_UNSPEC,
 435 +       TCA_CBQ_LSSOPT,
 436 +       TCA_CBQ_WRROPT,
 437 +       TCA_CBQ_FOPT,
 438 +       TCA_CBQ_OVL_STRATEGY,
 439 +       TCA_CBQ_RATE,
 440 +       TCA_CBQ_RTAB,
 441 +       TCA_CBQ_POLICE,
 442 +};
 443 +
 444 +#define TCA_CBQ_MAX    TCA_CBQ_POLICE
 445 +
 446 +/* dsmark section */
 447 +
 448 +enum {
 449 +       TCA_DSMARK_UNSPEC,
 450 +       TCA_DSMARK_INDICES,
 451 +       TCA_DSMARK_DEFAULT_INDEX,
 452 +       TCA_DSMARK_SET_TC_INDEX,
 453 +       TCA_DSMARK_MASK,
 454 +       TCA_DSMARK_VALUE
 455 +};
 456 +
 457 +#define TCA_DSMARK_MAX TCA_DSMARK_VALUE
 458 +
 459 +/* ATM  section */
 460 +
 461 +enum {
 462 +       TCA_ATM_UNSPEC,
 463 +       TCA_ATM_FD,             /* file/socket descriptor */
 464 +       TCA_ATM_PTR,            /* pointer to descriptor - later */
 465 +       TCA_ATM_HDR,            /* LL header */
 466 +       TCA_ATM_EXCESS,         /* excess traffic class (0 for CLP)  */
 467 +       TCA_ATM_ADDR,           /* PVC address (for output only) */
 468 +       TCA_ATM_STATE           /* VC state (ATM_VS_*; for output only) */
 469 +};
 470 +
 471 +#define TCA_ATM_MAX    TCA_ATM_STATE
 472 +
 473 +#endif
 474 +#endif
 475  #ifndef __LINUX_PKT_SCHED_H
 476  #define __LINUX_PKT_SCHED_H
 477
 478 @@ -518,4 +924,116 @@ struct tc_drr_stats
 479         __u32   deficit;
 480  };
 481
 482 +/* WRR section */
 483 +
 484 +/* Other includes */
 485 +#include <linux/if_ether.h>
 486 +
 487 +// A sub weight and of a class
 488 +// All numbers are represented as parts of (2^64-1).
 489 +struct tc_wrr_class_weight {
 490 +       __u64 val;      // Current value                        (0 is not valid)
 491 +       __u64 decr;     // Value pr bytes                       (2^64-1 is not valid)
 492 +       __u64 incr;     // Value pr seconds                     (2^64-1 is not valid)
 493 +       __u64 min;      // Minimal value                        (0 is not valid)
 494 +       __u64 max;      // Minimal value                        (0 is not valid)
 495 +
 496 +// The time where the above information was correct:
 497 +       time_t tim;
 498 +};
 499 +
 500 +// Packet send when modifying a class:
 501 +struct tc_wrr_class_modf {
 502 +       // Not-valid values are ignored.
 503 +       struct tc_wrr_class_weight weight1;
 504 +       struct tc_wrr_class_weight weight2;
 505 +};
 506 +
 507 +// Packet returned when quering a class:
 508 +struct tc_wrr_class_stats {
 509 +       char used;      // If this is false the information below is invalid
 510 +
 511 +       struct tc_wrr_class_modf class_modf;
 512 +
 513 +       unsigned char addr[ETH_ALEN];
 514 +       char usemac;    // True if addr is a MAC address, else it is an IP address
 515 +                       // (this value is only for convience, it is always the same
 516 +                       //  value as in the qdisc)
 517 +       int heappos;    // Current heap position or 0 if not in heap
 518 +       __u64 penal_ls; // Penalty value in heap (ls)
 519 +       __u64 penal_ms; // Penalty value in heap (ms)
 520 +};
 521 +
 522 +// Qdisc-wide penalty information (boolean values - 2 not valid)
 523 +struct tc_wrr_qdisc_weight {
 524 +       char weight_mode;       // 0=No automatic change to weight
 525 +                               // 1=Decrease normally
 526 +                               // 2=Also multiply with number of machines
 527 +                               // 3=Instead multiply with priority divided
 528 +                               //   with priority of the other.
 529 +                               // -1=no change
 530 +};
 531 +
 532 +// Packet send when modifing a qdisc:
 533 +struct tc_wrr_qdisc_modf {
 534 +       // Not-valid values are ignored:
 535 +       struct tc_wrr_qdisc_weight weight1;
 536 +       struct tc_wrr_qdisc_weight weight2;
 537 +};
 538 +
 539 +// Packet send when creating a qdisc:
 540 +struct tc_wrr_qdisc_crt {
 541 +       struct tc_wrr_qdisc_modf qdisc_modf;
 542 +
 543 +       char srcaddr;   // 1=lookup source, 0=lookup destination
 544 +       char usemac;    // 1=Classify on MAC addresses, 0=classify on IP
 545 +       char usemasq;   // 1=Classify based on masqgrading - only valid
 546 +                       //   if usemac is zero
 547 +       int bands_max;  // Maximal number of bands (i.e.: classes)
 548 +       int proxy_maxconn;// If differnt from 0 then we support proxy remapping
 549 +                       // of packets. And this is the number of maximal
 550 +                       // concurrent proxy connections.
 551 +};
 552 +
 553 +// Packet returned when quering a qdisc:
 554 +struct tc_wrr_qdisc_stats {
 555 +       struct tc_wrr_qdisc_crt qdisc_crt;
 556 +       int proxy_curconn;
 557 +       int nodes_in_heap;      // Current number of bands wanting to send something
 558 +       int bands_cur;          // Current number of bands used (i.e.: MAC/IP addresses seen)
 559 +       int bands_reused;       // Number of times this band has been reused.
 560 +       int packets_requed;     // Number of times packets have been requeued.
 561 +       __u64 priosum;          // Sum of priorities in heap where 1 is 2^32
 562 +};
 563 +
 564 +struct tc_wrr_qdisc_modf_std {
 565 +       // This indicates which of the tc_wrr_qdisc_modf structers this is:
 566 +       char proxy; // 0=This struct
 567 +
 568 +       // Should we also change a class?
 569 +       char change_class;
 570 +
 571 +       // Only valid if change_class is false
 572 +       struct tc_wrr_qdisc_modf qdisc_modf;
 573 +
 574 +       // Only valid if change_class is true:
 575 +       unsigned char addr[ETH_ALEN]; // Class to change (non-used bytes should be 0)
 576 +       struct tc_wrr_class_modf class_modf; // The change
 577 +};
 578 +
 579 +// Used for proxyrempping:
 580 +struct tc_wrr_qdisc_modf_proxy {
 581 +       // This indicates which of the tc_wrr_qdisc_modf structers this is:
 582 +       char proxy;     // 1=This struct
 583 +
 584 +       // This is 1 if the proxyremap information should be reset
 585 +       char reset;
 586 +
 587 +       // changec is the number of elements in changes.
 588 +       int changec;
 589 +
 590 +       // This is an array of type ProxyRemapBlock:
 591 +       long changes[0];
 592 +};
 593 +
 594  #endif
 595 --- a/ip/iproute.c
 596 +++ b/ip/iproute.c
 597 @@ -73,7 +73,7 @@ static void usage(void)
 598         fprintf(stderr, "           [ rtt TIME ] [ rttvar TIME ]\n");
 599         fprintf(stderr, "           [ window NUMBER] [ cwnd NUMBER ] [ initcwnd NUMBER ]\n");
 600         fprintf(stderr, "           [ ssthresh NUMBER ] [ realms REALM ] [ src ADDRESS ]\n");
 601 -       fprintf(stderr, "           [ rto_min TIME ]\n");
 602 +       fprintf(stderr, "           [ rto_min TIME ] [ hoplimit NUMBER ]\n");
 603         fprintf(stderr, "TYPE := [ unicast | local | broadcast | multicast | throw |\n");
 604         fprintf(stderr, "          unreachable | prohibit | blackhole | nat ]\n");
 605         fprintf(stderr, "TABLE_ID := [ local | main | default | all | NUMBER ]\n");
 606 @@ -792,6 +792,30 @@ int iproute_modify(int cmd, unsigned fla
 607                                 invarg("\"reordering\" value is invalid\n", *argv);
 608                         rta_addattr32(mxrta, sizeof(mxbuf), RTAX_REORDERING, reord);
 609  #endif
 610 +#ifdef RTAX_HOPLIMIT
 611 +               } else if (strcmp(*argv, "hoplimit") == 0) {
 612 +                       unsigned hoplim;
 613 +                       NEXT_ARG();
 614 +                       if (strcmp(*argv, "lock") == 0) {
 615 +                               mxlock |= (1<<RTAX_HOPLIMIT);
 616 +                               NEXT_ARG();
 617 +                       }
 618 +                       if (get_unsigned(&hoplim, *argv, 0))
 619 +                               invarg("\"hoplimit\" value is invalid\n", *argv);
 620 +                       rta_addattr32(mxrta, sizeof(mxbuf), RTAX_HOPLIMIT, hoplim);
 621 +#endif
 622 +#ifdef RTAX_INITCWND
 623 +               } else if (strcmp(*argv, "initcwnd") == 0) {
 624 +                       unsigned initcwnd;
 625 +                       NEXT_ARG();
 626 +                       if (strcmp(*argv, "lock") == 0) {
 627 +                               mxlock |= (1<<RTAX_HOPLIMIT);
 628 +                               NEXT_ARG();
 629 +                       }
 630 +                       if (get_unsigned(&initcwnd, *argv, 0))
 631 +                               invarg("\"initcwnd\" value is invalid\n", *argv);
 632 +                       rta_addattr32(mxrta, sizeof(mxbuf), RTAX_INITCWND, initcwnd);
 633 +#endif
 634                 } else if (strcmp(*argv, "rtt") == 0) {
 635                         unsigned rtt;
 636                         NEXT_ARG();
 637 --- a/ip/iptunnel.c
 638 +++ b/ip/iptunnel.c
 639 @@ -134,7 +134,7 @@ static int parse_args(int argc, char **a
 640                         NEXT_ARG();
 641                         p->o_flags |= GRE_KEY;
 642                         if (strchr(*argv, '.'))
 643 -                               p->o_key = get_addr32(*argv);
 644 +                               p->i_key = get_addr32(*argv);
 645                         else {
 646                                 if (get_unsigned(&uval, *argv, 0)<0) {
 647                                         fprintf(stderr, "invalid value of \"okey\"\n");
 648 --- a/Makefile
 649 +++ b/Makefile
 650 @@ -49,7 +49,7 @@ install: all
 651                 $(DESTDIR)$(DOCDIR)/examples
 652         install -m 0644 $(shell find examples/diffserv -maxdepth 1 -type f) \
 653                 $(DESTDIR)$(DOCDIR)/examples/diffserv
 654 -       @for i in $(SUBDIRS) doc; do $(MAKE) -C $$i install; done
 655 +       @set -e; for i in $(SUBDIRS) doc; do $(MAKE) -C $$i install; done
 656         install -m 0644 $(shell find etc/iproute2 -maxdepth 1 -type f) $(DESTDIR)$(CONFDIR)
 657         install -m 0755 -d $(DESTDIR)$(MANDIR)/man8
 658         install -m 0644 $(shell find man/man8 -maxdepth 1 -type f) $(DESTDIR)$(MANDIR)/man8
 659 @@ -67,7 +67,7 @@ snapshot:
 660
 661  clean:
 662         rm -f cscope.*
 663 -       @for i in $(SUBDIRS) doc; \
 664 +       @set -e; for i in $(SUBDIRS) doc; \
 665         do $(MAKE) $(MFLAGS) -C $$i clean; done
 666
 667  clobber: clean
 668 --- a/misc/Makefile
 669 +++ b/misc/Makefile
 670 @@ -1,7 +1,8 @@
 671  SSOBJ=ss.o ssfilter.o
 672  LNSTATOBJ=lnstat.o lnstat_util.o
 673
 674 -TARGETS=ss nstat ifstat rtacct arpd lnstat
 675 +#TARGETS=ss nstat ifstat rtacct arpd lnstat
 676 +TARGETS=ss nstat rtacct lnstat
 677
 678  include ../Config
 679
 680 --- a/tc/Makefile
 681 +++ b/tc/Makefile
 682 @@ -14,6 +14,7 @@ TCMODULES += q_cbq.o
 683  TCMODULES += q_rr.o
 684  TCMODULES += q_multiq.o
 685  TCMODULES += q_netem.o
 686 +TCMODULES += q_wrr.o
 687  TCMODULES += f_rsvp.o
 688  TCMODULES += f_u32.o
 689  TCMODULES += f_route.o
 690 --- a/tc/q_htb.c
 691 +++ b/tc/q_htb.c
 692 @@ -1,3 +1,311 @@
 693 +#if 0
 694 +/*
 695 + * q_htb.c             HTB.
 696 + *
 697 + *             This program is free software; you can redistribute it and/or
 698 + *             modify it under the terms of the GNU General Public License
 699 + *             as published by the Free Software Foundation; either version
 700 + *             2 of the License, or (at your option) any later version.
 701 + *
 702 + * Authors:    Martin Devera, devik@cdi.cz
 703 + *
 704 + */
 705 +
 706 +#include <stdio.h>
 707 +#include <stdlib.h>
 708 +#include <unistd.h>
 709 +#include <syslog.h>
 710 +#include <fcntl.h>
 711 +#include <sys/socket.h>
 712 +#include <netinet/in.h>
 713 +#include <arpa/inet.h>
 714 +#include <string.h>
 715 +
 716 +#include "utils.h"
 717 +#include "tc_util.h"
 718 +
 719 +#define HTB_TC_VER 0x30003
 720 +#if HTB_TC_VER >> 16 != TC_HTB_PROTOVER
 721 +#error "Different kernel and TC HTB versions"
 722 +#endif
 723 +
 724 +static void explain(void)
 725 +{
 726 +       fprintf(stderr, "Usage: ... qdisc add ... htb [default N] [r2q N]\n"
 727 +               " default  minor id of class to which unclassified packets are sent {0}\n"
 728 +               " r2q      DRR quantums are computed as rate in Bps/r2q {10}\n"
 729 +               " debug    string of 16 numbers each 0-3 {0}\n\n"
 730 +               "... class add ... htb rate R1 burst B1 [prio P] [slot S] [pslot PS]\n"
 731 +               "                      [ceil R2] [cburst B2] [mtu MTU] [quantum Q]\n"
 732 +               " rate     rate allocated to this class (class can still borrow)\n"
 733 +               " burst    max bytes burst which can be accumulated during idle period {computed}\n"
 734 +               " ceil     definite upper class rate (no borrows) {rate}\n"
 735 +               " cburst   burst but for ceil {computed}\n"
 736 +               " mtu      max packet size we create rate map for {1600}\n"
 737 +               " prio     priority of leaf; lower are served first {0}\n"
 738 +               " quantum  how much bytes to serve from leaf at once {use r2q}\n"
 739 +               "\nTC HTB version %d.%d\n",HTB_TC_VER>>16,HTB_TC_VER&0xffff
 740 +               );
 741 +}
 742 +
 743 +static void explain1(char *arg)
 744 +{
 745 +    fprintf(stderr, "Illegal \"%s\"\n", arg);
 746 +    explain();
 747 +}
 748 +
 749 +
 750 +#define usage() return(-1)
 751 +
 752 +static int htb_parse_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n)
 753 +{
 754 +       struct tc_htb_glob opt;
 755 +       struct rtattr *tail;
 756 +       unsigned i; char *p;
 757 +       memset(&opt,0,sizeof(opt));
 758 +       opt.rate2quantum = 10;
 759 +       opt.version = 3;
 760 +
 761 +       while (argc > 0) {
 762 +               if (matches(*argv, "r2q") == 0) {
 763 +                   NEXT_ARG();
 764 +                   if (get_u32(&opt.rate2quantum, *argv, 10)) {
 765 +                       explain1("r2q"); return -1;
 766 +                   }
 767 +               } else if (matches(*argv, "default") == 0) {
 768 +                   NEXT_ARG();
 769 +                   if (get_u32(&opt.defcls, *argv, 16)) {
 770 +                       explain1("default"); return -1;
 771 +                   }
 772 +               } else if (matches(*argv, "debug") == 0) {
 773 +                   NEXT_ARG(); p = *argv;
 774 +                   for (i=0; i<16; i++,p++) {
 775 +                       if (*p<'0' || *p>'3') break;
 776 +                       opt.debug |= (*p-'0')<<(2*i);
 777 +                   }
 778 +               } else {
 779 +                       fprintf(stderr, "What is \"%s\"?\n", *argv);
 780 +                       explain();
 781 +                       return -1;
 782 +               }
 783 +               argc--; argv++;
 784 +       }
 785 +       tail = (struct rtattr*)(((void*)n)+NLMSG_ALIGN(n->nlmsg_len));
 786 +       addattr_l(n, 1024, TCA_OPTIONS, NULL, 0);
 787 +       addattr_l(n, 2024, TCA_HTB_INIT, &opt, NLMSG_ALIGN(sizeof(opt)));
 788 +       tail->rta_len = (((void*)n)+NLMSG_ALIGN(n->nlmsg_len)) - (void*)tail;
 789 +       return 0;
 790 +}
 791 +
 792 +static int htb_parse_class_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n)
 793 +{
 794 +       int ok=0;
 795 +       struct tc_htb_opt opt;
 796 +       __u32 rtab[256],ctab[256];
 797 +       unsigned buffer=0,cbuffer=0;
 798 +       int cell_log=-1,ccell_log = -1,mtu;
 799 +       struct rtattr *tail;
 800 +
 801 +       memset(&opt, 0, sizeof(opt)); mtu = 1600; /* eth packet len */
 802 +
 803 +       while (argc > 0) {
 804 +               if (matches(*argv, "prio") == 0) {
 805 +                       NEXT_ARG();
 806 +                       if (get_u32(&opt.prio, *argv, 10)) {
 807 +                               explain1("prio"); return -1;
 808 +                       }
 809 +                       ok++;
 810 +               } else if (matches(*argv, "mtu") == 0) {
 811 +                       NEXT_ARG();
 812 +                       if (get_u32(&mtu, *argv, 10)) {
 813 +                               explain1("mtu"); return -1;
 814 +                       }
 815 +               } else if (matches(*argv, "quantum") == 0) {
 816 +                       NEXT_ARG();
 817 +                       if (get_u32(&opt.quantum, *argv, 10)) {
 818 +                               explain1("quantum"); return -1;
 819 +                       }
 820 +               } else if (matches(*argv, "burst") == 0 ||
 821 +                       strcmp(*argv, "buffer") == 0 ||
 822 +                       strcmp(*argv, "maxburst") == 0) {
 823 +                       NEXT_ARG();
 824 +                       if (get_size_and_cell(&buffer, &cell_log, *argv) < 0) {
 825 +                               explain1("buffer");
 826 +                               return -1;
 827 +                       }
 828 +                       ok++;
 829 +               } else if (matches(*argv, "cburst") == 0 ||
 830 +                       strcmp(*argv, "cbuffer") == 0 ||
 831 +                       strcmp(*argv, "cmaxburst") == 0) {
 832 +                       NEXT_ARG();
 833 +                       if (get_size_and_cell(&cbuffer, &ccell_log, *argv) < 0) {
 834 +                               explain1("cbuffer");
 835 +                               return -1;
 836 +                       }
 837 +                       ok++;
 838 +               } else if (strcmp(*argv, "ceil") == 0) {
 839 +                       NEXT_ARG();
 840 +                       if (opt.ceil.rate) {
 841 +                               fprintf(stderr, "Double \"ceil\" spec\n");
 842 +                               return -1;
 843 +                       }
 844 +                       if (get_rate(&opt.ceil.rate, *argv)) {
 845 +                               explain1("ceil");
 846 +                               return -1;
 847 +                       }
 848 +                       ok++;
 849 +               } else if (strcmp(*argv, "rate") == 0) {
 850 +                       NEXT_ARG();
 851 +                       if (opt.rate.rate) {
 852 +                               fprintf(stderr, "Double \"rate\" spec\n");
 853 +                               return -1;
 854 +                       }
 855 +                       if (get_rate(&opt.rate.rate, *argv)) {
 856 +                               explain1("rate");
 857 +                               return -1;
 858 +                       }
 859 +                       ok++;
 860 +               } else if (strcmp(*argv, "help") == 0) {
 861 +                       explain();
 862 +                       return -1;
 863 +               } else {
 864 +                       fprintf(stderr, "What is \"%s\"?\n", *argv);
 865 +                       explain();
 866 +                       return -1;
 867 +               }
 868 +               argc--; argv++;
 869 +       }
 870 +
 871 +/*     if (!ok)
 872 +               return 0;*/
 873 +
 874 +       if (opt.rate.rate == 0) {
 875 +               fprintf(stderr, "\"rate\" is required.\n");
 876 +               return -1;
 877 +       }
 878 +       /* if ceil params are missing, use the same as rate */
 879 +       if (!opt.ceil.rate) opt.ceil = opt.rate;
 880 +
 881 +       /* compute minimal allowed burst from rate; mtu is added here to make
 882 +          sute that buffer is larger than mtu and to have some safeguard space */
 883 +       if (!buffer) buffer = opt.rate.rate / HZ + mtu;
 884 +       if (!cbuffer) cbuffer = opt.ceil.rate / HZ + mtu;
 885 +
 886 +       if ((cell_log = tc_calc_rtable(opt.rate.rate, rtab, cell_log, mtu, 0)) < 0) {
 887 +               fprintf(stderr, "htb: failed to calculate rate table.\n");
 888 +               return -1;
 889 +       }
 890 +       opt.buffer = tc_calc_xmittime(opt.rate.rate, buffer);
 891 +       opt.rate.cell_log = cell_log;
 892 +
 893 +       if ((ccell_log = tc_calc_rtable(opt.ceil.rate, ctab, cell_log, mtu, 0)) < 0) {
 894 +               fprintf(stderr, "htb: failed to calculate ceil rate table.\n");
 895 +               return -1;
 896 +       }
 897 +       opt.cbuffer = tc_calc_xmittime(opt.ceil.rate, cbuffer);
 898 +       opt.ceil.cell_log = ccell_log;
 899 +
 900 +       tail = (struct rtattr*)(((void*)n)+NLMSG_ALIGN(n->nlmsg_len));
 901 +       addattr_l(n, 1024, TCA_OPTIONS, NULL, 0);
 902 +       addattr_l(n, 2024, TCA_HTB_PARMS, &opt, sizeof(opt));
 903 +       addattr_l(n, 3024, TCA_HTB_RTAB, rtab, 1024);
 904 +       addattr_l(n, 4024, TCA_HTB_CTAB, ctab, 1024);
 905 +       tail->rta_len = (((void*)n)+NLMSG_ALIGN(n->nlmsg_len)) - (void*)tail;
 906 +       return 0;
 907 +}
 908 +
 909 +static int htb_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt)
 910 +{
 911 +       struct rtattr *tb[TCA_HTB_RTAB+1];
 912 +       struct tc_htb_opt *hopt;
 913 +       struct tc_htb_glob *gopt;
 914 +       double buffer,cbuffer;
 915 +       SPRINT_BUF(b1);
 916 +       SPRINT_BUF(b2);
 917 +
 918 +       if (opt == NULL)
 919 +               return 0;
 920 +
 921 +       memset(tb, 0, sizeof(tb));
 922 +       parse_rtattr(tb, TCA_HTB_RTAB, RTA_DATA(opt), RTA_PAYLOAD(opt));
 923 +
 924 +       if (tb[TCA_HTB_PARMS]) {
 925 +
 926 +           hopt = RTA_DATA(tb[TCA_HTB_PARMS]);
 927 +           if (RTA_PAYLOAD(tb[TCA_HTB_PARMS])  < sizeof(*hopt)) return -1;
 928 +
 929 +               if (!hopt->level) {
 930 +                       fprintf(f, "prio %d ", (int)hopt->prio);
 931 +                       if (show_details)
 932 +                               fprintf(f, "quantum %d ", (int)hopt->quantum);
 933 +               }
 934 +           fprintf(f, "rate %s ", sprint_rate(hopt->rate.rate, b1));
 935 +           buffer = ((double)hopt->rate.rate*tc_core_tick2usec(hopt->buffer))/1000000;
 936 +           fprintf(f, "ceil %s ", sprint_rate(hopt->ceil.rate, b1));
 937 +           cbuffer = ((double)hopt->ceil.rate*tc_core_tick2usec(hopt->cbuffer))/1000000;
 938 +           if (show_details) {
 939 +               fprintf(f, "burst %s/%u mpu %s ", sprint_size(buffer, b1),
 940 +                       1<<hopt->rate.cell_log, sprint_size(hopt->rate.mpu, b2));
 941 +               fprintf(f, "cburst %s/%u mpu %s ", sprint_size(cbuffer, b1),
 942 +                       1<<hopt->ceil.cell_log, sprint_size(hopt->ceil.mpu, b2));
 943 +               fprintf(f, "level %d ", (int)hopt->level);
 944 +           } else {
 945 +               fprintf(f, "burst %s ", sprint_size(buffer, b1));
 946 +               fprintf(f, "cburst %s ", sprint_size(cbuffer, b1));
 947 +           }
 948 +           if (show_raw)
 949 +               fprintf(f, "buffer [%08x] cbuffer [%08x] ",
 950 +                       hopt->buffer,hopt->cbuffer);
 951 +       }
 952 +       if (tb[TCA_HTB_INIT]) {
 953 +           gopt = RTA_DATA(tb[TCA_HTB_INIT]);
 954 +           if (RTA_PAYLOAD(tb[TCA_HTB_INIT])  < sizeof(*gopt)) return -1;
 955 +
 956 +           fprintf(f, "r2q %d default %x direct_packets_stat %u",
 957 +                   gopt->rate2quantum,gopt->defcls,gopt->direct_pkts);
 958 +               if (show_details)
 959 +                       fprintf(f," ver %d.%d",gopt->version >> 16,gopt->version & 0xffff);
 960 +       }
 961 +       return 0;
 962 +}
 963 +
 964 +static int htb_print_xstats(struct qdisc_util *qu, FILE *f, struct rtattr *xstats)
 965 +{
 966 +       struct tc_htb_xstats *st;
 967 +       if (xstats == NULL)
 968 +               return 0;
 969 +
 970 +       if (RTA_PAYLOAD(xstats) < sizeof(*st))
 971 +               return -1;
 972 +
 973 +       st = RTA_DATA(xstats);
 974 +       fprintf(f, " lended: %u borrowed: %u giants: %u\n",
 975 +               st->lends,st->borrows,st->giants);
 976 +       fprintf(f, " tokens: %d ctokens: %d\n", st->tokens,st->ctokens);
 977 +       return 0;
 978 +}
 979 +
 980 +struct qdisc_util htb_util = {
 981 +       NULL,
 982 +       "htb",
 983 +       htb_parse_opt,
 984 +       htb_print_opt,
 985 +       htb_print_xstats,
 986 +       htb_parse_class_opt,
 987 +       htb_print_opt,
 988 +};
 989 +
 990 +/* for testing of old one */
 991 +struct qdisc_util htb2_util = {
 992 +       NULL,
 993 +       "htb2",
 994 +       htb_parse_opt,
 995 +       htb_print_opt,
 996 +       htb_print_xstats,
 997 +       htb_parse_class_opt,
 998 +       htb_print_opt,
 999 +};
1000 +#endif
1001  /*
1002   * q_htb.c             HTB.
1003   *
1004 --- /dev/null
1005 +++ b/tc/q_wrr.c
1006 @@ -0,0 +1,322 @@
1007 +#include <stdio.h>
1008 +#include <stdlib.h>
1009 +#include <unistd.h>
1010 +#include <syslog.h>
1011 +#include <fcntl.h>
1012 +#include <sys/socket.h>
1013 +#include <netinet/in.h>
1014 +#include <arpa/inet.h>
1015 +#include <string.h>
1016 +#include <math.h>
1017 +
1018 +#include "utils.h"
1019 +#include "tc_util.h"
1020 +
1021 +#define usage() return(-1)
1022 +
1023 +// Returns -1 on error
1024 +static int wrr_parse_qdisc_weight(int argc, char** argv,
1025 +                              struct tc_wrr_qdisc_modf* opt) {
1026 +  int i;
1027 +
1028 +  opt->weight1.weight_mode=-1;
1029 +  opt->weight2.weight_mode=-1;
1030 +
1031 +  for(i=0; i<argc; i++) {
1032 +    if(!memcmp(argv[i],"wmode1=",7)) {
1033 +      opt->weight1.weight_mode=atoi(argv[i]+7);
1034 +    } else if(!memcmp(argv[i],"wmode2=",7)) {
1035 +      opt->weight2.weight_mode=atoi(argv[i]+7);
1036 +    } else {
1037 +      printf("Usage: ... [wmode1=0|1|2|3] [wmode2=0|1|2|3]\n");
1038 +      return -1;
1039 +    }
1040 +  }
1041 +  return 0;
1042 +}
1043 +
1044 +static int wrr_parse_class_modf(int argc, char** argv,
1045 +                                struct tc_wrr_class_modf* modf) {
1046 +  int i;
1047 +
1048 +  if(argc<1) {
1049 +    fprintf(stderr, "Usage: ... [weight1=val] [decr1=val] [incr1=val] [min1=val] [max1=val] [val2=val] ...\n");
1050 +    fprintf(stderr, "  The values can be floating point like 0.42 or divisions like 42/100\n");
1051 +    return -1;
1052 +  }
1053 +
1054 +  // Set meaningless values:
1055 +  modf->weight1.val=0;
1056 +  modf->weight1.decr=(__u64)-1;
1057 +  modf->weight1.incr=(__u64)-1;
1058 +  modf->weight1.min=0;
1059 +  modf->weight1.max=0;
1060 +  modf->weight2.val=0;
1061 +  modf->weight2.decr=(__u64)-1;
1062 +  modf->weight2.incr=(__u64)-1;
1063 +  modf->weight2.min=0;
1064 +  modf->weight2.max=0;
1065 +
1066 +  // And read values:
1067 +  for(i=0; i<argc; i++) {
1068 +    char arg[80];
1069 +    char* name,*value1=0,*value2=0;
1070 +    long double f_val1,f_val2=1,value;
1071 +    if(strlen(argv[i])>=sizeof(arg)) {
1072 +      fprintf(stderr,"Argument too long: %s\n",argv[i]);
1073 +      return -1;
1074 +    }
1075 +    strcpy(arg,argv[i]);
1076 +
1077 +    name=strtok(arg,"=");
1078 +    if(name) value1=strtok(0,"/");
1079 +    if(value1) value2=strtok(0,"");
1080 +
1081 +    if(!value1) {
1082 +      fprintf(stderr,"No = found in argument: %s\n",argv[i]);
1083 +      return -1;
1084 +    }
1085 +
1086 +    f_val1=atof(value1);
1087 +    if(value2) f_val2=atof(value2);
1088 +
1089 +    if(f_val2==0)  {
1090 +      fprintf(stderr,"Division by 0\n");
1091 +      return -1;
1092 +    }
1093 +
1094 +    value=f_val1/f_val2;
1095 +    if(value>1) value=1;
1096 +    if(value<0) value=0;
1097 +    value*=((__u64)-1);
1098 +
1099 +    // And find the value set
1100 +    if(!strcmp(name,"weight1"))    modf->weight1.val=value;
1101 +    else if(!strcmp(name,"decr1")) modf->weight1.decr=value;
1102 +    else if(!strcmp(name,"incr1")) modf->weight1.incr=value;
1103 +    else if(!strcmp(name,"min1"))  modf->weight1.min=value;
1104 +    else if(!strcmp(name,"max1"))  modf->weight1.max=value;
1105 +    else if(!strcmp(name,"weight2")) modf->weight2.val=value;
1106 +    else if(!strcmp(name,"decr2")) modf->weight2.decr=value;
1107 +    else if(!strcmp(name,"incr2")) modf->weight2.incr=value;
1108 +    else if(!strcmp(name,"min2"))  modf->weight2.min=value;
1109 +    else if(!strcmp(name,"max2"))  modf->weight2.max=value;
1110 +    else {
1111 +      fprintf(stderr,"illegal value: %s\n",name);
1112 +      return -1;
1113 +    }
1114 +  }
1115 +
1116 +  return 0;
1117 +}
1118 +
1119 +static int wrr_parse_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n)
1120 +{
1121 +  if(n->nlmsg_flags & NLM_F_CREATE) {
1122 +    // This is a create request:
1123 +    struct tc_wrr_qdisc_crt opt;
1124 +
1125 +    int sour,dest,ip,mac,masq;
1126 +
1127 +    if(argc<4) {
1128 +      fprintf(stderr, "Usage: ... wrr sour|dest ip|masq|mac maxclasses proxymaxcon [penalty-setup]\n");
1129 +      return -1;
1130 +    }
1131 +
1132 +    // Read sour/dest:
1133 +    memset(&opt,0,sizeof(opt));
1134 +    sour=!strcmp(argv[0],"sour");
1135 +    dest=!strcmp(argv[0],"dest");
1136 +
1137 +    if(!sour && !dest) {
1138 +      fprintf(stderr,"sour or dest must be specified\n");
1139 +      return -1;
1140 +    }
1141 +
1142 +    // Read ip/mac
1143 +    ip=!strcmp(argv[1],"ip");
1144 +    mac=!strcmp(argv[1],"mac");
1145 +    masq=!strcmp(argv[1],"masq");
1146 +
1147 +    if(!ip && !mac && !masq) {
1148 +      fprintf(stderr,"ip, masq or mac must be specified\n");
1149 +      return -1;
1150 +    }
1151 +
1152 +    opt.srcaddr=sour;
1153 +    opt.usemac=mac;
1154 +    opt.usemasq=masq;
1155 +    opt.bands_max=atoi(argv[2]);
1156 +
1157 +    opt.proxy_maxconn=atoi(argv[3]);
1158 +
1159 +    // Read weights:
1160 +    if(wrr_parse_qdisc_weight(argc-4,argv+4,&opt.qdisc_modf)<0) return -1;
1161 +    if(opt.qdisc_modf.weight1.weight_mode==-1) opt.qdisc_modf.weight1.weight_mode=0;
1162 +    if(opt.qdisc_modf.weight2.weight_mode==-1) opt.qdisc_modf.weight2.weight_mode=0;
1163 +
1164 +    addattr_l(n, 1024, TCA_OPTIONS, &opt, sizeof(opt));
1165 +  } else {
1166 +    struct tc_wrr_qdisc_modf_std opt;
1167 +    char qdisc,class;
1168 +
1169 +    // This is a modify request:
1170 +    if(argc<1) {
1171 +      fprintf(stderr,"... qdisc ... or ... class ...\n");
1172 +      return -1;
1173 +    }
1174 +
1175 +    qdisc=!strcmp(argv[0],"qdisc");
1176 +    class=!strcmp(argv[0],"class");
1177 +
1178 +    if(!qdisc && !class) {
1179 +      fprintf(stderr,"qdisc or class must be specified\n");
1180 +      return -1;
1181 +    }
1182 +
1183 +    argc--;
1184 +    argv++;
1185 +
1186 +    opt.proxy=0;
1187 +
1188 +    if(qdisc) {
1189 +      opt.change_class=0;
1190 +      if(wrr_parse_qdisc_weight(argc, argv, &opt.qdisc_modf)<0) return -1;
1191 +    } else {
1192 +      int a0,a1,a2,a3,a4=0,a5=0;
1193 +
1194 +      opt.change_class=1;
1195 +
1196 +      if(argc<1) {
1197 +        fprintf(stderr,"... <mac>|<ip>|<masq> ...\n");
1198 +        return -1;
1199 +      }
1200 +      memset(opt.addr,0,sizeof(opt.addr));
1201 +
1202 +      if((sscanf(argv[0],"%i.%i.%i.%i",&a0,&a1,&a2,&a3)!=4) &&
1203 +         (sscanf(argv[0],"%x:%x:%x:%x:%x:%x",&a0,&a1,&a2,&a3,&a4,&a5)!=6)) {
1204 +       fprintf(stderr,"Wrong format of mac or ip address\n");
1205 +       return -1;
1206 +      }
1207 +
1208 +      opt.addr[0]=a0; opt.addr[1]=a1; opt.addr[2]=a2;
1209 +      opt.addr[3]=a3; opt.addr[4]=a4; opt.addr[5]=a5;
1210 +
1211 +      if(wrr_parse_class_modf(argc-1, argv+1, &opt.class_modf)<0) return -1;
1212 +    }
1213 +
1214 +    addattr_l(n, 1024, TCA_OPTIONS, &opt, sizeof(opt));
1215 +  }
1216 +  return 0;
1217 +}
1218 +
1219 +static int wrr_parse_copt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n) {
1220 +  struct tc_wrr_class_modf opt;
1221 +
1222 +  memset(&opt,0,sizeof(opt));
1223 +  if(wrr_parse_class_modf(argc,argv,&opt)<0) return -1;
1224 +
1225 +  addattr_l(n, 1024, TCA_OPTIONS, &opt, sizeof(opt));
1226 +  return 0;
1227 +}
1228 +
1229 +static int wrr_print_opt(struct qdisc_util *qu, FILE *f, struct rtattr *opt)
1230 +{
1231 +       struct tc_wrr_qdisc_stats *qopt;
1232 +
1233 +       if (opt == NULL)
1234 +               return 0;
1235 +
1236 +       if (RTA_PAYLOAD(opt)  < sizeof(*qopt))
1237 +               return -1;
1238 +       qopt = RTA_DATA(opt);
1239 +
1240 +       fprintf(f,"\n  (%s/%s) (maxclasses %i) (usedclasses %i) (reused classes %i)\n",
1241 +         qopt->qdisc_crt.srcaddr ? "sour" : "dest",
1242 +         qopt->qdisc_crt.usemac  ? "mac"  : (qopt->qdisc_crt.usemasq ? "masq" : "ip"),
1243 +         qopt->qdisc_crt.bands_max,
1244 +         qopt->bands_cur,
1245 +         qopt->bands_reused
1246 +         );
1247 +
1248 +       if(qopt->qdisc_crt.proxy_maxconn) {
1249 +         fprintf(f,"  (proxy maxcon %i) (proxy curcon %i)\n",
1250 +           qopt->qdisc_crt.proxy_maxconn,qopt->proxy_curconn);
1251 +       }
1252 +
1253 +       fprintf(f,"  (waiting classes %i) (packets requeued %i) (priosum: %Lg)\n",
1254 +         qopt->nodes_in_heap,
1255 +         qopt->packets_requed,
1256 +         qopt->priosum/((long double)((__u32)-1))
1257 +         );
1258 +
1259 +       fprintf(f,"  (wmode1 %i) (wmode2 %i) \n",
1260 +         qopt->qdisc_crt.qdisc_modf.weight1.weight_mode,
1261 +         qopt->qdisc_crt.qdisc_modf.weight2.weight_mode);
1262 +
1263 +       return 0;
1264 +}
1265 +
1266 +static int wrr_print_copt(struct qdisc_util *qu, FILE *f, struct rtattr *opt) {
1267 +  struct tc_wrr_class_stats *copt;
1268 +  long double d=(__u64)-1;
1269 +
1270 +  if (opt == NULL) return 0;
1271 +
1272 +  if (RTA_PAYLOAD(opt)  < sizeof(*copt))
1273 +    return -1;
1274 +  copt = RTA_DATA(opt);
1275 +
1276 +  if(!copt->used) {
1277 +    fprintf(f,"(unused)");
1278 +    return 0;
1279 +  }
1280 +
1281 +  if(copt->usemac) {
1282 +    fprintf(f,"\n  (address: %.2X:%.2X:%.2X:%.2X:%.2X:%.2X)\n",
1283 +      copt->addr[0],copt->addr[1],copt->addr[2],
1284 +      copt->addr[3],copt->addr[4],copt->addr[5]);
1285 +  } else {
1286 +    fprintf(f,"\n  (address: %i.%i.%i.%i)\n",copt->addr[0],copt->addr[1],copt->addr[2],copt->addr[3]);
1287 +  }
1288 +
1289 +  fprintf(f,"  (total weight: %Lg) (current position: %i) (counters: %u %u : %u %u)\n",
1290 +    (copt->class_modf.weight1.val/d)*(copt->class_modf.weight2.val/d),
1291 +    copt->heappos,
1292 +    (unsigned)(copt->penal_ms>>32),
1293 +    (unsigned)(copt->penal_ms & 0xffffffffU),
1294 +    (unsigned)(copt->penal_ls>>32),
1295 +    (unsigned)(copt->penal_ls & 0xffffffffU)
1296 +    );
1297 +
1298 +  fprintf(f,"  Pars 1: (weight %Lg) (decr: %Lg) (incr: %Lg) (min: %Lg) (max: %Lg)\n",
1299 +    copt->class_modf.weight1.val/d,
1300 +    copt->class_modf.weight1.decr/d,
1301 +    copt->class_modf.weight1.incr/d,
1302 +    copt->class_modf.weight1.min/d,
1303 +    copt->class_modf.weight1.max/d);
1304 +
1305 +  fprintf(f,"  Pars 2: (weight %Lg) (decr: %Lg) (incr: %Lg) (min: %Lg) (max: %Lg)",
1306 +    copt->class_modf.weight2.val/d,
1307 +    copt->class_modf.weight2.decr/d,
1308 +    copt->class_modf.weight2.incr/d,
1309 +    copt->class_modf.weight2.min/d,
1310 +    copt->class_modf.weight2.max/d);
1311 +
1312 +  return 0;
1313 +}
1314 +
1315 +static int wrr_print_xstats(struct qdisc_util *qu, FILE *f, struct rtattr *xstats)
1316 +{
1317 +       return 0;
1318 +}
1319 +
1320 +
1321 +struct qdisc_util wrr_qdisc_util = {
1322 +       .id = "wrr",
1323 +       .parse_qopt = wrr_parse_opt,
1324 +       .print_qopt = wrr_print_opt,
1325 +       .print_xstats = wrr_print_xstats,
1326 +       .parse_copt = wrr_parse_copt,
1327 +       .print_copt = wrr_print_copt
1328 +};