[#3211] More new getVector use cases

diff --git a/src/bin/dhcp4/tests/dhcp4to6_ipc_unittest.cc b/src/bin/dhcp4/tests/dhcp4to6_ipc_unittest.cc
index 713ccb8fe6140f83755db091f8deb09f1583e6ca..6cd510477ee269a75196bb7c59ddad99683ef07f 100644 (file)
--- a/src/bin/dhcp4/tests/dhcp4to6_ipc_unittest.cc
+++ b/src/bin/dhcp4/tests/dhcp4to6_ipc_unittest.cc
@@ -180,9 +180,7 @@ Dhcp4to6IpcTest::createDHCPv4MsgOption() const {
     Pkt4Ptr pkt(new Pkt4(DHCPREQUEST, 1234));
     // Make a wire representation of the DHCPv4 message.
     pkt->pack();
-    OutputBuffer& output_buffer = pkt->getBuffer();
-    const uint8_t* data = output_buffer.getData();
-    OptionBuffer option_buffer(data, data + output_buffer.getLength());
+    const OptionBuffer& option_buffer = pkt->getBuffer().getVector();
 
     // Create the DHCPv4 Message option holding the created message.
     OptionPtr opt_msg(new Option(Option::V6, D6O_DHCPV4_MSG, option_buffer));
@@ -334,9 +332,7 @@ TEST_F(Dhcp4to6IpcTest, process) {
     infreq->setCiaddr(IOAddress("192.0.1.2"));
     // Make a wire representation of the DHCPv4 message.
     infreq->pack();
-    OutputBuffer& output_buffer = infreq->getBuffer();
-    const uint8_t* data = output_buffer.getData();
-    OptionBuffer option_buffer(data, data + output_buffer.getLength());
+    const OptionBuffer& option_buffer = infreq->getBuffer().getVector();
 
     // Create the DHCPv4 Message option holding the created message.
     OptionPtr opt_msg(new Option(Option::V6, D6O_DHCPV4_MSG, option_buffer));

diff --git a/src/bin/dhcp6/dhcp6_srv.cc b/src/bin/dhcp6/dhcp6_srv.cc
index 58fb5c9b836de1914dbaaf65eb5afc3021aeb349..1dfc4aa98273a7e7565cba0d19bd1285092055c6 100644 (file)
--- a/src/bin/dhcp6/dhcp6_srv.cc
+++ b/src/bin/dhcp6/dhcp6_srv.cc
@@ -2345,10 +2345,7 @@ Dhcpv6Srv::createNameChangeRequests(const Pkt6Ptr& answer,
     // DHCID.
     OutputBuffer name_buf(1);
     opt_fqdn->packDomainName(name_buf);
-    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());
+    const std::vector<uint8_t>& buf_vec = name_buf.getVector();
     // Compute DHCID from Client Identifier and FQDN.
     isc::dhcp_ddns::D2Dhcid dhcid(*duid, buf_vec);
 

diff --git a/src/bin/dhcp6/tests/dhcp6to4_ipc_unittest.cc b/src/bin/dhcp6/tests/dhcp6to4_ipc_unittest.cc
index 42310716056db591ddc8e5baae82e6fb924c0569..4b453a54a91ca4ea93ccc6bde4dc1fb8969357e3 100644 (file)
--- a/src/bin/dhcp6/tests/dhcp6to4_ipc_unittest.cc
+++ b/src/bin/dhcp6/tests/dhcp6to4_ipc_unittest.cc
@@ -126,9 +126,7 @@ Dhcp6to4IpcTest::createDHCPv4MsgOption() const {
     Pkt4Ptr pkt(new Pkt4(DHCPREQUEST, 1234));
     // Make a wire representation of the DHCPv4 message.
     pkt->pack();
-    OutputBuffer& output_buffer = pkt->getBuffer();
-    const uint8_t* data = output_buffer.getData();
-    OptionBuffer option_buffer(data, data + output_buffer.getLength());
+    const OptionBuffer& option_buffer = pkt->getBuffer().getVector();
 
     // Create the DHCPv4 Message option holding the created message.
     OptionPtr opt_msg(new Option(Option::V6, D6O_DHCPV4_MSG, option_buffer));

diff --git a/src/bin/perfdhcp/test_control.cc b/src/bin/perfdhcp/test_control.cc
index ef420037e860684731efc1b6ac522d68af3f40b9..4e0f22e1d23f90e56e1c75e7f4735be29eb43d9a 100644 (file)
--- a/src/bin/perfdhcp/test_control.cc
+++ b/src/bin/perfdhcp/test_control.cc
@@ -630,10 +630,7 @@ TestControl::printTemplate(const uint8_t packet_type) const {
             template_packets_v4_.find(packet_type);
         if ((pkt_it != template_packets_v4_.end()) &&
             pkt_it->second) {
-            const util::OutputBuffer& out_buf(pkt_it->second->getBuffer());
-            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);
+            hex_buf = vector2Hex(pkt_it->second->getBuffer().getVector());
         }
     } else if (options_.getIpVersion() == 6) {
         if (packet_type == DHCPV6_REQUEST) {
@@ -643,10 +640,7 @@ TestControl::printTemplate(const uint8_t packet_type) const {
             template_packets_v6_.find(packet_type);
         if (pkt_it != template_packets_v6_.end() &&
             pkt_it->second) {
-            const util::OutputBuffer& out_buf(pkt_it->second->getBuffer());
-            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);
+            hex_buf = vector2Hex(pkt_it->second->getBuffer().getVector());
         }
     }
     std::cout << "xid-offset=" << getTransactionIdOffset(arg_idx) << std::endl;

diff --git a/src/lib/dhcp/pkt4o6.cc b/src/lib/dhcp/pkt4o6.cc
index 3c526aaf12eaee2b2392ca0b7a84e675fd922d2f..e30e032b6a58a28f10dfe7d1826f70c926ba3199 100644 (file)
--- a/src/lib/dhcp/pkt4o6.cc
+++ b/src/lib/dhcp/pkt4o6.cc
@@ -36,9 +36,7 @@ Pkt4o6::Pkt4o6(const Pkt4Ptr& pkt4, const Pkt6Ptr& pkt6)
 void Pkt4o6::pack() {
     // Convert wire-format Pkt4 data in the form of OptionBuffer.
     Pkt4::pack();
-    OutputBuffer& buf = getBuffer();
-    const uint8_t* ptr = buf.getData();
-    OptionBuffer msg(ptr, ptr + buf.getLength());
+    const OptionBuffer& msg = getBuffer().getVector();
 
     // Build the DHCPv4 Message option for the DHCPv6 message, and pack the
     // entire stuff.

diff --git a/src/lib/dhcp/tests/option6_pdexclude_unittest.cc b/src/lib/dhcp/tests/option6_pdexclude_unittest.cc
index 463fa47c7e88a2f509f63bd9e923e97cc482edf0..b9c49f747af6784b5a575f9bad81e71466c55b23 100644 (file)
--- a/src/lib/dhcp/tests/option6_pdexclude_unittest.cc
+++ b/src/lib/dhcp/tests/option6_pdexclude_unittest.cc
@@ -77,8 +77,8 @@ TEST(Option6PDExcludeTest, pack) {
 
     // Check that the generated wire format is correct.
     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()));
+    const std::vector<uint8_t>& vec = buf.getVector();
+    ASSERT_TRUE(std::equal(vec.cbegin(), vec.cend(), expected_vec.cbegin()));
 }
 
 // This test verifies parsing option wire format with subnet id of

diff --git a/src/lib/dhcp_ddns/ncr_msg.cc b/src/lib/dhcp_ddns/ncr_msg.cc
index 9b1e7bff4484a405a6a6c90978725407c26d3473..8a2b89f1e91895065a199f4a59efc59064bcceba 100644 (file)
--- a/src/lib/dhcp_ddns/ncr_msg.cc
+++ b/src/lib/dhcp_ddns/ncr_msg.cc
@@ -318,7 +318,7 @@ NameChangeRequest::fromFormat(const NameChangeFormat format,
             // NameChangeRequest instance.  Note the factory may throw
             // NcrMessageError.
             ncr = NameChangeRequest::fromJSON(string_data);
-        } catch (const isc::util::InvalidBufferPosition& ex) {
+        } catch (const isc::Exception& ex) {
             // Read error accessing data in InputBuffer.
             isc_throw(NcrMessageError, "fromFormat: buffer read error: "
                       << ex.what());

diff --git a/src/lib/dhcpsrv/tests/dhcp4o6_ipc_unittest.cc b/src/lib/dhcpsrv/tests/dhcp4o6_ipc_unittest.cc
index 69aae2bd14a7689f632412ddbeed617cfe53b3d1..e0f8973ad6cc474ea737965a0ccdcff32cf9d96f 100644 (file)
--- a/src/lib/dhcpsrv/tests/dhcp4o6_ipc_unittest.cc
+++ b/src/lib/dhcpsrv/tests/dhcp4o6_ipc_unittest.cc
@@ -226,9 +226,7 @@ Dhcp4o6IpcBaseTest::createDHCPv4MsgOption(TestIpc::EndpointType src) {
                          1234));
     // Make a wire representation of the DHCPv4 message.
     pkt->pack();
-    OutputBuffer& output_buffer = pkt->getBuffer();
-    const uint8_t* data = output_buffer.getData();
-    OptionBuffer option_buffer(data, data + output_buffer.getLength());
+    const OptionBuffer& option_buffer = pkt->getBuffer().getVector();
 
     // Create the DHCPv4 Message option holding the created message.
     OptionPtr opt_msg(new Option(Option::V6, D6O_DHCPV4_MSG, option_buffer));

diff --git a/src/lib/dns/tests/labelsequence_unittest.cc b/src/lib/dns/tests/labelsequence_unittest.cc
index ccc5c6e1539e6d9ce2b6946e8bd2068d370e39eb..1e8f232681ac4b1a5cc4e9090abf95c36b0ec229 100644 (file)
--- a/src/lib/dns/tests/labelsequence_unittest.cc
+++ b/src/lib/dns/tests/labelsequence_unittest.cc
@@ -816,8 +816,9 @@ TEST_F(LabelSequenceTest, serialize) {
     // Copy wire data of the name
     isc::util::OutputBuffer ob(0);
     n_maxlabel.toWire(ob);
-    expected_data7.insert(expected_data7.end(), ob.getData(),
-                          ob.getData() + ob.getLength());
+    expected_data7.insert(expected_data7.end(),
+                          ob.getVector().cbegin(),
+                          ob.getVector().cend());
     expected.push_back(DataPair(expected_data7.size(), &expected_data7[0]));
 
     // For each data set, serialize the labels and compare the data to the

diff --git a/src/lib/util/buffer.h b/src/lib/util/buffer.h
index 434448a618e840a996ca788d849fd2790ab7c974..318e7e686c693e0b7719b249ce8e7b0883ecdfa5 100644 (file)
--- a/src/lib/util/buffer.h
+++ b/src/lib/util/buffer.h
@@ -465,6 +465,8 @@ public:
     }
 
     /// \brief Return the buffer.
+    ///
+    /// \note The main use is to avoid a copy.
     const std::vector<uint8_t>& getVector() const {
         return (buffer_);
     }

diff --git a/src/lib/util/io/socketsession.cc b/src/lib/util/io/socketsession.cc
index 59e2983996d2de18bd1108d2586f1f9add8304a2..0b2196514751872237141ed803bf2281a41d54c0 100644 (file)
--- a/src/lib/util/io/socketsession.cc
+++ b/src/lib/util/io/socketsession.cc
@@ -425,7 +425,7 @@ SocketSessionReceiver::pop() {
         return (SocketSession(passed_sock.release(), family, type, protocol,
                               impl_->sa_local_, impl_->sa_remote_,
                               &impl_->data_buf_[0], data_len));
-    } catch (const InvalidBufferPosition& ex) {
+    } catch (const OutOfRange& ex) {
         // We catch the case where the given header is too short and convert
         // the exception to SocketSessionError.
         isc_throw(SocketSessionError, "bogus socket session header: " <<

diff --git a/src/lib/util/tests/buffer_unittest.cc b/src/lib/util/tests/buffer_unittest.cc
index 46706b179b758b82ddd6b3340ca06e8cb45d3505..cd6670085e0a5b5420808696a96ec4f7e0f97b39 100644 (file)
--- a/src/lib/util/tests/buffer_unittest.cc
+++ b/src/lib/util/tests/buffer_unittest.cc
@@ -86,29 +86,25 @@ TEST_F(BufferTest, inputBufferRead) {
 }
 
 TEST_F(BufferTest, inputBufferException) {
-    EXPECT_THROW(ibuffer.setPosition(6), isc::util::InvalidBufferPosition);
+    EXPECT_THROW(ibuffer.setPosition(6), isc::OutOfRange);
 
     ibuffer.setPosition(sizeof(testdata));
-    EXPECT_THROW(ibuffer.peekUint8(), isc::util::InvalidBufferPosition);
-    EXPECT_THROW(ibuffer.readUint8(), isc::util::InvalidBufferPosition);
+    EXPECT_THROW(ibuffer.peekUint8(), isc::OutOfRange);
+    EXPECT_THROW(ibuffer.readUint8(), isc::OutOfRange);
 
     ibuffer.setPosition(sizeof(testdata) - 1);
-    EXPECT_THROW(ibuffer.peekUint16(), isc::util::InvalidBufferPosition);
-    EXPECT_THROW(ibuffer.readUint16(), isc::util::InvalidBufferPosition);
+    EXPECT_THROW(ibuffer.peekUint16(), isc::OutOfRange);
+    EXPECT_THROW(ibuffer.readUint16(), isc::OutOfRange);
 
     ibuffer.setPosition(sizeof(testdata) - 3);
-    EXPECT_THROW(ibuffer.peekUint32(), isc::util::InvalidBufferPosition);
-    EXPECT_THROW(ibuffer.readUint32(), isc::util::InvalidBufferPosition);
+    EXPECT_THROW(ibuffer.peekUint32(), isc::OutOfRange);
+    EXPECT_THROW(ibuffer.readUint32(), isc::OutOfRange);
 
     ibuffer.setPosition(sizeof(testdata) - 4);
-    EXPECT_THROW(ibuffer.peekData(vdata, sizeof(vdata)),
-                 isc::util::InvalidBufferPosition);
-    EXPECT_THROW(ibuffer.readData(vdata, sizeof(vdata)),
-                 isc::util::InvalidBufferPosition);
-    EXPECT_THROW(ibuffer.peekVector(datav, sizeof(vdata)),
-                 isc::util::InvalidBufferPosition);
-    EXPECT_THROW(ibuffer.readVector(datav, sizeof(vdata)),
-                 isc::util::InvalidBufferPosition);
+    EXPECT_THROW(ibuffer.peekData(vdata, sizeof(vdata)), isc::OutOfRange);
+    EXPECT_THROW(ibuffer.readData(vdata, sizeof(vdata)), isc::OutOfRange);
+    EXPECT_THROW(ibuffer.peekVector(datav, sizeof(vdata)), isc::OutOfRange);
+    EXPECT_THROW(ibuffer.readVector(datav, sizeof(vdata)), isc::OutOfRange);
 }
 
 TEST_F(BufferTest, outputBufferExtend) {
@@ -149,6 +145,13 @@ TEST_F(BufferTest, outputBufferWrite) {
     EXPECT_EQ(expected_size, obuffer.getLength());
     cp = obuffer.getData();
     EXPECT_EQ(0, memcmp(cp + 7, testdata, sizeof(testdata)));
+
+    datav = obuffer.getVector();
+    ASSERT_EQ(expected_size, datav.size());
+    std::vector<uint8_t> expected = { 1, 2, 3, 4, 5, 6, 7 };
+    expected.insert(expected.end(), testdata, testdata + sizeof(testdata));
+    ASSERT_EQ(expected_size, expected.size());
+    EXPECT_EQ(0, memcmp(&expected[0], &datav[0], expected_size));
 }
 
 TEST_F(BufferTest, outputBufferWriteAt) {
@@ -175,16 +178,11 @@ TEST_F(BufferTest, outputBufferWriteAt) {
     EXPECT_EQ(2, *(cp + 2));
     EXPECT_EQ(3, *(cp + 3));
 
-    EXPECT_THROW(obuffer.writeUint8At(data16, 5),
-                 isc::util::InvalidBufferPosition);
-    EXPECT_THROW(obuffer.writeUint8At(data16, 4),
-                 isc::util::InvalidBufferPosition);
-    EXPECT_THROW(obuffer.writeUint16At(data16, 3),
-                 isc::util::InvalidBufferPosition);
-    EXPECT_THROW(obuffer.writeUint16At(data16, 4),
-                 isc::util::InvalidBufferPosition);
-    EXPECT_THROW(obuffer.writeUint16At(data16, 5),
-                 isc::util::InvalidBufferPosition);
+    EXPECT_THROW(obuffer.writeUint8At(data16, 5), isc::OutOfRange);
+    EXPECT_THROW(obuffer.writeUint8At(data16, 4), isc::OutOfRange);
+    EXPECT_THROW(obuffer.writeUint16At(data16, 3), isc::OutOfRange);
+    EXPECT_THROW(obuffer.writeUint16At(data16, 4), isc::OutOfRange);
+    EXPECT_THROW(obuffer.writeUint16At(data16, 5), isc::OutOfRange);
 }
 
 TEST_F(BufferTest, outputBufferSkip) {
@@ -213,7 +211,7 @@ TEST_F(BufferTest, outputBufferReadAt) {
     for (size_t i = 0; i < sizeof(testdata); ++i) {
         EXPECT_EQ(testdata[i], obuffer[i]);
     }
-    EXPECT_THROW(obuffer[sizeof(testdata)], isc::util::InvalidBufferPosition);
+    EXPECT_THROW(obuffer[sizeof(testdata)], isc::OutOfRange);
 }
 
 TEST_F(BufferTest, outputBufferClear) {