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 "lnn_lane_common.h"
17 
18 #include <securec.h>
19 
20 #include "lnn_lane_def.h"
21 #include "lnn_lane_interface.h"
22 #include "lnn_lane_link.h"
23 #include "lnn_log.h"
24 #include "lnn_map.h"
25 #include "message_handler.h"
26 #include "softbus_def.h"
27 #include "softbus_errcode.h"
28 
29 #define UINT_TO_STR_MAX_LEN 11
30 
31 typedef int32_t (*LinkInfoProc)(const LaneLinkInfo *, LaneConnInfo *, LaneProfile *);
32 
BrInfoProc(const LaneLinkInfo * linkInfo,LaneConnInfo * connInfo,LaneProfile * profile)33 static int32_t BrInfoProc(const LaneLinkInfo *linkInfo, LaneConnInfo *connInfo, LaneProfile *profile)
34 {
35     connInfo->type = LANE_BR;
36     if (memcpy_s(connInfo->connInfo.br.brMac, BT_MAC_LEN,
37         linkInfo->linkInfo.br.brMac, BT_MAC_LEN) != EOK) {
38         return SOFTBUS_MEM_ERR;
39     }
40     profile->linkType = LANE_BR;
41     return SOFTBUS_OK;
42 }
43 
BleInfoProc(const LaneLinkInfo * linkInfo,LaneConnInfo * connInfo,LaneProfile * profile)44 static int32_t BleInfoProc(const LaneLinkInfo *linkInfo, LaneConnInfo *connInfo, LaneProfile *profile)
45 {
46     connInfo->type = LANE_BLE;
47     if (memcpy_s(connInfo->connInfo.ble.bleMac, BT_MAC_LEN,
48         linkInfo->linkInfo.ble.bleMac, BT_MAC_LEN) != EOK) {
49         LNN_LOGE(LNN_LANE, "memcpy btMac fail");
50         return SOFTBUS_MEM_ERR;
51     }
52     if (memcpy_s(connInfo->connInfo.ble.deviceIdHash, UDID_HASH_LEN,
53         linkInfo->linkInfo.ble.deviceIdHash, UDID_HASH_LEN) != EOK) {
54         LNN_LOGE(LNN_LANE, "memcpy udidHash fail");
55         return SOFTBUS_MEM_ERR;
56     }
57     connInfo->connInfo.ble.protoType = linkInfo->linkInfo.ble.protoType;
58     connInfo->connInfo.ble.psm = linkInfo->linkInfo.ble.psm;
59     profile->linkType = LANE_BLE;
60     return SOFTBUS_OK;
61 }
62 
P2pInfoProc(const LaneLinkInfo * linkInfo,LaneConnInfo * connInfo,LaneProfile * profile)63 static int32_t P2pInfoProc(const LaneLinkInfo *linkInfo, LaneConnInfo *connInfo, LaneProfile *profile)
64 {
65     connInfo->type = LANE_P2P;
66     if (memcpy_s(&connInfo->connInfo.p2p, sizeof(P2pConnInfo),
67         &linkInfo->linkInfo.p2p.connInfo, sizeof(P2pConnInfo)) != EOK) {
68         LNN_LOGE(LNN_LANE, "memcpy P2pConnInfo fail");
69         return SOFTBUS_MEM_ERR;
70     }
71     profile->linkType = LANE_P2P;
72     profile->bw = linkInfo->linkInfo.p2p.bw;
73     profile->phyChannel = linkInfo->linkInfo.p2p.channel;
74     return SOFTBUS_OK;
75 }
76 
HmlInfoProc(const LaneLinkInfo * linkInfo,LaneConnInfo * connInfo,LaneProfile * profile)77 static int32_t HmlInfoProc(const LaneLinkInfo *linkInfo, LaneConnInfo *connInfo, LaneProfile *profile)
78 {
79     connInfo->type = LANE_HML;
80     if (memcpy_s(&connInfo->connInfo.p2p, sizeof(P2pConnInfo),
81         &linkInfo->linkInfo.p2p.connInfo, sizeof(P2pConnInfo)) != EOK) {
82         LNN_LOGE(LNN_LANE, "memcpy P2pConnInfo fail");
83         return SOFTBUS_MEM_ERR;
84     }
85     profile->linkType = LANE_HML;
86     profile->bw = linkInfo->linkInfo.p2p.bw;
87     profile->phyChannel = linkInfo->linkInfo.p2p.channel;
88     return SOFTBUS_OK;
89 }
90 
HmlRawInfoProc(const LaneLinkInfo * linkInfo,LaneConnInfo * connInfo,LaneProfile * profile)91 static int32_t HmlRawInfoProc(const LaneLinkInfo *linkInfo, LaneConnInfo *connInfo, LaneProfile *profile)
92 {
93     connInfo->type = LANE_HML_RAW;
94     if (memcpy_s(&connInfo->connInfo.rawWifiDirect, sizeof(RawWifiDirectConnInfo),
95         &linkInfo->linkInfo.rawWifiDirect, sizeof(RawWifiDirectConnInfo)) != EOK) {
96         return SOFTBUS_MEM_ERR;
97     }
98     return SOFTBUS_OK;
99 }
100 
P2pReuseInfoProc(const LaneLinkInfo * linkInfo,LaneConnInfo * connInfo,LaneProfile * profile)101 static int32_t P2pReuseInfoProc(const LaneLinkInfo *linkInfo, LaneConnInfo *connInfo, LaneProfile *profile)
102 {
103     connInfo->type = LANE_P2P_REUSE;
104     connInfo->connInfo.wlan = linkInfo->linkInfo.wlan.connInfo;
105     profile->linkType = LANE_P2P_REUSE;
106     return SOFTBUS_OK;
107 }
108 
Wlan2P4GInfoProc(const LaneLinkInfo * linkInfo,LaneConnInfo * connInfo,LaneProfile * profile)109 static int32_t Wlan2P4GInfoProc(const LaneLinkInfo *linkInfo, LaneConnInfo *connInfo, LaneProfile *profile)
110 {
111     connInfo->type = LANE_WLAN_2P4G;
112     if (memcpy_s(&connInfo->connInfo.wlan, sizeof(WlanConnInfo),
113         &linkInfo->linkInfo.wlan.connInfo, sizeof(WlanConnInfo)) != EOK) {
114         LNN_LOGE(LNN_LANE, "memcpy WlanConnInfo fail");
115         return SOFTBUS_MEM_ERR;
116     }
117     profile->linkType = LANE_WLAN_2P4G;
118     profile->bw = linkInfo->linkInfo.wlan.bw;
119     profile->phyChannel = linkInfo->linkInfo.wlan.channel;
120     return SOFTBUS_OK;
121 }
122 
Wlan5GInfoProc(const LaneLinkInfo * linkInfo,LaneConnInfo * connInfo,LaneProfile * profile)123 static int32_t Wlan5GInfoProc(const LaneLinkInfo *linkInfo, LaneConnInfo *connInfo, LaneProfile *profile)
124 {
125     connInfo->type = LANE_WLAN_5G;
126     if (memcpy_s(&connInfo->connInfo.wlan, sizeof(WlanConnInfo),
127         &linkInfo->linkInfo.wlan.connInfo, sizeof(WlanConnInfo)) != EOK) {
128         LNN_LOGE(LNN_LANE, "memcpy WlanConnInfo fail");
129         return SOFTBUS_MEM_ERR;
130     }
131     profile->linkType = LANE_WLAN_5G;
132     profile->bw = linkInfo->linkInfo.wlan.bw;
133     profile->phyChannel = linkInfo->linkInfo.wlan.channel;
134     return SOFTBUS_OK;
135 }
136 
BleDirectInfoProc(const LaneLinkInfo * linkInfo,LaneConnInfo * connInfo,LaneProfile * profile)137 static int32_t BleDirectInfoProc(const LaneLinkInfo *linkInfo, LaneConnInfo *connInfo, LaneProfile *profile)
138 {
139     if (strcpy_s(connInfo->connInfo.bleDirect.networkId, NETWORK_ID_BUF_LEN,
140         linkInfo->linkInfo.bleDirect.networkId) != EOK) {
141         LNN_LOGE(LNN_LANE, "memcpy networkId fail");
142         return SOFTBUS_STRCPY_ERR;
143     }
144     connInfo->type = LANE_BLE_DIRECT;
145     connInfo->connInfo.bleDirect.protoType = linkInfo->linkInfo.bleDirect.protoType;
146     profile->linkType = LANE_BLE_DIRECT;
147     return SOFTBUS_OK;
148 }
149 
CocInfoProc(const LaneLinkInfo * linkInfo,LaneConnInfo * connInfo,LaneProfile * profile)150 static int32_t CocInfoProc(const LaneLinkInfo *linkInfo, LaneConnInfo *connInfo, LaneProfile *profile)
151 {
152     connInfo->type = LANE_COC;
153     if (memcpy_s(connInfo->connInfo.ble.bleMac, BT_MAC_LEN,
154         linkInfo->linkInfo.ble.bleMac, BT_MAC_LEN) != EOK) {
155         LNN_LOGE(LNN_LANE, "memcpy bleMac fail");
156         return SOFTBUS_MEM_ERR;
157     }
158     if (memcpy_s(connInfo->connInfo.ble.deviceIdHash, UDID_HASH_LEN,
159         linkInfo->linkInfo.ble.deviceIdHash, UDID_HASH_LEN) != EOK) {
160         LNN_LOGE(LNN_LANE, "memcpy deviceIdHash fail");
161         return SOFTBUS_MEM_ERR;
162     }
163     connInfo->connInfo.ble.psm = linkInfo->linkInfo.ble.psm;
164     profile->linkType = LANE_COC;
165     return SOFTBUS_OK;
166 }
167 
168 static LinkInfoProc g_funcList[LANE_LINK_TYPE_BUTT] = {
169     [LANE_BR] = BrInfoProc,
170     [LANE_BLE] = BleInfoProc,
171     [LANE_P2P] = P2pInfoProc,
172     [LANE_HML] = HmlInfoProc,
173     [LANE_WLAN_2P4G] = Wlan2P4GInfoProc,
174     [LANE_WLAN_5G] = Wlan5GInfoProc,
175     [LANE_P2P_REUSE] = P2pReuseInfoProc,
176     [LANE_BLE_DIRECT] = BleDirectInfoProc,
177     [LANE_COC] = CocInfoProc,
178     // CoC reuse gatt direct
179     [LANE_COC_DIRECT] = BleDirectInfoProc,
180     [LANE_HML_RAW] = HmlRawInfoProc,
181 };
182 
LaneInfoProcess(const LaneLinkInfo * linkInfo,LaneConnInfo * connInfo,LaneProfile * profile)183 int32_t LaneInfoProcess(const LaneLinkInfo *linkInfo, LaneConnInfo *connInfo, LaneProfile *profile)
184 {
185     if ((linkInfo == NULL) || (connInfo == NULL) || (profile == NULL)) {
186         LNN_LOGE(LNN_LANE, "laneInfoProcess param invalid");
187         return SOFTBUS_INVALID_PARAM;
188     }
189     if ((linkInfo->type >= LANE_LINK_TYPE_BUTT) || (g_funcList[linkInfo->type] == NULL)) {
190         LNN_LOGE(LNN_LANE, "unsupport linkType=%{public}d", linkInfo->type);
191         return SOFTBUS_INVALID_PARAM;
192     }
193     return g_funcList[linkInfo->type](linkInfo, connInfo, profile);
194 }
195 
LnnCreateData(Map * map,uint32_t key,const void * value,uint32_t valueSize)196 int32_t LnnCreateData(Map *map, uint32_t key, const void *value, uint32_t valueSize)
197 {
198     char keyStr[UINT_TO_STR_MAX_LEN] = {0};
199     if (sprintf_s(keyStr, UINT_TO_STR_MAX_LEN, "%u", key) < 0) {
200         LNN_LOGE(LNN_LANE, "convert dataType fail");
201         return SOFTBUS_INVALID_PARAM;
202     }
203     int32_t ret = LnnMapSet(map, (const char *)keyStr, value, valueSize);
204     if (ret != SOFTBUS_OK) {
205         LNN_LOGE(LNN_LANE, "save data fail");
206         return ret;
207     }
208     return SOFTBUS_OK;
209 }
210 
LnnReadData(const Map * map,uint32_t key)211 void *LnnReadData(const Map *map, uint32_t key)
212 {
213     char keyStr[UINT_TO_STR_MAX_LEN] = {0};
214     if (sprintf_s(keyStr, UINT_TO_STR_MAX_LEN, "%u", key) < 0) {
215         LNN_LOGE(LNN_LANE, "convert dataType fail");
216         return NULL;
217     }
218     void *data = LnnMapGet(map, (const char *)keyStr);
219     return data;
220 }
221 
LnnDeleteData(Map * map,uint32_t key)222 void LnnDeleteData(Map *map, uint32_t key)
223 {
224     char keyStr[UINT_TO_STR_MAX_LEN] = {0};
225     if (sprintf_s(keyStr, UINT_TO_STR_MAX_LEN, "%u", key) < 0) {
226         LNN_LOGE(LNN_LANE, "convert dataType fail");
227         return;
228     }
229     if (LnnMapErase(map, (const char *)keyStr) != SOFTBUS_OK) {
230         LNN_LOGE(LNN_LANE, "delete data fail");
231         return;
232     }
233 }
234 
LnnGetSysTimeMs(void)235 uint64_t LnnGetSysTimeMs(void)
236 {
237     return SoftBusGetSysTimeMs();
238 }
239