1 /* Copyright (C) 2007-2016 B.A.T.M.A.N. contributors: 2 * 3 * Marek Lindner, Simon Wunderlich, Antonio Quartulli 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of version 2 of the GNU General Public 7 * License as published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it will be useful, but 10 * WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 * General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, see <http://www.gnu.org/licenses/>. 16 */ 17 18 #include "translation-table.h" 19 #include "main.h" 20 21 #include <linux/atomic.h> 22 #include <linux/bitops.h> 23 #include <linux/bug.h> 24 #include <linux/byteorder/generic.h> 25 #include <linux/compiler.h> 26 #include <linux/crc32c.h> 27 #include <linux/errno.h> 28 #include <linux/etherdevice.h> 29 #include <linux/fs.h> 30 #include <linux/if_ether.h> 31 #include <linux/jhash.h> 32 #include <linux/jiffies.h> 33 #include <linux/kernel.h> 34 #include <linux/kref.h> 35 #include <linux/list.h> 36 #include <linux/lockdep.h> 37 #include <linux/netdevice.h> 38 #include <linux/rculist.h> 39 #include <linux/rcupdate.h> 40 #include <linux/seq_file.h> 41 #include <linux/slab.h> 42 #include <linux/spinlock.h> 43 #include <linux/stddef.h> 44 #include <linux/string.h> 45 #include <linux/workqueue.h> 46 47 #include "bridge_loop_avoidance.h" 48 #include "hard-interface.h" 49 #include "hash.h" 50 #include "multicast.h" 51 #include "originator.h" 52 #include "packet.h" 53 #include "soft-interface.h" 54 55 /* hash class keys */ 56 static struct lock_class_key batadv_tt_local_hash_lock_class_key; 57 static struct lock_class_key batadv_tt_global_hash_lock_class_key; 58 59 static void batadv_send_roam_adv(struct batadv_priv *bat_priv, u8 *client, 60 unsigned short vid, 61 struct batadv_orig_node *orig_node); 62 static void batadv_tt_purge(struct work_struct *work); 63 static void 64 batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry); 65 static void batadv_tt_global_del(struct batadv_priv *bat_priv, 66 struct batadv_orig_node *orig_node, 67 const unsigned char *addr, 68 unsigned short vid, const char *message, 69 bool roaming); 70 71 /** 72 * batadv_compare_tt - check if two TT entries are the same 73 * @node: the list element pointer of the first TT entry 74 * @data2: pointer to the tt_common_entry of the second TT entry 75 * 76 * Compare the MAC address and the VLAN ID of the two TT entries and check if 77 * they are the same TT client. 78 * Return: true if the two TT clients are the same, false otherwise 79 */ 80 static bool batadv_compare_tt(const struct hlist_node *node, const void *data2) 81 { 82 const void *data1 = container_of(node, struct batadv_tt_common_entry, 83 hash_entry); 84 const struct batadv_tt_common_entry *tt1 = data1; 85 const struct batadv_tt_common_entry *tt2 = data2; 86 87 return (tt1->vid == tt2->vid) && batadv_compare_eth(data1, data2); 88 } 89 90 /** 91 * batadv_choose_tt - return the index of the tt entry in the hash table 92 * @data: pointer to the tt_common_entry object to map 93 * @size: the size of the hash table 94 * 95 * Return: the hash index where the object represented by 'data' should be 96 * stored at. 97 */ 98 static inline u32 batadv_choose_tt(const void *data, u32 size) 99 { 100 struct batadv_tt_common_entry *tt; 101 u32 hash = 0; 102 103 tt = (struct batadv_tt_common_entry *)data; 104 hash = jhash(&tt->addr, ETH_ALEN, hash); 105 hash = jhash(&tt->vid, sizeof(tt->vid), hash); 106 107 return hash % size; 108 } 109 110 /** 111 * batadv_tt_hash_find - look for a client in the given hash table 112 * @hash: the hash table to search 113 * @addr: the mac address of the client to look for 114 * @vid: VLAN identifier 115 * 116 * Return: a pointer to the tt_common struct belonging to the searched client if 117 * found, NULL otherwise. 118 */ 119 static struct batadv_tt_common_entry * 120 batadv_tt_hash_find(struct batadv_hashtable *hash, const u8 *addr, 121 unsigned short vid) 122 { 123 struct hlist_head *head; 124 struct batadv_tt_common_entry to_search, *tt, *tt_tmp = NULL; 125 u32 index; 126 127 if (!hash) 128 return NULL; 129 130 ether_addr_copy(to_search.addr, addr); 131 to_search.vid = vid; 132 133 index = batadv_choose_tt(&to_search, hash->size); 134 head = &hash->table[index]; 135 136 rcu_read_lock(); 137 hlist_for_each_entry_rcu(tt, head, hash_entry) { 138 if (!batadv_compare_eth(tt, addr)) 139 continue; 140 141 if (tt->vid != vid) 142 continue; 143 144 if (!kref_get_unless_zero(&tt->refcount)) 145 continue; 146 147 tt_tmp = tt; 148 break; 149 } 150 rcu_read_unlock(); 151 152 return tt_tmp; 153 } 154 155 /** 156 * batadv_tt_local_hash_find - search the local table for a given client 157 * @bat_priv: the bat priv with all the soft interface information 158 * @addr: the mac address of the client to look for 159 * @vid: VLAN identifier 160 * 161 * Return: a pointer to the corresponding tt_local_entry struct if the client is 162 * found, NULL otherwise. 163 */ 164 static struct batadv_tt_local_entry * 165 batadv_tt_local_hash_find(struct batadv_priv *bat_priv, const u8 *addr, 166 unsigned short vid) 167 { 168 struct batadv_tt_common_entry *tt_common_entry; 169 struct batadv_tt_local_entry *tt_local_entry = NULL; 170 171 tt_common_entry = batadv_tt_hash_find(bat_priv->tt.local_hash, addr, 172 vid); 173 if (tt_common_entry) 174 tt_local_entry = container_of(tt_common_entry, 175 struct batadv_tt_local_entry, 176 common); 177 return tt_local_entry; 178 } 179 180 /** 181 * batadv_tt_global_hash_find - search the global table for a given client 182 * @bat_priv: the bat priv with all the soft interface information 183 * @addr: the mac address of the client to look for 184 * @vid: VLAN identifier 185 * 186 * Return: a pointer to the corresponding tt_global_entry struct if the client 187 * is found, NULL otherwise. 188 */ 189 static struct batadv_tt_global_entry * 190 batadv_tt_global_hash_find(struct batadv_priv *bat_priv, const u8 *addr, 191 unsigned short vid) 192 { 193 struct batadv_tt_common_entry *tt_common_entry; 194 struct batadv_tt_global_entry *tt_global_entry = NULL; 195 196 tt_common_entry = batadv_tt_hash_find(bat_priv->tt.global_hash, addr, 197 vid); 198 if (tt_common_entry) 199 tt_global_entry = container_of(tt_common_entry, 200 struct batadv_tt_global_entry, 201 common); 202 return tt_global_entry; 203 } 204 205 /** 206 * batadv_tt_local_entry_release - release tt_local_entry from lists and queue 207 * for free after rcu grace period 208 * @ref: kref pointer of the nc_node 209 */ 210 static void batadv_tt_local_entry_release(struct kref *ref) 211 { 212 struct batadv_tt_local_entry *tt_local_entry; 213 214 tt_local_entry = container_of(ref, struct batadv_tt_local_entry, 215 common.refcount); 216 217 batadv_softif_vlan_put(tt_local_entry->vlan); 218 219 kfree_rcu(tt_local_entry, common.rcu); 220 } 221 222 /** 223 * batadv_tt_local_entry_put - decrement the tt_local_entry refcounter and 224 * possibly release it 225 * @tt_local_entry: tt_local_entry to be free'd 226 */ 227 static void 228 batadv_tt_local_entry_put(struct batadv_tt_local_entry *tt_local_entry) 229 { 230 kref_put(&tt_local_entry->common.refcount, 231 batadv_tt_local_entry_release); 232 } 233 234 /** 235 * batadv_tt_global_entry_release - release tt_global_entry from lists and queue 236 * for free after rcu grace period 237 * @ref: kref pointer of the nc_node 238 */ 239 static void batadv_tt_global_entry_release(struct kref *ref) 240 { 241 struct batadv_tt_global_entry *tt_global_entry; 242 243 tt_global_entry = container_of(ref, struct batadv_tt_global_entry, 244 common.refcount); 245 246 batadv_tt_global_del_orig_list(tt_global_entry); 247 kfree_rcu(tt_global_entry, common.rcu); 248 } 249 250 /** 251 * batadv_tt_global_entry_put - decrement the tt_global_entry refcounter and 252 * possibly release it 253 * @tt_global_entry: tt_global_entry to be free'd 254 */ 255 static void 256 batadv_tt_global_entry_put(struct batadv_tt_global_entry *tt_global_entry) 257 { 258 kref_put(&tt_global_entry->common.refcount, 259 batadv_tt_global_entry_release); 260 } 261 262 /** 263 * batadv_tt_global_hash_count - count the number of orig entries 264 * @bat_priv: the bat priv with all the soft interface information 265 * @addr: the mac address of the client to count entries for 266 * @vid: VLAN identifier 267 * 268 * Return: the number of originators advertising the given address/data 269 * (excluding ourself). 270 */ 271 int batadv_tt_global_hash_count(struct batadv_priv *bat_priv, 272 const u8 *addr, unsigned short vid) 273 { 274 struct batadv_tt_global_entry *tt_global_entry; 275 int count; 276 277 tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid); 278 if (!tt_global_entry) 279 return 0; 280 281 count = atomic_read(&tt_global_entry->orig_list_count); 282 batadv_tt_global_entry_put(tt_global_entry); 283 284 return count; 285 } 286 287 /** 288 * batadv_tt_local_size_mod - change the size by v of the local table identified 289 * by vid 290 * @bat_priv: the bat priv with all the soft interface information 291 * @vid: the VLAN identifier of the sub-table to change 292 * @v: the amount to sum to the local table size 293 */ 294 static void batadv_tt_local_size_mod(struct batadv_priv *bat_priv, 295 unsigned short vid, int v) 296 { 297 struct batadv_softif_vlan *vlan; 298 299 vlan = batadv_softif_vlan_get(bat_priv, vid); 300 if (!vlan) 301 return; 302 303 atomic_add(v, &vlan->tt.num_entries); 304 305 batadv_softif_vlan_put(vlan); 306 } 307 308 /** 309 * batadv_tt_local_size_inc - increase by one the local table size for the given 310 * vid 311 * @bat_priv: the bat priv with all the soft interface information 312 * @vid: the VLAN identifier 313 */ 314 static void batadv_tt_local_size_inc(struct batadv_priv *bat_priv, 315 unsigned short vid) 316 { 317 batadv_tt_local_size_mod(bat_priv, vid, 1); 318 } 319 320 /** 321 * batadv_tt_local_size_dec - decrease by one the local table size for the given 322 * vid 323 * @bat_priv: the bat priv with all the soft interface information 324 * @vid: the VLAN identifier 325 */ 326 static void batadv_tt_local_size_dec(struct batadv_priv *bat_priv, 327 unsigned short vid) 328 { 329 batadv_tt_local_size_mod(bat_priv, vid, -1); 330 } 331 332 /** 333 * batadv_tt_global_size_mod - change the size by v of the global table 334 * for orig_node identified by vid 335 * @orig_node: the originator for which the table has to be modified 336 * @vid: the VLAN identifier 337 * @v: the amount to sum to the global table size 338 */ 339 static void batadv_tt_global_size_mod(struct batadv_orig_node *orig_node, 340 unsigned short vid, int v) 341 { 342 struct batadv_orig_node_vlan *vlan; 343 344 vlan = batadv_orig_node_vlan_new(orig_node, vid); 345 if (!vlan) 346 return; 347 348 if (atomic_add_return(v, &vlan->tt.num_entries) == 0) { 349 spin_lock_bh(&orig_node->vlan_list_lock); 350 if (!hlist_unhashed(&vlan->list)) { 351 hlist_del_init_rcu(&vlan->list); 352 batadv_orig_node_vlan_put(vlan); 353 } 354 spin_unlock_bh(&orig_node->vlan_list_lock); 355 } 356 357 batadv_orig_node_vlan_put(vlan); 358 } 359 360 /** 361 * batadv_tt_global_size_inc - increase by one the global table size for the 362 * given vid 363 * @orig_node: the originator which global table size has to be decreased 364 * @vid: the vlan identifier 365 */ 366 static void batadv_tt_global_size_inc(struct batadv_orig_node *orig_node, 367 unsigned short vid) 368 { 369 batadv_tt_global_size_mod(orig_node, vid, 1); 370 } 371 372 /** 373 * batadv_tt_global_size_dec - decrease by one the global table size for the 374 * given vid 375 * @orig_node: the originator which global table size has to be decreased 376 * @vid: the vlan identifier 377 */ 378 static void batadv_tt_global_size_dec(struct batadv_orig_node *orig_node, 379 unsigned short vid) 380 { 381 batadv_tt_global_size_mod(orig_node, vid, -1); 382 } 383 384 /** 385 * batadv_tt_orig_list_entry_release - release tt orig entry from lists and 386 * queue for free after rcu grace period 387 * @ref: kref pointer of the tt orig entry 388 */ 389 static void batadv_tt_orig_list_entry_release(struct kref *ref) 390 { 391 struct batadv_tt_orig_list_entry *orig_entry; 392 393 orig_entry = container_of(ref, struct batadv_tt_orig_list_entry, 394 refcount); 395 396 batadv_orig_node_put(orig_entry->orig_node); 397 kfree_rcu(orig_entry, rcu); 398 } 399 400 /** 401 * batadv_tt_orig_list_entry_put - decrement the tt orig entry refcounter and 402 * possibly release it 403 * @orig_entry: tt orig entry to be free'd 404 */ 405 static void 406 batadv_tt_orig_list_entry_put(struct batadv_tt_orig_list_entry *orig_entry) 407 { 408 kref_put(&orig_entry->refcount, batadv_tt_orig_list_entry_release); 409 } 410 411 /** 412 * batadv_tt_local_event - store a local TT event (ADD/DEL) 413 * @bat_priv: the bat priv with all the soft interface information 414 * @tt_local_entry: the TT entry involved in the event 415 * @event_flags: flags to store in the event structure 416 */ 417 static void batadv_tt_local_event(struct batadv_priv *bat_priv, 418 struct batadv_tt_local_entry *tt_local_entry, 419 u8 event_flags) 420 { 421 struct batadv_tt_change_node *tt_change_node, *entry, *safe; 422 struct batadv_tt_common_entry *common = &tt_local_entry->common; 423 u8 flags = common->flags | event_flags; 424 bool event_removed = false; 425 bool del_op_requested, del_op_entry; 426 427 tt_change_node = kmalloc(sizeof(*tt_change_node), GFP_ATOMIC); 428 if (!tt_change_node) 429 return; 430 431 tt_change_node->change.flags = flags; 432 memset(tt_change_node->change.reserved, 0, 433 sizeof(tt_change_node->change.reserved)); 434 ether_addr_copy(tt_change_node->change.addr, common->addr); 435 tt_change_node->change.vid = htons(common->vid); 436 437 del_op_requested = flags & BATADV_TT_CLIENT_DEL; 438 439 /* check for ADD+DEL or DEL+ADD events */ 440 spin_lock_bh(&bat_priv->tt.changes_list_lock); 441 list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list, 442 list) { 443 if (!batadv_compare_eth(entry->change.addr, common->addr)) 444 continue; 445 446 /* DEL+ADD in the same orig interval have no effect and can be 447 * removed to avoid silly behaviour on the receiver side. The 448 * other way around (ADD+DEL) can happen in case of roaming of 449 * a client still in the NEW state. Roaming of NEW clients is 450 * now possible due to automatically recognition of "temporary" 451 * clients 452 */ 453 del_op_entry = entry->change.flags & BATADV_TT_CLIENT_DEL; 454 if (!del_op_requested && del_op_entry) 455 goto del; 456 if (del_op_requested && !del_op_entry) 457 goto del; 458 459 /* this is a second add in the same originator interval. It 460 * means that flags have been changed: update them! 461 */ 462 if (!del_op_requested && !del_op_entry) 463 entry->change.flags = flags; 464 465 continue; 466 del: 467 list_del(&entry->list); 468 kfree(entry); 469 kfree(tt_change_node); 470 event_removed = true; 471 goto unlock; 472 } 473 474 /* track the change in the OGMinterval list */ 475 list_add_tail(&tt_change_node->list, &bat_priv->tt.changes_list); 476 477 unlock: 478 spin_unlock_bh(&bat_priv->tt.changes_list_lock); 479 480 if (event_removed) 481 atomic_dec(&bat_priv->tt.local_changes); 482 else 483 atomic_inc(&bat_priv->tt.local_changes); 484 } 485 486 /** 487 * batadv_tt_len - compute length in bytes of given number of tt changes 488 * @changes_num: number of tt changes 489 * 490 * Return: computed length in bytes. 491 */ 492 static int batadv_tt_len(int changes_num) 493 { 494 return changes_num * sizeof(struct batadv_tvlv_tt_change); 495 } 496 497 /** 498 * batadv_tt_entries - compute the number of entries fitting in tt_len bytes 499 * @tt_len: available space 500 * 501 * Return: the number of entries. 502 */ 503 static u16 batadv_tt_entries(u16 tt_len) 504 { 505 return tt_len / batadv_tt_len(1); 506 } 507 508 /** 509 * batadv_tt_local_table_transmit_size - calculates the local translation table 510 * size when transmitted over the air 511 * @bat_priv: the bat priv with all the soft interface information 512 * 513 * Return: local translation table size in bytes. 514 */ 515 static int batadv_tt_local_table_transmit_size(struct batadv_priv *bat_priv) 516 { 517 u16 num_vlan = 0; 518 u16 tt_local_entries = 0; 519 struct batadv_softif_vlan *vlan; 520 int hdr_size; 521 522 rcu_read_lock(); 523 hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) { 524 num_vlan++; 525 tt_local_entries += atomic_read(&vlan->tt.num_entries); 526 } 527 rcu_read_unlock(); 528 529 /* header size of tvlv encapsulated tt response payload */ 530 hdr_size = sizeof(struct batadv_unicast_tvlv_packet); 531 hdr_size += sizeof(struct batadv_tvlv_hdr); 532 hdr_size += sizeof(struct batadv_tvlv_tt_data); 533 hdr_size += num_vlan * sizeof(struct batadv_tvlv_tt_vlan_data); 534 535 return hdr_size + batadv_tt_len(tt_local_entries); 536 } 537 538 static int batadv_tt_local_init(struct batadv_priv *bat_priv) 539 { 540 if (bat_priv->tt.local_hash) 541 return 0; 542 543 bat_priv->tt.local_hash = batadv_hash_new(1024); 544 545 if (!bat_priv->tt.local_hash) 546 return -ENOMEM; 547 548 batadv_hash_set_lock_class(bat_priv->tt.local_hash, 549 &batadv_tt_local_hash_lock_class_key); 550 551 return 0; 552 } 553 554 static void batadv_tt_global_free(struct batadv_priv *bat_priv, 555 struct batadv_tt_global_entry *tt_global, 556 const char *message) 557 { 558 batadv_dbg(BATADV_DBG_TT, bat_priv, 559 "Deleting global tt entry %pM (vid: %d): %s\n", 560 tt_global->common.addr, 561 BATADV_PRINT_VID(tt_global->common.vid), message); 562 563 batadv_hash_remove(bat_priv->tt.global_hash, batadv_compare_tt, 564 batadv_choose_tt, &tt_global->common); 565 batadv_tt_global_entry_put(tt_global); 566 } 567 568 /** 569 * batadv_tt_local_add - add a new client to the local table or update an 570 * existing client 571 * @soft_iface: netdev struct of the mesh interface 572 * @addr: the mac address of the client to add 573 * @vid: VLAN identifier 574 * @ifindex: index of the interface where the client is connected to (useful to 575 * identify wireless clients) 576 * @mark: the value contained in the skb->mark field of the received packet (if 577 * any) 578 * 579 * Return: true if the client was successfully added, false otherwise. 580 */ 581 bool batadv_tt_local_add(struct net_device *soft_iface, const u8 *addr, 582 unsigned short vid, int ifindex, u32 mark) 583 { 584 struct batadv_priv *bat_priv = netdev_priv(soft_iface); 585 struct batadv_tt_local_entry *tt_local; 586 struct batadv_tt_global_entry *tt_global = NULL; 587 struct net *net = dev_net(soft_iface); 588 struct batadv_softif_vlan *vlan; 589 struct net_device *in_dev = NULL; 590 struct hlist_head *head; 591 struct batadv_tt_orig_list_entry *orig_entry; 592 int hash_added, table_size, packet_size_max; 593 bool ret = false; 594 bool roamed_back = false; 595 u8 remote_flags; 596 u32 match_mark; 597 598 if (ifindex != BATADV_NULL_IFINDEX) 599 in_dev = dev_get_by_index(net, ifindex); 600 601 tt_local = batadv_tt_local_hash_find(bat_priv, addr, vid); 602 603 if (!is_multicast_ether_addr(addr)) 604 tt_global = batadv_tt_global_hash_find(bat_priv, addr, vid); 605 606 if (tt_local) { 607 tt_local->last_seen = jiffies; 608 if (tt_local->common.flags & BATADV_TT_CLIENT_PENDING) { 609 batadv_dbg(BATADV_DBG_TT, bat_priv, 610 "Re-adding pending client %pM (vid: %d)\n", 611 addr, BATADV_PRINT_VID(vid)); 612 /* whatever the reason why the PENDING flag was set, 613 * this is a client which was enqueued to be removed in 614 * this orig_interval. Since it popped up again, the 615 * flag can be reset like it was never enqueued 616 */ 617 tt_local->common.flags &= ~BATADV_TT_CLIENT_PENDING; 618 goto add_event; 619 } 620 621 if (tt_local->common.flags & BATADV_TT_CLIENT_ROAM) { 622 batadv_dbg(BATADV_DBG_TT, bat_priv, 623 "Roaming client %pM (vid: %d) came back to its original location\n", 624 addr, BATADV_PRINT_VID(vid)); 625 /* the ROAM flag is set because this client roamed away 626 * and the node got a roaming_advertisement message. Now 627 * that the client popped up again at its original 628 * location such flag can be unset 629 */ 630 tt_local->common.flags &= ~BATADV_TT_CLIENT_ROAM; 631 roamed_back = true; 632 } 633 goto check_roaming; 634 } 635 636 /* Ignore the client if we cannot send it in a full table response. */ 637 table_size = batadv_tt_local_table_transmit_size(bat_priv); 638 table_size += batadv_tt_len(1); 639 packet_size_max = atomic_read(&bat_priv->packet_size_max); 640 if (table_size > packet_size_max) { 641 net_ratelimited_function(batadv_info, soft_iface, 642 "Local translation table size (%i) exceeds maximum packet size (%i); Ignoring new local tt entry: %pM\n", 643 table_size, packet_size_max, addr); 644 goto out; 645 } 646 647 tt_local = kmalloc(sizeof(*tt_local), GFP_ATOMIC); 648 if (!tt_local) 649 goto out; 650 651 /* increase the refcounter of the related vlan */ 652 vlan = batadv_softif_vlan_get(bat_priv, vid); 653 if (WARN(!vlan, "adding TT local entry %pM to non-existent VLAN %d", 654 addr, BATADV_PRINT_VID(vid))) { 655 kfree(tt_local); 656 tt_local = NULL; 657 goto out; 658 } 659 660 batadv_dbg(BATADV_DBG_TT, bat_priv, 661 "Creating new local tt entry: %pM (vid: %d, ttvn: %d)\n", 662 addr, BATADV_PRINT_VID(vid), 663 (u8)atomic_read(&bat_priv->tt.vn)); 664 665 ether_addr_copy(tt_local->common.addr, addr); 666 /* The local entry has to be marked as NEW to avoid to send it in 667 * a full table response going out before the next ttvn increment 668 * (consistency check) 669 */ 670 tt_local->common.flags = BATADV_TT_CLIENT_NEW; 671 tt_local->common.vid = vid; 672 if (batadv_is_wifi_netdev(in_dev)) 673 tt_local->common.flags |= BATADV_TT_CLIENT_WIFI; 674 kref_init(&tt_local->common.refcount); 675 kref_get(&tt_local->common.refcount); 676 tt_local->last_seen = jiffies; 677 tt_local->common.added_at = tt_local->last_seen; 678 tt_local->vlan = vlan; 679 680 /* the batman interface mac and multicast addresses should never be 681 * purged 682 */ 683 if (batadv_compare_eth(addr, soft_iface->dev_addr) || 684 is_multicast_ether_addr(addr)) 685 tt_local->common.flags |= BATADV_TT_CLIENT_NOPURGE; 686 687 hash_added = batadv_hash_add(bat_priv->tt.local_hash, batadv_compare_tt, 688 batadv_choose_tt, &tt_local->common, 689 &tt_local->common.hash_entry); 690 691 if (unlikely(hash_added != 0)) { 692 /* remove the reference for the hash */ 693 batadv_tt_local_entry_put(tt_local); 694 batadv_softif_vlan_put(vlan); 695 goto out; 696 } 697 698 add_event: 699 batadv_tt_local_event(bat_priv, tt_local, BATADV_NO_FLAGS); 700 701 check_roaming: 702 /* Check whether it is a roaming, but don't do anything if the roaming 703 * process has already been handled 704 */ 705 if (tt_global && !(tt_global->common.flags & BATADV_TT_CLIENT_ROAM)) { 706 /* These node are probably going to update their tt table */ 707 head = &tt_global->orig_list; 708 rcu_read_lock(); 709 hlist_for_each_entry_rcu(orig_entry, head, list) { 710 batadv_send_roam_adv(bat_priv, tt_global->common.addr, 711 tt_global->common.vid, 712 orig_entry->orig_node); 713 } 714 rcu_read_unlock(); 715 if (roamed_back) { 716 batadv_tt_global_free(bat_priv, tt_global, 717 "Roaming canceled"); 718 tt_global = NULL; 719 } else { 720 /* The global entry has to be marked as ROAMING and 721 * has to be kept for consistency purpose 722 */ 723 tt_global->common.flags |= BATADV_TT_CLIENT_ROAM; 724 tt_global->roam_at = jiffies; 725 } 726 } 727 728 /* store the current remote flags before altering them. This helps 729 * understanding is flags are changing or not 730 */ 731 remote_flags = tt_local->common.flags & BATADV_TT_REMOTE_MASK; 732 733 if (batadv_is_wifi_netdev(in_dev)) 734 tt_local->common.flags |= BATADV_TT_CLIENT_WIFI; 735 else 736 tt_local->common.flags &= ~BATADV_TT_CLIENT_WIFI; 737 738 /* check the mark in the skb: if it's equal to the configured 739 * isolation_mark, it means the packet is coming from an isolated 740 * non-mesh client 741 */ 742 match_mark = (mark & bat_priv->isolation_mark_mask); 743 if (bat_priv->isolation_mark_mask && 744 match_mark == bat_priv->isolation_mark) 745 tt_local->common.flags |= BATADV_TT_CLIENT_ISOLA; 746 else 747 tt_local->common.flags &= ~BATADV_TT_CLIENT_ISOLA; 748 749 /* if any "dynamic" flag has been modified, resend an ADD event for this 750 * entry so that all the nodes can get the new flags 751 */ 752 if (remote_flags ^ (tt_local->common.flags & BATADV_TT_REMOTE_MASK)) 753 batadv_tt_local_event(bat_priv, tt_local, BATADV_NO_FLAGS); 754 755 ret = true; 756 out: 757 if (in_dev) 758 dev_put(in_dev); 759 if (tt_local) 760 batadv_tt_local_entry_put(tt_local); 761 if (tt_global) 762 batadv_tt_global_entry_put(tt_global); 763 return ret; 764 } 765 766 /** 767 * batadv_tt_prepare_tvlv_global_data - prepare the TVLV TT header to send 768 * within a TT Response directed to another node 769 * @orig_node: originator for which the TT data has to be prepared 770 * @tt_data: uninitialised pointer to the address of the TVLV buffer 771 * @tt_change: uninitialised pointer to the address of the area where the TT 772 * changed can be stored 773 * @tt_len: pointer to the length to reserve to the tt_change. if -1 this 774 * function reserves the amount of space needed to send the entire global TT 775 * table. In case of success the value is updated with the real amount of 776 * reserved bytes 777 * Allocate the needed amount of memory for the entire TT TVLV and write its 778 * header made up by one tvlv_tt_data object and a series of tvlv_tt_vlan_data 779 * objects, one per active VLAN served by the originator node. 780 * 781 * Return: the size of the allocated buffer or 0 in case of failure. 782 */ 783 static u16 784 batadv_tt_prepare_tvlv_global_data(struct batadv_orig_node *orig_node, 785 struct batadv_tvlv_tt_data **tt_data, 786 struct batadv_tvlv_tt_change **tt_change, 787 s32 *tt_len) 788 { 789 u16 num_vlan = 0; 790 u16 num_entries = 0; 791 u16 change_offset; 792 u16 tvlv_len; 793 struct batadv_tvlv_tt_vlan_data *tt_vlan; 794 struct batadv_orig_node_vlan *vlan; 795 u8 *tt_change_ptr; 796 797 rcu_read_lock(); 798 hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) { 799 num_vlan++; 800 num_entries += atomic_read(&vlan->tt.num_entries); 801 } 802 803 change_offset = sizeof(**tt_data); 804 change_offset += num_vlan * sizeof(*tt_vlan); 805 806 /* if tt_len is negative, allocate the space needed by the full table */ 807 if (*tt_len < 0) 808 *tt_len = batadv_tt_len(num_entries); 809 810 tvlv_len = *tt_len; 811 tvlv_len += change_offset; 812 813 *tt_data = kmalloc(tvlv_len, GFP_ATOMIC); 814 if (!*tt_data) { 815 *tt_len = 0; 816 goto out; 817 } 818 819 (*tt_data)->flags = BATADV_NO_FLAGS; 820 (*tt_data)->ttvn = atomic_read(&orig_node->last_ttvn); 821 (*tt_data)->num_vlan = htons(num_vlan); 822 823 tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(*tt_data + 1); 824 hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) { 825 tt_vlan->vid = htons(vlan->vid); 826 tt_vlan->crc = htonl(vlan->tt.crc); 827 828 tt_vlan++; 829 } 830 831 tt_change_ptr = (u8 *)*tt_data + change_offset; 832 *tt_change = (struct batadv_tvlv_tt_change *)tt_change_ptr; 833 834 out: 835 rcu_read_unlock(); 836 return tvlv_len; 837 } 838 839 /** 840 * batadv_tt_prepare_tvlv_local_data - allocate and prepare the TT TVLV for this 841 * node 842 * @bat_priv: the bat priv with all the soft interface information 843 * @tt_data: uninitialised pointer to the address of the TVLV buffer 844 * @tt_change: uninitialised pointer to the address of the area where the TT 845 * changes can be stored 846 * @tt_len: pointer to the length to reserve to the tt_change. if -1 this 847 * function reserves the amount of space needed to send the entire local TT 848 * table. In case of success the value is updated with the real amount of 849 * reserved bytes 850 * 851 * Allocate the needed amount of memory for the entire TT TVLV and write its 852 * header made up by one tvlv_tt_data object and a series of tvlv_tt_vlan_data 853 * objects, one per active VLAN. 854 * 855 * Return: the size of the allocated buffer or 0 in case of failure. 856 */ 857 static u16 858 batadv_tt_prepare_tvlv_local_data(struct batadv_priv *bat_priv, 859 struct batadv_tvlv_tt_data **tt_data, 860 struct batadv_tvlv_tt_change **tt_change, 861 s32 *tt_len) 862 { 863 struct batadv_tvlv_tt_vlan_data *tt_vlan; 864 struct batadv_softif_vlan *vlan; 865 u16 num_vlan = 0; 866 u16 num_entries = 0; 867 u16 tvlv_len; 868 u8 *tt_change_ptr; 869 int change_offset; 870 871 rcu_read_lock(); 872 hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) { 873 num_vlan++; 874 num_entries += atomic_read(&vlan->tt.num_entries); 875 } 876 877 change_offset = sizeof(**tt_data); 878 change_offset += num_vlan * sizeof(*tt_vlan); 879 880 /* if tt_len is negative, allocate the space needed by the full table */ 881 if (*tt_len < 0) 882 *tt_len = batadv_tt_len(num_entries); 883 884 tvlv_len = *tt_len; 885 tvlv_len += change_offset; 886 887 *tt_data = kmalloc(tvlv_len, GFP_ATOMIC); 888 if (!*tt_data) { 889 tvlv_len = 0; 890 goto out; 891 } 892 893 (*tt_data)->flags = BATADV_NO_FLAGS; 894 (*tt_data)->ttvn = atomic_read(&bat_priv->tt.vn); 895 (*tt_data)->num_vlan = htons(num_vlan); 896 897 tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(*tt_data + 1); 898 hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) { 899 tt_vlan->vid = htons(vlan->vid); 900 tt_vlan->crc = htonl(vlan->tt.crc); 901 902 tt_vlan++; 903 } 904 905 tt_change_ptr = (u8 *)*tt_data + change_offset; 906 *tt_change = (struct batadv_tvlv_tt_change *)tt_change_ptr; 907 908 out: 909 rcu_read_unlock(); 910 return tvlv_len; 911 } 912 913 /** 914 * batadv_tt_tvlv_container_update - update the translation table tvlv container 915 * after local tt changes have been committed 916 * @bat_priv: the bat priv with all the soft interface information 917 */ 918 static void batadv_tt_tvlv_container_update(struct batadv_priv *bat_priv) 919 { 920 struct batadv_tt_change_node *entry, *safe; 921 struct batadv_tvlv_tt_data *tt_data; 922 struct batadv_tvlv_tt_change *tt_change; 923 int tt_diff_len, tt_change_len = 0; 924 int tt_diff_entries_num = 0; 925 int tt_diff_entries_count = 0; 926 u16 tvlv_len; 927 928 tt_diff_entries_num = atomic_read(&bat_priv->tt.local_changes); 929 tt_diff_len = batadv_tt_len(tt_diff_entries_num); 930 931 /* if we have too many changes for one packet don't send any 932 * and wait for the tt table request which will be fragmented 933 */ 934 if (tt_diff_len > bat_priv->soft_iface->mtu) 935 tt_diff_len = 0; 936 937 tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv, &tt_data, 938 &tt_change, &tt_diff_len); 939 if (!tvlv_len) 940 return; 941 942 tt_data->flags = BATADV_TT_OGM_DIFF; 943 944 if (tt_diff_len == 0) 945 goto container_register; 946 947 spin_lock_bh(&bat_priv->tt.changes_list_lock); 948 atomic_set(&bat_priv->tt.local_changes, 0); 949 950 list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list, 951 list) { 952 if (tt_diff_entries_count < tt_diff_entries_num) { 953 memcpy(tt_change + tt_diff_entries_count, 954 &entry->change, 955 sizeof(struct batadv_tvlv_tt_change)); 956 tt_diff_entries_count++; 957 } 958 list_del(&entry->list); 959 kfree(entry); 960 } 961 spin_unlock_bh(&bat_priv->tt.changes_list_lock); 962 963 /* Keep the buffer for possible tt_request */ 964 spin_lock_bh(&bat_priv->tt.last_changeset_lock); 965 kfree(bat_priv->tt.last_changeset); 966 bat_priv->tt.last_changeset_len = 0; 967 bat_priv->tt.last_changeset = NULL; 968 tt_change_len = batadv_tt_len(tt_diff_entries_count); 969 /* check whether this new OGM has no changes due to size problems */ 970 if (tt_diff_entries_count > 0) { 971 /* if kmalloc() fails we will reply with the full table 972 * instead of providing the diff 973 */ 974 bat_priv->tt.last_changeset = kzalloc(tt_diff_len, GFP_ATOMIC); 975 if (bat_priv->tt.last_changeset) { 976 memcpy(bat_priv->tt.last_changeset, 977 tt_change, tt_change_len); 978 bat_priv->tt.last_changeset_len = tt_diff_len; 979 } 980 } 981 spin_unlock_bh(&bat_priv->tt.last_changeset_lock); 982 983 container_register: 984 batadv_tvlv_container_register(bat_priv, BATADV_TVLV_TT, 1, tt_data, 985 tvlv_len); 986 kfree(tt_data); 987 } 988 989 int batadv_tt_local_seq_print_text(struct seq_file *seq, void *offset) 990 { 991 struct net_device *net_dev = (struct net_device *)seq->private; 992 struct batadv_priv *bat_priv = netdev_priv(net_dev); 993 struct batadv_hashtable *hash = bat_priv->tt.local_hash; 994 struct batadv_tt_common_entry *tt_common_entry; 995 struct batadv_tt_local_entry *tt_local; 996 struct batadv_hard_iface *primary_if; 997 struct hlist_head *head; 998 unsigned short vid; 999 u32 i; 1000 int last_seen_secs; 1001 int last_seen_msecs; 1002 unsigned long last_seen_jiffies; 1003 bool no_purge; 1004 u16 np_flag = BATADV_TT_CLIENT_NOPURGE; 1005 1006 primary_if = batadv_seq_print_text_primary_if_get(seq); 1007 if (!primary_if) 1008 goto out; 1009 1010 seq_printf(seq, 1011 "Locally retrieved addresses (from %s) announced via TT (TTVN: %u):\n", 1012 net_dev->name, (u8)atomic_read(&bat_priv->tt.vn)); 1013 seq_puts(seq, 1014 " Client VID Flags Last seen (CRC )\n"); 1015 1016 for (i = 0; i < hash->size; i++) { 1017 head = &hash->table[i]; 1018 1019 rcu_read_lock(); 1020 hlist_for_each_entry_rcu(tt_common_entry, 1021 head, hash_entry) { 1022 tt_local = container_of(tt_common_entry, 1023 struct batadv_tt_local_entry, 1024 common); 1025 vid = tt_common_entry->vid; 1026 last_seen_jiffies = jiffies - tt_local->last_seen; 1027 last_seen_msecs = jiffies_to_msecs(last_seen_jiffies); 1028 last_seen_secs = last_seen_msecs / 1000; 1029 last_seen_msecs = last_seen_msecs % 1000; 1030 1031 no_purge = tt_common_entry->flags & np_flag; 1032 seq_printf(seq, 1033 " * %pM %4i [%c%c%c%c%c%c] %3u.%03u (%#.8x)\n", 1034 tt_common_entry->addr, 1035 BATADV_PRINT_VID(tt_common_entry->vid), 1036 ((tt_common_entry->flags & 1037 BATADV_TT_CLIENT_ROAM) ? 'R' : '.'), 1038 no_purge ? 'P' : '.', 1039 ((tt_common_entry->flags & 1040 BATADV_TT_CLIENT_NEW) ? 'N' : '.'), 1041 ((tt_common_entry->flags & 1042 BATADV_TT_CLIENT_PENDING) ? 'X' : '.'), 1043 ((tt_common_entry->flags & 1044 BATADV_TT_CLIENT_WIFI) ? 'W' : '.'), 1045 ((tt_common_entry->flags & 1046 BATADV_TT_CLIENT_ISOLA) ? 'I' : '.'), 1047 no_purge ? 0 : last_seen_secs, 1048 no_purge ? 0 : last_seen_msecs, 1049 tt_local->vlan->tt.crc); 1050 } 1051 rcu_read_unlock(); 1052 } 1053 out: 1054 if (primary_if) 1055 batadv_hardif_put(primary_if); 1056 return 0; 1057 } 1058 1059 static void 1060 batadv_tt_local_set_pending(struct batadv_priv *bat_priv, 1061 struct batadv_tt_local_entry *tt_local_entry, 1062 u16 flags, const char *message) 1063 { 1064 batadv_tt_local_event(bat_priv, tt_local_entry, flags); 1065 1066 /* The local client has to be marked as "pending to be removed" but has 1067 * to be kept in the table in order to send it in a full table 1068 * response issued before the net ttvn increment (consistency check) 1069 */ 1070 tt_local_entry->common.flags |= BATADV_TT_CLIENT_PENDING; 1071 1072 batadv_dbg(BATADV_DBG_TT, bat_priv, 1073 "Local tt entry (%pM, vid: %d) pending to be removed: %s\n", 1074 tt_local_entry->common.addr, 1075 BATADV_PRINT_VID(tt_local_entry->common.vid), message); 1076 } 1077 1078 /** 1079 * batadv_tt_local_remove - logically remove an entry from the local table 1080 * @bat_priv: the bat priv with all the soft interface information 1081 * @addr: the MAC address of the client to remove 1082 * @vid: VLAN identifier 1083 * @message: message to append to the log on deletion 1084 * @roaming: true if the deletion is due to a roaming event 1085 * 1086 * Return: the flags assigned to the local entry before being deleted 1087 */ 1088 u16 batadv_tt_local_remove(struct batadv_priv *bat_priv, const u8 *addr, 1089 unsigned short vid, const char *message, 1090 bool roaming) 1091 { 1092 struct batadv_tt_local_entry *tt_local_entry; 1093 u16 flags, curr_flags = BATADV_NO_FLAGS; 1094 void *tt_entry_exists; 1095 1096 tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid); 1097 if (!tt_local_entry) 1098 goto out; 1099 1100 curr_flags = tt_local_entry->common.flags; 1101 1102 flags = BATADV_TT_CLIENT_DEL; 1103 /* if this global entry addition is due to a roaming, the node has to 1104 * mark the local entry as "roamed" in order to correctly reroute 1105 * packets later 1106 */ 1107 if (roaming) { 1108 flags |= BATADV_TT_CLIENT_ROAM; 1109 /* mark the local client as ROAMed */ 1110 tt_local_entry->common.flags |= BATADV_TT_CLIENT_ROAM; 1111 } 1112 1113 if (!(tt_local_entry->common.flags & BATADV_TT_CLIENT_NEW)) { 1114 batadv_tt_local_set_pending(bat_priv, tt_local_entry, flags, 1115 message); 1116 goto out; 1117 } 1118 /* if this client has been added right now, it is possible to 1119 * immediately purge it 1120 */ 1121 batadv_tt_local_event(bat_priv, tt_local_entry, BATADV_TT_CLIENT_DEL); 1122 1123 tt_entry_exists = batadv_hash_remove(bat_priv->tt.local_hash, 1124 batadv_compare_tt, 1125 batadv_choose_tt, 1126 &tt_local_entry->common); 1127 if (!tt_entry_exists) 1128 goto out; 1129 1130 /* extra call to free the local tt entry */ 1131 batadv_tt_local_entry_put(tt_local_entry); 1132 1133 out: 1134 if (tt_local_entry) 1135 batadv_tt_local_entry_put(tt_local_entry); 1136 1137 return curr_flags; 1138 } 1139 1140 /** 1141 * batadv_tt_local_purge_list - purge inactive tt local entries 1142 * @bat_priv: the bat priv with all the soft interface information 1143 * @head: pointer to the list containing the local tt entries 1144 * @timeout: parameter deciding whether a given tt local entry is considered 1145 * inactive or not 1146 */ 1147 static void batadv_tt_local_purge_list(struct batadv_priv *bat_priv, 1148 struct hlist_head *head, 1149 int timeout) 1150 { 1151 struct batadv_tt_local_entry *tt_local_entry; 1152 struct batadv_tt_common_entry *tt_common_entry; 1153 struct hlist_node *node_tmp; 1154 1155 hlist_for_each_entry_safe(tt_common_entry, node_tmp, head, 1156 hash_entry) { 1157 tt_local_entry = container_of(tt_common_entry, 1158 struct batadv_tt_local_entry, 1159 common); 1160 if (tt_local_entry->common.flags & BATADV_TT_CLIENT_NOPURGE) 1161 continue; 1162 1163 /* entry already marked for deletion */ 1164 if (tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING) 1165 continue; 1166 1167 if (!batadv_has_timed_out(tt_local_entry->last_seen, timeout)) 1168 continue; 1169 1170 batadv_tt_local_set_pending(bat_priv, tt_local_entry, 1171 BATADV_TT_CLIENT_DEL, "timed out"); 1172 } 1173 } 1174 1175 /** 1176 * batadv_tt_local_purge - purge inactive tt local entries 1177 * @bat_priv: the bat priv with all the soft interface information 1178 * @timeout: parameter deciding whether a given tt local entry is considered 1179 * inactive or not 1180 */ 1181 static void batadv_tt_local_purge(struct batadv_priv *bat_priv, 1182 int timeout) 1183 { 1184 struct batadv_hashtable *hash = bat_priv->tt.local_hash; 1185 struct hlist_head *head; 1186 spinlock_t *list_lock; /* protects write access to the hash lists */ 1187 u32 i; 1188 1189 for (i = 0; i < hash->size; i++) { 1190 head = &hash->table[i]; 1191 list_lock = &hash->list_locks[i]; 1192 1193 spin_lock_bh(list_lock); 1194 batadv_tt_local_purge_list(bat_priv, head, timeout); 1195 spin_unlock_bh(list_lock); 1196 } 1197 } 1198 1199 static void batadv_tt_local_table_free(struct batadv_priv *bat_priv) 1200 { 1201 struct batadv_hashtable *hash; 1202 spinlock_t *list_lock; /* protects write access to the hash lists */ 1203 struct batadv_tt_common_entry *tt_common_entry; 1204 struct batadv_tt_local_entry *tt_local; 1205 struct hlist_node *node_tmp; 1206 struct hlist_head *head; 1207 u32 i; 1208 1209 if (!bat_priv->tt.local_hash) 1210 return; 1211 1212 hash = bat_priv->tt.local_hash; 1213 1214 for (i = 0; i < hash->size; i++) { 1215 head = &hash->table[i]; 1216 list_lock = &hash->list_locks[i]; 1217 1218 spin_lock_bh(list_lock); 1219 hlist_for_each_entry_safe(tt_common_entry, node_tmp, 1220 head, hash_entry) { 1221 hlist_del_rcu(&tt_common_entry->hash_entry); 1222 tt_local = container_of(tt_common_entry, 1223 struct batadv_tt_local_entry, 1224 common); 1225 1226 batadv_tt_local_entry_put(tt_local); 1227 } 1228 spin_unlock_bh(list_lock); 1229 } 1230 1231 batadv_hash_destroy(hash); 1232 1233 bat_priv->tt.local_hash = NULL; 1234 } 1235 1236 static int batadv_tt_global_init(struct batadv_priv *bat_priv) 1237 { 1238 if (bat_priv->tt.global_hash) 1239 return 0; 1240 1241 bat_priv->tt.global_hash = batadv_hash_new(1024); 1242 1243 if (!bat_priv->tt.global_hash) 1244 return -ENOMEM; 1245 1246 batadv_hash_set_lock_class(bat_priv->tt.global_hash, 1247 &batadv_tt_global_hash_lock_class_key); 1248 1249 return 0; 1250 } 1251 1252 static void batadv_tt_changes_list_free(struct batadv_priv *bat_priv) 1253 { 1254 struct batadv_tt_change_node *entry, *safe; 1255 1256 spin_lock_bh(&bat_priv->tt.changes_list_lock); 1257 1258 list_for_each_entry_safe(entry, safe, &bat_priv->tt.changes_list, 1259 list) { 1260 list_del(&entry->list); 1261 kfree(entry); 1262 } 1263 1264 atomic_set(&bat_priv->tt.local_changes, 0); 1265 spin_unlock_bh(&bat_priv->tt.changes_list_lock); 1266 } 1267 1268 /** 1269 * batadv_tt_global_orig_entry_find - find a TT orig_list_entry 1270 * @entry: the TT global entry where the orig_list_entry has to be 1271 * extracted from 1272 * @orig_node: the originator for which the orig_list_entry has to be found 1273 * 1274 * retrieve the orig_tt_list_entry belonging to orig_node from the 1275 * batadv_tt_global_entry list 1276 * 1277 * Return: it with an increased refcounter, NULL if not found 1278 */ 1279 static struct batadv_tt_orig_list_entry * 1280 batadv_tt_global_orig_entry_find(const struct batadv_tt_global_entry *entry, 1281 const struct batadv_orig_node *orig_node) 1282 { 1283 struct batadv_tt_orig_list_entry *tmp_orig_entry, *orig_entry = NULL; 1284 const struct hlist_head *head; 1285 1286 rcu_read_lock(); 1287 head = &entry->orig_list; 1288 hlist_for_each_entry_rcu(tmp_orig_entry, head, list) { 1289 if (tmp_orig_entry->orig_node != orig_node) 1290 continue; 1291 if (!kref_get_unless_zero(&tmp_orig_entry->refcount)) 1292 continue; 1293 1294 orig_entry = tmp_orig_entry; 1295 break; 1296 } 1297 rcu_read_unlock(); 1298 1299 return orig_entry; 1300 } 1301 1302 /** 1303 * batadv_tt_global_entry_has_orig - check if a TT global entry is also handled 1304 * by a given originator 1305 * @entry: the TT global entry to check 1306 * @orig_node: the originator to search in the list 1307 * 1308 * find out if an orig_node is already in the list of a tt_global_entry. 1309 * 1310 * Return: true if found, false otherwise 1311 */ 1312 static bool 1313 batadv_tt_global_entry_has_orig(const struct batadv_tt_global_entry *entry, 1314 const struct batadv_orig_node *orig_node) 1315 { 1316 struct batadv_tt_orig_list_entry *orig_entry; 1317 bool found = false; 1318 1319 orig_entry = batadv_tt_global_orig_entry_find(entry, orig_node); 1320 if (orig_entry) { 1321 found = true; 1322 batadv_tt_orig_list_entry_put(orig_entry); 1323 } 1324 1325 return found; 1326 } 1327 1328 static void 1329 batadv_tt_global_orig_entry_add(struct batadv_tt_global_entry *tt_global, 1330 struct batadv_orig_node *orig_node, int ttvn) 1331 { 1332 struct batadv_tt_orig_list_entry *orig_entry; 1333 1334 orig_entry = batadv_tt_global_orig_entry_find(tt_global, orig_node); 1335 if (orig_entry) { 1336 /* refresh the ttvn: the current value could be a bogus one that 1337 * was added during a "temporary client detection" 1338 */ 1339 orig_entry->ttvn = ttvn; 1340 goto out; 1341 } 1342 1343 orig_entry = kzalloc(sizeof(*orig_entry), GFP_ATOMIC); 1344 if (!orig_entry) 1345 goto out; 1346 1347 INIT_HLIST_NODE(&orig_entry->list); 1348 kref_get(&orig_node->refcount); 1349 batadv_tt_global_size_inc(orig_node, tt_global->common.vid); 1350 orig_entry->orig_node = orig_node; 1351 orig_entry->ttvn = ttvn; 1352 kref_init(&orig_entry->refcount); 1353 kref_get(&orig_entry->refcount); 1354 1355 spin_lock_bh(&tt_global->list_lock); 1356 hlist_add_head_rcu(&orig_entry->list, 1357 &tt_global->orig_list); 1358 spin_unlock_bh(&tt_global->list_lock); 1359 atomic_inc(&tt_global->orig_list_count); 1360 1361 out: 1362 if (orig_entry) 1363 batadv_tt_orig_list_entry_put(orig_entry); 1364 } 1365 1366 /** 1367 * batadv_tt_global_add - add a new TT global entry or update an existing one 1368 * @bat_priv: the bat priv with all the soft interface information 1369 * @orig_node: the originator announcing the client 1370 * @tt_addr: the mac address of the non-mesh client 1371 * @vid: VLAN identifier 1372 * @flags: TT flags that have to be set for this non-mesh client 1373 * @ttvn: the tt version number ever announcing this non-mesh client 1374 * 1375 * Add a new TT global entry for the given originator. If the entry already 1376 * exists add a new reference to the given originator (a global entry can have 1377 * references to multiple originators) and adjust the flags attribute to reflect 1378 * the function argument. 1379 * If a TT local entry exists for this non-mesh client remove it. 1380 * 1381 * The caller must hold orig_node refcount. 1382 * 1383 * Return: true if the new entry has been added, false otherwise 1384 */ 1385 static bool batadv_tt_global_add(struct batadv_priv *bat_priv, 1386 struct batadv_orig_node *orig_node, 1387 const unsigned char *tt_addr, 1388 unsigned short vid, u16 flags, u8 ttvn) 1389 { 1390 struct batadv_tt_global_entry *tt_global_entry; 1391 struct batadv_tt_local_entry *tt_local_entry; 1392 bool ret = false; 1393 int hash_added; 1394 struct batadv_tt_common_entry *common; 1395 u16 local_flags; 1396 1397 /* ignore global entries from backbone nodes */ 1398 if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig, vid)) 1399 return true; 1400 1401 tt_global_entry = batadv_tt_global_hash_find(bat_priv, tt_addr, vid); 1402 tt_local_entry = batadv_tt_local_hash_find(bat_priv, tt_addr, vid); 1403 1404 /* if the node already has a local client for this entry, it has to wait 1405 * for a roaming advertisement instead of manually messing up the global 1406 * table 1407 */ 1408 if ((flags & BATADV_TT_CLIENT_TEMP) && tt_local_entry && 1409 !(tt_local_entry->common.flags & BATADV_TT_CLIENT_NEW)) 1410 goto out; 1411 1412 if (!tt_global_entry) { 1413 tt_global_entry = kzalloc(sizeof(*tt_global_entry), GFP_ATOMIC); 1414 if (!tt_global_entry) 1415 goto out; 1416 1417 common = &tt_global_entry->common; 1418 ether_addr_copy(common->addr, tt_addr); 1419 common->vid = vid; 1420 1421 common->flags = flags; 1422 tt_global_entry->roam_at = 0; 1423 /* node must store current time in case of roaming. This is 1424 * needed to purge this entry out on timeout (if nobody claims 1425 * it) 1426 */ 1427 if (flags & BATADV_TT_CLIENT_ROAM) 1428 tt_global_entry->roam_at = jiffies; 1429 kref_init(&common->refcount); 1430 kref_get(&common->refcount); 1431 common->added_at = jiffies; 1432 1433 INIT_HLIST_HEAD(&tt_global_entry->orig_list); 1434 atomic_set(&tt_global_entry->orig_list_count, 0); 1435 spin_lock_init(&tt_global_entry->list_lock); 1436 1437 hash_added = batadv_hash_add(bat_priv->tt.global_hash, 1438 batadv_compare_tt, 1439 batadv_choose_tt, common, 1440 &common->hash_entry); 1441 1442 if (unlikely(hash_added != 0)) { 1443 /* remove the reference for the hash */ 1444 batadv_tt_global_entry_put(tt_global_entry); 1445 goto out_remove; 1446 } 1447 } else { 1448 common = &tt_global_entry->common; 1449 /* If there is already a global entry, we can use this one for 1450 * our processing. 1451 * But if we are trying to add a temporary client then here are 1452 * two options at this point: 1453 * 1) the global client is not a temporary client: the global 1454 * client has to be left as it is, temporary information 1455 * should never override any already known client state 1456 * 2) the global client is a temporary client: purge the 1457 * originator list and add the new one orig_entry 1458 */ 1459 if (flags & BATADV_TT_CLIENT_TEMP) { 1460 if (!(common->flags & BATADV_TT_CLIENT_TEMP)) 1461 goto out; 1462 if (batadv_tt_global_entry_has_orig(tt_global_entry, 1463 orig_node)) 1464 goto out_remove; 1465 batadv_tt_global_del_orig_list(tt_global_entry); 1466 goto add_orig_entry; 1467 } 1468 1469 /* if the client was temporary added before receiving the first 1470 * OGM announcing it, we have to clear the TEMP flag. Also, 1471 * remove the previous temporary orig node and re-add it 1472 * if required. If the orig entry changed, the new one which 1473 * is a non-temporary entry is preferred. 1474 */ 1475 if (common->flags & BATADV_TT_CLIENT_TEMP) { 1476 batadv_tt_global_del_orig_list(tt_global_entry); 1477 common->flags &= ~BATADV_TT_CLIENT_TEMP; 1478 } 1479 1480 /* the change can carry possible "attribute" flags like the 1481 * TT_CLIENT_WIFI, therefore they have to be copied in the 1482 * client entry 1483 */ 1484 common->flags |= flags; 1485 1486 /* If there is the BATADV_TT_CLIENT_ROAM flag set, there is only 1487 * one originator left in the list and we previously received a 1488 * delete + roaming change for this originator. 1489 * 1490 * We should first delete the old originator before adding the 1491 * new one. 1492 */ 1493 if (common->flags & BATADV_TT_CLIENT_ROAM) { 1494 batadv_tt_global_del_orig_list(tt_global_entry); 1495 common->flags &= ~BATADV_TT_CLIENT_ROAM; 1496 tt_global_entry->roam_at = 0; 1497 } 1498 } 1499 add_orig_entry: 1500 /* add the new orig_entry (if needed) or update it */ 1501 batadv_tt_global_orig_entry_add(tt_global_entry, orig_node, ttvn); 1502 1503 batadv_dbg(BATADV_DBG_TT, bat_priv, 1504 "Creating new global tt entry: %pM (vid: %d, via %pM)\n", 1505 common->addr, BATADV_PRINT_VID(common->vid), 1506 orig_node->orig); 1507 ret = true; 1508 1509 out_remove: 1510 /* Do not remove multicast addresses from the local hash on 1511 * global additions 1512 */ 1513 if (is_multicast_ether_addr(tt_addr)) 1514 goto out; 1515 1516 /* remove address from local hash if present */ 1517 local_flags = batadv_tt_local_remove(bat_priv, tt_addr, vid, 1518 "global tt received", 1519 flags & BATADV_TT_CLIENT_ROAM); 1520 tt_global_entry->common.flags |= local_flags & BATADV_TT_CLIENT_WIFI; 1521 1522 if (!(flags & BATADV_TT_CLIENT_ROAM)) 1523 /* this is a normal global add. Therefore the client is not in a 1524 * roaming state anymore. 1525 */ 1526 tt_global_entry->common.flags &= ~BATADV_TT_CLIENT_ROAM; 1527 1528 out: 1529 if (tt_global_entry) 1530 batadv_tt_global_entry_put(tt_global_entry); 1531 if (tt_local_entry) 1532 batadv_tt_local_entry_put(tt_local_entry); 1533 return ret; 1534 } 1535 1536 /** 1537 * batadv_transtable_best_orig - Get best originator list entry from tt entry 1538 * @bat_priv: the bat priv with all the soft interface information 1539 * @tt_global_entry: global translation table entry to be analyzed 1540 * 1541 * This functon assumes the caller holds rcu_read_lock(). 1542 * Return: best originator list entry or NULL on errors. 1543 */ 1544 static struct batadv_tt_orig_list_entry * 1545 batadv_transtable_best_orig(struct batadv_priv *bat_priv, 1546 struct batadv_tt_global_entry *tt_global_entry) 1547 { 1548 struct batadv_neigh_node *router, *best_router = NULL; 1549 struct batadv_algo_ops *bao = bat_priv->bat_algo_ops; 1550 struct hlist_head *head; 1551 struct batadv_tt_orig_list_entry *orig_entry, *best_entry = NULL; 1552 1553 head = &tt_global_entry->orig_list; 1554 hlist_for_each_entry_rcu(orig_entry, head, list) { 1555 router = batadv_orig_router_get(orig_entry->orig_node, 1556 BATADV_IF_DEFAULT); 1557 if (!router) 1558 continue; 1559 1560 if (best_router && 1561 bao->bat_neigh_cmp(router, BATADV_IF_DEFAULT, 1562 best_router, BATADV_IF_DEFAULT) <= 0) { 1563 batadv_neigh_node_put(router); 1564 continue; 1565 } 1566 1567 /* release the refcount for the "old" best */ 1568 if (best_router) 1569 batadv_neigh_node_put(best_router); 1570 1571 best_entry = orig_entry; 1572 best_router = router; 1573 } 1574 1575 if (best_router) 1576 batadv_neigh_node_put(best_router); 1577 1578 return best_entry; 1579 } 1580 1581 /** 1582 * batadv_tt_global_print_entry - print all orig nodes who announce the address 1583 * for this global entry 1584 * @bat_priv: the bat priv with all the soft interface information 1585 * @tt_global_entry: global translation table entry to be printed 1586 * @seq: debugfs table seq_file struct 1587 * 1588 * This functon assumes the caller holds rcu_read_lock(). 1589 */ 1590 static void 1591 batadv_tt_global_print_entry(struct batadv_priv *bat_priv, 1592 struct batadv_tt_global_entry *tt_global_entry, 1593 struct seq_file *seq) 1594 { 1595 struct batadv_tt_orig_list_entry *orig_entry, *best_entry; 1596 struct batadv_tt_common_entry *tt_common_entry; 1597 struct batadv_orig_node_vlan *vlan; 1598 struct hlist_head *head; 1599 u8 last_ttvn; 1600 u16 flags; 1601 1602 tt_common_entry = &tt_global_entry->common; 1603 flags = tt_common_entry->flags; 1604 1605 best_entry = batadv_transtable_best_orig(bat_priv, tt_global_entry); 1606 if (best_entry) { 1607 vlan = batadv_orig_node_vlan_get(best_entry->orig_node, 1608 tt_common_entry->vid); 1609 if (!vlan) { 1610 seq_printf(seq, 1611 " * Cannot retrieve VLAN %d for originator %pM\n", 1612 BATADV_PRINT_VID(tt_common_entry->vid), 1613 best_entry->orig_node->orig); 1614 goto print_list; 1615 } 1616 1617 last_ttvn = atomic_read(&best_entry->orig_node->last_ttvn); 1618 seq_printf(seq, 1619 " %c %pM %4i (%3u) via %pM (%3u) (%#.8x) [%c%c%c%c]\n", 1620 '*', tt_global_entry->common.addr, 1621 BATADV_PRINT_VID(tt_global_entry->common.vid), 1622 best_entry->ttvn, best_entry->orig_node->orig, 1623 last_ttvn, vlan->tt.crc, 1624 ((flags & BATADV_TT_CLIENT_ROAM) ? 'R' : '.'), 1625 ((flags & BATADV_TT_CLIENT_WIFI) ? 'W' : '.'), 1626 ((flags & BATADV_TT_CLIENT_ISOLA) ? 'I' : '.'), 1627 ((flags & BATADV_TT_CLIENT_TEMP) ? 'T' : '.')); 1628 1629 batadv_orig_node_vlan_put(vlan); 1630 } 1631 1632 print_list: 1633 head = &tt_global_entry->orig_list; 1634 1635 hlist_for_each_entry_rcu(orig_entry, head, list) { 1636 if (best_entry == orig_entry) 1637 continue; 1638 1639 vlan = batadv_orig_node_vlan_get(orig_entry->orig_node, 1640 tt_common_entry->vid); 1641 if (!vlan) { 1642 seq_printf(seq, 1643 " + Cannot retrieve VLAN %d for originator %pM\n", 1644 BATADV_PRINT_VID(tt_common_entry->vid), 1645 orig_entry->orig_node->orig); 1646 continue; 1647 } 1648 1649 last_ttvn = atomic_read(&orig_entry->orig_node->last_ttvn); 1650 seq_printf(seq, 1651 " %c %pM %4d (%3u) via %pM (%3u) (%#.8x) [%c%c%c%c]\n", 1652 '+', tt_global_entry->common.addr, 1653 BATADV_PRINT_VID(tt_global_entry->common.vid), 1654 orig_entry->ttvn, orig_entry->orig_node->orig, 1655 last_ttvn, vlan->tt.crc, 1656 ((flags & BATADV_TT_CLIENT_ROAM) ? 'R' : '.'), 1657 ((flags & BATADV_TT_CLIENT_WIFI) ? 'W' : '.'), 1658 ((flags & BATADV_TT_CLIENT_ISOLA) ? 'I' : '.'), 1659 ((flags & BATADV_TT_CLIENT_TEMP) ? 'T' : '.')); 1660 1661 batadv_orig_node_vlan_put(vlan); 1662 } 1663 } 1664 1665 int batadv_tt_global_seq_print_text(struct seq_file *seq, void *offset) 1666 { 1667 struct net_device *net_dev = (struct net_device *)seq->private; 1668 struct batadv_priv *bat_priv = netdev_priv(net_dev); 1669 struct batadv_hashtable *hash = bat_priv->tt.global_hash; 1670 struct batadv_tt_common_entry *tt_common_entry; 1671 struct batadv_tt_global_entry *tt_global; 1672 struct batadv_hard_iface *primary_if; 1673 struct hlist_head *head; 1674 u32 i; 1675 1676 primary_if = batadv_seq_print_text_primary_if_get(seq); 1677 if (!primary_if) 1678 goto out; 1679 1680 seq_printf(seq, 1681 "Globally announced TT entries received via the mesh %s\n", 1682 net_dev->name); 1683 seq_puts(seq, 1684 " Client VID (TTVN) Originator (Curr TTVN) (CRC ) Flags\n"); 1685 1686 for (i = 0; i < hash->size; i++) { 1687 head = &hash->table[i]; 1688 1689 rcu_read_lock(); 1690 hlist_for_each_entry_rcu(tt_common_entry, 1691 head, hash_entry) { 1692 tt_global = container_of(tt_common_entry, 1693 struct batadv_tt_global_entry, 1694 common); 1695 batadv_tt_global_print_entry(bat_priv, tt_global, seq); 1696 } 1697 rcu_read_unlock(); 1698 } 1699 out: 1700 if (primary_if) 1701 batadv_hardif_put(primary_if); 1702 return 0; 1703 } 1704 1705 /** 1706 * _batadv_tt_global_del_orig_entry - remove and free an orig_entry 1707 * @tt_global_entry: the global entry to remove the orig_entry from 1708 * @orig_entry: the orig entry to remove and free 1709 * 1710 * Remove an orig_entry from its list in the given tt_global_entry and 1711 * free this orig_entry afterwards. 1712 * 1713 * Caller must hold tt_global_entry->list_lock and ensure orig_entry->list is 1714 * part of a list. 1715 */ 1716 static void 1717 _batadv_tt_global_del_orig_entry(struct batadv_tt_global_entry *tt_global_entry, 1718 struct batadv_tt_orig_list_entry *orig_entry) 1719 { 1720 lockdep_assert_held(&tt_global_entry->list_lock); 1721 1722 batadv_tt_global_size_dec(orig_entry->orig_node, 1723 tt_global_entry->common.vid); 1724 atomic_dec(&tt_global_entry->orig_list_count); 1725 /* requires holding tt_global_entry->list_lock and orig_entry->list 1726 * being part of a list 1727 */ 1728 hlist_del_rcu(&orig_entry->list); 1729 batadv_tt_orig_list_entry_put(orig_entry); 1730 } 1731 1732 /* deletes the orig list of a tt_global_entry */ 1733 static void 1734 batadv_tt_global_del_orig_list(struct batadv_tt_global_entry *tt_global_entry) 1735 { 1736 struct hlist_head *head; 1737 struct hlist_node *safe; 1738 struct batadv_tt_orig_list_entry *orig_entry; 1739 1740 spin_lock_bh(&tt_global_entry->list_lock); 1741 head = &tt_global_entry->orig_list; 1742 hlist_for_each_entry_safe(orig_entry, safe, head, list) 1743 _batadv_tt_global_del_orig_entry(tt_global_entry, orig_entry); 1744 spin_unlock_bh(&tt_global_entry->list_lock); 1745 } 1746 1747 /** 1748 * batadv_tt_global_del_orig_node - remove orig_node from a global tt entry 1749 * @bat_priv: the bat priv with all the soft interface information 1750 * @tt_global_entry: the global entry to remove the orig_node from 1751 * @orig_node: the originator announcing the client 1752 * @message: message to append to the log on deletion 1753 * 1754 * Remove the given orig_node and its according orig_entry from the given 1755 * global tt entry. 1756 */ 1757 static void 1758 batadv_tt_global_del_orig_node(struct batadv_priv *bat_priv, 1759 struct batadv_tt_global_entry *tt_global_entry, 1760 struct batadv_orig_node *orig_node, 1761 const char *message) 1762 { 1763 struct hlist_head *head; 1764 struct hlist_node *safe; 1765 struct batadv_tt_orig_list_entry *orig_entry; 1766 unsigned short vid; 1767 1768 spin_lock_bh(&tt_global_entry->list_lock); 1769 head = &tt_global_entry->orig_list; 1770 hlist_for_each_entry_safe(orig_entry, safe, head, list) { 1771 if (orig_entry->orig_node == orig_node) { 1772 vid = tt_global_entry->common.vid; 1773 batadv_dbg(BATADV_DBG_TT, bat_priv, 1774 "Deleting %pM from global tt entry %pM (vid: %d): %s\n", 1775 orig_node->orig, 1776 tt_global_entry->common.addr, 1777 BATADV_PRINT_VID(vid), message); 1778 _batadv_tt_global_del_orig_entry(tt_global_entry, 1779 orig_entry); 1780 } 1781 } 1782 spin_unlock_bh(&tt_global_entry->list_lock); 1783 } 1784 1785 /* If the client is to be deleted, we check if it is the last origantor entry 1786 * within tt_global entry. If yes, we set the BATADV_TT_CLIENT_ROAM flag and the 1787 * timer, otherwise we simply remove the originator scheduled for deletion. 1788 */ 1789 static void 1790 batadv_tt_global_del_roaming(struct batadv_priv *bat_priv, 1791 struct batadv_tt_global_entry *tt_global_entry, 1792 struct batadv_orig_node *orig_node, 1793 const char *message) 1794 { 1795 bool last_entry = true; 1796 struct hlist_head *head; 1797 struct batadv_tt_orig_list_entry *orig_entry; 1798 1799 /* no local entry exists, case 1: 1800 * Check if this is the last one or if other entries exist. 1801 */ 1802 1803 rcu_read_lock(); 1804 head = &tt_global_entry->orig_list; 1805 hlist_for_each_entry_rcu(orig_entry, head, list) { 1806 if (orig_entry->orig_node != orig_node) { 1807 last_entry = false; 1808 break; 1809 } 1810 } 1811 rcu_read_unlock(); 1812 1813 if (last_entry) { 1814 /* its the last one, mark for roaming. */ 1815 tt_global_entry->common.flags |= BATADV_TT_CLIENT_ROAM; 1816 tt_global_entry->roam_at = jiffies; 1817 } else 1818 /* there is another entry, we can simply delete this 1819 * one and can still use the other one. 1820 */ 1821 batadv_tt_global_del_orig_node(bat_priv, tt_global_entry, 1822 orig_node, message); 1823 } 1824 1825 /** 1826 * batadv_tt_global_del - remove a client from the global table 1827 * @bat_priv: the bat priv with all the soft interface information 1828 * @orig_node: an originator serving this client 1829 * @addr: the mac address of the client 1830 * @vid: VLAN identifier 1831 * @message: a message explaining the reason for deleting the client to print 1832 * for debugging purpose 1833 * @roaming: true if the deletion has been triggered by a roaming event 1834 */ 1835 static void batadv_tt_global_del(struct batadv_priv *bat_priv, 1836 struct batadv_orig_node *orig_node, 1837 const unsigned char *addr, unsigned short vid, 1838 const char *message, bool roaming) 1839 { 1840 struct batadv_tt_global_entry *tt_global_entry; 1841 struct batadv_tt_local_entry *local_entry = NULL; 1842 1843 tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid); 1844 if (!tt_global_entry) 1845 goto out; 1846 1847 if (!roaming) { 1848 batadv_tt_global_del_orig_node(bat_priv, tt_global_entry, 1849 orig_node, message); 1850 1851 if (hlist_empty(&tt_global_entry->orig_list)) 1852 batadv_tt_global_free(bat_priv, tt_global_entry, 1853 message); 1854 1855 goto out; 1856 } 1857 1858 /* if we are deleting a global entry due to a roam 1859 * event, there are two possibilities: 1860 * 1) the client roamed from node A to node B => if there 1861 * is only one originator left for this client, we mark 1862 * it with BATADV_TT_CLIENT_ROAM, we start a timer and we 1863 * wait for node B to claim it. In case of timeout 1864 * the entry is purged. 1865 * 1866 * If there are other originators left, we directly delete 1867 * the originator. 1868 * 2) the client roamed to us => we can directly delete 1869 * the global entry, since it is useless now. 1870 */ 1871 local_entry = batadv_tt_local_hash_find(bat_priv, 1872 tt_global_entry->common.addr, 1873 vid); 1874 if (local_entry) { 1875 /* local entry exists, case 2: client roamed to us. */ 1876 batadv_tt_global_del_orig_list(tt_global_entry); 1877 batadv_tt_global_free(bat_priv, tt_global_entry, message); 1878 } else 1879 /* no local entry exists, case 1: check for roaming */ 1880 batadv_tt_global_del_roaming(bat_priv, tt_global_entry, 1881 orig_node, message); 1882 1883 out: 1884 if (tt_global_entry) 1885 batadv_tt_global_entry_put(tt_global_entry); 1886 if (local_entry) 1887 batadv_tt_local_entry_put(local_entry); 1888 } 1889 1890 /** 1891 * batadv_tt_global_del_orig - remove all the TT global entries belonging to the 1892 * given originator matching the provided vid 1893 * @bat_priv: the bat priv with all the soft interface information 1894 * @orig_node: the originator owning the entries to remove 1895 * @match_vid: the VLAN identifier to match. If negative all the entries will be 1896 * removed 1897 * @message: debug message to print as "reason" 1898 */ 1899 void batadv_tt_global_del_orig(struct batadv_priv *bat_priv, 1900 struct batadv_orig_node *orig_node, 1901 s32 match_vid, 1902 const char *message) 1903 { 1904 struct batadv_tt_global_entry *tt_global; 1905 struct batadv_tt_common_entry *tt_common_entry; 1906 u32 i; 1907 struct batadv_hashtable *hash = bat_priv->tt.global_hash; 1908 struct hlist_node *safe; 1909 struct hlist_head *head; 1910 spinlock_t *list_lock; /* protects write access to the hash lists */ 1911 unsigned short vid; 1912 1913 if (!hash) 1914 return; 1915 1916 for (i = 0; i < hash->size; i++) { 1917 head = &hash->table[i]; 1918 list_lock = &hash->list_locks[i]; 1919 1920 spin_lock_bh(list_lock); 1921 hlist_for_each_entry_safe(tt_common_entry, safe, 1922 head, hash_entry) { 1923 /* remove only matching entries */ 1924 if (match_vid >= 0 && tt_common_entry->vid != match_vid) 1925 continue; 1926 1927 tt_global = container_of(tt_common_entry, 1928 struct batadv_tt_global_entry, 1929 common); 1930 1931 batadv_tt_global_del_orig_node(bat_priv, tt_global, 1932 orig_node, message); 1933 1934 if (hlist_empty(&tt_global->orig_list)) { 1935 vid = tt_global->common.vid; 1936 batadv_dbg(BATADV_DBG_TT, bat_priv, 1937 "Deleting global tt entry %pM (vid: %d): %s\n", 1938 tt_global->common.addr, 1939 BATADV_PRINT_VID(vid), message); 1940 hlist_del_rcu(&tt_common_entry->hash_entry); 1941 batadv_tt_global_entry_put(tt_global); 1942 } 1943 } 1944 spin_unlock_bh(list_lock); 1945 } 1946 clear_bit(BATADV_ORIG_CAPA_HAS_TT, &orig_node->capa_initialized); 1947 } 1948 1949 static bool batadv_tt_global_to_purge(struct batadv_tt_global_entry *tt_global, 1950 char **msg) 1951 { 1952 bool purge = false; 1953 unsigned long roam_timeout = BATADV_TT_CLIENT_ROAM_TIMEOUT; 1954 unsigned long temp_timeout = BATADV_TT_CLIENT_TEMP_TIMEOUT; 1955 1956 if ((tt_global->common.flags & BATADV_TT_CLIENT_ROAM) && 1957 batadv_has_timed_out(tt_global->roam_at, roam_timeout)) { 1958 purge = true; 1959 *msg = "Roaming timeout\n"; 1960 } 1961 1962 if ((tt_global->common.flags & BATADV_TT_CLIENT_TEMP) && 1963 batadv_has_timed_out(tt_global->common.added_at, temp_timeout)) { 1964 purge = true; 1965 *msg = "Temporary client timeout\n"; 1966 } 1967 1968 return purge; 1969 } 1970 1971 static void batadv_tt_global_purge(struct batadv_priv *bat_priv) 1972 { 1973 struct batadv_hashtable *hash = bat_priv->tt.global_hash; 1974 struct hlist_head *head; 1975 struct hlist_node *node_tmp; 1976 spinlock_t *list_lock; /* protects write access to the hash lists */ 1977 u32 i; 1978 char *msg = NULL; 1979 struct batadv_tt_common_entry *tt_common; 1980 struct batadv_tt_global_entry *tt_global; 1981 1982 for (i = 0; i < hash->size; i++) { 1983 head = &hash->table[i]; 1984 list_lock = &hash->list_locks[i]; 1985 1986 spin_lock_bh(list_lock); 1987 hlist_for_each_entry_safe(tt_common, node_tmp, head, 1988 hash_entry) { 1989 tt_global = container_of(tt_common, 1990 struct batadv_tt_global_entry, 1991 common); 1992 1993 if (!batadv_tt_global_to_purge(tt_global, &msg)) 1994 continue; 1995 1996 batadv_dbg(BATADV_DBG_TT, bat_priv, 1997 "Deleting global tt entry %pM (vid: %d): %s\n", 1998 tt_global->common.addr, 1999 BATADV_PRINT_VID(tt_global->common.vid), 2000 msg); 2001 2002 hlist_del_rcu(&tt_common->hash_entry); 2003 2004 batadv_tt_global_entry_put(tt_global); 2005 } 2006 spin_unlock_bh(list_lock); 2007 } 2008 } 2009 2010 static void batadv_tt_global_table_free(struct batadv_priv *bat_priv) 2011 { 2012 struct batadv_hashtable *hash; 2013 spinlock_t *list_lock; /* protects write access to the hash lists */ 2014 struct batadv_tt_common_entry *tt_common_entry; 2015 struct batadv_tt_global_entry *tt_global; 2016 struct hlist_node *node_tmp; 2017 struct hlist_head *head; 2018 u32 i; 2019 2020 if (!bat_priv->tt.global_hash) 2021 return; 2022 2023 hash = bat_priv->tt.global_hash; 2024 2025 for (i = 0; i < hash->size; i++) { 2026 head = &hash->table[i]; 2027 list_lock = &hash->list_locks[i]; 2028 2029 spin_lock_bh(list_lock); 2030 hlist_for_each_entry_safe(tt_common_entry, node_tmp, 2031 head, hash_entry) { 2032 hlist_del_rcu(&tt_common_entry->hash_entry); 2033 tt_global = container_of(tt_common_entry, 2034 struct batadv_tt_global_entry, 2035 common); 2036 batadv_tt_global_entry_put(tt_global); 2037 } 2038 spin_unlock_bh(list_lock); 2039 } 2040 2041 batadv_hash_destroy(hash); 2042 2043 bat_priv->tt.global_hash = NULL; 2044 } 2045 2046 static bool 2047 _batadv_is_ap_isolated(struct batadv_tt_local_entry *tt_local_entry, 2048 struct batadv_tt_global_entry *tt_global_entry) 2049 { 2050 bool ret = false; 2051 2052 if (tt_local_entry->common.flags & BATADV_TT_CLIENT_WIFI && 2053 tt_global_entry->common.flags & BATADV_TT_CLIENT_WIFI) 2054 ret = true; 2055 2056 /* check if the two clients are marked as isolated */ 2057 if (tt_local_entry->common.flags & BATADV_TT_CLIENT_ISOLA && 2058 tt_global_entry->common.flags & BATADV_TT_CLIENT_ISOLA) 2059 ret = true; 2060 2061 return ret; 2062 } 2063 2064 /** 2065 * batadv_transtable_search - get the mesh destination for a given client 2066 * @bat_priv: the bat priv with all the soft interface information 2067 * @src: mac address of the source client 2068 * @addr: mac address of the destination client 2069 * @vid: VLAN identifier 2070 * 2071 * Return: a pointer to the originator that was selected as destination in the 2072 * mesh for contacting the client 'addr', NULL otherwise. 2073 * In case of multiple originators serving the same client, the function returns 2074 * the best one (best in terms of metric towards the destination node). 2075 * 2076 * If the two clients are AP isolated the function returns NULL. 2077 */ 2078 struct batadv_orig_node *batadv_transtable_search(struct batadv_priv *bat_priv, 2079 const u8 *src, 2080 const u8 *addr, 2081 unsigned short vid) 2082 { 2083 struct batadv_tt_local_entry *tt_local_entry = NULL; 2084 struct batadv_tt_global_entry *tt_global_entry = NULL; 2085 struct batadv_orig_node *orig_node = NULL; 2086 struct batadv_tt_orig_list_entry *best_entry; 2087 2088 if (src && batadv_vlan_ap_isola_get(bat_priv, vid)) { 2089 tt_local_entry = batadv_tt_local_hash_find(bat_priv, src, vid); 2090 if (!tt_local_entry || 2091 (tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING)) 2092 goto out; 2093 } 2094 2095 tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid); 2096 if (!tt_global_entry) 2097 goto out; 2098 2099 /* check whether the clients should not communicate due to AP 2100 * isolation 2101 */ 2102 if (tt_local_entry && 2103 _batadv_is_ap_isolated(tt_local_entry, tt_global_entry)) 2104 goto out; 2105 2106 rcu_read_lock(); 2107 best_entry = batadv_transtable_best_orig(bat_priv, tt_global_entry); 2108 /* found anything? */ 2109 if (best_entry) 2110 orig_node = best_entry->orig_node; 2111 if (orig_node && !kref_get_unless_zero(&orig_node->refcount)) 2112 orig_node = NULL; 2113 rcu_read_unlock(); 2114 2115 out: 2116 if (tt_global_entry) 2117 batadv_tt_global_entry_put(tt_global_entry); 2118 if (tt_local_entry) 2119 batadv_tt_local_entry_put(tt_local_entry); 2120 2121 return orig_node; 2122 } 2123 2124 /** 2125 * batadv_tt_global_crc - calculates the checksum of the local table belonging 2126 * to the given orig_node 2127 * @bat_priv: the bat priv with all the soft interface information 2128 * @orig_node: originator for which the CRC should be computed 2129 * @vid: VLAN identifier for which the CRC32 has to be computed 2130 * 2131 * This function computes the checksum for the global table corresponding to a 2132 * specific originator. In particular, the checksum is computed as follows: For 2133 * each client connected to the originator the CRC32C of the MAC address and the 2134 * VID is computed and then all the CRC32Cs of the various clients are xor'ed 2135 * together. 2136 * 2137 * The idea behind is that CRC32C should be used as much as possible in order to 2138 * produce a unique hash of the table, but since the order which is used to feed 2139 * the CRC32C function affects the result and since every node in the network 2140 * probably sorts the clients differently, the hash function cannot be directly 2141 * computed over the entire table. Hence the CRC32C is used only on 2142 * the single client entry, while all the results are then xor'ed together 2143 * because the XOR operation can combine them all while trying to reduce the 2144 * noise as much as possible. 2145 * 2146 * Return: the checksum of the global table of a given originator. 2147 */ 2148 static u32 batadv_tt_global_crc(struct batadv_priv *bat_priv, 2149 struct batadv_orig_node *orig_node, 2150 unsigned short vid) 2151 { 2152 struct batadv_hashtable *hash = bat_priv->tt.global_hash; 2153 struct batadv_tt_common_entry *tt_common; 2154 struct batadv_tt_global_entry *tt_global; 2155 struct hlist_head *head; 2156 u32 i, crc_tmp, crc = 0; 2157 u8 flags; 2158 __be16 tmp_vid; 2159 2160 for (i = 0; i < hash->size; i++) { 2161 head = &hash->table[i]; 2162 2163 rcu_read_lock(); 2164 hlist_for_each_entry_rcu(tt_common, head, hash_entry) { 2165 tt_global = container_of(tt_common, 2166 struct batadv_tt_global_entry, 2167 common); 2168 /* compute the CRC only for entries belonging to the 2169 * VLAN identified by the vid passed as parameter 2170 */ 2171 if (tt_common->vid != vid) 2172 continue; 2173 2174 /* Roaming clients are in the global table for 2175 * consistency only. They don't have to be 2176 * taken into account while computing the 2177 * global crc 2178 */ 2179 if (tt_common->flags & BATADV_TT_CLIENT_ROAM) 2180 continue; 2181 /* Temporary clients have not been announced yet, so 2182 * they have to be skipped while computing the global 2183 * crc 2184 */ 2185 if (tt_common->flags & BATADV_TT_CLIENT_TEMP) 2186 continue; 2187 2188 /* find out if this global entry is announced by this 2189 * originator 2190 */ 2191 if (!batadv_tt_global_entry_has_orig(tt_global, 2192 orig_node)) 2193 continue; 2194 2195 /* use network order to read the VID: this ensures that 2196 * every node reads the bytes in the same order. 2197 */ 2198 tmp_vid = htons(tt_common->vid); 2199 crc_tmp = crc32c(0, &tmp_vid, sizeof(tmp_vid)); 2200 2201 /* compute the CRC on flags that have to be kept in sync 2202 * among nodes 2203 */ 2204 flags = tt_common->flags & BATADV_TT_SYNC_MASK; 2205 crc_tmp = crc32c(crc_tmp, &flags, sizeof(flags)); 2206 2207 crc ^= crc32c(crc_tmp, tt_common->addr, ETH_ALEN); 2208 } 2209 rcu_read_unlock(); 2210 } 2211 2212 return crc; 2213 } 2214 2215 /** 2216 * batadv_tt_local_crc - calculates the checksum of the local table 2217 * @bat_priv: the bat priv with all the soft interface information 2218 * @vid: VLAN identifier for which the CRC32 has to be computed 2219 * 2220 * For details about the computation, please refer to the documentation for 2221 * batadv_tt_global_crc(). 2222 * 2223 * Return: the checksum of the local table 2224 */ 2225 static u32 batadv_tt_local_crc(struct batadv_priv *bat_priv, 2226 unsigned short vid) 2227 { 2228 struct batadv_hashtable *hash = bat_priv->tt.local_hash; 2229 struct batadv_tt_common_entry *tt_common; 2230 struct hlist_head *head; 2231 u32 i, crc_tmp, crc = 0; 2232 u8 flags; 2233 __be16 tmp_vid; 2234 2235 for (i = 0; i < hash->size; i++) { 2236 head = &hash->table[i]; 2237 2238 rcu_read_lock(); 2239 hlist_for_each_entry_rcu(tt_common, head, hash_entry) { 2240 /* compute the CRC only for entries belonging to the 2241 * VLAN identified by vid 2242 */ 2243 if (tt_common->vid != vid) 2244 continue; 2245 2246 /* not yet committed clients have not to be taken into 2247 * account while computing the CRC 2248 */ 2249 if (tt_common->flags & BATADV_TT_CLIENT_NEW) 2250 continue; 2251 2252 /* use network order to read the VID: this ensures that 2253 * every node reads the bytes in the same order. 2254 */ 2255 tmp_vid = htons(tt_common->vid); 2256 crc_tmp = crc32c(0, &tmp_vid, sizeof(tmp_vid)); 2257 2258 /* compute the CRC on flags that have to be kept in sync 2259 * among nodes 2260 */ 2261 flags = tt_common->flags & BATADV_TT_SYNC_MASK; 2262 crc_tmp = crc32c(crc_tmp, &flags, sizeof(flags)); 2263 2264 crc ^= crc32c(crc_tmp, tt_common->addr, ETH_ALEN); 2265 } 2266 rcu_read_unlock(); 2267 } 2268 2269 return crc; 2270 } 2271 2272 static void batadv_tt_req_list_free(struct batadv_priv *bat_priv) 2273 { 2274 struct batadv_tt_req_node *node; 2275 struct hlist_node *safe; 2276 2277 spin_lock_bh(&bat_priv->tt.req_list_lock); 2278 2279 hlist_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) { 2280 hlist_del_init(&node->list); 2281 kfree(node); 2282 } 2283 2284 spin_unlock_bh(&bat_priv->tt.req_list_lock); 2285 } 2286 2287 static void batadv_tt_save_orig_buffer(struct batadv_priv *bat_priv, 2288 struct batadv_orig_node *orig_node, 2289 const void *tt_buff, 2290 u16 tt_buff_len) 2291 { 2292 /* Replace the old buffer only if I received something in the 2293 * last OGM (the OGM could carry no changes) 2294 */ 2295 spin_lock_bh(&orig_node->tt_buff_lock); 2296 if (tt_buff_len > 0) { 2297 kfree(orig_node->tt_buff); 2298 orig_node->tt_buff_len = 0; 2299 orig_node->tt_buff = kmalloc(tt_buff_len, GFP_ATOMIC); 2300 if (orig_node->tt_buff) { 2301 memcpy(orig_node->tt_buff, tt_buff, tt_buff_len); 2302 orig_node->tt_buff_len = tt_buff_len; 2303 } 2304 } 2305 spin_unlock_bh(&orig_node->tt_buff_lock); 2306 } 2307 2308 static void batadv_tt_req_purge(struct batadv_priv *bat_priv) 2309 { 2310 struct batadv_tt_req_node *node; 2311 struct hlist_node *safe; 2312 2313 spin_lock_bh(&bat_priv->tt.req_list_lock); 2314 hlist_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) { 2315 if (batadv_has_timed_out(node->issued_at, 2316 BATADV_TT_REQUEST_TIMEOUT)) { 2317 hlist_del_init(&node->list); 2318 kfree(node); 2319 } 2320 } 2321 spin_unlock_bh(&bat_priv->tt.req_list_lock); 2322 } 2323 2324 /** 2325 * batadv_tt_req_node_new - search and possibly create a tt_req_node object 2326 * @bat_priv: the bat priv with all the soft interface information 2327 * @orig_node: orig node this request is being issued for 2328 * 2329 * Return: the pointer to the new tt_req_node struct if no request 2330 * has already been issued for this orig_node, NULL otherwise. 2331 */ 2332 static struct batadv_tt_req_node * 2333 batadv_tt_req_node_new(struct batadv_priv *bat_priv, 2334 struct batadv_orig_node *orig_node) 2335 { 2336 struct batadv_tt_req_node *tt_req_node_tmp, *tt_req_node = NULL; 2337 2338 spin_lock_bh(&bat_priv->tt.req_list_lock); 2339 hlist_for_each_entry(tt_req_node_tmp, &bat_priv->tt.req_list, list) { 2340 if (batadv_compare_eth(tt_req_node_tmp, orig_node) && 2341 !batadv_has_timed_out(tt_req_node_tmp->issued_at, 2342 BATADV_TT_REQUEST_TIMEOUT)) 2343 goto unlock; 2344 } 2345 2346 tt_req_node = kmalloc(sizeof(*tt_req_node), GFP_ATOMIC); 2347 if (!tt_req_node) 2348 goto unlock; 2349 2350 ether_addr_copy(tt_req_node->addr, orig_node->orig); 2351 tt_req_node->issued_at = jiffies; 2352 2353 hlist_add_head(&tt_req_node->list, &bat_priv->tt.req_list); 2354 unlock: 2355 spin_unlock_bh(&bat_priv->tt.req_list_lock); 2356 return tt_req_node; 2357 } 2358 2359 /** 2360 * batadv_tt_local_valid - verify that given tt entry is a valid one 2361 * @entry_ptr: to be checked local tt entry 2362 * @data_ptr: not used but definition required to satisfy the callback prototype 2363 * 2364 * Return: true if the entry is a valid, false otherwise. 2365 */ 2366 static bool batadv_tt_local_valid(const void *entry_ptr, const void *data_ptr) 2367 { 2368 const struct batadv_tt_common_entry *tt_common_entry = entry_ptr; 2369 2370 if (tt_common_entry->flags & BATADV_TT_CLIENT_NEW) 2371 return false; 2372 return true; 2373 } 2374 2375 static bool batadv_tt_global_valid(const void *entry_ptr, 2376 const void *data_ptr) 2377 { 2378 const struct batadv_tt_common_entry *tt_common_entry = entry_ptr; 2379 const struct batadv_tt_global_entry *tt_global_entry; 2380 const struct batadv_orig_node *orig_node = data_ptr; 2381 2382 if (tt_common_entry->flags & BATADV_TT_CLIENT_ROAM || 2383 tt_common_entry->flags & BATADV_TT_CLIENT_TEMP) 2384 return false; 2385 2386 tt_global_entry = container_of(tt_common_entry, 2387 struct batadv_tt_global_entry, 2388 common); 2389 2390 return batadv_tt_global_entry_has_orig(tt_global_entry, orig_node); 2391 } 2392 2393 /** 2394 * batadv_tt_tvlv_generate - fill the tvlv buff with the tt entries from the 2395 * specified tt hash 2396 * @bat_priv: the bat priv with all the soft interface information 2397 * @hash: hash table containing the tt entries 2398 * @tt_len: expected tvlv tt data buffer length in number of bytes 2399 * @tvlv_buff: pointer to the buffer to fill with the TT data 2400 * @valid_cb: function to filter tt change entries 2401 * @cb_data: data passed to the filter function as argument 2402 */ 2403 static void batadv_tt_tvlv_generate(struct batadv_priv *bat_priv, 2404 struct batadv_hashtable *hash, 2405 void *tvlv_buff, u16 tt_len, 2406 bool (*valid_cb)(const void *, 2407 const void *), 2408 void *cb_data) 2409 { 2410 struct batadv_tt_common_entry *tt_common_entry; 2411 struct batadv_tvlv_tt_change *tt_change; 2412 struct hlist_head *head; 2413 u16 tt_tot, tt_num_entries = 0; 2414 u32 i; 2415 2416 tt_tot = batadv_tt_entries(tt_len); 2417 tt_change = (struct batadv_tvlv_tt_change *)tvlv_buff; 2418 2419 rcu_read_lock(); 2420 for (i = 0; i < hash->size; i++) { 2421 head = &hash->table[i]; 2422 2423 hlist_for_each_entry_rcu(tt_common_entry, 2424 head, hash_entry) { 2425 if (tt_tot == tt_num_entries) 2426 break; 2427 2428 if ((valid_cb) && (!valid_cb(tt_common_entry, cb_data))) 2429 continue; 2430 2431 ether_addr_copy(tt_change->addr, tt_common_entry->addr); 2432 tt_change->flags = tt_common_entry->flags; 2433 tt_change->vid = htons(tt_common_entry->vid); 2434 memset(tt_change->reserved, 0, 2435 sizeof(tt_change->reserved)); 2436 2437 tt_num_entries++; 2438 tt_change++; 2439 } 2440 } 2441 rcu_read_unlock(); 2442 } 2443 2444 /** 2445 * batadv_tt_global_check_crc - check if all the CRCs are correct 2446 * @orig_node: originator for which the CRCs have to be checked 2447 * @tt_vlan: pointer to the first tvlv VLAN entry 2448 * @num_vlan: number of tvlv VLAN entries 2449 * 2450 * Return: true if all the received CRCs match the locally stored ones, false 2451 * otherwise 2452 */ 2453 static bool batadv_tt_global_check_crc(struct batadv_orig_node *orig_node, 2454 struct batadv_tvlv_tt_vlan_data *tt_vlan, 2455 u16 num_vlan) 2456 { 2457 struct batadv_tvlv_tt_vlan_data *tt_vlan_tmp; 2458 struct batadv_orig_node_vlan *vlan; 2459 int i, orig_num_vlan; 2460 u32 crc; 2461 2462 /* check if each received CRC matches the locally stored one */ 2463 for (i = 0; i < num_vlan; i++) { 2464 tt_vlan_tmp = tt_vlan + i; 2465 2466 /* if orig_node is a backbone node for this VLAN, don't check 2467 * the CRC as we ignore all the global entries over it 2468 */ 2469 if (batadv_bla_is_backbone_gw_orig(orig_node->bat_priv, 2470 orig_node->orig, 2471 ntohs(tt_vlan_tmp->vid))) 2472 continue; 2473 2474 vlan = batadv_orig_node_vlan_get(orig_node, 2475 ntohs(tt_vlan_tmp->vid)); 2476 if (!vlan) 2477 return false; 2478 2479 crc = vlan->tt.crc; 2480 batadv_orig_node_vlan_put(vlan); 2481 2482 if (crc != ntohl(tt_vlan_tmp->crc)) 2483 return false; 2484 } 2485 2486 /* check if any excess VLANs exist locally for the originator 2487 * which are not mentioned in the TVLV from the originator. 2488 */ 2489 rcu_read_lock(); 2490 orig_num_vlan = 0; 2491 hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) 2492 orig_num_vlan++; 2493 rcu_read_unlock(); 2494 2495 if (orig_num_vlan > num_vlan) 2496 return false; 2497 2498 return true; 2499 } 2500 2501 /** 2502 * batadv_tt_local_update_crc - update all the local CRCs 2503 * @bat_priv: the bat priv with all the soft interface information 2504 */ 2505 static void batadv_tt_local_update_crc(struct batadv_priv *bat_priv) 2506 { 2507 struct batadv_softif_vlan *vlan; 2508 2509 /* recompute the global CRC for each VLAN */ 2510 rcu_read_lock(); 2511 hlist_for_each_entry_rcu(vlan, &bat_priv->softif_vlan_list, list) { 2512 vlan->tt.crc = batadv_tt_local_crc(bat_priv, vlan->vid); 2513 } 2514 rcu_read_unlock(); 2515 } 2516 2517 /** 2518 * batadv_tt_global_update_crc - update all the global CRCs for this orig_node 2519 * @bat_priv: the bat priv with all the soft interface information 2520 * @orig_node: the orig_node for which the CRCs have to be updated 2521 */ 2522 static void batadv_tt_global_update_crc(struct batadv_priv *bat_priv, 2523 struct batadv_orig_node *orig_node) 2524 { 2525 struct batadv_orig_node_vlan *vlan; 2526 u32 crc; 2527 2528 /* recompute the global CRC for each VLAN */ 2529 rcu_read_lock(); 2530 hlist_for_each_entry_rcu(vlan, &orig_node->vlan_list, list) { 2531 /* if orig_node is a backbone node for this VLAN, don't compute 2532 * the CRC as we ignore all the global entries over it 2533 */ 2534 if (batadv_bla_is_backbone_gw_orig(bat_priv, orig_node->orig, 2535 vlan->vid)) 2536 continue; 2537 2538 crc = batadv_tt_global_crc(bat_priv, orig_node, vlan->vid); 2539 vlan->tt.crc = crc; 2540 } 2541 rcu_read_unlock(); 2542 } 2543 2544 /** 2545 * batadv_send_tt_request - send a TT Request message to a given node 2546 * @bat_priv: the bat priv with all the soft interface information 2547 * @dst_orig_node: the destination of the message 2548 * @ttvn: the version number that the source of the message is looking for 2549 * @tt_vlan: pointer to the first tvlv VLAN object to request 2550 * @num_vlan: number of tvlv VLAN entries 2551 * @full_table: ask for the entire translation table if true, while only for the 2552 * last TT diff otherwise 2553 * 2554 * Return: true if the TT Request was sent, false otherwise 2555 */ 2556 static bool batadv_send_tt_request(struct batadv_priv *bat_priv, 2557 struct batadv_orig_node *dst_orig_node, 2558 u8 ttvn, 2559 struct batadv_tvlv_tt_vlan_data *tt_vlan, 2560 u16 num_vlan, bool full_table) 2561 { 2562 struct batadv_tvlv_tt_data *tvlv_tt_data = NULL; 2563 struct batadv_tt_req_node *tt_req_node = NULL; 2564 struct batadv_tvlv_tt_vlan_data *tt_vlan_req; 2565 struct batadv_hard_iface *primary_if; 2566 bool ret = false; 2567 int i, size; 2568 2569 primary_if = batadv_primary_if_get_selected(bat_priv); 2570 if (!primary_if) 2571 goto out; 2572 2573 /* The new tt_req will be issued only if I'm not waiting for a 2574 * reply from the same orig_node yet 2575 */ 2576 tt_req_node = batadv_tt_req_node_new(bat_priv, dst_orig_node); 2577 if (!tt_req_node) 2578 goto out; 2579 2580 size = sizeof(*tvlv_tt_data) + sizeof(*tt_vlan_req) * num_vlan; 2581 tvlv_tt_data = kzalloc(size, GFP_ATOMIC); 2582 if (!tvlv_tt_data) 2583 goto out; 2584 2585 tvlv_tt_data->flags = BATADV_TT_REQUEST; 2586 tvlv_tt_data->ttvn = ttvn; 2587 tvlv_tt_data->num_vlan = htons(num_vlan); 2588 2589 /* send all the CRCs within the request. This is needed by intermediate 2590 * nodes to ensure they have the correct table before replying 2591 */ 2592 tt_vlan_req = (struct batadv_tvlv_tt_vlan_data *)(tvlv_tt_data + 1); 2593 for (i = 0; i < num_vlan; i++) { 2594 tt_vlan_req->vid = tt_vlan->vid; 2595 tt_vlan_req->crc = tt_vlan->crc; 2596 2597 tt_vlan_req++; 2598 tt_vlan++; 2599 } 2600 2601 if (full_table) 2602 tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE; 2603 2604 batadv_dbg(BATADV_DBG_TT, bat_priv, "Sending TT_REQUEST to %pM [%c]\n", 2605 dst_orig_node->orig, full_table ? 'F' : '.'); 2606 2607 batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_TX); 2608 batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr, 2609 dst_orig_node->orig, BATADV_TVLV_TT, 1, 2610 tvlv_tt_data, size); 2611 ret = true; 2612 2613 out: 2614 if (primary_if) 2615 batadv_hardif_put(primary_if); 2616 if (ret && tt_req_node) { 2617 spin_lock_bh(&bat_priv->tt.req_list_lock); 2618 /* hlist_del_init() verifies tt_req_node still is in the list */ 2619 hlist_del_init(&tt_req_node->list); 2620 spin_unlock_bh(&bat_priv->tt.req_list_lock); 2621 kfree(tt_req_node); 2622 } 2623 kfree(tvlv_tt_data); 2624 return ret; 2625 } 2626 2627 /** 2628 * batadv_send_other_tt_response - send reply to tt request concerning another 2629 * node's translation table 2630 * @bat_priv: the bat priv with all the soft interface information 2631 * @tt_data: tt data containing the tt request information 2632 * @req_src: mac address of tt request sender 2633 * @req_dst: mac address of tt request recipient 2634 * 2635 * Return: true if tt request reply was sent, false otherwise. 2636 */ 2637 static bool batadv_send_other_tt_response(struct batadv_priv *bat_priv, 2638 struct batadv_tvlv_tt_data *tt_data, 2639 u8 *req_src, u8 *req_dst) 2640 { 2641 struct batadv_orig_node *req_dst_orig_node; 2642 struct batadv_orig_node *res_dst_orig_node = NULL; 2643 struct batadv_tvlv_tt_change *tt_change; 2644 struct batadv_tvlv_tt_data *tvlv_tt_data = NULL; 2645 struct batadv_tvlv_tt_vlan_data *tt_vlan; 2646 bool ret = false, full_table; 2647 u8 orig_ttvn, req_ttvn; 2648 u16 tvlv_len; 2649 s32 tt_len; 2650 2651 batadv_dbg(BATADV_DBG_TT, bat_priv, 2652 "Received TT_REQUEST from %pM for ttvn: %u (%pM) [%c]\n", 2653 req_src, tt_data->ttvn, req_dst, 2654 ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.')); 2655 2656 /* Let's get the orig node of the REAL destination */ 2657 req_dst_orig_node = batadv_orig_hash_find(bat_priv, req_dst); 2658 if (!req_dst_orig_node) 2659 goto out; 2660 2661 res_dst_orig_node = batadv_orig_hash_find(bat_priv, req_src); 2662 if (!res_dst_orig_node) 2663 goto out; 2664 2665 orig_ttvn = (u8)atomic_read(&req_dst_orig_node->last_ttvn); 2666 req_ttvn = tt_data->ttvn; 2667 2668 tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(tt_data + 1); 2669 /* this node doesn't have the requested data */ 2670 if (orig_ttvn != req_ttvn || 2671 !batadv_tt_global_check_crc(req_dst_orig_node, tt_vlan, 2672 ntohs(tt_data->num_vlan))) 2673 goto out; 2674 2675 /* If the full table has been explicitly requested */ 2676 if (tt_data->flags & BATADV_TT_FULL_TABLE || 2677 !req_dst_orig_node->tt_buff) 2678 full_table = true; 2679 else 2680 full_table = false; 2681 2682 /* TT fragmentation hasn't been implemented yet, so send as many 2683 * TT entries fit a single packet as possible only 2684 */ 2685 if (!full_table) { 2686 spin_lock_bh(&req_dst_orig_node->tt_buff_lock); 2687 tt_len = req_dst_orig_node->tt_buff_len; 2688 2689 tvlv_len = batadv_tt_prepare_tvlv_global_data(req_dst_orig_node, 2690 &tvlv_tt_data, 2691 &tt_change, 2692 &tt_len); 2693 if (!tt_len) 2694 goto unlock; 2695 2696 /* Copy the last orig_node's OGM buffer */ 2697 memcpy(tt_change, req_dst_orig_node->tt_buff, 2698 req_dst_orig_node->tt_buff_len); 2699 spin_unlock_bh(&req_dst_orig_node->tt_buff_lock); 2700 } else { 2701 /* allocate the tvlv, put the tt_data and all the tt_vlan_data 2702 * in the initial part 2703 */ 2704 tt_len = -1; 2705 tvlv_len = batadv_tt_prepare_tvlv_global_data(req_dst_orig_node, 2706 &tvlv_tt_data, 2707 &tt_change, 2708 &tt_len); 2709 if (!tt_len) 2710 goto out; 2711 2712 /* fill the rest of the tvlv with the real TT entries */ 2713 batadv_tt_tvlv_generate(bat_priv, bat_priv->tt.global_hash, 2714 tt_change, tt_len, 2715 batadv_tt_global_valid, 2716 req_dst_orig_node); 2717 } 2718 2719 /* Don't send the response, if larger than fragmented packet. */ 2720 tt_len = sizeof(struct batadv_unicast_tvlv_packet) + tvlv_len; 2721 if (tt_len > atomic_read(&bat_priv->packet_size_max)) { 2722 net_ratelimited_function(batadv_info, bat_priv->soft_iface, 2723 "Ignoring TT_REQUEST from %pM; Response size exceeds max packet size.\n", 2724 res_dst_orig_node->orig); 2725 goto out; 2726 } 2727 2728 tvlv_tt_data->flags = BATADV_TT_RESPONSE; 2729 tvlv_tt_data->ttvn = req_ttvn; 2730 2731 if (full_table) 2732 tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE; 2733 2734 batadv_dbg(BATADV_DBG_TT, bat_priv, 2735 "Sending TT_RESPONSE %pM for %pM [%c] (ttvn: %u)\n", 2736 res_dst_orig_node->orig, req_dst_orig_node->orig, 2737 full_table ? 'F' : '.', req_ttvn); 2738 2739 batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX); 2740 2741 batadv_tvlv_unicast_send(bat_priv, req_dst_orig_node->orig, 2742 req_src, BATADV_TVLV_TT, 1, tvlv_tt_data, 2743 tvlv_len); 2744 2745 ret = true; 2746 goto out; 2747 2748 unlock: 2749 spin_unlock_bh(&req_dst_orig_node->tt_buff_lock); 2750 2751 out: 2752 if (res_dst_orig_node) 2753 batadv_orig_node_put(res_dst_orig_node); 2754 if (req_dst_orig_node) 2755 batadv_orig_node_put(req_dst_orig_node); 2756 kfree(tvlv_tt_data); 2757 return ret; 2758 } 2759 2760 /** 2761 * batadv_send_my_tt_response - send reply to tt request concerning this node's 2762 * translation table 2763 * @bat_priv: the bat priv with all the soft interface information 2764 * @tt_data: tt data containing the tt request information 2765 * @req_src: mac address of tt request sender 2766 * 2767 * Return: true if tt request reply was sent, false otherwise. 2768 */ 2769 static bool batadv_send_my_tt_response(struct batadv_priv *bat_priv, 2770 struct batadv_tvlv_tt_data *tt_data, 2771 u8 *req_src) 2772 { 2773 struct batadv_tvlv_tt_data *tvlv_tt_data = NULL; 2774 struct batadv_hard_iface *primary_if = NULL; 2775 struct batadv_tvlv_tt_change *tt_change; 2776 struct batadv_orig_node *orig_node; 2777 u8 my_ttvn, req_ttvn; 2778 u16 tvlv_len; 2779 bool full_table; 2780 s32 tt_len; 2781 2782 batadv_dbg(BATADV_DBG_TT, bat_priv, 2783 "Received TT_REQUEST from %pM for ttvn: %u (me) [%c]\n", 2784 req_src, tt_data->ttvn, 2785 ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.')); 2786 2787 spin_lock_bh(&bat_priv->tt.commit_lock); 2788 2789 my_ttvn = (u8)atomic_read(&bat_priv->tt.vn); 2790 req_ttvn = tt_data->ttvn; 2791 2792 orig_node = batadv_orig_hash_find(bat_priv, req_src); 2793 if (!orig_node) 2794 goto out; 2795 2796 primary_if = batadv_primary_if_get_selected(bat_priv); 2797 if (!primary_if) 2798 goto out; 2799 2800 /* If the full table has been explicitly requested or the gap 2801 * is too big send the whole local translation table 2802 */ 2803 if (tt_data->flags & BATADV_TT_FULL_TABLE || my_ttvn != req_ttvn || 2804 !bat_priv->tt.last_changeset) 2805 full_table = true; 2806 else 2807 full_table = false; 2808 2809 /* TT fragmentation hasn't been implemented yet, so send as many 2810 * TT entries fit a single packet as possible only 2811 */ 2812 if (!full_table) { 2813 spin_lock_bh(&bat_priv->tt.last_changeset_lock); 2814 2815 tt_len = bat_priv->tt.last_changeset_len; 2816 tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv, 2817 &tvlv_tt_data, 2818 &tt_change, 2819 &tt_len); 2820 if (!tt_len) 2821 goto unlock; 2822 2823 /* Copy the last orig_node's OGM buffer */ 2824 memcpy(tt_change, bat_priv->tt.last_changeset, 2825 bat_priv->tt.last_changeset_len); 2826 spin_unlock_bh(&bat_priv->tt.last_changeset_lock); 2827 } else { 2828 req_ttvn = (u8)atomic_read(&bat_priv->tt.vn); 2829 2830 /* allocate the tvlv, put the tt_data and all the tt_vlan_data 2831 * in the initial part 2832 */ 2833 tt_len = -1; 2834 tvlv_len = batadv_tt_prepare_tvlv_local_data(bat_priv, 2835 &tvlv_tt_data, 2836 &tt_change, 2837 &tt_len); 2838 if (!tt_len) 2839 goto out; 2840 2841 /* fill the rest of the tvlv with the real TT entries */ 2842 batadv_tt_tvlv_generate(bat_priv, bat_priv->tt.local_hash, 2843 tt_change, tt_len, 2844 batadv_tt_local_valid, NULL); 2845 } 2846 2847 tvlv_tt_data->flags = BATADV_TT_RESPONSE; 2848 tvlv_tt_data->ttvn = req_ttvn; 2849 2850 if (full_table) 2851 tvlv_tt_data->flags |= BATADV_TT_FULL_TABLE; 2852 2853 batadv_dbg(BATADV_DBG_TT, bat_priv, 2854 "Sending TT_RESPONSE to %pM [%c] (ttvn: %u)\n", 2855 orig_node->orig, full_table ? 'F' : '.', req_ttvn); 2856 2857 batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_TX); 2858 2859 batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr, 2860 req_src, BATADV_TVLV_TT, 1, tvlv_tt_data, 2861 tvlv_len); 2862 2863 goto out; 2864 2865 unlock: 2866 spin_unlock_bh(&bat_priv->tt.last_changeset_lock); 2867 out: 2868 spin_unlock_bh(&bat_priv->tt.commit_lock); 2869 if (orig_node) 2870 batadv_orig_node_put(orig_node); 2871 if (primary_if) 2872 batadv_hardif_put(primary_if); 2873 kfree(tvlv_tt_data); 2874 /* The packet was for this host, so it doesn't need to be re-routed */ 2875 return true; 2876 } 2877 2878 /** 2879 * batadv_send_tt_response - send reply to tt request 2880 * @bat_priv: the bat priv with all the soft interface information 2881 * @tt_data: tt data containing the tt request information 2882 * @req_src: mac address of tt request sender 2883 * @req_dst: mac address of tt request recipient 2884 * 2885 * Return: true if tt request reply was sent, false otherwise. 2886 */ 2887 static bool batadv_send_tt_response(struct batadv_priv *bat_priv, 2888 struct batadv_tvlv_tt_data *tt_data, 2889 u8 *req_src, u8 *req_dst) 2890 { 2891 if (batadv_is_my_mac(bat_priv, req_dst)) 2892 return batadv_send_my_tt_response(bat_priv, tt_data, req_src); 2893 return batadv_send_other_tt_response(bat_priv, tt_data, req_src, 2894 req_dst); 2895 } 2896 2897 static void _batadv_tt_update_changes(struct batadv_priv *bat_priv, 2898 struct batadv_orig_node *orig_node, 2899 struct batadv_tvlv_tt_change *tt_change, 2900 u16 tt_num_changes, u8 ttvn) 2901 { 2902 int i; 2903 int roams; 2904 2905 for (i = 0; i < tt_num_changes; i++) { 2906 if ((tt_change + i)->flags & BATADV_TT_CLIENT_DEL) { 2907 roams = (tt_change + i)->flags & BATADV_TT_CLIENT_ROAM; 2908 batadv_tt_global_del(bat_priv, orig_node, 2909 (tt_change + i)->addr, 2910 ntohs((tt_change + i)->vid), 2911 "tt removed by changes", 2912 roams); 2913 } else { 2914 if (!batadv_tt_global_add(bat_priv, orig_node, 2915 (tt_change + i)->addr, 2916 ntohs((tt_change + i)->vid), 2917 (tt_change + i)->flags, ttvn)) 2918 /* In case of problem while storing a 2919 * global_entry, we stop the updating 2920 * procedure without committing the 2921 * ttvn change. This will avoid to send 2922 * corrupted data on tt_request 2923 */ 2924 return; 2925 } 2926 } 2927 set_bit(BATADV_ORIG_CAPA_HAS_TT, &orig_node->capa_initialized); 2928 } 2929 2930 static void batadv_tt_fill_gtable(struct batadv_priv *bat_priv, 2931 struct batadv_tvlv_tt_change *tt_change, 2932 u8 ttvn, u8 *resp_src, 2933 u16 num_entries) 2934 { 2935 struct batadv_orig_node *orig_node; 2936 2937 orig_node = batadv_orig_hash_find(bat_priv, resp_src); 2938 if (!orig_node) 2939 goto out; 2940 2941 /* Purge the old table first.. */ 2942 batadv_tt_global_del_orig(bat_priv, orig_node, -1, 2943 "Received full table"); 2944 2945 _batadv_tt_update_changes(bat_priv, orig_node, tt_change, num_entries, 2946 ttvn); 2947 2948 spin_lock_bh(&orig_node->tt_buff_lock); 2949 kfree(orig_node->tt_buff); 2950 orig_node->tt_buff_len = 0; 2951 orig_node->tt_buff = NULL; 2952 spin_unlock_bh(&orig_node->tt_buff_lock); 2953 2954 atomic_set(&orig_node->last_ttvn, ttvn); 2955 2956 out: 2957 if (orig_node) 2958 batadv_orig_node_put(orig_node); 2959 } 2960 2961 static void batadv_tt_update_changes(struct batadv_priv *bat_priv, 2962 struct batadv_orig_node *orig_node, 2963 u16 tt_num_changes, u8 ttvn, 2964 struct batadv_tvlv_tt_change *tt_change) 2965 { 2966 _batadv_tt_update_changes(bat_priv, orig_node, tt_change, 2967 tt_num_changes, ttvn); 2968 2969 batadv_tt_save_orig_buffer(bat_priv, orig_node, tt_change, 2970 batadv_tt_len(tt_num_changes)); 2971 atomic_set(&orig_node->last_ttvn, ttvn); 2972 } 2973 2974 /** 2975 * batadv_is_my_client - check if a client is served by the local node 2976 * @bat_priv: the bat priv with all the soft interface information 2977 * @addr: the mac address of the client to check 2978 * @vid: VLAN identifier 2979 * 2980 * Return: true if the client is served by this node, false otherwise. 2981 */ 2982 bool batadv_is_my_client(struct batadv_priv *bat_priv, const u8 *addr, 2983 unsigned short vid) 2984 { 2985 struct batadv_tt_local_entry *tt_local_entry; 2986 bool ret = false; 2987 2988 tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid); 2989 if (!tt_local_entry) 2990 goto out; 2991 /* Check if the client has been logically deleted (but is kept for 2992 * consistency purpose) 2993 */ 2994 if ((tt_local_entry->common.flags & BATADV_TT_CLIENT_PENDING) || 2995 (tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM)) 2996 goto out; 2997 ret = true; 2998 out: 2999 if (tt_local_entry) 3000 batadv_tt_local_entry_put(tt_local_entry); 3001 return ret; 3002 } 3003 3004 /** 3005 * batadv_handle_tt_response - process incoming tt reply 3006 * @bat_priv: the bat priv with all the soft interface information 3007 * @tt_data: tt data containing the tt request information 3008 * @resp_src: mac address of tt reply sender 3009 * @num_entries: number of tt change entries appended to the tt data 3010 */ 3011 static void batadv_handle_tt_response(struct batadv_priv *bat_priv, 3012 struct batadv_tvlv_tt_data *tt_data, 3013 u8 *resp_src, u16 num_entries) 3014 { 3015 struct batadv_tt_req_node *node; 3016 struct hlist_node *safe; 3017 struct batadv_orig_node *orig_node = NULL; 3018 struct batadv_tvlv_tt_change *tt_change; 3019 u8 *tvlv_ptr = (u8 *)tt_data; 3020 u16 change_offset; 3021 3022 batadv_dbg(BATADV_DBG_TT, bat_priv, 3023 "Received TT_RESPONSE from %pM for ttvn %d t_size: %d [%c]\n", 3024 resp_src, tt_data->ttvn, num_entries, 3025 ((tt_data->flags & BATADV_TT_FULL_TABLE) ? 'F' : '.')); 3026 3027 orig_node = batadv_orig_hash_find(bat_priv, resp_src); 3028 if (!orig_node) 3029 goto out; 3030 3031 spin_lock_bh(&orig_node->tt_lock); 3032 3033 change_offset = sizeof(struct batadv_tvlv_tt_vlan_data); 3034 change_offset *= ntohs(tt_data->num_vlan); 3035 change_offset += sizeof(*tt_data); 3036 tvlv_ptr += change_offset; 3037 3038 tt_change = (struct batadv_tvlv_tt_change *)tvlv_ptr; 3039 if (tt_data->flags & BATADV_TT_FULL_TABLE) { 3040 batadv_tt_fill_gtable(bat_priv, tt_change, tt_data->ttvn, 3041 resp_src, num_entries); 3042 } else { 3043 batadv_tt_update_changes(bat_priv, orig_node, num_entries, 3044 tt_data->ttvn, tt_change); 3045 } 3046 3047 /* Recalculate the CRC for this orig_node and store it */ 3048 batadv_tt_global_update_crc(bat_priv, orig_node); 3049 3050 spin_unlock_bh(&orig_node->tt_lock); 3051 3052 /* Delete the tt_req_node from pending tt_requests list */ 3053 spin_lock_bh(&bat_priv->tt.req_list_lock); 3054 hlist_for_each_entry_safe(node, safe, &bat_priv->tt.req_list, list) { 3055 if (!batadv_compare_eth(node->addr, resp_src)) 3056 continue; 3057 hlist_del_init(&node->list); 3058 kfree(node); 3059 } 3060 3061 spin_unlock_bh(&bat_priv->tt.req_list_lock); 3062 out: 3063 if (orig_node) 3064 batadv_orig_node_put(orig_node); 3065 } 3066 3067 static void batadv_tt_roam_list_free(struct batadv_priv *bat_priv) 3068 { 3069 struct batadv_tt_roam_node *node, *safe; 3070 3071 spin_lock_bh(&bat_priv->tt.roam_list_lock); 3072 3073 list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) { 3074 list_del(&node->list); 3075 kfree(node); 3076 } 3077 3078 spin_unlock_bh(&bat_priv->tt.roam_list_lock); 3079 } 3080 3081 static void batadv_tt_roam_purge(struct batadv_priv *bat_priv) 3082 { 3083 struct batadv_tt_roam_node *node, *safe; 3084 3085 spin_lock_bh(&bat_priv->tt.roam_list_lock); 3086 list_for_each_entry_safe(node, safe, &bat_priv->tt.roam_list, list) { 3087 if (!batadv_has_timed_out(node->first_time, 3088 BATADV_ROAMING_MAX_TIME)) 3089 continue; 3090 3091 list_del(&node->list); 3092 kfree(node); 3093 } 3094 spin_unlock_bh(&bat_priv->tt.roam_list_lock); 3095 } 3096 3097 /** 3098 * batadv_tt_check_roam_count - check if a client has roamed too frequently 3099 * @bat_priv: the bat priv with all the soft interface information 3100 * @client: mac address of the roaming client 3101 * 3102 * This function checks whether the client already reached the 3103 * maximum number of possible roaming phases. In this case the ROAMING_ADV 3104 * will not be sent. 3105 * 3106 * Return: true if the ROAMING_ADV can be sent, false otherwise 3107 */ 3108 static bool batadv_tt_check_roam_count(struct batadv_priv *bat_priv, u8 *client) 3109 { 3110 struct batadv_tt_roam_node *tt_roam_node; 3111 bool ret = false; 3112 3113 spin_lock_bh(&bat_priv->tt.roam_list_lock); 3114 /* The new tt_req will be issued only if I'm not waiting for a 3115 * reply from the same orig_node yet 3116 */ 3117 list_for_each_entry(tt_roam_node, &bat_priv->tt.roam_list, list) { 3118 if (!batadv_compare_eth(tt_roam_node->addr, client)) 3119 continue; 3120 3121 if (batadv_has_timed_out(tt_roam_node->first_time, 3122 BATADV_ROAMING_MAX_TIME)) 3123 continue; 3124 3125 if (!batadv_atomic_dec_not_zero(&tt_roam_node->counter)) 3126 /* Sorry, you roamed too many times! */ 3127 goto unlock; 3128 ret = true; 3129 break; 3130 } 3131 3132 if (!ret) { 3133 tt_roam_node = kmalloc(sizeof(*tt_roam_node), GFP_ATOMIC); 3134 if (!tt_roam_node) 3135 goto unlock; 3136 3137 tt_roam_node->first_time = jiffies; 3138 atomic_set(&tt_roam_node->counter, 3139 BATADV_ROAMING_MAX_COUNT - 1); 3140 ether_addr_copy(tt_roam_node->addr, client); 3141 3142 list_add(&tt_roam_node->list, &bat_priv->tt.roam_list); 3143 ret = true; 3144 } 3145 3146 unlock: 3147 spin_unlock_bh(&bat_priv->tt.roam_list_lock); 3148 return ret; 3149 } 3150 3151 /** 3152 * batadv_send_roam_adv - send a roaming advertisement message 3153 * @bat_priv: the bat priv with all the soft interface information 3154 * @client: mac address of the roaming client 3155 * @vid: VLAN identifier 3156 * @orig_node: message destination 3157 * 3158 * Send a ROAMING_ADV message to the node which was previously serving this 3159 * client. This is done to inform the node that from now on all traffic destined 3160 * for this particular roamed client has to be forwarded to the sender of the 3161 * roaming message. 3162 */ 3163 static void batadv_send_roam_adv(struct batadv_priv *bat_priv, u8 *client, 3164 unsigned short vid, 3165 struct batadv_orig_node *orig_node) 3166 { 3167 struct batadv_hard_iface *primary_if; 3168 struct batadv_tvlv_roam_adv tvlv_roam; 3169 3170 primary_if = batadv_primary_if_get_selected(bat_priv); 3171 if (!primary_if) 3172 goto out; 3173 3174 /* before going on we have to check whether the client has 3175 * already roamed to us too many times 3176 */ 3177 if (!batadv_tt_check_roam_count(bat_priv, client)) 3178 goto out; 3179 3180 batadv_dbg(BATADV_DBG_TT, bat_priv, 3181 "Sending ROAMING_ADV to %pM (client %pM, vid: %d)\n", 3182 orig_node->orig, client, BATADV_PRINT_VID(vid)); 3183 3184 batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_TX); 3185 3186 memcpy(tvlv_roam.client, client, sizeof(tvlv_roam.client)); 3187 tvlv_roam.vid = htons(vid); 3188 3189 batadv_tvlv_unicast_send(bat_priv, primary_if->net_dev->dev_addr, 3190 orig_node->orig, BATADV_TVLV_ROAM, 1, 3191 &tvlv_roam, sizeof(tvlv_roam)); 3192 3193 out: 3194 if (primary_if) 3195 batadv_hardif_put(primary_if); 3196 } 3197 3198 static void batadv_tt_purge(struct work_struct *work) 3199 { 3200 struct delayed_work *delayed_work; 3201 struct batadv_priv_tt *priv_tt; 3202 struct batadv_priv *bat_priv; 3203 3204 delayed_work = to_delayed_work(work); 3205 priv_tt = container_of(delayed_work, struct batadv_priv_tt, work); 3206 bat_priv = container_of(priv_tt, struct batadv_priv, tt); 3207 3208 batadv_tt_local_purge(bat_priv, BATADV_TT_LOCAL_TIMEOUT); 3209 batadv_tt_global_purge(bat_priv); 3210 batadv_tt_req_purge(bat_priv); 3211 batadv_tt_roam_purge(bat_priv); 3212 3213 queue_delayed_work(batadv_event_workqueue, &bat_priv->tt.work, 3214 msecs_to_jiffies(BATADV_TT_WORK_PERIOD)); 3215 } 3216 3217 void batadv_tt_free(struct batadv_priv *bat_priv) 3218 { 3219 batadv_tvlv_container_unregister(bat_priv, BATADV_TVLV_TT, 1); 3220 batadv_tvlv_handler_unregister(bat_priv, BATADV_TVLV_TT, 1); 3221 3222 cancel_delayed_work_sync(&bat_priv->tt.work); 3223 3224 batadv_tt_local_table_free(bat_priv); 3225 batadv_tt_global_table_free(bat_priv); 3226 batadv_tt_req_list_free(bat_priv); 3227 batadv_tt_changes_list_free(bat_priv); 3228 batadv_tt_roam_list_free(bat_priv); 3229 3230 kfree(bat_priv->tt.last_changeset); 3231 } 3232 3233 /** 3234 * batadv_tt_local_set_flags - set or unset the specified flags on the local 3235 * table and possibly count them in the TT size 3236 * @bat_priv: the bat priv with all the soft interface information 3237 * @flags: the flag to switch 3238 * @enable: whether to set or unset the flag 3239 * @count: whether to increase the TT size by the number of changed entries 3240 */ 3241 static void batadv_tt_local_set_flags(struct batadv_priv *bat_priv, u16 flags, 3242 bool enable, bool count) 3243 { 3244 struct batadv_hashtable *hash = bat_priv->tt.local_hash; 3245 struct batadv_tt_common_entry *tt_common_entry; 3246 u16 changed_num = 0; 3247 struct hlist_head *head; 3248 u32 i; 3249 3250 if (!hash) 3251 return; 3252 3253 for (i = 0; i < hash->size; i++) { 3254 head = &hash->table[i]; 3255 3256 rcu_read_lock(); 3257 hlist_for_each_entry_rcu(tt_common_entry, 3258 head, hash_entry) { 3259 if (enable) { 3260 if ((tt_common_entry->flags & flags) == flags) 3261 continue; 3262 tt_common_entry->flags |= flags; 3263 } else { 3264 if (!(tt_common_entry->flags & flags)) 3265 continue; 3266 tt_common_entry->flags &= ~flags; 3267 } 3268 changed_num++; 3269 3270 if (!count) 3271 continue; 3272 3273 batadv_tt_local_size_inc(bat_priv, 3274 tt_common_entry->vid); 3275 } 3276 rcu_read_unlock(); 3277 } 3278 } 3279 3280 /* Purge out all the tt local entries marked with BATADV_TT_CLIENT_PENDING */ 3281 static void batadv_tt_local_purge_pending_clients(struct batadv_priv *bat_priv) 3282 { 3283 struct batadv_hashtable *hash = bat_priv->tt.local_hash; 3284 struct batadv_tt_common_entry *tt_common; 3285 struct batadv_tt_local_entry *tt_local; 3286 struct hlist_node *node_tmp; 3287 struct hlist_head *head; 3288 spinlock_t *list_lock; /* protects write access to the hash lists */ 3289 u32 i; 3290 3291 if (!hash) 3292 return; 3293 3294 for (i = 0; i < hash->size; i++) { 3295 head = &hash->table[i]; 3296 list_lock = &hash->list_locks[i]; 3297 3298 spin_lock_bh(list_lock); 3299 hlist_for_each_entry_safe(tt_common, node_tmp, head, 3300 hash_entry) { 3301 if (!(tt_common->flags & BATADV_TT_CLIENT_PENDING)) 3302 continue; 3303 3304 batadv_dbg(BATADV_DBG_TT, bat_priv, 3305 "Deleting local tt entry (%pM, vid: %d): pending\n", 3306 tt_common->addr, 3307 BATADV_PRINT_VID(tt_common->vid)); 3308 3309 batadv_tt_local_size_dec(bat_priv, tt_common->vid); 3310 hlist_del_rcu(&tt_common->hash_entry); 3311 tt_local = container_of(tt_common, 3312 struct batadv_tt_local_entry, 3313 common); 3314 3315 batadv_tt_local_entry_put(tt_local); 3316 } 3317 spin_unlock_bh(list_lock); 3318 } 3319 } 3320 3321 /** 3322 * batadv_tt_local_commit_changes_nolock - commit all pending local tt changes 3323 * which have been queued in the time since the last commit 3324 * @bat_priv: the bat priv with all the soft interface information 3325 * 3326 * Caller must hold tt->commit_lock. 3327 */ 3328 static void batadv_tt_local_commit_changes_nolock(struct batadv_priv *bat_priv) 3329 { 3330 lockdep_assert_held(&bat_priv->tt.commit_lock); 3331 3332 /* Update multicast addresses in local translation table */ 3333 batadv_mcast_mla_update(bat_priv); 3334 3335 if (atomic_read(&bat_priv->tt.local_changes) < 1) { 3336 if (!batadv_atomic_dec_not_zero(&bat_priv->tt.ogm_append_cnt)) 3337 batadv_tt_tvlv_container_update(bat_priv); 3338 return; 3339 } 3340 3341 batadv_tt_local_set_flags(bat_priv, BATADV_TT_CLIENT_NEW, false, true); 3342 3343 batadv_tt_local_purge_pending_clients(bat_priv); 3344 batadv_tt_local_update_crc(bat_priv); 3345 3346 /* Increment the TTVN only once per OGM interval */ 3347 atomic_inc(&bat_priv->tt.vn); 3348 batadv_dbg(BATADV_DBG_TT, bat_priv, 3349 "Local changes committed, updating to ttvn %u\n", 3350 (u8)atomic_read(&bat_priv->tt.vn)); 3351 3352 /* reset the sending counter */ 3353 atomic_set(&bat_priv->tt.ogm_append_cnt, BATADV_TT_OGM_APPEND_MAX); 3354 batadv_tt_tvlv_container_update(bat_priv); 3355 } 3356 3357 /** 3358 * batadv_tt_local_commit_changes - commit all pending local tt changes which 3359 * have been queued in the time since the last commit 3360 * @bat_priv: the bat priv with all the soft interface information 3361 */ 3362 void batadv_tt_local_commit_changes(struct batadv_priv *bat_priv) 3363 { 3364 spin_lock_bh(&bat_priv->tt.commit_lock); 3365 batadv_tt_local_commit_changes_nolock(bat_priv); 3366 spin_unlock_bh(&bat_priv->tt.commit_lock); 3367 } 3368 3369 bool batadv_is_ap_isolated(struct batadv_priv *bat_priv, u8 *src, u8 *dst, 3370 unsigned short vid) 3371 { 3372 struct batadv_tt_local_entry *tt_local_entry = NULL; 3373 struct batadv_tt_global_entry *tt_global_entry = NULL; 3374 struct batadv_softif_vlan *vlan; 3375 bool ret = false; 3376 3377 vlan = batadv_softif_vlan_get(bat_priv, vid); 3378 if (!vlan) 3379 return false; 3380 3381 if (!atomic_read(&vlan->ap_isolation)) 3382 goto out; 3383 3384 tt_local_entry = batadv_tt_local_hash_find(bat_priv, dst, vid); 3385 if (!tt_local_entry) 3386 goto out; 3387 3388 tt_global_entry = batadv_tt_global_hash_find(bat_priv, src, vid); 3389 if (!tt_global_entry) 3390 goto out; 3391 3392 if (!_batadv_is_ap_isolated(tt_local_entry, tt_global_entry)) 3393 goto out; 3394 3395 ret = true; 3396 3397 out: 3398 batadv_softif_vlan_put(vlan); 3399 if (tt_global_entry) 3400 batadv_tt_global_entry_put(tt_global_entry); 3401 if (tt_local_entry) 3402 batadv_tt_local_entry_put(tt_local_entry); 3403 return ret; 3404 } 3405 3406 /** 3407 * batadv_tt_update_orig - update global translation table with new tt 3408 * information received via ogms 3409 * @bat_priv: the bat priv with all the soft interface information 3410 * @orig_node: the orig_node of the ogm 3411 * @tt_buff: pointer to the first tvlv VLAN entry 3412 * @tt_num_vlan: number of tvlv VLAN entries 3413 * @tt_change: pointer to the first entry in the TT buffer 3414 * @tt_num_changes: number of tt changes inside the tt buffer 3415 * @ttvn: translation table version number of this changeset 3416 */ 3417 static void batadv_tt_update_orig(struct batadv_priv *bat_priv, 3418 struct batadv_orig_node *orig_node, 3419 const void *tt_buff, u16 tt_num_vlan, 3420 struct batadv_tvlv_tt_change *tt_change, 3421 u16 tt_num_changes, u8 ttvn) 3422 { 3423 u8 orig_ttvn = (u8)atomic_read(&orig_node->last_ttvn); 3424 struct batadv_tvlv_tt_vlan_data *tt_vlan; 3425 bool full_table = true; 3426 bool has_tt_init; 3427 3428 tt_vlan = (struct batadv_tvlv_tt_vlan_data *)tt_buff; 3429 has_tt_init = test_bit(BATADV_ORIG_CAPA_HAS_TT, 3430 &orig_node->capa_initialized); 3431 3432 /* orig table not initialised AND first diff is in the OGM OR the ttvn 3433 * increased by one -> we can apply the attached changes 3434 */ 3435 if ((!has_tt_init && ttvn == 1) || ttvn - orig_ttvn == 1) { 3436 /* the OGM could not contain the changes due to their size or 3437 * because they have already been sent BATADV_TT_OGM_APPEND_MAX 3438 * times. 3439 * In this case send a tt request 3440 */ 3441 if (!tt_num_changes) { 3442 full_table = false; 3443 goto request_table; 3444 } 3445 3446 spin_lock_bh(&orig_node->tt_lock); 3447 3448 batadv_tt_update_changes(bat_priv, orig_node, tt_num_changes, 3449 ttvn, tt_change); 3450 3451 /* Even if we received the precomputed crc with the OGM, we 3452 * prefer to recompute it to spot any possible inconsistency 3453 * in the global table 3454 */ 3455 batadv_tt_global_update_crc(bat_priv, orig_node); 3456 3457 spin_unlock_bh(&orig_node->tt_lock); 3458 3459 /* The ttvn alone is not enough to guarantee consistency 3460 * because a single value could represent different states 3461 * (due to the wrap around). Thus a node has to check whether 3462 * the resulting table (after applying the changes) is still 3463 * consistent or not. E.g. a node could disconnect while its 3464 * ttvn is X and reconnect on ttvn = X + TTVN_MAX: in this case 3465 * checking the CRC value is mandatory to detect the 3466 * inconsistency 3467 */ 3468 if (!batadv_tt_global_check_crc(orig_node, tt_vlan, 3469 tt_num_vlan)) 3470 goto request_table; 3471 } else { 3472 /* if we missed more than one change or our tables are not 3473 * in sync anymore -> request fresh tt data 3474 */ 3475 if (!has_tt_init || ttvn != orig_ttvn || 3476 !batadv_tt_global_check_crc(orig_node, tt_vlan, 3477 tt_num_vlan)) { 3478 request_table: 3479 batadv_dbg(BATADV_DBG_TT, bat_priv, 3480 "TT inconsistency for %pM. Need to retrieve the correct information (ttvn: %u last_ttvn: %u num_changes: %u)\n", 3481 orig_node->orig, ttvn, orig_ttvn, 3482 tt_num_changes); 3483 batadv_send_tt_request(bat_priv, orig_node, ttvn, 3484 tt_vlan, tt_num_vlan, 3485 full_table); 3486 return; 3487 } 3488 } 3489 } 3490 3491 /** 3492 * batadv_tt_global_client_is_roaming - check if a client is marked as roaming 3493 * @bat_priv: the bat priv with all the soft interface information 3494 * @addr: the mac address of the client to check 3495 * @vid: VLAN identifier 3496 * 3497 * Return: true if we know that the client has moved from its old originator 3498 * to another one. This entry is still kept for consistency purposes and will be 3499 * deleted later by a DEL or because of timeout 3500 */ 3501 bool batadv_tt_global_client_is_roaming(struct batadv_priv *bat_priv, 3502 u8 *addr, unsigned short vid) 3503 { 3504 struct batadv_tt_global_entry *tt_global_entry; 3505 bool ret = false; 3506 3507 tt_global_entry = batadv_tt_global_hash_find(bat_priv, addr, vid); 3508 if (!tt_global_entry) 3509 goto out; 3510 3511 ret = tt_global_entry->common.flags & BATADV_TT_CLIENT_ROAM; 3512 batadv_tt_global_entry_put(tt_global_entry); 3513 out: 3514 return ret; 3515 } 3516 3517 /** 3518 * batadv_tt_local_client_is_roaming - tells whether the client is roaming 3519 * @bat_priv: the bat priv with all the soft interface information 3520 * @addr: the mac address of the local client to query 3521 * @vid: VLAN identifier 3522 * 3523 * Return: true if the local client is known to be roaming (it is not served by 3524 * this node anymore) or not. If yes, the client is still present in the table 3525 * to keep the latter consistent with the node TTVN 3526 */ 3527 bool batadv_tt_local_client_is_roaming(struct batadv_priv *bat_priv, 3528 u8 *addr, unsigned short vid) 3529 { 3530 struct batadv_tt_local_entry *tt_local_entry; 3531 bool ret = false; 3532 3533 tt_local_entry = batadv_tt_local_hash_find(bat_priv, addr, vid); 3534 if (!tt_local_entry) 3535 goto out; 3536 3537 ret = tt_local_entry->common.flags & BATADV_TT_CLIENT_ROAM; 3538 batadv_tt_local_entry_put(tt_local_entry); 3539 out: 3540 return ret; 3541 } 3542 3543 bool batadv_tt_add_temporary_global_entry(struct batadv_priv *bat_priv, 3544 struct batadv_orig_node *orig_node, 3545 const unsigned char *addr, 3546 unsigned short vid) 3547 { 3548 bool ret = false; 3549 3550 if (!batadv_tt_global_add(bat_priv, orig_node, addr, vid, 3551 BATADV_TT_CLIENT_TEMP, 3552 atomic_read(&orig_node->last_ttvn))) 3553 goto out; 3554 3555 batadv_dbg(BATADV_DBG_TT, bat_priv, 3556 "Added temporary global client (addr: %pM, vid: %d, orig: %pM)\n", 3557 addr, BATADV_PRINT_VID(vid), orig_node->orig); 3558 ret = true; 3559 out: 3560 return ret; 3561 } 3562 3563 /** 3564 * batadv_tt_local_resize_to_mtu - resize the local translation table fit the 3565 * maximum packet size that can be transported through the mesh 3566 * @soft_iface: netdev struct of the mesh interface 3567 * 3568 * Remove entries older than 'timeout' and half timeout if more entries need 3569 * to be removed. 3570 */ 3571 void batadv_tt_local_resize_to_mtu(struct net_device *soft_iface) 3572 { 3573 struct batadv_priv *bat_priv = netdev_priv(soft_iface); 3574 int packet_size_max = atomic_read(&bat_priv->packet_size_max); 3575 int table_size, timeout = BATADV_TT_LOCAL_TIMEOUT / 2; 3576 bool reduced = false; 3577 3578 spin_lock_bh(&bat_priv->tt.commit_lock); 3579 3580 while (true) { 3581 table_size = batadv_tt_local_table_transmit_size(bat_priv); 3582 if (packet_size_max >= table_size) 3583 break; 3584 3585 batadv_tt_local_purge(bat_priv, timeout); 3586 batadv_tt_local_purge_pending_clients(bat_priv); 3587 3588 timeout /= 2; 3589 reduced = true; 3590 net_ratelimited_function(batadv_info, soft_iface, 3591 "Forced to purge local tt entries to fit new maximum fragment MTU (%i)\n", 3592 packet_size_max); 3593 } 3594 3595 /* commit these changes immediately, to avoid synchronization problem 3596 * with the TTVN 3597 */ 3598 if (reduced) 3599 batadv_tt_local_commit_changes_nolock(bat_priv); 3600 3601 spin_unlock_bh(&bat_priv->tt.commit_lock); 3602 } 3603 3604 /** 3605 * batadv_tt_tvlv_ogm_handler_v1 - process incoming tt tvlv container 3606 * @bat_priv: the bat priv with all the soft interface information 3607 * @orig: the orig_node of the ogm 3608 * @flags: flags indicating the tvlv state (see batadv_tvlv_handler_flags) 3609 * @tvlv_value: tvlv buffer containing the gateway data 3610 * @tvlv_value_len: tvlv buffer length 3611 */ 3612 static void batadv_tt_tvlv_ogm_handler_v1(struct batadv_priv *bat_priv, 3613 struct batadv_orig_node *orig, 3614 u8 flags, void *tvlv_value, 3615 u16 tvlv_value_len) 3616 { 3617 struct batadv_tvlv_tt_vlan_data *tt_vlan; 3618 struct batadv_tvlv_tt_change *tt_change; 3619 struct batadv_tvlv_tt_data *tt_data; 3620 u16 num_entries, num_vlan; 3621 3622 if (tvlv_value_len < sizeof(*tt_data)) 3623 return; 3624 3625 tt_data = (struct batadv_tvlv_tt_data *)tvlv_value; 3626 tvlv_value_len -= sizeof(*tt_data); 3627 3628 num_vlan = ntohs(tt_data->num_vlan); 3629 3630 if (tvlv_value_len < sizeof(*tt_vlan) * num_vlan) 3631 return; 3632 3633 tt_vlan = (struct batadv_tvlv_tt_vlan_data *)(tt_data + 1); 3634 tt_change = (struct batadv_tvlv_tt_change *)(tt_vlan + num_vlan); 3635 tvlv_value_len -= sizeof(*tt_vlan) * num_vlan; 3636 3637 num_entries = batadv_tt_entries(tvlv_value_len); 3638 3639 batadv_tt_update_orig(bat_priv, orig, tt_vlan, num_vlan, tt_change, 3640 num_entries, tt_data->ttvn); 3641 } 3642 3643 /** 3644 * batadv_tt_tvlv_unicast_handler_v1 - process incoming (unicast) tt tvlv 3645 * container 3646 * @bat_priv: the bat priv with all the soft interface information 3647 * @src: mac address of tt tvlv sender 3648 * @dst: mac address of tt tvlv recipient 3649 * @tvlv_value: tvlv buffer containing the tt data 3650 * @tvlv_value_len: tvlv buffer length 3651 * 3652 * Return: NET_RX_DROP if the tt tvlv is to be re-routed, NET_RX_SUCCESS 3653 * otherwise. 3654 */ 3655 static int batadv_tt_tvlv_unicast_handler_v1(struct batadv_priv *bat_priv, 3656 u8 *src, u8 *dst, 3657 void *tvlv_value, 3658 u16 tvlv_value_len) 3659 { 3660 struct batadv_tvlv_tt_data *tt_data; 3661 u16 tt_vlan_len, tt_num_entries; 3662 char tt_flag; 3663 bool ret; 3664 3665 if (tvlv_value_len < sizeof(*tt_data)) 3666 return NET_RX_SUCCESS; 3667 3668 tt_data = (struct batadv_tvlv_tt_data *)tvlv_value; 3669 tvlv_value_len -= sizeof(*tt_data); 3670 3671 tt_vlan_len = sizeof(struct batadv_tvlv_tt_vlan_data); 3672 tt_vlan_len *= ntohs(tt_data->num_vlan); 3673 3674 if (tvlv_value_len < tt_vlan_len) 3675 return NET_RX_SUCCESS; 3676 3677 tvlv_value_len -= tt_vlan_len; 3678 tt_num_entries = batadv_tt_entries(tvlv_value_len); 3679 3680 switch (tt_data->flags & BATADV_TT_DATA_TYPE_MASK) { 3681 case BATADV_TT_REQUEST: 3682 batadv_inc_counter(bat_priv, BATADV_CNT_TT_REQUEST_RX); 3683 3684 /* If this node cannot provide a TT response the tt_request is 3685 * forwarded 3686 */ 3687 ret = batadv_send_tt_response(bat_priv, tt_data, src, dst); 3688 if (!ret) { 3689 if (tt_data->flags & BATADV_TT_FULL_TABLE) 3690 tt_flag = 'F'; 3691 else 3692 tt_flag = '.'; 3693 3694 batadv_dbg(BATADV_DBG_TT, bat_priv, 3695 "Routing TT_REQUEST to %pM [%c]\n", 3696 dst, tt_flag); 3697 /* tvlv API will re-route the packet */ 3698 return NET_RX_DROP; 3699 } 3700 break; 3701 case BATADV_TT_RESPONSE: 3702 batadv_inc_counter(bat_priv, BATADV_CNT_TT_RESPONSE_RX); 3703 3704 if (batadv_is_my_mac(bat_priv, dst)) { 3705 batadv_handle_tt_response(bat_priv, tt_data, 3706 src, tt_num_entries); 3707 return NET_RX_SUCCESS; 3708 } 3709 3710 if (tt_data->flags & BATADV_TT_FULL_TABLE) 3711 tt_flag = 'F'; 3712 else 3713 tt_flag = '.'; 3714 3715 batadv_dbg(BATADV_DBG_TT, bat_priv, 3716 "Routing TT_RESPONSE to %pM [%c]\n", dst, tt_flag); 3717 3718 /* tvlv API will re-route the packet */ 3719 return NET_RX_DROP; 3720 } 3721 3722 return NET_RX_SUCCESS; 3723 } 3724 3725 /** 3726 * batadv_roam_tvlv_unicast_handler_v1 - process incoming tt roam tvlv container 3727 * @bat_priv: the bat priv with all the soft interface information 3728 * @src: mac address of tt tvlv sender 3729 * @dst: mac address of tt tvlv recipient 3730 * @tvlv_value: tvlv buffer containing the tt data 3731 * @tvlv_value_len: tvlv buffer length 3732 * 3733 * Return: NET_RX_DROP if the tt roam tvlv is to be re-routed, NET_RX_SUCCESS 3734 * otherwise. 3735 */ 3736 static int batadv_roam_tvlv_unicast_handler_v1(struct batadv_priv *bat_priv, 3737 u8 *src, u8 *dst, 3738 void *tvlv_value, 3739 u16 tvlv_value_len) 3740 { 3741 struct batadv_tvlv_roam_adv *roaming_adv; 3742 struct batadv_orig_node *orig_node = NULL; 3743 3744 /* If this node is not the intended recipient of the 3745 * roaming advertisement the packet is forwarded 3746 * (the tvlv API will re-route the packet). 3747 */ 3748 if (!batadv_is_my_mac(bat_priv, dst)) 3749 return NET_RX_DROP; 3750 3751 if (tvlv_value_len < sizeof(*roaming_adv)) 3752 goto out; 3753 3754 orig_node = batadv_orig_hash_find(bat_priv, src); 3755 if (!orig_node) 3756 goto out; 3757 3758 batadv_inc_counter(bat_priv, BATADV_CNT_TT_ROAM_ADV_RX); 3759 roaming_adv = (struct batadv_tvlv_roam_adv *)tvlv_value; 3760 3761 batadv_dbg(BATADV_DBG_TT, bat_priv, 3762 "Received ROAMING_ADV from %pM (client %pM)\n", 3763 src, roaming_adv->client); 3764 3765 batadv_tt_global_add(bat_priv, orig_node, roaming_adv->client, 3766 ntohs(roaming_adv->vid), BATADV_TT_CLIENT_ROAM, 3767 atomic_read(&orig_node->last_ttvn) + 1); 3768 3769 out: 3770 if (orig_node) 3771 batadv_orig_node_put(orig_node); 3772 return NET_RX_SUCCESS; 3773 } 3774 3775 /** 3776 * batadv_tt_init - initialise the translation table internals 3777 * @bat_priv: the bat priv with all the soft interface information 3778 * 3779 * Return: 0 on success or negative error number in case of failure. 3780 */ 3781 int batadv_tt_init(struct batadv_priv *bat_priv) 3782 { 3783 int ret; 3784 3785 /* synchronized flags must be remote */ 3786 BUILD_BUG_ON(!(BATADV_TT_SYNC_MASK & BATADV_TT_REMOTE_MASK)); 3787 3788 ret = batadv_tt_local_init(bat_priv); 3789 if (ret < 0) 3790 return ret; 3791 3792 ret = batadv_tt_global_init(bat_priv); 3793 if (ret < 0) 3794 return ret; 3795 3796 batadv_tvlv_handler_register(bat_priv, batadv_tt_tvlv_ogm_handler_v1, 3797 batadv_tt_tvlv_unicast_handler_v1, 3798 BATADV_TVLV_TT, 1, BATADV_NO_FLAGS); 3799 3800 batadv_tvlv_handler_register(bat_priv, NULL, 3801 batadv_roam_tvlv_unicast_handler_v1, 3802 BATADV_TVLV_ROAM, 1, BATADV_NO_FLAGS); 3803 3804 INIT_DELAYED_WORK(&bat_priv->tt.work, batadv_tt_purge); 3805 queue_delayed_work(batadv_event_workqueue, &bat_priv->tt.work, 3806 msecs_to_jiffies(BATADV_TT_WORK_PERIOD)); 3807 3808 return 1; 3809 } 3810 3811 /** 3812 * batadv_tt_global_is_isolated - check if a client is marked as isolated 3813 * @bat_priv: the bat priv with all the soft interface information 3814 * @addr: the mac address of the client 3815 * @vid: the identifier of the VLAN where this client is connected 3816 * 3817 * Return: true if the client is marked with the TT_CLIENT_ISOLA flag, false 3818 * otherwise 3819 */ 3820 bool batadv_tt_global_is_isolated(struct batadv_priv *bat_priv, 3821 const u8 *addr, unsigned short vid) 3822 { 3823 struct batadv_tt_global_entry *tt; 3824 bool ret; 3825 3826 tt = batadv_tt_global_hash_find(bat_priv, addr, vid); 3827 if (!tt) 3828 return false; 3829 3830 ret = tt->common.flags & BATADV_TT_CLIENT_ISOLA; 3831 3832 batadv_tt_global_entry_put(tt); 3833 3834 return ret; 3835 } 3836