Home | History | Annotate | Download | only in base 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "net/base/ip_endpoint.h"
      6 
      7 #include "base/logging.h"
      8 #include "base/strings/string_number_conversions.h"
      9 #include "base/sys_byteorder.h"
     10 #if defined(OS_WIN)
     11 #include <winsock2.h>
     12 #elif defined(OS_POSIX)
     13 #include <netinet/in.h>
     14 #endif
     15 
     16 namespace net {
     17 
     18 namespace {
     19 // By definition, socklen_t is large enough to hold both sizes.
     20 const socklen_t kSockaddrInSize = sizeof(struct sockaddr_in);
     21 const socklen_t kSockaddrIn6Size = sizeof(struct sockaddr_in6);
     22 }
     23 
     24 IPEndPoint::IPEndPoint() : port_(0) {}
     25 
     26 IPEndPoint::~IPEndPoint() {}
     27 
     28 IPEndPoint::IPEndPoint(const IPAddressNumber& address, int port)
     29     : address_(address),
     30       port_(port) {}
     31 
     32 IPEndPoint::IPEndPoint(const IPEndPoint& endpoint) {
     33   address_ = endpoint.address_;
     34   port_ = endpoint.port_;
     35 }
     36 
     37 AddressFamily IPEndPoint::GetFamily() const {
     38   return GetAddressFamily(address_);
     39 }
     40 
     41 int IPEndPoint::GetSockAddrFamily() const {
     42   switch (address_.size()) {
     43     case kIPv4AddressSize:
     44       return AF_INET;
     45     case kIPv6AddressSize:
     46       return AF_INET6;
     47     default:
     48       NOTREACHED() << "Bad IP address";
     49       return AF_UNSPEC;
     50   }
     51 }
     52 
     53 bool IPEndPoint::ToSockAddr(struct sockaddr* address,
     54                             socklen_t* address_length) const {
     55   DCHECK(address);
     56   DCHECK(address_length);
     57   switch (address_.size()) {
     58     case kIPv4AddressSize: {
     59       if (*address_length < kSockaddrInSize)
     60         return false;
     61       *address_length = kSockaddrInSize;
     62       struct sockaddr_in* addr = reinterpret_cast<struct sockaddr_in*>(address);
     63       memset(addr, 0, sizeof(struct sockaddr_in));
     64       addr->sin_family = AF_INET;
     65       addr->sin_port = base::HostToNet16(port_);
     66       memcpy(&addr->sin_addr, &address_[0], kIPv4AddressSize);
     67       break;
     68     }
     69     case kIPv6AddressSize: {
     70       if (*address_length < kSockaddrIn6Size)
     71         return false;
     72       *address_length = kSockaddrIn6Size;
     73       struct sockaddr_in6* addr6 =
     74           reinterpret_cast<struct sockaddr_in6*>(address);
     75       memset(addr6, 0, sizeof(struct sockaddr_in6));
     76       addr6->sin6_family = AF_INET6;
     77       addr6->sin6_port = base::HostToNet16(port_);
     78       memcpy(&addr6->sin6_addr, &address_[0], kIPv6AddressSize);
     79       break;
     80     }
     81     default:
     82       return false;
     83   }
     84   return true;
     85 }
     86 
     87 bool IPEndPoint::FromSockAddr(const struct sockaddr* sock_addr,
     88                               socklen_t sock_addr_len) {
     89   DCHECK(sock_addr);
     90 
     91   const uint8* address;
     92   size_t address_len;
     93   uint16 port;
     94   if (!GetIPAddressFromSockAddr(sock_addr, sock_addr_len, &address,
     95                                 &address_len, &port)) {
     96     return false;
     97   }
     98 
     99   address_.assign(address, address + address_len);
    100   port_ = port;
    101   return true;
    102 }
    103 
    104 std::string IPEndPoint::ToString() const {
    105   return IPAddressToStringWithPort(address_, port_);
    106 }
    107 
    108 std::string IPEndPoint::ToStringWithoutPort() const {
    109   return IPAddressToString(address_);
    110 }
    111 
    112 bool IPEndPoint::operator<(const IPEndPoint& that) const {
    113   // Sort IPv4 before IPv6.
    114   if (address_.size() != that.address_.size()) {
    115     return address_.size() < that.address_.size();
    116   }
    117   if (address_ != that.address_) {
    118     return address_ < that.address_;
    119   }
    120   return port_ < that.port_;
    121 }
    122 
    123 bool IPEndPoint::operator==(const IPEndPoint& that) const {
    124   return address_ == that.address_ && port_ == that.port_;
    125 }
    126 
    127 }  // namespace net
    128