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 "local_socketpair.h"
17 #include "hilog/log.h"
18
19 #include <sys/types.h>
20 #include <sys/socket.h>
21 #include <unistd.h>
22 #include <fcntl.h>
23 #include <cerrno>
24 #include <scoped_bytrace.h>
25
26 namespace OHOS {
27 using namespace OHOS::HiviewDFX;
28
29 namespace {
30 constexpr HiLogLabel LABEL = { LOG_CORE, 0xD001400, "LocalSocketPair" };
31 constexpr int32_t SOCKET_PAIR_SIZE = 2;
32 constexpr int32_t INVALID_FD = -1;
33 constexpr int32_t ERRNO_EAGAIN = -1;
34 constexpr int32_t ERRNO_OTHER = -2;
35 } // namespace
36
LocalSocketPair()37 LocalSocketPair::LocalSocketPair()
38 : sendFd_(INVALID_FD), receiveFd_(INVALID_FD)
39 {
40 HiLog::Debug(LABEL, "%{public}s sendFd: %{public}d", __func__, sendFd_);
41 }
42
~LocalSocketPair()43 LocalSocketPair::~LocalSocketPair()
44 {
45 CloseFd(sendFd_);
46 CloseFd(receiveFd_);
47 }
48
CreateChannel(size_t sendSize,size_t receiveSize)49 int32_t LocalSocketPair::CreateChannel(size_t sendSize, size_t receiveSize)
50 {
51 if ((sendFd_ != INVALID_FD) || (receiveFd_ != INVALID_FD)) {
52 HiLog::Debug(LABEL, "%{public}s already create socketpair", __func__);
53 return 0;
54 }
55
56 int32_t socketPair[SOCKET_PAIR_SIZE] = { 0 };
57 if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, socketPair) != 0) {
58 ScopedBytrace func("Create socketpair failed, errno = " + std::to_string(errno));
59 HiLog::Error(LABEL, "%{public}s create socketpair failed", __func__);
60 return -1;
61 }
62 if (socketPair[0] == 0 || socketPair[1] == 0) {
63 int32_t unusedFds[SOCKET_PAIR_SIZE] = {socketPair[0], socketPair[1]};
64 int32_t err = socketpair(AF_UNIX, SOCK_SEQPACKET, 0, socketPair);
65 CloseFd(unusedFds[0]);
66 CloseFd(unusedFds[1]);
67 if (err != 0) {
68 ScopedBytrace func2("Create socketpair failed for the second time, errno = " + std::to_string(errno));
69 HiLog::Error(LABEL, "%{public}s create socketpair failed", __func__);
70 return -1;
71 }
72 }
73
74 // set socket attr
75 for (int i = 0; i < SOCKET_PAIR_SIZE; ++i) {
76 int32_t ret = setsockopt(socketPair[i], SOL_SOCKET, SO_SNDBUF, &sendSize, sizeof(sendSize));
77 if (ret != 0) {
78 HiLog::Error(LABEL, "%{public}s setsockopt socketpair %{public}d sendbuffer size failed", __func__, i);
79 return -1;
80 }
81 ret = setsockopt(socketPair[i], SOL_SOCKET, SO_RCVBUF, &receiveSize, sizeof(receiveSize));
82 if (ret != 0) {
83 HiLog::Error(LABEL, "%{public}s setsockopt socketpair %{public}d receivebuffer size failed", __func__, i);
84 return -1;
85 }
86 ret = fcntl(socketPair[i], F_SETFL, O_NONBLOCK);
87 if (ret != 0) {
88 HiLog::Error(LABEL, "%{public}s fcntl socketpair %{public}d nonblock failed", __func__, i);
89 return -1;
90 }
91 }
92 sendFd_ = socketPair[0];
93 receiveFd_ = socketPair[1];
94 HiLog::Debug(LABEL, "%{public}s create socketpair success, receiveFd_ : %{public}d, sendFd_ : %{public}d", __func__,
95 receiveFd_, sendFd_);
96
97 return 0;
98 }
99
SendData(const void * vaddr,size_t size)100 int32_t LocalSocketPair::SendData(const void *vaddr, size_t size)
101 {
102 if (vaddr == nullptr || sendFd_ < 0) {
103 HiLog::Error(LABEL, "%{public}s failed, param is invalid", __func__);
104 return -1;
105 }
106 ssize_t length;
107 do {
108 length = send(sendFd_, vaddr, size, MSG_DONTWAIT | MSG_NOSIGNAL);
109 } while (errno == EINTR);
110 if (length < 0) {
111 ScopedBytrace func("SocketPair SendData failed, errno = " + std::to_string(errno) +
112 ", sendFd_ = " + std::to_string(sendFd_) + ", receiveFd_ = " + std::to_string(receiveFd_) +
113 ", length = " + std::to_string(length));
114 HiLog::Debug(LABEL, "%{public}s send failed:%{public}d, length = %{public}d", __func__, errno, (int32_t)length);
115 if (errno == EAGAIN) {
116 return ERRNO_EAGAIN;
117 } else {
118 return ERRNO_OTHER;
119 }
120 }
121 return length;
122 }
123
ReceiveData(void * vaddr,size_t size)124 int32_t LocalSocketPair::ReceiveData(void *vaddr, size_t size)
125 {
126 if (vaddr == nullptr || (receiveFd_ < 0)) {
127 HiLog::Error(LABEL, "%{public}s failed, vaddr is null or receiveFd_ invalid", __func__);
128 return -1;
129 }
130 ssize_t length;
131 do {
132 length = recv(receiveFd_, vaddr, size, MSG_DONTWAIT);
133 } while (errno == EINTR);
134 if (length < 0) {
135 ScopedBytrace func("SocketPair ReceiveData failed errno = " + std::to_string(errno) +
136 ", sendFd_ = " + std::to_string(sendFd_) + ", receiveFd_ = " + std::to_string(receiveFd_) +
137 ", length = " + std::to_string(length));
138 return -1;
139 }
140 return length;
141 }
142
143 // internal interface
SendFdToBinder(MessageParcel & data,int32_t & fd)144 int32_t LocalSocketPair::SendFdToBinder(MessageParcel &data, int32_t &fd)
145 {
146 if (fd < 0) {
147 return -1;
148 }
149 // need dup???
150 bool result = data.WriteFileDescriptor(fd);
151 if (!result) {
152 return -1;
153 }
154 return 0;
155 }
156
SendToBinder(MessageParcel & data)157 int32_t LocalSocketPair::SendToBinder(MessageParcel &data)
158 {
159 return SendFdToBinder(data, sendFd_);
160 }
161
ReceiveToBinder(MessageParcel & data)162 int32_t LocalSocketPair::ReceiveToBinder(MessageParcel &data)
163 {
164 return SendFdToBinder(data, receiveFd_);
165 }
166
167 // internal interface
CloseFd(int32_t & fd)168 void LocalSocketPair::CloseFd(int32_t &fd)
169 {
170 if (fd != INVALID_FD) {
171 close(fd);
172 fd = INVALID_FD;
173 }
174 }
175 }
176
177