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