Socket.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_comm_Socket_hpp
#define anna_comm_Socket_hpp

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

#include <anna/config/defines.hpp>
#include <anna/core/mt/Mutex.hpp>

#include <anna/comm/INetAddress.hpp>
#include <anna/comm/AccessPoint.hpp>

namespace anna {

class DataBlock;

namespace xml {
class Node;
}

namespace comm {

class TransportFactory;
class ReceiverFactory;

class Socket : public Mutex  {
public:
  struct Domain { enum _v {  Unix = PF_UNIX, Inet = PF_INET } ;  };

  struct Type { enum _v {  Stream = SOCK_STREAM, Datagram = SOCK_DGRAM, Raw = SOCK_RAW } ;  };

  struct Notify {
    enum _v {
      None,          
      ReceiveData,   
      Close,         
      Corrupt        
    };
  };

  virtual ~Socket();

  int getfd() const { return a_fd; }

  Type::_v getType() const { return a_type; }

  Domain::_v getDomain() const { return a_domain; }

  int getCategory() const { return a_category; }

  bool support(const char* transportClassName) const ;

  bool isBound() const { return a_isBound; }

  bool isOpened() const { return a_fd != -1; }

  virtual bool isSecure() const { return false; }

  const AccessPoint& getLocalAccessPoint() const { return a_localAccessPoint; }

  TransportFactory* getTransportFactory() const { return a_transportFactory; }

  ReceiverFactory* getReceiverFactory() { return a_receiverFactory; }

  bool setBlockingMode(const bool blockingMode) noexcept(false);

  bool setReuseMode(const bool reuseMode) noexcept(false);

  void setTransportFactory(TransportFactory* transportFactory)  { a_transportFactory = transportFactory; }

  void setReceiverFactory(ReceiverFactory& receiverFactory)  { a_receiverFactory = &receiverFactory; }

  void setCategory(const int category) { a_category = category; }

  void close() ;

  virtual void bind() noexcept(false);

  virtual std::string asString() const ;

  virtual xml::Node* asXML(xml::Node* parent) const noexcept(false);

protected:
  const Domain::_v  a_domain;
  const Type::_v a_type;
  int a_fd;
  AccessPoint a_localAccessPoint;
  bool a_isBound;
  TransportFactory* a_transportFactory;
  ReceiverFactory* a_receiverFactory;
  int a_category;

  Socket(const Domain::_v domain, const Type::_v type, TransportFactory* transportFactory = NULL);

  Socket(const INetAddress& localAddress,  const Type::_v type, TransportFactory* transportFactory = NULL);

  Socket(const std::string& path, const Type::_v type, TransportFactory* transportFactory = NULL);

  void open() noexcept(false);

  virtual void do_close() { ::close(a_fd); }

  virtual int do_bind(const struct sockaddr*, const int) noexcept(false);

  static const char* asText(const Notify::_v v) ;

private:
  bool a_reuseMode;
};

#define anna_socket_assert(a,b) \
   if ((a)) { \
      std::string msg (asString ()); \
      msg += " | "; \
      msg += b; \
      throw RuntimeException (msg, __FILE__, __LINE__); \
   }

#define anna_comm_socket_check(a,b) \
   if ((a) < 0) { \
      std::string msg (asString ()); \
      msg += " | "; \
      msg += b; \
      throw RuntimeException (msg, errno, ANNA_FILE_LOCATION); \
   }
}
}


#endif