~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/batman-adv/routing.c

Version: ~ [ linux-5.16-rc3 ] ~ [ linux-5.15.5 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.82 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.162 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.218 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.256 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.291 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.293 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* Copyright (C) 2007-2015 B.A.T.M.A.N. contributors:
  2  *
  3  * Marek Lindner, Simon Wunderlich
  4  *
  5  * This program is free software; you can redistribute it and/or
  6  * modify it under the terms of version 2 of the GNU General Public
  7  * License as published by the Free Software Foundation.
  8  *
  9  * This program is distributed in the hope that it will be useful, but
 10  * WITHOUT ANY WARRANTY; without even the implied warranty of
 11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 12  * General Public License for more details.
 13  *
 14  * You should have received a copy of the GNU General Public License
 15  * along with this program; if not, see <http://www.gnu.org/licenses/>.
 16  */
 17 
 18 #include "routing.h"
 19 #include "main.h"
 20 
 21 #include <linux/atomic.h>
 22 #include <linux/byteorder/generic.h>
 23 #include <linux/compiler.h>
 24 #include <linux/errno.h>
 25 #include <linux/etherdevice.h>
 26 #include <linux/if_ether.h>
 27 #include <linux/jiffies.h>
 28 #include <linux/netdevice.h>
 29 #include <linux/printk.h>
 30 #include <linux/rculist.h>
 31 #include <linux/rcupdate.h>
 32 #include <linux/skbuff.h>
 33 #include <linux/spinlock.h>
 34 #include <linux/stddef.h>
 35 
 36 #include "bitarray.h"
 37 #include "bridge_loop_avoidance.h"
 38 #include "distributed-arp-table.h"
 39 #include "fragmentation.h"
 40 #include "hard-interface.h"
 41 #include "icmp_socket.h"
 42 #include "network-coding.h"
 43 #include "originator.h"
 44 #include "packet.h"
 45 #include "send.h"
 46 #include "soft-interface.h"
 47 #include "translation-table.h"
 48 
 49 static int batadv_route_unicast_packet(struct sk_buff *skb,
 50                                        struct batadv_hard_iface *recv_if);
 51 
 52 /**
 53  * _batadv_update_route - set the router for this originator
 54  * @bat_priv: the bat priv with all the soft interface information
 55  * @orig_node: orig node which is to be configured
 56  * @recv_if: the receive interface for which this route is set
 57  * @neigh_node: neighbor which should be the next router
 58  *
 59  * This function does not perform any error checks
 60  */
 61 static void _batadv_update_route(struct batadv_priv *bat_priv,
 62                                  struct batadv_orig_node *orig_node,
 63                                  struct batadv_hard_iface *recv_if,
 64                                  struct batadv_neigh_node *neigh_node)
 65 {
 66         struct batadv_orig_ifinfo *orig_ifinfo;
 67         struct batadv_neigh_node *curr_router;
 68 
 69         orig_ifinfo = batadv_orig_ifinfo_get(orig_node, recv_if);
 70         if (!orig_ifinfo)
 71                 return;
 72 
 73         rcu_read_lock();
 74         curr_router = rcu_dereference(orig_ifinfo->router);
 75         if (curr_router && !atomic_inc_not_zero(&curr_router->refcount))
 76                 curr_router = NULL;
 77         rcu_read_unlock();
 78 
 79         /* route deleted */
 80         if ((curr_router) && (!neigh_node)) {
 81                 batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
 82                            "Deleting route towards: %pM\n", orig_node->orig);
 83                 batadv_tt_global_del_orig(bat_priv, orig_node, -1,
 84                                           "Deleted route towards originator");
 85 
 86         /* route added */
 87         } else if ((!curr_router) && (neigh_node)) {
 88                 batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
 89                            "Adding route towards: %pM (via %pM)\n",
 90                            orig_node->orig, neigh_node->addr);
 91         /* route changed */
 92         } else if (neigh_node && curr_router) {
 93                 batadv_dbg(BATADV_DBG_ROUTES, bat_priv,
 94                            "Changing route towards: %pM (now via %pM - was via %pM)\n",
 95                            orig_node->orig, neigh_node->addr,
 96                            curr_router->addr);
 97         }
 98 
 99         if (curr_router)
