1 /*
2 * Copyright (c) 2021 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_node_info.h"
17
18 #include <string.h>
19
20 #include <securec.h>
21
22 #include "softbus_errcode.h"
23 #include "softbus_log.h"
24
LnnHasDiscoveryType(const NodeInfo * info,DiscoveryType type)25 bool LnnHasDiscoveryType(const NodeInfo *info, DiscoveryType type)
26 {
27 if (info == NULL || type >= DISCOVERY_TYPE_COUNT) {
28 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
29 return false;
30 }
31 if (((uint32_t)info->discoveryType & (1 << (uint32_t)type)) != 0) {
32 return true;
33 }
34 return false;
35 }
36
LnnGetDeviceUdid(const NodeInfo * info)37 const char *LnnGetDeviceUdid(const NodeInfo *info)
38 {
39 if (info == NULL) {
40 return NULL;
41 }
42 return info->deviceInfo.deviceUdid;
43 }
44
LnnSetDeviceUdid(NodeInfo * info,const char * udid)45 int32_t LnnSetDeviceUdid(NodeInfo *info, const char *udid)
46 {
47 if (info == NULL || udid == NULL) {
48 return SOFTBUS_INVALID_PARAM;
49 }
50 if (strncpy_s(info->deviceInfo.deviceUdid, UDID_BUF_LEN, udid, strlen(udid)) != EOK) {
51 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "STR COPY ERROR!");
52 return SOFTBUS_MEM_ERR;
53 }
54 return SOFTBUS_OK;
55 }
56
LnnSetDiscoveryType(NodeInfo * info,DiscoveryType type)57 int32_t LnnSetDiscoveryType(NodeInfo *info, DiscoveryType type)
58 {
59 if (info == NULL || type >= DISCOVERY_TYPE_COUNT) {
60 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
61 return SOFTBUS_INVALID_PARAM;
62 }
63 info->discoveryType = (uint32_t)info->discoveryType | (1 << (uint32_t)type);
64 return SOFTBUS_OK;
65 }
66
LnnClearDiscoveryType(NodeInfo * info,DiscoveryType type)67 int32_t LnnClearDiscoveryType(NodeInfo *info, DiscoveryType type)
68 {
69 if (info == NULL || type >= DISCOVERY_TYPE_COUNT) {
70 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
71 return SOFTBUS_INVALID_PARAM;
72 }
73 info->discoveryType = (uint32_t)info->discoveryType & ~(1 << (uint32_t)type);
74 return SOFTBUS_OK;
75 }
76
LnnIsNodeOnline(const NodeInfo * info)77 bool LnnIsNodeOnline(const NodeInfo *info)
78 {
79 if (info == NULL) {
80 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
81 return false;
82 }
83 return (info->status == STATUS_ONLINE);
84 }
85
LnnSetNodeConnStatus(NodeInfo * info,ConnectStatus status)86 void LnnSetNodeConnStatus(NodeInfo *info, ConnectStatus status)
87 {
88 if (info == NULL) {
89 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!!!");
90 return;
91 }
92 info->status = status;
93 }
94
LnnGetBtMac(const NodeInfo * info)95 const char *LnnGetBtMac(const NodeInfo *info)
96 {
97 if (info == NULL) {
98 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
99 return DEFAULT_MAC;
100 }
101 return info->connectInfo.macAddr;
102 }
103
LnnSetBtMac(NodeInfo * info,const char * mac)104 void LnnSetBtMac(NodeInfo *info, const char *mac)
105 {
106 if (info == NULL || mac == NULL) {
107 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "PARA ERROR!");
108 return;
109 }
110 if (strncpy_s(info->connectInfo.macAddr, MAC_LEN, mac, strlen(mac)) != EOK) {
111 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "str copy error!");
112 }
113 return;
114 }
115
LnnGetNetIfName(const NodeInfo * info)116 const char *LnnGetNetIfName(const NodeInfo *info)
117 {
118 if (info == NULL) {
119 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
120 return DEFAULT_MAC;
121 }
122 return info->connectInfo.netIfName;
123 }
124
LnnSetNetIfName(NodeInfo * info,const char * netIfName)125 void LnnSetNetIfName(NodeInfo *info, const char *netIfName)
126 {
127 if (info == NULL || netIfName == NULL) {
128 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "PARA ERROR!");
129 return;
130 }
131 if (strncpy_s(info->connectInfo.netIfName, NET_IF_NAME_LEN, netIfName, strlen(netIfName)) != EOK) {
132 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "str copy error!");
133 }
134 return;
135 }
136
LnnGetWiFiIp(const NodeInfo * info)137 const char *LnnGetWiFiIp(const NodeInfo *info)
138 {
139 if (info == NULL) {
140 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "PARA error!");
141 return DEFAULT_IP;
142 }
143 return info->connectInfo.deviceIp;
144 }
145
LnnSetWiFiIp(NodeInfo * info,const char * ip)146 void LnnSetWiFiIp(NodeInfo *info, const char *ip)
147 {
148 if (info == NULL || ip == NULL) {
149 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "PARA ERROR!");
150 return;
151 }
152 if (strncpy_s(info->connectInfo.deviceIp, sizeof(info->connectInfo.deviceIp), ip, strlen(ip)) != EOK) {
153 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "STR COPY ERROR!");
154 }
155 return;
156 }
157
LnnGetMasterUdid(const NodeInfo * info)158 const char *LnnGetMasterUdid(const NodeInfo *info)
159 {
160 if (info == NULL) {
161 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "PARA ERROR!");
162 return NULL;
163 }
164 return info->masterUdid;
165 }
166
LnnSetMasterUdid(NodeInfo * info,const char * udid)167 int32_t LnnSetMasterUdid(NodeInfo *info, const char *udid)
168 {
169 if (info == NULL || udid == NULL) {
170 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "PARA ERROR!");
171 return SOFTBUS_INVALID_PARAM;
172 }
173 if (strncpy_s(info->masterUdid, UDID_BUF_LEN, udid, strlen(udid)) != EOK) {
174 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "STR COPY ERROR!");
175 return SOFTBUS_ERR;
176 }
177 return SOFTBUS_OK;
178 }
179
LnnGetAuthPort(const NodeInfo * info)180 int32_t LnnGetAuthPort(const NodeInfo *info)
181 {
182 if (info == NULL) {
183 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error");
184 return SOFTBUS_INVALID_PARAM;
185 }
186 return info->connectInfo.authPort;
187 }
188
LnnSetAuthPort(NodeInfo * info,int32_t port)189 int32_t LnnSetAuthPort(NodeInfo *info, int32_t port)
190 {
191 if (info == NULL) {
192 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error.");
193 return SOFTBUS_INVALID_PARAM;
194 }
195 info->connectInfo.authPort = port;
196 return SOFTBUS_OK;
197 }
198
LnnGetSessionPort(const NodeInfo * info)199 int32_t LnnGetSessionPort(const NodeInfo *info)
200 {
201 if (info == NULL) {
202 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
203 return SOFTBUS_INVALID_PARAM;
204 }
205 return info->connectInfo.sessionPort;
206 }
207
LnnSetSessionPort(NodeInfo * info,int32_t port)208 int32_t LnnSetSessionPort(NodeInfo *info, int32_t port)
209 {
210 if (info == NULL) {
211 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
212 return SOFTBUS_INVALID_PARAM;
213 }
214 info->connectInfo.sessionPort = port;
215 return SOFTBUS_OK;
216 }
217
LnnGetProxyPort(const NodeInfo * info)218 int32_t LnnGetProxyPort(const NodeInfo *info)
219 {
220 if (info == NULL) {
221 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
222 return SOFTBUS_INVALID_PARAM;
223 }
224 return info->connectInfo.proxyPort;
225 }
226
LnnSetProxyPort(NodeInfo * info,int32_t port)227 int32_t LnnSetProxyPort(NodeInfo *info, int32_t port)
228 {
229 if (info == NULL) {
230 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
231 return SOFTBUS_OK;
232 }
233 info->connectInfo.proxyPort = port;
234 return SOFTBUS_OK;
235 }
236
LnnSetP2pRole(NodeInfo * info,int32_t p2pRole)237 int32_t LnnSetP2pRole(NodeInfo *info, int32_t p2pRole)
238 {
239 if (info == NULL) {
240 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:invalid param.", __func__);
241 return SOFTBUS_INVALID_PARAM;
242 }
243 info->p2pInfo.p2pRole = p2pRole;
244 return SOFTBUS_OK;
245 }
246
LnnGetP2pRole(const NodeInfo * info)247 int32_t LnnGetP2pRole(const NodeInfo *info)
248 {
249 if (info == NULL) {
250 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:invalid param.", __func__);
251 return 0;
252 }
253 return info->p2pInfo.p2pRole;
254 }
255
LnnSetP2pMac(NodeInfo * info,const char * p2pMac)256 int32_t LnnSetP2pMac(NodeInfo *info, const char *p2pMac)
257 {
258 if (info == NULL || p2pMac == NULL) {
259 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:invalid param.", __func__);
260 return SOFTBUS_INVALID_PARAM;
261 }
262 if (strcpy_s(info->p2pInfo.p2pMac, sizeof(info->p2pInfo.p2pMac), p2pMac) != EOK) {
263 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "strcpy_s p2p mac err.");
264 return SOFTBUS_MEM_ERR;
265 }
266 return SOFTBUS_OK;
267 }
268
LnnGetP2pMac(const NodeInfo * info)269 const char *LnnGetP2pMac(const NodeInfo *info)
270 {
271 if (info == NULL) {
272 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:invalid param.", __func__);
273 return NULL;
274 }
275 return info->p2pInfo.p2pMac;
276 }
277
LnnSetDataChangeFlag(NodeInfo * info,uint16_t dataChangeFlag)278 int32_t LnnSetDataChangeFlag(NodeInfo *info, uint16_t dataChangeFlag)
279 {
280 if (info == NULL) {
281 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:invalid param.", __func__);
282 return SOFTBUS_INVALID_PARAM;
283 }
284 info->dataChangeFlag = dataChangeFlag;
285 return SOFTBUS_OK;
286 }
287
LnnGetDataChangeFlag(const NodeInfo * info)288 uint16_t LnnGetDataChangeFlag(const NodeInfo *info)
289 {
290 if (info == NULL) {
291 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:invalid param.", __func__);
292 return 0;
293 }
294 return info->dataChangeFlag;
295 }
296
LnnSetP2pGoMac(NodeInfo * info,const char * goMac)297 int32_t LnnSetP2pGoMac(NodeInfo *info, const char *goMac)
298 {
299 if (info == NULL || goMac == NULL) {
300 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:invalid param.", __func__);
301 return SOFTBUS_INVALID_PARAM;
302 }
303
304 if (strcpy_s(info->p2pInfo.goMac, sizeof(info->p2pInfo.goMac), goMac) != EOK) {
305 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "strcpy_s go mac err.");
306 return SOFTBUS_MEM_ERR;
307 }
308 return SOFTBUS_OK;
309 }
310
LnnGetP2pGoMac(const NodeInfo * info)311 const char *LnnGetP2pGoMac(const NodeInfo *info)
312 {
313 if (info == NULL) {
314 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:invalid param.", __func__);
315 return NULL;
316 }
317 return info->p2pInfo.goMac;
318 }
319
LnnGetSupportedProtocols(const NodeInfo * info)320 uint64_t LnnGetSupportedProtocols(const NodeInfo *info)
321 {
322 if (info == NULL) {
323 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "%s:invalid param.", __func__);
324 return 0;
325 }
326 return info->supportedProtocols;
327 }
328
LnnSetSupportedProtocols(NodeInfo * info,uint64_t protocols)329 int32_t LnnSetSupportedProtocols(NodeInfo *info, uint64_t protocols)
330 {
331 if (info == NULL) {
332 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "para error!");
333 return SOFTBUS_OK;
334 }
335 info->supportedProtocols = protocols;
336 return SOFTBUS_OK;
337 }
338