1 /*
2  * Copyright (c) 2021 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 "ability_sync.h"
17 
18 #include "message_transform.h"
19 #include "version.h"
20 #include "db_errno.h"
21 #include "log_print.h"
22 #include "sync_types.h"
23 #include "db_common.h"
24 #include "single_ver_kvdb_sync_interface.h"
25 #include "single_ver_sync_task_context.h"
26 #include "single_ver_kv_sync_task_context.h"
27 #ifdef RELATIONAL_STORE
28 #include "relational_db_sync_interface.h"
29 #include "single_ver_relational_sync_task_context.h"
30 #endif
31 
32 namespace DistributedDB {
AbilitySyncRequestPacket()33 AbilitySyncRequestPacket::AbilitySyncRequestPacket()
34     : protocolVersion_(ABILITY_SYNC_VERSION_V1),
35       sendCode_(E_OK),
36       softwareVersion_(SOFTWARE_VERSION_CURRENT),
37       secLabel_(0),
38       secFlag_(0),
39       schemaType_(0),
40       dbCreateTime_(0),
41       schemaVersion_(0)
42 {
43 }
44 
~AbilitySyncRequestPacket()45 AbilitySyncRequestPacket::~AbilitySyncRequestPacket()
46 {
47 }
48 
SetProtocolVersion(uint32_t protocolVersion)49 void AbilitySyncRequestPacket::SetProtocolVersion(uint32_t protocolVersion)
50 {
51     protocolVersion_ = protocolVersion;
52 }
53 
GetProtocolVersion() const54 uint32_t AbilitySyncRequestPacket::GetProtocolVersion() const
55 {
56     return protocolVersion_;
57 }
58 
SetSendCode(int32_t sendCode)59 void AbilitySyncRequestPacket::SetSendCode(int32_t sendCode)
60 {
61     sendCode_ = sendCode;
62 }
63 
GetSendCode() const64 int32_t AbilitySyncRequestPacket::GetSendCode() const
65 {
66     return sendCode_;
67 }
68 
SetSoftwareVersion(uint32_t swVersion)69 void AbilitySyncRequestPacket::SetSoftwareVersion(uint32_t swVersion)
70 {
71     softwareVersion_ = swVersion;
72 }
73 
GetSoftwareVersion() const74 uint32_t AbilitySyncRequestPacket::GetSoftwareVersion() const
75 {
76     return softwareVersion_;
77 }
78 
SetSchema(const std::string & schema)79 void AbilitySyncRequestPacket::SetSchema(const std::string &schema)
80 {
81     schema_ = schema;
82 }
83 
GetSchema() const84 std::string AbilitySyncRequestPacket::GetSchema() const
85 {
86     return schema_;
87 }
88 
SetSchemaType(uint32_t schemaType)89 void AbilitySyncRequestPacket::SetSchemaType(uint32_t schemaType)
90 {
91     schemaType_ = schemaType;
92 }
93 
GetSchemaType() const94 uint32_t AbilitySyncRequestPacket::GetSchemaType() const
95 {
96     return schemaType_;
97 }
98 
SetSecLabel(int32_t secLabel)99 void AbilitySyncRequestPacket::SetSecLabel(int32_t secLabel)
100 {
101     secLabel_ = secLabel;
102 }
103 
GetSecLabel() const104 int32_t AbilitySyncRequestPacket::GetSecLabel() const
105 {
106     return secLabel_;
107 }
108 
SetSecFlag(int32_t secFlag)109 void AbilitySyncRequestPacket::SetSecFlag(int32_t secFlag)
110 {
111     secFlag_ = secFlag;
112 }
113 
GetSecFlag() const114 int32_t AbilitySyncRequestPacket::GetSecFlag() const
115 {
116     return secFlag_;
117 }
118 
SetDbCreateTime(uint64_t dbCreateTime)119 void AbilitySyncRequestPacket::SetDbCreateTime(uint64_t dbCreateTime)
120 {
121     dbCreateTime_ = dbCreateTime;
122 }
123 
GetDbCreateTime() const124 uint64_t AbilitySyncRequestPacket::GetDbCreateTime() const
125 {
126     return dbCreateTime_;
127 }
128 
CalculateLen() const129 uint32_t AbilitySyncRequestPacket::CalculateLen() const
130 {
131     uint64_t len = 0;
132     len += Parcel::GetUInt32Len(); // protocolVersion_
133     len += Parcel::GetIntLen(); // sendCode_
134     len += Parcel::GetUInt32Len(); // softwareVersion_
135     uint32_t schemaLen = Parcel::GetStringLen(schema_);
136     if (schemaLen == 0) {
137         LOGE("[AbilitySyncRequestPacket][CalculateLen] schemaLen err!");
138         return 0;
139     }
140     len += schemaLen;
141     len += Parcel::GetIntLen(); // secLabel_
142     len += Parcel::GetIntLen(); // secFlag_
143     len += Parcel::GetUInt32Len(); // schemaType_
144     len += Parcel::GetUInt64Len(); // dbCreateTime_
145     len += DbAbility::CalculateLen(dbAbility_); // dbAbility_
146     len += Parcel::GetUInt64Len(); // schema version add in 109
147     // the reason why not 8-byte align is that old version is not 8-byte align
148     // so it is not possible to set 8-byte align for high version.
149     if (len > INT32_MAX) {
150         LOGE("[AbilitySyncRequestPacket][CalculateLen] err len:%" PRIu64, len);
151         return 0;
152     }
153     return len;
154 }
155 
GetDbAbility() const156 DbAbility AbilitySyncRequestPacket::GetDbAbility() const
157 {
158     return dbAbility_;
159 }
160 
SetDbAbility(const DbAbility & dbAbility)161 void AbilitySyncRequestPacket::SetDbAbility(const DbAbility &dbAbility)
162 {
163     dbAbility_ = dbAbility;
164 }
165 
SetSchemaVersion(uint64_t schemaVersion)166 void AbilitySyncRequestPacket::SetSchemaVersion(uint64_t schemaVersion)
167 {
168     schemaVersion_ = schemaVersion;
169 }
170 
GetSchemaVersion() const171 uint64_t AbilitySyncRequestPacket::GetSchemaVersion() const
172 {
173     return schemaVersion_;
174 }
175 
AbilitySyncAckPacket()176 AbilitySyncAckPacket::AbilitySyncAckPacket()
177     : protocolVersion_(ABILITY_SYNC_VERSION_V1),
178       softwareVersion_(SOFTWARE_VERSION_CURRENT),
179       ackCode_(E_OK),
180       secLabel_(0),
181       secFlag_(0),
182       schemaType_(0),
183       permitSync_(0),
184       requirePeerConvert_(0),
185       dbCreateTime_(0),
186       schemaVersion_(0)
187 {
188 }
189 
~AbilitySyncAckPacket()190 AbilitySyncAckPacket::~AbilitySyncAckPacket()
191 {
192 }
193 
SetProtocolVersion(uint32_t protocolVersion)194 void AbilitySyncAckPacket::SetProtocolVersion(uint32_t protocolVersion)
195 {
196     protocolVersion_ = protocolVersion;
197 }
198 
SetSoftwareVersion(uint32_t swVersion)199 void AbilitySyncAckPacket::SetSoftwareVersion(uint32_t swVersion)
200 {
201     softwareVersion_ = swVersion;
202 }
203 
GetSoftwareVersion() const204 uint32_t AbilitySyncAckPacket::GetSoftwareVersion() const
205 {
206     return softwareVersion_;
207 }
208 
GetProtocolVersion() const209 uint32_t AbilitySyncAckPacket::GetProtocolVersion() const
210 {
211     return protocolVersion_;
212 }
213 
SetAckCode(int32_t ackCode)214 void AbilitySyncAckPacket::SetAckCode(int32_t ackCode)
215 {
216     ackCode_ = ackCode;
217 }
218 
GetAckCode() const219 int32_t AbilitySyncAckPacket::GetAckCode() const
220 {
221     return ackCode_;
222 }
223 
SetSchema(const std::string & schema)224 void AbilitySyncAckPacket::SetSchema(const std::string &schema)
225 {
226     schema_ = schema;
227 }
228 
GetSchema() const229 std::string AbilitySyncAckPacket::GetSchema() const
230 {
231     return schema_;
232 }
233 
SetSchemaType(uint32_t schemaType)234 void AbilitySyncAckPacket::SetSchemaType(uint32_t schemaType)
235 {
236     schemaType_ = schemaType;
237 }
238 
GetSchemaType() const239 uint32_t AbilitySyncAckPacket::GetSchemaType() const
240 {
241     return schemaType_;
242 }
243 
SetSecLabel(int32_t secLabel)244 void AbilitySyncAckPacket::SetSecLabel(int32_t secLabel)
245 {
246     secLabel_ = secLabel;
247 }
248 
GetSecLabel() const249 int32_t AbilitySyncAckPacket::GetSecLabel() const
250 {
251     return secLabel_;
252 }
253 
SetSecFlag(int32_t secFlag)254 void AbilitySyncAckPacket::SetSecFlag(int32_t secFlag)
255 {
256     secFlag_ = secFlag;
257 }
258 
GetSecFlag() const259 int32_t AbilitySyncAckPacket::GetSecFlag() const
260 {
261     return secFlag_;
262 }
263 
SetPermitSync(uint32_t permitSync)264 void AbilitySyncAckPacket::SetPermitSync(uint32_t permitSync)
265 {
266     permitSync_ = permitSync;
267 }
268 
GetPermitSync() const269 uint32_t AbilitySyncAckPacket::GetPermitSync() const
270 {
271     return permitSync_;
272 }
273 
SetRequirePeerConvert(uint32_t requirePeerConvert)274 void AbilitySyncAckPacket::SetRequirePeerConvert(uint32_t requirePeerConvert)
275 {
276     requirePeerConvert_ = requirePeerConvert;
277 }
278 
GetRequirePeerConvert() const279 uint32_t AbilitySyncAckPacket::GetRequirePeerConvert() const
280 {
281     return requirePeerConvert_;
282 }
283 
SetDbCreateTime(uint64_t dbCreateTime)284 void AbilitySyncAckPacket::SetDbCreateTime(uint64_t dbCreateTime)
285 {
286     dbCreateTime_ = dbCreateTime;
287 }
288 
GetDbCreateTime() const289 uint64_t AbilitySyncAckPacket::GetDbCreateTime() const
290 {
291     return dbCreateTime_;
292 }
293 
GetSchemaVersion() const294 uint64_t AbilitySyncAckPacket::GetSchemaVersion() const
295 {
296     return schemaVersion_;
297 }
298 
SetSchemaVersion(uint64_t schemaVersion)299 void AbilitySyncAckPacket::SetSchemaVersion(uint64_t schemaVersion)
300 {
301     schemaVersion_ = schemaVersion;
302 }
303 
CalculateLen() const304 uint32_t AbilitySyncAckPacket::CalculateLen() const
305 {
306     uint64_t len = 0;
307     len += Parcel::GetUInt32Len();
308     len += Parcel::GetUInt32Len();
309     len += Parcel::GetIntLen();
310     uint32_t schemaLen = Parcel::GetStringLen(schema_);
311     if (schemaLen == 0) {
312         LOGE("[AbilitySyncAckPacket][CalculateLen] schemaLen err!");
313         return 0;
314     }
315     len += schemaLen;
316     len += Parcel::GetIntLen(); // secLabel_
317     len += Parcel::GetIntLen(); // secFlag_
318     len += Parcel::GetUInt32Len(); // schemaType_
319     len += Parcel::GetUInt32Len(); // permitSync_
320     len += Parcel::GetUInt32Len(); // requirePeerConvert_
321     len += Parcel::GetUInt64Len(); // dbCreateTime_
322     len += DbAbility::CalculateLen(dbAbility_); // dbAbility_
323     len += SchemaNegotiate::CalculateParcelLen(relationalSyncOpinion_);
324     len += Parcel::GetUInt64Len(); // schemaVersion_
325     if (len > INT32_MAX) {
326         LOGE("[AbilitySyncAckPacket][CalculateLen] err len:%" PRIu64, len);
327         return 0;
328     }
329     return len;
330 }
331 
GetDbAbility() const332 DbAbility AbilitySyncAckPacket::GetDbAbility() const
333 {
334     return dbAbility_;
335 }
336 
SetDbAbility(const DbAbility & dbAbility)337 void AbilitySyncAckPacket::SetDbAbility(const DbAbility &dbAbility)
338 {
339     dbAbility_ = dbAbility;
340 }
341 
SetRelationalSyncOpinion(const RelationalSyncOpinion & relationalSyncOpinion)342 void AbilitySyncAckPacket::SetRelationalSyncOpinion(const RelationalSyncOpinion &relationalSyncOpinion)
343 {
344     relationalSyncOpinion_ = relationalSyncOpinion;
345 }
346 
GetRelationalSyncOpinion() const347 RelationalSyncOpinion AbilitySyncAckPacket::GetRelationalSyncOpinion() const
348 {
349     return relationalSyncOpinion_;
350 }
351 
AbilitySync()352 AbilitySync::AbilitySync()
353     : communicator_(nullptr),
354       storageInterface_(nullptr),
355       metadata_(nullptr),
356       syncFinished_(false)
357 {
358 }
359 
~AbilitySync()360 AbilitySync::~AbilitySync()
361 {
362     communicator_ = nullptr;
363     storageInterface_ = nullptr;
364     metadata_ = nullptr;
365 }
366 
Initialize(ICommunicator * inCommunicator,ISyncInterface * inStorage,const std::shared_ptr<Metadata> & inMetadata,const std::string & deviceId)367 int AbilitySync::Initialize(ICommunicator *inCommunicator, ISyncInterface *inStorage,
368     const std::shared_ptr<Metadata> &inMetadata, const std::string &deviceId)
369 {
370     if (inCommunicator == nullptr || inStorage == nullptr || deviceId.empty() || inMetadata == nullptr) {
371         return -E_INVALID_ARGS;
372     }
373     communicator_ = inCommunicator;
374     storageInterface_ = inStorage;
375     metadata_ = inMetadata;
376     deviceId_ = deviceId;
377     return E_OK;
378 }
379 
SyncStart(uint32_t sessionId,uint32_t sequenceId,uint16_t remoteCommunicatorVersion,const CommErrHandler & handler,const ISyncTaskContext * context)380 int AbilitySync::SyncStart(uint32_t sessionId, uint32_t sequenceId, uint16_t remoteCommunicatorVersion,
381     const CommErrHandler &handler, const ISyncTaskContext *context)
382 {
383     AbilitySyncRequestPacket packet;
384     int errCode = SetAbilityRequestBodyInfo(remoteCommunicatorVersion, context, packet);
385     if (errCode != E_OK) {
386         return errCode;
387     }
388     Message *message = new (std::nothrow) Message(ABILITY_SYNC_MESSAGE);
389     if (message == nullptr) {
390         return -E_OUT_OF_MEMORY;
391     }
392     message->SetMessageType(TYPE_REQUEST);
393     errCode = message->SetCopiedObject<>(packet);
394     if (errCode != E_OK) {
395         LOGE("[AbilitySync][SyncStart] SetCopiedObject failed, err %d", errCode);
396         delete message;
397         message = nullptr;
398         return errCode;
399     }
400     message->SetVersion(MSG_VERSION_EXT);
401     message->SetSessionId(sessionId);
402     message->SetSequenceId(sequenceId);
403     SendConfig conf;
404     SetSendConfigParam(storageInterface_->GetDbProperties(), deviceId_, false, SEND_TIME_OUT, conf);
405     errCode = communicator_->SendMessage(deviceId_, message, conf, handler);
406     if (errCode != E_OK) {
407         LOGE("[AbilitySync][SyncStart] SendPacket failed, err %d", errCode);
408         delete message;
409         message = nullptr;
410     }
411     return errCode;
412 }
413 
AckRecv(const Message * message,ISyncTaskContext * context)414 int AbilitySync::AckRecv(const Message *message, ISyncTaskContext *context)
415 {
416     int errCode = AckMsgCheck(message, context);
417     if (errCode != E_OK) {
418         return errCode;
419     }
420     const AbilitySyncAckPacket *packet = message->GetObject<AbilitySyncAckPacket>();
421     if (packet == nullptr) {
422         return -E_INVALID_ARGS;
423     }
424     uint32_t remoteSoftwareVersion = packet->GetSoftwareVersion();
425     context->SetRemoteSoftwareVersion(remoteSoftwareVersion);
426     if (remoteSoftwareVersion > SOFTWARE_VERSION_RELEASE_2_0) {
427         errCode = AckRecvWithHighVersion(message, context, packet);
428     } else {
429         std::string schema = packet->GetSchema();
430         uint8_t schemaType = packet->GetSchemaType();
431         bool isCompatible = static_cast<SyncGenericInterface *>(storageInterface_)->CheckCompatible(schema, schemaType);
432         if (!isCompatible) { // LCOV_EXCL_BR_LINE
433             (static_cast<SingleVerSyncTaskContext *>(context))->SetTaskErrCode(-E_SCHEMA_MISMATCH);
434             LOGE("[AbilitySync][AckRecv] scheme check failed");
435             return -E_SCHEMA_MISMATCH;
436         }
437         LOGI("[AbilitySync][AckRecv]remoteSoftwareVersion = %u, isCompatible = %d,", remoteSoftwareVersion,
438             isCompatible);
439     }
440     return errCode;
441 }
442 
RequestRecv(const Message * message,ISyncTaskContext * context)443 int AbilitySync::RequestRecv(const Message *message, ISyncTaskContext *context)
444 {
445     if (message == nullptr || context == nullptr) {
446         return -E_INVALID_ARGS;
447     }
448     const AbilitySyncRequestPacket *packet = message->GetObject<AbilitySyncRequestPacket>();
449     if (packet == nullptr) {
450         return -E_INVALID_ARGS;
451     }
452     if (packet->GetSendCode() == -E_VERSION_NOT_SUPPORT) {
453         AbilitySyncAckPacket ackPacket;
454         (void)SendAck(context, message, -E_VERSION_NOT_SUPPORT, false, ackPacket);
455         LOGI("[AbilitySync][RequestRecv] version can not support, remote version is %u", packet->GetProtocolVersion());
456         return -E_VERSION_NOT_SUPPORT;
457     }
458 
459     std::string schema = packet->GetSchema();
460     uint8_t schemaType = packet->GetSchemaType();
461     bool isCompatible = static_cast<SyncGenericInterface *>(storageInterface_)->CheckCompatible(schema, schemaType);
462     if (!isCompatible) {
463         (static_cast<SingleVerSyncTaskContext *>(context))->SetTaskErrCode(-E_SCHEMA_MISMATCH);
464     }
465     uint32_t remoteSoftwareVersion = packet->GetSoftwareVersion();
466     context->SetRemoteSoftwareVersion(remoteSoftwareVersion);
467     return HandleRequestRecv(message, context, isCompatible);
468 }
469 
AckNotifyRecv(const Message * message,ISyncTaskContext * context)470 int AbilitySync::AckNotifyRecv(const Message *message, ISyncTaskContext *context)
471 {
472     if (message == nullptr || context == nullptr) {
473         return -E_INVALID_ARGS;
474     }
475     if (message->GetErrorNo() == E_FEEDBACK_UNKNOWN_MESSAGE) {
476         LOGE("[AbilitySync][AckNotifyRecv] Remote device dose not support this message id");
477         context->SetRemoteSoftwareVersion(SOFTWARE_VERSION_EARLIEST);
478         return -E_FEEDBACK_UNKNOWN_MESSAGE;
479     }
480     const AbilitySyncAckPacket *packet = message->GetObject<AbilitySyncAckPacket>();
481     if (packet == nullptr) {
482         return -E_INVALID_ARGS;
483     }
484     int errCode = packet->GetAckCode();
485     if (errCode != E_OK) {
486         LOGE("[AbilitySync][AckNotifyRecv] received an errCode %d", errCode);
487         return errCode;
488     }
489     uint32_t remoteSoftwareVersion = packet->GetSoftwareVersion();
490     context->SetRemoteSoftwareVersion(remoteSoftwareVersion);
491     AbilitySyncAckPacket sendPacket;
492     std::pair<bool, bool> schemaSyncStatus;
493     errCode = HandleVersionV3AckSchemaParam(packet, sendPacket, context, false, schemaSyncStatus);
494     errCode = errCode == -E_ABILITY_SYNC_FINISHED ? E_OK : errCode;
495     int ackCode = errCode;
496     LOGI("[AckNotifyRecv] receive dev = %s ack notify, remoteSoftwareVersion = %u, ackCode = %d",
497         STR_MASK(deviceId_), remoteSoftwareVersion, errCode);
498     if (errCode == E_OK) {
499         ackCode = AbilitySync::LAST_NOTIFY;
500     }
501     (void)SendAckWithEmptySchema(context, message, ackCode, true);
502     return errCode;
503 }
504 
GetAbilitySyncFinishedStatus() const505 bool AbilitySync::GetAbilitySyncFinishedStatus() const
506 {
507     return syncFinished_;
508 }
509 
SetAbilitySyncFinishedStatus(bool syncFinished,ISyncTaskContext & context)510 void AbilitySync::SetAbilitySyncFinishedStatus(bool syncFinished, ISyncTaskContext &context)
511 {
512     syncFinished_ = syncFinished;
513     if (context.GetRemoteSoftwareVersion() < SOFTWARE_VERSION_RELEASE_9_0) {
514         return;
515     }
516     // record finished with all schema compatible
517     if (syncFinished && !context.IsSchemaCompatible()) { // LCOV_EXCL_BR_LINE
518         return;
519     }
520     int errCode = metadata_->SetAbilitySyncFinishMark(deviceId_, syncFinished);
521     if (errCode != E_OK) {
522         LOGW("[AbilitySync] Set ability sync finish mark failed %d", errCode);
523     }
524 }
525 
SecLabelCheck(const AbilitySyncRequestPacket * packet) const526 bool AbilitySync::SecLabelCheck(const AbilitySyncRequestPacket *packet) const
527 {
528     SecurityOption option;
529     int errCode = (static_cast<SyncGenericInterface *>(storageInterface_))->GetSecurityOption(option);
530     int32_t remoteSecLabel = TransformSecLabelIfNeed(packet->GetSecLabel(), option.securityLabel);
531     LOGI("[AbilitySync][RequestRecv] remote label:%d local l:%d, f:%d, errCode:%d", remoteSecLabel,
532         option.securityLabel, option.securityFlag, errCode);
533     if (remoteSecLabel == NOT_SUPPORT_SEC_CLASSIFICATION && errCode == -E_NOT_SUPPORT) {
534         return true;
535     }
536     uint32_t remoteSoftwareVersion = packet->GetSoftwareVersion();
537     if (errCode != -E_NOT_SUPPORT && option.securityLabel == SecurityLabel::NOT_SET) {
538         LOGE("[AbilitySync][RequestRecv] local security label not set!");
539         return false;
540     }
541     if (remoteSoftwareVersion >= SOFTWARE_VERSION_RELEASE_7_0 && remoteSecLabel == SecurityLabel::NOT_SET) {
542         LOGE("[AbilitySync][RequestRecv] remote security label not set!");
543         return false;
544     }
545     if (remoteSecLabel == NOT_SUPPORT_SEC_CLASSIFICATION || remoteSecLabel == SecurityLabel::NOT_SET) {
546         return true;
547     }
548     if (errCode == -E_NOT_SUPPORT || (errCode == E_OK && option.securityLabel == SecurityLabel::NOT_SET)) {
549         return true;
550     }
551     if (remoteSecLabel == FAILED_GET_SEC_CLASSIFICATION || errCode != E_OK) {
552         LOGE("[AbilitySync][RequestRecv] check error remoteL:%d, errCode:%d", remoteSecLabel, errCode);
553         return false;
554     }
555     if (remoteSecLabel == option.securityLabel) {
556         return true;
557     }
558     LOGE("[AbilitySync][RequestRecv] check error remote:%d , %d local:%d , %d",
559          remoteSecLabel, packet->GetSecFlag(), option.securityLabel, option.securityFlag);
560     return false;
561 }
562 
HandleVersionV3RequestParam(const AbilitySyncRequestPacket * packet,ISyncTaskContext * context)563 void AbilitySync::HandleVersionV3RequestParam(const AbilitySyncRequestPacket *packet, ISyncTaskContext *context)
564 {
565     int32_t remoteSecLabel = packet->GetSecLabel();
566     int32_t remoteSecFlag = packet->GetSecFlag();
567     DbAbility remoteDbAbility = packet->GetDbAbility();
568     (static_cast<SingleVerSyncTaskContext *>(context))->SetDbAbility(remoteDbAbility);
569     (static_cast<SingleVerSyncTaskContext *>(context))->SetRemoteSeccurityOption({remoteSecLabel, remoteSecFlag});
570     (static_cast<SingleVerSyncTaskContext *>(context))->SetReceivcPermitCheck(false);
571     LOGI("[AbilitySync][HandleVersionV3RequestParam] remoteSecLabel = %d, remoteSecFlag = %d, remoteSchemaType = %u",
572         remoteSecLabel, remoteSecFlag, packet->GetSchemaType());
573 }
574 
HandleVersionV3AckSecOptionParam(const AbilitySyncAckPacket * packet,ISyncTaskContext * context)575 void AbilitySync::HandleVersionV3AckSecOptionParam(const AbilitySyncAckPacket *packet,
576     ISyncTaskContext *context)
577 {
578     int32_t remoteSecLabel = packet->GetSecLabel();
579     int32_t remoteSecFlag = packet->GetSecFlag();
580     SecurityOption secOption = {remoteSecLabel, remoteSecFlag};
581     (static_cast<SingleVerSyncTaskContext *>(context))->SetRemoteSeccurityOption(secOption);
582     (static_cast<SingleVerSyncTaskContext *>(context))->SetSendPermitCheck(false);
583     LOGI("[AbilitySync][AckRecv] remoteSecLabel = %d, remoteSecFlag = %d", remoteSecLabel, remoteSecFlag);
584 }
585 
HandleVersionV3AckSchemaParam(const AbilitySyncAckPacket * recvPacket,AbilitySyncAckPacket & sendPacket,ISyncTaskContext * context,bool sendOpinion,std::pair<bool,bool> & schemaSyncStatus)586 int AbilitySync::HandleVersionV3AckSchemaParam(const AbilitySyncAckPacket *recvPacket,
587     AbilitySyncAckPacket &sendPacket,  ISyncTaskContext *context, bool sendOpinion,
588     std::pair<bool, bool> &schemaSyncStatus)
589 {
590     if (IsSingleRelationalVer()) {
591         return HandleRelationAckSchemaParam(recvPacket, sendPacket, context, sendOpinion, schemaSyncStatus);
592     }
593     return HandleKvAckSchemaParam(recvPacket, context, sendPacket, schemaSyncStatus);
594 }
595 
GetPacketSecOption(const ISyncTaskContext * context,SecurityOption & option) const596 void AbilitySync::GetPacketSecOption(const ISyncTaskContext *context, SecurityOption &option) const
597 {
598     int errCode =
599         (static_cast<SyncGenericInterface *>(storageInterface_))->GetSecurityOption(option);
600     if (errCode == -E_NOT_SUPPORT) {
601         LOGE("[AbilitySync][SyncStart] GetSecOpt not surpport sec classification");
602         option.securityLabel = NOT_SUPPORT_SEC_CLASSIFICATION;
603     } else if (errCode != E_OK) {
604         LOGE("[AbilitySync][SyncStart] GetSecOpt errCode:%d", errCode);
605         option.securityLabel = FAILED_GET_SEC_CLASSIFICATION;
606     }
607     if (context == nullptr) {
608         return;
609     }
610     auto remoteSecOption = (static_cast<const SingleVerSyncTaskContext *>(context))->GetRemoteSeccurityOption();
611     option.securityLabel = TransformSecLabelIfNeed(option.securityLabel, remoteSecOption.securityLabel);
612 }
613 
RegisterTransformFunc()614 int AbilitySync::RegisterTransformFunc()
615 {
616     TransformFunc func;
617     func.computeFunc = [](const Message *inMsg) { return CalculateLen(inMsg); };
618     func.serializeFunc = [](uint8_t *buffer, uint32_t length, const Message *inMsg) {
619         return Serialization(buffer, length, inMsg);
620     };
621     func.deserializeFunc = [](const uint8_t *buffer, uint32_t length, Message *inMsg) {
622         return DeSerialization(buffer, length, inMsg);
623     };
624     return MessageTransform::RegTransformFunction(ABILITY_SYNC_MESSAGE, func);
625 }
626 
CalculateLen(const Message * inMsg)627 uint32_t AbilitySync::CalculateLen(const Message *inMsg)
628 {
629     if ((inMsg == nullptr) || (inMsg->GetMessageId() != ABILITY_SYNC_MESSAGE)) {
630         return 0;
631     }
632     int errCode;
633     uint32_t len = 0;
634     switch (inMsg->GetMessageType()) {
635         case TYPE_REQUEST:
636             errCode = RequestPacketCalculateLen(inMsg, len);
637             if (errCode != E_OK) {
638                 LOGE("[AbilitySync][CalculateLen] request packet calc length err %d", errCode);
639             }
640             break;
641         case TYPE_RESPONSE:
642             errCode = AckPacketCalculateLen(inMsg, len);
643             if (errCode != E_OK) {
644                 LOGE("[AbilitySync][CalculateLen] ack packet calc length err %d", errCode);
645             }
646             break;
647         case TYPE_NOTIFY:
648             errCode = AckPacketCalculateLen(inMsg, len);
649             if (errCode != E_OK) {
650                 LOGE("[AbilitySync][CalculateLen] ack packet calc length err %d", errCode);
651             }
652             break;
653         default:
654             LOGE("[AbilitySync][CalculateLen] message type not support, type %d", inMsg->GetMessageType());
655             break;
656     }
657     return len;
658 }
659 
Serialization(uint8_t * buffer,uint32_t length,const Message * inMsg)660 int AbilitySync::Serialization(uint8_t *buffer, uint32_t length, const Message *inMsg)
661 {
662     if ((buffer == nullptr) || (inMsg == nullptr)) {
663         return -E_INVALID_ARGS;
664     }
665 
666     switch (inMsg->GetMessageType()) {
667         case TYPE_REQUEST:
668             return RequestPacketSerialization(buffer, length, inMsg);
669         case TYPE_RESPONSE:
670         case TYPE_NOTIFY:
671             return AckPacketSerialization(buffer, length, inMsg);
672         default:
673             return -E_MESSAGE_TYPE_ERROR;
674     }
675 }
676 
DeSerialization(const uint8_t * buffer,uint32_t length,Message * inMsg)677 int AbilitySync::DeSerialization(const uint8_t *buffer, uint32_t length, Message *inMsg)
678 {
679     if ((buffer == nullptr) || (inMsg == nullptr)) {
680         return -E_INVALID_ARGS;
681     }
682 
683     switch (inMsg->GetMessageType()) {
684         case TYPE_REQUEST:
685             return RequestPacketDeSerialization(buffer, length, inMsg);
686         case TYPE_RESPONSE:
687         case TYPE_NOTIFY:
688             return AckPacketDeSerialization(buffer, length, inMsg);
689         default:
690             return -E_MESSAGE_TYPE_ERROR;
691     }
692 }
693 
RequestPacketCalculateLen(const Message * inMsg,uint32_t & len)694 int AbilitySync::RequestPacketCalculateLen(const Message *inMsg, uint32_t &len)
695 {
696     const AbilitySyncRequestPacket *packet = inMsg->GetObject<AbilitySyncRequestPacket>();
697     if (packet == nullptr) {
698         return -E_INVALID_ARGS;
699     }
700 
701     len = packet->CalculateLen();
702     return E_OK;
703 }
704 
AckPacketCalculateLen(const Message * inMsg,uint32_t & len)705 int AbilitySync::AckPacketCalculateLen(const Message *inMsg, uint32_t &len)
706 {
707     const AbilitySyncAckPacket *packet = inMsg->GetObject<AbilitySyncAckPacket>();
708     if (packet == nullptr) {
709         return -E_INVALID_ARGS;
710     }
711 
712     len = packet->CalculateLen();
713     return E_OK;
714 }
715 
RequestPacketSerialization(uint8_t * buffer,uint32_t length,const Message * inMsg)716 int AbilitySync::RequestPacketSerialization(uint8_t *buffer, uint32_t length, const Message *inMsg)
717 {
718     const AbilitySyncRequestPacket *packet = inMsg->GetObject<AbilitySyncRequestPacket>();
719     if ((packet == nullptr) || (length != packet->CalculateLen())) {
720         return -E_INVALID_ARGS;
721     }
722 
723     Parcel parcel(buffer, length);
724     parcel.WriteUInt32(packet->GetProtocolVersion());
725     parcel.WriteInt(packet->GetSendCode());
726     parcel.WriteUInt32(packet->GetSoftwareVersion());
727     parcel.WriteString(packet->GetSchema());
728     parcel.WriteInt(packet->GetSecLabel());
729     parcel.WriteInt(packet->GetSecFlag());
730     parcel.WriteUInt32(packet->GetSchemaType());
731     parcel.WriteUInt64(packet->GetDbCreateTime());
732     int errCode = DbAbility::Serialize(parcel, packet->GetDbAbility());
733     parcel.WriteUInt64(packet->GetSchemaVersion());
734     if (parcel.IsError() || errCode != E_OK) {
735         return -E_PARSE_FAIL;
736     }
737     return E_OK;
738 }
739 
AckPacketSerialization(uint8_t * buffer,uint32_t length,const Message * inMsg)740 int AbilitySync::AckPacketSerialization(uint8_t *buffer, uint32_t length, const Message *inMsg)
741 {
742     const AbilitySyncAckPacket *packet = inMsg->GetObject<AbilitySyncAckPacket>();
743     if ((packet == nullptr) || (length != packet->CalculateLen())) {
744         return -E_INVALID_ARGS;
745     }
746 
747     Parcel parcel(buffer, length);
748     parcel.WriteUInt32(ABILITY_SYNC_VERSION_V1);
749     parcel.WriteUInt32(SOFTWARE_VERSION_CURRENT);
750     parcel.WriteInt(packet->GetAckCode());
751     parcel.WriteString(packet->GetSchema());
752     parcel.WriteInt(packet->GetSecLabel());
753     parcel.WriteInt(packet->GetSecFlag());
754     parcel.WriteUInt32(packet->GetSchemaType());
755     parcel.WriteUInt32(packet->GetPermitSync());
756     parcel.WriteUInt32(packet->GetRequirePeerConvert());
757     parcel.WriteUInt64(packet->GetDbCreateTime());
758     int errCode = DbAbility::Serialize(parcel, packet->GetDbAbility());
759     if (parcel.IsError() || errCode != E_OK) {
760         return -E_PARSE_FAIL;
761     }
762     errCode = SchemaNegotiate::SerializeData(packet->GetRelationalSyncOpinion(), parcel);
763     if (parcel.IsError() || errCode != E_OK) {
764         return -E_PARSE_FAIL;
765     }
766     parcel.WriteUInt64(packet->GetSchemaVersion());
767     if (parcel.IsError()) {
768         LOGE("[AbilitySync] Serialize schema version failed");
769         return -E_PARSE_FAIL;
770     }
771     return E_OK;
772 }
773 
RequestPacketDeSerialization(const uint8_t * buffer,uint32_t length,Message * inMsg)774 int AbilitySync::RequestPacketDeSerialization(const uint8_t *buffer, uint32_t length, Message *inMsg)
775 {
776     auto *packet = new (std::nothrow) AbilitySyncRequestPacket();
777     if (packet == nullptr) {
778         return -E_OUT_OF_MEMORY;
779     }
780 
781     Parcel parcel(const_cast<uint8_t *>(buffer), length);
782     uint32_t version = 0;
783     uint32_t softwareVersion = 0;
784     std::string schema;
785     int32_t sendCode = 0;
786     int errCode = -E_PARSE_FAIL;
787 
788     parcel.ReadUInt32(version);
789     if (parcel.IsError()) {
790         goto ERROR_OUT;
791     }
792     packet->SetProtocolVersion(version);
793     if (version > ABILITY_SYNC_VERSION_V1) {
794         packet->SetSendCode(-E_VERSION_NOT_SUPPORT);
795         errCode = inMsg->SetExternalObject<>(packet);
796         if (errCode != E_OK) {
797             goto ERROR_OUT;
798         }
799         return errCode;
800     }
801     parcel.ReadInt(sendCode);
802     parcel.ReadUInt32(softwareVersion);
803     parcel.ReadString(schema);
804     errCode = RequestPacketDeSerializationTailPart(parcel, packet, softwareVersion);
805     if (parcel.IsError() || errCode != E_OK) {
806         goto ERROR_OUT;
807     }
808     packet->SetSendCode(sendCode);
809     packet->SetSoftwareVersion(softwareVersion);
810     packet->SetSchema(schema);
811 
812     errCode = inMsg->SetExternalObject<>(packet);
813     if (errCode == E_OK) {
814         return E_OK;
815     }
816 
817 ERROR_OUT:
818     delete packet;
819     return errCode;
820 }
821 
RequestPacketDeSerializationTailPart(Parcel & parcel,AbilitySyncRequestPacket * packet,uint32_t version)822 int AbilitySync::RequestPacketDeSerializationTailPart(Parcel &parcel, AbilitySyncRequestPacket *packet,
823     uint32_t version)
824 {
825     if (!parcel.IsError() && version > SOFTWARE_VERSION_RELEASE_2_0) {
826         int32_t secLabel = 0;
827         int32_t secFlag = 0;
828         uint32_t schemaType = 0;
829         parcel.ReadInt(secLabel);
830         parcel.ReadInt(secFlag);
831         parcel.ReadUInt32(schemaType);
832         packet->SetSecLabel(secLabel);
833         packet->SetSecFlag(secFlag);
834         packet->SetSchemaType(schemaType);
835     }
836     if (!parcel.IsError() && version > SOFTWARE_VERSION_RELEASE_3_0) {
837         uint64_t dbCreateTime = 0;
838         parcel.ReadUInt64(dbCreateTime);
839         packet->SetDbCreateTime(dbCreateTime);
840     }
841     DbAbility remoteDbAbility;
842     int errCode = DbAbility::DeSerialize(parcel, remoteDbAbility);
843     if (errCode != E_OK) {
844         LOGE("[AbilitySync] request packet DeSerializ failed.");
845         return errCode;
846     }
847     packet->SetDbAbility(remoteDbAbility);
848     if (version >= SOFTWARE_VERSION_RELEASE_9_0) {
849         uint64_t schemaVersion = 0u;
850         parcel.ReadUInt64(schemaVersion);
851         if (parcel.IsError()) {
852             LOGW("[AbilitySync] request packet read schema version failed");
853             return -E_PARSE_FAIL;
854         }
855         packet->SetSchemaVersion(schemaVersion);
856     }
857     return E_OK;
858 }
859 
AckPacketDeSerializationTailPart(Parcel & parcel,AbilitySyncAckPacket * packet,uint32_t version)860 int AbilitySync::AckPacketDeSerializationTailPart(Parcel &parcel, AbilitySyncAckPacket *packet, uint32_t version)
861 {
862     if (!parcel.IsError() && version > SOFTWARE_VERSION_RELEASE_2_0) {
863         int32_t secLabel = 0;
864         int32_t secFlag = 0;
865         uint32_t schemaType = 0;
866         uint32_t permitSync = 0;
867         uint32_t requirePeerConvert = 0;
868         parcel.ReadInt(secLabel);
869         parcel.ReadInt(secFlag);
870         parcel.ReadUInt32(schemaType);
871         parcel.ReadUInt32(permitSync);
872         parcel.ReadUInt32(requirePeerConvert);
873         packet->SetSecLabel(secLabel);
874         packet->SetSecFlag(secFlag);
875         packet->SetSchemaType(schemaType);
876         packet->SetPermitSync(permitSync);
877         packet->SetRequirePeerConvert(requirePeerConvert);
878     }
879     if (!parcel.IsError() && version > SOFTWARE_VERSION_RELEASE_3_0) {
880         uint64_t dbCreateTime = 0;
881         parcel.ReadUInt64(dbCreateTime);
882         packet->SetDbCreateTime(dbCreateTime);
883     }
884     DbAbility remoteDbAbility;
885     int errCode = DbAbility::DeSerialize(parcel, remoteDbAbility);
886     if (errCode != E_OK) {
887         LOGE("[AbilitySync] ack packet DeSerializ failed.");
888         return errCode;
889     }
890     packet->SetDbAbility(remoteDbAbility);
891     RelationalSyncOpinion relationalSyncOpinion;
892     errCode = SchemaNegotiate::DeserializeData(parcel, relationalSyncOpinion);
893     if (errCode != E_OK) {
894         LOGE("[AbilitySync] ack packet DeSerializ RelationalSyncOpinion failed.");
895         return errCode;
896     }
897     packet->SetRelationalSyncOpinion(relationalSyncOpinion);
898     if (version >= SOFTWARE_VERSION_RELEASE_9_0) {
899         uint64_t schemaVersion = 0;
900         parcel.ReadUInt64(schemaVersion);
901         if (parcel.IsError()) {
902             LOGW("[AbilitySync] ack packet read schema version failed.");
903             return -E_PARSE_FAIL;
904         }
905         packet->SetSchemaVersion(schemaVersion);
906     }
907     return E_OK;
908 }
909 
AckPacketDeSerialization(const uint8_t * buffer,uint32_t length,Message * inMsg)910 int AbilitySync::AckPacketDeSerialization(const uint8_t *buffer, uint32_t length, Message *inMsg)
911 {
912     auto *packet = new (std::nothrow) AbilitySyncAckPacket();
913     if (packet == nullptr) {
914         return -E_OUT_OF_MEMORY;
915     }
916 
917     Parcel parcel(const_cast<uint8_t *>(buffer), length);
918     uint32_t version = 0;
919     uint32_t softwareVersion = 0;
920     int32_t ackCode = E_OK;
921     std::string schema;
922     int errCode;
923     parcel.ReadUInt32(version);
924     if (parcel.IsError()) {
925         LOGE("[AbilitySync][RequestDeSerialization] read version failed!");
926         errCode = -E_PARSE_FAIL;
927         goto ERROR_OUT;
928     }
929     packet->SetProtocolVersion(version);
930     if (version > ABILITY_SYNC_VERSION_V1) {
931         packet->SetAckCode(-E_VERSION_NOT_SUPPORT);
932         errCode = inMsg->SetExternalObject<>(packet);
933         if (errCode != E_OK) {
934             goto ERROR_OUT;
935         }
936         return errCode;
937     }
938     parcel.ReadUInt32(softwareVersion);
939     parcel.ReadInt(ackCode);
940     parcel.ReadString(schema);
941     errCode = AckPacketDeSerializationTailPart(parcel, packet, softwareVersion);
942     if (parcel.IsError() || errCode != E_OK) {
943         LOGE("[AbilitySync][RequestDeSerialization] DeSerialization failed!");
944         errCode = -E_PARSE_FAIL;
945         goto ERROR_OUT;
946     }
947     packet->SetSoftwareVersion(softwareVersion);
948     packet->SetAckCode(ackCode);
949     packet->SetSchema(schema);
950     errCode = inMsg->SetExternalObject<>(packet);
951     if (errCode == E_OK) {
952         return E_OK;
953     }
954 
955 ERROR_OUT:
956     delete packet;
957     return errCode;
958 }
959 
SetAbilityRequestBodyInfo(uint16_t remoteCommunicatorVersion,const ISyncTaskContext * context,AbilitySyncRequestPacket & packet) const960 int AbilitySync::SetAbilityRequestBodyInfo(uint16_t remoteCommunicatorVersion, const ISyncTaskContext *context,
961     AbilitySyncRequestPacket &packet) const
962 {
963     uint64_t dbCreateTime;
964     int errCode =
965         (static_cast<SyncGenericInterface *>(storageInterface_))->GetDatabaseCreateTimestamp(dbCreateTime);
966     if (errCode != E_OK) {
967         LOGE("[AbilitySync][FillAbilityRequest] GetDatabaseCreateTimestamp failed, err %d", errCode);
968         return errCode;
969     }
970     SecurityOption option;
971     GetPacketSecOption(context, option);
972     std::string schemaStr;
973     uint32_t schemaType = 0;
974     if (IsSingleKvVer()) {
975         SchemaObject schemaObj = (static_cast<SingleVerKvDBSyncInterface *>(storageInterface_))->GetSchemaInfo();
976         schemaStr = schemaObj.ToSchemaString();
977         schemaType = static_cast<uint32_t>(schemaObj.GetSchemaType());
978     } else if (IsSingleRelationalVer()) {
979         auto schemaObj = (static_cast<RelationalDBSyncInterface *>(storageInterface_))->GetSchemaInfo();
980         schemaStr = schemaObj.ToSchemaString();
981         schemaType = static_cast<uint32_t>(schemaObj.GetSchemaType());
982     }
983     DbAbility dbAbility;
984     errCode = GetDbAbilityInfo(dbAbility);
985     if (errCode != E_OK) {
986         LOGE("[AbilitySync][FillAbilityRequest] GetDbAbility failed, err %d", errCode);
987         return errCode;
988     }
989     auto [err, localSchemaVer] = metadata_->GetLocalSchemaVersion();
990     if (err != E_OK) {
991         LOGE("[AbilitySync][FillAbilityRequest] GetLocalSchemaVersion failed, err %d", err);
992         return err;
993     }
994     // 102 version is forbidden to sync with 103 json-schema or flatbuffer-schema
995     // so schema should put null string while remote is 102 version to avoid this bug.
996     if (remoteCommunicatorVersion == 1) {
997         packet.SetSchema("");
998         packet.SetSchemaType(0);
999     } else {
1000         packet.SetSchema(schemaStr);
1001         packet.SetSchemaType(schemaType);
1002     }
1003     packet.SetProtocolVersion(ABILITY_SYNC_VERSION_V1);
1004     packet.SetSoftwareVersion(SOFTWARE_VERSION_CURRENT);
1005     packet.SetSecLabel(option.securityLabel);
1006     packet.SetSecFlag(option.securityFlag);
1007     packet.SetDbCreateTime(dbCreateTime);
1008     packet.SetDbAbility(dbAbility);
1009     packet.SetSchemaVersion(localSchemaVer);
1010     LOGI("[AbilitySync][FillRequest] ver=%u,Lab=%d,Flag=%d,dbCreateTime=%" PRId64 ",schemaVer=%" PRId64,
1011         SOFTWARE_VERSION_CURRENT, option.securityLabel, option.securityFlag, dbCreateTime, localSchemaVer);
1012     return E_OK;
1013 }
1014 
SetAbilityAckBodyInfo(const ISyncTaskContext * context,int ackCode,bool isAckNotify,AbilitySyncAckPacket & ackPacket) const1015 int AbilitySync::SetAbilityAckBodyInfo(const ISyncTaskContext *context, int ackCode, bool isAckNotify,
1016     AbilitySyncAckPacket &ackPacket) const
1017 {
1018     ackPacket.SetProtocolVersion(ABILITY_SYNC_VERSION_V1);
1019     ackPacket.SetSoftwareVersion(SOFTWARE_VERSION_CURRENT);
1020     if (!isAckNotify) {
1021         SecurityOption option;
1022         GetPacketSecOption(context, option);
1023         ackPacket.SetSecLabel(option.securityLabel);
1024         ackPacket.SetSecFlag(option.securityFlag);
1025         uint64_t dbCreateTime = 0;
1026         int errCode =
1027             (static_cast<SyncGenericInterface *>(storageInterface_))->GetDatabaseCreateTimestamp(dbCreateTime);
1028         if (errCode != E_OK) {
1029             LOGE("[AbilitySync][SyncStart] GetDatabaseCreateTimestamp failed, err %d", errCode);
1030             ackCode = errCode;
1031         }
1032         DbAbility dbAbility;
1033         errCode = GetDbAbilityInfo(dbAbility);
1034         if (errCode != E_OK) {
1035             LOGE("[AbilitySync][FillAbilityRequest] GetDbAbility failed, err %d", errCode);
1036             return errCode;
1037         }
1038         ackPacket.SetDbCreateTime(dbCreateTime);
1039         ackPacket.SetDbAbility(dbAbility);
1040     }
1041     auto [ret, schemaVersion] = metadata_->GetLocalSchemaVersion();
1042     if (ret != E_OK) {
1043         return ret;
1044     }
1045     ackPacket.SetAckCode(ackCode);
1046     ackPacket.SetSchemaVersion(schemaVersion);
1047     return E_OK;
1048 }
1049 
SetAbilityAckSchemaInfo(AbilitySyncAckPacket & ackPacket,const ISchema & schemaObj)1050 void AbilitySync::SetAbilityAckSchemaInfo(AbilitySyncAckPacket &ackPacket, const ISchema &schemaObj)
1051 {
1052     ackPacket.SetSchema(schemaObj.ToSchemaString());
1053     ackPacket.SetSchemaType(static_cast<uint32_t>(schemaObj.GetSchemaType()));
1054 }
1055 
SetAbilityAckSyncOpinionInfo(AbilitySyncAckPacket & ackPacket,SyncOpinion localOpinion)1056 void AbilitySync::SetAbilityAckSyncOpinionInfo(AbilitySyncAckPacket &ackPacket, SyncOpinion localOpinion)
1057 {
1058     ackPacket.SetPermitSync(localOpinion.permitSync);
1059     ackPacket.SetRequirePeerConvert(localOpinion.requirePeerConvert);
1060 }
1061 
GetDbAbilityInfo(DbAbility & dbAbility)1062 int AbilitySync::GetDbAbilityInfo(DbAbility &dbAbility)
1063 {
1064     int errCode = E_OK;
1065     for (const auto &item : SyncConfig::ABILITYBITS) {
1066         errCode = dbAbility.SetAbilityItem(item, SUPPORT_MARK);
1067         if (errCode != E_OK) {
1068             return errCode;
1069         }
1070     }
1071     return errCode;
1072 }
1073 
AckMsgCheck(const Message * message,ISyncTaskContext * context) const1074 int AbilitySync::AckMsgCheck(const Message *message, ISyncTaskContext *context) const
1075 {
1076     if (message == nullptr || context == nullptr) {
1077         return -E_INVALID_ARGS;
1078     }
1079     if (message->GetErrorNo() == E_FEEDBACK_UNKNOWN_MESSAGE) {
1080         LOGE("[AbilitySync][AckMsgCheck] Remote device dose not support this message id");
1081         context->SetRemoteSoftwareVersion(SOFTWARE_VERSION_EARLIEST);
1082         context->SetTaskErrCode(-E_FEEDBACK_UNKNOWN_MESSAGE);
1083         return -E_FEEDBACK_UNKNOWN_MESSAGE;
1084     }
1085     if (message->GetErrorNo() == E_FEEDBACK_COMMUNICATOR_NOT_FOUND) {
1086         LOGE("[AbilitySync][AckMsgCheck] Remote db is closed");
1087         context->SetTaskErrCode(-E_FEEDBACK_COMMUNICATOR_NOT_FOUND);
1088         return -E_FEEDBACK_COMMUNICATOR_NOT_FOUND;
1089     }
1090     const AbilitySyncAckPacket *packet = message->GetObject<AbilitySyncAckPacket>();
1091     if (packet == nullptr) {
1092         return -E_INVALID_ARGS;
1093     }
1094     int ackCode = packet->GetAckCode();
1095     if (ackCode != E_OK) {
1096         LOGE("[AbilitySync][AckMsgCheck] received an errCode %d", ackCode);
1097         context->SetTaskErrCode(ackCode);
1098         return ackCode;
1099     }
1100     return E_OK;
1101 }
1102 
IsSingleKvVer() const1103 bool AbilitySync::IsSingleKvVer() const
1104 {
1105     return storageInterface_->GetInterfaceType() == ISyncInterface::SYNC_SVD;
1106 }
IsSingleRelationalVer() const1107 bool AbilitySync::IsSingleRelationalVer() const
1108 {
1109 #ifdef RELATIONAL_STORE
1110     return storageInterface_->GetInterfaceType() == ISyncInterface::SYNC_RELATION;
1111 #else
1112     return false;
1113 #endif
1114 }
1115 
HandleRequestRecv(const Message * message,ISyncTaskContext * context,bool isCompatible)1116 int AbilitySync::HandleRequestRecv(const Message *message, ISyncTaskContext *context, bool isCompatible)
1117 {
1118     const AbilitySyncRequestPacket *packet = message->GetObject<AbilitySyncRequestPacket>();
1119     if (packet == nullptr) {
1120         return -E_INVALID_ARGS;
1121     }
1122     uint32_t remoteSoftwareVersion = packet->GetSoftwareVersion();
1123     int ackCode;
1124     std::string schema = packet->GetSchema();
1125     if (remoteSoftwareVersion <= SOFTWARE_VERSION_RELEASE_2_0) {
1126         LOGI("[AbilitySync][RequestRecv] remote version = %u, CheckSchemaCompatible = %d",
1127             remoteSoftwareVersion, isCompatible);
1128         return SendAckWithEmptySchema(context, message, E_OK, false);
1129     }
1130     HandleVersionV3RequestParam(packet, context);
1131     if (SecLabelCheck(packet)) {
1132         ackCode = E_OK;
1133     } else {
1134         ackCode = -E_SECURITY_OPTION_CHECK_ERROR;
1135     }
1136     if (ackCode == E_OK && remoteSoftwareVersion > SOFTWARE_VERSION_RELEASE_3_0) {
1137         ackCode = metadata_->SetDbCreateTime(deviceId_, packet->GetDbCreateTime(), true);
1138     }
1139     if (ackCode == E_OK && remoteSoftwareVersion >= SOFTWARE_VERSION_RELEASE_9_0) {
1140         ackCode = metadata_->SetRemoteSchemaVersion(context->GetDeviceId(), packet->GetSchemaVersion());
1141     }
1142     AbilitySyncAckPacket ackPacket;
1143     if (IsSingleRelationalVer()) {
1144         ackPacket.SetRelationalSyncOpinion(MakeRelationSyncOpinion(packet, schema));
1145     } else {
1146         SetAbilityAckSyncOpinionInfo(ackPacket, MakeKvSyncOpinion(packet, schema, context));
1147     }
1148     LOGI("[AbilitySync][RequestRecv] remote dev=%s,ver=%u,schemaCompatible=%d", STR_MASK(deviceId_),
1149         remoteSoftwareVersion, isCompatible);
1150     int errCode = SendAck(context, message, ackCode, false, ackPacket);
1151     return ackCode != E_OK ? ackCode : errCode;
1152 }
1153 
SendAck(const ISyncTaskContext * context,const Message * message,int ackCode,bool isAckNotify,AbilitySyncAckPacket & ackPacket)1154 int AbilitySync::SendAck(const ISyncTaskContext *context, const Message *message, int ackCode, bool isAckNotify,
1155     AbilitySyncAckPacket &ackPacket)
1156 {
1157     int errCode = SetAbilityAckBodyInfo(context, ackCode, isAckNotify, ackPacket);
1158     if (errCode != E_OK) {
1159         return errCode;
1160     }
1161     if (IsSingleRelationalVer()) {
1162         auto schemaObj = (static_cast<RelationalDBSyncInterface *>(storageInterface_))->GetSchemaInfo();
1163         SetAbilityAckSchemaInfo(ackPacket, schemaObj);
1164     } else if (IsSingleKvVer()) {
1165         SchemaObject schemaObject = static_cast<SingleVerKvDBSyncInterface *>(storageInterface_)->GetSchemaInfo();
1166         SetAbilityAckSchemaInfo(ackPacket, schemaObject);
1167     }
1168     return SendAck(message, ackPacket, isAckNotify);
1169 }
1170 
SendAckWithEmptySchema(const ISyncTaskContext * context,const Message * message,int ackCode,bool isAckNotify)1171 int AbilitySync::SendAckWithEmptySchema(const ISyncTaskContext *context, const Message *message, int ackCode,
1172     bool isAckNotify)
1173 {
1174     AbilitySyncAckPacket ackPacket;
1175     int errCode = SetAbilityAckBodyInfo(context, ackCode, isAckNotify, ackPacket);
1176     if (errCode != E_OK) {
1177         return errCode;
1178     }
1179     SetAbilityAckSchemaInfo(ackPacket, SchemaObject());
1180     return SendAck(message, ackPacket, isAckNotify);
1181 }
1182 
SendAck(const Message * inMsg,const AbilitySyncAckPacket & ackPacket,bool isAckNotify)1183 int AbilitySync::SendAck(const Message *inMsg, const AbilitySyncAckPacket &ackPacket, bool isAckNotify)
1184 {
1185     Message *ackMessage = new (std::nothrow) Message(ABILITY_SYNC_MESSAGE);
1186     if (ackMessage == nullptr) {
1187         LOGE("[AbilitySync][SendAck] message create failed, may be memleak!");
1188         return -E_OUT_OF_MEMORY;
1189     }
1190     int errCode = ackMessage->SetCopiedObject<>(ackPacket);
1191     if (errCode != E_OK) {
1192         LOGE("[AbilitySync][SendAck] SetCopiedObject failed, err %d", errCode);
1193         delete ackMessage;
1194         ackMessage = nullptr;
1195         return errCode;
1196     }
1197     (!isAckNotify) ? ackMessage->SetMessageType(TYPE_RESPONSE) : ackMessage->SetMessageType(TYPE_NOTIFY);
1198     ackMessage->SetTarget(deviceId_);
1199     ackMessage->SetSessionId(inMsg->GetSessionId());
1200     ackMessage->SetSequenceId(inMsg->GetSequenceId());
1201     SendConfig conf;
1202     SetSendConfigParam(storageInterface_->GetDbProperties(), deviceId_, false, SEND_TIME_OUT, conf);
1203     errCode = communicator_->SendMessage(deviceId_, ackMessage, conf);
1204     if (errCode != E_OK) {
1205         LOGE("[AbilitySync][SendAck] SendPacket failed, err %d", errCode);
1206         delete ackMessage;
1207         ackMessage = nullptr;
1208     }
1209     return errCode;
1210 }
1211 
MakeKvSyncOpinion(const AbilitySyncRequestPacket * packet,const std::string & remoteSchema,ISyncTaskContext * context)1212 SyncOpinion AbilitySync::MakeKvSyncOpinion(const AbilitySyncRequestPacket *packet,
1213     const std::string &remoteSchema, ISyncTaskContext *context)
1214 {
1215     uint8_t remoteSchemaType = packet->GetSchemaType();
1216     SchemaObject localSchema = (static_cast<SingleVerKvDBSyncInterface *>(storageInterface_))->GetSchemaInfo();
1217     SyncOpinion localSyncOpinion = SchemaNegotiate::MakeLocalSyncOpinion(localSchema, remoteSchema, remoteSchemaType);
1218     if (IsBothKvAndOptAbilitySync(context->GetRemoteSoftwareVersion(),
1219         localSchema.GetSchemaType(), remoteSchemaType)) { // LCOV_EXCL_BR_LINE
1220         // both kv no need convert
1221         SyncStrategy localStrategy;
1222         localStrategy.permitSync = true;
1223         (static_cast<SingleVerKvSyncTaskContext *>(context))->SetSyncStrategy(localStrategy, true);
1224         SetAbilitySyncFinishedStatus(true, *context);
1225     }
1226     return localSyncOpinion;
1227 }
1228 
MakeRelationSyncOpinion(const AbilitySyncRequestPacket * packet,const std::string & remoteSchema) const1229 RelationalSyncOpinion AbilitySync::MakeRelationSyncOpinion(const AbilitySyncRequestPacket *packet,
1230     const std::string &remoteSchema) const
1231 {
1232     uint8_t remoteSchemaType = packet->GetSchemaType();
1233     RelationalSchemaObject localSchema = (static_cast<RelationalDBSyncInterface *>(storageInterface_))->GetSchemaInfo();
1234     return SchemaNegotiate::MakeLocalSyncOpinion(localSchema, remoteSchema, remoteSchemaType);
1235 }
1236 
HandleKvAckSchemaParam(const AbilitySyncAckPacket * recvPacket,ISyncTaskContext * context,AbilitySyncAckPacket & sendPacket,std::pair<bool,bool> & schemaSyncStatus)1237 int AbilitySync::HandleKvAckSchemaParam(const AbilitySyncAckPacket *recvPacket,
1238     ISyncTaskContext *context, AbilitySyncAckPacket &sendPacket, std::pair<bool, bool> &schemaSyncStatus)
1239 {
1240     std::string remoteSchema = recvPacket->GetSchema();
1241     uint8_t remoteSchemaType = recvPacket->GetSchemaType();
1242     bool permitSync = static_cast<bool>(recvPacket->GetPermitSync());
1243     bool requirePeerConvert = static_cast<bool>(recvPacket->GetRequirePeerConvert());
1244     SyncOpinion remoteOpinion = {permitSync, requirePeerConvert, true};
1245     SchemaObject localSchema = (static_cast<SingleVerKvDBSyncInterface *>(storageInterface_))->GetSchemaInfo();
1246     SyncOpinion syncOpinion = SchemaNegotiate::MakeLocalSyncOpinion(localSchema, remoteSchema, remoteSchemaType);
1247     SyncStrategy localStrategy = SchemaNegotiate::ConcludeSyncStrategy(syncOpinion, remoteOpinion);
1248     SetAbilityAckSyncOpinionInfo(sendPacket, syncOpinion);
1249     (static_cast<SingleVerKvSyncTaskContext *>(context))->SetSyncStrategy(localStrategy, true);
1250     schemaSyncStatus = {
1251         localStrategy.permitSync,
1252         true
1253     };
1254     if (localStrategy.permitSync) { // LCOV_EXCL_BR_LINE
1255         RecordAbilitySyncFinish(recvPacket->GetSchemaVersion(), *context);
1256     }
1257     if (IsBothKvAndOptAbilitySync(context->GetRemoteSoftwareVersion(),
1258         localSchema.GetSchemaType(), remoteSchemaType)) { // LCOV_EXCL_BR_LINE
1259         return -E_ABILITY_SYNC_FINISHED;
1260     }
1261     return E_OK;
1262 }
1263 
HandleRelationAckSchemaParam(const AbilitySyncAckPacket * recvPacket,AbilitySyncAckPacket & sendPacket,ISyncTaskContext * context,bool sendOpinion,std::pair<bool,bool> & schemaSyncStatus)1264 int AbilitySync::HandleRelationAckSchemaParam(const AbilitySyncAckPacket *recvPacket, AbilitySyncAckPacket &sendPacket,
1265     ISyncTaskContext *context, bool sendOpinion, std::pair<bool, bool> &schemaSyncStatus)
1266 {
1267     std::string remoteSchema = recvPacket->GetSchema();
1268     uint8_t remoteSchemaType = recvPacket->GetSchemaType();
1269     auto localSchema = (static_cast<RelationalDBSyncInterface *>(storageInterface_))->GetSchemaInfo();
1270     auto localOpinion = SchemaNegotiate::MakeLocalSyncOpinion(localSchema, remoteSchema, remoteSchemaType);
1271     auto localStrategy = SchemaNegotiate::ConcludeSyncStrategy(localOpinion,
1272         recvPacket->GetRelationalSyncOpinion());
1273     (static_cast<SingleVerRelationalSyncTaskContext *>(context))->SetRelationalSyncStrategy(localStrategy, true);
1274     bool permitSync = std::any_of(localStrategy.begin(), localStrategy.end(),
1275         [] (const std::pair<std::string, SyncStrategy> &it) {
1276         return it.second.permitSync;
1277         });
1278     if (permitSync) {
1279         int innerErrCode = (static_cast<RelationalDBSyncInterface *>(storageInterface_)->SaveRemoteDeviceSchema(
1280             deviceId_, remoteSchema, remoteSchemaType));
1281         if (innerErrCode != E_OK) {
1282             LOGE("[AbilitySync][AckRecv] save remote device Schema failed,errCode=%d", innerErrCode);
1283             return innerErrCode;
1284         }
1285     }
1286     int errCode = (static_cast<RelationalDBSyncInterface *>(storageInterface_))->
1287         CreateDistributedDeviceTable(context->GetDeviceId(), localStrategy);
1288     if (errCode != E_OK) {
1289         LOGE("[AbilitySync][AckRecv] create distributed device table failed,errCode=%d", errCode);
1290     }
1291     if (sendOpinion) {
1292         sendPacket.SetRelationalSyncOpinion(localOpinion);
1293     }
1294     auto singleVerContext = static_cast<SingleVerSyncTaskContext *>(context);
1295     auto strategy = localStrategy.find(singleVerContext->GetQuery().GetRelationTableName());
1296     schemaSyncStatus = {
1297         !(strategy == localStrategy.end()) && strategy->second.permitSync,
1298         true
1299     };
1300     if (permitSync) {
1301         RecordAbilitySyncFinish(recvPacket->GetSchemaVersion(), *context);
1302     }
1303     return errCode;
1304 }
1305 
AckRecvWithHighVersion(const Message * message,ISyncTaskContext * context,const AbilitySyncAckPacket * packet)1306 int AbilitySync::AckRecvWithHighVersion(const Message *message, ISyncTaskContext *context,
1307     const AbilitySyncAckPacket *packet)
1308 {
1309     HandleVersionV3AckSecOptionParam(packet, context);
1310     AbilitySyncAckPacket ackPacket;
1311     std::pair<bool, bool> schemaSyncStatus;
1312     int errCode = E_OK;
1313     if (context->GetRemoteSoftwareVersion() > SOFTWARE_VERSION_RELEASE_3_0) {
1314         errCode = metadata_->SetDbCreateTime(deviceId_, packet->GetDbCreateTime(), true);
1315         if (errCode != E_OK) {
1316             LOGE("[AbilitySync][AckRecv] set db create time failed,errCode=%d", errCode);
1317             context->SetTaskErrCode(errCode);
1318             return errCode;
1319         }
1320     }
1321     errCode = HandleVersionV3AckSchemaParam(packet, ackPacket, context, true, schemaSyncStatus);
1322     DbAbility remoteDbAbility = packet->GetDbAbility();
1323     auto singleVerContext = static_cast<SingleVerSyncTaskContext *>(context);
1324     singleVerContext->SetDbAbility(remoteDbAbility);
1325     if (errCode == -E_ABILITY_SYNC_FINISHED) {
1326         return errCode;
1327     }
1328     if (errCode != E_OK) {
1329         context->SetTaskErrCode(errCode);
1330         return errCode;
1331     }
1332     if (!schemaSyncStatus.first) {
1333         singleVerContext->SetTaskErrCode(-E_SCHEMA_MISMATCH);
1334         LOGE("[AbilitySync][AckRecv] scheme check failed");
1335         return -E_SCHEMA_MISMATCH;
1336     }
1337     (void)SendAck(context, message, AbilitySync::CHECK_SUCCESS, true, ackPacket);
1338     return E_OK;
1339 }
1340 
TransformSecLabelIfNeed(int32_t originLabel,int targetLabel)1341 int32_t AbilitySync::TransformSecLabelIfNeed(int32_t originLabel, int targetLabel)
1342 {
1343     if ((originLabel == S0 && targetLabel == S1) || (originLabel == S1 && targetLabel == S0)) {
1344         LOGI("[AbilitySync] Accept SecLabel From %d To %d", originLabel, targetLabel);
1345         return targetLabel;
1346     }
1347     return originLabel;
1348 }
1349 
IsBothKvAndOptAbilitySync(uint32_t remoteVersion,SchemaType localType,uint8_t remoteType)1350 bool AbilitySync::IsBothKvAndOptAbilitySync(uint32_t remoteVersion, SchemaType localType, uint8_t remoteType)
1351 {
1352     return remoteVersion >= SOFTWARE_VERSION_RELEASE_8_0 && localType == SchemaType::NONE &&
1353         static_cast<SchemaType>(remoteType) == SchemaType::NONE;
1354 }
1355 
InitAbilitySyncFinishStatus(ISyncTaskContext & context)1356 void AbilitySync::InitAbilitySyncFinishStatus(ISyncTaskContext &context)
1357 {
1358     if (!metadata_->IsAbilitySyncFinish(context.GetDeviceId())) {
1359         return;
1360     }
1361     LOGI("[AbilitySync] Mark ability sync finish from db status");
1362     syncFinished_ = true;
1363     if (context.GetRemoteSoftwareVersion() == 0u) { // LCOV_EXCL_BR_LINE
1364         LOGI("[AbilitySync] Init remote version with default");
1365         context.SetRemoteSoftwareVersion(SOFTWARE_VERSION_RELEASE_9_0); // remote version >= 109
1366     }
1367     InitRemoteDBAbility(context);
1368 }
1369 
InitRemoteDBAbility(ISyncTaskContext & context)1370 void AbilitySync::InitRemoteDBAbility(ISyncTaskContext &context)
1371 {
1372     DbAbility ability;
1373     int errCode = GetDbAbilityInfo(ability);
1374     if (errCode != E_OK) {
1375         return;
1376     }
1377     context.SetDbAbility(ability);
1378 }
1379 
RecordAbilitySyncFinish(uint64_t remoteSchemaVersion,ISyncTaskContext & context)1380 void AbilitySync::RecordAbilitySyncFinish(uint64_t remoteSchemaVersion, ISyncTaskContext &context)
1381 {
1382     SetAbilitySyncFinishedStatus(true, context);
1383     if (context.GetRemoteSoftwareVersion() >= SOFTWARE_VERSION_RELEASE_9_0) { // LCOV_EXCL_BR_LINE
1384         (void)metadata_->SetRemoteSchemaVersion(deviceId_, remoteSchemaVersion);
1385     }
1386 }
1387 } // namespace DistributedDB