inital commit

CMakeLists.txt

@@ -0,0 +1,16 @@
+cmake_minimum_required(VERSION 2.4)
+
+
+project(MessageReciever)
+
+set(SRC_FILES main.cpp Socket.cpp )
+set(LIBS -lnotify -lgobject-2.0)
+
+add_executable(${PROJECT_NAME} ${SRC_FILES})
+
+target_link_libraries( ${PROJECT_NAME} ${LIBS})
+target_include_directories(${PROJECT_NAME} PRIVATE  "/usr/include/glib-2.0/" "/usr/lib/glib-2.0/include" "/usr/include/gdk-pixbuf-2.0")
+set_target_properties( ${PROJECT_NAME} PROPERTIES COMPILE_FLAGS -m64 LINK_FLAGS -m64)
+add_definitions(" -std=c++11 -Wall -O2 -flto")
+
+install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION bin)

Socket.cpp

@@ -0,0 +1,379 @@
+
+#include "Socket.h"
+
+
+  #include <sys/types.h>       // For data types
+  #include <sys/socket.h>      // For socket(), connect(), send(), and recv()
+  #include <netdb.h>           // For gethostbyname()
+  #include <arpa/inet.h>       // For inet_addr()
+  #include <unistd.h>          // For close()
+  #include <netinet/in.h>      // For sockaddr_in
+  #include <netinet/tcp.h>     // TCP_KEEPCNT
+  #include <fcntl.h>
+  typedef void raw_type;       // Type used for raw data on this platform
+
+#include <errno.h>             // For errno
+
+using namespace std;
+
+// SocketException Code
+
+SocketException::SocketException(const string &message, bool inclSysMsg)
+   : userMessage(message) {
+  if (inclSysMsg) {
+    userMessage.append(": ");
+    userMessage.append(strerror(errno));
+  }
+}
+
+SocketException::~SocketException() noexcept (true) {
+}
+
+const char *SocketException::what(){
+  return userMessage.c_str();
+}
+
+// Function to fill in address structure given an address and port
+static void fillAddr(const string &address, unsigned short port, 
+                     sockaddr_in &addr) {
+  memset(&addr, 0, sizeof(addr));  // Zero out address structure
+  addr.sin_family = AF_INET;       // Internet address
+
+  hostent *host;  // Resolve name
+  if ((host = gethostbyname(address.c_str())) == NULL) {
+    // strerror() will not work for gethostbyname() and hstrerror() 
+    // is supposedly obsolete
+    throw SocketException("Failed to resolve name (gethostbyname())");
+  }
+  addr.sin_addr.s_addr = *((unsigned long *) host->h_addr_list[0]);
+
+  addr.sin_port = htons(port);     // Assign port in network byte order
+}
+
+// Socket Code
+
+Socket::Socket(int type, int protocol)  {
+
+  // Make a new socket
+  if ((sockDesc = socket(PF_INET, type, protocol)) < 0) {
+    throw SocketException("Socket creation failed (socket())", true);
+  }
+}
+
+Socket::Socket(int sockDesc) {
+  this->sockDesc = sockDesc;
+}
+
+Socket::~Socket() 
+{
+  close(sockDesc);
+  sockDesc = -1;
+}
+
+string Socket::getLocalAddress()  {
+  sockaddr_in addr;
+  unsigned int addr_len = sizeof(addr);
+
+  if (getsockname(sockDesc, (sockaddr *) &addr, (socklen_t *) &addr_len) < 0) {
+    throw SocketException("Fetch of local address failed (getsockname())", true);
+  }
+  return inet_ntoa(addr.sin_addr);
+}
+
+unsigned short Socket::getLocalPort()  {
+  sockaddr_in addr;
+  unsigned int addr_len = sizeof(addr);
+
+  if (getsockname(sockDesc, (sockaddr *) &addr, (socklen_t *) &addr_len) < 0) {
+    throw SocketException("Fetch of local port failed (getsockname())", true);
+  }
+  return ntohs(addr.sin_port);
+}
+
+void Socket::setLocalPort(unsigned short localPort)  {
+  // Bind the socket to its port
+  sockaddr_in localAddr;
+  memset(&localAddr, 0, sizeof(localAddr));
+  localAddr.sin_family = AF_INET;
+  localAddr.sin_addr.s_addr = htonl(INADDR_ANY);
+  localAddr.sin_port = htons(localPort);
+
+  if (bind(sockDesc, (sockaddr *) &localAddr, sizeof(sockaddr_in)) < 0) {
+    throw SocketException("Set of local port failed (bind())", true);
+  }
+}
+
+void Socket::setLocalAddressAndPort(const string &localAddress,
+    unsigned short localPort)  {
+  // Get the address of the requested host
+  sockaddr_in localAddr;
+  fillAddr(localAddress, localPort, localAddr);
+
+  if (bind(sockDesc, (sockaddr *) &localAddr, sizeof(sockaddr_in)) < 0) {
+    throw SocketException("Set of local address and port failed (bind())", true);
+  }
+}
+
+void Socket::setKeepalive()
+{
+      int optval = 1;
+      setsockopt(sockDesc, SOL_SOCKET, SO_KEEPALIVE,&optval, sizeof(optval));
+      
+      optval = 2;
+      setsockopt(sockDesc, SOL_SOCKET, TCP_KEEPCNT, &optval, sizeof(optval));
+      
+      optval = 10;
+      setsockopt(sockDesc, SOL_SOCKET, TCP_KEEPIDLE, &optval, sizeof(optval));
+      
+      optval = 5;
+      setsockopt(sockDesc, SOL_SOCKET, TCP_KEEPINTVL, &optval, sizeof(optval));
+}
+
+void Socket::setBlocking(bool flag)
+{
+    int flags = fcntl(sockDesc, F_GETFL, 0);
+    if( !flag ) flags = flags | O_NONBLOCK;
+    else flags = flags & ~O_NONBLOCK;
+    fcntl(sockDesc, F_SETFL, flags);
+}
+
+void Socket::cleanUp()  {
+    
+}
+
+int Socket::getFD()
+{
+	return sockDesc;
+}
+
+unsigned short Socket::resolveService(const string &service,
+                                      const string &protocol) {
+  struct servent *serv;        /* Structure containing service information */
+
+  if ((serv = getservbyname(service.c_str(), protocol.c_str())) == NULL)
+    return atoi(service.c_str());  /* Service is port number */
+  else 
+    return ntohs(serv->s_port);    /* Found port (network byte order) by name */
+}
+
+// CommunicatingSocket Code
+
+CommunicatingSocket::CommunicatingSocket(int type, int protocol)  
+     : Socket(type, protocol) {
+}
+
+CommunicatingSocket::CommunicatingSocket(int newConnSD) : Socket(newConnSD) {
+}
+
+void CommunicatingSocket::connect(const string &foreignAddress,
+    unsigned short foreignPort)  {
+  // Get the address of the requested host
+  sockaddr_in destAddr;
+  fillAddr(foreignAddress, foreignPort, destAddr);
+
+  // Try to connect to the given port
+  if (::connect(sockDesc, (sockaddr *) &destAddr, sizeof(destAddr)) < 0) {
+    throw SocketException("Connect failed (connect())", true);
+  }
+}
+
+void CommunicatingSocket::send(const void *buffer, int bufferLen) 
+     {
+  if (::send(sockDesc, (raw_type *) buffer, bufferLen, 0) < 0) {
+    throw SocketException("Send failed (send())", true);
+  }
+}
+
+
+int CommunicatingSocket::recv(void *buffer, int bufferLen) 
+{
+  int rtn;
+  if ((rtn = ::recv(sockDesc, (raw_type *) buffer, bufferLen, 0)) < 0 ) 
+  {
+    if(errno == EWOULDBLOCK || errno == EAGAIN) 
+    {
+        return -1;
+    }
+    else throw SocketException("Received failed (recv())", true);
+  }
+
+  return rtn;
+}
+
+string CommunicatingSocket::getForeignAddress() 
+     {
+  sockaddr_in addr;
+  unsigned int addr_len = sizeof(addr);
+
+  if (getpeername(sockDesc, (sockaddr *) &addr,(socklen_t *) &addr_len) < 0) {
+    throw SocketException("Fetch of foreign address failed (getpeername())", true);
+  }
+  return inet_ntoa(addr.sin_addr);
+}
+
+unsigned short CommunicatingSocket::getForeignPort()  {
+  sockaddr_in addr;
+  unsigned int addr_len = sizeof(addr);
+
+  if (getpeername(sockDesc, (sockaddr *) &addr, (socklen_t *) &addr_len) < 0) {
+    throw SocketException("Fetch of foreign port failed (getpeername())", true);
+  }
+  return ntohs(addr.sin_port);
+}
+
+// TCPSocket Code
+
+TCPSocket::TCPSocket() 
+     : CommunicatingSocket(SOCK_STREAM, 
+    IPPROTO_TCP) {
+}
+
+TCPSocket::TCPSocket(const string &foreignAddress, unsigned short foreignPort, bool keepalive)
+     : CommunicatingSocket(SOCK_STREAM, IPPROTO_TCP) {
+  connect(foreignAddress, foreignPort);
+  if(keepalive) setKeepalive();
+}
+
+TCPSocket::TCPSocket(int newConnSD) : CommunicatingSocket(newConnSD) {
+}
+
+// TCPServerSocket Code
+
+TCPServerSocket::TCPServerSocket(unsigned short localPort, int queueLen, bool keepaliveIN) 
+     : Socket(SOCK_STREAM, IPPROTO_TCP) 
+{
+  keepalive = keepaliveIN;
+  setLocalPort(localPort);
+  setListen(queueLen);
+}
+
+TCPServerSocket::TCPServerSocket(const string &localAddress, unsigned short localPort, int queueLen, bool keepaliveIN) 
+     : Socket(SOCK_STREAM, IPPROTO_TCP) 
+{
+  keepalive = keepaliveIN;
+  setLocalAddressAndPort(localAddress, localPort);
+  setListen(queueLen);
+}
+
+TCPSocket* TCPServerSocket::accept()  
+{
+  int newConnSD = -1;
+  if ((newConnSD = ::accept(sockDesc, NULL, 0)) < 0 && errno != EAGAIN  && errno != EWOULDBLOCK )
+  {
+    throw SocketException("Accept failed (accept())", true);
+  }
+  TCPSocket* newSocket = nullptr; 
+  if(newConnSD > 0) 
+  {
+    newSocket = new TCPSocket(newConnSD);
+    if(keepalive) newSocket->setKeepalive();
+  }
+  return newSocket;
+}
+
+
+
+void TCPServerSocket::setListen(int queueLen)  {
+  if (listen(sockDesc, queueLen) < 0) {
+    throw SocketException("Set listening socket failed (listen())", true);
+  }
+}
+
+// UDPSocket Code
+
+UDPSocket::UDPSocket()  : CommunicatingSocket(SOCK_DGRAM,
+    IPPROTO_UDP) {
+  setBroadcast();
+}
+
+UDPSocket::UDPSocket(unsigned short localPort)   : 
+    CommunicatingSocket(SOCK_DGRAM, IPPROTO_UDP) {
+  setLocalPort(localPort);
+  setBroadcast();
+}
+
+UDPSocket::UDPSocket(const string &localAddress, unsigned short localPort) 
+      : CommunicatingSocket(SOCK_DGRAM, IPPROTO_UDP) {
+  setLocalAddressAndPort(localAddress, localPort);
+  setBroadcast();
+}
+
+void UDPSocket::setBroadcast() {
+  // If this fails, we'll hear about it when we try to send.  This will allow 
+  // system that cannot broadcast to continue if they don't plan to broadcast
+  int broadcastPermission = 1;
+  setsockopt(sockDesc, SOL_SOCKET, SO_BROADCAST, 
+             (raw_type *) &broadcastPermission, sizeof(broadcastPermission));
+}
+
+void UDPSocket::disconnect()  {
+  sockaddr_in nullAddr;
+  memset(&nullAddr, 0, sizeof(nullAddr));
+  nullAddr.sin_family = AF_UNSPEC;
+
+  // Try to disconnect
+  if (::connect(sockDesc, (sockaddr *) &nullAddr, sizeof(nullAddr)) < 0) {
+    if (errno != EAFNOSUPPORT) {
+      throw SocketException("Disconnect failed (connect())", true);
+    }
+  }
+}
+
+void UDPSocket::sendTo(const void *buffer, int bufferLen, 
+    const string &foreignAddress, unsigned short foreignPort) 
+     {
+  sockaddr_in destAddr;
+  fillAddr(foreignAddress, foreignPort, destAddr);
+
+  // Write out the whole buffer as a single message.
+  if (sendto(sockDesc, (raw_type *) buffer, bufferLen, 0,
+             (sockaddr *) &destAddr, sizeof(destAddr)) != bufferLen) {
+    throw SocketException("Send failed (sendto())", true);
+  }
+}
+
+int UDPSocket::recvFrom(void *buffer, int bufferLen, string &sourceAddress,
+    unsigned short &sourcePort)  {
+  sockaddr_in clntAddr;
+  socklen_t addrLen = sizeof(clntAddr);
+  int rtn;
+  if ((rtn = recvfrom(sockDesc, (raw_type *) buffer, bufferLen, MSG_DONTWAIT, (sockaddr *) &clntAddr, (socklen_t *) &addrLen)) < 0) 
+  {
+    throw SocketException("Receive failed (recvfrom())", true);
+  }
+  sourceAddress = inet_ntoa(clntAddr.sin_addr);
+  sourcePort = ntohs(clntAddr.sin_port);
+
+  return rtn;
+}
+
+void UDPSocket::setMulticastTTL(unsigned char multicastTTL)  {
+  if (setsockopt(sockDesc, IPPROTO_IP, IP_MULTICAST_TTL, 
+                 (raw_type *) &multicastTTL, sizeof(multicastTTL)) < 0) {
+    throw SocketException("Multicast TTL set failed (setsockopt())", true);
+  }
+}
+
+void UDPSocket::joinGroup(const string &multicastGroup)  {
+  struct ip_mreq multicastRequest;
+
+  multicastRequest.imr_multiaddr.s_addr = inet_addr(multicastGroup.c_str());
+  multicastRequest.imr_interface.s_addr = htonl(INADDR_ANY);
+  if (setsockopt(sockDesc, IPPROTO_IP, IP_ADD_MEMBERSHIP, 
+                 (raw_type *) &multicastRequest, 
+                 sizeof(multicastRequest)) < 0) {
+    throw SocketException("Multicast group join failed (setsockopt())", true);
+  }
+}
+
+void UDPSocket::leaveGroup(const string &multicastGroup)  {
+  struct ip_mreq multicastRequest;
+
+  multicastRequest.imr_multiaddr.s_addr = inet_addr(multicastGroup.c_str());
+  multicastRequest.imr_interface.s_addr = htonl(INADDR_ANY);
+  if (setsockopt(sockDesc, IPPROTO_IP, IP_DROP_MEMBERSHIP, 
+                 (raw_type *) &multicastRequest, 
+                 sizeof(multicastRequest)) < 0) {
+    throw SocketException("Multicast group leave failed (setsockopt())", true);
+  }
+}

