1 /* Copyright (C) 2011-2016 B.A.T.M.A.N. contributors: 2 * 3 * Antonio Quartulli 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 "distributed-arp-table.h" 19 #include "main.h" 20 21 #include <linux/atomic.h> 22 #include <linux/bitops.h> 23 #include <linux/byteorder/generic.h> 24 #include <linux/errno.h> 25 #include <linux/etherdevice.h> 26 #include <linux/fs.h> 27 #include <linux/if_arp.h> 28 #include <linux/if_ether.h> 29 #include <linux/if_vlan.h> 30 #include <linux/in.h> 31 #include <linux/jiffies.h> 32 #include <linux/kernel.h> 33 #include <linux/list.h> 34 #include <linux/rculist.h> 35 #include <linux/rcupdate.h> 36 #include <linux/seq_file.h> 37 #include <linux/skbuff.h> 38 #include <linux/slab.h> 39 #include <linux/spinlock.h> 40 #include <linux/stddef.h> 41 #include <linux/string.h> 42 #include <linux/workqueue.h> 43 #include <net/arp.h> 44 45 #include "hard-interface.h" 46 #include "hash.h" 47 #include "originator.h" 48 #include "send.h" 49 #include "translation-table.h" 50 51 static void batadv_dat_purge(struct work_struct *work); 52 53 /** 54 * batadv_dat_start_timer - initialise the DAT periodic worker 55 * @bat_priv: the bat priv with all the soft interface information 56 */ 57 static void batadv_dat_start_timer(struct batadv_priv *bat_priv) 58 { 59 INIT_DELAYED_WORK(&bat_priv->dat.work, batadv_dat_purge); 60 queue_delayed_work(batadv_event_workqueue, &bat_priv->dat.work, 61 msecs_to_jiffies(10000)); 62 } 63 64 /** 65 * batadv_dat_entry_free_ref - decrement the dat_entry refcounter and possibly 66 * free it 67 * @dat_entry: the entry to free 68 */ 69 static void batadv_dat_entry_free_ref(struct batadv_dat_entry *dat_entry) 70 { 71 if (atomic_dec_and_test(&dat_entry->refcount)) 72 kfree_rcu(dat_entry, rcu); 73 } 74 75 /** 76 * batadv_dat_to_purge - check whether a dat_entry has to be purged or not 77 * @dat_entry: the entry to check 78 * 79 * Return: true if the entry has to be purged now, false otherwise. 80 */ 81 static bool batadv_dat_to_purge(struct batadv_dat_entry *dat_entry) 82 { 83 return batadv_has_timed_out(dat_entry->last_update, 84 BATADV_DAT_ENTRY_TIMEOUT); 85 } 86 87 /** 88 * __batadv_dat_purge - delete entries from the DAT local storage 89 * @bat_priv: the bat priv with all the soft interface information 90 * @to_purge: function in charge to decide whether an entry has to be purged or 91 * not. This function takes the dat_entry as argument and has to 92 * returns a boolean value: true is the entry has to be deleted, 93 * false otherwise 94 * 95 * Loops over each entry in the DAT local storage and deletes it if and only if 96 * the to_purge function passed as argument returns true. 97 */ 98 static void __batadv_dat_purge(struct batadv_priv *bat_priv, 99 bool (*to_purge)(struct batadv_dat_entry *)) 100 { 101 spinlock_t *list_lock; /* protects write access to the hash lists */ 102 struct batadv_dat_entry *dat_entry; 103 struct hlist_node *node_tmp; 104 struct hlist_head *head; 105 u32 i; 106 107 if (!bat_priv->dat.hash) 108 return; 109 110 for (i = 0; i < bat_priv->dat.hash->size; i++) { 111 head = &bat_priv->dat.hash->table[i]; 112 list_lock = &bat_priv->dat.hash->list_locks[i]; 113 114 spin_lock_bh(list_lock); 115 hlist_for_each_entry_safe(dat_entry, node_tmp, head, 116 hash_entry) { 117 /* if a helper function has been passed as parameter, 118 * ask it if the entry has to be purged or not 119 */ 120 if (to_purge && !to_purge(dat_entry)) 121 continue; 122 123 hlist_del_rcu(&dat_entry->hash_entry); 124 batadv_dat_entry_free_ref(dat_entry); 125 } 126 spin_unlock_bh(list_lock); 127 } 128 } 129 130 /** 131 * batadv_dat_purge - periodic task that deletes old entries from the local DAT 132 * hash table 133 * @work: kernel work struct 134 */ 135 static void batadv_dat_purge(struct work_struct *work) 136 { 137 struct delayed_work *delayed_work; 138 struct batadv_priv_dat *priv_dat; 139 struct batadv_priv *bat_priv; 140 141 delayed_work = container_of(work, struct delayed_work, work); 142 priv_dat = container_of(delayed_work, struct batadv_priv_dat, work); 143 bat_priv = container_of(priv_dat, struct batadv_priv, dat); 144 145 __batadv_dat_purge(bat_priv, batadv_dat_to_purge); 146 batadv_dat_start_timer(bat_priv); 147 } 148 149 /** 150 * batadv_compare_dat - comparing function used in the local DAT hash table 151 * @node: node in the local table 152 * @data2: second object to compare the node to 153 * 154 * Return: 1 if the two entries are the same, 0 otherwise. 155 */ 156 static int batadv_compare_dat(const struct hlist_node *node, const void *data2) 157 { 158 const void *data1 = container_of(node, struct batadv_dat_entry, 159 hash_entry); 160 161 return memcmp(data1, data2, sizeof(__be32)) == 0 ? 1 : 0; 162 } 163 164 /** 165 * batadv_arp_hw_src - extract the hw_src field from an ARP packet 166 * @skb: ARP packet 167 * @hdr_size: size of the possible header before the ARP packet 168 * 169 * Return: the value of the hw_src field in the ARP packet. 170 */ 171 static u8 *batadv_arp_hw_src(struct sk_buff *skb, int hdr_size) 172 { 173 u8 *addr; 174 175 addr = (u8 *)(skb->data + hdr_size); 176 addr += ETH_HLEN + sizeof(struct arphdr); 177 178 return addr; 179 } 180 181 /** 182 * batadv_arp_ip_src - extract the ip_src field from an ARP packet 183 * @skb: ARP packet 184 * @hdr_size: size of the possible header before the ARP packet 185 * 186 * Return: the value of the ip_src field in the ARP packet. 187 */ 188 static __be32 batadv_arp_ip_src(struct sk_buff *skb, int hdr_size) 189 { 190 return *(__be32 *)(batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN); 191 } 192 193 /** 194 * batadv_arp_hw_dst - extract the hw_dst field from an ARP packet 195 * @skb: ARP packet 196 * @hdr_size: size of the possible header before the ARP packet 197 * 198 * Return: the value of the hw_dst field in the ARP packet. 199 */ 200 static u8 *batadv_arp_hw_dst(struct sk_buff *skb, int hdr_size) 201 { 202 return batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN + 4; 203 } 204 205 /** 206 * batadv_arp_ip_dst - extract the ip_dst field from an ARP packet 207 * @skb: ARP packet 208 * @hdr_size: size of the possible header before the ARP packet 209 * 210 * Return: the value of the ip_dst field in the ARP packet. 211 */ 212 static __be32 batadv_arp_ip_dst(struct sk_buff *skb, int hdr_size) 213 { 214 return *(__be32 *)(batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN * 2 + 4); 215 } 216 217 /** 218 * batadv_hash_dat - compute the hash value for an IP address 219 * @data: data to hash 220 * @size: size of the hash table 221 * 222 * Return: the selected index in the hash table for the given data. 223 */ 224 static u32 batadv_hash_dat(const void *data, u32 size) 225 { 226 u32 hash = 0; 227 const struct batadv_dat_entry *dat = data; 228 const unsigned char *key; 229 u32 i; 230 231 key = (const unsigned char *)&dat->ip; 232 for (i = 0; i < sizeof(dat->ip); i++) { 233 hash += key[i]; 234 hash += (hash << 10); 235 hash ^= (hash >> 6); 236 } 237 238 key = (const unsigned char *)&dat->vid; 239 for (i = 0; i < sizeof(dat->vid); i++) { 240 hash += key[i]; 241 hash += (hash << 10); 242 hash ^= (hash >> 6); 243 } 244 245 hash += (hash << 3); 246 hash ^= (hash >> 11); 247 hash += (hash << 15); 248 249 return hash % size; 250 } 251 252 /** 253 * batadv_dat_entry_hash_find - look for a given dat_entry in the local hash 254 * table 255 * @bat_priv: the bat priv with all the soft interface information 256 * @ip: search key 257 * @vid: VLAN identifier 258 * 259 * Return: the dat_entry if found, NULL otherwise. 260 */ 261 static struct batadv_dat_entry * 262 batadv_dat_entry_hash_find(struct batadv_priv *bat_priv, __be32 ip, 263 unsigned short vid) 264 { 265 struct hlist_head *head; 266 struct batadv_dat_entry to_find, *dat_entry, *dat_entry_tmp = NULL; 267 struct batadv_hashtable *hash = bat_priv->dat.hash; 268 u32 index; 269 270 if (!hash) 271 return NULL; 272 273 to_find.ip = ip; 274 to_find.vid = vid; 275 276 index = batadv_hash_dat(&to_find, hash->size); 277 head = &hash->table[index]; 278 279 rcu_read_lock(); 280 hlist_for_each_entry_rcu(dat_entry, head, hash_entry) { 281 if (dat_entry->ip != ip) 282 continue; 283 284 if (!atomic_inc_not_zero(&dat_entry->refcount)) 285 continue; 286 287 dat_entry_tmp = dat_entry; 288 break; 289 } 290 rcu_read_unlock(); 291 292 return dat_entry_tmp; 293 } 294 295 /** 296 * batadv_dat_entry_add - add a new dat entry or update it if already exists 297 * @bat_priv: the bat priv with all the soft interface information 298 * @ip: ipv4 to add/edit 299 * @mac_addr: mac address to assign to the given ipv4 300 * @vid: VLAN identifier 301 */ 302 static void batadv_dat_entry_add(struct batadv_priv *bat_priv, __be32 ip, 303 u8 *mac_addr, unsigned short vid) 304 { 305 struct batadv_dat_entry *dat_entry; 306 int hash_added; 307 308 dat_entry = batadv_dat_entry_hash_find(bat_priv, ip, vid); 309 /* if this entry is already known, just update it */ 310 if (dat_entry) { 311 if (!batadv_compare_eth(dat_entry->mac_addr, mac_addr)) 312 ether_addr_copy(dat_entry->mac_addr, mac_addr); 313 dat_entry->last_update = jiffies; 314 batadv_dbg(BATADV_DBG_DAT, bat_priv, 315 "Entry updated: %pI4 %pM (vid: %d)\n", 316 &dat_entry->ip, dat_entry->mac_addr, 317 BATADV_PRINT_VID(vid)); 318 goto out; 319 } 320 321 dat_entry = kmalloc(sizeof(*dat_entry), GFP_ATOMIC); 322 if (!dat_entry) 323 goto out; 324 325 dat_entry->ip = ip; 326 dat_entry->vid = vid; 327 ether_addr_copy(dat_entry->mac_addr, mac_addr); 328 dat_entry->last_update = jiffies; 329 atomic_set(&dat_entry->refcount, 2); 330 331 hash_added = batadv_hash_add(bat_priv->dat.hash, batadv_compare_dat, 332 batadv_hash_dat, dat_entry, 333 &dat_entry->hash_entry); 334 335 if (unlikely(hash_added != 0)) { 336 /* remove the reference for the hash */ 337 batadv_dat_entry_free_ref(dat_entry); 338 goto out; 339 } 340 341 batadv_dbg(BATADV_DBG_DAT, bat_priv, "New entry added: %pI4 %pM (vid: %d)\n", 342 &dat_entry->ip, dat_entry->mac_addr, BATADV_PRINT_VID(vid)); 343 344 out: 345 if (dat_entry) 346 batadv_dat_entry_free_ref(dat_entry); 347 } 348 349 #ifdef CONFIG_BATMAN_ADV_DEBUG 350 351 /** 352 * batadv_dbg_arp - print a debug message containing all the ARP packet details 353 * @bat_priv: the bat priv with all the soft interface information 354 * @skb: ARP packet 355 * @type: ARP type 356 * @hdr_size: size of the possible header before the ARP packet 357 * @msg: message to print together with the debugging information 358 */ 359 static void batadv_dbg_arp(struct batadv_priv *bat_priv, struct sk_buff *skb, 360 u16 type, int hdr_size, char *msg) 361 { 362 struct batadv_unicast_4addr_packet *unicast_4addr_packet; 363 struct batadv_bcast_packet *bcast_pkt; 364 u8 *orig_addr; 365 __be32 ip_src, ip_dst; 366 367 if (msg) 368 batadv_dbg(BATADV_DBG_DAT, bat_priv, "%s\n", msg); 369 370 ip_src = batadv_arp_ip_src(skb, hdr_size); 371 ip_dst = batadv_arp_ip_dst(skb, hdr_size); 372 batadv_dbg(BATADV_DBG_DAT, bat_priv, 373 "ARP MSG = [src: %pM-%pI4 dst: %pM-%pI4]\n", 374 batadv_arp_hw_src(skb, hdr_size), &ip_src, 375 batadv_arp_hw_dst(skb, hdr_size), &ip_dst); 376 377 if (hdr_size == 0) 378 return; 379 380 unicast_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data; 381 382 switch (unicast_4addr_packet->u.packet_type) { 383 case BATADV_UNICAST: 384 batadv_dbg(BATADV_DBG_DAT, bat_priv, 385 "* encapsulated within a UNICAST packet\n"); 386 break; 387 case BATADV_UNICAST_4ADDR: 388 batadv_dbg(BATADV_DBG_DAT, bat_priv, 389 "* encapsulated within a UNICAST_4ADDR packet (src: %pM)\n", 390 unicast_4addr_packet->src); 391 switch (unicast_4addr_packet->subtype) { 392 case BATADV_P_DAT_DHT_PUT: 393 batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DAT_DHT_PUT\n"); 394 break; 395 case BATADV_P_DAT_DHT_GET: 396 batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DAT_DHT_GET\n"); 397 break; 398 case BATADV_P_DAT_CACHE_REPLY: 399 batadv_dbg(BATADV_DBG_DAT, bat_priv, 400 "* type: DAT_CACHE_REPLY\n"); 401 break; 402 case BATADV_P_DATA: 403 batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DATA\n"); 404 break; 405 default: 406 batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: Unknown (%u)!\n", 407 unicast_4addr_packet->u.packet_type); 408 } 409 break; 410 case BATADV_BCAST: 411 bcast_pkt = (struct batadv_bcast_packet *)unicast_4addr_packet; 412 orig_addr = bcast_pkt->orig; 413 batadv_dbg(BATADV_DBG_DAT, bat_priv, 414 "* encapsulated within a BCAST packet (src: %pM)\n", 415 orig_addr); 416 break; 417 default: 418 batadv_dbg(BATADV_DBG_DAT, bat_priv, 419 "* encapsulated within an unknown packet type (0x%x)\n", 420 unicast_4addr_packet->u.packet_type); 421 } 422 } 423 424 #else 425 426 static void batadv_dbg_arp(struct batadv_priv *bat_priv, struct sk_buff *skb, 427 u16 type, int hdr_size, char *msg) 428 { 429 } 430 431 #endif /* CONFIG_BATMAN_ADV_DEBUG */ 432 433 /** 434 * batadv_is_orig_node_eligible - check whether a node can be a DHT candidate 435 * @res: the array with the already selected candidates 436 * @select: number of already selected candidates 437 * @tmp_max: address of the currently evaluated node 438 * @max: current round max address 439 * @last_max: address of the last selected candidate 440 * @candidate: orig_node under evaluation 441 * @max_orig_node: last selected candidate 442 * 443 * Return: true if the node has been elected as next candidate or false 444 * otherwise. 445 */ 446 static bool batadv_is_orig_node_eligible(struct batadv_dat_candidate *res, 447 int select, batadv_dat_addr_t tmp_max, 448 batadv_dat_addr_t max, 449 batadv_dat_addr_t last_max, 450 struct batadv_orig_node *candidate, 451 struct batadv_orig_node *max_orig_node) 452 { 453 bool ret = false; 454 int j; 455 456 /* check if orig node candidate is running DAT */ 457 if (!test_bit(BATADV_ORIG_CAPA_HAS_DAT, &candidate->capabilities)) 458 goto out; 459 460 /* Check if this node has already been selected... */ 461 for (j = 0; j < select; j++) 462 if (res[j].orig_node == candidate) 463 break; 464 /* ..and possibly skip it */ 465 if (j < select) 466 goto out; 467 /* sanity check: has it already been selected? This should not happen */ 468 if (tmp_max > last_max) 469 goto out; 470 /* check if during this iteration an originator with a closer dht 471 * address has already been found 472 */ 473 if (tmp_max < max) 474 goto out; 475 /* this is an hash collision with the temporary selected node. Choose 476 * the one with the lowest address 477 */ 478 if ((tmp_max == max) && max_orig_node && 479 (batadv_compare_eth(candidate->orig, max_orig_node->orig) > 0)) 480 goto out; 481 482 ret = true; 483 out: 484 return ret; 485 } 486 487 /** 488 * batadv_choose_next_candidate - select the next DHT candidate 489 * @bat_priv: the bat priv with all the soft interface information 490 * @cands: candidates array 491 * @select: number of candidates already present in the array 492 * @ip_key: key to look up in the DHT 493 * @last_max: pointer where the address of the selected candidate will be saved 494 */ 495 static void batadv_choose_next_candidate(struct batadv_priv *bat_priv, 496 struct batadv_dat_candidate *cands, 497 int select, batadv_dat_addr_t ip_key, 498 batadv_dat_addr_t *last_max) 499 { 500 batadv_dat_addr_t max = 0; 501 batadv_dat_addr_t tmp_max = 0; 502 struct batadv_orig_node *orig_node, *max_orig_node = NULL; 503 struct batadv_hashtable *hash = bat_priv->orig_hash; 504 struct hlist_head *head; 505 int i; 506 507 /* if no node is eligible as candidate, leave the candidate type as 508 * NOT_FOUND 509 */ 510 cands[select].type = BATADV_DAT_CANDIDATE_NOT_FOUND; 511 512 /* iterate over the originator list and find the node with the closest 513 * dat_address which has not been selected yet 514 */ 515 for (i = 0; i < hash->size; i++) { 516 head = &hash->table[i]; 517 518 rcu_read_lock(); 519 hlist_for_each_entry_rcu(orig_node, head, hash_entry) { 520 /* the dht space is a ring using unsigned addresses */ 521 tmp_max = BATADV_DAT_ADDR_MAX - orig_node->dat_addr + 522 ip_key; 523 524 if (!batadv_is_orig_node_eligible(cands, select, 525 tmp_max, max, 526 *last_max, orig_node, 527 max_orig_node)) 528 continue; 529 530 if (!atomic_inc_not_zero(&orig_node->refcount)) 531 continue; 532 533 max = tmp_max; 534 if (max_orig_node) 535 batadv_orig_node_free_ref(max_orig_node); 536 max_orig_node = orig_node; 537 } 538 rcu_read_unlock(); 539 } 540 if (max_orig_node) { 541 cands[select].type = BATADV_DAT_CANDIDATE_ORIG; 542 cands[select].orig_node = max_orig_node; 543 batadv_dbg(BATADV_DBG_DAT, bat_priv, 544 "dat_select_candidates() %d: selected %pM addr=%u dist=%u\n", 545 select, max_orig_node->orig, max_orig_node->dat_addr, 546 max); 547 } 548 *last_max = max; 549 } 550 551 /** 552 * batadv_dat_select_candidates - select the nodes which the DHT message has to 553 * be sent to 554 * @bat_priv: the bat priv with all the soft interface information 555 * @ip_dst: ipv4 to look up in the DHT 556 * 557 * An originator O is selected if and only if its DHT_ID value is one of three 558 * closest values (from the LEFT, with wrap around if needed) then the hash 559 * value of the key. ip_dst is the key. 560 * 561 * Return: the candidate array of size BATADV_DAT_CANDIDATE_NUM. 562 */ 563 static struct batadv_dat_candidate * 564 batadv_dat_select_candidates(struct batadv_priv *bat_priv, __be32 ip_dst) 565 { 566 int select; 567 batadv_dat_addr_t last_max = BATADV_DAT_ADDR_MAX, ip_key; 568 struct batadv_dat_candidate *res; 569 struct batadv_dat_entry dat; 570 571 if (!bat_priv->orig_hash) 572 return NULL; 573 574 res = kmalloc_array(BATADV_DAT_CANDIDATES_NUM, sizeof(*res), 575 GFP_ATOMIC); 576 if (!res) 577 return NULL; 578 579 dat.ip = ip_dst; 580 dat.vid = 0; 581 ip_key = (batadv_dat_addr_t)batadv_hash_dat(&dat, 582 BATADV_DAT_ADDR_MAX); 583 584 batadv_dbg(BATADV_DBG_DAT, bat_priv, 585 "dat_select_candidates(): IP=%pI4 hash(IP)=%u\n", &ip_dst, 586 ip_key); 587 588 for (select = 0; select < BATADV_DAT_CANDIDATES_NUM; select++) 589 batadv_choose_next_candidate(bat_priv, res, select, ip_key, 590 &last_max); 591 592 return res; 593 } 594 595 /** 596 * batadv_dat_send_data - send a payload to the selected candidates 597 * @bat_priv: the bat priv with all the soft interface information 598 * @skb: payload to send 599 * @ip: the DHT key 600 * @packet_subtype: unicast4addr packet subtype to use 601 * 602 * This function copies the skb with pskb_copy() and is sent as unicast packet 603 * to each of the selected candidates. 604 * 605 * Return: true if the packet is sent to at least one candidate, false 606 * otherwise. 607 */ 608 static bool batadv_dat_send_data(struct batadv_priv *bat_priv, 609 struct sk_buff *skb, __be32 ip, 610 int packet_subtype) 611 { 612 int i; 613 bool ret = false; 614 int send_status; 615 struct batadv_neigh_node *neigh_node = NULL; 616 struct sk_buff *tmp_skb; 617 struct batadv_dat_candidate *cand; 618 619 cand = batadv_dat_select_candidates(bat_priv, ip); 620 if (!cand) 621 goto out; 622 623 batadv_dbg(BATADV_DBG_DAT, bat_priv, "DHT_SEND for %pI4\n", &ip); 624 625 for (i = 0; i < BATADV_DAT_CANDIDATES_NUM; i++) { 626 if (cand[i].type == BATADV_DAT_CANDIDATE_NOT_FOUND) 627 continue; 628 629 neigh_node = batadv_orig_router_get(cand[i].orig_node, 630 BATADV_IF_DEFAULT); 631 if (!neigh_node) 632 goto free_orig; 633 634 tmp_skb = pskb_copy_for_clone(skb, GFP_ATOMIC); 635 if (!batadv_send_skb_prepare_unicast_4addr(bat_priv, tmp_skb, 636 cand[i].orig_node, 637 packet_subtype)) { 638 kfree_skb(tmp_skb); 639 goto free_neigh; 640 } 641 642 send_status = batadv_send_skb_packet(tmp_skb, 643 neigh_node->if_incoming, 644 neigh_node->addr); 645 if (send_status == NET_XMIT_SUCCESS) { 646 /* count the sent packet */ 647 switch (packet_subtype) { 648 case BATADV_P_DAT_DHT_GET: 649 batadv_inc_counter(bat_priv, 650 BATADV_CNT_DAT_GET_TX); 651 break; 652 case BATADV_P_DAT_DHT_PUT: 653 batadv_inc_counter(bat_priv, 654 BATADV_CNT_DAT_PUT_TX); 655 break; 656 } 657 658 /* packet sent to a candidate: return true */ 659 ret = true; 660 } 661 free_neigh: 662 batadv_neigh_node_free_ref(neigh_node); 663 free_orig: 664 batadv_orig_node_free_ref(cand[i].orig_node); 665 } 666 667 out: 668 kfree(cand); 669 return ret; 670 } 671 672 /** 673 * batadv_dat_tvlv_container_update - update the dat tvlv container after dat 674 * setting change 675 * @bat_priv: the bat priv with all the soft interface information 676 */ 677 static void batadv_dat_tvlv_container_update(struct batadv_priv *bat_priv) 678 { 679 char dat_mode; 680 681 dat_mode = atomic_read(&bat_priv->distributed_arp_table); 682 683 switch (dat_mode) { 684 case 0: 685 batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_DAT, 1); 686 break; 687 case 1: 688 batadv_tvlv_container_register(bat_priv, BATADV_TVLV_DAT, 1, 689 NULL, 0); 690 break; 691 } 692 } 693 694 /** 695 * batadv_dat_status_update - update the dat tvlv container after dat 696 * setting change 697 * @net_dev: the soft interface net device 698 */ 699 void batadv_dat_status_update(struct net_device *net_dev) 700 { 701 struct batadv_priv *bat_priv = netdev_priv(net_dev); 702 703 batadv_dat_tvlv_container_update(bat_priv); 704 } 705 706 /** 707 * batadv_gw_tvlv_ogm_handler_v1 - process incoming dat tvlv container 708 * @bat_priv: the bat priv with all the soft interface information 709 * @orig: the orig_node of the ogm 710 * @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags) 711 * @tvlv_value: tvlv buffer containing the gateway data 712 * @tvlv_value_len: tvlv buffer length 713 */ 714 static void batadv_dat_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv, 715 struct batadv_orig_node *orig, 716 u8 flags, 717 void *tvlv_value, u16 tvlv_value_len) 718 { 719 if (flags & BATADV_TVLV_HANDLER_OGM_CIFNOTFND) 720 clear_bit(BATADV_ORIG_CAPA_HAS_DAT, &orig->capabilities); 721 else 722 set_bit(BATADV_ORIG_CAPA_HAS_DAT, &orig->capabilities); 723 } 724 725 /** 726 * batadv_dat_hash_free - free the local DAT hash table 727 * @bat_priv: the bat priv with all the soft interface information 728 */ 729 static void batadv_dat_hash_free(struct batadv_priv *bat_priv) 730 { 731 if (!bat_priv->dat.hash) 732 return; 733 734 __batadv_dat_purge(bat_priv, NULL); 735 736 batadv_hash_destroy(bat_priv->dat.hash); 737 738 bat_priv->dat.hash = NULL; 739 } 740 741 /** 742 * batadv_dat_init - initialise the DAT internals 743 * @bat_priv: the bat priv with all the soft interface information 744 * 745 * Return: 0 in case of success, a negative error code otherwise 746 */ 747 int batadv_dat_init(struct batadv_priv *bat_priv) 748 { 749 if (bat_priv->dat.hash) 750 return 0; 751 752 bat_priv->dat.hash = batadv_hash_new(1024); 753 754 if (!bat_priv->dat.hash) 755 return -ENOMEM; 756 757 batadv_dat_start_timer(bat_priv); 758 759 batadv_tvlv_handler_register(bat_priv, batadv_dat_tvlv_ogm_handler_v1, 760 NULL, BATADV_TVLV_DAT, 1, 761 BATADV_TVLV_HANDLER_OGM_CIFNOTFND); 762 batadv_dat_tvlv_container_update(bat_priv); 763 return 0; 764 } 765 766 /** 767 * batadv_dat_free - free the DAT internals 768 * @bat_priv: the bat priv with all the soft interface information 769 */ 770 void batadv_dat_free(struct batadv_priv *bat_priv) 771 { 772 batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_DAT, 1); 773 batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_DAT, 1); 774 775 cancel_delayed_work_sync(&bat_priv->dat.work); 776 777 batadv_dat_hash_free(bat_priv); 778 } 779 780 /** 781 * batadv_dat_cache_seq_print_text - print the local DAT hash table 782 * @seq: seq file to print on 783 * @offset: not used 784 * 785 * Return: always 0 786 */ 787 int batadv_dat_cache_seq_print_text(struct seq_file *seq, void *offset) 788 { 789 struct net_device *net_dev = (struct net_device *)seq->private; 790 struct batadv_priv *bat_priv = netdev_priv(net_dev); 791 struct batadv_hashtable *hash = bat_priv->dat.hash; 792 struct batadv_dat_entry *dat_entry; 793 struct batadv_hard_iface *primary_if; 794 struct hlist_head *head; 795 unsigned long last_seen_jiffies; 796 int last_seen_msecs, last_seen_secs, last_seen_mins; 797 u32 i; 798 799 primary_if = batadv_seq_print_text_primary_if_get(seq); 800 if (!primary_if) 801 goto out; 802 803 seq_printf(seq, "Distributed ARP Table (%s):\n", net_dev->name); 804 seq_printf(seq, " %-7s %-9s %4s %11s\n", "IPv4", 805 "MAC", "VID", "last-seen"); 806 807 for (i = 0; i < hash->size; i++) { 808 head = &hash->table[i]; 809 810 rcu_read_lock(); 811 hlist_for_each_entry_rcu(dat_entry, head, hash_entry) { 812 last_seen_jiffies = jiffies - dat_entry->last_update; 813 last_seen_msecs = jiffies_to_msecs(last_seen_jiffies); 814 last_seen_mins = last_seen_msecs / 60000; 815 last_seen_msecs = last_seen_msecs % 60000; 816 last_seen_secs = last_seen_msecs / 1000; 817 818 seq_printf(seq, " * %15pI4 %14pM %4i %6i:%02i\n", 819 &dat_entry->ip, dat_entry->mac_addr, 820 BATADV_PRINT_VID(dat_entry->vid), 821 last_seen_mins, last_seen_secs); 822 } 823 rcu_read_unlock(); 824 } 825 826 out: 827 if (primary_if) 828 batadv_hardif_free_ref(primary_if); 829 return 0; 830 } 831 832 /** 833 * batadv_arp_get_type - parse an ARP packet and gets the type 834 * @bat_priv: the bat priv with all the soft interface information 835 * @skb: packet to analyse 836 * @hdr_size: size of the possible header before the ARP packet in the skb 837 * 838 * Return: the ARP type if the skb contains a valid ARP packet, 0 otherwise. 839 */ 840 static u16 batadv_arp_get_type(struct batadv_priv *bat_priv, 841 struct sk_buff *skb, int hdr_size) 842 { 843 struct arphdr *arphdr; 844 struct ethhdr *ethhdr; 845 __be32 ip_src, ip_dst; 846 u8 *hw_src, *hw_dst; 847 u16 type = 0; 848 849 /* pull the ethernet header */ 850 if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN))) 851 goto out; 852 853 ethhdr = (struct ethhdr *)(skb->data + hdr_size); 854 855 if (ethhdr->h_proto != htons(ETH_P_ARP)) 856 goto out; 857 858 /* pull the ARP payload */ 859 if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN + 860 arp_hdr_len(skb->dev)))) 861 goto out; 862 863 arphdr = (struct arphdr *)(skb->data + hdr_size + ETH_HLEN); 864 865 /* check whether the ARP packet carries a valid IP information */ 866 if (arphdr->ar_hrd != htons(ARPHRD_ETHER)) 867 goto out; 868 869 if (arphdr->ar_pro != htons(ETH_P_IP)) 870 goto out; 871 872 if (arphdr->ar_hln != ETH_ALEN) 873 goto out; 874 875 if (arphdr->ar_pln != 4) 876 goto out; 877 878 /* Check for bad reply/request. If the ARP message is not sane, DAT 879 * will simply ignore it 880 */ 881 ip_src = batadv_arp_ip_src(skb, hdr_size); 882 ip_dst = batadv_arp_ip_dst(skb, hdr_size); 883 if (ipv4_is_loopback(ip_src) || ipv4_is_multicast(ip_src) || 884 ipv4_is_loopback(ip_dst) || ipv4_is_multicast(ip_dst) || 885 ipv4_is_zeronet(ip_src) || ipv4_is_lbcast(ip_src) || 886 ipv4_is_zeronet(ip_dst) || ipv4_is_lbcast(ip_dst)) 887 goto out; 888 889 hw_src = batadv_arp_hw_src(skb, hdr_size); 890 if (is_zero_ether_addr(hw_src) || is_multicast_ether_addr(hw_src)) 891 goto out; 892 893 /* don't care about the destination MAC address in ARP requests */ 894 if (arphdr->ar_op != htons(ARPOP_REQUEST)) { 895 hw_dst = batadv_arp_hw_dst(skb, hdr_size); 896 if (is_zero_ether_addr(hw_dst) || 897 is_multicast_ether_addr(hw_dst)) 898 goto out; 899 } 900 901 type = ntohs(arphdr->ar_op); 902 out: 903 return type; 904 } 905 906 /** 907 * batadv_dat_get_vid - extract the VLAN identifier from skb if any 908 * @skb: the buffer containing the packet to extract the VID from 909 * @hdr_size: the size of the batman-adv header encapsulating the packet 910 * 911 * Return: If the packet embedded in the skb is vlan tagged this function 912 * returns the VID with the BATADV_VLAN_HAS_TAG flag. Otherwise BATADV_NO_FLAGS 913 * is returned. 914 */ 915 static unsigned short batadv_dat_get_vid(struct sk_buff *skb, int *hdr_size) 916 { 917 unsigned short vid; 918 919 vid = batadv_get_vid(skb, *hdr_size); 920 921 /* ARP parsing functions jump forward of hdr_size + ETH_HLEN. 922 * If the header contained in the packet is a VLAN one (which is longer) 923 * hdr_size is updated so that the functions will still skip the 924 * correct amount of bytes. 925 */ 926 if (vid & BATADV_VLAN_HAS_TAG) 927 *hdr_size += VLAN_HLEN; 928 929 return vid; 930 } 931 932 /** 933 * batadv_dat_snoop_outgoing_arp_request - snoop the ARP request and try to 934 * answer using DAT 935 * @bat_priv: the bat priv with all the soft interface information 936 * @skb: packet to check 937 * 938 * Return: true if the message has been sent to the dht candidates, false 939 * otherwise. In case of a positive return value the message has to be enqueued 940 * to permit the fallback. 941 */ 942 bool batadv_dat_snoop_outgoing_arp_request(struct batadv_priv *bat_priv, 943 struct sk_buff *skb) 944 { 945 u16 type = 0; 946 __be32 ip_dst, ip_src; 947 u8 *hw_src; 948 bool ret = false; 949 struct batadv_dat_entry *dat_entry = NULL; 950 struct sk_buff *skb_new; 951 int hdr_size = 0; 952 unsigned short vid; 953 954 if (!atomic_read(&bat_priv->distributed_arp_table)) 955 goto out; 956 957 vid = batadv_dat_get_vid(skb, &hdr_size); 958 959 type = batadv_arp_get_type(bat_priv, skb, hdr_size); 960 /* If the node gets an ARP_REQUEST it has to send a DHT_GET unicast 961 * message to the selected DHT candidates 962 */ 963 if (type != ARPOP_REQUEST) 964 goto out; 965 966 batadv_dbg_arp(bat_priv, skb, type, hdr_size, 967 "Parsing outgoing ARP REQUEST"); 968 969 ip_src = batadv_arp_ip_src(skb, hdr_size); 970 hw_src = batadv_arp_hw_src(skb, hdr_size); 971 ip_dst = batadv_arp_ip_dst(skb, hdr_size); 972 973 batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid); 974 975 dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid); 976 if (dat_entry) { 977 /* If the ARP request is destined for a local client the local 978 * client will answer itself. DAT would only generate a 979 * duplicate packet. 980 * 981 * Moreover, if the soft-interface is enslaved into a bridge, an 982 * additional DAT answer may trigger kernel warnings about 983 * a packet coming from the wrong port. 984 */ 985 if (batadv_is_my_client(bat_priv, dat_entry->mac_addr, vid)) { 986 ret = true; 987 goto out; 988 } 989 990 skb_new = arp_create(ARPOP_REPLY, ETH_P_ARP, ip_src, 991 bat_priv->soft_iface, ip_dst, hw_src, 992 dat_entry->mac_addr, hw_src); 993 if (!skb_new) 994 goto out; 995 996 if (vid & BATADV_VLAN_HAS_TAG) 997 skb_new = vlan_insert_tag(skb_new, htons(ETH_P_8021Q), 998 vid & VLAN_VID_MASK); 999 1000 skb_reset_mac_header(skb_new); 1001 skb_new->protocol = eth_type_trans(skb_new, 1002 bat_priv->soft_iface); 1003 bat_priv->stats.rx_packets++; 1004 bat_priv->stats.rx_bytes += skb->len + ETH_HLEN + hdr_size; 1005 bat_priv->soft_iface->last_rx = jiffies; 1006 1007 netif_rx(skb_new); 1008 batadv_dbg(BATADV_DBG_DAT, bat_priv, "ARP request replied locally\n"); 1009 ret = true; 1010 } else { 1011 /* Send the request to the DHT */ 1012 ret = batadv_dat_send_data(bat_priv, skb, ip_dst, 1013 BATADV_P_DAT_DHT_GET); 1014 } 1015 out: 1016 if (dat_entry) 1017 batadv_dat_entry_free_ref(dat_entry); 1018 return ret; 1019 } 1020 1021 /** 1022 * batadv_dat_snoop_incoming_arp_request - snoop the ARP request and try to 1023 * answer using the local DAT storage 1024 * @bat_priv: the bat priv with all the soft interface information 1025 * @skb: packet to check 1026 * @hdr_size: size of the encapsulation header 1027 * 1028 * Return: true if the request has been answered, false otherwise. 1029 */ 1030 bool batadv_dat_snoop_incoming_arp_request(struct batadv_priv *bat_priv, 1031 struct sk_buff *skb, int hdr_size) 1032 { 1033 u16 type; 1034 __be32 ip_src, ip_dst; 1035 u8 *hw_src; 1036 struct sk_buff *skb_new; 1037 struct batadv_dat_entry *dat_entry = NULL; 1038 bool ret = false; 1039 unsigned short vid; 1040 int err; 1041 1042 if (!atomic_read(&bat_priv->distributed_arp_table)) 1043 goto out; 1044 1045 vid = batadv_dat_get_vid(skb, &hdr_size); 1046 1047 type = batadv_arp_get_type(bat_priv, skb, hdr_size); 1048 if (type != ARPOP_REQUEST) 1049 goto out; 1050 1051 hw_src = batadv_arp_hw_src(skb, hdr_size); 1052 ip_src = batadv_arp_ip_src(skb, hdr_size); 1053 ip_dst = batadv_arp_ip_dst(skb, hdr_size); 1054 1055 batadv_dbg_arp(bat_priv, skb, type, hdr_size, 1056 "Parsing incoming ARP REQUEST"); 1057 1058 batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid); 1059 1060 dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid); 1061 if (!dat_entry) 1062 goto out; 1063 1064 skb_new = arp_create(ARPOP_REPLY, ETH_P_ARP, ip_src, 1065 bat_priv->soft_iface, ip_dst, hw_src, 1066 dat_entry->mac_addr, hw_src); 1067 1068 if (!skb_new) 1069 goto out; 1070 1071 /* the rest of the TX path assumes that the mac_header offset pointing 1072 * to the inner Ethernet header has been set, therefore reset it now. 1073 */ 1074 skb_reset_mac_header(skb_new); 1075 1076 if (vid & BATADV_VLAN_HAS_TAG) 1077 skb_new = vlan_insert_tag(skb_new, htons(ETH_P_8021Q), 1078 vid & VLAN_VID_MASK); 1079 1080 /* To preserve backwards compatibility, the node has choose the outgoing 1081 * format based on the incoming request packet type. The assumption is 1082 * that a node not using the 4addr packet format doesn't support it. 1083 */ 1084 if (hdr_size == sizeof(struct batadv_unicast_4addr_packet)) 1085 err = batadv_send_skb_via_tt_4addr(bat_priv, skb_new, 1086 BATADV_P_DAT_CACHE_REPLY, 1087 NULL, vid); 1088 else 1089 err = batadv_send_skb_via_tt(bat_priv, skb_new, NULL, vid); 1090 1091 if (err != NET_XMIT_DROP) { 1092 batadv_inc_counter(bat_priv, BATADV_CNT_DAT_CACHED_REPLY_TX); 1093 ret = true; 1094 } 1095 out: 1096 if (dat_entry) 1097 batadv_dat_entry_free_ref(dat_entry); 1098 if (ret) 1099 kfree_skb(skb); 1100 return ret; 1101 } 1102 1103 /** 1104 * batadv_dat_snoop_outgoing_arp_reply - snoop the ARP reply and fill the DHT 1105 * @bat_priv: the bat priv with all the soft interface information 1106 * @skb: packet to check 1107 */ 1108 void batadv_dat_snoop_outgoing_arp_reply(struct batadv_priv *bat_priv, 1109 struct sk_buff *skb) 1110 { 1111 u16 type; 1112 __be32 ip_src, ip_dst; 1113 u8 *hw_src, *hw_dst; 1114 int hdr_size = 0; 1115 unsigned short vid; 1116 1117 if (!atomic_read(&bat_priv->distributed_arp_table)) 1118 return; 1119 1120 vid = batadv_dat_get_vid(skb, &hdr_size); 1121 1122 type = batadv_arp_get_type(bat_priv, skb, hdr_size); 1123 if (type != ARPOP_REPLY) 1124 return; 1125 1126 batadv_dbg_arp(bat_priv, skb, type, hdr_size, 1127 "Parsing outgoing ARP REPLY"); 1128 1129 hw_src = batadv_arp_hw_src(skb, hdr_size); 1130 ip_src = batadv_arp_ip_src(skb, hdr_size); 1131 hw_dst = batadv_arp_hw_dst(skb, hdr_size); 1132 ip_dst = batadv_arp_ip_dst(skb, hdr_size); 1133 1134 batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid); 1135 batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid); 1136 1137 /* Send the ARP reply to the candidates for both the IP addresses that 1138 * the node obtained from the ARP reply 1139 */ 1140 batadv_dat_send_data(bat_priv, skb, ip_src, BATADV_P_DAT_DHT_PUT); 1141 batadv_dat_send_data(bat_priv, skb, ip_dst, BATADV_P_DAT_DHT_PUT); 1142 } 1143 1144 /** 1145 * batadv_dat_snoop_incoming_arp_reply - snoop the ARP reply and fill the local 1146 * DAT storage only 1147 * @bat_priv: the bat priv with all the soft interface information 1148 * @skb: packet to check 1149 * @hdr_size: size of the encapsulation header 1150 * 1151 * Return: true if the packet was snooped and consumed by DAT. False if the 1152 * packet has to be delivered to the interface 1153 */ 1154 bool batadv_dat_snoop_incoming_arp_reply(struct batadv_priv *bat_priv, 1155 struct sk_buff *skb, int hdr_size) 1156 { 1157 u16 type; 1158 __be32 ip_src, ip_dst; 1159 u8 *hw_src, *hw_dst; 1160 bool dropped = false; 1161 unsigned short vid; 1162 1163 if (!atomic_read(&bat_priv->distributed_arp_table)) 1164 goto out; 1165 1166 vid = batadv_dat_get_vid(skb, &hdr_size); 1167 1168 type = batadv_arp_get_type(bat_priv, skb, hdr_size); 1169 if (type != ARPOP_REPLY) 1170 goto out; 1171 1172 batadv_dbg_arp(bat_priv, skb, type, hdr_size, 1173 "Parsing incoming ARP REPLY"); 1174 1175 hw_src = batadv_arp_hw_src(skb, hdr_size); 1176 ip_src = batadv_arp_ip_src(skb, hdr_size); 1177 hw_dst = batadv_arp_hw_dst(skb, hdr_size); 1178 ip_dst = batadv_arp_ip_dst(skb, hdr_size); 1179 1180 /* Update our internal cache with both the IP addresses the node got 1181 * within the ARP reply 1182 */ 1183 batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid); 1184 batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid); 1185 1186 /* if this REPLY is directed to a client of mine, let's deliver the 1187 * packet to the interface 1188 */ 1189 dropped = !batadv_is_my_client(bat_priv, hw_dst, vid); 1190 1191 /* if this REPLY is sent on behalf of a client of mine, let's drop the 1192 * packet because the client will reply by itself 1193 */ 1194 dropped |= batadv_is_my_client(bat_priv, hw_src, vid); 1195 out: 1196 if (dropped) 1197 kfree_skb(skb); 1198 /* if dropped == false -> deliver to the interface */ 1199 return dropped; 1200 } 1201 1202 /** 1203 * batadv_dat_drop_broadcast_packet - check if an ARP request has to be dropped 1204 * (because the node has already obtained the reply via DAT) or not 1205 * @bat_priv: the bat priv with all the soft interface information 1206 * @forw_packet: the broadcast packet 1207 * 1208 * Return: true if the node can drop the packet, false otherwise. 1209 */ 1210 bool batadv_dat_drop_broadcast_packet(struct batadv_priv *bat_priv, 1211 struct batadv_forw_packet *forw_packet) 1212 { 1213 u16 type; 1214 __be32 ip_dst; 1215 struct batadv_dat_entry *dat_entry = NULL; 1216 bool ret = false; 1217 int hdr_size = sizeof(struct batadv_bcast_packet); 1218 unsigned short vid; 1219 1220 if (!atomic_read(&bat_priv->distributed_arp_table)) 1221 goto out; 1222 1223 /* If this packet is an ARP_REQUEST and the node already has the 1224 * information that it is going to ask, then the packet can be dropped 1225 */ 1226 if (forw_packet->num_packets) 1227 goto out; 1228 1229 vid = batadv_dat_get_vid(forw_packet->skb, &hdr_size); 1230 1231 type = batadv_arp_get_type(bat_priv, forw_packet->skb, hdr_size); 1232 if (type != ARPOP_REQUEST) 1233 goto out; 1234 1235 ip_dst = batadv_arp_ip_dst(forw_packet->skb, hdr_size); 1236 dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid); 1237 /* check if the node already got this entry */ 1238 if (!dat_entry) { 1239 batadv_dbg(BATADV_DBG_DAT, bat_priv, 1240 "ARP Request for %pI4: fallback\n", &ip_dst); 1241 goto out; 1242 } 1243 1244 batadv_dbg(BATADV_DBG_DAT, bat_priv, 1245 "ARP Request for %pI4: fallback prevented\n", &ip_dst); 1246 ret = true; 1247 1248 out: 1249 if (dat_entry) 1250 batadv_dat_entry_free_ref(dat_entry); 1251 return ret; 1252 } 1253