1 /* 2 * f_flow.c Flow filter 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: Patrick McHardy <kaber (at) trash.net> 10 */ 11 #include <stdio.h> 12 #include <stdlib.h> 13 #include <unistd.h> 14 #include <string.h> 15 #include <errno.h> 16 17 #include "utils.h" 18 #include "tc_util.h" 19 #include "m_ematch.h" 20 21 static void explain(void) 22 { 23 fprintf(stderr, 24 "Usage: ... flow ...\n" 25 "\n" 26 " [mapping mode]: map key KEY [ OPS ] ...\n" 27 " [hashing mode]: hash keys KEY-LIST ... [ perturb SECS ]\n" 28 "\n" 29 " [ divisor NUM ] [ baseclass ID ] [ match EMATCH_TREE ]\n" 30 " [ police POLICE_SPEC ] [ action ACTION_SPEC ]\n" 31 "\n" 32 "KEY-LIST := [ KEY-LIST , ] KEY\n" 33 "KEY := [ src | dst | proto | proto-src | proto-dst | iif | priority | \n" 34 " mark | nfct | nfct-src | nfct-dst | nfct-proto-src | \n" 35 " nfct-proto-dst | rt-classid | sk-uid | sk-gid |\n" 36 " vlan-tag | rxhash ]\n" 37 "OPS := [ or NUM | and NUM | xor NUM | rshift NUM | addend NUM ]\n" 38 "ID := X:Y\n" 39 ); 40 } 41 42 static const char *flow_keys[FLOW_KEY_MAX+1] = { 43 [FLOW_KEY_SRC] = "src", 44 [FLOW_KEY_DST] = "dst", 45 [FLOW_KEY_PROTO] = "proto", 46 [FLOW_KEY_PROTO_SRC] = "proto-src", 47 [FLOW_KEY_PROTO_DST] = "proto-dst", 48 [FLOW_KEY_IIF] = "iif", 49 [FLOW_KEY_PRIORITY] = "priority", 50 [FLOW_KEY_MARK] = "mark", 51 [FLOW_KEY_NFCT] = "nfct", 52 [FLOW_KEY_NFCT_SRC] = "nfct-src", 53 [FLOW_KEY_NFCT_DST] = "nfct-dst", 54 [FLOW_KEY_NFCT_PROTO_SRC] = "nfct-proto-src", 55 [FLOW_KEY_NFCT_PROTO_DST] = "nfct-proto-dst", 56 [FLOW_KEY_RTCLASSID] = "rt-classid", 57 [FLOW_KEY_SKUID] = "sk-uid", 58 [FLOW_KEY_SKGID] = "sk-gid", 59 [FLOW_KEY_VLAN_TAG] = "vlan-tag", 60 [FLOW_KEY_RXHASH] = "rxhash", 61 }; 62 63 static int flow_parse_keys(__u32 *keys, __u32 *nkeys, char *argv) 64 { 65 char *s, *sep; 66 unsigned int i; 67 68 *keys = 0; 69 *nkeys = 0; 70 s = argv; 71 while (s != NULL) { 72 sep = strchr(s, ','); 73 if (sep) 74 *sep = '\0'; 75 76 for (i = 0; i <= FLOW_KEY_MAX; i++) { 77 if (matches(s, flow_keys[i]) == 0) { 78 *keys |= 1 << i; 79 (*nkeys)++; 80 break; 81 } 82 } 83 if (i > FLOW_KEY_MAX) { 84 fprintf(stderr, "Unknown flow key \"%s\"\n", s); 85 return -1; 86 } 87 s = sep ? sep + 1 : NULL; 88 } 89 return 0; 90 } 91 92 static void transfer_bitop(__u32 *mask, __u32 *xor, __u32 m, __u32 x) 93 { 94 *xor = x ^ (*xor & m); 95 *mask &= m; 96 } 97 98 static int get_addend(__u32 *addend, char *argv, __u32 keys) 99 { 100 inet_prefix addr; 101 int sign = 0; 102 __u32 tmp; 103 104 if (*argv == '-') { 105 sign = 1; 106 argv++; 107 } 108 109 if (get_u32(&tmp, argv, 0) == 0) 110 goto out; 111 112 if (keys & (FLOW_KEY_SRC | FLOW_KEY_DST | 113 FLOW_KEY_NFCT_SRC | FLOW_KEY_NFCT_DST) && 114 get_addr(&addr, argv, AF_UNSPEC) == 0) { 115 switch (addr.family) { 116 case AF_INET: 117 tmp = ntohl(addr.data[0]); 118 goto out; 119 case AF_INET6: 120 tmp = ntohl(addr.data[3]); 121 goto out; 122 } 123 } 124 125 return -1; 126 out: 127 if (sign) 128 tmp = -tmp; 129 *addend = tmp; 130 return 0; 131 } 132 133 static int flow_parse_opt(struct filter_util *fu, char *handle, 134 int argc, char **argv, struct nlmsghdr *n) 135 { 136 struct tc_police tp; 137 struct tcmsg *t = NLMSG_DATA(n); 138 struct rtattr *tail; 139 __u32 mask = ~0U, xor = 0; 140 __u32 keys = 0, nkeys = 0; 141 __u32 mode = FLOW_MODE_MAP; 142 __u32 tmp; 143 144 memset(&tp, 0, sizeof(tp)); 145 146 if (handle) { 147 if (get_u32(&t->tcm_handle, handle, 0)) { 148 fprintf(stderr, "Illegal \"handle\"\n"); 149 return -1; 150 } 151 } 152 153 tail = NLMSG_TAIL(n); 154 addattr_l(n, 4096, TCA_OPTIONS, NULL, 0); 155 156 while (argc > 0) { 157 if (matches(*argv, "map") == 0) { 158 mode = FLOW_MODE_MAP; 159 } else if (matches(*argv, "hash") == 0) { 160 mode = FLOW_MODE_HASH; 161 } else if (matches(*argv, "keys") == 0) { 162 NEXT_ARG(); 163 if (flow_parse_keys(&keys, &nkeys, *argv)) 164 return -1; 165 addattr32(n, 4096, TCA_FLOW_KEYS, keys); 166 } else if (matches(*argv, "and") == 0) { 167 NEXT_ARG(); 168 if (get_u32(&tmp, *argv, 0)) { 169 fprintf(stderr, "Illegal \"mask\"\n"); 170 return -1; 171 } 172 transfer_bitop(&mask, &xor, tmp, 0); 173 } else if (matches(*argv, "or") == 0) { 174 NEXT_ARG(); 175 if (get_u32(&tmp, *argv, 0)) { 176 fprintf(stderr, "Illegal \"or\"\n"); 177 return -1; 178 } 179 transfer_bitop(&mask, &xor, ~tmp, tmp); 180 } else if (matches(*argv, "xor") == 0) { 181 NEXT_ARG(); 182 if (get_u32(&tmp, *argv, 0)) { 183 fprintf(stderr, "Illegal \"xor\"\n"); 184 return -1; 185 } 186 transfer_bitop(&mask, &xor, ~0, tmp); 187 } else if (matches(*argv, "rshift") == 0) { 188 NEXT_ARG(); 189 if (get_u32(&tmp, *argv, 0)) { 190 fprintf(stderr, "Illegal \"rshift\"\n"); 191 return -1; 192 } 193 addattr32(n, 4096, TCA_FLOW_RSHIFT, tmp); 194 } else if (matches(*argv, "addend") == 0) { 195 NEXT_ARG(); 196 if (get_addend(&tmp, *argv, keys)) { 197 fprintf(stderr, "Illegal \"addend\"\n"); 198 return -1; 199 } 200 addattr32(n, 4096, TCA_FLOW_ADDEND, tmp); 201 } else if (matches(*argv, "divisor") == 0) { 202 NEXT_ARG(); 203 if (get_u32(&tmp, *argv, 0)) { 204 fprintf(stderr, "Illegal \"divisor\"\n"); 205 return -1; 206 } 207 addattr32(n, 4096, TCA_FLOW_DIVISOR, tmp); 208 } else if (matches(*argv, "baseclass") == 0) { 209 NEXT_ARG(); 210 if (get_tc_classid(&tmp, *argv) || TC_H_MIN(tmp) == 0) { 211 fprintf(stderr, "Illegal \"baseclass\"\n"); 212 return -1; 213 } 214 addattr32(n, 4096, TCA_FLOW_BASECLASS, tmp); 215 } else if (matches(*argv, "perturb") == 0) { 216 NEXT_ARG(); 217 if (get_u32(&tmp, *argv, 0)) { 218 fprintf(stderr, "Illegal \"perturb\"\n"); 219 return -1; 220 } 221 addattr32(n, 4096, TCA_FLOW_PERTURB, tmp); 222 } else if (matches(*argv, "police") == 0) { 223 NEXT_ARG(); 224 if (parse_police(&argc, &argv, TCA_FLOW_POLICE, n)) { 225 fprintf(stderr, "Illegal \"police\"\n"); 226 return -1; 227 } 228 continue; 229 } else if (matches(*argv, "action") == 0) { 230 NEXT_ARG(); 231 if (parse_action(&argc, &argv, TCA_FLOW_ACT, n)) { 232 fprintf(stderr, "Illegal \"action\"\n"); 233 return -1; 234 } 235 continue; 236 } else if (matches(*argv, "match") == 0) { 237 NEXT_ARG(); 238 if (parse_ematch(&argc, &argv, TCA_FLOW_EMATCHES, n)) { 239 fprintf(stderr, "Illegal \"ematch\"\n"); 240 return -1; 241 } 242 continue; 243 } else if (matches(*argv, "help") == 0) { 244 explain(); 245 return -1; 246 } else { 247 fprintf(stderr, "What is \"%s\"?\n", *argv); 248 explain(); 249 return -1; 250 } 251 argv++, argc--; 252 } 253 254 if (nkeys > 1 && mode != FLOW_MODE_HASH) { 255 fprintf(stderr, "Invalid mode \"map\" for multiple keys\n"); 256 return -1; 257 } 258 addattr32(n, 4096, TCA_FLOW_MODE, mode); 259 260 if (mask != ~0 || xor != 0) { 261 addattr32(n, 4096, TCA_FLOW_MASK, mask); 262 addattr32(n, 4096, TCA_FLOW_XOR, xor); 263 } 264 265 tail->rta_len = (void *)NLMSG_TAIL(n) - (void *)tail; 266 return 0; 267 } 268 269 static int flow_print_opt(struct filter_util *fu, FILE *f, struct rtattr *opt, 270 __u32 handle) 271 { 272 struct rtattr *tb[TCA_FLOW_MAX+1]; 273 SPRINT_BUF(b1); 274 unsigned int i; 275 __u32 mask = ~0, val = 0; 276 277 if (opt == NULL) 278 return -EINVAL; 279 280 parse_rtattr_nested(tb, TCA_FLOW_MAX, opt); 281 282 fprintf(f, "handle 0x%x ", handle); 283 284 if (tb[TCA_FLOW_MODE]) { 285 __u32 mode = rta_getattr_u32(tb[TCA_FLOW_MODE]); 286 287 switch (mode) { 288 case FLOW_MODE_MAP: 289 fprintf(f, "map "); 290 break; 291 case FLOW_MODE_HASH: 292 fprintf(f, "hash "); 293 break; 294 } 295 } 296 297 if (tb[TCA_FLOW_KEYS]) { 298 __u32 keymask = rta_getattr_u32(tb[TCA_FLOW_KEYS]); 299 char *sep = ""; 300 301 fprintf(f, "keys "); 302 for (i = 0; i <= FLOW_KEY_MAX; i++) { 303 if (keymask & (1 << i)) { 304 fprintf(f, "%s%s", sep, flow_keys[i]); 305 sep = ","; 306 } 307 } 308 fprintf(f, " "); 309 } 310 311 if (tb[TCA_FLOW_MASK]) 312 mask = rta_getattr_u32(tb[TCA_FLOW_MASK]); 313 if (tb[TCA_FLOW_XOR]) 314 val = rta_getattr_u32(tb[TCA_FLOW_XOR]); 315 316 if (mask != ~0 || val != 0) { 317 __u32 or = (mask & val) ^ val; 318 __u32 xor = mask & val; 319 320 if (mask != ~0) 321 fprintf(f, "and 0x%.8x ", mask); 322 if (xor != 0) 323 fprintf(f, "xor 0x%.8x ", xor); 324 if (or != 0) 325 fprintf(f, "or 0x%.8x ", or); 326 } 327 328 if (tb[TCA_FLOW_RSHIFT]) 329 fprintf(f, "rshift %u ", 330 rta_getattr_u32(tb[TCA_FLOW_RSHIFT])); 331 if (tb[TCA_FLOW_ADDEND]) 332 fprintf(f, "addend 0x%x ", 333 rta_getattr_u32(tb[TCA_FLOW_ADDEND])); 334 335 if (tb[TCA_FLOW_DIVISOR]) 336 fprintf(f, "divisor %u ", 337 rta_getattr_u32(tb[TCA_FLOW_DIVISOR])); 338 if (tb[TCA_FLOW_BASECLASS]) 339 fprintf(f, "baseclass %s ", 340 sprint_tc_classid(rta_getattr_u32(tb[TCA_FLOW_BASECLASS]), b1)); 341 342 if (tb[TCA_FLOW_PERTURB]) 343 fprintf(f, "perturb %usec ", 344 rta_getattr_u32(tb[TCA_FLOW_PERTURB])); 345 346 if (tb[TCA_FLOW_EMATCHES]) 347 print_ematch(f, tb[TCA_FLOW_EMATCHES]); 348 if (tb[TCA_FLOW_POLICE]) 349 tc_print_police(f, tb[TCA_FLOW_POLICE]); 350 if (tb[TCA_FLOW_ACT]) { 351 fprintf(f, "\n"); 352 tc_print_action(f, tb[TCA_FLOW_ACT]); 353 } 354 return 0; 355 } 356 357 struct filter_util flow_filter_util = { 358 .id = "flow", 359 .parse_fopt = flow_parse_opt, 360 .print_fopt = flow_print_opt, 361 }; 362
