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.h"
17
18 #include "data_ability_observer_interface.h"
19 #include "datashare_log.h"
20 #include "ipc_types.h"
21 #include "ishared_result_set.h"
22 #include "itypes_utils.h"
23 #include "unistd.h"
24
25 namespace OHOS {
26 namespace DataShare {
27 constexpr int DEFAULT_NUMBER = -1;
28 constexpr int PERMISSION_ERROR_NUMBER = -2;
DataShareStub()29 DataShareStub::DataShareStub()
30 {
31 stubFuncMap_[CMD_GET_FILE_TYPES] = &DataShareStub::CmdGetFileTypes;
32 stubFuncMap_[CMD_OPEN_FILE] = &DataShareStub::CmdOpenFile;
33 stubFuncMap_[CMD_OPEN_RAW_FILE] = &DataShareStub::CmdOpenRawFile;
34 stubFuncMap_[CMD_INSERT] = &DataShareStub::CmdInsert;
35 stubFuncMap_[CMD_UPDATE] = &DataShareStub::CmdUpdate;
36 stubFuncMap_[CMD_DELETE] = &DataShareStub::CmdDelete;
37 stubFuncMap_[CMD_QUERY] = &DataShareStub::CmdQuery;
38 stubFuncMap_[CMD_GET_TYPE] = &DataShareStub::CmdGetType;
39 stubFuncMap_[CMD_BATCH_INSERT] = &DataShareStub::CmdBatchInsert;
40 stubFuncMap_[CMD_REGISTER_OBSERVER] = &DataShareStub::CmdRegisterObserver;
41 stubFuncMap_[CMD_UNREGISTER_OBSERVER] = &DataShareStub::CmdUnregisterObserver;
42 stubFuncMap_[CMD_NOTIFY_CHANGE] = &DataShareStub::CmdNotifyChange;
43 stubFuncMap_[CMD_NORMALIZE_URI] = &DataShareStub::CmdNormalizeUri;
44 stubFuncMap_[CMD_DENORMALIZE_URI] = &DataShareStub::CmdDenormalizeUri;
45 }
46
~DataShareStub()47 DataShareStub::~DataShareStub()
48 {
49 stubFuncMap_.clear();
50 }
51
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)52 int DataShareStub::OnRemoteRequest(uint32_t code, MessageParcel& data, MessageParcel& reply,
53 MessageOption& option)
54 {
55 std::u16string descriptor = DataShareStub::GetDescriptor();
56 std::u16string remoteDescriptor = data.ReadInterfaceToken();
57 if (descriptor != remoteDescriptor) {
58 LOG_INFO("local descriptor is not equal to remote");
59 return ERR_INVALID_STATE;
60 }
61
62 const auto &itFunc = stubFuncMap_.find(code);
63 if (itFunc != stubFuncMap_.end()) {
64 return (this->*(itFunc->second))(data, reply);
65 }
66
67 LOG_INFO("remote request unhandled: %{public}d", code);
68 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
69 }
70
ReadUri(std::shared_ptr<Uri> & uri,MessageParcel & data)71 bool ReadUri(std::shared_ptr<Uri> &uri, MessageParcel &data)
72 {
73 uri = std::shared_ptr<Uri>(data.ReadParcelable<Uri>());
74 if (uri == nullptr) {
75 LOG_ERROR("uri is nullptr");
76 return false;
77 }
78 return true;
79 }
80
CmdGetFileTypes(MessageParcel & data,MessageParcel & reply)81 ErrCode DataShareStub::CmdGetFileTypes(MessageParcel &data, MessageParcel &reply)
82 {
83 std::shared_ptr<Uri> uri = nullptr;
84 if (!ReadUri(uri, data)) {
85 return ERR_INVALID_VALUE;
86 }
87 std::string mimeTypeFilter = data.ReadString();
88 if (mimeTypeFilter.empty()) {
89 LOG_ERROR("mimeTypeFilter is nullptr");
90 return ERR_INVALID_VALUE;
91 }
92 std::vector<std::string> types = GetFileTypes(*uri, mimeTypeFilter);
93 if (!reply.WriteStringVector(types)) {
94 LOG_ERROR("fail to WriteStringVector types");
95 return ERR_INVALID_VALUE;
96 }
97 return DATA_SHARE_NO_ERROR;
98 }
99
CmdOpenFile(MessageParcel & data,MessageParcel & reply)100 ErrCode DataShareStub::CmdOpenFile(MessageParcel &data, MessageParcel &reply)
101 {
102 std::shared_ptr<Uri> uri = nullptr;
103 if (!ReadUri(uri, data)) {
104 return ERR_INVALID_VALUE;
105 }
106 std::string mode = data.ReadString();
107 if (mode.empty()) {
108 LOG_ERROR("mode is nullptr");
109 return ERR_INVALID_VALUE;
110 }
111 int fd = OpenFile(*uri, mode);
112 if (fd < 0) {
113 LOG_ERROR("OpenFile fail, fd is %{pubilc}d", fd);
114 return ERR_INVALID_VALUE;
115 }
116 if (!reply.WriteFileDescriptor(fd)) {
117 LOG_ERROR("fail to WriteFileDescriptor fd");
118 close(fd);
119 return ERR_INVALID_VALUE;
120 }
121 close(fd);
122 return DATA_SHARE_NO_ERROR;
123 }
124
CmdOpenRawFile(MessageParcel & data,MessageParcel & reply)125 ErrCode DataShareStub::CmdOpenRawFile(MessageParcel &data, MessageParcel &reply)
126 {
127 std::shared_ptr<Uri> uri = nullptr;
128 if (!ReadUri(uri, data)) {
129 return ERR_INVALID_VALUE;
130 }
131 std::string mode = data.ReadString();
132 if (mode.empty()) {
133 LOG_ERROR("mode is nullptr");
134 return ERR_INVALID_VALUE;
135 }
136 int fd = OpenRawFile(*uri, mode);
137 if (!reply.WriteInt32(fd)) {
138 LOG_ERROR("fail to WriteInt32 fd");
139 return ERR_INVALID_VALUE;
140 }
141 return DATA_SHARE_NO_ERROR;
142 }
143
CmdInsert(MessageParcel & data,MessageParcel & reply)144 ErrCode DataShareStub::CmdInsert(MessageParcel &data, MessageParcel &reply)
145 {
146 std::shared_ptr<Uri> uri(data.ReadParcelable<Uri>());
147 if (uri == nullptr) {
148 LOG_ERROR("DataShareStub uri is nullptr");
149 return ERR_INVALID_VALUE;
150 }
151 DataShareValuesBucket value;
152 if (!ITypesUtils::Unmarshalling(data, value)) {
153 LOG_ERROR("Unmarshalling value is nullptr");
154 return ERR_INVALID_VALUE;
155 }
156 int index = Insert(*uri, value);
157 if (index == DEFAULT_NUMBER) {
158 LOG_ERROR("Insert inner error");
159 return ERR_INVALID_VALUE;
160 } else if (index == PERMISSION_ERROR_NUMBER) {
161 LOG_ERROR("Insert permission error");
162 return ERR_PERMISSION_DENIED;
163 }
164 if (!reply.WriteInt32(index)) {
165 LOG_ERROR("fail to WriteInt32 index");
166 return ERR_INVALID_VALUE;
167 }
168 LOG_INFO("DataShareStub::CmdInsertInner end");
169 return DATA_SHARE_NO_ERROR;
170 }
171
CmdUpdate(MessageParcel & data,MessageParcel & reply)172 ErrCode DataShareStub::CmdUpdate(MessageParcel &data, MessageParcel &reply)
173 {
174 std::shared_ptr<Uri> uri = nullptr;
175 if (!ReadUri(uri, data)) {
176 return ERR_INVALID_VALUE;
177 }
178 DataSharePredicates predicates;
179 if (!ITypesUtils::Unmarshalling(data, predicates)) {
180 LOG_ERROR("Unmarshalling predicates is nullptr");
181 return ERR_INVALID_VALUE;
182 }
183 DataShareValuesBucket value;
184 if (!ITypesUtils::Unmarshalling(data, value)) {
185 LOG_ERROR("Unmarshalling value is nullptr");
186 return ERR_INVALID_VALUE;
187 }
188 int index = Update(*uri, predicates, value);
189 if (index == DEFAULT_NUMBER) {
190 LOG_ERROR("Update inner error");
191 return ERR_INVALID_VALUE;
192 } else if (index == PERMISSION_ERROR_NUMBER) {
193 LOG_ERROR("Update permission error");
194 return ERR_PERMISSION_DENIED;
195 }
196 if (!reply.WriteInt32(index)) {
197 LOG_ERROR("fail to WriteInt32 index");
198 return ERR_INVALID_VALUE;
199 }
200 return DATA_SHARE_NO_ERROR;
201 }
202
CmdDelete(MessageParcel & data,MessageParcel & reply)203 ErrCode DataShareStub::CmdDelete(MessageParcel &data, MessageParcel &reply)
204 {
205 std::shared_ptr<Uri> uri = nullptr;
206 if (!ReadUri(uri, data)) {
207 return ERR_INVALID_VALUE;
208 }
209 DataSharePredicates predicates;
210 if (!ITypesUtils::Unmarshalling(data, predicates)) {
211 LOG_ERROR("Unmarshalling predicates is nullptr");
212 return ERR_INVALID_VALUE;
213 }
214 int index = Delete(*uri, predicates);
215 if (index == DEFAULT_NUMBER) {
216 LOG_ERROR("Delete inner error");
217 return ERR_INVALID_VALUE;
218 } else if (index == PERMISSION_ERROR_NUMBER) {
219 LOG_ERROR("Delete permission error");
220 return ERR_PERMISSION_DENIED;
221 }
222 if (!reply.WriteInt32(index)) {
223 LOG_ERROR("fail to WriteInt32 index");
224 return ERR_INVALID_VALUE;
225 }
226 return DATA_SHARE_NO_ERROR;
227 }
228
CmdQuery(MessageParcel & data,MessageParcel & reply)229 ErrCode DataShareStub::CmdQuery(MessageParcel &data, MessageParcel &reply)
230 {
231 std::shared_ptr<Uri> uri = nullptr;
232 if (!ReadUri(uri, data)) {
233 return ERR_INVALID_VALUE;
234 }
235 DataSharePredicates predicates;
236 if (!ITypesUtils::Unmarshalling(data, predicates)) {
237 LOG_ERROR("Unmarshalling predicates is nullptr");
238 return ERR_INVALID_VALUE;
239 }
240 std::vector<std::string> columns;
241 if (!data.ReadStringVector(&columns)) {
242 LOG_ERROR("fail to ReadStringVector columns");
243 return ERR_INVALID_VALUE;
244 }
245 auto resultSet = Query(*uri, predicates, columns);
246 if (resultSet == nullptr) {
247 LOG_ERROR("fail to WriteParcelable resultSet");
248 return ERR_INVALID_VALUE;
249 }
250 auto result = ISharedResultSet::WriteToParcel(std::move(resultSet), reply);
251 if (result == nullptr) {
252 LOG_ERROR("!resultSet->Marshalling(reply)");
253 return ERR_INVALID_VALUE;
254 }
255 return DATA_SHARE_NO_ERROR;
256 }
257
CmdGetType(MessageParcel & data,MessageParcel & reply)258 ErrCode DataShareStub::CmdGetType(MessageParcel &data, MessageParcel &reply)
259 {
260 std::shared_ptr<Uri> uri = nullptr;
261 if (!ReadUri(uri, data)) {
262 return ERR_INVALID_VALUE;
263 }
264 std::string type = GetType(*uri);
265 if (!reply.WriteString(type)) {
266 LOG_ERROR("fail to WriteString type");
267 return ERR_INVALID_VALUE;
268 }
269 return DATA_SHARE_NO_ERROR;
270 }
271
CmdBatchInsert(MessageParcel & data,MessageParcel & reply)272 ErrCode DataShareStub::CmdBatchInsert(MessageParcel &data, MessageParcel &reply)
273 {
274 std::shared_ptr<Uri> uri = nullptr;
275 if (!ReadUri(uri, data)) {
276 return ERR_INVALID_VALUE;
277 }
278
279 int count = 0;
280 if (!data.ReadInt32(count)) {
281 LOG_ERROR("fail to ReadInt32 index");
282 return ERR_INVALID_VALUE;
283 }
284
285 std::vector<DataShareValuesBucket> values;
286 for (int i = 0; i < count; i++) {
287 DataShareValuesBucket value;
288 if (!ITypesUtils::Unmarshalling(data, value)) {
289 LOG_ERROR("Unmarshalling value is nullptr");
290 return ERR_INVALID_VALUE;
291 }
292 values.emplace_back(value);
293 }
294
295 int ret = BatchInsert(*uri, values);
296 if (ret == DEFAULT_NUMBER) {
297 LOG_ERROR("BatchInsert inner error");
298 return ERR_INVALID_VALUE;
299 } else if (ret == PERMISSION_ERROR_NUMBER) {
300 LOG_ERROR("BatchInsert permission error");
301 return ERR_PERMISSION_DENIED;
302 }
303 if (!reply.WriteInt32(ret)) {
304 LOG_ERROR("fail to WriteInt32 ret");
305 return ERR_INVALID_VALUE;
306 }
307 return DATA_SHARE_NO_ERROR;
308 }
309
310
CmdRegisterObserver(MessageParcel & data,MessageParcel & reply)311 ErrCode DataShareStub::CmdRegisterObserver(MessageParcel &data, MessageParcel &reply)
312 {
313 std::shared_ptr<Uri> uri = nullptr;
314 if (!ReadUri(uri, data)) {
315 return ERR_INVALID_VALUE;
316 }
317 auto obServer = iface_cast<AAFwk::IDataAbilityObserver>(data.ReadRemoteObject());
318 if (obServer == nullptr) {
319 LOG_ERROR("obServer is nullptr");
320 return ERR_INVALID_VALUE;
321 }
322
323 bool ret = RegisterObserver(*uri, obServer);
324 if (!reply.WriteInt32(ret)) {
325 LOG_ERROR("fail to WriteInt32 ret");
326 return ERR_INVALID_VALUE;
327 }
328 return DATA_SHARE_NO_ERROR;
329 }
330
CmdUnregisterObserver(MessageParcel & data,MessageParcel & reply)331 ErrCode DataShareStub::CmdUnregisterObserver(MessageParcel &data, MessageParcel &reply)
332 {
333 std::shared_ptr<Uri> uri = nullptr;
334 if (!ReadUri(uri, data)) {
335 return ERR_INVALID_VALUE;
336 }
337 auto obServer = iface_cast<AAFwk::IDataAbilityObserver>(data.ReadRemoteObject());
338 if (obServer == nullptr) {
339 LOG_ERROR("obServer is nullptr");
340 return ERR_INVALID_VALUE;
341 }
342
343 bool ret = UnregisterObserver(*uri, obServer);
344 if (!reply.WriteInt32(ret)) {
345 LOG_ERROR("fail to WriteInt32 ret");
346 return ERR_INVALID_VALUE;
347 }
348 return DATA_SHARE_NO_ERROR;
349 }
350
CmdNotifyChange(MessageParcel & data,MessageParcel & reply)351 ErrCode DataShareStub::CmdNotifyChange(MessageParcel &data, MessageParcel &reply)
352 {
353 std::shared_ptr<Uri> uri = nullptr;
354 if (!ReadUri(uri, data)) {
355 return ERR_INVALID_VALUE;
356 }
357
358 bool ret = NotifyChange(*uri);
359 if (!reply.WriteInt32(ret)) {
360 LOG_ERROR("fail to WriteInt32 ret");
361 return ERR_INVALID_VALUE;
362 }
363 return DATA_SHARE_NO_ERROR;
364 }
365
CmdNormalizeUri(MessageParcel & data,MessageParcel & reply)366 ErrCode DataShareStub::CmdNormalizeUri(MessageParcel &data, MessageParcel &reply)
367 {
368 std::shared_ptr<Uri> uri = nullptr;
369 if (!ReadUri(uri, data)) {
370 return ERR_INVALID_VALUE;
371 }
372
373 Uri ret("");
374 ret = NormalizeUri(*uri);
375 if (!reply.WriteParcelable(&ret)) {
376 LOG_ERROR("fail to WriteParcelable type");
377 return ERR_INVALID_VALUE;
378 }
379 return DATA_SHARE_NO_ERROR;
380 }
381
CmdDenormalizeUri(MessageParcel & data,MessageParcel & reply)382 ErrCode DataShareStub::CmdDenormalizeUri(MessageParcel &data, MessageParcel &reply)
383 {
384 std::shared_ptr<Uri> uri = nullptr;
385 if (!ReadUri(uri, data)) {
386 return ERR_INVALID_VALUE;
387 }
388
389 Uri ret("");
390 ret = DenormalizeUri(*uri);
391 if (!reply.WriteParcelable(&ret)) {
392 LOG_ERROR("fail to WriteParcelable type");
393 return ERR_INVALID_VALUE;
394 }
395 return DATA_SHARE_NO_ERROR;
396 }
397 } // namespace DataShare
398 } // namespace OHOS