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 "accesstoken_kit.h"
17 #include "dcamera_ipc_interface_code.h"
18 #include "dcamera_radar.h"
19 #include "distributed_camera_sink_stub.h"
20 #include "distributed_camera_errno.h"
21 #include "distributed_hardware_log.h"
22 #include "ipc_skeleton.h"
23 #include "dcamera_sink_callback_proxy.h"
24
25 namespace OHOS {
26 namespace DistributedHardware {
DistributedCameraSinkStub()27 DistributedCameraSinkStub::DistributedCameraSinkStub() : IRemoteStub(true)
28 {
29 memberFuncMap_[static_cast<uint32_t>(IDCameraSinkInterfaceCode::INIT_SINK)] =
30 &DistributedCameraSinkStub::InitSinkInner;
31 memberFuncMap_[static_cast<uint32_t>(IDCameraSinkInterfaceCode::RELEASE_SINK)] =
32 &DistributedCameraSinkStub::ReleaseSinkInner;
33 memberFuncMap_[static_cast<uint32_t>(IDCameraSinkInterfaceCode::SUBSCRIBE_LOCAL_HARDWARE)] =
34 &DistributedCameraSinkStub::SubscribeLocalHardwareInner;
35 memberFuncMap_[static_cast<uint32_t>(IDCameraSinkInterfaceCode::UNSUBSCRIBE_LOCAL_HARDWARE)] =
36 &DistributedCameraSinkStub::UnsubscribeLocalHardwareInner;
37 memberFuncMap_[static_cast<uint32_t>(IDCameraSinkInterfaceCode::STOP_CAPTURE)] =
38 &DistributedCameraSinkStub::StopCaptureInner;
39 memberFuncMap_[static_cast<uint32_t>(IDCameraSinkInterfaceCode::CHANNEL_NEG)] =
40 &DistributedCameraSinkStub::ChannelNegInner;
41 memberFuncMap_[static_cast<uint32_t>(IDCameraSinkInterfaceCode::GET_CAMERA_INFO)] =
42 &DistributedCameraSinkStub::GetCameraInfoInner;
43 memberFuncMap_[static_cast<uint32_t>(IDCameraSinkInterfaceCode::OPEN_CHANNEL)] =
44 &DistributedCameraSinkStub::OpenChannelInner;
45 memberFuncMap_[static_cast<uint32_t>(IDCameraSinkInterfaceCode::CLOSE_CHANNEL)] =
46 &DistributedCameraSinkStub::CloseChannelInner;
47 memberFuncMap_[static_cast<uint32_t>(IDCameraSinkInterfaceCode::PAUSE_DISTRIBUTED_HARDWARE)] =
48 &DistributedCameraSinkStub::PauseDistributedHardwareInner;
49 memberFuncMap_[static_cast<uint32_t>(IDCameraSinkInterfaceCode::RESUME_DISTRIBUTED_HARDWARE)] =
50 &DistributedCameraSinkStub::ResumeDistributedHardwareInner;
51 memberFuncMap_[static_cast<uint32_t>(IDCameraSinkInterfaceCode::STOP_DISTRIBUTED_HARDWARE)] =
52 &DistributedCameraSinkStub::StopDistributedHardwareInner;
53 }
54
~DistributedCameraSinkStub()55 DistributedCameraSinkStub::~DistributedCameraSinkStub()
56 {}
57
HasEnableDHPermission()58 bool DistributedCameraSinkStub::HasEnableDHPermission()
59 {
60 Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
61 const std::string permissionName = "ohos.permission.ENABLE_DISTRIBUTED_HARDWARE";
62 int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
63 permissionName);
64 return (result == Security::AccessToken::PERMISSION_GRANTED);
65 }
66
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)67 int32_t DistributedCameraSinkStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,
68 MessageOption &option)
69 {
70 DHLOGD("remote request code: %{public}d", code);
71 std::u16string desc = DistributedCameraSinkStub::GetDescriptor();
72 std::u16string remoteDesc = data.ReadInterfaceToken();
73 if (desc != remoteDesc) {
74 DHLOGE("remoteDesc is invalid!");
75 return ERR_INVALID_DATA;
76 }
77
78 switch (code) {
79 case static_cast<uint32_t>(IDCameraSinkInterfaceCode::INIT_SINK):
80 return InitSinkInner(data, reply);
81 case static_cast<uint32_t>(IDCameraSinkInterfaceCode::RELEASE_SINK):
82 return ReleaseSinkInner(data, reply);
83 case static_cast<uint32_t>(IDCameraSinkInterfaceCode::SUBSCRIBE_LOCAL_HARDWARE):
84 return SubscribeLocalHardwareInner(data, reply);
85 case static_cast<uint32_t>(IDCameraSinkInterfaceCode::UNSUBSCRIBE_LOCAL_HARDWARE):
86 return UnsubscribeLocalHardwareInner(data, reply);
87 case static_cast<uint32_t>(IDCameraSinkInterfaceCode::STOP_CAPTURE):
88 return StopCaptureInner(data, reply);
89 case static_cast<uint32_t>(IDCameraSinkInterfaceCode::CHANNEL_NEG):
90 return ChannelNegInner(data, reply);
91 case static_cast<uint32_t>(IDCameraSinkInterfaceCode::GET_CAMERA_INFO):
92 return GetCameraInfoInner(data, reply);
93 case static_cast<uint32_t>(IDCameraSinkInterfaceCode::OPEN_CHANNEL):
94 return OpenChannelInner(data, reply);
95 case static_cast<uint32_t>(IDCameraSinkInterfaceCode::CLOSE_CHANNEL):
96 return CloseChannelInner(data, reply);
97 case static_cast<uint32_t>(IDCameraSinkInterfaceCode::PAUSE_DISTRIBUTED_HARDWARE):
98 return PauseDistributedHardwareInner(data, reply);
99 case static_cast<uint32_t>(IDCameraSinkInterfaceCode::RESUME_DISTRIBUTED_HARDWARE):
100 return ResumeDistributedHardwareInner(data, reply);
101 case static_cast<uint32_t>(IDCameraSinkInterfaceCode::STOP_DISTRIBUTED_HARDWARE):
102 return StopDistributedHardwareInner(data, reply);
103 default:
104 DHLOGE("Invalid OnRemoteRequest code=%{public}d", code);
105 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
106 }
107 return DCAMERA_NOT_FOUND;
108 }
109
InitSinkInner(MessageParcel & data,MessageParcel & reply)110 int32_t DistributedCameraSinkStub::InitSinkInner(MessageParcel &data, MessageParcel &reply)
111 {
112 DHLOGD("enter");
113 int32_t ret = DCAMERA_OK;
114 do {
115 if (!HasEnableDHPermission()) {
116 DHLOGE("The caller has no ENABLE_DISTRIBUTED_HARDWARE permission.");
117 ret = DCAMERA_BAD_VALUE;
118 break;
119 }
120 std::string params = data.ReadString();
121 if (params.empty() || params.size() > PARAM_MAX_SIZE) {
122 DHLOGE("params is invalid");
123 ret = DCAMERA_BAD_VALUE;
124 break;
125 }
126 sptr<IRemoteObject> remoteObject = data.ReadRemoteObject();
127 if (remoteObject == nullptr) {
128 DHLOGE("Read ReadRemoteObject failed.");
129 ret = DCAMERA_BAD_VALUE;
130 break;
131 }
132
133 sptr<DCameraSinkCallbackProxy> dCameraSinkCallbackProxy(new DCameraSinkCallbackProxy(remoteObject));
134 ret = InitSink(params, dCameraSinkCallbackProxy);
135 } while (0);
136 reply.WriteInt32(ret);
137 return DCAMERA_OK;
138 }
139
ReleaseSinkInner(MessageParcel & data,MessageParcel & reply)140 int32_t DistributedCameraSinkStub::ReleaseSinkInner(MessageParcel &data, MessageParcel &reply)
141 {
142 DHLOGD("enter");
143 int32_t ret = DCAMERA_OK;
144 do {
145 if (!HasEnableDHPermission()) {
146 DHLOGE("The caller has no ENABLE_DISTRIBUTED_HARDWARE permission.");
147 ret = DCAMERA_BAD_VALUE;
148 break;
149 }
150 ret = ReleaseSink();
151 } while (0);
152 reply.WriteInt32(ret);
153 return DCAMERA_OK;
154 }
155
SubscribeLocalHardwareInner(MessageParcel & data,MessageParcel & reply)156 int32_t DistributedCameraSinkStub::SubscribeLocalHardwareInner(MessageParcel &data, MessageParcel &reply)
157 {
158 DHLOGD("enter");
159 int32_t ret = DCAMERA_OK;
160 do {
161 std::string dhId = data.ReadString();
162 std::string parameters = data.ReadString();
163 if (parameters.empty() || parameters.size() > PARAM_MAX_SIZE || dhId.empty() ||
164 dhId.size() > DID_MAX_SIZE) {
165 DHLOGE("params is invalid");
166 ret = DCAMERA_BAD_VALUE;
167 break;
168 }
169 ret = SubscribeLocalHardware(dhId, parameters);
170 } while (0);
171 reply.WriteInt32(ret);
172 return DCAMERA_OK;
173 }
174
UnsubscribeLocalHardwareInner(MessageParcel & data,MessageParcel & reply)175 int32_t DistributedCameraSinkStub::UnsubscribeLocalHardwareInner(MessageParcel &data, MessageParcel &reply)
176 {
177 DHLOGD("enter");
178 int32_t ret = DCAMERA_OK;
179 do {
180 std::string dhId = data.ReadString();
181 if (dhId.empty() || dhId.size() > DID_MAX_SIZE) {
182 DHLOGE("params is invalid");
183 ret = DCAMERA_BAD_VALUE;
184 break;
185 }
186 ret = UnsubscribeLocalHardware(dhId);
187 } while (0);
188 reply.WriteInt32(ret);
189 return DCAMERA_OK;
190 }
191
StopCaptureInner(MessageParcel & data,MessageParcel & reply)192 int32_t DistributedCameraSinkStub::StopCaptureInner(MessageParcel &data, MessageParcel &reply)
193 {
194 DHLOGD("enter");
195 int32_t ret = DCAMERA_OK;
196 do {
197 std::string dhId = data.ReadString();
198 if (dhId.empty() || dhId.size() > DID_MAX_SIZE) {
199 DHLOGE("params is invalid");
200 ret = DCAMERA_BAD_VALUE;
201 break;
202 }
203 ret = StopCapture(dhId);
204 } while (0);
205 reply.WriteInt32(ret);
206 return DCAMERA_OK;
207 }
208
ChannelNegInner(MessageParcel & data,MessageParcel & reply)209 int32_t DistributedCameraSinkStub::ChannelNegInner(MessageParcel &data, MessageParcel &reply)
210 {
211 DHLOGD("enter");
212 int32_t ret = DCAMERA_OK;
213 do {
214 std::string dhId = data.ReadString();
215 std::string channelInfo = data.ReadString();
216 if (dhId.empty() || dhId.size() > DID_MAX_SIZE || channelInfo.empty() ||
217 channelInfo.size() > PARAM_MAX_SIZE) {
218 DHLOGE("params is invalid");
219 ret = DCAMERA_BAD_VALUE;
220 break;
221 }
222 ret = ChannelNeg(dhId, channelInfo);
223 } while (0);
224 reply.WriteInt32(ret);
225 return DCAMERA_OK;
226 }
227
GetCameraInfoInner(MessageParcel & data,MessageParcel & reply)228 int32_t DistributedCameraSinkStub::GetCameraInfoInner(MessageParcel &data, MessageParcel &reply)
229 {
230 DHLOGD("enter");
231 int32_t ret = DCAMERA_OK;
232 do {
233 std::string dhId = data.ReadString();
234 std::string cameraInfo = data.ReadString();
235 if (dhId.empty() || dhId.size() > DID_MAX_SIZE) {
236 DHLOGE("params is invalid");
237 ret = DCAMERA_BAD_VALUE;
238 break;
239 }
240 ret = GetCameraInfo(dhId, cameraInfo);
241 } while (0);
242 reply.WriteInt32(ret);
243 return DCAMERA_OK;
244 }
245
OpenChannelInner(MessageParcel & data,MessageParcel & reply)246 int32_t DistributedCameraSinkStub::OpenChannelInner(MessageParcel &data, MessageParcel &reply)
247 {
248 DHLOGD("DistributedCameraSinkStub OpenChannelInner Begin");
249 int32_t ret = DCAMERA_OK;
250 do {
251 std::string dhId = data.ReadString();
252 std::string openInfo = data.ReadString();
253 if (dhId.empty() || dhId.size() > DID_MAX_SIZE || openInfo.empty()||
254 openInfo.size() > PARAM_MAX_SIZE) {
255 DHLOGE("params is invalid");
256 ret = DCAMERA_BAD_VALUE;
257 break;
258 }
259 ret = OpenChannel(dhId, openInfo);
260 } while (0);
261 reply.WriteInt32(ret);
262 DHLOGD("DistributedCameraSinkStub OpenChannelInner End");
263 return DCAMERA_OK;
264 }
265
CloseChannelInner(MessageParcel & data,MessageParcel & reply)266 int32_t DistributedCameraSinkStub::CloseChannelInner(MessageParcel &data, MessageParcel &reply)
267 {
268 DHLOGD("enter");
269 int32_t ret = DCAMERA_OK;
270 do {
271 std::string dhId = data.ReadString();
272 if (dhId.empty() || dhId.size() > DID_MAX_SIZE) {
273 DHLOGE("params is invalid");
274 ret = DCAMERA_BAD_VALUE;
275 break;
276 }
277 ret = CloseChannel(dhId);
278 } while (0);
279 reply.WriteInt32(ret);
280 return DCAMERA_OK;
281 }
282
HasAccessDHPermission()283 bool DistributedCameraSinkStub::HasAccessDHPermission()
284 {
285 Security::AccessToken::AccessTokenID callerToken = IPCSkeleton::GetCallingTokenID();
286 const std::string permissionName = "ohos.permission.ACCESS_DISTRIBUTED_HARDWARE";
287 int32_t result = Security::AccessToken::AccessTokenKit::VerifyAccessToken(callerToken,
288 permissionName);
289 return (result == Security::AccessToken::PERMISSION_GRANTED);
290 }
291
PauseDistributedHardwareInner(MessageParcel & data,MessageParcel & reply)292 int32_t DistributedCameraSinkStub::PauseDistributedHardwareInner(MessageParcel &data, MessageParcel &reply)
293 {
294 DHLOGD("enter");
295 int32_t ret = DCAMERA_OK;
296 do {
297 if (!HasAccessDHPermission()) {
298 DHLOGE("The caller has no ACCESS_DISTRIBUTED_HARDWARE permission.");
299 ret = DCAMERA_BAD_VALUE;
300 break;
301 }
302 std::string networkId = data.ReadString();
303 if (networkId.empty() || networkId.size() > DID_MAX_SIZE) {
304 DHLOGE("params is invalid");
305 ret = DCAMERA_BAD_VALUE;
306 break;
307 }
308 ret = PauseDistributedHardware(networkId);
309 } while (0);
310 reply.WriteInt32(ret);
311 return DCAMERA_OK;
312 }
313
ResumeDistributedHardwareInner(MessageParcel & data,MessageParcel & reply)314 int32_t DistributedCameraSinkStub::ResumeDistributedHardwareInner(MessageParcel &data, MessageParcel &reply)
315 {
316 DHLOGD("enter");
317 int32_t ret = DCAMERA_OK;
318 do {
319 if (!HasAccessDHPermission()) {
320 DHLOGE("The caller has no ACCESS_DISTRIBUTED_HARDWARE permission.");
321 ret = DCAMERA_BAD_VALUE;
322 break;
323 }
324 std::string networkId = data.ReadString();
325 if (networkId.empty() || networkId.size() > DID_MAX_SIZE) {
326 DHLOGE("params is invalid");
327 ret = DCAMERA_BAD_VALUE;
328 break;
329 }
330 ret = ResumeDistributedHardware(networkId);
331 } while (0);
332 reply.WriteInt32(ret);
333 return DCAMERA_OK;
334 }
335
StopDistributedHardwareInner(MessageParcel & data,MessageParcel & reply)336 int32_t DistributedCameraSinkStub::StopDistributedHardwareInner(MessageParcel &data, MessageParcel &reply)
337 {
338 DHLOGD("enter");
339 int32_t ret = DCAMERA_OK;
340 do {
341 if (!HasAccessDHPermission()) {
342 DHLOGE("The caller has no ACCESS_DISTRIBUTED_HARDWARE permission.");
343 ret = DCAMERA_BAD_VALUE;
344 break;
345 }
346 std::string networkId = data.ReadString();
347 if (networkId.empty() || networkId.size() > DID_MAX_SIZE) {
348 DHLOGE("params is invalid");
349 ret = DCAMERA_BAD_VALUE;
350 break;
351 }
352 ret = StopDistributedHardware(networkId);
353 } while (0);
354 reply.WriteInt32(ret);
355 return DCAMERA_OK;
356 }
357 } // namespace DistributedHardware
358 } // namespace OHOS