1 /*
2 * aidl interface for wpa_hostapd daemon
3 * Copyright (c) 2004-2018, Jouni Malinen <j@w1.fi>
4 * Copyright (c) 2004-2018, Roshan Pius <rpius@google.com>
5 *
6 * This software may be distributed under the terms of the BSD license.
7 * See README for more details.
8 */
9 #include <iomanip>
10 #include <sstream>
11 #include <string>
12 #include <vector>
13 #include <net/if.h>
14 #include <sys/socket.h>
15 #include <linux/if_bridge.h>
16
17 #include <android-base/file.h>
18 #include <android-base/stringprintf.h>
19 #include <android-base/unique_fd.h>
20
21 #include "hostapd.h"
22 #include <aidl/android/hardware/wifi/hostapd/ApInfo.h>
23 #include <aidl/android/hardware/wifi/hostapd/BandMask.h>
24 #include <aidl/android/hardware/wifi/hostapd/ChannelParams.h>
25 #include <aidl/android/hardware/wifi/hostapd/ClientInfo.h>
26 #include <aidl/android/hardware/wifi/hostapd/EncryptionType.h>
27 #include <aidl/android/hardware/wifi/hostapd/HostapdStatusCode.h>
28 #include <aidl/android/hardware/wifi/hostapd/IfaceParams.h>
29 #include <aidl/android/hardware/wifi/hostapd/NetworkParams.h>
30 #include <aidl/android/hardware/wifi/hostapd/ParamSizeLimits.h>
31
32 extern "C"
33 {
34 #include "common/wpa_ctrl.h"
35 #include "drivers/linux_ioctl.h"
36 }
37
38 // The AIDL implementation for hostapd creates a hostapd.conf dynamically for
39 // each interface. This file can then be used to hook onto the normal config
40 // file parsing logic in hostapd code. Helps us to avoid duplication of code
41 // in the AIDL interface.
42 // TOOD(b/71872409): Add unit tests for this.
43 namespace {
44 constexpr char kConfFileNameFmt[] = "/data/vendor/wifi/hostapd/hostapd_%s.conf";
45
46 using android::base::RemoveFileIfExists;
47 using android::base::StringPrintf;
48 using android::base::WriteStringToFile;
49 using aidl::android::hardware::wifi::hostapd::BandMask;
50 using aidl::android::hardware::wifi::hostapd::ChannelBandwidth;
51 using aidl::android::hardware::wifi::hostapd::ChannelParams;
52 using aidl::android::hardware::wifi::hostapd::EncryptionType;
53 using aidl::android::hardware::wifi::hostapd::Generation;
54 using aidl::android::hardware::wifi::hostapd::HostapdStatusCode;
55 using aidl::android::hardware::wifi::hostapd::IfaceParams;
56 using aidl::android::hardware::wifi::hostapd::NetworkParams;
57 using aidl::android::hardware::wifi::hostapd::ParamSizeLimits;
58
59 int band2Ghz = (int)BandMask::BAND_2_GHZ;
60 int band5Ghz = (int)BandMask::BAND_5_GHZ;
61 int band6Ghz = (int)BandMask::BAND_6_GHZ;
62 int band60Ghz = (int)BandMask::BAND_60_GHZ;
63
64 #define MAX_PORTS 1024
GetInterfacesInBridge(std::string br_name,std::vector<std::string> * interfaces)65 bool GetInterfacesInBridge(std::string br_name,
66 std::vector<std::string>* interfaces) {
67 android::base::unique_fd sock(socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0));
68 if (sock.get() < 0) {
69 wpa_printf(MSG_ERROR, "Failed to create sock (%s) in %s",
70 strerror(errno), __FUNCTION__);
71 return false;
72 }
73
74 struct ifreq request;
75 int i, ifindices[MAX_PORTS];
76 char if_name[IFNAMSIZ];
77 unsigned long args[3];
78
79 memset(ifindices, 0, MAX_PORTS * sizeof(int));
80
81 args[0] = BRCTL_GET_PORT_LIST;
82 args[1] = (unsigned long) ifindices;
83 args[2] = MAX_PORTS;
84
85 strlcpy(request.ifr_name, br_name.c_str(), IFNAMSIZ);
86 request.ifr_data = (char *)args;
87
88 if (ioctl(sock.get(), SIOCDEVPRIVATE, &request) < 0) {
89 wpa_printf(MSG_ERROR, "Failed to ioctl SIOCDEVPRIVATE in %s",
90 __FUNCTION__);
91 return false;
92 }
93
94 for (i = 0; i < MAX_PORTS; i ++) {
95 memset(if_name, 0, IFNAMSIZ);
96 if (ifindices[i] == 0 || !if_indextoname(ifindices[i], if_name)) {
97 continue;
98 }
99 interfaces->push_back(if_name);
100 }
101 return true;
102 }
103
WriteHostapdConfig(const std::string & interface_name,const std::string & config)104 std::string WriteHostapdConfig(
105 const std::string& interface_name, const std::string& config)
106 {
107 const std::string file_path =
108 StringPrintf(kConfFileNameFmt, interface_name.c_str());
109 if (WriteStringToFile(
110 config, file_path, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
111 getuid(), getgid())) {
112 return file_path;
113 }
114 // Diagnose failure
115 int error = errno;
116 wpa_printf(
117 MSG_ERROR, "Cannot write hostapd config to %s, error: %s",
118 file_path.c_str(), strerror(error));
119 struct stat st;
120 int result = stat(file_path.c_str(), &st);
121 if (result == 0) {
122 wpa_printf(
123 MSG_ERROR, "hostapd config file uid: %d, gid: %d, mode: %d",
124 st.st_uid, st.st_gid, st.st_mode);
125 } else {
126 wpa_printf(
127 MSG_ERROR,
128 "Error calling stat() on hostapd config file: %s",
129 strerror(errno));
130 }
131 return "";
132 }
133
134 /*
135 * Get the op_class for a channel/band
136 * The logic here is based on Table E-4 in the 802.11 Specification
137 */
getOpClassForChannel(int channel,int band,bool support11n,bool support11ac)138 int getOpClassForChannel(int channel, int band, bool support11n, bool support11ac) {
139 // 2GHz Band
140 if ((band & band2Ghz) != 0) {
141 if (channel == 14) {
142 return 82;
143 }
144 if (channel >= 1 && channel <= 13) {
145 if (!support11n) {
146 //20MHz channel
147 return 81;
148 }
149 if (channel <= 9) {
150 // HT40 with secondary channel above primary
151 return 83;
152 }
153 // HT40 with secondary channel below primary
154 return 84;
155 }
156 // Error
157 return 0;
158 }
159
160 // 5GHz Band
161 if ((band & band5Ghz) != 0) {
162 if (support11ac) {
163 switch (channel) {
164 case 42:
165 case 58:
166 case 106:
167 case 122:
168 case 138:
169 case 155:
170 // 80MHz channel
171 return 128;
172 case 50:
173 case 114:
174 // 160MHz channel
175 return 129;
176 }
177 }
178
179 if (!support11n) {
180 if (channel >= 36 && channel <= 48) {
181 return 115;
182 }
183 if (channel >= 52 && channel <= 64) {
184 return 118;
185 }
186 if (channel >= 100 && channel <= 144) {
187 return 121;
188 }
189 if (channel >= 149 && channel <= 161) {
190 return 124;
191 }
192 if (channel >= 165 && channel <= 169) {
193 return 125;
194 }
195 } else {
196 switch (channel) {
197 case 36:
198 case 44:
199 // HT40 with secondary channel above primary
200 return 116;
201 case 40:
202 case 48:
203 // HT40 with secondary channel below primary
204 return 117;
205 case 52:
206 case 60:
207 // HT40 with secondary channel above primary
208 return 119;
209 case 56:
210 case 64:
211 // HT40 with secondary channel below primary
212 return 120;
213 case 100:
214 case 108:
215 case 116:
216 case 124:
217 case 132:
218 case 140:
219 // HT40 with secondary channel above primary
220 return 122;
221 case 104:
222 case 112:
223 case 120:
224 case 128:
225 case 136:
226 case 144:
227 // HT40 with secondary channel below primary
228 return 123;
229 case 149:
230 case 157:
231 // HT40 with secondary channel above primary
232 return 126;
233 case 153:
234 case 161:
235 // HT40 with secondary channel below primary
236 return 127;
237 }
238 }
239 // Error
240 return 0;
241 }
242
243 // 6GHz Band
244 if ((band & band6Ghz) != 0) {
245 // Channels 1, 5. 9, 13, ...
246 if ((channel & 0x03) == 0x01) {
247 // 20MHz channel
248 return 131;
249 }
250 // Channels 3, 11, 19, 27, ...
251 if ((channel & 0x07) == 0x03) {
252 // 40MHz channel
253 return 132;
254 }
255 // Channels 7, 23, 39, 55, ...
256 if ((channel & 0x0F) == 0x07) {
257 // 80MHz channel
258 return 133;
259 }
260 // Channels 15, 47, 69, ...
261 if ((channel & 0x1F) == 0x0F) {
262 // 160MHz channel
263 return 134;
264 }
265 if (channel == 2) {
266 // 20MHz channel
267 return 136;
268 }
269 // Error
270 return 0;
271 }
272
273 if ((band & band60Ghz) != 0) {
274 if (1 <= channel && channel <= 8) {
275 return 180;
276 } else if (9 <= channel && channel <= 15) {
277 return 181;
278 } else if (17 <= channel && channel <= 22) {
279 return 182;
280 } else if (25 <= channel && channel <= 29) {
281 return 183;
282 }
283 // Error
284 return 0;
285 }
286
287 return 0;
288 }
289
validatePassphrase(int passphrase_len,int min_len,int max_len)290 bool validatePassphrase(int passphrase_len, int min_len, int max_len)
291 {
292 if (min_len != -1 && passphrase_len < min_len) return false;
293 if (max_len != -1 && passphrase_len > max_len) return false;
294 return true;
295 }
296
CreateHostapdConfig(const IfaceParams & iface_params,const ChannelParams & channelParams,const NetworkParams & nw_params,const std::string br_name,const std::string owe_transition_ifname)297 std::string CreateHostapdConfig(
298 const IfaceParams& iface_params,
299 const ChannelParams& channelParams,
300 const NetworkParams& nw_params,
301 const std::string br_name,
302 const std::string owe_transition_ifname)
303 {
304 if (nw_params.ssid.size() >
305 static_cast<uint32_t>(
306 ParamSizeLimits::SSID_MAX_LEN_IN_BYTES)) {
307 wpa_printf(
308 MSG_ERROR, "Invalid SSID size: %zu", nw_params.ssid.size());
309 return "";
310 }
311
312 // SSID string
313 std::stringstream ss;
314 ss << std::hex;
315 ss << std::setfill('0');
316 for (uint8_t b : nw_params.ssid) {
317 ss << std::setw(2) << static_cast<unsigned int>(b);
318 }
319 const std::string ssid_as_string = ss.str();
320
321 // Encryption config string
322 uint32_t band = 0;
323 band |= static_cast<uint32_t>(channelParams.bandMask);
324 bool is_2Ghz_band_only = band == static_cast<uint32_t>(band2Ghz);
325 bool is_6Ghz_band_only = band == static_cast<uint32_t>(band6Ghz);
326 bool is_60Ghz_band_only = band == static_cast<uint32_t>(band60Ghz);
327 std::string encryption_config_as_string;
328 switch (nw_params.encryptionType) {
329 case EncryptionType::NONE:
330 // no security params
331 break;
332 case EncryptionType::WPA:
333 if (!validatePassphrase(
334 nw_params.passphrase.size(),
335 static_cast<uint32_t>(ParamSizeLimits::
336 WPA2_PSK_PASSPHRASE_MIN_LEN_IN_BYTES),
337 static_cast<uint32_t>(ParamSizeLimits::
338 WPA2_PSK_PASSPHRASE_MAX_LEN_IN_BYTES))) {
339 return "";
340 }
341 encryption_config_as_string = StringPrintf(
342 "wpa=3\n"
343 "wpa_pairwise=%s\n"
344 "wpa_passphrase=%s",
345 is_60Ghz_band_only ? "GCMP" : "TKIP CCMP",
346 nw_params.passphrase.c_str());
347 break;
348 case EncryptionType::WPA2:
349 if (!validatePassphrase(
350 nw_params.passphrase.size(),
351 static_cast<uint32_t>(ParamSizeLimits::
352 WPA2_PSK_PASSPHRASE_MIN_LEN_IN_BYTES),
353 static_cast<uint32_t>(ParamSizeLimits::
354 WPA2_PSK_PASSPHRASE_MAX_LEN_IN_BYTES))) {
355 return "";
356 }
357 encryption_config_as_string = StringPrintf(
358 "wpa=2\n"
359 "rsn_pairwise=%s\n"
360 #ifdef ENABLE_HOSTAPD_CONFIG_80211W_MFP_OPTIONAL
361 "ieee80211w=1\n"
362 #endif
363 "wpa_passphrase=%s",
364 is_60Ghz_band_only ? "GCMP" : "CCMP",
365 nw_params.passphrase.c_str());
366 break;
367 case EncryptionType::WPA3_SAE_TRANSITION:
368 if (!validatePassphrase(
369 nw_params.passphrase.size(),
370 static_cast<uint32_t>(ParamSizeLimits::
371 WPA2_PSK_PASSPHRASE_MIN_LEN_IN_BYTES),
372 static_cast<uint32_t>(ParamSizeLimits::
373 WPA2_PSK_PASSPHRASE_MAX_LEN_IN_BYTES))) {
374 return "";
375 }
376 // WPA3 transition mode or SAE+WPA_PSK key management(AKM) is not allowed in 6GHz.
377 // Auto-convert any such configurations to SAE.
378 if ((band & band6Ghz) != 0) {
379 wpa_printf(MSG_INFO, "WPA3_SAE_TRANSITION configured in 6GHz band."
380 "Enable only SAE in key_mgmt");
381 encryption_config_as_string = StringPrintf(
382 "wpa=2\n"
383 "rsn_pairwise=CCMP\n"
384 "wpa_key_mgmt=%s\n"
385 "ieee80211w=2\n"
386 "sae_require_mfp=2\n"
387 "sae_pwe=%d\n"
388 "sae_password=%s",
389 #ifdef CONFIG_IEEE80211BE
390 iface_params.hwModeParams.enable80211BE ?
391 "SAE SAE-EXT-KEY" : "SAE",
392 #else
393 "SAE",
394 #endif
395 is_6Ghz_band_only ? 1 : 2,
396 nw_params.passphrase.c_str());
397 } else {
398 encryption_config_as_string = StringPrintf(
399 "wpa=2\n"
400 "rsn_pairwise=%s\n"
401 "wpa_key_mgmt=%s\n"
402 "ieee80211w=1\n"
403 "sae_require_mfp=1\n"
404 "wpa_passphrase=%s\n"
405 "sae_password=%s",
406 is_60Ghz_band_only ? "GCMP" : "CCMP",
407 #ifdef CONFIG_IEEE80211BE
408 iface_params.hwModeParams.enable80211BE ?
409 "WPA-PSK SAE SAE-EXT-KEY" : "WPA-PSK SAE",
410 #else
411 "WPA-PSK SAE",
412 #endif
413 nw_params.passphrase.c_str(),
414 nw_params.passphrase.c_str());
415 }
416 break;
417 case EncryptionType::WPA3_SAE:
418 if (!validatePassphrase(nw_params.passphrase.size(), 1, -1)) {
419 return "";
420 }
421 encryption_config_as_string = StringPrintf(
422 "wpa=2\n"
423 "rsn_pairwise=%s\n"
424 "wpa_key_mgmt=%s\n"
425 "ieee80211w=2\n"
426 "sae_require_mfp=2\n"
427 "sae_pwe=%d\n"
428 "sae_password=%s",
429 is_60Ghz_band_only ? "GCMP" : "CCMP",
430 #ifdef CONFIG_IEEE80211BE
431 iface_params.hwModeParams.enable80211BE ? "SAE SAE-EXT-KEY" : "SAE",
432 #else
433 "SAE",
434 #endif
435 is_6Ghz_band_only ? 1 : 2,
436 nw_params.passphrase.c_str());
437 break;
438 case EncryptionType::WPA3_OWE_TRANSITION:
439 encryption_config_as_string = StringPrintf(
440 "wpa=2\n"
441 "rsn_pairwise=%s\n"
442 "wpa_key_mgmt=OWE\n"
443 "ieee80211w=2",
444 is_60Ghz_band_only ? "GCMP" : "CCMP");
445 break;
446 case EncryptionType::WPA3_OWE:
447 encryption_config_as_string = StringPrintf(
448 "wpa=2\n"
449 "rsn_pairwise=%s\n"
450 "wpa_key_mgmt=OWE\n"
451 "ieee80211w=2",
452 is_60Ghz_band_only ? "GCMP" : "CCMP");
453 break;
454 default:
455 wpa_printf(MSG_ERROR, "Unknown encryption type");
456 return "";
457 }
458
459 std::string channel_config_as_string;
460 bool isFirst = true;
461 if (channelParams.enableAcs) {
462 std::string freqList_as_string;
463 for (const auto &range :
464 channelParams.acsChannelFreqRangesMhz) {
465 if (!isFirst) {
466 freqList_as_string += ",";
467 }
468 isFirst = false;
469
470 if (range.startMhz != range.endMhz) {
471 freqList_as_string +=
472 StringPrintf("%d-%d", range.startMhz, range.endMhz);
473 } else {
474 freqList_as_string += StringPrintf("%d", range.startMhz);
475 }
476 }
477 channel_config_as_string = StringPrintf(
478 "channel=0\n"
479 "acs_exclude_dfs=%d\n"
480 "freqlist=%s",
481 channelParams.acsShouldExcludeDfs,
482 freqList_as_string.c_str());
483 } else {
484 int op_class = getOpClassForChannel(
485 channelParams.channel,
486 band,
487 iface_params.hwModeParams.enable80211N,
488 iface_params.hwModeParams.enable80211AC);
489 channel_config_as_string = StringPrintf(
490 "channel=%d\n"
491 "op_class=%d",
492 channelParams.channel, op_class);
493 }
494
495 std::string hw_mode_as_string;
496 std::string enable_edmg_as_string;
497 std::string edmg_channel_as_string;
498 bool is_60Ghz_used = false;
499
500 if (((band & band60Ghz) != 0)) {
501 hw_mode_as_string = "hw_mode=ad";
502 if (iface_params.hwModeParams.enableEdmg) {
503 enable_edmg_as_string = "enable_edmg=1";
504 edmg_channel_as_string = StringPrintf(
505 "edmg_channel=%d",
506 channelParams.channel);
507 }
508 is_60Ghz_used = true;
509 } else if ((band & band2Ghz) != 0) {
510 if (((band & band5Ghz) != 0)
511 || ((band & band6Ghz) != 0)) {
512 hw_mode_as_string = "hw_mode=any";
513 } else {
514 hw_mode_as_string = "hw_mode=g";
515 }
516 } else if (((band & band5Ghz) != 0)
517 || ((band & band6Ghz) != 0)) {
518 hw_mode_as_string = "hw_mode=a";
519 } else {
520 wpa_printf(MSG_ERROR, "Invalid band");
521 return "";
522 }
523
524 std::string he_params_as_string;
525 #ifdef CONFIG_IEEE80211AX
526 if (iface_params.hwModeParams.enable80211AX && !is_60Ghz_used) {
527 he_params_as_string = StringPrintf(
528 "ieee80211ax=1\n"
529 "he_su_beamformer=%d\n"
530 "he_su_beamformee=%d\n"
531 "he_mu_beamformer=%d\n"
532 "he_twt_required=%d\n",
533 iface_params.hwModeParams.enableHeSingleUserBeamformer ? 1 : 0,
534 iface_params.hwModeParams.enableHeSingleUserBeamformee ? 1 : 0,
535 iface_params.hwModeParams.enableHeMultiUserBeamformer ? 1 : 0,
536 iface_params.hwModeParams.enableHeTargetWakeTime ? 1 : 0);
537 } else {
538 he_params_as_string = "ieee80211ax=0";
539 }
540 #endif /* CONFIG_IEEE80211AX */
541 std::string eht_params_as_string;
542 #ifdef CONFIG_IEEE80211BE
543 if (iface_params.hwModeParams.enable80211BE && !is_60Ghz_used) {
544 eht_params_as_string = "ieee80211be=1";
545 /* TODO set eht_su_beamformer, eht_su_beamformee, eht_mu_beamformer */
546 } else {
547 eht_params_as_string = "ieee80211be=0";
548 }
549 #endif /* CONFIG_IEEE80211BE */
550
551 std::string ht_cap_vht_oper_he_oper_chwidth_as_string;
552 switch (iface_params.hwModeParams.maximumChannelBandwidth) {
553 case ChannelBandwidth::BANDWIDTH_20:
554 ht_cap_vht_oper_he_oper_chwidth_as_string = StringPrintf(
555 #ifdef CONFIG_IEEE80211AX
556 "he_oper_chwidth=0\n"
557 #endif
558 "vht_oper_chwidth=0");
559 break;
560 case ChannelBandwidth::BANDWIDTH_40:
561 ht_cap_vht_oper_he_oper_chwidth_as_string = StringPrintf(
562 "ht_capab=[HT40+]\n"
563 #ifdef CONFIG_IEEE80211AX
564 "he_oper_chwidth=0\n"
565 #endif
566 "vht_oper_chwidth=0");
567 break;
568 case ChannelBandwidth::BANDWIDTH_80:
569 ht_cap_vht_oper_he_oper_chwidth_as_string = StringPrintf(
570 "ht_capab=[HT40+]\n"
571 #ifdef CONFIG_IEEE80211AX
572 "he_oper_chwidth=%d\n"
573 #endif
574 "vht_oper_chwidth=%d",
575 #ifdef CONFIG_IEEE80211AX
576 (iface_params.hwModeParams.enable80211AX && !is_60Ghz_used) ? 1 : 0,
577 #endif
578 iface_params.hwModeParams.enable80211AC ? 1 : 0);
579 break;
580 case ChannelBandwidth::BANDWIDTH_160:
581 ht_cap_vht_oper_he_oper_chwidth_as_string = StringPrintf(
582 "ht_capab=[HT40+]\n"
583 #ifdef CONFIG_IEEE80211AX
584 "he_oper_chwidth=%d\n"
585 #endif
586 "vht_oper_chwidth=%d",
587 #ifdef CONFIG_IEEE80211AX
588 (iface_params.hwModeParams.enable80211AX && !is_60Ghz_used) ? 2 : 0,
589 #endif
590 iface_params.hwModeParams.enable80211AC ? 2 : 0);
591 break;
592 default:
593 if (!is_2Ghz_band_only && !is_60Ghz_used) {
594 if (iface_params.hwModeParams.enable80211AC) {
595 ht_cap_vht_oper_he_oper_chwidth_as_string =
596 "ht_capab=[HT40+]\n"
597 "vht_oper_chwidth=1\n";
598 }
599 #ifdef CONFIG_IEEE80211AX
600 if (iface_params.hwModeParams.enable80211AX) {
601 ht_cap_vht_oper_he_oper_chwidth_as_string += "he_oper_chwidth=1";
602 }
603 #endif
604 }
605 break;
606 }
607
608 #ifdef CONFIG_INTERWORKING
609 std::string access_network_params_as_string;
610 if (nw_params.isMetered) {
611 access_network_params_as_string = StringPrintf(
612 "interworking=1\n"
613 "access_network_type=2\n"); // CHARGEABLE_PUBLIC_NETWORK
614 } else {
615 access_network_params_as_string = StringPrintf(
616 "interworking=0\n");
617 }
618 #endif /* CONFIG_INTERWORKING */
619
620 std::string bridge_as_string;
621 if (!br_name.empty()) {
622 bridge_as_string = StringPrintf("bridge=%s", br_name.c_str());
623 }
624
625 // vendor_elements string
626 std::string vendor_elements_as_string;
627 if (nw_params.vendorElements.size() > 0) {
628 std::stringstream ss;
629 ss << std::hex;
630 ss << std::setfill('0');
631 for (uint8_t b : nw_params.vendorElements) {
632 ss << std::setw(2) << static_cast<unsigned int>(b);
633 }
634 vendor_elements_as_string = StringPrintf("vendor_elements=%s", ss.str().c_str());
635 }
636
637 std::string owe_transition_ifname_as_string;
638 if (!owe_transition_ifname.empty()) {
639 owe_transition_ifname_as_string = StringPrintf(
640 "owe_transition_ifname=%s", owe_transition_ifname.c_str());
641 }
642
643 return StringPrintf(
644 "interface=%s\n"
645 "driver=nl80211\n"
646 "ctrl_interface=/data/vendor/wifi/hostapd/ctrl\n"
647 // ssid2 signals to hostapd that the value is not a literal value
648 // for use as a SSID. In this case, we're giving it a hex
649 // std::string and hostapd needs to expect that.
650 "ssid2=%s\n"
651 "%s\n"
652 "ieee80211n=%d\n"
653 "ieee80211ac=%d\n"
654 "%s\n"
655 "%s\n"
656 "%s\n"
657 "%s\n"
658 "ignore_broadcast_ssid=%d\n"
659 "wowlan_triggers=any\n"
660 #ifdef CONFIG_INTERWORKING
661 "%s\n"
662 #endif /* CONFIG_INTERWORKING */
663 "%s\n"
664 "%s\n"
665 "%s\n"
666 "%s\n"
667 "%s\n"
668 "%s\n",
669 iface_params.name.c_str(), ssid_as_string.c_str(),
670 channel_config_as_string.c_str(),
671 iface_params.hwModeParams.enable80211N ? 1 : 0,
672 iface_params.hwModeParams.enable80211AC ? 1 : 0,
673 he_params_as_string.c_str(),
674 eht_params_as_string.c_str(),
675 hw_mode_as_string.c_str(), ht_cap_vht_oper_he_oper_chwidth_as_string.c_str(),
676 nw_params.isHidden ? 1 : 0,
677 #ifdef CONFIG_INTERWORKING
678 access_network_params_as_string.c_str(),
679 #endif /* CONFIG_INTERWORKING */
680 encryption_config_as_string.c_str(),
681 bridge_as_string.c_str(),
682 owe_transition_ifname_as_string.c_str(),
683 enable_edmg_as_string.c_str(),
684 edmg_channel_as_string.c_str(),
685 vendor_elements_as_string.c_str());
686 }
687
getGeneration(hostapd_hw_modes * current_mode)688 Generation getGeneration(hostapd_hw_modes *current_mode)
689 {
690 wpa_printf(MSG_DEBUG, "getGeneration hwmode=%d, ht_enabled=%d,"
691 " vht_enabled=%d, he_supported=%d",
692 current_mode->mode, current_mode->ht_capab != 0,
693 current_mode->vht_capab != 0, current_mode->he_capab->he_supported);
694 switch (current_mode->mode) {
695 case HOSTAPD_MODE_IEEE80211B:
696 return Generation::WIFI_STANDARD_LEGACY;
697 case HOSTAPD_MODE_IEEE80211G:
698 return current_mode->ht_capab == 0 ?
699 Generation::WIFI_STANDARD_LEGACY : Generation::WIFI_STANDARD_11N;
700 case HOSTAPD_MODE_IEEE80211A:
701 if (current_mode->he_capab->he_supported) {
702 return Generation::WIFI_STANDARD_11AX;
703 }
704 return current_mode->vht_capab == 0 ?
705 Generation::WIFI_STANDARD_11N : Generation::WIFI_STANDARD_11AC;
706 case HOSTAPD_MODE_IEEE80211AD:
707 return Generation::WIFI_STANDARD_11AD;
708 default:
709 return Generation::WIFI_STANDARD_UNKNOWN;
710 }
711 }
712
getChannelBandwidth(struct hostapd_config * iconf)713 ChannelBandwidth getChannelBandwidth(struct hostapd_config *iconf)
714 {
715 wpa_printf(MSG_DEBUG, "getChannelBandwidth %d, isHT=%d, isHT40=%d",
716 iconf->vht_oper_chwidth, iconf->ieee80211n,
717 iconf->secondary_channel);
718 switch (iconf->vht_oper_chwidth) {
719 case CONF_OPER_CHWIDTH_80MHZ:
720 return ChannelBandwidth::BANDWIDTH_80;
721 case CONF_OPER_CHWIDTH_80P80MHZ:
722 return ChannelBandwidth::BANDWIDTH_80P80;
723 break;
724 case CONF_OPER_CHWIDTH_160MHZ:
725 return ChannelBandwidth::BANDWIDTH_160;
726 break;
727 case CONF_OPER_CHWIDTH_USE_HT:
728 if (iconf->ieee80211n) {
729 return iconf->secondary_channel != 0 ?
730 ChannelBandwidth::BANDWIDTH_40 : ChannelBandwidth::BANDWIDTH_20;
731 }
732 return ChannelBandwidth::BANDWIDTH_20_NOHT;
733 case CONF_OPER_CHWIDTH_2160MHZ:
734 return ChannelBandwidth::BANDWIDTH_2160;
735 case CONF_OPER_CHWIDTH_4320MHZ:
736 return ChannelBandwidth::BANDWIDTH_4320;
737 case CONF_OPER_CHWIDTH_6480MHZ:
738 return ChannelBandwidth::BANDWIDTH_6480;
739 case CONF_OPER_CHWIDTH_8640MHZ:
740 return ChannelBandwidth::BANDWIDTH_8640;
741 default:
742 return ChannelBandwidth::BANDWIDTH_INVALID;
743 }
744 }
745
forceStaDisconnection(struct hostapd_data * hapd,const std::vector<uint8_t> & client_address,const uint16_t reason_code)746 bool forceStaDisconnection(struct hostapd_data* hapd,
747 const std::vector<uint8_t>& client_address,
748 const uint16_t reason_code) {
749 struct sta_info *sta;
750 if (client_address.size() != ETH_ALEN) {
751 return false;
752 }
753 for (sta = hapd->sta_list; sta; sta = sta->next) {
754 int res;
755 res = memcmp(sta->addr, client_address.data(), ETH_ALEN);
756 if (res == 0) {
757 wpa_printf(MSG_INFO, "Force client:" MACSTR " disconnect with reason: %d",
758 MAC2STR(client_address.data()), reason_code);
759 ap_sta_disconnect(hapd, sta, sta->addr, reason_code);
760 return true;
761 }
762 }
763 return false;
764 }
765
766 // hostapd core functions accept "C" style function pointers, so use global
767 // functions to pass to the hostapd core function and store the corresponding
768 // std::function methods to be invoked.
769 //
770 // NOTE: Using the pattern from the vendor HAL (wifi_legacy_hal.cpp).
771 //
772 // Callback to be invoked once setup is complete
773 std::function<void(struct hostapd_data*)> on_setup_complete_internal_callback;
onAsyncSetupCompleteCb(void * ctx)774 void onAsyncSetupCompleteCb(void* ctx)
775 {
776 struct hostapd_data* iface_hapd = (struct hostapd_data*)ctx;
777 if (on_setup_complete_internal_callback) {
778 on_setup_complete_internal_callback(iface_hapd);
779 // Invalidate this callback since we don't want this firing
780 // again in single AP mode.
781 if (strlen(iface_hapd->conf->bridge) > 0) {
782 on_setup_complete_internal_callback = nullptr;
783 }
784 }
785 }
786
787 // Callback to be invoked on hotspot client connection/disconnection
788 std::function<void(struct hostapd_data*, const u8 *mac_addr, int authorized,
789 const u8 *p2p_dev_addr)> on_sta_authorized_internal_callback;
onAsyncStaAuthorizedCb(void * ctx,const u8 * mac_addr,int authorized,const u8 * p2p_dev_addr)790 void onAsyncStaAuthorizedCb(void* ctx, const u8 *mac_addr, int authorized,
791 const u8 *p2p_dev_addr)
792 {
793 struct hostapd_data* iface_hapd = (struct hostapd_data*)ctx;
794 if (on_sta_authorized_internal_callback) {
795 on_sta_authorized_internal_callback(iface_hapd, mac_addr,
796 authorized, p2p_dev_addr);
797 }
798 }
799
800 std::function<void(struct hostapd_data*, int level,
801 enum wpa_msg_type type, const char *txt,
802 size_t len)> on_wpa_msg_internal_callback;
803
onAsyncWpaEventCb(void * ctx,int level,enum wpa_msg_type type,const char * txt,size_t len)804 void onAsyncWpaEventCb(void *ctx, int level,
805 enum wpa_msg_type type, const char *txt,
806 size_t len)
807 {
808 struct hostapd_data* iface_hapd = (struct hostapd_data*)ctx;
809 if (on_wpa_msg_internal_callback) {
810 on_wpa_msg_internal_callback(iface_hapd, level,
811 type, txt, len);
812 }
813 }
814
createStatus(HostapdStatusCode status_code)815 inline ndk::ScopedAStatus createStatus(HostapdStatusCode status_code) {
816 return ndk::ScopedAStatus::fromServiceSpecificError(
817 static_cast<int32_t>(status_code));
818 }
819
createStatusWithMsg(HostapdStatusCode status_code,std::string msg)820 inline ndk::ScopedAStatus createStatusWithMsg(
821 HostapdStatusCode status_code, std::string msg)
822 {
823 return ndk::ScopedAStatus::fromServiceSpecificErrorWithMessage(
824 static_cast<int32_t>(status_code), msg.c_str());
825 }
826
827 // Method called by death_notifier_ on client death.
onDeath(void * cookie)828 void onDeath(void* cookie) {
829 wpa_printf(MSG_ERROR, "Client died. Terminating...");
830 eloop_terminate();
831 }
832
833 } // namespace
834
835 namespace aidl {
836 namespace android {
837 namespace hardware {
838 namespace wifi {
839 namespace hostapd {
840
Hostapd(struct hapd_interfaces * interfaces)841 Hostapd::Hostapd(struct hapd_interfaces* interfaces)
842 : interfaces_(interfaces)
843 {
844 death_notifier_ = AIBinder_DeathRecipient_new(onDeath);
845 }
846
addAccessPoint(const IfaceParams & iface_params,const NetworkParams & nw_params)847 ::ndk::ScopedAStatus Hostapd::addAccessPoint(
848 const IfaceParams& iface_params, const NetworkParams& nw_params)
849 {
850 return addAccessPointInternal(iface_params, nw_params);
851 }
852
removeAccessPoint(const std::string & iface_name)853 ::ndk::ScopedAStatus Hostapd::removeAccessPoint(const std::string& iface_name)
854 {
855 return removeAccessPointInternal(iface_name);
856 }
857
terminate()858 ::ndk::ScopedAStatus Hostapd::terminate()
859 {
860 wpa_printf(MSG_INFO, "Terminating...");
861 // Clear the callback to avoid IPCThreadState shutdown during the
862 // callback event.
863 callbacks_.clear();
864 eloop_terminate();
865 return ndk::ScopedAStatus::ok();
866 }
867
registerCallback(const std::shared_ptr<IHostapdCallback> & callback)868 ::ndk::ScopedAStatus Hostapd::registerCallback(
869 const std::shared_ptr<IHostapdCallback>& callback)
870 {
871 return registerCallbackInternal(callback);
872 }
873
forceClientDisconnect(const std::string & iface_name,const std::vector<uint8_t> & client_address,Ieee80211ReasonCode reason_code)874 ::ndk::ScopedAStatus Hostapd::forceClientDisconnect(
875 const std::string& iface_name, const std::vector<uint8_t>& client_address,
876 Ieee80211ReasonCode reason_code)
877 {
878 return forceClientDisconnectInternal(iface_name, client_address, reason_code);
879 }
880
setDebugParams(DebugLevel level)881 ::ndk::ScopedAStatus Hostapd::setDebugParams(DebugLevel level)
882 {
883 return setDebugParamsInternal(level);
884 }
885
addAccessPointInternal(const IfaceParams & iface_params,const NetworkParams & nw_params)886 ::ndk::ScopedAStatus Hostapd::addAccessPointInternal(
887 const IfaceParams& iface_params,
888 const NetworkParams& nw_params)
889 {
890 int channelParamsSize = iface_params.channelParams.size();
891 if (channelParamsSize == 1) {
892 // Single AP
893 wpa_printf(MSG_INFO, "AddSingleAccessPoint, iface=%s",
894 iface_params.name.c_str());
895 return addSingleAccessPoint(iface_params, iface_params.channelParams[0],
896 nw_params, "", "");
897 } else if (channelParamsSize == 2) {
898 // Concurrent APs
899 wpa_printf(MSG_INFO, "AddDualAccessPoint, iface=%s",
900 iface_params.name.c_str());
901 return addConcurrentAccessPoints(iface_params, nw_params);
902 }
903 return createStatus(HostapdStatusCode::FAILURE_ARGS_INVALID);
904 }
905
generateRandomOweSsid()906 std::vector<uint8_t> generateRandomOweSsid()
907 {
908 u8 random[8] = {0};
909 os_get_random(random, 8);
910
911 std::string ssid = StringPrintf("Owe-%s", random);
912 wpa_printf(MSG_INFO, "Generated OWE SSID: %s", ssid.c_str());
913 std::vector<uint8_t> vssid(ssid.begin(), ssid.end());
914
915 return vssid;
916 }
917
addConcurrentAccessPoints(const IfaceParams & iface_params,const NetworkParams & nw_params)918 ::ndk::ScopedAStatus Hostapd::addConcurrentAccessPoints(
919 const IfaceParams& iface_params, const NetworkParams& nw_params)
920 {
921 int channelParamsListSize = iface_params.channelParams.size();
922 // Get available interfaces in bridge
923 std::vector<std::string> managed_interfaces;
924 std::string br_name = StringPrintf(
925 "%s", iface_params.name.c_str());
926 if (!GetInterfacesInBridge(br_name, &managed_interfaces)) {
927 return createStatusWithMsg(HostapdStatusCode::FAILURE_UNKNOWN,
928 "Get interfaces in bridge failed.");
929 }
930 if (managed_interfaces.size() < channelParamsListSize) {
931 return createStatusWithMsg(HostapdStatusCode::FAILURE_UNKNOWN,
932 "Available interfaces less than requested bands");
933 }
934 // start BSS on specified bands
935 for (std::size_t i = 0; i < channelParamsListSize; i ++) {
936 IfaceParams iface_params_new = iface_params;
937 NetworkParams nw_params_new = nw_params;
938 iface_params_new.name = managed_interfaces[i];
939
940 std::string owe_transition_ifname = "";
941 if (nw_params.encryptionType == EncryptionType::WPA3_OWE_TRANSITION) {
942 if (i == 0 && i+1 < channelParamsListSize) {
943 owe_transition_ifname = managed_interfaces[i+1];
944 nw_params_new.encryptionType = EncryptionType::NONE;
945 } else {
946 owe_transition_ifname = managed_interfaces[0];
947 nw_params_new.isHidden = true;
948 nw_params_new.ssid = generateRandomOweSsid();
949 }
950 }
951
952 ndk::ScopedAStatus status = addSingleAccessPoint(
953 iface_params_new, iface_params.channelParams[i], nw_params_new,
954 br_name, owe_transition_ifname);
955 if (!status.isOk()) {
956 wpa_printf(MSG_ERROR, "Failed to addAccessPoint %s",
957 managed_interfaces[i].c_str());
958 return status;
959 }
960 }
961 // Save bridge interface info
962 br_interfaces_[br_name] = managed_interfaces;
963 return ndk::ScopedAStatus::ok();
964 }
965
addSingleAccessPoint(const IfaceParams & iface_params,const ChannelParams & channelParams,const NetworkParams & nw_params,const std::string br_name,const std::string owe_transition_ifname)966 ::ndk::ScopedAStatus Hostapd::addSingleAccessPoint(
967 const IfaceParams& iface_params,
968 const ChannelParams& channelParams,
969 const NetworkParams& nw_params,
970 const std::string br_name,
971 const std::string owe_transition_ifname)
972 {
973 if (hostapd_get_iface(interfaces_, iface_params.name.c_str())) {
974 wpa_printf(
975 MSG_ERROR, "Interface %s already present",
976 iface_params.name.c_str());
977 return createStatus(HostapdStatusCode::FAILURE_IFACE_EXISTS);
978 }
979 const auto conf_params = CreateHostapdConfig(iface_params, channelParams, nw_params,
980 br_name, owe_transition_ifname);
981 if (conf_params.empty()) {
982 wpa_printf(MSG_ERROR, "Failed to create config params");
983 return createStatus(HostapdStatusCode::FAILURE_ARGS_INVALID);
984 }
985 const auto conf_file_path =
986 WriteHostapdConfig(iface_params.name, conf_params);
987 if (conf_file_path.empty()) {
988 wpa_printf(MSG_ERROR, "Failed to write config file");
989 return createStatus(HostapdStatusCode::FAILURE_UNKNOWN);
990 }
991 std::string add_iface_param_str = StringPrintf(
992 "%s config=%s", iface_params.name.c_str(),
993 conf_file_path.c_str());
994 std::vector<char> add_iface_param_vec(
995 add_iface_param_str.begin(), add_iface_param_str.end() + 1);
996 if (hostapd_add_iface(interfaces_, add_iface_param_vec.data()) < 0) {
997 wpa_printf(
998 MSG_ERROR, "Adding interface %s failed",
999 add_iface_param_str.c_str());
1000 return createStatus(HostapdStatusCode::FAILURE_UNKNOWN);
1001 }
1002 struct hostapd_data* iface_hapd =
1003 hostapd_get_iface(interfaces_, iface_params.name.c_str());
1004 WPA_ASSERT(iface_hapd != nullptr && iface_hapd->iface != nullptr);
1005 // Register the setup complete callbacks
1006 on_setup_complete_internal_callback =
1007 [this](struct hostapd_data* iface_hapd) {
1008 wpa_printf(
1009 MSG_INFO, "AP interface setup completed - state %s",
1010 hostapd_state_text(iface_hapd->iface->state));
1011 if (iface_hapd->iface->state == HAPD_IFACE_DISABLED) {
1012 // Invoke the failure callback on all registered
1013 // clients.
1014 for (const auto& callback : callbacks_) {
1015 callback->onFailure(strlen(iface_hapd->conf->bridge) > 0 ?
1016 iface_hapd->conf->bridge : iface_hapd->conf->iface,
1017 iface_hapd->conf->iface);
1018 }
1019 }
1020 };
1021
1022 // Register for new client connect/disconnect indication.
1023 on_sta_authorized_internal_callback =
1024 [this](struct hostapd_data* iface_hapd, const u8 *mac_addr,
1025 int authorized, const u8 *p2p_dev_addr) {
1026 wpa_printf(MSG_DEBUG, "notify client " MACSTR " %s",
1027 MAC2STR(mac_addr),
1028 (authorized) ? "Connected" : "Disconnected");
1029 ClientInfo info;
1030 info.ifaceName = strlen(iface_hapd->conf->bridge) > 0 ?
1031 iface_hapd->conf->bridge : iface_hapd->conf->iface;
1032 info.apIfaceInstance = iface_hapd->conf->iface;
1033 info.clientAddress.assign(mac_addr, mac_addr + ETH_ALEN);
1034 info.isConnected = authorized;
1035 for (const auto &callback : callbacks_) {
1036 callback->onConnectedClientsChanged(info);
1037 }
1038 };
1039
1040 // Register for wpa_event which used to get channel switch event
1041 on_wpa_msg_internal_callback =
1042 [this](struct hostapd_data* iface_hapd, int level,
1043 enum wpa_msg_type type, const char *txt,
1044 size_t len) {
1045 wpa_printf(MSG_DEBUG, "Receive wpa msg : %s", txt);
1046 if (os_strncmp(txt, AP_EVENT_ENABLED,
1047 strlen(AP_EVENT_ENABLED)) == 0 ||
1048 os_strncmp(txt, WPA_EVENT_CHANNEL_SWITCH,
1049 strlen(WPA_EVENT_CHANNEL_SWITCH)) == 0) {
1050 ApInfo info;
1051 info.ifaceName = strlen(iface_hapd->conf->bridge) > 0 ?
1052 iface_hapd->conf->bridge : iface_hapd->conf->iface,
1053 info.apIfaceInstance = iface_hapd->conf->iface;
1054 info.freqMhz = iface_hapd->iface->freq;
1055 info.channelBandwidth = getChannelBandwidth(iface_hapd->iconf);
1056 info.generation = getGeneration(iface_hapd->iface->current_mode);
1057 info.apIfaceInstanceMacAddress.assign(iface_hapd->own_addr,
1058 iface_hapd->own_addr + ETH_ALEN);
1059 for (const auto &callback : callbacks_) {
1060 callback->onApInstanceInfoChanged(info);
1061 }
1062 } else if (os_strncmp(txt, AP_EVENT_DISABLED, strlen(AP_EVENT_DISABLED)) == 0
1063 || os_strncmp(txt, INTERFACE_DISABLED, strlen(INTERFACE_DISABLED)) == 0)
1064 {
1065 // Invoke the failure callback on all registered clients.
1066 for (const auto& callback : callbacks_) {
1067 callback->onFailure(strlen(iface_hapd->conf->bridge) > 0 ?
1068 iface_hapd->conf->bridge : iface_hapd->conf->iface,
1069 iface_hapd->conf->iface);
1070 }
1071 }
1072 };
1073
1074 // Setup callback
1075 iface_hapd->setup_complete_cb = onAsyncSetupCompleteCb;
1076 iface_hapd->setup_complete_cb_ctx = iface_hapd;
1077 iface_hapd->sta_authorized_cb = onAsyncStaAuthorizedCb;
1078 iface_hapd->sta_authorized_cb_ctx = iface_hapd;
1079 wpa_msg_register_aidl_cb(onAsyncWpaEventCb);
1080
1081 if (hostapd_enable_iface(iface_hapd->iface) < 0) {
1082 wpa_printf(
1083 MSG_ERROR, "Enabling interface %s failed",
1084 iface_params.name.c_str());
1085 return createStatus(HostapdStatusCode::FAILURE_UNKNOWN);
1086 }
1087 return ndk::ScopedAStatus::ok();
1088 }
1089
removeAccessPointInternal(const std::string & iface_name)1090 ::ndk::ScopedAStatus Hostapd::removeAccessPointInternal(const std::string& iface_name)
1091 {
1092 // interfaces to be removed
1093 std::vector<std::string> interfaces;
1094 bool is_error = false;
1095
1096 const auto it = br_interfaces_.find(iface_name);
1097 if (it != br_interfaces_.end()) {
1098 // In case bridge, remove managed interfaces
1099 interfaces = it->second;
1100 br_interfaces_.erase(iface_name);
1101 } else {
1102 // else remove current interface
1103 interfaces.push_back(iface_name);
1104 }
1105
1106 for (auto& iface : interfaces) {
1107 std::vector<char> remove_iface_param_vec(
1108 iface.begin(), iface.end() + 1);
1109 if (hostapd_remove_iface(interfaces_, remove_iface_param_vec.data()) < 0) {
1110 wpa_printf(MSG_INFO, "Remove interface %s failed", iface.c_str());
1111 is_error = true;
1112 }
1113 }
1114 if (is_error) {
1115 return createStatus(HostapdStatusCode::FAILURE_UNKNOWN);
1116 }
1117 return ndk::ScopedAStatus::ok();
1118 }
1119
registerCallbackInternal(const std::shared_ptr<IHostapdCallback> & callback)1120 ::ndk::ScopedAStatus Hostapd::registerCallbackInternal(
1121 const std::shared_ptr<IHostapdCallback>& callback)
1122 {
1123 binder_status_t status = AIBinder_linkToDeath(callback->asBinder().get(),
1124 death_notifier_, this /* cookie */);
1125 if (status != STATUS_OK) {
1126 wpa_printf(
1127 MSG_ERROR,
1128 "Error registering for death notification for "
1129 "hostapd callback object");
1130 return createStatus(HostapdStatusCode::FAILURE_UNKNOWN);
1131 }
1132 callbacks_.push_back(callback);
1133 return ndk::ScopedAStatus::ok();
1134 }
1135
forceClientDisconnectInternal(const std::string & iface_name,const std::vector<uint8_t> & client_address,Ieee80211ReasonCode reason_code)1136 ::ndk::ScopedAStatus Hostapd::forceClientDisconnectInternal(const std::string& iface_name,
1137 const std::vector<uint8_t>& client_address, Ieee80211ReasonCode reason_code)
1138 {
1139 struct hostapd_data *hapd = hostapd_get_iface(interfaces_, iface_name.c_str());
1140 bool result;
1141 if (!hapd) {
1142 for (auto const& iface : br_interfaces_) {
1143 if (iface.first == iface_name) {
1144 for (auto const& instance : iface.second) {
1145 hapd = hostapd_get_iface(interfaces_, instance.c_str());
1146 if (hapd) {
1147 result = forceStaDisconnection(hapd, client_address,
1148 (uint16_t) reason_code);
1149 if (result) break;
1150 }
1151 }
1152 }
1153 }
1154 } else {
1155 result = forceStaDisconnection(hapd, client_address, (uint16_t) reason_code);
1156 }
1157 if (!hapd) {
1158 wpa_printf(MSG_ERROR, "Interface %s doesn't exist", iface_name.c_str());
1159 return createStatus(HostapdStatusCode::FAILURE_IFACE_UNKNOWN);
1160 }
1161 if (result) {
1162 return ndk::ScopedAStatus::ok();
1163 }
1164 return createStatus(HostapdStatusCode::FAILURE_CLIENT_UNKNOWN);
1165 }
1166
setDebugParamsInternal(DebugLevel level)1167 ::ndk::ScopedAStatus Hostapd::setDebugParamsInternal(DebugLevel level)
1168 {
1169 wpa_debug_level = static_cast<uint32_t>(level);
1170 return ndk::ScopedAStatus::ok();
1171 }
1172
1173 } // namespace hostapd
1174 } // namespace wifi
1175 } // namespace hardware
1176 } // namespace android
1177 } // namespace aidl
1178