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
Sync(const AppId & appId,const StoreId & storeId,const SyncInfo & syncInfo)155 Status KVDBServiceClient::Sync(const AppId &appId, const StoreId &storeId, const SyncInfo &syncInfo)
156 {
157 MessageParcel reply;
158 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_SYNC), reply, appId, storeId,
159 syncInfo.seqId, syncInfo.mode, syncInfo.devices, syncInfo.delay, syncInfo.query);
160 if (status != SUCCESS) {
161 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s, sequenceId:%{public}" PRIu64, status,
162 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str(), syncInfo.seqId);
163 }
164 return static_cast<Status>(status);
165 }
166
RegisterSyncCallback(const AppId & appId,sptr<IKvStoreSyncCallback> callback)167 Status KVDBServiceClient::RegisterSyncCallback(const AppId &appId, sptr<IKvStoreSyncCallback> callback)
168 {
169 MessageParcel reply;
170 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_REGISTER_CALLBACK), reply,
171 appId, StoreId(), callback->AsObject().GetRefPtr());
172 if (status != SUCCESS) {
173 ZLOGE("status:0x%{public}x, appId:%{public}s, callback:0x%{public}x", status, appId.appId.c_str(),
174 StoreUtil::Anonymous(callback.GetRefPtr()));
175 }
176 return static_cast<Status>(status);
177 }
178
UnregisterSyncCallback(const AppId & appId)179 Status KVDBServiceClient::UnregisterSyncCallback(const AppId &appId)
180 {
181 MessageParcel reply;
182 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_UNREGISTER_CALLBACK),
183 reply, appId, StoreId());
184 if (status != SUCCESS) {
185 ZLOGE("status:0x%{public}x, appId:%{public}s", status, appId.appId.c_str());
186 }
187 return static_cast<Status>(status);
188 }
189
SetSyncParam(const AppId & appId,const StoreId & storeId,const KvSyncParam & syncParam)190 Status KVDBServiceClient::SetSyncParam(const AppId &appId, const StoreId &storeId, const KvSyncParam &syncParam)
191 {
192 MessageParcel reply;
193 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_SET_SYNC_PARAM), reply,
194 appId, storeId, syncParam.allowedDelayMs);
195 if (status != SUCCESS) {
196 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s", status, appId.appId.c_str(),
197 StoreUtil::Anonymous(storeId.storeId).c_str());
198 }
199 return static_cast<Status>(status);
200 }
201
GetSyncParam(const AppId & appId,const StoreId & storeId,KvSyncParam & syncParam)202 Status KVDBServiceClient::GetSyncParam(const AppId &appId, const StoreId &storeId, KvSyncParam &syncParam)
203 {
204 MessageParcel reply;
205 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_GET_SYNC_PARAM),
206 reply, appId, storeId);
207 if (status != SUCCESS) {
208 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s", status, appId.appId.c_str(),
209 StoreUtil::Anonymous(storeId.storeId).c_str());
210 return SUCCESS;
211 }
212 ITypesUtil::Unmarshal(reply, syncParam.allowedDelayMs);
213 return static_cast<Status>(status);
214 }
215
EnableCapability(const AppId & appId,const StoreId & storeId)216 Status KVDBServiceClient::EnableCapability(const AppId &appId, const StoreId &storeId)
217 {
218 MessageParcel reply;
219 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_ENABLE_CAP),
220 reply, appId, storeId);
221 if (status != SUCCESS) {
222 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s", status, appId.appId.c_str(),
223 StoreUtil::Anonymous(storeId.storeId).c_str());
224 }
225 return static_cast<Status>(status);
226 }
227
DisableCapability(const AppId & appId,const StoreId & storeId)228 Status KVDBServiceClient::DisableCapability(const AppId &appId, const StoreId &storeId)
229 {
230 MessageParcel reply;
231 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_DISABLE_CAP),
232 reply, appId, storeId);
233 if (status != SUCCESS) {
234 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s", status, appId.appId.c_str(),
235 StoreUtil::Anonymous(storeId.storeId).c_str());
236 }
237 return static_cast<Status>(status);
238 }
239
SetCapability(const AppId & appId,const StoreId & storeId,const std::vector<std::string> & local,const std::vector<std::string> & remote)240 Status KVDBServiceClient::SetCapability(const AppId &appId, const StoreId &storeId,
241 const std::vector<std::string> &local, const std::vector<std::string> &remote)
242 {
243 MessageParcel reply;
244 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_SET_CAP),
245 reply, appId, storeId, local, remote);
246 if (status != SUCCESS) {
247 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s", status, appId.appId.c_str(),
248 StoreUtil::Anonymous(storeId.storeId).c_str());
249 }
250 return static_cast<Status>(status);
251 }
252
AddSubscribeInfo(const AppId & appId,const StoreId & storeId,const SyncInfo & syncInfo)253 Status KVDBServiceClient::AddSubscribeInfo(const AppId &appId, const StoreId &storeId, const SyncInfo &syncInfo)
254 {
255 MessageParcel reply;
256 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_ADD_SUB),
257 reply, appId, storeId, syncInfo.seqId, syncInfo.devices, syncInfo.query);
258 if (status != SUCCESS) {
259 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s, query:%{public}s", status,
260 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str(),
261 StoreUtil::Anonymous(syncInfo.query).c_str());
262 }
263 return static_cast<Status>(status);
264 }
265
RmvSubscribeInfo(const AppId & appId,const StoreId & storeId,const SyncInfo & syncInfo)266 Status KVDBServiceClient::RmvSubscribeInfo(const AppId &appId, const StoreId &storeId, const SyncInfo &syncInfo)
267 {
268 MessageParcel reply;
269 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_RMV_SUB),
270 reply, appId, storeId, syncInfo.seqId, syncInfo.devices, syncInfo.query);
271 if (status != SUCCESS) {
272 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s, query:%{public}s", status,
273 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str(),
274 StoreUtil::Anonymous(syncInfo.query).c_str());
275 }
276 return static_cast<Status>(status);
277 }
278
Subscribe(const AppId & appId,const StoreId & storeId,sptr<IKvStoreObserver> observer)279 Status KVDBServiceClient::Subscribe(const AppId &appId, const StoreId &storeId, sptr<IKvStoreObserver> observer)
280 {
281 MessageParcel reply;
282 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_SUB),
283 reply, appId, storeId, observer->AsObject());
284 if (status != SUCCESS) {
285 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s, observer:0x%{public}x", status,
286 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str(),
287 StoreUtil::Anonymous(observer.GetRefPtr()));
288 }
289 return static_cast<Status>(status);
290 }
291
Unsubscribe(const AppId & appId,const StoreId & storeId,sptr<IKvStoreObserver> observer)292 Status KVDBServiceClient::Unsubscribe(const AppId &appId, const StoreId &storeId, sptr<IKvStoreObserver> observer)
293 {
294 MessageParcel reply;
295 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_UNSUB),
296 reply, appId, storeId, observer->AsObject().GetRefPtr());
297 if (status != SUCCESS) {
298 ZLOGE("status:0x%{public}x, appId:%{public}s, storeId:%{public}s, observer:0x%{public}x", status,
299 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str(),
300 StoreUtil::Anonymous(observer.GetRefPtr()));
301 }
302 return static_cast<Status>(status);
303 }
304
GetBackupPassword(const AppId & appId,const StoreId & storeId,std::vector<uint8_t> & password)305 Status KVDBServiceClient::GetBackupPassword(
306 const AppId &appId, const StoreId &storeId, std::vector<uint8_t> &password)
307 {
308 MessageParcel reply;
309 int32_t status = IPC_SEND(static_cast<uint32_t>(KVDBServiceInterfaceCode::TRANS_GET_PASSWORD),
310 reply, appId, storeId);
311 if (status != SUCCESS) {
312 ZLOGE("status:0x%{public}x appId:%{public}s, storeId:%{public}s", status,
313 appId.appId.c_str(), StoreUtil::Anonymous(storeId.storeId).c_str());
314 }
315 ITypesUtil::Unmarshal(reply, password);
316 return static_cast<Status>(status);
317 }
318
GetSyncAgent(const AppId & appId)319 sptr<KvStoreSyncCallbackClient> KVDBServiceClient::GetSyncAgent(const AppId &appId)
320 {
321 std::lock_guard<decltype(agentMtx_)> lockGuard(agentMtx_);
322 if (syncAgent_ != nullptr) {
323 return syncAgent_;
324 }
325
326 sptr<KvStoreSyncCallbackClient> syncAgent = new (std::nothrow) KvStoreSyncCallbackClient();
327 auto status = RegisterSyncCallback(appId, syncAgent);
328 if (status == SUCCESS) {
329 syncAgent_ = std::move(syncAgent);
330 }
331 return syncAgent_;
332 }
333 } // namespace OHOS::DistributedKv