projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
add prereq checks for target/linux/* and target/image/*, check for fdisk for the...
[openwrt.git] / target / linux / generic-2.4 / patches / 700-multiple_default_gateways.patch
1 diff -ur v2.4.29/linux/include/linux/netfilter_ipv4/ip_nat.h linux/include/linux/netfilter_ipv4/ip_nat.h
2 --- v2.4.29/linux/include/linux/netfilter_ipv4/ip_nat.h 2005-01-20 09:25:34.000000000 +0200
3 +++ linux/include/linux/netfilter_ipv4/ip_nat.h 2005-01-20 09:55:46.998651976 +0200
4 @@ -121,5 +121,13 @@
5 extern u_int16_t ip_nat_cheat_check(u_int32_t oldvalinv,
6 u_int32_t newval,
7 u_int16_t oldcheck);
8 +
9 +/* Call input routing for SNAT-ed traffic */
10 +extern unsigned int ip_nat_route_input(unsigned int hooknum,
11 + struct sk_buff **pskb,
12 + const struct net_device *in,
13 + const struct net_device *out,
14 + int (*okfn)(struct sk_buff *));
15 +
16 #endif /*__KERNEL__*/
17 #endif
18 diff -ur v2.4.29/linux/include/linux/rtnetlink.h linux/include/linux/rtnetlink.h
19 --- v2.4.29/linux/include/linux/rtnetlink.h 2004-08-08 10:56:48.000000000 +0300
20 +++ linux/include/linux/rtnetlink.h 2005-01-20 09:55:33.431714464 +0200
21 @@ -234,6 +234,8 @@
22 #define RTNH_F_DEAD 1 /* Nexthop is dead (used by multipath) */
23 #define RTNH_F_PERVASIVE 2 /* Do recursive gateway lookup */
24 #define RTNH_F_ONLINK 4 /* Gateway is forced on link */
25 +#define RTNH_F_SUSPECT 8 /* We don't know the real state */
26 +#define RTNH_F_BADSTATE (RTNH_F_DEAD | RTNH_F_SUSPECT)
27
28 /* Macros to handle hexthops */
29
30 diff -ur v2.4.29/linux/include/net/ip_fib.h linux/include/net/ip_fib.h
31 --- v2.4.29/linux/include/net/ip_fib.h 2001-11-13 03:24:05.000000000 +0200
32 +++ linux/include/net/ip_fib.h 2005-01-20 09:55:33.432714312 +0200
33 @@ -162,7 +162,8 @@
34
35 static inline void fib_select_default(const struct rt_key *key, struct fib_result *res)
36 {
37 - if (FIB_RES_GW(*res) && FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK)
38 + if ((FIB_RES_GW(*res) && FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK) ||
39 + FIB_RES_NH(*res).nh_scope == RT_SCOPE_HOST)
40 main_table->tb_select_default(main_table, key, res);
41 }
42
43 @@ -174,6 +175,7 @@
44 extern int fib_lookup(const struct rt_key *key, struct fib_result *res);
45 extern struct fib_table *__fib_new_table(int id);
46 extern void fib_rule_put(struct fib_rule *r);
47 +extern int fib_result_table(struct fib_result *res);
48
49 static inline struct fib_table *fib_get_table(int id)
50 {
51 @@ -275,5 +277,6 @@
52 #endif
53 }
54
55 +extern rwlock_t fib_nhflags_lock;
56
57 #endif /* _NET_FIB_H */
58 diff -ur v2.4.29/linux/include/net/route.h linux/include/net/route.h
59 --- v2.4.29/linux/include/net/route.h 2003-08-25 22:06:13.000000000 +0300
60 +++ linux/include/net/route.h 2005-01-20 09:55:46.999651824 +0200
61 @@ -49,6 +49,8 @@
62 {
63 __u32 dst;
64 __u32 src;
65 + __u32 lsrc;
66 + __u32 gw;
67 int iif;
68 int oif;
69 #ifdef CONFIG_IP_ROUTE_FWMARK
70 @@ -128,6 +130,7 @@
71 extern void rt_cache_flush(int how);
72 extern int ip_route_output_key(struct rtable **, const struct rt_key *key);
73 extern int ip_route_input(struct sk_buff*, u32 dst, u32 src, u8 tos, struct net_device *devin);
74 +extern int ip_route_input_lookup(struct sk_buff*, u32 dst, u32 src, u8 tos, struct net_device *devin, u32 lsrc);
75 extern unsigned short ip_rt_frag_needed(struct iphdr *iph, unsigned short new_mtu);
76 extern void ip_rt_update_pmtu(struct dst_entry *dst, unsigned mtu);
77 extern void ip_rt_send_redirect(struct sk_buff *skb);
78 @@ -148,6 +151,15 @@
79 }
80
81
82 +static inline int
83 +ip_route_output_lookup(struct rtable **rp,
84 + u32 daddr, u32 saddr, u32 tos, int oif, u32 gw)
85 +{
86 + struct rt_key key = { dst:daddr, src:saddr, gw:gw, oif:oif, tos:tos };
87 +
88 + return ip_route_output_key(rp, &key);
89 +}
90 +
91 static inline void ip_rt_put(struct rtable * rt)
92 {
93 if (rt)
94 diff -ur v2.4.29/linux/net/ipv4/fib_frontend.c linux/net/ipv4/fib_frontend.c
95 --- v2.4.29/linux/net/ipv4/fib_frontend.c 2003-08-25 22:06:13.000000000 +0300
96 +++ linux/net/ipv4/fib_frontend.c 2005-01-20 09:55:46.999651824 +0200
97 @@ -54,6 +54,8 @@
98 struct fib_table *local_table;
99 struct fib_table *main_table;
100
101 +#define FIB_RES_TABLE(r) (RT_TABLE_MAIN)
102 +
103 #else
104
105 #define RT_TABLE_MIN 1
106 @@ -71,6 +73,7 @@
107 return tb;
108 }
109
110 +#define FIB_RES_TABLE(r) (fib_result_table(r))
111
112 #endif /* CONFIG_IP_MULTIPLE_TABLES */
113
114 @@ -209,6 +212,9 @@
115 struct in_device *in_dev;
116 struct rt_key key;
117 struct fib_result res;
118 + int table;
119 + unsigned char prefixlen;
120 + unsigned char scope;
121 int no_addr, rpf;
122 int ret;
123
124 @@ -216,6 +222,7 @@
125 key.src = dst;
126 key.tos = tos;
127 key.oif = 0;
128 + key.gw = 0;
129 key.iif = oif;
130 key.scope = RT_SCOPE_UNIVERSE;
131
132 @@ -237,31 +244,35 @@
133 goto e_inval_res;
134 *spec_dst = FIB_RES_PREFSRC(res);
135 fib_combine_itag(itag, &res);
136 -#ifdef CONFIG_IP_ROUTE_MULTIPATH
137 - if (FIB_RES_DEV(res) == dev || res.fi->fib_nhs > 1)
138 -#else
139 if (FIB_RES_DEV(res) == dev)
140 -#endif
141 {
142 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
143 fib_res_put(&res);
144 return ret;
145 }
146 + table = FIB_RES_TABLE(&res);
147 + prefixlen = res.prefixlen;
148 + scope = res.scope;
149 fib_res_put(&res);
150 if (no_addr)
151 goto last_resort;
152 - if (rpf)
153 - goto e_inval;
154 key.oif = dev->ifindex;
155
156 ret = 0;
157 if (fib_lookup(&key, &res) == 0) {
158 - if (res.type == RTN_UNICAST) {
159 + if (res.type == RTN_UNICAST &&
160 + ((table == FIB_RES_TABLE(&res) &&
161 + res.prefixlen >= prefixlen && res.scope >= scope) ||
162 + !rpf)) {
163 *spec_dst = FIB_RES_PREFSRC(res);
164 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
165 + fib_res_put(&res);
166 + return ret;
167 }
168 fib_res_put(&res);
169 }
170 + if (rpf)
171 + goto e_inval;
172 return ret;
173
174 last_resort:
175 @@ -579,9 +590,7 @@
176 switch (event) {
177 case NETDEV_UP:
178 fib_add_ifaddr(ifa);
179 -#ifdef CONFIG_IP_ROUTE_MULTIPATH
180 fib_sync_up(ifa->ifa_dev->dev);
181 -#endif
182 rt_cache_flush(-1);
183 break;
184 case NETDEV_DOWN:
185 @@ -617,9 +626,7 @@
186 for_ifa(in_dev) {
187 fib_add_ifaddr(ifa);
188 } endfor_ifa(in_dev);
189 -#ifdef CONFIG_IP_ROUTE_MULTIPATH
190 fib_sync_up(dev);
191 -#endif
192 rt_cache_flush(-1);
193 break;
194 case NETDEV_DOWN:
195 diff -ur v2.4.29/linux/net/ipv4/fib_hash.c linux/net/ipv4/fib_hash.c
196 --- v2.4.29/linux/net/ipv4/fib_hash.c 2003-08-25 22:06:13.000000000 +0300
197 +++ linux/net/ipv4/fib_hash.c 2005-01-20 09:55:47.000651672 +0200
198 @@ -71,6 +71,7 @@
199 struct fib_info *fn_info;
200 #define FIB_INFO(f) ((f)->fn_info)
201 fn_key_t fn_key;
202 + int fn_last_dflt;
203 u8 fn_tos;
204 u8 fn_type;
205 u8 fn_scope;
206 @@ -336,72 +337,123 @@
207 return err;
208 }
209
210 -static int fn_hash_last_dflt=-1;
211 -
212 -static int fib_detect_death(struct fib_info *fi, int order,
213 - struct fib_info **last_resort, int *last_idx)
214 +static int fib_detect_death(struct fib_info *fi, int order, int last_dflt,
215 + struct fib_info **last_resort, int *last_idx,
216 + int *last_nhsel, const struct rt_key *key)
217 {
218 struct neighbour *n;
219 - int state = NUD_NONE;
220 + int nhsel;
221 + int state;
222 + struct fib_nh * nh;
223 + u32 dst;
224 + int flag, dead = 1;
225 +
226 + /* change_nexthops(fi) { */
227 + for (nhsel = 0, nh = fi->fib_nh; nhsel < fi->fib_nhs; nh++, nhsel++) {
228 + if (key->oif && key->oif != nh->nh_oif)
229 + continue;
230 + if (key->gw && key->gw != nh->nh_gw && nh->nh_gw &&
231 + nh->nh_scope == RT_SCOPE_LINK)
232 + continue;
233 + if (nh->nh_flags & RTNH_F_DEAD)
234 + continue;
235
236 - n = neigh_lookup(&arp_tbl, &fi->fib_nh[0].nh_gw, fi->fib_dev);
237 - if (n) {
238 - state = n->nud_state;
239 - neigh_release(n);
240 + flag = 0;
241 + if (nh->nh_dev->flags & IFF_NOARP) {
242 + dead = 0;
243 + goto setfl;
244 + }
245 +
246 + dst = nh->nh_gw;
247 + if (!nh->nh_gw || nh->nh_scope != RT_SCOPE_LINK)
248 + dst = key->dst;
249 +
250 + state = NUD_NONE;
251 + n = neigh_lookup(&arp_tbl, &dst, nh->nh_dev);
252 + if (n) {
253 + state = n->nud_state;
254 + neigh_release(n);
255 + }
256 + if (state==NUD_REACHABLE ||
257 + ((state&NUD_VALID) && order != last_dflt)) {
258 + dead = 0;
259 + goto setfl;
260 + }
261 + if (!(state&NUD_VALID))
262 + flag = 1;
263 + if (!dead)
264 + goto setfl;
265 + if ((state&NUD_VALID) ||
266 + (*last_idx<0 && order >= last_dflt)) {
267 + *last_resort = fi;
268 + *last_idx = order;
269 + *last_nhsel = nhsel;
270 + }
271 +
272 + setfl:
273 +
274 + read_lock_bh(&fib_nhflags_lock);
275 + if (flag)
276 + nh->nh_flags |= RTNH_F_SUSPECT;
277 + else
278 + nh->nh_flags &= ~RTNH_F_SUSPECT;
279 + read_unlock_bh(&fib_nhflags_lock);
280 }
281 - if (state==NUD_REACHABLE)
282 - return 0;
283 - if ((state&NUD_VALID) && order != fn_hash_last_dflt)
284 - return 0;
285 - if ((state&NUD_VALID) ||
286 - (*last_idx<0 && order > fn_hash_last_dflt)) {
287 - *last_resort = fi;
288 - *last_idx = order;
289 - }
290 - return 1;
291 + /* } endfor_nexthops(fi) */
292 +
293 + return dead;
294 }
295
296 static void
297 fn_hash_select_default(struct fib_table *tb, const struct rt_key *key, struct fib_result *res)
298 {
299 - int order, last_idx;
300 - struct fib_node *f;
301 + int order, last_idx, last_dflt, last_nhsel;
302 + struct fib_node *f, *first_node;
303 struct fib_info *fi = NULL;
304 struct fib_info *last_resort;
305 struct fn_hash *t = (struct fn_hash*)tb->tb_data;
306 - struct fn_zone *fz = t->fn_zones[0];
307 + struct fn_zone *fz = t->fn_zones[res->prefixlen];
308 + fn_key_t k;
309
310 if (fz == NULL)
311 return;
312
313 + k = fz_key(key->dst, fz);
314 + last_dflt = -2;
315 + first_node = NULL;
316 last_idx = -1;
317 last_resort = NULL;
318 + last_nhsel = 0;
319 order = -1;
320
321 read_lock(&fib_hash_lock);
322 - for (f = fz->fz_hash[0]; f; f = f->fn_next) {
323 + for (f = fz_chain(k, fz); f; f = f->fn_next) {
324 struct fib_info *next_fi = FIB_INFO(f);
325
326 - if ((f->fn_state&FN_S_ZOMBIE) ||
327 + if (!fn_key_eq(k, f->fn_key) ||
328 + (f->fn_state&FN_S_ZOMBIE) ||
329 f->fn_scope != res->scope ||
330 +#ifdef CONFIG_IP_ROUTE_TOS
331 + (f->fn_tos && f->fn_tos != key->tos) ||
332 +#endif
333 f->fn_type != RTN_UNICAST)
334 continue;
335
336 if (next_fi->fib_priority > res->fi->fib_priority)
337 break;
338 - if (!next_fi->fib_nh[0].nh_gw || next_fi->fib_nh[0].nh_scope != RT_SCOPE_LINK)
339 - continue;
340 f->fn_state |= FN_S_ACCESSED;
341
342 - if (fi == NULL) {
343 - if (next_fi != res->fi)
344 - break;
345 - } else if (!fib_detect_death(fi, order, &last_resort, &last_idx)) {
346 + if (!first_node) {
347 + last_dflt = f->fn_last_dflt;
348 + first_node = f;
349 + }
350 + if (fi && !fib_detect_death(fi, order, last_dflt,
351 + &last_resort, &last_idx, &last_nhsel, key)) {
352 if (res->fi)
353 fib_info_put(res->fi);
354 res->fi = fi;
355 atomic_inc(&fi->fib_clntref);
356 - fn_hash_last_dflt = order;
357 + first_node->fn_last_dflt = order;
358 goto out;
359 }
360 fi = next_fi;
361 @@ -409,16 +461,25 @@
362 }
363
364 if (order<=0 || fi==NULL) {
365 - fn_hash_last_dflt = -1;
366 + if (fi && fi->fib_nhs > 1 &&
367 + fib_detect_death(fi, order, last_dflt,
368 + &last_resort, &last_idx, &last_nhsel, key) &&
369 + last_resort == fi) {
370 + read_lock_bh(&fib_nhflags_lock);
371 + fi->fib_nh[last_nhsel].nh_flags &= ~RTNH_F_SUSPECT;
372 + read_unlock_bh(&fib_nhflags_lock);
373 + }
374 + if (first_node) first_node->fn_last_dflt = -1;
375 goto out;
376 }
377
378 - if (!fib_detect_death(fi, order, &last_resort, &last_idx)) {
379 + if (!fib_detect_death(fi, order, last_dflt, &last_resort, &last_idx,
380 + &last_nhsel, key)) {
381 if (res->fi)
382 fib_info_put(res->fi);
383 res->fi = fi;
384 atomic_inc(&fi->fib_clntref);
385 - fn_hash_last_dflt = order;
386 + first_node->fn_last_dflt = order;
387 goto out;
388 }
389
390 @@ -428,8 +489,11 @@
391 res->fi = last_resort;
392 if (last_resort)
393 atomic_inc(&last_resort->fib_clntref);
394 + read_lock_bh(&fib_nhflags_lock);
395 + last_resort->fib_nh[last_nhsel].nh_flags &= ~RTNH_F_SUSPECT;
396 + read_unlock_bh(&fib_nhflags_lock);
397 + first_node->fn_last_dflt = last_idx;
398 }
399 - fn_hash_last_dflt = last_idx;
400 out:
401 read_unlock(&fib_hash_lock);
402 }
403 @@ -589,6 +653,7 @@
404
405 memset(new_f, 0, sizeof(struct fib_node));
406
407 + new_f->fn_last_dflt = -1;
408 new_f->fn_key = key;
409 #ifdef CONFIG_IP_ROUTE_TOS
410 new_f->fn_tos = tos;
411 diff -ur v2.4.29/linux/net/ipv4/fib_rules.c linux/net/ipv4/fib_rules.c
412 --- v2.4.29/linux/net/ipv4/fib_rules.c 2004-02-19 00:23:39.000000000 +0200
413 +++ linux/net/ipv4/fib_rules.c 2005-01-20 09:55:33.433714160 +0200
414 @@ -307,6 +307,11 @@
415 }
416 }
417
418 +int fib_result_table(struct fib_result *res)
419 +{
420 + return res->r->r_table;
421 +}
422 +
423 int fib_lookup(const struct rt_key *key, struct fib_result *res)
424 {
425 int err;
426 @@ -371,8 +376,10 @@
427
428 void fib_select_default(const struct rt_key *key, struct fib_result *res)
429 {
430 - if (res->r && res->r->r_action == RTN_UNICAST &&
431 - FIB_RES_GW(*res) && FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK) {
432 + if (res->r &&
433 + (res->r->r_action == RTN_UNICAST || res->r->r_action == RTN_NAT) &&
434 + ((FIB_RES_GW(*res) && FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK) ||
435 + FIB_RES_NH(*res).nh_scope == RT_SCOPE_HOST)) {
436 struct fib_table *tb;
437 if ((tb = fib_get_table(res->r->r_table)) != NULL)
438 tb->tb_select_default(tb, key, res);
439 diff -ur v2.4.29/linux/net/ipv4/fib_semantics.c linux/net/ipv4/fib_semantics.c
440 --- v2.4.29/linux/net/ipv4/fib_semantics.c 2003-08-25 22:06:13.000000000 +0300
441 +++ linux/net/ipv4/fib_semantics.c 2005-01-20 09:55:47.000651672 +0200
442 @@ -48,6 +48,7 @@
443 static struct fib_info *fib_info_list;
444 static rwlock_t fib_info_lock = RW_LOCK_UNLOCKED;
445 int fib_info_cnt;
446 +rwlock_t fib_nhflags_lock = RW_LOCK_UNLOCKED;
447
448 #define for_fib_info() { struct fib_info *fi; \
449 for (fi = fib_info_list; fi; fi = fi->fib_next)
450 @@ -150,7 +151,7 @@
451 #ifdef CONFIG_NET_CLS_ROUTE
452 nh->nh_tclassid != onh->nh_tclassid ||
453 #endif
454 - ((nh->nh_flags^onh->nh_flags)&~RTNH_F_DEAD))
455 + ((nh->nh_flags^onh->nh_flags)&~RTNH_F_BADSTATE))
456 return -1;
457 onh++;
458 } endfor_nexthops(fi);
459 @@ -166,7 +167,7 @@
460 nfi->fib_prefsrc == fi->fib_prefsrc &&
461 nfi->fib_priority == fi->fib_priority &&
462 memcmp(nfi->fib_metrics, fi->fib_metrics, sizeof(fi->fib_metrics)) == 0 &&
463 - ((nfi->fib_flags^fi->fib_flags)&~RTNH_F_DEAD) == 0 &&
464 + ((nfi->fib_flags^fi->fib_flags)&~RTNH_F_BADSTATE) == 0 &&
465 (nfi->fib_nhs == 0 || nh_comp(fi, nfi) == 0))
466 return fi;
467 } endfor_fib_info();
468 @@ -365,8 +366,11 @@
469 return -EINVAL;
470 if ((dev = __dev_get_by_index(nh->nh_oif)) == NULL)
471 return -ENODEV;
472 - if (!(dev->flags&IFF_UP))
473 - return -ENETDOWN;
474 + if (!(dev->flags&IFF_UP)) {
475 + if (fi->fib_protocol != RTPROT_STATIC)
476 + return -ENETDOWN;
477 + nh->nh_flags |= RTNH_F_DEAD;
478 + }
479 nh->nh_dev = dev;
480 dev_hold(dev);
481 nh->nh_scope = RT_SCOPE_LINK;
482 @@ -380,23 +384,48 @@
483 /* It is not necessary, but requires a bit of thinking */
484 if (key.scope < RT_SCOPE_LINK)
485 key.scope = RT_SCOPE_LINK;
486 - if ((err = fib_lookup(&key, &res)) != 0)
487 - return err;
488 - err = -EINVAL;
489 - if (res.type != RTN_UNICAST && res.type != RTN_LOCAL)
490 - goto out;
491 - nh->nh_scope = res.scope;
492 - nh->nh_oif = FIB_RES_OIF(res);
493 - if ((nh->nh_dev = FIB_RES_DEV(res)) == NULL)
494 - goto out;
495 - dev_hold(nh->nh_dev);
496 - err = -ENETDOWN;
497 - if (!(nh->nh_dev->flags & IFF_UP))
498 - goto out;
499 - err = 0;
500 +
501 + err = fib_lookup(&key, &res);
502 + if (err) {
503 + struct in_device *in_dev;
504 +
505 + if (err != -ENETUNREACH ||
506 + fi->fib_protocol != RTPROT_STATIC)
507 + return err;
508 +
509 + in_dev = inetdev_by_index(nh->nh_oif);
510 + if (in_dev == NULL ||
511 + in_dev->dev->flags & IFF_UP) {
512 + if (in_dev)
513 + in_dev_put(in_dev);
514 + return err;
515 + }
516 + nh->nh_flags |= RTNH_F_DEAD;
517 + nh->nh_scope = RT_SCOPE_LINK;
518 + nh->nh_dev = in_dev->dev;
519 + dev_hold(nh->nh_dev);
520 + in_dev_put(in_dev);
521 + } else {
522 + err = -EINVAL;
523 + if (res.type != RTN_UNICAST && res.type != RTN_LOCAL)
524 + goto out;
525 + nh->nh_scope = res.scope;
526 + nh->nh_oif = FIB_RES_OIF(res);
527 + if ((nh->nh_dev = FIB_RES_DEV(res)) == NULL)
528 + goto out;
529 + dev_hold(nh->nh_dev);
530 + if (!(nh->nh_dev->flags & IFF_UP)) {
531 + if (fi->fib_protocol != RTPROT_STATIC) {
532 + err = -ENETDOWN;
533 + goto out;
534 + }
535 + nh->nh_flags |= RTNH_F_DEAD;
536 + }
537 + err = 0;
538 out:
539 - fib_res_put(&res);
540 - return err;
541 + fib_res_put(&res);
542 + return err;
543 + }
544 } else {
545 struct in_device *in_dev;
546
547 @@ -407,8 +436,11 @@
548 if (in_dev == NULL)
549 return -ENODEV;
550 if (!(in_dev->dev->flags&IFF_UP)) {
551 - in_dev_put(in_dev);
552 - return -ENETDOWN;
553 + if (fi->fib_protocol != RTPROT_STATIC) {
554 + in_dev_put(in_dev);
555 + return -ENETDOWN;
556 + }
557 + nh->nh_flags |= RTNH_F_DEAD;
558 }
559 nh->nh_dev = in_dev->dev;
560 dev_hold(nh->nh_dev);
561 @@ -603,8 +635,12 @@
562 for_nexthops(fi) {
563 if (nh->nh_flags&RTNH_F_DEAD)
564 continue;
565 - if (!key->oif || key->oif == nh->nh_oif)
566 - break;
567 + if (key->oif && key->oif != nh->nh_oif)
568 + continue;
569 + if (key->gw && key->gw != nh->nh_gw &&
570 + nh->nh_gw && nh->nh_scope == RT_SCOPE_LINK)
571 + continue;
572 + break;
573 }
574 #ifdef CONFIG_IP_ROUTE_MULTIPATH
575 if (nhsel < fi->fib_nhs) {
576 @@ -870,22 +906,35 @@
577 if (local && fi->fib_prefsrc == local) {
578 fi->fib_flags |= RTNH_F_DEAD;
579 ret++;
580 - } else if (dev && fi->fib_nhs) {
581 + } else if (fi->fib_nhs) {
582 int dead = 0;
583
584 change_nexthops(fi) {
585 - if (nh->nh_flags&RTNH_F_DEAD)
586 - dead++;
587 - else if (nh->nh_dev == dev &&
588 - nh->nh_scope != scope) {
589 - nh->nh_flags |= RTNH_F_DEAD;
590 + if (nh->nh_flags&RTNH_F_DEAD) {
591 + if (fi->fib_protocol!=RTPROT_STATIC ||
592 + nh->nh_dev == NULL ||
593 + !__in_dev_get(nh->nh_dev) ||
594 + nh->nh_dev->flags&IFF_UP)
595 + dead++;
596 + } else if ((nh->nh_dev == dev && dev &&
597 + nh->nh_scope != scope) ||
598 + (local == nh->nh_gw && local &&
599 + nh->nh_oif)) {
600 + write_lock_bh(&fib_nhflags_lock);
601 #ifdef CONFIG_IP_ROUTE_MULTIPATH
602 - spin_lock_bh(&fib_multipath_lock);
603 + spin_lock(&fib_multipath_lock);
604 + nh->nh_flags |= RTNH_F_DEAD;
605 fi->fib_power -= nh->nh_power;
606 nh->nh_power = 0;
607 - spin_unlock_bh(&fib_multipath_lock);
608 + spin_unlock(&fib_multipath_lock);
609 +#else
610 + nh->nh_flags |= RTNH_F_DEAD;
611 #endif
612 - dead++;
613 + write_unlock_bh(&fib_nhflags_lock);
614 + if (fi->fib_protocol!=RTPROT_STATIC ||
615 + force ||
616 + (dev && __in_dev_get(dev) == NULL))
617 + dead++;
618 }
619 #ifdef CONFIG_IP_ROUTE_MULTIPATH
620 if (force > 1 && nh->nh_dev == dev) {
621 @@ -903,37 +952,55 @@
622 return ret;
623 }
624
625 -#ifdef CONFIG_IP_ROUTE_MULTIPATH
626 -
627 /*
628 - Dead device goes up. We wake up dead nexthops.
629 - It takes sense only on multipath routes.
630 + Dead device goes up or new address is added. We wake up dead nexthops.
631 */
632
633 int fib_sync_up(struct net_device *dev)
634 {
635 - int ret = 0;
636 + struct rt_key key;
637 + struct fib_result res;
638 + int ret, rep;
639
640 +repeat:
641 if (!(dev->flags&IFF_UP))
642 return 0;
643
644 + ret = 0;
645 + rep = 0;
646 for_fib_info() {
647 int alive = 0;
648
649 change_nexthops(fi) {
650 - if (!(nh->nh_flags&RTNH_F_DEAD)) {
651 - alive++;
652 + if (!(nh->nh_flags&RTNH_F_DEAD))
653 continue;
654 - }
655 if (nh->nh_dev == NULL || !(nh->nh_dev->flags&IFF_UP))
656 continue;
657 if (nh->nh_dev != dev || __in_dev_get(dev) == NULL)
658 continue;
659 + if (nh->nh_gw && fi->fib_protocol == RTPROT_STATIC) {
660 + memset(&key, 0, sizeof(key));
661 + key.dst = nh->nh_gw;
662 + key.oif = nh->nh_oif;
663 + key.scope = nh->nh_scope;
664 + if (fib_lookup(&key, &res) != 0)
665 + continue;
666 + if (res.type != RTN_UNICAST &&
667 + res.type != RTN_LOCAL) {
668 + fib_res_put(&res);
669 + continue;
670 + }
671 + nh->nh_scope = res.scope;
672 + fib_res_put(&res);
673 + rep = 1;
674 + }
675 alive++;
676 +#ifdef CONFIG_IP_ROUTE_MULTIPATH
677 spin_lock_bh(&fib_multipath_lock);
678 nh->nh_power = 0;
679 nh->nh_flags &= ~RTNH_F_DEAD;
680 spin_unlock_bh(&fib_multipath_lock);
681 +#endif
682 } endfor_nexthops(fi)
683
684 if (alive > 0) {
685 @@ -941,9 +1008,13 @@
686 ret++;
687 }
688 } endfor_fib_info();
689 + if (rep)
690 + goto repeat;
691 return ret;
692 }
693
694 +#ifdef CONFIG_IP_ROUTE_MULTIPATH
695 +
696 /*
697 The algorithm is suboptimal, but it provides really
698 fair weighted route distribution.
699 @@ -952,24 +1023,45 @@
700 void fib_select_multipath(const struct rt_key *key, struct fib_result *res)
701 {
702 struct fib_info *fi = res->fi;
703 - int w;
704 + int w, alive;
705
706 spin_lock_bh(&fib_multipath_lock);
707 + if (key->oif) {
708 + int sel = -1;
709 + w = -1;
710 + change_nexthops(fi) {
711 + if (key->oif != nh->nh_oif)
712 + continue;
713 + if (key->gw && key->gw != nh->nh_gw &&
714 + nh->nh_gw && nh->nh_scope == RT_SCOPE_LINK)
715 + continue;
716 + if (!(nh->nh_flags&RTNH_F_BADSTATE)) {
717 + if (nh->nh_power > w) {
718 + w = nh->nh_power;
719 + sel = nhsel;
720 + }
721 + }
722 + } endfor_nexthops(fi);
723 + if (sel >= 0) {
724 + spin_unlock_bh(&fib_multipath_lock);
725 + res->nh_sel = sel;
726 + return;
727 + }
728 + goto last_resort;
729 + }
730 +
731 +repeat:
732 if (fi->fib_power <= 0) {
733 int power = 0;
734 change_nexthops(fi) {
735 - if (!(nh->nh_flags&RTNH_F_DEAD)) {
736 + if (!(nh->nh_flags&RTNH_F_BADSTATE)) {
737 power += nh->nh_weight;
738 nh->nh_power = nh->nh_weight;
739 }
740 } endfor_nexthops(fi);
741 fi->fib_power = power;
742 - if (power <= 0) {
743 - spin_unlock_bh(&fib_multipath_lock);
744 - /* Race condition: route has just become dead. */
745 - res->nh_sel = 0;
746 - return;
747 - }
748 + if (power <= 0)
749 + goto last_resort;
750 }
751
752
753 @@ -979,20 +1071,40 @@
754
755 w = jiffies % fi->fib_power;
756
757 + alive = 0;
758 change_nexthops(fi) {
759 - if (!(nh->nh_flags&RTNH_F_DEAD) && nh->nh_power) {
760 + if (!(nh->nh_flags&RTNH_F_BADSTATE) && nh->nh_power) {
761 if ((w -= nh->nh_power) <= 0) {
762 nh->nh_power--;
763 fi->fib_power--;
764 - res->nh_sel = nhsel;
765 spin_unlock_bh(&fib_multipath_lock);
766 + res->nh_sel = nhsel;
767 return;
768 }
769 + alive = 1;
770 + }
771 + } endfor_nexthops(fi);
772 + if (alive) {
773 + fi->fib_power = 0;
774 + goto repeat;
775 + }
776 +
777 +last_resort:
778 +
779 + for_nexthops(fi) {
780 + if (!(nh->nh_flags&RTNH_F_DEAD)) {
781 + if (key->oif && key->oif != nh->nh_oif)
782 + continue;
783 + if (key->gw && key->gw != nh->nh_gw &&
784 + nh->nh_gw && nh->nh_scope == RT_SCOPE_LINK)
785 + continue;
786 + spin_unlock_bh(&fib_multipath_lock);
787 + res->nh_sel = nhsel;
788 + return;
789 }
790 } endfor_nexthops(fi);
791
792 /* Race condition: route has just become dead. */
793 - res->nh_sel = 0;
794 spin_unlock_bh(&fib_multipath_lock);
795 }
796 #endif
797 diff -ur v2.4.29/linux/net/ipv4/ip_nat_dumb.c linux/net/ipv4/ip_nat_dumb.c
798 --- v2.4.29/linux/net/ipv4/ip_nat_dumb.c 2001-11-13 03:25:26.000000000 +0200
799 +++ linux/net/ipv4/ip_nat_dumb.c 2005-01-20 09:55:47.001651520 +0200
800 @@ -124,6 +124,7 @@
801 key.dst = ciph->saddr;
802 key.iif = skb->dev->ifindex;
803 key.oif = 0;
804 + key.gw = 0;
805 #ifdef CONFIG_IP_ROUTE_TOS
806 key.tos = RT_TOS(ciph->tos);
807 #endif
808 diff -ur v2.4.29/linux/net/ipv4/netfilter/ip_fw_compat_masq.c linux/net/ipv4/netfilter/ip_fw_compat_masq.c
809 --- v2.4.29/linux/net/ipv4/netfilter/ip_fw_compat_masq.c 2005-01-20 09:25:34.000000000 +0200
810 +++ linux/net/ipv4/netfilter/ip_fw_compat_masq.c 2005-01-20 09:55:47.001651520 +0200
811 @@ -41,6 +41,10 @@
812 enum ip_conntrack_info ctinfo;
813 struct ip_conntrack *ct;
814 unsigned int ret;
815 + struct rtable *rt, *skb_rt;
816 + struct net_device *skb_dev;
817 + __u32 saddr;
818 + int new;
819
820 /* Sorry, only ICMP, TCP and UDP. */
821 if (iph->protocol != IPPROTO_ICMP
822 @@ -64,22 +68,28 @@
823 }
824
825 info = &ct->nat.info;
826 + iph = (*pskb)->nh.iph;
827 + saddr = iph->saddr;
828 + new = 0;
829
830 WRITE_LOCK(&ip_nat_lock);
831 /* Setup the masquerade, if not already */
832 if (!info->initialized) {
833 u_int32_t newsrc;
834 - struct rtable *rt;
835 struct ip_nat_multi_range range;
836
837 + skb_rt = (struct rtable *) (*pskb)->dst;
838 + skb_dev = skb_rt->u.dst.dev;
839 /* Pass 0 instead of saddr, since it's going to be changed
840 anyway. */
841 - if (ip_route_output(&rt, iph->daddr, 0, 0, 0) != 0) {
842 + if (ip_route_output_lookup(&rt, iph->daddr, 0, RT_TOS(iph->tos),
843 + skb_dev? skb_dev->ifindex : 0,
844 + skb_dev? skb_rt->rt_gateway : 0) != 0) {
845 + WRITE_UNLOCK(&ip_nat_lock);
846 DEBUGP("ipnat_rule_masquerade: Can't reroute.\n");
847 return NF_DROP;
848 }
849 - newsrc = inet_select_addr(rt->u.dst.dev, rt->rt_gateway,
850 - RT_SCOPE_UNIVERSE);
851 + newsrc = rt->rt_src;
852 ip_rt_put(rt);
853 range = ((struct ip_nat_multi_range)
854 { 1,
855 @@ -92,11 +102,31 @@
856 WRITE_UNLOCK(&ip_nat_lock);
857 return ret;
858 }
859 + new = 1;
860 } else
861 DEBUGP("Masquerading already done on this conn.\n");
862 WRITE_UNLOCK(&ip_nat_lock);
863
864 - return do_bindings(ct, ctinfo, info, NF_IP_POST_ROUTING, pskb);
865 + ret = do_bindings(ct, ctinfo, info, NF_IP_POST_ROUTING, pskb);
866 + if (ret != NF_ACCEPT || saddr == (*pskb)->nh.iph->saddr || new)
867 + return ret;
868 +
869 + iph = (*pskb)->nh.iph;
870 + if (ip_route_output(&rt, iph->daddr, iph->saddr, RT_TOS(iph->tos), 0) != 0)
871 + return NF_DROP;
872 +
873 + skb_rt = (struct rtable *) (*pskb)->dst;
874 + skb_dev = skb_rt->u.dst.dev;
875 + if (skb_dev != rt->u.dst.dev || rt->rt_gateway != skb_rt->rt_gateway) {
876 + if (skb_dev != rt->u.dst.dev) {
877 + /* TODO: check the new mtu and reply FRAG_NEEDED */
878 + }
879 + dst_release((*pskb)->dst);
880 + (*pskb)->dst = &rt->u.dst;
881 + } else {
882 + ip_rt_put(rt);
883 + }
884 + return NF_ACCEPT;
885 }
886
887 void
888 diff -ur v2.4.29/linux/net/ipv4/netfilter/ip_nat_core.c linux/net/ipv4/netfilter/ip_nat_core.c
889 --- v2.4.29/linux/net/ipv4/netfilter/ip_nat_core.c 2005-01-20 09:25:34.000000000 +0200
890 +++ linux/net/ipv4/netfilter/ip_nat_core.c 2005-01-20 09:55:47.002651368 +0200
891 @@ -994,6 +994,60 @@
892 return NF_ACCEPT;
893 }
894
895 +unsigned int
896 +ip_nat_route_input(unsigned int hooknum,
897 + struct sk_buff **pskb,
898 + const struct net_device *in,
899 + const struct net_device *out,
900 + int (*okfn)(struct sk_buff *))
901 +{
902 + struct sk_buff *skb = *pskb;
903 + struct iphdr *iph;
904 + struct ip_conntrack *ct;
905 + enum ip_conntrack_info ctinfo;
906 + struct ip_nat_info *info;
907 + enum ip_conntrack_dir dir;
908 + __u32 saddr;
909 + int i;
910 +
911 + if (!(ct = ip_conntrack_get(skb, &ctinfo)))
912 + return NF_ACCEPT;
913 +
914 + info = &ct->nat.info;
915 + if (!info->initialized)
916 + return NF_ACCEPT;
917 +
918 + if (skb->dst)
919 + return NF_ACCEPT;
920 +
921 + if (skb->len < sizeof(struct iphdr))
922 + return NF_ACCEPT;
923 +
924 + iph = skb->nh.iph;
925 + saddr = iph->saddr;
926 + hooknum = NF_IP_POST_ROUTING;
927 + dir = CTINFO2DIR(ctinfo);
928 +
929 + READ_LOCK(&ip_nat_lock);
930 + for (i = 0; i < info->num_manips; i++) {
931 + if (info->manips[i].direction == dir
932 + && info->manips[i].hooknum == hooknum
933 + && info->manips[i].maniptype == IP_NAT_MANIP_SRC) {
934 + saddr = info->manips[i].manip.ip;
935 + }
936 + }
937 + READ_UNLOCK(&ip_nat_lock);
938 +
939 + if (saddr == iph->saddr)
940 + return NF_ACCEPT;
941 +
942 + if (ip_route_input_lookup(skb, iph->daddr, iph->saddr, iph->tos,
943 + skb->dev, saddr))
944 + return NF_DROP;
945 +
946 + return NF_ACCEPT;
947 +}
948 +
949 int __init ip_nat_init(void)
950 {
951 size_t i;
952 diff -ur v2.4.29/linux/net/ipv4/netfilter/ip_nat_standalone.c linux/net/ipv4/netfilter/ip_nat_standalone.c
953 --- v2.4.29/linux/net/ipv4/netfilter/ip_nat_standalone.c 2005-01-20 09:25:34.000000000 +0200
954 +++ linux/net/ipv4/netfilter/ip_nat_standalone.c 2005-01-20 09:55:47.002651368 +0200
955 @@ -241,6 +241,9 @@
956 /* Before packet filtering, change destination */
957 static struct nf_hook_ops ip_nat_in_ops
958 = { { NULL, NULL }, ip_nat_in, PF_INET, NF_IP_PRE_ROUTING, NF_IP_PRI_NAT_DST };
959 +/* Before routing, route before mangling */
960 +static struct nf_hook_ops ip_nat_inr_ops
961 += { { NULL, NULL }, ip_nat_route_input, PF_INET, NF_IP_PRE_ROUTING, NF_IP_PRI_LAST-1 };
962 /* After packet filtering, change source */
963 static struct nf_hook_ops ip_nat_out_ops
964 = { { NULL, NULL }, ip_nat_out, PF_INET, NF_IP_POST_ROUTING, NF_IP_PRI_NAT_SRC};
965 @@ -309,10 +312,15 @@
966 printk("ip_nat_init: can't register in hook.\n");
967 goto cleanup_nat;
968 }
969 + ret = nf_register_hook(&ip_nat_inr_ops);
970 + if (ret < 0) {
971 + printk("ip_nat_init: can't register inr hook.\n");
972 + goto cleanup_inops;
973 + }
974 ret = nf_register_hook(&ip_nat_out_ops);
975 if (ret < 0) {
976 printk("ip_nat_init: can't register out hook.\n");
977 - goto cleanup_inops;
978 + goto cleanup_inrops;
979 }
980 ret = nf_register_hook(&ip_nat_local_out_ops);
981 if (ret < 0) {
982 @@ -332,6 +340,8 @@
983 nf_unregister_hook(&ip_nat_local_out_ops);
984 cleanup_outops:
985 nf_unregister_hook(&ip_nat_out_ops);
986 + cleanup_inrops:
987 + nf_unregister_hook(&ip_nat_inr_ops);
988 cleanup_inops:
989 nf_unregister_hook(&ip_nat_in_ops);
990 cleanup_nat:
991 diff -ur v2.4.29/linux/net/ipv4/netfilter/ipt_MASQUERADE.c linux/net/ipv4/netfilter/ipt_MASQUERADE.c
992 --- v2.4.29/linux/net/ipv4/netfilter/ipt_MASQUERADE.c 2005-01-20 09:25:34.000000000 +0200
993 +++ linux/net/ipv4/netfilter/ipt_MASQUERADE.c 2005-01-20 09:55:47.003651216 +0200
994 @@ -87,7 +87,8 @@
995 key.dst = (*pskb)->nh.iph->daddr;
996 key.src = 0; /* Unknown: that's what we're trying to establish */
997 key.tos = RT_TOS((*pskb)->nh.iph->tos)|RTO_CONN;
998 - key.oif = 0;
999 + key.oif = out->ifindex;
1000 + key.gw = ((struct rtable *) (*pskb)->dst)->rt_gateway;
1001 #ifdef CONFIG_IP_ROUTE_FWMARK
1002 key.fwmark = (*pskb)->nfmark;
1003 #endif
1004 @@ -98,13 +99,6 @@
1005 " No route: Rusty's brain broke!\n");
1006 return NF_DROP;
1007 }
1008 - if (rt->u.dst.dev != out) {
1009 - if (net_ratelimit())
1010 - printk("MASQUERADE:"
1011 - " Route sent us somewhere else.\n");
1012 - ip_rt_put(rt);
1013 - return NF_DROP;
1014 - }
1015
1016 newsrc = rt->rt_src;
1017 DEBUGP("newsrc = %u.%u.%u.%u\n", NIPQUAD(newsrc));
1018 diff -ur v2.4.29/linux/net/ipv4/route.c linux/net/ipv4/route.c
1019 --- v2.4.29/linux/net/ipv4/route.c 2004-11-18 08:30:33.000000000 +0200
1020 +++ linux/net/ipv4/route.c 2005-01-20 09:55:47.004651064 +0200
1021 @@ -919,6 +919,7 @@
1022
1023 /* Gateway is different ... */
1024 rt->rt_gateway = new_gw;
1025 + if (rt->key.gw) rt->key.gw = new_gw;
1026
1027 /* Redirect received -> path was valid */
1028 dst_confirm(&rth->u.dst);
1029 @@ -1343,6 +1344,7 @@
1030 rth->key.fwmark = skb->nfmark;
1031 #endif
1032 rth->key.src = saddr;
1033 + rth->key.lsrc = 0;
1034 rth->rt_src = saddr;
1035 #ifdef CONFIG_IP_ROUTE_NAT
1036 rth->rt_dst_map = daddr;
1037 @@ -1356,6 +1358,7 @@
1038 rth->u.dst.dev = &loopback_dev;
1039 dev_hold(rth->u.dst.dev);
1040 rth->key.oif = 0;
1041 + rth->key.gw = 0;
1042 rth->rt_gateway = daddr;
1043 rth->rt_spec_dst= spec_dst;
1044 rth->rt_type = RTN_MULTICAST;
1045 @@ -1395,7 +1398,7 @@
1046 */
1047
1048 int ip_route_input_slow(struct sk_buff *skb, u32 daddr, u32 saddr,
1049 - u8 tos, struct net_device *dev)
1050 + u8 tos, struct net_device *dev, u32 lsrc)
1051 {
1052 struct rt_key key;
1053 struct fib_result res;
1054 @@ -1415,16 +1418,17 @@
1055 goto out;
1056
1057 key.dst = daddr;
1058 - key.src = saddr;
1059 + key.src = lsrc? : saddr;
1060 key.tos = tos;
1061 #ifdef CONFIG_IP_ROUTE_FWMARK
1062 key.fwmark = skb->nfmark;
1063 #endif
1064 - key.iif = dev->ifindex;
1065 + key.iif = lsrc? loopback_dev.ifindex : dev->ifindex;
1066 key.oif = 0;
1067 + key.gw = 0;
1068 key.scope = RT_SCOPE_UNIVERSE;
1069
1070 - hash = rt_hash_code(daddr, saddr ^ (key.iif << 5), tos);
1071 + hash = rt_hash_code(daddr, saddr ^ (dev->ifindex << 5), tos);
1072
1073 /* Check for the most weird martians, which can be not detected
1074 by fib_lookup.
1075 @@ -1445,6 +1449,12 @@
1076 if (BADCLASS(daddr) || ZERONET(daddr) || LOOPBACK(daddr))
1077 goto martian_destination;
1078
1079 + if (lsrc) {
1080 + if (MULTICAST(lsrc) || BADCLASS(lsrc) ||
1081 + ZERONET(lsrc) || LOOPBACK(lsrc))
1082 + goto e_inval;
1083 + }
1084 +
1085 /*
1086 * Now we are ready to route packet.
1087 */
1088 @@ -1454,6 +1464,10 @@
1089 goto no_route;
1090 }
1091 free_res = 1;
1092 + if (lsrc && res.type != RTN_UNICAST && res.type != RTN_NAT)
1093 + goto e_inval;
1094 + key.iif = dev->ifindex;
1095 + key.src = saddr;
1096
1097 rt_cache_stat[smp_processor_id()].in_slow_tot++;
1098
1099 @@ -1464,7 +1478,7 @@
1100
1101 if (1) {
1102 u32 src_map = saddr;
1103 - if (res.r)
1104 + if (res.r && !lsrc)
1105 src_map = fib_rules_policy(saddr, &res, &flags);
1106
1107 if (res.type == RTN_NAT) {
1108 @@ -1503,8 +1517,9 @@
1109 if (res.type != RTN_UNICAST)
1110 goto martian_destination;
1111
1112 + fib_select_default(&key, &res);
1113 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1114 - if (res.fi->fib_nhs > 1 && key.oif == 0)
1115 + if (res.fi->fib_nhs > 1)
1116 fib_select_multipath(&key, &res);
1117 #endif
1118 out_dev = in_dev_get(FIB_RES_DEV(res));
1119 @@ -1524,6 +1539,7 @@
1120 flags |= RTCF_DIRECTSRC;
1121
1122 if (out_dev == in_dev && err && !(flags & (RTCF_NAT | RTCF_MASQ)) &&
1123 + !lsrc &&
1124 (IN_DEV_SHARED_MEDIA(out_dev) ||
1125 inet_addr_onlink(out_dev, saddr, FIB_RES_GW(res))))
1126 flags |= RTCF_DOREDIRECT;
1127 @@ -1550,6 +1566,7 @@
1128 #endif
1129 rth->key.src = saddr;
1130 rth->rt_src = saddr;
1131 + rth->key.lsrc = lsrc;
1132 rth->rt_gateway = daddr;
1133 #ifdef CONFIG_IP_ROUTE_NAT
1134 rth->rt_src_map = key.src;
1135 @@ -1562,6 +1579,7 @@
1136 rth->u.dst.dev = out_dev->dev;
1137 dev_hold(rth->u.dst.dev);
1138 rth->key.oif = 0;
1139 + rth->key.gw = 0;
1140 rth->rt_spec_dst= spec_dst;
1141
1142 rth->u.dst.input = ip_forward;
1143 @@ -1572,7 +1590,8 @@
1144 rth->rt_flags = flags;
1145
1146 #ifdef CONFIG_NET_FASTROUTE
1147 - if (netdev_fastroute && !(flags&(RTCF_NAT|RTCF_MASQ|RTCF_DOREDIRECT))) {
1148 + if (netdev_fastroute && !(flags&(RTCF_NAT|RTCF_MASQ|RTCF_DOREDIRECT)) &&
1149 + !lsrc) {
1150 struct net_device *odev = rth->u.dst.dev;
1151 if (odev != dev &&
1152 dev->accept_fastpath &&
1153 @@ -1595,6 +1614,8 @@
1154 brd_input:
1155 if (skb->protocol != htons(ETH_P_IP))
1156 goto e_inval;
1157 + if (lsrc)
1158 + goto e_inval;
1159
1160 if (ZERONET(saddr))
1161 spec_dst = inet_select_addr(dev, 0, RT_SCOPE_LINK);
1162 @@ -1627,6 +1648,7 @@
1163 #endif
1164 rth->key.src = saddr;
1165 rth->rt_src = saddr;
1166 + rth->key.lsrc = 0;
1167 #ifdef CONFIG_IP_ROUTE_NAT
1168 rth->rt_dst_map = key.dst;
1169 rth->rt_src_map = key.src;
1170 @@ -1639,6 +1661,7 @@
1171 rth->u.dst.dev = &loopback_dev;
1172 dev_hold(rth->u.dst.dev);
1173 rth->key.oif = 0;
1174 + rth->key.gw = 0;
1175 rth->rt_gateway = daddr;
1176 rth->rt_spec_dst= spec_dst;
1177 rth->u.dst.input= ip_local_deliver;
1178 @@ -1704,8 +1727,9 @@
1179 goto e_inval;
1180 }
1181
1182 -int ip_route_input(struct sk_buff *skb, u32 daddr, u32 saddr,
1183 - u8 tos, struct net_device *dev)
1184 +static inline int
1185 +ip_route_input_cached(struct sk_buff *skb, u32 daddr, u32 saddr,
1186 + u8 tos, struct net_device *dev, u32 lsrc)
1187 {
1188 struct rtable * rth;
1189 unsigned hash;
1190 @@ -1719,6 +1743,7 @@
1191 if (rth->key.dst == daddr &&
1192 rth->key.src == saddr &&
1193 rth->key.iif == iif &&
1194 + rth->key.lsrc == lsrc &&
1195 rth->key.oif == 0 &&
1196 #ifdef CONFIG_IP_ROUTE_FWMARK
1197 rth->key.fwmark == skb->nfmark &&
1198 @@ -1766,9 +1791,21 @@
1199 read_unlock(&inetdev_lock);
1200 return -EINVAL;
1201 }
1202 - return ip_route_input_slow(skb, daddr, saddr, tos, dev);
1203 + return ip_route_input_slow(skb, daddr, saddr, tos, dev, lsrc);
1204 +}
1205 +
1206 +int ip_route_input(struct sk_buff *skb, u32 daddr, u32 saddr,
1207 + u8 tos, struct net_device *dev)
1208 +{
1209 + return ip_route_input_cached(skb, daddr, saddr, tos, dev, 0);
1210 }
1211
1212 +int ip_route_input_lookup(struct sk_buff *skb, u32 daddr, u32 saddr,
1213 + u8 tos, struct net_device *dev, u32 lsrc)
1214 +{
1215 + return ip_route_input_cached(skb, daddr, saddr, tos, dev, lsrc);
1216 +}
1217 +
1218 /*
1219 * Major route resolver routine.
1220 */
1221 @@ -1791,6 +1828,7 @@
1222 key.tos = tos & IPTOS_RT_MASK;
1223 key.iif = loopback_dev.ifindex;
1224 key.oif = oldkey->oif;
1225 + key.gw = oldkey->gw;
1226 #ifdef CONFIG_IP_ROUTE_FWMARK
1227 key.fwmark = oldkey->fwmark;
1228 #endif
1229 @@ -1880,6 +1918,7 @@
1230 dev_out = &loopback_dev;
1231 dev_hold(dev_out);
1232 key.oif = loopback_dev.ifindex;
1233 + key.gw = 0;
1234 res.type = RTN_LOCAL;
1235 flags |= RTCF_LOCAL;
1236 goto make_route;
1237 @@ -1887,7 +1926,7 @@
1238
1239 if (fib_lookup(&key, &res)) {
1240 res.fi = NULL;
1241 - if (oldkey->oif) {
1242 + if (oldkey->oif && dev_out->flags&IFF_UP) {
1243 /* Apparently, routing tables are wrong. Assume,
1244 that the destination is on link.
1245
1246 @@ -1930,6 +1969,7 @@
1247 dev_out = &loopback_dev;
1248 dev_hold(dev_out);
1249 key.oif = dev_out->ifindex;
1250 + key.gw = 0;
1251 if (res.fi)
1252 fib_info_put(res.fi);
1253 res.fi = NULL;
1254 @@ -1937,13 +1977,12 @@
1255 goto make_route;
1256 }
1257
1258 + if (res.type == RTN_UNICAST)
1259 + fib_select_default(&key, &res);
1260 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1261 - if (res.fi->fib_nhs > 1 && key.oif == 0)
1262 + if (res.fi->fib_nhs > 1)
1263 fib_select_multipath(&key, &res);
1264 - else
1265 #endif
1266 - if (!res.prefixlen && res.type == RTN_UNICAST && !key.oif)
1267 - fib_select_default(&key, &res);
1268
1269 if (!key.src)
1270 key.src = FIB_RES_PREFSRC(res);
1271 @@ -2001,7 +2040,9 @@
1272 rth->key.tos = tos;
1273 rth->key.src = oldkey->src;
1274 rth->key.iif = 0;
1275 + rth->key.lsrc = 0;
1276 rth->key.oif = oldkey->oif;
1277 + rth->key.gw = oldkey->gw;
1278 #ifdef CONFIG_IP_ROUTE_FWMARK
1279 rth->key.fwmark = oldkey->fwmark;
1280 #endif
1281 @@ -2080,6 +2121,7 @@
1282 rth->key.src == key->src &&
1283 rth->key.iif == 0 &&
1284 rth->key.oif == key->oif &&
1285 + rth->key.gw == key->gw &&
1286 #ifdef CONFIG_IP_ROUTE_FWMARK
1287 rth->key.fwmark == key->fwmark &&
1288 #endif
1289 diff -ur v2.4.29/linux/net/netsyms.c linux/net/netsyms.c
1290 --- v2.4.29/linux/net/netsyms.c 2005-01-20 09:25:34.000000000 +0200
1291 +++ linux/net/netsyms.c 2005-01-20 09:55:47.005650912 +0200
1292 @@ -260,6 +260,7 @@
1293 EXPORT_SYMBOL(inet_unregister_protosw);
1294 EXPORT_SYMBOL(ip_route_output_key);
1295 EXPORT_SYMBOL(ip_route_input);
1296 +EXPORT_SYMBOL(ip_route_input_lookup);
1297 EXPORT_SYMBOL(icmp_send);
1298 EXPORT_SYMBOL(icmp_statistics);
1299 EXPORT_SYMBOL(icmp_err_convert);
Personal OpenWRT clone
This page took 0.098999 seconds and 5 git commands to generate.