1 /*
2 * hidl 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
14 #include <android-base/file.h>
15 #include <android-base/stringprintf.h>
16
17 #include "hostapd.h"
18 #include "hidl_return_util.h"
19
20 extern "C"
21 {
22 #include "utils/eloop.h"
23 }
24
25 // The HIDL implementation for hostapd creates a hostapd.conf dynamically for
26 // each interface. This file can then be used to hook onto the normal config
27 // file parsing logic in hostapd code. Helps us to avoid duplication of code
28 // in the HIDL interface.
29 // TOOD(b/71872409): Add unit tests for this.
30 namespace {
31 constexpr char kConfFileNameFmt[] = "/data/vendor/wifi/hostapd/hostapd_%s.conf";
32
33 using android::base::RemoveFileIfExists;
34 using android::base::StringPrintf;
35 using android::base::WriteStringToFile;
36 using android::hardware::wifi::hostapd::V1_2::IHostapd;
37
WriteHostapdConfig(const std::string & interface_name,const std::string & config)38 std::string WriteHostapdConfig(
39 const std::string& interface_name, const std::string& config)
40 {
41 const std::string file_path =
42 StringPrintf(kConfFileNameFmt, interface_name.c_str());
43 if (WriteStringToFile(
44 config, file_path, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
45 getuid(), getgid())) {
46 return file_path;
47 }
48 // Diagnose failure
49 int error = errno;
50 wpa_printf(
51 MSG_ERROR, "Cannot write hostapd config to %s, error: %s",
52 file_path.c_str(), strerror(error));
53 struct stat st;
54 int result = stat(file_path.c_str(), &st);
55 if (result == 0) {
56 wpa_printf(
57 MSG_ERROR, "hostapd config file uid: %d, gid: %d, mode: %d",
58 st.st_uid, st.st_gid, st.st_mode);
59 } else {
60 wpa_printf(
61 MSG_ERROR,
62 "Error calling stat() on hostapd config file: %s",
63 strerror(errno));
64 }
65 return "";
66 }
67
68 /*
69 * Get the op_class for a channel/band
70 * The logic here is based on Table E-4 in the 802.11 Specification
71 */
getOpClassForChannel(int channel,int band,bool support11n,bool support11ac)72 int getOpClassForChannel(int channel, int band, bool support11n, bool support11ac) {
73 // 2GHz Band
74 if ((band & IHostapd::BandMask::BAND_2_GHZ) != 0) {
75 if (channel == 14) {
76 return 82;
77 }
78 if (channel >= 1 && channel <= 13) {
79 if (!support11n) {
80 //20MHz channel
81 return 81;
82 }
83 if (channel <= 9) {
84 // HT40 with secondary channel above primary
85 return 83;
86 }
87 // HT40 with secondary channel below primary
88 return 84;
89 }
90 // Error
91 return 0;
92 }
93
94 // 5GHz Band
95 if ((band & IHostapd::BandMask::BAND_5_GHZ) != 0) {
96 if (support11ac) {
97 switch (channel) {
98 case 42:
99 case 58:
100 case 106:
101 case 122:
102 case 138:
103 case 155:
104 // 80MHz channel
105 return 128;
106 case 50:
107 case 114:
108 // 160MHz channel
109 return 129;
110 }
111 }
112
113 if (!support11n) {
114 if (channel >= 36 && channel <= 48) {
115 return 115;
116 }
117 if (channel >= 52 && channel <= 64) {
118 return 118;
119 }
120 if (channel >= 100 && channel <= 144) {
121 return 121;
122 }
123 if (channel >= 149 && channel <= 161) {
124 return 124;
125 }
126 if (channel >= 165 && channel <= 169) {
127 return 125;
128 }
129 } else {
130 switch (channel) {
131 case 36:
132 case 44:
133 // HT40 with secondary channel above primary
134 return 116;
135 case 40:
136 case 48:
137 // HT40 with secondary channel below primary
138 return 117;
139 case 52:
140 case 60:
141 // HT40 with secondary channel above primary
142 return 119;
143 case 56:
144 case 64:
145 // HT40 with secondary channel below primary
146 return 120;
147 case 100:
148 case 108:
149 case 116:
150 case 124:
151 case 132:
152 case 140:
153 // HT40 with secondary channel above primary
154 return 122;
155 case 104:
156 case 112:
157 case 120:
158 case 128:
159 case 136:
160 case 144:
161 // HT40 with secondary channel below primary
162 return 123;
163 case 149:
164 case 157:
165 // HT40 with secondary channel above primary
166 return 126;
167 case 153:
168 case 161:
169 // HT40 with secondary channel below primary
170 return 127;
171 }
172 }
173 // Error
174 return 0;
175 }
176
177 // 6GHz Band
178 if ((band & IHostapd::BandMask::BAND_6_GHZ) != 0) {
179 // Channels 1, 5. 9, 13, ...
180 if ((channel & 0x03) == 0x01) {
181 // 20MHz channel
182 return 131;
183 }
184 // Channels 3, 11, 19, 27, ...
185 if ((channel & 0x07) == 0x03) {
186 // 40MHz channel
187 return 132;
188 }
189 // Channels 7, 23, 39, 55, ...
190 if ((channel & 0x0F) == 0x07) {
191 // 80MHz channel
192 return 133;
193 }
194 // Channels 15, 47, 69, ...
195 if ((channel & 0x1F) == 0x0F) {
196 // 160MHz channel
197 return 134;
198 }
199 if (channel == 2) {
200 // 20MHz channel
201 return 136;
202 }
203 // Error
204 return 0;
205 }
206
207 return 0;
208 }
209
validatePassphrase(int passphrase_len,int min_len,int max_len)210 bool validatePassphrase(int passphrase_len, int min_len, int max_len)
211 {
212 if (min_len != -1 && passphrase_len < min_len) return false;
213 if (max_len != -1 && passphrase_len > max_len) return false;
214 return true;
215 }
216
CreateHostapdConfig(const IHostapd::IfaceParams & iface_params,const IHostapd::NetworkParams & nw_params)217 std::string CreateHostapdConfig(
218 const IHostapd::IfaceParams& iface_params,
219 const IHostapd::NetworkParams& nw_params)
220 {
221 if (nw_params.V1_0.ssid.size() >
222 static_cast<uint32_t>(
223 IHostapd::ParamSizeLimits::SSID_MAX_LEN_IN_BYTES)) {
224 wpa_printf(
225 MSG_ERROR, "Invalid SSID size: %zu", nw_params.V1_0.ssid.size());
226 return "";
227 }
228
229 // SSID string
230 std::stringstream ss;
231 ss << std::hex;
232 ss << std::setfill('0');
233 for (uint8_t b : nw_params.V1_0.ssid) {
234 ss << std::setw(2) << static_cast<unsigned int>(b);
235 }
236 const std::string ssid_as_string = ss.str();
237
238 // Encryption config string
239 std::string encryption_config_as_string;
240 switch (nw_params.encryptionType) {
241 case IHostapd::EncryptionType::NONE:
242 // no security params
243 break;
244 case IHostapd::EncryptionType::WPA:
245 if (!validatePassphrase(
246 nw_params.passphrase.size(),
247 static_cast<uint32_t>(IHostapd::ParamSizeLimits::
248 WPA2_PSK_PASSPHRASE_MIN_LEN_IN_BYTES),
249 static_cast<uint32_t>(IHostapd::ParamSizeLimits::
250 WPA2_PSK_PASSPHRASE_MAX_LEN_IN_BYTES))) {
251 return "";
252 }
253 encryption_config_as_string = StringPrintf(
254 "wpa=3\n"
255 "wpa_pairwise=TKIP CCMP\n"
256 "wpa_passphrase=%s",
257 nw_params.passphrase.c_str());
258 break;
259 case IHostapd::EncryptionType::WPA2:
260 if (!validatePassphrase(
261 nw_params.passphrase.size(),
262 static_cast<uint32_t>(IHostapd::ParamSizeLimits::
263 WPA2_PSK_PASSPHRASE_MIN_LEN_IN_BYTES),
264 static_cast<uint32_t>(IHostapd::ParamSizeLimits::
265 WPA2_PSK_PASSPHRASE_MAX_LEN_IN_BYTES))) {
266 return "";
267 }
268 encryption_config_as_string = StringPrintf(
269 "wpa=2\n"
270 "rsn_pairwise=CCMP\n"
271 "wpa_passphrase=%s",
272 nw_params.passphrase.c_str());
273 break;
274 case IHostapd::EncryptionType::WPA3_SAE_TRANSITION:
275 if (!validatePassphrase(
276 nw_params.passphrase.size(),
277 static_cast<uint32_t>(IHostapd::ParamSizeLimits::
278 WPA2_PSK_PASSPHRASE_MIN_LEN_IN_BYTES),
279 static_cast<uint32_t>(IHostapd::ParamSizeLimits::
280 WPA2_PSK_PASSPHRASE_MAX_LEN_IN_BYTES))) {
281 return "";
282 }
283 encryption_config_as_string = StringPrintf(
284 "wpa=2\n"
285 "rsn_pairwise=CCMP\n"
286 "wpa_key_mgmt=WPA-PSK SAE\n"
287 "ieee80211w=1\n"
288 "sae_require_mfp=1\n"
289 "wpa_passphrase=%s\n"
290 "sae_password=%s",
291 nw_params.passphrase.c_str(),
292 nw_params.passphrase.c_str());
293 break;
294 case IHostapd::EncryptionType::WPA3_SAE:
295 if (!validatePassphrase(nw_params.passphrase.size(), 1, -1)) {
296 return "";
297 }
298 encryption_config_as_string = StringPrintf(
299 "wpa=2\n"
300 "rsn_pairwise=CCMP\n"
301 "wpa_key_mgmt=SAE\n"
302 "ieee80211w=2\n"
303 "sae_require_mfp=2\n"
304 "sae_password=%s",
305 nw_params.passphrase.c_str());
306 break;
307 default:
308 wpa_printf(MSG_ERROR, "Unknown encryption type");
309 return "";
310 }
311
312 unsigned int band = 0;
313 band |= iface_params.channelParams.bandMask;
314
315 std::string channel_config_as_string;
316 bool isFirst = true;
317 if (iface_params.V1_1.V1_0.channelParams.enableAcs) {
318 std::string freqList_as_string;
319 for (const auto &range :
320 iface_params.channelParams.acsChannelFreqRangesMhz) {
321 if (!isFirst) {
322 freqList_as_string += ",";
323 }
324 isFirst = false;
325
326 if (range.start != range.end) {
327 freqList_as_string +=
328 StringPrintf("%d-%d", range.start, range.end);
329 } else {
330 freqList_as_string += StringPrintf("%d", range.start);
331 }
332 }
333 channel_config_as_string = StringPrintf(
334 "channel=0\n"
335 "acs_exclude_dfs=%d\n"
336 "freqlist=%s",
337 iface_params.V1_1.V1_0.channelParams.acsShouldExcludeDfs,
338 freqList_as_string.c_str());
339 } else {
340 int op_class = getOpClassForChannel(
341 iface_params.V1_1.V1_0.channelParams.channel,
342 band,
343 iface_params.V1_1.V1_0.hwModeParams.enable80211N,
344 iface_params.V1_1.V1_0.hwModeParams.enable80211AC);
345 channel_config_as_string = StringPrintf(
346 "channel=%d\n"
347 "op_class=%d",
348 iface_params.V1_1.V1_0.channelParams.channel, op_class);
349 }
350
351 std::string hw_mode_as_string;
352 std::string ht_cap_vht_oper_chwidth_as_string;
353
354 if ((band & IHostapd::BandMask::BAND_2_GHZ) != 0) {
355 if (((band & IHostapd::BandMask::BAND_5_GHZ) != 0)
356 || ((band & IHostapd::BandMask::BAND_6_GHZ) != 0)) {
357 hw_mode_as_string = "hw_mode=any";
358 if (iface_params.V1_1.V1_0.channelParams.enableAcs) {
359 ht_cap_vht_oper_chwidth_as_string =
360 "ht_capab=[HT40+]\n"
361 "vht_oper_chwidth=1";
362 }
363 } else {
364 hw_mode_as_string = "hw_mode=g";
365 }
366 } else {
367 if (((band & IHostapd::BandMask::BAND_5_GHZ) != 0)
368 || ((band & IHostapd::BandMask::BAND_6_GHZ) != 0)) {
369 hw_mode_as_string = "hw_mode=a";
370 if (iface_params.V1_1.V1_0.channelParams.enableAcs) {
371 ht_cap_vht_oper_chwidth_as_string =
372 "ht_capab=[HT40+]\n"
373 "vht_oper_chwidth=1";
374 }
375 } else {
376 wpa_printf(MSG_ERROR, "Invalid band");
377 return "";
378 }
379 }
380
381 std::string he_params_as_string;
382 #ifdef CONFIG_IEEE80211AX
383 if (iface_params.hwModeParams.enable80211AX) {
384 he_params_as_string = StringPrintf(
385 "ieee80211ax=1\n"
386 "he_su_beamformer=%d\n"
387 "he_su_beamformee=%d\n"
388 "he_mu_beamformer=%d\n"
389 "he_twt_required=%d\n",
390 iface_params.hwModeParams.enableHeSingleUserBeamformer ? 1 : 0,
391 iface_params.hwModeParams.enableHeSingleUserBeamformee ? 1 : 0,
392 iface_params.hwModeParams.enableHeMultiUserBeamformer ? 1 : 0,
393 iface_params.hwModeParams.enableHeTargetWakeTime ? 1 : 0);
394 } else {
395 he_params_as_string = "ieee80211ax=0";
396 }
397 #endif /* CONFIG_IEEE80211AX */
398
399 return StringPrintf(
400 "interface=%s\n"
401 "driver=nl80211\n"
402 "ctrl_interface=/data/vendor/wifi/hostapd/ctrl\n"
403 // ssid2 signals to hostapd that the value is not a literal value
404 // for use as a SSID. In this case, we're giving it a hex
405 // std::string and hostapd needs to expect that.
406 "ssid2=%s\n"
407 "%s\n"
408 "ieee80211n=%d\n"
409 "ieee80211ac=%d\n"
410 "%s\n"
411 "%s\n"
412 "%s\n"
413 "ignore_broadcast_ssid=%d\n"
414 "wowlan_triggers=any\n"
415 "%s\n",
416 iface_params.V1_1.V1_0.ifaceName.c_str(), ssid_as_string.c_str(),
417 channel_config_as_string.c_str(),
418 iface_params.V1_1.V1_0.hwModeParams.enable80211N ? 1 : 0,
419 iface_params.V1_1.V1_0.hwModeParams.enable80211AC ? 1 : 0,
420 he_params_as_string.c_str(),
421 hw_mode_as_string.c_str(), ht_cap_vht_oper_chwidth_as_string.c_str(),
422 nw_params.V1_0.isHidden ? 1 : 0, encryption_config_as_string.c_str());
423 }
424
425 // hostapd core functions accept "C" style function pointers, so use global
426 // functions to pass to the hostapd core function and store the corresponding
427 // std::function methods to be invoked.
428 //
429 // NOTE: Using the pattern from the vendor HAL (wifi_legacy_hal.cpp).
430 //
431 // Callback to be invoked once setup is complete
432 std::function<void(struct hostapd_data*)> on_setup_complete_internal_callback;
onAsyncSetupCompleteCb(void * ctx)433 void onAsyncSetupCompleteCb(void* ctx)
434 {
435 struct hostapd_data* iface_hapd = (struct hostapd_data*)ctx;
436 if (on_setup_complete_internal_callback) {
437 on_setup_complete_internal_callback(iface_hapd);
438 // Invalidate this callback since we don't want this firing
439 // again.
440 on_setup_complete_internal_callback = nullptr;
441 }
442 }
443 } // namespace
444
445 namespace android {
446 namespace hardware {
447 namespace wifi {
448 namespace hostapd {
449 namespace V1_2 {
450 namespace implementation {
451 using hidl_return_util::call;
452 using namespace android::hardware::wifi::hostapd::V1_0;
453
Hostapd(struct hapd_interfaces * interfaces)454 Hostapd::Hostapd(struct hapd_interfaces* interfaces) : interfaces_(interfaces)
455 {}
456
addAccessPoint(const V1_0::IHostapd::IfaceParams & iface_params,const V1_0::IHostapd::NetworkParams & nw_params,addAccessPoint_cb _hidl_cb)457 Return<void> Hostapd::addAccessPoint(
458 const V1_0::IHostapd::IfaceParams& iface_params,
459 const V1_0::IHostapd::NetworkParams& nw_params, addAccessPoint_cb _hidl_cb)
460 {
461 return call(
462 this, &Hostapd::addAccessPointInternal, _hidl_cb, iface_params,
463 nw_params);
464 }
465
addAccessPoint_1_1(const V1_1::IHostapd::IfaceParams & iface_params,const V1_0::IHostapd::NetworkParams & nw_params,addAccessPoint_cb _hidl_cb)466 Return<void> Hostapd::addAccessPoint_1_1(
467 const V1_1::IHostapd::IfaceParams& iface_params,
468 const V1_0::IHostapd::NetworkParams& nw_params, addAccessPoint_cb _hidl_cb)
469 {
470 return call(
471 this, &Hostapd::addAccessPointInternal_1_1, _hidl_cb, iface_params,
472 nw_params);
473 }
474
addAccessPoint_1_2(const IfaceParams & iface_params,const NetworkParams & nw_params,addAccessPoint_1_2_cb _hidl_cb)475 Return<void> Hostapd::addAccessPoint_1_2(
476 const IfaceParams& iface_params, const NetworkParams& nw_params,
477 addAccessPoint_1_2_cb _hidl_cb)
478 {
479 return call(
480 this, &Hostapd::addAccessPointInternal_1_2, _hidl_cb, iface_params,
481 nw_params);
482 }
483
removeAccessPoint(const hidl_string & iface_name,removeAccessPoint_cb _hidl_cb)484 Return<void> Hostapd::removeAccessPoint(
485 const hidl_string& iface_name, removeAccessPoint_cb _hidl_cb)
486 {
487 return call(
488 this, &Hostapd::removeAccessPointInternal, _hidl_cb, iface_name);
489 }
490
terminate()491 Return<void> Hostapd::terminate()
492 {
493 wpa_printf(MSG_INFO, "Terminating...");
494 eloop_terminate();
495 return Void();
496 }
497
registerCallback(const sp<V1_1::IHostapdCallback> & callback,registerCallback_cb _hidl_cb)498 Return<void> Hostapd::registerCallback(
499 const sp<V1_1::IHostapdCallback>& callback, registerCallback_cb _hidl_cb)
500 {
501 return call(
502 this, &Hostapd::registerCallbackInternal, _hidl_cb, callback);
503 }
504
forceClientDisconnect(const hidl_string & iface_name,const hidl_array<uint8_t,6> & client_address,V1_2::Ieee80211ReasonCode reason_code,forceClientDisconnect_cb _hidl_cb)505 Return<void> Hostapd::forceClientDisconnect(
506 const hidl_string& iface_name, const hidl_array<uint8_t, 6>& client_address,
507 V1_2::Ieee80211ReasonCode reason_code, forceClientDisconnect_cb _hidl_cb)
508 {
509 return call(
510 this, &Hostapd::forceClientDisconnectInternal, _hidl_cb, iface_name,
511 client_address, reason_code);
512 }
513
setDebugParams(DebugLevel level,setDebugParams_cb _hidl_cb)514 Return<void> Hostapd::setDebugParams(
515 DebugLevel level, setDebugParams_cb _hidl_cb)
516 {
517 return call(
518 this, &Hostapd::setDebugParamsInternal, _hidl_cb, level);
519 }
520
addAccessPointInternal(const V1_0::IHostapd::IfaceParams & iface_params,const V1_0::IHostapd::NetworkParams & nw_params)521 V1_0::HostapdStatus Hostapd::addAccessPointInternal(
522 const V1_0::IHostapd::IfaceParams& iface_params,
523 const V1_0::IHostapd::NetworkParams& nw_params)
524 {
525 return {V1_0::HostapdStatusCode::FAILURE_UNKNOWN, ""};
526 }
527
addAccessPointInternal_1_1(const V1_1::IHostapd::IfaceParams & iface_params,const V1_1::IHostapd::NetworkParams & nw_params)528 V1_0::HostapdStatus Hostapd::addAccessPointInternal_1_1(
529 const V1_1::IHostapd::IfaceParams& iface_params,
530 const V1_1::IHostapd::NetworkParams& nw_params)
531 {
532 return {V1_0::HostapdStatusCode::FAILURE_UNKNOWN, ""};
533 }
534
addAccessPointInternal_1_2(const IfaceParams & iface_params,const NetworkParams & nw_params)535 HostapdStatus Hostapd::addAccessPointInternal_1_2(
536 const IfaceParams& iface_params, const NetworkParams& nw_params)
537 {
538 if (hostapd_get_iface(interfaces_, iface_params.V1_1.V1_0.ifaceName.c_str())) {
539 wpa_printf(
540 MSG_ERROR, "Interface %s already present",
541 iface_params.V1_1.V1_0.ifaceName.c_str());
542 return {HostapdStatusCode::FAILURE_IFACE_EXISTS, ""};
543 }
544 const auto conf_params = CreateHostapdConfig(iface_params, nw_params);
545 if (conf_params.empty()) {
546 wpa_printf(MSG_ERROR, "Failed to create config params");
547 return {HostapdStatusCode::FAILURE_ARGS_INVALID, ""};
548 }
549 const auto conf_file_path =
550 WriteHostapdConfig(iface_params.V1_1.V1_0.ifaceName, conf_params);
551 if (conf_file_path.empty()) {
552 wpa_printf(MSG_ERROR, "Failed to write config file");
553 return {HostapdStatusCode::FAILURE_UNKNOWN, ""};
554 }
555 std::string add_iface_param_str = StringPrintf(
556 "%s config=%s", iface_params.V1_1.V1_0.ifaceName.c_str(),
557 conf_file_path.c_str());
558 std::vector<char> add_iface_param_vec(
559 add_iface_param_str.begin(), add_iface_param_str.end() + 1);
560 if (hostapd_add_iface(interfaces_, add_iface_param_vec.data()) < 0) {
561 wpa_printf(
562 MSG_ERROR, "Adding interface %s failed",
563 add_iface_param_str.c_str());
564 return {HostapdStatusCode::FAILURE_UNKNOWN, ""};
565 }
566 struct hostapd_data* iface_hapd =
567 hostapd_get_iface(interfaces_, iface_params.V1_1.V1_0.ifaceName.c_str());
568 WPA_ASSERT(iface_hapd != nullptr && iface_hapd->iface != nullptr);
569 // Register the setup complete callbacks
570 on_setup_complete_internal_callback =
571 [this](struct hostapd_data* iface_hapd) {
572 wpa_printf(
573 MSG_DEBUG, "AP interface setup completed - state %s",
574 hostapd_state_text(iface_hapd->iface->state));
575 if (iface_hapd->iface->state == HAPD_IFACE_DISABLED) {
576 // Invoke the failure callback on all registered
577 // clients.
578 for (const auto& callback : callbacks_) {
579 callback->onFailure(
580 iface_hapd->conf->iface);
581 }
582 }
583 };
584 iface_hapd->setup_complete_cb = onAsyncSetupCompleteCb;
585 iface_hapd->setup_complete_cb_ctx = iface_hapd;
586 if (hostapd_enable_iface(iface_hapd->iface) < 0) {
587 wpa_printf(
588 MSG_ERROR, "Enabling interface %s failed",
589 iface_params.V1_1.V1_0.ifaceName.c_str());
590 return {HostapdStatusCode::FAILURE_UNKNOWN, ""};
591 }
592 return {HostapdStatusCode::SUCCESS, ""};
593 }
594
removeAccessPointInternal(const std::string & iface_name)595 V1_0::HostapdStatus Hostapd::removeAccessPointInternal(const std::string& iface_name)
596 {
597 std::vector<char> remove_iface_param_vec(
598 iface_name.begin(), iface_name.end() + 1);
599 if (hostapd_remove_iface(interfaces_, remove_iface_param_vec.data()) <
600 0) {
601 wpa_printf(
602 MSG_ERROR, "Removing interface %s failed",
603 iface_name.c_str());
604 return {V1_0::HostapdStatusCode::FAILURE_UNKNOWN, ""};
605 }
606 return {V1_0::HostapdStatusCode::SUCCESS, ""};
607 }
608
registerCallbackInternal(const sp<V1_1::IHostapdCallback> & callback)609 V1_0::HostapdStatus Hostapd::registerCallbackInternal(
610 const sp<V1_1::IHostapdCallback>& callback)
611 {
612 callbacks_.push_back(callback);
613 return {V1_0::HostapdStatusCode::SUCCESS, ""};
614 }
615
forceClientDisconnectInternal(const std::string & iface_name,const std::array<uint8_t,6> & client_address,V1_2::Ieee80211ReasonCode reason_code)616 V1_2::HostapdStatus Hostapd::forceClientDisconnectInternal(const std::string& iface_name,
617 const std::array<uint8_t, 6>& client_address, V1_2::Ieee80211ReasonCode reason_code)
618 {
619 struct hostapd_data *hapd = hostapd_get_iface(interfaces_, iface_name.c_str());
620 struct sta_info *sta;
621 if (!hapd) {
622 wpa_printf(MSG_ERROR, "Interface %s doesn't exist", iface_name.c_str());
623 return {V1_2::HostapdStatusCode::FAILURE_IFACE_UNKNOWN, ""};
624 }
625 for (sta = hapd->sta_list; sta; sta = sta->next) {
626 int res;
627 res = memcmp(sta->addr, client_address.data(), ETH_ALEN);
628 if (res == 0) {
629 wpa_printf(MSG_INFO, "Force client:" MACSTR " disconnect with reason: %d",
630 MAC2STR(client_address.data()), (uint16_t) reason_code);
631 ap_sta_disconnect(hapd, sta, sta->addr, (uint16_t) reason_code);
632 return {V1_2::HostapdStatusCode::SUCCESS, ""};
633 }
634 }
635 return {V1_2::HostapdStatusCode::FAILURE_CLIENT_UNKNOWN, ""};
636 }
637
setDebugParamsInternal(DebugLevel level)638 V1_2::HostapdStatus Hostapd::setDebugParamsInternal(DebugLevel level)
639 {
640 wpa_debug_level = static_cast<uint32_t>(level);
641 return {V1_2::HostapdStatusCode::SUCCESS, ""};
642 }
643
644 } // namespace implementation
645 } // namespace V1_2
646 } // namespace hostapd
647 } // namespace wifi
648 } // namespace hardware
649 } // namespace android
650