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