1 /* 2 * Copyright (c) 2008, 2009 open80211s Ltd. 3 * Authors: Luis Carlos Cobo <luisca@cozybit.com> 4 * Javier Cardona <javier@cozybit.com> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License version 2 as 8 * published by the Free Software Foundation. 9 */ 10 11 #include <linux/slab.h> 12 #include <asm/unaligned.h> 13 #include "ieee80211_i.h" 14 #include "mesh.h" 15 16 static int mesh_allocated; 17 static struct kmem_cache *rm_cache; 18 19 bool mesh_action_is_path_sel(struct ieee80211_mgmt *mgmt) 20 { 21 return (mgmt->u.action.u.mesh_action.action_code == 22 WLAN_MESH_ACTION_HWMP_PATH_SELECTION); 23 } 24 25 void ieee80211s_init(void) 26 { 27 mesh_pathtbl_init(); 28 mesh_allocated = 1; 29 rm_cache = kmem_cache_create("mesh_rmc", sizeof(struct rmc_entry), 30 0, 0, NULL); 31 } 32 33 void ieee80211s_stop(void) 34 { 35 if (!mesh_allocated) 36 return; 37 mesh_pathtbl_unregister(); 38 kmem_cache_destroy(rm_cache); 39 } 40 41 static void ieee80211_mesh_housekeeping_timer(unsigned long data) 42 { 43 struct ieee80211_sub_if_data *sdata = (void *) data; 44 struct ieee80211_local *local = sdata->local; 45 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 46 47 set_bit(MESH_WORK_HOUSEKEEPING, &ifmsh->wrkq_flags); 48 49 ieee80211_queue_work(&local->hw, &sdata->work); 50 } 51 52 /** 53 * mesh_matches_local - check if the config of a mesh point matches ours 54 * 55 * @sdata: local mesh subif 56 * @ie: information elements of a management frame from the mesh peer 57 * 58 * This function checks if the mesh configuration of a mesh point matches the 59 * local mesh configuration, i.e. if both nodes belong to the same mesh network. 60 */ 61 bool mesh_matches_local(struct ieee80211_sub_if_data *sdata, 62 struct ieee802_11_elems *ie) 63 { 64 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 65 u32 basic_rates = 0; 66 struct cfg80211_chan_def sta_chan_def; 67 68 /* 69 * As support for each feature is added, check for matching 70 * - On mesh config capabilities 71 * - Power Save Support En 72 * - Sync support enabled 73 * - Sync support active 74 * - Sync support required from peer 75 * - MDA enabled 76 * - Power management control on fc 77 */ 78 if (!(ifmsh->mesh_id_len == ie->mesh_id_len && 79 memcmp(ifmsh->mesh_id, ie->mesh_id, ie->mesh_id_len) == 0 && 80 (ifmsh->mesh_pp_id == ie->mesh_config->meshconf_psel) && 81 (ifmsh->mesh_pm_id == ie->mesh_config->meshconf_pmetric) && 82 (ifmsh->mesh_cc_id == ie->mesh_config->meshconf_congest) && 83 (ifmsh->mesh_sp_id == ie->mesh_config->meshconf_synch) && 84 (ifmsh->mesh_auth_id == ie->mesh_config->meshconf_auth))) 85 return false; 86 87 ieee80211_sta_get_rates(sdata, ie, ieee80211_get_sdata_band(sdata), 88 &basic_rates); 89 90 if (sdata->vif.bss_conf.basic_rates != basic_rates) 91 return false; 92 93 ieee80211_ht_oper_to_chandef(sdata->vif.bss_conf.chandef.chan, 94 ie->ht_operation, &sta_chan_def); 95 96 if (!cfg80211_chandef_compatible(&sdata->vif.bss_conf.chandef, 97 &sta_chan_def)) 98 return false; 99 100 return true; 101 } 102 103 /** 104 * mesh_peer_accepts_plinks - check if an mp is willing to establish peer links 105 * 106 * @ie: information elements of a management frame from the mesh peer 107 */ 108 bool mesh_peer_accepts_plinks(struct ieee802_11_elems *ie) 109 { 110 return (ie->mesh_config->meshconf_cap & 111 IEEE80211_MESHCONF_CAPAB_ACCEPT_PLINKS) != 0; 112 } 113 114 /** 115 * mesh_accept_plinks_update - update accepting_plink in local mesh beacons 116 * 117 * @sdata: mesh interface in which mesh beacons are going to be updated 118 * 119 * Returns: beacon changed flag if the beacon content changed. 120 */ 121 u32 mesh_accept_plinks_update(struct ieee80211_sub_if_data *sdata) 122 { 123 bool free_plinks; 124 u32 changed = 0; 125 126 /* In case mesh_plink_free_count > 0 and mesh_plinktbl_capacity == 0, 127 * the mesh interface might be able to establish plinks with peers that 128 * are already on the table but are not on PLINK_ESTAB state. However, 129 * in general the mesh interface is not accepting peer link requests 130 * from new peers, and that must be reflected in the beacon 131 */ 132 free_plinks = mesh_plink_availables(sdata); 133 134 if (free_plinks != sdata->u.mesh.accepting_plinks) { 135 sdata->u.mesh.accepting_plinks = free_plinks; 136 changed = BSS_CHANGED_BEACON; 137 } 138 139 return changed; 140 } 141 142 /* 143 * mesh_sta_cleanup - clean up any mesh sta state 144 * 145 * @sta: mesh sta to clean up. 146 */ 147 void mesh_sta_cleanup(struct sta_info *sta) 148 { 149 struct ieee80211_sub_if_data *sdata = sta->sdata; 150 u32 changed; 151 152 /* 153 * maybe userspace handles peer allocation and peering, but in either 154 * case the beacon is still generated by the kernel and we might need 155 * an update. 156 */ 157 changed = mesh_accept_plinks_update(sdata); 158 if (!sdata->u.mesh.user_mpm) { 159 changed |= mesh_plink_deactivate(sta); 160 del_timer_sync(&sta->plink_timer); 161 } 162 163 if (changed) 164 ieee80211_mbss_info_change_notify(sdata, changed); 165 } 166 167 int mesh_rmc_init(struct ieee80211_sub_if_data *sdata) 168 { 169 int i; 170 171 sdata->u.mesh.rmc = kmalloc(sizeof(struct mesh_rmc), GFP_KERNEL); 172 if (!sdata->u.mesh.rmc) 173 return -ENOMEM; 174 sdata->u.mesh.rmc->idx_mask = RMC_BUCKETS - 1; 175 for (i = 0; i < RMC_BUCKETS; i++) 176 INIT_LIST_HEAD(&sdata->u.mesh.rmc->bucket[i]); 177 return 0; 178 } 179 180 void mesh_rmc_free(struct ieee80211_sub_if_data *sdata) 181 { 182 struct mesh_rmc *rmc = sdata->u.mesh.rmc; 183 struct rmc_entry *p, *n; 184 int i; 185 186 if (!sdata->u.mesh.rmc) 187 return; 188 189 for (i = 0; i < RMC_BUCKETS; i++) { 190 list_for_each_entry_safe(p, n, &rmc->bucket[i], list) { 191 list_del(&p->list); 192 kmem_cache_free(rm_cache, p); 193 } 194 } 195 196 kfree(rmc); 197 sdata->u.mesh.rmc = NULL; 198 } 199 200 /** 201 * mesh_rmc_check - Check frame in recent multicast cache and add if absent. 202 * 203 * @sdata: interface 204 * @sa: source address 205 * @mesh_hdr: mesh_header 206 * 207 * Returns: 0 if the frame is not in the cache, nonzero otherwise. 208 * 209 * Checks using the source address and the mesh sequence number if we have 210 * received this frame lately. If the frame is not in the cache, it is added to 211 * it. 212 */ 213 int mesh_rmc_check(struct ieee80211_sub_if_data *sdata, 214 const u8 *sa, struct ieee80211s_hdr *mesh_hdr) 215 { 216 struct mesh_rmc *rmc = sdata->u.mesh.rmc; 217 u32 seqnum = 0; 218 int entries = 0; 219 u8 idx; 220 struct rmc_entry *p, *n; 221 222 /* Don't care about endianness since only match matters */ 223 memcpy(&seqnum, &mesh_hdr->seqnum, sizeof(mesh_hdr->seqnum)); 224 idx = le32_to_cpu(mesh_hdr->seqnum) & rmc->idx_mask; 225 list_for_each_entry_safe(p, n, &rmc->bucket[idx], list) { 226 ++entries; 227 if (time_after(jiffies, p->exp_time) || 228 entries == RMC_QUEUE_MAX_LEN) { 229 list_del(&p->list); 230 kmem_cache_free(rm_cache, p); 231 --entries; 232 } else if ((seqnum == p->seqnum) && ether_addr_equal(sa, p->sa)) 233 return -1; 234 } 235 236 p = kmem_cache_alloc(rm_cache, GFP_ATOMIC); 237 if (!p) 238 return 0; 239 240 p->seqnum = seqnum; 241 p->exp_time = jiffies + RMC_TIMEOUT; 242 memcpy(p->sa, sa, ETH_ALEN); 243 list_add(&p->list, &rmc->bucket[idx]); 244 return 0; 245 } 246 247 int mesh_add_meshconf_ie(struct ieee80211_sub_if_data *sdata, 248 struct sk_buff *skb) 249 { 250 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 251 u8 *pos, neighbors; 252 u8 meshconf_len = sizeof(struct ieee80211_meshconf_ie); 253 254 if (skb_tailroom(skb) < 2 + meshconf_len) 255 return -ENOMEM; 256 257 pos = skb_put(skb, 2 + meshconf_len); 258 *pos++ = WLAN_EID_MESH_CONFIG; 259 *pos++ = meshconf_len; 260 261 /* Active path selection protocol ID */ 262 *pos++ = ifmsh->mesh_pp_id; 263 /* Active path selection metric ID */ 264 *pos++ = ifmsh->mesh_pm_id; 265 /* Congestion control mode identifier */ 266 *pos++ = ifmsh->mesh_cc_id; 267 /* Synchronization protocol identifier */ 268 *pos++ = ifmsh->mesh_sp_id; 269 /* Authentication Protocol identifier */ 270 *pos++ = ifmsh->mesh_auth_id; 271 /* Mesh Formation Info - number of neighbors */ 272 neighbors = atomic_read(&ifmsh->estab_plinks); 273 neighbors = min_t(int, neighbors, IEEE80211_MAX_MESH_PEERINGS); 274 *pos++ = neighbors << 1; 275 /* Mesh capability */ 276 *pos = 0x00; 277 *pos |= ifmsh->mshcfg.dot11MeshForwarding ? 278 IEEE80211_MESHCONF_CAPAB_FORWARDING : 0x00; 279 *pos |= ifmsh->accepting_plinks ? 280 IEEE80211_MESHCONF_CAPAB_ACCEPT_PLINKS : 0x00; 281 /* Mesh PS mode. See IEEE802.11-2012 8.4.2.100.8 */ 282 *pos |= ifmsh->ps_peers_deep_sleep ? 283 IEEE80211_MESHCONF_CAPAB_POWER_SAVE_LEVEL : 0x00; 284 *pos++ |= ifmsh->adjusting_tbtt ? 285 IEEE80211_MESHCONF_CAPAB_TBTT_ADJUSTING : 0x00; 286 *pos++ = 0x00; 287 288 return 0; 289 } 290 291 int mesh_add_meshid_ie(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb) 292 { 293 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 294 u8 *pos; 295 296 if (skb_tailroom(skb) < 2 + ifmsh->mesh_id_len) 297 return -ENOMEM; 298 299 pos = skb_put(skb, 2 + ifmsh->mesh_id_len); 300 *pos++ = WLAN_EID_MESH_ID; 301 *pos++ = ifmsh->mesh_id_len; 302 if (ifmsh->mesh_id_len) 303 memcpy(pos, ifmsh->mesh_id, ifmsh->mesh_id_len); 304 305 return 0; 306 } 307 308 static int mesh_add_awake_window_ie(struct ieee80211_sub_if_data *sdata, 309 struct sk_buff *skb) 310 { 311 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 312 u8 *pos; 313 314 /* see IEEE802.11-2012 13.14.6 */ 315 if (ifmsh->ps_peers_light_sleep == 0 && 316 ifmsh->ps_peers_deep_sleep == 0 && 317 ifmsh->nonpeer_pm == NL80211_MESH_POWER_ACTIVE) 318 return 0; 319 320 if (skb_tailroom(skb) < 4) 321 return -ENOMEM; 322 323 pos = skb_put(skb, 2 + 2); 324 *pos++ = WLAN_EID_MESH_AWAKE_WINDOW; 325 *pos++ = 2; 326 put_unaligned_le16(ifmsh->mshcfg.dot11MeshAwakeWindowDuration, pos); 327 328 return 0; 329 } 330 331 int mesh_add_vendor_ies(struct ieee80211_sub_if_data *sdata, 332 struct sk_buff *skb) 333 { 334 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 335 u8 offset, len; 336 const u8 *data; 337 338 if (!ifmsh->ie || !ifmsh->ie_len) 339 return 0; 340 341 /* fast-forward to vendor IEs */ 342 offset = ieee80211_ie_split_vendor(ifmsh->ie, ifmsh->ie_len, 0); 343 344 if (offset) { 345 len = ifmsh->ie_len - offset; 346 data = ifmsh->ie + offset; 347 if (skb_tailroom(skb) < len) 348 return -ENOMEM; 349 memcpy(skb_put(skb, len), data, len); 350 } 351 352 return 0; 353 } 354 355 int mesh_add_rsn_ie(struct ieee80211_sub_if_data *sdata, struct sk_buff *skb) 356 { 357 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 358 u8 len = 0; 359 const u8 *data; 360 361 if (!ifmsh->ie || !ifmsh->ie_len) 362 return 0; 363 364 /* find RSN IE */ 365 data = ifmsh->ie; 366 while (data < ifmsh->ie + ifmsh->ie_len) { 367 if (*data == WLAN_EID_RSN) { 368 len = data[1] + 2; 369 break; 370 } 371 data++; 372 } 373 374 if (len) { 375 if (skb_tailroom(skb) < len) 376 return -ENOMEM; 377 memcpy(skb_put(skb, len), data, len); 378 } 379 380 return 0; 381 } 382 383 static int mesh_add_ds_params_ie(struct ieee80211_sub_if_data *sdata, 384 struct sk_buff *skb) 385 { 386 struct ieee80211_chanctx_conf *chanctx_conf; 387 struct ieee80211_channel *chan; 388 u8 *pos; 389 390 if (skb_tailroom(skb) < 3) 391 return -ENOMEM; 392 393 rcu_read_lock(); 394 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf); 395 if (WARN_ON(!chanctx_conf)) { 396 rcu_read_unlock(); 397 return -EINVAL; 398 } 399 chan = chanctx_conf->def.chan; 400 rcu_read_unlock(); 401 402 pos = skb_put(skb, 2 + 1); 403 *pos++ = WLAN_EID_DS_PARAMS; 404 *pos++ = 1; 405 *pos++ = ieee80211_frequency_to_channel(chan->center_freq); 406 407 return 0; 408 } 409 410 int mesh_add_ht_cap_ie(struct ieee80211_sub_if_data *sdata, 411 struct sk_buff *skb) 412 { 413 struct ieee80211_local *local = sdata->local; 414 enum ieee80211_band band = ieee80211_get_sdata_band(sdata); 415 struct ieee80211_supported_band *sband; 416 u8 *pos; 417 418 sband = local->hw.wiphy->bands[band]; 419 if (!sband->ht_cap.ht_supported || 420 sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_20_NOHT || 421 sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_5 || 422 sdata->vif.bss_conf.chandef.width == NL80211_CHAN_WIDTH_10) 423 return 0; 424 425 if (skb_tailroom(skb) < 2 + sizeof(struct ieee80211_ht_cap)) 426 return -ENOMEM; 427 428 pos = skb_put(skb, 2 + sizeof(struct ieee80211_ht_cap)); 429 ieee80211_ie_build_ht_cap(pos, &sband->ht_cap, sband->ht_cap.cap); 430 431 return 0; 432 } 433 434 int mesh_add_ht_oper_ie(struct ieee80211_sub_if_data *sdata, 435 struct sk_buff *skb) 436 { 437 struct ieee80211_local *local = sdata->local; 438 struct ieee80211_chanctx_conf *chanctx_conf; 439 struct ieee80211_channel *channel; 440 enum nl80211_channel_type channel_type = 441 cfg80211_get_chandef_type(&sdata->vif.bss_conf.chandef); 442 struct ieee80211_supported_band *sband; 443 struct ieee80211_sta_ht_cap *ht_cap; 444 u8 *pos; 445 446 rcu_read_lock(); 447 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf); 448 if (WARN_ON(!chanctx_conf)) { 449 rcu_read_unlock(); 450 return -EINVAL; 451 } 452 channel = chanctx_conf->def.chan; 453 rcu_read_unlock(); 454 455 sband = local->hw.wiphy->bands[channel->band]; 456 ht_cap = &sband->ht_cap; 457 458 if (!ht_cap->ht_supported || channel_type == NL80211_CHAN_NO_HT) 459 return 0; 460 461 if (skb_tailroom(skb) < 2 + sizeof(struct ieee80211_ht_operation)) 462 return -ENOMEM; 463 464 pos = skb_put(skb, 2 + sizeof(struct ieee80211_ht_operation)); 465 ieee80211_ie_build_ht_oper(pos, ht_cap, &sdata->vif.bss_conf.chandef, 466 sdata->vif.bss_conf.ht_operation_mode); 467 468 return 0; 469 } 470 471 static void ieee80211_mesh_path_timer(unsigned long data) 472 { 473 struct ieee80211_sub_if_data *sdata = 474 (struct ieee80211_sub_if_data *) data; 475 476 ieee80211_queue_work(&sdata->local->hw, &sdata->work); 477 } 478 479 static void ieee80211_mesh_path_root_timer(unsigned long data) 480 { 481 struct ieee80211_sub_if_data *sdata = 482 (struct ieee80211_sub_if_data *) data; 483 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 484 485 set_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags); 486 487 ieee80211_queue_work(&sdata->local->hw, &sdata->work); 488 } 489 490 void ieee80211_mesh_root_setup(struct ieee80211_if_mesh *ifmsh) 491 { 492 if (ifmsh->mshcfg.dot11MeshHWMPRootMode > IEEE80211_ROOTMODE_ROOT) 493 set_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags); 494 else { 495 clear_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags); 496 /* stop running timer */ 497 del_timer_sync(&ifmsh->mesh_path_root_timer); 498 } 499 } 500 501 /** 502 * ieee80211_fill_mesh_addresses - fill addresses of a locally originated mesh frame 503 * @hdr: 802.11 frame header 504 * @fc: frame control field 505 * @meshda: destination address in the mesh 506 * @meshsa: source address address in the mesh. Same as TA, as frame is 507 * locally originated. 508 * 509 * Return the length of the 802.11 (does not include a mesh control header) 510 */ 511 int ieee80211_fill_mesh_addresses(struct ieee80211_hdr *hdr, __le16 *fc, 512 const u8 *meshda, const u8 *meshsa) 513 { 514 if (is_multicast_ether_addr(meshda)) { 515 *fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS); 516 /* DA TA SA */ 517 memcpy(hdr->addr1, meshda, ETH_ALEN); 518 memcpy(hdr->addr2, meshsa, ETH_ALEN); 519 memcpy(hdr->addr3, meshsa, ETH_ALEN); 520 return 24; 521 } else { 522 *fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS); 523 /* RA TA DA SA */ 524 memset(hdr->addr1, 0, ETH_ALEN); /* RA is resolved later */ 525 memcpy(hdr->addr2, meshsa, ETH_ALEN); 526 memcpy(hdr->addr3, meshda, ETH_ALEN); 527 memcpy(hdr->addr4, meshsa, ETH_ALEN); 528 return 30; 529 } 530 } 531 532 /** 533 * ieee80211_new_mesh_header - create a new mesh header 534 * @sdata: mesh interface to be used 535 * @meshhdr: uninitialized mesh header 536 * @addr4or5: 1st address in the ae header, which may correspond to address 4 537 * (if addr6 is NULL) or address 5 (if addr6 is present). It may 538 * be NULL. 539 * @addr6: 2nd address in the ae header, which corresponds to addr6 of the 540 * mesh frame 541 * 542 * Return the header length. 543 */ 544 int ieee80211_new_mesh_header(struct ieee80211_sub_if_data *sdata, 545 struct ieee80211s_hdr *meshhdr, 546 const char *addr4or5, const char *addr6) 547 { 548 if (WARN_ON(!addr4or5 && addr6)) 549 return 0; 550 551 memset(meshhdr, 0, sizeof(*meshhdr)); 552 553 meshhdr->ttl = sdata->u.mesh.mshcfg.dot11MeshTTL; 554 555 /* FIXME: racy -- TX on multiple queues can be concurrent */ 556 put_unaligned(cpu_to_le32(sdata->u.mesh.mesh_seqnum), &meshhdr->seqnum); 557 sdata->u.mesh.mesh_seqnum++; 558 559 if (addr4or5 && !addr6) { 560 meshhdr->flags |= MESH_FLAGS_AE_A4; 561 memcpy(meshhdr->eaddr1, addr4or5, ETH_ALEN); 562 return 2 * ETH_ALEN; 563 } else if (addr4or5 && addr6) { 564 meshhdr->flags |= MESH_FLAGS_AE_A5_A6; 565 memcpy(meshhdr->eaddr1, addr4or5, ETH_ALEN); 566 memcpy(meshhdr->eaddr2, addr6, ETH_ALEN); 567 return 3 * ETH_ALEN; 568 } 569 570 return ETH_ALEN; 571 } 572 573 static void ieee80211_mesh_housekeeping(struct ieee80211_sub_if_data *sdata) 574 { 575 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 576 u32 changed; 577 578 ieee80211_sta_expire(sdata, ifmsh->mshcfg.plink_timeout * HZ); 579 mesh_path_expire(sdata); 580 581 changed = mesh_accept_plinks_update(sdata); 582 ieee80211_mbss_info_change_notify(sdata, changed); 583 584 mod_timer(&ifmsh->housekeeping_timer, 585 round_jiffies(jiffies + 586 IEEE80211_MESH_HOUSEKEEPING_INTERVAL)); 587 } 588 589 static void ieee80211_mesh_rootpath(struct ieee80211_sub_if_data *sdata) 590 { 591 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 592 u32 interval; 593 594 mesh_path_tx_root_frame(sdata); 595 596 if (ifmsh->mshcfg.dot11MeshHWMPRootMode == IEEE80211_PROACTIVE_RANN) 597 interval = ifmsh->mshcfg.dot11MeshHWMPRannInterval; 598 else 599 interval = ifmsh->mshcfg.dot11MeshHWMProotInterval; 600 601 mod_timer(&ifmsh->mesh_path_root_timer, 602 round_jiffies(TU_TO_EXP_TIME(interval))); 603 } 604 605 static int 606 ieee80211_mesh_build_beacon(struct ieee80211_if_mesh *ifmsh) 607 { 608 struct beacon_data *bcn; 609 int head_len, tail_len; 610 struct sk_buff *skb; 611 struct ieee80211_mgmt *mgmt; 612 struct ieee80211_chanctx_conf *chanctx_conf; 613 enum ieee80211_band band; 614 u8 *pos; 615 struct ieee80211_sub_if_data *sdata; 616 int hdr_len = offsetof(struct ieee80211_mgmt, u.beacon) + 617 sizeof(mgmt->u.beacon); 618 619 sdata = container_of(ifmsh, struct ieee80211_sub_if_data, u.mesh); 620 rcu_read_lock(); 621 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf); 622 band = chanctx_conf->def.chan->band; 623 rcu_read_unlock(); 624 625 head_len = hdr_len + 626 2 + /* NULL SSID */ 627 2 + 8 + /* supported rates */ 628 2 + 3; /* DS params */ 629 tail_len = 2 + (IEEE80211_MAX_SUPP_RATES - 8) + 630 2 + sizeof(struct ieee80211_ht_cap) + 631 2 + sizeof(struct ieee80211_ht_operation) + 632 2 + ifmsh->mesh_id_len + 633 2 + sizeof(struct ieee80211_meshconf_ie) + 634 2 + sizeof(__le16) + /* awake window */ 635 ifmsh->ie_len; 636 637 bcn = kzalloc(sizeof(*bcn) + head_len + tail_len, GFP_KERNEL); 638 /* need an skb for IE builders to operate on */ 639 skb = dev_alloc_skb(max(head_len, tail_len)); 640 641 if (!bcn || !skb) 642 goto out_free; 643 644 /* 645 * pointers go into the block we allocated, 646 * memory is | beacon_data | head | tail | 647 */ 648 bcn->head = ((u8 *) bcn) + sizeof(*bcn); 649 650 /* fill in the head */ 651 mgmt = (struct ieee80211_mgmt *) skb_put(skb, hdr_len); 652 memset(mgmt, 0, hdr_len); 653 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 654 IEEE80211_STYPE_BEACON); 655 eth_broadcast_addr(mgmt->da); 656 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN); 657 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN); 658 ieee80211_mps_set_frame_flags(sdata, NULL, (void *) mgmt); 659 mgmt->u.beacon.beacon_int = 660 cpu_to_le16(sdata->vif.bss_conf.beacon_int); 661 mgmt->u.beacon.capab_info |= cpu_to_le16( 662 sdata->u.mesh.security ? WLAN_CAPABILITY_PRIVACY : 0); 663 664 pos = skb_put(skb, 2); 665 *pos++ = WLAN_EID_SSID; 666 *pos++ = 0x0; 667 668 if (ieee80211_add_srates_ie(sdata, skb, true, band) || 669 mesh_add_ds_params_ie(sdata, skb)) 670 goto out_free; 671 672 bcn->head_len = skb->len; 673 memcpy(bcn->head, skb->data, bcn->head_len); 674 675 /* now the tail */ 676 skb_trim(skb, 0); 677 bcn->tail = bcn->head + bcn->head_len; 678 679 if (ieee80211_add_ext_srates_ie(sdata, skb, true, band) || 680 mesh_add_rsn_ie(sdata, skb) || 681 mesh_add_ht_cap_ie(sdata, skb) || 682 mesh_add_ht_oper_ie(sdata, skb) || 683 mesh_add_meshid_ie(sdata, skb) || 684 mesh_add_meshconf_ie(sdata, skb) || 685 mesh_add_awake_window_ie(sdata, skb) || 686 mesh_add_vendor_ies(sdata, skb)) 687 goto out_free; 688 689 bcn->tail_len = skb->len; 690 memcpy(bcn->tail, skb->data, bcn->tail_len); 691 692 dev_kfree_skb(skb); 693 rcu_assign_pointer(ifmsh->beacon, bcn); 694 return 0; 695 out_free: 696 kfree(bcn); 697 dev_kfree_skb(skb); 698 return -ENOMEM; 699 } 700 701 static int 702 ieee80211_mesh_rebuild_beacon(struct ieee80211_sub_if_data *sdata) 703 { 704 struct beacon_data *old_bcn; 705 int ret; 706 707 old_bcn = rcu_dereference_protected(sdata->u.mesh.beacon, 708 lockdep_is_held(&sdata->wdev.mtx)); 709 ret = ieee80211_mesh_build_beacon(&sdata->u.mesh); 710 if (ret) 711 /* just reuse old beacon */ 712 return ret; 713 714 if (old_bcn) 715 kfree_rcu(old_bcn, rcu_head); 716 return 0; 717 } 718 719 void ieee80211_mbss_info_change_notify(struct ieee80211_sub_if_data *sdata, 720 u32 changed) 721 { 722 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 723 unsigned long bits = changed; 724 u32 bit; 725 726 if (!bits) 727 return; 728 729 /* if we race with running work, worst case this work becomes a noop */ 730 for_each_set_bit(bit, &bits, sizeof(changed) * BITS_PER_BYTE) 731 set_bit(bit, &ifmsh->mbss_changed); 732 set_bit(MESH_WORK_MBSS_CHANGED, &ifmsh->wrkq_flags); 733 ieee80211_queue_work(&sdata->local->hw, &sdata->work); 734 } 735 736 int ieee80211_start_mesh(struct ieee80211_sub_if_data *sdata) 737 { 738 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 739 struct ieee80211_local *local = sdata->local; 740 u32 changed = BSS_CHANGED_BEACON | 741 BSS_CHANGED_BEACON_ENABLED | 742 BSS_CHANGED_HT | 743 BSS_CHANGED_BASIC_RATES | 744 BSS_CHANGED_BEACON_INT; 745 746 local->fif_other_bss++; 747 /* mesh ifaces must set allmulti to forward mcast traffic */ 748 atomic_inc(&local->iff_allmultis); 749 ieee80211_configure_filter(local); 750 751 ifmsh->mesh_cc_id = 0; /* Disabled */ 752 /* register sync ops from extensible synchronization framework */ 753 ifmsh->sync_ops = ieee80211_mesh_sync_ops_get(ifmsh->mesh_sp_id); 754 ifmsh->adjusting_tbtt = false; 755 ifmsh->sync_offset_clockdrift_max = 0; 756 set_bit(MESH_WORK_HOUSEKEEPING, &ifmsh->wrkq_flags); 757 ieee80211_mesh_root_setup(ifmsh); 758 ieee80211_queue_work(&local->hw, &sdata->work); 759 sdata->vif.bss_conf.ht_operation_mode = 760 ifmsh->mshcfg.ht_opmode; 761 sdata->vif.bss_conf.enable_beacon = true; 762 763 changed |= ieee80211_mps_local_status_update(sdata); 764 765 if (ieee80211_mesh_build_beacon(ifmsh)) { 766 ieee80211_stop_mesh(sdata); 767 return -ENOMEM; 768 } 769 770 ieee80211_bss_info_change_notify(sdata, changed); 771 772 netif_carrier_on(sdata->dev); 773 return 0; 774 } 775 776 void ieee80211_stop_mesh(struct ieee80211_sub_if_data *sdata) 777 { 778 struct ieee80211_local *local = sdata->local; 779 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 780 struct beacon_data *bcn; 781 782 netif_carrier_off(sdata->dev); 783 784 /* stop the beacon */ 785 ifmsh->mesh_id_len = 0; 786 sdata->vif.bss_conf.enable_beacon = false; 787 clear_bit(SDATA_STATE_OFFCHANNEL_BEACON_STOPPED, &sdata->state); 788 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED); 789 bcn = rcu_dereference_protected(ifmsh->beacon, 790 lockdep_is_held(&sdata->wdev.mtx)); 791 rcu_assign_pointer(ifmsh->beacon, NULL); 792 kfree_rcu(bcn, rcu_head); 793 794 /* flush STAs and mpaths on this iface */ 795 sta_info_flush(sdata); 796 mesh_path_flush_by_iface(sdata); 797 798 /* free all potentially still buffered group-addressed frames */ 799 local->total_ps_buffered -= skb_queue_len(&ifmsh->ps.bc_buf); 800 skb_queue_purge(&ifmsh->ps.bc_buf); 801 802 del_timer_sync(&sdata->u.mesh.housekeeping_timer); 803 del_timer_sync(&sdata->u.mesh.mesh_path_root_timer); 804 del_timer_sync(&sdata->u.mesh.mesh_path_timer); 805 806 /* clear any mesh work (for next join) we may have accrued */ 807 ifmsh->wrkq_flags = 0; 808 ifmsh->mbss_changed = 0; 809 810 local->fif_other_bss--; 811 atomic_dec(&local->iff_allmultis); 812 ieee80211_configure_filter(local); 813 } 814 815 static void 816 ieee80211_mesh_rx_probe_req(struct ieee80211_sub_if_data *sdata, 817 struct ieee80211_mgmt *mgmt, size_t len) 818 { 819 struct ieee80211_local *local = sdata->local; 820 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 821 struct sk_buff *presp; 822 struct beacon_data *bcn; 823 struct ieee80211_mgmt *hdr; 824 struct ieee802_11_elems elems; 825 size_t baselen; 826 u8 *pos; 827 828 pos = mgmt->u.probe_req.variable; 829 baselen = (u8 *) pos - (u8 *) mgmt; 830 if (baselen > len) 831 return; 832 833 ieee802_11_parse_elems(pos, len - baselen, false, &elems); 834 835 if (!elems.mesh_id) 836 return; 837 838 /* 802.11-2012 10.1.4.3.2 */ 839 if ((!ether_addr_equal(mgmt->da, sdata->vif.addr) && 840 !is_broadcast_ether_addr(mgmt->da)) || 841 elems.ssid_len != 0) 842 return; 843 844 if (elems.mesh_id_len != 0 && 845 (elems.mesh_id_len != ifmsh->mesh_id_len || 846 memcmp(elems.mesh_id, ifmsh->mesh_id, ifmsh->mesh_id_len))) 847 return; 848 849 rcu_read_lock(); 850 bcn = rcu_dereference(ifmsh->beacon); 851 852 if (!bcn) 853 goto out; 854 855 presp = dev_alloc_skb(local->tx_headroom + 856 bcn->head_len + bcn->tail_len); 857 if (!presp) 858 goto out; 859 860 skb_reserve(presp, local->tx_headroom); 861 memcpy(skb_put(presp, bcn->head_len), bcn->head, bcn->head_len); 862 memcpy(skb_put(presp, bcn->tail_len), bcn->tail, bcn->tail_len); 863 hdr = (struct ieee80211_mgmt *) presp->data; 864 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 865 IEEE80211_STYPE_PROBE_RESP); 866 memcpy(hdr->da, mgmt->sa, ETH_ALEN); 867 IEEE80211_SKB_CB(presp)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT; 868 ieee80211_tx_skb(sdata, presp); 869 out: 870 rcu_read_unlock(); 871 } 872 873 static void ieee80211_mesh_rx_bcn_presp(struct ieee80211_sub_if_data *sdata, 874 u16 stype, 875 struct ieee80211_mgmt *mgmt, 876 size_t len, 877 struct ieee80211_rx_status *rx_status) 878 { 879 struct ieee80211_local *local = sdata->local; 880 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 881 struct ieee802_11_elems elems; 882 struct ieee80211_channel *channel; 883 size_t baselen; 884 int freq; 885 enum ieee80211_band band = rx_status->band; 886 887 /* ignore ProbeResp to foreign address */ 888 if (stype == IEEE80211_STYPE_PROBE_RESP && 889 !ether_addr_equal(mgmt->da, sdata->vif.addr)) 890 return; 891 892 baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt; 893 if (baselen > len) 894 return; 895 896 ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen, 897 false, &elems); 898 899 /* ignore non-mesh or secure / unsecure mismatch */ 900 if ((!elems.mesh_id || !elems.mesh_config) || 901 (elems.rsn && sdata->u.mesh.security == IEEE80211_MESH_SEC_NONE) || 902 (!elems.rsn && sdata->u.mesh.security != IEEE80211_MESH_SEC_NONE)) 903 return; 904 905 if (elems.ds_params) 906 freq = ieee80211_channel_to_frequency(elems.ds_params[0], band); 907 else 908 freq = rx_status->freq; 909 910 channel = ieee80211_get_channel(local->hw.wiphy, freq); 911 912 if (!channel || channel->flags & IEEE80211_CHAN_DISABLED) 913 return; 914 915 if (mesh_matches_local(sdata, &elems)) 916 mesh_neighbour_update(sdata, mgmt->sa, &elems); 917 918 if (ifmsh->sync_ops) 919 ifmsh->sync_ops->rx_bcn_presp(sdata, 920 stype, mgmt, &elems, rx_status); 921 } 922 923 static void ieee80211_mesh_rx_mgmt_action(struct ieee80211_sub_if_data *sdata, 924 struct ieee80211_mgmt *mgmt, 925 size_t len, 926 struct ieee80211_rx_status *rx_status) 927 { 928 switch (mgmt->u.action.category) { 929 case WLAN_CATEGORY_SELF_PROTECTED: 930 switch (mgmt->u.action.u.self_prot.action_code) { 931 case WLAN_SP_MESH_PEERING_OPEN: 932 case WLAN_SP_MESH_PEERING_CLOSE: 933 case WLAN_SP_MESH_PEERING_CONFIRM: 934 mesh_rx_plink_frame(sdata, mgmt, len, rx_status); 935 break; 936 } 937 break; 938 case WLAN_CATEGORY_MESH_ACTION: 939 if (mesh_action_is_path_sel(mgmt)) 940 mesh_rx_path_sel_frame(sdata, mgmt, len); 941 break; 942 } 943 } 944 945 void ieee80211_mesh_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata, 946 struct sk_buff *skb) 947 { 948 struct ieee80211_rx_status *rx_status; 949 struct ieee80211_mgmt *mgmt; 950 u16 stype; 951 952 sdata_lock(sdata); 953 954 /* mesh already went down */ 955 if (!sdata->wdev.mesh_id_len) 956 goto out; 957 958 rx_status = IEEE80211_SKB_RXCB(skb); 959 mgmt = (struct ieee80211_mgmt *) skb->data; 960 stype = le16_to_cpu(mgmt->frame_control) & IEEE80211_FCTL_STYPE; 961 962 switch (stype) { 963 case IEEE80211_STYPE_PROBE_RESP: 964 case IEEE80211_STYPE_BEACON: 965 ieee80211_mesh_rx_bcn_presp(sdata, stype, mgmt, skb->len, 966 rx_status); 967 break; 968 case IEEE80211_STYPE_PROBE_REQ: 969 ieee80211_mesh_rx_probe_req(sdata, mgmt, skb->len); 970 break; 971 case IEEE80211_STYPE_ACTION: 972 ieee80211_mesh_rx_mgmt_action(sdata, mgmt, skb->len, rx_status); 973 break; 974 } 975 out: 976 sdata_unlock(sdata); 977 } 978 979 static void mesh_bss_info_changed(struct ieee80211_sub_if_data *sdata) 980 { 981 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 982 u32 bit, changed = 0; 983 984 for_each_set_bit(bit, &ifmsh->mbss_changed, 985 sizeof(changed) * BITS_PER_BYTE) { 986 clear_bit(bit, &ifmsh->mbss_changed); 987 changed |= BIT(bit); 988 } 989 990 if (sdata->vif.bss_conf.enable_beacon && 991 (changed & (BSS_CHANGED_BEACON | 992 BSS_CHANGED_HT | 993 BSS_CHANGED_BASIC_RATES | 994 BSS_CHANGED_BEACON_INT))) 995 if (ieee80211_mesh_rebuild_beacon(sdata)) 996 return; 997 998 ieee80211_bss_info_change_notify(sdata, changed); 999 } 1000 1001 void ieee80211_mesh_work(struct ieee80211_sub_if_data *sdata) 1002 { 1003 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 1004 1005 sdata_lock(sdata); 1006 1007 /* mesh already went down */ 1008 if (!sdata->wdev.mesh_id_len) 1009 goto out; 1010 1011 if (ifmsh->preq_queue_len && 1012 time_after(jiffies, 1013 ifmsh->last_preq + msecs_to_jiffies(ifmsh->mshcfg.dot11MeshHWMPpreqMinInterval))) 1014 mesh_path_start_discovery(sdata); 1015 1016 if (test_and_clear_bit(MESH_WORK_GROW_MPATH_TABLE, &ifmsh->wrkq_flags)) 1017 mesh_mpath_table_grow(); 1018 1019 if (test_and_clear_bit(MESH_WORK_GROW_MPP_TABLE, &ifmsh->wrkq_flags)) 1020 mesh_mpp_table_grow(); 1021 1022 if (test_and_clear_bit(MESH_WORK_HOUSEKEEPING, &ifmsh->wrkq_flags)) 1023 ieee80211_mesh_housekeeping(sdata); 1024 1025 if (test_and_clear_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags)) 1026 ieee80211_mesh_rootpath(sdata); 1027 1028 if (test_and_clear_bit(MESH_WORK_DRIFT_ADJUST, &ifmsh->wrkq_flags)) 1029 mesh_sync_adjust_tbtt(sdata); 1030 1031 if (test_and_clear_bit(MESH_WORK_MBSS_CHANGED, &ifmsh->wrkq_flags)) 1032 mesh_bss_info_changed(sdata); 1033 out: 1034 sdata_unlock(sdata); 1035 } 1036 1037 void ieee80211_mesh_notify_scan_completed(struct ieee80211_local *local) 1038 { 1039 struct ieee80211_sub_if_data *sdata; 1040 1041 rcu_read_lock(); 1042 list_for_each_entry_rcu(sdata, &local->interfaces, list) 1043 if (ieee80211_vif_is_mesh(&sdata->vif) && 1044 ieee80211_sdata_running(sdata)) 1045 ieee80211_queue_work(&local->hw, &sdata->work); 1046 rcu_read_unlock(); 1047 } 1048 1049 void ieee80211_mesh_init_sdata(struct ieee80211_sub_if_data *sdata) 1050 { 1051 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 1052 static u8 zero_addr[ETH_ALEN] = {}; 1053 1054 setup_timer(&ifmsh->housekeeping_timer, 1055 ieee80211_mesh_housekeeping_timer, 1056 (unsigned long) sdata); 1057 1058 ifmsh->accepting_plinks = true; 1059 ifmsh->preq_id = 0; 1060 ifmsh->sn = 0; 1061 ifmsh->num_gates = 0; 1062 atomic_set(&ifmsh->mpaths, 0); 1063 mesh_rmc_init(sdata); 1064 ifmsh->last_preq = jiffies; 1065 ifmsh->next_perr = jiffies; 1066 /* Allocate all mesh structures when creating the first mesh interface. */ 1067 if (!mesh_allocated) 1068 ieee80211s_init(); 1069 setup_timer(&ifmsh->mesh_path_timer, 1070 ieee80211_mesh_path_timer, 1071 (unsigned long) sdata); 1072 setup_timer(&ifmsh->mesh_path_root_timer, 1073 ieee80211_mesh_path_root_timer, 1074 (unsigned long) sdata); 1075 INIT_LIST_HEAD(&ifmsh->preq_queue.list); 1076 skb_queue_head_init(&ifmsh->ps.bc_buf); 1077 spin_lock_init(&ifmsh->mesh_preq_queue_lock); 1078 spin_lock_init(&ifmsh->sync_offset_lock); 1079 RCU_INIT_POINTER(ifmsh->beacon, NULL); 1080 1081 sdata->vif.bss_conf.bssid = zero_addr; 1082 } 1083