100                 batadv_neigh_node_free_ref(curr_router);
101 
102         /* increase refcount of new best neighbor */
103         if (neigh_node && !atomic_inc_not_zero(&neigh_node->refcount))
104                 neigh_node = NULL;
105 
106         spin_lock_bh(&orig_node->neigh_list_lock);
107         rcu_assign_pointer(orig_ifinfo->router, neigh_node);
108         spin_unlock_bh(&orig_node->neigh_list_lock);
109         batadv_orig_ifinfo_free_ref(orig_ifinfo);
110 
111         /* decrease refcount of previous best neighbor */
112         if (curr_router)
113                 batadv_neigh_node_free_ref(curr_router);
114 }
115 
116 /**
117  * batadv_update_route - set the router for this originator
118  * @bat_priv: the bat priv with all the soft interface information
119  * @orig_node: orig node which is to be configured
120  * @recv_if: the receive interface for which this route is set
121  * @neigh_node: neighbor which should be the next router
122  */
123 void batadv_update_route(struct batadv_priv *bat_priv,
124                          struct batadv_orig_node *orig_node,
125                          struct batadv_hard_iface *recv_if,
126                          struct batadv_neigh_node *neigh_node)
127 {
128         struct batadv_neigh_node *router = NULL;
129 
130         if (!orig_node)
131                 goto out;
132 
133         router = batadv_orig_router_get(orig_node, recv_if);
134 
135         if (router != neigh_node)
136                 _batadv_update_route(bat_priv, orig_node, recv_if, neigh_node);
137 
138 out:
139         if (router)
140                 batadv_neigh_node_free_ref(router);
141 }
142 
143 /* checks whether the host restarted and is in the protection time.
144  * returns:
145  *  0 if the packet is to be accepted
146  *  1 if the packet is to be ignored.
147  */
148 int batadv_window_protected(struct batadv_priv *bat_priv, int32_t seq_num_diff,
149                             unsigned long *last_reset)
150 {
151         if (seq_num_diff <= -BATADV_TQ_LOCAL_WINDOW_SIZE ||
152             seq_num_diff >= BATADV_EXPECTED_SEQNO_RANGE) {
153                 if (!batadv_has_timed_out(*last_reset,
154                                           BATADV_RESET_PROTECTION_MS))
155                         return 1;
156 
157                 *last_reset = jiffies;
158                 batadv_dbg(BATADV_DBG_BATMAN, bat_priv,
159                            "old packet received, start protection\n");
160         }
161 
162         return 0;
163 }
164 
165 bool batadv_check_management_packet(struct sk_buff *skb,
166                                     struct batadv_hard_iface *hard_iface,
167                                     int header_len)
168 {
169         struct ethhdr *ethhdr;
170 
171         /* drop packet if it has not necessary minimum size */
172         if (unlikely(!pskb_may_pull(skb, header_len)))
173                 return false;
174 
175         ethhdr = eth_hdr(skb);
176 
177         /* packet with broadcast indication but unicast recipient */
178         if (!is_broadcast_ether_addr(ethhdr->h_dest))
179                 return false;
180 
181         /* packet with broadcast sender address */
182         if (is_broadcast_ether_addr(ethhdr->h_source))
183                 return false;
184 
185         /* create a copy of the skb, if needed, to modify it. */
186         if (skb_cow(skb, 0) < 0)
187                 return false;
188 
189         /* keep skb linear */
190         if (skb_linearize(skb) < 0)
191                 return false;
192 
193         return true;
194 }
195 
196 /**
197  * batadv_recv_my_icmp_packet - receive an icmp packet locally
198  * @bat_priv: the bat priv with all the soft interface information
199  * @skb: icmp packet to process
200  *
201  * Returns NET_RX_SUCCESS if the packet has been consumed or NET_RX_DROP
202  * otherwise.
203  */
204 static int batadv_recv_my_icmp_packet(struct batadv_priv *bat_priv,
205                                       struct sk_buff *skb)
206 {
207         struct batadv_hard_iface *primary_if = NULL;
208         struct batadv_orig_node *orig_node = NULL;
209         struct batadv_icmp_header *icmph;
210         int res, ret = NET_RX_DROP;
211 
212         icmph = (struct batadv_icmp_header *)skb->data;
213 
214         switch (icmph->msg_type) {
215         case BATADV_ECHO_REPLY:
216         case BATADV_DESTINATION_UNREACHABLE:
217         case BATADV_TTL_EXCEEDED:
218                 /* receive the packet */
219                 if (skb_linearize(skb) < 0)
220                         break;
221 
222                 batadv_socket_receive_packet(icmph, skb->len);
223                 break;
224         case BATADV_ECHO_REQUEST:
225                 /* answer echo request (ping) */
226                 primary_if = batadv_primary_if_get_selected(bat_priv);
227                 if (!primary_if)
228                         goto out;
229 
230                 /* get routing information */
231                 orig_node = batadv_orig_hash_find(bat_priv, icmph->orig);
232                 if (!orig_node)
233                         goto out;
234 
235                 /* create a copy of the skb, if needed, to modify it. */
236                 if (skb_cow(skb, ETH_HLEN) < 0)
237                         goto out;
238 
239                 icmph = (struct batadv_icmp_header *)skb->data;
240 
241                 ether_addr_copy(icmph->dst, icmph->orig);
242                 ether_addr_copy(icmph->orig, primary_if->net_dev->dev_addr);
243                 icmph->msg_type = BATADV_ECHO_REPLY;
244                 icmph->ttl = BATADV_TTL;
245 
246                 res = batadv_send_skb_to_orig(skb, orig_node, NULL);
247                 if (res != NET_XMIT_DROP)
248                         ret = NET_RX_SUCCESS;
249 
250                 break;
251         default:
252                 /* drop unknown type */
253                 goto out;
254         }
255 out:
256         if (primary_if)
257                 batadv_hardif_free_ref(primary_if);
258         if (orig_node)
259                 batadv_orig_node_free_ref(orig_node);
260         return ret;
261 }
262 
263 static int batadv_recv_icmp_ttl_exceeded(struct batadv_priv *bat_priv,
264                                          struct sk_buff *skb)
265 {
266         struct batadv_hard_iface *primary_if = NULL;
267         struct batadv_orig_node *orig_node = NULL;
268         struct batadv_icmp_packet *icmp_packet;
269         int ret = NET_RX_DROP;
270 
271         icmp_packet = (struct batadv_icmp_packet *)skb->data;
272 
273         /* send TTL exceeded if packet is an echo request (traceroute) */
274         if (icmp_packet->msg_type != BATADV_ECHO_REQUEST) {
275                 pr_debug("Warning - can't forward icmp packet from %pM to %pM: ttl exceeded\n",
276                          icmp_packet->orig, icmp_packet->dst);
277                 goto out;
278         }
279 
280         primary_if = batadv_primary_if_get_selected(bat_priv);
281         if (!primary_if)
282                 goto out;
283 
284         /* get routing information */
285         orig_node = batadv_orig_hash_find(bat_priv, icmp_packet->orig);
286         if (!orig_node)
287                 goto out;
288 
289         /* create a copy of the skb, if needed, to modify it. */
290         if (skb_cow(skb, ETH_HLEN) < 0)
291                 goto out;
292 
293         icmp_packet = (struct batadv_icmp_packet *)skb->data;
294 
295         ether_addr_copy(icmp_packet->dst, icmp_packet->orig);
296         ether_addr_copy(icmp_packet->orig, primary_if->net_dev->dev_addr);
297         icmp_packet->msg_type = BATADV_TTL_EXCEEDED;
298         icmp_packet->ttl = BATADV_TTL;
299 
300         if (batadv_send_skb_to_orig(skb, orig_node, NULL) != NET_XMIT_DROP)
301                 ret = NET_RX_SUCCESS;
302 
303 out:
304         if (primary_if)
305                 batadv_hardif_free_ref(primary_if);
306         if (orig_node)
307                 batadv_orig_node_free_ref(orig_node);
308         return ret;
309 }
310 
311 int batadv_recv_icmp_packet(struct sk_buff *skb,
312                             struct batadv_hard_iface *recv_if)
313 {
314         struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
315         struct batadv_icmp_header *icmph;
316         struct batadv_icmp_packet_rr *icmp_packet_rr;
317         struct ethhdr *ethhdr;
318         struct batadv_orig_node *orig_node = NULL;
319         int hdr_size = sizeof(struct batadv_icmp_header);
320         int ret = NET_RX_DROP;
321 
322         /* drop packet if it has not necessary minimum size */
323         if (unlikely(!pskb_may_pull(skb, hdr_size)))
324                 goto out;
325 
326         ethhdr = eth_hdr(skb);
327 
328         /* packet with unicast indication but broadcast recipient */
329         if (is_broadcast_ether_addr(ethhdr->h_dest))
330                 goto out;
331 
332         /* packet with broadcast sender address */
333         if (is_broadcast_ether_addr(ethhdr->h_source))
334                 goto out;
335 
336         /* not for me */
337         if (!batadv_is_my_mac(bat_priv, ethhdr->h_dest))
338                 goto out;
339 
340         icmph = (struct batadv_icmp_header *)skb->data;
341 
342         /* add record route information if not full */
343         if ((icmph->msg_type == BATADV_ECHO_REPLY ||
344              icmph->msg_type == BATADV_ECHO_REQUEST) &&
345             (skb->len >= sizeof(struct batadv_icmp_packet_rr))) {
346                 if (skb_linearize(skb) < 0)
347                         goto out;
348 
349                 /* create a copy of the skb, if needed, to modify it. */
350                 if (skb_cow(skb, ETH_HLEN) < 0)
351                         goto out;
352 
353                 icmph = (struct batadv_icmp_header *)skb->data;
354                 icmp_packet_rr = (struct batadv_icmp_packet_rr *)icmph;
355                 if (icmp_packet_rr->rr_cur >= BATADV_RR_LEN)
356                         goto out;
357 
358                 ether_addr_copy(icmp_packet_rr->rr[icmp_packet_rr->rr_cur],
359                                 ethhdr->h_dest);
360                 icmp_packet_rr->rr_cur++;
361         }
362 
363         /* packet for me */
364         if (batadv_is_my_mac(bat_priv, icmph->dst))
365                 return batadv_recv_my_icmp_packet(bat_priv, skb);
366 
367         /* TTL exceeded */
368         if (icmph->ttl < 2)
369                 return batadv_recv_icmp_ttl_exceeded(bat_priv, skb);
370 
371         /* get routing information */
372         orig_node = batadv_orig_hash_find(bat_priv, icmph->dst);
373         if (!orig_node)
374                 goto out;
375 
376         /* create a copy of the skb, if needed, to modify it. */
377         if (skb_cow(skb, ETH_HLEN) < 0)
378                 goto out;
379 
380         icmph = (struct batadv_icmp_header *)skb->data;
381 
382         /* decrement ttl */
383         icmph->ttl--;
384 
385         /* route it */
386         if (batadv_send_skb_to_orig(skb, orig_node, recv_if) != NET_XMIT_DROP)
387                 ret = NET_RX_SUCCESS;
388 
389 out:
390         if (orig_node)
391                 batadv_orig_node_free_ref(orig_node);
392         return ret;
393 }
394 
395 /**
396  * batadv_check_unicast_packet - Check for malformed unicast packets
397  * @bat_priv: the bat priv with all the soft interface information
398  * @skb: packet to check
399  * @hdr_size: size of header to pull
400  *
401  * Check for short header and bad addresses in given packet. Returns negative
402  * value when check fails and 0 otherwise. The negative value depends on the
403  * reason: -ENODATA for bad header, -EBADR for broadcast destination or source,
404  * and -EREMOTE for non-local (other host) destination.
405  */
406 static int batadv_check_unicast_packet(struct batadv_priv *bat_priv,
407                                        struct sk_buff *skb, int hdr_size)
408 {
409         struct ethhdr *ethhdr;
410 
411         /* drop packet if it has not necessary minimum size */
412         if (unlikely(!pskb_may_pull(skb, hdr_size)))
413                 return -ENODATA;
414 
415         ethhdr = eth_hdr(skb);
416 
417         /* packet with unicast indication but broadcast recipient */
418         if (is_broadcast_ether_addr(ethhdr->h_dest))
419                 return -EBADR;
420 
421         /* packet with broadcast sender address */
422         if (is_broadcast_ether_addr(ethhdr->h_source))
423                 return -EBADR;
424 
425         /* not for me */
426         if (!batadv_is_my_mac(bat_priv, ethhdr->h_dest))
427                 return -EREMOTE;
428 
429         return 0;
430 }
431 
432 /**
433  * batadv_find_router - find a suitable router for this originator
434  * @bat_priv: the bat priv with all the soft interface information
435  * @orig_node: the destination node
436  * @recv_if: pointer to interface this packet was received on
437  *
438  * Returns the router which should be used for this orig_node on
439  * this interface, or NULL if not available.
440  */
441 struct batadv_neigh_node *
442 batadv_find_router(struct batadv_priv *bat_priv,
443                    struct batadv_orig_node *orig_node,
444                    struct batadv_hard_iface *recv_if)
445 {
446         struct batadv_algo_ops *bao = bat_priv->bat_algo_ops;
447         struct batadv_neigh_node *first_candidate_router = NULL;
448         struct batadv_neigh_node *next_candidate_router = NULL;
449         struct batadv_neigh_node *router, *cand_router = NULL;
450         struct batadv_neigh_node *last_cand_router = NULL;
451         struct batadv_orig_ifinfo *cand, *first_candidate = NULL;
452         struct batadv_orig_ifinfo *next_candidate = NULL;
453         struct batadv_orig_ifinfo *last_candidate;
454         bool last_candidate_found = false;
455 
456         if (!orig_node)
457                 return NULL;
458 
459         router = batadv_orig_router_get(orig_node, recv_if);
460 
461         if (!router)
462                 return router;
463 
464         /* only consider bonding for recv_if == BATADV_IF_DEFAULT (first hop)
465          * and if activated.
466          */
467         if (!(recv_if == BATADV_IF_DEFAULT && atomic_read(&bat_priv->bonding)))
468                 return router;
469 
470         /* bonding: loop through the list of possible routers found
471          * for the various outgoing interfaces and find a candidate after
472          * the last chosen bonding candidate (next_candidate). If no such
473          * router is found, use the first candidate found (the previously
474          * chosen bonding candidate might have been the last one in the list).
475          * If this can't be found either, return the previously chosen
476          * router - obviously there are no other candidates.
477          */
478         rcu_read_lock();
479         last_candidate = orig_node->last_bonding_candidate;
480         if (last_candidate)
481                 last_cand_router = rcu_dereference(last_candidate->router);
482 
483         hlist_for_each_entry_rcu(cand, &orig_node->ifinfo_list, list) {
484                 /* acquire some structures and references ... */
485                 if (!atomic_inc_not_zero(&cand->refcount))
486                         continue;
487 
488                 cand_router = rcu_dereference(cand->router);
489                 if (!cand_router)
490                         goto next;
491 
492                 if (!atomic_inc_not_zero(&cand_router->refcount)) {
493                         cand_router = NULL;
494                         goto next;
495                 }
496 
497                 /* alternative candidate should be good enough to be
498                  * considered
499                  */
500                 if (!bao->bat_neigh_is_equiv_or_better(cand_router,
501                                                        cand->if_outgoing,
502                                                        router, recv_if))
503                         goto next;
504 
505                 /* don't use the same router twice */
506                 if (last_cand_router == cand_router)
507                         goto next;
508 
509                 /* mark the first possible candidate */
510                 if (!first_candidate) {
511                         atomic_inc(&cand_router->refcount);
512                         atomic_inc(&cand->refcount);
513                         first_candidate = cand;
514                         first_candidate_router = cand_router;
515                 }
516 
517                 /* check if the loop has already passed the previously selected
518                  * candidate ... this function should select the next candidate
519                  * AFTER the previously used bonding candidate.
520                  */
521                 if (!last_candidate || last_candidate_found) {
522                         next_candidate = cand;
523                         next_candidate_router = cand_router;
524                         break;
525                 }
526 
527                 if (last_candidate == cand)
528                         last_candidate_found = true;
529 next:
530                 /* free references */
531                 if (cand_router) {
532                         batadv_neigh_node_free_ref(cand_router);
533                         cand_router = NULL;
534                 }
535                 batadv_orig_ifinfo_free_ref(cand);
536         }
537         rcu_read_unlock();
538 
539         /* last_bonding_candidate is reset below, remove the old reference. */
540         if (orig_node->last_bonding_candidate)
541                 batadv_orig_ifinfo_free_ref(orig_node->last_bonding_candidate);
542 
543         /* After finding candidates, handle the three cases:
544          * 1) there is a next candidate, use that
545          * 2) there is no next candidate, use the first of the list
546          * 3) there is no candidate at all, return the default router
547          */
548         if (next_candidate) {
549                 batadv_neigh_node_free_ref(router);
550 
551                 /* remove references to first candidate, we don't need it. */
552                 if (first_candidate) {
553                         batadv_neigh_node_free_ref(first_candidate_router);
554                         batadv_orig_ifinfo_free_ref(first_candidate);
555                 }
556                 router = next_candidate_router;
557                 orig_node->last_bonding_candidate = next_candidate;
558         } else if (first_candidate) {
559                 batadv_neigh_node_free_ref(router);
560 
561                 /* refcounting has already been done in the loop above. */
562                 router = first_candidate_router;
563                 orig_node->last_bonding_candidate = first_candidate;
564         } else {
565                 orig_node->last_bonding_candidate = NULL;
566         }
567 
568         return router;
569 }
570 
571 static int batadv_route_unicast_packet(struct sk_buff *skb,
572                                        struct batadv_hard_iface *recv_if)
573 {
574         struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
575         struct batadv_orig_node *orig_node = NULL;
576         struct batadv_unicast_packet *unicast_packet;
577         struct ethhdr *ethhdr = eth_hdr(skb);
578         int res, hdr_len, ret = NET_RX_DROP;
579 
580         unicast_packet = (struct batadv_unicast_packet *)skb->data;
581 
582         /* TTL exceeded */
583         if (unicast_packet->ttl < 2) {
584                 pr_debug("Warning - can't forward unicast packet from %pM to %pM: ttl exceeded\n",
585                          ethhdr->h_source, unicast_packet->dest);
586                 goto out;
587         }
588 
589         /* get routing information */
590         orig_node = batadv_orig_hash_find(bat_priv, unicast_packet->dest);
591 
592         if (!orig_node)
593                 goto out;
594 
595         /* create a copy of the skb, if needed, to modify it. */
596         if (skb_cow(skb, ETH_HLEN) < 0)
597                 goto out;
598 
599         /* decrement ttl */
600         unicast_packet = (struct batadv_unicast_packet *)skb->data;
601         unicast_packet->ttl--;
602 
603         switch (unicast_packet->packet_type) {
604         case BATADV_UNICAST_4ADDR:
605                 hdr_len = sizeof(struct batadv_unicast_4addr_packet);
606                 break;
607         case BATADV_UNICAST:
608                 hdr_len = sizeof(struct batadv_unicast_packet);
609                 break;
610         default:
611                 /* other packet types not supported - yet */
612                 hdr_len = -1;
613                 break;
614         }
615 
616         if (hdr_len > 0)
617                 batadv_skb_set_priority(skb, hdr_len);
618 
619         res = batadv_send_skb_to_orig(skb, orig_node, recv_if);
620 
621         /* translate transmit result into receive result */
622         if (res == NET_XMIT_SUCCESS) {
623                 /* skb was transmitted and consumed */
624                 batadv_inc_counter(bat_priv, BATADV_CNT_FORWARD);
625                 batadv_add_counter(bat_priv, BATADV_CNT_FORWARD_BYTES,
626                                    skb->len + ETH_HLEN);
627 
628                 ret = NET_RX_SUCCESS;
629         } else if (res == NET_XMIT_POLICED) {
630                 /* skb was buffered and consumed */
631                 ret = NET_RX_SUCCESS;
632         }
633 
634 out:
635         if (orig_node)
636                 batadv_orig_node_free_ref(orig_node);
637         return ret;
638 }
639 
640 /**
641  * batadv_reroute_unicast_packet - update the unicast header for re-routing
642  * @bat_priv: the bat priv with all the soft interface information
643  * @unicast_packet: the unicast header to be updated
644  * @dst_addr: the payload destination
645  * @vid: VLAN identifier
646  *
647  * Search the translation table for dst_addr and update the unicast header with
648  * the new corresponding information (originator address where the destination
649  * client currently is and its known TTVN)
650  *
651  * Returns true if the packet header has been updated, false otherwise
652  */
653 static bool
654 batadv_reroute_unicast_packet(struct batadv_priv *bat_priv,
655                               struct batadv_unicast_packet *unicast_packet,
656                               uint8_t *dst_addr, unsigned short vid)
657 {
658         struct batadv_orig_node *orig_node = NULL;
659         struct batadv_hard_iface *primary_if = NULL;
660         bool ret = false;
661         uint8_t *orig_addr, orig_ttvn;
662 
663         if (batadv_is_my_client(bat_priv, dst_addr, vid)) {
664                 primary_if = batadv_primary_if_get_selected(bat_priv);
665                 if (!primary_if)
666                         goto out;
667                 orig_addr = primary_if->net_dev->dev_addr;
668                 orig_ttvn = (uint8_t)atomic_read(&bat_priv->tt.vn);
669         } else {
670                 orig_node = batadv_transtable_search(bat_priv, NULL, dst_addr,
671                                                      vid);
672                 if (!orig_node)
673                         goto out;
674 
675                 if (batadv_compare_eth(orig_node->orig, unicast_packet->dest))
676                         goto out;
677 
678                 orig_addr = orig_node->orig;
679                 orig_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
680         }
681 
682         /* update the packet header */
683         ether_addr_copy(unicast_packet->dest, orig_addr);
684         unicast_packet->ttvn = orig_ttvn;
685 
686         ret = true;
687 out:
688         if (primary_if)
689                 batadv_hardif_free_ref(primary_if);
690         if (orig_node)
691                 batadv_orig_node_free_ref(orig_node);
692 
693         return ret;
694 }
695 
696 static int batadv_check_unicast_ttvn(struct batadv_priv *bat_priv,
697                                      struct sk_buff *skb, int hdr_len) {
698         struct batadv_unicast_packet *unicast_packet;
699         struct batadv_hard_iface *primary_if;
700         struct batadv_orig_node *orig_node;
701         uint8_t curr_ttvn, old_ttvn;
702         struct ethhdr *ethhdr;
703         unsigned short vid;
704         int is_old_ttvn;
705 
706         /* check if there is enough data before accessing it */
707         if (!pskb_may_pull(skb, hdr_len + ETH_HLEN))
708                 return 0;
709 
710         /* create a copy of the skb (in case of for re-routing) to modify it. */
711         if (skb_cow(skb, sizeof(*unicast_packet)) < 0)
712                 return 0;
713 
714         unicast_packet = (struct batadv_unicast_packet *)skb->data;
715         vid = batadv_get_vid(skb, hdr_len);
716         ethhdr = (struct ethhdr *)(skb->data + hdr_len);
717 
718         /* check if the destination client was served by this node and it is now
719          * roaming. In this case, it means that the node has got a ROAM_ADV
720          * message and that it knows the new destination in the mesh to re-route
721          * the packet to
722          */
723         if (batadv_tt_local_client_is_roaming(bat_priv, ethhdr->h_dest, vid)) {
724                 if (batadv_reroute_unicast_packet(bat_priv, unicast_packet,
725                                                   ethhdr->h_dest, vid))
726                         batadv_dbg_ratelimited(BATADV_DBG_TT,
727                                                bat_priv,
728                                                "Rerouting unicast packet to %pM (dst=%pM): Local Roaming\n",
729                                                unicast_packet->dest,
730                                                ethhdr->h_dest);
731                 /* at this point the mesh destination should have been
732                  * substituted with the originator address found in the global
733                  * table. If not, let the packet go untouched anyway because
734                  * there is nothing the node can do
735                  */
736                 return 1;
737         }
738 
739         /* retrieve the TTVN known by this node for the packet destination. This
740          * value is used later to check if the node which sent (or re-routed
741          * last time) the packet had an updated information or not
742          */
743         curr_ttvn = (uint8_t)atomic_read(&bat_priv->tt.vn);
744         if (!batadv_is_my_mac(bat_priv, unicast_packet->dest)) {
745                 orig_node = batadv_orig_hash_find(bat_priv,
746                                                   unicast_packet->dest);
747                 /* if it is not possible to find the orig_node representing the
748                  * destination, the packet can immediately be dropped as it will
749                  * not be possible to deliver it
750                  */
751                 if (!orig_node)
752                         return 0;
753 
754                 curr_ttvn = (uint8_t)atomic_read(&orig_node->last_ttvn);
755                 batadv_orig_node_free_ref(orig_node);
756         }
757 
758         /* check if the TTVN contained in the packet is fresher than what the
759          * node knows
760          */
761         is_old_ttvn = batadv_seq_before(unicast_packet->ttvn, curr_ttvn);
762         if (!is_old_ttvn)
763                 return 1;
764 
765         old_ttvn = unicast_packet->ttvn;
766         /* the packet was forged based on outdated network information. Its
767          * destination can possibly be updated and forwarded towards the new
768          * target host
769          */
770         if (batadv_reroute_unicast_packet(bat_priv, unicast_packet,
771                                           ethhdr->h_dest, vid)) {
772                 batadv_dbg_ratelimited(BATADV_DBG_TT, bat_priv,
773                                        "Rerouting unicast packet to %pM (dst=%pM): TTVN mismatch old_ttvn=%u new_ttvn=%u\n",
774                                        unicast_packet->dest, ethhdr->h_dest,
775                                        old_ttvn, curr_ttvn);
776                 return 1;
777         }
778 
779         /* the packet has not been re-routed: either the destination is
780          * currently served by this node or there is no destination at all and
781          * it is possible to drop the packet
782          */
783         if (!batadv_is_my_client(bat_priv, ethhdr->h_dest, vid))
784                 return 0;
785 
786         /* update the header in order to let the packet be delivered to this
787          * node's soft interface
788          */
789         primary_if = batadv_primary_if_get_selected(bat_priv);
790         if (!primary_if)
791                 return 0;
792 
793         ether_addr_copy(unicast_packet->dest, primary_if->net_dev->dev_addr);
794 
795         batadv_hardif_free_ref(primary_if);
796 
797         unicast_packet->ttvn = curr_ttvn;
798 
799         return 1;
800 }
801 
802 /**
803  * batadv_recv_unhandled_unicast_packet - receive and process packets which
804  *      are in the unicast number space but not yet known to the implementation
805  * @skb: unicast tvlv packet to process
806  * @recv_if: pointer to interface this packet was received on
807  *
808  * Returns NET_RX_SUCCESS if the packet has been consumed or NET_RX_DROP
809  * otherwise.
810  */
811 int batadv_recv_unhandled_unicast_packet(struct sk_buff *skb,
812                                          struct batadv_hard_iface *recv_if)
813 {
814         struct batadv_unicast_packet *unicast_packet;
815         struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
816         int check, hdr_size = sizeof(*unicast_packet);
817 
818         check = batadv_check_unicast_packet(bat_priv, skb, hdr_size);
819         if (check < 0)
820                 return NET_RX_DROP;
821 
822         /* we don't know about this type, drop it. */
823         unicast_packet = (struct batadv_unicast_packet *)skb->data;
824         if (batadv_is_my_mac(bat_priv, unicast_packet->dest))
825                 return NET_RX_DROP;
826 
827         return batadv_route_unicast_packet(skb, recv_if);
828 }
829 
830 int batadv_recv_unicast_packet(struct sk_buff *skb,
831                                struct batadv_hard_iface *recv_if)
832 {
833         struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
834         struct batadv_unicast_packet *unicast_packet;
835         struct batadv_unicast_4addr_packet *unicast_4addr_packet;
836         uint8_t *orig_addr;
837         struct batadv_orig_node *orig_node = NULL;
838         int check, hdr_size = sizeof(*unicast_packet);
839         bool is4addr;
840 
841         unicast_packet = (struct batadv_unicast_packet *)skb->data;
842         unicast_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data;
843 
844         is4addr = unicast_packet->packet_type == BATADV_UNICAST_4ADDR;
845         /* the caller function should have already pulled 2 bytes */
846         if (is4addr)
847                 hdr_size = sizeof(*unicast_4addr_packet);
848 
849         /* function returns -EREMOTE for promiscuous packets */
850         check = batadv_check_unicast_packet(bat_priv, skb, hdr_size);
851 
852         /* Even though the packet is not for us, we might save it to use for
853          * decoding a later received coded packet
854          */
855         if (check == -EREMOTE)
856                 batadv_nc_skb_store_sniffed_unicast(bat_priv, skb);
857 
858         if (check < 0)
859                 return NET_RX_DROP;
860         if (!batadv_check_unicast_ttvn(bat_priv, skb, hdr_size))
861                 return NET_RX_DROP;
862 
863         /* packet for me */
864         if (batadv_is_my_mac(bat_priv, unicast_packet->dest)) {
865                 if (is4addr) {
866                         batadv_dat_inc_counter(bat_priv,
867                                                unicast_4addr_packet->subtype);
868                         orig_addr = unicast_4addr_packet->src;
869                         orig_node = batadv_orig_hash_find(bat_priv, orig_addr);
870                 }
871 
872                 if (batadv_dat_snoop_incoming_arp_request(bat_priv, skb,
873                                                           hdr_size))
874                         goto rx_success;
875                 if (batadv_dat_snoop_incoming_arp_reply(bat_priv, skb,
876                                                         hdr_size))
877                         goto rx_success;
878 
879                 batadv_interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size,
880                                     orig_node);
881 
882 rx_success:
883                 if (orig_node)
884                         batadv_orig_node_free_ref(orig_node);
885 
886                 return NET_RX_SUCCESS;
887         }
888 
889         return batadv_route_unicast_packet(skb, recv_if);
890 }
891 
892 /**
893  * batadv_recv_unicast_tvlv - receive and process unicast tvlv packets
894  * @skb: unicast tvlv packet to process
895  * @recv_if: pointer to interface this packet was received on
896  * @dst_addr: the payload destination
897  *
898  * Returns NET_RX_SUCCESS if the packet has been consumed or NET_RX_DROP
899  * otherwise.
900  */
901 int batadv_recv_unicast_tvlv(struct sk_buff *skb,
902                              struct batadv_hard_iface *recv_if)
903 {
904         struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
905         struct batadv_unicast_tvlv_packet *unicast_tvlv_packet;
906         unsigned char *tvlv_buff;
907         uint16_t tvlv_buff_len;
908         int hdr_size = sizeof(*unicast_tvlv_packet);
909         int ret = NET_RX_DROP;
910 
911         if (batadv_check_unicast_packet(bat_priv, skb, hdr_size) < 0)
912                 return NET_RX_DROP;
913 
914         /* the header is likely to be modified while forwarding */
915         if (skb_cow(skb, hdr_size) < 0)
916                 return NET_RX_DROP;
917 
918         /* packet needs to be linearized to access the tvlv content */
919         if (skb_linearize(skb) < 0)
920                 return NET_RX_DROP;
921 
922         unicast_tvlv_packet = (struct batadv_unicast_tvlv_packet *)skb->data;
923 
924         tvlv_buff = (unsigned char *)(skb->data + hdr_size);
925         tvlv_buff_len = ntohs(unicast_tvlv_packet->tvlv_len);
926 
927         if (tvlv_buff_len > skb->len - hdr_size)
928                 return NET_RX_DROP;
929 
930         ret = batadv_tvlv_containers_process(bat_priv, false, NULL,
931                                              unicast_tvlv_packet->src,
932                                              unicast_tvlv_packet->dst,
933                                              tvlv_buff, tvlv_buff_len);
934 
935         if (ret != NET_RX_SUCCESS)
936                 ret = batadv_route_unicast_packet(skb, recv_if);
937         else
938                 consume_skb(skb);
939 
940         return ret;
941 }
942 
943 /**
944  * batadv_recv_frag_packet - process received fragment
945  * @skb: the received fragment
946  * @recv_if: interface that the skb is received on
947  *
948  * This function does one of the three following things: 1) Forward fragment, if
949  * the assembled packet will exceed our MTU; 2) Buffer fragment, if we till
950  * lack further fragments; 3) Merge fragments, if we have all needed parts.
951  *
952  * Return NET_RX_DROP if the skb is not consumed, NET_RX_SUCCESS otherwise.
953  */
954 int batadv_recv_frag_packet(struct sk_buff *skb,
955                             struct batadv_hard_iface *recv_if)
956 {
957         struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
958         struct batadv_orig_node *orig_node_src = NULL;
959         struct batadv_frag_packet *frag_packet;
960         int ret = NET_RX_DROP;
961 
962         if (batadv_check_unicast_packet(bat_priv, skb,
963                                         sizeof(*frag_packet)) < 0)
964                 goto out;
965 
966         frag_packet = (struct batadv_frag_packet *)skb->data;
967         orig_node_src = batadv_orig_hash_find(bat_priv, frag_packet->orig);
968         if (!orig_node_src)
969                 goto out;
970 
971         /* Route the fragment if it is not for us and too big to be merged. */
972         if (!batadv_is_my_mac(bat_priv, frag_packet->dest) &&
973             batadv_frag_skb_fwd(skb, recv_if, orig_node_src)) {
974                 ret = NET_RX_SUCCESS;
975                 goto out;
976         }
977 
978         batadv_inc_counter(bat_priv, BATADV_CNT_FRAG_RX);
979         batadv_add_counter(bat_priv, BATADV_CNT_FRAG_RX_BYTES, skb->len);
980 
981         /* Add fragment to buffer and merge if possible. */
982         if (!batadv_frag_skb_buffer(&skb, orig_node_src))
983                 goto out;
984 
985         /* Deliver merged packet to the appropriate handler, if it was
986          * merged
987          */
988         if (skb)
989                 batadv_batman_skb_recv(skb, recv_if->net_dev,
990                                        &recv_if->batman_adv_ptype, NULL);
991 
992         ret = NET_RX_SUCCESS;
993 
994 out:
995         if (orig_node_src)
996                 batadv_orig_node_free_ref(orig_node_src);
997 
998         return ret;
999 }
1000 
1001 int batadv_recv_bcast_packet(struct sk_buff *skb,
1002                              struct batadv_hard_iface *recv_if)
1003 {
1004         struct batadv_priv *bat_priv = netdev_priv(recv_if->soft_iface);
1005         struct batadv_orig_node *orig_node = NULL;
1006         struct batadv_bcast_packet *bcast_packet;
1007         struct ethhdr *ethhdr;
1008         int hdr_size = sizeof(*bcast_packet);
1009         int ret = NET_RX_DROP;
1010         int32_t seq_diff;
1011         uint32_t seqno;
1012 
1013         /* drop packet if it has not necessary minimum size */
1014         if (unlikely(!pskb_may_pull(skb, hdr_size)))
1015                 goto out;
1016 
1017         ethhdr = eth_hdr(skb);
1018 
1019         /* packet with broadcast indication but unicast recipient */
1020         if (!is_broadcast_ether_addr(ethhdr->h_dest))
1021                 goto out;
1022 
1023         /* packet with broadcast sender address */
1024         if (is_broadcast_ether_addr(ethhdr->h_source))
1025                 goto out;
1026 
1027         /* ignore broadcasts sent by myself */
1028         if (batadv_is_my_mac(bat_priv, ethhdr->h_source))
1029                 goto out;
1030 
1031         bcast_packet = (struct batadv_bcast_packet *)skb->data;
1032 
1033         /* ignore broadcasts originated by myself */
1034         if (batadv_is_my_mac(bat_priv, bcast_packet->orig))
1035                 goto out;
1036 
1037         if (bcast_packet->ttl < 2)
1038                 goto out;
1039 
1040         orig_node = batadv_orig_hash_find(bat_priv, bcast_packet->orig);
1041 
1042         if (!orig_node)
1043                 goto out;
1044 
1045         spin_lock_bh(&orig_node->bcast_seqno_lock);
1046 
1047         seqno = ntohl(bcast_packet->seqno);
1048         /* check whether the packet is a duplicate */
1049         if (batadv_test_bit(orig_node->bcast_bits, orig_node->last_bcast_seqno,
1050                             seqno))
1051                 goto spin_unlock;
1052 
1053         seq_diff = seqno - orig_node->last_bcast_seqno;
1054 
1055         /* check whether the packet is old and the host just restarted. */
1056         if (batadv_window_protected(bat_priv, seq_diff,
1057                                     &orig_node->bcast_seqno_reset))
1058                 goto spin_unlock;
1059 
1060         /* mark broadcast in flood history, update window position
1061          * if required.
1062          */
1063         if (batadv_bit_get_packet(bat_priv, orig_node->bcast_bits, seq_diff, 1))
1064                 orig_node->last_bcast_seqno = seqno;
1065 
1066         spin_unlock_bh(&orig_node->bcast_seqno_lock);
1067 
1068         /* check whether this has been sent by another originator before */
1069         if (batadv_bla_check_bcast_duplist(bat_priv, skb))
1070                 goto out;
1071 
1072         batadv_skb_set_priority(skb, sizeof(struct batadv_bcast_packet));
1073 
1074         /* rebroadcast packet */
1075         batadv_add_bcast_packet_to_list(bat_priv, skb, 1);
1076 
1077         /* don't hand the broadcast up if it is from an originator
1078          * from the same backbone.
1079          */
1080         if (batadv_bla_is_backbone_gw(skb, orig_node, hdr_size))
1081                 goto out;
1082 
1083         if (batadv_dat_snoop_incoming_arp_request(bat_priv, skb, hdr_size))
1084                 goto rx_success;
1085         if (batadv_dat_snoop_incoming_arp_reply(bat_priv, skb, hdr_size))
1086                 goto rx_success;
1087 
1088         /* broadcast for me */
1089         batadv_interface_rx(recv_if->soft_iface, skb, recv_if, hdr_size,
1090                             orig_node);
1091 
1092 rx_success:
1093         ret = NET_RX_SUCCESS;
1094         goto out;
1095 
1096 spin_unlock:
1097         spin_unlock_bh(&orig_node->bcast_seqno_lock);
1098 out:
1099         if (orig_node)
1100                 batadv_orig_node_free_ref(orig_node);
1101         return ret;
1102 }
1103 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp