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() const52const PreparedStmt &RemoteExecutorRequestPacket::GetPreparedStmt() const 53 { 54 return preparedStmt_; 55 } 56 IsNeedResponse() const57bool RemoteExecutorRequestPacket::IsNeedResponse() const 58 { 59 return (flag_ & REQUEST_FLAG_RESPONSE_ACK) != 0; 60 } 61 SetNeedResponse()62void RemoteExecutorRequestPacket::SetNeedResponse() 63 { 64 flag_ |= REQUEST_FLAG_RESPONSE_ACK; 65 } 66 SetExtraConditions(const std::map<std::string,std::string> & extraConditions)67void RemoteExecutorRequestPacket::SetExtraConditions(const std::map<std::string, std::string> &extraConditions) 68 { 69 extraConditions_ = extraConditions; 70 } 71 GetExtraConditions() const72std::map<std::string, std::string> RemoteExecutorRequestPacket::GetExtraConditions() const 73 { 74 return extraConditions_; 75 } 76 CalculateLen() const77uint32_t RemoteExecutorRequestPacket::CalculateLen() const 78 { 79 uint32_t len = Parcel::GetUInt32Len(); // version 80 len += Parcel::GetUInt32Len(); // flag 81 uint32_t tmpLen = preparedStmt_.CalcLength(); 82 if ((len + tmpLen) > static_cast<uint32_t>(INT32_MAX) || tmpLen == 0u) { 83 LOGE("[RemoteExecutorRequestPacket][CalculateLen] Prepared statement is too large"); 84 return 0; 85 } 86 len += tmpLen; 87 len += Parcel::GetUInt32Len(); // conditions count 88 for (const auto &entry : extraConditions_) { 89 // each condition len never greater than 256 90 len += Parcel::GetStringLen(entry.first); 91 len += Parcel::GetStringLen(entry.second); 92 if (len > static_cast<uint32_t>(INT32_MAX)) { 93 LOGE("[RemoteExecutorRequestPacket][CalculateLen] conditions is too large"); 94 return 0; 95 } 96 } 97 len = Parcel::GetEightByteAlign(len); // 8-byte align 98 len += Parcel::GetIntLen(); 99 return len; 100 } 101 Serialization(Parcel & parcel) const102int RemoteExecutorRequestPacket::Serialization(Parcel &parcel) const 103 { 104 (void) parcel.WriteUInt32(version_); 105 (void) parcel.WriteUInt32(flag_); 106 (void) preparedStmt_.Serialize(parcel); 107 if (parcel.IsError()) { 108 LOGE("[RemoteExecutorRequestPacket] Serialization failed"); 109 return -E_INVALID_ARGS; 110 } 111 if (extraConditions_.size() > DBConstant::MAX_CONDITION_COUNT) { 112 return -E_INVALID_ARGS; 113 } 114 parcel.WriteUInt32(static_cast<uint32_t>(extraConditions_.size())); 115 for (const auto &entry : extraConditions_) { 116 if (entry.first.length() > DBConstant::MAX_CONDITION_KEY_LEN || 117 entry.second.length() > DBConstant::MAX_CONDITION_VALUE_LEN) { 118 return -E_INVALID_ARGS; 119 } 120 parcel.WriteString(entry.first); 121 parcel.WriteString(entry.second); 122 } 123 parcel.EightByteAlign(); 124 parcel.WriteInt(secLabel_); 125 if (parcel.IsError()) { 126 return -E_PARSE_FAIL; 127 } 128 return E_OK; 129 } 130 DeSerialization(Parcel & parcel)131int RemoteExecutorRequestPacket::DeSerialization(Parcel &parcel) 132 { 133 (void) parcel.ReadUInt32(version_); 134 (void) parcel.ReadUInt32(flag_); 135 (void) preparedStmt_.DeSerialize(parcel); 136 if (parcel.IsError()) { 137 LOGE("[RemoteExecutorRequestPacket] DeSerialization failed"); 138 return -E_INVALID_ARGS; 139 } 140 if (version_ < REQUEST_PACKET_VERSION_V2) { 141 return E_OK; 142 } 143 uint32_t conditionSize = 0u; 144 (void) parcel.ReadUInt32(conditionSize); 145 if (conditionSize > DBConstant::MAX_CONDITION_COUNT) { 146 return -E_INVALID_ARGS; 147 } 148 for (uint32_t i = 0; i < conditionSize; i++) { 149 std::string conditionKey; 150 std::string conditionVal; 151 (void) parcel.ReadString(conditionKey); 152 (void) parcel.ReadString(conditionVal); 153 if (conditionKey.length() > DBConstant::MAX_CONDITION_KEY_LEN || 154 conditionVal.length() > DBConstant::MAX_CONDITION_VALUE_LEN) { 155 return -E_INVALID_ARGS; 156 } 157 extraConditions_[conditionKey] = conditionVal; 158 } 159 parcel.EightByteAlign(); 160 if (version_ >= REQUEST_PACKET_VERSION_V3) { 161 parcel.ReadInt(secLabel_); 162 } 163 if (parcel.IsError()) { 164 return -E_PARSE_FAIL; 165 } 166 return E_OK; 167 } 168 SetOpCode(PreparedStmt::ExecutorOperation opCode)169void RemoteExecutorRequestPacket::SetOpCode(PreparedStmt::ExecutorOperation opCode) 170 { 171 preparedStmt_.SetOpCode(opCode); 172 } 173 SetSql(const std::string & sql)174void RemoteExecutorRequestPacket::SetSql(const std::string &sql) 175 { 176 preparedStmt_.SetSql(sql); 177 } 178 SetBindArgs(const std::vector<std::string> & bindArgs)179void RemoteExecutorRequestPacket::SetBindArgs(const std::vector<std::string> &bindArgs) 180 { 181 preparedStmt_.SetBindArgs(bindArgs); 182 } 183 SetSecLabel(int32_t secLabel)184void RemoteExecutorRequestPacket::SetSecLabel(int32_t secLabel) 185 { 186 secLabel_ = secLabel; 187 } 188 GetSecLabel() const189int32_t RemoteExecutorRequestPacket::GetSecLabel() const 190 { 191 return secLabel_; 192 } 193 Create()194RemoteExecutorRequestPacket* RemoteExecutorRequestPacket::Create() 195 { 196 return new (std::nothrow) RemoteExecutorRequestPacket(); 197 } 198 Release(RemoteExecutorRequestPacket * & packet)199void RemoteExecutorRequestPacket::Release(RemoteExecutorRequestPacket *&packet) 200 { 201 delete packet; 202 packet = nullptr; 203 } 204 RemoteExecutorAckPacket()205RemoteExecutorAckPacket::RemoteExecutorAckPacket() 206 { 207 } 208 ~RemoteExecutorAckPacket()209RemoteExecutorAckPacket::~RemoteExecutorAckPacket() 210 { 211 } 212 GetVersion() const213uint32_t RemoteExecutorAckPacket::GetVersion() const 214 { 215 return version_; 216 } 217 SetVersion(uint32_t version)218void RemoteExecutorAckPacket::SetVersion(uint32_t version) 219 { 220 version_ = version; 221 } 222 GetFlag() const223uint32_t RemoteExecutorAckPacket::GetFlag() const 224 { 225 return flag_; 226 } 227 SetFlag(uint32_t flag)228void RemoteExecutorAckPacket::SetFlag(uint32_t flag) 229 { 230 flag_ = flag; 231 } 232 GetAckCode() const233int32_t RemoteExecutorAckPacket::GetAckCode() const 234 { 235 return ackCode_; 236 } 237 SetAckCode(int32_t ackCode)238void RemoteExecutorAckPacket::SetAckCode(int32_t ackCode) 239 { 240 ackCode_ = ackCode; 241 } 242 MoveInRowDataSet(RelationalRowDataSet && rowDataSet)243void RemoteExecutorAckPacket::MoveInRowDataSet(RelationalRowDataSet &&rowDataSet) 244 { 245 rowDataSet_ = std::move(rowDataSet); 246 } 247 MoveOutRowDataSet() const248RelationalRowDataSet &&RemoteExecutorAckPacket::MoveOutRowDataSet() const 249 { 250 return std::move(rowDataSet_); 251 } 252 IsLastAck() const253bool RemoteExecutorAckPacket::IsLastAck() const 254 { 255 return (flag_ & ACK_FLAG_LAST_ACK) != 0; 256 } 257 SetLastAck()258void RemoteExecutorAckPacket::SetLastAck() 259 { 260 flag_ |= ACK_FLAG_LAST_ACK; 261 } 262 CalculateLen() const263uint32_t RemoteExecutorAckPacket::CalculateLen() const 264 { 265 uint32_t len = Parcel::GetUInt32Len(); // version 266 len += Parcel::GetIntLen(); // ackCode 267 len += Parcel::GetUInt32Len(); // flag 268 len = Parcel::GetEightByteAlign(len); 269 len += static_cast<uint32_t>(rowDataSet_.CalcLength()); 270 len += Parcel::GetIntLen(); // secLabel 271 len += Parcel::GetIntLen(); // secFlag 272 return len; 273 } 274 Serialization(Parcel & parcel) const275int RemoteExecutorAckPacket::Serialization(Parcel &parcel) const 276 { 277 (void) parcel.WriteUInt32(version_); 278 (void) parcel.WriteInt(ackCode_); 279 (void) parcel.WriteUInt32(flag_); 280 parcel.EightByteAlign(); 281 (void) rowDataSet_.Serialize(parcel); 282 (void) parcel.WriteInt(secLabel_); 283 (void) parcel.WriteInt(secFlag_); 284 if (parcel.IsError()) { 285 LOGE("[RemoteExecutorAckPacket] Serialization failed"); 286 return -E_INVALID_ARGS; 287 } 288 return E_OK; 289 } 290 DeSerialization(Parcel & parcel)291int RemoteExecutorAckPacket::DeSerialization(Parcel &parcel) 292 { 293 (void) parcel.ReadUInt32(version_); 294 (void) parcel.ReadInt(ackCode_); 295 (void) parcel.ReadUInt32(flag_); 296 parcel.EightByteAlign(); 297 if (parcel.IsError()) { 298 LOGE("[RemoteExecutorAckPacket] DeSerialization failed"); 299 return -E_INVALID_ARGS; 300 } 301 int errCode = rowDataSet_.DeSerialize(parcel); 302 if (errCode != E_OK) { 303 return errCode; 304 } 305 if ((flag_ & ACK_FLAG_SECURITY_OPTION) != 0) { 306 (void) parcel.ReadInt(secLabel_); 307 (void) parcel.ReadInt(secFlag_); 308 } else { 309 secLabel_ = NOT_SURPPORT_SEC_CLASSIFICATION; 310 } 311 if (parcel.IsError()) { 312 LOGE("[RemoteExecutorAckPacket] DeSerialization failed"); 313 return -E_INVALID_ARGS; 314 } 315 return E_OK; 316 } 317 GetSecurityOption() const318SecurityOption RemoteExecutorAckPacket::GetSecurityOption() const 319 { 320 SecurityOption option = {secLabel_, secFlag_}; 321 return option; 322 } 323 SetSecurityOption(const SecurityOption & option)324void RemoteExecutorAckPacket::SetSecurityOption(const SecurityOption &option) 325 { 326 secLabel_ = option.securityLabel; 327 secFlag_ = option.securityFlag; 328 flag_ |= ACK_FLAG_SECURITY_OPTION; 329 } 330 }