Socket.h

@@ -0,0 +1,328 @@
+#ifndef __SOCKET_INCLUDED__
+#define __SOCKET_INCLUDED__
+
+#include <string>            // For std::string
+#include <exception>         // For exception class
+#include <errno.h>
+#include <string.h>
+
+/**
+ *   Signals a problem with the execution of a socket call.
+ */
+class SocketException : public std::exception {
+public:
+  /**
+   *   Construct a SocketException with a explanatory message.
+   *   @param message explanatory message
+   *   @param incSysMsg true if system message (from strerror(errno))
+   *   should be postfixed to the user provided message
+   */
+  SocketException(const std::string &message, bool inclSysMsg = false) ;
+
+  /**
+   *   Provided just to guarantee that no exceptions are thrown.
+   */
+  ~SocketException() noexcept (true);
+
+  /**
+   *   Get the exception message
+   *   @return exception message
+   */
+  const char *what();
+
+private:
+  std::string userMessage;  // Exception message
+};
+
+/**
+ *   Base class representing basic communication endpoint
+ */
+class Socket {
+public:
+  /**
+   *   Close and deallocate this socket
+   */
+  ~Socket();
+
+  /**
+   *   Get the local address
+   *   @return local address of socket
+   *   @exception SocketException thrown if fetch fails
+   */
+  std::string getLocalAddress();
+
+  /**
+   *   Get the local port
+   *   @return local port of socket
+   *   @exception SocketException thrown if fetch fails
+   */
+  unsigned short getLocalPort() ;
+
+  /**
+   *   Set the local port to the specified port and the local address
+   *   to any interface
+   *   @param localPort local port
+   *   @exception SocketException thrown if setting local port fails
+   */
+  void setLocalPort(unsigned short localPort) ;
+
+  /**
+   *   Set the local port to the specified port and the local address
+   *   to the specified address.  If you omit the port, a random port 
+   *   will be selected.
+   *   @param localAddress local address
+   *   @param localPort local port
+   *   @exception SocketException thrown if setting local port or address fails
+   */
+  void setLocalAddressAndPort(const std::string &localAddress, 
+    unsigned short localPort = 0) ;
+
+  /**
+   *   If WinSock, unload the WinSock DLLs; otherwise do nothing.  We ignore
+   *   this in our sample client code but include it in the library for
+   *   completeness.  If you are running on Windows and you are concerned
+   *   about DLL resource consumption, call this after you are done with all
+   *   Socket instances.  If you execute this on Windows while some instance of
+   *   Socket exists, you are toast.  For portability of client code, this is 
+   *   an empty function on non-Windows platforms so you can always include it.
+   *   @param buffer buffer to receive the data
+   *   @param bufferLen maximum number of bytes to read into buffer
+   *   @return number of bytes read, 0 for EOF, and -1 for error
+   *   @exception SocketException thrown WinSock clean up fails
+   */
+  static void cleanUp() ;
+
+  /**
+   *   Resolve the specified service for the specified protocol to the
+   *   corresponding port number in host byte order
+   *   @param service service to resolve (e.g., "http")
+   *   @param protocol protocol of service to resolve.  Default is "tcp".
+   */
+  static unsigned short resolveService(const std::string &service,
+                                       const std::string &protocol = "tcp");
+  
+  void setKeepalive();
+  void setBlocking(bool flag);
+  
+  int getFD();
+
+private:
+  // Prevent the user from trying to use value semantics on this object
+  Socket(const Socket &sock);
+  void operator=(const Socket &sock);
+
+protected:
+  int sockDesc;              // Socket descriptor
+  Socket(int type, int protocol) ;
+  Socket(int sockDesc);
+};
+
+/**
+ *   Socket which is able to connect, send, and receive
+ */
+class CommunicatingSocket : public Socket {
+public:
+  /**
+   *   Establish a socket connection with the given foreign
+   *   address and port
+   *   @param foreignAddress foreign address (IP address or name)
+   *   @param foreignPort foreign port
+   *   @exception SocketException thrown if unable to establish connection
+   */
+  void connect(const std::string &foreignAddress, unsigned short foreignPort)
+    ;
+
+  /**
+   *   Write the given buffer to this socket.  Call connect() before
+   *   calling send()
+   *   @param buffer buffer to be written
+   *   @param bufferLen number of bytes from buffer to be written
+   *   @exception SocketException thrown if unable to send data
+   */
+  void send(const void *buffer, int bufferLen) ;
+
+  /**
+   *   Read into the given buffer up to bufferLen bytes data from this
+   *   socket.  Call connect() before calling recv()
+   *   @param buffer buffer to receive the data
+   *   @param bufferLen maximum number of bytes to read into buffer
+   *   @return number of bytes read, 0 for EOF, and -1 for error
+   *   @exception SocketException thrown if unable to receive data
+   */
+  int recv(void *buffer, int bufferLen) ;
+
+  /**
+   *   Get the foreign address.  Call connect() before calling recv()
+   *   @return foreign address
+   *   @exception SocketException thrown if unable to fetch foreign address
+   */
+  std::string getForeignAddress() ;
+
+  /**
+   *   Get the foreign port.  Call connect() before calling recv()
+   *   @return foreign port
+   *   @exception SocketException thrown if unable to fetch foreign port
+   */
+  unsigned short getForeignPort() ;
+
+protected:
+  CommunicatingSocket(int type, int protocol) ;
+  CommunicatingSocket(int newConnSD);
+};
+
+/**
+ *   TCP socket for communication with other TCP sockets
+ */
+class TCPSocket : public CommunicatingSocket {
+public:
+  /**
+   *   Construct a TCP socket with no connection
+   *   @exception SocketException thrown if unable to create TCP socket
+   */
+  TCPSocket() ;
+
+  /**
+   *   Construct a TCP socket with a connection to the given foreign address
+   *   and port
+   *   @param foreignAddress foreign address (IP address or name)
+   *   @param foreignPort foreign port
+   *   @exception SocketException thrown if unable to create TCP socket
+   */
+  TCPSocket(const std::string &foreignAddress, unsigned short foreignPort, bool keepalive = false) 
+      ;
+
+  bool isOpen();
+    
+private:
+  // Access for TCPServerSocket::accept() connection creation
+  friend class TCPServerSocket;
+  TCPSocket(int newConnSD);
+};
+
+/**
+ *   TCP socket class for servers
+ */
+class TCPServerSocket : public Socket {
+public:
+  /**
+   *   Construct a TCP socket for use with a server, accepting connections
+   *   on the specified port on any interface
+   *   @param localPort local port of server socket, a value of zero will
+   *                   give a system-assigned unused port
+   *   @param queueLen maximum queue length for outstanding 
+   *                   connection requests (default 5)
+   *   @exception SocketException thrown if unable to create TCP server socket
+   */
+  TCPServerSocket(unsigned short localPort, int queueLen = 5, bool keepaliveIN = false);
+
+  /**
+   *   Construct a TCP socket for use with a server, accepting connections
+   *   on the specified port on the interface specified by the given address
+   *   @param localAddress local interface (address) of server socket
+   *   @param localPort local port of server socket
+   *   @param queueLen maximum queue length for outstanding 
+   *                   connection requests (default 5)
+   *   @exception SocketException thrown if unable to create TCP server socket
+   */
+  TCPServerSocket(const std::string &localAddress, unsigned short localPort,
+      int queueLen = 5, bool keepaliveIN = false);
+
+  /**
+   *   Blocks until a new connection is established on this socket or error
+   *   @return new connection socket
+   *   @exception SocketException thrown if attempt to accept a new connection fails
+   */
+  TCPSocket *accept() ;
+
+
+private:
+  void setListen(int queueLen) ;
+  bool keepalive;
+};
+
+/**
+  *   UDP socket class
+  */
+class UDPSocket : public CommunicatingSocket {
+public:
+  /**
+   *   Construct a UDP socket
+   *   @exception SocketException thrown if unable to create UDP socket
+   */
+  UDPSocket() ;
+
+  /**
+   *   Construct a UDP socket with the given local port
+   *   @param localPort local port
+   *   @exception SocketException thrown if unable to create UDP socket
+   */
+  UDPSocket(unsigned short localPort) ;
+
+  /**
+   *   Construct a UDP socket with the given local port and address
+   *   @param localAddress local address
+   *   @param localPort local port
+   *   @exception SocketException thrown if unable to create UDP socket
+   */
+  UDPSocket(const std::string &localAddress, unsigned short localPort) 
+      ;
+
+  /**
+   *   Unset foreign address and port
+   *   @return true if disassociation is successful
+   *   @exception SocketException thrown if unable to disconnect UDP socket
+   */
+  void disconnect() ;
+
+  /**
+   *   Send the given buffer as a UDP datagram to the
+   *   specified address/port
+   *   @param buffer buffer to be written
+   *   @param bufferLen number of bytes to write
+   *   @param foreignAddress address (IP address or name) to send to
+   *   @param foreignPort port number to send to
+   *   @return true if send is successful
+   *   @exception SocketException thrown if unable to send datagram
+   */
+  void sendTo(const void *buffer, int bufferLen, const std::string &foreignAddress,
+            unsigned short foreignPort) ;
+
+  /**
+   *   Read read up to bufferLen bytes data from this socket.  The given buffer
+   *   is where the data will be placed
+   *   @param buffer buffer to receive data
+   *   @param bufferLen maximum number of bytes to receive
+   *   @param sourceAddress address of datagram source
+   *   @param sourcePort port of data source
+   *   @return number of bytes received and -1 for error
+   *   @exception SocketException thrown if unable to receive datagram
+   */
+  int recvFrom(void *buffer, int bufferLen, std::string &sourceAddress, 
+               unsigned short &sourcePort) ;
+
+  /**
+   *   Set the multicast TTL
+   *   @param multicastTTL multicast TTL
+   *   @exception SocketException thrown if unable to set TTL
+   */
+  void setMulticastTTL(unsigned char multicastTTL) ;
+
+  /**
+   *   Join the specified multicast group
+   *   @param multicastGroup multicast group address to join
+   *   @exception SocketException thrown if unable to join group
+   */
+  void joinGroup(const std::string &multicastGroup) ;
+
+  /**
+   *   Leave the specified multicast group
+   *   @param multicastGroup multicast group address to leave
+   *   @exception SocketException thrown if unable to leave group
+   */
+  void leaveGroup(const std::string &multicastGroup) ;
+
+private:
+  void setBroadcast();
+};
+
+#endif

