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 /* Number of neighbor mesh STAs or 15 whichever is smaller */ 275 neighbors = (neighbors > 15) ? 15 : neighbors; 276 *pos++ = neighbors << 1; 277 /* Mesh capability */ 278 *pos = IEEE80211_MESHCONF_CAPAB_FORWARDING; 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 return 0; 422 423 if (skb_tailroom(skb) < 2 + sizeof(struct ieee80211_ht_cap)) 424 return -ENOMEM; 425 426 pos = skb_put(skb, 2 + sizeof(struct ieee80211_ht_cap)); 427 ieee80211_ie_build_ht_cap(pos, &sband->ht_cap, sband->ht_cap.cap); 428 429 return 0; 430 } 431 432 int mesh_add_ht_oper_ie(struct ieee80211_sub_if_data *sdata, 433 struct sk_buff *skb) 434 { 435 struct ieee80211_local *local = sdata->local; 436 struct ieee80211_chanctx_conf *chanctx_conf; 437 struct ieee80211_channel *channel; 438 enum nl80211_channel_type channel_type = 439 cfg80211_get_chandef_type(&sdata->vif.bss_conf.chandef); 440 struct ieee80211_supported_band *sband; 441 struct ieee80211_sta_ht_cap *ht_cap; 442 u8 *pos; 443 444 rcu_read_lock(); 445 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf); 446 if (WARN_ON(!chanctx_conf)) { 447 rcu_read_unlock(); 448 return -EINVAL; 449 } 450 channel = chanctx_conf->def.chan; 451 rcu_read_unlock(); 452 453 sband = local->hw.wiphy->bands[channel->band]; 454 ht_cap = &sband->ht_cap; 455 456 if (!ht_cap->ht_supported || channel_type == NL80211_CHAN_NO_HT) 457 return 0; 458 459 if (skb_tailroom(skb) < 2 + sizeof(struct ieee80211_ht_operation)) 460 return -ENOMEM; 461 462 pos = skb_put(skb, 2 + sizeof(struct ieee80211_ht_operation)); 463 ieee80211_ie_build_ht_oper(pos, ht_cap, &sdata->vif.bss_conf.chandef, 464 sdata->vif.bss_conf.ht_operation_mode); 465 466 return 0; 467 } 468 469 static void ieee80211_mesh_path_timer(unsigned long data) 470 { 471 struct ieee80211_sub_if_data *sdata = 472 (struct ieee80211_sub_if_data *) data; 473 474 ieee80211_queue_work(&sdata->local->hw, &sdata->work); 475 } 476 477 static void ieee80211_mesh_path_root_timer(unsigned long data) 478 { 479 struct ieee80211_sub_if_data *sdata = 480 (struct ieee80211_sub_if_data *) data; 481 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 482 483 set_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags); 484 485 ieee80211_queue_work(&sdata->local->hw, &sdata->work); 486 } 487 488 void ieee80211_mesh_root_setup(struct ieee80211_if_mesh *ifmsh) 489 { 490 if (ifmsh->mshcfg.dot11MeshHWMPRootMode > IEEE80211_ROOTMODE_ROOT) 491 set_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags); 492 else { 493 clear_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags); 494 /* stop running timer */ 495 del_timer_sync(&ifmsh->mesh_path_root_timer); 496 } 497 } 498 499 /** 500 * ieee80211_fill_mesh_addresses - fill addresses of a locally originated mesh frame 501 * @hdr: 802.11 frame header 502 * @fc: frame control field 503 * @meshda: destination address in the mesh 504 * @meshsa: source address address in the mesh. Same as TA, as frame is 505 * locally originated. 506 * 507 * Return the length of the 802.11 (does not include a mesh control header) 508 */ 509 int ieee80211_fill_mesh_addresses(struct ieee80211_hdr *hdr, __le16 *fc, 510 const u8 *meshda, const u8 *meshsa) 511 { 512 if (is_multicast_ether_addr(meshda)) { 513 *fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS); 514 /* DA TA SA */ 515 memcpy(hdr->addr1, meshda, ETH_ALEN); 516 memcpy(hdr->addr2, meshsa, ETH_ALEN); 517 memcpy(hdr->addr3, meshsa, ETH_ALEN); 518 return 24; 519 } else { 520 *fc |= cpu_to_le16(IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS); 521 /* RA TA DA SA */ 522 memset(hdr->addr1, 0, ETH_ALEN); /* RA is resolved later */ 523 memcpy(hdr->addr2, meshsa, ETH_ALEN); 524 memcpy(hdr->addr3, meshda, ETH_ALEN); 525 memcpy(hdr->addr4, meshsa, ETH_ALEN); 526 return 30; 527 } 528 } 529 530 /** 531 * ieee80211_new_mesh_header - create a new mesh header 532 * @sdata: mesh interface to be used 533 * @meshhdr: uninitialized mesh header 534 * @addr4or5: 1st address in the ae header, which may correspond to address 4 535 * (if addr6 is NULL) or address 5 (if addr6 is present). It may 536 * be NULL. 537 * @addr6: 2nd address in the ae header, which corresponds to addr6 of the 538 * mesh frame 539 * 540 * Return the header length. 541 */ 542 int ieee80211_new_mesh_header(struct ieee80211_sub_if_data *sdata, 543 struct ieee80211s_hdr *meshhdr, 544 const char *addr4or5, const char *addr6) 545 { 546 if (WARN_ON(!addr4or5 && addr6)) 547 return 0; 548 549 memset(meshhdr, 0, sizeof(*meshhdr)); 550 551 meshhdr->ttl = sdata->u.mesh.mshcfg.dot11MeshTTL; 552 553 /* FIXME: racy -- TX on multiple queues can be concurrent */ 554 put_unaligned(cpu_to_le32(sdata->u.mesh.mesh_seqnum), &meshhdr->seqnum); 555 sdata->u.mesh.mesh_seqnum++; 556 557 if (addr4or5 && !addr6) { 558 meshhdr->flags |= MESH_FLAGS_AE_A4; 559 memcpy(meshhdr->eaddr1, addr4or5, ETH_ALEN); 560 return 2 * ETH_ALEN; 561 } else if (addr4or5 && addr6) { 562 meshhdr->flags |= MESH_FLAGS_AE_A5_A6; 563 memcpy(meshhdr->eaddr1, addr4or5, ETH_ALEN); 564 memcpy(meshhdr->eaddr2, addr6, ETH_ALEN); 565 return 3 * ETH_ALEN; 566 } 567 568 return ETH_ALEN; 569 } 570 571 static void ieee80211_mesh_housekeeping(struct ieee80211_sub_if_data *sdata) 572 { 573 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 574 u32 changed; 575 576 ieee80211_sta_expire(sdata, IEEE80211_MESH_PEER_INACTIVITY_LIMIT); 577 mesh_path_expire(sdata); 578 579 changed = mesh_accept_plinks_update(sdata); 580 ieee80211_mbss_info_change_notify(sdata, changed); 581 582 mod_timer(&ifmsh->housekeeping_timer, 583 round_jiffies(jiffies + 584 IEEE80211_MESH_HOUSEKEEPING_INTERVAL)); 585 } 586 587 static void ieee80211_mesh_rootpath(struct ieee80211_sub_if_data *sdata) 588 { 589 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 590 u32 interval; 591 592 mesh_path_tx_root_frame(sdata); 593 594 if (ifmsh->mshcfg.dot11MeshHWMPRootMode == IEEE80211_PROACTIVE_RANN) 595 interval = ifmsh->mshcfg.dot11MeshHWMPRannInterval; 596 else 597 interval = ifmsh->mshcfg.dot11MeshHWMProotInterval; 598 599 mod_timer(&ifmsh->mesh_path_root_timer, 600 round_jiffies(TU_TO_EXP_TIME(interval))); 601 } 602 603 static int 604 ieee80211_mesh_build_beacon(struct ieee80211_if_mesh *ifmsh) 605 { 606 struct beacon_data *bcn; 607 int head_len, tail_len; 608 struct sk_buff *skb; 609 struct ieee80211_mgmt *mgmt; 610 struct ieee80211_chanctx_conf *chanctx_conf; 611 enum ieee80211_band band; 612 u8 *pos; 613 struct ieee80211_sub_if_data *sdata; 614 int hdr_len = offsetof(struct ieee80211_mgmt, u.beacon) + 615 sizeof(mgmt->u.beacon); 616 617 sdata = container_of(ifmsh, struct ieee80211_sub_if_data, u.mesh); 618 rcu_read_lock(); 619 chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf); 620 band = chanctx_conf->def.chan->band; 621 rcu_read_unlock(); 622 623 head_len = hdr_len + 624 2 + /* NULL SSID */ 625 2 + 8 + /* supported rates */ 626 2 + 3; /* DS params */ 627 tail_len = 2 + (IEEE80211_MAX_SUPP_RATES - 8) + 628 2 + sizeof(struct ieee80211_ht_cap) + 629 2 + sizeof(struct ieee80211_ht_operation) + 630 2 + ifmsh->mesh_id_len + 631 2 + sizeof(struct ieee80211_meshconf_ie) + 632 2 + sizeof(__le16) + /* awake window */ 633 ifmsh->ie_len; 634 635 bcn = kzalloc(sizeof(*bcn) + head_len + tail_len, GFP_KERNEL); 636 /* need an skb for IE builders to operate on */ 637 skb = dev_alloc_skb(max(head_len, tail_len)); 638 639 if (!bcn || !skb) 640 goto out_free; 641 642 /* 643 * pointers go into the block we allocated, 644 * memory is | beacon_data | head | tail | 645 */ 646 bcn->head = ((u8 *) bcn) + sizeof(*bcn); 647 648 /* fill in the head */ 649 mgmt = (struct ieee80211_mgmt *) skb_put(skb, hdr_len); 650 memset(mgmt, 0, hdr_len); 651 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 652 IEEE80211_STYPE_BEACON); 653 eth_broadcast_addr(mgmt->da); 654 memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN); 655 memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN); 656 ieee80211_mps_set_frame_flags(sdata, NULL, (void *) mgmt); 657 mgmt->u.beacon.beacon_int = 658 cpu_to_le16(sdata->vif.bss_conf.beacon_int); 659 mgmt->u.beacon.capab_info |= cpu_to_le16( 660 sdata->u.mesh.security ? WLAN_CAPABILITY_PRIVACY : 0); 661 662 pos = skb_put(skb, 2); 663 *pos++ = WLAN_EID_SSID; 664 *pos++ = 0x0; 665 666 if (ieee80211_add_srates_ie(sdata, skb, true, band) || 667 mesh_add_ds_params_ie(sdata, skb)) 668 goto out_free; 669 670 bcn->head_len = skb->len; 671 memcpy(bcn->head, skb->data, bcn->head_len); 672 673 /* now the tail */ 674 skb_trim(skb, 0); 675 bcn->tail = bcn->head + bcn->head_len; 676 677 if (ieee80211_add_ext_srates_ie(sdata, skb, true, band) || 678 mesh_add_rsn_ie(sdata, skb) || 679 mesh_add_ht_cap_ie(sdata, skb) || 680 mesh_add_ht_oper_ie(sdata, skb) || 681 mesh_add_meshid_ie(sdata, skb) || 682 mesh_add_meshconf_ie(sdata, skb) || 683 mesh_add_awake_window_ie(sdata, skb) || 684 mesh_add_vendor_ies(sdata, skb)) 685 goto out_free; 686 687 bcn->tail_len = skb->len; 688 memcpy(bcn->tail, skb->data, bcn->tail_len); 689 690 dev_kfree_skb(skb); 691 rcu_assign_pointer(ifmsh->beacon, bcn); 692 return 0; 693 out_free: 694 kfree(bcn); 695 dev_kfree_skb(skb); 696 return -ENOMEM; 697 } 698 699 static int 700 ieee80211_mesh_rebuild_beacon(struct ieee80211_if_mesh *ifmsh) 701 { 702 struct beacon_data *old_bcn; 703 int ret; 704 705 mutex_lock(&ifmsh->mtx); 706 707 old_bcn = rcu_dereference_protected(ifmsh->beacon, 708 lockdep_is_held(&ifmsh->mtx)); 709 ret = ieee80211_mesh_build_beacon(ifmsh); 710 if (ret) 711 /* just reuse old beacon */ 712 goto out; 713 714 if (old_bcn) 715 kfree_rcu(old_bcn, rcu_head); 716 out: 717 mutex_unlock(&ifmsh->mtx); 718 return ret; 719 } 720 721 void ieee80211_mbss_info_change_notify(struct ieee80211_sub_if_data *sdata, 722 u32 changed) 723 { 724 if (sdata->vif.bss_conf.enable_beacon && 725 (changed & (BSS_CHANGED_BEACON | 726 BSS_CHANGED_HT | 727 BSS_CHANGED_BASIC_RATES | 728 BSS_CHANGED_BEACON_INT))) 729 if (ieee80211_mesh_rebuild_beacon(&sdata->u.mesh)) 730 return; 731 ieee80211_bss_info_change_notify(sdata, changed); 732 } 733 734 int ieee80211_start_mesh(struct ieee80211_sub_if_data *sdata) 735 { 736 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 737 struct ieee80211_local *local = sdata->local; 738 u32 changed = BSS_CHANGED_BEACON | 739 BSS_CHANGED_BEACON_ENABLED | 740 BSS_CHANGED_HT | 741 BSS_CHANGED_BASIC_RATES | 742 BSS_CHANGED_BEACON_INT; 743 enum ieee80211_band band = ieee80211_get_sdata_band(sdata); 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 ifmsh->mesh_auth_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 sdata->vif.bss_conf.basic_rates = 763 ieee80211_mandatory_rates(local, band); 764 765 changed |= ieee80211_mps_local_status_update(sdata); 766 767 if (ieee80211_mesh_build_beacon(ifmsh)) { 768 ieee80211_stop_mesh(sdata); 769 return -ENOMEM; 770 } 771 772 ieee80211_bss_info_change_notify(sdata, changed); 773 774 netif_carrier_on(sdata->dev); 775 return 0; 776 } 777 778 void ieee80211_stop_mesh(struct ieee80211_sub_if_data *sdata) 779 { 780 struct ieee80211_local *local = sdata->local; 781 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 782 struct beacon_data *bcn; 783 784 netif_carrier_off(sdata->dev); 785 786 /* stop the beacon */ 787 ifmsh->mesh_id_len = 0; 788 sdata->vif.bss_conf.enable_beacon = false; 789 clear_bit(SDATA_STATE_OFFCHANNEL_BEACON_STOPPED, &sdata->state); 790 ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BEACON_ENABLED); 791 mutex_lock(&ifmsh->mtx); 792 bcn = rcu_dereference_protected(ifmsh->beacon, 793 lockdep_is_held(&ifmsh->mtx)); 794 rcu_assign_pointer(ifmsh->beacon, NULL); 795 kfree_rcu(bcn, rcu_head); 796 mutex_unlock(&ifmsh->mtx); 797 798 /* flush STAs and mpaths on this iface */ 799 sta_info_flush(sdata); 800 mesh_path_flush_by_iface(sdata); 801 802 /* free all potentially still buffered group-addressed frames */ 803 local->total_ps_buffered -= skb_queue_len(&ifmsh->ps.bc_buf); 804 skb_queue_purge(&ifmsh->ps.bc_buf); 805 806 del_timer_sync(&sdata->u.mesh.housekeeping_timer); 807 del_timer_sync(&sdata->u.mesh.mesh_path_root_timer); 808 del_timer_sync(&sdata->u.mesh.mesh_path_timer); 809 /* 810 * If the timer fired while we waited for it, it will have 811 * requeued the work. Now the work will be running again 812 * but will not rearm the timer again because it checks 813 * whether the interface is running, which, at this point, 814 * it no longer is. 815 */ 816 cancel_work_sync(&sdata->work); 817 818 local->fif_other_bss--; 819 atomic_dec(&local->iff_allmultis); 820 ieee80211_configure_filter(local); 821 } 822 823 static void 824 ieee80211_mesh_rx_probe_req(struct ieee80211_sub_if_data *sdata, 825 struct ieee80211_mgmt *mgmt, size_t len) 826 { 827 struct ieee80211_local *local = sdata->local; 828 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 829 struct sk_buff *presp; 830 struct beacon_data *bcn; 831 struct ieee80211_mgmt *hdr; 832 struct ieee802_11_elems elems; 833 size_t baselen; 834 u8 *pos; 835 836 pos = mgmt->u.probe_req.variable; 837 baselen = (u8 *) pos - (u8 *) mgmt; 838 if (baselen > len) 839 return; 840 841 ieee802_11_parse_elems(pos, len - baselen, false, &elems); 842 843 /* 802.11-2012 10.1.4.3.2 */ 844 if ((!ether_addr_equal(mgmt->da, sdata->vif.addr) && 845 !is_broadcast_ether_addr(mgmt->da)) || 846 elems.ssid_len != 0) 847 return; 848 849 if (elems.mesh_id_len != 0 && 850 (elems.mesh_id_len != ifmsh->mesh_id_len || 851 memcmp(elems.mesh_id, ifmsh->mesh_id, ifmsh->mesh_id_len))) 852 return; 853 854 rcu_read_lock(); 855 bcn = rcu_dereference(ifmsh->beacon); 856 857 if (!bcn) 858 goto out; 859 860 presp = dev_alloc_skb(local->tx_headroom + 861 bcn->head_len + bcn->tail_len); 862 if (!presp) 863 goto out; 864 865 skb_reserve(presp, local->tx_headroom); 866 memcpy(skb_put(presp, bcn->head_len), bcn->head, bcn->head_len); 867 memcpy(skb_put(presp, bcn->tail_len), bcn->tail, bcn->tail_len); 868 hdr = (struct ieee80211_mgmt *) presp->data; 869 hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | 870 IEEE80211_STYPE_PROBE_RESP); 871 memcpy(hdr->da, mgmt->sa, ETH_ALEN); 872 IEEE80211_SKB_CB(presp)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT; 873 ieee80211_tx_skb(sdata, presp); 874 out: 875 rcu_read_unlock(); 876 } 877 878 static void ieee80211_mesh_rx_bcn_presp(struct ieee80211_sub_if_data *sdata, 879 u16 stype, 880 struct ieee80211_mgmt *mgmt, 881 size_t len, 882 struct ieee80211_rx_status *rx_status) 883 { 884 struct ieee80211_local *local = sdata->local; 885 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 886 struct ieee802_11_elems elems; 887 struct ieee80211_channel *channel; 888 size_t baselen; 889 int freq; 890 enum ieee80211_band band = rx_status->band; 891 892 /* ignore ProbeResp to foreign address */ 893 if (stype == IEEE80211_STYPE_PROBE_RESP && 894 !ether_addr_equal(mgmt->da, sdata->vif.addr)) 895 return; 896 897 baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt; 898 if (baselen > len) 899 return; 900 901 ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen, 902 false, &elems); 903 904 /* ignore non-mesh or secure / unsecure mismatch */ 905 if ((!elems.mesh_id || !elems.mesh_config) || 906 (elems.rsn && sdata->u.mesh.security == IEEE80211_MESH_SEC_NONE) || 907 (!elems.rsn && sdata->u.mesh.security != IEEE80211_MESH_SEC_NONE)) 908 return; 909 910 if (elems.ds_params) 911 freq = ieee80211_channel_to_frequency(elems.ds_params[0], band); 912 else 913 freq = rx_status->freq; 914 915 channel = ieee80211_get_channel(local->hw.wiphy, freq); 916 917 if (!channel || channel->flags & IEEE80211_CHAN_DISABLED) 918 return; 919 920 if (mesh_matches_local(sdata, &elems)) 921 mesh_neighbour_update(sdata, mgmt->sa, &elems); 922 923 if (ifmsh->sync_ops) 924 ifmsh->sync_ops->rx_bcn_presp(sdata, 925 stype, mgmt, &elems, rx_status); 926 } 927 928 static void ieee80211_mesh_rx_mgmt_action(struct ieee80211_sub_if_data *sdata, 929 struct ieee80211_mgmt *mgmt, 930 size_t len, 931 struct ieee80211_rx_status *rx_status) 932 { 933 switch (mgmt->u.action.category) { 934 case WLAN_CATEGORY_SELF_PROTECTED: 935 switch (mgmt->u.action.u.self_prot.action_code) { 936 case WLAN_SP_MESH_PEERING_OPEN: 937 case WLAN_SP_MESH_PEERING_CLOSE: 938 case WLAN_SP_MESH_PEERING_CONFIRM: 939 mesh_rx_plink_frame(sdata, mgmt, len, rx_status); 940 break; 941 } 942 break; 943 case WLAN_CATEGORY_MESH_ACTION: 944 if (mesh_action_is_path_sel(mgmt)) 945 mesh_rx_path_sel_frame(sdata, mgmt, len); 946 break; 947 } 948 } 949 950 void ieee80211_mesh_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata, 951 struct sk_buff *skb) 952 { 953 struct ieee80211_rx_status *rx_status; 954 struct ieee80211_mgmt *mgmt; 955 u16 stype; 956 957 rx_status = IEEE80211_SKB_RXCB(skb); 958 mgmt = (struct ieee80211_mgmt *) skb->data; 959 stype = le16_to_cpu(mgmt->frame_control) & IEEE80211_FCTL_STYPE; 960 961 switch (stype) { 962 case IEEE80211_STYPE_PROBE_RESP: 963 case IEEE80211_STYPE_BEACON: 964 ieee80211_mesh_rx_bcn_presp(sdata, stype, mgmt, skb->len, 965 rx_status); 966 break; 967 case IEEE80211_STYPE_PROBE_REQ: 968 ieee80211_mesh_rx_probe_req(sdata, mgmt, skb->len); 969 break; 970 case IEEE80211_STYPE_ACTION: 971 ieee80211_mesh_rx_mgmt_action(sdata, mgmt, skb->len, rx_status); 972 break; 973 } 974 } 975 976 void ieee80211_mesh_work(struct ieee80211_sub_if_data *sdata) 977 { 978 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 979 980 if (ifmsh->preq_queue_len && 981 time_after(jiffies, 982 ifmsh->last_preq + msecs_to_jiffies(ifmsh->mshcfg.dot11MeshHWMPpreqMinInterval))) 983 mesh_path_start_discovery(sdata); 984 985 if (test_and_clear_bit(MESH_WORK_GROW_MPATH_TABLE, &ifmsh->wrkq_flags)) 986 mesh_mpath_table_grow(); 987 988 if (test_and_clear_bit(MESH_WORK_GROW_MPP_TABLE, &ifmsh->wrkq_flags)) 989 mesh_mpp_table_grow(); 990 991 if (test_and_clear_bit(MESH_WORK_HOUSEKEEPING, &ifmsh->wrkq_flags)) 992 ieee80211_mesh_housekeeping(sdata); 993 994 if (test_and_clear_bit(MESH_WORK_ROOT, &ifmsh->wrkq_flags)) 995 ieee80211_mesh_rootpath(sdata); 996 997 if (test_and_clear_bit(MESH_WORK_DRIFT_ADJUST, &ifmsh->wrkq_flags)) 998 mesh_sync_adjust_tbtt(sdata); 999 } 1000 1001 void ieee80211_mesh_notify_scan_completed(struct ieee80211_local *local) 1002 { 1003 struct ieee80211_sub_if_data *sdata; 1004 1005 rcu_read_lock(); 1006 list_for_each_entry_rcu(sdata, &local->interfaces, list) 1007 if (ieee80211_vif_is_mesh(&sdata->vif) && 1008 ieee80211_sdata_running(sdata)) 1009 ieee80211_queue_work(&local->hw, &sdata->work); 1010 rcu_read_unlock(); 1011 } 1012 1013 void ieee80211_mesh_init_sdata(struct ieee80211_sub_if_data *sdata) 1014 { 1015 struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh; 1016 static u8 zero_addr[ETH_ALEN] = {}; 1017 1018 setup_timer(&ifmsh->housekeeping_timer, 1019 ieee80211_mesh_housekeeping_timer, 1020 (unsigned long) sdata); 1021 1022 ifmsh->accepting_plinks = true; 1023 ifmsh->preq_id = 0; 1024 ifmsh->sn = 0; 1025 ifmsh->num_gates = 0; 1026 atomic_set(&ifmsh->mpaths, 0); 1027 mesh_rmc_init(sdata); 1028 ifmsh->last_preq = jiffies; 1029 ifmsh->next_perr = jiffies; 1030 /* Allocate all mesh structures when creating the first mesh interface. */ 1031 if (!mesh_allocated) 1032 ieee80211s_init(); 1033 setup_timer(&ifmsh->mesh_path_timer, 1034 ieee80211_mesh_path_timer, 1035 (unsigned long) sdata); 1036 setup_timer(&ifmsh->mesh_path_root_timer, 1037 ieee80211_mesh_path_root_timer, 1038 (unsigned long) sdata); 1039 INIT_LIST_HEAD(&ifmsh->preq_queue.list); 1040 skb_queue_head_init(&ifmsh->ps.bc_buf); 1041 spin_lock_init(&ifmsh->mesh_preq_queue_lock); 1042 spin_lock_init(&ifmsh->sync_offset_lock); 1043 RCU_INIT_POINTER(ifmsh->beacon, NULL); 1044 mutex_init(&ifmsh->mtx); 1045 1046 sdata->vif.bss_conf.bssid = zero_addr; 1047 } 1048