1 /* 2 * Copyright (c) 2022 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "remote_executor_packet.h" 17 18 namespace DistributedDB { 19 namespace { 20 constexpr uint8_t REQUEST_FLAG_RESPONSE_ACK = 1u; 21 constexpr uint8_t ACK_FLAG_LAST_ACK = 1u; 22 constexpr uint8_t ACK_FLAG_SECURITY_OPTION = 2u; 23 } RemoteExecutorRequestPacket()24RemoteExecutorRequestPacket::RemoteExecutorRequestPacket() 25 { 26 } 27 ~RemoteExecutorRequestPacket()28RemoteExecutorRequestPacket::~RemoteExecutorRequestPacket() 29 { 30 } 31 GetVersion() const32uint32_t RemoteExecutorRequestPacket::GetVersion() const 33 { 34 return version_; 35 } 36 SetVersion(uint32_t version)37void RemoteExecutorRequestPacket::SetVersion(uint32_t version) 38 { 39 version_ = version; 40 } 41 GetFlag() const42uint32_t RemoteExecutorRequestPacket::GetFlag() const 43 { 44 return flag_; 45 } 46 SetFlag(uint32_t flag)47void RemoteExecutorRequestPacket::SetFlag(uint32_t flag) 48 { 49 flag_ = flag; 50 } 51 GetPreparedStmt() const52PreparedStmt RemoteExecutorRequestPacket::GetPreparedStmt() const 53 { 54 return perparedStmt_; 55 } 56 SetPreparedStmt(const PreparedStmt & perparedStmt)57void RemoteExecutorRequestPacket::SetPreparedStmt(const PreparedStmt &perparedStmt) 58 { 59 perparedStmt_ = perparedStmt; 60 } 61 IsNeedResponse() const62bool RemoteExecutorRequestPacket::IsNeedResponse() const 63 { 64 return (flag_ & REQUEST_FLAG_RESPONSE_ACK) != 0; 65 } 66 SetNeedResponse()67void RemoteExecutorRequestPacket::SetNeedResponse() 68 { 69 flag_ |= REQUEST_FLAG_RESPONSE_ACK; 70 } 71 SetExtraConditions(const std::map<std::string,std::string> & extraConditions)72void RemoteExecutorRequestPacket::SetExtraConditions(const std::map<std::string, std::string> &extraConditions) 73 { 74 extraConditions_ = extraConditions; 75 } 76 GetExtraConditions() const77std::map<std::string, std::string> RemoteExecutorRequestPacket::GetExtraConditions() const 78 { 79 return extraConditions_; 80 } 81 CalculateLen() const82uint32_t RemoteExecutorRequestPacket::CalculateLen() const 83 { 84 uint32_t len = Parcel::GetUInt32Len(); // version 85 len += Parcel::GetUInt32Len(); // flag 86 len += perparedStmt_.CalcLength(); 87 len += Parcel::GetUInt32Len(); // conditions count 88 for (const auto &entry : extraConditions_) { 89 len += Parcel::GetStringLen(entry.first); 90 len += Parcel::GetStringLen(entry.second); 91 } 92 len = Parcel::GetEightByteAlign(len); // 8-byte align 93 len += Parcel::GetIntLen(); 94 return len; 95 } 96 Serialization(Parcel & parcel) const97int RemoteExecutorRequestPacket::Serialization(Parcel &parcel) const 98 { 99 (void) parcel.WriteUInt32(version_); 100 (void) parcel.WriteUInt32(flag_); 101 (void) perparedStmt_.Serialize(parcel); 102 if (parcel.IsError()) { 103 LOGE("[RemoteExecutorRequestPacket] Serialization failed"); 104 return -E_INVALID_ARGS; 105 } 106 if (extraConditions_.size() > DBConstant::MAX_CONDITION_COUNT) { 107 return -E_INVALID_ARGS; 108 } 109 parcel.WriteUInt32(static_cast<uint32_t>(extraConditions_.size())); 110 for (const auto &entry : extraConditions_) { 111 if (entry.first.length() > DBConstant::MAX_CONDITION_KEY_LEN || 112 entry.second.length() > DBConstant::MAX_CONDITION_VALUE_LEN) { 113 return -E_INVALID_ARGS; 114 } 115 parcel.WriteString(entry.first); 116 parcel.WriteString(entry.second); 117 } 118 parcel.EightByteAlign(); 119 parcel.WriteInt(secLabel_); 120 if (parcel.IsError()) { 121 return -E_PARSE_FAIL; 122 } 123 return E_OK; 124 } 125 DeSerialization(Parcel & parcel)126int RemoteExecutorRequestPacket::DeSerialization(Parcel &parcel) 127 { 128 (void) parcel.ReadUInt32(version_); 129 (void) parcel.ReadUInt32(flag_); 130 (void) perparedStmt_.DeSerialize(parcel); 131 if (parcel.IsError()) { 132 LOGE("[RemoteExecutorRequestPacket] DeSerialization failed"); 133 return -E_INVALID_ARGS; 134 } 135 if (version_ < REQUEST_PACKET_VERSION_V2) { 136 return E_OK; 137 } 138 uint32_t conditionSize = 0u; 139 (void) parcel.ReadUInt32(conditionSize); 140 if (conditionSize > DBConstant::MAX_CONDITION_COUNT) { 141 return -E_INVALID_ARGS; 142 } 143 for (uint32_t i = 0; i < conditionSize; i++) { 144 std::string conditionKey; 145 std::string conditionVal; 146 (void) parcel.ReadString(conditionKey); 147 (void) parcel.ReadString(conditionVal); 148 if (conditionKey.length() > DBConstant::MAX_CONDITION_KEY_LEN || 149 conditionVal.length() > DBConstant::MAX_CONDITION_VALUE_LEN) { 150 return -E_INVALID_ARGS; 151 } 152 extraConditions_[conditionKey] = conditionVal; 153 } 154 parcel.EightByteAlign(); 155 if (version_ >= REQUEST_PACKET_VERSION_V3) { 156 parcel.ReadInt(secLabel_); 157 } 158 if (parcel.IsError()) { 159 return -E_PARSE_FAIL; 160 } 161 return E_OK; 162 } 163 SetSecLabel(int32_t secLabel)164void RemoteExecutorRequestPacket::SetSecLabel(int32_t secLabel) 165 { 166 secLabel_ = secLabel; 167 } 168 GetSecLabel() const169int32_t RemoteExecutorRequestPacket::GetSecLabel() const 170 { 171 return secLabel_; 172 } 173 Create()174RemoteExecutorRequestPacket* RemoteExecutorRequestPacket::Create() 175 { 176 return new (std::nothrow) RemoteExecutorRequestPacket(); 177 } 178 Release(RemoteExecutorRequestPacket * & packet)179void RemoteExecutorRequestPacket::Release(RemoteExecutorRequestPacket *&packet) 180 { 181 delete packet; 182 packet = nullptr; 183 } 184 RemoteExecutorAckPacket()185RemoteExecutorAckPacket::RemoteExecutorAckPacket() 186 { 187 } 188 ~RemoteExecutorAckPacket()189RemoteExecutorAckPacket::~RemoteExecutorAckPacket() 190 { 191 } 192 GetVersion() const193uint32_t RemoteExecutorAckPacket::GetVersion() const 194 { 195 return version_; 196 } 197 SetVersion(uint32_t version)198void RemoteExecutorAckPacket::SetVersion(uint32_t version) 199 { 200 version_ = version; 201 } 202 GetFlag() const203uint32_t RemoteExecutorAckPacket::GetFlag() const 204 { 205 return flag_; 206 } 207 SetFlag(uint32_t flag)208void RemoteExecutorAckPacket::SetFlag(uint32_t flag) 209 { 210 flag_ = flag; 211 } 212 GetAckCode() const213int32_t RemoteExecutorAckPacket::GetAckCode() const 214 { 215 return ackCode_; 216 } 217 SetAckCode(int32_t ackCode)218void RemoteExecutorAckPacket::SetAckCode(int32_t ackCode) 219 { 220 ackCode_ = ackCode; 221 } 222 MoveInRowDataSet(RelationalRowDataSet && rowDataSet)223void RemoteExecutorAckPacket::MoveInRowDataSet(RelationalRowDataSet &&rowDataSet) 224 { 225 rowDataSet_ = std::move(rowDataSet); 226 } 227 MoveOutRowDataSet() const228RelationalRowDataSet &&RemoteExecutorAckPacket::MoveOutRowDataSet() const 229 { 230 return std::move(rowDataSet_); 231 } 232 IsLastAck() const233bool RemoteExecutorAckPacket::IsLastAck() const 234 { 235 return (flag_ & ACK_FLAG_LAST_ACK) != 0; 236 } 237 SetLastAck()238void RemoteExecutorAckPacket::SetLastAck() 239 { 240 flag_ |= ACK_FLAG_LAST_ACK; 241 } 242 CalculateLen() const243uint32_t RemoteExecutorAckPacket::CalculateLen() const 244 { 245 uint32_t len = Parcel::GetUInt32Len(); // version 246 len += Parcel::GetIntLen(); // ackCode 247 len += Parcel::GetUInt32Len(); // flag 248 len = Parcel::GetEightByteAlign(len); 249 len += rowDataSet_.CalcLength(); 250 len += Parcel::GetIntLen(); // secLabel 251 len += Parcel::GetIntLen(); // secFlag 252 return len; 253 } 254 Serialization(Parcel & parcel) const255int RemoteExecutorAckPacket::Serialization(Parcel &parcel) const 256 { 257 (void) parcel.WriteUInt32(version_); 258 (void) parcel.WriteInt(ackCode_); 259 (void) parcel.WriteUInt32(flag_); 260 parcel.EightByteAlign(); 261 (void) rowDataSet_.Serialize(parcel); 262 (void) parcel.WriteInt(secLabel_); 263 (void) parcel.WriteInt(secFlag_); 264 if (parcel.IsError()) { 265 LOGE("[RemoteExecutorAckPacket] Serialization failed"); 266 return -E_INVALID_ARGS; 267 } 268 return E_OK; 269 } 270 DeSerialization(Parcel & parcel)271int RemoteExecutorAckPacket::DeSerialization(Parcel &parcel) 272 { 273 (void) parcel.ReadUInt32(version_); 274 (void) parcel.ReadInt(ackCode_); 275 (void) parcel.ReadUInt32(flag_); 276 parcel.EightByteAlign(); 277 (void) rowDataSet_.DeSerialize(parcel); 278 if ((flag_ & ACK_FLAG_SECURITY_OPTION) != 0) { 279 (void) parcel.ReadInt(secLabel_); 280 (void) parcel.ReadInt(secFlag_); 281 } else { 282 secLabel_ = NOT_SURPPORT_SEC_CLASSIFICATION; 283 } 284 if (parcel.IsError()) { 285 LOGE("[RemoteExecutorAckPacket] DeSerialization failed"); 286 return -E_INVALID_ARGS; 287 } 288 return E_OK; 289 } 290 GetSecurityOption() const291SecurityOption RemoteExecutorAckPacket::GetSecurityOption() const 292 { 293 SecurityOption option = {secLabel_, secFlag_}; 294 return option; 295 } 296 SetSecurityOption(const SecurityOption & option)297void RemoteExecutorAckPacket::SetSecurityOption(const SecurityOption &option) 298 { 299 secLabel_ = option.securityLabel; 300 secFlag_ = option.securityFlag; 301 flag_ |= ACK_FLAG_SECURITY_OPTION; 302 } 303 }