tc/tc.c

   1 /*
   2  * tc.c         "tc" utility frontend.
   3  *
   4  *              This program is free software; you can redistribute it and/or
   5  *              modify it under the terms of the GNU General Public License
   6  *              as published by the Free Software Foundation; either version
   7  *              2 of the License, or (at your option) any later version.
   8  *
   9  * Authors:     Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
  10  *
  11  * Fixes:
  12  *
  13  * Petri Mattila <petri@prihateam.fi> 990308: wrong memset's resulted in faults
  14  */
  15
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <unistd.h>
  19 #include <fcntl.h>
  20 #include <dlfcn.h>
  21 #include <sys/socket.h>
  22 #include <netinet/in.h>
  23 #include <arpa/inet.h>
  24 #include <string.h>
  25 #include <errno.h>
  26
  27 #include "SNAPSHOT.h"
  28 #include "utils.h"
  29 #include "tc_util.h"
  30 #include "tc_common.h"
  31 #include "namespace.h"
  32
  33 int show_stats;
  34 int show_details;
  35 int show_raw;
  36 int show_graph;
  37 int timestamp;
  38
  39 int batch_mode;
  40 int use_iec;
  41 int force;
  42 bool use_names;
  43 int json;
  44 int color;
  45
  46 static char *conf_file;
  47
  48 struct rtnl_handle rth;
  49
  50 static void *BODY;      /* cached handle dlopen(NULL) */
  51 static struct qdisc_util *qdisc_list;
  52 static struct filter_util *filter_list;
  53
  54 static int print_noqopt(struct qdisc_util *qu, FILE *f,
  55                         struct rtattr *opt)
  56 {
  57         if (opt && RTA_PAYLOAD(opt))
  58                 fprintf(f, "[Unknown qdisc, optlen=%u] ",
  59                         (unsigned int) RTA_PAYLOAD(opt));
  60         return 0;
  61 }
  62
  63 static int parse_noqopt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n, const char *dev)
  64 {
  65         if (argc) {
  66                 fprintf(stderr, "Unknown qdisc \"%s\", hence option \"%s\" is unparsable\n", qu->id, *argv);
  67                 return -1;
  68         }
  69         return 0;
  70 }
  71
  72 static int print_nofopt(struct filter_util *qu, FILE *f, struct rtattr *opt, __u32 fhandle)
  73 {
  74         if (opt && RTA_PAYLOAD(opt))
  75                 fprintf(f, "fh %08x [Unknown filter, optlen=%u] ",
  76                         fhandle, (unsigned int) RTA_PAYLOAD(opt));
  77         else if (fhandle)
  78                 fprintf(f, "fh %08x ", fhandle);
  79         return 0;
  80 }
  81
  82 static int parse_nofopt(struct filter_util *qu, char *fhandle, int argc, char **argv, struct nlmsghdr *n)
  83 {
  84         __u32 handle;
  85
  86         if (argc) {
  87                 fprintf(stderr, "Unknown filter \"%s\", hence option \"%s\" is unparsable\n", qu->id, *argv);
  88                 return -1;
  89         }
  90         if (fhandle) {
  91                 struct tcmsg *t = NLMSG_DATA(n);
  92
  93                 if (get_u32(&handle, fhandle, 16)) {
  94                         fprintf(stderr, "Unparsable filter ID \"%s\"\n", fhandle);
  95                         return -1;
  96                 }
  97                 t->tcm_handle = handle;
  98         }
  99         return 0;
 100 }
 101
 102 struct qdisc_util *get_qdisc_kind(const char *str)
 103 {
 104         void *dlh;
 105         char buf[256];
 106         struct qdisc_util *q;
 107
 108         for (q = qdisc_list; q; q = q->next)
 109                 if (strcmp(q->id, str) == 0)
 110                         return q;
 111
 112         snprintf(buf, sizeof(buf), "%s/q_%s.so", get_tc_lib(), str);
 113         dlh = dlopen(buf, RTLD_LAZY);
 114         if (!dlh) {
 115                 /* look in current binary, only open once */
 116                 dlh = BODY;
 117                 if (dlh == NULL) {
 118                         dlh = BODY = dlopen(NULL, RTLD_LAZY);
 119                         if (dlh == NULL)
 120                                 goto noexist;
 121                 }
 122         }
 123
 124         snprintf(buf, sizeof(buf), "%s_qdisc_util", str);
 125         q = dlsym(dlh, buf);
 126         if (q == NULL)
 127                 goto noexist;
 128
 129 reg:
 130         q->next = qdisc_list;
 131         qdisc_list = q;
 132         return q;
 133
 134 noexist:
 135         q = calloc(1, sizeof(*q));
 136         if (q) {
 137                 q->id = strdup(str);
 138                 q->parse_qopt = parse_noqopt;
 139                 q->print_qopt = print_noqopt;
 140                 goto reg;
 141         }
 142         return q;
 143 }
 144
 145
 146 struct filter_util *get_filter_kind(const char *str)
 147 {
 148         void *dlh;
 149         char buf[256];
 150         struct filter_util *q;
 151
 152         for (q = filter_list; q; q = q->next)
 153                 if (strcmp(q->id, str) == 0)
 154                         return q;
 155
 156         snprintf(buf, sizeof(buf), "%s/f_%s.so", get_tc_lib(), str);
 157         dlh = dlopen(buf, RTLD_LAZY);
 158         if (dlh == NULL) {
 159                 dlh = BODY;
 160                 if (dlh == NULL) {
 161                         dlh = BODY = dlopen(NULL, RTLD_LAZY);
 162                         if (dlh == NULL)
 163                                 goto noexist;
 164                 }
 165         }
 166
 167         snprintf(buf, sizeof(buf), "%s_filter_util", str);
 168         q = dlsym(dlh, buf);
 169         if (q == NULL)
 170                 goto noexist;
 171
 172 reg:
 173         q->next = filter_list;
 174         filter_list = q;
 175         return q;
 176 noexist:
 177         q = calloc(1, sizeof(*q));
 178         if (q) {
 179                 strncpy(q->id, str, 15);
 180                 q->parse_fopt = parse_nofopt;
 181                 q->print_fopt = print_nofopt;
 182                 goto reg;
 183         }
 184         return q;
 185 }
 186
 187 static void usage(void)
 188 {
 189         fprintf(stderr, "Usage: tc [ OPTIONS ] OBJECT { COMMAND | help }\n"
 190                 "       tc [-force] -batch filename\n"
 191                 "where  OBJECT := { qdisc | class | filter | action | monitor | exec }\n"
 192                 "       OPTIONS := { -s[tatistics] | -d[etails] | -r[aw] | -b[atch] [filename] | -n[etns] name |\n"
 193                 "                    -nm | -nam[es] | { -cf | -conf } path } |\n"
 194                 "                    -j[son] -p[retty] -c[olor]\n");
 195 }
 196
 197 static int do_cmd(int argc, char **argv, void *buf, size_t buflen)
 198 {
 199         if (matches(*argv, "qdisc") == 0)
 200                 return do_qdisc(argc-1, argv+1);
 201         if (matches(*argv, "class") == 0)
 202                 return do_class(argc-1, argv+1);
 203         if (matches(*argv, "filter") == 0)
 204                 return do_filter(argc-1, argv+1, buf, buflen);
 205         if (matches(*argv, "actions") == 0)
 206                 return do_action(argc-1, argv+1, buf, buflen);
 207         if (matches(*argv, "monitor") == 0)
 208                 return do_tcmonitor(argc-1, argv+1);
 209         if (matches(*argv, "exec") == 0)
 210                 return do_exec(argc-1, argv+1);
 211         if (matches(*argv, "help") == 0) {
 212                 usage();
 213                 return 0;
 214         }
 215
 216         fprintf(stderr, "Object \"%s\" is unknown, try \"tc help\".\n",
 217                 *argv);
 218         return -1;
 219 }
 220
 221 #define TC_MAX_SUBC     10
 222 static bool batchsize_enabled(int argc, char *argv[])
 223 {
 224         struct {
 225                 char *c;
 226                 char *subc[TC_MAX_SUBC];
 227         } table[] = {
 228                 {"filter", {"add", "delete", "change", "replace", NULL}},
 229                 {"actions", {"add", "change", "replace", NULL}},
 230                 { NULL },
 231         }, *iter;
 232         char *s;
 233         int i;
 234
 235         if (argc < 2)
 236                 return false;
 237
 238         for (iter = table; iter->c; iter++) {
 239                 if (matches(argv[0], iter->c))
 240                         continue;
 241                 for (i = 0; i < TC_MAX_SUBC; i++) {
 242                         s = iter->subc[i];
 243                         if (s && matches(argv[1], s) == 0)
 244                                 return true;
 245                 }
 246         }
 247
 248         return false;
 249 }
 250
 251 struct batch_buf {
 252         struct batch_buf        *next;
 253         char                    buf[16420];     /* sizeof (struct nlmsghdr) +
 254                                                    max(sizeof (struct tcmsg) +
 255                                                    sizeof (struct tcamsg)) +
 256                                                    MAX_MSG */
 257 };
 258
 259 static struct batch_buf *get_batch_buf(struct batch_buf **pool,
 260                                        struct batch_buf **head,
 261                                        struct batch_buf **tail)
 262 {
 263         struct batch_buf *buf;
 264
 265         if (*pool == NULL)
 266                 buf = calloc(1, sizeof (struct batch_buf));
 267         else {
 268                 buf = *pool;
 269                 *pool = (*pool)->next;
 270                 memset(buf, 0, sizeof (struct batch_buf));
 271         }
 272
 273         if (*head == NULL)
 274                 *head = *tail = buf;
 275         else {
 276                 (*tail)->next = buf;
 277                 (*tail) = buf;
 278         }
 279
 280         return buf;
 281 }
 282
 283 static void put_batch_bufs(struct batch_buf **pool,
 284                            struct batch_buf **head,
 285                            struct batch_buf **tail)
 286 {
 287         if (*head == NULL || *tail == NULL)
 288                 return;
 289
 290         if (*pool == NULL)
 291                 *pool = *head;
 292         else {
 293                 (*tail)->next = *pool;
 294                 *pool = *head;
 295         }
 296         *head = NULL;
 297         *tail = NULL;
 298 }
 299
 300 static void free_batch_bufs(struct batch_buf **pool)
 301 {
 302         struct batch_buf *buf;
 303
 304         for (buf = *pool; buf != NULL; buf = *pool) {
 305                 *pool = buf->next;
 306                 free(buf);
 307         }
 308         *pool = NULL;
 309 }
 310
 311 static int batch(const char *name)
 312 {
 313         struct batch_buf *head = NULL, *tail = NULL, *buf_pool = NULL;
 314         char *largv[100], *largv_next[100];
 315         char *line, *line_next = NULL;
 316         bool bs_enabled_next = false;
 317         bool bs_enabled = false;
 318         bool lastline = false;
 319         int largc, largc_next;
 320         bool bs_enabled_saved;
 321         int batchsize = 0;
 322         size_t len = 0;
 323         int ret = 0;
 324         bool send;
 325
 326         batch_mode = 1;
 327         if (name && strcmp(name, "-") != 0) {
 328                 if (freopen(name, "r", stdin) == NULL) {
 329                         fprintf(stderr, "Cannot open file \"%s\" for reading: %s\n",
 330                                 name, strerror(errno));
 331                         return -1;
 332                 }
 333         }
 334
 335         tc_core_init();
 336
 337         if (rtnl_open(&rth, 0) < 0) {
 338                 fprintf(stderr, "Cannot open rtnetlink\n");
 339                 return -1;
 340         }
 341
 342         cmdlineno = 0;
 343         if (getcmdline(&line, &len, stdin) == -1)
 344                 goto Exit;
 345         largc = makeargs(line, largv, 100);
 346         bs_enabled = batchsize_enabled(largc, largv);
 347         bs_enabled_saved = bs_enabled;
 348         do {
 349                 if (getcmdline(&line_next, &len, stdin) == -1)
 350                         lastline = true;
 351
 352                 largc_next = makeargs(line_next, largv_next, 100);
 353                 bs_enabled_next = batchsize_enabled(largc_next, largv_next);
 354                 if (bs_enabled) {
 355                         struct batch_buf *buf;
 356
 357                         buf = get_batch_buf(&buf_pool, &head, &tail);
 358                         if (!buf) {
 359                                 fprintf(stderr,
 360                                         "failed to allocate batch_buf\n");
 361                                 return -1;
 362                         }
 363                         ++batchsize;
 364                 }
 365
 366                 /*
 367                  * In batch mode, if we haven't accumulated enough commands
 368                  * and this is not the last command and this command & next
 369                  * command both support the batchsize feature, don't send the
 370                  * message immediately.
 371                  */
 372                 if (!lastline && bs_enabled && bs_enabled_next
 373                     && batchsize != MSG_IOV_MAX)
 374                         send = false;
 375                 else
 376                         send = true;
 377
 378                 line = line_next;
 379                 line_next = NULL;
 380                 len = 0;
 381                 bs_enabled_saved = bs_enabled;
 382                 bs_enabled = bs_enabled_next;
 383                 bs_enabled_next = false;
 384
 385                 if (largc == 0) {
 386                         largc = largc_next;
 387                         memcpy(largv, largv_next, largc * sizeof(char *));
 388                         continue;       /* blank line */
 389                 }
 390
 391                 ret = do_cmd(largc, largv, tail == NULL ? NULL : tail->buf,
 392                              tail == NULL ? 0 : sizeof (tail->buf));
 393                 if (ret != 0) {
 394                         fprintf(stderr, "Command failed %s:%d\n", name,
 395                                 cmdlineno - 1);
 396                         ret = 1;
 397                         if (!force)
 398                                 break;
 399                 }
 400                 largc = largc_next;
 401                 memcpy(largv, largv_next, largc * sizeof(char *));
 402
 403                 if (send && bs_enabled_saved) {
 404                         struct iovec *iov, *iovs;
 405                         struct batch_buf *buf;
 406                         struct nlmsghdr *n;
 407
 408                         iov = iovs = malloc(batchsize * sizeof (struct iovec));
 409                         for (buf = head; buf != NULL; buf = buf->next, ++iov) {
 410                                 n = (struct nlmsghdr *)&buf->buf;
 411                                 iov->iov_base = n;
 412                                 iov->iov_len = n->nlmsg_len;
 413                         }
 414
 415                         ret = rtnl_talk_iov(&rth, iovs, batchsize, NULL);
 416                         if (ret < 0) {
 417                                 fprintf(stderr, "Command failed %s:%d\n", name,
 418                                         cmdlineno - (batchsize + ret) - 1);
 419                                 return 2;
 420                         }
 421                         put_batch_bufs(&buf_pool, &head, &tail);
 422                         batchsize = 0;
 423                         free(iovs);
 424                 }
 425         } while (!lastline);
 426
 427         free_batch_bufs(&buf_pool);
 428 Exit:
 429         free(line);
 430         rtnl_close(&rth);
 431
 432         return ret;
 433 }
 434
 435
 436 int main(int argc, char **argv)
 437 {
 438         int ret;
 439         char *batch_file = NULL;
 440
 441         while (argc > 1) {
 442                 if (argv[1][0] != '-')
 443                         break;
 444                 if (matches(argv[1], "-stats") == 0 ||
 445                          matches(argv[1], "-statistics") == 0) {
 446                         ++show_stats;
 447                 } else if (matches(argv[1], "-details") == 0) {
 448                         ++show_details;
 449                 } else if (matches(argv[1], "-raw") == 0) {
 450                         ++show_raw;
 451                 } else if (matches(argv[1], "-pretty") == 0) {
 452                         ++pretty;
 453                 } else if (matches(argv[1], "-graph") == 0) {
 454                         show_graph = 1;
 455                 } else if (matches(argv[1], "-Version") == 0) {
 456                         printf("tc utility, iproute2-ss%s\n", SNAPSHOT);
 457                         return 0;
 458                 } else if (matches(argv[1], "-iec") == 0) {
 459                         ++use_iec;
 460                 } else if (matches(argv[1], "-help") == 0) {
 461                         usage();
 462                         return 0;
 463                 } else if (matches(argv[1], "-force") == 0) {
 464                         ++force;
 465                 } else if (matches(argv[1], "-batch") == 0) {
 466                         argc--; argv++;
 467                         if (argc <= 1)
 468                                 usage();
 469                         batch_file = argv[1];
 470                 } else if (matches(argv[1], "-netns") == 0) {
 471                         NEXT_ARG();
 472                         if (netns_switch(argv[1]))
 473                                 return -1;
 474                 } else if (matches(argv[1], "-names") == 0 ||
 475                                 matches(argv[1], "-nm") == 0) {
 476                         use_names = true;
 477                 } else if (matches(argv[1], "-cf") == 0 ||
 478                                 matches(argv[1], "-conf") == 0) {
 479                         NEXT_ARG();
 480                         conf_file = argv[1];
 481                 } else if (matches(argv[1], "-color") == 0) {
 482                         ++color;
 483                 } else if (matches(argv[1], "-timestamp") == 0) {
 484                         timestamp++;
 485                 } else if (matches(argv[1], "-tshort") == 0) {
 486                         ++timestamp;
 487                         ++timestamp_short;
 488                 } else if (matches(argv[1], "-json") == 0) {
 489                         ++json;
 490                 } else {
 491                         fprintf(stderr, "Option \"%s\" is unknown, try \"tc -help\".\n", argv[1]);
 492                         return -1;
 493                 }
 494                 argc--; argv++;
 495         }
 496
 497         if (color & !json)
 498                 enable_color();
 499
 500         if (batch_file)
 501                 return batch(batch_file);
 502
 503         if (argc <= 1) {
 504                 usage();
 505                 return 0;
 506         }
 507
 508         tc_core_init();
 509         if (rtnl_open(&rth, 0) < 0) {
 510                 fprintf(stderr, "Cannot open rtnetlink\n");
 511                 exit(1);
 512         }
 513
 514         if (use_names && cls_names_init(conf_file)) {
 515                 ret = -1;
 516                 goto Exit;
 517         }
 518
 519         ret = do_cmd(argc-1, argv+1, NULL, 0);
 520 Exit:
 521         rtnl_close(&rth);
 522
 523         if (use_names)
 524                 cls_names_uninit();
 525
 526         return ret;
 527 }