message.hpp

Go to the documentation of this file.

#ifndef __MESSAGE_HPP__
#define __MESSAGE_HPP__

#include "utilities.hpp"

#include <sys/socket.h>
#include <unistd.h>
#include <string.h>


/*********************************************************/
/* */
/* Constant */
/* */
/*********************************************************/


#define POINTER_SIZE ( sizeof( void * ) )

#define MESSAGE_HEADER_LENGTH 4

#define MESSAGE_SIZE ( POINTER_SIZE + MESSAGE_HEADER_LENGTH )


/*********************************************************/
/* */
/* Message classes */
/* */
/*********************************************************/


class Message final {

 class Msg final {

/* clang-format off */
#define MESSAGE_INTERNALS( HEADER_ONLY ) \
 \
 static const constexpr bool header_only = HEADER_ONLY; \
 \
 static const constexpr int size = MESSAGE_SIZE; \
 \
 static const constexpr char *const header = Info::header; \
 \
 static_assert( strlen( Info::header ) == MESSAGE_HEADER_LENGTH, \
 "Header is of wrong size." ); \
 \
 MessageType<HEADER_ONLY, Info>() = delete;
 /* clang-format on */

 static const char *set_length( char *const dst, const char *const src,
 const int n );

 template <bool only_header, typename Info> struct MessageType;

 // Note: **ALL** messages will be of the same size.
 // Header only messages - the contents of the body do not matter.

 template <typename Info> struct MessageType<true, Info> final {

 // Setup the internals of the message
 MESSAGE_INTERNALS( true )

 
 static const char *const message;

 private:
 static char internal[size];
 };

 template <typename Info> struct MessageType<false, Info> final {

 // Setup the internals of the message
 MESSAGE_INTERNALS( false )

 
 explicit MessageType<false, Info>( const char *const ptr ) {
 memcpy( message, header, MESSAGE_HEADER_LENGTH );
 memcpy( &message[MESSAGE_HEADER_LENGTH], ptr, POINTER_SIZE );
 }

 char message[size];
 };

// Remove macros
#undef MESSAGE_INTERNALS

 public:
 template <typename T> using HeaderOnly = MessageType<true, T>;

 template <typename T> using WithBody = MessageType<false, T>;
 };


 // General Headers

 struct ContinueInfo final {
 static constexpr const char *const header = "CONT";
 };

 struct CallInfo final {
 static const constexpr char *const header = "CALL";
 };

 struct RetInfo final {
 static const constexpr char *const header = "RET-";
 };


 struct NewSignalInfo final {
 static constexpr const char *const header = "NEWS";
 };

 struct ExecveInfo final {
 static constexpr const char *const header = "EXEC";
 };

 struct ForkInfo final {
 static const constexpr char *const header = "FORK";
 };

 struct ThreadInfo final {
 static const constexpr char *const header = "THRD";
 };

 public:
 template <class T> static bool is_a_valid( const char *const buffer ) {
 return !memcmp( buffer, T::header, MESSAGE_HEADER_LENGTH );
 }

 typedef const Msg::HeaderOnly<ContinueInfo> Continue;
 typedef const Msg::WithBody<CallInfo> Call;
 typedef const Msg::WithBody<RetInfo> Ret;

 typedef const Msg::HeaderOnly<NewSignalInfo> NewSignal;
 typedef const Msg::HeaderOnly<ExecveInfo> Execve;
 typedef const Msg::HeaderOnly<ForkInfo> Fork;
 typedef const Msg::HeaderOnly<ThreadInfo> Thread;
};


template <typename T> char Message::Msg::MessageType<true, T>::internal[size] = {};

template <typename T>
const char *const Message::Msg::MessageType<true, T>::message =
 set_length( Message::Msg::MessageType<true, T>::internal,
 Message::Msg::MessageType<true, T>::header,
 Message::Msg::MessageType<true, T>::size );


/*********************************************************/
/* */
/* Used to send / recieve messages */
/* */
/*********************************************************/


template <typename Msg> void send_msg( const int sock ) {
 static_assert( Msg::header_only == true, "wrong send_msg called." );
 const int bytes_sent = write( sock, Msg::header, Msg::size );
 Utilities::assert( bytes_sent == Msg::size, "write() failed!" );
}

template <typename Msg> void send_msg( const int sock, const char *const bdy ) {
 static_assert( Msg::header_only == false, "wrong send_msg called." );
 Msg to_send( bdy );
 const int bytes_sent = write( sock, to_send.message, to_send.size );
 Utilities::assert( bytes_sent == to_send.size, "write() failed!" );
}

template <typename Msg> void recv_msg( const int sock ) {
 static_assert( Msg::header_only == true, "wrong recv_msg called." );
 char buffer[Msg::size];
 const int bytes_recv = recv( sock, buffer, Msg::size, MSG_WAITALL );
 Utilities::assert( bytes_recv == Msg::size, "Did not get full size message!" );
 const constexpr auto is_msg = Message::is_a_valid<Message::Continue>;
 Utilities::assert( is_msg( buffer ), "Received incorrect message!" );
}

template <typename Msg> const char *recv_msg_and_body( const int sock ) {
 static_assert( Msg::header_only == false, "wrong recv_msg called." );
 static char buffer[Msg::size];
 const int bytes_recv = recv( sock, buffer, Msg::size, MSG_WAITALL );
 Utilities::assert( bytes_recv == Msg::size, "Did not get full size message!" );
 const constexpr auto is_msg = Message::is_a_valid<Message::Continue>;
 Utilities::assert( is_msg( buffer ), "Received incorrect message!" );
 return buffer;
}


#endif