1 /* 2 * net/core/fib_rules.c Generic Routing Rules 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 as 6 * published by the Free Software Foundation, version 2. 7 * 8 * Authors: Thomas Graf <tgraf@suug.ch> 9 */ 10 11 #include <linux/types.h> 12 #include <linux/kernel.h> 13 #include <linux/list.h> 14 #include <net/fib_rules.h> 15 16 static LIST_HEAD(rules_ops); 17 static DEFINE_SPINLOCK(rules_mod_lock); 18 19 static void notify_rule_change(int event, struct fib_rule *rule, 20 struct fib_rules_ops *ops, struct nlmsghdr *nlh, 21 u32 pid); 22 23 static struct fib_rules_ops *lookup_rules_ops(int family) 24 { 25 struct fib_rules_ops *ops; 26 27 rcu_read_lock(); 28 list_for_each_entry_rcu(ops, &rules_ops, list) { 29 if (ops->family == family) { 30 if (!try_module_get(ops->owner)) 31 ops = NULL; 32 rcu_read_unlock(); 33 return ops; 34 } 35 } 36 rcu_read_unlock(); 37 38 return NULL; 39 } 40 41 static void rules_ops_put(struct fib_rules_ops *ops) 42 { 43 if (ops) 44 module_put(ops->owner); 45 } 46 47 int fib_rules_register(struct fib_rules_ops *ops) 48 { 49 int err = -EEXIST; 50 struct fib_rules_ops *o; 51 52 if (ops->rule_size < sizeof(struct fib_rule)) 53 return -EINVAL; 54 55 if (ops->match == NULL || ops->configure == NULL || 56 ops->compare == NULL || ops->fill == NULL || 57 ops->action == NULL) 58 return -EINVAL; 59 60 spin_lock(&rules_mod_lock); 61 list_for_each_entry(o, &rules_ops, list) 62 if (ops->family == o->family) 63 goto errout; 64 65 list_add_tail_rcu(&ops->list, &rules_ops); 66 err = 0; 67 errout: 68 spin_unlock(&rules_mod_lock); 69 70 return err; 71 } 72 73 EXPORT_SYMBOL_GPL(fib_rules_register); 74 75 static void cleanup_ops(struct fib_rules_ops *ops) 76 { 77 struct fib_rule *rule, *tmp; 78 79 list_for_each_entry_safe(rule, tmp, ops->rules_list, list) { 80 list_del_rcu(&rule->list); 81 fib_rule_put(rule); 82 } 83 } 84 85 int fib_rules_unregister(struct fib_rules_ops *ops) 86 { 87 int err = 0; 88 struct fib_rules_ops *o; 89 90 spin_lock(&rules_mod_lock); 91 list_for_each_entry(o, &rules_ops, list) { 92 if (o == ops) { 93 list_del_rcu(&o->list); 94 cleanup_ops(ops); 95 goto out; 96 } 97 } 98 99 err = -ENOENT; 100 out: 101 spin_unlock(&rules_mod_lock); 102 103 synchronize_rcu(); 104 105 return err; 106 } 107 108 EXPORT_SYMBOL_GPL(fib_rules_unregister); 109 110 static int fib_rule_match(struct fib_rule *rule, struct fib_rules_ops *ops, 111 struct flowi *fl, int flags) 112 { 113 int ret = 0; 114 115 if (rule->ifindex && (rule->ifindex != fl->iif)) 116 goto out; 117 118 if ((rule->mark ^ fl->mark) & rule->mark_mask) 119 goto out; 120 121 ret = ops->match(rule, fl, flags); 122 out: 123 return (rule->flags & FIB_RULE_INVERT) ? !ret : ret; 124 } 125 126 int fib_rules_lookup(struct fib_rules_ops *ops, struct flowi *fl, 127 int flags, struct fib_lookup_arg *arg) 128 { 129 struct fib_rule *rule; 130 int err; 131 132 rcu_read_lock(); 133 134 list_for_each_entry_rcu(rule, ops->rules_list, list) { 135 if (!fib_rule_match(rule, ops, fl, flags)) 136 continue; 137 138 err = ops->action(rule, fl, flags, arg); 139 if (err != -EAGAIN) { 140 fib_rule_get(rule); 141 arg->rule = rule; 142 goto out; 143 } 144 } 145 146 err = -ENETUNREACH; 147 out: 148 rcu_read_unlock(); 149 150 return err; 151 } 152 153 EXPORT_SYMBOL_GPL(fib_rules_lookup); 154 155 int fib_nl_newrule(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg) 156 { 157 struct fib_rule_hdr *frh = nlmsg_data(nlh); 158 struct fib_rules_ops *ops = NULL; 159 struct fib_rule *rule, *r, *last = NULL; 160 struct nlattr *tb[FRA_MAX+1]; 161 int err = -EINVAL; 162 163 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*frh))) 164 goto errout; 165 166 ops = lookup_rules_ops(frh->family); 167 if (ops == NULL) { 168 err = EAFNOSUPPORT; 169 goto errout; 170 } 171 172 err = nlmsg_parse(nlh, sizeof(*frh), tb, FRA_MAX, ops->policy); 173 if (err < 0) 174 goto errout; 175 176 rule = kzalloc(ops->rule_size, GFP_KERNEL); 177 if (rule == NULL) { 178 err = -ENOMEM; 179 goto errout; 180 } 181 182 if (tb[FRA_PRIORITY]) 183 rule->pref = nla_get_u32(tb[FRA_PRIORITY]); 184 185 if (tb[FRA_IFNAME]) { 186 struct net_device *dev; 187 188 rule->ifindex = -1; 189 nla_strlcpy(rule->ifname, tb[FRA_IFNAME], IFNAMSIZ); 190 dev = __dev_get_by_name(rule->ifname); 191 if (dev) 192 rule->ifindex = dev->ifindex; 193 } 194 195 if (tb[FRA_FWMARK]) { 196 rule->mark = nla_get_u32(tb[FRA_FWMARK]); 197 if (rule->mark) 198 /* compatibility: if the mark value is non-zero all bits 199 * are compared unless a mask is explicitly specified. 200 */ 201 rule->mark_mask = 0xFFFFFFFF; 202 } 203 204 if (tb[FRA_FWMASK]) 205 rule->mark_mask = nla_get_u32(tb[FRA_FWMASK]); 206 207 rule->action = frh->action; 208 rule->flags = frh->flags; 209 rule->table = frh_get_table(frh, tb); 210 211 if (!rule->pref && ops->default_pref) 212 rule->pref = ops->default_pref(); 213 214 err = ops->configure(rule, skb, nlh, frh, tb); 215 if (err < 0) 216 goto errout_free; 217 218 list_for_each_entry(r, ops->rules_list, list) { 219 if (r->pref > rule->pref) 220 break; 221 last = r; 222 } 223 224 fib_rule_get(rule); 225 226 if (last) 227 list_add_rcu(&rule->list, &last->list); 228 else 229 list_add_rcu(&rule->list, ops->rules_list); 230 231 notify_rule_change(RTM_NEWRULE, rule, ops, nlh, NETLINK_CB(skb).pid); 232 rules_ops_put(ops); 233 return 0; 234 235 errout_free: 236 kfree(rule); 237 errout: 238 rules_ops_put(ops); 239 return err; 240 } 241 242 int fib_nl_delrule(struct sk_buff *skb, struct nlmsghdr* nlh, void *arg) 243 { 244 struct fib_rule_hdr *frh = nlmsg_data(nlh); 245 struct fib_rules_ops *ops = NULL; 246 struct fib_rule *rule; 247 struct nlattr *tb[FRA_MAX+1]; 248 int err = -EINVAL; 249 250 if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*frh))) 251 goto errout; 252 253 ops = lookup_rules_ops(frh->family); 254 if (ops == NULL) { 255 err = EAFNOSUPPORT; 256 goto errout; 257 } 258 259 err = nlmsg_parse(nlh, sizeof(*frh), tb, FRA_MAX, ops->policy); 260 if (err < 0) 261 goto errout; 262 263 list_for_each_entry(rule, ops->rules_list, list) { 264 if (frh->action && (frh->action != rule->action)) 265 continue; 266 267 if (frh->table && (frh_get_table(frh, tb) != rule->table)) 268 continue; 269 270 if (tb[FRA_PRIORITY] && 271 (rule->pref != nla_get_u32(tb[FRA_PRIORITY]))) 272 continue; 273 274 if (tb[FRA_IFNAME] && 275 nla_strcmp(tb[FRA_IFNAME], rule->ifname)) 276 continue; 277 278 if (tb[FRA_FWMARK] && 279 (rule->mark != nla_get_u32(tb[FRA_FWMARK]))) 280 continue; 281 282 if (tb[FRA_FWMASK] && 283 (rule->mark_mask != nla_get_u32(tb[FRA_FWMASK]))) 284 continue; 285 286 if (!ops->compare(rule, frh, tb)) 287 continue; 288 289 if (rule->flags & FIB_RULE_PERMANENT) { 290 err = -EPERM; 291 goto errout; 292 } 293 294 list_del_rcu(&rule->list); 295 synchronize_rcu(); 296 notify_rule_change(RTM_DELRULE, rule, ops, nlh, 297 NETLINK_CB(skb).pid); 298 fib_rule_put(rule); 299 rules_ops_put(ops); 300 return 0; 301 } 302 303 err = -ENOENT; 304 errout: 305 rules_ops_put(ops); 306 return err; 307 } 308 309 static inline size_t fib_rule_nlmsg_size(struct fib_rules_ops *ops, 310 struct fib_rule *rule) 311 { 312 size_t payload = NLMSG_ALIGN(sizeof(struct fib_rule_hdr)) 313 + nla_total_size(IFNAMSIZ) /* FRA_IFNAME */ 314 + nla_total_size(4) /* FRA_PRIORITY */ 315 + nla_total_size(4) /* FRA_TABLE */ 316 + nla_total_size(4) /* FRA_FWMARK */ 317 + nla_total_size(4); /* FRA_FWMASK */ 318 319 if (ops->nlmsg_payload) 320 payload += ops->nlmsg_payload(rule); 321 322 return payload; 323 } 324 325 static int fib_nl_fill_rule(struct sk_buff *skb, struct fib_rule *rule, 326 u32 pid, u32 seq, int type, int flags, 327 struct fib_rules_ops *ops) 328 { 329 struct nlmsghdr *nlh; 330 struct fib_rule_hdr *frh; 331 332 nlh = nlmsg_put(skb, pid, seq, type, sizeof(*frh), flags); 333 if (nlh == NULL) 334 return -EMSGSIZE; 335 336 frh = nlmsg_data(nlh); 337 frh->table = rule->table; 338 NLA_PUT_U32(skb, FRA_TABLE, rule->table); 339 frh->res1 = 0; 340 frh->res2 = 0; 341 frh->action = rule->action; 342 frh->flags = rule->flags; 343 344 if (rule->ifname[0]) 345 NLA_PUT_STRING(skb, FRA_IFNAME, rule->ifname); 346 347 if (rule->pref) 348 NLA_PUT_U32(skb, FRA_PRIORITY, rule->pref); 349 350 if (rule->mark) 351 NLA_PUT_U32(skb, FRA_FWMARK, rule->mark); 352 353 if (rule->mark_mask || rule->mark) 354 NLA_PUT_U32(skb, FRA_FWMASK, rule->mark_mask); 355 356 if (ops->fill(rule, skb, nlh, frh) < 0) 357 goto nla_put_failure; 358 359 return nlmsg_end(skb, nlh); 360 361 nla_put_failure: 362 nlmsg_cancel(skb, nlh); 363 return -EMSGSIZE; 364 } 365 366 int fib_rules_dump(struct sk_buff *skb, struct netlink_callback *cb, int family) 367 { 368 int idx = 0; 369 struct fib_rule *rule; 370 struct fib_rules_ops *ops; 371 372 ops = lookup_rules_ops(family); 373 if (ops == NULL) 374 return -EAFNOSUPPORT; 375 376 rcu_read_lock(); 377 list_for_each_entry(rule, ops->rules_list, list) { 378 if (idx < cb->args[0]) 379 goto skip; 380 381 if (fib_nl_fill_rule(skb, rule, NETLINK_CB(cb->skb).pid, 382 cb->nlh->nlmsg_seq, RTM_NEWRULE, 383 NLM_F_MULTI, ops) < 0) 384 break; 385 skip: 386 idx++; 387 } 388 rcu_read_unlock(); 389 cb->args[0] = idx; 390 rules_ops_put(ops); 391 392 return skb->len; 393 } 394 395 EXPORT_SYMBOL_GPL(fib_rules_dump); 396 397 static void notify_rule_change(int event, struct fib_rule *rule, 398 struct fib_rules_ops *ops, struct nlmsghdr *nlh, 399 u32 pid) 400 { 401 struct sk_buff *skb; 402 int err = -ENOBUFS; 403 404 skb = nlmsg_new(fib_rule_nlmsg_size(ops, rule), GFP_KERNEL); 405 if (skb == NULL) 406 goto errout; 407 408 err = fib_nl_fill_rule(skb, rule, pid, nlh->nlmsg_seq, event, 0, ops); 409 if (err < 0) { 410 /* -EMSGSIZE implies BUG in fib_rule_nlmsg_size() */ 411 WARN_ON(err == -EMSGSIZE); 412 kfree_skb(skb); 413 goto errout; 414 } 415 err = rtnl_notify(skb, pid, ops->nlgroup, nlh, GFP_KERNEL); 416 errout: 417 if (err < 0) 418 rtnl_set_sk_err(ops->nlgroup, err); 419 } 420 421 static void attach_rules(struct list_head *rules, struct net_device *dev) 422 { 423 struct fib_rule *rule; 424 425 list_for_each_entry(rule, rules, list) { 426 if (rule->ifindex == -1 && 427 strcmp(dev->name, rule->ifname) == 0) 428 rule->ifindex = dev->ifindex; 429 } 430 } 431 432 static void detach_rules(struct list_head *rules, struct net_device *dev) 433 { 434 struct fib_rule *rule; 435 436 list_for_each_entry(rule, rules, list) 437 if (rule->ifindex == dev->ifindex) 438 rule->ifindex = -1; 439 } 440 441 442 static int fib_rules_event(struct notifier_block *this, unsigned long event, 443 void *ptr) 444 { 445 struct net_device *dev = ptr; 446 struct fib_rules_ops *ops; 447 448 ASSERT_RTNL(); 449 rcu_read_lock(); 450 451 switch (event) { 452 case NETDEV_REGISTER: 453 list_for_each_entry(ops, &rules_ops, list) 454 attach_rules(ops->rules_list, dev); 455 break; 456 457 case NETDEV_UNREGISTER: 458 list_for_each_entry(ops, &rules_ops, list) 459 detach_rules(ops->rules_list, dev); 460 break; 461 } 462 463 rcu_read_unlock(); 464 465 return NOTIFY_DONE; 466 } 467 468 static struct notifier_block fib_rules_notifier = { 469 .notifier_call = fib_rules_event, 470 }; 471 472 static int __init fib_rules_init(void) 473 { 474 return register_netdevice_notifier(&fib_rules_notifier); 475 } 476 477 subsys_initcall(fib_rules_init); 478