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