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 return len; 94 } 95 Serialization(Parcel & parcel) const96int RemoteExecutorRequestPacket::Serialization(Parcel &parcel) const 97 { 98 (void) parcel.WriteUInt32(version_); 99 (void) parcel.WriteUInt32(flag_); 100 (void) perparedStmt_.Serialize(parcel); 101 if (parcel.IsError()) { 102 LOGE("[RemoteExecutorRequestPacket] Serialization failed"); 103 return -E_INVALID_ARGS; 104 } 105 if (extraConditions_.size() > DBConstant::MAX_CONDITION_COUNT) { 106 return -E_INVALID_ARGS; 107 } 108 parcel.WriteUInt32(static_cast<uint32_t>(extraConditions_.size())); 109 for (const auto &entry : extraConditions_) { 110 if (entry.first.length() > DBConstant::MAX_CONDITION_KEY_LEN || 111 entry.second.length() > DBConstant::MAX_CONDITION_VALUE_LEN) { 112 return -E_INVALID_ARGS; 113 } 114 parcel.WriteString(entry.first); 115 parcel.WriteString(entry.second); 116 } 117 parcel.EightByteAlign(); 118 if (parcel.IsError()) { 119 return -E_PARSE_FAIL; 120 } 121 return E_OK; 122 } 123 DeSerialization(Parcel & parcel)124int RemoteExecutorRequestPacket::DeSerialization(Parcel &parcel) 125 { 126 (void) parcel.ReadUInt32(version_); 127 (void) parcel.ReadUInt32(flag_); 128 (void) perparedStmt_.DeSerialize(parcel); 129 if (parcel.IsError()) { 130 LOGE("[RemoteExecutorRequestPacket] DeSerialization failed"); 131 return -E_INVALID_ARGS; 132 } 133 if (version_ < REQUEST_PACKET_VERSION_V2) { 134 return E_OK; 135 } 136 uint32_t conditionSize = 0u; 137 (void) parcel.ReadUInt32(conditionSize); 138 if (conditionSize > DBConstant::MAX_CONDITION_COUNT) { 139 return -E_INVALID_ARGS; 140 } 141 for (uint32_t i = 0; i < conditionSize; i++) { 142 std::string conditionKey; 143 std::string conditionVal; 144 (void) parcel.ReadString(conditionKey); 145 (void) parcel.ReadString(conditionVal); 146 if (conditionKey.length() > DBConstant::MAX_CONDITION_KEY_LEN || 147 conditionVal.length() > DBConstant::MAX_CONDITION_VALUE_LEN) { 148 return -E_INVALID_ARGS; 149 } 150 extraConditions_[conditionKey] = conditionVal; 151 } 152 parcel.EightByteAlign(); 153 if (parcel.IsError()) { 154 return -E_PARSE_FAIL; 155 } 156 return E_OK; 157 } 158 Create()159RemoteExecutorRequestPacket* RemoteExecutorRequestPacket::Create() 160 { 161 return new (std::nothrow) RemoteExecutorRequestPacket(); 162 } 163 Release(RemoteExecutorRequestPacket * & packet)164void RemoteExecutorRequestPacket::Release(RemoteExecutorRequestPacket *&packet) 165 { 166 delete packet; 167 packet = nullptr; 168 } 169 RemoteExecutorAckPacket()170RemoteExecutorAckPacket::RemoteExecutorAckPacket() 171 { 172 } 173 ~RemoteExecutorAckPacket()174RemoteExecutorAckPacket::~RemoteExecutorAckPacket() 175 { 176 } 177 GetVersion() const178uint32_t RemoteExecutorAckPacket::GetVersion() const 179 { 180 return version_; 181 } 182 SetVersion(uint32_t version)183void RemoteExecutorAckPacket::SetVersion(uint32_t version) 184 { 185 version_ = version; 186 } 187 GetFlag() const188uint32_t RemoteExecutorAckPacket::GetFlag() const 189 { 190 return flag_; 191 } 192 SetFlag(uint32_t flag)193void RemoteExecutorAckPacket::SetFlag(uint32_t flag) 194 { 195 flag_ = flag; 196 } 197 GetAckCode() const198int32_t RemoteExecutorAckPacket::GetAckCode() const 199 { 200 return ackCode_; 201 } 202 SetAckCode(int32_t ackCode)203void RemoteExecutorAckPacket::SetAckCode(int32_t ackCode) 204 { 205 ackCode_ = ackCode; 206 } 207 MoveInRowDataSet(RelationalRowDataSet && rowDataSet)208void RemoteExecutorAckPacket::MoveInRowDataSet(RelationalRowDataSet &&rowDataSet) 209 { 210 rowDataSet_ = std::move(rowDataSet); 211 } 212 MoveOutRowDataSet() const213RelationalRowDataSet &&RemoteExecutorAckPacket::MoveOutRowDataSet() const 214 { 215 return std::move(rowDataSet_); 216 } 217 IsLastAck() const218bool RemoteExecutorAckPacket::IsLastAck() const 219 { 220 return (flag_ & ACK_FLAG_LAST_ACK) != 0; 221 } 222 SetLastAck()223void RemoteExecutorAckPacket::SetLastAck() 224 { 225 flag_ |= ACK_FLAG_LAST_ACK; 226 } 227 CalculateLen() const228uint32_t RemoteExecutorAckPacket::CalculateLen() const 229 { 230 uint32_t len = Parcel::GetUInt32Len(); // version 231 len += Parcel::GetIntLen(); // ackCode 232 len += Parcel::GetUInt32Len(); // flag 233 len = Parcel::GetEightByteAlign(len); 234 len += rowDataSet_.CalcLength(); 235 len += Parcel::GetIntLen(); // secLabel 236 len += Parcel::GetIntLen(); // secFlag 237 return len; 238 } 239 Serialization(Parcel & parcel) const240int RemoteExecutorAckPacket::Serialization(Parcel &parcel) const 241 { 242 (void) parcel.WriteUInt32(version_); 243 (void) parcel.WriteInt(ackCode_); 244 (void) parcel.WriteUInt32(flag_); 245 parcel.EightByteAlign(); 246 (void) rowDataSet_.Serialize(parcel); 247 (void) parcel.WriteInt(secLabel_); 248 (void) parcel.WriteInt(secFlag_); 249 if (parcel.IsError()) { 250 LOGE("[RemoteExecutorAckPacket] Serialization failed"); 251 return -E_INVALID_ARGS; 252 } 253 return E_OK; 254 } 255 DeSerialization(Parcel & parcel)256int RemoteExecutorAckPacket::DeSerialization(Parcel &parcel) 257 { 258 (void) parcel.ReadUInt32(version_); 259 (void) parcel.ReadInt(ackCode_); 260 (void) parcel.ReadUInt32(flag_); 261 parcel.EightByteAlign(); 262 (void) rowDataSet_.DeSerialize(parcel); 263 if ((flag_ & ACK_FLAG_SECURITY_OPTION) != 0) { 264 (void) parcel.ReadInt(secLabel_); 265 (void) parcel.ReadInt(secFlag_); 266 } else { 267 secLabel_ = NOT_SURPPORT_SEC_CLASSIFICATION; 268 } 269 if (parcel.IsError()) { 270 LOGE("[RemoteExecutorAckPacket] DeSerialization failed"); 271 return -E_INVALID_ARGS; 272 } 273 return E_OK; 274 } 275 GetSecurityOption() const276SecurityOption RemoteExecutorAckPacket::GetSecurityOption() const 277 { 278 SecurityOption option = {secLabel_, secFlag_}; 279 return option; 280 } 281 SetSecurityOption(const SecurityOption & option)282void RemoteExecutorAckPacket::SetSecurityOption(const SecurityOption &option) 283 { 284 secLabel_ = option.securityLabel; 285 secFlag_ = option.securityFlag; 286 flag_ |= ACK_FLAG_SECURITY_OPTION; 287 } 288 }