Lines Matching defs:buffer

157 int32_t UpgradePkgFile::CheckPackageHeader(std::vector<uint8_t> &buffer, size_t &offset)

163     WriteLE16(buffer.data(), GetPackageTlvType()); // Type is 1 for package header in TLV format

164     WriteLE16(buffer.data() + sizeof(uint16_t), sizeof(UpgradePkgHeader));

166     UpgradePkgHeader *header = reinterpret_cast<UpgradePkgHeader *>(buffer.data() + offset);

188     WriteLE16(buffer.data() + offset, 0x02); // Type is 2 for time in TLV format

189     WriteLE16(buffer.data() + offset + sizeof(uint16_t), sizeof(UpgradePkgTime));

194 int32_t UpgradePkgFile::WriteBuffer(std::vector<uint8_t> &buffer, size_t &offset, size_t &signOffset)

199     buffer.assign(buffer.capacity(), 0);

202         pkgInfo_.descriptPackageId, {buffer.data(), UPGRADE_RESERVE_LEN}, nameLen);

207     ret = pkgStream_->Write(buffer, GetUpgradeSignatureLen() + UPGRADE_RESERVE_LEN, offset);

221     // Allocate buffer size with max possible size

224     std::vector<uint8_t> buffer(buffSize);

228     int32_t ret = CheckPackageHeader(buffer, offset);

234     UpgradePkgTime *time = reinterpret_cast<UpgradePkgTime *>(buffer.data() + offset);

247     WriteLE16(buffer.data() + offset, 0x05); // Type is 5 for component in TLV format

248     WriteLE16(buffer.data() + offset + sizeof(uint16_t), pkgInfo_.pkgInfo.entryCount * sizeof(UpgradeCompInfo));

250     ret = pkgStream_->Write(buffer, UPGRADE_FILE_HEADER_LEN, 0);

255     // Clear buffer and save signature information

256     ret = WriteBuffer(buffer, offset, signOffset);

269     PkgBuffer buffer(HASH_TLV_SIZE);

270     int32_t ret = pkgStream_->Read(buffer, parsedLen, buffer.length, readBytes);

276     parsedLen += buffer.length;

277     uint16_t dataType = ReadLE16(buffer.buffer);

278     uint32_t dataLen = ReadLE32(buffer.buffer + sizeof(uint16_t));

310     PkgBuffer buffer(HASH_TLV_SIZE);

311     int32_t ret = pkgStream_->Read(buffer, parsedLen, buffer.length, readBytes);

318     parsedLen += buffer.length;

319     uint16_t type = ReadLE16(buffer.buffer);

320     uint32_t len = ReadLE32(buffer.buffer + sizeof(uint16_t));

325     algorithm->Update(buffer, buffer.length);

326     imgHashBuf.insert(imgHashBuf.end(), buffer.data.begin(), buffer.data.end());

393     PkgBuffer buffer(GetUpgradeSignatureLen() + UPGRADE_RESERVE_LEN);

395     int32_t ret = pkgStream_->Read(buffer, parsedLen, buffer.length, readBytes);

402     PkgFileImpl::ConvertBufferToString(pkgInfo_.descriptPackageId, {buffer.buffer, UPGRADE_RESERVE_LEN});

406             buffer.buffer + UPGRADE_RESERVE_LEN + SIGN_SHA256_LEN, SIGN_SHA384_LEN);

409         ret = memcpy_s(signData.data(), signData.size(), buffer.buffer + UPGRADE_RESERVE_LEN, SIGN_SHA256_LEN);

424     ret = memset_s(buffer.buffer + UPGRADE_RESERVE_LEN, buffer.length, 0, GetUpgradeSignatureLen());

430     algorithm->Update(buffer, UPGRADE_RESERVE_LEN + GetUpgradeSignatureLen());

449     // Allocate buffer with smallest package size

538     PkgBuffer buffer(buffSize);

