1//
2// Copyright (C) 2012 The Android Open Source Project
3//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8//      http://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15//
16
17#ifndef SHILL_NET_IP_ADDRESS_H_
18#define SHILL_NET_IP_ADDRESS_H_
19
20#include <netinet/in.h>
21
22#include <string>
23
24#include "shill/net/byte_string.h"
25#include "shill/net/shill_export.h"
26
27namespace shill {
28
29class SHILL_EXPORT IPAddress {
30 public:
31  typedef unsigned char Family;
32  static const Family kFamilyUnknown;
33  static const Family kFamilyIPv4;
34  static const Family kFamilyIPv6;
35  static const char kFamilyNameUnknown[];
36  static const char kFamilyNameIPv4[];
37  static const char kFamilyNameIPv6[];
38
39  explicit IPAddress(Family family);
40  // Constructs an IPAddress object given a standard string representation of an
41  // IP address (e.g. "192.144.30.54").
42  explicit IPAddress(std::string ip_string);
43
44  // Constructs an IPAddress object from a sockaddr_in or sockaddr_in6
45  // structure, depending on the family specified in |address_struct|.  |size|
46  // specifies the actual size of the structure backing |address_struct|.
47  explicit IPAddress(const sockaddr* address_struct, size_t size);
48
49  IPAddress(Family family, const ByteString& address);
50  IPAddress(Family family, const ByteString& address, unsigned int prefix);
51  ~IPAddress();
52
53  // Since this is a copyable datatype...
54  IPAddress(const IPAddress& b)
55    : family_(b.family_),
56      address_(b.address_),
57      prefix_(b.prefix_) {}
58  IPAddress& operator=(const IPAddress& b) {
59    family_ = b.family_;
60    address_ = b.address_;
61    prefix_ = b.prefix_;
62    return *this;
63  }
64
65  // Static utilities
66  // Get the length in bytes of addresses of the given family
67  static size_t GetAddressLength(Family family);
68
69  // Returns the maximum prefix length for address family |family|, i.e.,
70  // the length of this address type in bits.
71  static size_t GetMaxPrefixLength(Family family);
72
73  // Provides a guideline for the minimum sensible prefix for this IP
74  // address.  As opposed to GetMaxPrefixLength() above, this function
75  // takes into account the class of this IP address to determine the
76  // smallest prefix that makes sense for this class of address to have.
77  // Since this function uses classful (pre-CIDR) rules to perform this
78  // estimate, this is not an absolute rule and others methods like
79  // IsValid() do not consider this a criteria.  It is only useful for
80  // making guesses as to the mimimal plausible prefix that might be
81  // viable for an address when the supplied prefix is obviously incorrect.
82  size_t GetMinPrefixLength() const;
83
84  // Returns the prefix length given an address |family| and a |mask|. For
85  // example, returns 24 for an IPv4 mask 255.255.255.0.
86  static size_t GetPrefixLengthFromMask(Family family, const std::string& mask);
87
88  // Returns an IPAddress of type |family| that has all the high-order |prefix|
89  // bits set.
90  static IPAddress GetAddressMaskFromPrefix(Family family, size_t prefix);
91
92  // Returns the name of an address family.
93  static std::string GetAddressFamilyName(Family family);
94
95  // Getters and Setters
96  Family family() const { return family_; }
97  void set_family(Family family) { family_ = family; }
98  const ByteString& address() const { return address_; }
99  unsigned int prefix() const { return prefix_; }
100  void set_prefix(unsigned int prefix) { prefix_ = prefix; }
101  const unsigned char* GetConstData() const { return address_.GetConstData(); }
102  size_t GetLength() const { return address_.GetLength(); }
103  bool IsDefault() const { return address_.IsZero(); }
104  bool IsValid() const {
105    return family_ != kFamilyUnknown &&
106        GetLength() == GetAddressLength(family_);
107  }
108
109  // Parse an IP address string.
110  bool SetAddressFromString(const std::string& address_string);
111  // Parse an "address/prefix" IP address and prefix pair from a string.
112  bool SetAddressAndPrefixFromString(const std::string& address_string);
113  // An uninitialized IPAddress is empty and invalid when constructed.
114  // Use SetAddressToDefault() to set it to the default or "all-zeroes" address.
115  void SetAddressToDefault();
116  // Return the string equivalent of the address.  Returns true if the
117  // conversion succeeds in which case |address_string| is set to the
118  // result.  Otherwise the function returns false and |address_string|
119  // is left unmodified.
120  bool IntoString(std::string* address_string) const;
121  // Similar to IntoString, but returns by value. Convenient for logging.
122  std::string ToString() const;
123
124  // Populates the address and family portion of a sockaddr_in or
125  // sockaddr_in6 structure, depending on the IPAddress family.  Returns true
126  // if the specified |size| is large enough to accommodate the address family,
127  // and a valid address and family are written to the structure.  Otherwise,
128  // false is returned and the memory at |address_struct| is unmodified.
129  bool IntoSockAddr(sockaddr* address_struct, size_t size) const;
130
131  // Returns whether |b| has the same family, address and prefix as |this|.
132  bool Equals(const IPAddress& b) const;
133
134  // Returns whether |b| has the same family and address as |this|.
135  bool HasSameAddressAs(const IPAddress& b) const;
136
137  // Perform an AND operation between the address data of |this| and that
138  // of |b|.  Returns an IPAddress containing the result of the operation.
139  // It is an error if |this| and |b| are not of the same address family
140  // or if either are not valid,
141  IPAddress MaskWith(const IPAddress& b) const;
142
143  // Perform an OR operation between the address data of |this| and that
144  // of |b|.  Returns an IPAddress containing the result of the operation.
145  // It is an error if |this| and |b| are not of the same address family
146  // or if either are not valid,
147  IPAddress MergeWith(const IPAddress& b) const;
148
149  // Return an address that represents the network-part of the address,
150  // i.e, the address with all but the prefix bits masked out.
151  IPAddress GetNetworkPart() const;
152
153  // Return the default broadcast address for the IP address, by setting
154  // all of the host-part bits to 1.
155  IPAddress GetDefaultBroadcast();
156
157  // Tests whether this IPAddress is able to directly access the address
158  // |b| without an intervening gateway.  It tests whether the network
159  // part of |b| is the same as the network part of |this|, using the
160  // prefix of |this|.  Returns true if |b| is reachable, false otherwise.
161  bool CanReachAddress(const IPAddress& b) const;
162
163 private:
164  Family family_;
165  ByteString address_;
166  unsigned int prefix_;
167  // NO DISALLOW_COPY_AND_ASSIGN -- we assign IPAddresses in STL datatypes
168};
169
170}  // namespace shill
171
172#endif  // SHILL_NET_IP_ADDRESS_H_
173