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 "sensors_errors.h"
24
25 namespace OHOS {
26 namespace Sensors {
27 using namespace OHOS::HiviewDFX;
28
29 namespace {
30 constexpr HiLogLabel LABEL = { LOG_CORE, SENSOR_LOG_DOMAIN, "SensorBasicChannel" };
31 constexpr int32_t SENSOR_READ_DATA_SIZE = sizeof(SensorEvent) * 100;
32 constexpr int32_t DEFAULT_CHANNEL_SIZE = 2 * 1024;
33 constexpr int32_t SOCKET_PAIR_SIZE = 2;
34 } // namespace
35
SensorBasicDataChannel()36 SensorBasicDataChannel::SensorBasicDataChannel() : sendFd_(-1), receiveFd_(-1), isActive_(false)
37 {
38 SEN_HILOGD("isActive_:%{public}d,sendFd:%{public}d", isActive_, sendFd_);
39 }
40
CreateSensorBasicChannel()41 int32_t SensorBasicDataChannel::CreateSensorBasicChannel()
42 {
43 if ((sendFd_ != -1) || (receiveFd_ != -1)) {
44 SEN_HILOGD("already create socketpair");
45 return ERR_OK;
46 }
47
48 int32_t socketPair[SOCKET_PAIR_SIZE] = { 0 };
49 if (socketpair(AF_UNIX, SOCK_SEQPACKET, 0, socketPair) != 0) {
50 HiSysEvent::Write(HiviewDFX::HiSysEvent::Domain::SENSOR, "SENSOR_DATA_CHANNEL_EXCEPTION",
51 HiSysEvent::EventType::FAULT, "PKG_NAME", "CreateSensorBasicChannel", "ERROR_CODE", errno);
52 SEN_HILOGE("create socketpair failed");
53 sendFd_ = -1;
54 receiveFd_ = -1;
55 return SENSOR_CHANNEL_SOCKET_CREATE_ERR;
56 }
57 // set socket attr
58 int32_t ret = setsockopt(socketPair[0], SOL_SOCKET, SO_SNDBUF, &SENSOR_READ_DATA_SIZE,
59 sizeof(SENSOR_READ_DATA_SIZE));
60 if (ret != 0) {
61 SEN_HILOGE("setsockopt socketpair 0 failed");
62 return SENSOR_CHANNEL_SOCKET_CREATE_ERR;
63 }
64 ret = setsockopt(socketPair[1], SOL_SOCKET, SO_RCVBUF, &SENSOR_READ_DATA_SIZE, sizeof(SENSOR_READ_DATA_SIZE));
65 if (ret != 0) {
66 SEN_HILOGE("setsockopt socketpair 1 failed");
67 return SENSOR_CHANNEL_SOCKET_CREATE_ERR;
68 }
69 int32_t bufferSize = DEFAULT_CHANNEL_SIZE;
70 ret = setsockopt(socketPair[0], SOL_SOCKET, SO_RCVBUF, &bufferSize, sizeof(bufferSize));
71 if (ret != 0) {
72 SEN_HILOGE("setsockopt socketpair 0 failed");
73 return SENSOR_CHANNEL_SOCKET_CREATE_ERR;
74 }
75 ret = setsockopt(socketPair[1], SOL_SOCKET, SO_SNDBUF, &bufferSize, sizeof(bufferSize));
76 if (ret != 0) {
77 SEN_HILOGE("setsockopt socketpair 1 failed");
78 return SENSOR_CHANNEL_SOCKET_CREATE_ERR;
79 }
80 ret = fcntl(socketPair[0], F_SETFL, O_NONBLOCK);
81 if (ret != 0) {
82 SEN_HILOGE("fcntl socketpair 0 failed");
83 return SENSOR_CHANNEL_SOCKET_CREATE_ERR;
84 }
85 ret = fcntl(socketPair[1], F_SETFL, O_NONBLOCK);
86 if (ret != 0) {
87 SEN_HILOGE("fcntl socketpair 1 failed");
88 return SENSOR_CHANNEL_SOCKET_CREATE_ERR;
89 }
90 sendFd_ = socketPair[0];
91 receiveFd_ = socketPair[1];
92 SEN_HILOGD("create socketpair success,receiveFd_:%{public}d,sendFd_:%{public}d", receiveFd_, sendFd_);
93 return ERR_OK;
94 }
95
CreateSensorBasicChannel(MessageParcel & data)96 int32_t SensorBasicDataChannel::CreateSensorBasicChannel(MessageParcel &data)
97 {
98 CALL_LOG_ENTER;
99 if ((sendFd_ != -1) || (receiveFd_ != -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 HiSysEvent::Write(HiviewDFX::HiSysEvent::Domain::SENSOR, "SENSOR_DATA_CHANNEL_EXCEPTION",
155 HiSysEvent::EventType::FAULT, "PKG_NAME", "SendData", "ERROR_CODE", errno);
156 SEN_HILOGE("send fail:%{public}d,length:%{public}d", errno, (int32_t)length);
157 return SENSOR_CHANNEL_SEND_DATA_ERR;
158 }
159 return ERR_OK;
160 }
161
ReceiveData(void * vaddr,size_t size)162 int32_t SensorBasicDataChannel::ReceiveData(void *vaddr, size_t size)
163 {
164 CHKPR(vaddr, SENSOR_CHANNEL_SEND_ADDR_ERR);
165 SEN_HILOGE("failed, vaddr is null or receiveFd_ invalid");
166 return SENSOR_CHANNEL_RECEIVE_ADDR_ERR;
167 ssize_t length;
168 do {
169 length = recv(receiveFd_, vaddr, size, MSG_DONTWAIT);
170 } while (errno == EINTR);
171 return length;
172 }
173
GetSendDataFd() const174 int32_t SensorBasicDataChannel::GetSendDataFd() const
175 {
176 return sendFd_;
177 }
178
GetReceiveDataFd() const179 int32_t SensorBasicDataChannel::GetReceiveDataFd() const
180 {
181 return receiveFd_;
182 }
183
DestroySensorBasicChannel()184 int32_t SensorBasicDataChannel::DestroySensorBasicChannel()
185 {
186 if (sendFd_ >= 0) {
187 close(sendFd_);
188 sendFd_ = -1;
189 SEN_HILOGD("close sendFd_ success");
190 }
191 if (receiveFd_ >= 0) {
192 close(receiveFd_);
193 receiveFd_ = -1;
194 SEN_HILOGD("close receiveFd_ success");
195 }
196 return ERR_OK;
197 }
198
GetDataCacheBuf() const199 const std::unordered_map<uint32_t, SensorEvent> &SensorBasicDataChannel::GetDataCacheBuf() const
200 {
201 return dataCacheBuf_;
202 }
203
GetSensorStatus() const204 bool SensorBasicDataChannel::GetSensorStatus() const
205 {
206 return isActive_;
207 }
208
SetSensorStatus(bool isActive)209 void SensorBasicDataChannel::SetSensorStatus(bool isActive)
210 {
211 SEN_HILOGD("isActive_:%{public}d", isActive);
212 std::unique_lock<std::mutex> lock(statusLock_);
213 isActive_ = isActive;
214 return;
215 }
216 } // namespace Sensors
217 } // namespace OHOS
218