forked from mirrors/gecko-dev
127 lines
3.5 KiB
C++
127 lines
3.5 KiB
C++
/* -*- 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
|