blob: 5adf7f82fc99e58e896b2f1949317ea0a701817c [file] [log] [blame]
// Copyright (C) 2015 The Android Open Source Project
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// See the License for the specific language governing permissions and
// limitations under the License.
#include <memory>
#include <base/callback.h>
#include <base/cancelable_callback.h>
#include "shill/refptr_types.h"
namespace shill {
class ArpClient;
class EventDispatcher;
class IOHandler;
// PassiveLinkMonitor tracks the status of a connection by monitoring ARP
// requests received on the given interface. Each cycle consist of 25 seconds,
// with at lease 5 ARP requests expected in a cycle, a callback indicating
// failure will be invoke if that expectation is not met. Caller can specify
// number of cycles to monitor, once that number is reached without any
// failures, a callback indicating success will be invoked. Monitor will
// automatically stop when the monitor results in either failure or success.
class PassiveLinkMonitor {
using ResultCallback = base::Callback<void(bool)>;
// The default number of cycles to monitor for.
static const int kDefaultMonitorCycles;
PassiveLinkMonitor(const ConnectionRefPtr& connection,
EventDispatcher* dispatcher,
const ResultCallback& result_callback);
virtual ~PassiveLinkMonitor();
// Starts passive link-monitoring for the specified number of cycles.
virtual bool Start(int num_cycles);
// Stop passive link-monitoring. Clears any accumulated statistics.
virtual void Stop();
friend class PassiveLinkMonitorTest;
bool StartArpClient();
void StopArpClient();
// Callback to be invoked whenever the ARP reception socket has data
// available to be received.
void ReceiveRequest(int fd);
// Callback to be invoked when cycle period is reached without receiving
// the expected number of ARP requests.
void CycleTimeoutHandler();
// Method to be called when the monitor is completed.
void MonitorCompleted(bool status);
// The connection on which to perform passive link monitoring.
ConnectionRefPtr connection_;
// The dispatcher on which to create delayed tasks.
EventDispatcher* dispatcher_;
// ArpClient instance for monitoring ARP requests.
std::unique_ptr<ArpClient> arp_client_;
// Callback to be invoked when monitor is completed, either failure or
// success.
ResultCallback result_callback_;
// Number of cycles to monitor for.
int num_cycles_to_monitor_;
// Number of ARP requests received in current cycle.
int num_requests_received_;
// Number of cycles passed so far.
int num_cycles_passed_;
// IOCallback that fires when the socket associated with our ArpClient
// has a packet to be received. Calls ReceiveRequest().
std::unique_ptr<IOHandler> receive_request_handler_;
// Callback for handling cycle timeout.
base::CancelableClosure monitor_cycle_timeout_callback_;
// Callback for handling monitor completed event.
base::CancelableClosure monitor_completed_callback_;
} // namespace shill