transmission/libtransmission/announcer.h

163 lines
4.2 KiB
C
Raw Normal View History

// This file Copyright © 2010-2023 Mnemosyne LLC.
2022-08-08 18:05:39 +00:00
// It may be used under GPLv2 (SPDX: GPL-2.0-only), GPLv3 (SPDX: GPL-3.0-only),
// or any future license endorsed by Mnemosyne LLC.
// License text can be found in the licenses/ folder.
#pragma once
#ifndef __TRANSMISSION__
#error only libtransmission should #include this header.
#endif
#include <atomic>
#include <cstddef> // size_t
#include <cstdint> // uint32_t
#include <ctime>
#include <functional>
#include <memory>
#include <optional>
#include <string_view>
#include <vector>
2023-07-08 15:24:03 +00:00
#ifdef _WIN32
#include <ws2tcpip.h>
#else
#include <sys/socket.h> // socklen_t
#endif
#include "libtransmission/transmission.h"
2023-07-08 15:24:03 +00:00
#include "libtransmission/interned-string.h"
#include "libtransmission/peer-mgr.h"
2023-07-08 15:24:03 +00:00
struct tr_address;
class tr_announcer_udp;
2023-07-08 15:24:03 +00:00
struct tr_session;
struct tr_torrent;
struct tr_torrent_announcer;
// --- Tracker Publish / Subscribe
/** @brief Notification object to tell listeners about announce or scrape occurrences */
struct tr_tracker_event
{
enum class Type
{
Error,
ErrorClear,
Counts,
Peers,
Warning,
};
// What type of event this is
Type type;
// for Warning and Error events
std::string_view text;
tr_interned_string announce_url;
// for Peers events
std::vector<tr_pex> pex;
// for Peers and Counts events
int leechers;
int seeders;
};
using tr_tracker_callback = std::function<void(tr_torrent&, tr_tracker_event const*)>;
class tr_announcer
{
public:
[[nodiscard]] static std::unique_ptr<tr_announcer> create(
tr_session* session,
tr_announcer_udp&,
std::atomic<size_t>& n_pending_stops);
virtual ~tr_announcer() = default;
virtual tr_torrent_announcer* addTorrent(tr_torrent*, tr_tracker_callback callback) = 0;
virtual void startTorrent(tr_torrent* tor) = 0;
virtual void stopTorrent(tr_torrent* tor) = 0;
virtual void resetTorrent(tr_torrent* tor) = 0;
virtual void removeTorrent(tr_torrent* tor) = 0;
virtual void startShutdown() = 0;
};
std::unique_ptr<tr_announcer> tr_announcerCreate(tr_session* session);
// --- For torrent customers
void tr_announcerChangeMyPort(tr_torrent*);
bool tr_announcerCanManualAnnounce(tr_torrent const*);
void tr_announcerManualAnnounce(tr_torrent*);
void tr_announcerTorrentCompleted(tr_torrent*);
enum
{
TR_ANN_UP,
TR_ANN_DOWN,
TR_ANN_CORRUPT
};
void tr_announcerAddBytes(tr_torrent*, int type, uint32_t n_bytes);
time_t tr_announcerNextManualAnnounce(tr_torrent const*);
tr_tracker_view tr_announcerTracker(tr_torrent const* torrent, size_t nth);
size_t tr_announcerTrackerCount(tr_torrent const* tor);
// --- ANNOUNCE
enum tr_announce_event
{
/* Note: the ordering of this enum's values is important to
* announcer.c's tr_tier.announce_event_priority. If changing
* the enum, ensure announcer.c is compatible with the change. */
TR_ANNOUNCE_EVENT_NONE,
TR_ANNOUNCE_EVENT_STARTED,
TR_ANNOUNCE_EVENT_COMPLETED,
TR_ANNOUNCE_EVENT_STOPPED,
};
struct tr_announce_request;
struct tr_announce_response;
struct tr_scrape_request;
struct tr_scrape_response;
// --- UDP ANNOUNCER
using tr_scrape_response_func = std::function<void(tr_scrape_response const&)>;
using tr_announce_response_func = std::function<void(tr_announce_response const&)>;
class tr_announcer_udp
{
public:
class Mediator
{
public:
virtual ~Mediator() noexcept = default;
virtual void sendto(void const* buf, size_t buflen, sockaddr const* addr, socklen_t addrlen) = 0;
[[nodiscard]] virtual std::optional<tr_address> announce_ip() const = 0;
};
virtual ~tr_announcer_udp() noexcept = default;
[[nodiscard]] static std::unique_ptr<tr_announcer_udp> create(Mediator&);
virtual void announce(tr_announce_request const& request, tr_announce_response_func on_response) = 0;
virtual void scrape(tr_scrape_request const& request, tr_scrape_response_func on_response) = 0;
virtual void upkeep() = 0;
// @brief process an incoming udp message if it's a tracker response.
// @return true if msg was a tracker response; false otherwise
virtual bool handle_message(uint8_t const* msg, size_t msglen) = 0;
};