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 16namespace net { 17 18namespace { 19// By definition, socklen_t is large enough to hold both sizes. 20const socklen_t kSockaddrInSize = sizeof(struct sockaddr_in); 21const socklen_t kSockaddrIn6Size = sizeof(struct sockaddr_in6); 22} 23 24IPEndPoint::IPEndPoint() : port_(0) {} 25 26IPEndPoint::~IPEndPoint() {} 27 28IPEndPoint::IPEndPoint(const IPAddressNumber& address, int port) 29 : address_(address), 30 port_(port) {} 31 32IPEndPoint::IPEndPoint(const IPEndPoint& endpoint) { 33 address_ = endpoint.address_; 34 port_ = endpoint.port_; 35} 36 37AddressFamily IPEndPoint::GetFamily() const { 38 return GetAddressFamily(address_); 39} 40 41int 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 53bool 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 87bool 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 104std::string IPEndPoint::ToString() const { 105 return IPAddressToStringWithPort(address_, port_); 106} 107 108std::string IPEndPoint::ToStringWithoutPort() const { 109 return IPAddressToString(address_); 110} 111 112bool 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 123bool IPEndPoint::operator==(const IPEndPoint& that) const { 124 return address_ == that.address_ && port_ == that.port_; 125} 126 127} // namespace net 128