src/socket/inet.hpp

   1 #ifndef POSIXX_SOCKET_INET_HPP_
   2 #define POSIXX_SOCKET_INET_HPP_
   3
   4 #include "basic_socket.hpp" // posixx::socket
   5
   6 #include <netinet/in.h> // sockaddr_in, htonl, htons, {PF,AF}_INET, INADDR_ANY
   7 #include <arpa/inet.h> // inet_addr
   8 #include <cstring> // memset
   9 #include <string> // std::string
  10
  11 /// @file
  12
  13 namespace posixx { namespace socket {
  14
  15 /// Internet Protocol sockets
  16 namespace inet {
  17
  18
  19 /// Address to accept any incoming messages
  20 const uint32_t any = INADDR_ANY;
  21
  22 /// Address to send to all hosts
  23 const uint32_t broadcast = INADDR_BROADCAST;
  24
  25
  26 /// IP socket address
  27 struct sockaddr: sockaddr_in
  28 {
  29
  30         /**
  31          * Create an IP socket address.
  32          *
  33          * @note The IP address is expected in network byte order but the
  34          *       port is expected in host byte order. This is because this
  35          *       constructor is expected to be used with predefined IP
  36          *       addresses, like any, none, loopback, etc.
  37          *
  38          * @param addr IP address in network byte order
  39          * @param port IP port in host byte order
  40          *
  41          * @see any, none, etc. constants
  42          */
  43         explicit sockaddr(uint32_t addr = any, uint16_t port = 0) throw ();
  44
  45         /**
  46          * Create an IP socket address.
  47          *
  48          * @param addr String representation of the IP address
  49          * @param port IP port in host byte order
  50          */
  51         explicit sockaddr(const std::string& addr, uint16_t port) throw ();
  52
  53         /**
  54          * Set the IP address and port.
  55          *
  56          * @param addr IP address in network byte order
  57          * @param port IP port in host byte order
  58          *
  59          * @see sockaddr(uint32_t, uint16_t)
  60          */
  61         void set(uint32_t addr, uint16_t port) throw();
  62
  63         /**
  64          * Set the IP address and port.
  65          *
  66          * @param addr String representation of the IP address
  67          * @param port IP port in host byte order
  68          *
  69          * @see sockaddr(const std::string&, uint16_t)
  70          */
  71         void set(const std::string& addr, uint16_t port) throw();
  72
  73         /// Get the IP address as a string
  74         std::string addr() const throw ();
  75
  76         /// Set the IP address (in network byte order)
  77         void addr(uint32_t addr) throw ();
  78
  79         /// Set the IP address from a string
  80         void addr(const std::string& addr) throw ();
  81
  82         /// Get the port number
  83         uint16_t port() const throw ();
  84
  85         /// Set the port number (port is expected to be in host byte order)
  86         void port(uint16_t port) throw ();
  87
  88         /// Length of this IP socket address
  89         socklen_t length() const throw ();
  90
  91         /// Compare two IP socket addresses
  92         bool operator == (const sockaddr& other) const throw ();
  93
  94 }; // struct sockaddr
  95
  96 /// IP socket traits
  97 struct traits
  98 {
  99         /// Socket address type.
 100         typedef inet::sockaddr sockaddr;
 101         /// Protocol family.
 102         enum { PF = PF_INET };
 103 };
 104
 105 /// IP socket
 106 typedef posixx::socket::basic_socket< traits > socket;
 107
 108 } } } // namespace posixx::socket::inet
 109
 110
 111
 112
 113 inline
 114 posixx::socket::inet::sockaddr::sockaddr(uint32_t addr, uint16_t port)
 115                 throw ()
 116 {
 117         memset(this, 0, sizeof(struct sockaddr_in));
 118         sin_family = AF_INET;
 119         set(addr, port);
 120 }
 121
 122 inline
 123 posixx::socket::inet::sockaddr::sockaddr(const std::string& addr, uint16_t port)
 124                 throw ()
 125 {
 126         memset(this, 0, sizeof(struct sockaddr_in));
 127         sin_family = AF_INET;
 128         set(addr, port);
 129 }
 130
 131 inline
 132 void posixx::socket::inet::sockaddr::set(uint32_t addr, uint16_t port)
 133                 throw ()
 134 {
 135         sin_addr.s_addr = addr;
 136         this->port(port);
 137 }
 138
 139 inline
 140 void posixx::socket::inet::sockaddr::set(const std::string& addr, uint16_t port)
 141                 throw ()
 142 {
 143         this->addr(addr);
 144         this->port(port);
 145 }
 146
 147 inline
 148 std::string posixx::socket::inet::sockaddr::addr() const throw ()
 149 {
 150         return inet_ntoa(sin_addr);
 151 }
 152
 153 inline
 154 void posixx::socket::inet::sockaddr::addr(uint32_t addr) throw ()
 155 {
 156         sin_addr.s_addr = addr;
 157 }
 158
 159 inline
 160 void posixx::socket::inet::sockaddr::addr(const std::string& addr) throw ()
 161 {
 162         sin_addr.s_addr = inet_addr(addr.c_str());
 163 }
 164
 165 inline
 166 uint16_t posixx::socket::inet::sockaddr::port() const throw ()
 167 {
 168         return ntohs(sin_port);
 169 }
 170
 171 inline
 172 void posixx::socket::inet::sockaddr::port(uint16_t port) throw ()
 173 {
 174         sin_port = htons(port);
 175 }
 176
 177 inline
 178 socklen_t posixx::socket::inet::sockaddr::length() const throw ()
 179 {
 180         return sizeof(sockaddr_in);
 181 }
 182
 183 inline
 184 bool posixx::socket::inet::sockaddr::operator == (const sockaddr& other) const
 185                 throw ()
 186 {
 187         return !memcmp(this, &other, sizeof(*this));
 188 }
 189
 190 #endif // POSIXX_SOCKET_INET_HPP_