Added sized overloads for buffer construction of IPv6Address and MacAddress.

Common++/header/IpAddress.h

@@ -8,6 +8,8 @@
 #include <array>
 #include <memory>
 
+#include "DeprecationUtils.h"
+
 /// @file
 
 /// @namespace pcpp
@@ -39,8 +41,21 @@ namespace pcpp
 
 		/// A constructor that creates an instance of the class out of 4-byte array.
 		/// @param[in] bytes The address as 4-byte array in network byte order
-		IPv4Address(const uint8_t bytes[4])
+		/// @remarks This constructor assumes that the provided array is exactly 4 bytes long.
+		/// Prefer using the constructor with size parameter if the array length is not guaranteed to be 4 bytes.
+		IPv4Address(const uint8_t bytes[4]) : IPv4Address(bytes, 4)
+		{}
+
+		/// A constructor that creates an instance of the class out of a 4-byte array.
+		/// @param[in] bytes The address as 4-byte array in network byte order
+		/// @param[in] size The size of the array in bytes
+		/// @throws std::out_of_range If the provided size is smaller than 4 bytes.
+		IPv4Address(const uint8_t bytes[4], size_t size)
 		{
+			if (size < 4)
+			{
+				throw std::out_of_range("Buffer size is smaller than IPv4 address size");
+			}
 			memcpy(m_Bytes.data(), bytes, 4 * sizeof(uint8_t));
 		}
 
@@ -160,9 +175,22 @@ namespace pcpp
 
 		/// A constructor that creates an instance of the class out of 16-byte array.
 		/// @param[in] bytes The address as 16-byte array in network byte order
-		IPv6Address(const uint8_t bytes[16])
+		/// remarks This constructor assumes that the provided array is exactly 16 bytes long.
+		/// Prefer using the constructor with size parameter if the array length is not guaranteed to be 16 bytes.
+		IPv6Address(const uint8_t bytes[16]) : IPv6Address(bytes, 16)
+		{}
+
+		/// @brief A constructor that creates an instance of the class out of a 16-byte array.
+		/// @param bytes The address as 16-byte array in network byte order
+		/// @param size The size of the array in bytes
+		/// @throws std::out_of_range If the provided size is smaller than 16 bytes.
+		IPv6Address(const uint8_t bytes[16], size_t size)
 		{
-			memcpy(m_Bytes.data(), bytes, 16 * sizeof(uint8_t));
+			if (size < 16)
+			{
+				throw std::out_of_range("Buffer size is smaller than IPv6 address size");
+			}
+			std::memcpy(m_Bytes.data(), bytes, 16 * sizeof(uint8_t));
 		}
 
 		/// A constructor that creates an instance of the class out of a 16-byte standard array.
@@ -224,16 +252,39 @@ namespace pcpp
 		/// Allocates a byte array and copies address value into it. Array deallocation is user responsibility
 		/// @param[in] arr A pointer to where array will be allocated
 		/// @param[out] length Returns the length in bytes of the array that was allocated
+		/// @deprecated Use copyToNewBuffer instead as it returns a unique pointer to the allocated array.
+		PCPP_DEPRECATED("Use copyToNewBuffer instead.")
 		void copyTo(uint8_t** arr, size_t& length) const;
 
 		/// Gets a pointer to an already allocated byte array and copies the address value to it.
 		/// This method assumes array allocated size is at least 16 (the size of an IPv6 address)
 		/// @param[in] arr A pointer to the array which address will be copied to
+		/// @remarks This method assumes that the provided array is at least 16 bytes long.
+		/// Prefer using the copyTo(uint8_t* buffer, size_t size) method if the array length is not guaranteed to be 16
+		/// bytes.
 		void copyTo(uint8_t* arr) const
 		{
-			memcpy(arr, m_Bytes.data(), m_Bytes.size() * sizeof(uint8_t));
+			return copyTo(arr, 16);
+		}
+
+		/// @brief Copies the address value to a user-provided buffer.
+		/// @param buffer[in] A pointer to the buffer where the address will be copied
+		/// @param size[in] The size of the buffer in bytes
+		/// @throws std::out_of_range If the provided size is smaller than 16 bytes.
+		void copyTo(uint8_t* buffer, size_t size) const
+		{
+			if (size < m_Bytes.size())
+			{
+				throw std::out_of_range("Buffer size is smaller than IPv6 address size");
+			}
+			memcpy(buffer, m_Bytes.data(), m_Bytes.size() * sizeof(uint8_t));
 		}
 
+		/// @brief Allocates a byte array and copies address value into it.
+		/// @param[out] size Returns the size in bytes of the allocated array. Usually 16.
+		/// @return A unique pointer to the allocated byte array containing the address value
+		std::unique_ptr<uint8_t[]> copyToNewBuffer(size_t& size) const;
+
 		/// Checks whether the address matches a network.
 		/// @param network An IPv6Network network
 		/// @return True if the address matches the network or false otherwise

Common++/header/MacAddress.h

@@ -7,6 +7,9 @@
 #include <cstdint>
 #include <string>
 #include <array>
+#include <memory>
+
+#include "DeprecationUtils.h"
 
 /// @file
 
@@ -28,8 +31,21 @@ namespace pcpp
 		/// The byte array length should be 6 (as MAC address is 6-byte long), and the remaining bytes are ignored.
 		/// If the byte array is invalid, the constructor throws an exception.
 		/// @param[in] addr A pointer to the byte array containing 6 bytes representing the MAC address
