Kea: ping_channel.cc Source File

| Kea 3.0.2-git

ping_channel.cc
Go to the documentation of this file.
1// Copyright (C) 2023-2025 Internet Systems Consortium, Inc. ("ISC")
2//
3// This Source Code Form is subject to the terms of the Mozilla Public
4// License, v. 2.0. If a copy of the MPL was not distributed with this
5// file, You can obtain one at http://mozilla.org/MPL/2.0/.
6
7#include <config.h>
8#include <ping_channel.h>
9#include <ping_check_log.h>
10#include <dhcp/iface_mgr.h>
11#include <exceptions/exceptions.h>
12#include <util/multi_threading_mgr.h>
13#include <iostream>
14
15using namespace isc;
16using namespace isc::asiolink;
17using namespace isc::dhcp;
18using namespace isc::util;
19
20namespace ph = std::placeholders;
21
22namespace isc {
23namespace ping_check {
24
25uint32_t
26PingChannel::nextEchoInstanceNum() {
27 static uint32_t echo_instance_num = 0x00010000;
28 if (echo_instance_num == UINT32_MAX) {
29 echo_instance_num = 0x00010001;
30 } else {
31 ++echo_instance_num;
32 }
33
34 return (echo_instance_num);
35}
36
37PingChannel::PingChannel(IOServicePtr& io_service,
38 NextToSendCallback next_to_send_cb,
39 UpdateToSendCallback update_to_send_cb,
40 EchoSentCallback echo_sent_cb,
41 ReplyReceivedCallback reply_received_cb,
42 ShutdownCallback shutdown_cb)
43 : io_service_(io_service),
44 next_to_send_cb_(next_to_send_cb),
45 update_to_send_cb_(update_to_send_cb),
46 echo_sent_cb_(echo_sent_cb),
47 reply_received_cb_(reply_received_cb),
48 shutdown_cb_(shutdown_cb),
49 socket_(0), input_buf_(256),
50 reading_(false), sending_(false), stopping_(false), mutex_(new std::mutex),
51 send_mutex_(new std::mutex), single_threaded_(!MultiThreadingMgr::instance().getMode()),
52 watch_socket_(0), registered_write_fd_(-1), registered_read_fd_(-1) {
53 if (!io_service_) {
54 isc_throw(BadValue,
55 "PingChannel ctor - io_service cannot be empty");
56 }
57}
58
59PingChannel::~PingChannel() {
60 close();
61}
62
63void
64PingChannel::open() {
65 try {
66 MultiThreadingLock lock(*mutex_);
67 if (socket_ && socket_->isOpen()) {
68 return;
69 }
70
71 // For open(), the endpoint is only used to determine protocol,
72 // the address is irrelevant.
73 ICMPEndpoint ping_to_endpoint(IOAddress::IPV4_ZERO_ADDRESS());
74 SocketCallback socket_cb(
75 [](boost::system::error_code ec, size_t /*length */) {
76 isc_throw(Unexpected, "ICMPSocket open is synchronous, should not invoke cb: "
77 << ec.message());
78 }
79 );
80
81 socket_.reset(new PingSocket(io_service_));
82 socket_->open(&ping_to_endpoint, socket_cb);
83 reading_ = false;
84 sending_ = false;
85 stopping_ = false;
86
87 if (single_threaded_) {
88 // Open new watch socket.
89 watch_socket_.reset(new util::WatchSocket());
90
91 // Register the WatchSocket with IfaceMgr to signal data ready to write.
92 registered_write_fd_ = watch_socket_->getSelectFd();
93 IfaceMgr::instance().addExternalSocket(registered_write_fd_, IfaceMgr::SocketCallback());
94
95 // Register ICMPSocket with IfaceMgr to signal data ready to read.
96 registered_read_fd_ = socket_->getNative();
97 IfaceMgr::instance().addExternalSocket(registered_read_fd_, IfaceMgr::SocketCallback());
98 }
99
100 } catch (const std::exception& ex) {
101 isc_throw(Unexpected, "PingChannel::open failed:" << ex.what());
102 }
103
104 LOG_DEBUG(ping_check_logger, isc::log::DBGLVL_TRACE_BASIC, PING_CHECK_CHANNEL_SOCKET_OPENED);
105}
106
107bool
108PingChannel::isOpen() const {
109 MultiThreadingLock lock(*mutex_);
110 return (socket_ && socket_->isOpen());
111}
112
113void
114PingChannel::close() {
115 try {
116 MultiThreadingLock lock(*mutex_);
117
118 if (single_threaded_) {
119 // Unregister from IfaceMgr.
120 if (registered_write_fd_ != -1) {
121 IfaceMgr::instance().deleteExternalSocket(registered_write_fd_);
122 registered_write_fd_ = -1;
123 }
124
125 if (registered_read_fd_ != -1) {
126 IfaceMgr::instance().deleteExternalSocket(registered_read_fd_);
127 registered_read_fd_ = -1;
128 }
129
130 // Close watch socket.
131 if (watch_socket_) {
132 std::string error_string;
133 watch_socket_->closeSocket(error_string);
134 if (!error_string.empty()) {
135 LOG_ERROR(ping_check_logger, PING_CHECK_CHANNEL_WATCH_SOCKET_CLOSE_ERROR)
136 .arg(error_string);
137 }
138
139 watch_socket_.reset();
140 }
141 }
142
143 if (!socket_ || !socket_->isOpen()) {
144 return;
145 }
146
147 socket_->close();
148 } catch (const std::exception& ex) {
149 // On close error, log but do not throw.
150 LOG_ERROR(ping_check_logger, PING_CHECK_CHANNEL_SOCKET_CLOSE_ERROR)
151 .arg(ex.what());
152 }
153
154 LOG_DEBUG(ping_check_logger, isc::log::DBGLVL_TRACE_BASIC, PING_CHECK_CHANNEL_SOCKET_CLOSED);
155}
156
157void
158PingChannel::stopChannel() {
159 {
160 MultiThreadingLock lock(*mutex_);
161 if (stopping_) {
162 return;
163 }
164
165 stopping_ = true;
166 }
167
168 LOG_DEBUG(ping_check_logger, isc::log::DBGLVL_TRACE_BASIC, PING_CHECK_CHANNEL_STOP);
169 close();
170
171 if (shutdown_cb_) {
172 (shutdown_cb_)();
173 }
174}
175
176void
177PingChannel::asyncReceive(void* data, size_t length, size_t offset,
178 asiolink::IOEndpoint* endpoint, SocketCallback& callback) {
179 socket_->asyncReceive(data, length, offset, endpoint, callback);
180}
181
182void
183PingChannel::asyncSend(void* data, size_t length, asiolink::IOEndpoint* endpoint,
184 SocketCallback& callback) {
185 socket_->asyncSend(data, length, endpoint, callback);
186
187 if (single_threaded_) {
188 // Set IO ready marker so sender activity is visible to select() or poll().
189 watch_socket_->markReady();
190 }
191}
192
193void
194PingChannel::doRead() {
195 try {
196 MultiThreadingLock lock(*mutex_);
197 if (!canRead()) {
198 return;
199 }
200
201 reading_ = true;
202
203 // Create instance of the callback. It is safe to pass the
204 // local instance of the callback, because the underlying
205 // std functions make copies as needed.
206 SocketCallback cb(std::bind(&PingChannel::socketReadCallback,
207 shared_from_this(),
208 ph::_1, // error
209 ph::_2)); // bytes_transferred
210 asyncReceive(static_cast<void*>(getInputBufData()), getInputBufSize(),
211 0, &reply_endpoint_, cb);
212 } catch (const std::exception& ex) {
213 // Normal IO failures should be passed to the callback. A failure here
214 // indicates the call to asyncReceive() itself failed.
215 LOG_ERROR(ping_check_logger, PING_CHECK_UNEXPECTED_READ_ERROR)
216 .arg(ex.what());
217 stopChannel();
218 }
219}
220
221void
222PingChannel::socketReadCallback(boost::system::error_code ec, size_t length) {
223 {
224 MultiThreadingLock lock(*mutex_);
225 if (stopping_) {
226 return;
227 }
228 }
229
230 if (ec) {
231 if (ec.value() == boost::asio::error::operation_aborted) {
232 // IO service has been stopped and the connection is probably
233 // going to be shutting down.
234 return;
235 } else if ((ec.value() == boost::asio::error::try_again) ||
236 (ec.value() == boost::asio::error::would_block)) {
237 // We got EWOULDBLOCK or EAGAIN which indicates that we may be able to
238 // read something from the socket on the next attempt. Just make sure
239 // we don't try to read anything now in case there is any garbage
240 // passed in length.
241 length = 0;
242 } else {
243 // Anything else is fatal for the socket.
244 LOG_ERROR(ping_check_logger, PING_CHECK_CHANNEL_SOCKET_READ_FAILED)
245 .arg(ec.message());
246 stopChannel();
247 return;
248 }
249 }
250
251 // Unpack the reply and pass it to the reply callback.
252 ICMPMsgPtr reply;
253 if (length > 0) {
254 {
255 try {
256 MultiThreadingLock lock(*mutex_);
257 reply = ICMPMsg::unpack(getInputBufData(), getInputBufSize());
258 if (reply->getType() == ICMPMsg::ECHO_REPLY) {
259 LOG_DEBUG(ping_check_logger, isc::log::DBGLVL_TRACE_DETAIL,
260 PING_CHECK_CHANNEL_ECHO_REPLY_RECEIVED)
261 .arg(reply->getSource())
262 .arg(reply->getId())
263 .arg(reply->getSequence());
264 }
265 } catch (const std::exception& ex) {
266 LOG_DEBUG(ping_check_logger, isc::log::DBGLVL_TRACE_BASIC,
267 PING_CHECK_CHANNEL_MALFORMED_PACKET_RECEIVED)
268 .arg(ex.what());
269 }
270 }
271 }
272
273 {
274 MultiThreadingLock lock(*mutex_);
275 reading_ = false;
276 }
277
278 if (reply) {
279 (reply_received_cb_)(reply);
280 }
281
282 // Start the next read.
283 doRead();
284}
285
286void
287PingChannel::startSend() {
288 MultiThreadingLock lock(*mutex_);
289 if (canSend()) {
290 // Post the call to sendNext to the IOService.
291 // This ensures its carried out on a thread
292 // associated with the channel's IOService
293 // not the thread invoking this function.
294 auto f = [](PingChannelPtr ptr) { ptr->sendNext(); };
295 io_service_->post(std::bind(f, shared_from_this()));
296 }
297}
298
299void
300PingChannel::startRead() {
301 MultiThreadingLock lock(*mutex_);
302 if (canRead()) {
303 // Post the call to doRead to the IOService.
304 // This ensures its carried out on a thread
305 // associated with the channel's IOService
306 // not the thread invoking this function.
307 auto f = [](PingChannelPtr ptr) { ptr->doRead(); };
308 io_service_->post(std::bind(f, shared_from_this()));
309 }
310}
311
312void
313PingChannel::sendNext() {
314 try {
315 // Mutex used to do atomic read of the store entry using
316 // @ref PingContextStore::getNextToSend and update the context from
317 // WAITING_TO_SEND state to SENDING state using
318 // @ref PingContext::setState. Both functions (when transitioning from
319 // WAITING_TO_SEND state to SENDING state) should be called only
320 // with this mutex locked.
321 MultiThreadingLock send_lock(*send_mutex_);
322
323 // Fetch the next one to send (outside the mutex) to avoid a possible
324 // deadlock with the mutex in the @ref PingCheckMgr::nextToSend callback.
325 PingContextPtr context = ((next_to_send_cb_)());
326 if (!context) {
327 // Nothing to send.
328 return;
329 }
330
331 MultiThreadingLock lock(*mutex_);
332 if (!canSend()) {
333 // Can't send right now, get out.
334 return;
335 }
336
337 // Update context to SENDING (inside the mutex).
338 if (update_to_send_cb_) {
339 (update_to_send_cb_)(context);
340 }
341
342 // Have an target IP, build an ECHO REQUEST for it.
343 sending_ = true;
344 ICMPMsgPtr next_echo(new ICMPMsg());
345 next_echo->setType(ICMPMsg::ECHO_REQUEST);
346 next_echo->setDestination(context->getTarget());
347
348 uint32_t instance_num = nextEchoInstanceNum();
349 next_echo->setId(static_cast<uint16_t>(instance_num >> 16));
350 next_echo->setSequence(static_cast<uint16_t>(instance_num & 0x0000FFFF));
351
352 // Get packed wire-form.
353 ICMPPtr echo_icmp = next_echo->pack();
354
355 // Create instance of the callback. It is safe to pass the
356 // local instance of the callback, because the underlying
357 // std functions make copies as needed.
358 SocketCallback cb(std::bind(&PingChannel::socketWriteCallback,
359 shared_from_this(),
360 next_echo,
361 ph::_1, // error
362 ph::_2)); // bytes_transferred
363
364 ICMPEndpoint target_endpoint(context->getTarget());
365 asyncSend(echo_icmp.get(), sizeof(struct icmp), &target_endpoint, cb);
366 } catch (const std::exception& ex) {
367 // Normal IO failures should be passed to the callback. A failure here
368 // indicates the call to asyncSend() itself failed.
369 LOG_ERROR(ping_check_logger, PING_CHECK_UNEXPECTED_WRITE_ERROR)
370 .arg(ex.what());
371 stopChannel();
372 return;
373 }
374}
375
376void
377PingChannel::socketWriteCallback(ICMPMsgPtr echo, boost::system::error_code ec,
378 size_t length) {
379 {
380 MultiThreadingLock lock(*mutex_);
381 if (stopping_) {
382 return;
383 }
384 }
385
386 if (single_threaded_) {
387 try {
388 // Clear the IO ready marker.
389 watch_socket_->clearReady();
390 } catch (const std::exception& ex) {
391 // This can only happen if the WatchSocket's select_fd has been
392 // compromised which is a programmatic error. We'll log the error
393 // here, then continue on and process the IO result we were given.
394 // WatchSocket issue will resurface on the next send as a closed
395 // fd in markReady() rather than fail out of this callback.
396 LOG_ERROR(ping_check_logger, PING_CHECK_CHANNEL_WATCH_SOCKET_CLEAR_ERROR)
397 .arg(ex.what());
398 }
399 }
400
401 // Handle an error. Note we can't use a case statement as some values
402 // on some OSes are the same (e.g. try_again and would_block) which causes
403 // duplicate case compilation errors.
404 bool send_failed = false;
405 if (ec) {
406 auto error_value = ec.value();
407 if (error_value == boost::asio::error::operation_aborted) {
408 // IO service has been stopped and the connection is probably
409 // going to be shutting down.
410 return;
411 } else if ((error_value == boost::asio::error::try_again) ||
412 (error_value == boost::asio::error::would_block)) {
413 // We got EWOULDBLOCK or EAGAIN which indicates that we may be able to
414 // write something from the socket on the next attempt. Set the length
415 // to zero so we skip the completion callback.
416 length = 0;
417 } else if ((error_value == boost::asio::error::network_unreachable) ||
418 (error_value == boost::asio::error::host_unreachable) ||
419 (error_value == boost::asio::error::network_down)) {
420 // One of these implies an interface might be down, or there's no
421 // way to ping this network. Other networks might be working OK.
422 send_failed = true;
423 } else if (error_value == boost::asio::error::no_buffer_space) {
424 // Writing faster than the kernel will write them out.
425 send_failed = true;
426 } else if (error_value == boost::asio::error::access_denied) {
427 // Means the address we tried to ping is not allowed. Most likey a broadcast
428 // address.
429 send_failed = true;
430 } else {
431 // Anything else is fatal for the socket.
432 LOG_ERROR(ping_check_logger, PING_CHECK_CHANNEL_SOCKET_WRITE_FAILED)
433 .arg(ec.message());
434 stopChannel();
435 return;
436 }
437 }
438
439 {
440 MultiThreadingLock lock(*mutex_);
441 sending_ = false;
442 }
443
444 if (send_failed) {
445 // Invoke the callback with send failed. This instructs the manager
446 // to treat the address as free to use.
447 LOG_ERROR(ping_check_logger, PING_CHECK_CHANNEL_NETWORK_WRITE_ERROR)
448 .arg(echo->getDestination())
449 .arg(ec.message());
450 // Invoke the send completed callback.
451 (echo_sent_cb_)(echo, true);
452 } else if (length > 0) {
453 LOG_DEBUG(ping_check_logger, isc::log::DBGLVL_TRACE_DETAIL,
454 PING_CHECK_CHANNEL_ECHO_REQUEST_SENT)
455 .arg(echo->getDestination())
456 .arg(echo->getId())
457 .arg(echo->getSequence());
458 // Invoke the send completed callback.
459 (echo_sent_cb_)(echo, false);
460 }
461
462 // Schedule the next send.
463 sendNext();
464}
465
466size_t
467PingChannel::getInputBufSize() const {
468 return (input_buf_.size());
469}
470
471unsigned char*
472PingChannel::getInputBufData() {
473 if (input_buf_.empty()) {
474 isc_throw(InvalidOperation,
475 "PingChannel::getInputBufData() - cannot access empty buffer");
476 }
477
478 return (input_buf_.data());
479}
480
481} // end of namespace ping_check
482} // end of namespace isc
UINT32_MAX
#define UINT32_MAX
Definition agent_lexer.cc:365
isc::BadValue
A generic exception that is thrown if a parameter given to a method is considered invalid in that con...
Definition exceptions/exceptions.h:132
isc::InvalidOperation
A generic exception that is thrown if a function is called in a prohibited way.
Definition exceptions/exceptions.h:143
isc::Unexpected
A generic exception that is thrown when an unexpected error condition occurs.
Definition exceptions/exceptions.h:153
isc::asiolink::IOAddress::IPV4_ZERO_ADDRESS
static const IOAddress & IPV4_ZERO_ADDRESS()
Returns an address set to all zeros.
Definition io_address.h:277
isc::asiolink::IOEndpoint
The IOEndpoint class is an abstract base class to represent a communication endpoint.
Definition io_endpoint.h:38
isc::dhcp::IfaceMgr::deleteExternalSocket
void deleteExternalSocket(int socketfd)
Deletes external socket.
Definition iface_mgr.cc:352
isc::dhcp::IfaceMgr::SocketCallback
std::function< void(int fd)> SocketCallback
Defines callback used when data is received over external sockets.
Definition iface_mgr.h:661
isc::dhcp::IfaceMgr::instance
static IfaceMgr & instance()
IfaceMgr is a singleton class.
Definition iface_mgr.cc:54
isc::dhcp::IfaceMgr::addExternalSocket
void addExternalSocket(int socketfd, SocketCallback callback)
Adds external socket and a callback.
Definition iface_mgr.cc:329
isc::ping_check::ICMPEndpoint
The ICMPEndpoint class is a concrete derived class of IOEndpoint that represents an endpoint of a ICM...
Definition icmp_endpoint.h:19
isc::ping_check::ICMPMsg
Embodies an ICMP message.
Definition icmp_msg.h:35
isc::ping_check::ICMPMsg::ECHO_REPLY
@ ECHO_REPLY
Definition icmp_msg.h:40
isc::ping_check::ICMPMsg::ECHO_REQUEST
@ ECHO_REQUEST
Definition icmp_msg.h:42
isc::ping_check::ICMPMsg::unpack
static ICMPMsgPtr unpack(const uint8_t *wire_data, size_t length)
Unpacks an ICMP message from the given wire_data.
Definition icmp_msg.cc:30
isc::ping_check::PingChannel::registered_read_fd_
int registered_read_fd_
ICMPSocket fd registered with IfaceMgr.
Definition ping_channel.h:382
isc::ping_check::PingChannel::getInputBufSize
size_t getInputBufSize() const
Returns input buffer size.
Definition ping_channel.cc:467
isc::ping_check::PingChannel::doRead
void doRead()
Initiates an asynchronous socket read.
Definition ping_channel.cc:194
isc::ping_check::PingChannel::~PingChannel
virtual ~PingChannel()
Destructor.
Definition ping_channel.cc:59
isc::ping_check::PingChannel::socket_
PingSocketPtr socket_
Socket through which to ping.
Definition ping_channel.h:341
isc::ping_check::PingChannel::stopChannel
void stopChannel()
Closes the socket channel and invokes the shutdown callback.
Definition ping_channel.cc:158
isc::ping_check::PingChannel::stopping_
bool stopping_
Indicates whether or not the channel has been told to stop.
Definition ping_channel.h:356
isc::ping_check::PingChannel::sendNext
virtual void sendNext()
Initiates sending the next ECHO REQUEST.
Definition ping_channel.cc:313
isc::ping_check::PingChannel::sending_
bool sending_
Indicates whether or not the socket has a write in progress.
Definition ping_channel.h:353
isc::ping_check::PingChannel::update_to_send_cb_
UpdateToSendCallback update_to_send_cb_
Callback to invoke to update selected context to SENDING state.
Definition ping_channel.h:329
isc::ping_check::PingChannel::isOpen
bool isOpen() const
Indicates whether or not the channel socket is open.
Definition ping_channel.cc:108
isc::ping_check::PingChannel::open
void open()
Opens the socket for communications.
Definition ping_channel.cc:64
isc::ping_check::PingChannel::nextEchoInstanceNum
static uint32_t nextEchoInstanceNum()
returns the next unique ECHO instance number.
Definition ping_channel.cc:26
isc::ping_check::PingChannel::send_mutex_
const boost::scoped_ptr< std::mutex > send_mutex_
The mutex used to protect internal state on send events.
Definition ping_channel.h:369
isc::ping_check::PingChannel::input_buf_
std::vector< uint8_t > input_buf_
Buffer to hold the contents for most recent socket read.
Definition ping_channel.h:344
isc::ping_check::PingChannel::startRead
void startRead()
Definition ping_channel.cc:300
isc::ping_check::PingChannel::registered_write_fd_
int registered_write_fd_
WatchSocket fd registered with IfaceMgr.
Definition ping_channel.h:379
isc::ping_check::PingChannel::startSend
virtual void startSend()
Definition ping_channel.cc:287
isc::ping_check::PingChannel::socketWriteCallback
void socketWriteCallback(ICMPMsgPtr echo_sent, boost::system::error_code ec, size_t length)
Socket write completion callback.
Definition ping_channel.cc:377
isc::ping_check::PingChannel::reply_endpoint_
ICMPEndpoint reply_endpoint_
Retains the endpoint from which the most recent reply was received.
Definition ping_channel.h:347
isc::ping_check::PingChannel::echo_sent_cb_
EchoSentCallback echo_sent_cb_
Callback to invoke when an ECHO write has completed.
Definition ping_channel.h:332
isc::ping_check::PingChannel::getInputBufData
unsigned char * getInputBufData()
Returns pointer to the first byte of the input buffer.
Definition ping_channel.cc:472
isc::ping_check::PingChannel::canRead
bool canRead()
Indicates whether or not a read can be initiated.
Definition ping_channel.h:303
isc::ping_check::PingChannel::io_service_
asiolink::IOServicePtr io_service_
IOService instance the drives socket IO.
Definition ping_channel.h:323
isc::ping_check::PingChannel::PingChannel
PingChannel(asiolink::IOServicePtr &io_service, NextToSendCallback next_to_send_cb, UpdateToSendCallback update_to_send_cb, EchoSentCallback echo_sent_cb, ReplyReceivedCallback reply_received_cb, ShutdownCallback shutdown_cb=ShutdownCallback())
Constructor.
Definition ping_channel.cc:37
isc::ping_check::PingChannel::close
void close()
Closes the channel's socket.
Definition ping_channel.cc:114
isc::ping_check::PingChannel::reply_received_cb_
ReplyReceivedCallback reply_received_cb_
Callback to invoke when an ICMP reply has been received.
Definition ping_channel.h:335
isc::ping_check::PingChannel::shutdown_cb_
ShutdownCallback shutdown_cb_
Callback to invoke when the channel has shutdown.
Definition ping_channel.h:338
isc::ping_check::PingChannel::watch_socket_
util::WatchSocketPtr watch_socket_
Pointer to WatchSocket instance supplying the "select-fd".
Definition ping_channel.h:376
isc::ping_check::PingChannel::reading_
bool reading_
Indicates whether or not the socket has a read in progress.
Definition ping_channel.h:350
isc::ping_check::PingChannel::next_to_send_cb_
NextToSendCallback next_to_send_cb_
Callback to invoke to fetch the next context with target address to ping.
Definition ping_channel.h:326
isc::ping_check::PingChannel::socketReadCallback
void socketReadCallback(boost::system::error_code ec, size_t length)
Socket read completion callback.
Definition ping_channel.cc:222
isc::ping_check::PingChannel::asyncSend
virtual void asyncSend(void *data, size_t length, asiolink::IOEndpoint *endpoint, SocketCallback &callback)
Send data on the socket asynchronously.
Definition ping_channel.cc:183
isc::ping_check::PingChannel::mutex_
const boost::scoped_ptr< std::mutex > mutex_
The mutex used to protect internal state.
Definition ping_channel.h:359
isc::ping_check::PingChannel::asyncReceive
virtual void asyncReceive(void *data, size_t length, size_t offset, asiolink::IOEndpoint *endpoint, SocketCallback &callback)
Receive data on the socket asynchronously.
Definition ping_channel.cc:177
isc::ping_check::PingChannel::single_threaded_
bool single_threaded_
True if channel was opened in single-threaded mode, false otherwise.
Definition ping_channel.h:373
isc::ping_check::PingChannel::canSend
bool canSend()
Indicates whether or not a send can be initiated.
Definition ping_channel.h:293
isc::ping_check::SocketCallback
Functor associated with the socket object.
Definition ping_channel.h:34
isc::util::MultiThreadingMgr
Multi Threading Manager.
Definition multi_threading_mgr.h:136
isc::util::WatchSocket
Provides an IO "ready" semaphore for use with select() or poll() WatchSocket exposes a single open fi...
Definition watch_socket.h:47
exceptions.h
isc_throw
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
Definition exceptions/exceptions.h:210
iface_mgr.h
LOG_ERROR
#define LOG_ERROR(LOGGER, MESSAGE)
Macro to conveniently test error output and log it.
Definition macros.h:32
LOG_DEBUG
#define LOG_DEBUG(LOGGER, LEVEL, MESSAGE)
Macro to conveniently test debug output and log it.
Definition macros.h:14
multi_threading_mgr.h
isc::asiolink
Definition addr_utilities.cc:170
isc::asiolink::IOServicePtr
boost::shared_ptr< IOService > IOServicePtr
Defines a smart pointer to an IOService instance.
Definition io_service.h:28
isc::cb
Definition base_config_backend.h:18
isc::data
Definition base_stamped_element.cc:12
isc::dhcp
Definition dhcp4/client_handler.cc:20
isc::log::DBGLVL_TRACE_BASIC
const int DBGLVL_TRACE_BASIC
Trace basic operations.
Definition log_dbglevels.h:69
isc::log::DBGLVL_TRACE_DETAIL
const int DBGLVL_TRACE_DETAIL
Trace detailed operations.
Definition log_dbglevels.h:75
isc::ping_check
Definition config_cache.cc:19
isc::ping_check::ShutdownCallback
std::function< void()> ShutdownCallback
Function type for callback to invoke when the channel has shutdown.
Definition ping_channel.h:84
isc::ping_check::ICMPMsgPtr
boost::shared_ptr< ICMPMsg > ICMPMsgPtr
Shared pointer type for ICMPMsg.
Definition icmp_msg.h:26
isc::ping_check::ping_check_logger
isc::log::Logger ping_check_logger("ping-check-hooks")
Definition ping_check_log.h:19
isc::ping_check::ReplyReceivedCallback
std::function< void(ICMPMsgPtr &reply)> ReplyReceivedCallback
Function type for callback to invoke when an ICMP reply has been received.
Definition ping_channel.h:81
isc::ping_check::EchoSentCallback
std::function< void(ICMPMsgPtr &echo, bool send_failed)> EchoSentCallback
Function type for callback to invoke upon ECHO send completion.
Definition ping_channel.h:77
isc::ping_check::UpdateToSendCallback
std::function< void(PingContextPtr context)> UpdateToSendCallback
Function type for callback to update a context to SENDING state.
Definition ping_channel.h:74
isc::ping_check::ICMPPtr
boost::shared_ptr< struct icmp > ICMPPtr
Shared pointer type for struct icmp.
Definition icmp_msg.h:29
isc::ping_check::PingContextPtr
boost::shared_ptr< PingContext > PingContextPtr
Defines a shared pointer to a PingContext.
Definition ping_context.h:275
isc::ping_check::PingChannelPtr
boost::shared_ptr< PingChannel > PingChannelPtr
Defines a smart pointer to PingChannel.
Definition ping_channel.h:386
isc::ping_check::NextToSendCallback
std::function< PingContextPtr()> NextToSendCallback
Function type for callback to fetch a context with next target to ping.
Definition ping_channel.h:71
isc::ping_check::PingSocket
ICMPSocket< SocketCallback > PingSocket
Socket type for performing ICMP socket IO.
Definition ping_channel.h:65
isc::util
Definition time_utils.cc:43
isc
Defines the logger used by the top-level component of kea-lfc.
Definition agent_parser.cc:148
ping_channel.h
ping_check_log.h
PING_CHECK_CHANNEL_STOP
const isc::log::MessageID PING_CHECK_CHANNEL_STOP
PING_CHECK_CHANNEL_WATCH_SOCKET_CLEAR_ERROR
const isc::log::MessageID PING_CHECK_CHANNEL_WATCH_SOCKET_CLEAR_ERROR
PING_CHECK_CHANNEL_SOCKET_CLOSED
const isc::log::MessageID PING_CHECK_CHANNEL_SOCKET_CLOSED
PING_CHECK_CHANNEL_MALFORMED_PACKET_RECEIVED
const isc::log::MessageID PING_CHECK_CHANNEL_MALFORMED_PACKET_RECEIVED
PING_CHECK_CHANNEL_SOCKET_READ_FAILED
const isc::log::MessageID PING_CHECK_CHANNEL_SOCKET_READ_FAILED
PING_CHECK_CHANNEL_SOCKET_WRITE_FAILED
const isc::log::MessageID PING_CHECK_CHANNEL_SOCKET_WRITE_FAILED
PING_CHECK_CHANNEL_ECHO_REPLY_RECEIVED
const isc::log::MessageID PING_CHECK_CHANNEL_ECHO_REPLY_RECEIVED
PING_CHECK_UNEXPECTED_WRITE_ERROR
const isc::log::MessageID PING_CHECK_UNEXPECTED_WRITE_ERROR
PING_CHECK_CHANNEL_SOCKET_OPENED
const isc::log::MessageID PING_CHECK_CHANNEL_SOCKET_OPENED
PING_CHECK_UNEXPECTED_READ_ERROR
const isc::log::MessageID PING_CHECK_UNEXPECTED_READ_ERROR
PING_CHECK_CHANNEL_WATCH_SOCKET_CLOSE_ERROR
const isc::log::MessageID PING_CHECK_CHANNEL_WATCH_SOCKET_CLOSE_ERROR
PING_CHECK_CHANNEL_SOCKET_CLOSE_ERROR
const isc::log::MessageID PING_CHECK_CHANNEL_SOCKET_CLOSE_ERROR
PING_CHECK_CHANNEL_NETWORK_WRITE_ERROR
const isc::log::MessageID PING_CHECK_CHANNEL_NETWORK_WRITE_ERROR
PING_CHECK_CHANNEL_ECHO_REQUEST_SENT
const isc::log::MessageID PING_CHECK_CHANNEL_ECHO_REQUEST_SENT
isc::util::MultiThreadingLock
RAII lock object to protect the code in the same scope with a mutex.
Definition multi_threading_mgr.h:349