/*
* em_meta.c Metadata Ematch
*
* This program is free software; you can distribute 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: Thomas Graf <tgraf@suug.ch>
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <errno.h>
#include "m_ematch.h"
#include <linux/tc_ematch/tc_em_meta.h>
extern struct ematch_util meta_ematch_util;
static void meta_print_usage(FILE *fd)
{
fprintf(fd,
"Usage: meta(OBJECT { eq | lt | gt } OBJECT)\n" \
"where: OBJECT := { META_ID | VALUE }\n" \
" META_ID := id [ shift SHIFT ] [ mask MASK ]\n" \
"\n" \
"Example: meta(nf_mark gt 24)\n" \
" meta(indev shift 1 eq \"ppp\")\n" \
" meta(tcindex mask 0xf0 eq 0xf0)\n" \
"\n" \
"For a list of meta identifiers, use meta(list).\n");
}
static const struct meta_entry {
int id;
char *kind;
char *mask;
char *desc;
} meta_table[] = {
#define TCF_META_ID_SECTION 0
#define __A(id, name, mask, desc) { TCF_META_ID_##id, name, mask, desc }
__A(SECTION, "Generic", "", ""),
__A(RANDOM, "random", "i",
"Random value (32 bit)"),
__A(LOADAVG_0, "loadavg_1", "i",
"Load average in last minute"),
__A(LOADAVG_1, "loadavg_5", "i",
"Load average in last 5 minutes"),
__A(LOADAVG_2, "loadavg_15", "i",
"Load average in last 15 minutes"),
__A(SECTION, "Interfaces", "", ""),
__A(DEV, "dev", "iv",
"Device the packet is on"),
__A(SECTION, "Packet attributes", "", ""),
__A(PRIORITY, "priority", "i",
"Priority of packet"),
__A(PROTOCOL, "protocol", "i",
"Link layer protocol"),
__A(PKTTYPE, "pkt_type", "i",
"Packet type (uni|multi|broad|...)cast"),
__A(PKTLEN, "pkt_len", "i",
"Length of packet"),
__A(DATALEN, "data_len", "i",
"Length of data in packet"),
__A(MACLEN, "mac_len", "i",
"Length of link layer header"),
__A(SECTION, "Netfilter", "", ""),
__A(NFMARK, "nf_mark", "i",
"Netfilter mark"),
__A(NFMARK, "fwmark", "i",
"Alias for nf_mark"),
__A(SECTION, "Traffic Control", "", ""),
__A(TCINDEX, "tc_index", "i", "TC Index"),
__A(SECTION, "Routing", "", ""),
__A(RTCLASSID, "rt_classid", "i",
"Routing ClassID (cls_route)"),
__A(RTIIF, "rt_iif", "i",
"Incoming interface index"),
__A(VLAN_TAG, "vlan", "i", "Vlan tag"),
__A(SECTION, "Sockets", "", ""),
__A(SK_FAMILY, "sk_family", "i", "Address family"),
__A(SK_STATE, "sk_state", "i", "State"),
__A(SK_REUSE, "sk_reuse", "i", "Reuse Flag"),
__A(SK_BOUND_IF, "sk_bind_if", "iv", "Bound interface"),
__A(SK_REFCNT, "sk_refcnt", "i", "Reference counter"),
__A(SK_SHUTDOWN, "sk_shutdown", "i", "Shutdown mask"),
__A(SK_PROTO, "sk_proto", "i", "Protocol"),
__A(SK_TYPE, "sk_type", "i", "Type"),
__A(SK_RCVBUF, "sk_rcvbuf", "i", "Receive buffer size"),
__A(SK_RMEM_ALLOC, "sk_rmem", "i", "RMEM"),
__A(SK_WMEM_ALLOC, "sk_wmem", "i", "WMEM"),
__A(SK_OMEM_ALLOC, "sk_omem", "i", "OMEM"),
__A(SK_WMEM_QUEUED, "sk_wmem_queue", "i", "WMEM queue"),
__A(SK_SND_QLEN, "sk_snd_queue", "i", "Send queue length"),
__A(SK_RCV_QLEN, "sk_rcv_queue", "i", "Receive queue length"),
__A(SK_ERR_QLEN, "sk_err_queue", "i", "Error queue length"),
__A(SK_FORWARD_ALLOCS, "sk_fwd_alloc", "i", "Forward allocations"),
__A(SK_SNDBUF, "sk_sndbuf", "i", "Send buffer size"),
#undef __A
};
static inline int map_type(char k)
{
switch (k) {
case 'i': return TCF_META_TYPE_INT;
case 'v': return TCF_META_TYPE_VAR;
}
fprintf(stderr, "BUG: Unknown map character '%c'\n", k);
return INT_MAX;
}
static const struct meta_entry *lookup_meta_entry(struct bstr *kind)
{
int i;
for (i = 0; i < ARRAY_SIZE(meta_table); i++)
if (!bstrcmp(kind, meta_table[i].kind) &&
meta_table[i].id != 0)
return &meta_table[i];
return NULL;
}
static const struct meta_entry *lookup_meta_entry_byid(int id)
{
int i;
for (i = 0; i < ARRAY_SIZE(meta_table); i++)
if (meta_table[i].id == id)
return &meta_table[i];
return NULL;
}
static inline void dump_value(struct nlmsghdr *n, int tlv, unsigned long val,
struct tcf_meta_val *hdr)
{
__u32 t;
switch (TCF_META_TYPE(hdr->kind)) {
case TCF_META_TYPE_INT:
t = val;
addattr_l(n, MAX_MSG, tlv, &t, sizeof(t));
break;
case TCF_META_TYPE_VAR:
if (TCF_META_ID(hdr->kind) == TCF_META_ID_VALUE) {
struct bstr *a = (struct bstr *) val;
addattr_l(n, MAX_MSG, tlv, a->data, a->len);
}
break;
}
}
static inline int is_compatible(struct tcf_meta_val *what,
struct tcf_meta_val *needed)
{
const struct meta_entry *entry;
char *p;
entry = lookup_meta_entry_byid(TCF_META_ID(what->kind));
if (entry == NULL)
return 0;
for (p = entry->mask; p; p++)
if (map_type(*p) == TCF_META_TYPE(needed->kind))
return 1;
return 0;
}
static void list_meta_ids(FILE *fd)
{
int i;
fprintf(fd,
"--------------------------------------------------------\n" \
" ID Type Description\n" \
"--------------------------------------------------------");
for (i = 0; i < ARRAY_SIZE(meta_table); i++) {
if (meta_table[i].id == TCF_META_ID_SECTION) {
fprintf(fd, "\n%s:\n", meta_table[i].kind);
} else {
char *p = meta_table[i].mask;
char buf[64] = {0};
fprintf(fd, " %-16s ", meta_table[i].kind);
while (*p) {
int type = map_type(*p);
switch (type) {
case TCF_META_TYPE_INT:
strcat(buf, "INT");
break;
case TCF_META_TYPE_VAR:
strcat(buf, "VAR");
break;
}
if (*(++p))
strcat(buf, ",");
}
fprintf(fd, "%-10s %s\n", buf, meta_table[i].desc);
}
}
fprintf(fd,
"--------------------------------------------------------\n");
}
#undef TCF_META_ID_SECTION
#define PARSE_FAILURE ((void *) (-1))
#define PARSE_ERR(CARG, FMT, ARGS...) \
em_parse_error(EINVAL, args, CARG, &meta_ematch_util, FMT, ##ARGS)
static inline int can_adopt(struct tcf_meta_val *val)
{
return !!TCF_META_ID(val->kind);
}
static inline int overwrite_type(struct tcf_meta_val *src,
struct tcf_meta_val *dst)
{
return (TCF_META_TYPE(dst->kind) << 12) | TCF_META_ID(src->kind);
}
static inline struct bstr *
parse_object(struct bstr *args, struct bstr *arg, struct tcf_meta_val *obj,
unsigned long *dst, struct tcf_meta_val *left)
{
const struct meta_entry *entry;
unsigned long num;
struct bstr *a;
if (arg->quoted) {
obj->kind = TCF_META_TYPE_VAR << 12;
obj->kind |= TCF_META_ID_VALUE;
*dst = (unsigned long) arg;
return bstr_next(arg);
}
num = bstrtoul(arg);
if (num != ULONG_MAX) {
obj->kind = TCF_META_TYPE_INT << 12;
obj->kind |= TCF_META_ID_VALUE;
*dst = (unsigned long) num;
return bstr_next(arg);
}
entry = lookup_meta_entry(arg);
if (entry == NULL) {
PARSE_ERR(arg, "meta: unknown meta id\n");
return PARSE_FAILURE;
}
obj->kind = entry->id | (map_type(entry->mask[0]) << 12);
if (left) {
struct tcf_meta_val *right = obj;
if (TCF_META_TYPE(right->kind) == TCF_META_TYPE(left->kind))
goto compatible;
if (can_adopt(left) && !can_adopt(right)) {
if (is_compatible(left, right))
left->kind = overwrite_type(left, right);
else
goto not_compatible;
} else if (can_adopt(right) && !can_adopt(left)) {
if (is_compatible(right, left))
right->kind = overwrite_type(right, left);
else
goto not_compatible;
} else if (can_adopt(left) && can_adopt(right)) {
if (is_compatible(left, right))
left->kind = overwrite_type(left, right);
else if (is_compatible(right, left))
right->kind = overwrite_type(right, left);
else
goto not_compatible;
} else
goto not_compatible;
}
compatible:
a = bstr_next(arg);
while (a) {
if (!bstrcmp(a, "shift")) {
unsigned long shift;
if (a->next == NULL) {
PARSE_ERR(a, "meta: missing argument");
return PARSE_FAILURE;
}
a = bstr_next(a);
shift = bstrtoul(a);
if (shift == ULONG_MAX) {
PARSE_ERR(a, "meta: invalid shift, must " \
"be numeric");
return PARSE_FAILURE;
}
obj->shift = (__u8) shift;
a = bstr_next(a);
} else if (!bstrcmp(a, "mask")) {
unsigned long mask;
if (a->next == NULL) {
PARSE_ERR(a, "meta: missing argument");
return PARSE_FAILURE;
}
a = bstr_next(a);
mask = bstrtoul(a);
if (mask == ULONG_MAX) {
PARSE_ERR(a, "meta: invalid mask, must be " \
"numeric");
return PARSE_FAILURE;
}
*dst = (unsigned long) mask;
a = bstr_next(a);
} else
break;
}
return a;
not_compatible:
PARSE_ERR(arg, "lvalue and rvalue are not compatible.");
return PARSE_FAILURE;
}
static int meta_parse_eopt(struct nlmsghdr *n, struct tcf_ematch_hdr *hdr,
struct bstr *args)
{
int opnd;
struct bstr *a;
struct tcf_meta_hdr meta_hdr = {};
unsigned long lvalue = 0, rvalue = 0;
if (args == NULL)
return PARSE_ERR(args, "meta: missing arguments");
if (!bstrcmp(args, "list")) {
list_meta_ids(stderr);
return -1;
}
a = parse_object(args, args, &meta_hdr.left, &lvalue, NULL);
if (a == PARSE_FAILURE)
return -1;
else if (a == NULL)
return PARSE_ERR(args, "meta: missing operand");
if (!bstrcmp(a, "eq"))
opnd = TCF_EM_OPND_EQ;
else if (!bstrcmp(a, "gt"))
opnd = TCF_EM_OPND_GT;
else if (!bstrcmp(a, "lt"))
opnd = TCF_EM_OPND_LT;
else
return PARSE_ERR(a, "meta: invalid operand");
meta_hdr.left.op = (__u8) opnd;
if (a->next == NULL)
return PARSE_ERR(args, "meta: missing rvalue");
a = bstr_next(a);
a = parse_object(args, a, &meta_hdr.right, &rvalue, &meta_hdr.left);
if (a == PARSE_FAILURE)
return -1;
else if (a != NULL)
return PARSE_ERR(a, "meta: unexpected trailer");
addraw_l(n, MAX_MSG, hdr, sizeof(*hdr));
addattr_l(n, MAX_MSG, TCA_EM_META_HDR, &meta_hdr, sizeof(meta_hdr));
dump_value(n, TCA_EM_META_LVALUE, lvalue, &meta_hdr.left);
dump_value(n, TCA_EM_META_RVALUE, rvalue, &meta_hdr.right);
return 0;
}
#undef PARSE_ERR
static inline void print_binary(FILE *fd, unsigned char *str, int len)
{
int i;
for (i = 0; i < len; i++)
if (!isprint(str[i]))
goto binary;
for (i = 0; i < len; i++)
fprintf(fd, "%c", str[i]);
return;
binary:
for (i = 0; i < len; i++)
fprintf(fd, "%02x ", str[i]);
fprintf(fd, "\"");
for (i = 0; i < len; i++)
fprintf(fd, "%c", isprint(str[i]) ? str[i] : '.');
fprintf(fd, "\"");
}
static inline int print_value(FILE *fd, int type, struct rtattr *rta)
{
if (rta == NULL) {
fprintf(stderr, "Missing value TLV\n");
return -1;
}
switch (type) {
case TCF_META_TYPE_INT:
if (RTA_PAYLOAD(rta) < sizeof(__u32)) {
fprintf(stderr, "meta int type value TLV " \
"size mismatch.\n");
return -1;
}
fprintf(fd, "%d", rta_getattr_u32(rta));
break;
case TCF_META_TYPE_VAR:
print_binary(fd, RTA_DATA(rta), RTA_PAYLOAD(rta));
break;
}
return 0;
}
static int print_object(FILE *fd, struct tcf_meta_val *obj, struct rtattr *rta)
{
int id = TCF_META_ID(obj->kind);
int type = TCF_META_TYPE(obj->kind);
const struct meta_entry *entry;
if (id == TCF_META_ID_VALUE)
return print_value(fd, type, rta);
entry = lookup_meta_entry_byid(id);
if (entry == NULL)
fprintf(fd, "[unknown meta id %d]", id);
else
fprintf(fd, "%s", entry->kind);
if (obj->shift)
fprintf(fd, " shift %d", obj->shift);
switch (type) {
case TCF_META_TYPE_INT:
if (rta) {
if (RTA_PAYLOAD(rta) < sizeof(__u32))
goto size_mismatch;
if (rta_getattr_u32(rta))
fprintf(fd, " mask 0x%08x",
rta_getattr_u32(rta));
}
break;
}
return 0;
size_mismatch:
fprintf(stderr, "meta int type mask TLV size mismatch\n");
return -1;
}
static int meta_print_eopt(FILE *fd, struct tcf_ematch_hdr *hdr, void *data,
int data_len)
{
struct rtattr *tb[TCA_EM_META_MAX+1];
struct tcf_meta_hdr *meta_hdr;
if (parse_rtattr(tb, TCA_EM_META_MAX, data, data_len) < 0)
return -1;
if (tb[TCA_EM_META_HDR] == NULL) {
fprintf(stderr, "Missing meta header\n");
return -1;
}
if (RTA_PAYLOAD(tb[TCA_EM_META_HDR]) < sizeof(*meta_hdr)) {
fprintf(stderr, "Meta header size mismatch\n");
return -1;
}
meta_hdr = RTA_DATA(tb[TCA_EM_META_HDR]);
if (print_object(fd, &meta_hdr->left, tb[TCA_EM_META_LVALUE]) < 0)
return -1;
switch (meta_hdr->left.op) {
case TCF_EM_OPND_EQ:
fprintf(fd, " eq ");
break;
case TCF_EM_OPND_LT:
fprintf(fd, " lt ");
break;
case TCF_EM_OPND_GT:
fprintf(fd, " gt ");
break;
}
return print_object(fd, &meta_hdr->right, tb[TCA_EM_META_RVALUE]);
}
struct ematch_util meta_ematch_util = {
.kind = "meta",
.kind_num = TCF_EM_META,
.parse_eopt = meta_parse_eopt,
.print_eopt = meta_print_eopt,
.print_usage = meta_print_usage
};