]>
Commit | Line | Data |
---|---|---|
1 | ||
2 | /* | |
3 | * DECnet An implementation of the DECnet protocol suite for the LINUX | |
4 | * operating system. DECnet is implemented using the BSD Socket | |
5 | * interface as the means of communication with the user level. | |
6 | * | |
7 | * DECnet Routing Forwarding Information Base (Rules) | |
8 | * | |
9 | * Author: Steve Whitehouse <SteveW@ACM.org> | |
10 | * Mostly copied from Alexey Kuznetsov's ipv4/fib_rules.c | |
11 | * | |
12 | * | |
13 | * Changes: | |
14 | * Steve Whitehouse <steve@chygwyn.com> | |
15 | * Updated for Thomas Graf's generic rules | |
16 | * | |
17 | */ | |
18 | #include <linux/net.h> | |
19 | #include <linux/init.h> | |
20 | #include <linux/netlink.h> | |
21 | #include <linux/rtnetlink.h> | |
22 | #include <linux/netdevice.h> | |
23 | #include <linux/spinlock.h> | |
24 | #include <linux/list.h> | |
25 | #include <linux/rcupdate.h> | |
26 | #include <net/neighbour.h> | |
27 | #include <net/dst.h> | |
28 | #include <net/flow.h> | |
29 | #include <net/fib_rules.h> | |
30 | #include <net/dn.h> | |
31 | #include <net/dn_fib.h> | |
32 | #include <net/dn_neigh.h> | |
33 | #include <net/dn_dev.h> | |
34 | #include <net/dn_route.h> | |
35 | ||
36 | static struct fib_rules_ops *dn_fib_rules_ops; | |
37 | ||
38 | struct dn_fib_rule | |
39 | { | |
40 | struct fib_rule common; | |
41 | unsigned char dst_len; | |
42 | unsigned char src_len; | |
43 | __le16 src; | |
44 | __le16 srcmask; | |
45 | __le16 dst; | |
46 | __le16 dstmask; | |
47 | __le16 srcmap; | |
48 | u8 flags; | |
49 | }; | |
50 | ||
51 | ||
52 | int dn_fib_lookup(struct flowi *flp, struct dn_fib_res *res) | |
53 | { | |
54 | struct fib_lookup_arg arg = { | |
55 | .result = res, | |
56 | }; | |
57 | int err; | |
58 | ||
59 | err = fib_rules_lookup(dn_fib_rules_ops, flp, 0, &arg); | |
60 | res->r = arg.rule; | |
61 | ||
62 | return err; | |
63 | } | |
64 | ||
65 | static int dn_fib_rule_action(struct fib_rule *rule, struct flowi *flp, | |
66 | int flags, struct fib_lookup_arg *arg) | |
67 | { | |
68 | int err = -EAGAIN; | |
69 | struct dn_fib_table *tbl; | |
70 | ||
71 | switch(rule->action) { | |
72 | case FR_ACT_TO_TBL: | |
73 | break; | |
74 | ||
75 | case FR_ACT_UNREACHABLE: | |
76 | err = -ENETUNREACH; | |
77 | goto errout; | |
78 | ||
79 | case FR_ACT_PROHIBIT: | |
80 | err = -EACCES; | |
81 | goto errout; | |
82 | ||
83 | case FR_ACT_BLACKHOLE: | |
84 | default: | |
85 | err = -EINVAL; | |
86 | goto errout; | |
87 | } | |
88 | ||
89 | tbl = dn_fib_get_table(rule->table, 0); | |
90 | if (tbl == NULL) | |
91 | goto errout; | |
92 | ||
93 | err = tbl->lookup(tbl, flp, (struct dn_fib_res *)arg->result); | |
94 | if (err > 0) | |
95 | err = -EAGAIN; | |
96 | errout: | |
97 | return err; | |
98 | } | |
99 | ||
100 | static const struct nla_policy dn_fib_rule_policy[FRA_MAX+1] = { | |
101 | FRA_GENERIC_POLICY, | |
102 | }; | |
103 | ||
104 | static int dn_fib_rule_match(struct fib_rule *rule, struct flowi *fl, int flags) | |
105 | { | |
106 | struct dn_fib_rule *r = (struct dn_fib_rule *)rule; | |
107 | __le16 daddr = fl->fld_dst; | |
108 | __le16 saddr = fl->fld_src; | |
109 | ||
110 | if (((saddr ^ r->src) & r->srcmask) || | |
111 | ((daddr ^ r->dst) & r->dstmask)) | |
112 | return 0; | |
113 | ||
114 | return 1; | |
115 | } | |
116 | ||
117 | static int dn_fib_rule_configure(struct fib_rule *rule, struct sk_buff *skb, | |
118 | struct fib_rule_hdr *frh, | |
119 | struct nlattr **tb) | |
120 | { | |
121 | int err = -EINVAL; | |
122 | struct dn_fib_rule *r = (struct dn_fib_rule *)rule; | |
123 | ||
124 | if (frh->tos) | |
125 | goto errout; | |
126 | ||
127 | if (rule->table == RT_TABLE_UNSPEC) { | |
128 | if (rule->action == FR_ACT_TO_TBL) { | |
129 | struct dn_fib_table *table; | |
130 | ||
131 | table = dn_fib_empty_table(); | |
132 | if (table == NULL) { | |
133 | err = -ENOBUFS; | |
134 | goto errout; | |
135 | } | |
136 | ||
137 | rule->table = table->n; | |
138 | } | |
139 | } | |
140 | ||
141 | if (frh->src_len) | |
142 | r->src = nla_get_le16(tb[FRA_SRC]); | |
143 | ||
144 | if (frh->dst_len) | |
145 | r->dst = nla_get_le16(tb[FRA_DST]); | |
146 | ||
147 | r->src_len = frh->src_len; | |
148 | r->srcmask = dnet_make_mask(r->src_len); | |
149 | r->dst_len = frh->dst_len; | |
150 | r->dstmask = dnet_make_mask(r->dst_len); | |
151 | err = 0; | |
152 | errout: | |
153 | return err; | |
154 | } | |
155 | ||
156 | static int dn_fib_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh, | |
157 | struct nlattr **tb) | |
158 | { | |
159 | struct dn_fib_rule *r = (struct dn_fib_rule *)rule; | |
160 | ||
161 | if (frh->src_len && (r->src_len != frh->src_len)) | |
162 | return 0; | |
163 | ||
164 | if (frh->dst_len && (r->dst_len != frh->dst_len)) | |
165 | return 0; | |
166 | ||
167 | if (frh->src_len && (r->src != nla_get_le16(tb[FRA_SRC]))) | |
168 | return 0; | |
169 | ||
170 | if (frh->dst_len && (r->dst != nla_get_le16(tb[FRA_DST]))) | |
171 | return 0; | |
172 | ||
173 | return 1; | |
174 | } | |
175 | ||
176 | unsigned dnet_addr_type(__le16 addr) | |
177 | { | |
178 | struct flowi fl = { .fld_dst = addr }; | |
179 | struct dn_fib_res res; | |
180 | unsigned ret = RTN_UNICAST; | |
181 | struct dn_fib_table *tb = dn_fib_get_table(RT_TABLE_LOCAL, 0); | |
182 | ||
183 | res.r = NULL; | |
184 | ||
185 | if (tb) { | |
186 | if (!tb->lookup(tb, &fl, &res)) { | |
187 | ret = res.type; | |
188 | dn_fib_res_put(&res); | |
189 | } | |
190 | } | |
191 | return ret; | |
192 | } | |
193 | ||
194 | static int dn_fib_rule_fill(struct fib_rule *rule, struct sk_buff *skb, | |
195 | struct fib_rule_hdr *frh) | |
196 | { | |
197 | struct dn_fib_rule *r = (struct dn_fib_rule *)rule; | |
198 | ||
199 | frh->dst_len = r->dst_len; | |
200 | frh->src_len = r->src_len; | |
201 | frh->tos = 0; | |
202 | ||
203 | if (r->dst_len) | |
204 | NLA_PUT_LE16(skb, FRA_DST, r->dst); | |
205 | if (r->src_len) | |
206 | NLA_PUT_LE16(skb, FRA_SRC, r->src); | |
207 | ||
208 | return 0; | |
209 | ||
210 | nla_put_failure: | |
211 | return -ENOBUFS; | |
212 | } | |
213 | ||
214 | static void dn_fib_rule_flush_cache(struct fib_rules_ops *ops) | |
215 | { | |
216 | dn_rt_cache_flush(-1); | |
217 | } | |
218 | ||
219 | static const struct fib_rules_ops __net_initdata dn_fib_rules_ops_template = { | |
220 | .family = AF_DECnet, | |
221 | .rule_size = sizeof(struct dn_fib_rule), | |
222 | .addr_size = sizeof(u16), | |
223 | .action = dn_fib_rule_action, | |
224 | .match = dn_fib_rule_match, | |
225 | .configure = dn_fib_rule_configure, | |
226 | .compare = dn_fib_rule_compare, | |
227 | .fill = dn_fib_rule_fill, | |
228 | .default_pref = fib_default_rule_pref, | |
229 | .flush_cache = dn_fib_rule_flush_cache, | |
230 | .nlgroup = RTNLGRP_DECnet_RULE, | |
231 | .policy = dn_fib_rule_policy, | |
232 | .owner = THIS_MODULE, | |
233 | .fro_net = &init_net, | |
234 | }; | |
235 | ||
236 | void __init dn_fib_rules_init(void) | |
237 | { | |
238 | dn_fib_rules_ops = | |
239 | fib_rules_register(&dn_fib_rules_ops_template, &init_net); | |
240 | BUG_ON(IS_ERR(dn_fib_rules_ops)); | |
241 | BUG_ON(fib_default_rule_add(dn_fib_rules_ops, 0x7fff, | |
242 | RT_TABLE_MAIN, 0)); | |
243 | } | |
244 | ||
245 | void __exit dn_fib_rules_cleanup(void) | |
246 | { | |
247 | fib_rules_unregister(dn_fib_rules_ops); | |
248 | rcu_barrier(); | |
249 | } | |
250 | ||
251 |