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