NS-3 based Named Data Networking (NDN) simulator
ndnSIM 2.5: NDN, CCN, CCNx, content centric networks
API Documentation
tcp-channel.cpp
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * Copyright (c) 2014-2022, 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 "tcp-channel.hpp"
27 #include "face.hpp"
28 #include "generic-link-service.hpp"
29 #include "tcp-transport.hpp"
30 #include "common/global.hpp"
31 
32 namespace nfd {
33 namespace face {
34 
36 
37 namespace ip = boost::asio::ip;
38 
39 TcpChannel::TcpChannel(const tcp::Endpoint& localEndpoint, bool wantCongestionMarking,
40  DetermineFaceScopeFromAddress determineFaceScope)
41  : m_localEndpoint(localEndpoint)
42  , m_acceptor(getGlobalIoService())
43  , m_socket(getGlobalIoService())
44  , m_wantCongestionMarking(wantCongestionMarking)
45  , m_determineFaceScope(std::move(determineFaceScope))
46 {
47  setUri(FaceUri(m_localEndpoint));
48  NFD_LOG_CHAN_INFO("Creating channel");
49 }
50 
51 void
53  const FaceCreationFailedCallback& onAcceptFailed,
54  int backlog/* = tcp::acceptor::max_connections*/)
55 {
56  if (isListening()) {
57  NFD_LOG_CHAN_WARN("Already listening");
58  return;
59  }
60 
61  m_acceptor.open(m_localEndpoint.protocol());
62  m_acceptor.set_option(ip::tcp::acceptor::reuse_address(true));
63  if (m_localEndpoint.address().is_v6()) {
64  m_acceptor.set_option(ip::v6_only(true));
65  }
66  m_acceptor.bind(m_localEndpoint);
67  m_acceptor.listen(backlog);
68 
69  accept(onFaceCreated, onAcceptFailed);
70  NFD_LOG_CHAN_DEBUG("Started listening");
71 }
72 
73 void
74 TcpChannel::connect(const tcp::Endpoint& remoteEndpoint,
75  const FaceParams& params,
76  const FaceCreatedCallback& onFaceCreated,
77  const FaceCreationFailedCallback& onConnectFailed,
79 {
80  auto it = m_channelFaces.find(remoteEndpoint);
81  if (it != m_channelFaces.end()) {
82  NFD_LOG_CHAN_TRACE("Reusing existing face for " << remoteEndpoint);
83  onFaceCreated(it->second);
84  return;
85  }
86 
87  auto clientSocket = make_shared<ip::tcp::socket>(getGlobalIoService());
88  auto timeoutEvent = getScheduler().schedule(timeout, [=] {
89  handleConnectTimeout(remoteEndpoint, clientSocket, onConnectFailed);
90  });
91 
92  NFD_LOG_CHAN_TRACE("Connecting to " << remoteEndpoint);
93  clientSocket->async_connect(remoteEndpoint, [=] (const auto& e) {
94  this->handleConnect(e, remoteEndpoint, clientSocket, params, timeoutEvent, onFaceCreated, onConnectFailed);
95  });
96 }
97 
98 void
99 TcpChannel::createFace(ip::tcp::socket&& socket,
100  const FaceParams& params,
101  const FaceCreatedCallback& onFaceCreated,
102  const FaceCreationFailedCallback& onFaceCreationFailed)
103 {
104  shared_ptr<Face> face;
105  boost::system::error_code ec;
106  tcp::Endpoint remoteEndpoint = socket.remote_endpoint(ec);
107  if (ec) {
108  NFD_LOG_CHAN_DEBUG("Retrieve socket remote endpoint failed: " << ec.message());
109  if (onFaceCreationFailed) {
110  onFaceCreationFailed(500, "Retrieve socket remote endpoint failed: " + ec.message());
111  }
112  return;
113  }
114 
115  auto it = m_channelFaces.find(remoteEndpoint);
116  if (it == m_channelFaces.end()) {
117  GenericLinkService::Options options;
118  options.allowLocalFields = params.wantLocalFields;
119  options.reliabilityOptions.isEnabled = params.wantLpReliability;
120 
121  if (boost::logic::indeterminate(params.wantCongestionMarking)) {
122  // Use default value for this channel if parameter is indeterminate
123  options.allowCongestionMarking = m_wantCongestionMarking;
124  }
125  else {
126  options.allowCongestionMarking = bool(params.wantCongestionMarking);
127  }
128 
129  if (params.baseCongestionMarkingInterval) {
130  options.baseCongestionMarkingInterval = *params.baseCongestionMarkingInterval;
131  }
132  if (params.defaultCongestionThreshold) {
133  options.defaultCongestionThreshold = *params.defaultCongestionThreshold;
134  }
135 
136  auto linkService = make_unique<GenericLinkService>(options);
137  auto faceScope = m_determineFaceScope(socket.local_endpoint().address(),
138  socket.remote_endpoint().address());
139  auto transport = make_unique<TcpTransport>(std::move(socket), params.persistency, faceScope);
140  face = make_shared<Face>(std::move(linkService), std::move(transport));
141  face->setChannel(shared_from_this()); // use weak_from_this() in C++17
142 
143  m_channelFaces[remoteEndpoint] = face;
144  connectFaceClosedSignal(*face, [this, remoteEndpoint] { m_channelFaces.erase(remoteEndpoint); });
145  }
146  else {
147  // we already have a face for this endpoint, just reuse it
148  face = it->second;
149  NFD_LOG_CHAN_TRACE("Reusing existing face for " << remoteEndpoint);
150 
151  boost::system::error_code error;
152  socket.shutdown(ip::tcp::socket::shutdown_both, error);
153  socket.close(error);
154  }
155 
156  // Need to invoke the callback regardless of whether or not we have already created
157  // the face so that control responses and such can be sent.
158  onFaceCreated(face);
159 }
160 
161 void
162 TcpChannel::accept(const FaceCreatedCallback& onFaceCreated,
163  const FaceCreationFailedCallback& onAcceptFailed)
164 {
165  m_acceptor.async_accept(m_socket, [=] (const auto& e) { this->handleAccept(e, onFaceCreated, onAcceptFailed); });
166 }
167 
168 void
169 TcpChannel::handleAccept(const boost::system::error_code& error,
170  const FaceCreatedCallback& onFaceCreated,
171  const FaceCreationFailedCallback& onAcceptFailed)
172 {
173  if (error) {
175  NFD_LOG_CHAN_DEBUG("Accept failed: " << error.message());
176  if (onAcceptFailed)
177  onAcceptFailed(500, "Accept failed: " + error.message());
178  }
179  return;
180  }
181 
182  NFD_LOG_CHAN_TRACE("Incoming connection from " << m_socket.remote_endpoint());
183 
184  FaceParams params;
186  createFace(std::move(m_socket), params, onFaceCreated, onAcceptFailed);
187 
188  // prepare accepting the next connection
189  accept(onFaceCreated, onAcceptFailed);
190 }
191 
192 void
193 TcpChannel::handleConnect(const boost::system::error_code& error,
194  const tcp::Endpoint& remoteEndpoint,
195  const shared_ptr<ip::tcp::socket>& socket,
196  const FaceParams& params,
197  const scheduler::EventId& connectTimeoutEvent,
198  const FaceCreatedCallback& onFaceCreated,
199  const FaceCreationFailedCallback& onConnectFailed)
200 {
201  connectTimeoutEvent.cancel();
202 
203  if (error) {
205  NFD_LOG_CHAN_DEBUG("Connection to " << remoteEndpoint << " failed: " << error.message());
206  if (onConnectFailed)
207  onConnectFailed(504, "Connection failed: " + error.message());
208  }
209  return;
210  }
211 
212  NFD_LOG_CHAN_TRACE("Connected to " << socket->remote_endpoint());
213  createFace(std::move(*socket), params, onFaceCreated, onConnectFailed);
214 }
215 
216 void
217 TcpChannel::handleConnectTimeout(const tcp::Endpoint& remoteEndpoint,
218  const shared_ptr<ip::tcp::socket>& socket,
219  const FaceCreationFailedCallback& onConnectFailed)
220 {
221  NFD_LOG_CHAN_DEBUG("Connection to " << remoteEndpoint << " timed out");
222 
223  // abort the connection attempt
224  boost::system::error_code error;
225  socket->close(error);
226 
227  if (onConnectFailed)
228  onConnectFailed(504, "Connection timed out");
229 }
230 
231 } // namespace face
232 } // namespace nfd
optional< uint64_t > defaultCongestionThreshold
Definition: face-common.hpp:82
void setUri(const FaceUri &uri)
Definition: channel.cpp:35
#define NFD_LOG_INIT(name)
Definition: logger.hpp:31
boost::logic::tribool wantCongestionMarking
Definition: face-common.hpp:86
Accept any value the remote endpoint offers.
Definition: enabled.hpp:207
std::function< ndn::nfd::FaceScope(const boost::asio::ip::address &local, const boost::asio::ip::address &remote)> DetermineFaceScopeFromAddress
Definition: tcp-channel.hpp:40
ndn::nfd::FacePersistency persistency
Definition: face-common.hpp:80
STL namespace.
detail::SimulatorIo & getGlobalIoService()
Returns the global io_service instance for the calling thread.
Definition: global.cpp:49
std::function< void(uint32_t status, const std::string &reason)> FaceCreationFailedCallback
Prototype for the callback that is invoked when a face fails to be created.
Definition: channel.hpp:90
void listen(const FaceCreatedCallback &onFaceCreated, const FaceCreationFailedCallback &onAcceptFailed, int backlog=boost::asio::ip::tcp::acceptor::max_connections)
Enable listening on the local endpoint, accept connections, and create faces when remote host makes a...
Definition: tcp-channel.cpp:52
A handle for a scheduled event.
Definition: scheduler.hpp:58
void connectFaceClosedSignal(Face &face, std::function< void()> f)
Invokes a callback when a face is closed.
Definition: channel.cpp:47
Scheduler & getScheduler()
Returns the global Scheduler instance for the calling thread.
Definition: global.cpp:70
#define NFD_LOG_CHAN_DEBUG(msg)
Log a message at DEBUG level.
Definition: channel-log.hpp:49
TcpChannel(const tcp::Endpoint &localEndpoint, bool wantCongestionMarking, DetermineFaceScopeFromAddress determineFaceScope)
Create TCP channel for the local endpoint.
Definition: tcp-channel.cpp:39
optional< time::nanoseconds > baseCongestionMarkingInterval
Definition: face-common.hpp:81
Copyright (c) 2011-2015 Regents of the University of California.
Definition: ndn-common.hpp:39
#define NFD_LOG_CHAN_INFO(msg)
Log a message at INFO level.
Definition: channel-log.hpp:52
#define NFD_LOG_CHAN_TRACE(msg)
Log a message at TRACE level.
Definition: channel-log.hpp:46
boost::asio::ip::tcp::endpoint Endpoint
Definition: tcp-channel.hpp:34
#define NFD_LOG_CHAN_WARN(msg)
Log a message at WARN level.
Definition: channel-log.hpp:55
represents the underlying protocol and address used by a Face
Definition: face-uri.hpp:44
bool isListening() const final
Returns whether the channel is listening.
Definition: tcp-channel.hpp:62
void connect(const tcp::Endpoint &remoteEndpoint, const FaceParams &params, const FaceCreatedCallback &onFaceCreated, const FaceCreationFailedCallback &onConnectFailed, time::nanoseconds timeout=8_s)
Create a face by establishing a TCP connection to remoteEndpoint.
Definition: tcp-channel.cpp:74
std::function< void(const shared_ptr< Face > &)> FaceCreatedCallback
Prototype for the callback that is invoked when a face is created (in response to an incoming connect...
Definition: channel.hpp:86
Catch-all error for socket component errors that don&#39;t fit in other categories.
Definition: base.hpp:83
Class implementing TCP-based channel to create faces.
Definition: tcp-channel.hpp:49
void cancel() const
Cancel the operation.
boost::chrono::nanoseconds nanoseconds
Definition: time.hpp:50
Parameters used to set Transport properties or LinkService options on a newly created face...
Definition: face-common.hpp:78