br_forward.c 5.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265
  1. /*
  2. * Forwarding decision
  3. * Linux ethernet bridge
  4. *
  5. * Authors:
  6. * Lennert Buytenhek <buytenh@gnu.org>
  7. *
  8. * This program is free software; you can redistribute it and/or
  9. * modify it under the terms of the GNU General Public License
  10. * as published by the Free Software Foundation; either version
  11. * 2 of the License, or (at your option) any later version.
  12. */
  13. #include <linux/err.h>
  14. #include <linux/kernel.h>
  15. #include <linux/netdevice.h>
  16. #include <linux/skbuff.h>
  17. #include <linux/if_vlan.h>
  18. #include <linux/netfilter_bridge.h>
  19. #include "br_private.h"
  20. static int deliver_clone(const struct net_bridge_port *prev,
  21. struct sk_buff *skb,
  22. void (*__packet_hook)(const struct net_bridge_port *p,
  23. struct sk_buff *skb));
  24. /* Don't forward packets to originating port or forwarding diasabled */
  25. static inline int should_deliver(const struct net_bridge_port *p,
  26. const struct sk_buff *skb)
  27. {
  28. return (((p->flags & BR_HAIRPIN_MODE) || skb->dev != p->dev) &&
  29. p->state == BR_STATE_FORWARDING);
  30. }
  31. static inline unsigned packet_length(const struct sk_buff *skb)
  32. {
  33. return skb->len - (skb->protocol == htons(ETH_P_8021Q) ? VLAN_HLEN : 0);
  34. }
  35. int br_dev_queue_push_xmit(struct sk_buff *skb)
  36. {
  37. /* drop mtu oversized packets except gso */
  38. if (packet_length(skb) > skb->dev->mtu && !skb_is_gso(skb))
  39. kfree_skb(skb);
  40. else {
  41. /* ip_refrag calls ip_fragment, doesn't copy the MAC header. */
  42. if (nf_bridge_maybe_copy_header(skb))
  43. kfree_skb(skb);
  44. else {
  45. skb_push(skb, ETH_HLEN);
  46. dev_queue_xmit(skb);
  47. }
  48. }
  49. return 0;
  50. }
  51. int br_forward_finish(struct sk_buff *skb)
  52. {
  53. return NF_HOOK(PF_BRIDGE, NF_BR_POST_ROUTING, skb, NULL, skb->dev,
  54. br_dev_queue_push_xmit);
  55. }
  56. static void __br_deliver(const struct net_bridge_port *to, struct sk_buff *skb)
  57. {
  58. skb->dev = to->dev;
  59. NF_HOOK(PF_BRIDGE, NF_BR_LOCAL_OUT, skb, NULL, skb->dev,
  60. br_forward_finish);
  61. }
  62. static void __br_forward(const struct net_bridge_port *to, struct sk_buff *skb)
  63. {
  64. struct net_device *indev;
  65. if (skb_warn_if_lro(skb)) {
  66. kfree_skb(skb);
  67. return;
  68. }
  69. indev = skb->dev;
  70. skb->dev = to->dev;
  71. skb_forward_csum(skb);
  72. NF_HOOK(PF_BRIDGE, NF_BR_FORWARD, skb, indev, skb->dev,
  73. br_forward_finish);
  74. }
  75. /* called with rcu_read_lock */
  76. void br_deliver(const struct net_bridge_port *to, struct sk_buff *skb)
  77. {
  78. if (should_deliver(to, skb)) {
  79. __br_deliver(to, skb);
  80. return;
  81. }
  82. kfree_skb(skb);
  83. }
  84. /* called with rcu_read_lock */
  85. void br_forward(const struct net_bridge_port *to, struct sk_buff *skb, struct sk_buff *skb0)
  86. {
  87. if (should_deliver(to, skb)) {
  88. if (skb0)
  89. deliver_clone(to, skb, __br_forward);
  90. else
  91. __br_forward(to, skb);
  92. return;
  93. }
  94. if (!skb0)
  95. kfree_skb(skb);
  96. }
  97. static int deliver_clone(const struct net_bridge_port *prev,
  98. struct sk_buff *skb,
  99. void (*__packet_hook)(const struct net_bridge_port *p,
  100. struct sk_buff *skb))
  101. {
  102. skb = skb_clone(skb, GFP_ATOMIC);
  103. if (!skb) {
  104. struct net_device *dev = BR_INPUT_SKB_CB(skb)->brdev;
  105. dev->stats.tx_dropped++;
  106. return -ENOMEM;
  107. }
  108. __packet_hook(prev, skb);
  109. return 0;
  110. }
  111. static struct net_bridge_port *maybe_deliver(
  112. struct net_bridge_port *prev, struct net_bridge_port *p,
  113. struct sk_buff *skb,
  114. void (*__packet_hook)(const struct net_bridge_port *p,
  115. struct sk_buff *skb))
  116. {
  117. int err;
  118. if (!should_deliver(p, skb))
  119. return prev;
  120. if (!prev)
  121. goto out;
  122. err = deliver_clone(prev, skb, __packet_hook);
  123. if (err)
  124. return ERR_PTR(err);
  125. out:
  126. return p;
  127. }
  128. /* called under bridge lock */
  129. static void br_flood(struct net_bridge *br, struct sk_buff *skb,
  130. struct sk_buff *skb0,
  131. void (*__packet_hook)(const struct net_bridge_port *p,
  132. struct sk_buff *skb))
  133. {
  134. struct net_bridge_port *p;
  135. struct net_bridge_port *prev;
  136. prev = NULL;
  137. list_for_each_entry_rcu(p, &br->port_list, list) {
  138. prev = maybe_deliver(prev, p, skb, __packet_hook);
  139. if (IS_ERR(prev))
  140. goto out;
  141. }
  142. if (!prev)
  143. goto out;
  144. if (skb0)
  145. deliver_clone(prev, skb, __packet_hook);
  146. else
  147. __packet_hook(prev, skb);
  148. return;
  149. out:
  150. if (!skb0)
  151. kfree_skb(skb);
  152. }
  153. /* called with rcu_read_lock */
  154. void br_flood_deliver(struct net_bridge *br, struct sk_buff *skb)
  155. {
  156. br_flood(br, skb, NULL, __br_deliver);
  157. }
  158. /* called under bridge lock */
  159. void br_flood_forward(struct net_bridge *br, struct sk_buff *skb,
  160. struct sk_buff *skb2)
  161. {
  162. br_flood(br, skb, skb2, __br_forward);
  163. }
  164. #ifdef CONFIG_BRIDGE_IGMP_SNOOPING
  165. /* called with rcu_read_lock */
  166. static void br_multicast_flood(struct net_bridge_mdb_entry *mdst,
  167. struct sk_buff *skb, struct sk_buff *skb0,
  168. void (*__packet_hook)(
  169. const struct net_bridge_port *p,
  170. struct sk_buff *skb))
  171. {
  172. struct net_device *dev = BR_INPUT_SKB_CB(skb)->brdev;
  173. struct net_bridge *br = netdev_priv(dev);
  174. struct net_bridge_port *port;
  175. struct net_bridge_port *lport, *rport;
  176. struct net_bridge_port *prev;
  177. struct net_bridge_port_group *p;
  178. struct hlist_node *rp;
  179. prev = NULL;
  180. rp = br->router_list.first;
  181. p = mdst ? mdst->ports : NULL;
  182. while (p || rp) {
  183. lport = p ? p->port : NULL;
  184. rport = rp ? hlist_entry(rp, struct net_bridge_port, rlist) :
  185. NULL;
  186. port = (unsigned long)lport > (unsigned long)rport ?
  187. lport : rport;
  188. prev = maybe_deliver(prev, port, skb, __packet_hook);
  189. if (IS_ERR(prev))
  190. goto out;
  191. if ((unsigned long)lport >= (unsigned long)port)
  192. p = p->next;
  193. if ((unsigned long)rport >= (unsigned long)port)
  194. rp = rp->next;
  195. }
  196. if (!prev)
  197. goto out;
  198. if (skb0)
  199. deliver_clone(prev, skb, __packet_hook);
  200. else
  201. __packet_hook(prev, skb);
  202. return;
  203. out:
  204. if (!skb0)
  205. kfree_skb(skb);
  206. }
  207. /* called with rcu_read_lock */
  208. void br_multicast_deliver(struct net_bridge_mdb_entry *mdst,
  209. struct sk_buff *skb)
  210. {
  211. br_multicast_flood(mdst, skb, NULL, __br_deliver);
  212. }
  213. /* called with rcu_read_lock */
  214. void br_multicast_forward(struct net_bridge_mdb_entry *mdst,
  215. struct sk_buff *skb, struct sk_buff *skb2)
  216. {
  217. br_multicast_flood(mdst, skb, skb2, __br_forward);
  218. }
  219. #endif