1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (C) 2011-2020 B.A.T.M.A.N. contributors: 3 * 4 * Antonio Quartulli 5 */ 6 7 #include "distributed-arp-table.h" 8 #include "main.h" 9 10 #include <asm/unaligned.h> 11 #include <linux/atomic.h> 12 #include <linux/bitops.h> 13 #include <linux/byteorder/generic.h> 14 #include <linux/errno.h> 15 #include <linux/etherdevice.h> 16 #include <linux/gfp.h> 17 #include <linux/if_arp.h> 18 #include <linux/if_ether.h> 19 #include <linux/if_vlan.h> 20 #include <linux/in.h> 21 #include <linux/ip.h> 22 #include <linux/jiffies.h> 23 #include <linux/kernel.h> 24 #include <linux/kref.h> 25 #include <linux/list.h> 26 #include <linux/netlink.h> 27 #include <linux/rculist.h> 28 #include <linux/rcupdate.h> 29 #include <linux/skbuff.h> 30 #include <linux/slab.h> 31 #include <linux/spinlock.h> 32 #include <linux/stddef.h> 33 #include <linux/string.h> 34 #include <linux/udp.h> 35 #include <linux/workqueue.h> 36 #include <net/arp.h> 37 #include <net/genetlink.h> 38 #include <net/netlink.h> 39 #include <net/sock.h> 40 #include <uapi/linux/batman_adv.h> 41 42 #include "bridge_loop_avoidance.h" 43 #include "hard-interface.h" 44 #include "hash.h" 45 #include "log.h" 46 #include "netlink.h" 47 #include "originator.h" 48 #include "send.h" 49 #include "soft-interface.h" 50 #include "translation-table.h" 51 #include "tvlv.h" 52 53 enum batadv_bootpop { 54 BATADV_BOOTREPLY = 2, 55 }; 56 57 enum batadv_boothtype { 58 BATADV_HTYPE_ETHERNET = 1, 59 }; 60 61 enum batadv_dhcpoptioncode { 62 BATADV_DHCP_OPT_PAD = 0, 63 BATADV_DHCP_OPT_MSG_TYPE = 53, 64 BATADV_DHCP_OPT_END = 255, 65 }; 66 67 enum batadv_dhcptype { 68 BATADV_DHCPACK = 5, 69 }; 70 71 /* { 99, 130, 83, 99 } */ 72 #define BATADV_DHCP_MAGIC 1669485411 73 74 struct batadv_dhcp_packet { 75 __u8 op; 76 __u8 htype; 77 __u8 hlen; 78 __u8 hops; 79 __be32 xid; 80 __be16 secs; 81 __be16 flags; 82 __be32 ciaddr; 83 __be32 yiaddr; 84 __be32 siaddr; 85 __be32 giaddr; 86 __u8 chaddr[16]; 87 __u8 sname[64]; 88 __u8 file[128]; 89 __be32 magic; 90 __u8 options[]; 91 }; 92 93 #define BATADV_DHCP_YIADDR_LEN sizeof(((struct batadv_dhcp_packet *)0)->yiaddr) 94 #define BATADV_DHCP_CHADDR_LEN sizeof(((struct batadv_dhcp_packet *)0)->chaddr) 95 96 static void batadv_dat_purge(struct work_struct *work); 97 98 /** 99 * batadv_dat_start_timer() - initialise the DAT periodic worker 100 * @bat_priv: the bat priv with all the soft interface information 101 */ 102 static void batadv_dat_start_timer(struct batadv_priv *bat_priv) 103 { 104 INIT_DELAYED_WORK(&bat_priv->dat.work, batadv_dat_purge); 105 queue_delayed_work(batadv_event_workqueue, &bat_priv->dat.work, 106 msecs_to_jiffies(10000)); 107 } 108 109 /** 110 * batadv_dat_entry_release() - release dat_entry from lists and queue for free 111 * after rcu grace period 112 * @ref: kref pointer of the dat_entry 113 */ 114 static void batadv_dat_entry_release(struct kref *ref) 115 { 116 struct batadv_dat_entry *dat_entry; 117 118 dat_entry = container_of(ref, struct batadv_dat_entry, refcount); 119 120 kfree_rcu(dat_entry, rcu); 121 } 122 123 /** 124 * batadv_dat_entry_put() - decrement the dat_entry refcounter and possibly 125 * release it 126 * @dat_entry: dat_entry to be free'd 127 */ 128 static void batadv_dat_entry_put(struct batadv_dat_entry *dat_entry) 129 { 130 kref_put(&dat_entry->refcount, batadv_dat_entry_release); 131 } 132 133 /** 134 * batadv_dat_to_purge() - check whether a dat_entry has to be purged or not 135 * @dat_entry: the entry to check 136 * 137 * Return: true if the entry has to be purged now, false otherwise. 138 */ 139 static bool batadv_dat_to_purge(struct batadv_dat_entry *dat_entry) 140 { 141 return batadv_has_timed_out(dat_entry->last_update, 142 BATADV_DAT_ENTRY_TIMEOUT); 143 } 144 145 /** 146 * __batadv_dat_purge() - delete entries from the DAT local storage 147 * @bat_priv: the bat priv with all the soft interface information 148 * @to_purge: function in charge to decide whether an entry has to be purged or 149 * not. This function takes the dat_entry as argument and has to 150 * returns a boolean value: true is the entry has to be deleted, 151 * false otherwise 152 * 153 * Loops over each entry in the DAT local storage and deletes it if and only if 154 * the to_purge function passed as argument returns true. 155 */ 156 static void __batadv_dat_purge(struct batadv_priv *bat_priv, 157 bool (*to_purge)(struct batadv_dat_entry *)) 158 { 159 spinlock_t *list_lock; /* protects write access to the hash lists */ 160 struct batadv_dat_entry *dat_entry; 161 struct hlist_node *node_tmp; 162 struct hlist_head *head; 163 u32 i; 164 165 if (!bat_priv->dat.hash) 166 return; 167 168 for (i = 0; i < bat_priv->dat.hash->size; i++) { 169 head = &bat_priv->dat.hash->table[i]; 170 list_lock = &bat_priv->dat.hash->list_locks[i]; 171 172 spin_lock_bh(list_lock); 173 hlist_for_each_entry_safe(dat_entry, node_tmp, head, 174 hash_entry) { 175 /* if a helper function has been passed as parameter, 176 * ask it if the entry has to be purged or not 177 */ 178 if (to_purge && !to_purge(dat_entry)) 179 continue; 180 181 hlist_del_rcu(&dat_entry->hash_entry); 182 batadv_dat_entry_put(dat_entry); 183 } 184 spin_unlock_bh(list_lock); 185 } 186 } 187 188 /** 189 * batadv_dat_purge() - periodic task that deletes old entries from the local 190 * DAT hash table 191 * @work: kernel work struct 192 */ 193 static void batadv_dat_purge(struct work_struct *work) 194 { 195 struct delayed_work *delayed_work; 196 struct batadv_priv_dat *priv_dat; 197 struct batadv_priv *bat_priv; 198 199 delayed_work = to_delayed_work(work); 200 priv_dat = container_of(delayed_work, struct batadv_priv_dat, work); 201 bat_priv = container_of(priv_dat, struct batadv_priv, dat); 202 203 __batadv_dat_purge(bat_priv, batadv_dat_to_purge); 204 batadv_dat_start_timer(bat_priv); 205 } 206 207 /** 208 * batadv_compare_dat() - comparing function used in the local DAT hash table 209 * @node: node in the local table 210 * @data2: second object to compare the node to 211 * 212 * Return: true if the two entries are the same, false otherwise. 213 */ 214 static bool batadv_compare_dat(const struct hlist_node *node, const void *data2) 215 { 216 const void *data1 = container_of(node, struct batadv_dat_entry, 217 hash_entry); 218 219 return memcmp(data1, data2, sizeof(__be32)) == 0; 220 } 221 222 /** 223 * batadv_arp_hw_src() - extract the hw_src field from an ARP packet 224 * @skb: ARP packet 225 * @hdr_size: size of the possible header before the ARP packet 226 * 227 * Return: the value of the hw_src field in the ARP packet. 228 */ 229 static u8 *batadv_arp_hw_src(struct sk_buff *skb, int hdr_size) 230 { 231 u8 *addr; 232 233 addr = (u8 *)(skb->data + hdr_size); 234 addr += ETH_HLEN + sizeof(struct arphdr); 235 236 return addr; 237 } 238 239 /** 240 * batadv_arp_ip_src() - extract the ip_src field from an ARP packet 241 * @skb: ARP packet 242 * @hdr_size: size of the possible header before the ARP packet 243 * 244 * Return: the value of the ip_src field in the ARP packet. 245 */ 246 static __be32 batadv_arp_ip_src(struct sk_buff *skb, int hdr_size) 247 { 248 return *(__force __be32 *)(batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN); 249 } 250 251 /** 252 * batadv_arp_hw_dst() - extract the hw_dst field from an ARP packet 253 * @skb: ARP packet 254 * @hdr_size: size of the possible header before the ARP packet 255 * 256 * Return: the value of the hw_dst field in the ARP packet. 257 */ 258 static u8 *batadv_arp_hw_dst(struct sk_buff *skb, int hdr_size) 259 { 260 return batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN + 4; 261 } 262 263 /** 264 * batadv_arp_ip_dst() - extract the ip_dst field from an ARP packet 265 * @skb: ARP packet 266 * @hdr_size: size of the possible header before the ARP packet 267 * 268 * Return: the value of the ip_dst field in the ARP packet. 269 */ 270 static __be32 batadv_arp_ip_dst(struct sk_buff *skb, int hdr_size) 271 { 272 u8 *dst = batadv_arp_hw_src(skb, hdr_size) + ETH_ALEN * 2 + 4; 273 274 return *(__force __be32 *)dst; 275 } 276 277 /** 278 * batadv_hash_dat() - compute the hash value for an IP address 279 * @data: data to hash 280 * @size: size of the hash table 281 * 282 * Return: the selected index in the hash table for the given data. 283 */ 284 static u32 batadv_hash_dat(const void *data, u32 size) 285 { 286 u32 hash = 0; 287 const struct batadv_dat_entry *dat = data; 288 const unsigned char *key; 289 __be16 vid; 290 u32 i; 291 292 key = (__force const unsigned char *)&dat->ip; 293 for (i = 0; i < sizeof(dat->ip); i++) { 294 hash += key[i]; 295 hash += (hash << 10); 296 hash ^= (hash >> 6); 297 } 298 299 vid = htons(dat->vid); 300 key = (__force const unsigned char *)&vid; 301 for (i = 0; i < sizeof(dat->vid); i++) { 302 hash += key[i]; 303 hash += (hash << 10); 304 hash ^= (hash >> 6); 305 } 306 307 hash += (hash << 3); 308 hash ^= (hash >> 11); 309 hash += (hash << 15); 310 311 return hash % size; 312 } 313 314 /** 315 * batadv_dat_entry_hash_find() - look for a given dat_entry in the local hash 316 * table 317 * @bat_priv: the bat priv with all the soft interface information 318 * @ip: search key 319 * @vid: VLAN identifier 320 * 321 * Return: the dat_entry if found, NULL otherwise. 322 */ 323 static struct batadv_dat_entry * 324 batadv_dat_entry_hash_find(struct batadv_priv *bat_priv, __be32 ip, 325 unsigned short vid) 326 { 327 struct hlist_head *head; 328 struct batadv_dat_entry to_find, *dat_entry, *dat_entry_tmp = NULL; 329 struct batadv_hashtable *hash = bat_priv->dat.hash; 330 u32 index; 331 332 if (!hash) 333 return NULL; 334 335 to_find.ip = ip; 336 to_find.vid = vid; 337 338 index = batadv_hash_dat(&to_find, hash->size); 339 head = &hash->table[index]; 340 341 rcu_read_lock(); 342 hlist_for_each_entry_rcu(dat_entry, head, hash_entry) { 343 if (dat_entry->ip != ip) 344 continue; 345 346 if (!kref_get_unless_zero(&dat_entry->refcount)) 347 continue; 348 349 dat_entry_tmp = dat_entry; 350 break; 351 } 352 rcu_read_unlock(); 353 354 return dat_entry_tmp; 355 } 356 357 /** 358 * batadv_dat_entry_add() - add a new dat entry or update it if already exists 359 * @bat_priv: the bat priv with all the soft interface information 360 * @ip: ipv4 to add/edit 361 * @mac_addr: mac address to assign to the given ipv4 362 * @vid: VLAN identifier 363 */ 364 static void batadv_dat_entry_add(struct batadv_priv *bat_priv, __be32 ip, 365 u8 *mac_addr, unsigned short vid) 366 { 367 struct batadv_dat_entry *dat_entry; 368 int hash_added; 369 370 dat_entry = batadv_dat_entry_hash_find(bat_priv, ip, vid); 371 /* if this entry is already known, just update it */ 372 if (dat_entry) { 373 if (!batadv_compare_eth(dat_entry->mac_addr, mac_addr)) 374 ether_addr_copy(dat_entry->mac_addr, mac_addr); 375 dat_entry->last_update = jiffies; 376 batadv_dbg(BATADV_DBG_DAT, bat_priv, 377 "Entry updated: %pI4 %pM (vid: %d)\n", 378 &dat_entry->ip, dat_entry->mac_addr, 379 batadv_print_vid(vid)); 380 goto out; 381 } 382 383 dat_entry = kmalloc(sizeof(*dat_entry), GFP_ATOMIC); 384 if (!dat_entry) 385 goto out; 386 387 dat_entry->ip = ip; 388 dat_entry->vid = vid; 389 ether_addr_copy(dat_entry->mac_addr, mac_addr); 390 dat_entry->last_update = jiffies; 391 kref_init(&dat_entry->refcount); 392 393 kref_get(&dat_entry->refcount); 394 hash_added = batadv_hash_add(bat_priv->dat.hash, batadv_compare_dat, 395 batadv_hash_dat, dat_entry, 396 &dat_entry->hash_entry); 397 398 if (unlikely(hash_added != 0)) { 399 /* remove the reference for the hash */ 400 batadv_dat_entry_put(dat_entry); 401 goto out; 402 } 403 404 batadv_dbg(BATADV_DBG_DAT, bat_priv, "New entry added: %pI4 %pM (vid: %d)\n", 405 &dat_entry->ip, dat_entry->mac_addr, batadv_print_vid(vid)); 406 407 out: 408 if (dat_entry) 409 batadv_dat_entry_put(dat_entry); 410 } 411 412 #ifdef CONFIG_BATMAN_ADV_DEBUG 413 414 /** 415 * batadv_dbg_arp() - print a debug message containing all the ARP packet 416 * details 417 * @bat_priv: the bat priv with all the soft interface information 418 * @skb: ARP packet 419 * @hdr_size: size of the possible header before the ARP packet 420 * @msg: message to print together with the debugging information 421 */ 422 static void batadv_dbg_arp(struct batadv_priv *bat_priv, struct sk_buff *skb, 423 int hdr_size, char *msg) 424 { 425 struct batadv_unicast_4addr_packet *unicast_4addr_packet; 426 struct batadv_bcast_packet *bcast_pkt; 427 u8 *orig_addr; 428 __be32 ip_src, ip_dst; 429 430 if (msg) 431 batadv_dbg(BATADV_DBG_DAT, bat_priv, "%s\n", msg); 432 433 ip_src = batadv_arp_ip_src(skb, hdr_size); 434 ip_dst = batadv_arp_ip_dst(skb, hdr_size); 435 batadv_dbg(BATADV_DBG_DAT, bat_priv, 436 "ARP MSG = [src: %pM-%pI4 dst: %pM-%pI4]\n", 437 batadv_arp_hw_src(skb, hdr_size), &ip_src, 438 batadv_arp_hw_dst(skb, hdr_size), &ip_dst); 439 440 if (hdr_size < sizeof(struct batadv_unicast_packet)) 441 return; 442 443 unicast_4addr_packet = (struct batadv_unicast_4addr_packet *)skb->data; 444 445 switch (unicast_4addr_packet->u.packet_type) { 446 case BATADV_UNICAST: 447 batadv_dbg(BATADV_DBG_DAT, bat_priv, 448 "* encapsulated within a UNICAST packet\n"); 449 break; 450 case BATADV_UNICAST_4ADDR: 451 batadv_dbg(BATADV_DBG_DAT, bat_priv, 452 "* encapsulated within a UNICAST_4ADDR packet (src: %pM)\n", 453 unicast_4addr_packet->src); 454 switch (unicast_4addr_packet->subtype) { 455 case BATADV_P_DAT_DHT_PUT: 456 batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DAT_DHT_PUT\n"); 457 break; 458 case BATADV_P_DAT_DHT_GET: 459 batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DAT_DHT_GET\n"); 460 break; 461 case BATADV_P_DAT_CACHE_REPLY: 462 batadv_dbg(BATADV_DBG_DAT, bat_priv, 463 "* type: DAT_CACHE_REPLY\n"); 464 break; 465 case BATADV_P_DATA: 466 batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: DATA\n"); 467 break; 468 default: 469 batadv_dbg(BATADV_DBG_DAT, bat_priv, "* type: Unknown (%u)!\n", 470 unicast_4addr_packet->u.packet_type); 471 } 472 break; 473 case BATADV_BCAST: 474 bcast_pkt = (struct batadv_bcast_packet *)unicast_4addr_packet; 475 orig_addr = bcast_pkt->orig; 476 batadv_dbg(BATADV_DBG_DAT, bat_priv, 477 "* encapsulated within a BCAST packet (src: %pM)\n", 478 orig_addr); 479 break; 480 default: 481 batadv_dbg(BATADV_DBG_DAT, bat_priv, 482 "* encapsulated within an unknown packet type (0x%x)\n", 483 unicast_4addr_packet->u.packet_type); 484 } 485 } 486 487 #else 488 489 static void batadv_dbg_arp(struct batadv_priv *bat_priv, struct sk_buff *skb, 490 int hdr_size, char *msg) 491 { 492 } 493 494 #endif /* CONFIG_BATMAN_ADV_DEBUG */ 495 496 /** 497 * batadv_is_orig_node_eligible() - check whether a node can be a DHT candidate 498 * @res: the array with the already selected candidates 499 * @select: number of already selected candidates 500 * @tmp_max: address of the currently evaluated node 501 * @max: current round max address 502 * @last_max: address of the last selected candidate 503 * @candidate: orig_node under evaluation 504 * @max_orig_node: last selected candidate 505 * 506 * Return: true if the node has been elected as next candidate or false 507 * otherwise. 508 */ 509 static bool batadv_is_orig_node_eligible(struct batadv_dat_candidate *res, 510 int select, batadv_dat_addr_t tmp_max, 511 batadv_dat_addr_t max, 512 batadv_dat_addr_t last_max, 513 struct batadv_orig_node *candidate, 514 struct batadv_orig_node *max_orig_node) 515 { 516 bool ret = false; 517 int j; 518 519 /* check if orig node candidate is running DAT */ 520 if (!test_bit(BATADV_ORIG_CAPA_HAS_DAT, &candidate->capabilities)) 521 goto out; 522 523 /* Check if this node has already been selected... */ 524 for (j = 0; j < select; j++) 525 if (res[j].orig_node == candidate) 526 break; 527 /* ..and possibly skip it */ 528 if (j < select) 529 goto out; 530 /* sanity check: has it already been selected? This should not happen */ 531 if (tmp_max > last_max) 532 goto out; 533 /* check if during this iteration an originator with a closer dht 534 * address has already been found 535 */ 536 if (tmp_max < max) 537 goto out; 538 /* this is an hash collision with the temporary selected node. Choose 539 * the one with the lowest address 540 */ 541 if (tmp_max == max && max_orig_node && 542 batadv_compare_eth(candidate->orig, max_orig_node->orig)) 543 goto out; 544 545 ret = true; 546 out: 547 return ret; 548 } 549 550 /** 551 * batadv_choose_next_candidate() - select the next DHT candidate 552 * @bat_priv: the bat priv with all the soft interface information 553 * @cands: candidates array 554 * @select: number of candidates already present in the array 555 * @ip_key: key to look up in the DHT 556 * @last_max: pointer where the address of the selected candidate will be saved 557 */ 558 static void batadv_choose_next_candidate(struct batadv_priv *bat_priv, 559 struct batadv_dat_candidate *cands, 560 int select, batadv_dat_addr_t ip_key, 561 batadv_dat_addr_t *last_max) 562 { 563 batadv_dat_addr_t max = 0; 564 batadv_dat_addr_t tmp_max = 0; 565 struct batadv_orig_node *orig_node, *max_orig_node = NULL; 566 struct batadv_hashtable *hash = bat_priv->orig_hash; 567 struct hlist_head *head; 568 int i; 569 570 /* if no node is eligible as candidate, leave the candidate type as 571 * NOT_FOUND 572 */ 573 cands[select].type = BATADV_DAT_CANDIDATE_NOT_FOUND; 574 575 /* iterate over the originator list and find the node with the closest 576 * dat_address which has not been selected yet 577 */ 578 for (i = 0; i < hash->size; i++) { 579 head = &hash->table[i]; 580 581 rcu_read_lock(); 582 hlist_for_each_entry_rcu(orig_node, head, hash_entry) { 583 /* the dht space is a ring using unsigned addresses */ 584 tmp_max = BATADV_DAT_ADDR_MAX - orig_node->dat_addr + 585 ip_key; 586 587 if (!batadv_is_orig_node_eligible(cands, select, 588 tmp_max, max, 589 *last_max, orig_node, 590 max_orig_node)) 591 continue; 592 593 if (!kref_get_unless_zero(&orig_node->refcount)) 594 continue; 595 596 max = tmp_max; 597 if (max_orig_node) 598 batadv_orig_node_put(max_orig_node); 599 max_orig_node = orig_node; 600 } 601 rcu_read_unlock(); 602 } 603 if (max_orig_node) { 604 cands[select].type = BATADV_DAT_CANDIDATE_ORIG; 605 cands[select].orig_node = max_orig_node; 606 batadv_dbg(BATADV_DBG_DAT, bat_priv, 607 "dat_select_candidates() %d: selected %pM addr=%u dist=%u\n", 608 select, max_orig_node->orig, max_orig_node->dat_addr, 609 max); 610 } 611 *last_max = max; 612 } 613 614 /** 615 * batadv_dat_select_candidates() - select the nodes which the DHT message has 616 * to be sent to 617 * @bat_priv: the bat priv with all the soft interface information 618 * @ip_dst: ipv4 to look up in the DHT 619 * @vid: VLAN identifier 620 * 621 * An originator O is selected if and only if its DHT_ID value is one of three 622 * closest values (from the LEFT, with wrap around if needed) then the hash 623 * value of the key. ip_dst is the key. 624 * 625 * Return: the candidate array of size BATADV_DAT_CANDIDATE_NUM. 626 */ 627 static struct batadv_dat_candidate * 628 batadv_dat_select_candidates(struct batadv_priv *bat_priv, __be32 ip_dst, 629 unsigned short vid) 630 { 631 int select; 632 batadv_dat_addr_t last_max = BATADV_DAT_ADDR_MAX, ip_key; 633 struct batadv_dat_candidate *res; 634 struct batadv_dat_entry dat; 635 636 if (!bat_priv->orig_hash) 637 return NULL; 638 639 res = kmalloc_array(BATADV_DAT_CANDIDATES_NUM, sizeof(*res), 640 GFP_ATOMIC); 641 if (!res) 642 return NULL; 643 644 dat.ip = ip_dst; 645 dat.vid = vid; 646 ip_key = (batadv_dat_addr_t)batadv_hash_dat(&dat, 647 BATADV_DAT_ADDR_MAX); 648 649 batadv_dbg(BATADV_DBG_DAT, bat_priv, 650 "%s(): IP=%pI4 hash(IP)=%u\n", __func__, &ip_dst, 651 ip_key); 652 653 for (select = 0; select < BATADV_DAT_CANDIDATES_NUM; select++) 654 batadv_choose_next_candidate(bat_priv, res, select, ip_key, 655 &last_max); 656 657 return res; 658 } 659 660 /** 661 * batadv_dat_forward_data() - copy and send payload to the selected candidates 662 * @bat_priv: the bat priv with all the soft interface information 663 * @skb: payload to send 664 * @ip: the DHT key 665 * @vid: VLAN identifier 666 * @packet_subtype: unicast4addr packet subtype to use 667 * 668 * This function copies the skb with pskb_copy() and is sent as a unicast packet 669 * to each of the selected candidates. 670 * 671 * Return: true if the packet is sent to at least one candidate, false 672 * otherwise. 673 */ 674 static bool batadv_dat_forward_data(struct batadv_priv *bat_priv, 675 struct sk_buff *skb, __be32 ip, 676 unsigned short vid, int packet_subtype) 677 { 678 int i; 679 bool ret = false; 680 int send_status; 681 struct batadv_neigh_node *neigh_node = NULL; 682 struct sk_buff *tmp_skb; 683 struct batadv_dat_candidate *cand; 684 685 cand = batadv_dat_select_candidates(bat_priv, ip, vid); 686 if (!cand) 687 goto out; 688 689 batadv_dbg(BATADV_DBG_DAT, bat_priv, "DHT_SEND for %pI4\n", &ip); 690 691 for (i = 0; i < BATADV_DAT_CANDIDATES_NUM; i++) { 692 if (cand[i].type == BATADV_DAT_CANDIDATE_NOT_FOUND) 693 continue; 694 695 neigh_node = batadv_orig_router_get(cand[i].orig_node, 696 BATADV_IF_DEFAULT); 697 if (!neigh_node) 698 goto free_orig; 699 700 tmp_skb = pskb_copy_for_clone(skb, GFP_ATOMIC); 701 if (!batadv_send_skb_prepare_unicast_4addr(bat_priv, tmp_skb, 702 cand[i].orig_node, 703 packet_subtype)) { 704 kfree_skb(tmp_skb); 705 goto free_neigh; 706 } 707 708 send_status = batadv_send_unicast_skb(tmp_skb, neigh_node); 709 if (send_status == NET_XMIT_SUCCESS) { 710 /* count the sent packet */ 711 switch (packet_subtype) { 712 case BATADV_P_DAT_DHT_GET: 713 batadv_inc_counter(bat_priv, 714 BATADV_CNT_DAT_GET_TX); 715 break; 716 case BATADV_P_DAT_DHT_PUT: 717 batadv_inc_counter(bat_priv, 718 BATADV_CNT_DAT_PUT_TX); 719 break; 720 } 721 722 /* packet sent to a candidate: return true */ 723 ret = true; 724 } 725 free_neigh: 726 batadv_neigh_node_put(neigh_node); 727 free_orig: 728 batadv_orig_node_put(cand[i].orig_node); 729 } 730 731 out: 732 kfree(cand); 733 return ret; 734 } 735 736 /** 737 * batadv_dat_tvlv_container_update() - update the dat tvlv container after dat 738 * setting change 739 * @bat_priv: the bat priv with all the soft interface information 740 */ 741 static void batadv_dat_tvlv_container_update(struct batadv_priv *bat_priv) 742 { 743 char dat_mode; 744 745 dat_mode = atomic_read(&bat_priv->distributed_arp_table); 746 747 switch (dat_mode) { 748 case 0: 749 batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_DAT, 1); 750 break; 751 case 1: 752 batadv_tvlv_container_register(bat_priv, BATADV_TVLV_DAT, 1, 753 NULL, 0); 754 break; 755 } 756 } 757 758 /** 759 * batadv_dat_status_update() - update the dat tvlv container after dat 760 * setting change 761 * @net_dev: the soft interface net device 762 */ 763 void batadv_dat_status_update(struct net_device *net_dev) 764 { 765 struct batadv_priv *bat_priv = netdev_priv(net_dev); 766 767 batadv_dat_tvlv_container_update(bat_priv); 768 } 769 770 /** 771 * batadv_dat_tvlv_ogm_handler_v1() - process incoming dat tvlv container 772 * @bat_priv: the bat priv with all the soft interface information 773 * @orig: the orig_node of the ogm 774 * @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags) 775 * @tvlv_value: tvlv buffer containing the gateway data 776 * @tvlv_value_len: tvlv buffer length 777 */ 778 static void batadv_dat_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv, 779 struct batadv_orig_node *orig, 780 u8 flags, 781 void *tvlv_value, u16 tvlv_value_len) 782 { 783 if (flags & BATADV_TVLV_HANDLER_OGM_CIFNOTFND) 784 clear_bit(BATADV_ORIG_CAPA_HAS_DAT, &orig->capabilities); 785 else 786 set_bit(BATADV_ORIG_CAPA_HAS_DAT, &orig->capabilities); 787 } 788 789 /** 790 * batadv_dat_hash_free() - free the local DAT hash table 791 * @bat_priv: the bat priv with all the soft interface information 792 */ 793 static void batadv_dat_hash_free(struct batadv_priv *bat_priv) 794 { 795 if (!bat_priv->dat.hash) 796 return; 797 798 __batadv_dat_purge(bat_priv, NULL); 799 800 batadv_hash_destroy(bat_priv->dat.hash); 801 802 bat_priv->dat.hash = NULL; 803 } 804 805 /** 806 * batadv_dat_init() - initialise the DAT internals 807 * @bat_priv: the bat priv with all the soft interface information 808 * 809 * Return: 0 in case of success, a negative error code otherwise 810 */ 811 int batadv_dat_init(struct batadv_priv *bat_priv) 812 { 813 if (bat_priv->dat.hash) 814 return 0; 815 816 bat_priv->dat.hash = batadv_hash_new(1024); 817 818 if (!bat_priv->dat.hash) 819 return -ENOMEM; 820 821 batadv_dat_start_timer(bat_priv); 822 823 batadv_tvlv_handler_register(bat_priv, batadv_dat_tvlv_ogm_handler_v1, 824 NULL, BATADV_TVLV_DAT, 1, 825 BATADV_TVLV_HANDLER_OGM_CIFNOTFND); 826 batadv_dat_tvlv_container_update(bat_priv); 827 return 0; 828 } 829 830 /** 831 * batadv_dat_free() - free the DAT internals 832 * @bat_priv: the bat priv with all the soft interface information 833 */ 834 void batadv_dat_free(struct batadv_priv *bat_priv) 835 { 836 batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_DAT, 1); 837 batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_DAT, 1); 838 839 cancel_delayed_work_sync(&bat_priv->dat.work); 840 841 batadv_dat_hash_free(bat_priv); 842 } 843 844 /** 845 * batadv_dat_cache_dump_entry() - dump one entry of the DAT cache table to a 846 * netlink socket 847 * @msg: buffer for the message 848 * @portid: netlink port 849 * @cb: Control block containing additional options 850 * @dat_entry: entry to dump 851 * 852 * Return: 0 or error code. 853 */ 854 static int 855 batadv_dat_cache_dump_entry(struct sk_buff *msg, u32 portid, 856 struct netlink_callback *cb, 857 struct batadv_dat_entry *dat_entry) 858 { 859 int msecs; 860 void *hdr; 861 862 hdr = genlmsg_put(msg, portid, cb->nlh->nlmsg_seq, 863 &batadv_netlink_family, NLM_F_MULTI, 864 BATADV_CMD_GET_DAT_CACHE); 865 if (!hdr) 866 return -ENOBUFS; 867 868 genl_dump_check_consistent(cb, hdr); 869 870 msecs = jiffies_to_msecs(jiffies - dat_entry->last_update); 871 872 if (nla_put_in_addr(msg, BATADV_ATTR_DAT_CACHE_IP4ADDRESS, 873 dat_entry->ip) || 874 nla_put(msg, BATADV_ATTR_DAT_CACHE_HWADDRESS, ETH_ALEN, 875 dat_entry->mac_addr) || 876 nla_put_u16(msg, BATADV_ATTR_DAT_CACHE_VID, dat_entry->vid) || 877 nla_put_u32(msg, BATADV_ATTR_LAST_SEEN_MSECS, msecs)) { 878 genlmsg_cancel(msg, hdr); 879 return -EMSGSIZE; 880 } 881 882 genlmsg_end(msg, hdr); 883 return 0; 884 } 885 886 /** 887 * batadv_dat_cache_dump_bucket() - dump one bucket of the DAT cache table to 888 * a netlink socket 889 * @msg: buffer for the message 890 * @portid: netlink port 891 * @cb: Control block containing additional options 892 * @hash: hash to dump 893 * @bucket: bucket index to dump 894 * @idx_skip: How many entries to skip 895 * 896 * Return: 0 or error code. 897 */ 898 static int 899 batadv_dat_cache_dump_bucket(struct sk_buff *msg, u32 portid, 900 struct netlink_callback *cb, 901 struct batadv_hashtable *hash, unsigned int bucket, 902 int *idx_skip) 903 { 904 struct batadv_dat_entry *dat_entry; 905 int idx = 0; 906 907 spin_lock_bh(&hash->list_locks[bucket]); 908 cb->seq = atomic_read(&hash->generation) << 1 | 1; 909 910 hlist_for_each_entry(dat_entry, &hash->table[bucket], hash_entry) { 911 if (idx < *idx_skip) 912 goto skip; 913 914 if (batadv_dat_cache_dump_entry(msg, portid, cb, dat_entry)) { 915 spin_unlock_bh(&hash->list_locks[bucket]); 916 *idx_skip = idx; 917 918 return -EMSGSIZE; 919 } 920 921 skip: 922 idx++; 923 } 924 spin_unlock_bh(&hash->list_locks[bucket]); 925 926 return 0; 927 } 928 929 /** 930 * batadv_dat_cache_dump() - dump DAT cache table to a netlink socket 931 * @msg: buffer for the message 932 * @cb: callback structure containing arguments 933 * 934 * Return: message length. 935 */ 936 int batadv_dat_cache_dump(struct sk_buff *msg, struct netlink_callback *cb) 937 { 938 struct batadv_hard_iface *primary_if = NULL; 939 int portid = NETLINK_CB(cb->skb).portid; 940 struct net *net = sock_net(cb->skb->sk); 941 struct net_device *soft_iface; 942 struct batadv_hashtable *hash; 943 struct batadv_priv *bat_priv; 944 int bucket = cb->args[0]; 945 int idx = cb->args[1]; 946 int ifindex; 947 int ret = 0; 948 949 ifindex = batadv_netlink_get_ifindex(cb->nlh, 950 BATADV_ATTR_MESH_IFINDEX); 951 if (!ifindex) 952 return -EINVAL; 953 954 soft_iface = dev_get_by_index(net, ifindex); 955 if (!soft_iface || !batadv_softif_is_valid(soft_iface)) { 956 ret = -ENODEV; 957 goto out; 958 } 959 960 bat_priv = netdev_priv(soft_iface); 961 hash = bat_priv->dat.hash; 962 963 primary_if = batadv_primary_if_get_selected(bat_priv); 964 if (!primary_if || primary_if->if_status != BATADV_IF_ACTIVE) { 965 ret = -ENOENT; 966 goto out; 967 } 968 969 while (bucket < hash->size) { 970 if (batadv_dat_cache_dump_bucket(msg, portid, cb, hash, bucket, 971 &idx)) 972 break; 973 974 bucket++; 975 idx = 0; 976 } 977 978 cb->args[0] = bucket; 979 cb->args[1] = idx; 980 981 ret = msg->len; 982 983 out: 984 if (primary_if) 985 batadv_hardif_put(primary_if); 986 987 if (soft_iface) 988 dev_put(soft_iface); 989 990 return ret; 991 } 992 993 /** 994 * batadv_arp_get_type() - parse an ARP packet and gets the type 995 * @bat_priv: the bat priv with all the soft interface information 996 * @skb: packet to analyse 997 * @hdr_size: size of the possible header before the ARP packet in the skb 998 * 999 * Return: the ARP type if the skb contains a valid ARP packet, 0 otherwise. 1000 */ 1001 static u16 batadv_arp_get_type(struct batadv_priv *bat_priv, 1002 struct sk_buff *skb, int hdr_size) 1003 { 1004 struct arphdr *arphdr; 1005 struct ethhdr *ethhdr; 1006 __be32 ip_src, ip_dst; 1007 u8 *hw_src, *hw_dst; 1008 u16 type = 0; 1009 1010 /* pull the ethernet header */ 1011 if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN))) 1012 goto out; 1013 1014 ethhdr = (struct ethhdr *)(skb->data + hdr_size); 1015 1016 if (ethhdr->h_proto != htons(ETH_P_ARP)) 1017 goto out; 1018 1019 /* pull the ARP payload */ 1020 if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN + 1021 arp_hdr_len(skb->dev)))) 1022 goto out; 1023 1024 arphdr = (struct arphdr *)(skb->data + hdr_size + ETH_HLEN); 1025 1026 /* check whether the ARP packet carries a valid IP information */ 1027 if (arphdr->ar_hrd != htons(ARPHRD_ETHER)) 1028 goto out; 1029 1030 if (arphdr->ar_pro != htons(ETH_P_IP)) 1031 goto out; 1032 1033 if (arphdr->ar_hln != ETH_ALEN) 1034 goto out; 1035 1036 if (arphdr->ar_pln != 4) 1037 goto out; 1038 1039 /* Check for bad reply/request. If the ARP message is not sane, DAT 1040 * will simply ignore it 1041 */ 1042 ip_src = batadv_arp_ip_src(skb, hdr_size); 1043 ip_dst = batadv_arp_ip_dst(skb, hdr_size); 1044 if (ipv4_is_loopback(ip_src) || ipv4_is_multicast(ip_src) || 1045 ipv4_is_loopback(ip_dst) || ipv4_is_multicast(ip_dst) || 1046 ipv4_is_zeronet(ip_src) || ipv4_is_lbcast(ip_src) || 1047 ipv4_is_zeronet(ip_dst) || ipv4_is_lbcast(ip_dst)) 1048 goto out; 1049 1050 hw_src = batadv_arp_hw_src(skb, hdr_size); 1051 if (is_zero_ether_addr(hw_src) || is_multicast_ether_addr(hw_src)) 1052 goto out; 1053 1054 /* don't care about the destination MAC address in ARP requests */ 1055 if (arphdr->ar_op != htons(ARPOP_REQUEST)) { 1056 hw_dst = batadv_arp_hw_dst(skb, hdr_size); 1057 if (is_zero_ether_addr(hw_dst) || 1058 is_multicast_ether_addr(hw_dst)) 1059 goto out; 1060 } 1061 1062 type = ntohs(arphdr->ar_op); 1063 out: 1064 return type; 1065 } 1066 1067 /** 1068 * batadv_dat_get_vid() - extract the VLAN identifier from skb if any 1069 * @skb: the buffer containing the packet to extract the VID from 1070 * @hdr_size: the size of the batman-adv header encapsulating the packet 1071 * 1072 * Return: If the packet embedded in the skb is vlan tagged this function 1073 * returns the VID with the BATADV_VLAN_HAS_TAG flag. Otherwise BATADV_NO_FLAGS 1074 * is returned. 1075 */ 1076 static unsigned short batadv_dat_get_vid(struct sk_buff *skb, int *hdr_size) 1077 { 1078 unsigned short vid; 1079 1080 vid = batadv_get_vid(skb, *hdr_size); 1081 1082 /* ARP parsing functions jump forward of hdr_size + ETH_HLEN. 1083 * If the header contained in the packet is a VLAN one (which is longer) 1084 * hdr_size is updated so that the functions will still skip the 1085 * correct amount of bytes. 1086 */ 1087 if (vid & BATADV_VLAN_HAS_TAG) 1088 *hdr_size += VLAN_HLEN; 1089 1090 return vid; 1091 } 1092 1093 /** 1094 * batadv_dat_arp_create_reply() - create an ARP Reply 1095 * @bat_priv: the bat priv with all the soft interface information 1096 * @ip_src: ARP sender IP 1097 * @ip_dst: ARP target IP 1098 * @hw_src: Ethernet source and ARP sender MAC 1099 * @hw_dst: Ethernet destination and ARP target MAC 1100 * @vid: VLAN identifier (optional, set to zero otherwise) 1101 * 1102 * Creates an ARP Reply from the given values, optionally encapsulated in a 1103 * VLAN header. 1104 * 1105 * Return: An skb containing an ARP Reply. 1106 */ 1107 static struct sk_buff * 1108 batadv_dat_arp_create_reply(struct batadv_priv *bat_priv, __be32 ip_src, 1109 __be32 ip_dst, u8 *hw_src, u8 *hw_dst, 1110 unsigned short vid) 1111 { 1112 struct sk_buff *skb; 1113 1114 skb = arp_create(ARPOP_REPLY, ETH_P_ARP, ip_dst, bat_priv->soft_iface, 1115 ip_src, hw_dst, hw_src, hw_dst); 1116 if (!skb) 1117 return NULL; 1118 1119 skb_reset_mac_header(skb); 1120 1121 if (vid & BATADV_VLAN_HAS_TAG) 1122 skb = vlan_insert_tag(skb, htons(ETH_P_8021Q), 1123 vid & VLAN_VID_MASK); 1124 1125 return skb; 1126 } 1127 1128 /** 1129 * batadv_dat_snoop_outgoing_arp_request() - snoop the ARP request and try to 1130 * answer using DAT 1131 * @bat_priv: the bat priv with all the soft interface information 1132 * @skb: packet to check 1133 * 1134 * Return: true if the message has been sent to the dht candidates, false 1135 * otherwise. In case of a positive return value the message has to be enqueued 1136 * to permit the fallback. 1137 */ 1138 bool batadv_dat_snoop_outgoing_arp_request(struct batadv_priv *bat_priv, 1139 struct sk_buff *skb) 1140 { 1141 u16 type = 0; 1142 __be32 ip_dst, ip_src; 1143 u8 *hw_src; 1144 bool ret = false; 1145 struct batadv_dat_entry *dat_entry = NULL; 1146 struct sk_buff *skb_new; 1147 struct net_device *soft_iface = bat_priv->soft_iface; 1148 int hdr_size = 0; 1149 unsigned short vid; 1150 1151 if (!atomic_read(&bat_priv->distributed_arp_table)) 1152 goto out; 1153 1154 vid = batadv_dat_get_vid(skb, &hdr_size); 1155 1156 type = batadv_arp_get_type(bat_priv, skb, hdr_size); 1157 /* If the node gets an ARP_REQUEST it has to send a DHT_GET unicast 1158 * message to the selected DHT candidates 1159 */ 1160 if (type != ARPOP_REQUEST) 1161 goto out; 1162 1163 batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing outgoing ARP REQUEST"); 1164 1165 ip_src = batadv_arp_ip_src(skb, hdr_size); 1166 hw_src = batadv_arp_hw_src(skb, hdr_size); 1167 ip_dst = batadv_arp_ip_dst(skb, hdr_size); 1168 1169 batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid); 1170 1171 dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid); 1172 if (dat_entry) { 1173 /* If the ARP request is destined for a local client the local 1174 * client will answer itself. DAT would only generate a 1175 * duplicate packet. 1176 * 1177 * Moreover, if the soft-interface is enslaved into a bridge, an 1178 * additional DAT answer may trigger kernel warnings about 1179 * a packet coming from the wrong port. 1180 */ 1181 if (batadv_is_my_client(bat_priv, dat_entry->mac_addr, vid)) { 1182 ret = true; 1183 goto out; 1184 } 1185 1186 /* If BLA is enabled, only send ARP replies if we have claimed 1187 * the destination for the ARP request or if no one else of 1188 * the backbone gws belonging to our backbone has claimed the 1189 * destination. 1190 */ 1191 if (!batadv_bla_check_claim(bat_priv, 1192 dat_entry->mac_addr, vid)) { 1193 batadv_dbg(BATADV_DBG_DAT, bat_priv, 1194 "Device %pM claimed by another backbone gw. Don't send ARP reply!", 1195 dat_entry->mac_addr); 1196 ret = true; 1197 goto out; 1198 } 1199 1200 skb_new = batadv_dat_arp_create_reply(bat_priv, ip_dst, ip_src, 1201 dat_entry->mac_addr, 1202 hw_src, vid); 1203 if (!skb_new) 1204 goto out; 1205 1206 skb_new->protocol = eth_type_trans(skb_new, soft_iface); 1207 1208 batadv_inc_counter(bat_priv, BATADV_CNT_RX); 1209 batadv_add_counter(bat_priv, BATADV_CNT_RX_BYTES, 1210 skb->len + ETH_HLEN + hdr_size); 1211 1212 netif_rx(skb_new); 1213 batadv_dbg(BATADV_DBG_DAT, bat_priv, "ARP request replied locally\n"); 1214 ret = true; 1215 } else { 1216 /* Send the request to the DHT */ 1217 ret = batadv_dat_forward_data(bat_priv, skb, ip_dst, vid, 1218 BATADV_P_DAT_DHT_GET); 1219 } 1220 out: 1221 if (dat_entry) 1222 batadv_dat_entry_put(dat_entry); 1223 return ret; 1224 } 1225 1226 /** 1227 * batadv_dat_snoop_incoming_arp_request() - snoop the ARP request and try to 1228 * answer using the local DAT storage 1229 * @bat_priv: the bat priv with all the soft interface information 1230 * @skb: packet to check 1231 * @hdr_size: size of the encapsulation header 1232 * 1233 * Return: true if the request has been answered, false otherwise. 1234 */ 1235 bool batadv_dat_snoop_incoming_arp_request(struct batadv_priv *bat_priv, 1236 struct sk_buff *skb, int hdr_size) 1237 { 1238 u16 type; 1239 __be32 ip_src, ip_dst; 1240 u8 *hw_src; 1241 struct sk_buff *skb_new; 1242 struct batadv_dat_entry *dat_entry = NULL; 1243 bool ret = false; 1244 unsigned short vid; 1245 int err; 1246 1247 if (!atomic_read(&bat_priv->distributed_arp_table)) 1248 goto out; 1249 1250 vid = batadv_dat_get_vid(skb, &hdr_size); 1251 1252 type = batadv_arp_get_type(bat_priv, skb, hdr_size); 1253 if (type != ARPOP_REQUEST) 1254 goto out; 1255 1256 hw_src = batadv_arp_hw_src(skb, hdr_size); 1257 ip_src = batadv_arp_ip_src(skb, hdr_size); 1258 ip_dst = batadv_arp_ip_dst(skb, hdr_size); 1259 1260 batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing incoming ARP REQUEST"); 1261 1262 batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid); 1263 1264 dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid); 1265 if (!dat_entry) 1266 goto out; 1267 1268 skb_new = batadv_dat_arp_create_reply(bat_priv, ip_dst, ip_src, 1269 dat_entry->mac_addr, hw_src, vid); 1270 if (!skb_new) 1271 goto out; 1272 1273 /* To preserve backwards compatibility, the node has choose the outgoing 1274 * format based on the incoming request packet type. The assumption is 1275 * that a node not using the 4addr packet format doesn't support it. 1276 */ 1277 if (hdr_size == sizeof(struct batadv_unicast_4addr_packet)) 1278 err = batadv_send_skb_via_tt_4addr(bat_priv, skb_new, 1279 BATADV_P_DAT_CACHE_REPLY, 1280 NULL, vid); 1281 else 1282 err = batadv_send_skb_via_tt(bat_priv, skb_new, NULL, vid); 1283 1284 if (err != NET_XMIT_DROP) { 1285 batadv_inc_counter(bat_priv, BATADV_CNT_DAT_CACHED_REPLY_TX); 1286 ret = true; 1287 } 1288 out: 1289 if (dat_entry) 1290 batadv_dat_entry_put(dat_entry); 1291 if (ret) 1292 kfree_skb(skb); 1293 return ret; 1294 } 1295 1296 /** 1297 * batadv_dat_snoop_outgoing_arp_reply() - snoop the ARP reply and fill the DHT 1298 * @bat_priv: the bat priv with all the soft interface information 1299 * @skb: packet to check 1300 */ 1301 void batadv_dat_snoop_outgoing_arp_reply(struct batadv_priv *bat_priv, 1302 struct sk_buff *skb) 1303 { 1304 u16 type; 1305 __be32 ip_src, ip_dst; 1306 u8 *hw_src, *hw_dst; 1307 int hdr_size = 0; 1308 unsigned short vid; 1309 1310 if (!atomic_read(&bat_priv->distributed_arp_table)) 1311 return; 1312 1313 vid = batadv_dat_get_vid(skb, &hdr_size); 1314 1315 type = batadv_arp_get_type(bat_priv, skb, hdr_size); 1316 if (type != ARPOP_REPLY) 1317 return; 1318 1319 batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing outgoing ARP REPLY"); 1320 1321 hw_src = batadv_arp_hw_src(skb, hdr_size); 1322 ip_src = batadv_arp_ip_src(skb, hdr_size); 1323 hw_dst = batadv_arp_hw_dst(skb, hdr_size); 1324 ip_dst = batadv_arp_ip_dst(skb, hdr_size); 1325 1326 batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid); 1327 batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid); 1328 1329 /* Send the ARP reply to the candidates for both the IP addresses that 1330 * the node obtained from the ARP reply 1331 */ 1332 batadv_dat_forward_data(bat_priv, skb, ip_src, vid, 1333 BATADV_P_DAT_DHT_PUT); 1334 batadv_dat_forward_data(bat_priv, skb, ip_dst, vid, 1335 BATADV_P_DAT_DHT_PUT); 1336 } 1337 1338 /** 1339 * batadv_dat_snoop_incoming_arp_reply() - snoop the ARP reply and fill the 1340 * local DAT storage only 1341 * @bat_priv: the bat priv with all the soft interface information 1342 * @skb: packet to check 1343 * @hdr_size: size of the encapsulation header 1344 * 1345 * Return: true if the packet was snooped and consumed by DAT. False if the 1346 * packet has to be delivered to the interface 1347 */ 1348 bool batadv_dat_snoop_incoming_arp_reply(struct batadv_priv *bat_priv, 1349 struct sk_buff *skb, int hdr_size) 1350 { 1351 struct batadv_dat_entry *dat_entry = NULL; 1352 u16 type; 1353 __be32 ip_src, ip_dst; 1354 u8 *hw_src, *hw_dst; 1355 bool dropped = false; 1356 unsigned short vid; 1357 1358 if (!atomic_read(&bat_priv->distributed_arp_table)) 1359 goto out; 1360 1361 vid = batadv_dat_get_vid(skb, &hdr_size); 1362 1363 type = batadv_arp_get_type(bat_priv, skb, hdr_size); 1364 if (type != ARPOP_REPLY) 1365 goto out; 1366 1367 batadv_dbg_arp(bat_priv, skb, hdr_size, "Parsing incoming ARP REPLY"); 1368 1369 hw_src = batadv_arp_hw_src(skb, hdr_size); 1370 ip_src = batadv_arp_ip_src(skb, hdr_size); 1371 hw_dst = batadv_arp_hw_dst(skb, hdr_size); 1372 ip_dst = batadv_arp_ip_dst(skb, hdr_size); 1373 1374 /* If ip_dst is already in cache and has the right mac address, 1375 * drop this frame if this ARP reply is destined for us because it's 1376 * most probably an ARP reply generated by another node of the DHT. 1377 * We have most probably received already a reply earlier. Delivering 1378 * this frame would lead to doubled receive of an ARP reply. 1379 */ 1380 dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_src, vid); 1381 if (dat_entry && batadv_compare_eth(hw_src, dat_entry->mac_addr)) { 1382 batadv_dbg(BATADV_DBG_DAT, bat_priv, "Doubled ARP reply removed: ARP MSG = [src: %pM-%pI4 dst: %pM-%pI4]; dat_entry: %pM-%pI4\n", 1383 hw_src, &ip_src, hw_dst, &ip_dst, 1384 dat_entry->mac_addr, &dat_entry->ip); 1385 dropped = true; 1386 } 1387 1388 /* Update our internal cache with both the IP addresses the node got 1389 * within the ARP reply 1390 */ 1391 batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid); 1392 batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid); 1393 1394 if (dropped) 1395 goto out; 1396 1397 /* If BLA is enabled, only forward ARP replies if we have claimed the 1398 * source of the ARP reply or if no one else of the same backbone has 1399 * already claimed that client. This prevents that different gateways 1400 * to the same backbone all forward the ARP reply leading to multiple 1401 * replies in the backbone. 1402 */ 1403 if (!batadv_bla_check_claim(bat_priv, hw_src, vid)) { 1404 batadv_dbg(BATADV_DBG_DAT, bat_priv, 1405 "Device %pM claimed by another backbone gw. Drop ARP reply.\n", 1406 hw_src); 1407 dropped = true; 1408 goto out; 1409 } 1410 1411 /* if this REPLY is directed to a client of mine, let's deliver the 1412 * packet to the interface 1413 */ 1414 dropped = !batadv_is_my_client(bat_priv, hw_dst, vid); 1415 1416 /* if this REPLY is sent on behalf of a client of mine, let's drop the 1417 * packet because the client will reply by itself 1418 */ 1419 dropped |= batadv_is_my_client(bat_priv, hw_src, vid); 1420 out: 1421 if (dropped) 1422 kfree_skb(skb); 1423 if (dat_entry) 1424 batadv_dat_entry_put(dat_entry); 1425 /* if dropped == false -> deliver to the interface */ 1426 return dropped; 1427 } 1428 1429 /** 1430 * batadv_dat_check_dhcp_ipudp() - check skb for IP+UDP headers valid for DHCP 1431 * @skb: the packet to check 1432 * @ip_src: a buffer to store the IPv4 source address in 1433 * 1434 * Checks whether the given skb has an IP and UDP header valid for a DHCP 1435 * message from a DHCP server. And if so, stores the IPv4 source address in 1436 * the provided buffer. 1437 * 1438 * Return: True if valid, false otherwise. 1439 */ 1440 static bool 1441 batadv_dat_check_dhcp_ipudp(struct sk_buff *skb, __be32 *ip_src) 1442 { 1443 unsigned int offset = skb_network_offset(skb); 1444 struct udphdr *udphdr, _udphdr; 1445 struct iphdr *iphdr, _iphdr; 1446 1447 iphdr = skb_header_pointer(skb, offset, sizeof(_iphdr), &_iphdr); 1448 if (!iphdr || iphdr->version != 4 || iphdr->ihl * 4 < sizeof(_iphdr)) 1449 return false; 1450 1451 if (iphdr->protocol != IPPROTO_UDP) 1452 return false; 1453 1454 offset += iphdr->ihl * 4; 1455 skb_set_transport_header(skb, offset); 1456 1457 udphdr = skb_header_pointer(skb, offset, sizeof(_udphdr), &_udphdr); 1458 if (!udphdr || udphdr->source != htons(67)) 1459 return false; 1460 1461 *ip_src = get_unaligned(&iphdr->saddr); 1462 1463 return true; 1464 } 1465 1466 /** 1467 * batadv_dat_check_dhcp() - examine packet for valid DHCP message 1468 * @skb: the packet to check 1469 * @proto: ethernet protocol hint (behind a potential vlan) 1470 * @ip_src: a buffer to store the IPv4 source address in 1471 * 1472 * Checks whether the given skb is a valid DHCP packet. And if so, stores the 1473 * IPv4 source address in the provided buffer. 1474 * 1475 * Caller needs to ensure that the skb network header is set correctly. 1476 * 1477 * Return: If skb is a valid DHCP packet, then returns its op code 1478 * (e.g. BOOTREPLY vs. BOOTREQUEST). Otherwise returns -EINVAL. 1479 */ 1480 static int 1481 batadv_dat_check_dhcp(struct sk_buff *skb, __be16 proto, __be32 *ip_src) 1482 { 1483 __be32 *magic, _magic; 1484 unsigned int offset; 1485 struct { 1486 __u8 op; 1487 __u8 htype; 1488 __u8 hlen; 1489 __u8 hops; 1490 } *dhcp_h, _dhcp_h; 1491 1492 if (proto != htons(ETH_P_IP)) 1493 return -EINVAL; 1494 1495 if (!batadv_dat_check_dhcp_ipudp(skb, ip_src)) 1496 return -EINVAL; 1497 1498 offset = skb_transport_offset(skb) + sizeof(struct udphdr); 1499 if (skb->len < offset + sizeof(struct batadv_dhcp_packet)) 1500 return -EINVAL; 1501 1502 dhcp_h = skb_header_pointer(skb, offset, sizeof(_dhcp_h), &_dhcp_h); 1503 if (!dhcp_h || dhcp_h->htype != BATADV_HTYPE_ETHERNET || 1504 dhcp_h->hlen != ETH_ALEN) 1505 return -EINVAL; 1506 1507 offset += offsetof(struct batadv_dhcp_packet, magic); 1508 1509 magic = skb_header_pointer(skb, offset, sizeof(_magic), &_magic); 1510 if (!magic || get_unaligned(magic) != htonl(BATADV_DHCP_MAGIC)) 1511 return -EINVAL; 1512 1513 return dhcp_h->op; 1514 } 1515 1516 /** 1517 * batadv_dat_get_dhcp_message_type() - get message type of a DHCP packet 1518 * @skb: the DHCP packet to parse 1519 * 1520 * Iterates over the DHCP options of the given DHCP packet to find a 1521 * DHCP Message Type option and parse it. 1522 * 1523 * Caller needs to ensure that the given skb is a valid DHCP packet and 1524 * that the skb transport header is set correctly. 1525 * 1526 * Return: The found DHCP message type value, if found. -EINVAL otherwise. 1527 */ 1528 static int batadv_dat_get_dhcp_message_type(struct sk_buff *skb) 1529 { 1530 unsigned int offset = skb_transport_offset(skb) + sizeof(struct udphdr); 1531 u8 *type, _type; 1532 struct { 1533 u8 type; 1534 u8 len; 1535 } *tl, _tl; 1536 1537 offset += sizeof(struct batadv_dhcp_packet); 1538 1539 while ((tl = skb_header_pointer(skb, offset, sizeof(_tl), &_tl))) { 1540 if (tl->type == BATADV_DHCP_OPT_MSG_TYPE) 1541 break; 1542 1543 if (tl->type == BATADV_DHCP_OPT_END) 1544 break; 1545 1546 if (tl->type == BATADV_DHCP_OPT_PAD) 1547 offset++; 1548 else 1549 offset += tl->len + sizeof(_tl); 1550 } 1551 1552 /* Option Overload Code not supported */ 1553 if (!tl || tl->type != BATADV_DHCP_OPT_MSG_TYPE || 1554 tl->len != sizeof(_type)) 1555 return -EINVAL; 1556 1557 offset += sizeof(_tl); 1558 1559 type = skb_header_pointer(skb, offset, sizeof(_type), &_type); 1560 if (!type) 1561 return -EINVAL; 1562 1563 return *type; 1564 } 1565 1566 /** 1567 * batadv_dat_get_dhcp_yiaddr() - get yiaddr from a DHCP packet 1568 * @skb: the DHCP packet to parse 1569 * @buf: a buffer to store the yiaddr in 1570 * 1571 * Caller needs to ensure that the given skb is a valid DHCP packet and 1572 * that the skb transport header is set correctly. 1573 * 1574 * Return: True on success, false otherwise. 1575 */ 1576 static bool batadv_dat_dhcp_get_yiaddr(struct sk_buff *skb, __be32 *buf) 1577 { 1578 unsigned int offset = skb_transport_offset(skb) + sizeof(struct udphdr); 1579 __be32 *yiaddr; 1580 1581 offset += offsetof(struct batadv_dhcp_packet, yiaddr); 1582 yiaddr = skb_header_pointer(skb, offset, BATADV_DHCP_YIADDR_LEN, buf); 1583 1584 if (!yiaddr) 1585 return false; 1586 1587 if (yiaddr != buf) 1588 *buf = get_unaligned(yiaddr); 1589 1590 return true; 1591 } 1592 1593 /** 1594 * batadv_dat_get_dhcp_chaddr() - get chaddr from a DHCP packet 1595 * @skb: the DHCP packet to parse 1596 * @buf: a buffer to store the chaddr in 1597 * 1598 * Caller needs to ensure that the given skb is a valid DHCP packet and 1599 * that the skb transport header is set correctly. 1600 * 1601 * Return: True on success, false otherwise 1602 */ 1603 static bool batadv_dat_get_dhcp_chaddr(struct sk_buff *skb, u8 *buf) 1604 { 1605 unsigned int offset = skb_transport_offset(skb) + sizeof(struct udphdr); 1606 u8 *chaddr; 1607 1608 offset += offsetof(struct batadv_dhcp_packet, chaddr); 1609 chaddr = skb_header_pointer(skb, offset, BATADV_DHCP_CHADDR_LEN, buf); 1610 1611 if (!chaddr) 1612 return false; 1613 1614 if (chaddr != buf) 1615 memcpy(buf, chaddr, BATADV_DHCP_CHADDR_LEN); 1616 1617 return true; 1618 } 1619 1620 /** 1621 * batadv_dat_put_dhcp() - puts addresses from a DHCP packet into the DHT and 1622 * DAT cache 1623 * @bat_priv: the bat priv with all the soft interface information 1624 * @chaddr: the DHCP client MAC address 1625 * @yiaddr: the DHCP client IP address 1626 * @hw_dst: the DHCP server MAC address 1627 * @ip_dst: the DHCP server IP address 1628 * @vid: VLAN identifier 1629 * 1630 * Adds given MAC/IP pairs to the local DAT cache and propagates them further 1631 * into the DHT. 1632 * 1633 * For the DHT propagation, client MAC + IP will appear as the ARP Reply 1634 * transmitter (and hw_dst/ip_dst as the target). 1635 */ 1636 static void batadv_dat_put_dhcp(struct batadv_priv *bat_priv, u8 *chaddr, 1637 __be32 yiaddr, u8 *hw_dst, __be32 ip_dst, 1638 unsigned short vid) 1639 { 1640 struct sk_buff *skb; 1641 1642 skb = batadv_dat_arp_create_reply(bat_priv, yiaddr, ip_dst, chaddr, 1643 hw_dst, vid); 1644 if (!skb) 1645 return; 1646 1647 skb_set_network_header(skb, ETH_HLEN); 1648 1649 batadv_dat_entry_add(bat_priv, yiaddr, chaddr, vid); 1650 batadv_dat_entry_add(bat_priv, ip_dst, hw_dst, vid); 1651 1652 batadv_dat_forward_data(bat_priv, skb, yiaddr, vid, 1653 BATADV_P_DAT_DHT_PUT); 1654 batadv_dat_forward_data(bat_priv, skb, ip_dst, vid, 1655 BATADV_P_DAT_DHT_PUT); 1656 1657 consume_skb(skb); 1658 1659 batadv_dbg(BATADV_DBG_DAT, bat_priv, 1660 "Snooped from outgoing DHCPACK (server address): %pI4, %pM (vid: %i)\n", 1661 &ip_dst, hw_dst, batadv_print_vid(vid)); 1662 batadv_dbg(BATADV_DBG_DAT, bat_priv, 1663 "Snooped from outgoing DHCPACK (client address): %pI4, %pM (vid: %i)\n", 1664 &yiaddr, chaddr, batadv_print_vid(vid)); 1665 } 1666 1667 /** 1668 * batadv_dat_check_dhcp_ack() - examine packet for valid DHCP message 1669 * @skb: the packet to check 1670 * @proto: ethernet protocol hint (behind a potential vlan) 1671 * @ip_src: a buffer to store the IPv4 source address in 1672 * @chaddr: a buffer to store the DHCP Client Hardware Address in 1673 * @yiaddr: a buffer to store the DHCP Your IP Address in 1674 * 1675 * Checks whether the given skb is a valid DHCPACK. And if so, stores the 1676 * IPv4 server source address (ip_src), client MAC address (chaddr) and client 1677 * IPv4 address (yiaddr) in the provided buffers. 1678 * 1679 * Caller needs to ensure that the skb network header is set correctly. 1680 * 1681 * Return: True if the skb is a valid DHCPACK. False otherwise. 1682 */ 1683 static bool 1684 batadv_dat_check_dhcp_ack(struct sk_buff *skb, __be16 proto, __be32 *ip_src, 1685 u8 *chaddr, __be32 *yiaddr) 1686 { 1687 int type; 1688 1689 type = batadv_dat_check_dhcp(skb, proto, ip_src); 1690 if (type != BATADV_BOOTREPLY) 1691 return false; 1692 1693 type = batadv_dat_get_dhcp_message_type(skb); 1694 if (type != BATADV_DHCPACK) 1695 return false; 1696 1697 if (!batadv_dat_dhcp_get_yiaddr(skb, yiaddr)) 1698 return false; 1699 1700 if (!batadv_dat_get_dhcp_chaddr(skb, chaddr)) 1701 return false; 1702 1703 return true; 1704 } 1705 1706 /** 1707 * batadv_dat_snoop_outgoing_dhcp_ack() - snoop DHCPACK and fill DAT with it 1708 * @bat_priv: the bat priv with all the soft interface information 1709 * @skb: the packet to snoop 1710 * @proto: ethernet protocol hint (behind a potential vlan) 1711 * @vid: VLAN identifier 1712 * 1713 * This function first checks whether the given skb is a valid DHCPACK. If 1714 * so then its source MAC and IP as well as its DHCP Client Hardware Address 1715 * field and DHCP Your IP Address field are added to the local DAT cache and 1716 * propagated into the DHT. 1717 * 1718 * Caller needs to ensure that the skb mac and network headers are set 1719 * correctly. 1720 */ 1721 void batadv_dat_snoop_outgoing_dhcp_ack(struct batadv_priv *bat_priv, 1722 struct sk_buff *skb, 1723 __be16 proto, 1724 unsigned short vid) 1725 { 1726 u8 chaddr[BATADV_DHCP_CHADDR_LEN]; 1727 __be32 ip_src, yiaddr; 1728 1729 if (!atomic_read(&bat_priv->distributed_arp_table)) 1730 return; 1731 1732 if (!batadv_dat_check_dhcp_ack(skb, proto, &ip_src, chaddr, &yiaddr)) 1733 return; 1734 1735 batadv_dat_put_dhcp(bat_priv, chaddr, yiaddr, eth_hdr(skb)->h_source, 1736 ip_src, vid); 1737 } 1738 1739 /** 1740 * batadv_dat_snoop_incoming_dhcp_ack() - snoop DHCPACK and fill DAT cache 1741 * @bat_priv: the bat priv with all the soft interface information 1742 * @skb: the packet to snoop 1743 * @hdr_size: header size, up to the tail of the batman-adv header 1744 * 1745 * This function first checks whether the given skb is a valid DHCPACK. If 1746 * so then its source MAC and IP as well as its DHCP Client Hardware Address 1747 * field and DHCP Your IP Address field are added to the local DAT cache. 1748 */ 1749 void batadv_dat_snoop_incoming_dhcp_ack(struct batadv_priv *bat_priv, 1750 struct sk_buff *skb, int hdr_size) 1751 { 1752 u8 chaddr[BATADV_DHCP_CHADDR_LEN]; 1753 struct ethhdr *ethhdr; 1754 __be32 ip_src, yiaddr; 1755 unsigned short vid; 1756 __be16 proto; 1757 u8 *hw_src; 1758 1759 if (!atomic_read(&bat_priv->distributed_arp_table)) 1760 return; 1761 1762 if (unlikely(!pskb_may_pull(skb, hdr_size + ETH_HLEN))) 1763 return; 1764 1765 ethhdr = (struct ethhdr *)(skb->data + hdr_size); 1766 skb_set_network_header(skb, hdr_size + ETH_HLEN); 1767 proto = ethhdr->h_proto; 1768 1769 if (!batadv_dat_check_dhcp_ack(skb, proto, &ip_src, chaddr, &yiaddr)) 1770 return; 1771 1772 hw_src = ethhdr->h_source; 1773 vid = batadv_dat_get_vid(skb, &hdr_size); 1774 1775 batadv_dat_entry_add(bat_priv, yiaddr, chaddr, vid); 1776 batadv_dat_entry_add(bat_priv, ip_src, hw_src, vid); 1777 1778 batadv_dbg(BATADV_DBG_DAT, bat_priv, 1779 "Snooped from incoming DHCPACK (server address): %pI4, %pM (vid: %i)\n", 1780 &ip_src, hw_src, batadv_print_vid(vid)); 1781 batadv_dbg(BATADV_DBG_DAT, bat_priv, 1782 "Snooped from incoming DHCPACK (client address): %pI4, %pM (vid: %i)\n", 1783 &yiaddr, chaddr, batadv_print_vid(vid)); 1784 } 1785 1786 /** 1787 * batadv_dat_drop_broadcast_packet() - check if an ARP request has to be 1788 * dropped (because the node has already obtained the reply via DAT) or not 1789 * @bat_priv: the bat priv with all the soft interface information 1790 * @forw_packet: the broadcast packet 1791 * 1792 * Return: true if the node can drop the packet, false otherwise. 1793 */ 1794 bool batadv_dat_drop_broadcast_packet(struct batadv_priv *bat_priv, 1795 struct batadv_forw_packet *forw_packet) 1796 { 1797 u16 type; 1798 __be32 ip_dst; 1799 struct batadv_dat_entry *dat_entry = NULL; 1800 bool ret = false; 1801 int hdr_size = sizeof(struct batadv_bcast_packet); 1802 unsigned short vid; 1803 1804 if (!atomic_read(&bat_priv->distributed_arp_table)) 1805 goto out; 1806 1807 /* If this packet is an ARP_REQUEST and the node already has the 1808 * information that it is going to ask, then the packet can be dropped 1809 */ 1810 if (batadv_forw_packet_is_rebroadcast(forw_packet)) 1811 goto out; 1812 1813 vid = batadv_dat_get_vid(forw_packet->skb, &hdr_size); 1814 1815 type = batadv_arp_get_type(bat_priv, forw_packet->skb, hdr_size); 1816 if (type != ARPOP_REQUEST) 1817 goto out; 1818 1819 ip_dst = batadv_arp_ip_dst(forw_packet->skb, hdr_size); 1820 dat_entry = batadv_dat_entry_hash_find(bat_priv, ip_dst, vid); 1821 /* check if the node already got this entry */ 1822 if (!dat_entry) { 1823 batadv_dbg(BATADV_DBG_DAT, bat_priv, 1824 "ARP Request for %pI4: fallback\n", &ip_dst); 1825 goto out; 1826 } 1827 1828 batadv_dbg(BATADV_DBG_DAT, bat_priv, 1829 "ARP Request for %pI4: fallback prevented\n", &ip_dst); 1830 ret = true; 1831 1832 out: 1833 if (dat_entry) 1834 batadv_dat_entry_put(dat_entry); 1835 return ret; 1836 } 1837