| /* | |
| * tc.c "tc" utility frontend. | |
| * | |
| * 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: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> | |
| * | |
| * Fixes: | |
| * | |
| * Petri Mattila <petri@prihateam.fi> 990308: wrong memset's resulted in faults | |
| */ | |
| #include <stdio.h> | |
| #include <stdlib.h> | |
| #include <unistd.h> | |
| #include <syslog.h> | |
| #include <fcntl.h> | |
| #include <dlfcn.h> | |
| #include <sys/socket.h> | |
| #include <netinet/in.h> | |
| #include <arpa/inet.h> | |
| #include <string.h> | |
| #include <errno.h> | |
| #include "SNAPSHOT.h" | |
| #include "utils.h" | |
| #include "tc_util.h" | |
| #include "tc_common.h" | |
| #include "namespace.h" | |
| int show_stats = 0; | |
| int show_details = 0; | |
| int show_raw = 0; | |
| int show_pretty = 0; | |
| int show_graph = 0; | |
| int timestamp; | |
| int batch_mode = 0; | |
| int resolve_hosts = 0; | |
| int use_iec = 0; | |
| int force = 0; | |
| bool use_names = false; | |
| static char *conf_file; | |
| struct rtnl_handle rth; | |
| static void *BODY = NULL; /* cached handle dlopen(NULL) */ | |
| static struct qdisc_util * qdisc_list; | |
| static struct filter_util * filter_list; | |
| #ifdef ANDROID | |
| extern struct qdisc_util cbq_qdisc_util; | |
| extern struct qdisc_util htb_qdisc_util; | |
| extern struct qdisc_util ingress_qdisc_util; | |
| extern struct filter_util u32_filter_util; | |
| #endif | |
| static int print_noqopt(struct qdisc_util *qu, FILE *f, | |
| struct rtattr *opt) | |
| { | |
| if (opt && RTA_PAYLOAD(opt)) | |
| fprintf(f, "[Unknown qdisc, optlen=%u] ", | |
| (unsigned) RTA_PAYLOAD(opt)); | |
| return 0; | |
| } | |
| static int parse_noqopt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n) | |
| { | |
| if (argc) { | |
| fprintf(stderr, "Unknown qdisc \"%s\", hence option \"%s\" is unparsable\n", qu->id, *argv); | |
| return -1; | |
| } | |
| return 0; | |
| } | |
| static int print_nofopt(struct filter_util *qu, FILE *f, struct rtattr *opt, __u32 fhandle) | |
| { | |
| if (opt && RTA_PAYLOAD(opt)) | |
| fprintf(f, "fh %08x [Unknown filter, optlen=%u] ", | |
| fhandle, (unsigned) RTA_PAYLOAD(opt)); | |
| else if (fhandle) | |
| fprintf(f, "fh %08x ", fhandle); | |
| return 0; | |
| } | |
| static int parse_nofopt(struct filter_util *qu, char *fhandle, int argc, char **argv, struct nlmsghdr *n) | |
| { | |
| __u32 handle; | |
| if (argc) { | |
| fprintf(stderr, "Unknown filter \"%s\", hence option \"%s\" is unparsable\n", qu->id, *argv); | |
| return -1; | |
| } | |
| if (fhandle) { | |
| struct tcmsg *t = NLMSG_DATA(n); | |
| if (get_u32(&handle, fhandle, 16)) { | |
| fprintf(stderr, "Unparsable filter ID \"%s\"\n", fhandle); | |
| return -1; | |
| } | |
| t->tcm_handle = handle; | |
| } | |
| return 0; | |
| } | |
| struct qdisc_util *get_qdisc_kind(const char *str) | |
| { | |
| void *dlh; | |
| char buf[256]; | |
| struct qdisc_util *q; | |
| #ifdef ANDROID | |
| if (!strcmp(str, "cbq")) | |
| return &cbq_qdisc_util; | |
| else if (!strcmp(str, "htb")) | |
| return &htb_qdisc_util; | |
| else if (!strcmp(str, "ingress")) | |
| return &ingress_qdisc_util; | |
| else { | |
| fprintf(stderr, "Android does not support qdisc '%s'\n", str); | |
| return NULL; | |
| } | |
| #endif | |
| for (q = qdisc_list; q; q = q->next) | |
| if (strcmp(q->id, str) == 0) | |
| return q; | |
| snprintf(buf, sizeof(buf), "%s/q_%s.so", get_tc_lib(), str); | |
| dlh = dlopen(buf, RTLD_LAZY); | |
| if (!dlh) { | |
| /* look in current binary, only open once */ | |
| dlh = BODY; | |
| if (dlh == NULL) { | |
| dlh = BODY = dlopen(NULL, RTLD_LAZY); | |
| if (dlh == NULL) | |
| goto noexist; | |
| } | |
| } | |
| snprintf(buf, sizeof(buf), "%s_qdisc_util", str); | |
| q = dlsym(dlh, buf); | |
| if (q == NULL) | |
| goto noexist; | |
| reg: | |
| q->next = qdisc_list; | |
| qdisc_list = q; | |
| return q; | |
| noexist: | |
| q = malloc(sizeof(*q)); | |
| if (q) { | |
| memset(q, 0, sizeof(*q)); | |
| q->id = strcpy(malloc(strlen(str)+1), str); | |
| q->parse_qopt = parse_noqopt; | |
| q->print_qopt = print_noqopt; | |
| goto reg; | |
| } | |
| return q; | |
| } | |
| struct filter_util *get_filter_kind(const char *str) | |
| { | |
| void *dlh; | |
| char buf[256]; | |
| struct filter_util *q; | |
| #ifdef ANDROID | |
| if (!strcmp(str, "u32")) | |
| return &u32_filter_util; | |
| else { | |
| fprintf(stderr, "Android does not support filter '%s'\n", str); | |
| return NULL; | |
| } | |
| #endif | |
| for (q = filter_list; q; q = q->next) | |
| if (strcmp(q->id, str) == 0) | |
| return q; | |
| snprintf(buf, sizeof(buf), "%s/f_%s.so", get_tc_lib(), str); | |
| dlh = dlopen(buf, RTLD_LAZY); | |
| if (dlh == NULL) { | |
| dlh = BODY; | |
| if (dlh == NULL) { | |
| dlh = BODY = dlopen(NULL, RTLD_LAZY); | |
| if (dlh == NULL) | |
| goto noexist; | |
| } | |
| } | |
| snprintf(buf, sizeof(buf), "%s_filter_util", str); | |
| q = dlsym(dlh, buf); | |
| if (q == NULL) | |
| goto noexist; | |
| reg: | |
| q->next = filter_list; | |
| filter_list = q; | |
| return q; | |
| noexist: | |
| q = malloc(sizeof(*q)); | |
| if (q) { | |
| memset(q, 0, sizeof(*q)); | |
| strncpy(q->id, str, 15); | |
| q->parse_fopt = parse_nofopt; | |
| q->print_fopt = print_nofopt; | |
| goto reg; | |
| } | |
| return q; | |
| } | |
| static void usage(void) | |
| { | |
| fprintf(stderr, "Usage: tc [ OPTIONS ] OBJECT { COMMAND | help }\n" | |
| #ifdef ANDROID | |
| " tc [-force]\n" | |
| #else | |
| " tc [-force] -batch filename\n" | |
| #endif | |
| "where OBJECT := { qdisc | class | filter | action | monitor | exec }\n" | |
| " OPTIONS := { -s[tatistics] | -d[etails] | -r[aw] | -p[retty] | -b[atch] [filename] | " | |
| "-n[etns] name |\n" | |
| " -nm | -nam[es] | { -cf | -conf } path }\n"); | |
| } | |
| static int do_cmd(int argc, char **argv) | |
| { | |
| if (matches(*argv, "qdisc") == 0) | |
| return do_qdisc(argc-1, argv+1); | |
| if (matches(*argv, "class") == 0) | |
| return do_class(argc-1, argv+1); | |
| if (matches(*argv, "filter") == 0) | |
| return do_filter(argc-1, argv+1); | |
| if (matches(*argv, "actions") == 0) | |
| return do_action(argc-1, argv+1); | |
| if (matches(*argv, "monitor") == 0) | |
| return do_tcmonitor(argc-1, argv+1); | |
| if (matches(*argv, "exec") == 0) | |
| return do_exec(argc-1, argv+1); | |
| if (matches(*argv, "help") == 0) { | |
| usage(); | |
| return 0; | |
| } | |
| fprintf(stderr, "Object \"%s\" is unknown, try \"tc help\".\n", | |
| *argv); | |
| return -1; | |
| } | |
| #ifndef ANDROID | |
| static int batch(const char *name) | |
| { | |
| char *line = NULL; | |
| size_t len = 0; | |
| int ret = 0; | |
| batch_mode = 1; | |
| if (name && strcmp(name, "-") != 0) { | |
| if (freopen(name, "r", stdin) == NULL) { | |
| fprintf(stderr, "Cannot open file \"%s\" for reading: %s\n", | |
| name, strerror(errno)); | |
| return -1; | |
| } | |
| } | |
| tc_core_init(); | |
| if (rtnl_open(&rth, 0) < 0) { | |
| fprintf(stderr, "Cannot open rtnetlink\n"); | |
| return -1; | |
| } | |
| cmdlineno = 0; | |
| while (getcmdline(&line, &len, stdin) != -1) { | |
| char *largv[100]; | |
| int largc; | |
| largc = makeargs(line, largv, 100); | |
| if (largc == 0) | |
| continue; /* blank line */ | |
| if (do_cmd(largc, largv)) { | |
| fprintf(stderr, "Command failed %s:%d\n", name, cmdlineno); | |
| ret = 1; | |
| if (!force) | |
| break; | |
| } | |
| } | |
| if (line) | |
| free(line); | |
| rtnl_close(&rth); | |
| return ret; | |
| } | |
| #endif | |
| int main(int argc, char **argv) | |
| { | |
| int ret; | |
| #ifndef ANDROID | |
| char *batch_file = NULL; | |
| #endif | |
| while (argc > 1) { | |
| if (argv[1][0] != '-') | |
| break; | |
| if (matches(argv[1], "-stats") == 0 || | |
| matches(argv[1], "-statistics") == 0) { | |
| ++show_stats; | |
| } else if (matches(argv[1], "-details") == 0) { | |
| ++show_details; | |
| } else if (matches(argv[1], "-raw") == 0) { | |
| ++show_raw; | |
| } else if (matches(argv[1], "-pretty") == 0) { | |
| ++show_pretty; | |
| } else if (matches(argv[1], "-graph") == 0) { | |
| show_graph = 1; | |
| } else if (matches(argv[1], "-Version") == 0) { | |
| printf("tc utility, iproute2-ss%s\n", SNAPSHOT); | |
| return 0; | |
| } else if (matches(argv[1], "-iec") == 0) { | |
| ++use_iec; | |
| } else if (matches(argv[1], "-help") == 0) { | |
| usage(); | |
| return 0; | |
| } else if (matches(argv[1], "-force") == 0) { | |
| ++force; | |
| #ifndef ANDROID | |
| } else if (matches(argv[1], "-batch") == 0) { | |
| argc--; argv++; | |
| if (argc <= 1) | |
| usage(); | |
| batch_file = argv[1]; | |
| #endif | |
| } else if (matches(argv[1], "-netns") == 0) { | |
| NEXT_ARG(); | |
| if (netns_switch(argv[1])) | |
| return -1; | |
| } else if (matches(argv[1], "-names") == 0 || | |
| matches(argv[1], "-nm") == 0) { | |
| use_names = true; | |
| } else if (matches(argv[1], "-cf") == 0 || | |
| matches(argv[1], "-conf") == 0) { | |
| NEXT_ARG(); | |
| conf_file = argv[1]; | |
| } else if (matches(argv[1], "-timestamp") == 0) { | |
| timestamp++; | |
| } else if (matches(argv[1], "-tshort") == 0) { | |
| ++timestamp; | |
| ++timestamp_short; | |
| } else { | |
| fprintf(stderr, "Option \"%s\" is unknown, try \"tc -help\".\n", argv[1]); | |
| return -1; | |
| } | |
| argc--; argv++; | |
| } | |
| #ifndef ANDROID | |
| if (batch_file) | |
| return batch(batch_file); | |
| #endif | |
| if (argc <= 1) { | |
| usage(); | |
| return 0; | |
| } | |
| tc_core_init(); | |
| if (rtnl_open(&rth, 0) < 0) { | |
| fprintf(stderr, "Cannot open rtnetlink\n"); | |
| exit(1); | |
| } | |
| if (use_names && cls_names_init(conf_file)) { | |
| ret = -1; | |
| goto Exit; | |
| } | |
| ret = do_cmd(argc-1, argv+1); | |
| Exit: | |
| rtnl_close(&rth); | |
| if (use_names) | |
| cls_names_uninit(); | |
| return ret; | |
| } |