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