2 * em_meta.c Metadata Ematch
4 * This program is free software; you can distribute 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.
9 * Authors: Thomas Graf <tgraf@suug.ch>
17 #include <sys/socket.h>
18 #include <netinet/in.h>
19 #include <arpa/inet.h>
25 #include <linux/tc_ematch/tc_em_meta.h>
27 extern struct ematch_util meta_ematch_util;
29 static void meta_print_usage(FILE *fd)
32 "Usage: meta(OBJECT { eq | lt | gt } OBJECT)\n" \
33 "where: OBJECT := { META_ID | VALUE }\n" \
34 " META_ID := id [ shift SHIFT ] [ mask MASK ]\n" \
36 "Example: meta(nfmark gt 24)\n" \
37 " meta(indev shift 1 eq \"ppp\"\n" \
38 " meta(tcindex mask 0xf0 eq 0xf0)\n" \
39 " meta(dev eq indev)\n" \
41 "For a list of meta identifiers, use meta(list).\n");
50 #define TCF_META_ID_SECTION 0
51 #define __A(id, name, mask, desc) { TCF_META_ID_##id, name, mask, desc }
52 __A(SECTION, "Generic", "", ""),
53 __A(RANDOM, "random", "i",
54 "Random value (32 bit)"),
55 __A(LOADAVG_0, "loadavg_1", "i",
56 "Load average in last minute"),
57 __A(LOADAVG_1, "loadavg_5", "i",
58 "Load average in last 5 minutes"),
59 __A(LOADAVG_2, "loadavg_15", "i",
60 "Load average in last 15 minutes"),
62 __A(SECTION, "Interfaces", "", ""),
64 "Device the packet is on"),
65 __A(SECTION, "Packet attributes", "", ""),
66 __A(PRIORITY, "priority", "i",
67 "Priority of packet"),
68 __A(PROTOCOL, "protocol", "i",
69 "Link layer protocol"),
70 __A(PKTTYPE, "pkt_type", "i",
71 "Packet type (uni|multi|broad|...)cast"),
72 __A(PKTLEN, "pkt_len", "i",
74 __A(DATALEN, "data_len", "i",
75 "Length of data in packet"),
76 __A(MACLEN, "mac_len", "i",
77 "Length of link layer header"),
79 __A(SECTION, "Netfilter", "", ""),
80 __A(NFMARK, "nf_mark", "i",
82 __A(NFMARK, "fwmark", "i",
85 __A(SECTION, "Traffic Control", "", ""),
86 __A(TCINDEX, "tc_index", "i", "TC Index"),
87 __A(SECTION, "Routing", "", ""),
88 __A(RTCLASSID, "rt_classid", "i",
89 "Routing ClassID (cls_route)"),
90 __A(RTIIF, "rt_iif", "i",
91 "Incoming interface index"),
93 __A(SECTION, "Sockets", "", ""),
94 __A(SK_FAMILY, "sk_family", "i", "Address family"),
95 __A(SK_STATE, "sk_state", "i", "State"),
96 __A(SK_REUSE, "sk_reuse", "i", "Reuse Flag"),
97 __A(SK_BOUND_IF, "sk_bind_if", "iv", "Bound interface"),
98 __A(SK_REFCNT, "sk_refcnt", "i", "Reference counter"),
99 __A(SK_SHUTDOWN, "sk_shutdown", "i", "Shutdown mask"),
100 __A(SK_PROTO, "sk_proto", "i", "Protocol"),
101 __A(SK_TYPE, "sk_type", "i", "Type"),
102 __A(SK_RCVBUF, "sk_rcvbuf", "i", "Receive buffer size"),
103 __A(SK_RMEM_ALLOC, "sk_rmem", "i", "RMEM"),
104 __A(SK_WMEM_ALLOC, "sk_wmem", "i", "WMEM"),
105 __A(SK_OMEM_ALLOC, "sk_omem", "i", "OMEM"),
106 __A(SK_WMEM_QUEUED, "sk_wmem_queue","i", "WMEM queue"),
107 __A(SK_SND_QLEN, "sk_snd_queue", "i", "Send queue length"),
108 __A(SK_RCV_QLEN, "sk_rcv_queue", "i", "Receive queue length"),
109 __A(SK_ERR_QLEN, "sk_err_queue", "i", "Error queue length"),
110 __A(SK_FORWARD_ALLOCS, "sk_fwd_alloc", "i", "Forward allocations"),
111 __A(SK_SNDBUF, "sk_sndbuf", "i", "Send buffer size"),
112 __A(VLAN_TAG, "vlan", "i", "Vlan tag"),
116 static inline int map_type(char k)
119 case 'i': return TCF_META_TYPE_INT;
120 case 'v': return TCF_META_TYPE_VAR;
123 fprintf(stderr, "BUG: Unknown map character '%c'\n", k);
127 static struct meta_entry * lookup_meta_entry(struct bstr *kind)
131 for (i = 0; i < (sizeof(meta_table)/sizeof(meta_table[0])); i++)
132 if (!bstrcmp(kind, meta_table[i].kind) &&
133 meta_table[i].id != 0)
134 return &meta_table[i];
139 static struct meta_entry * lookup_meta_entry_byid(int id)
143 for (i = 0; i < (sizeof(meta_table)/sizeof(meta_table[0])); i++)
144 if (meta_table[i].id == id)
145 return &meta_table[i];
150 static inline void dump_value(struct nlmsghdr *n, int tlv, unsigned long val,
151 struct tcf_meta_val *hdr)
155 switch (TCF_META_TYPE(hdr->kind)) {
156 case TCF_META_TYPE_INT:
158 addattr_l(n, MAX_MSG, tlv, &t, sizeof(t));
161 case TCF_META_TYPE_VAR:
162 if (TCF_META_ID(hdr->kind) == TCF_META_ID_VALUE) {
163 struct bstr *a = (struct bstr *) val;
164 addattr_l(n, MAX_MSG, tlv, a->data, a->len);
170 static inline int is_compatible(struct tcf_meta_val *what,
171 struct tcf_meta_val *needed)
174 struct meta_entry *entry;
176 entry = lookup_meta_entry_byid(TCF_META_ID(what->kind));
181 for (p = entry->mask; p; p++)
182 if (map_type(*p) == TCF_META_TYPE(needed->kind))
188 static void list_meta_ids(FILE *fd)
193 "--------------------------------------------------------\n" \
194 " ID Type Description\n" \
195 "--------------------------------------------------------");
197 for (i = 0; i < (sizeof(meta_table)/sizeof(meta_table[0])); i++) {
198 if (meta_table[i].id == TCF_META_ID_SECTION) {
199 fprintf(fd, "\n%s:\n", meta_table[i].kind);
201 char *p = meta_table[i].mask;
204 fprintf(fd, " %-16s ", meta_table[i].kind);
207 int type = map_type(*p);
210 case TCF_META_TYPE_INT:
214 case TCF_META_TYPE_VAR:
223 fprintf(fd, "%-10s %s\n", buf, meta_table[i].desc);
228 "--------------------------------------------------------\n");
231 #undef TCF_META_ID_SECTION
233 #define PARSE_FAILURE ((void *) (-1))
235 #define PARSE_ERR(CARG, FMT, ARGS...) \
236 em_parse_error(EINVAL, args, CARG, &meta_ematch_util, FMT ,##ARGS)
238 static inline int can_adopt(struct tcf_meta_val *val)
240 return !!TCF_META_ID(val->kind);
243 static inline int overwrite_type(struct tcf_meta_val *src,
244 struct tcf_meta_val *dst)
246 return (TCF_META_TYPE(dst->kind) << 12) | TCF_META_ID(src->kind);
250 static inline struct bstr *
251 parse_object(struct bstr *args, struct bstr *arg, struct tcf_meta_val *obj,
252 unsigned long *dst, struct tcf_meta_val *left)
254 struct meta_entry *entry;
259 obj->kind = TCF_META_TYPE_VAR << 12;
260 obj->kind |= TCF_META_ID_VALUE;
261 *dst = (unsigned long) arg;
262 return bstr_next(arg);
266 if (num != LONG_MAX) {
267 obj->kind = TCF_META_TYPE_INT << 12;
268 obj->kind |= TCF_META_ID_VALUE;
269 *dst = (unsigned long) num;
270 return bstr_next(arg);
273 entry = lookup_meta_entry(arg);
276 PARSE_ERR(arg, "meta: unknown meta id\n");
277 return PARSE_FAILURE;
280 obj->kind = entry->id | (map_type(entry->mask[0]) << 12);
283 struct tcf_meta_val *right = obj;
285 if (TCF_META_TYPE(right->kind) == TCF_META_TYPE(left->kind))
288 if (can_adopt(left) && !can_adopt(right)) {
289 if (is_compatible(left, right))
290 left->kind = overwrite_type(left, right);
293 } else if (can_adopt(right) && !can_adopt(left)) {
294 if (is_compatible(right, left))
295 right->kind = overwrite_type(right, left);
298 } else if (can_adopt(left) && can_adopt(right)) {
299 if (is_compatible(left, right))
300 left->kind = overwrite_type(left, right);
301 else if (is_compatible(right, left))
302 right->kind = overwrite_type(right, left);
314 if (!bstrcmp(a, "shift")) {
317 if (a->next == NULL) {
318 PARSE_ERR(a, "meta: missing argument");
319 return PARSE_FAILURE;
324 if (shift == LONG_MAX) {
325 PARSE_ERR(a, "meta: invalid shift, must " \
327 return PARSE_FAILURE;
330 obj->shift = (__u8) shift;
332 } else if (!bstrcmp(a, "mask")) {
335 if (a->next == NULL) {
336 PARSE_ERR(a, "meta: missing argument");
337 return PARSE_FAILURE;
342 if (mask == LONG_MAX) {
343 PARSE_ERR(a, "meta: invalid mask, must be " \
345 return PARSE_FAILURE;
347 *dst = (unsigned long) mask;
356 PARSE_ERR(arg, "lvalue and rvalue are not compatible.");
357 return PARSE_FAILURE;
360 static int meta_parse_eopt(struct nlmsghdr *n, struct tcf_ematch_hdr *hdr,
365 struct tcf_meta_hdr meta_hdr;
366 unsigned long lvalue = 0, rvalue = 0;
368 memset(&meta_hdr, 0, sizeof(meta_hdr));
371 return PARSE_ERR(args, "meta: missing arguments");
373 if (!bstrcmp(args, "list")) {
374 list_meta_ids(stderr);
378 a = parse_object(args, args, &meta_hdr.left, &lvalue, NULL);
379 if (a == PARSE_FAILURE)
382 return PARSE_ERR(args, "meta: missing operand");
384 if (!bstrcmp(a, "eq"))
385 opnd = TCF_EM_OPND_EQ;
386 else if (!bstrcmp(a, "gt"))
387 opnd = TCF_EM_OPND_GT;
388 else if (!bstrcmp(a, "lt"))
389 opnd = TCF_EM_OPND_LT;
391 return PARSE_ERR(a, "meta: invalid operand");
393 meta_hdr.left.op = (__u8) opnd;
396 return PARSE_ERR(args, "meta: missing rvalue");
399 a = parse_object(args, a, &meta_hdr.right, &rvalue, &meta_hdr.left);
400 if (a == PARSE_FAILURE)
403 return PARSE_ERR(a, "meta: unexpected trailer");
406 addraw_l(n, MAX_MSG, hdr, sizeof(*hdr));
408 addattr_l(n, MAX_MSG, TCA_EM_META_HDR, &meta_hdr, sizeof(meta_hdr));
410 dump_value(n, TCA_EM_META_LVALUE, lvalue, &meta_hdr.left);
411 dump_value(n, TCA_EM_META_RVALUE, rvalue, &meta_hdr.right);
417 static inline void print_binary(FILE *fd, unsigned char *str, int len)
421 for (i = 0; i < len; i++)
422 if (!isprint(str[i]))
425 for (i = 0; i < len; i++)
426 fprintf(fd, "%c", str[i]);
430 for (i = 0; i < len; i++)
431 fprintf(fd, "%02x ", str[i]);
434 for (i = 0; i < len; i++)
435 fprintf(fd, "%c", isprint(str[i]) ? str[i] : '.');
439 static inline int print_value(FILE *fd, int type, struct rtattr *rta)
442 fprintf(stderr, "Missing value TLV\n");
447 case TCF_META_TYPE_INT:
448 if (RTA_PAYLOAD(rta) < sizeof(__u32)) {
449 fprintf(stderr, "meta int type value TLV " \
453 fprintf(fd, "%d", *(__u32 *) RTA_DATA(rta));
456 case TCF_META_TYPE_VAR:
457 print_binary(fd, RTA_DATA(rta), RTA_PAYLOAD(rta));
464 static int print_object(FILE *fd, struct tcf_meta_val *obj, struct rtattr *rta)
466 int id = TCF_META_ID(obj->kind);
467 int type = TCF_META_TYPE(obj->kind);
468 struct meta_entry *entry;
470 if (id == TCF_META_ID_VALUE)
471 return print_value(fd, type, rta);
473 entry = lookup_meta_entry_byid(id);
476 fprintf(fd, "[unknown meta id %d]", id);
478 fprintf(fd, "%s", entry->kind);
481 fprintf(fd, " shift %d", obj->shift);
484 case TCF_META_TYPE_INT:
486 if (RTA_PAYLOAD(rta) < sizeof(__u32))
489 fprintf(fd, " mask 0x%08x",
490 *(__u32*) RTA_DATA(rta));
498 fprintf(stderr, "meta int type mask TLV size mismatch\n");
503 static int meta_print_eopt(FILE *fd, struct tcf_ematch_hdr *hdr, void *data,
506 struct rtattr *tb[TCA_EM_META_MAX+1];
507 struct tcf_meta_hdr *meta_hdr;
509 if (parse_rtattr(tb, TCA_EM_META_MAX, data, data_len) < 0)
512 if (tb[TCA_EM_META_HDR] == NULL) {
513 fprintf(stderr, "Missing meta header\n");
517 if (RTA_PAYLOAD(tb[TCA_EM_META_HDR]) < sizeof(*meta_hdr)) {
518 fprintf(stderr, "Meta header size mismatch\n");
522 meta_hdr = RTA_DATA(tb[TCA_EM_META_HDR]);
524 if (print_object(fd, &meta_hdr->left, tb[TCA_EM_META_LVALUE]) < 0)
527 switch (meta_hdr->left.op) {
539 return print_object(fd, &meta_hdr->right, tb[TCA_EM_META_RVALUE]);
542 struct ematch_util meta_ematch_util = {
544 .kind_num = TCF_EM_META,
545 .parse_eopt = meta_parse_eopt,
546 .print_eopt = meta_print_eopt,
547 .print_usage = meta_print_usage