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