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