545         ret = pkgStream_->Read(buffer, offset, remainBytes, readBytes);

551         algorithm->Update(buffer, readBytes);

588 int32_t UpgradePkgFile::SaveEntry(const PkgBuffer &buffer, size_t &parsedLen, UpgradeParam &info,

599     PkgBuffer headerBuff(buffer.buffer + info.currLen, info.readLen - info.currLen);

611     PkgBuffer signBuffer(buffer.buffer + info.currLen, decodeLen);

637     PkgBuffer buffer(sizeof(PkgTlv));

638     int32_t ret = pkgStream_->Read(buffer, parsedLen, buffer.length, info.readLen);

645     tlv.type = ReadLE16(buffer.buffer);

646     tlv.length = ReadLE16(buffer.buffer + sizeof(uint16_t));

648     algorithm->Update(buffer, sizeof(PkgTlv)); // tlv generate digest

678 void UpgradePkgFile::ParsePkgHeaderToTlv(const PkgBuffer &buffer, size_t &currLen, PkgTlv &tlv)

684     tlv.type = ReadLE16(buffer.buffer);

685     tlv.length = ReadLE16(buffer.buffer + sizeof(uint16_t));

692     UpgradePkgHeader *header = reinterpret_cast<UpgradePkgHeader *>(buffer.buffer + currLen);

693     pkgInfo_.updateFileVersion = ReadLE32(buffer.buffer + currLen + offsetof(UpgradePkgHeader, updateFileVersion));

710     PkgFileImpl::ConvertBufferToString(pkgInfo_.descriptPackageId, {reserve_buf.buffer, UPGRADE_RESERVE_LEN});

723     PkgBuffer buffer(UPGRADE_FILE_BASIC_LEN);

724     int32_t ret = pkgStream_->Read(buffer, 0, buffer.length, readLen);

731     ParsePkgHeaderToTlv(buffer, currLen, tlv);

742         algorithm->Update(buffer, realLen);

743         ret = pkgStream_->Read(buffer, realLen, buffer.length, readLen);

754     tlv.type = ReadLE16(buffer.buffer + currLen);

755     tlv.length = ReadLE16(buffer.buffer + currLen + sizeof(uint16_t));

758     UpgradePkgTime *time = reinterpret_cast<UpgradePkgTime *>(buffer.buffer + currLen);

765     algorithm->Update(buffer, currLen); // Generate digest

819     PkgBuffer buffer(reinterpret_cast<uint8_t *>(&comp), sizeof(comp));

820     ret = outStream->Write(buffer, sizeof(comp), startOffset);

869 int32_t UpgradeFileEntry::DecodeHeader(PkgBuffer &buffer, size_t headerOffset, size_t dataOffset,

883     if (buffer.length < sizeof(UpgradeCompInfo)) {

884         PKG_LOGE("Fail to check buffer %zu", buffer.length);

888     UpgradeCompInfo *info = reinterpret_cast<UpgradeCompInfo *>(buffer.buffer);

890         fileInfo_.fileInfo.packedSize = ReadLE64(buffer.buffer + offsetof(UpgradeCompInfo, size));

892         fileInfo_.fileInfo.packedSize = ReadLE32(buffer.buffer + offsetof(UpgradeCompInfo, size));

893         fileInfo_.originalSize = ReadLE32(buffer.buffer + offsetof(UpgradeCompInfo, originalSize));

907     fileInfo_.id = ReadLE16(buffer.buffer + offsetof(UpgradeCompInfo, id));

945         [this](PkgBuffer &buffer, size_t len, size_t offset) ->int32_t {

946             return Verify(buffer, len, offset);

958 int32_t UpgradeFileEntry::Verify(PkgBuffer &buffer, size_t len, size_t offset)

971     int32_t ret = pkgFile->GetPkgMgr()->CreatePkgStream(stream, fileName_, buffer);

980         PKG_LOGE("cal digest for pkg stream, buffer.length: %zu", buffer.length);