argpopt.h

@@ -0,0 +1,47 @@
+#pragma once
+#include<argp.h>
+
+struct Config
+{
+    bool verbose = false;
+    std::string hostName = "localhost";
+    unsigned short port = 6856;
+};
+
+const char *argp_program_version = "1.0";
+const char *argp_program_bug_address = "<carl@uvos.xyz>";
+static char doc[] = "Application gets messages from SerialMultiplexer bus and displays them as a desktop notification";
+static char args_doc[] = "";
+
+static struct argp_option options[] = 
+{
+  {"verbose",  'v', 0,      0,  "Produce verbose output" },
+  {"host",     'H', "ADDR", 0,  "Sets the host name to connect to"  },
+  {"port",     'p', "PORT", 0,  "Sets the port to connect to" },
+  { 0 }
+};
+
+
+error_t parse_opt (int key, char *arg, struct argp_state *state)
+{
+    Config* config = reinterpret_cast<Config*>(state->input);
+    switch (key)
+    {
+        case 'v':
+        config->verbose = true;
+        break;
+        case 'p':
+        config->port = atoi(arg);
+        break;
+        case 'H':
+        config->hostName = arg;
+        break;
+        default:
+        return ARGP_ERR_UNKNOWN;
+    }
+    return 0;
+}
+
+static struct argp argp = { options, parse_opt, args_doc, doc };
+
+

