1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
// Copyright (c) 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef NET_BASE_IP_ADDRESS_NET_H_
#define NET_BASE_IP_ADDRESS_NET_H_
#include <stddef.h>
#include <stdint.h>
#include <string>
#include <vector>
#include "base/compiler_specific.h"
#include "base/strings/string_piece.h"
#include "net/base/ip_address_number.h"
#include "net/base/net_export.h"
namespace net {
class NET_EXPORT IPAddress {
public:
enum : size_t { kIPv4AddressSize = 4, kIPv6AddressSize = 16 };
// Creates a zero-sized, invalid address.
IPAddress();
// Creates an IP address from a deprecated IPAddressNumber.
explicit IPAddress(const IPAddressNumber& address);
IPAddress(const IPAddress& other);
// Copies the input address to |ip_address_|. The input is expected to be in
// network byte order.
template <size_t N>
IPAddress(const uint8_t(&address)[N])
: IPAddress(address, N) {}
// Copies the input address to |ip_address_| taking an additional length
// parameter. The input is expected to be in network byte order.
IPAddress(const uint8_t* address, size_t address_len);
// Initializes |ip_address_| from the 4 bX bytes. The bytes are expected to be
// in network byte order.
IPAddress(uint8_t b0, uint8_t b1, uint8_t b2, uint8_t b3);
~IPAddress();
// Returns true if the IP has |kIPv4AddressSize| elements.
bool IsIPv4() const;
// Returns true if the IP has |kIPv6AddressSize| elements.
bool IsIPv6() const;
// Returns true if the IP is either an IPv4 or IPv6 address. This function
// only checks the address length.
bool IsValid() const;
// Returns true if an IP address hostname is in a range reserved by the IANA.
// Works with both IPv4 and IPv6 addresses, and only compares against a given
// protocols's reserved ranges.
bool IsReserved() const;
// Returns true if the IP is "zero" (e.g. the 0.0.0.0 IPv4 address).
bool IsZero() const;
// Returns true if |ip_address_| is an IPv4-mapped IPv6 address.
bool IsIPv4MappedIPv6() const;
// The size in bytes of |ip_address_|.
size_t size() const { return ip_address_.size(); }
// Returns true if the IP is an empty, zero-sized (invalid) address.
bool empty() const { return ip_address_.empty(); }
// Returns the canonical string representation of an IP address.
// For example: "192.168.0.1" or "::1". Returns the empty string when
// |ip_address_| is invalid.
std::string ToString() const;
// Parses an IP address literal (either IPv4 or IPv6) to its numeric value.
// Returns true on success and fills |ip_address_| with the numeric value.
bool AssignFromIPLiteral(const base::StringPiece& ip_literal)
WARN_UNUSED_RESULT;
// Returns the underlying byte vector.
const std::vector<uint8_t>& bytes() const { return ip_address_; };
// Returns an IPAddress instance representing the 127.0.0.1 address.
static IPAddress IPv4Localhost();
// Returns an IPAddress instance representing the ::1 address.
static IPAddress IPv6Localhost();
// Returns an IPAddress made up of |num_zero_bytes| zeros.
static IPAddress AllZeros(size_t num_zero_bytes);
bool operator==(const IPAddress& that) const;
bool operator!=(const IPAddress& that) const;
bool operator<(const IPAddress& that) const;
private:
// IPv4 addresses will have length kIPv4AddressSize, whereas IPv6 address
// will have length kIPv6AddressSize.
std::vector<uint8_t> ip_address_;
// This class is copyable and assignable.
};
using IPAddressList = std::vector<IPAddress>;
// TODO(Martijnc): These utility functions currently forward the calls to
// the IPAddressNumber implementations. Move the implementations over when
// the IPAddressNumber migration is complete. https://crbug.com/496258.
// Returns the canonical string representation of an IP address along with its
// port. For example: "192.168.0.1:99" or "[::1]:80".
NET_EXPORT std::string IPAddressToStringWithPort(const IPAddress& address,
uint16_t port);
// Returns the address as a sequence of bytes in network-byte-order.
NET_EXPORT std::string IPAddressToPackedString(const IPAddress& address);
// Converts an IPv4 address to an IPv4-mapped IPv6 address.
// For example 192.168.0.1 would be converted to ::ffff:192.168.0.1.
NET_EXPORT IPAddress ConvertIPv4ToIPv4MappedIPv6(const IPAddress& address);
// Converts an IPv4-mapped IPv6 address to IPv4 address. Should only be called
// on IPv4-mapped IPv6 addresses.
NET_EXPORT IPAddress ConvertIPv4MappedIPv6ToIPv4(const IPAddress& address);
// Compares an IP address to see if it falls within the specified IP block.
// Returns true if it does, false otherwise.
//
// The IP block is given by (|ip_prefix|, |prefix_length_in_bits|) -- any
// IP address whose |prefix_length_in_bits| most significant bits match
// |ip_prefix| will be matched.
//
// In cases when an IPv4 address is being compared to an IPv6 address prefix
// and vice versa, the IPv4 addresses will be converted to IPv4-mapped
// (IPv6) addresses.
NET_EXPORT bool IPAddressMatchesPrefix(const IPAddress& ip_address,
const IPAddress& ip_prefix,
size_t prefix_length_in_bits);
// Returns number of matching initial bits between the addresses |a1| and |a2|.
unsigned CommonPrefixLength(const IPAddress& a1, const IPAddress& a2);
// Computes the number of leading 1-bits in |mask|.
unsigned MaskPrefixLength(const IPAddress& mask);
// Checks whether |address| starts with |prefix|. This provides similar
// functionality as IPAddressMatchesPrefix() but doesn't perform automatic IPv4
// to IPv4MappedIPv6 conversions and only checks against full bytes.
template <size_t N>
bool IPAddressStartsWith(const IPAddress& address, const uint8_t (&prefix)[N]) {
if (address.size() < N)
return false;
return std::equal(prefix, prefix + N, address.bytes().begin());
}
} // namespace net
#endif // NET_BASE_IP_ADDRESS_NET_H_
|
