ip_fib.h File Reference

#include <linux/config.h>

Go to the source code of this file.

Classes
struct	kern_rta
struct	fib_nh
struct	fib_info
struct	fib_result
struct	fib_table
Defines
#define	fib_mtu   fib_metrics[RTAX_MTU-1]
#define	fib_window   fib_metrics[RTAX_WINDOW-1]
#define	fib_rtt   fib_metrics[RTAX_RTT-1]
#define	fib_advmss   fib_metrics[RTAX_ADVMSS-1]
#define	fib_dev   fib_nh[0].nh_dev
#define	FIB_RES_NH(res)   ((res).fi->fib_nh[0])
#define	FIB_RES_RESET(res)
#define	FIB_RES_PREFSRC(res)   ((res).fi->fib_prefsrc ? : __fib_res_prefsrc(&res))
#define	FIB_RES_GW(res)   (FIB_RES_NH(res).nh_gw)
#define	FIB_RES_DEV(res)   (FIB_RES_NH(res).nh_dev)
#define	FIB_RES_OIF(res)   (FIB_RES_NH(res).nh_oif)
Functions
fib_table *	fib_get_table (int id)
fib_table *	fib_new_table (int id)
int	fib_lookup (const struct rt_key *key, struct fib_result *res)
void	fib_select_default (const struct rt_key *key, struct fib_result *res)
void	ip_fib_init (void)
void	fib_flush (void)
int	inet_rtm_delroute (struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
int	inet_rtm_newroute (struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
int	inet_rtm_getroute (struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
int	inet_dump_fib (struct sk_buff *skb, struct netlink_callback *cb)
int	fib_validate_source (u32 src, u32 dst, u8 tos, int oif, struct net_device *dev, u32 *spec_dst, u32 *itag)
void	fib_select_multipath (const struct rt_key *key, struct fib_result *res)
int	ip_fib_check_default (u32 gw, struct net_device *dev)
void	fib_release_info (struct fib_info *)
int	fib_semantic_match (int type, struct fib_info *, const struct rt_key *, struct fib_result *)
fib_info *	fib_create_info (const struct rtmsg *r, struct kern_rta *rta, const struct nlmsghdr *, int *err)
int	fib_nh_match (struct rtmsg *r, struct nlmsghdr *, struct kern_rta *rta, struct fib_info *fi)
int	fib_dump_info (struct sk_buff *skb, u32 pid, u32 seq, int event, u8 tb_id, u8 type, u8 scope, void *dst, int dst_len, u8 tos, struct fib_info *fi)
int	fib_sync_down (u32 local, struct net_device *dev, int force)
int	fib_sync_up (struct net_device *dev)
int	fib_convert_rtentry (int cmd, struct nlmsghdr *nl, struct rtmsg *rtm, struct kern_rta *rta, struct rtentry *r)
void	fib_node_get_info (int type, int dead, struct fib_info *fi, u32 prefix, u32 mask, char *buffer)
u32	__fib_res_prefsrc (struct fib_result *res)
fib_table *	fib_hash_init (int id)
void	fib_combine_itag (u32 *itag, struct fib_result *res)
void	free_fib_info (struct fib_info *fi)
void	fib_info_put (struct fib_info *fi)
void	fib_res_put (struct fib_result *res)
Variables
fib_table *	local_table
fib_table *	main_table

---

Define Documentation

#define fib_advmss   fib_metrics[RTAX_ADVMSS-1]

Definition at line 72 of file ip_fib.h.

#define fib_dev   fib_nh[0].nh_dev

Definition at line 78 of file ip_fib.h.

#define fib_mtu   fib_metrics[RTAX_MTU-1]

Definition at line 69 of file ip_fib.h.

#define FIB_RES_DEV (  res   )     (FIB_RES_NH(res).nh_dev)

Definition at line 113 of file ip_fib.h. Referenced by __fib_res_prefsrc(), fib_check_nh(), fib_validate_source(), ip_dev_find(), ip_route_input_slow(), and ip_route_output_slow().

#define FIB_RES_GW (  res   )     (FIB_RES_NH(res).nh_gw)

Definition at line 112 of file ip_fib.h. Referenced by __fib_res_prefsrc(), fib_select_default(), ip_route_input_slow(), and rt_set_nexthop().

#define FIB_RES_NH (  res   )     ((res).fi->fib_nh[0])

Definition at line 106 of file ip_fib.h. Referenced by fib_combine_itag(), fib_select_default(), fib_validate_source(), and rt_set_nexthop().

#define FIB_RES_OIF (  res   )     (FIB_RES_NH(res).nh_oif)

Definition at line 114 of file ip_fib.h. Referenced by fib_check_nh(), and ip_route_input_slow().

#define FIB_RES_PREFSRC (  res   )     ((res).fi->fib_prefsrc ? : __fib_res_prefsrc(&res))

Definition at line 111 of file ip_fib.h. Referenced by fib_validate_source(), ip_route_output_slow(), and ip_rt_get_source().

#define FIB_RES_RESET (  res   )

Definition at line 107 of file ip_fib.h. Referenced by fib_semantic_match().

#define fib_rtt   fib_metrics[RTAX_RTT-1]

Definition at line 71 of file ip_fib.h.

#define fib_window   fib_metrics[RTAX_WINDOW-1]

Definition at line 70 of file ip_fib.h.

---

Function Documentation

u32 __fib_res_prefsrc (  struct fib_result *  res  )

Definition at line 635 of file fib_semantics.c. References FIB_RES_DEV, FIB_RES_GW, inet_select_addr(), and fib_result::scope. { return inet_select_addr(FIB_RES_DEV(*res), FIB_RES_GW(*res), res->scope); }

void fib_combine_itag (  u32 *  itag, struct fib_result *  res )  [inline, static]

Definition at line 248 of file ip_fib.h. References FIB_RES_NH. Referenced by fib_validate_source(). { #ifdef CONFIG_NET_CLS_ROUTE #ifdef CONFIG_IP_MULTIPLE_TABLES u32 rtag; #endif *itag = FIB_RES_NH(*res).nh_tclassid<<16; #ifdef CONFIG_IP_MULTIPLE_TABLES rtag = fib_rules_tclass(res); if (*itag == 0) *itag = (rtag<<16); *itag |= (rtag>>16); #endif #endif }

int fib_convert_rtentry (  int  cmd, struct nlmsghdr *  nl, struct rtmsg *  rtm, struct kern_rta *  rta, struct rtentry *  r )

Definition at line 713 of file fib_semantics.c. References __dev_get_by_name(), __in_dev_get(), bad_mask(), inet_addr_type(), inet_mask_len(), NLM_F_CREATE, NLM_F_REQUEST, nlmsghdr::nlmsg_flags, nlmsghdr::nlmsg_len, NLMSG_LENGTH, nlmsghdr::nlmsg_pid, nlmsghdr::nlmsg_seq, and nlmsghdr::nlmsg_type. Referenced by ip_rt_ioctl(). { int plen; u32 *ptr; memset(rtm, 0, sizeof(*rtm)); memset(rta, 0, sizeof(*rta)); if (r->rt_dst.sa_family != AF_INET) return -EAFNOSUPPORT; /* Check mask for validity: a) it must be contiguous. b) destination must have all host bits clear. c) if application forgot to set correct family (AF_INET), reject request unless it is absolutely clear i.e. both family and mask are zero. */ plen = 32; ptr = &((struct sockaddr_in*)&r->rt_dst)->sin_addr.s_addr; if (!(r->rt_flags&RTF_HOST)) { u32 mask = ((struct sockaddr_in*)&r->rt_genmask)->sin_addr.s_addr; if (r->rt_genmask.sa_family != AF_INET) { if (mask || r->rt_genmask.sa_family) return -EAFNOSUPPORT; } if (bad_mask(mask, *ptr)) return -EINVAL; plen = inet_mask_len(mask); } nl->nlmsg_flags = NLM_F_REQUEST; nl->nlmsg_pid = 0; nl->nlmsg_seq = 0; nl->nlmsg_len = NLMSG_LENGTH(sizeof(*rtm)); if (cmd == SIOCDELRT) { nl->nlmsg_type = RTM_DELROUTE; nl->nlmsg_flags = 0; } else { nl->nlmsg_type = RTM_NEWROUTE; nl->nlmsg_flags = NLM_F_REQUEST|NLM_F_CREATE; rtm->rtm_protocol = RTPROT_BOOT; } rtm->rtm_dst_len = plen; rta->rta_dst = ptr; if (r->rt_metric) { *(u32*)&r->rt_pad3 = r->rt_metric - 1; rta->rta_priority = (u32*)&r->rt_pad3; } if (r->rt_flags&RTF_REJECT) { rtm->rtm_scope = RT_SCOPE_HOST; rtm->rtm_type = RTN_UNREACHABLE; return 0; } rtm->rtm_scope = RT_SCOPE_NOWHERE; rtm->rtm_type = RTN_UNICAST; if (r->rt_dev) { char *colon; struct net_device *dev; char devname[IFNAMSIZ]; if (copy_from_user(devname, r->rt_dev, IFNAMSIZ-1)) return -EFAULT; devname[IFNAMSIZ-1] = 0; colon = strchr(devname, ':'); if (colon) *colon = 0; dev = __dev_get_by_name(devname); if (!dev) return -ENODEV; rta->rta_oif = &dev->ifindex; if (colon) { struct in_ifaddr *ifa; struct in_device *in_dev = __in_dev_get(dev); if (!in_dev) return -ENODEV; *colon = ':'; for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) if (strcmp(ifa->ifa_label, devname) == 0) break; if (ifa == NULL) return -ENODEV; rta->rta_prefsrc = &ifa->ifa_local; } } ptr = &((struct sockaddr_in*)&r->rt_gateway)->sin_addr.s_addr; if (r->rt_gateway.sa_family == AF_INET && *ptr) { rta->rta_gw = ptr; if (r->rt_flags&RTF_GATEWAY && inet_addr_type(*ptr) == RTN_UNICAST) rtm->rtm_scope = RT_SCOPE_UNIVERSE; } if (cmd == SIOCDELRT) return 0; if (r->rt_flags&RTF_GATEWAY && rta->rta_gw == NULL) return -EINVAL; if (rtm->rtm_scope == RT_SCOPE_NOWHERE) rtm->rtm_scope = RT_SCOPE_LINK; if (r->rt_flags&(RTF_MTU|RTF_WINDOW|RTF_IRTT)) { struct rtattr *rec; struct rtattr *mx = kmalloc(RTA_LENGTH(3*RTA_LENGTH(4)), GFP_KERNEL); if (mx == NULL) return -ENOMEM; rta->rta_mx = mx; mx->rta_type = RTA_METRICS; mx->rta_len = RTA_LENGTH(0); if (r->rt_flags&RTF_MTU) { rec = (void*)((char*)mx + RTA_ALIGN(mx->rta_len)); rec->rta_type = RTAX_ADVMSS; rec->rta_len = RTA_LENGTH(4); mx->rta_len += RTA_LENGTH(4); *(u32*)RTA_DATA(rec) = r->rt_mtu - 40; } if (r->rt_flags&RTF_WINDOW) { rec = (void*)((char*)mx + RTA_ALIGN(mx->rta_len)); rec->rta_type = RTAX_WINDOW; rec->rta_len = RTA_LENGTH(4); mx->rta_len += RTA_LENGTH(4); *(u32*)RTA_DATA(rec) = r->rt_window; } if (r->rt_flags&RTF_IRTT) { rec = (void*)((char*)mx + RTA_ALIGN(mx->rta_len)); rec->rta_type = RTAX_RTT; rec->rta_len = RTA_LENGTH(4); mx->rta_len += RTA_LENGTH(4); *(u32*)RTA_DATA(rec) = r->rt_irtt<<3; } } return 0; }

struct fib_info* fib_create_info (  const struct rtmsg *  r, struct kern_rta *  rta, const struct nlmsghdr *  , int *  err )

Definition at line 422 of file fib_semantics.c. References change_nexthops, dev_get_by_index(), endfor_nexthops, fib_check_nh(), fib_find_info(), fib_info_cnt, fib_info_list, fib_info_lock, fib_info::fib_prev, free_fib_info(), inet_addr_type(), kern_rta::rta_dst, kern_rta::rta_flow, kern_rta::rta_gw, kern_rta::rta_mp, kern_rta::rta_mx, kern_rta::rta_oif, kern_rta::rta_prefsrc, and kern_rta::rta_priority. Referenced by fn_hash_insert(). { int err; struct fib_info *fi = NULL; struct fib_info *ofi; #ifdef CONFIG_IP_ROUTE_MULTIPATH int nhs = 1; #else const int nhs = 1; #endif /* Fast check to catch the most weird cases */ if (fib_props[r->rtm_type].scope > r->rtm_scope) goto err_inval; #ifdef CONFIG_IP_ROUTE_MULTIPATH if (rta->rta_mp) { nhs = fib_count_nexthops(rta->rta_mp); if (nhs == 0) goto err_inval; } #endif fi = kmalloc(sizeof(*fi)+nhs*sizeof(struct fib_nh), GFP_KERNEL); err = -ENOBUFS; if (fi == NULL) goto failure; fib_info_cnt++; memset(fi, 0, sizeof(*fi)+nhs*sizeof(struct fib_nh)); fi->fib_protocol = r->rtm_protocol; fi->fib_nhs = nhs; fi->fib_flags = r->rtm_flags; if (rta->rta_priority) fi->fib_priority = *rta->rta_priority; if (rta->rta_mx) { int attrlen = RTA_PAYLOAD(rta->rta_mx); struct rtattr *attr = RTA_DATA(rta->rta_mx); while (RTA_OK(attr, attrlen)) { unsigned flavor = attr->rta_type; if (flavor) { if (flavor > RTAX_MAX) goto err_inval; fi->fib_metrics[flavor-1] = *(unsigned*)RTA_DATA(attr); } attr = RTA_NEXT(attr, attrlen); } } if (rta->rta_prefsrc) memcpy(&fi->fib_prefsrc, rta->rta_prefsrc, 4); if (rta->rta_mp) { #ifdef CONFIG_IP_ROUTE_MULTIPATH if ((err = fib_get_nhs(fi, rta->rta_mp, r)) != 0) goto failure; if (rta->rta_oif && fi->fib_nh->nh_oif != *rta->rta_oif) goto err_inval; if (rta->rta_gw && memcmp(&fi->fib_nh->nh_gw, rta->rta_gw, 4)) goto err_inval; #ifdef CONFIG_NET_CLS_ROUTE if (rta->rta_flow && memcmp(&fi->fib_nh->nh_tclassid, rta->rta_flow, 4)) goto err_inval; #endif #else goto err_inval; #endif } else { struct fib_nh *nh = fi->fib_nh; if (rta->rta_oif) nh->nh_oif = *rta->rta_oif; if (rta->rta_gw) memcpy(&nh->nh_gw, rta->rta_gw, 4); #ifdef CONFIG_NET_CLS_ROUTE if (rta->rta_flow) memcpy(&nh->nh_tclassid, rta->rta_flow, 4); #endif nh->nh_flags = r->rtm_flags; #ifdef CONFIG_IP_ROUTE_MULTIPATH nh->nh_weight = 1; #endif } #ifdef CONFIG_IP_ROUTE_NAT if (r->rtm_type == RTN_NAT) { if (rta->rta_gw == NULL || nhs != 1 || rta->rta_oif) goto err_inval; memcpy(&fi->fib_nh->nh_gw, rta->rta_gw, 4); goto link_it; } #endif if (fib_props[r->rtm_type].error) { if (rta->rta_gw || rta->rta_oif || rta->rta_mp) goto err_inval; goto link_it; } if (r->rtm_scope > RT_SCOPE_HOST) goto err_inval; if (r->rtm_scope == RT_SCOPE_HOST) { struct fib_nh *nh = fi->fib_nh; /* Local address is added. */ if (nhs != 1 || nh->nh_gw) goto err_inval; nh->nh_scope = RT_SCOPE_NOWHERE; nh->nh_dev = dev_get_by_index(fi->fib_nh->nh_oif); err = -ENODEV; if (nh->nh_dev == NULL) goto failure; } else { change_nexthops(fi) { if ((err = fib_check_nh(r, fi, nh)) != 0) goto failure; } endfor_nexthops(fi) } if (fi->fib_prefsrc) { if (r->rtm_type != RTN_LOCAL || rta->rta_dst == NULL || memcmp(&fi->fib_prefsrc, rta->rta_dst, 4)) if (inet_addr_type(fi->fib_prefsrc) != RTN_LOCAL) goto err_inval; } link_it: if ((ofi = fib_find_info(fi)) != NULL) { fi->fib_dead = 1; free_fib_info(fi); ofi->fib_treeref++; return ofi; } fi->fib_treeref++; atomic_inc(&fi->fib_clntref); write_lock(&fib_info_lock); fi->fib_next = fib_info_list; fi->fib_prev = NULL; if (fib_info_list) fib_info_list->fib_prev = fi; fib_info_list = fi; write_unlock(&fib_info_lock); return fi; err_inval: err = -EINVAL; failure: *errp = err; if (fi) { fi->fib_dead = 1; free_fib_info(fi); } return NULL; }

int fib_dump_info (  struct sk_buff *  skb, u32  pid, u32  seq, int  event, u8  tb_id, u8  type, u8  scope, void *  dst, int  dst_len, u8  tos, struct fib_info *  fi )

Definition at line 641 of file fib_semantics.c. References sk_buff::data, endfor_nexthops, fib_info::fib_flags, fib_info::fib_metrics, fib_info::fib_nh, fib_info::fib_nhs, fib_info::fib_prefsrc, fib_info::fib_priority, fib_info::fib_protocol, for_nexthops, sk_buff::len, fib_nh::nh_gw, fib_nh::nh_oif, NLMSG_DATA, NLMSG_PUT, rtnetlink_put_metrics(), scope, skb_put(), skb_tailroom(), skb_trim(), and sk_buff::tail. Referenced by fn_hash_dump_bucket(), and rtmsg_fib(). { struct rtmsg *rtm; struct nlmsghdr *nlh; unsigned char *b = skb->tail; nlh = NLMSG_PUT(skb, pid, seq, event, sizeof(*rtm)); rtm = NLMSG_DATA(nlh); rtm->rtm_family = AF_INET; rtm->rtm_dst_len = dst_len; rtm->rtm_src_len = 0; rtm->rtm_tos = tos; rtm->rtm_table = tb_id; rtm->rtm_type = type; rtm->rtm_flags = fi->fib_flags; rtm->rtm_scope = scope; if (rtm->rtm_dst_len) RTA_PUT(skb, RTA_DST, 4, dst); rtm->rtm_protocol = fi->fib_protocol; if (fi->fib_priority) RTA_PUT(skb, RTA_PRIORITY, 4, &fi->fib_priority); #ifdef CONFIG_NET_CLS_ROUTE if (fi->fib_nh[0].nh_tclassid) RTA_PUT(skb, RTA_FLOW, 4, &fi->fib_nh[0].nh_tclassid); #endif if (rtnetlink_put_metrics(skb, fi->fib_metrics) < 0) goto rtattr_failure; if (fi->fib_prefsrc) RTA_PUT(skb, RTA_PREFSRC, 4, &fi->fib_prefsrc); if (fi->fib_nhs == 1) { if (fi->fib_nh->nh_gw) RTA_PUT(skb, RTA_GATEWAY, 4, &fi->fib_nh->nh_gw); if (fi->fib_nh->nh_oif) RTA_PUT(skb, RTA_OIF, sizeof(int), &fi->fib_nh->nh_oif); } #ifdef CONFIG_IP_ROUTE_MULTIPATH if (fi->fib_nhs > 1) { struct rtnexthop *nhp; struct rtattr *mp_head; if (skb_tailroom(skb) <= RTA_SPACE(0)) goto rtattr_failure; mp_head = (struct rtattr*)skb_put(skb, RTA_SPACE(0)); for_nexthops(fi) { if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4)) goto rtattr_failure; nhp = (struct rtnexthop*)skb_put(skb, RTA_ALIGN(sizeof(*nhp))); nhp->rtnh_flags = nh->nh_flags & 0xFF; nhp->rtnh_hops = nh->nh_weight-1; nhp->rtnh_ifindex = nh->nh_oif; if (nh->nh_gw) RTA_PUT(skb, RTA_GATEWAY, 4, &nh->nh_gw); nhp->rtnh_len = skb->tail - (unsigned char*)nhp; } endfor_nexthops(fi); mp_head->rta_type = RTA_MULTIPATH; mp_head->rta_len = skb->tail - (u8*)mp_head; } #endif nlh->nlmsg_len = skb->tail - b; return skb->len; nlmsg_failure: rtattr_failure: skb_trim(skb, b - skb->data); return -1; }

void fib_flush (  void   )

Definition at line 78 of file fib_frontend.c. References fib_get_table(), local_table, main_table, rt_cache_flush(), and fib_table::tb_flush. Referenced by fib_del_ifaddr(), fib_disable_ip(), and fn_hash_delete(). { int flushed = 0; #ifdef CONFIG_IP_MULTIPLE_TABLES struct fib_table *tb; int id; for (id = RT_TABLE_MAX; id>0; id--) { if ((tb = fib_get_table(id))==NULL) continue; flushed += tb->tb_flush(tb); } #else /* CONFIG_IP_MULTIPLE_TABLES */ flushed += main_table->tb_flush(main_table); flushed += local_table->tb_flush(local_table); #endif /* CONFIG_IP_MULTIPLE_TABLES */ if (flushed) rt_cache_flush(-1); }

struct fib_table* fib_get_table (  int  id  )  [inline, static]

Definition at line 147 of file ip_fib.h. References local_table, and main_table. Referenced by fib_flush(), fib_lookup(), fib_new_table(), fib_select_default(), inet_dump_fib(), inet_rtm_delroute(), and ip_rt_ioctl(). { if (id != RT_TABLE_LOCAL) return main_table; return local_table; }

struct fib_table* fib_hash_init (  int  id  )

Definition at line 929 of file fib_hash.c. References fn_hash(), fn_hash_delete(), fn_hash_dump(), fn_hash_flush(), fn_hash_insert(), fn_hash_kmem, fn_hash_lookup(), fn_hash_select_default(), fib_table::tb_data, fib_table::tb_delete, fib_table::tb_dump, fib_table::tb_flush, fib_table::tb_get_info, fib_table::tb_id, fib_table::tb_insert, fib_table::tb_lookup, and fib_table::tb_select_default. Referenced by ip_fib_init(). { struct fib_table *tb; if (fn_hash_kmem == NULL) fn_hash_kmem = kmem_cache_create("ip_fib_hash", sizeof(struct fib_node), 0, SLAB_HWCACHE_ALIGN, NULL, NULL); tb = kmalloc(sizeof(struct fib_table) + sizeof(struct fn_hash), GFP_KERNEL); if (tb == NULL) return NULL; tb->tb_id = id; tb->tb_lookup = fn_hash_lookup; tb->tb_insert = fn_hash_insert; tb->tb_delete = fn_hash_delete; tb->tb_flush = fn_hash_flush; tb->tb_select_default = fn_hash_select_default; tb->tb_dump = fn_hash_dump; #ifdef CONFIG_PROC_FS tb->tb_get_info = fn_hash_get_info; #endif memset(tb->tb_data, 0, sizeof(struct fn_hash)); return tb; }

void fib_info_put (  struct fib_info *  fi  )  [inline, static]

Definition at line 266 of file ip_fib.h. References fib_info::fib_clntref, and free_fib_info(). Referenced by fib_release_info(), fib_res_put(), fn_hash_select_default(), and ip_route_output_slow(). { if (atomic_dec_and_test(&fi->fib_clntref)) free_fib_info(fi); }

int fib_lookup (  const struct rt_key *  key, struct fib_result *  res )  [inline, static]

Definition at line 159 of file ip_fib.h. References local_table, main_table, and fib_table::tb_lookup. { if (local_table->tb_lookup(local_table, key, res) && main_table->tb_lookup(main_table, key, res)) return -ENETUNREACH; return 0; }

struct fib_table* fib_new_table (  int  id  )  [inline, static]

Definition at line 154 of file ip_fib.h. References fib_get_table(). Referenced by fib_magic(), inet_rtm_newroute(), and ip_rt_ioctl(). { return fib_get_table(id); }

int fib_nh_match (  struct rtmsg *  r, struct nlmsghdr *  , struct kern_rta *  rta, struct fib_info *  fi )

Definition at line 253 of file fib_semantics.c. References endfor_nexthops, fib_info::fib_nh, fib_info::fib_priority, for_nexthops, fib_nh::nh_gw, fib_nh::nh_oif, kern_rta::rta_gw, kern_rta::rta_mp, kern_rta::rta_oif, and kern_rta::rta_priority. Referenced by fn_hash_delete(). { #ifdef CONFIG_IP_ROUTE_MULTIPATH struct rtnexthop *nhp; int nhlen; #endif if (rta->rta_priority && *rta->rta_priority != fi->fib_priority) return 1; if (rta->rta_oif || rta->rta_gw) { if ((!rta->rta_oif || *rta->rta_oif == fi->fib_nh->nh_oif) && (!rta->rta_gw || memcmp(rta->rta_gw, &fi->fib_nh->nh_gw, 4) == 0)) return 0; return 1; } #ifdef CONFIG_IP_ROUTE_MULTIPATH if (rta->rta_mp == NULL) return 0; nhp = RTA_DATA(rta->rta_mp); nhlen = RTA_PAYLOAD(rta->rta_mp); for_nexthops(fi) { int attrlen = nhlen - sizeof(struct rtnexthop); u32 gw; if (attrlen < 0 || (nhlen -= nhp->rtnh_len) < 0) return -EINVAL; if (nhp->rtnh_ifindex && nhp->rtnh_ifindex != nh->nh_oif) return 1; if (attrlen) { gw = fib_get_attr32(RTNH_DATA(nhp), attrlen, RTA_GATEWAY); if (gw && gw != nh->nh_gw) return 1; #ifdef CONFIG_NET_CLS_ROUTE gw = fib_get_attr32(RTNH_DATA(nhp), attrlen, RTA_FLOW); if (gw && gw != nh->nh_tclassid) return 1; #endif } nhp = RTNH_NEXT(nhp); } endfor_nexthops(fi); #endif return 0; }

void fib_node_get_info (  int  type, int  dead, struct fib_info *  fi, u32  prefix, u32  mask, char *  buffer )

void fib_release_info (  struct fib_info *   )

Definition at line 123 of file fib_semantics.c. References fib_info::fib_dead, fib_info_list, fib_info_lock, fib_info_put(), fib_info::fib_next, fib_info::fib_prev, and fib_info::fib_treeref. Referenced by fn_free_node(), and fn_hash_insert(). { write_lock(&fib_info_lock); if (fi && --fi->fib_treeref == 0) { if (fi->fib_next) fi->fib_next->fib_prev = fi->fib_prev; if (fi->fib_prev) fi->fib_prev->fib_next = fi->fib_next; if (fi == fib_info_list) fib_info_list = fi->fib_next; fi->fib_dead = 1; fib_info_put(fi); } write_unlock(&fib_info_lock); }

void fib_res_put (  struct fib_result *  res  )  [inline, static]

Definition at line 272 of file ip_fib.h. References fib_result::fi, fib_info_put(), and fib_rule_put(). Referenced by fib_check_nh(), fib_validate_source(), inet_addr_type(), ip_dev_find(), ip_do_nat(), ip_route_input_slow(), ip_route_output_slow(), and ip_rt_get_source(). { if (res->fi) fib_info_put(res->fi); #ifdef CONFIG_IP_MULTIPLE_TABLES if (res->r) fib_rule_put(res->r); #endif }

void fib_select_default (  const struct rt_key *  key, struct fib_result *  res )  [inline, static]

Definition at line 167 of file ip_fib.h. References FIB_RES_GW, FIB_RES_NH, main_table, and fib_table::tb_select_default. { if (FIB_RES_GW(*res) && FIB_RES_NH(*res).nh_scope == RT_SCOPE_LINK) main_table->tb_select_default(main_table, key, res); }

void fib_select_multipath (  const struct rt_key *  key, struct fib_result *  res )

Referenced by ip_route_input_slow(), and ip_route_output_slow().

int fib_semantic_match (  int  type, struct fib_info *  , const struct rt_key *  , struct fib_result *  )

Definition at line 581 of file fib_semantics.c. References endfor_nexthops, fib_result::fi, fib_info::fib_clntref, fib_info::fib_flags, fib_info::fib_nhs, FIB_RES_RESET, for_nexthops, fib_result::nh_sel, and rt_key::oif. Referenced by fn_hash_lookup(). { int err = fib_props[type].error; if (err == 0) { if (fi->fib_flags&RTNH_F_DEAD) return 1; res->fi = fi; switch (type) { #ifdef CONFIG_IP_ROUTE_NAT case RTN_NAT: FIB_RES_RESET(*res); atomic_inc(&fi->fib_clntref); return 0; #endif case RTN_UNICAST: case RTN_LOCAL: case RTN_BROADCAST: case RTN_ANYCAST: case RTN_MULTICAST: for_nexthops(fi) { if (nh->nh_flags&RTNH_F_DEAD) continue; if (!key->oif || key->oif == nh->nh_oif) break; } #ifdef CONFIG_IP_ROUTE_MULTIPATH if (nhsel < fi->fib_nhs) { res->nh_sel = nhsel; atomic_inc(&fi->fib_clntref); return 0; } #else if (nhsel < 1) { atomic_inc(&fi->fib_clntref); return 0; } #endif endfor_nexthops(fi); res->fi = NULL; return 1; default: res->fi = NULL; printk(KERN_DEBUG "impossible 102\n"); return -EINVAL; } } return err; }

int fib_sync_down (  u32  local, struct net_device *  dev, int  force )

Definition at line 861 of file fib_semantics.c. References change_nexthops, endfor_fib_info, endfor_nexthops, fib_info::fib_flags, fib_info::fib_nhs, fib_info::fib_prefsrc, for_fib_info, and scope. Referenced by fib_del_ifaddr(), and fib_disable_ip(). { int ret = 0; int scope = RT_SCOPE_NOWHERE; if (force) scope = -1; for_fib_info() { if (local && fi->fib_prefsrc == local) { fi->fib_flags |= RTNH_F_DEAD; ret++; } else if (dev && fi->fib_nhs) { int dead = 0; change_nexthops(fi) { if (nh->nh_flags&RTNH_F_DEAD) dead++; else if (nh->nh_dev == dev && nh->nh_scope != scope) { nh->nh_flags |= RTNH_F_DEAD; #ifdef CONFIG_IP_ROUTE_MULTIPATH spin_lock_bh(&fib_multipath_lock); fi->fib_power -= nh->nh_power; nh->nh_power = 0; spin_unlock_bh(&fib_multipath_lock); #endif dead++; } #ifdef CONFIG_IP_ROUTE_MULTIPATH if (force > 1 && nh->nh_dev == dev) { dead = fi->fib_nhs; break; } #endif } endfor_nexthops(fi) if (dead == fi->fib_nhs) { fi->fib_flags |= RTNH_F_DEAD; ret++; } } } endfor_fib_info(); return ret; }

int fib_sync_up (  struct net_device *  dev  )

Referenced by fib_inetaddr_event(), and fib_netdev_event().

int fib_validate_source (  u32  src, u32  dst, u8  tos, int  oif, struct net_device *  dev, u32 *  spec_dst, u32 *  itag )

Definition at line 206 of file fib_frontend.c. References __in_dev_get(), rt_key::dst, fib_result::fi, fib_combine_itag(), fib_lookup(), fib_info::fib_nhs, FIB_RES_DEV, FIB_RES_NH, FIB_RES_PREFSRC, fib_res_put(), net_device::ifindex, rt_key::iif, IN_DEV_LOOP, IN_DEV_RPFILTER, inet_select_addr(), inetdev_lock, rt_key::oif, rt_key::scope, rt_key::src, rt_key::tos, and fib_result::type. Referenced by ip_route_input_mc(), and ip_route_input_slow(). { struct in_device *in_dev; struct rt_key key; struct fib_result res; int no_addr, rpf, loop; int ret; key.dst = src; key.src = dst; key.tos = tos; key.oif = 0; key.iif = oif; key.scope = RT_SCOPE_UNIVERSE; no_addr = rpf = loop = 0; read_lock(&inetdev_lock); in_dev = __in_dev_get(dev); if (in_dev) { no_addr = in_dev->ifa_list == NULL; rpf = IN_DEV_RPFILTER(in_dev); loop = IN_DEV_LOOP(in_dev); } read_unlock(&inetdev_lock); if (in_dev == NULL) goto e_inval; if (fib_lookup(&key, &res)) goto last_resort; if (loop && res.type == RTN_LOCAL) { *spec_dst = FIB_RES_PREFSRC(res); fib_res_put(&res); return 0; } if (res.type != RTN_UNICAST) goto e_inval_res; *spec_dst = FIB_RES_PREFSRC(res); fib_combine_itag(itag, &res); #ifdef CONFIG_IP_ROUTE_MULTIPATH if (FIB_RES_DEV(res) == dev || res.fi->fib_nhs > 1) #else if (FIB_RES_DEV(res) == dev) #endif { ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST; fib_res_put(&res); return ret; } fib_res_put(&res); if (no_addr) goto last_resort; if (rpf) goto e_inval; key.oif = dev->ifindex; ret = 0; if (fib_lookup(&key, &res) == 0) { if (res.type == RTN_UNICAST) { *spec_dst = FIB_RES_PREFSRC(res); ret = FIB_RES_NH(res).nh_scope >= RT_SCOPE_HOST; } fib_res_put(&res); } return ret; last_resort: if (rpf) goto e_inval; *spec_dst = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE); *itag = 0; return 0; e_inval_res: fib_res_put(&res); e_inval: return -EINVAL; }

void free_fib_info (  struct fib_info *  fi  )

Definition at line 108 of file fib_semantics.c. References change_nexthops, dev_put(), endfor_nexthops, fib_info::fib_dead, and fib_info_cnt. Referenced by fib_create_info(), and fib_info_put(). { if (fi->fib_dead == 0) { printk("Freeing alive fib_info %p\n", fi); return; } change_nexthops(fi) { if (nh->nh_dev) dev_put(nh->nh_dev); nh->nh_dev = NULL; } endfor_nexthops(fi); fib_info_cnt--; kfree(fi); }

int inet_dump_fib (  struct sk_buff *  skb, struct netlink_callback *  cb )

Definition at line 387 of file fib_frontend.c. References netlink_callback::args, fib_get_table(), ip_rt_dump(), sk_buff::len, netlink_callback::nlh, NLMSG_DATA, NLMSG_PAYLOAD, and RT_TABLE_MIN. { int t; int s_t; struct fib_table *tb; if (NLMSG_PAYLOAD(cb->nlh, 0) >= sizeof(struct rtmsg) && ((struct rtmsg*)NLMSG_DATA(cb->nlh))->rtm_flags&RTM_F_CLONED) return ip_rt_dump(skb, cb); s_t = cb->args[0]; if (s_t == 0) s_t = cb->args[0] = RT_TABLE_MIN; for (t=s_t; t<=RT_TABLE_MAX; t++) { if (t < s_t) continue; if (t > s_t) memset(&cb->args[1], 0, sizeof(cb->args)-sizeof(cb->args[0])); if ((tb = fib_get_table(t))==NULL) continue; if (tb->tb_dump(tb, skb, cb) < 0) break; } cb->args[0] = t; return skb->len; }

int inet_rtm_delroute (  struct sk_buff *  skb, struct nlmsghdr *  nlh, void *  arg )

Definition at line 357 of file fib_frontend.c. References fib_get_table(), inet_check_attr(), NETLINK_CB, and NLMSG_DATA. { struct fib_table * tb; struct rtattr **rta = arg; struct rtmsg *r = NLMSG_DATA(nlh); if (inet_check_attr(r, rta)) return -EINVAL; tb = fib_get_table(r->rtm_table); if (tb) return tb->tb_delete(tb, r, (struct kern_rta*)rta, nlh, &NETLINK_CB(skb)); return -ESRCH; }

int inet_rtm_getroute (  struct sk_buff *  skb, struct nlmsghdr *  nlh, void *  arg )

Definition at line 2240 of file route.c. References __dev_get_by_index(), alloc_skb(), ip_route_input(), ip_route_output(), kfree_skb(), MAX_HEADER, NETLINK_CB, netlink_unicast(), NLMSG_DATA, NLMSG_GOODSIZE, nlmsghdr::nlmsg_seq, rt_fill_info(), rtnl, and skb_reserve(). { struct rtattr **rta = arg; struct rtmsg *rtm = NLMSG_DATA(nlh); struct rtable *rt = NULL; u32 dst = 0; u32 src = 0; int iif = 0; int err = -ENOBUFS; struct sk_buff *skb; skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL); if (!skb) goto out; /* Reserve room for dummy headers, this skb can pass through good chunk of routing engine. */ skb->mac.raw = skb->data; skb_reserve(skb, MAX_HEADER + sizeof(struct iphdr)); if (rta[RTA_SRC - 1]) memcpy(&src, RTA_DATA(rta[RTA_SRC - 1]), 4); if (rta[RTA_DST - 1]) memcpy(&dst, RTA_DATA(rta[RTA_DST - 1]), 4); if (rta[RTA_IIF - 1]) memcpy(&iif, RTA_DATA(rta[RTA_IIF - 1]), sizeof(int)); if (iif) { struct net_device *dev = __dev_get_by_index(iif); err = -ENODEV; if (!dev) goto out_free; skb->protocol = htons(ETH_P_IP); skb->dev = dev; local_bh_disable(); err = ip_route_input(skb, dst, src, rtm->rtm_tos, dev); local_bh_enable(); rt = (struct rtable*)skb->dst; if (!err && rt->u.dst.error) err = -rt->u.dst.error; } else { int oif = 0; if (rta[RTA_OIF - 1]) memcpy(&oif, RTA_DATA(rta[RTA_OIF - 1]), sizeof(int)); err = ip_route_output(&rt, dst, src, rtm->rtm_tos, oif); } if (err) goto out_free; skb->dst = &rt->u.dst; if (rtm->rtm_flags & RTM_F_NOTIFY) rt->rt_flags |= RTCF_NOTIFY; NETLINK_CB(skb).dst_pid = NETLINK_CB(in_skb).pid; err = rt_fill_info(skb, NETLINK_CB(in_skb).pid, nlh->nlmsg_seq, RTM_NEWROUTE, 0); if (!err) goto out_free; if (err < 0) { err = -EMSGSIZE; goto out_free; } err = netlink_unicast(rtnl, skb, NETLINK_CB(in_skb).pid, MSG_DONTWAIT); if (err > 0) err = 0; out: return err; out_free: kfree_skb(skb); goto out; }

int inet_rtm_newroute (  struct sk_buff *  skb, struct nlmsghdr *  nlh, void *  arg )

Definition at line 372 of file fib_frontend.c. References fib_new_table(), inet_check_attr(), NETLINK_CB, and NLMSG_DATA. { struct fib_table * tb; struct rtattr **rta = arg; struct rtmsg *r = NLMSG_DATA(nlh); if (inet_check_attr(r, rta)) return -EINVAL; tb = fib_new_table(r->rtm_table); if (tb) return tb->tb_insert(tb, r, (struct kern_rta*)rta, nlh, &NETLINK_CB(skb)); return -ENOBUFS; }

int ip_fib_check_default (  u32  gw, struct net_device *  dev )

Definition at line 180 of file fib_semantics.c. References endfor_fib_info, endfor_nexthops, fib_info_lock, for_fib_info, and for_nexthops. Referenced by ip_rt_redirect(). { read_lock(&fib_info_lock); for_fib_info() { if (fi->fib_flags & RTNH_F_DEAD) continue; for_nexthops(fi) { if (nh->nh_dev == dev && nh->nh_gw == gw && nh->nh_scope == RT_SCOPE_LINK && !(nh->nh_flags&RTNH_F_DEAD)) { read_unlock(&fib_info_lock); return 0; } } endfor_nexthops(fi); } endfor_fib_info(); read_unlock(&fib_info_lock); return -1; }

void ip_fib_init (  void   )

Definition at line 650 of file fib_frontend.c. References fib_hash_init(), fib_inetaddr_notifier, fib_netdev_notifier, fib_rules_init(), local_table, main_table, register_inetaddr_notifier(), and register_netdevice_notifier(). Referenced by ip_rt_init(). { #ifdef CONFIG_PROC_FS proc_net_create("route",0,fib_get_procinfo); #endif /* CONFIG_PROC_FS */ #ifndef CONFIG_IP_MULTIPLE_TABLES local_table = fib_hash_init(RT_TABLE_LOCAL); main_table = fib_hash_init(RT_TABLE_MAIN); #else fib_rules_init(); #endif register_netdevice_notifier(&fib_netdev_notifier); register_inetaddr_notifier(&fib_inetaddr_notifier); }

---

Variable Documentation

struct fib_table* local_table

Definition at line 54 of file fib_frontend.c. Referenced by fib_flush(), fib_get_table(), fib_lookup(), inet_addr_type(), ip_dev_find(), and ip_fib_init().

struct fib_table* main_table

Definition at line 55 of file fib_frontend.c. Referenced by fib_flush(), fib_get_table(), fib_lookup(), fib_select_default(), and ip_fib_init().

---