1 /*
2 * Copyright (c) 2023 Shenzhen Kaihong Digital Industry Development 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 "socket_utils.h"
17 #include <arpa/inet.h>
18 #include <fcntl.h>
19 #include <iostream>
20 #include <netinet/tcp.h>
21 #include <unistd.h>
22 #include "common/common_macro.h"
23 #include "common/const_def.h"
24 #include "common/media_log.h"
25 #include "utils.h"
26
27 namespace OHOS {
28 namespace Sharing {
29 uint16_t SocketUtils::minPort_ = MIN_PORT;
30 uint16_t SocketUtils::maxPort_ = MAX_PORT;
31 const uint32_t ERRNO_MAX_LEN = 256;
32
CreateTcpServer(const char * ip,unsigned port,int32_t & fd)33 bool SocketUtils::CreateTcpServer(const char *ip, unsigned port, int32_t &fd)
34 {
35 SHARING_LOGD("trace.");
36 RETURN_FALSE_IF_NULL(ip);
37 return CreateSocket(SOCK_STREAM, fd) && SetReuseAddr(fd, true) && SetNoDelay(fd, true) &&
38 BindSocket(fd, ip, port) && ListenSocket(fd);
39 }
40
GetAvailableUdpPortPair()41 uint16_t SocketUtils::GetAvailableUdpPortPair()
42 {
43 SHARING_LOGD("trace.");
44 static uint16_t gAvailablePort = minPort_;
45
46 SHARING_LOGD("current udp port: %{public}d.", gAvailablePort);
47 if (gAvailablePort >= maxPort_) {
48 gAvailablePort = minPort_;
49 }
50
51 uint16_t port = GetAvailableUdpPortPair(gAvailablePort, maxPort_);
52 if (port != 0) {
53 gAvailablePort = port + 2; // 2: pair port
54 return port;
55 }
56
57 port = GetAvailableUdpPortPair(minPort_, gAvailablePort);
58 if (port != 0) {
59 gAvailablePort = port + 2; // 2: pair port
60 }
61
62 return port;
63 }
64
GetAvailableUdpPortPair(uint16_t minPort,uint16_t maxPort)65 uint16_t SocketUtils::GetAvailableUdpPortPair(uint16_t minPort, uint16_t maxPort)
66 {
67 SHARING_LOGD("trace.");
68 if (minPort == maxPort) {
69 return 0;
70 }
71
72 uint16_t port = minPort;
73 bool portAvalaible = false;
74 while (!portAvalaible) {
75 if (port >= maxPort) {
76 port = 0;
77 portAvalaible = true;
78 } else if (IsUdpPortAvailable(port) && IsUdpPortAvailable(port + 1)) {
79 portAvalaible = true;
80 } else {
81 port += 2; // 2: pair port
82 }
83 }
84
85 return port;
86 }
87
IsUdpPortAvailable(uint16_t port)88 bool SocketUtils::IsUdpPortAvailable(uint16_t port)
89 {
90 SHARING_LOGD("trace.");
91 int32_t fd = -1;
92 auto ret = CreateSocket(SOCK_DGRAM, fd) && BindSocket(fd, "", port);
93 if (fd != -1) {
94 CloseSocket(fd);
95 }
96
97 return ret;
98 }
99
CreateTcpClient(const char * ip,unsigned port,int32_t & fd,int32_t & ret)100 bool SocketUtils::CreateTcpClient(const char *ip, unsigned port, int32_t &fd, int32_t &ret)
101 {
102 SHARING_LOGD("trace.");
103 RETURN_FALSE_IF_NULL(ip);
104 return CreateSocket(SOCK_STREAM, fd) && ConnectSocket(fd, true, ip, port, ret);
105 }
106
CreateUdpSession(unsigned port,int32_t & fd)107 bool SocketUtils::CreateUdpSession(unsigned port, int32_t &fd)
108 {
109 SHARING_LOGD("trace.");
110 return CreateSocket(SOCK_DGRAM, fd) && SetRecvBuf(fd) && SetSendBuf(fd) && BindSocket(fd, "", port);
111 }
112
CreateSocket(int32_t socketType,int32_t & fd)113 bool SocketUtils::CreateSocket(int32_t socketType, int32_t &fd)
114 {
115 SHARING_LOGD("trace.");
116 fd = -1;
117 if (socketType != SOCK_STREAM && socketType != SOCK_DGRAM) {
118 SHARING_LOGE("type error: %{public}d!", socketType);
119 return false;
120 }
121
122 fd = socket(AF_INET, socketType, (socketType == SOCK_STREAM ? IPPROTO_TCP : IPPROTO_UDP));
123 if (fd < 0) {
124 char errmsg[ERRNO_MAX_LEN] = {0};
125 strerror_r(errno, errmsg, ERRNO_MAX_LEN);
126 SHARING_LOGE("error: %{public}s!", errmsg);
127 return false;
128 }
129 SHARING_LOGD("success fd: %{public}d.", fd);
130 return true;
131 }
132
BindSocket(int32_t fd,const std::string & host,uint16_t port)133 bool SocketUtils::BindSocket(int32_t fd, const std::string &host, uint16_t port)
134 {
135 SHARING_LOGD("trace.");
136 struct sockaddr_in addr = {};
137 addr.sin_family = AF_INET;
138 addr.sin_port = htons(port);
139 if (host == "" || host == "::") {
140 addr.sin_addr.s_addr = INADDR_ANY;
141 } else {
142 if (inet_pton(AF_INET, host.c_str(), &addr.sin_addr) <= 0) {
143 char errmsg[ERRNO_MAX_LEN] = {0};
144 strerror_r(errno, errmsg, ERRNO_MAX_LEN);
145 SHARING_LOGE("error: %{public}s!", errmsg);
146 return false;
147 }
148 }
149 if (::bind(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
150 char errmsg[ERRNO_MAX_LEN] = {0};
151 strerror_r(errno, errmsg, ERRNO_MAX_LEN);
152 SHARING_LOGE("error: %{public}s!", errmsg);
153 return false;
154 }
155
156 return true;
157 }
158
ListenSocket(int32_t fd,uint32_t backlog)159 bool SocketUtils::ListenSocket(int32_t fd, uint32_t backlog)
160 {
161 SHARING_LOGD("trace.");
162 if (::listen(fd, backlog) == -1) {
163 char errmsg[ERRNO_MAX_LEN] = {0};
164 strerror_r(errno, errmsg, ERRNO_MAX_LEN);
165 SHARING_LOGE("error: %{public}s!", errmsg);
166 return false;
167 }
168
169 return true;
170 }
171
ConnectSocket(int32_t fd,bool isAsync,const std::string & ip,uint16_t port,int32_t & ret)172 bool SocketUtils::ConnectSocket(int32_t fd, bool isAsync, const std::string &ip, uint16_t port, int32_t &ret)
173 {
174 SHARING_LOGD("trace.");
175 if (ip == "") {
176 SHARING_LOGE("ip null!");
177 return false;
178 }
179
180 struct sockaddr_in serverAddr = {};
181 serverAddr.sin_family = AF_INET;
182 serverAddr.sin_port = htons(port);
183 if (inet_pton(AF_INET, ip.c_str(), &serverAddr.sin_addr) <= 0) {
184 char errmsg[ERRNO_MAX_LEN] = {0};
185 strerror_r(errno, errmsg, ERRNO_MAX_LEN);
186 SHARING_LOGE("inet_pton ip error: %{public}s!", errmsg);
187 return false;
188 }
189
190 int32_t res = ::connect(fd, (struct sockaddr *)&serverAddr, sizeof(serverAddr));
191 ret = res;
192 if (isAsync) {
193 if (res == 0) {
194 SHARING_LOGI("connect immediately.");
195 return true;
196 } else {
197 if (errno == EINPROGRESS) {
198 SHARING_LOGI("connecting.");
199 return SocketUtils::CheckAsyncConnect(fd);
200 } else {
201 return false;
202 }
203 }
204 } else {
205 if (res == 0) {
206 return true;
207 } else {
208 return false;
209 }
210 }
211 }
212
CheckAsyncConnect(int32_t fd)213 bool SocketUtils::CheckAsyncConnect(int32_t fd)
214 {
215 SHARING_LOGD("trace.");
216 struct timeval timeout;
217 timeout.tv_sec = 2; // 2: wait +2 second
218 timeout.tv_usec = 500 * 1000; // 500 * 1000: wait +0.5 second
219
220 fd_set fdr;
221 fd_set fdw;
222 FD_ZERO(&fdr);
223 FD_ZERO(&fdw);
224 FD_SET(fd, &fdr);
225 FD_SET(fd, &fdw);
226
227 int32_t rc = select(fd + 1, &fdr, &fdw, nullptr, &timeout);
228 if (rc == 1 && FD_ISSET(fd, &fdw)) {
229 SHARING_LOGI("async connect success\n");
230 return true;
231 }
232
233 if (rc == 0) {
234 SHARING_LOGE("async connect timeout.");
235 }
236
237 if ((rc < 0) || (rc == 2)) { // 2: select error
238 char errmsg[ERRNO_MAX_LEN] = {0};
239 strerror_r(errno, errmsg, ERRNO_MAX_LEN);
240 SHARING_LOGE("async connect error: %{public}s!", errmsg);
241 }
242
243 return false;
244 }
245
ShutDownSocket(int32_t fd)246 void SocketUtils::ShutDownSocket(int32_t fd)
247 {
248 SHARING_LOGD("trace.");
249 if (fd >= 0) {
250 SHARING_LOGD("shutdown fd: %{public}d.", fd);
251 shutdown(fd, SHUT_RDWR);
252 }
253 }
254
SetReuseAddr(int32_t fd,bool isReuse)255 bool SocketUtils::SetReuseAddr(int32_t fd, bool isReuse)
256 {
257 SHARING_LOGD("trace.");
258 int32_t on = isReuse ? 1 : 0;
259 if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) != 0) {
260 char errmsg[ERRNO_MAX_LEN] = {0};
261 strerror_r(errno, errmsg, ERRNO_MAX_LEN);
262 SHARING_LOGE("error: %{public}s!", errmsg);
263 return false;
264 }
265
266 return true;
267 }
268
SetReusePort(int32_t fd,bool isReuse)269 bool SocketUtils::SetReusePort(int32_t fd, bool isReuse)
270 {
271 SHARING_LOGD("trace.");
272 int32_t on = isReuse ? 1 : 0;
273 if (setsockopt(fd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on)) != 0) {
274 char errmsg[ERRNO_MAX_LEN] = {0};
275 strerror_r(errno, errmsg, ERRNO_MAX_LEN);
276 SHARING_LOGE("error: %{public}s!", errmsg);
277 return false;
278 }
279
280 return true;
281 }
282
SetCloseWait(int32_t fd,int32_t second)283 bool SocketUtils::SetCloseWait(int32_t fd, int32_t second)
284 {
285 SHARING_LOGD("trace.");
286 linger sLinger;
287 sLinger.l_onoff = (second > 0);
288 sLinger.l_linger = second;
289 if (setsockopt(fd, SOL_SOCKET, SO_LINGER, &sLinger, sizeof(linger)) == -1) {
290 char errmsg[ERRNO_MAX_LEN] = {0};
291 strerror_r(errno, errmsg, ERRNO_MAX_LEN);
292 SHARING_LOGE("error: %{public}s!", errmsg);
293 return false;
294 }
295
296 return true;
297 }
298
SetCloExec(int32_t fd,bool isOn)299 bool SocketUtils::SetCloExec(int32_t fd, bool isOn)
300 {
301 SHARING_LOGD("trace.");
302
303 int32_t flags = fcntl(fd, F_GETFD);
304 if (flags == -1) {
305 char errmsg[ERRNO_MAX_LEN] = {0};
306 strerror_r(errno, errmsg, ERRNO_MAX_LEN);
307 SHARING_LOGE("fcntl error: %{public}s!", errmsg);
308 return false;
309 }
310
311 if (isOn) {
312 flags = static_cast<int32_t>(static_cast<uint32_t>(flags) | FD_CLOEXEC);
313 } else {
314 int32_t cloexec = FD_CLOEXEC;
315 flags = static_cast<int32_t>(static_cast<uint32_t>(flags) & ~static_cast<uint32_t>(cloexec));
316 }
317
318 if (fcntl(fd, F_SETFD, flags) == -1) {
319 char errmsg[ERRNO_MAX_LEN] = {0};
320 strerror_r(errno, errmsg, ERRNO_MAX_LEN);
321 SHARING_LOGE("error: %{public}s!", errmsg);
322 return false;
323 }
324
325 return true;
326 }
327
SetNoDelay(int32_t fd,bool isOn)328 bool SocketUtils::SetNoDelay(int32_t fd, bool isOn)
329 {
330 SHARING_LOGD("trace.");
331 int32_t on = isOn;
332 if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(on)) != 0) {
333 char errmsg[ERRNO_MAX_LEN] = {0};
334 strerror_r(errno, errmsg, ERRNO_MAX_LEN);
335 SHARING_LOGE("error: %{public}s!", errmsg);
336 return false;
337 }
338
339 return true;
340 }
341
SetKeepAlive(int32_t sockfd)342 void SocketUtils::SetKeepAlive(int32_t sockfd)
343 {
344 SHARING_LOGD("trace.");
345 int32_t on = 1;
346 setsockopt(sockfd, SOL_SOCKET, SO_KEEPALIVE, reinterpret_cast<char *>(&on), sizeof(on));
347 }
348
SetNonBlocking(int32_t fd,bool isNonBlock,uint32_t writeTimeout)349 bool SocketUtils::SetNonBlocking(int32_t fd, bool isNonBlock, uint32_t writeTimeout)
350 {
351 SHARING_LOGD("trace.");
352 int32_t flags = -1;
353 if (isNonBlock) {
354 flags = fcntl(fd, F_SETFL, static_cast<uint32_t>(fcntl(fd, F_GETFL)) | O_NONBLOCK);
355 } else {
356 flags = fcntl(fd, F_SETFL, static_cast<uint32_t>(fcntl(fd, F_GETFL)) & ~O_NONBLOCK);
357 if (writeTimeout > 0) {
358 struct timeval tv = {writeTimeout / 1000, (writeTimeout % 1000) * 1000};
359 setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, reinterpret_cast<char *>(&tv), sizeof tv);
360 }
361 }
362
363 return (flags != -1) ? true : false;
364 }
365
SetSendBuf(int32_t fd,int32_t size)366 bool SocketUtils::SetSendBuf(int32_t fd, int32_t size)
367 {
368 SHARING_LOGD("trace.");
369 if (setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size)) != 0) {
370 char errmsg[ERRNO_MAX_LEN] = {0};
371 strerror_r(errno, errmsg, ERRNO_MAX_LEN);
372 SHARING_LOGE("error: %{public}s!", errmsg);
373 return false;
374 }
375
376 return true;
377 }
378
SetRecvBuf(int32_t fd,int32_t size)379 bool SocketUtils::SetRecvBuf(int32_t fd, int32_t size)
380 {
381 SHARING_LOGD("trace.");
382 if (setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size)) != 0) {
383 char errmsg[ERRNO_MAX_LEN] = {0};
384 strerror_r(errno, errmsg, ERRNO_MAX_LEN);
385 SHARING_LOGE("error: %{public}s!", errmsg);
386 return false;
387 }
388
389 return true;
390 }
391
CloseSocket(int32_t fd)392 void SocketUtils::CloseSocket(int32_t fd)
393 {
394 SHARING_LOGD("trace.");
395 if (fd >= 0) {
396 SHARING_LOGD("close fd: %{public}d.", fd);
397 close(fd);
398 }
399 }
400
SendSocket(int32_t fd,const char * buf,int32_t len)401 int32_t SocketUtils::SendSocket(int32_t fd, const char *buf, int32_t len)
402 {
403 SHARING_LOGD("trace.");
404 if (fd < 0 || buf == nullptr || len == 0) {
405 return -1;
406 }
407 int32_t bytes = 0;
408 bool sending = true;
409 while (sending) {
410 if (bytes >= len || bytes < 0) {
411 sending = false;
412 break;
413 }
414
415 int32_t retCode = send(fd, &buf[bytes], len - bytes, 0);
416 if ((retCode < 0) && (errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN)) {
417 SHARING_LOGD("sendSocket: continue.");
418 continue;
419 } else if (retCode > 0) {
420 bytes += retCode;
421 if (bytes == len) {
422 sending = false;
423 break;
424 }
425 } else {
426 char errmsg[ERRNO_MAX_LEN] = {0};
427 strerror_r(errno, errmsg, ERRNO_MAX_LEN);
428 SHARING_LOGE("error: %{public}s!", errmsg);
429 bytes = 0;
430 sending = false;
431 break;
432 }
433 }
434
435 SHARING_LOGD("finish! fd: %{public}d size: %{public}d.", fd, bytes);
436 return bytes;
437 }
438
Sendto(int32_t fd,const char * buf,size_t len,const char * ip,int32_t nPort)439 int32_t SocketUtils::Sendto(int32_t fd, const char *buf, size_t len, const char *ip, int32_t nPort)
440 {
441 RETURN_INVALID_IF_NULL(buf);
442 RETURN_INVALID_IF_NULL(ip);
443 struct sockaddr_in addr = {};
444 addr.sin_family = AF_INET;
445 addr.sin_port = htons(nPort);
446 if (inet_pton(AF_INET, ip, &addr.sin_addr) <= 0) {
447 char errmsg[ERRNO_MAX_LEN] = {0};
448 strerror_r(errno, errmsg, ERRNO_MAX_LEN);
449 SHARING_LOGE("inet_pton error: %{public}s!", errmsg);
450 return -1;
451 }
452 int32_t retCode = sendto(fd, buf, len, 0, (struct sockaddr *)&addr, sizeof(addr));
453 if (retCode < 0 && (errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN)) {
454 } else if (retCode > 0) {
455 } else {
456 char errmsg[ERRNO_MAX_LEN] = {0};
457 strerror_r(errno, errmsg, ERRNO_MAX_LEN);
458 SHARING_LOGE("sendto error: %{public}s!", errmsg);
459 retCode = 0;
460 }
461
462 return retCode;
463 }
464
ReadSocket(int32_t fd,char * buf,uint32_t len,int32_t & error)465 int32_t SocketUtils::ReadSocket(int32_t fd, char *buf, uint32_t len, int32_t &error)
466 {
467 SHARING_LOGD("trace.");
468 if (fd < 0 || buf == nullptr || len == 0) {
469 SHARING_LOGE("invalid param!");
470 return -1;
471 }
472
473 int32_t retCode = read(fd, buf, len);
474 error = errno;
475 if (retCode < 0 && (errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN)) {
476 } else if (retCode > 0) {
477 } else {
478 char errmsg[ERRNO_MAX_LEN] = {0};
479 strerror_r(errno, errmsg, ERRNO_MAX_LEN);
480 SHARING_LOGE("error: %{public}s!", errmsg);
481 retCode = 0;
482 }
483
484 return retCode;
485 }
486
ReadSocket(int32_t fd,DataBuffer::Ptr buf,int32_t & error)487 int32_t SocketUtils::ReadSocket(int32_t fd, DataBuffer::Ptr buf, int32_t &error)
488 {
489 SHARING_LOGD("trace.");
490 if (fd < 0 || !buf) {
491 SHARING_LOGE("readSocket:invalid param!");
492 return -1;
493 }
494
495 auto size = buf->Capacity() - buf->Size();
496 if (size < READ_BUF_SIZE) {
497 uint32_t bufferReaderSize = (uint32_t)buf->Size();
498 if (bufferReaderSize > MAX_READ_BUF_SIZE) {
499 SHARING_LOGE("error data size!");
500 return -1;
501 }
502 buf->Resize(bufferReaderSize + READ_BUF_SIZE);
503 }
504
505 int32_t bytesRead = read(fd, buf->Data() + buf->Size(), READ_BUF_SIZE);
506 error = errno;
507 if (bytesRead > 0) {
508 buf->UpdateSize(buf->Size() + bytesRead);
509 } else if (bytesRead < 0 && (errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN)) {
510 } else {
511 bytesRead = 0;
512 char errmsg[ERRNO_MAX_LEN] = {0};
513 strerror_r(errno, errmsg, ERRNO_MAX_LEN);
514 SHARING_LOGE("error: %{public}s!", errmsg);
515 }
516
517 return bytesRead;
518 }
519
RecvSocket(int32_t fd,char * buf,uint32_t len,int32_t flags,int32_t & error)520 int32_t SocketUtils::RecvSocket(int32_t fd, char *buf, uint32_t len, int32_t flags, int32_t &error)
521 {
522 SHARING_LOGI("RecvSocket fd is %{public}d", fd);
523 if (fd < 0 || buf == nullptr || len == 0) {
524 SHARING_LOGE("invalid param.");
525 return -1;
526 }
527
528 int32_t retCode = recv(fd, buf, len, flags);
529 error = errno;
530 if (retCode < 0 && (errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN)) {
531 } else if (retCode > 0) {
532 } else {
533 char errmsg[ERRNO_MAX_LEN] = {0};
534 strerror_r(errno, errmsg, ERRNO_MAX_LEN);
535 SHARING_LOGE("error: %{public}s!", errmsg);
536 retCode = 0;
537 }
538
539 return retCode;
540 }
541
AcceptSocket(int32_t fd,struct sockaddr_in * clientAddr,socklen_t * addrLen)542 int32_t SocketUtils::AcceptSocket(int32_t fd, struct sockaddr_in *clientAddr, socklen_t *addrLen)
543 {
544 SHARING_LOGD("trace.");
545 RETURN_INVALID_IF_NULL(clientAddr);
546 RETURN_INVALID_IF_NULL(addrLen);
547 int32_t clientFd = accept(fd, reinterpret_cast<struct sockaddr *>(clientAddr), addrLen);
548 if (clientFd < 0) {
549 char errmsg[ERRNO_MAX_LEN] = {0};
550 strerror_r(errno, errmsg, ERRNO_MAX_LEN);
551 SHARING_LOGE("accept error: %{public}s!", errmsg);
552 }
553
554 return clientFd;
555 }
556
GetIpPortInfo(int32_t fd,std::string & strLocalAddr,std::string & strRemoteAddr,uint16_t & localPort,uint16_t & remotePort)557 bool SocketUtils::GetIpPortInfo(int32_t fd, std::string &strLocalAddr, std::string &strRemoteAddr, uint16_t &localPort,
558 uint16_t &remotePort)
559 {
560 SHARING_LOGD("trace.");
561 struct sockaddr_in localAddr;
562 socklen_t localAddrLen = sizeof(localAddr);
563 if (-1 == getsockname(fd, (struct sockaddr *)&localAddr, &localAddrLen)) {
564 char errmsg[ERRNO_MAX_LEN] = {0};
565 strerror_r(errno, errmsg, ERRNO_MAX_LEN);
566 SHARING_LOGE("getsockname error: %{public}s!", errmsg);
567 return false;
568 }
569
570 struct sockaddr_in remoteAddr;
571 socklen_t remoteAddrLen = sizeof(remoteAddr);
572 if (-1 == getpeername(fd, (struct sockaddr *)&remoteAddr, &remoteAddrLen)) {
573 char errmsg[ERRNO_MAX_LEN] = {0};
574 strerror_r(errno, errmsg, ERRNO_MAX_LEN);
575 SHARING_LOGE("getpeername error: %{public}s!", errmsg);
576 return false;
577 }
578
579 strLocalAddr = ConvertSinAddrToStr(localAddr);
580 strRemoteAddr = ConvertSinAddrToStr(remoteAddr);
581
582 localPort = ntohs(localAddr.sin_port);
583 remotePort = ntohs(remoteAddr.sin_port);
584 SHARING_LOGD("localAddr: %{public}s localPort: %{public}d remoteAddr: %{public}s remotePort: %{public}d",
585 GetAnonymousIp(strLocalAddr).c_str(), localPort, GetAnonymousIp(strRemoteAddr).c_str(), remotePort);
586 return true;
587 }
588 } // namespace Sharing
589 } // namespace OHOS