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 -1; 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 return nlmsg_cancel(skb, nlh); 363 } 364 365 int fib_rules_dump(struct sk_buff *skb, struct netlink_callback *cb, int family) 366 { 367 int idx = 0; 368 struct fib_rule *rule; 369 struct fib_rules_ops *ops; 370 371 ops = lookup_rules_ops(family); 372 if (ops == NULL) 373 return -EAFNOSUPPORT; 374 375 rcu_read_lock(); 376 list_for_each_entry(rule, ops->rules_list, list) { 377 if (idx < cb->args[0]) 378 goto skip; 379 380 if (fib_nl_fill_rule(skb, rule, NETLINK_CB(cb->skb).pid, 381 cb->nlh->nlmsg_seq, RTM_NEWRULE, 382 NLM_F_MULTI, ops) < 0) 383 break; 384 skip: 385 idx++; 386 } 387 rcu_read_unlock(); 388 cb->args[0] = idx; 389 rules_ops_put(ops); 390 391 return skb->len; 392 } 393 394 EXPORT_SYMBOL_GPL(fib_rules_dump); 395 396 static void notify_rule_change(int event, struct fib_rule *rule, 397 struct fib_rules_ops *ops, struct nlmsghdr *nlh, 398 u32 pid) 399 { 400 struct sk_buff *skb; 401 int err = -ENOBUFS; 402 403 skb = nlmsg_new(fib_rule_nlmsg_size(ops, rule), GFP_KERNEL); 404 if (skb == NULL) 405 goto errout; 406 407 err = fib_nl_fill_rule(skb, rule, pid, nlh->nlmsg_seq, event, 0, ops); 408 /* failure implies BUG in fib_rule_nlmsg_size() */ 409 BUG_ON(err < 0); 410 411 err = rtnl_notify(skb, pid, ops->nlgroup, nlh, GFP_KERNEL); 412 errout: 413 if (err < 0) 414 rtnl_set_sk_err(ops->nlgroup, err); 415 } 416 417 static void attach_rules(struct list_head *rules, struct net_device *dev) 418 { 419 struct fib_rule *rule; 420 421 list_for_each_entry(rule, rules, list) { 422 if (rule->ifindex == -1 && 423 strcmp(dev->name, rule->ifname) == 0) 424 rule->ifindex = dev->ifindex; 425 } 426 } 427 428 static void detach_rules(struct list_head *rules, struct net_device *dev) 429 { 430 struct fib_rule *rule; 431 432 list_for_each_entry(rule, rules, list) 433 if (rule->ifindex == dev->ifindex) 434 rule->ifindex = -1; 435 } 436 437 438 static int fib_rules_event(struct notifier_block *this, unsigned long event, 439 void *ptr) 440 { 441 struct net_device *dev = ptr; 442 struct fib_rules_ops *ops; 443 444 ASSERT_RTNL(); 445 rcu_read_lock(); 446 447 switch (event) { 448 case NETDEV_REGISTER: 449 list_for_each_entry(ops, &rules_ops, list) 450 attach_rules(ops->rules_list, dev); 451 break; 452 453 case NETDEV_UNREGISTER: 454 list_for_each_entry(ops, &rules_ops, list) 455 detach_rules(ops->rules_list, dev); 456 break; 457 } 458 459 rcu_read_unlock(); 460 461 return NOTIFY_DONE; 462 } 463 464 static struct notifier_block fib_rules_notifier = { 465 .notifier_call = fib_rules_event, 466 }; 467 468 static int __init fib_rules_init(void) 469 { 470 return register_netdevice_notifier(&fib_rules_notifier); 471 } 472 473 subsys_initcall(fib_rules_init); 474