1 /*
2 * Copyright (C) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "../../../interfaces/kits/c/wifi_hid2d.h"
17 #include "../../../interfaces/inner_api/wifi_hid2d.h"
18 #include "define.h"
19 #include "wifi_logger.h"
20 #include "wifi_c_utils.h"
21 #include "wifi_common_util.h"
22 #include "../../../interfaces/kits/c/wifi_device.h"
23
24 DEFINE_WIFILOG_LABEL("WifiCHid2d");
25
26 std::unique_ptr<OHOS::Wifi::Hid2d> wifiHid2dPtr = OHOS::Wifi::Hid2d::GetInstance(WIFI_P2P_ABILITY_ID);
27
Hid2dRequestGcIp(const unsigned char gcMac[MAC_LEN],unsigned int ipAddr[IPV4_ARRAY_LEN])28 NO_SANITIZE("cfi") WifiErrorCode Hid2dRequestGcIp(const unsigned char gcMac[MAC_LEN],
29 unsigned int ipAddr[IPV4_ARRAY_LEN])
30 {
31 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
32
33 std::string strMac = OHOS::Wifi::MacArrayToStr(gcMac);
34 std::string strIpAddr;
35 OHOS::Wifi::ErrCode ret = wifiHid2dPtr->Hid2dRequestGcIp(strMac, strIpAddr);
36 if (ret != OHOS::Wifi::WIFI_OPT_SUCCESS) {
37 WIFI_LOGE("Request gc ip failed!");
38 return ERROR_WIFI_UNKNOWN;
39 }
40 return OHOS::Wifi::IpStrToArray(strIpAddr, ipAddr);
41 }
42
Hid2dSharedlinkIncrease(void)43 NO_SANITIZE("cfi") WifiErrorCode Hid2dSharedlinkIncrease(void)
44 {
45 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
46 return GetCErrorCode(wifiHid2dPtr->Hid2dSharedlinkIncrease());
47 }
48
Hid2dSharedlinkDecrease(void)49 NO_SANITIZE("cfi") WifiErrorCode Hid2dSharedlinkDecrease(void)
50 {
51 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
52 return GetCErrorCode(wifiHid2dPtr->Hid2dSharedlinkDecrease());
53 }
54
Hid2dCreateGroup(const int frequency,FreqType type)55 NO_SANITIZE("cfi") WifiErrorCode Hid2dCreateGroup(const int frequency, FreqType type)
56 {
57 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
58 return GetCErrorCode(wifiHid2dPtr->Hid2dCreateGroup(frequency, OHOS::Wifi::FreqType(static_cast<int>(type))));
59 }
60
Hid2dRemoveGcGroup(const char gcIfName[IF_NAME_LEN])61 NO_SANITIZE("cfi") WifiErrorCode Hid2dRemoveGcGroup(const char gcIfName[IF_NAME_LEN])
62 {
63 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
64 return GetCErrorCode(wifiHid2dPtr->Hid2dRemoveGcGroup(gcIfName));
65 }
66
Hid2dConnect(const Hid2dConnectConfig * config)67 NO_SANITIZE("cfi") WifiErrorCode Hid2dConnect(const Hid2dConnectConfig *config)
68 {
69 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
70 CHECK_PTR_RETURN(config, ERROR_WIFI_INVALID_ARGS);
71
72 OHOS::Wifi::Hid2dConnectConfig cppConfig;
73 cppConfig.SetSsid(config->ssid);
74 cppConfig.SetBssid(OHOS::Wifi::MacArrayToStr(config->bssid));
75 cppConfig.SetPreSharedKey(config->preSharedKey);
76 cppConfig.SetFrequency(config->frequency);
77 cppConfig.SetDhcpMode(OHOS::Wifi::DhcpMode(static_cast<int>(config->dhcpMode)));
78 return GetCErrorCode(wifiHid2dPtr->Hid2dConnect(cppConfig));
79 }
80
Hid2dConfigIPAddr(const char ifName[IF_NAME_LEN],const IpAddrInfo * ipInfo)81 NO_SANITIZE("cfi") WifiErrorCode Hid2dConfigIPAddr(const char ifName[IF_NAME_LEN], const IpAddrInfo* ipInfo)
82 {
83 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
84 CHECK_PTR_RETURN(ipInfo, ERROR_WIFI_INVALID_ARGS);
85
86 OHOS::Wifi::IpAddrInfo ipAddrInfo;
87 ipAddrInfo.ip = OHOS::Wifi::IpArrayToStr(ipInfo->ip);
88 ipAddrInfo.gateway = OHOS::Wifi::IpArrayToStr(ipInfo->gateway);
89 ipAddrInfo.netmask = OHOS::Wifi::IpArrayToStr(ipInfo->netmask);
90 return GetCErrorCode(wifiHid2dPtr->Hid2dConfigIPAddr(ifName, ipAddrInfo));
91 }
92
Hid2dReleaseIPAddr(const char ifName[IF_NAME_LEN])93 NO_SANITIZE("cfi") WifiErrorCode Hid2dReleaseIPAddr(const char ifName[IF_NAME_LEN])
94 {
95 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
96 return GetCErrorCode(wifiHid2dPtr->Hid2dReleaseIPAddr(ifName));
97 }
98
ConvertRecommendChannelRequest(const RecommendChannelRequest * request,OHOS::Wifi::RecommendChannelRequest & req)99 static void ConvertRecommendChannelRequest(const RecommendChannelRequest *request,
100 OHOS::Wifi::RecommendChannelRequest& req)
101 {
102 CHECK_PTR_RETURN_VOID(request);
103 req.remoteIfName = request->remoteIfName;
104 req.remoteIfMode = request->remoteIfMode;
105 req.localIfName = request->localIfName;
106 req.localIfMode = request->localIfMode;
107 req.prefBand = request->prefBand;
108 req.prefBandwidth = OHOS::Wifi::PreferBandwidth(static_cast<int>(request->prefBandwidth));
109 }
110
ConvertRecommendChannelResponse(const OHOS::Wifi::RecommendChannelResponse & rsp,RecommendChannelResponse * response)111 static void ConvertRecommendChannelResponse(const OHOS::Wifi::RecommendChannelResponse& rsp,
112 RecommendChannelResponse* response)
113 {
114 CHECK_PTR_RETURN_VOID(response);
115 response->status = RecommendStatus(static_cast<int>(rsp.status));
116 response->index = rsp.index;
117 response->centerFreq = rsp.centerFreq;
118 response->centerFreq1 = rsp.centerFreq1;
119 response->centerFreq2 = rsp.centerFreq2;
120 response->bandwidth = rsp.bandwidth;
121 }
122
Hid2dGetRecommendChannel(const RecommendChannelRequest * request,RecommendChannelResponse * response)123 NO_SANITIZE("cfi") WifiErrorCode Hid2dGetRecommendChannel(const RecommendChannelRequest *request,
124 RecommendChannelResponse *response)
125 {
126 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
127 CHECK_PTR_RETURN(request, ERROR_WIFI_INVALID_ARGS);
128 CHECK_PTR_RETURN(response, ERROR_WIFI_INVALID_ARGS);
129 OHOS::Wifi::RecommendChannelRequest req;
130 OHOS::Wifi::RecommendChannelResponse rsp;
131 ConvertRecommendChannelRequest(request, req);
132 OHOS::Wifi::ErrCode retCode = wifiHid2dPtr->Hid2dGetRecommendChannel(req, rsp);
133 if (retCode != OHOS::Wifi::WIFI_OPT_SUCCESS) {
134 return GetCErrorCode(retCode);
135 }
136 ConvertRecommendChannelResponse(rsp, response);
137 return WIFI_SUCCESS;
138 }
139
Hid2dGetChannelListFor5G(int * chanList,int len)140 NO_SANITIZE("cfi") WifiErrorCode Hid2dGetChannelListFor5G(int *chanList, int len)
141 {
142 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
143 CHECK_PTR_RETURN(chanList, ERROR_WIFI_INVALID_ARGS);
144
145 std::vector<int> vecChannelList;
146 OHOS::Wifi::ErrCode ret = wifiHid2dPtr->Hid2dGetChannelListFor5G(vecChannelList);
147 if (ret == OHOS::Wifi::WIFI_OPT_SUCCESS) {
148 size_t idx = 0;
149 for (; idx != vecChannelList.size() && (int)(idx + 1) < len; ++idx) {
150 *chanList = vecChannelList[idx];
151 ++chanList;
152 }
153 if (idx != vecChannelList.size()) {
154 WIFI_LOGW("Get channel list for 5G, `chanList` is too small!");
155 }
156 *chanList = 0;
157 }
158 return GetCErrorCode(ret);
159 }
160
Hid2dGetSelfWifiCfgInfo(SelfCfgType cfgType,char cfgData[CFG_DATA_MAX_BYTES],int * getDatValidLen)161 NO_SANITIZE("cfi") WifiErrorCode Hid2dGetSelfWifiCfgInfo(SelfCfgType cfgType,
162 char cfgData[CFG_DATA_MAX_BYTES], int* getDatValidLen)
163 {
164 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
165 CHECK_PTR_RETURN(getDatValidLen, ERROR_WIFI_INVALID_ARGS);
166 return GetCErrorCode(wifiHid2dPtr->Hid2dGetSelfWifiCfgInfo(
167 OHOS::Wifi::SelfCfgType(static_cast<int>(cfgType)), cfgData, getDatValidLen));
168 }
169
Hid2dSetPeerWifiCfgInfo(PeerCfgType cfgType,char cfgData[CFG_DATA_MAX_BYTES],int setDataValidLen)170 NO_SANITIZE("cfi") WifiErrorCode Hid2dSetPeerWifiCfgInfo(PeerCfgType cfgType,
171 char cfgData[CFG_DATA_MAX_BYTES], int setDataValidLen)
172 {
173 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
174 return GetCErrorCode(wifiHid2dPtr->Hid2dSetPeerWifiCfgInfo(
175 OHOS::Wifi::PeerCfgType(static_cast<int>(cfgType)), cfgData, setDataValidLen));
176 }
177
Hid2dIsWideBandwidthSupported(void)178 int Hid2dIsWideBandwidthSupported(void)
179 {
180 constexpr int NOT_SUPPORT = 0; // false
181 return NOT_SUPPORT;
182 }
183
Hid2dSetUpperScene(const char ifName[IF_NAME_LEN],const Hid2dUpperScene * scene)184 NO_SANITIZE("cfi") WifiErrorCode Hid2dSetUpperScene(const char ifName[IF_NAME_LEN], const Hid2dUpperScene *scene)
185 {
186 CHECK_PTR_RETURN(wifiHid2dPtr, ERROR_WIFI_NOT_AVAILABLE);
187 CHECK_PTR_RETURN(scene, ERROR_WIFI_INVALID_ARGS);
188 OHOS::Wifi::Hid2dUpperScene upperScene;
189 upperScene.mac = OHOS::Wifi::MacArrayToStr(scene->mac);
190 upperScene.scene = scene->scene;
191 upperScene.fps = scene->fps;
192 upperScene.bw = scene->bw;
193 return GetCErrorCode(wifiHid2dPtr->Hid2dSetUpperScene(ifName, upperScene));
194 }
195