Line data Source code
1 : /*
2 : *
3 : * Copyright (c) 2020-2021 Project CHIP Authors
4 : * Copyright (c) 2018 Nest Labs, Inc.
5 : *
6 : * Licensed under the Apache License, Version 2.0 (the "License");
7 : * you may not use this file except in compliance with the License.
8 : * You may obtain a copy of the License at
9 : *
10 : * http://www.apache.org/licenses/LICENSE-2.0
11 : *
12 : * Unless required by applicable law or agreed to in writing, software
13 : * distributed under the License is distributed on an "AS IS" BASIS,
14 : * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 : * See the License for the specific language governing permissions and
16 : * limitations under the License.
17 : */
18 :
19 : #pragma once
20 :
21 : #include <platform/ConnectivityManager.h>
22 : #include <platform/internal/GenericConnectivityManagerImpl.h>
23 : #include <platform/internal/GenericConnectivityManagerImpl_UDP.h>
24 : #if INET_CONFIG_ENABLE_TCP_ENDPOINT
25 : #include <platform/internal/GenericConnectivityManagerImpl_TCP.h>
26 : #endif
27 : #if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE
28 : #include <platform/internal/GenericConnectivityManagerImpl_BLE.h>
29 : #else
30 : #include <platform/internal/GenericConnectivityManagerImpl_NoBLE.h>
31 : #endif
32 : #if CHIP_DEVICE_CONFIG_ENABLE_THREAD
33 : #include <platform/internal/GenericConnectivityManagerImpl_Thread.h>
34 : #else
35 : #include <platform/internal/GenericConnectivityManagerImpl_NoThread.h>
36 : #endif
37 : #if CHIP_DEVICE_CONFIG_ENABLE_WPA
38 : #include <platform/internal/GenericConnectivityManagerImpl_WiFi.h>
39 : #else
40 : #include <platform/internal/GenericConnectivityManagerImpl_NoWiFi.h>
41 : #endif
42 :
43 : #if CHIP_DEVICE_CONFIG_ENABLE_WPA
44 : #include <platform/Linux/dbus/wpa/DBusWpa.h>
45 : #include <platform/Linux/dbus/wpa/DBusWpaBss.h>
46 : #include <platform/Linux/dbus/wpa/DBusWpaInterface.h>
47 : #include <platform/Linux/dbus/wpa/DBusWpaNetwork.h>
48 : #include <system/SystemMutex.h>
49 :
50 : #include <mutex>
51 : #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
52 : #include <wifipaf/WiFiPAFEndPoint.h>
53 : #include <wifipaf/WiFiPAFLayer.h>
54 : #endif
55 : #endif
56 :
57 : #include <platform/Linux/NetworkCommissioningDriver.h>
58 : #include <platform/NetworkCommissioning.h>
59 : #include <vector>
60 :
61 : namespace chip {
62 : namespace Inet {
63 : class IPAddress;
64 : } // namespace Inet
65 : } // namespace chip
66 :
67 : namespace chip {
68 : namespace DeviceLayer {
69 :
70 : #if CHIP_DEVICE_CONFIG_ENABLE_WPA
71 : struct GDBusWpaSupplicant
72 : {
73 : enum class WpaState
74 : {
75 : INIT,
76 : CONNECTING,
77 : CONNECTED,
78 : NOT_CONNECTED,
79 : NO_INTERFACE_PATH,
80 : GOT_INTERFACE_PATH,
81 : INTERFACE_CONNECTED,
82 : };
83 :
84 : enum class WpaScanningState
85 : {
86 : IDLE,
87 : SCANNING,
88 : };
89 :
90 : WpaState state = WpaState::INIT;
91 : WpaScanningState scanState = WpaScanningState::IDLE;
92 : WpaSupplicant1 * proxy = nullptr;
93 : WpaSupplicant1Interface * iface = nullptr;
94 : WpaSupplicant1BSS * bss = nullptr;
95 : gchar * interfacePath = nullptr;
96 : gchar * networkPath = nullptr;
97 : };
98 : #endif
99 :
100 : /**
101 : * Concrete implementation of the ConnectivityManager singleton object for Linux platforms.
102 : */
103 : class ConnectivityManagerImpl final : public ConnectivityManager,
104 : #if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE
105 : public Internal::GenericConnectivityManagerImpl_BLE<ConnectivityManagerImpl>,
106 : #else
107 : public Internal::GenericConnectivityManagerImpl_NoBLE<ConnectivityManagerImpl>,
108 : #endif
109 : #if CHIP_DEVICE_CONFIG_ENABLE_THREAD
110 : public Internal::GenericConnectivityManagerImpl_Thread<ConnectivityManagerImpl>,
111 : #else
112 : public Internal::GenericConnectivityManagerImpl_NoThread<ConnectivityManagerImpl>,
113 : #endif
114 : #if CHIP_DEVICE_CONFIG_ENABLE_WPA
115 : public Internal::GenericConnectivityManagerImpl_WiFi<ConnectivityManagerImpl>,
116 : #else
117 : public Internal::GenericConnectivityManagerImpl_NoWiFi<ConnectivityManagerImpl>,
118 : #endif
119 : public Internal::GenericConnectivityManagerImpl_UDP<ConnectivityManagerImpl>,
120 : #if INET_CONFIG_ENABLE_TCP_ENDPOINT
121 : public Internal::GenericConnectivityManagerImpl_TCP<ConnectivityManagerImpl>,
122 : #endif
123 : public Internal::GenericConnectivityManagerImpl<ConnectivityManagerImpl>
124 : {
125 : // Allow the ConnectivityManager interface class to delegate method calls to
126 : // the implementation methods provided by this class.
127 : friend class ConnectivityManager;
128 :
129 : #if CHIP_DEVICE_CONFIG_ENABLE_WPA
130 : public:
131 : void
132 : SetNetworkStatusChangeCallback(NetworkCommissioning::Internal::BaseDriver::NetworkStatusChangeCallback * statusChangeCallback)
133 : {
134 : mpStatusChangeCallback = statusChangeCallback;
135 : }
136 :
137 : CHIP_ERROR ConnectWiFiNetworkAsync(ByteSpan ssid, ByteSpan credentials,
138 : NetworkCommissioning::Internal::WirelessDriver::ConnectCallback * connectCallback);
139 : #if CHIP_DEVICE_CONFIG_ENABLE_WIFI_PDC
140 : CHIP_ERROR ConnectWiFiNetworkWithPDCAsync(ByteSpan ssid, ByteSpan networkIdentity, ByteSpan clientIdentity,
141 : const Crypto::P256Keypair & clientIdentityKeypair,
142 : NetworkCommissioning::Internal::WirelessDriver::ConnectCallback * connectCallback);
143 : #endif // CHIP_DEVICE_CONFIG_ENABLE_WIFI_PDC
144 : #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
145 : CHIP_ERROR _WiFiPAFSubscribe(const uint16_t & connDiscriminator, void * appState, OnConnectionCompleteFunct onSuccess,
146 : OnConnectionErrorFunct onError);
147 : CHIP_ERROR _WiFiPAFCancelSubscribe(uint32_t SubscribeId);
148 : CHIP_ERROR _WiFiPAFCancelIncompleteSubscribe();
149 : void OnDiscoveryResult(GVariant * obj);
150 : void OnReplied(GVariant * obj);
151 : void OnNanReceive(GVariant * obj);
152 : void OnNanPublishTerminated(guint public_id, gchar * reason);
153 : void OnNanSubscribeTerminated(guint subscribe_id, gchar * reason);
154 : CHIP_ERROR _WiFiPAFSend(const WiFiPAF::WiFiPAFSession & TxInfo, chip::System::PacketBufferHandle && msgBuf);
155 : void _WiFiPafSetApFreq(const uint16_t freq) { mApFreq = freq; }
156 : CHIP_ERROR _WiFiPAFShutdown(uint32_t id, WiFiPAF::WiFiPafRole role);
157 : #endif
158 :
159 : void PostNetworkConnect();
160 : CHIP_ERROR CommitConfig();
161 :
162 : void StartWiFiManagement();
163 : bool IsWiFiManagementStarted();
164 : void StartNonConcurrentWiFiManagement();
165 : int32_t GetDisconnectReason();
166 : CHIP_ERROR GetWiFiBssId(MutableByteSpan & value);
167 : CHIP_ERROR GetWiFiSecurityType(app::Clusters::WiFiNetworkDiagnostics::SecurityTypeEnum & securityType);
168 : CHIP_ERROR GetWiFiVersion(app::Clusters::WiFiNetworkDiagnostics::WiFiVersionEnum & wiFiVersion);
169 : CHIP_ERROR GetConfiguredNetwork(NetworkCommissioning::Network & network);
170 : CHIP_ERROR StartWiFiScan(ByteSpan ssid, NetworkCommissioning::WiFiDriver::ScanCallback * callback);
171 :
172 : private:
173 : CHIP_ERROR _ConnectWiFiNetworkAsync(GVariant * networkArgs,
174 : NetworkCommissioning::Internal::WirelessDriver::ConnectCallback * connectCallback)
175 : CHIP_REQUIRES(mWpaSupplicantMutex);
176 : void _ConnectWiFiNetworkAsyncCallback(GObject * sourceObject, GAsyncResult * res);
177 : #endif
178 :
179 : public:
180 : const char * GetEthernetIfName() { return (mEthIfName[0] == '\0') ? nullptr : mEthIfName; }
181 :
182 : #if CHIP_DEVICE_CONFIG_ENABLE_WIFI
183 : const char * GetWiFiIfName() { return (sWiFiIfName[0] == '\0') ? nullptr : sWiFiIfName; }
184 : #endif
185 :
186 : private:
187 : // ===== Members that implement the ConnectivityManager abstract interface.
188 :
189 : struct WiFiNetworkScanned
190 : {
191 : // The fields matches WiFiInterfaceScanResult::Type.
192 : uint8_t ssid[Internal::kMaxWiFiSSIDLength];
193 : uint8_t ssidLen;
194 : uint8_t bssid[6];
195 : int8_t rssi;
196 : uint16_t frequencyBand;
197 : uint8_t channel;
198 : uint8_t security;
199 : };
200 :
201 : CHIP_ERROR _Init();
202 : void _OnPlatformEvent(const ChipDeviceEvent * event);
203 :
204 : #if CHIP_DEVICE_CONFIG_ENABLE_WPA
205 : WiFiStationMode _GetWiFiStationMode();
206 : CHIP_ERROR _SetWiFiStationMode(ConnectivityManager::WiFiStationMode val);
207 : System::Clock::Timeout _GetWiFiStationReconnectInterval();
208 : CHIP_ERROR _SetWiFiStationReconnectInterval(System::Clock::Timeout val);
209 : bool _IsWiFiStationEnabled();
210 : bool _IsWiFiStationConnected();
211 : bool _IsWiFiStationApplicationControlled();
212 : bool _IsWiFiStationProvisioned();
213 : void _ClearWiFiStationProvision();
214 : bool _CanStartWiFiScan();
215 :
216 : WiFiAPMode _GetWiFiAPMode();
217 : CHIP_ERROR _SetWiFiAPMode(WiFiAPMode val);
218 : bool _IsWiFiAPActive();
219 : bool _IsWiFiAPApplicationControlled();
220 : void _DemandStartWiFiAP();
221 : void _StopOnDemandWiFiAP();
222 : void _MaintainOnDemandWiFiAP();
223 : System::Clock::Timeout _GetWiFiAPIdleTimeout();
224 : void _SetWiFiAPIdleTimeout(System::Clock::Timeout val);
225 : void UpdateNetworkStatus();
226 : CHIP_ERROR StopAutoScan();
227 :
228 : void _OnWpaProxyReady(GObject * sourceObject, GAsyncResult * res);
229 : void _OnWpaInterfaceRemoved(WpaSupplicant1 * proxy, const char * path, GVariant * properties);
230 : void _OnWpaInterfaceAdded(WpaSupplicant1 * proxy, const char * path, GVariant * properties);
231 : void _OnWpaPropertiesChanged(WpaSupplicant1Interface * proxy, GVariant * properties);
232 : void _OnWpaInterfaceScanDone(WpaSupplicant1Interface * proxy, gboolean success);
233 : void _OnWpaInterfaceReady(GObject * sourceObject, GAsyncResult * res);
234 : void _OnWpaInterfaceProxyReady(GObject * sourceObject, GAsyncResult * res);
235 : void _OnWpaBssProxyReady(GObject * sourceObject, GAsyncResult * res);
236 : #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF
237 : OnConnectionCompleteFunct mOnPafSubscribeComplete;
238 : OnConnectionErrorFunct mOnPafSubscribeError;
239 : WiFiPAF::WiFiPAFLayer * pmWiFiPAF;
240 : WiFiPAF::WiFiPAFEndPoint mWiFiPAFEndPoint;
241 : void * mAppState;
242 : uint16_t mApFreq;
243 : CHIP_ERROR _WiFiPAFPublish(WiFiPAFAdvertiseParam & args);
244 : CHIP_ERROR _WiFiPAFCancelPublish(uint32_t PublishId);
245 : #endif
246 :
247 : bool _GetBssInfo(const gchar * bssPath, NetworkCommissioning::WiFiScanResponse & result);
248 :
249 : CHIP_ERROR _StartWiFiManagement();
250 :
251 : bool mAssociationStarted = false;
252 : BitFlags<ConnectivityFlags> mConnectivityFlag;
253 : GDBusWpaSupplicant mWpaSupplicant CHIP_GUARDED_BY(mWpaSupplicantMutex);
254 : // Access to mWpaSupplicant has to be protected by a mutex because it is accessed from
255 : // the CHIP event loop thread and dedicated D-Bus thread started by platform manager.
256 : std::mutex mWpaSupplicantMutex;
257 :
258 : NetworkCommissioning::Internal::BaseDriver::NetworkStatusChangeCallback * mpStatusChangeCallback = nullptr;
259 : #endif
260 :
261 : // ==================== ConnectivityManager Private Methods ====================
262 :
263 : #if CHIP_DEVICE_CONFIG_ENABLE_WPA
264 : void DriveAPState();
265 : CHIP_ERROR ConfigureWiFiAP();
266 : void ChangeWiFiAPState(WiFiAPState newState);
267 : static void DriveAPState(::chip::System::Layer * aLayer, void * aAppState);
268 : #endif
269 :
270 : // ===== Members for internal use by the following friends.
271 :
272 : friend ConnectivityManager & ConnectivityMgr();
273 : friend ConnectivityManagerImpl & ConnectivityMgrImpl();
274 :
275 : static ConnectivityManagerImpl sInstance;
276 :
277 : // ===== Private members reserved for use by this class only.
278 :
279 : char mEthIfName[Inet::InterfaceId::kMaxIfNameLength];
280 :
281 : #if CHIP_DEVICE_CONFIG_ENABLE_WPA
282 : ConnectivityManager::WiFiStationMode mWiFiStationMode;
283 : ConnectivityManager::WiFiAPMode mWiFiAPMode;
284 : WiFiAPState mWiFiAPState;
285 : System::Clock::Timestamp mLastAPDemandTime;
286 : System::Clock::Timeout mWiFiStationReconnectInterval;
287 : System::Clock::Timeout mWiFiAPIdleTimeout;
288 : #endif
289 :
290 : #if CHIP_DEVICE_CONFIG_ENABLE_WIFI
291 : char sWiFiIfName[Inet::InterfaceId::kMaxIfNameLength];
292 : #endif
293 :
294 : #if CHIP_DEVICE_CONFIG_ENABLE_WPA
295 : uint8_t sInterestedSSID[Internal::kMaxWiFiSSIDLength];
296 : uint8_t sInterestedSSIDLen;
297 : #endif
298 : NetworkCommissioning::WiFiDriver::ScanCallback * mpScanCallback;
299 : NetworkCommissioning::Internal::WirelessDriver::ConnectCallback * mpConnectCallback;
300 : };
301 :
302 : #if CHIP_DEVICE_CONFIG_ENABLE_WPA
303 : inline ConnectivityManager::WiFiAPMode ConnectivityManagerImpl::_GetWiFiAPMode()
304 : {
305 : return mWiFiAPMode;
306 : }
307 :
308 : inline bool ConnectivityManagerImpl::_IsWiFiAPActive()
309 : {
310 : return mWiFiAPState == kWiFiAPState_Active;
311 : }
312 :
313 : inline bool ConnectivityManagerImpl::_IsWiFiAPApplicationControlled()
314 : {
315 : return mWiFiAPMode == kWiFiAPMode_ApplicationControlled;
316 : }
317 :
318 : inline System::Clock::Timeout ConnectivityManagerImpl::_GetWiFiAPIdleTimeout()
319 : {
320 : return mWiFiAPIdleTimeout;
321 : }
322 :
323 : #endif
324 :
325 : /**
326 : * Returns the public interface of the ConnectivityManager singleton object.
327 : *
328 : * chip applications should use this to access features of the ConnectivityManager object
329 : * that are common to all platforms.
330 : */
331 54 : inline ConnectivityManager & ConnectivityMgr()
332 : {
333 54 : return ConnectivityManagerImpl::sInstance;
334 : }
335 :
336 : /**
337 : * Returns the platform-specific implementation of the ConnectivityManager singleton object.
338 : *
339 : * chip applications can use this to gain access to features of the ConnectivityManager
340 : * that are specific to the ESP32 platform.
341 : */
342 0 : inline ConnectivityManagerImpl & ConnectivityMgrImpl()
343 : {
344 0 : return ConnectivityManagerImpl::sInstance;
345 : }
346 :
347 : } // namespace DeviceLayer
348 : } // namespace chip
|
