ap.c 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904
  1. /*
  2. * WPA Supplicant - Basic AP mode support routines
  3. * Copyright (c) 2003-2009, Jouni Malinen <j@w1.fi>
  4. * Copyright (c) 2009, Atheros Communications
  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. * Alternatively, this software may be distributed under the terms of BSD
  11. * license.
  12. *
  13. * See README and COPYING for more details.
  14. */
  15. #include "utils/includes.h"
  16. #include "utils/common.h"
  17. #include "utils/eloop.h"
  18. #include "utils/uuid.h"
  19. #include "common/ieee802_11_defs.h"
  20. #include "common/wpa_ctrl.h"
  21. #include "ap/hostapd.h"
  22. #include "ap/ap_config.h"
  23. #include "ap/ap_drv_ops.h"
  24. #ifdef NEED_AP_MLME
  25. #include "ap/ieee802_11.h"
  26. #endif /* NEED_AP_MLME */
  27. #include "ap/beacon.h"
  28. #include "ap/ieee802_1x.h"
  29. #include "ap/wps_hostapd.h"
  30. #include "ap/ctrl_iface_ap.h"
  31. #include "eap_common/eap_defs.h"
  32. #include "eap_server/eap_methods.h"
  33. #include "eap_common/eap_wsc_common.h"
  34. #include "wps/wps.h"
  35. #include "common/ieee802_11_defs.h"
  36. #include "config_ssid.h"
  37. #include "config.h"
  38. #include "wpa_supplicant_i.h"
  39. #include "driver_i.h"
  40. #include "p2p_supplicant.h"
  41. #include "ap.h"
  42. #include "ap/sta_info.h"
  43. #include "notify.h"
  44. #ifdef CONFIG_WPS
  45. static void wpas_wps_ap_pin_timeout(void *eloop_data, void *user_ctx);
  46. #endif /* CONFIG_WPS */
  47. static int wpa_supplicant_conf_ap(struct wpa_supplicant *wpa_s,
  48. struct wpa_ssid *ssid,
  49. struct hostapd_config *conf)
  50. {
  51. struct hostapd_bss_config *bss = &conf->bss[0];
  52. int pairwise;
  53. #ifdef CONFIG_IEEE80211N
  54. struct hostapd_hw_modes *modes;
  55. u16 num_modes, flags;
  56. #endif /* CONFIG_IEEE80211N */
  57. conf->driver = wpa_s->driver;
  58. os_strlcpy(bss->iface, wpa_s->ifname, sizeof(bss->iface));
  59. if (ssid->frequency == 0) {
  60. /* default channel 11 */
  61. conf->hw_mode = HOSTAPD_MODE_IEEE80211G;
  62. conf->channel = 11;
  63. } else if (ssid->frequency >= 2412 && ssid->frequency <= 2472) {
  64. conf->hw_mode = HOSTAPD_MODE_IEEE80211G;
  65. conf->channel = (ssid->frequency - 2407) / 5;
  66. } else if ((ssid->frequency >= 5180 && ssid->frequency <= 5240) ||
  67. (ssid->frequency >= 5745 && ssid->frequency <= 5825)) {
  68. conf->hw_mode = HOSTAPD_MODE_IEEE80211A;
  69. conf->channel = (ssid->frequency - 5000) / 5;
  70. } else {
  71. wpa_printf(MSG_ERROR, "Unsupported AP mode frequency: %d MHz",
  72. ssid->frequency);
  73. return -1;
  74. }
  75. /* TODO: enable HT40 if driver supports it;
  76. * drop to 11b if driver does not support 11g */
  77. #ifdef CONFIG_IEEE80211N
  78. /*
  79. * Enable HT20 if the driver supports it, by setting conf->ieee80211n.
  80. * Using default config settings for: conf->ht_op_mode_fixed,
  81. * conf->ht_capab, conf->secondary_channel, conf->require_ht
  82. */
  83. modes = wpa_drv_get_hw_feature_data(wpa_s, &num_modes, &flags);
  84. if (modes) {
  85. struct hostapd_hw_modes *mode = NULL;
  86. int i;
  87. for (i = 0; i < num_modes; i++) {
  88. if (modes[i].mode == conf->hw_mode) {
  89. mode = &modes[i];
  90. break;
  91. }
  92. }
  93. if (mode && mode->ht_capab)
  94. conf->ieee80211n = 1;
  95. ieee80211_sta_free_hw_features(modes, num_modes);
  96. modes = NULL;
  97. }
  98. #endif /* CONFIG_IEEE80211N */
  99. #ifdef CONFIG_P2P
  100. if (conf->hw_mode == HOSTAPD_MODE_IEEE80211G) {
  101. /* Remove 802.11b rates from supported and basic rate sets */
  102. int *list = os_malloc(4 * sizeof(int));
  103. if (list) {
  104. list[0] = 60;
  105. list[1] = 120;
  106. list[2] = 240;
  107. list[3] = -1;
  108. }
  109. conf->basic_rates = list;
  110. list = os_malloc(9 * sizeof(int));
  111. if (list) {
  112. list[0] = 60;
  113. list[1] = 90;
  114. list[2] = 120;
  115. list[3] = 180;
  116. list[4] = 240;
  117. list[5] = 360;
  118. list[6] = 480;
  119. list[7] = 540;
  120. list[8] = -1;
  121. }
  122. conf->supported_rates = list;
  123. }
  124. bss->isolate = !wpa_s->conf->p2p_intra_bss;
  125. #endif /* CONFIG_P2P */
  126. if (ssid->ssid_len == 0) {
  127. wpa_printf(MSG_ERROR, "No SSID configured for AP mode");
  128. return -1;
  129. }
  130. os_memcpy(bss->ssid.ssid, ssid->ssid, ssid->ssid_len);
  131. bss->ssid.ssid[ssid->ssid_len] = '\0';
  132. bss->ssid.ssid_len = ssid->ssid_len;
  133. bss->ssid.ssid_set = 1;
  134. if (wpa_key_mgmt_wpa_psk(ssid->key_mgmt))
  135. bss->wpa = ssid->proto;
  136. bss->wpa_key_mgmt = ssid->key_mgmt;
  137. bss->wpa_pairwise = ssid->pairwise_cipher;
  138. if (ssid->passphrase) {
  139. bss->ssid.wpa_passphrase = os_strdup(ssid->passphrase);
  140. } else if (ssid->psk_set) {
  141. os_free(bss->ssid.wpa_psk);
  142. bss->ssid.wpa_psk = os_zalloc(sizeof(struct hostapd_wpa_psk));
  143. if (bss->ssid.wpa_psk == NULL)
  144. return -1;
  145. os_memcpy(bss->ssid.wpa_psk->psk, ssid->psk, PMK_LEN);
  146. bss->ssid.wpa_psk->group = 1;
  147. }
  148. /* Select group cipher based on the enabled pairwise cipher suites */
  149. pairwise = 0;
  150. if (bss->wpa & 1)
  151. pairwise |= bss->wpa_pairwise;
  152. if (bss->wpa & 2) {
  153. if (bss->rsn_pairwise == 0)
  154. bss->rsn_pairwise = bss->wpa_pairwise;
  155. pairwise |= bss->rsn_pairwise;
  156. }
  157. if (pairwise & WPA_CIPHER_TKIP)
  158. bss->wpa_group = WPA_CIPHER_TKIP;
  159. else
  160. bss->wpa_group = WPA_CIPHER_CCMP;
  161. if (bss->wpa && bss->ieee802_1x)
  162. bss->ssid.security_policy = SECURITY_WPA;
  163. else if (bss->wpa)
  164. bss->ssid.security_policy = SECURITY_WPA_PSK;
  165. else if (bss->ieee802_1x) {
  166. bss->ssid.security_policy = SECURITY_IEEE_802_1X;
  167. bss->ssid.wep.default_len = bss->default_wep_key_len;
  168. } else if (bss->ssid.wep.keys_set)
  169. bss->ssid.security_policy = SECURITY_STATIC_WEP;
  170. else
  171. bss->ssid.security_policy = SECURITY_PLAINTEXT;
  172. #ifdef CONFIG_WPS
  173. /*
  174. * Enable WPS by default, but require user interaction to actually use
  175. * it. Only the internal Registrar is supported.
  176. */
  177. bss->eap_server = 1;
  178. bss->wps_state = 2;
  179. bss->ap_setup_locked = 2;
  180. if (wpa_s->conf->config_methods)
  181. bss->config_methods = os_strdup(wpa_s->conf->config_methods);
  182. os_memcpy(bss->device_type, wpa_s->conf->device_type,
  183. WPS_DEV_TYPE_LEN);
  184. if (wpa_s->conf->device_name) {
  185. bss->device_name = os_strdup(wpa_s->conf->device_name);
  186. bss->friendly_name = os_strdup(wpa_s->conf->device_name);
  187. }
  188. if (wpa_s->conf->manufacturer)
  189. bss->manufacturer = os_strdup(wpa_s->conf->manufacturer);
  190. if (wpa_s->conf->model_name)
  191. bss->model_name = os_strdup(wpa_s->conf->model_name);
  192. if (wpa_s->conf->model_number)
  193. bss->model_number = os_strdup(wpa_s->conf->model_number);
  194. if (wpa_s->conf->serial_number)
  195. bss->serial_number = os_strdup(wpa_s->conf->serial_number);
  196. if (is_nil_uuid(wpa_s->conf->uuid))
  197. os_memcpy(bss->uuid, wpa_s->wps->uuid, WPS_UUID_LEN);
  198. else
  199. os_memcpy(bss->uuid, wpa_s->conf->uuid, WPS_UUID_LEN);
  200. os_memcpy(bss->os_version, wpa_s->conf->os_version, 4);
  201. #endif /* CONFIG_WPS */
  202. if (wpa_s->max_stations &&
  203. wpa_s->max_stations < wpa_s->conf->max_num_sta)
  204. bss->max_num_sta = wpa_s->max_stations;
  205. else
  206. bss->max_num_sta = wpa_s->conf->max_num_sta;
  207. bss->disassoc_low_ack = wpa_s->conf->disassoc_low_ack;
  208. return 0;
  209. }
  210. static void ap_public_action_rx(void *ctx, const u8 *buf, size_t len, int freq)
  211. {
  212. #ifdef CONFIG_P2P
  213. struct wpa_supplicant *wpa_s = ctx;
  214. const struct ieee80211_mgmt *mgmt;
  215. size_t hdr_len;
  216. mgmt = (const struct ieee80211_mgmt *) buf;
  217. hdr_len = (const u8 *) &mgmt->u.action.u.vs_public_action.action - buf;
  218. if (hdr_len > len)
  219. return;
  220. wpas_p2p_rx_action(wpa_s, mgmt->da, mgmt->sa, mgmt->bssid,
  221. mgmt->u.action.category,
  222. &mgmt->u.action.u.vs_public_action.action,
  223. len - hdr_len, freq);
  224. #endif /* CONFIG_P2P */
  225. }
  226. static void ap_wps_event_cb(void *ctx, enum wps_event event,
  227. union wps_event_data *data)
  228. {
  229. #ifdef CONFIG_P2P
  230. struct wpa_supplicant *wpa_s = ctx;
  231. if (event == WPS_EV_FAIL) {
  232. struct wps_event_fail *fail = &data->fail;
  233. if (wpa_s->parent && wpa_s->parent != wpa_s &&
  234. wpa_s == wpa_s->global->p2p_group_formation) {
  235. /*
  236. * src/ap/wps_hostapd.c has already sent this on the
  237. * main interface, so only send on the parent interface
  238. * here if needed.
  239. */
  240. wpa_msg(wpa_s->parent, MSG_INFO, WPS_EVENT_FAIL
  241. "msg=%d config_error=%d",
  242. fail->msg, fail->config_error);
  243. }
  244. wpas_p2p_wps_failed(wpa_s, fail);
  245. }
  246. #endif /* CONFIG_P2P */
  247. }
  248. static void ap_sta_authorized_cb(void *ctx, const u8 *mac_addr,
  249. int authorized)
  250. {
  251. wpas_notify_sta_authorized(ctx, mac_addr, authorized);
  252. }
  253. static int ap_vendor_action_rx(void *ctx, const u8 *buf, size_t len, int freq)
  254. {
  255. #ifdef CONFIG_P2P
  256. struct wpa_supplicant *wpa_s = ctx;
  257. const struct ieee80211_mgmt *mgmt;
  258. size_t hdr_len;
  259. mgmt = (const struct ieee80211_mgmt *) buf;
  260. hdr_len = (const u8 *) &mgmt->u.action.u.vs_public_action.action - buf;
  261. if (hdr_len > len)
  262. return -1;
  263. wpas_p2p_rx_action(wpa_s, mgmt->da, mgmt->sa, mgmt->bssid,
  264. mgmt->u.action.category,
  265. &mgmt->u.action.u.vs_public_action.action,
  266. len - hdr_len, freq);
  267. #endif /* CONFIG_P2P */
  268. return 0;
  269. }
  270. static int ap_probe_req_rx(void *ctx, const u8 *sa, const u8 *da,
  271. const u8 *bssid, const u8 *ie, size_t ie_len)
  272. {
  273. #ifdef CONFIG_P2P
  274. struct wpa_supplicant *wpa_s = ctx;
  275. return wpas_p2p_probe_req_rx(wpa_s, sa, da, bssid, ie, ie_len);
  276. #else /* CONFIG_P2P */
  277. return 0;
  278. #endif /* CONFIG_P2P */
  279. }
  280. static void ap_wps_reg_success_cb(void *ctx, const u8 *mac_addr,
  281. const u8 *uuid_e)
  282. {
  283. #ifdef CONFIG_P2P
  284. struct wpa_supplicant *wpa_s = ctx;
  285. wpas_p2p_wps_success(wpa_s, mac_addr, 1);
  286. #endif /* CONFIG_P2P */
  287. }
  288. static void wpas_ap_configured_cb(void *ctx)
  289. {
  290. struct wpa_supplicant *wpa_s = ctx;
  291. wpa_supplicant_set_state(wpa_s, WPA_COMPLETED);
  292. if (wpa_s->ap_configured_cb)
  293. wpa_s->ap_configured_cb(wpa_s->ap_configured_cb_ctx,
  294. wpa_s->ap_configured_cb_data);
  295. }
  296. int wpa_supplicant_create_ap(struct wpa_supplicant *wpa_s,
  297. struct wpa_ssid *ssid)
  298. {
  299. struct wpa_driver_associate_params params;
  300. struct hostapd_iface *hapd_iface;
  301. struct hostapd_config *conf;
  302. size_t i;
  303. if (ssid->ssid == NULL || ssid->ssid_len == 0) {
  304. wpa_printf(MSG_ERROR, "No SSID configured for AP mode");
  305. return -1;
  306. }
  307. wpa_supplicant_ap_deinit(wpa_s);
  308. wpa_printf(MSG_DEBUG, "Setting up AP (SSID='%s')",
  309. wpa_ssid_txt(ssid->ssid, ssid->ssid_len));
  310. os_memset(&params, 0, sizeof(params));
  311. params.ssid = ssid->ssid;
  312. params.ssid_len = ssid->ssid_len;
  313. switch (ssid->mode) {
  314. case WPAS_MODE_INFRA:
  315. params.mode = IEEE80211_MODE_INFRA;
  316. break;
  317. case WPAS_MODE_IBSS:
  318. params.mode = IEEE80211_MODE_IBSS;
  319. break;
  320. case WPAS_MODE_AP:
  321. case WPAS_MODE_P2P_GO:
  322. case WPAS_MODE_P2P_GROUP_FORMATION:
  323. params.mode = IEEE80211_MODE_AP;
  324. break;
  325. }
  326. params.freq = ssid->frequency;
  327. if (ssid->key_mgmt & WPA_KEY_MGMT_PSK)
  328. wpa_s->key_mgmt = WPA_KEY_MGMT_PSK;
  329. else
  330. wpa_s->key_mgmt = WPA_KEY_MGMT_NONE;
  331. params.key_mgmt_suite = key_mgmt2driver(wpa_s->key_mgmt);
  332. if (ssid->pairwise_cipher & WPA_CIPHER_CCMP)
  333. wpa_s->pairwise_cipher = WPA_CIPHER_CCMP;
  334. else if (ssid->pairwise_cipher & WPA_CIPHER_TKIP)
  335. wpa_s->pairwise_cipher = WPA_CIPHER_TKIP;
  336. else if (ssid->pairwise_cipher & WPA_CIPHER_NONE)
  337. wpa_s->pairwise_cipher = WPA_CIPHER_NONE;
  338. else {
  339. wpa_printf(MSG_WARNING, "WPA: Failed to select pairwise "
  340. "cipher.");
  341. return -1;
  342. }
  343. params.pairwise_suite = cipher_suite2driver(wpa_s->pairwise_cipher);
  344. params.group_suite = params.pairwise_suite;
  345. #ifdef CONFIG_P2P
  346. if (ssid->mode == WPAS_MODE_P2P_GO ||
  347. ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION)
  348. params.p2p = 1;
  349. wpa_drv_set_intra_bss(wpa_s, wpa_s->conf->p2p_intra_bss);
  350. #endif /* CONFIG_P2P */
  351. if (wpa_s->parent->set_ap_uapsd)
  352. params.uapsd = wpa_s->parent->ap_uapsd;
  353. else
  354. params.uapsd = -1;
  355. if (wpa_drv_associate(wpa_s, &params) < 0) {
  356. wpa_msg(wpa_s, MSG_INFO, "Failed to start AP functionality");
  357. return -1;
  358. }
  359. wpa_s->ap_iface = hapd_iface = os_zalloc(sizeof(*wpa_s->ap_iface));
  360. if (hapd_iface == NULL)
  361. return -1;
  362. hapd_iface->owner = wpa_s;
  363. wpa_s->ap_iface->conf = conf = hostapd_config_defaults();
  364. if (conf == NULL) {
  365. wpa_supplicant_ap_deinit(wpa_s);
  366. return -1;
  367. }
  368. if (params.uapsd > 0) {
  369. conf->bss->wmm_enabled = 1;
  370. conf->bss->wmm_uapsd = 1;
  371. }
  372. if (wpa_supplicant_conf_ap(wpa_s, ssid, conf)) {
  373. wpa_printf(MSG_ERROR, "Failed to create AP configuration");
  374. wpa_supplicant_ap_deinit(wpa_s);
  375. return -1;
  376. }
  377. #ifdef CONFIG_P2P
  378. if (ssid->mode == WPAS_MODE_P2P_GO)
  379. conf->bss[0].p2p = P2P_ENABLED | P2P_GROUP_OWNER;
  380. else if (ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION)
  381. conf->bss[0].p2p = P2P_ENABLED | P2P_GROUP_OWNER |
  382. P2P_GROUP_FORMATION;
  383. #endif /* CONFIG_P2P */
  384. hapd_iface->num_bss = conf->num_bss;
  385. hapd_iface->bss = os_zalloc(conf->num_bss *
  386. sizeof(struct hostapd_data *));
  387. if (hapd_iface->bss == NULL) {
  388. wpa_supplicant_ap_deinit(wpa_s);
  389. return -1;
  390. }
  391. for (i = 0; i < conf->num_bss; i++) {
  392. hapd_iface->bss[i] =
  393. hostapd_alloc_bss_data(hapd_iface, conf,
  394. &conf->bss[i]);
  395. if (hapd_iface->bss[i] == NULL) {
  396. wpa_supplicant_ap_deinit(wpa_s);
  397. return -1;
  398. }
  399. hapd_iface->bss[i]->msg_ctx = wpa_s;
  400. hapd_iface->bss[i]->public_action_cb = ap_public_action_rx;
  401. hapd_iface->bss[i]->public_action_cb_ctx = wpa_s;
  402. hapd_iface->bss[i]->vendor_action_cb = ap_vendor_action_rx;
  403. hapd_iface->bss[i]->vendor_action_cb_ctx = wpa_s;
  404. hostapd_register_probereq_cb(hapd_iface->bss[i],
  405. ap_probe_req_rx, wpa_s);
  406. hapd_iface->bss[i]->wps_reg_success_cb = ap_wps_reg_success_cb;
  407. hapd_iface->bss[i]->wps_reg_success_cb_ctx = wpa_s;
  408. hapd_iface->bss[i]->wps_event_cb = ap_wps_event_cb;
  409. hapd_iface->bss[i]->wps_event_cb_ctx = wpa_s;
  410. hapd_iface->bss[i]->sta_authorized_cb = ap_sta_authorized_cb;
  411. hapd_iface->bss[i]->sta_authorized_cb_ctx = wpa_s;
  412. #ifdef CONFIG_P2P
  413. hapd_iface->bss[i]->p2p = wpa_s->global->p2p;
  414. hapd_iface->bss[i]->p2p_group = wpas_p2p_group_init(
  415. wpa_s, ssid->p2p_persistent_group,
  416. ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION);
  417. #endif /* CONFIG_P2P */
  418. hapd_iface->bss[i]->setup_complete_cb = wpas_ap_configured_cb;
  419. hapd_iface->bss[i]->setup_complete_cb_ctx = wpa_s;
  420. }
  421. os_memcpy(hapd_iface->bss[0]->own_addr, wpa_s->own_addr, ETH_ALEN);
  422. hapd_iface->bss[0]->driver = wpa_s->driver;
  423. hapd_iface->bss[0]->drv_priv = wpa_s->drv_priv;
  424. wpa_s->current_ssid = ssid;
  425. os_memcpy(wpa_s->bssid, wpa_s->own_addr, ETH_ALEN);
  426. wpa_s->assoc_freq = ssid->frequency;
  427. if (hostapd_setup_interface(wpa_s->ap_iface)) {
  428. wpa_printf(MSG_ERROR, "Failed to initialize AP interface");
  429. wpa_supplicant_ap_deinit(wpa_s);
  430. return -1;
  431. }
  432. return 0;
  433. }
  434. void wpa_supplicant_ap_deinit(struct wpa_supplicant *wpa_s)
  435. {
  436. #ifdef CONFIG_WPS
  437. eloop_cancel_timeout(wpas_wps_ap_pin_timeout, wpa_s, NULL);
  438. #endif /* CONFIG_WPS */
  439. if (wpa_s->ap_iface == NULL)
  440. return;
  441. wpa_s->current_ssid = NULL;
  442. wpa_s->assoc_freq = 0;
  443. wpa_s->reassociated_connection = 0;
  444. #ifdef CONFIG_P2P
  445. if (wpa_s->ap_iface->bss)
  446. wpa_s->ap_iface->bss[0]->p2p_group = NULL;
  447. wpas_p2p_group_deinit(wpa_s);
  448. #endif /* CONFIG_P2P */
  449. hostapd_interface_deinit(wpa_s->ap_iface);
  450. hostapd_interface_free(wpa_s->ap_iface);
  451. wpa_s->ap_iface = NULL;
  452. wpa_drv_deinit_ap(wpa_s);
  453. }
  454. void ap_tx_status(void *ctx, const u8 *addr,
  455. const u8 *buf, size_t len, int ack)
  456. {
  457. #ifdef NEED_AP_MLME
  458. struct wpa_supplicant *wpa_s = ctx;
  459. hostapd_tx_status(wpa_s->ap_iface->bss[0], addr, buf, len, ack);
  460. #endif /* NEED_AP_MLME */
  461. }
  462. void ap_rx_from_unknown_sta(void *ctx, const u8 *frame, size_t len)
  463. {
  464. #ifdef NEED_AP_MLME
  465. struct wpa_supplicant *wpa_s = ctx;
  466. const struct ieee80211_hdr *hdr =
  467. (const struct ieee80211_hdr *) frame;
  468. u16 fc = le_to_host16(hdr->frame_control);
  469. ieee802_11_rx_from_unknown(wpa_s->ap_iface->bss[0], hdr->addr2,
  470. (fc & (WLAN_FC_TODS | WLAN_FC_FROMDS)) ==
  471. (WLAN_FC_TODS | WLAN_FC_FROMDS));
  472. #endif /* NEED_AP_MLME */
  473. }
  474. void ap_mgmt_rx(void *ctx, struct rx_mgmt *rx_mgmt)
  475. {
  476. #ifdef NEED_AP_MLME
  477. struct wpa_supplicant *wpa_s = ctx;
  478. struct hostapd_frame_info fi;
  479. os_memset(&fi, 0, sizeof(fi));
  480. fi.datarate = rx_mgmt->datarate;
  481. fi.ssi_signal = rx_mgmt->ssi_signal;
  482. ieee802_11_mgmt(wpa_s->ap_iface->bss[0], rx_mgmt->frame,
  483. rx_mgmt->frame_len, &fi);
  484. #endif /* NEED_AP_MLME */
  485. }
  486. void ap_mgmt_tx_cb(void *ctx, const u8 *buf, size_t len, u16 stype, int ok)
  487. {
  488. #ifdef NEED_AP_MLME
  489. struct wpa_supplicant *wpa_s = ctx;
  490. ieee802_11_mgmt_cb(wpa_s->ap_iface->bss[0], buf, len, stype, ok);
  491. #endif /* NEED_AP_MLME */
  492. }
  493. void wpa_supplicant_ap_rx_eapol(struct wpa_supplicant *wpa_s,
  494. const u8 *src_addr, const u8 *buf, size_t len)
  495. {
  496. ieee802_1x_receive(wpa_s->ap_iface->bss[0], src_addr, buf, len);
  497. }
  498. #ifdef CONFIG_WPS
  499. int wpa_supplicant_ap_wps_pbc(struct wpa_supplicant *wpa_s, const u8 *bssid,
  500. const u8 *p2p_dev_addr)
  501. {
  502. if (!wpa_s->ap_iface)
  503. return -1;
  504. return hostapd_wps_button_pushed(wpa_s->ap_iface->bss[0],
  505. p2p_dev_addr);
  506. }
  507. static int wpa_supplicant_ap_wps_sta_cancel(struct hostapd_data *hapd,
  508. struct sta_info *sta, void *ctx)
  509. {
  510. if (sta && (sta->flags & WLAN_STA_WPS)) {
  511. ap_sta_deauthenticate(hapd, sta,
  512. WLAN_REASON_PREV_AUTH_NOT_VALID);
  513. wpa_printf(MSG_DEBUG, "WPS: %s: Deauth sta=" MACSTR,
  514. __func__, MAC2STR(sta->addr));
  515. return 1;
  516. }
  517. return 0;
  518. }
  519. int wpa_supplicant_ap_wps_cancel(struct wpa_supplicant *wpa_s)
  520. {
  521. struct wps_registrar *reg;
  522. int reg_sel = 0, wps_sta = 0;
  523. if (!wpa_s->ap_iface || !wpa_s->ap_iface->bss[0]->wps)
  524. return -1;
  525. reg = wpa_s->ap_iface->bss[0]->wps->registrar;
  526. reg_sel = wps_registrar_wps_cancel(reg);
  527. wps_sta = ap_for_each_sta(wpa_s->ap_iface->bss[0],
  528. wpa_supplicant_ap_wps_sta_cancel, NULL);
  529. if (!reg_sel && !wps_sta) {
  530. wpa_printf(MSG_DEBUG, "No WPS operation in progress at this "
  531. "time");
  532. return -1;
  533. }
  534. /*
  535. * There are 2 cases to return wps cancel as success:
  536. * 1. When wps cancel was initiated but no connection has been
  537. * established with client yet.
  538. * 2. Client is in the middle of exchanging WPS messages.
  539. */
  540. return 0;
  541. }
  542. int wpa_supplicant_ap_wps_pin(struct wpa_supplicant *wpa_s, const u8 *bssid,
  543. const char *pin, char *buf, size_t buflen)
  544. {
  545. int ret, ret_len = 0;
  546. if (!wpa_s->ap_iface)
  547. return -1;
  548. if (pin == NULL) {
  549. unsigned int rpin = wps_generate_pin();
  550. ret_len = os_snprintf(buf, buflen, "%d", rpin);
  551. pin = buf;
  552. } else
  553. ret_len = os_snprintf(buf, buflen, "%s", pin);
  554. ret = hostapd_wps_add_pin(wpa_s->ap_iface->bss[0], bssid, "any", pin,
  555. 0);
  556. if (ret)
  557. return -1;
  558. return ret_len;
  559. }
  560. static void wpas_wps_ap_pin_timeout(void *eloop_data, void *user_ctx)
  561. {
  562. struct wpa_supplicant *wpa_s = eloop_data;
  563. wpa_printf(MSG_DEBUG, "WPS: AP PIN timed out");
  564. wpas_wps_ap_pin_disable(wpa_s);
  565. }
  566. static void wpas_wps_ap_pin_enable(struct wpa_supplicant *wpa_s, int timeout)
  567. {
  568. struct hostapd_data *hapd;
  569. if (wpa_s->ap_iface == NULL)
  570. return;
  571. hapd = wpa_s->ap_iface->bss[0];
  572. wpa_printf(MSG_DEBUG, "WPS: Enabling AP PIN (timeout=%d)", timeout);
  573. hapd->ap_pin_failures = 0;
  574. eloop_cancel_timeout(wpas_wps_ap_pin_timeout, wpa_s, NULL);
  575. if (timeout > 0)
  576. eloop_register_timeout(timeout, 0,
  577. wpas_wps_ap_pin_timeout, wpa_s, NULL);
  578. }
  579. void wpas_wps_ap_pin_disable(struct wpa_supplicant *wpa_s)
  580. {
  581. struct hostapd_data *hapd;
  582. if (wpa_s->ap_iface == NULL)
  583. return;
  584. wpa_printf(MSG_DEBUG, "WPS: Disabling AP PIN");
  585. hapd = wpa_s->ap_iface->bss[0];
  586. os_free(hapd->conf->ap_pin);
  587. hapd->conf->ap_pin = NULL;
  588. eloop_cancel_timeout(wpas_wps_ap_pin_timeout, wpa_s, NULL);
  589. }
  590. const char * wpas_wps_ap_pin_random(struct wpa_supplicant *wpa_s, int timeout)
  591. {
  592. struct hostapd_data *hapd;
  593. unsigned int pin;
  594. char pin_txt[9];
  595. if (wpa_s->ap_iface == NULL)
  596. return NULL;
  597. hapd = wpa_s->ap_iface->bss[0];
  598. pin = wps_generate_pin();
  599. os_snprintf(pin_txt, sizeof(pin_txt), "%u", pin);
  600. os_free(hapd->conf->ap_pin);
  601. hapd->conf->ap_pin = os_strdup(pin_txt);
  602. if (hapd->conf->ap_pin == NULL)
  603. return NULL;
  604. wpas_wps_ap_pin_enable(wpa_s, timeout);
  605. return hapd->conf->ap_pin;
  606. }
  607. const char * wpas_wps_ap_pin_get(struct wpa_supplicant *wpa_s)
  608. {
  609. struct hostapd_data *hapd;
  610. if (wpa_s->ap_iface == NULL)
  611. return NULL;
  612. hapd = wpa_s->ap_iface->bss[0];
  613. return hapd->conf->ap_pin;
  614. }
  615. int wpas_wps_ap_pin_set(struct wpa_supplicant *wpa_s, const char *pin,
  616. int timeout)
  617. {
  618. struct hostapd_data *hapd;
  619. char pin_txt[9];
  620. int ret;
  621. if (wpa_s->ap_iface == NULL)
  622. return -1;
  623. hapd = wpa_s->ap_iface->bss[0];
  624. ret = os_snprintf(pin_txt, sizeof(pin_txt), "%s", pin);
  625. if (ret < 0 || ret >= (int) sizeof(pin_txt))
  626. return -1;
  627. os_free(hapd->conf->ap_pin);
  628. hapd->conf->ap_pin = os_strdup(pin_txt);
  629. if (hapd->conf->ap_pin == NULL)
  630. return -1;
  631. wpas_wps_ap_pin_enable(wpa_s, timeout);
  632. return 0;
  633. }
  634. void wpa_supplicant_ap_pwd_auth_fail(struct wpa_supplicant *wpa_s)
  635. {
  636. struct hostapd_data *hapd;
  637. if (wpa_s->ap_iface == NULL)
  638. return;
  639. hapd = wpa_s->ap_iface->bss[0];
  640. /*
  641. * Registrar failed to prove its knowledge of the AP PIN. Disable AP
  642. * PIN if this happens multiple times to slow down brute force attacks.
  643. */
  644. hapd->ap_pin_failures++;
  645. wpa_printf(MSG_DEBUG, "WPS: AP PIN authentication failure number %u",
  646. hapd->ap_pin_failures);
  647. if (hapd->ap_pin_failures < 3)
  648. return;
  649. wpa_printf(MSG_DEBUG, "WPS: Disable AP PIN");
  650. hapd->ap_pin_failures = 0;
  651. os_free(hapd->conf->ap_pin);
  652. hapd->conf->ap_pin = NULL;
  653. }
  654. #endif /* CONFIG_WPS */
  655. #ifdef CONFIG_CTRL_IFACE
  656. int ap_ctrl_iface_sta_first(struct wpa_supplicant *wpa_s,
  657. char *buf, size_t buflen)
  658. {
  659. if (wpa_s->ap_iface == NULL)
  660. return -1;
  661. return hostapd_ctrl_iface_sta_first(wpa_s->ap_iface->bss[0],
  662. buf, buflen);
  663. }
  664. int ap_ctrl_iface_sta(struct wpa_supplicant *wpa_s, const char *txtaddr,
  665. char *buf, size_t buflen)
  666. {
  667. if (wpa_s->ap_iface == NULL)
  668. return -1;
  669. return hostapd_ctrl_iface_sta(wpa_s->ap_iface->bss[0], txtaddr,
  670. buf, buflen);
  671. }
  672. int ap_ctrl_iface_sta_next(struct wpa_supplicant *wpa_s, const char *txtaddr,
  673. char *buf, size_t buflen)
  674. {
  675. if (wpa_s->ap_iface == NULL)
  676. return -1;
  677. return hostapd_ctrl_iface_sta_next(wpa_s->ap_iface->bss[0], txtaddr,
  678. buf, buflen);
  679. }
  680. int ap_ctrl_iface_wpa_get_status(struct wpa_supplicant *wpa_s, char *buf,
  681. size_t buflen, int verbose)
  682. {
  683. char *pos = buf, *end = buf + buflen;
  684. int ret;
  685. struct hostapd_bss_config *conf;
  686. if (wpa_s->ap_iface == NULL)
  687. return -1;
  688. conf = wpa_s->ap_iface->bss[0]->conf;
  689. if (conf->wpa == 0)
  690. return 0;
  691. ret = os_snprintf(pos, end - pos,
  692. "pairwise_cipher=%s\n"
  693. "group_cipher=%s\n"
  694. "key_mgmt=%s\n",
  695. wpa_cipher_txt(conf->rsn_pairwise),
  696. wpa_cipher_txt(conf->wpa_group),
  697. wpa_key_mgmt_txt(conf->wpa_key_mgmt,
  698. conf->wpa));
  699. if (ret < 0 || ret >= end - pos)
  700. return pos - buf;
  701. pos += ret;
  702. return pos - buf;
  703. }
  704. #endif /* CONFIG_CTRL_IFACE */
  705. int wpa_supplicant_ap_update_beacon(struct wpa_supplicant *wpa_s)
  706. {
  707. struct hostapd_iface *iface = wpa_s->ap_iface;
  708. struct wpa_ssid *ssid = wpa_s->current_ssid;
  709. struct hostapd_data *hapd;
  710. if (ssid == NULL || wpa_s->ap_iface == NULL)
  711. return -1;
  712. #ifdef CONFIG_P2P
  713. if (ssid->mode == WPAS_MODE_P2P_GO)
  714. iface->conf->bss[0].p2p = P2P_ENABLED | P2P_GROUP_OWNER;
  715. else if (ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION)
  716. iface->conf->bss[0].p2p = P2P_ENABLED | P2P_GROUP_OWNER |
  717. P2P_GROUP_FORMATION;
  718. #endif /* CONFIG_P2P */
  719. ieee802_11_set_beacons(iface);
  720. hapd = iface->bss[0];
  721. hostapd_set_ap_wps_ie(hapd);
  722. return 0;
  723. }
  724. int wpa_supplicant_ap_mac_addr_filter(struct wpa_supplicant *wpa_s,
  725. const u8 *addr)
  726. {
  727. struct hostapd_data *hapd;
  728. struct hostapd_bss_config *conf;
  729. if (!wpa_s->ap_iface)
  730. return -1;
  731. if (addr)
  732. wpa_printf(MSG_DEBUG, "AP: Set MAC address filter: " MACSTR,
  733. MAC2STR(addr));
  734. else
  735. wpa_printf(MSG_DEBUG, "AP: Clear MAC address filter");
  736. hapd = wpa_s->ap_iface->bss[0];
  737. conf = hapd->conf;
  738. os_free(conf->accept_mac);
  739. conf->accept_mac = NULL;
  740. conf->num_accept_mac = 0;
  741. os_free(conf->deny_mac);
  742. conf->deny_mac = NULL;
  743. conf->num_deny_mac = 0;
  744. if (addr == NULL) {
  745. conf->macaddr_acl = ACCEPT_UNLESS_DENIED;
  746. return 0;
  747. }
  748. conf->macaddr_acl = DENY_UNLESS_ACCEPTED;
  749. conf->accept_mac = os_zalloc(sizeof(struct mac_acl_entry));
  750. if (conf->accept_mac == NULL)
  751. return -1;
  752. os_memcpy(conf->accept_mac[0].addr, addr, ETH_ALEN);
  753. conf->num_accept_mac = 1;
  754. return 0;
  755. }