1 /*
2  * Copyright (c) 2021-2023 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_service_stub.h"
17 
18 #include <string>
19 #include <sys/socket.h>
20 #include <tokenid_kit.h>
21 #include <unistd.h>
22 #include <vector>
23 
24 #include "accesstoken_kit.h"
25 #ifdef HIVIEWDFX_HISYSEVENT_ENABLE
26 #include "hisysevent.h"
27 #endif // HIVIEWDFX_HISYSEVENT_ENABLE
28 #include "ipc_skeleton.h"
29 #include "message_parcel.h"
30 #include "permission_util.h"
31 #include "sensor_client_proxy.h"
32 #include "sensor_errors.h"
33 #include "sensor_parcel.h"
34 
35 #undef LOG_TAG
36 #define LOG_TAG "SensorServiceStub"
37 
38 namespace OHOS {
39 namespace Sensors {
40 using namespace OHOS::HiviewDFX;
41 
SensorServiceStub()42 SensorServiceStub::SensorServiceStub() {}
43 
~SensorServiceStub()44 SensorServiceStub::~SensorServiceStub() {}
45 
ProcessRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)46 int32_t SensorServiceStub::ProcessRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
47     MessageOption &option)
48 {
49     switch (code) {
50         case static_cast<int32_t>(SensorInterfaceCode::ENABLE_SENSOR): {
51             return SensorEnableInner(data, reply);
52         }
53         case static_cast<int32_t>(SensorInterfaceCode::DISABLE_SENSOR): {
54             return SensorDisableInner(data, reply);
55         }
56         case static_cast<int32_t>(SensorInterfaceCode::GET_SENSOR_LIST): {
57             return GetAllSensorsInner(data, reply);
58         }
59         case static_cast<int32_t>(SensorInterfaceCode::TRANSFER_DATA_CHANNEL): {
60             return CreateDataChannelInner(data, reply);
61         }
62         case static_cast<int32_t>(SensorInterfaceCode::DESTROY_SENSOR_CHANNEL): {
63             return DestroyDataChannelInner(data, reply);
64         }
65         case static_cast<int32_t>(SensorInterfaceCode::SUSPEND_SENSORS): {
66             return SuspendSensorsInner(data, reply);
67         }
68         case static_cast<int32_t>(SensorInterfaceCode::RESUME_SENSORS): {
69             return ResumeSensorsInner(data, reply);
70         }
71         case static_cast<int32_t>(SensorInterfaceCode::GET_ACTIVE_INFO_LIST): {
72             return GetActiveInfoListInner(data, reply);
73         }
74         case static_cast<int32_t>(SensorInterfaceCode::CREATE_SOCKET_CHANNEL): {
75             return CreateSocketChannelInner(data, reply);
76         }
77         case static_cast<int32_t>(SensorInterfaceCode::DESTROY_SOCKET_CHANNEL): {
78             return DestroySocketChannelInner(data, reply);
79         }
80         case static_cast<int32_t>(SensorInterfaceCode::ENABLE_ACTIVE_INFO_CB): {
81             return EnableActiveInfoCBInner(data, reply);
82         }
83         case static_cast<int32_t>(SensorInterfaceCode::DISABLE_ACTIVE_INFO_CB): {
84             return DisableActiveInfoCBInner(data, reply);
85         }
86         case static_cast<int32_t>(SensorInterfaceCode::RESET_SENSORS): {
87             return ResetSensorsInner(data, reply);
88         }
89         default: {
90             SEN_HILOGD("No member func supporting, applying default process");
91             return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
92         }
93     }
94 }
95 
OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)96 int32_t SensorServiceStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
97                                            MessageOption &option)
98 {
99     SEN_HILOGD("Begin, cmd:%{public}u", code);
100     std::u16string descriptor = SensorServiceStub::GetDescriptor();
101     std::u16string remoteDescriptor = data.ReadInterfaceToken();
102     if (descriptor != remoteDescriptor) {
103         SEN_HILOGE("Client and service descriptors are inconsistent");
104         return OBJECT_NULL;
105     }
106     return ProcessRemoteRequest(code, data, reply, option);
107 }
108 
IsSystemServiceCalling()109 bool SensorServiceStub::IsSystemServiceCalling()
110 {
111     const auto tokenId = IPCSkeleton::GetCallingTokenID();
112     const auto flag = Security::AccessToken::AccessTokenKit::GetTokenTypeFlag(tokenId);
113     if (flag == Security::AccessToken::ATokenTypeEnum::TOKEN_NATIVE ||
114         flag == Security::AccessToken::ATokenTypeEnum::TOKEN_SHELL) {
115         SEN_HILOGD("system service calling, tokenId: %{public}u, flag: %{public}u", tokenId, flag);
116         return true;
117     }
118     return false;
119 }
120 
IsSystemCalling()121 bool SensorServiceStub::IsSystemCalling()
122 {
123     if (IsSystemServiceCalling()) {
124         return true;
125     }
126     return Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(IPCSkeleton::GetCallingFullTokenID());
127 }
128 
SensorEnableInner(MessageParcel &data, MessageParcel &reply)129 ErrCode SensorServiceStub::SensorEnableInner(MessageParcel &data, MessageParcel &reply)
130 {
131     (void)reply;
132     int32_t sensorId;
133     READINT32(data, sensorId, READ_PARCEL_ERR);
134     if ((sensorId == SENSOR_TYPE_ID_COLOR || sensorId == SENSOR_TYPE_ID_SAR) && !IsSystemCalling()) {
135         SEN_HILOGE("Permission check failed. A non-system application uses the system API");
136         return NON_SYSTEM_API;
137     }
138     PermissionUtil &permissionUtil = PermissionUtil::GetInstance();
139     int32_t ret = permissionUtil.CheckSensorPermission(GetCallingTokenID(), sensorId);
140     if (ret != PERMISSION_GRANTED) {
141 #ifdef HIVIEWDFX_HISYSEVENT_ENABLE
142         HiSysEventWrite(HiSysEvent::Domain::SENSOR, "VERIFY_ACCESS_TOKEN_FAIL",
143             HiSysEvent::EventType::SECURITY, "PKG_NAME", "SensorEnableInner", "ERROR_CODE", ret);
144 #endif // HIVIEWDFX_HISYSEVENT_ENABLE
145         SEN_HILOGE("sensorId:%{public}d grant failed, result:%{public}d", sensorId, ret);
146         return PERMISSION_DENIED;
147     }
148     int64_t samplingPeriodNs;
149     int64_t maxReportDelayNs;
150     READINT64(data, samplingPeriodNs, READ_PARCEL_ERR);
151     READINT64(data, maxReportDelayNs, READ_PARCEL_ERR);
152     return EnableSensor(sensorId, samplingPeriodNs, maxReportDelayNs);
153 }
154 
SensorDisableInner(MessageParcel &data, MessageParcel &reply)155 ErrCode SensorServiceStub::SensorDisableInner(MessageParcel &data, MessageParcel &reply)
156 {
157     (void)reply;
158     int32_t sensorId;
159     READINT32(data, sensorId, READ_PARCEL_ERR);
160     if ((sensorId == SENSOR_TYPE_ID_COLOR || sensorId == SENSOR_TYPE_ID_SAR) && !IsSystemCalling()) {
161         SEN_HILOGE("Permission check failed. A non-system application uses the system API");
162         return NON_SYSTEM_API;
163     }
164     PermissionUtil &permissionUtil = PermissionUtil::GetInstance();
165     int32_t ret = permissionUtil.CheckSensorPermission(GetCallingTokenID(), sensorId);
166     if (ret != PERMISSION_GRANTED) {
167 #ifdef HIVIEWDFX_HISYSEVENT_ENABLE
168         HiSysEventWrite(HiSysEvent::Domain::SENSOR, "VERIFY_ACCESS_TOKEN_FAIL",
169             HiSysEvent::EventType::SECURITY, "PKG_NAME", "SensorDisableInner", "ERROR_CODE", ret);
170 #endif // HIVIEWDFX_HISYSEVENT_ENABLE
171         SEN_HILOGE("sensorId:%{public}d grant failed, result:%{public}d", sensorId, ret);
172         return PERMISSION_DENIED;
173     }
174     return DisableSensor(sensorId);
175 }
176 
GetAllSensorsInner(MessageParcel &data, MessageParcel &reply)177 ErrCode SensorServiceStub::GetAllSensorsInner(MessageParcel &data, MessageParcel &reply)
178 {
179     (void)data;
180     std::vector<Sensor> sensors = GetSensorList();
181     uint32_t sensorCount = static_cast<uint32_t>(sensors.size());
182     if (sensorCount > MAX_SENSOR_COUNT) {
183         SEN_HILOGD("SensorCount:%{public}u", sensorCount);
184         sensorCount = MAX_SENSOR_COUNT;
185     }
186     WRITEUINT32(reply, sensorCount, WRITE_PARCEL_ERR);
187     for (uint32_t i = 0; i < sensorCount; ++i) {
188         if (!sensors[i].Marshalling(reply)) {
189             SEN_HILOGE("Sensor %{public}u marshalling failed", i);
190             return GET_SENSOR_LIST_ERR;
191         }
192     }
193     return NO_ERROR;
194 }
195 
CreateDataChannelInner(MessageParcel &data, MessageParcel &reply)196 ErrCode SensorServiceStub::CreateDataChannelInner(MessageParcel &data, MessageParcel &reply)
197 {
198     (void)reply;
199     sptr<SensorBasicDataChannel> sensorChannel = new (std::nothrow) SensorBasicDataChannel();
200     CHKPR(sensorChannel, OBJECT_NULL);
201     auto ret = sensorChannel->CreateSensorBasicChannel(data);
202     if (ret != ERR_OK) {
203         SEN_HILOGE("CreateSensorBasicChannel ret:%{public}d", ret);
204         return OBJECT_NULL;
205     }
206     sptr<IRemoteObject> sensorClient = data.ReadRemoteObject();
207     CHKPR(sensorClient, OBJECT_NULL);
208     return TransferDataChannel(sensorChannel, sensorClient);
209 }
210 
DestroyDataChannelInner(MessageParcel &data, MessageParcel &reply)211 ErrCode SensorServiceStub::DestroyDataChannelInner(MessageParcel &data, MessageParcel &reply)
212 {
213     sptr<IRemoteObject> sensorClient = data.ReadRemoteObject();
214     CHKPR(sensorClient, OBJECT_NULL);
215     return DestroySensorChannel(sensorClient);
216 }
217 
SuspendSensorsInner(MessageParcel &data, MessageParcel &reply)218 ErrCode SensorServiceStub::SuspendSensorsInner(MessageParcel &data, MessageParcel &reply)
219 {
220     PermissionUtil &permissionUtil = PermissionUtil::GetInstance();
221     if (!permissionUtil.IsNativeToken(GetCallingTokenID())) {
222         SEN_HILOGE("TokenType is not TOKEN_NATIVE");
223         return PERMISSION_DENIED;
224     }
225     int32_t ret = permissionUtil.CheckManageSensorPermission(GetCallingTokenID());
226     if (ret != PERMISSION_GRANTED) {
227         SEN_HILOGE("Check manage sensor permission failed, ret:%{public}d", ret);
228         return PERMISSION_DENIED;
229     }
230     (void)reply;
231     int32_t pid;
232     READINT32(data, pid, READ_PARCEL_ERR);
233     return SuspendSensors(pid);
234 }
235 
ResumeSensorsInner(MessageParcel &data, MessageParcel &reply)236 ErrCode SensorServiceStub::ResumeSensorsInner(MessageParcel &data, MessageParcel &reply)
237 {
238     PermissionUtil &permissionUtil = PermissionUtil::GetInstance();
239     if (!permissionUtil.IsNativeToken(GetCallingTokenID())) {
240         SEN_HILOGE("TokenType is not TOKEN_NATIVE");
241         return PERMISSION_DENIED;
242     }
243     int32_t ret = permissionUtil.CheckManageSensorPermission(GetCallingTokenID());
244     if (ret != PERMISSION_GRANTED) {
245         SEN_HILOGE("Check manage sensor permission failed, ret:%{public}d", ret);
246         return PERMISSION_DENIED;
247     }
248     (void)reply;
249     int32_t pid;
250     READINT32(data, pid, READ_PARCEL_ERR);
251     return ResumeSensors(pid);
252 }
253 
GetActiveInfoListInner(MessageParcel &data, MessageParcel &reply)254 ErrCode SensorServiceStub::GetActiveInfoListInner(MessageParcel &data, MessageParcel &reply)
255 {
256     PermissionUtil &permissionUtil = PermissionUtil::GetInstance();
257     if (!permissionUtil.IsNativeToken(GetCallingTokenID())) {
258         SEN_HILOGE("TokenType is not TOKEN_NATIVE");
259         return PERMISSION_DENIED;
260     }
261     int32_t pid;
262     READINT32(data, pid, READ_PARCEL_ERR);
263     std::vector<ActiveInfo> activeInfoList;
264     int32_t ret = GetActiveInfoList(pid, activeInfoList);
265     if (ret != ERR_OK) {
266         SEN_HILOGE("Get activeInfo list failed");
267         return ret;
268     }
269     uint32_t activeInfoCount = static_cast<uint32_t>(activeInfoList.size());
270     if (activeInfoCount > MAX_SENSOR_COUNT) {
271         SEN_HILOGD("ActiveInfoCount:%{public}u", activeInfoCount);
272         activeInfoCount = MAX_SENSOR_COUNT;
273     }
274     WRITEUINT32(reply, activeInfoCount, WRITE_PARCEL_ERR);
275     for (uint32_t i = 0; i < activeInfoCount; ++i) {
276         if (!activeInfoList[i].Marshalling(reply)) {
277             SEN_HILOGE("ActiveInfo %{public}u marshalling failed", i);
278             return WRITE_PARCEL_ERR;
279         }
280     }
281     return ERR_OK;
282 }
283 
CreateSocketChannelInner(MessageParcel &data, MessageParcel &reply)284 ErrCode SensorServiceStub::CreateSocketChannelInner(MessageParcel &data, MessageParcel &reply)
285 {
286     PermissionUtil &permissionUtil = PermissionUtil::GetInstance();
287     if (!permissionUtil.IsNativeToken(GetCallingTokenID())) {
288         SEN_HILOGE("TokenType is not TOKEN_NATIVE");
289         return PERMISSION_DENIED;
290     }
291     sptr<IRemoteObject> sensorClient = data.ReadRemoteObject();
292     CHKPR(sensorClient, INVALID_POINTER);
293     int32_t clientFd = -1;
294     int32_t ret = CreateSocketChannel(sensorClient, clientFd);
295     if (ret != ERR_OK) {
296         SEN_HILOGE("Create socket channel failed");
297         return ret;
298     }
299     if (!reply.WriteFileDescriptor(clientFd)) {
300         SEN_HILOGE("Parcel write file descriptor failed");
301         close(clientFd);
302         return WRITE_PARCEL_ERR;
303     }
304     close(clientFd);
305     return ERR_OK;
306 }
307 
DestroySocketChannelInner(MessageParcel &data, MessageParcel &reply)308 ErrCode SensorServiceStub::DestroySocketChannelInner(MessageParcel &data, MessageParcel &reply)
309 {
310     PermissionUtil &permissionUtil = PermissionUtil::GetInstance();
311     if (!permissionUtil.IsNativeToken(GetCallingTokenID())) {
312         SEN_HILOGE("TokenType is not TOKEN_NATIVE");
313         return PERMISSION_DENIED;
314     }
315     sptr<IRemoteObject> sensorClient = data.ReadRemoteObject();
316     CHKPR(sensorClient, INVALID_POINTER);
317     int32_t ret = DestroySocketChannel(sensorClient);
318     if (ret != ERR_OK) {
319         SEN_HILOGE("Destroy socket channel failed");
320         return ret;
321     }
322     return ERR_OK;
323 }
324 
EnableActiveInfoCBInner(MessageParcel &data, MessageParcel &reply)325 ErrCode SensorServiceStub::EnableActiveInfoCBInner(MessageParcel &data, MessageParcel &reply)
326 {
327     PermissionUtil &permissionUtil = PermissionUtil::GetInstance();
328     if (!permissionUtil.IsNativeToken(GetCallingTokenID())) {
329         SEN_HILOGE("TokenType is not TOKEN_NATIVE");
330         return PERMISSION_DENIED;
331     }
332     return EnableActiveInfoCB();
333 }
334 
DisableActiveInfoCBInner(MessageParcel &data, MessageParcel &reply)335 ErrCode SensorServiceStub::DisableActiveInfoCBInner(MessageParcel &data, MessageParcel &reply)
336 {
337     PermissionUtil &permissionUtil = PermissionUtil::GetInstance();
338     if (!permissionUtil.IsNativeToken(GetCallingTokenID())) {
339         SEN_HILOGE("TokenType is not TOKEN_NATIVE");
340         return PERMISSION_DENIED;
341     }
342     return DisableActiveInfoCB();
343 }
344 
ResetSensorsInner(MessageParcel &data, MessageParcel &reply)345 ErrCode SensorServiceStub::ResetSensorsInner(MessageParcel &data, MessageParcel &reply)
346 {
347     PermissionUtil &permissionUtil = PermissionUtil::GetInstance();
348     if (!permissionUtil.IsNativeToken(GetCallingTokenID())) {
349         SEN_HILOGE("TokenType is not TOKEN_NATIVE");
350         return PERMISSION_DENIED;
351     }
352     int32_t ret = permissionUtil.CheckManageSensorPermission(GetCallingTokenID());
353     if (ret != PERMISSION_GRANTED) {
354         SEN_HILOGE("Check manage sensor permission failed, ret:%{public}d", ret);
355         return PERMISSION_DENIED;
356     }
357     return ResetSensors();
358 }
359 } // namespace Sensors
360 } // namespace OHOS
361