expected_data_len);
}
// Verify that the data is correct. Do not verify suboptions and a header.
- const uint8_t* data = static_cast<const uint8_t*>(buf.getData());
+ const uint8_t* data = buf.getData();
EXPECT_EQ(0, memcmp(expected_data, data + option_desc.option_->getHeaderLen(),
expected_data_len));
}
// Create a copy of the packet using the output buffer from the source
// packet.
try {
- dst_pkt.reset(new Pkt4(static_cast<const uint8_t*>(buf.getData()),
- buf.getLength()));
+ dst_pkt.reset(new Pkt4(buf.getData(), buf.getLength()));
} catch (const Exception& ex) {
return (::testing::AssertionFailure(::testing::Message()
<< "Failed to create a"
-// Copyright (C) 2015-2023 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2015-2024 Internet Systems Consortium, Inc. ("ISC")
//
// 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
// Make a wire representation of the DHCPv4 message.
pkt->pack();
OutputBuffer& output_buffer = pkt->getBuffer();
- const uint8_t* data = static_cast<const uint8_t*>(output_buffer.getData());
+ const uint8_t* data = output_buffer.getData();
OptionBuffer option_buffer(data, data + output_buffer.getLength());
// Create the DHCPv4 Message option holding the created message.
// Make a wire representation of the DHCPv4 message.
infreq->pack();
OutputBuffer& output_buffer = infreq->getBuffer();
- const uint8_t* data = static_cast<const uint8_t*>(output_buffer.getData());
+ const uint8_t* data = output_buffer.getData();
OptionBuffer option_buffer(data, data + output_buffer.getLength());
// Create the DHCPv4 Message option holding the created message.
// DHCID.
OutputBuffer name_buf(1);
opt_fqdn->packDomainName(name_buf);
- const uint8_t* name_data = static_cast<const uint8_t*>(name_buf.getData());
+ const uint8_t* name_data = name_buf.getData();
// @todo currently D2Dhcid accepts a vector holding FQDN.
// However, it will be faster if we used a pointer name_data.
std::vector<uint8_t> buf_vec(name_data, name_data + name_buf.getLength());
expected_data_len);
}
// Verify that the data is correct. Do not verify suboptions and a header.
- const uint8_t* data = static_cast<const uint8_t*>(buf.getData());
- EXPECT_EQ(0, memcmp(expected_data, data + option_desc.option_->getHeaderLen(),
+ const uint8_t* data = buf.getData();
+ EXPECT_EQ(0, memcmp(expected_data,
+ data + option_desc.option_->getHeaderLen(),
expected_data_len));
}
-// Copyright (C) 2015-2023 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2015-2024 Internet Systems Consortium, Inc. ("ISC")
//
// 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
// Make a wire representation of the DHCPv4 message.
pkt->pack();
OutputBuffer& output_buffer = pkt->getBuffer();
- const uint8_t* data = static_cast<const uint8_t*>(output_buffer.getData());
+ const uint8_t* data = output_buffer.getData();
OptionBuffer option_buffer(data, data + output_buffer.getLength());
// Create the DHCPv4 Message option holding the created message.
-// Copyright (C) 2012-2016 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2012-2024 Internet Systems Consortium, Inc. ("ISC")
//
// 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
// Try to pack option data into the temporary buffer.
opt_ia->pack(buf);
if (buf.getLength() > 0) {
- const char* buf_data = static_cast<const char*>(buf.getData());
+ const uint8_t* buf_data = buf.getData();
// Option has been packed along with option type flag
// and transaction id so we have to skip first 4 bytes
// when copying temporary buffer option buffer.
// OutputBuffer class has nice functions that write
// data at the specified position so we can use it to
// inject contents of temporary buffer to output buffer.
- const uint8_t *buf_data =
- static_cast<const uint8_t*>(buf.getData());
+ const uint8_t *buf_data = buf.getData();
for (size_t i = 0; i < buf.getLength(); ++i) {
out_buffer.writeUint8At(buf_data[i], offset + i);
}
if ((pkt_it != template_packets_v4_.end()) &&
pkt_it->second) {
const util::OutputBuffer& out_buf(pkt_it->second->getBuffer());
- const char* out_buf_data =
- static_cast<const char*>(out_buf.getData());
+ const uint8_t* out_buf_data = out_buf.getData();
std::vector<uint8_t> buf(out_buf_data, out_buf_data + out_buf.getLength());
hex_buf = vector2Hex(buf);
}
if (pkt_it != template_packets_v6_.end() &&
pkt_it->second) {
const util::OutputBuffer& out_buf(pkt_it->second->getBuffer());
- const char* out_buf_data =
- static_cast<const char*>(out_buf.getData());
+ const uint8_t* out_buf_data = out_buf.getData();
std::vector<uint8_t> buf(out_buf_data, out_buf_data + out_buf.getLength());
hex_buf = vector2Hex(buf);
}
-// Copyright (C) 2012-2017 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2012-2024 Internet Systems Consortium, Inc. ("ISC")
//
// 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
// DHO_BOOT_SIZE options.
util::OutputBuffer pkt_output = pkt->getBuffer();
ASSERT_EQ(buf.size(), pkt_output.getLength());
- const uint8_t* out_buf_data =
- static_cast<const uint8_t*>(pkt_output.getData());
+ const uint8_t* out_buf_data = pkt_output.getData();
// Check if options we read from buffer is valid.
EXPECT_EQ(0, memcmp(buf_hostname,
// Get packet's output buffer and make sure it has valid size.
util::OutputBuffer out_buf = pkt1->getBuffer();
ASSERT_EQ(buf.size(), out_buf.getLength());
- const uint8_t *out_buf_data =
- static_cast<const uint8_t*>(out_buf.getData());
+ const uint8_t *out_buf_data = out_buf.getData();
// Initialize reference data for transaction id.
const uint8_t ref_data[] = { 0, 0, 1, 2 };
const util::OutputBuffer& out_buf = pkt1->getBuffer();
ASSERT_EQ(in_data.size(), out_buf.getLength());
// Verify that 4,5,6,7 has been written to the packet's buffer.
- const char* out_data = static_cast<const char*>(out_buf.getData());
+ const uint8_t* out_data = out_buf.getData();
EXPECT_TRUE(std::equal(write_buf.begin() + 3, write_buf.begin() + 7,
out_data + 10));
// Write 1 octet (0x51) at position 10.
if (option->formatted_value_.empty() && (opt->len() > opt->getHeaderLen())) {
OutputBuffer buf(opt->len());
opt->pack(buf);
- const char* buf_ptr = static_cast<const char*>(buf.getData());
+ const uint8_t* buf_ptr = buf.getData();
std::vector<uint8_t> blob(buf_ptr + opt->getHeaderLen(),
buf_ptr + buf.getLength());
return (MySqlBinding::createBlob(blob.begin(), blob.end()));
if (option->formatted_value_.empty() && (opt->len() > opt->getHeaderLen())) {
OutputBuffer buf(opt->len());
opt->pack(buf);
- const char* buf_ptr = static_cast<const char*>(buf.getData());
+ const uint8_t* buf_ptr = buf.getData();
std::vector<uint8_t> blob(buf_ptr + opt->getHeaderLen(),
buf_ptr + buf.getLength());
bindings.addTempBinary(blob);
-// Copyright (C) 2011-2020 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2011-2024 Internet Systems Consortium, Inc. ("ISC")
//
// 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
// identical, then check that the data is identical as well.
EXPECT_EQ(msgbuf_->getLength(), length);
EXPECT_TRUE(equal(receive_buffer_, (receive_buffer_ + length - 1),
- static_cast<const uint8_t*>(msgbuf_->getData())));
+ msgbuf_->getData()));
// Return a message back to the IOFetch object.
if (!bad_qid) {
receive_buffer_[2] = receive_buffer_[3] = 0;
EXPECT_TRUE(equal((receive_buffer_ + 2), (receive_buffer_ + cumulative_ - 2),
- static_cast<const uint8_t*>(msgbuf_->getData())));
+ msgbuf_->getData()));
// ... and return a message back. This has to be preceded by a two-byte
// count field.
result_buff_->writeUint8At(return_data_[0], 0);
result_buff_->writeUint8At(return_data_[1], 1);
}
- const uint8_t* start = static_cast<const uint8_t*>(result_buff_->getData());
+ const uint8_t* start = result_buff_->getData();
EXPECT_TRUE(equal(return_data_.begin(), return_data_.end(), start));
}
}
-// Copyright (C) 2011-2021 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2011-2024 Internet Systems Consortium, Inc. ("ISC")
//
// 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
EXPECT_EQ(PACKET_SIZE, expected);
EXPECT_EQ(2, outbuff->getLength());
- const uint8_t* dataptr = static_cast<const uint8_t*>(outbuff->getData());
+ const uint8_t* dataptr = outbuff->getData();
EXPECT_TRUE(equal(inbuff + 2, inbuff + cumulative, dataptr));
// And add the remaining data. Remember that "inbuff" is "PACKET_SIZE + 2"
EXPECT_EQ(0, offset);
EXPECT_EQ(PACKET_SIZE, expected);
EXPECT_EQ(PACKET_SIZE, outbuff->getLength());
- dataptr = static_cast<const uint8_t*>(outbuff->getData());
+ dataptr = outbuff->getData();
EXPECT_TRUE(equal(inbuff + 2, inbuff + cumulative, dataptr));
}
EXPECT_EQ(sizeof(INBOUND_DATA) + 2, server_cb.length());
// ... and that what was sent is what was received.
- const uint8_t* received = static_cast<const uint8_t*>(client_buffer->getData());
+ const uint8_t* received = client_buffer->getData();
EXPECT_TRUE(equal(INBOUND_DATA, (INBOUND_DATA + (sizeof(INBOUND_DATA) - 1)),
received));
-// Copyright (C) 2011-2021 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2011-2024 Internet Systems Consortium, Inc. ("ISC")
//
// 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
EXPECT_EQ(PACKET_SIZE, expected);
EXPECT_EQ(2, outbuff->getLength());
- const uint8_t* dataptr = static_cast<const uint8_t*>(outbuff->getData());
+ const uint8_t* dataptr = outbuff->getData();
EXPECT_TRUE(equal(inbuff + 2, inbuff + cumulative, dataptr));
// And add the remaining data. Remember that "inbuff" is "PACKET_SIZE + 2"
EXPECT_EQ(0, offset);
EXPECT_EQ(PACKET_SIZE, expected);
EXPECT_EQ(PACKET_SIZE, outbuff->getLength());
- dataptr = static_cast<const uint8_t*>(outbuff->getData());
+ dataptr = outbuff->getData();
EXPECT_TRUE(equal(inbuff + 2, inbuff + cumulative, dataptr));
}
EXPECT_EQ(sizeof(INBOUND_DATA) + 2, server_cb.length());
// ... and that what was sent is what was received.
- const uint8_t* received = static_cast<const uint8_t*>(client_buffer->getData());
+ const uint8_t* received = client_buffer->getData();
EXPECT_TRUE(equal(INBOUND_DATA, (INBOUND_DATA + (sizeof(INBOUND_DATA) - 1)),
received));
-// Copyright (C) 2011-2020 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2011-2024 Internet Systems Consortium, Inc. ("ISC")
//
// 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
EXPECT_EQ(0, offset);
EXPECT_EQ(sizeof(inbuff), expected);
- const uint8_t* dataptr = static_cast<const uint8_t*>(outbuff->getData());
+ const uint8_t* dataptr = outbuff->getData();
EXPECT_TRUE(equal(inbuff, inbuff + sizeof(inbuff) - 1, dataptr));
}
}
EXPECT_EQ(client_cb.getLength(), client_buffer->getLength());
// ...and check that the data was copied to the output client buffer.
- const char* client_char_data = static_cast<const char*>(client_buffer->getData());
+ const uint8_t* client_char_data = client_buffer->getData();
EXPECT_TRUE(equal(&data[0], &data[client_cb.getLength() - 1], client_char_data));
// Close client and server.
size_t len)
{
ASSERT_EQ(len, buf.getLength());
- checkData(static_cast<const uint8_t*>(buf.getData()), expected,
- len);
+ checkData(buf.getData(), expected, len);
}
/// @brief Hash with the convenience functions
size_t len)
{
ASSERT_EQ(len, buf.getLength());
- checkData(static_cast<const uint8_t*>(buf.getData()), expected,
- len);
+ checkData(buf.getData(), expected, len);
}
/// @brief Sign and verify with the convenience functions
}
// Create new option with data starting from offset and
// containing truncated length.
- const uint8_t* data = static_cast<const uint8_t*>(buf.getData());
+ const uint8_t* data = buf.getData();
data += header_len;
OptionPtr new_option(new Option(candidate->getUniverse(),
candidate->getType(),
-// Copyright (C) 2014-2023 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2014-2024 Internet Systems Consortium, Inc. ("ISC")
//
// 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
void append(const char* data, const size_t len) {
data_.insert(data_.end(), data, data + len);
}
+ void append(const uint8_t* data, const size_t len) {
+ data_.insert(data_.end(), data, data + len);
+ }
void append(InputIterator data, const size_t len) {
data_.insert(data_.end(), data, data + len);
}
alpn_id_tuple.pack(out_buf);
}
- svc_param_val_tuple.append(static_cast<const char*>(out_buf.getData()), out_buf.getLength());
+ svc_param_val_tuple.append(out_buf.getData(), out_buf.getLength());
svc_params_map_.insert(std::make_pair(1, svc_param_val_tuple));
out_buf.clear();
}
}
out_buf.writeUint16(port);
- svc_param_val_tuple.append(static_cast<const char*>(out_buf.getData()), out_buf.getLength());
+ svc_param_val_tuple.append(out_buf.getData(), out_buf.getLength());
out_buf.clear();
svc_params_map_.insert(std::make_pair(3, svc_param_val_tuple));
}
-// Copyright (C) 2015-2016 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2015-2024 Internet Systems Consortium, Inc. ("ISC")
//
// 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
// Convert wire-format Pkt4 data in the form of OptionBuffer.
Pkt4::pack();
OutputBuffer& buf = getBuffer();
- const uint8_t* ptr = static_cast<const uint8_t*>(buf.getData());
+ const uint8_t* ptr = buf.getData();
OptionBuffer msg(ptr, ptr + buf.getLength());
// Build the DHCPv4 Message option for the DHCPv6 message, and pack the
memset(&v, 0, sizeof(v));
// iov_base field is of void * type. We use it for packet
// transmission, so this buffer will not be modified.
- v.iov_base = const_cast<void *>(pkt->getBuffer().getData());
+ v.iov_base = const_cast<void *>(pkt->getBuffer().getDataAsVP());
v.iov_len = pkt->getBuffer().getLength();
m.msg_iov = &v;
m.msg_iovlen = 1;
// to assign const void* to void*.
struct iovec v;
memset(&v, 0, sizeof(v));
- v.iov_base = const_cast<void *>(pkt->getBuffer().getData());
+ v.iov_base = const_cast<void *>(pkt->getBuffer().getDataAsVP());
v.iov_len = pkt->getBuffer().getLength();
m.msg_iov = &v;
m.msg_iovlen = 1;
-// Copyright (C) 2013-2022 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2013-2024 Internet Systems Consortium, Inc. ("ISC")
//
// 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
// 4 bytes of source address and 4 bytes of destination address.
// The IPPROTO_UDP and udp_len are also added up to the checksum.
uint16_t pseudo_hdr_checksum =
- calcChecksum(static_cast<const uint8_t*>(out_buf.getData()) + out_buf.getLength() - 8,
+ calcChecksum(out_buf.getData() + out_buf.getLength() - 8,
8, IPPROTO_UDP + udp_len);
// Calculate IP header checksum.
- uint16_t ip_checksum = ~calcChecksum(static_cast<const uint8_t*>(out_buf.getData())
+ uint16_t ip_checksum = ~calcChecksum(out_buf.getData()
+ out_buf.getLength() - 20, 20);
// Write checksum in the IP header. The offset of the checksum is 10 bytes
// back from the tail of the current buffer.
// tail of the current buffer. These 6 bytes contain source and destination port
// as well as the length of the header.
uint16_t udp_checksum =
- ~calcChecksum(static_cast<const uint8_t*>(out_buf.getData()) + out_buf.getLength() - 6, 6,
- calcChecksum(static_cast<const uint8_t*>(pkt->getBuffer().getData()),
+ ~calcChecksum(out_buf.getData() + out_buf.getLength() - 6, 6,
+ calcChecksum(pkt->getBuffer().getData(),
pkt->getBuffer().getLength(),
pseudo_hdr_checksum));
// Write UDP checksum.
-// Copyright (C) 2014-2021 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2014-2024 Internet Systems Consortium, Inc. ("ISC")
//
// 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
OutputBuffer out_buf(10);
ASSERT_NO_THROW(tuple.pack(out_buf));
ASSERT_EQ(1, out_buf.getLength());
- const uint8_t* zero_len = static_cast<const uint8_t*>(out_buf.getData());
+ const uint8_t* zero_len = out_buf.getData();
ASSERT_EQ(0, *zero_len);
// Reset the output buffer for another test.
out_buf.clear();
ASSERT_EQ(101, out_buf.getLength());
// Get the rendered data into the vector for convenience.
std::vector<uint8_t>
- render_data(static_cast<const uint8_t*>(out_buf.getData()),
- static_cast<const uint8_t*>(out_buf.getData()) + 101);
+ render_data(out_buf.getData(), out_buf.getData() + 101);
// The first byte is a length byte. It should hold the length of 100.
EXPECT_EQ(100, render_data[0]);
// Verify that the rendered data is correct.
// opaque data length, the remaining bytes hold the actual data.
ASSERT_EQ(256, out_buf.getLength());
// Check that the data is correct.
- render_data.assign(static_cast<const uint8_t*>(out_buf.getData()),
- static_cast<const uint8_t*>(out_buf.getData()) + 256);
+ render_data.assign(out_buf.getData(), out_buf.getData() + 256);
EXPECT_EQ(255, render_data[0]);
EXPECT_TRUE(std::equal(render_data.begin() + 1, render_data.end(),
data.begin()));
OutputBuffer out_buf(10);
ASSERT_NO_THROW(tuple.pack(out_buf));
ASSERT_EQ(2, out_buf.getLength());
- const uint16_t* zero_len = static_cast<const uint16_t*>(out_buf.getData());
- ASSERT_EQ(0, *zero_len);
+ const uint8_t* out_data = out_buf.getData();
+ ASSERT_LE(sizeof(uint16_t), out_buf.getLength());
+ ASSERT_EQ(0, out_data[0]);
+ ASSERT_EQ(0, out_data[1]);
// Reset the output buffer for another test.
out_buf.clear();
// Set the data for tuple.
ASSERT_EQ(514, out_buf.getLength());
// Get the rendered data into the vector for convenience.
std::vector<uint8_t>
- render_data(static_cast<const uint8_t*>(out_buf.getData()),
- static_cast<const uint8_t*>(out_buf.getData()) + 514);
+ render_data(out_buf.getData(), out_buf.getData() + 514);
// The first two bytes hold the length of 512.
uint16_t len = (render_data[0] << 8) + render_data[1];
EXPECT_EQ(512, len);
-// Copyright (C) 2011-2017 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2011-2024 Internet Systems Consortium, Inc. ("ISC")
//
// 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
/// @param expected_type expected option type
void checkOutputBuffer(uint16_t expected_type) {
// Check if pack worked properly:
- const uint8_t* out = static_cast<const uint8_t*>(out_buf_.getData());
+ const uint8_t* out = out_buf_.getData();
// - if option type is correct
EXPECT_EQ(expected_type, out[0]*256 + out[1]);
ASSERT_EQ(expected_vec.size(), buf.getLength());
// Check that the generated wire format is correct.
- const uint8_t* data = static_cast<const uint8_t*>(buf.getData());
+ const uint8_t* data = buf.getData();
std::vector<uint8_t> vec(data, data + buf.getLength());
ASSERT_TRUE(std::equal(vec.begin(), vec.end(), expected_vec.begin()));
}
-// Copyright (C) 2015-2023 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2015-2024 Internet Systems Consortium, Inc. ("ISC")
//
// 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
0x66, 0x6F, 0x6F // foo
};
// Compare the buffer with reference data.
- EXPECT_EQ(0, memcmp(static_cast<const void*>(ref),
- static_cast<const void*>(buf.getData()),
- buf.getLength()));
+ EXPECT_EQ(0, memcmp(ref, buf.getData(), buf.getLength()));
}
// Check that the DHCPv4 option is rendered to the buffer in wire format,
0x66, 0x6F, 0x6F // foo
};
// Compare the buffer with reference data.
- EXPECT_EQ(0, memcmp(static_cast<const void*>(ref),
- static_cast<const void*>(buf.getData()),
- buf.getLength()));
+ EXPECT_EQ(0, memcmp(ref, buf.getData(), buf.getLength()));
}
// Check that the DHCPv6 option is rendered to the buffer in wire format.
0x66, 0x6F, 0x6F // foo
};
// Compare the buffer with reference data.
- EXPECT_EQ(0, memcmp(static_cast<const void*>(ref),
- static_cast<const void*>(buf.getData()),
- buf.getLength()));
+ EXPECT_EQ(0, memcmp(ref, buf.getData(), buf.getLength()));
}
// This function checks that the DHCPv4 option with two opaque data tuples
-// Copyright (C) 2011-2023 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2011-2024 Internet Systems Consortium, Inc. ("ISC")
//
// 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
opt->pack(outBuf_);
EXPECT_EQ(11, outBuf_.getLength());
- const uint8_t* out = static_cast<const uint8_t*>(outBuf_.getData());
+ const uint8_t* out = outBuf_.getData();
EXPECT_EQ(out[0], 333 / 256); // Type
EXPECT_EQ(out[1], 333 % 256);
// Check if pack worked properly:
// If option type is correct
- const uint8_t* out = static_cast<const uint8_t*>(outBuf_.getData());
+ const uint8_t* out = outBuf_.getData();
EXPECT_EQ(D6O_CLIENTID, out[0] * 256 + out[1]);
opt1->setData(buf_.begin(), buf_.end());
opt1->pack(outBuf_);
ASSERT_EQ(outBuf_.getLength() - opt1->getHeaderLen(), buf_.size());
- const uint8_t* test_data = static_cast<const uint8_t*>(outBuf_.getData());
+ const uint8_t* test_data = outBuf_.getData();
EXPECT_TRUE(0 == memcmp(&buf_[0], test_data + opt1->getHeaderLen(),
buf_.size()));
opt2->setData(buf_.begin(), buf_.end());
opt2->pack(outBuf_);
ASSERT_EQ(outBuf_.getLength() - opt1->getHeaderLen(), buf_.size());
- test_data = static_cast<const uint8_t*>(outBuf_.getData());
+ test_data = outBuf_.getData();
EXPECT_TRUE(0 == memcmp(&buf_[0], test_data + opt1->getHeaderLen(),
buf_.size()));
}
-// Copyright (C) 2014-2023 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2014-2024 Internet Systems Consortium, Inc. ("ISC")
//
// 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
0x66, 0x6F, 0x6F // foo
};
// Compare the buffer with reference data.
- EXPECT_EQ(0, memcmp(static_cast<const void*>(ref),
- static_cast<const void*>(buf.getData()), 26));
+ EXPECT_EQ(0, memcmp(ref, buf.getData(), 26));
}
// Check that the DHCPv6 option is rendered to the buffer in wire format.
0x66, 0x6F, 0x6F // foo
};
// Compare the buffer with reference data.
- EXPECT_EQ(0, memcmp(static_cast<const void*>(ref),
- static_cast<const void*>(buf.getData()),
- buf.getLength()));
+ EXPECT_EQ(0, memcmp(ref, buf.getData(), buf.getLength()));
}
// This function checks that the DHCPv4 option with two opaque data tuples
// Redundant but MUCH easier for debug in gdb
const uint8_t* exp = &expectedFormat[0];
- const uint8_t* got = static_cast<const uint8_t*>(pkt->getBuffer().getData());
+ const uint8_t* got = pkt->getBuffer().getData();
EXPECT_EQ(0, memcmp(exp, got, Pkt4::DHCPV4_PKT_HDR_LEN));
}
);
// CHADDR starts at offset 28 in DHCP packet
- const uint8_t* ptr =
- static_cast<const uint8_t*>(pkt->getBuffer().getData()) + 28;
+ const uint8_t* ptr = pkt->getBuffer().getData() + 28;
EXPECT_EQ(0, memcmp(ptr, expectedChaddr, Pkt4::MAX_CHADDR_LEN));
);
// SNAME starts at offset 44 in DHCP packet
- const uint8_t* ptr =
- static_cast<const uint8_t*>(pkt->getBuffer().getData()) + 44;
+ const uint8_t* ptr = pkt->getBuffer().getData() + 44;
EXPECT_EQ(0, memcmp(ptr, sname, Pkt4::MAX_SNAME_LEN));
pkt.reset();
);
// FILE starts at offset 108 in DHCP packet.
- const uint8_t* ptr =
- static_cast<const uint8_t*>(pkt->getBuffer().getData()) + 108;
+ const uint8_t* ptr = pkt->getBuffer().getData() + 108;
EXPECT_EQ(0, memcmp(ptr, file, Pkt4::MAX_FILE_LEN));
pkt.reset();
buf.getLength());
// That that this extra data actually contain our options
- const uint8_t* ptr = static_cast<const uint8_t*>(buf.getData());
+ const uint8_t* ptr = buf.getData();
// Rewind to end of fixed part.
ptr += Pkt4::DHCPV4_PKT_HDR_LEN + sizeof(DHCP_OPTIONS_COOKIE);
DHO_ROOT_PATH, 4, 'n', 'o', 'n', 'e',
};
- const uint8_t* packed = static_cast<const uint8_t*>(pkt->getBuffer().getData());
+ const uint8_t* packed = pkt->getBuffer().getData();
int packed_len = pkt->getBuffer().getLength();
// Packed message options should be 3 bytes smaller than original onwire data.
// The iovec structure holds the packet data.
struct iovec v;
memset(&v, 0, sizeof(v));
- v.iov_base = const_cast<void *>(test_message_->getBuffer().getData());
+ v.iov_base = const_cast<void *>(test_message_->getBuffer().getDataAsVP());
v.iov_len = test_message_->getBuffer().getLength();
// Assign the iovec to msghdr structure.
m.msg_iov = &v;
-// Copyright (C) 2013-2022 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2013-2024 Internet Systems Consortium, Inc. ("ISC")
//
// 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
// Copy the wire-ized request to callback. This way we know after
// send completes what we sent (or attempted to send).
- send_callback_->putData(static_cast<const uint8_t*>(ncr_buffer.getData()),
- ncr_buffer.getLength());
+ send_callback_->putData(ncr_buffer.getData(), ncr_buffer.getLength());
// Call the socket's asynchronous send, passing our callback
socket_->asyncSend(send_callback_->getData(), send_callback_->getPutLen(),
LibDHCP::packOptions6(buf, relay.options_);
if (buf.getLength() > 0) {
- const uint8_t* cp = static_cast<const uint8_t*>(buf.getData());
+ const uint8_t* cp = buf.getData();
std::vector<uint8_t> bytes;
std::stringstream ss;
// option and store it in the database as a blob.
OutputBuffer buf(opt_desc.option_->len());
opt_desc.option_->pack(buf);
- const char* buf_ptr = static_cast<const char*>(buf.getData());
+ const uint8_t* buf_ptr = buf.getData();
value_.assign(buf_ptr + opt_desc.option_->getHeaderLen(),
buf_ptr + buf.getLength());
value_len_ = value_.size();
// option and store it in the database as a BYTEA.
OutputBuffer buf(opt_desc.option_->len());
opt_desc.option_->pack(buf);
- const char* buf_ptr = static_cast<const char*>(buf.getData());
+ const uint8_t* buf_ptr = buf.getData();
value_.assign(buf_ptr + opt_desc.option_->getHeaderLen(),
buf_ptr + buf.getLength());
value_len_ = value_.size();
-// Copyright (C) 2015-2023 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2015-2024 Internet Systems Consortium, Inc. ("ISC")
//
// 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
// Make a wire representation of the DHCPv4 message.
pkt->pack();
OutputBuffer& output_buffer = pkt->getBuffer();
- const uint8_t* data = static_cast<const uint8_t*>(output_buffer.getData());
+ const uint8_t* data = output_buffer.getData();
OptionBuffer option_buffer(data, data + output_buffer.getLength());
// Create the DHCPv4 Message option holding the created message.
buf.clear();
ASSERT_NO_THROW(pkt->pack());
- ASSERT_NE(-1, ::send(ipc_src.getSocketFd(), buf.getData(),
+ ASSERT_NE(-1, ::send(ipc_src.getSocketFd(), buf.getDataAsVP(),
buf.getLength(), 0));
// Call receive with a timeout. The data should appear on the socket
-// Copyright (C) 2012-2020 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2012-2024 Internet Systems Consortium, Inc. ("ISC")
//
// 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
// Copy wire data of the name
isc::util::OutputBuffer ob(0);
n_maxlabel.toWire(ob);
- expected_data7.insert(expected_data7.end(),
- static_cast<const uint8_t*>(ob.getData()),
- static_cast<const uint8_t*>(ob.getData()) +
- ob.getLength());
+ expected_data7.insert(expected_data7.end(), ob.getData(),
+ ob.getData() + ob.getLength());
expected.push_back(DataPair(expected_data7.size(), &expected_data7[0]));
// For each data set, serialize the labels and compare the data to the
/// // pass the buffer to a DNS message object to construct a wire-format
/// // DNS message.
/// struct sockaddr to;
-/// sendto(s, buffer.getData(), buffer.getLength(), 0, &to, sizeof(to));
+/// sendto(s, buffer.getDataAsVP(), buffer.getLength(), 0, &to, sizeof(to));
/// \endcode
///
/// where the \c getData() method gives a reference to the internal memory
//@{
/// \brief Constructor from the initial size of the buffer.
///
- /// \param len The initial length of the buffer in bytes.
- OutputBuffer(size_t len) :
- buffer_(NULL),
- size_(0),
- allocated_(len)
+ /// \param len The initial allocated length of the buffer in bytes.
+ OutputBuffer(size_t len) : buffer_()
{
- // We use malloc and free instead of C++ new[] and delete[].
- // This way we can use realloc, which may in fact do it without a copy.
- if (allocated_ != 0) {
- buffer_ = static_cast<uint8_t*>(malloc(allocated_));
- if (buffer_ == NULL) {
- throw std::bad_alloc();
- }
+ if (len != 0) {
+ buffer_.reserve(len);
}
}
/// size_ <= allocated_, and that if allocated_ is greater than zero,
/// buffer_ points to valid memory.
OutputBuffer(const OutputBuffer& other) :
- buffer_(NULL),
- size_(other.size_),
- allocated_(other.allocated_)
+ buffer_(other.buffer_)
{
- if (allocated_ != 0) {
- buffer_ = static_cast<uint8_t*>(malloc(allocated_));
- if (buffer_ == NULL) {
- throw std::bad_alloc();
- }
- static_cast<void>(std::memmove(buffer_, other.buffer_, other.size_));
+ size_t len = other.buffer_.capacity();
+ if (len != 0) {
+ buffer_.reserve(len);
}
}
/// \brief Destructor
~OutputBuffer() {
- free(buffer_);
+ buffer_.clear();
}
//@}
OutputBuffer& operator =(const OutputBuffer& other) {
if (this != &other) {
// Not self-assignment.
- if (other.allocated_ != 0) {
-
- // There is something in the source object, so allocate memory
- // and copy it. The pointer to the allocated memory is placed
- // in a temporary variable so that if the allocation fails and
- // an exception is thrown, the destination object ("this") is
- // unchanged.
- uint8_t* newbuff = static_cast<uint8_t*>(malloc(other.allocated_));
- if (newbuff == NULL) {
- throw std::bad_alloc();
- }
-
- // Memory allocated, update the source object and copy data
- // across.
- free(buffer_);
- buffer_ = newbuff;
- static_cast<void>(std::memmove(buffer_, other.buffer_, other.size_));
-
- } else {
-
- // Nothing allocated in the source object, so zero the buffer
- // in the destination.
- free(buffer_);
- buffer_ = NULL;
+ buffer_ = other.buffer_;
+ size_t len = other.buffer_.capacity();
+ if (len != 0) {
+ buffer_.reserve(len);
}
-
- // Update the other member variables.
- size_ = other.size_;
- allocated_ = other.allocated_;
}
return (*this);
}
///
//@{
/// \brief Return the current capacity of the buffer.
- size_t getCapacity() const { return (allocated_); }
+ size_t getCapacity() const {
+ return (buffer_.capacity());
+ }
+
/// \brief Return a pointer to the head of the data stored in the buffer.
///
/// The caller can assume that the subsequent \c getLength() bytes are
///
/// Note: The pointer returned by this method may be invalidated after a
/// subsequent write operation.
- const void* getData() const { return (buffer_); }
+ const uint8_t* getData() const {
+ if (!buffer_.empty()) {
+ return (&buffer_[0]);
+ } else {
+ return (0);
+ }
+ }
+
+ /// \brief Return data as a pointer to void.
+ const void* getDataAsVP() const {
+ return (static_cast<const void*>(getData()));
+ }
+
/// \brief Return the length of data written in the buffer.
- size_t getLength() const { return (size_); }
+ size_t getLength() const {
+ return (buffer_.size());
+ }
+
/// \brief Return the value of the buffer at the specified position.
///
/// \c pos must specify the valid position of the buffer; otherwise an
///
/// \param pos The position in the buffer to be returned.
uint8_t operator[](size_t pos) const {
- if (pos >= size_) {
+ if (pos >= buffer_.size()) {
isc_throw(InvalidBufferPosition,
- "[]: pos (" << pos << ") >= size (" << size_ << ")");
+ "[]: pos (" << pos << ") >= size (" << buffer_.size() << ")");
}
return (buffer_[pos]);
}
+
+ /// \brief Return the buffer.
+ const std::vector<uint8_t>& getVector() const {
+ return (buffer_);
+ }
//@}
///
/// that is to be filled in later, e.g, by \ref writeUint16At().
/// \param len The length of the gap to be inserted in bytes.
void skip(size_t len) {
- ensureAllocated(size_ + len);
- size_ += len;
+ buffer_.resize(buffer_.size() + len);
}
/// \brief Trim the specified length of data from the end of the buffer.
///
/// \param len The length of data that should be trimmed.
void trim(size_t len) {
- if (len > size_) {
+ if (len > buffer_.size()) {
isc_throw(OutOfRange, "trimming too large from output buffer");
}
- size_ -= len;
+ buffer_.resize(buffer_.size() - len);
}
- /// \brief Clear buffer content.
- ///
- /// This method can be used to re-initialize and reuse the buffer without
- /// constructing a new one. Note it must keep current content.
- void clear() { size_ = 0; }
- /// \brief Wipe buffer content.
- ///
- /// This method is the destructive alternative to clear().
- void wipe() {
- if (buffer_ != NULL) {
- static_cast<void>(std::memset(buffer_, 0, allocated_));
- }
- size_ = 0;
+ /// \brief Clear buffer content.
+ void clear() {
+ buffer_.clear();
}
/// \brief Write an unsigned 8-bit integer into the buffer.
///
/// \param data The 8-bit integer to be written into the buffer.
void writeUint8(uint8_t data) {
- ensureAllocated(size_ + 1);
- buffer_[size_ ++] = data;
+ buffer_.push_back(data);
}
/// \brief Write an unsigned 8-bit integer into the buffer.
/// \param data The 8-bit integer to be written into the buffer.
/// \param pos The position in the buffer to write the data.
void writeUint8At(uint8_t data, size_t pos) {
- if (pos + sizeof(data) > size_) {
+ if (pos + sizeof(data) > buffer_.size()) {
isc_throw(InvalidBufferPosition, "write at invalid position");
}
buffer_[pos] = data;
///
/// \param data The 16-bit integer to be written into the buffer.
void writeUint16(uint16_t data) {
- ensureAllocated(size_ + sizeof(data));
- buffer_[size_ ++] = static_cast<uint8_t>((data & 0xff00U) >> 8);
- buffer_[size_ ++] = static_cast<uint8_t>(data & 0x00ffU);
+ buffer_.push_back(static_cast<uint8_t>((data & 0xff00U) >> 8));
+ buffer_.push_back(static_cast<uint8_t>(data & 0x00ffU));
}
/// \brief Write an unsigned 16-bit integer in host byte order at the
/// \param data The 16-bit integer to be written into the buffer.
/// \param pos The beginning position in the buffer to write the data.
void writeUint16At(uint16_t data, size_t pos) {
- if (pos + sizeof(data) > size_) {
+ if (pos + sizeof(data) > buffer_.size()) {
isc_throw(InvalidBufferPosition, "write at invalid position");
}
///
/// \param data The 32-bit integer to be written into the buffer.
void writeUint32(uint32_t data) {
- ensureAllocated(size_ + sizeof(data));
- buffer_[size_ ++] = static_cast<uint8_t>((data & 0xff000000) >> 24);
- buffer_[size_ ++] = static_cast<uint8_t>((data & 0x00ff0000) >> 16);
- buffer_[size_ ++] = static_cast<uint8_t>((data & 0x0000ff00) >> 8);
- buffer_[size_ ++] = static_cast<uint8_t>(data & 0x000000ff);
+ buffer_.push_back(static_cast<uint8_t>((data & 0xff000000) >> 24));
+ buffer_.push_back(static_cast<uint8_t>((data & 0x00ff0000) >> 16));
+ buffer_.push_back(static_cast<uint8_t>((data & 0x0000ff00) >> 8));
+ buffer_.push_back(static_cast<uint8_t>(data & 0x000000ff));
}
/// \brief Write an unsigned 64-bit integer in host byte order
///
/// \param data The 64-bit integer to be written into the buffer.
void writeUint64(uint64_t data) {
- ensureAllocated(size_ + sizeof(data));
- buffer_[size_ ++] = static_cast<uint8_t>((data & 0xff00000000000000) >> 56);
- buffer_[size_ ++] = static_cast<uint8_t>((data & 0x00ff000000000000) >> 48);
- buffer_[size_ ++] = static_cast<uint8_t>((data & 0x0000ff0000000000) >> 40);
- buffer_[size_ ++] = static_cast<uint8_t>((data & 0x000000ff00000000) >> 32);
- buffer_[size_ ++] = static_cast<uint8_t>((data & 0x00000000ff000000) >> 24);
- buffer_[size_ ++] = static_cast<uint8_t>((data & 0x0000000000ff0000) >> 16);
- buffer_[size_ ++] = static_cast<uint8_t>((data & 0x000000000000ff00) >> 8);
- buffer_[size_ ++] = static_cast<uint8_t>(data & 0x00000000000000ff);
+ buffer_.push_back(static_cast<uint8_t>((data & 0xff00000000000000) >> 56));
+ buffer_.push_back(static_cast<uint8_t>((data & 0x00ff000000000000) >> 48));
+ buffer_.push_back(static_cast<uint8_t>((data & 0x0000ff0000000000) >> 40));
+ buffer_.push_back(static_cast<uint8_t>((data & 0x000000ff00000000) >> 32));
+ buffer_.push_back(static_cast<uint8_t>((data & 0x00000000ff000000) >> 24));
+ buffer_.push_back(static_cast<uint8_t>((data & 0x0000000000ff0000) >> 16));
+ buffer_.push_back(static_cast<uint8_t>((data & 0x000000000000ff00) >> 8));
+ buffer_.push_back(static_cast<uint8_t>(data & 0x00000000000000ff));
}
/// \brief Copy an arbitrary length of data into the buffer.
return;
}
- ensureAllocated(size_ + len);
- static_cast<void>(std::memmove(buffer_ + size_, data, len));
- size_ += len;
+ const uint8_t* ptr = static_cast<const uint8_t*>(data);
+ buffer_.insert(buffer_.end(), ptr, ptr + len);
}
//@}
private:
/// The actual data
- uint8_t* buffer_;
- /// How many bytes are used
- size_t size_;
- /// How many bytes do we have preallocated (eg. the capacity)
- size_t allocated_;
-
- /// \brief Ensure buffer is appropriate size
- ///
- /// Checks that the buffer equal to or larger than the size given as
- /// argument and extends it to at least that size if not.
- ///
- /// \param needed_size The number of bytes required in the buffer
- void ensureAllocated(size_t needed_size) {
- if (allocated_ < needed_size) {
- // Guess some bigger size
- size_t new_size = (allocated_ == 0) ? 1024 : allocated_;
- while (new_size < needed_size) {
- new_size *= 2;
- }
- // Allocate bigger space. Note that buffer_ may be NULL,
- // in which case realloc acts as malloc.
- uint8_t* new_buffer_(static_cast<uint8_t*>(realloc(buffer_,
- new_size)));
- if (new_buffer_ == NULL) {
- // If it fails, the original block is left intact by it
- throw std::bad_alloc();
- }
- buffer_ = new_buffer_;
- allocated_ = new_size;
- }
- }
+ std::vector<uint8_t> buffer_;
};
/// \brief Pointer-like types pointing to \c InputBuffer or \c OutputBuffer
-// Copyright (C) 2011-2021 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2011-2024 Internet Systems Consortium, Inc. ("ISC")
//
// 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
impl_->buf_.writeUint16At(impl_->buf_.getLength() - sizeof(uint16_t), 0);
const struct iovec iov[2] = {
- { const_cast<void*>(impl_->buf_.getData()), impl_->buf_.getLength() },
+ { const_cast<void*>(impl_->buf_.getDataAsVP()), impl_->buf_.getLength() },
{ const_cast<void*>(data), data_len }
};
const int cc = writev(impl_->fd_, iov, 2);
obuffer.writeUint8(1);
expected_size += sizeof(uint8_t);
EXPECT_EQ(expected_size, obuffer.getLength());
- cp = static_cast<const uint8_t*>(obuffer.getData());
+ cp = obuffer.getData();
EXPECT_EQ(1, *cp);
obuffer.writeUint16(data16);
expected_size += sizeof(data16);
- cp = static_cast<const uint8_t*>(obuffer.getData());
+ cp = obuffer.getData();
EXPECT_EQ(expected_size, obuffer.getLength());
EXPECT_EQ(2, *(cp + 1));
EXPECT_EQ(3, *(cp + 2));
obuffer.writeUint32(data32);
expected_size += sizeof(data32);
- cp = static_cast<const uint8_t*>(obuffer.getData());
+ cp = obuffer.getData();
EXPECT_EQ(expected_size, obuffer.getLength());
EXPECT_EQ(4, *(cp + 3));
EXPECT_EQ(5, *(cp + 4));
obuffer.writeData(testdata, sizeof(testdata));
expected_size += sizeof(testdata);
EXPECT_EQ(expected_size, obuffer.getLength());
- cp = static_cast<const uint8_t*>(obuffer.getData());
+ cp = obuffer.getData();
EXPECT_EQ(0, memcmp(cp + 7, testdata, sizeof(testdata)));
}
-TEST_F(BufferTest, outputBufferWriteat) {
+TEST_F(BufferTest, outputBufferWriteAt) {
obuffer.writeUint32(data32);
expected_size += sizeof(data32);
// overwrite 2nd byte
obuffer.writeUint8At(4, 1);
EXPECT_EQ(expected_size, obuffer.getLength()); // length shouldn't change
- const uint8_t* cp = static_cast<const uint8_t*>(obuffer.getData());
+ const uint8_t* cp = obuffer.getData();
EXPECT_EQ(4, *(cp + 1));
// overwrite 2nd and 3rd bytes
obuffer.writeUint16At(data16, 1);
EXPECT_EQ(expected_size, obuffer.getLength()); // length shouldn't change
- cp = static_cast<const uint8_t*>(obuffer.getData());
+ cp = obuffer.getData();
EXPECT_EQ(2, *(cp + 1));
EXPECT_EQ(3, *(cp + 2));
// overwrite 3rd and 4th bytes
obuffer.writeUint16At(data16, 2);
EXPECT_EQ(expected_size, obuffer.getLength());
- cp = static_cast<const uint8_t*>(obuffer.getData());
+ cp = obuffer.getData();
EXPECT_EQ(2, *(cp + 2));
EXPECT_EQ(3, *(cp + 3));
TEST_F(BufferTest, outputBufferReadAt) {
obuffer.writeData(testdata, sizeof(testdata));
- for (int i = 0; i < sizeof(testdata); i ++) {
+ for (size_t i = 0; i < sizeof(testdata); ++i) {
EXPECT_EQ(testdata[i], obuffer[i]);
}
EXPECT_THROW(obuffer[sizeof(testdata)], isc::util::InvalidBufferPosition);
}
TEST_F(BufferTest, outputBufferClear) {
- const uint8_t* cp;
-
obuffer.writeData(testdata, sizeof(testdata));
- cp = static_cast<const uint8_t*>(obuffer.getData());
+ const uint8_t* cp = obuffer.getData();
obuffer.clear();
EXPECT_EQ(0, obuffer.getLength());
- EXPECT_EQ(*cp, 1);
-}
-
-TEST_F(BufferTest, outputBufferWipe) {
- const uint8_t* cp;
-
- obuffer.writeData(testdata, sizeof(testdata));
- cp = static_cast<const uint8_t*>(obuffer.getData());
- obuffer.wipe();
- EXPECT_EQ(0, obuffer.getLength());
- EXPECT_EQ(*cp, 0);
-}
-
-TEST_F(BufferTest, emptyOutputBufferWipe) {
- ASSERT_NO_THROW(obuffer.wipe());
- EXPECT_EQ(0, obuffer.getLength());
+ EXPECT_FALSE(obuffer.getData());
}
TEST_F(BufferTest, outputBufferCopy) {
EXPECT_NO_THROW({
OutputBuffer copy(obuffer);
ASSERT_EQ(0, copy.getLength());
+ EXPECT_FALSE(copy.getData());
});
}
copy = obuffer;
});
ASSERT_EQ(0, copy.getLength());
- EXPECT_EQ(NULL, copy.getData());
+ EXPECT_EQ(0, copy.getData());
}
// Check assign to self doesn't break stuff
});
}
-TEST_F(BufferTest, inputBufferReadVectorAll) {
- std::vector<uint8_t> vec;
-
- // check that vector can read the whole buffer
- ibuffer.readVector(vec, 5);
-
- ASSERT_EQ(5, vec.size());
- EXPECT_EQ(0, memcmp(&vec[0], testdata, 5));
-
- // ibuffer is 5 bytes long. Can't read past it.
- EXPECT_THROW(
- ibuffer.readVector(vec, 1),
- isc::util::InvalidBufferPosition
- );
-}
-
TEST_F(BufferTest, inputBufferReadVectorChunks) {
std::vector<uint8_t> vec;
ibuffer.readVector(vec, 2)
);
- EXPECT_EQ(0, memcmp(&vec[0], testdata+3, 2));
+ ASSERT_EQ(2, vec.size());
+ EXPECT_EQ(0, memcmp(&vec[0], &testdata[3], 2));
}
// Tests whether uint64 can be written properly.
obuffer.writeUint64(val1);
ASSERT_EQ(sizeof(uint64_t), obuffer.getLength());
- cp = static_cast<const uint8_t*>(obuffer.getData());
+ cp = obuffer.getData();
EXPECT_TRUE(cp);
EXPECT_FALSE(memcmp(exp_val1, obuffer.getData(), sizeof(uint64_t)));
obuffer.writeUint64(val2);
ASSERT_EQ(sizeof(uint64_t), obuffer.getLength());
- cp = static_cast<const uint8_t*>(obuffer.getData());
+ cp = obuffer.getData();
EXPECT_TRUE(cp);
EXPECT_FALSE(memcmp(exp_val2, obuffer.getData(), sizeof(uint64_t)));
}
-// Copyright (C) 2011-2022 Internet Systems Consortium, Inc. ("ISC")
+// Copyright (C) 2011-2024 Internet Systems Consortium, Inc. ("ISC")
//
// 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
writeUint16(i16, test, sizeof(test));
// ... and compare
- const uint8_t* ref = static_cast<const uint8_t*>(buffer.getData());
+ const uint8_t* ref = buffer.getData();
EXPECT_EQ(ref[0], test[0]);
EXPECT_EQ(ref[1], test[1]);
}
projects / thirdparty / kea.git / commitdiff