-		explicit MacAddress(const uint8_t addr[6])
+		/// @remarks This constructor assumes that the provided array is exactly 6 bytes long.
+		/// Prefer using the constructor with size parameter if the array length is not guaranteed to be 6 bytes.
+		explicit MacAddress(const uint8_t addr[6]) : MacAddress(addr, 6)
+		{}
+
+		/// @brief A constructor that creates an instance of the class out of a byte array.
+		/// @param[in] addr The address as a byte array in network byte order
+		/// @param[in] size The size of the array in bytes
+		/// @throws std::out_of_range If the provided size is smaller than 6 bytes.
+		explicit MacAddress(const uint8_t addr[6], size_t size)
 		{
+			if (size < 6)
+			{
+				throw std::out_of_range("Buffer size is smaller than MAC address size");
+			}
 			std::copy(addr, addr + 6, m_Address.begin());
 		}
 
@@ -127,18 +143,47 @@ namespace pcpp
 		/// Allocates a byte array of length 6 and copies address value into it. Array deallocation is user
 		/// responsibility
 		/// @param[in] arr A pointer to where array will be allocated
+		/// @deprecated Use copyToNewBuffer instead as it returns a unique pointer to the allocated array.
+		PCPP_DEPRECATED("Use copyToNewBuffer instead as it returns a unique pointer to the allocated array.")
 		void copyTo(uint8_t** arr) const
 		{
-			*arr = new uint8_t[m_Address.size()];
-			std::copy(m_Address.begin(), m_Address.end(), *arr);
+			size_t size;
+			*arr = copyToNewBuffer(size).release();
 		}
 
 		/// Gets a pointer to an already allocated byte array and copies the address value to it.
 		/// This method assumes array allocated size is at least 6 (the size of a MAC address)
 		/// @param[in] arr A pointer to the array which address will be copied to
+		/// @remarks This method assumes that the provided array is at least 6 bytes long.
+		/// Prefer using the copyTo(uint8_t* buffer, size_t size) method if the array length is not guaranteed to be 6
+		/// bytes.
 		void copyTo(uint8_t arr[6]) const
 		{
-			std::copy(m_Address.begin(), m_Address.end(), arr);
+			return copyTo(arr, 6);
+		}
+
+		/// @brief Copies the address value to a user-provided buffer.
+		/// @param[in] buffer A pointer to the buffer where the address will be copied
+		/// @param[in] size The size of the buffer in bytes
+		/// @throws std::out_of_range If the provided size is smaller than 6 bytes.
+		void copyTo(uint8_t* buffer, size_t size) const
+		{
+			if (size < m_Address.size())
+			{
+				throw std::out_of_range("Buffer size is smaller than MAC address size");
+			}
+			std::copy(m_Address.begin(), m_Address.end(), buffer);
+		}
+
+		/// @brief Allocates a byte array and copies address value into it.
+		/// @param size[out] The size of the allocated array in bytes. Usually 6.
+		/// @return A unique pointer to the allocated byte array containing the MAC address.
+		std::unique_ptr<uint8_t[]> copyToNewBuffer(size_t& size) const
+		{
+			size = m_Address.size();
+			auto arr = std::make_unique<uint8_t[]>(size);
+			std::copy(m_Address.begin(), m_Address.end(), arr.get());
+			return arr;
 		}
 
 		/// A static value representing a zero value of MAC address, meaning address of value "00:00:00:00:00:00"

Common++/src/IpAddress.cpp

@@ -111,10 +111,15 @@ namespace pcpp
 
 	void IPv6Address::copyTo(uint8_t** arr, size_t& length) const
 	{
-		const size_t addrLen = m_Bytes.size() * sizeof(uint8_t);
-		length = addrLen;
-		*arr = new uint8_t[addrLen];
-		memcpy(*arr, m_Bytes.data(), addrLen);
+		*arr = copyToNewBuffer(length).release();
+	}
+
+	std::unique_ptr<uint8_t[]> IPv6Address::copyToNewBuffer(size_t& size) const
+	{
+		size = m_Bytes.size() * sizeof(uint8_t);
+		auto arr = std::make_unique<uint8_t[]>(size);
+		memcpy(arr.get(), m_Bytes.data(), size);
+		return arr;
 	}
 
 	bool IPv6Address::matchNetwork(const IPv6Network& network) const

Tests/Pcap++Test/Tests/IpMacTests.cpp

@@ -270,15 +270,15 @@ PTF_TEST_CASE(TestMacAddress)
 	oss << macAddr1;
 	PTF_ASSERT_EQUAL(oss.str(), "11:02:33:04:55:06");
 
-	uint8_t* arrToCopyTo = nullptr;
-	macAddr3.copyTo(&arrToCopyTo);
+	size_t arrLen = 0;
+	auto arrToCopyTo = macAddr3.copyToNewBuffer(arrLen);
+	PTF_ASSERT_EQUAL(arrLen, 6);
 	PTF_ASSERT_EQUAL(arrToCopyTo[0], 0x11, hex);
 	PTF_ASSERT_EQUAL(arrToCopyTo[1], 0x02, hex);
 	PTF_ASSERT_EQUAL(arrToCopyTo[2], 0x33, hex);
 	PTF_ASSERT_EQUAL(arrToCopyTo[3], 0x04, hex);
 	PTF_ASSERT_EQUAL(arrToCopyTo[4], 0x55, hex);
 	PTF_ASSERT_EQUAL(arrToCopyTo[5], 0x06, hex);
-	delete[] arrToCopyTo;
 
 	uint8_t macBytes[6];
 	macAddr3.copyTo(macBytes);