projects / openwrt / staging / wigyori.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
let ipkg fail when a package file to be installed is not found
[openwrt/staging/wigyori.git] / openwrt / target / linux / generic-2.6 / patches / 201-multiple_default_gateways.patch
1 diff -ur v2.6.14/linux/include/linux/netfilter_ipv4/ip_nat.h linux/include/linux/netfilter_ipv4/ip_nat.h
2 --- v2.6.14/linux/include/linux/netfilter_ipv4/ip_nat.h 2005-10-29 14:15:09.000000000 +0300
3 +++ linux/include/linux/netfilter_ipv4/ip_nat.h 2005-10-29 18:11:32.885759304 +0300
4 @@ -63,6 +63,13 @@
5
6 struct ip_conntrack;
7
8 +/* Call input routing for SNAT-ed traffic */
9 +extern unsigned int ip_nat_route_input(unsigned int hooknum,
10 + struct sk_buff **pskb,
11 + const struct net_device *in,
12 + const struct net_device *out,
13 + int (*okfn)(struct sk_buff *));
14 +
15 /* Set up the info structure to map into this range. */
16 extern unsigned int ip_nat_setup_info(struct ip_conntrack *conntrack,
17 const struct ip_nat_range *range,
18 diff -ur v2.6.14/linux/include/linux/rtnetlink.h linux/include/linux/rtnetlink.h
19 --- v2.6.14/linux/include/linux/rtnetlink.h 2005-10-29 14:15:09.000000000 +0300
20 +++ linux/include/linux/rtnetlink.h 2005-10-29 18:11:21.299520680 +0300
21 @@ -292,6 +292,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.6.14/linux/include/net/flow.h linux/include/net/flow.h
31 --- v2.6.14/linux/include/net/flow.h 2005-06-18 08:50:52.000000000 +0300
32 +++ linux/include/net/flow.h 2005-10-29 18:11:32.885759304 +0300
33 @@ -19,6 +19,8 @@
34 __u32 daddr;
35 __u32 saddr;
36 __u32 fwmark;
37 + __u32 lsrc;
38 + __u32 gw;
39 __u8 tos;
40 __u8 scope;
41 } ip4_u;
42 @@ -46,6 +48,8 @@
43 #define fl4_dst nl_u.ip4_u.daddr
44 #define fl4_src nl_u.ip4_u.saddr
45 #define fl4_fwmark nl_u.ip4_u.fwmark
46 +#define fl4_lsrc nl_u.ip4_u.lsrc
47 +#define fl4_gw nl_u.ip4_u.gw
48 #define fl4_tos nl_u.ip4_u.tos
49 #define fl4_scope nl_u.ip4_u.scope
50
51 diff -ur v2.6.14/linux/include/net/ip_fib.h linux/include/net/ip_fib.h
52 --- v2.6.14/linux/include/net/ip_fib.h 2005-10-29 14:15:09.000000000 +0300
53 +++ linux/include/net/ip_fib.h 2005-10-29 18:11:21.300520528 +0300
54 @@ -195,7 +195,8 @@
55
56 static inline void fib_select_default(const struct flowi *flp, struct fib_result *res)
57 {
58 - if (FIB_RES_GW(*res) && FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK)
59 + if ((FIB_RES_GW(*res) && FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK) ||
60 + FIB_RES_NH(*res).nh_scope == RT_SCOPE_HOST)
61 ip_fib_main_table->tb_select_default(ip_fib_main_table, flp, res);
62 }
63
64 @@ -207,6 +208,7 @@
65 extern int fib_lookup(const struct flowi *flp, struct fib_result *res);
66 extern struct fib_table *__fib_new_table(int id);
67 extern void fib_rule_put(struct fib_rule *r);
68 +extern int fib_result_table(struct fib_result *res);
69
70 static inline struct fib_table *fib_get_table(int id)
71 {
72 @@ -300,4 +302,6 @@
73 extern void fib_proc_exit(void);
74 #endif
75
76 +extern rwlock_t fib_nhflags_lock;
77 +
78 #endif /* _NET_FIB_H */
79 diff -ur v2.6.14/linux/include/net/route.h linux/include/net/route.h
80 --- v2.6.14/linux/include/net/route.h 2005-10-29 14:15:09.000000000 +0300
81 +++ linux/include/net/route.h 2005-10-29 18:11:32.885759304 +0300
82 @@ -117,6 +117,7 @@
83 extern int ip_route_output_key(struct rtable **, struct flowi *flp);
84 extern int ip_route_output_flow(struct rtable **rp, struct flowi *flp, struct sock *sk, int flags);
85 extern int ip_route_input(struct sk_buff*, u32 dst, u32 src, u8 tos, struct net_device *devin);
86 +extern int ip_route_input_lookup(struct sk_buff*, u32 dst, u32 src, u8 tos, struct net_device *devin, u32 lsrc);
87 extern unsigned short ip_rt_frag_needed(struct iphdr *iph, unsigned short new_mtu);
88 extern void ip_rt_send_redirect(struct sk_buff *skb);
89
90 diff -ur v2.6.14/linux/net/ipv4/fib_frontend.c linux/net/ipv4/fib_frontend.c
91 --- v2.6.14/linux/net/ipv4/fib_frontend.c 2005-10-29 14:15:09.000000000 +0300
92 +++ linux/net/ipv4/fib_frontend.c 2005-10-29 18:11:21.300520528 +0300
93 @@ -54,6 +54,8 @@
94 struct fib_table *ip_fib_local_table;
95 struct fib_table *ip_fib_main_table;
96
97 +#define FIB_RES_TABLE(r) (RT_TABLE_MAIN)
98 +
99 #else
100
101 #define RT_TABLE_MIN 1
102 @@ -71,6 +73,7 @@
103 return tb;
104 }
105
106 +#define FIB_RES_TABLE(r) (fib_result_table(r))
107
108 #endif /* CONFIG_IP_MULTIPLE_TABLES */
109
110 @@ -168,6 +171,9 @@
111 .tos = tos } },
112 .iif = oif };
113 struct fib_result res;
114 + int table;
115 + unsigned char prefixlen;
116 + unsigned char scope;
117 int no_addr, rpf;
118 int ret;
119
120 @@ -189,31 +195,35 @@
121 goto e_inval_res;
122 *spec_dst = FIB_RES_PREFSRC(res);
123 fib_combine_itag(itag, &res);
124 -#ifdef CONFIG_IP_ROUTE_MULTIPATH
125 - if (FIB_RES_DEV(res) == dev || res.fi->fib_nhs > 1)
126 -#else
127 if (FIB_RES_DEV(res) == dev)
128 -#endif
129 {
130 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
131 fib_res_put(&res);
132 return ret;
133 }
134 + table = FIB_RES_TABLE(&res);
135 + prefixlen = res.prefixlen;
136 + scope = res.scope;
137 fib_res_put(&res);
138 if (no_addr)
139 goto last_resort;
140 - if (rpf)
141 - goto e_inval;
142 fl.oif = dev->ifindex;
143
144 ret = 0;
145 if (fib_lookup(&fl, &res) == 0) {
146 - if (res.type == RTN_UNICAST) {
147 + if (res.type == RTN_UNICAST &&
148 + ((table == FIB_RES_TABLE(&res) &&
149 + res.prefixlen >= prefixlen && res.scope >= scope) ||
150 + !rpf)) {
151 *spec_dst = FIB_RES_PREFSRC(res);
152 ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST;
153 + fib_res_put(&res);
154 + return ret;
155 }
156 fib_res_put(&res);
157 }
158 + if (rpf)
159 + goto e_inval;
160 return ret;
161
162 last_resort:
163 @@ -584,9 +594,7 @@
164 switch (event) {
165 case NETDEV_UP:
166 fib_add_ifaddr(ifa);
167 -#ifdef CONFIG_IP_ROUTE_MULTIPATH
168 fib_sync_up(ifa->ifa_dev->dev);
169 -#endif
170 rt_cache_flush(-1);
171 break;
172 case NETDEV_DOWN:
173 @@ -622,9 +630,7 @@
174 for_ifa(in_dev) {
175 fib_add_ifaddr(ifa);
176 } endfor_ifa(in_dev);
177 -#ifdef CONFIG_IP_ROUTE_MULTIPATH
178 fib_sync_up(dev);
179 -#endif
180 rt_cache_flush(-1);
181 break;
182 case NETDEV_DOWN:
183 diff -ur v2.6.14/linux/net/ipv4/fib_hash.c linux/net/ipv4/fib_hash.c
184 --- v2.6.14/linux/net/ipv4/fib_hash.c 2005-10-29 14:15:09.000000000 +0300
185 +++ linux/net/ipv4/fib_hash.c 2005-10-29 18:11:21.301520376 +0300
186 @@ -276,30 +276,38 @@
187 return err;
188 }
189
190 -static int fn_hash_last_dflt=-1;
191 -
192 static void
193 fn_hash_select_default(struct fib_table *tb, const struct flowi *flp, struct fib_result *res)
194 {
195 - int order, last_idx;
196 + int order, last_idx, last_dflt, last_nhsel;
197 + struct fib_alias *first_fa = NULL;
198 + struct hlist_head *head;
199 struct hlist_node *node;
200 struct fib_node *f;
201 struct fib_info *fi = NULL;
202 struct fib_info *last_resort;
203 struct fn_hash *t = (struct fn_hash*)tb->tb_data;
204 - struct fn_zone *fz = t->fn_zones[0];
205 + struct fn_zone *fz = t->fn_zones[res->prefixlen];
206 + u32 k;
207
208 if (fz == NULL)
209 return;
210
211 + k = fz_key(flp->fl4_dst, fz);
212 + last_dflt = -2;
213 + last_nhsel = 0;
214 last_idx = -1;
215 last_resort = NULL;
216 order = -1;
217
218 read_lock(&fib_hash_lock);
219 - hlist_for_each_entry(f, node, &fz->fz_hash[0], fn_hash) {
220 + head = &fz->fz_hash[fn_hash(k, fz)];
221 + hlist_for_each_entry(f, node, head, fn_hash) {
222 struct fib_alias *fa;
223
224 + if (f->fn_key != k)
225 + continue;
226 +
227 list_for_each_entry(fa, &f->fn_alias, fa_list) {
228 struct fib_info *next_fi = fa->fa_info;
229
230 @@ -307,41 +315,52 @@
231 fa->fa_type != RTN_UNICAST)
232 continue;
233
234 + if (fa->fa_tos &&
235 + fa->fa_tos != flp->fl4_tos)
236 + continue;
237 if (next_fi->fib_priority > res->fi->fib_priority)
238 break;
239 - if (!next_fi->fib_nh[0].nh_gw ||
240 - next_fi->fib_nh[0].nh_scope != RT_SCOPE_LINK)
241 - continue;
242 fa->fa_state |= FA_S_ACCESSED;
243
244 - if (fi == NULL) {
245 - if (next_fi != res->fi)
246 - break;
247 - } else if (!fib_detect_death(fi, order, &last_resort,
248 - &last_idx, &fn_hash_last_dflt)) {
249 + if (!first_fa) {
250 + last_dflt = fa->fa_last_dflt;
251 + first_fa = fa;
252 + }
253 + if (fi && !fib_detect_death(fi, order, &last_resort,
254 + &last_idx, &last_dflt, &last_nhsel, flp)) {
255 if (res->fi)
256 fib_info_put(res->fi);
257 res->fi = fi;
258 atomic_inc(&fi->fib_clntref);
259 - fn_hash_last_dflt = order;
260 + first_fa->fa_last_dflt = order;
261 goto out;
262 }
263 fi = next_fi;
264 order++;
265 }
266 + break;
267 }
268
269 if (order <= 0 || fi == NULL) {
270 - fn_hash_last_dflt = -1;
271 + if (fi && fi->fib_nhs > 1 &&
272 + fib_detect_death(fi, order, &last_resort, &last_idx,
273 + &last_dflt, &last_nhsel, flp) &&
274 + last_resort == fi) {
275 + read_lock_bh(&fib_nhflags_lock);
276 + fi->fib_nh[last_nhsel].nh_flags &= ~RTNH_F_SUSPECT;
277 + read_unlock_bh(&fib_nhflags_lock);
278 + }
279 + if (first_fa) first_fa->fa_last_dflt = -1;
280 goto out;
281 }
282
283 - if (!fib_detect_death(fi, order, &last_resort, &last_idx, &fn_hash_last_dflt)) {
284 + if (!fib_detect_death(fi, order, &last_resort, &last_idx,
285 + &last_dflt, &last_nhsel, flp)) {
286 if (res->fi)
287 fib_info_put(res->fi);
288 res->fi = fi;
289 atomic_inc(&fi->fib_clntref);
290 - fn_hash_last_dflt = order;
291 + first_fa->fa_last_dflt = order;
292 goto out;
293 }
294
295 @@ -351,8 +370,11 @@
296 res->fi = last_resort;
297 if (last_resort)
298 atomic_inc(&last_resort->fib_clntref);
299 + read_lock_bh(&fib_nhflags_lock);
300 + last_resort->fib_nh[last_nhsel].nh_flags &= ~RTNH_F_SUSPECT;
301 + read_unlock_bh(&fib_nhflags_lock);
302 + first_fa->fa_last_dflt = last_idx;
303 }
304 - fn_hash_last_dflt = last_idx;
305 out:
306 read_unlock(&fib_hash_lock);
307 }
308 @@ -451,6 +473,7 @@
309 write_lock_bh(&fib_hash_lock);
310 fi_drop = fa->fa_info;
311 fa->fa_info = fi;
312 + fa->fa_last_dflt = -1;
313 fa->fa_type = type;
314 fa->fa_scope = r->rtm_scope;
315 state = fa->fa_state;
316 @@ -510,6 +533,7 @@
317 new_fa->fa_type = type;
318 new_fa->fa_scope = r->rtm_scope;
319 new_fa->fa_state = 0;
320 + new_fa->fa_last_dflt = -1;
321
322 /*
323 * Insert new entry to the list.
324 diff -ur v2.6.14/linux/net/ipv4/fib_lookup.h linux/net/ipv4/fib_lookup.h
325 --- v2.6.14/linux/net/ipv4/fib_lookup.h 2005-10-29 14:15:09.000000000 +0300
326 +++ linux/net/ipv4/fib_lookup.h 2005-10-29 18:11:21.302520224 +0300
327 @@ -9,6 +9,7 @@
328 struct list_head fa_list;
329 struct rcu_head rcu;
330 struct fib_info *fa_info;
331 + int fa_last_dflt;
332 u8 fa_tos;
333 u8 fa_type;
334 u8 fa_scope;
335 @@ -40,6 +41,7 @@
336 u8 tos, u32 prio);
337 extern int fib_detect_death(struct fib_info *fi, int order,
338 struct fib_info **last_resort,
339 - int *last_idx, int *dflt);
340 + int *last_idx, int *dflt, int *last_nhsel,
341 + const struct flowi *flp);
342
343 #endif /* _FIB_LOOKUP_H */
344 diff -ur v2.6.14/linux/net/ipv4/fib_rules.c linux/net/ipv4/fib_rules.c
345 --- v2.6.14/linux/net/ipv4/fib_rules.c 2005-08-29 07:51:29.000000000 +0300
346 +++ linux/net/ipv4/fib_rules.c 2005-10-29 18:11:21.302520224 +0300
347 @@ -280,6 +280,11 @@
348 }
349 }
350
351 +int fib_result_table(struct fib_result *res)
352 +{
353 + return res->r->r_table;
354 +}
355 +
356 int fib_lookup(const struct flowi *flp, struct fib_result *res)
357 {
358 int err;
359 @@ -342,7 +347,8 @@
360 void fib_select_default(const struct flowi *flp, struct fib_result *res)
361 {
362 if (res->r && res->r->r_action == RTN_UNICAST &&
363 - FIB_RES_GW(*res) && FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK) {
364 + ((FIB_RES_GW(*res) && FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK) ||
365 + FIB_RES_NH(*res).nh_scope == RT_SCOPE_HOST)) {
366 struct fib_table *tb;
367 if ((tb = fib_get_table(res->r->r_table)) != NULL)
368 tb->tb_select_default(tb, flp, res);
369 diff -ur v2.6.14/linux/net/ipv4/fib_semantics.c linux/net/ipv4/fib_semantics.c
370 --- v2.6.14/linux/net/ipv4/fib_semantics.c 2005-10-29 14:15:09.000000000 +0300
371 +++ linux/net/ipv4/fib_semantics.c 2005-10-29 18:11:32.886759152 +0300
372 @@ -53,6 +53,7 @@
373 static struct hlist_head *fib_info_laddrhash;
374 static unsigned int fib_hash_size;
375 static unsigned int fib_info_cnt;
376 +rwlock_t fib_nhflags_lock = RW_LOCK_UNLOCKED;
377
378 #define DEVINDEX_HASHBITS 8
379 #define DEVINDEX_HASHSIZE (1U << DEVINDEX_HASHBITS)
380 @@ -188,7 +189,7 @@
381 #ifdef CONFIG_NET_CLS_ROUTE
382 nh->nh_tclassid != onh->nh_tclassid ||
383 #endif
384 - ((nh->nh_flags^onh->nh_flags)&~RTNH_F_DEAD))
385 + ((nh->nh_flags^onh->nh_flags)&~RTNH_F_BADSTATE))
386 return -1;
387 onh++;
388 } endfor_nexthops(fi);
389 @@ -225,7 +226,7 @@
390 nfi->fib_priority == fi->fib_priority &&
391 memcmp(nfi->fib_metrics, fi->fib_metrics,
392 sizeof(fi->fib_metrics)) == 0 &&
393 - ((nfi->fib_flags^fi->fib_flags)&~RTNH_F_DEAD) == 0 &&
394 + ((nfi->fib_flags^fi->fib_flags)&~RTNH_F_BADSTATE) == 0 &&
395 (nfi->fib_nhs == 0 || nh_comp(fi, nfi) == 0))
396 return fi;
397 }
398 @@ -317,26 +318,70 @@
399 }
400
401 int fib_detect_death(struct fib_info *fi, int order,
402 - struct fib_info **last_resort, int *last_idx, int *dflt)
403 + struct fib_info **last_resort, int *last_idx, int *dflt,
404 + int *last_nhsel, const struct flowi *flp)
405 {
406 struct neighbour *n;
407 - int state = NUD_NONE;
408 + int nhsel;
409 + int state;
410 + struct fib_nh * nh;
411 + u32 dst;
412 + int flag, dead = 1;
413 +
414 + /* change_nexthops(fi) { */
415 + for (nhsel = 0, nh = fi->fib_nh; nhsel < fi->fib_nhs; nh++, nhsel++) {
416 + if (flp->oif && flp->oif != nh->nh_oif)
417 + continue;
418 + if (flp->fl4_gw && flp->fl4_gw != nh->nh_gw && nh->nh_gw &&
419 + nh->nh_scope == RT_SCOPE_LINK)
420 + continue;
421 + if (nh->nh_flags & RTNH_F_DEAD)
422 + continue;
423
424 - n = neigh_lookup(&arp_tbl, &fi->fib_nh[0].nh_gw, fi->fib_dev);
425 - if (n) {
426 - state = n->nud_state;
427 - neigh_release(n);
428 - }
429 - if (state==NUD_REACHABLE)
430 - return 0;
431 - if ((state&NUD_VALID) && order != *dflt)
432 - return 0;
433 - if ((state&NUD_VALID) ||
434 - (*last_idx<0 && order > *dflt)) {
435 - *last_resort = fi;
436 - *last_idx = order;
437 + flag = 0;
438 + if (nh->nh_dev->flags & IFF_NOARP) {
439 + dead = 0;
440 + goto setfl;
441 + }
442 +
443 + dst = nh->nh_gw;
444 + if (!nh->nh_gw || nh->nh_scope != RT_SCOPE_LINK)
445 + dst = flp->fl4_dst;
446 +
447 + state = NUD_NONE;
448 + n = neigh_lookup(&arp_tbl, &dst, nh->nh_dev);
449 + if (n) {
450 + state = n->nud_state;
451 + neigh_release(n);
452 + }
453 + if (state==NUD_REACHABLE ||
454 + ((state&NUD_VALID) && order != *dflt)) {
455 + dead = 0;
456 + goto setfl;
457 + }
458 + if (!(state&NUD_VALID))
459 + flag = 1;
460 + if (!dead)
461 + goto setfl;
462 + if ((state&NUD_VALID) ||
463 + (*last_idx<0 && order >= *dflt)) {
464 + *last_resort = fi;
465 + *last_idx = order;
466 + *last_nhsel = nhsel;
467 + }
468 +
469 + setfl:
470 +
471 + read_lock_bh(&fib_nhflags_lock);
472 + if (flag)
473 + nh->nh_flags |= RTNH_F_SUSPECT;
474 + else
475 + nh->nh_flags &= ~RTNH_F_SUSPECT;
476 + read_unlock_bh(&fib_nhflags_lock);
477 }
478 - return 1;
479 + /* } endfor_nexthops(fi) */
480 +
481 + return dead;
482 }
483
484 #ifdef CONFIG_IP_ROUTE_MULTIPATH
485 @@ -507,8 +552,11 @@
486 return -EINVAL;
487 if ((dev = __dev_get_by_index(nh->nh_oif)) == NULL)
488 return -ENODEV;
489 - if (!(dev->flags&IFF_UP))
490 - return -ENETDOWN;
491 + if (!(dev->flags&IFF_UP)) {
492 + if (fi->fib_protocol != RTPROT_STATIC)
493 + return -ENETDOWN;
494 + nh->nh_flags |= RTNH_F_DEAD;
495 + }
496 nh->nh_dev = dev;
497 dev_hold(dev);
498 nh->nh_scope = RT_SCOPE_LINK;
499 @@ -523,24 +571,48 @@
500 /* It is not necessary, but requires a bit of thinking */
501 if (fl.fl4_scope < RT_SCOPE_LINK)
502 fl.fl4_scope = RT_SCOPE_LINK;
503 - if ((err = fib_lookup(&fl, &res)) != 0)
504 - return err;
505 + err = fib_lookup(&fl, &res);
506 }
507 - err = -EINVAL;
508 - if (res.type != RTN_UNICAST && res.type != RTN_LOCAL)
509 - goto out;
510 - nh->nh_scope = res.scope;
511 - nh->nh_oif = FIB_RES_OIF(res);
512 - if ((nh->nh_dev = FIB_RES_DEV(res)) == NULL)
513 - goto out;
514 - dev_hold(nh->nh_dev);
515 - err = -ENETDOWN;
516 - if (!(nh->nh_dev->flags & IFF_UP))
517 - goto out;
518 - err = 0;
519 + if (err) {
520 + struct in_device *in_dev;
521 +
522 + if (err != -ENETUNREACH ||
523 + fi->fib_protocol != RTPROT_STATIC)
524 + return err;
525 +
526 + in_dev = inetdev_by_index(nh->nh_oif);
527 + if (in_dev == NULL ||
528 + in_dev->dev->flags & IFF_UP) {
529 + if (in_dev)
530 + in_dev_put(in_dev);
531 + return err;
532 + }
533 + nh->nh_flags |= RTNH_F_DEAD;
534 + nh->nh_scope = RT_SCOPE_LINK;
535 + nh->nh_dev = in_dev->dev;
536 + dev_hold(nh->nh_dev);
537 + in_dev_put(in_dev);
538 + } else {
539 + err = -EINVAL;
540 + if (res.type != RTN_UNICAST && res.type != RTN_LOCAL)
541 + goto out;
542 + nh->nh_scope = res.scope;
543 + nh->nh_oif = FIB_RES_OIF(res);
544 + if ((nh->nh_dev = FIB_RES_DEV(res)) == NULL)
545 + goto out;
546 + dev_hold(nh->nh_dev);
547 + if (!(nh->nh_dev->flags & IFF_UP)) {
548 + if (fi->fib_protocol != RTPROT_STATIC) {
549 + err = -ENETDOWN;
550 + goto out;
551 + }
552 + nh->nh_flags |= RTNH_F_DEAD;
553 + }
554 + err = 0;
555 out:
556 - fib_res_put(&res);
557 - return err;
558 + fib_res_put(&res);
559 + return err;
560 + }
561 } else {
562 struct in_device *in_dev;
563
564 @@ -551,8 +623,11 @@
565 if (in_dev == NULL)
566 return -ENODEV;
567 if (!(in_dev->dev->flags&IFF_UP)) {
568 - in_dev_put(in_dev);
569 - return -ENETDOWN;
570 + if (fi->fib_protocol != RTPROT_STATIC) {
571 + in_dev_put(in_dev);
572 + return -ENETDOWN;
573 + }
574 + nh->nh_flags |= RTNH_F_DEAD;
575 }
576 nh->nh_dev = in_dev->dev;
577 dev_hold(nh->nh_dev);
578 @@ -890,8 +965,12 @@
579 for_nexthops(fi) {
580 if (nh->nh_flags&RTNH_F_DEAD)
581 continue;
582 - if (!flp->oif || flp->oif == nh->nh_oif)
583 - break;
584 + if (flp->oif && flp->oif != nh->nh_oif)
585 + continue;
586 + if (flp->fl4_gw && flp->fl4_gw != nh->nh_gw &&
587 + nh->nh_gw && nh->nh_scope == RT_SCOPE_LINK)
588 + continue;
589 + break;
590 }
591 #ifdef CONFIG_IP_ROUTE_MULTIPATH
592 if (nhsel < fi->fib_nhs) {
593 @@ -1197,18 +1276,29 @@
594 prev_fi = fi;
595 dead = 0;
596 change_nexthops(fi) {
597 - if (nh->nh_flags&RTNH_F_DEAD)
598 - dead++;
599 - else if (nh->nh_dev == dev &&
600 - nh->nh_scope != scope) {
601 - nh->nh_flags |= RTNH_F_DEAD;
602 + if (nh->nh_flags&RTNH_F_DEAD) {
603 + if (fi->fib_protocol!=RTPROT_STATIC ||
604 + nh->nh_dev == NULL ||
605 + __in_dev_get_rtnl(nh->nh_dev) == NULL ||
606 + nh->nh_dev->flags&IFF_UP)
607 + dead++;
608 + } else if (nh->nh_dev == dev &&
609 + nh->nh_scope != scope) {
610 + write_lock_bh(&fib_nhflags_lock);
611 #ifdef CONFIG_IP_ROUTE_MULTIPATH
612 - spin_lock_bh(&fib_multipath_lock);
613 + spin_lock(&fib_multipath_lock);
614 + nh->nh_flags |= RTNH_F_DEAD;
615 fi->fib_power -= nh->nh_power;
616 nh->nh_power = 0;
617 - spin_unlock_bh(&fib_multipath_lock);
618 + spin_unlock(&fib_multipath_lock);
619 +#else
620 + nh->nh_flags |= RTNH_F_DEAD;
621 #endif
622 - dead++;
623 + write_unlock_bh(&fib_nhflags_lock);
624 + if (fi->fib_protocol!=RTPROT_STATIC ||
625 + force ||
626 + __in_dev_get_rtnl(dev) == NULL)
627 + dead++;
628 }
629 #ifdef CONFIG_IP_ROUTE_MULTIPATH
630 if (force > 1 && nh->nh_dev == dev) {
631 @@ -1227,11 +1317,8 @@
632 return ret;
633 }
634
635 -#ifdef CONFIG_IP_ROUTE_MULTIPATH
636 -
637 /*
638 - Dead device goes up. We wake up dead nexthops.
639 - It takes sense only on multipath routes.
640 + Dead device goes up or new address is added. We wake up dead nexthops.
641 */
642
643 int fib_sync_up(struct net_device *dev)
644 @@ -1241,8 +1328,10 @@
645 struct hlist_head *head;
646 struct hlist_node *node;
647 struct fib_nh *nh;
648 - int ret;
649 + struct fib_result res;
650 + int ret, rep;
651
652 +repeat:
653 if (!(dev->flags&IFF_UP))
654 return 0;
655
656 @@ -1250,6 +1339,7 @@
657 hash = fib_devindex_hashfn(dev->ifindex);
658 head = &fib_info_devhash[hash];
659 ret = 0;
660 + rep = 0;
661
662 hlist_for_each_entry(nh, node, head, nh_hash) {
663 struct fib_info *fi = nh->nh_parent;
664 @@ -1262,19 +1352,37 @@
665 prev_fi = fi;
666 alive = 0;
667 change_nexthops(fi) {
668 - if (!(nh->nh_flags&RTNH_F_DEAD)) {
669 - alive++;
670 + if (!(nh->nh_flags&RTNH_F_DEAD))
671 continue;
672 - }
673 if (nh->nh_dev == NULL || !(nh->nh_dev->flags&IFF_UP))
674 continue;
675 if (nh->nh_dev != dev || !__in_dev_get_rtnl(dev))
676 continue;
677 + if (nh->nh_gw && fi->fib_protocol == RTPROT_STATIC) {
678 + struct flowi fl = {
679 + .nl_u = { .ip4_u =
680 + { .daddr = nh->nh_gw,
681 + .scope = nh->nh_scope } },
682 + .oif = nh->nh_oif,
683 + };
684 + if (fib_lookup(&fl, &res) != 0)
685 + continue;
686 + if (res.type != RTN_UNICAST &&
687 + res.type != RTN_LOCAL) {
688 + fib_res_put(&res);
689 + continue;
690 + }
691 + nh->nh_scope = res.scope;
692 + fib_res_put(&res);
693 + rep = 1;
694 + }
695 alive++;
696 +#ifdef CONFIG_IP_ROUTE_MULTIPATH
697 spin_lock_bh(&fib_multipath_lock);
698 nh->nh_power = 0;
699 nh->nh_flags &= ~RTNH_F_DEAD;
700 spin_unlock_bh(&fib_multipath_lock);
701 +#endif
702 } endfor_nexthops(fi)
703
704 if (alive > 0) {
705 @@ -1282,10 +1390,14 @@
706 ret++;
707 }
708 }
709 + if (rep)
710 + goto repeat;
711
712 return ret;
713 }
714
715 +#ifdef CONFIG_IP_ROUTE_MULTIPATH
716 +
717 /*
718 The algorithm is suboptimal, but it provides really
719 fair weighted route distribution.
720 @@ -1294,24 +1406,45 @@
721 void fib_select_multipath(const struct flowi *flp, struct fib_result *res)
722 {
723 struct fib_info *fi = res->fi;
724 - int w;
725 + int w, alive;
726
727 spin_lock_bh(&fib_multipath_lock);
728 + if (flp->oif) {
729 + int sel = -1;
730 + w = -1;
731 + change_nexthops(fi) {
732 + if (flp->oif != nh->nh_oif)
733 + continue;
734 + if (flp->fl4_gw && flp->fl4_gw != nh->nh_gw &&
735 + nh->nh_gw && nh->nh_scope == RT_SCOPE_LINK)
736 + continue;
737 + if (!(nh->nh_flags&RTNH_F_BADSTATE)) {
738 + if (nh->nh_power > w) {
739 + w = nh->nh_power;
740 + sel = nhsel;
741 + }
742 + }
743 + } endfor_nexthops(fi);
744 + if (sel >= 0) {
745 + spin_unlock_bh(&fib_multipath_lock);
746 + res->nh_sel = sel;
747 + return;
748 + }
749 + goto last_resort;
750 + }
751 +
752 +repeat:
753 if (fi->fib_power <= 0) {
754 int power = 0;
755 change_nexthops(fi) {
756 - if (!(nh->nh_flags&RTNH_F_DEAD)) {
757 + if (!(nh->nh_flags&RTNH_F_BADSTATE)) {
758 power += nh->nh_weight;
759 nh->nh_power = nh->nh_weight;
760 }
761 } endfor_nexthops(fi);
762 fi->fib_power = power;
763 - if (power <= 0) {
764 - spin_unlock_bh(&fib_multipath_lock);
765 - /* Race condition: route has just become dead. */
766 - res->nh_sel = 0;
767 - return;
768 - }
769 + if (power <= 0)
770 + goto last_resort;
771 }
772
773
774 @@ -1321,20 +1454,40 @@
775
776 w = jiffies % fi->fib_power;
777
778 + alive = 0;
779 change_nexthops(fi) {
780 - if (!(nh->nh_flags&RTNH_F_DEAD) && nh->nh_power) {
781 + if (!(nh->nh_flags&RTNH_F_BADSTATE) && nh->nh_power) {
782 if ((w -= nh->nh_power) <= 0) {
783 nh->nh_power--;
784 fi->fib_power--;
785 - res->nh_sel = nhsel;
786 spin_unlock_bh(&fib_multipath_lock);
787 + res->nh_sel = nhsel;
788 return;
789 }
790 + alive = 1;
791 + }
792 + } endfor_nexthops(fi);
793 + if (alive) {
794 + fi->fib_power = 0;
795 + goto repeat;
796 + }
797 +
798 +last_resort:
799 +
800 + for_nexthops(fi) {
801 + if (!(nh->nh_flags&RTNH_F_DEAD)) {
802 + if (flp->oif && flp->oif != nh->nh_oif)
803 + continue;
804 + if (flp->fl4_gw && flp->fl4_gw != nh->nh_gw &&
805 + nh->nh_gw && nh->nh_scope == RT_SCOPE_LINK)
806 + continue;
807 + spin_unlock_bh(&fib_multipath_lock);
808 + res->nh_sel = nhsel;
809 + return;
810 }
811 } endfor_nexthops(fi);
812
813 /* Race condition: route has just become dead. */
814 - res->nh_sel = 0;
815 spin_unlock_bh(&fib_multipath_lock);
816 }
817 #endif
818 diff -ur v2.6.14/linux/net/ipv4/netfilter/ip_nat_core.c linux/net/ipv4/netfilter/ip_nat_core.c
819 --- v2.6.14/linux/net/ipv4/netfilter/ip_nat_core.c 2005-10-29 14:15:09.000000000 +0300
820 +++ linux/net/ipv4/netfilter/ip_nat_core.c 2005-10-29 18:11:32.887759000 +0300
821 @@ -591,6 +591,53 @@
822 EXPORT_SYMBOL_GPL(ip_nat_port_range_to_nfattr);
823 #endif
824
825 +unsigned int
826 +ip_nat_route_input(unsigned int hooknum,
827 + struct sk_buff **pskb,
828 + const struct net_device *in,
829 + const struct net_device *out,
830 + int (*okfn)(struct sk_buff *))
831 +{
832 + struct sk_buff *skb = *pskb;
833 + struct iphdr *iph;
834 + struct ip_conntrack *conn;
835 + enum ip_conntrack_info ctinfo;
836 + enum ip_conntrack_dir dir;
837 + unsigned long statusbit;
838 + u32 saddr;
839 +
840 + if (!(conn = ip_conntrack_get(skb, &ctinfo)))
841 + return NF_ACCEPT;
842 +
843 + if (!(conn->status & IPS_NAT_DONE_MASK))
844 + return NF_ACCEPT;
845 + dir = CTINFO2DIR(ctinfo);
846 + statusbit = IPS_SRC_NAT;
847 + if (dir == IP_CT_DIR_REPLY)
848 + statusbit ^= IPS_NAT_MASK;
849 + if (!(conn->status & statusbit))
850 + return NF_ACCEPT;
851 +
852 + if (skb->dst)
853 + return NF_ACCEPT;
854 +
855 + if (skb->len < sizeof(struct iphdr))
856 + return NF_ACCEPT;
857 +
858 + /* use daddr in other direction as masquerade address (lsrc) */
859 + iph = skb->nh.iph;
860 + saddr = conn->tuplehash[!dir].tuple.dst.ip;
861 + if (saddr == iph->saddr)
862 + return NF_ACCEPT;
863 +
864 + if (ip_route_input_lookup(skb, iph->daddr, iph->saddr, iph->tos,
865 + skb->dev, saddr))
866 + return NF_DROP;
867 +
868 + return NF_ACCEPT;
869 +}
870 +EXPORT_SYMBOL_GPL(ip_nat_route_input);
871 +
872 static int __init ip_nat_init(void)
873 {
874 size_t i;
875 diff -ur v2.6.14/linux/net/ipv4/netfilter/ip_nat_standalone.c linux/net/ipv4/netfilter/ip_nat_standalone.c
876 --- v2.6.14/linux/net/ipv4/netfilter/ip_nat_standalone.c 2005-10-29 14:15:09.000000000 +0300
877 +++ linux/net/ipv4/netfilter/ip_nat_standalone.c 2005-10-29 18:11:32.887759000 +0300
878 @@ -266,6 +266,14 @@
879 .priority = NF_IP_PRI_NAT_DST,
880 };
881
882 +/* Before routing, route before mangling */
883 +static struct nf_hook_ops ip_nat_inr_ops = {
884 + .hook = ip_nat_route_input,
885 + .pf = PF_INET,
886 + .hooknum = NF_IP_PRE_ROUTING,
887 + .priority = NF_IP_PRI_LAST-1,
888 +};
889 +
890 /* After packet filtering, change source */
891 static struct nf_hook_ops ip_nat_out_ops = {
892 .hook = ip_nat_out,
893 @@ -330,10 +338,15 @@
894 printk("ip_nat_init: can't register in hook.\n");
895 goto cleanup_rule_init;
896 }
897 + ret = nf_register_hook(&ip_nat_inr_ops);
898 + if (ret < 0) {
899 + printk("ip_nat_init: can't register inr hook.\n");
900 + goto cleanup_inops;
901 + }
902 ret = nf_register_hook(&ip_nat_out_ops);
903 if (ret < 0) {
904 printk("ip_nat_init: can't register out hook.\n");
905 - goto cleanup_inops;
906 + goto cleanup_inrops;
907 }
908 ret = nf_register_hook(&ip_nat_adjust_in_ops);
909 if (ret < 0) {
910 @@ -367,6 +380,8 @@
911 nf_unregister_hook(&ip_nat_adjust_in_ops);
912 cleanup_outops:
913 nf_unregister_hook(&ip_nat_out_ops);
914 + cleanup_inrops:
915 + nf_unregister_hook(&ip_nat_inr_ops);
916 cleanup_inops:
917 nf_unregister_hook(&ip_nat_in_ops);
918 cleanup_rule_init:
919 diff -ur v2.6.14/linux/net/ipv4/netfilter/ipt_MASQUERADE.c linux/net/ipv4/netfilter/ipt_MASQUERADE.c
920 --- v2.6.14/linux/net/ipv4/netfilter/ipt_MASQUERADE.c 2005-10-29 14:15:09.000000000 +0300
921 +++ linux/net/ipv4/netfilter/ipt_MASQUERADE.c 2005-10-29 18:11:32.887759000 +0300
922 @@ -97,13 +97,31 @@
923 return NF_ACCEPT;
924
925 mr = targinfo;
926 - rt = (struct rtable *)(*pskb)->dst;
927 - newsrc = inet_select_addr(out, rt->rt_gateway, RT_SCOPE_UNIVERSE);
928 - if (!newsrc) {
929 - printk("MASQUERADE: %s ate my IP address\n", out->name);
930 - return NF_DROP;
931 +
932 + {
933 + struct flowi fl = { .nl_u = { .ip4_u =
934 + { .daddr = (*pskb)->nh.iph->daddr,
935 + .tos = (RT_TOS((*pskb)->nh.iph->tos) |
936 + RTO_CONN),
937 + .gw = ((struct rtable *) (*pskb)->dst)->rt_gateway,
938 +#ifdef CONFIG_IP_ROUTE_FWMARK
939 + .fwmark = (*pskb)->nfmark
940 +#endif
941 + } },
942 + .oif = out->ifindex };
943 + if (ip_route_output_key(&rt, &fl) != 0) {
944 + /* Funky routing can do this. */
945 + if (net_ratelimit())
946 + printk("MASQUERADE:"
947 + " No route: Rusty's brain broke!\n");
948 + return NF_DROP;
949 + }
950 }
951
952 + newsrc = rt->rt_src;
953 + DEBUGP("newsrc = %u.%u.%u.%u\n", NIPQUAD(newsrc));
954 + ip_rt_put(rt);
955 +
956 write_lock_bh(&masq_lock);
957 ct->nat.masq_index = out->ifindex;
958 write_unlock_bh(&masq_lock);
959 diff -ur v2.6.14/linux/net/ipv4/route.c linux/net/ipv4/route.c
960 --- v2.6.14/linux/net/ipv4/route.c 2005-10-29 14:15:09.000000000 +0300
961 +++ linux/net/ipv4/route.c 2005-10-29 18:11:32.889758696 +0300
962 @@ -1197,6 +1197,7 @@
963
964 /* Gateway is different ... */
965 rt->rt_gateway = new_gw;
966 + if (rt->fl.fl4_gw) rt->fl.fl4_gw = new_gw;
967
968 /* Redirect received -> path was valid */
969 dst_confirm(&rth->u.dst);
970 @@ -1632,6 +1633,7 @@
971 rth->fl.fl4_fwmark= skb->nfmark;
972 #endif
973 rth->fl.fl4_src = saddr;
974 + rth->fl.fl4_lsrc = 0;
975 rth->rt_src = saddr;
976 #ifdef CONFIG_NET_CLS_ROUTE
977 rth->u.dst.tclassid = itag;
978 @@ -1642,6 +1644,7 @@
979 dev_hold(rth->u.dst.dev);
980 rth->idev = in_dev_get(rth->u.dst.dev);
981 rth->fl.oif = 0;
982 + rth->fl.fl4_gw = 0;
983 rth->rt_gateway = daddr;
984 rth->rt_spec_dst= spec_dst;
985 rth->rt_type = RTN_MULTICAST;
986 @@ -1706,7 +1709,7 @@
987 struct fib_result* res,
988 struct in_device *in_dev,
989 u32 daddr, u32 saddr, u32 tos,
990 - struct rtable **result)
991 + u32 lsrc, struct rtable **result)
992 {
993
994 struct rtable *rth;
995 @@ -1739,6 +1742,7 @@
996 flags |= RTCF_DIRECTSRC;
997
998 if (out_dev == in_dev && err && !(flags & (RTCF_NAT | RTCF_MASQ)) &&
999 + !lsrc &&
1000 (IN_DEV_SHARED_MEDIA(out_dev) ||
1001 inet_addr_onlink(out_dev, saddr, FIB_RES_GW(*res))))
1002 flags |= RTCF_DOREDIRECT;
1003 @@ -1778,6 +1782,7 @@
1004 #endif
1005 rth->fl.fl4_src = saddr;
1006 rth->rt_src = saddr;
1007 + rth->fl.fl4_lsrc = lsrc;
1008 rth->rt_gateway = daddr;
1009 rth->rt_iif =
1010 rth->fl.iif = in_dev->dev->ifindex;
1011 @@ -1785,6 +1790,7 @@
1012 dev_hold(rth->u.dst.dev);
1013 rth->idev = in_dev_get(rth->u.dst.dev);
1014 rth->fl.oif = 0;
1015 + rth->fl.fl4_gw = 0;
1016 rth->rt_spec_dst= spec_dst;
1017
1018 rth->u.dst.input = ip_forward;
1019 @@ -1806,19 +1812,20 @@
1020 struct fib_result* res,
1021 const struct flowi *fl,
1022 struct in_device *in_dev,
1023 - u32 daddr, u32 saddr, u32 tos)
1024 + u32 daddr, u32 saddr, u32 tos, u32 lsrc)
1025 {
1026 struct rtable* rth = NULL;
1027 int err;
1028 unsigned hash;
1029
1030 + fib_select_default(fl, res);
1031 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1032 - if (res->fi && res->fi->fib_nhs > 1 && fl->oif == 0)
1033 + if (res->fi && res->fi->fib_nhs > 1)
1034 fib_select_multipath(fl, res);
1035 #endif
1036
1037 /* create a routing cache entry */
1038 - err = __mkroute_input(skb, res, in_dev, daddr, saddr, tos, &rth);
1039 + err = __mkroute_input(skb, res, in_dev, daddr, saddr, tos, lsrc, &rth);
1040 if (err)
1041 return err;
1042
1043 @@ -1831,7 +1838,7 @@
1044 struct fib_result* res,
1045 const struct flowi *fl,
1046 struct in_device *in_dev,
1047 - u32 daddr, u32 saddr, u32 tos)
1048 + u32 daddr, u32 saddr, u32 tos, u32 lsrc)
1049 {
1050 #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
1051 struct rtable* rth = NULL, *rtres;
1052 @@ -1847,7 +1854,7 @@
1053 /* distinguish between multipath and singlepath */
1054 if (hopcount < 2)
1055 return ip_mkroute_input_def(skb, res, fl, in_dev, daddr,
1056 - saddr, tos);
1057 + saddr, tos, 0);
1058
1059 /* add all alternatives to the routing cache */
1060 for (hop = 0; hop < hopcount; hop++) {
1061 @@ -1859,7 +1866,7 @@
1062
1063 /* create a routing cache entry */
1064 err = __mkroute_input(skb, res, in_dev, daddr, saddr, tos,
1065 - &rth);
1066 + 0, &rth);
1067 if (err)
1068 return err;
1069
1070 @@ -1879,7 +1886,7 @@
1071 skb->dst = &rtres->u.dst;
1072 return err;
1073 #else /* CONFIG_IP_ROUTE_MULTIPATH_CACHED */
1074 - return ip_mkroute_input_def(skb, res, fl, in_dev, daddr, saddr, tos);
1075 + return ip_mkroute_input_def(skb, res, fl, in_dev, daddr, saddr, tos, lsrc);
1076 #endif /* CONFIG_IP_ROUTE_MULTIPATH_CACHED */
1077 }
1078
1079 @@ -1895,20 +1902,20 @@
1080 */
1081
1082 static int ip_route_input_slow(struct sk_buff *skb, u32 daddr, u32 saddr,
1083 - u8 tos, struct net_device *dev)
1084 + u8 tos, struct net_device *dev, u32 lsrc)
1085 {
1086 struct fib_result res;
1087 struct in_device *in_dev = in_dev_get(dev);
1088 struct flowi fl = { .nl_u = { .ip4_u =
1089 { .daddr = daddr,
1090 - .saddr = saddr,
1091 + .saddr = lsrc? : saddr,
1092 .tos = tos,
1093 .scope = RT_SCOPE_UNIVERSE,
1094 #ifdef CONFIG_IP_ROUTE_FWMARK
1095 .fwmark = skb->nfmark
1096 #endif
1097 } },
1098 - .iif = dev->ifindex };
1099 + .iif = lsrc? loopback_dev.ifindex : dev->ifindex };
1100 unsigned flags = 0;
1101 u32 itag = 0;
1102 struct rtable * rth;
1103 @@ -1941,6 +1948,12 @@
1104 if (BADCLASS(daddr) || ZERONET(daddr) || LOOPBACK(daddr))
1105 goto martian_destination;
1106
1107 + if (lsrc) {
1108 + if (MULTICAST(lsrc) || BADCLASS(lsrc) ||
1109 + ZERONET(lsrc) || LOOPBACK(lsrc))
1110 + goto e_inval;
1111 + }
1112 +
1113 /*
1114 * Now we are ready to route packet.
1115 */
1116 @@ -1950,6 +1963,10 @@
1117 goto no_route;
1118 }
1119 free_res = 1;
1120 + if (lsrc && res.type != RTN_UNICAST && res.type != RTN_NAT)
1121 + goto e_inval;
1122 + fl.iif = dev->ifindex;
1123 + fl.fl4_src = saddr;
1124
1125 RT_CACHE_STAT_INC(in_slow_tot);
1126
1127 @@ -1974,7 +1991,7 @@
1128 if (res.type != RTN_UNICAST)
1129 goto martian_destination;
1130
1131 - err = ip_mkroute_input(skb, &res, &fl, in_dev, daddr, saddr, tos);
1132 + err = ip_mkroute_input(skb, &res, &fl, in_dev, daddr, saddr, tos, lsrc);
1133 if (err == -ENOBUFS)
1134 goto e_nobufs;
1135 if (err == -EINVAL)
1136 @@ -1989,6 +2006,8 @@
1137 brd_input:
1138 if (skb->protocol != htons(ETH_P_IP))
1139 goto e_inval;
1140 + if (lsrc)
1141 + goto e_inval;
1142
1143 if (ZERONET(saddr))
1144 spec_dst = inet_select_addr(dev, 0, RT_SCOPE_LINK);
1145 @@ -2031,6 +2050,7 @@
1146 rth->u.dst.dev = &loopback_dev;
1147 dev_hold(rth->u.dst.dev);
1148 rth->idev = in_dev_get(rth->u.dst.dev);
1149 + rth->fl.fl4_gw = 0;
1150 rth->rt_gateway = daddr;
1151 rth->rt_spec_dst= spec_dst;
1152 rth->u.dst.input= ip_local_deliver;
1153 @@ -2080,8 +2100,9 @@
1154 goto e_inval;
1155 }
1156
1157 -int ip_route_input(struct sk_buff *skb, u32 daddr, u32 saddr,
1158 - u8 tos, struct net_device *dev)
1159 +static inline int
1160 +ip_route_input_cached(struct sk_buff *skb, u32 daddr, u32 saddr,
1161 + u8 tos, struct net_device *dev, u32 lsrc)
1162 {
1163 struct rtable * rth;
1164 unsigned hash;
1165 @@ -2096,6 +2117,7 @@
1166 if (rth->fl.fl4_dst == daddr &&
1167 rth->fl.fl4_src == saddr &&
1168 rth->fl.iif == iif &&
1169 + rth->fl.fl4_lsrc == lsrc &&
1170 rth->fl.oif == 0 &&
1171 #ifdef CONFIG_IP_ROUTE_FWMARK
1172 rth->fl.fl4_fwmark == skb->nfmark &&
1173 @@ -2144,7 +2166,19 @@
1174 rcu_read_unlock();
1175 return -EINVAL;
1176 }
1177 - return ip_route_input_slow(skb, daddr, saddr, tos, dev);
1178 + return ip_route_input_slow(skb, daddr, saddr, tos, dev, lsrc);
1179 +}
1180 +
1181 +int ip_route_input(struct sk_buff *skb, u32 daddr, u32 saddr,
1182 + u8 tos, struct net_device *dev)
1183 +{
1184 + return ip_route_input_cached(skb, daddr, saddr, tos, dev, 0);
1185 +}
1186 +
1187 +int ip_route_input_lookup(struct sk_buff *skb, u32 daddr, u32 saddr,
1188 + u8 tos, struct net_device *dev, u32 lsrc)
1189 +{
1190 + return ip_route_input_cached(skb, daddr, saddr, tos, dev, lsrc);
1191 }
1192
1193 static inline int __mkroute_output(struct rtable **result,
1194 @@ -2223,6 +2257,7 @@
1195 rth->fl.fl4_tos = tos;
1196 rth->fl.fl4_src = oldflp->fl4_src;
1197 rth->fl.oif = oldflp->oif;
1198 + rth->fl.fl4_gw = oldflp->fl4_gw;
1199 #ifdef CONFIG_IP_ROUTE_FWMARK
1200 rth->fl.fl4_fwmark= oldflp->fl4_fwmark;
1201 #endif
1202 @@ -2370,6 +2405,7 @@
1203 struct flowi fl = { .nl_u = { .ip4_u =
1204 { .daddr = oldflp->fl4_dst,
1205 .saddr = oldflp->fl4_src,
1206 + .gw = oldflp->fl4_gw,
1207 .tos = tos & IPTOS_RT_MASK,
1208 .scope = ((tos & RTO_ONLINK) ?
1209 RT_SCOPE_LINK :
1210 @@ -2475,6 +2511,7 @@
1211 dev_out = &loopback_dev;
1212 dev_hold(dev_out);
1213 fl.oif = loopback_dev.ifindex;
1214 + fl.fl4_gw = 0;
1215 res.type = RTN_LOCAL;
1216 flags |= RTCF_LOCAL;
1217 goto make_route;
1218 @@ -2482,7 +2519,7 @@
1219
1220 if (fib_lookup(&fl, &res)) {
1221 res.fi = NULL;
1222 - if (oldflp->oif) {
1223 + if (oldflp->oif && dev_out->flags & IFF_UP) {
1224 /* Apparently, routing tables are wrong. Assume,
1225 that the destination is on link.
1226
1227 @@ -2522,6 +2559,7 @@
1228 dev_out = &loopback_dev;
1229 dev_hold(dev_out);
1230 fl.oif = dev_out->ifindex;
1231 + fl.fl4_gw = 0;
1232 if (res.fi)
1233 fib_info_put(res.fi);
1234 res.fi = NULL;
1235 @@ -2529,13 +2567,12 @@
1236 goto make_route;
1237 }
1238
1239 + if (res.type == RTN_UNICAST)
1240 + fib_select_default(&fl, &res);
1241 #ifdef CONFIG_IP_ROUTE_MULTIPATH
1242 - if (res.fi->fib_nhs > 1 && fl.oif == 0)
1243 + if (res.fi->fib_nhs > 1)
1244 fib_select_multipath(&fl, &res);
1245 - else
1246 #endif
1247 - if (!res.prefixlen && res.type == RTN_UNICAST && !fl.oif)
1248 - fib_select_default(&fl, &res);
1249
1250 if (!fl.fl4_src)
1251 fl.fl4_src = FIB_RES_PREFSRC(res);
1252 @@ -2572,6 +2609,7 @@
1253 rth->fl.fl4_src == flp->fl4_src &&
1254 rth->fl.iif == 0 &&
1255 rth->fl.oif == flp->oif &&
1256 + rth->fl.fl4_gw == flp->fl4_gw &&
1257 #ifdef CONFIG_IP_ROUTE_FWMARK
1258 rth->fl.fl4_fwmark == flp->fl4_fwmark &&
1259 #endif
1260 @@ -3211,3 +3249,4 @@
1261 EXPORT_SYMBOL(__ip_select_ident);
1262 EXPORT_SYMBOL(ip_route_input);
1263 EXPORT_SYMBOL(ip_route_output_key);
1264 +EXPORT_SYMBOL(ip_route_input_lookup);
Staging tree of Zoltan Herpai