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 #define LOG_TAG "KVDBServiceClient"
16 #include "kvdb_service_client.h"
17 #include <cinttypes>
18 #include "distributeddata_kvdb_ipc_interface_code.h"
19 #include "itypes_util.h"
20 #include "kvstore_observer_client.h"
21 #include "kvstore_service_death_notifier.h"
22 #include "log_print.h"
23 #include "security_manager.h"
24 #include "single_store_impl.h"
25 #include "store_factory.h"
26 #include "store_util.h"
27 namespace OHOS::DistributedKv {
28 #define IPC_SEND(code, reply, ...) \
29 ({ \
30 int32_t __status = SUCCESS; \
31 do { \
32 MessageParcel request; \
33 if (!request.WriteInterfaceToken(GetDescriptor())) { \
34 __status = IPC_PARCEL_ERROR; \
35 break; \
36 } \
37 if (!ITypesUtil::Marshal(request, ##__VA_ARGS__)) { \
38 __status = IPC_PARCEL_ERROR; \
39 break; \
40 } \
41 MessageOption option; \
42 auto result = remote_->SendRequest((code), request, reply, option); \
43 if (result != 0) { \
44 __status = IPC_ERROR; \
45 break; \
46 } \
47 \
48 ITypesUtil::Unmarshal(reply, __status); \
49 } while (0); \
50 __status; \
51 })
52
53 std::mutex KVDBServiceClient::mutex_;
54 std::shared_ptr<KVDBServiceClient> KVDBServiceClient::instance_;
55 std::atomic_bool KVDBServiceClient::isWatched_(false);
56
GetInstance()57 std::shared_ptr<KVDBServiceClient> KVDBServiceClient::GetInstance()
58 {
59 if (!isWatched_.exchange(true)) {
60 KvStoreServiceDeathNotifier::AddServiceDeathWatcher(std::make_shared<ServiceDeath>());
61 }
62
63 std::lock_guard<decltype(mutex_)> lockGuard(mutex_);
64 if (instance_ != nullptr) {
65 return instance_;
66 }
67
68 sptr<IKvStoreDataService> ability = KvStoreServiceDeathNotifier::GetDistributedKvDataService();
69 if (ability == nullptr) {
70 return nullptr;
71 }
72
73 sptr<IRemoteObject> service = ability->GetFeatureInterface("kv_store");
74 if (service == nullptr) {
75 return nullptr;
76 }
77
78 sptr<KVDBServiceClient> client = nullptr;
79 if (service->IsProxyObject()) {
80 client = iface_cast<KVDBServiceClient>(service);
81 }
82
83 if (client == nullptr) {
84 client = new (std::nothrow) KVDBServiceClient(service);
85 }
86
87 if (client == nullptr) {
88 return nullptr;
89 }
90
91 instance_.reset(client.GetRefPtr(), [client](auto *) mutable { client = nullptr; });
92 return instance_;
93 }
94
OnRemoteDied()95 void KVDBServiceClient::ServiceDeath::OnRemoteDied()
96 {
97 std::lock_guard<decltype(mutex_)> lockGuard(mutex_);
98 instance_ = nullptr;
99 }
100
KVDBServiceClient(const sptr<IRemoteObject> & handle)101 KVDBServiceClient::KVDBServiceClient(const sptr<IRemoteObject> &handle) : IRemoteProxy(handle)
102 {
103 remote_ = Remote();
104 }
105
GetStoreIds(const AppId & appId,std::vector<StoreId> & storeIds)106 Status KVDBServiceClient::GetStoreIds(const AppId &appId, std::vector<StoreId> &storeIds)
107 {
108 MessageParcel reply;
109 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_GET_STORE_IDS),
110 reply, appId, StoreId(), storeIds);
111 if (status != SUCCESS) {
112 ZLOGE("status:0x%{public}x, appId:%{public}s", status, appId.appId.c_str());
113 }
114 ITypesUtil::Unmarshal(reply, storeIds);
115 return static_cast<Status>(status);
116 }
117
BeforeCreate(const AppId & appId,const StoreId & storeId,const Options & options)118 Status KVDBServiceClient::BeforeCreate(const AppId &appId, const StoreId &storeId, const Options &options)
119 {
120 MessageParcel reply;
121 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_BEFORE_CREATE),
122 reply, appId, storeId, options);
123 if (status != SUCCESS) {
124 ZLOGE("status:0x%{public}x appId:%{public}s, storeId:%{public}s", status, appId.appId.c_str(),
125 StoreUtil::Anonymous(storeId.storeId).c_str());
126 }
127 return static_cast<Status>(status);
128 }
129
AfterCreate(const AppId & appId,const StoreId & storeId,const Options & options,const std::vector<uint8_t> & password)130 Status KVDBServiceClient::AfterCreate(
131 const AppId &appId, const StoreId &storeId, const Options &options, const std::vector<uint8_t> &password)
132 {
133 MessageParcel reply;
134 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_AFTER_CREATE),
135 reply, appId, storeId, options, password);
136 if (status != SUCCESS) {
137 ZLOGE("status:0x%{public}x appId:%{public}s, storeId:%{public}s, encrypt:%{public}d", status,
138 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str(), options.encrypt);
139 }
140 return static_cast<Status>(status);
141 }
142
Delete(const AppId & appId,const StoreId & storeId)143 Status KVDBServiceClient::Delete(const AppId &appId, const StoreId &storeId)
144 {
145 MessageParcel reply;
146 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_DELETE),
147 reply, appId, storeId);
148 if (status != SUCCESS) {
149 ZLOGE("status:0x%{public}x appId:%{public}s, storeId:%{public}s", status, appId.appId.c_str(),
150 StoreUtil::Anonymous(storeId.storeId).c_str());
151 }
152 return static_cast<Status>(status);
153 }
154
Close(const AppId & appId,const StoreId & storeId)155 Status KVDBServiceClient::Close(const AppId &appId, const StoreId &storeId)
156 {
157 MessageParcel reply;
158 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_CLOSE),
159 reply, appId, storeId);
160 if (status != SUCCESS) {
161 ZLOGE("status:0x%{public}x appId:%{public}s, storeId:%{public}s", status, appId.appId.c_str(),
162 StoreUtil::Anonymous(storeId.storeId).c_str());
163 }
164 return static_cast<Status>(status);
165 }
166
Sync(const AppId & appId,const StoreId & storeId,SyncInfo & syncInfo)167 Status KVDBServiceClient::Sync(const AppId &appId, const StoreId &storeId, SyncInfo &syncInfo)
168 {
169 MessageParcel reply;
170 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_SYNC), reply, appId, storeId,
171 syncInfo.seqId, syncInfo.mode, syncInfo.devices, syncInfo.delay, syncInfo.query);
172 if (status != SUCCESS) {
173 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s, sequenceId:%{public}" PRIu64, status,
174 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str(), syncInfo.seqId);
175 }
176 return static_cast<Status>(status);
177 }
178
CloudSync(const AppId & appId,const StoreId & storeId,const SyncInfo & syncInfo)179 Status KVDBServiceClient::CloudSync(const AppId &appId, const StoreId &storeId, const SyncInfo &syncInfo)
180 {
181 MessageParcel reply;
182 int32_t status = IPC_SEND(
183 static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_CLOUD_SYNC), reply, appId, storeId, syncInfo.seqId);
184 if (status != SUCCESS) {
185 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s" PRIu64, status, appId.appId.c_str(),
186 StoreUtil::Anonymous(storeId.storeId).c_str());
187 }
188 return static_cast<Status>(status);
189 }
190
NotifyDataChange(const AppId & appId,const StoreId & storeId,uint64_t delay)191 Status KVDBServiceClient::NotifyDataChange(const AppId &appId, const StoreId &storeId, uint64_t delay)
192 {
193 MessageParcel reply;
194 int32_t status = IPC_SEND(
195 static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_NOTIFY_DATA_CHANGE), reply, appId, storeId, delay);
196 if (status != SUCCESS) {
197 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s",
198 status, appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str());
199 }
200 return static_cast<Status>(status);
201 }
202
RegServiceNotifier(const AppId & appId,sptr<IKVDBNotifier> notifier)203 Status KVDBServiceClient::RegServiceNotifier(const AppId &appId, sptr<IKVDBNotifier> notifier)
204 {
205 MessageParcel reply;
206 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_REGISTER_NOTIFIER), reply,
207 appId, StoreId(), notifier->AsObject().GetRefPtr());
208 if (status != SUCCESS) {
209 ZLOGE("status:0x%{public}x, appId:%{public}s, notifier:0x%{public}x", status, appId.appId.c_str(),
210 StoreUtil::Anonymous(notifier.GetRefPtr()));
211 }
212 return static_cast<Status>(status);
213 }
214
UnregServiceNotifier(const AppId & appId)215 Status KVDBServiceClient::UnregServiceNotifier(const AppId &appId)
216 {
217 MessageParcel reply;
218 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_UNREGISTER_NOTIFIER),
219 reply, appId, StoreId());
220 if (status != SUCCESS) {
221 ZLOGE("status:0x%{public}x, appId:%{public}s", status, appId.appId.c_str());
222 }
223 return static_cast<Status>(status);
224 }
225
SetSyncParam(const AppId & appId,const StoreId & storeId,const KvSyncParam & syncParam)226 Status KVDBServiceClient::SetSyncParam(const AppId &appId, const StoreId &storeId, const KvSyncParam &syncParam)
227 {
228 MessageParcel reply;
229 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_SET_SYNC_PARAM), reply,
230 appId, storeId, syncParam.allowedDelayMs);
231 if (status != SUCCESS) {
232 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s", status, appId.appId.c_str(),
233 StoreUtil::Anonymous(storeId.storeId).c_str());
234 }
235 return static_cast<Status>(status);
236 }
237
GetSyncParam(const AppId & appId,const StoreId & storeId,KvSyncParam & syncParam)238 Status KVDBServiceClient::GetSyncParam(const AppId &appId, const StoreId &storeId, KvSyncParam &syncParam)
239 {
240 MessageParcel reply;
241 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_GET_SYNC_PARAM),
242 reply, appId, storeId);
243 if (status != SUCCESS) {
244 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s", status, appId.appId.c_str(),
245 StoreUtil::Anonymous(storeId.storeId).c_str());
246 return SUCCESS;
247 }
248 ITypesUtil::Unmarshal(reply, syncParam.allowedDelayMs);
249 return static_cast<Status>(status);
250 }
251
EnableCapability(const AppId & appId,const StoreId & storeId)252 Status KVDBServiceClient::EnableCapability(const AppId &appId, const StoreId &storeId)
253 {
254 MessageParcel reply;
255 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_ENABLE_CAP),
256 reply, appId, storeId);
257 if (status != SUCCESS) {
258 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s", status, appId.appId.c_str(),
259 StoreUtil::Anonymous(storeId.storeId).c_str());
260 }
261 return static_cast<Status>(status);
262 }
263
DisableCapability(const AppId & appId,const StoreId & storeId)264 Status KVDBServiceClient::DisableCapability(const AppId &appId, const StoreId &storeId)
265 {
266 MessageParcel reply;
267 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_DISABLE_CAP),
268 reply, appId, storeId);
269 if (status != SUCCESS) {
270 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s", status, appId.appId.c_str(),
271 StoreUtil::Anonymous(storeId.storeId).c_str());
272 }
273 return static_cast<Status>(status);
274 }
275
SetCapability(const AppId & appId,const StoreId & storeId,const std::vector<std::string> & local,const std::vector<std::string> & remote)276 Status KVDBServiceClient::SetCapability(const AppId &appId, const StoreId &storeId,
277 const std::vector<std::string> &local, const std::vector<std::string> &remote)
278 {
279 MessageParcel reply;
280 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_SET_CAP),
281 reply, appId, storeId, local, remote);
282 if (status != SUCCESS) {
283 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s", status, appId.appId.c_str(),
284 StoreUtil::Anonymous(storeId.storeId).c_str());
285 }
286 return static_cast<Status>(status);
287 }
288
AddSubscribeInfo(const AppId & appId,const StoreId & storeId,const SyncInfo & syncInfo)289 Status KVDBServiceClient::AddSubscribeInfo(const AppId &appId, const StoreId &storeId, const SyncInfo &syncInfo)
290 {
291 MessageParcel reply;
292 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_ADD_SUB),
293 reply, appId, storeId, syncInfo.seqId, syncInfo.devices, syncInfo.query);
294 if (status != SUCCESS) {
295 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s, query:%{public}s", status,
296 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str(),
297 StoreUtil::Anonymous(syncInfo.query).c_str());
298 }
299 return static_cast<Status>(status);
300 }
301
RmvSubscribeInfo(const AppId & appId,const StoreId & storeId,const SyncInfo & syncInfo)302 Status KVDBServiceClient::RmvSubscribeInfo(const AppId &appId, const StoreId &storeId, const SyncInfo &syncInfo)
303 {
304 MessageParcel reply;
305 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_RMV_SUB),
306 reply, appId, storeId, syncInfo.seqId, syncInfo.devices, syncInfo.query);
307 if (status != SUCCESS) {
308 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s, query:%{public}s", status,
309 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str(),
310 StoreUtil::Anonymous(syncInfo.query).c_str());
311 }
312 return static_cast<Status>(status);
313 }
314
Subscribe(const AppId & appId,const StoreId & storeId,sptr<IKvStoreObserver> observer)315 Status KVDBServiceClient::Subscribe(const AppId &appId, const StoreId &storeId, sptr<IKvStoreObserver> observer)
316 {
317 MessageParcel reply;
318 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_SUB),
319 reply, appId, storeId, observer->AsObject());
320 if (status != SUCCESS) {
321 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s, observer:0x%{public}x", status,
322 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str(),
323 StoreUtil::Anonymous(observer.GetRefPtr()));
324 }
325 return static_cast<Status>(status);
326 }
327
Unsubscribe(const AppId & appId,const StoreId & storeId,sptr<IKvStoreObserver> observer)328 Status KVDBServiceClient::Unsubscribe(const AppId &appId, const StoreId &storeId, sptr<IKvStoreObserver> observer)
329 {
330 MessageParcel reply;
331 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_UNSUB),
332 reply, appId, storeId, observer->AsObject().GetRefPtr());
333 if (status != SUCCESS) {
334 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s, observer:0x%{public}x", status,
335 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str(),
336 StoreUtil::Anonymous(observer.GetRefPtr()));
337 }
338 return static_cast<Status>(status);
339 }
340
GetBackupPassword(const AppId & appId,const StoreId & storeId,std::vector<uint8_t> & password,int32_t passwordType)341 Status KVDBServiceClient::GetBackupPassword(
342 const AppId &appId, const StoreId &storeId, std::vector<uint8_t> &password, int32_t passwordType)
343 {
344 MessageParcel reply;
345 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_GET_PASSWORD),
346 reply, appId, storeId, passwordType);
347 if (status != SUCCESS) {
348 ZLOGE("status:0x%{public}x appId:%{public}s, storeId:%{public}s", status,
349 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str());
350 }
351 ITypesUtil::Unmarshal(reply, password);
352 return static_cast<Status>(status);
353 }
354
GetServiceAgent(const AppId & appId)355 sptr<KVDBNotifierClient> KVDBServiceClient::GetServiceAgent(const AppId &appId)
356 {
357 std::lock_guard<decltype(agentMtx_)> lockGuard(agentMtx_);
358 if (serviceAgent_ != nullptr) {
359 return serviceAgent_;
360 }
361
362 sptr<KVDBNotifierClient> serviceAgent = new (std::nothrow) KVDBNotifierClient();
363 auto status = RegServiceNotifier(appId, serviceAgent);
364 if (status == SUCCESS) {
365 serviceAgent_ = std::move(serviceAgent);
366 }
367 return serviceAgent_;
368 }
369
PutSwitch(const AppId & appId,const SwitchData & data)370 Status KVDBServiceClient::PutSwitch(const AppId &appId, const SwitchData &data)
371 {
372 MessageParcel reply;
373 int32_t status = IPC_SEND(
374 static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_PUT_SWITCH), reply, appId, StoreId(), data);
375 if (status != SUCCESS) {
376 ZLOGE("status:0x%{public}x, appId:%{public}s", status, appId.appId.c_str());
377 }
378 return static_cast<Status>(status);
379 }
380
GetSwitch(const AppId & appId,const std::string & networkId,SwitchData & data)381 Status KVDBServiceClient::GetSwitch(const AppId &appId, const std::string &networkId, SwitchData &data)
382 {
383 MessageParcel reply;
384 int32_t status = IPC_SEND(
385 static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_GET_SWITCH), reply, appId, StoreId(), networkId);
386 if (status != SUCCESS) {
387 ZLOGE("status:0x%{public}x, appId:%{public}s, networkId:%{public}s",
388 status, appId.appId.c_str(), StoreUtil::Anonymous(networkId).c_str());
389 }
390 ITypesUtil::Unmarshal(reply, data);
391 return static_cast<Status>(status);
392 }
393
SubscribeSwitchData(const AppId & appId)394 Status KVDBServiceClient::SubscribeSwitchData(const AppId &appId)
395 {
396 MessageParcel reply;
397 int32_t status = IPC_SEND(
398 static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_SUBSCRIBE_SWITCH_DATA), reply, appId, StoreId());
399 if (status != SUCCESS) {
400 ZLOGE("status:0x%{public}x, appId:%{public}s", status, appId.appId.c_str());
401 }
402 return static_cast<Status>(status);
403 }
404
UnsubscribeSwitchData(const AppId & appId)405 Status KVDBServiceClient::UnsubscribeSwitchData(const AppId &appId)
406 {
407 MessageParcel reply;
408 int32_t status = IPC_SEND(
409 static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_UNSUBSCRIBE_SWITCH_DATA), reply, appId, StoreId());
410 if (status != SUCCESS) {
411 ZLOGE("status:0x%{public}x, appId:%{public}s", status, appId.appId.c_str());
412 }
413 return static_cast<Status>(status);
414 }
415
SetConfig(const AppId & appId,const StoreId & storeId,const StoreConfig & storeConfig)416 Status KVDBServiceClient::SetConfig(const AppId &appId, const StoreId &storeId, const StoreConfig &storeConfig)
417 {
418 MessageParcel reply;
419 int32_t status = IPC_SEND(
420 static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_SET_CONFIG), reply, appId, storeId, storeConfig);
421 if (status != SUCCESS) {
422 ZLOGE("status:0x%{public}x appId:%{public}s, storeId:%{public}s", status,
423 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str());
424 }
425 return static_cast<Status>(status);
426 }
427
RemoveDeviceData(const AppId & appId,const StoreId & storeId,const std::string & device)428 Status KVDBServiceClient::RemoveDeviceData(const AppId &appId, const StoreId &storeId, const std::string &device)
429 {
430 MessageParcel reply;
431 int32_t status = IPC_SEND(
432 static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_REMOVE_DEVICE_DATA), reply, appId, storeId, device);
433 if (status != SUCCESS) {
434 ZLOGE("status:0x%{public}x appId:%{public}s, storeId:%{public}s", status,
435 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str());
436 }
437 return static_cast<Status>(status);
438 }
439 } // namespace OHOS::DistributedKv