1 /*
2 * Copyright (c) 2022 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 "datashare_stub_impl.h"
17
18 #include "accesstoken_kit.h"
19 #include "datashare_log.h"
20 #include "ipc_skeleton.h"
21
22 namespace OHOS {
23 namespace DataShare {
24 using OHOS::Security::AccessToken::AccessTokenKit;
25
26 constexpr int DEFAULT_NUMBER = -1;
27 constexpr int PERMISSION_ERROR_NUMBER = -2;
GetOwner()28 std::shared_ptr<JsDataShareExtAbility> DataShareStubImpl::GetOwner()
29 {
30 if (extension_ == nullptr) {
31 LOG_ERROR("extension_ is nullptr.");
32 }
33 return extension_;
34 }
35
CheckCallingPermission(const std::string & permission)36 bool DataShareStubImpl::CheckCallingPermission(const std::string &permission)
37 {
38 if (!permission.empty() && AccessTokenKit::VerifyAccessToken(IPCSkeleton::GetCallingTokenID(), permission)
39 != AppExecFwk::Constants::PERMISSION_GRANTED) {
40 LOG_ERROR("permission not granted.");
41 return false;
42 }
43 return true;
44 }
45
GetFileTypes(const Uri & uri,const std::string & mimeTypeFilter)46 std::vector<std::string> DataShareStubImpl::GetFileTypes(const Uri &uri, const std::string &mimeTypeFilter)
47 {
48 std::vector<std::string> ret;
49 std::function<void()> syncTaskFunc = [=, &ret, client = sptr<DataShareStubImpl>(this)]() {
50 auto extension = client->GetOwner();
51 if (extension == nullptr) {
52 return;
53 }
54 ret = extension->GetFileTypes(uri, mimeTypeFilter);
55 };
56 std::function<bool()> getRetFunc = [=, &ret, client = sptr<DataShareStubImpl>(this)]() -> bool {
57 auto extension = client->GetOwner();
58 if (extension == nullptr) {
59 return false;
60 }
61 extension->GetResult(ret);
62 return (ret.size() != 0);
63 };
64 uvQueue_->SyncCall(syncTaskFunc, getRetFunc);
65 return ret;
66 }
67
OpenFile(const Uri & uri,const std::string & mode)68 int DataShareStubImpl::OpenFile(const Uri &uri, const std::string &mode)
69 {
70 int ret = -1;
71 std::function<void()> syncTaskFunc = [=, &ret, client = sptr<DataShareStubImpl>(this)]() {
72 auto extension = client->GetOwner();
73 if (extension == nullptr) {
74 return;
75 }
76 ret = extension->OpenFile(uri, mode);
77 };
78 std::function<bool()> getRetFunc = [=, &ret, client = sptr<DataShareStubImpl>(this)]() -> bool {
79 auto extension = client->GetOwner();
80 if (extension == nullptr) {
81 return false;
82 }
83 extension->GetResult(ret);
84 return (ret != DEFAULT_NUMBER);
85 };
86 uvQueue_->SyncCall(syncTaskFunc, getRetFunc);
87 return ret;
88 }
89
OpenRawFile(const Uri & uri,const std::string & mode)90 int DataShareStubImpl::OpenRawFile(const Uri &uri, const std::string &mode)
91 {
92 int ret = -1;
93 std::function<void()> syncTaskFunc = [=, &ret, client = sptr<DataShareStubImpl>(this)]() {
94 auto extension = client->GetOwner();
95 if (extension == nullptr) {
96 return;
97 }
98 ret = extension->OpenRawFile(uri, mode);
99 };
100 uvQueue_->SyncCall(syncTaskFunc);
101 return ret;
102 }
103
Insert(const Uri & uri,const DataShareValuesBucket & value)104 int DataShareStubImpl::Insert(const Uri &uri, const DataShareValuesBucket &value)
105 {
106 CallingInfo info;
107 GetCallingInfo(info);
108
109 auto client = sptr<DataShareStubImpl>(this);
110 auto extension = client->GetOwner();
111 if (extension == nullptr) {
112 return DEFAULT_NUMBER;
113 }
114
115 if (!CheckCallingPermission(extension->abilityInfo_->writePermission)) {
116 LOG_ERROR("Check calling permission failed.");
117 return PERMISSION_ERROR_NUMBER;
118 }
119
120 int ret = 0;
121 std::function<void()> syncTaskFunc = [=, &ret, &extension]() {
122 extension->SetCallingInfo(info);
123 ret = extension->Insert(uri, value);
124 };
125 std::function<bool()> getRetFunc = [=, &ret, client = sptr<DataShareStubImpl>(this)]() -> bool {
126 auto extension = client->GetOwner();
127 if (extension == nullptr) {
128 return false;
129 }
130 extension->GetResult(ret);
131 return (extension->GetRecvReply() != false);
132 };
133 std::lock_guard<std::mutex> lock(mutex_);
134 uvQueue_->SyncCall(syncTaskFunc, getRetFunc);
135 return ret;
136 }
137
Update(const Uri & uri,const DataSharePredicates & predicates,const DataShareValuesBucket & value)138 int DataShareStubImpl::Update(const Uri &uri, const DataSharePredicates &predicates,
139 const DataShareValuesBucket &value)
140 {
141 CallingInfo info;
142 GetCallingInfo(info);
143
144 auto client = sptr<DataShareStubImpl>(this);
145 auto extension = client->GetOwner();
146 if (extension == nullptr) {
147 return DEFAULT_NUMBER;
148 }
149
150 if (!CheckCallingPermission(extension->abilityInfo_->writePermission)) {
151 LOG_ERROR("Check calling permission failed.");
152 return PERMISSION_ERROR_NUMBER;
153 }
154
155 int ret = 0;
156 std::function<void()> syncTaskFunc = [=, &ret, &extension]() {
157 extension->SetCallingInfo(info);
158 ret = extension->Update(uri, predicates, value);
159 };
160 std::function<bool()> getRetFunc = [=, &ret, client = sptr<DataShareStubImpl>(this)]() -> bool {
161 auto extension = client->GetOwner();
162 if (extension == nullptr) {
163 return false;
164 }
165 extension->GetResult(ret);
166 return (extension->GetRecvReply() != false);
167 };
168 std::lock_guard<std::mutex> lock(mutex_);
169 uvQueue_->SyncCall(syncTaskFunc, getRetFunc);
170 return ret;
171 }
172
Delete(const Uri & uri,const DataSharePredicates & predicates)173 int DataShareStubImpl::Delete(const Uri &uri, const DataSharePredicates &predicates)
174 {
175 CallingInfo info;
176 GetCallingInfo(info);
177
178 auto client = sptr<DataShareStubImpl>(this);
179 auto extension = client->GetOwner();
180 if (extension == nullptr) {
181 return DEFAULT_NUMBER;
182 }
183
184 if (!CheckCallingPermission(extension->abilityInfo_->writePermission)) {
185 LOG_ERROR("Check calling permission failed.");
186 return PERMISSION_ERROR_NUMBER;
187 }
188
189 int ret = 0;
190 std::function<void()> syncTaskFunc = [=, &ret, &extension]() {
191 extension->SetCallingInfo(info);
192 ret = extension->Delete(uri, predicates);
193 };
194 std::function<bool()> getRetFunc = [=, &ret, client = sptr<DataShareStubImpl>(this)]() -> bool {
195 auto extension = client->GetOwner();
196 if (extension == nullptr) {
197 return false;
198 }
199 extension->GetResult(ret);
200 return (extension->GetRecvReply() != false);
201 };
202 std::lock_guard<std::mutex> lock(mutex_);
203 uvQueue_->SyncCall(syncTaskFunc, getRetFunc);
204 return ret;
205 }
206
Query(const Uri & uri,const DataSharePredicates & predicates,std::vector<std::string> & columns,DatashareBusinessError & businessError)207 std::shared_ptr<DataShareResultSet> DataShareStubImpl::Query(const Uri &uri,
208 const DataSharePredicates &predicates, std::vector<std::string> &columns, DatashareBusinessError &businessError)
209 {
210 CallingInfo info;
211 GetCallingInfo(info);
212 std::shared_ptr<DataShareResultSet> resultSet = nullptr;
213 auto client = sptr<DataShareStubImpl>(this);
214 auto extension = client->GetOwner();
215 if (extension == nullptr) {
216 return resultSet;
217 }
218
219 if (!CheckCallingPermission(extension->abilityInfo_->readPermission)) {
220 LOG_ERROR("Check calling permission failed.");
221 return resultSet;
222 }
223
224 std::function<void()> syncTaskFunc = [=, &columns, &resultSet, &businessError, &extension]() {
225 resultSet = extension->Query(uri, predicates, columns, businessError);
226 };
227 std::function<bool()> getRetFunc = [=, &resultSet, &businessError,
228 client = sptr<DataShareStubImpl>(this)]() -> bool {
229 auto extension = client->GetOwner();
230 if (extension == nullptr) {
231 return false;
232 }
233 extension->SetCallingInfo(info);
234 extension->GetResultSet(resultSet);
235 extension->GetBusinessError(businessError);
236 return (extension->GetRecvReply() != false);
237 };
238 std::lock_guard<std::mutex> lock(mutex_);
239 uvQueue_->SyncCall(syncTaskFunc, getRetFunc);
240 return resultSet;
241 }
242
GetType(const Uri & uri)243 std::string DataShareStubImpl::GetType(const Uri &uri)
244 {
245 std::string ret = "";
246 std::function<void()> syncTaskFunc = [=, &ret, client = sptr<DataShareStubImpl>(this)]() {
247 auto extension = client->GetOwner();
248 if (extension == nullptr) {
249 return;
250 }
251 ret = extension->GetType(uri);
252 };
253 std::function<bool()> getRetFunc = [=, &ret, client = sptr<DataShareStubImpl>(this)]() -> bool {
254 auto extension = client->GetOwner();
255 if (extension == nullptr) {
256 return false;
257 }
258 extension->GetResult(ret);
259 return (ret != "");
260 };
261 uvQueue_->SyncCall(syncTaskFunc, getRetFunc);
262 return ret;
263 }
264
BatchInsert(const Uri & uri,const std::vector<DataShareValuesBucket> & values)265 int DataShareStubImpl::BatchInsert(const Uri &uri, const std::vector<DataShareValuesBucket> &values)
266 {
267 auto client = sptr<DataShareStubImpl>(this);
268 auto extension = client->GetOwner();
269 if (extension == nullptr) {
270 return DEFAULT_NUMBER;
271 }
272
273 if (!CheckCallingPermission(extension->abilityInfo_->writePermission)) {
274 LOG_ERROR("Check calling permission failed.");
275 return PERMISSION_ERROR_NUMBER;
276 }
277
278 int ret = 0;
279 std::function<void()> syncTaskFunc = [=, &ret, &extension]() {
280 auto extension = client->GetOwner();
281 if (extension == nullptr) {
282 return;
283 }
284 ret = extension->BatchInsert(uri, values);
285 };
286 std::function<bool()> getRetFunc = [=, &ret, client = sptr<DataShareStubImpl>(this)]() -> bool {
287 auto extension = client->GetOwner();
288 if (extension == nullptr) {
289 return false;
290 }
291 extension->GetResult(ret);
292 return (extension->GetRecvReply() != false);
293 };
294 std::lock_guard<std::mutex> lock(mutex_);
295 uvQueue_->SyncCall(syncTaskFunc, getRetFunc);
296 return ret;
297 }
298
RegisterObserver(const Uri & uri,const sptr<AAFwk::IDataAbilityObserver> & dataObserver)299 bool DataShareStubImpl::RegisterObserver(const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver)
300 {
301 auto extension = GetOwner();
302 if (extension == nullptr) {
303 return false;
304 }
305 return extension->RegisterObserver(uri, dataObserver);
306 }
307
UnregisterObserver(const Uri & uri,const sptr<AAFwk::IDataAbilityObserver> & dataObserver)308 bool DataShareStubImpl::UnregisterObserver(const Uri &uri, const sptr<AAFwk::IDataAbilityObserver> &dataObserver)
309 {
310 auto extension = GetOwner();
311 if (extension == nullptr) {
312 return false;
313 }
314 return extension->UnregisterObserver(uri, dataObserver);
315 }
316
NotifyChange(const Uri & uri)317 bool DataShareStubImpl::NotifyChange(const Uri &uri)
318 {
319 bool ret = false;
320 std::function<void()> syncTaskFunc = [=, &ret, client = sptr<DataShareStubImpl>(this)]() {
321 auto extension = client->GetOwner();
322 if (extension == nullptr) {
323 return;
324 }
325 ret = extension->NotifyChange(uri);
326 };
327 uvQueue_->SyncCall(syncTaskFunc);
328 return ret;
329 }
330
NormalizeUri(const Uri & uri)331 Uri DataShareStubImpl::NormalizeUri(const Uri &uri)
332 {
333 Uri urivalue("");
334 std::function<void()> syncTaskFunc = [=, &urivalue, client = sptr<DataShareStubImpl>(this)]() {
335 auto extension = client->GetOwner();
336 if (extension == nullptr) {
337 return;
338 }
339 urivalue = extension->NormalizeUri(uri);
340 };
341 std::function<bool()> getRetFunc = [=, &urivalue, client = sptr<DataShareStubImpl>(this)]() -> bool {
342 auto extension = client->GetOwner();
343 if (extension == nullptr) {
344 return false;
345 }
346 std::string ret;
347 extension->GetResult(ret);
348 Uri tmp(ret);
349 urivalue = tmp;
350 return (urivalue.ToString() != "");
351 };
352 uvQueue_->SyncCall(syncTaskFunc, getRetFunc);
353 return urivalue;
354 }
355
DenormalizeUri(const Uri & uri)356 Uri DataShareStubImpl::DenormalizeUri(const Uri &uri)
357 {
358 Uri urivalue("");
359 std::function<void()> syncTaskFunc = [=, &urivalue, client = sptr<DataShareStubImpl>(this)]() {
360 auto extension = client->GetOwner();
361 if (extension == nullptr) {
362 return;
363 }
364 urivalue = extension->DenormalizeUri(uri);
365 };
366 std::function<bool()> getRetFunc = [=, &urivalue, client = sptr<DataShareStubImpl>(this)]() -> bool {
367 auto extension = client->GetOwner();
368 if (extension == nullptr) {
369 return false;
370 }
371 std::string ret;
372 extension->GetResult(ret);
373 Uri tmp(ret);
374 urivalue = tmp;
375 return (urivalue.ToString() != "");
376 };
377 uvQueue_->SyncCall(syncTaskFunc, getRetFunc);
378 return urivalue;
379 }
380
GetCallingInfo(CallingInfo & callingInfo)381 void DataShareStubImpl::GetCallingInfo(CallingInfo& callingInfo)
382 {
383 callingInfo.callingTokenId = GetCallingTokenID();
384 callingInfo.callingPid = GetCallingPid();
385 callingInfo.callingUid = GetCallingUid();
386 }
387 } // namespace DataShare
388 } // namespace OHOS