Wifi笔记 | Wifi热点的开启
2020-01-02 本文已影响0人
力卉编程
代码基于Android P
Android使用wpa_supplicant作为daemon来控制WIFI，它是一个安全中间件，代码位于external/wpa_supplicant，为各种无线网卡提供统一的安全机制。当然在这里只是介绍一下wpa_supplicant和 hostapd，研究分析的部分主要还是应用层和java框架层，有时也会涉及Native层。
wpa_supplicant_8主要有三个子目录 ：
- hostapd：当手机进入Soft AP模式时，手机将扮演AP的角色，需要hostapd来提供AP的功能，也就是wifi热点的实现。
- wpa_supplicant：Station模式，也叫Managed模式，这是平时最常见的使用wifi连接AP的情况。
- src：hostapd和wpa_supplicant中都包含一些通用的数据结构和处理方法，这些内容都放在此src目录中。
Hostapd简介
hostapd能够使得无线网卡切换为master模式，模拟AP(通常可以认为是路由器)功能，也就是我们说的软AP(Soft AP)。
Hostapd的功能就是作为AP的认证服务器，负责控制管理stations(通常可以认为带无线网卡的PC)的接入和认证。
通过Hostapd可以将无线网卡切换为AP/Master模式，通过修改配置文件，可以建立一个开放式的(不加密)的，WEP，WPA或WPA2的无线网络。并且通过修改配置文件可以设置无线网卡的各种参数，包括频率，信号，beacon包时间间隔，是否发送beacon包，如果响应探针请求等等。
当用以wifi的时候，作为station，工作在managed模式，有后台进程wpa_supplicant对认证管理。
工作在sofap的时候，作为AP， 工作在master模式，由后台进程hostapd做认证处理。
作为station，用户通过UI启动WIFI，由framework层，JNI，hardware层加载WIFI的驱动，加载firmware。驱动加载成功后，启动wpa_supplicant，设置mad地址，设置为managed模式，通过ioctl命令启动scan，启动DHCPD获取IP地址，链接到对应的AP，建立连接后同时sock通信。
作为softap模式的时候，和station模式的流程差不多，只不过不是启动wpa_supplicant，启动hostapd的后台管理进程。
由framework层，JNI，hardware层加载softap的驱动，加载firmware。驱动加载成功后，启动hostap，设置mad地址，设置为master模式，设置BSSID，启动DHCPD获取IP地址。等待station来连接。
流程图
Android P之后，Wifi模块增加了packages/apps/Settings/src/com/android/settings/wifi/tether/路径，相当于把Wifi热点独立放到了tether文件夹下面，并添加了WifiTetherSettings.java类，对应着Wifi热点的界面，而Android P之前是没有的，Wifi热点界面之前是对应在TetherSettings的一部分，有些厂商也还是会改到TetherSettings上。
1.1 创建WifiTetherSwitchBarController
//packages/apps/Settings/src/com/android/settings/wifi/tether/WifiTetherSettings.java
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
// Assume we are in a SettingsActivity. This is only safe because we currently use
// SettingsActivity as base for all preference fragments.
final SettingsActivity activity = (SettingsActivity) getActivity();
final SwitchBar switchBar = activity.getSwitchBar();
mSwitchBarController = new WifiTetherSwitchBarController(activity,
new SwitchBarController(switchBar));
getLifecycle().addObserver(mSwitchBarController);
switchBar.show();
}
1.2 初始化mSwitchBarController
//packages/apps/Settings/src/com/android/settings/wifi/tether/WifiTetherSwitchBarController.java
public class WifiTetherSwitchBarController implements SwitchWidgetController.OnSwitchChangeListener,
LifecycleObserver, OnStart, OnStop, DataSaverBackend.Listener {
//...
}
//packages/apps/Settings/src/com/android/settings/widget/SwitchWidgetController.java
public interface OnSwitchChangeListener {
/**
* Called when the checked state of the Switch has changed.
*
* @param isChecked The new checked state of switchView.
*
* @return true to update the state of the switch with the new value.
*/
boolean onSwitchToggled(boolean isChecked);
}
//packages/apps/Settings/src/com/android/settings/wifi/tether/WifiTetherSwitchBarController.java
public boolean onSwitchToggled(boolean isChecked) {
if (!isChecked) {
stopTether();
} else if (!mWifiManager.isWifiApEnabled()) {
startTether();
}
return true;
}
void startTether() {
mSwitchBar.setEnabled(false);
mConnectivityManager.startTethering(TETHERING_WIFI, true /* showProvisioningUi */,
mOnStartTetheringCallback, new Handler(Looper.getMainLooper()));
}
1.3 启动 mConnectivityManager.startTethering
注意： android O开始通过mConnectivityManager.startTethering来启动热点了，之前都是通过WifiManager的setWifiApEnable的方法，该方法现在也已废弃。
//frameworks/base/core/java/android/net/ConnectivityManager.java
/**
* Convenient overload for
* {@link #startTethering(int, boolean, OnStartTetheringCallback, Handler)} which passes a null
* handler to run on the current thread's {@link Looper}.
* @hide
*/
@SystemApi
@RequiresPermission(android.Manifest.permission.TETHER_PRIVILEGED)
public void startTethering(int type, boolean showProvisioningUi,
final OnStartTetheringCallback callback) {
startTethering(type, showProvisioningUi, callback, null);
}
1.4 startTethering
/**
* Runs tether provisioning for the given type if needed and then starts tethering if
* the check succeeds. If no carrier provisioning is required for tethering, tethering is
* enabled immediately. If provisioning fails, tethering will not be enabled. It also
* schedules tether provisioning re-checks if appropriate.
*
* @param type The type of tethering to start. Must be one of
* {@link ConnectivityManager.TETHERING_WIFI},
* {@link ConnectivityManager.TETHERING_USB}, or
* {@link ConnectivityManager.TETHERING_BLUETOOTH}.
* @param showProvisioningUi a boolean indicating to show the provisioning app UI if there
* is one. This should be true the first time this function is called and also any time
* the user can see this UI. It gives users information from their carrier about the
* check failing and how they can sign up for tethering if possible.
* @param callback an {@link OnStartTetheringCallback} which will be called to notify the caller
* of the result of trying to tether.
* @param handler {@link Handler} to specify the thread upon which the callback will be invoked.
* @hide
*/
@SystemApi
@RequiresPermission(android.Manifest.permission.TETHER_PRIVILEGED)
public void startTethering(int type, boolean showProvisioningUi,
final OnStartTetheringCallback callback, Handler handler) {
Preconditions.checkNotNull(callback, "OnStartTetheringCallback cannot be null.");
ResultReceiver wrappedCallback = new ResultReceiver(handler) {
@Override
protected void onReceiveResult(int resultCode, Bundle resultData) {
if (resultCode == TETHER_ERROR_NO_ERROR) {
callback.onTetheringStarted();
} else {
callback.onTetheringFailed();
}
}
};
try {
String pkgName = mContext.getOpPackageName();
Log.i(TAG, "startTethering caller:" + pkgName);
mService.startTethering(type, wrappedCallback, showProvisioningUi, pkgName);
} catch (RemoteException e) {
Log.e(TAG, "Exception trying to start tethering.", e);
wrappedCallback.send(TETHER_ERROR_SERVICE_UNAVAIL, null);
}
}
1.5 mService.startTethering
//frameworks/base/services/core/java/com/android/server/ConnectivityService.java
@Override
public void startTethering(int type, ResultReceiver receiver, boolean showProvisioningUi,
String callerPkg) {
ConnectivityManager.enforceTetherChangePermission(mContext, callerPkg);
if (!isTetheringSupported()) {
receiver.send(ConnectivityManager.TETHER_ERROR_UNSUPPORTED, null);
return;
}
mTethering.startTethering(type, receiver, showProvisioningUi);
}
1.6 mTethering.startTethering
//frameworks/base/services/core/java/com/android/server/connectivity/Tethering.java
public void startTethering(int type, ResultReceiver receiver, boolean showProvisioningUi) {
if (!isTetherProvisioningRequired()) {
enableTetheringInternal(type, true, receiver);
return;
}
if (showProvisioningUi) {
runUiTetherProvisioningAndEnable(type, receiver);
} else {
runSilentTetherProvisioningAndEnable(type, receiver);
}
}
1.7 Tethering.enableTetheringInternal
/**
* Enables or disables tethering for the given type. This should only be called once
* provisioning has succeeded or is not necessary. It will also schedule provisioning rechecks
* for the specified interface.
*/
private void enableTetheringInternal(int type, boolean enable, ResultReceiver receiver) {
boolean isProvisioningRequired = enable && isTetherProvisioningRequired();
int result;
switch (type) {
case TETHERING_WIFI:
result = setWifiTethering(enable);
if (isProvisioningRequired && result == TETHER_ERROR_NO_ERROR) {
scheduleProvisioningRechecks(type);
}
sendTetherResult(receiver, result);
break;
case TETHERING_USB:
result = setUsbTethering(enable);
if (isProvisioningRequired && result == TETHER_ERROR_NO_ERROR) {
scheduleProvisioningRechecks(type);
}
sendTetherResult(receiver, result);
break;
case TETHERING_BLUETOOTH:
setBluetoothTethering(enable, receiver);
break;
default:
Log.w(TAG, "Invalid tether type.");
sendTetherResult(receiver, TETHER_ERROR_UNKNOWN_IFACE);
}
}
1.8 Tethering.setWifiTethering
private int setWifiTethering(final boolean enable) {
int rval = TETHER_ERROR_MASTER_ERROR;
final long ident = Binder.clearCallingIdentity();
try {
synchronized (mPublicSync) {
mWifiTetherRequested = enable;
final WifiManager mgr = getWifiManager();
if ((enable && mgr.startSoftAp(null /* use existing wifi config */)) ||
(!enable && mgr.stopSoftAp())) {
rval = TETHER_ERROR_NO_ERROR;
}
}
} finally {
Binder.restoreCallingIdentity(ident);
}
return rval;
}
1.9 mgr.startSoftAp
//frameworks/base/wifi/java/android/net/wifi/WifiManager.java
public boolean startSoftAp(@Nullable WifiConfiguration wifiConfig) {
try {
return mService.startSoftAp(wifiConfig);
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
}
}
startSoftAp --> startSoftApInternal --> mWifiController.sendMessage --> makeSoftApManager-->
frameworks/opt/net/wifi/service/java/com/android/server/wifi/SoftApManager.java
frameworks/opt/net/wifi/service/java/com/android/server/wifi/WifiInjector.java
1.10 SoftApStateMachine是SoftApManager的内部类。
函数中调用Native的 stopSoftAp 将通过Native调用Wifi的相关代码
@Override
public boolean processMessage(Message message) {
switch (message.what) {
case CMD_START:
mApInterfaceName = mWifiNative.setupInterfaceForSoftApMode(
mWifiNativeInterfaceCallback);
if (TextUtils.isEmpty(mApInterfaceName)) {
Log.e(TAG, "setup failure when creating ap interface.");
updateApState(WifiManager.WIFI_AP_STATE_FAILED,
WifiManager.WIFI_AP_STATE_DISABLED,
WifiManager.SAP_START_FAILURE_GENERAL);
mWifiMetrics.incrementSoftApStartResult(
false, WifiManager.SAP_START_FAILURE_GENERAL);
break;
}
updateApState(WifiManager.WIFI_AP_STATE_ENABLING,
WifiManager.WIFI_AP_STATE_DISABLED, 0);
int result = startSoftAp((WifiConfiguration) message.obj);
if (result != SUCCESS) {
int failureReason = WifiManager.SAP_START_FAILURE_GENERAL;
if (result == ERROR_NO_CHANNEL) {
failureReason = WifiManager.SAP_START_FAILURE_NO_CHANNEL;
}
updateApState(WifiManager.WIFI_AP_STATE_FAILED,
WifiManager.WIFI_AP_STATE_ENABLING,
failureReason);
stopSoftAp();
mWifiMetrics.incrementSoftApStartResult(false, failureReason);
break;
}
transitionTo(mStartedState);
break;
default:
// Ignore all other commands.
break;
}
return HANDLED;
}
}
1.11 mWifiNative.startSoftAp
mWifiNative.startSoftAp
/**
* Start a soft AP instance with the given configuration.
* @param config AP configuration
* @return integer result code
*/
private int startSoftAp(WifiConfiguration config) {
if (config == null || config.SSID == null) {
Log.e(TAG, "Unable to start soft AP without valid configuration");
return ERROR_GENERIC;
}
// Make a copy of configuration for updating AP band and channel.
WifiConfiguration localConfig = new WifiConfiguration(config);
int result = ApConfigUtil.updateApChannelConfig(
mWifiNative, mCountryCode,
mWifiApConfigStore.getAllowed2GChannel(), localConfig);
if (result != SUCCESS) {
Log.e(TAG, "Failed to update AP band and channel");
return result;
}
// Setup country code if it is provided.
if (mCountryCode != null) {
// Country code is mandatory for 5GHz band, return an error if failed to set
// country code when AP is configured for 5GHz band.
if (!mWifiNative.setCountryCodeHal(
mApInterfaceName, mCountryCode.toUpperCase(Locale.ROOT))
&& config.apBand == WifiConfiguration.AP_BAND_5GHZ) {
Log.e(TAG, "Failed to set country code, required for setting up "
+ "soft ap in 5GHz");
return ERROR_GENERIC;
}
}
if (localConfig.hiddenSSID) {
Log.d(TAG, "SoftAP is a hidden network");
}
if (!mWifiNative.startSoftAp(mApInterfaceName, localConfig, mSoftApListener)) {
Log.e(TAG, "Soft AP start failed");
return ERROR_GENERIC;
}
Log.d(TAG, "Soft AP is started");
return SUCCESS;
}
1.12 mWifiNative.startSoftAp
//frameworks/opt/net/wifi/service/java/com/android/server/wifi/WifiNative.java
/**
* Start Soft AP operation using the provided configuration.
*
* @param ifaceName Name of the interface.
* @param config Configuration to use for the soft ap created.
* @param listener Callback for AP events.
* @return true on success, false otherwise.
*/
public boolean startSoftAp(
@NonNull String ifaceName, WifiConfiguration config, SoftApListener listener) {
if (!mWificondControl.startHostapd(ifaceName, listener)) {
Log.e(TAG, "Failed to start hostapd");
mWifiMetrics.incrementNumSetupSoftApInterfaceFailureDueToHostapd();
return false;
}
if (!waitForHostapdConnection()) {
Log.e(TAG, "Failed to establish connection to hostapd");
mWifiMetrics.incrementNumSetupSoftApInterfaceFailureDueToHostapd();
return false;
}
if (!mHostapdHal.registerDeathHandler(new HostapdDeathHandlerInternal())) {
Log.e(TAG, "Failed to register hostapd death handler");
mWifiMetrics.incrementNumSetupSoftApInterfaceFailureDueToHostapd();
return false;
}
if (!mHostapdHal.addAccessPoint(ifaceName, config)) {
Log.e(TAG, "Failed to add acccess point");
mWifiMetrics.incrementNumSetupSoftApInterfaceFailureDueToHostapd();
return false;
}
return true;
}
以上函数处理了
- mWificondControl.startHostapd
- waitForHostapdConnection
- mHostapdHal.registerDeathHandler
- mHostapdHal.addAccessPoint
就以mWificondControl.startHostapd为主线进行分析。
1.13 mWificondControl.startHostapd
//frameworks/opt/net/wifi/service/java/com/android/server/wifi/WificondControl.java
public boolean startHostapd(@NonNull String ifaceName,
SoftApListener listener) {
IApInterface iface = getApInterface(ifaceName);
if (iface == null) {
Log.e(TAG, "No valid ap interface handler");
return false;
}
try {
IApInterfaceEventCallback callback = new ApInterfaceEventCallback(listener);
mApInterfaceListeners.put(ifaceName, callback);
boolean success = iface.startHostapd(callback);
if (!success) {
Log.e(TAG, "Failed to start hostapd.");
return false;
}
} catch (RemoteException e) {
Log.e(TAG, "Exception in starting soft AP: " + e);
return false;
}
return true;
}
1.14 iface.startHostapd
//system/connectivity/wificond/aidl/android/net/wifi/IApInterface.aidl
boolean startHostapd(IApInterfaceEventCallback callback);
//system/connectivity/wificond/ap_interface_binder.h
binder::Status startHostapd(
const sp<net::wifi::IApInterfaceEventCallback>& callback,
bool* out_success) override;
1.15 ApInterfaceBinder::startHostapd
//system/connectivity/wificond/ap_interface_binder.cpp
binder::Status ApInterfaceBinder::startHostapd(
const sp<IApInterfaceEventCallback>& callback, bool* out_success) {
*out_success = false;
if (!impl_) {
LOG(WARNING) << "Cannot start hostapd on dead ApInterface.";
return binder::Status::ok();
}
*out_success = impl_->StartHostapd();
if (*out_success) {
ap_interface_event_callback_ = callback;
}
return binder::Status::ok();
}
1.16 impl_->StartHostapd()
//system/connectivity/wificond/ap_interface_impl.h
#ifndef WIFICOND_AP_INTERFACE_IMPL_H_
#define WIFICOND_AP_INTERFACE_IMPL_H_
#include <string>
#include <vector>
#include <android-base/macros.h>
#include <wifi_system/hostapd_manager.h>
#include <wifi_system/interface_tool.h>
#include "wificond/net/netlink_manager.h"
#include "android/net/wifi/IApInterface.h"
namespace android {
namespace wificond {
class ApInterfaceBinder;
class NetlinkUtils;
// Holds the guts of how we control network interfaces capable of exposing an AP
// via hostapd. Because remote processes may hold on to the corresponding
// binder object past the lifetime of the local object, we are forced to
// keep this object separate from the binder representation of itself.
class ApInterfaceImpl {
public:
ApInterfaceImpl(const std::string& interface_name,
uint32_t interface_index,
NetlinkUtils* netlink_utils,
wifi_system::InterfaceTool* if_tool,
wifi_system::HostapdManager* hostapd_manager);
~ApInterfaceImpl();
// Get a pointer to the binder representing this ApInterfaceImpl.
android::sp<android::net::wifi::IApInterface> GetBinder() const;
bool StartHostapd();
bool StopHostapd();
std::string GetInterfaceName() { return interface_name_; }
int GetNumberOfAssociatedStations() const;
void Dump(std::stringstream* ss) const;
private:
const std::string interface_name_;
const uint32_t interface_index_;
NetlinkUtils* const netlink_utils_;
wifi_system::InterfaceTool* const if_tool_;
wifi_system::HostapdManager* const hostapd_manager_;
const android::sp<ApInterfaceBinder> binder_;
// Number of associated stations.
int number_of_associated_stations_;
void OnStationEvent(StationEvent event,
const std::vector<uint8_t>& mac_address);
void OnChannelSwitchEvent(uint32_t frequency, ChannelBandwidth bandwidth);
DISALLOW_COPY_AND_ASSIGN(ApInterfaceImpl);
};
} // namespace wificond
} // namespace android
#endif // WIFICOND_AP_INTERFACE_IMPL_H_
1.17 ApInterfaceImpl::StartHostapd()
//system/connectivity/wificond/ap_interface_impl.cpp
bool ApInterfaceImpl::StartHostapd() {
return hostapd_manager_->StartHostapd();
}
总结： 工作在sofap的时候，作为AP， 工作在master模式，由后台进程hostapd做认证处理。
完~~~
文 | 力卉编程
