Files

365 lines
11 KiB
C++

/**
* @file include/ActivMiddleware/ActivBase/Ip/UdpPacketBuilder.h
*
* @brief Header for the UdpPacketBuilder class.
*/
#if (!defined ACTIV_BASE_IP_UDP_PACKET_BUILDER_H)
#define ACTIV_BASE_IP_UDP_PACKET_BUILDER_H
#include "ActivMiddleware/ActivBase/External.h"
#include "ActivMiddleware/ActivBase/MessageBuilder.h"
#include "ActivMiddleware/ActivBase/Ip/IpAddress.h"
#include "ActivMiddleware/Misc/MacAddress.h"
//! Activ namespace.
namespace Activ
{
/**
* @brief UdpPacketBuilder class.
*
* This class can be used to build udp packets. The AppendMessage() functions provided will build the message by appending a
* uint16_t with the length of the message, followed by the message itself. To send a more generic message the MessageBuilder can
* be used directly with GetMessageBuilder() and GetUdpPayloadOffset().
*/
class UdpPacketBuilder
{
public:
//! Default constructor.
ACTIV_BASE_API UdpPacketBuilder();
/**
* @brief Set the destination MacAddress.
*
* @param macAddress the MacAddress.
*
* @throws Exception
*/
void SetDestinationMacAddress(const MacAddress &macAddress);
/**
* @brief Set the source MacAddress.
*
* @param macAddress the MacAddress.
*
* @throws Exception
*/
void SetSourceMacAddress(const MacAddress &macAddress);
/**
* @brief Set the vlan id.
*
* @param vlanId the vlan id.
*
* @throws Exception
*/
ACTIV_BASE_API void SetVlanId(const uint16_t vlanId);
/**
* @brief Set the TTL.
*
* @param ttl the TTL.
*
* @throws Exception
*/
void SetTtl(const uint8_t ttl);
/**
* @brief Set the source IpAddress.
*
* @param ipAddress the IpAddress.
*
* @throws Exception
*/
void SetSourceIpAddress(const IpAddress &ipAddress);
/**
* @brief Set the destination IpAddress.
*
* @param ipAddress the IpAddress.
*
* @throws Exception
*/
void SetDestinationIpAddress(const IpAddress &ipAddress);
/**
* @brief Set the source port.
*
* @param port the port.
*
* @throws Exception
*/
void SetSourcePort(const uint16_t port);
/**
* @brief Set the destination port.
*
* @param port the port.
*
* @throws Exception
*/
void SetDestinationPort(const uint16_t port);
/**
* @brief Get the message builder.
*
* Use the message builder to write the udp payload into.
*
* When the packet is finalized use the message builder to access the full Ethernet packet.
*/
MessageBuilder &GetMessageBuilder();
/**
* @brief Get the const message builder.
*
* When the packet is finalized use the message builder to access the full Ethernet packet.
*/
const MessageBuilder &GetMessageBuilder() const;
//! Get udp payload offset.
size_t GetUdpPayloadOffset() const;
/**
* @brief Finalize the packet, ready to send.
*
* Writes the length fields in the ip and udp headers.
*
* @throws Exception
*/
void Finalize();
/**
* @brief Finalize the packet, to the specified length.
*
* Writes the length fields in the ip and udp headers.
*
* @param length
*
* @throws Exception
*/
void Finalize(const size_t length);
/**
* @brief Reset the packet.
*
* The udp payload will be lost. The Ethernet and IP headers will be retained.
*
* @throws Exception
*/
void Reset();
/**
* @brief Append a message.
*
* @param function function taking a MessageBuilder, that will write the message.
*
* @throws Exception
*/
template <typename F>
void AppendMessage(const F &function);
/**
* @brief Append a message.
*
* @param pMessage
* @param length
*
* @throws Exception
*/
void AppendMessage(const void * const pMessage, const size_t length);
private:
// Ethernet offset constants.
static const size_t ETHERNET_DST_MAC_ADDRESS_OFFSET = 0;
static const size_t ETHERNET_SRC_MAC_ADDRESS_OFFSET = ETHERNET_DST_MAC_ADDRESS_OFFSET + MacAddress::SIZE;
static const size_t ETHERNET_VLAN_TAG_OFFSET = ETHERNET_SRC_MAC_ADDRESS_OFFSET + MacAddress::SIZE;
static const size_t ETHERNET_VLAN_ID_OFFSET = ETHERNET_VLAN_TAG_OFFSET + sizeof(uint16_t);
// IP header constants with offsets from m_ipHeaderOffset.
static const size_t IP_V4_ADDRESS_LENGTH = 4;
static const size_t IP_LENGTH_OFFSET = 2;
static const size_t IP_TTL_OFFSET = 8;
static const size_t IP_SRC_IP_OFFSET = 12;
static const size_t IP_DST_IP_OFFSET = IP_SRC_IP_OFFSET + IP_V4_ADDRESS_LENGTH;
// UDP header constants with offsets from m_ipHeaderOffset.
static const size_t UDP_HEADER_LENGTH = 8;
static const size_t UDP_HEADER_START_OFFSET = IP_DST_IP_OFFSET + IP_V4_ADDRESS_LENGTH;
static const size_t UDP_SRC_PORT_OFFSET = UDP_HEADER_START_OFFSET;
static const size_t UDP_DST_PORT_OFFSET = UDP_SRC_PORT_OFFSET + sizeof(uint16_t);
static const size_t UDP_LENGTH_OFFSET = UDP_DST_PORT_OFFSET + sizeof(uint16_t);
size_t m_ipHeaderOffset;
size_t m_udpPayloadOffset;
MessageBuilder m_messageBuilder;
bool m_hasVlanTag;
};
// ---------------------------------------------------------------------------------------------------------------------------------
inline void UdpPacketBuilder::SetDestinationMacAddress(const MacAddress &macAddress)
{
ACTIV_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, m_messageBuilder.OverwriteBuffer(ETHERNET_DST_MAC_ADDRESS_OFFSET,
macAddress.Get(), MacAddress::SIZE));
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline void UdpPacketBuilder::SetSourceMacAddress(const MacAddress &macAddress)
{
ACTIV_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=,
m_messageBuilder.OverwriteBuffer(ETHERNET_SRC_MAC_ADDRESS_OFFSET, macAddress.Get(), MacAddress::SIZE));
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline void UdpPacketBuilder::SetTtl(const uint8_t ttl)
{
const size_t offset = m_ipHeaderOffset + IP_TTL_OFFSET;
ACTIV_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=,
(m_messageBuilder.Overwrite<MessageHandler::ENDIAN_BIG, sizeof(uint8_t)>(offset, ttl)));
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline void UdpPacketBuilder::SetSourceIpAddress(const IpAddress &ipAddress)
{
const size_t offset = m_ipHeaderOffset + IP_SRC_IP_OFFSET;
const size_t value = ipAddress.GetAddress().AddressIn.sin_addr.s_addr;
ACTIV_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=,
(m_messageBuilder.Overwrite<MessageHandler::ENDIAN_LOCAL, IP_V4_ADDRESS_LENGTH>(offset, value)));
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline void UdpPacketBuilder::SetDestinationIpAddress(const IpAddress &ipAddress)
{
const size_t offset = m_ipHeaderOffset + IP_DST_IP_OFFSET;
const size_t value = ipAddress.GetAddress().AddressIn.sin_addr.s_addr;
ACTIV_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=,
(m_messageBuilder.Overwrite<MessageHandler::ENDIAN_LOCAL, IP_V4_ADDRESS_LENGTH>(offset, value)));
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline void UdpPacketBuilder::SetSourcePort(const uint16_t port)
{
const size_t offset = m_ipHeaderOffset + UDP_SRC_PORT_OFFSET;
ACTIV_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=,
(m_messageBuilder.Overwrite<MessageHandler::ENDIAN_BIG, sizeof(uint16_t)>(offset, port)));
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline void UdpPacketBuilder::SetDestinationPort(const uint16_t port)
{
const size_t offset = m_ipHeaderOffset + UDP_DST_PORT_OFFSET;
ACTIV_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=,
(m_messageBuilder.Overwrite<MessageHandler::ENDIAN_BIG, sizeof(uint16_t)>(offset, port)));
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline MessageBuilder &UdpPacketBuilder::GetMessageBuilder()
{
return m_messageBuilder;
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline const MessageBuilder &UdpPacketBuilder::GetMessageBuilder() const
{
return m_messageBuilder;
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline size_t UdpPacketBuilder::GetUdpPayloadOffset() const
{
return m_udpPayloadOffset;
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline void UdpPacketBuilder::Finalize()
{
Finalize(m_messageBuilder.GetLength());
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline void UdpPacketBuilder::Finalize(const size_t length)
{
if (ACTIV_UNLIKELY(length < m_udpPayloadOffset))
ACTIV_THROW(StatusCodeException, STATUS_CODE_INVALID_LENGTH);
// Write ip length.
size_t offset = m_ipHeaderOffset + IP_LENGTH_OFFSET;
size_t value = length - m_ipHeaderOffset;
ACTIV_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=,
(m_messageBuilder.Overwrite<MessageHandler::ENDIAN_BIG, sizeof(uint16_t)>(offset, value)));
// Write udp length.
offset = m_ipHeaderOffset + UDP_LENGTH_OFFSET;
value = length - (m_ipHeaderOffset + UDP_HEADER_START_OFFSET);
ACTIV_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=,
(m_messageBuilder.Overwrite<MessageHandler::ENDIAN_BIG, sizeof(uint16_t)>(offset, value)));
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline void UdpPacketBuilder::Reset()
{
ACTIV_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, m_messageBuilder.SetLength(m_udpPayloadOffset));
}
// ---------------------------------------------------------------------------------------------------------------------------------
template <typename F>
inline void UdpPacketBuilder::AppendMessage(const F &function)
{
const size_t lengthOffset = m_messageBuilder.GetLength();
try
{
// Append zero length. Overwrite later.
ACTIV_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=,
m_messageBuilder.Append<MessageBuilder::ENDIAN_LITTLE>(uint16_t(0)));
function(m_messageBuilder);
const uint16_t messageLength =
static_cast<uint16_t>((m_messageBuilder.GetLength() - (lengthOffset + sizeof(uint16_t))));
assert ((m_messageBuilder.GetLength() - lengthOffset) <= std::numeric_limits<uint16_t>::max());
ACTIV_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=,
m_messageBuilder.Overwrite<MessageBuilder::ENDIAN_LITTLE>(lengthOffset, messageLength));
}
ACTIV_CATCH_ALL()
{
m_messageBuilder.SetLength(lengthOffset);
throw;
}
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline void UdpPacketBuilder::AppendMessage(const void * const pMessage, const size_t length)
{
assert (length <= std::numeric_limits<uint16_t>::max());
ACTIV_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=,
m_messageBuilder.Append<MessageBuilder::ENDIAN_LITTLE>(static_cast<uint16_t>(length)));
ACTIV_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=,
m_messageBuilder.AppendBuffer(pMessage, length));
}
} // namespace Activ
#endif // (!defined ACTIV_BASE_IP_UDP_PACKET_BUILDER_H)