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 "auth_tcp_connection.h"
17
18 #include <securec.h>
19
20 #include "auth_channel.h"
21 #include "auth_common.h"
22 #include "bus_center_manager.h"
23 #include "softbus_adapter_mem.h"
24 #include "softbus_adapter_socket.h"
25 #include "softbus_base_listener.h"
26 #include "softbus_socket.h"
27
28 #define MAGIC_NUMBER 0xBABEFACE
29 #define AUTH_PKT_HEAD_LEN 24
30 #define AUTH_KEEP_ALIVE_TIME_INTERVAL (10 * 60)
31 #define AUTH_SOCKET_MAX_DATA_LEN (64 * 1024)
32
33 typedef struct {
34 int32_t magic;
35 int32_t module;
36 int64_t seq;
37 int32_t flag;
38 uint32_t len;
39 } SocketPktHead;
40
41 typedef struct {
42 int32_t module;
43 AuthChannelListener listener;
44 } InnerChannelListener;
45
46 static InnerChannelListener g_listener[] = {
47 {
48 .module = MODULE_AUTH_CHANNEL,
49 .listener = { NULL, NULL },
50 },
51 {
52 .module = MODULE_AUTH_MSG,
53 .listener = { NULL, NULL },
54 },
55 };
56
57 static SocketCallback g_callback = {NULL, NULL, NULL};
58
59 static void NotifyChannelDisconnected(int32_t channelId);
60 static void NotifyChannelDataReceived(int32_t channelId, const SocketPktHead *head, const uint8_t *data);
61
GetSocketPktSize(uint32_t len)62 static uint32_t GetSocketPktSize(uint32_t len)
63 {
64 return AUTH_PKT_HEAD_LEN + len;
65 }
66
PackSocketPkt(const SocketPktHead * pktHead,const uint8_t * data,uint8_t * buf,uint32_t size)67 static int32_t PackSocketPkt(const SocketPktHead *pktHead, const uint8_t *data,
68 uint8_t *buf, uint32_t size)
69 {
70 if (size < GetSocketPktSize(pktHead->len)) {
71 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "SocketPkt: buffer not enough.");
72 return SOFTBUS_NO_ENOUGH_DATA;
73 }
74 uint32_t offset = 0;
75 *(uint32_t *)buf = SoftBusHtoLl((uint32_t)pktHead->magic);
76 offset += sizeof(uint32_t);
77 *(uint32_t *)(buf + offset) = SoftBusHtoLl((uint32_t)pktHead->module);
78 offset += sizeof(uint32_t);
79 *(uint64_t *)(buf + offset) = SoftBusHtoLll((uint64_t)pktHead->seq);
80 offset += sizeof(uint64_t);
81 *(uint32_t *)(buf + offset) = SoftBusHtoLl((uint32_t)pktHead->flag);
82 offset += sizeof(uint32_t);
83 *(uint32_t *)(buf + offset) = SoftBusHtoLl(pktHead->len);
84 offset += sizeof(uint32_t);
85 if (memcpy_s(buf + offset, size - offset, data, pktHead->len) != EOK) {
86 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "SocketPkt: pack fail.");
87 return SOFTBUS_MEM_ERR;
88 }
89 return SOFTBUS_OK;
90 }
91
UnpackSocketPkt(const uint8_t * data,uint32_t len,SocketPktHead * head)92 static int32_t UnpackSocketPkt(const uint8_t *data, uint32_t len, SocketPktHead *head)
93 {
94 if (len < GetSocketPktSize(0)) {
95 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "SocketPkt: head not enough.");
96 return SOFTBUS_NO_ENOUGH_DATA;
97 }
98 uint32_t offset = 0;
99 head->magic = (int32_t)SoftBusLtoHl(*(uint32_t *)data);
100 offset += sizeof(uint32_t);
101 head->module = (int32_t)SoftBusLtoHl(*(uint32_t *)(data + offset));
102 offset += sizeof(uint32_t);
103 head->seq = (int64_t)SoftBusLtoHll(*(uint64_t *)(data + offset));
104 offset += sizeof(uint64_t);
105 head->flag = (int32_t)SoftBusLtoHl(*(uint32_t *)(data + offset));
106 offset += sizeof(uint32_t);
107 head->len = SoftBusLtoHl(*(uint32_t *)(data + offset));
108 return SOFTBUS_OK;
109 }
110
NotifyConnected(int32_t fd,bool isClient)111 static void NotifyConnected(int32_t fd, bool isClient)
112 {
113 if (g_callback.onConnected != NULL) {
114 g_callback.onConnected(fd, isClient);
115 }
116 }
117
NotifyDisconnected(int32_t fd)118 static void NotifyDisconnected(int32_t fd)
119 {
120 if (g_callback.onDisconnected != NULL) {
121 g_callback.onDisconnected(fd);
122 }
123 NotifyChannelDisconnected(fd);
124 }
125
ModuleToDataType(int32_t module)126 static uint32_t ModuleToDataType(int32_t module)
127 {
128 switch (module) {
129 case MODULE_TRUST_ENGINE:
130 return DATA_TYPE_DEVICE_ID;
131 case MODULE_AUTH_SDK:
132 return DATA_TYPE_AUTH;
133 case MODULE_AUTH_CONNECTION:
134 return DATA_TYPE_DEVICE_INFO;
135 default:
136 break;
137 }
138 return DATA_TYPE_CONNECTION;
139 }
140
NotifyDataReceived(int32_t fd,const SocketPktHead * pktHead,const uint8_t * data)141 static void NotifyDataReceived(int32_t fd, const SocketPktHead *pktHead, const uint8_t *data)
142 {
143 if (pktHead->module == MODULE_AUTH_CHANNEL || pktHead->module == MODULE_AUTH_MSG) {
144 NotifyChannelDataReceived(fd, pktHead, data);
145 return;
146 }
147 AuthDataHead head = {
148 .dataType = ModuleToDataType(pktHead->module),
149 .module = pktHead->module,
150 .seq = pktHead->seq,
151 .flag = pktHead->flag,
152 .len = pktHead->len,
153 };
154 if (g_callback.onDataReceived != NULL) {
155 g_callback.onDataReceived(fd, &head, data);
156 }
157 }
158
RecvPacketHead(int32_t fd,SocketPktHead * head)159 static int32_t RecvPacketHead(int32_t fd, SocketPktHead *head)
160 {
161 uint8_t buf[AUTH_PKT_HEAD_LEN] = {0};
162 ssize_t len = ConnRecvSocketData(fd, (char *)&buf[0], sizeof(buf), 0);
163 if (len < AUTH_PKT_HEAD_LEN) {
164 if (len < 0) {
165 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "recv head fail(=%d).", ConnGetSocketError(fd));
166 (void)DelTrigger(AUTH, fd, READ_TRIGGER);
167 ConnShutdownSocket(fd);
168 NotifyDisconnected(fd);
169 }
170 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "head not enough, len=%d, abandon it.", len);
171 return SOFTBUS_ERR;
172 }
173 return UnpackSocketPkt(buf, len, head);
174 }
175
RecvPacketData(int32_t fd,uint32_t len)176 static uint8_t *RecvPacketData(int32_t fd, uint32_t len)
177 {
178 uint8_t *data = (uint8_t *)SoftBusMalloc(len);
179 if (data == NULL) {
180 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "malloc data buf fail.");
181 return NULL;
182 }
183 uint32_t offset = 0;
184 while (offset < len) {
185 ssize_t recvLen = ConnRecvSocketData(fd, (char *)(data + offset), (size_t)(len - offset), 0);
186 if (recvLen < 0) {
187 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "recv data fail(=%d).", ConnGetSocketError(fd));
188 SoftBusFree(data);
189 return NULL;
190 }
191 offset += (uint32_t)recvLen;
192 }
193 return data;
194 }
195
ProcessSocketOutEvent(int32_t fd)196 static int32_t ProcessSocketOutEvent(int32_t fd)
197 {
198 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_INFO, "socket client connect succ: fd=%d.", fd);
199 (void)DelTrigger(AUTH, fd, WRITE_TRIGGER);
200 if (AddTrigger(AUTH, fd, READ_TRIGGER) != SOFTBUS_OK) {
201 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "AddTrigger fail.");
202 goto FAIL;
203 }
204 if (ConnToggleNonBlockMode(fd, false) != SOFTBUS_OK) {
205 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "set block mode fail.");
206 goto FAIL;
207 }
208 NotifyConnected(fd, true);
209 return SOFTBUS_OK;
210
211 FAIL:
212 (void)DelTrigger(AUTH, fd, READ_TRIGGER);
213 ConnShutdownSocket(fd);
214 NotifyDisconnected(fd);
215 return SOFTBUS_ERR;
216 }
217
ProcessSocketInEvent(int32_t fd)218 static int32_t ProcessSocketInEvent(int32_t fd)
219 {
220 SocketPktHead head = {0};
221 if (RecvPacketHead(fd, &head) != SOFTBUS_OK) {
222 return SOFTBUS_ERR;
223 }
224 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_INFO,
225 "RecvSocketData: fd=%d, module=%d, seq=%" PRId64 ", flag=%d, len=%u.",
226 fd, head.module, head.seq, head.flag, head.len);
227 if (head.len == 0 || head.len > AUTH_SOCKET_MAX_DATA_LEN) {
228 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_WARN, "data is out of size, abandon it.");
229 return SOFTBUS_ERR;
230 }
231 if (head.magic != (int32_t)MAGIC_NUMBER) {
232 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "magic number not match.");
233 return SOFTBUS_ERR;
234 }
235 uint8_t *data = RecvPacketData(fd, head.len);
236 if (data == NULL) {
237 return SOFTBUS_ERR;
238 }
239 NotifyDataReceived(fd, &head, data);
240 SoftBusFree(data);
241 return SOFTBUS_OK;
242 }
243
OnConnectEvent(ListenerModule module,int32_t events,int32_t cfd,const ConnectOption * clientAddr)244 static int32_t OnConnectEvent(ListenerModule module, int32_t events,
245 int32_t cfd, const ConnectOption *clientAddr)
246 {
247 (void)module;
248 (void)clientAddr;
249 if (events == SOFTBUS_SOCKET_EXCEPTION) {
250 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "exception occurred, fd=%d.", cfd);
251 return SOFTBUS_ERR;
252 }
253 if (cfd < 0) {
254 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "%s:invalid param.", __func__);
255 return SOFTBUS_INVALID_PARAM;
256 }
257 if (ConnSetTcpKeepAlive(cfd, AUTH_KEEP_ALIVE_TIME_INTERVAL) != 0) {
258 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "set keepalive fail!");
259 ConnShutdownSocket(cfd);
260 return SOFTBUS_ERR;
261 }
262 if (AddTrigger(AUTH, cfd, READ_TRIGGER) != SOFTBUS_OK) {
263 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "AddTrigger fail.");
264 ConnShutdownSocket(cfd);
265 return SOFTBUS_ERR;
266 }
267 NotifyConnected(cfd, false);
268 return SOFTBUS_OK;
269 }
270
OnDataEvent(ListenerModule module,int32_t events,int32_t fd)271 static int32_t OnDataEvent(ListenerModule module, int32_t events, int32_t fd)
272 {
273 (void)module;
274 if (events == SOFTBUS_SOCKET_OUT) {
275 return ProcessSocketOutEvent(fd);
276 } else if (events == SOFTBUS_SOCKET_IN) {
277 return ProcessSocketInEvent(fd);
278 }
279 return SOFTBUS_ERR;
280 }
281
SetSocketCallback(const SocketCallback * cb)282 int32_t SetSocketCallback(const SocketCallback *cb)
283 {
284 CHECK_NULL_PTR_RETURN_VALUE(cb, SOFTBUS_INVALID_PARAM);
285 if (memcpy_s(&g_callback, sizeof(SocketCallback), cb, sizeof(SocketCallback)) != EOK) {
286 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "set SocketCallback fail.");
287 return SOFTBUS_MEM_ERR;
288 }
289 return SOFTBUS_OK;
290 }
291
UnsetSocketCallback(void)292 void UnsetSocketCallback(void)
293 {
294 (void)memset_s(&g_callback, sizeof(SocketCallback), 0, sizeof(SocketCallback));
295 }
296
StartSocketListening(const char * ip,int32_t port)297 int32_t StartSocketListening(const char *ip, int32_t port)
298 {
299 CHECK_NULL_PTR_RETURN_VALUE(ip, SOFTBUS_INVALID_PARAM);
300 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_INFO, "start socket listening.");
301 LocalListenerInfo info = {
302 .type = CONNECT_TCP,
303 .socketOption = {
304 .addr = "",
305 .port = port,
306 .moduleId = AUTH,
307 .protocol = LNN_PROTOCOL_IP
308 }
309 };
310 if (strcpy_s(info.socketOption.addr, sizeof(info.socketOption.addr), ip) != EOK) {
311 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "strcpy_s ip fail.");
312 return SOFTBUS_MEM_ERR;
313 }
314 SoftbusBaseListener listener = {
315 .onConnectEvent = OnConnectEvent,
316 .onDataEvent = OnDataEvent,
317 };
318 if (SetSoftbusBaseListener(AUTH, &listener) != SOFTBUS_OK) {
319 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "set listener fail.");
320 return SOFTBUS_ERR;
321 }
322 port = StartBaseListener(&info);
323 if (port <= 0) {
324 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "StartBaseListener fail(=%d).", port);
325 return SOFTBUS_ERR;
326 }
327 return port;
328 }
329
StopSocketListening(void)330 void StopSocketListening(void)
331 {
332 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_INFO, "stop socket listening.");
333 if (StopBaseListener(AUTH) != SOFTBUS_OK) {
334 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "StopBaseListener fail.");
335 }
336 }
337
SocketConnectDevice(const char * ip,int32_t port,bool isBlockMode)338 int32_t SocketConnectDevice(const char *ip, int32_t port, bool isBlockMode)
339 {
340 char localIp[MAX_ADDR_LEN] = {0};
341 if (LnnGetLocalStrInfo(STRING_KEY_WLAN_IP, localIp, MAX_ADDR_LEN) != SOFTBUS_OK) {
342 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "get local ip fail.");
343 return AUTH_INVALID_FD;
344 }
345 ConnectOption option = {
346 .type = CONNECT_TCP,
347 .socketOption = {
348 .addr = "",
349 .port = port,
350 .moduleId = AUTH,
351 .protocol = LNN_PROTOCOL_IP
352 }
353 };
354 if (strcpy_s(option.socketOption.addr, sizeof(option.socketOption.addr), ip) != EOK) {
355 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "copy remote ip fail.");
356 return AUTH_INVALID_FD;
357 }
358 int32_t fd = ConnOpenClientSocket(&option, localIp, !isBlockMode);
359 if (fd < 0) {
360 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "ConnOpenClientSocket fail.");
361 return AUTH_INVALID_FD;
362 }
363 TriggerType triggerMode = isBlockMode ? READ_TRIGGER : WRITE_TRIGGER;
364 if (AddTrigger(AUTH, fd, triggerMode) != SOFTBUS_OK) {
365 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "AddTrigger fail.");
366 ConnShutdownSocket(fd);
367 return AUTH_INVALID_FD;
368 }
369 if (ConnSetTcpKeepAlive(fd, AUTH_KEEP_ALIVE_TIME_INTERVAL) != SOFTBUS_OK) {
370 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "set tcp keep alive fail.");
371 (void)DelTrigger(AUTH, fd, triggerMode);
372 ConnShutdownSocket(fd);
373 return AUTH_INVALID_FD;
374 }
375 return fd;
376 }
377
SocketDisconnectDevice(int32_t fd)378 void SocketDisconnectDevice(int32_t fd)
379 {
380 if (fd < 0) {
381 return;
382 }
383 (void)DelTrigger(AUTH, fd, RW_TRIGGER);
384 ConnShutdownSocket(fd);
385 }
386
SocketPostBytes(int32_t fd,const AuthDataHead * head,const uint8_t * data)387 int32_t SocketPostBytes(int32_t fd, const AuthDataHead *head, const uint8_t *data)
388 {
389 CHECK_NULL_PTR_RETURN_VALUE(head, SOFTBUS_INVALID_PARAM);
390 CHECK_NULL_PTR_RETURN_VALUE(data, SOFTBUS_INVALID_PARAM);
391 uint32_t size = GetSocketPktSize(head->len);
392 uint8_t *buf = (uint8_t *)SoftBusCalloc(size);
393 if (buf == NULL) {
394 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "malloc pkt err.");
395 return SOFTBUS_ERR;
396 }
397 SocketPktHead pktHead = {
398 .magic = MAGIC_NUMBER,
399 .module = head->module,
400 .seq = head->seq,
401 .flag = head->flag,
402 .len = head->len,
403 };
404 if (PackSocketPkt(&pktHead, data, buf, size) != SOFTBUS_OK) {
405 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "pack socket pkt fail.");
406 SoftBusFree(buf);
407 return SOFTBUS_ERR;
408 }
409
410 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_INFO,
411 "SocketPostBytes: fd=%d, module=%d, seq=%"PRId64", flag=%d, len=%u.",
412 fd, pktHead.module, pktHead.seq, pktHead.flag, pktHead.len);
413 ssize_t ret = ConnSendSocketData(fd, (const char *)buf, (size_t)size, 0);
414 SoftBusFree(buf);
415 if (ret != (ssize_t)size) {
416 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "ConnSendSocketData fail(=%d).", ret);
417 return SOFTBUS_ERR;
418 }
419 return SOFTBUS_OK;
420 }
421
SocketGetConnInfo(int32_t fd,AuthConnInfo * connInfo,bool * isServer)422 int32_t SocketGetConnInfo(int32_t fd, AuthConnInfo *connInfo, bool *isServer)
423 {
424 CHECK_NULL_PTR_RETURN_VALUE(connInfo, SOFTBUS_INVALID_PARAM);
425 CHECK_NULL_PTR_RETURN_VALUE(isServer, SOFTBUS_INVALID_PARAM);
426 SocketAddr socket;
427 if (ConnGetPeerSocketAddr(fd, &socket) != SOFTBUS_OK) {
428 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "ConnGetPeerSocketAddr fail, fd=%d.", fd);
429 return SOFTBUS_ERR;
430 }
431 int32_t localPort = ConnGetLocalSocketPort(fd);
432 if (localPort <= 0) {
433 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "ConnGetLocalSocketPort fail, fd=%d.", fd);
434 return SOFTBUS_ERR;
435 }
436 connInfo->type = AUTH_LINK_TYPE_WIFI;
437 if (strcpy_s(connInfo->info.ipInfo.ip, sizeof(connInfo->info.ipInfo.ip), socket.addr) != EOK) {
438 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "copy ip fail, fd=%d.", fd);
439 return SOFTBUS_MEM_ERR;
440 }
441 connInfo->info.ipInfo.port = socket.port;
442 int32_t serverPort = 0;
443 if (LnnGetLocalNumInfo(NUM_KEY_AUTH_PORT, &serverPort) != SOFTBUS_OK) {
444 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "get local auth port fail.");
445 return SOFTBUS_ERR;
446 }
447 *isServer = (serverPort != localPort);
448 return SOFTBUS_OK;
449 }
450
451 /* Auth Channel */
NotifyChannelDataReceived(int32_t channelId,const SocketPktHead * head,const uint8_t * data)452 static void NotifyChannelDataReceived(int32_t channelId, const SocketPktHead *head, const uint8_t *data)
453 {
454 uint32_t i;
455 AuthChannelListener *listener = NULL;
456 for (i = 0; i < sizeof(g_listener) / sizeof(InnerChannelListener); i++) {
457 if (g_listener[i].module == head->module) {
458 listener = &g_listener[i].listener;
459 break;
460 }
461 }
462 if (listener == NULL || listener->onDataReceived == NULL) {
463 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "AuthChannelListener not set.");
464 return;
465 }
466
467 AuthChannelData channelData = {
468 .module = head->module,
469 .seq = head->seq,
470 .flag = head->flag,
471 .len = head->len,
472 .data = data,
473 };
474 listener->onDataReceived(channelId, &channelData);
475 }
476
NotifyChannelDisconnected(int32_t channelId)477 static void NotifyChannelDisconnected(int32_t channelId)
478 {
479 uint32_t i;
480 for (i = 0; i < sizeof(g_listener) / sizeof(InnerChannelListener); i++) {
481 if (g_listener[i].listener.onDisconnected != NULL) {
482 g_listener[i].listener.onDisconnected(channelId);
483 }
484 }
485 }
486
RegAuthChannelListener(int32_t module,const AuthChannelListener * listener)487 int32_t RegAuthChannelListener(int32_t module, const AuthChannelListener *listener)
488 {
489 if (listener == NULL || listener->onDataReceived == NULL) {
490 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "AuthChannel: invalid listener.");
491 return SOFTBUS_INVALID_PARAM;
492 }
493 uint32_t i;
494 for (i = 0; i < sizeof(g_listener) / sizeof(InnerChannelListener); i++) {
495 if (g_listener[i].module == module) {
496 g_listener[i].listener.onDataReceived = listener->onDataReceived;
497 g_listener[i].listener.onDisconnected = listener->onDisconnected;
498 return SOFTBUS_OK;
499 }
500 }
501 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "AuthChannel: unknown module(=%d).", module);
502 return SOFTBUS_ERR;
503 }
504
UnregAuthChannelListener(int32_t module)505 void UnregAuthChannelListener(int32_t module)
506 {
507 uint32_t i;
508 for (i = 0; i < sizeof(g_listener) / sizeof(InnerChannelListener); i++) {
509 if (g_listener[i].module == module) {
510 g_listener[i].listener.onDataReceived = NULL;
511 g_listener[i].listener.onDisconnected = NULL;
512 return;
513 }
514 }
515 }
516
AuthOpenChannel(const char * ip,int32_t port)517 int32_t AuthOpenChannel(const char *ip, int32_t port)
518 {
519 if (ip == NULL || port <= 0) {
520 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "AuthChannel: invalid param.");
521 return INVALID_CHANNEL_ID;
522 }
523 int32_t fd = SocketConnectDevice(ip, port, true);
524 if (fd < 0) {
525 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "AuthChannel: connect fail.");
526 return INVALID_CHANNEL_ID;
527 }
528 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_INFO, "AuthChannel: open auth channel succ, channelId=%d.", fd);
529 return fd;
530 }
531
AuthCloseChannel(int32_t channelId)532 void AuthCloseChannel(int32_t channelId)
533 {
534 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_INFO, "AuthChannel: close auth channel, id=%d.", channelId);
535 SocketDisconnectDevice(channelId);
536 }
537
AuthPostChannelData(int32_t channelId,const AuthChannelData * data)538 int32_t AuthPostChannelData(int32_t channelId, const AuthChannelData *data)
539 {
540 if (channelId < 0 || data == NULL || data->data == NULL || data->len == 0) {
541 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "AuthChannel: invalid param, channelId=%d.", channelId);
542 return SOFTBUS_INVALID_PARAM;
543 }
544 AuthDataHead head = {
545 .dataType = DATA_TYPE_CONNECTION,
546 .module = data->module,
547 .seq = data->seq,
548 .flag = data->flag,
549 .len = data->len,
550 };
551 return SocketPostBytes(channelId, &head, data->data);
552 }
553