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 "sensor_basic_data_channel.h"
17
18 #include <fcntl.h>
19 #include <sys/socket.h>
20 #include <unistd.h>
21
22 #include "hisysevent.h"
23 #include "sensor_errors.h"
24
25 #undef LOG_TAG
26 #define LOG_TAG "SensorBasicChannel"
27
28 namespace OHOS {
29 namespace Sensors {
30 using namespace OHOS::HiviewDFX;
31
32 namespace {
33 constexpr int32_t SENSOR_READ_DATA_SIZE = sizeof(SensorData) * 100;
34 constexpr int32_t DEFAULT_CHANNEL_SIZE = 2 * 1024;
35 constexpr int32_t SOCKET_PAIR_SIZE = 2;
36 } // namespace
37
SensorBasicDataChannel()38 SensorBasicDataChannel::SensorBasicDataChannel() : sendFd_(-1), receiveFd_(-1), isActive_(false)
39 {
40 SEN_HILOGD("isActive_:%{public}d, sendFd:%{public}d", isActive_, sendFd_);
41 }
42
CreateSensorBasicChannel()43 int32_t SensorBasicDataChannel::CreateSensorBasicChannel()
44 {
45 if ((sendFd_ != -1) || (receiveFd_ != -1)) {
46 SEN_HILOGD("Already create socketpair");
47 return ERR_OK;
48 }
49
50 int32_t socketPair[SOCKET_PAIR_SIZE] = { 0 };
51 if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, socketPair) != 0) {
52 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::SENSOR, "DATA_CHANNEL_EXCEPTION",
53 HiSysEvent::EventType::FAULT, "PKG_NAME", "CreateSensorBasicChannel", "ERROR_CODE", errno);
54 SEN_HILOGE("Create socketpair failed");
55 sendFd_ = -1;
56 receiveFd_ = -1;
57 return SENSOR_CHANNEL_SOCKET_CREATE_ERR;
58 }
59 // set socket attr
60 if (setsockopt(socketPair[0], SOL_SOCKET, SO_SNDBUF, &SENSOR_READ_DATA_SIZE, sizeof(SENSOR_READ_DATA_SIZE)) != 0) {
61 SEN_HILOGE("setsockopt socketpair 0, SNDBUF failed, errno:%{public}d", errno);
62 goto CLOSE_SOCK;
63 }
64 if (setsockopt(socketPair[1], SOL_SOCKET, SO_RCVBUF, &SENSOR_READ_DATA_SIZE, sizeof(SENSOR_READ_DATA_SIZE)) != 0) {
65 SEN_HILOGE("setsockopt socketpair 1, RCVBUF failed, errno:%{public}d", errno);
66 goto CLOSE_SOCK;
67 }
68 if (setsockopt(socketPair[0], SOL_SOCKET, SO_RCVBUF, &DEFAULT_CHANNEL_SIZE, sizeof(DEFAULT_CHANNEL_SIZE)) != 0) {
69 SEN_HILOGE("setsockopt socketpair 0, RCVBUF failed, errno:%{public}d", errno);
70 goto CLOSE_SOCK;
71 }
72 if (setsockopt(socketPair[1], SOL_SOCKET, SO_SNDBUF, &DEFAULT_CHANNEL_SIZE, sizeof(DEFAULT_CHANNEL_SIZE)) != 0) {
73 SEN_HILOGE("setsockopt socketpair 1, SNDBUF failed, errno:%{public}d", errno);
74 goto CLOSE_SOCK;
75 }
76 if (fcntl(socketPair[0], F_SETFL, O_NONBLOCK) != 0) {
77 SEN_HILOGE("fcntl socketpair 0 failed, errno:%{public}d", errno);
78 goto CLOSE_SOCK;
79 }
80 if (fcntl(socketPair[1], F_SETFL, O_NONBLOCK) != 0) {
81 SEN_HILOGE("fcntl socketpair 1 failed, errno:%{public}d", errno);
82 goto CLOSE_SOCK;
83 }
84 sendFd_ = socketPair[0];
85 receiveFd_ = socketPair[1];
86 return ERR_OK;
87
88 CLOSE_SOCK:
89 close(socketPair[0]);
90 close(socketPair[1]);
91 sendFd_ = -1;
92 receiveFd_ = -1;
93 return SENSOR_CHANNEL_SOCKET_CREATE_ERR;
94 }
95
CreateSensorBasicChannel(MessageParcel & data)96 int32_t SensorBasicDataChannel::CreateSensorBasicChannel(MessageParcel &data)
97 {
98 CALL_LOG_ENTER;
99 if (sendFd_ != -1) {
100 SEN_HILOGD("Already create socketpair");
101 return ERR_OK;
102 }
103 sendFd_ = data.ReadFileDescriptor();
104 if (sendFd_ < 0) {
105 SEN_HILOGE("ReadFileDescriptor is failed");
106 sendFd_ = -1;
107 return SENSOR_CHANNEL_READ_DESCRIPTOR_ERR;
108 }
109 return ERR_OK;
110 }
111
~SensorBasicDataChannel()112 SensorBasicDataChannel::~SensorBasicDataChannel()
113 {
114 DestroySensorBasicChannel();
115 }
116
SendToBinder(MessageParcel & data)117 int32_t SensorBasicDataChannel::SendToBinder(MessageParcel &data)
118 {
119 SEN_HILOGD("sendFd:%{public}d", sendFd_);
120 if (sendFd_ < 0) {
121 SEN_HILOGE("sendFd FileDescriptor error");
122 return SENSOR_CHANNEL_SENDFD_ERR;
123 }
124 bool result = data.WriteFileDescriptor(sendFd_);
125 if (!result) {
126 SEN_HILOGE("Send sendFd_ failed");
127 CloseSendFd();
128 return SENSOR_CHANNEL_WRITE_DESCRIPTOR_ERR;
129 }
130 return ERR_OK;
131 }
132
CloseSendFd()133 void SensorBasicDataChannel::CloseSendFd()
134 {
135 if (sendFd_ != -1) {
136 close(sendFd_);
137 sendFd_ = -1;
138 SEN_HILOGD("Close sendFd_");
139 }
140 }
141
SendData(const void * vaddr,size_t size)142 int32_t SensorBasicDataChannel::SendData(const void *vaddr, size_t size)
143 {
144 CHKPR(vaddr, SENSOR_CHANNEL_SEND_ADDR_ERR);
145 if (sendFd_ < 0) {
146 SEN_HILOGE("Failed, param is invalid");
147 return SENSOR_CHANNEL_SEND_ADDR_ERR;
148 }
149 ssize_t length;
150 do {
151 length = send(sendFd_, vaddr, size, MSG_DONTWAIT | MSG_NOSIGNAL);
152 } while (errno == EINTR);
153 if (length < 0) {
154 SEN_HILOGD("Send fail:%{public}d, length:%{public}d", errno, (int32_t)length);
155 return SENSOR_CHANNEL_SEND_DATA_ERR;
156 }
157 return ERR_OK;
158 }
159
ReceiveData(void * vaddr,size_t size)160 int32_t SensorBasicDataChannel::ReceiveData(void *vaddr, size_t size)
161 {
162 if ((vaddr == nullptr) || (receiveFd_ < 0)) {
163 SEN_HILOGE("Failed, vaddr is null or receiveFd_ invalid");
164 return SENSOR_CHANNEL_RECEIVE_ADDR_ERR;
165 }
166 ssize_t length;
167 do {
168 length = recv(receiveFd_, vaddr, size, MSG_DONTWAIT);
169 } while (errno == EINTR);
170 return length;
171 }
172
GetSendDataFd() const173 int32_t SensorBasicDataChannel::GetSendDataFd() const
174 {
175 return sendFd_;
176 }
177
GetReceiveDataFd() const178 int32_t SensorBasicDataChannel::GetReceiveDataFd() const
179 {
180 return receiveFd_;
181 }
182
DestroySensorBasicChannel()183 int32_t SensorBasicDataChannel::DestroySensorBasicChannel()
184 {
185 if (sendFd_ >= 0) {
186 close(sendFd_);
187 sendFd_ = -1;
188 SEN_HILOGD("Close sendFd_ success");
189 }
190 if (receiveFd_ >= 0) {
191 close(receiveFd_);
192 receiveFd_ = -1;
193 SEN_HILOGD("Close receiveFd_ success");
194 }
195 return ERR_OK;
196 }
197
GetDataCacheBuf() const198 const std::unordered_map<int32_t, SensorData> &SensorBasicDataChannel::GetDataCacheBuf() const
199 {
200 return dataCacheBuf_;
201 }
202
GetSensorStatus() const203 bool SensorBasicDataChannel::GetSensorStatus() const
204 {
205 return isActive_;
206 }
207
SetSensorStatus(bool isActive)208 void SensorBasicDataChannel::SetSensorStatus(bool isActive)
209 {
210 SEN_HILOGD("isActive_:%{public}d", isActive);
211 std::unique_lock<std::mutex> lock(statusLock_);
212 isActive_ = isActive;
213 return;
214 }
215 } // namespace Sensors
216 } // namespace OHOS
217