NS-3 based Named Data Networking (NDN) simulator
ndnSIM 2.5: NDN, CCN, CCNx, content centric networks
API Documentation
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-2018, 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 <boost/utility/value_init.hpp>
29 #include <algorithm>
30 #include <cctype>
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  try {
70  boost::lexical_cast<Network>(cidr);
71  return true;
72  }
73  catch (const boost::bad_lexical_cast&) {
74  return false;
75  }
76 }
77 
78 std::ostream&
79 operator<<(std::ostream& os, const Network& network)
80 {
81  return os << network.m_minAddress << " <-> " << network.m_maxAddress;
82 }
83 
84 std::istream&
85 operator>>(std::istream& is, Network& network)
86 {
87  namespace ip = boost::asio::ip;
88 
89  std::string networkStr;
90  is >> networkStr;
91 
92  size_t position = networkStr.find('/');
93  if (position == std::string::npos) {
94  try {
95  network.m_minAddress = ip::address::from_string(networkStr);
96  network.m_maxAddress = ip::address::from_string(networkStr);
97  }
98  catch (const boost::system::system_error&) {
99  is.setstate(std::ios::failbit);
100  return is;
101  }
102  }
103  else {
104  boost::system::error_code ec;
105  auto address = ip::address::from_string(networkStr.substr(0, position), ec);
106  if (ec) {
107  is.setstate(std::ios::failbit);
108  return is;
109  }
110 
111  auto prefixLenStr = networkStr.substr(position + 1);
112  if (!std::all_of(prefixLenStr.begin(), prefixLenStr.end(),
113  [] (unsigned char c) { return std::isdigit(c); })) {
114  is.setstate(std::ios::failbit);
115  return is;
116  }
117  size_t mask;
118  try {
119  mask = boost::lexical_cast<size_t>(prefixLenStr);
120  }
121  catch (const boost::bad_lexical_cast&) {
122  is.setstate(std::ios::failbit);
123  return is;
124  }
125 
126  if (address.is_v4()) {
127  if (mask > 32) {
128  is.setstate(std::ios::failbit);
129  return is;
130  }
131 
132  ip::address_v4::bytes_type maskBytes = boost::initialized_value;
133  for (size_t i = 0; i < mask; i++) {
134  size_t byteId = i / 8;
135  size_t bitIndex = 7 - i % 8;
136  maskBytes[byteId] |= (1 << bitIndex);
137  }
138 
139  ip::address_v4::bytes_type addressBytes = address.to_v4().to_bytes();
140  ip::address_v4::bytes_type min;
141  ip::address_v4::bytes_type max;
142 
143  for (size_t i = 0; i < addressBytes.size(); i++) {
144  min[i] = addressBytes[i] & maskBytes[i];
145  max[i] = addressBytes[i] | ~(maskBytes[i]);
146  }
147 
148  network.m_minAddress = ip::address_v4(min);
149  network.m_maxAddress = ip::address_v4(max);
150  }
151  else {
152  if (mask > 128) {
153  is.setstate(std::ios::failbit);
154  return is;
155  }
156 
157  ip::address_v6::bytes_type maskBytes = boost::initialized_value;
158  for (size_t i = 0; i < mask; i++) {
159  size_t byteId = i / 8;
160  size_t bitIndex = 7 - i % 8;
161  maskBytes[byteId] |= (1 << bitIndex);
162  }
163 
164  ip::address_v6::bytes_type addressBytes = address.to_v6().to_bytes();
165  ip::address_v6::bytes_type min;
166  ip::address_v6::bytes_type max;
167 
168  for (size_t i = 0; i < addressBytes.size(); i++) {
169  min[i] = addressBytes[i] & maskBytes[i];
170  max[i] = addressBytes[i] | ~(maskBytes[i]);
171  }
172 
173  network.m_minAddress = ip::address_v6(min);
174  network.m_maxAddress = ip::address_v6(max);
175  }
176  }
177 
178  return is;
179 }
180 
181 } // namespace nfd
nfd::Network
Definition: network.hpp:34
nfd::Network::Network
Network()
nfd::Network::isValidCidr
static bool isValidCidr(const std::string &cidr)
Definition: network.cpp:62
nfd
Copyright (c) 2011-2015 Regents of the University of California.
Definition: ndn-common.hpp:40
nfd::Network::getMaxRangeV4
static const Network & getMaxRangeV4()
Definition: network.cpp:44
nfd::operator<<
std::ostream & operator<<(std::ostream &os, const Network &network)
Definition: network.cpp:79
network.hpp
nfd::Network::getMaxRangeV6
static const Network & getMaxRangeV6()
Definition: network.cpp:52
nfd::operator>>
std::istream & operator>>(std::istream &is, Network &network)
Definition: network.cpp:85