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