| /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ |
| /* vim: set ts=2 et sw=2 tw=80: */ |
| /* This Source Code Form is subject to the terms of the Mozilla Public |
| * License, v. 2.0. If a copy of the MPL was not distributed with this file, |
| * You can obtain one at http://mozilla.org/MPL/2.0/. */ |
| |
| #include "databuffer.h" |
| #include <algorithm> |
| #include <cassert> |
| #include <cstring> |
| #include <iomanip> |
| #include <iostream> |
| #if defined(WIN32) || defined(WIN64) |
| #include <winsock2.h> |
| #else |
| #include <arpa/inet.h> |
| #endif |
| |
| namespace nss_test { |
| |
| void DataBuffer::Assign(const uint8_t* d, size_t l) { |
| if (d) { |
| Allocate(l); |
| memcpy(static_cast<void*>(data_), static_cast<const void*>(d), l); |
| } else { |
| assert(l == 0); |
| data_ = nullptr; |
| len_ = 0; |
| } |
| } |
| |
| // Write will do a new allocation and expand the size of the buffer if needed. |
| // Returns the offset of the end of the write. |
| size_t DataBuffer::Write(size_t index, const uint8_t* val, size_t count) { |
| assert(val); |
| if (index + count > len_) { |
| size_t newlen = index + count; |
| uint8_t* tmp = new uint8_t[newlen]; // Always > 0. |
| if (data_) { |
| memcpy(static_cast<void*>(tmp), static_cast<const void*>(data_), len_); |
| } |
| if (index > len_) { |
| memset(static_cast<void*>(tmp + len_), 0, index - len_); |
| } |
| delete[] data_; |
| data_ = tmp; |
| len_ = newlen; |
| } |
| if (data_) { |
| memcpy(static_cast<void*>(data_ + index), static_cast<const void*>(val), |
| count); |
| } |
| return index + count; |
| } |
| |
| // Write an integer, also performing host-to-network order conversion. |
| // Returns the offset of the end of the write. |
| size_t DataBuffer::Write(size_t index, uint32_t val, size_t count) { |
| assert(count <= sizeof(uint32_t)); |
| uint32_t nvalue = htonl(val); |
| auto* addr = reinterpret_cast<const uint8_t*>(&nvalue); |
| return Write(index, addr + sizeof(uint32_t) - count, count); |
| } |
| |
| void DataBuffer::Splice(const uint8_t* ins, size_t ins_len, size_t index, |
| size_t remove) { |
| assert(ins); |
| uint8_t* old_value = data_; |
| size_t old_len = len_; |
| |
| // The amount of stuff remaining from the tail of the old. |
| size_t tail_len = old_len - (std::min)(old_len, index + remove); |
| // The new length: the head of the old, the new, and the tail of the old. |
| len_ = index + ins_len + tail_len; |
| data_ = new uint8_t[len_ ? len_ : 1]; |
| |
| // The head of the old. |
| if (old_value) { |
| Write(0, old_value, (std::min)(old_len, index)); |
| } |
| // Maybe a gap. |
| if (old_value && index > old_len) { |
| memset(old_value + index, 0, index - old_len); |
| } |
| // The new. |
| Write(index, ins, ins_len); |
| // The tail of the old. |
| if (tail_len > 0) { |
| Write(index + ins_len, old_value + index + remove, tail_len); |
| } |
| |
| delete[] old_value; |
| } |
| |
| // This can't use the same trick as Write(), since we might be reading from a |
| // smaller data source. |
| bool DataBuffer::Read(size_t index, size_t count, uint64_t* val) const { |
| assert(count <= sizeof(uint64_t)); |
| assert(val); |
| if ((index > len()) || (count > (len() - index))) { |
| return false; |
| } |
| *val = 0; |
| for (size_t i = 0; i < count; ++i) { |
| *val = (*val << 8) | data()[index + i]; |
| } |
| return true; |
| } |
| |
| bool DataBuffer::Read(size_t index, size_t count, uint32_t* val) const { |
| assert(count <= sizeof(uint32_t)); |
| uint64_t tmp; |
| |
| if (!Read(index, count, &tmp)) { |
| return false; |
| } |
| *val = tmp & 0xffffffff; |
| return true; |
| } |
| |
| size_t DataBuffer::logging_limit = 32; |
| |
| /* static */ void DataBuffer::SetLogLimit(size_t limit) { |
| DataBuffer::logging_limit = limit; |
| } |
| |
| } // namespace nss_test |