src/Network/Address.cc
changeset 381 9b35bc329d23
parent 380 d193dd1d8a7e
equal deleted inserted replaced
380:d193dd1d8a7e 381:9b35bc329d23
     1 
     1 
     2 #include "Address.hh"
     2 #include "Address.hh"
     3 
     3 
     4 #include <sstream>
     4 #include <sstream>
     5 
     5 
     6 NetworkAddress::NetworkAddress (void) :
     6 NetworkEndpoint::NetworkEndpoint (void) :
     7     hostname(), service(), address_length(0)
     7     hostname(), service()
     8 {
     8 {
     9 
     9 
    10 }
    10 }
    11 
    11 
    12 NetworkAddress::NetworkAddress (std::string service) :
    12 NetworkEndpoint::NetworkEndpoint (std::string service) :
    13     hostname(), service(service), address_length(0)
    13     hostname(), service(service)
    14 {
    14 {
    15 
    15 
    16 }
    16 }
    17         
    17         
    18 NetworkAddress::NetworkAddress (std::string hostname, std::string service) :
    18 NetworkEndpoint::NetworkEndpoint (std::string hostname, std::string service) :
    19     hostname(hostname), service(service), address_length(0)
    19     hostname(hostname), service(service)
    20 {
    20 {
    21 
    21 
    22 }
    22 }
    23         
    23        
    24 NetworkAddress::NetworkAddress (const sockaddr *addr, socklen_t len) :
    24 addrinfo* NetworkEndpoint::get_addrinfo (int family, int socktype, int protocol, int flags) const {
    25     hostname(), service(), address_length(0)
       
    26 {
       
    27     // proxy to set_sockaddr
       
    28     set_sockaddr(addr, len);
       
    29 }
       
    30         
       
    31 addrinfo* NetworkAddress::get_addrinfo (int family, int socktype, int protocol, int flags) const {
       
    32     addrinfo hints, *results;
    25     addrinfo hints, *results;
    33     int err;
    26     int err;
    34     
    27     
    35     // initialize flags
    28     // initialize flags
    36     hints.ai_flags = flags;
    29     hints.ai_flags = flags;
    51 
    44 
    52     // done
    45     // done
    53     return results;
    46     return results;
    54 }
    47 }
    55         
    48         
    56 const sockaddr* NetworkAddress::get_sockaddr (socklen_t &len_ref) const {
    49 void NetworkEndpoint::free_addrinfo (addrinfo *info) const {
    57     // we can't figure this out ourselves...
    50     freeaddrinfo(info);
    58     if (address_length == 0)
       
    59         throw Error("NetworkAddress::get_sockaddr called without a valid sockaddr set");
       
    60     
       
    61     // update len
       
    62     len_ref = address_length;
       
    63     
       
    64     // and return a pointer to our internal address
       
    65     return (const sockaddr*) &address;
       
    66 }
    51 }
    67 
    52 
    68 void NetworkAddress::set_sockaddr (const sockaddr *addr, socklen_t len) {
    53 std::ostream& operator<< (std::ostream &s, const NetworkEndpoint &addr) {
    69     char host_buf[NI_MAXHOST], serv_buf[NI_MAXSERV];
       
    70     int err;
       
    71 
       
    72     // invalid length?
       
    73     if (len > sizeof(this->address))
       
    74         throw NetworkAddressError(*this, "set_sockaddr", "invalid sockaddr length");
       
    75 
       
    76     // do getnameinfo()
       
    77     if ((err = getnameinfo(addr, len, host_buf, NI_MAXHOST, serv_buf, NI_MAXSERV, NI_NUMERICHOST | NI_NUMERICSERV)))
       
    78         throw NetworkAddressError(*this, "getnameinfo", gai_strerror(err));
       
    79     
       
    80     // copy over to address
       
    81     memcpy(&this->address, addr, len);
       
    82 
       
    83     // and update address_length
       
    84     this->address_length = len;
       
    85 
       
    86     // and the hostname + service
       
    87     hostname = host_buf;
       
    88     service = serv_buf;
       
    89 }
       
    90 
       
    91 std::ostream& operator<< (std::ostream &s, const NetworkAddress &addr) {
       
    92     s << "[" << addr.get_hostname() << ":" << addr.get_service() << "]";
    54     s << "[" << addr.get_hostname() << ":" << addr.get_service() << "]";
    93 
    55 
    94     return s;
    56     return s;
    95 
    57 
    96 }
    58 }
    97  
    59  
    98 std::string NetworkAddressError::build_str (const NetworkAddress &addr, const char *op, const char *msg) {
    60 std::string NetworkAddressError::build_str (const NetworkEndpoint &addr, const char *op, const char *msg) {
    99     std::stringstream ss;
    61     std::stringstream ss;
   100 
    62 
   101     ss << op << ": " << addr << ": " << msg;
    63     ss << op << ": " << addr << ": " << msg;
   102 
    64 
   103     return ss.str();
    65     return ss.str();
   104 }
    66 }
   105 
    67 
   106 NetworkAddressError::NetworkAddressError (const NetworkAddress &addr, const char *op, const char *msg) :
    68 NetworkAddressError::NetworkAddressError (const NetworkEndpoint &addr, const char *op, const char *msg) :
   107     Error(build_str(addr, op, msg))
    69     Error(build_str(addr, op, msg))
   108 {
    70 {
   109 
    71 
   110 }
    72 }
   111 
    73 
   112 
       
   113