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(SensorData) * 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 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::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 if (setsockopt(socketPair[0], SOL_SOCKET, SO_SNDBUF, &SENSOR_READ_DATA_SIZE, sizeof(SENSOR_READ_DATA_SIZE)) != 0) {
59 SEN_HILOGE("setsockopt socketpair 0, SNDBUF failed, errno:%{public}d", errno);
60 goto CLOSE_SOCK;
61 }
62 if (setsockopt(socketPair[1], SOL_SOCKET, SO_RCVBUF, &SENSOR_READ_DATA_SIZE, sizeof(SENSOR_READ_DATA_SIZE)) != 0) {
63 SEN_HILOGE("setsockopt socketpair 1, RCVBUF failed, errno:%{public}d", errno);
64 goto CLOSE_SOCK;
65 }
66 if (setsockopt(socketPair[0], SOL_SOCKET, SO_RCVBUF, &DEFAULT_CHANNEL_SIZE, sizeof(DEFAULT_CHANNEL_SIZE)) != 0) {
67 SEN_HILOGE("setsockopt socketpair 0, RCVBUF failed, errno:%{public}d", errno);
68 goto CLOSE_SOCK;
69 }
70 if (setsockopt(socketPair[1], SOL_SOCKET, SO_SNDBUF, &DEFAULT_CHANNEL_SIZE, sizeof(DEFAULT_CHANNEL_SIZE)) != 0) {
71 SEN_HILOGE("setsockopt socketpair 1, SNDBUF failed, errno:%{public}d", errno);
72 goto CLOSE_SOCK;
73 }
74 if (fcntl(socketPair[0], F_SETFL, O_NONBLOCK) != 0) {
75 SEN_HILOGE("fcntl socketpair 0 failed, errno:%{public}d", errno);
76 goto CLOSE_SOCK;
77 }
78 if (fcntl(socketPair[1], F_SETFL, O_NONBLOCK) != 0) {
79 SEN_HILOGE("fcntl socketpair 1 failed, errno:%{public}d", errno);
80 goto CLOSE_SOCK;
81 }
82 sendFd_ = socketPair[0];
83 receiveFd_ = socketPair[1];
84 return ERR_OK;
85
86 CLOSE_SOCK:
87 close(socketPair[0]);
88 close(socketPair[1]);
89 sendFd_ = -1;
90 receiveFd_ = -1;
91 return SENSOR_CHANNEL_SOCKET_CREATE_ERR;
92 }
93
CreateSensorBasicChannel(MessageParcel & data)94 int32_t SensorBasicDataChannel::CreateSensorBasicChannel(MessageParcel &data)
95 {
96 CALL_LOG_ENTER;
97 if (sendFd_ != -1) {
98 SEN_HILOGD("Already create socketpair");
99 return ERR_OK;
100 }
101 sendFd_ = data.ReadFileDescriptor();
102 if (sendFd_ < 0) {
103 SEN_HILOGE("ReadFileDescriptor is failed");
104 sendFd_ = -1;
105 return SENSOR_CHANNEL_READ_DESCRIPTOR_ERR;
106 }
107 return ERR_OK;
108 }
109
~SensorBasicDataChannel()110 SensorBasicDataChannel::~SensorBasicDataChannel()
111 {
112 DestroySensorBasicChannel();
113 }
114
SendToBinder(MessageParcel & data)115 int32_t SensorBasicDataChannel::SendToBinder(MessageParcel &data)
116 {
117 SEN_HILOGD("sendFd:%{public}d", sendFd_);
118 if (sendFd_ < 0) {
119 SEN_HILOGE("sendFd FileDescriptor error");
120 return SENSOR_CHANNEL_SENDFD_ERR;
121 }
122 bool result = data.WriteFileDescriptor(sendFd_);
123 if (!result) {
124 SEN_HILOGE("Send sendFd_ failed");
125 CloseSendFd();
126 return SENSOR_CHANNEL_WRITE_DESCRIPTOR_ERR;
127 }
128 return ERR_OK;
129 }
130
CloseSendFd()131 void SensorBasicDataChannel::CloseSendFd()
132 {
133 if (sendFd_ != -1) {
134 close(sendFd_);
135 sendFd_ = -1;
136 SEN_HILOGD("Close sendFd_");
137 }
138 }
139
SendData(const void * vaddr,size_t size)140 int32_t SensorBasicDataChannel::SendData(const void *vaddr, size_t size)
141 {
142 CHKPR(vaddr, SENSOR_CHANNEL_SEND_ADDR_ERR);
143 if (sendFd_ < 0) {
144 SEN_HILOGE("Failed, param is invalid");
145 return SENSOR_CHANNEL_SEND_ADDR_ERR;
146 }
147 ssize_t length;
148 do {
149 length = send(sendFd_, vaddr, size, MSG_DONTWAIT | MSG_NOSIGNAL);
150 } while (errno == EINTR);
151 if (length < 0) {
152 HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::SENSOR, "DATA_CHANNEL_EXCEPTION",
153 HiSysEvent::EventType::FAULT, "PKG_NAME", "SendData", "ERROR_CODE", errno);
154 SEN_HILOGE("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