network.cpp
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2014-2017, Regents of the University of California,
4  * Arizona Board of Regents,
5  * Colorado State University,
6  * University Pierre & Marie Curie, Sorbonne University,
7  * Washington University in St. Louis,
8  * Beijing Institute of Technology,
9  * The University of Memphis
10  *
11  * This file is part of NFD (Named Data Networking Forwarding Daemon).
12  * See AUTHORS.md for complete list of NFD authors and contributors.
13  *
14  * NFD is free software: you can redistribute it and/or modify it under the terms
15  * of the GNU General Public License as published by the Free Software Foundation,
16  * either version 3 of the License, or (at your option) any later version.
17  *
18  * NFD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
19  * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
20  * PURPOSE. See the GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License along with
23  * NFD, e.g., in COPYING.md file. If not, see <http://www.gnu.org/licenses/>.
24  */
25 
26 #include "network.hpp"
27 
28 #include <ndn-cxx/net/address-converter.hpp>
29 #include <boost/utility/value_init.hpp>
30 #include <algorithm>
31 
32 namespace nfd {
33 
34 Network::Network() = default;
35 
36 Network::Network(const boost::asio::ip::address& minAddress,
37  const boost::asio::ip::address& maxAddress)
38  : m_minAddress(minAddress)
39  , m_maxAddress(maxAddress)
40 {
41 }
42 
43 const Network&
45 {
46  using boost::asio::ip::address_v4;
47  static Network range{address_v4{}, address_v4{0xffffffff}};
48  return range;
49 }
50 
51 const Network&
53 {
54  using boost::asio::ip::address_v6;
55  static address_v6::bytes_type maxV6 = {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
56  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}};
57  static Network range{address_v6{}, address_v6{maxV6}};
58  return range;
59 }
60 
61 bool
62 Network::isValidCidr(const std::string& cidr)
63 {
64  auto pos = cidr.find('/');
65  if (pos == std::string::npos) {
66  return false;
67  }
68 
69  boost::system::error_code invalidIp;
70  boost::asio::ip::address_v4::from_string(cidr.substr(0, pos), invalidIp);
71  if (invalidIp) {
72  return false;
73  }
74 
75  auto prefixLenStr = cidr.substr(pos + 1);
76  if (!std::all_of(prefixLenStr.begin(), prefixLenStr.end(), ::isdigit)) {
77  return false;
78  }
79  int prefixLen = -1;
80  try {
81  prefixLen = boost::lexical_cast<int>(prefixLenStr);
82  }
83  catch (const boost::bad_lexical_cast&) {
84  return false;
85  }
86  if (prefixLen < 0 || prefixLen > 32) {
87  return false;
88  }
89 
90  return true;
91 }
92 
93 std::ostream&
94 operator<<(std::ostream& os, const Network& network)
95 {
96  return os << network.m_minAddress << " <-> " << network.m_maxAddress;
97 }
98 
99 std::istream&
100 operator>>(std::istream& is, Network& network)
101 {
102  namespace ip = boost::asio::ip;
103 
104  std::string networkStr;
105  is >> networkStr;
106 
107  size_t position = networkStr.find('/');
108  if (position == std::string::npos) {
109  network.m_minAddress = ndn::ip::addressFromString(networkStr);
110  network.m_maxAddress = ndn::ip::addressFromString(networkStr);
111  }
112  else {
113  ip::address address = ndn::ip::addressFromString(networkStr.substr(0, position));
114  size_t mask = boost::lexical_cast<size_t>(networkStr.substr(position+1));
115 
116  if (address.is_v4()) {
117  ip::address_v4::bytes_type maskBytes = boost::initialized_value;
118  for (size_t i = 0; i < mask; i++) {
119  size_t byteId = i / 8;
120  size_t bitIndex = 7 - i % 8;
121  maskBytes[byteId] |= (1 << bitIndex);
122  }
123 
124  ip::address_v4::bytes_type addressBytes = address.to_v4().to_bytes();
125  ip::address_v4::bytes_type min;
126  ip::address_v4::bytes_type max;
127 
128  for (size_t i = 0; i < addressBytes.size(); i++) {
129  min[i] = addressBytes[i] & maskBytes[i];
130  max[i] = addressBytes[i] | ~(maskBytes[i]);
131  }
132 
133  network.m_minAddress = ip::address_v4(min);
134  network.m_maxAddress = ip::address_v4(max);
135  }
136  else {
137  ip::address_v6::bytes_type maskBytes = boost::initialized_value;
138  for (size_t i = 0; i < mask; i++) {
139  size_t byteId = i / 8;
140  size_t bitIndex = 7 - i % 8;
141  maskBytes[byteId] |= (1 << bitIndex);
142  }
143 
144  ip::address_v6::bytes_type addressBytes = address.to_v6().to_bytes();
145  ip::address_v6::bytes_type min;
146  ip::address_v6::bytes_type max;
147 
148  for (size_t i = 0; i < addressBytes.size(); i++) {
149  min[i] = addressBytes[i] & maskBytes[i];
150  max[i] = addressBytes[i] | ~(maskBytes[i]);
151  }
152 
153  network.m_minAddress = ip::address_v6(min);
154  network.m_maxAddress = ip::address_v6(max);
155  }
156  }
157 
158  return is;
159 }
160 
161 } // namespace nfd
friend std::ostream & operator<<(std::ostream &os, const Network &network)
Definition: network.cpp:94
static bool isValidCidr(const std::string &cidr)
Definition: network.cpp:62
Copyright (c) 2014-2015, Regents of the University of California, Arizona Board of Regents...
Definition: algorithm.hpp:32
static const Network & getMaxRangeV6()
Definition: network.cpp:52
friend std::istream & operator>>(std::istream &is, Network &network)
Definition: network.cpp:100
static const Network & getMaxRangeV4()
Definition: network.cpp:44