main.cpp

@@ -0,0 +1,116 @@
+#include <iostream>
+#include <string.h>
+#include <libnotify/notify.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include "Socket.h"
+#include "argpopt.h"
+
+void sigHandler(int sig)
+{
+    exit(0);
+}
+
+bool showMessage(const std::string& title, const std::string& body = "")
+{
+    NotifyNotification* message = notify_notification_new (title.c_str(), body.c_str(), nullptr);
+    bool ret = notify_notification_show (message, NULL);
+    g_object_unref(G_OBJECT(message));
+    return ret;
+}
+
+void processLineBuffer(std::string& buffer)
+{
+    if(buffer.find("bcst:") == 0) buffer.erase(0, 6);
+    if(buffer.size() > 5 && buffer.find("MESG") == 0)
+    {
+        size_t titleEnd  = buffer.size();
+        size_t bodyBegin = buffer.find("BODY");
+        if(bodyBegin != std::string::npos && bodyBegin > 5)
+        {
+          titleEnd = bodyBegin - 1;
+        }
+        
+        const std::string body = (bodyBegin == std::string::npos && buffer.begin()+bodyBegin+5 < buffer.end()) ? 
+        "" : std::string(buffer.begin()+bodyBegin+5, buffer.end());
+        
+        const std::string title(buffer.begin()+5, buffer.begin()+titleEnd);
+        showMessage(title, body);
+    }
+    
+}
+
+static TCPSocket* socket = nullptr;
+
+void exitHandler()
+{
+    notify_uninit();
+    if(socket)delete socket;
+}
+
+bool reconnect(std::string host,  unsigned short port)
+{
+    try
+    {
+        if(socket)delete socket;
+        socket = new TCPSocket(host, port);
+    }
+    catch(SocketException &e)
+    {
+        std::cerr<<e.what()<<std::endl;
+        return false;
+    }
+    return true;
+}
+
+int main(int argc, char* argv[])
+{
+	Config config;
+    
+    notify_init("Message");
+    
+    if( atexit(exitHandler) != 0 ) 
+    {
+        std::cerr<<"can not register atexit handler\n";
+        return -1;
+    }    
+    argp_parse(&argp, argc, argv, 0, 0, &config);
+    
+    std::cout<<argp_program_version<<std::endl;
+	
+    std::string lineBuffer;
+    
+    signal(SIGINT, sigHandler);
+    signal(SIGTERM, sigHandler);
+    char buffer[256];
+    
+    if(!reconnect(config.hostName, config.port)) return 1;
+	
+	while(true)
+	{
+        int len = socket->recv(buffer, sizeof(buffer));
+        if(len <= 0) 
+        {
+            std::cerr<<"socket error\n";
+            int i = 0;
+            for(; i < 30 && reconnect(config.hostName, config.port) == false; ++i) sleep(10);
+            if(i >= 10)
+            {
+                std::cerr<<"reconnect failed\n";
+                return 1;
+            }
+        }
+        for(int i = 0; i<len; ++i)
+        {
+            if(buffer[i] != '\n') lineBuffer.push_back(buffer[i]);
+            else 
+            {
+                processLineBuffer(lineBuffer);
+                lineBuffer.clear();
+            }
+            
+        }
+	}
+	
+	return 0;
+}