• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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