1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
//! # midwest_mainline
//!
//! Midwest Mainline is a BitTorrent Distributed Hash Table written in Rust with all async network calls.
//!
//! ## why the name?
//! The BitTorrent DHT is sometimes referred to as the "Mainline" DHT since there were other non-standard DHTs that ran on
//! clients that supported the BT protocol. Since calling it rusty mainline is too boring, the name of rust conjures up the
//! images of midwestern states, hence midwest mainline!
//!
//! ## what is a DHT?
//! A DHT exist to solve the issue that of spreading a large hash table to multiple machines and providing redundancy. In
//! the case of BitTorrent, it is used to share information about other peers for a given torrent.
//!
//! The gist of a DHT is by using the same key space for the identification of us and the key in the hash table, we only
//! include what's near us in the hash table. By maintaining some contacts about other nodes that are close to our id, other
//! nodes can ask us about our neighbors and gradually lead to the node that has the exact key they want.
//!
//! - For the original paper, [see](https://www.scs.stanford.edu/~dm/home/papers/kpos.pdf)
//! - For an excellent video explaining it, [see](https://youtu.be/NxhZ_c8YX8E)
//! - For the BitTorrent specification, [see](https://www.bittorrent.org/beps/bep_0005.html)
//!
//! ## roadmap
//! - [x] routing
//! - [x] bootstrapping
//! - [x] find node
//! - [x] get peers
//! - [x] ping
//! - [x] security extension [BEP-42](https://www.bittorrent.org/beps/bep_0042.html)
//! - [x] announce
//! - [x] respond to ping
//! - [x] respond to get peers
//! - [x] respond to announce
//! - [x] respond to find node
//! - [ ] expiration for hash table
//! - [ ] ping and prune for routing table
//! - [x] upload to crate.io
//!
//! ## state of the development
//! As of right now, the code base is still experience large changes daily and very little comments are added.
//!
//! ## warning
//! I do not have any formal training in security, anything that listens for incoming traffic should be considered as
//! problematic and require attention. Especially when the protocol is effectively send over clear text.
//!
//! ## unstable tokio features
//! This library uses unstable tokio features for tracing, go see tokio's [docs](https://docs.rs/tokio/1.20.0/tokio/index.html#unstable-features).
//! about using unstable features.
//!
//! # TL;DR
//! The library is still in beta, I am aware the interfaces are quite clunky
//!
//! ``` rust
//! use std::io;
//! use midwest_mainline::dht_service;
//! use midwest_mainline::dht_service::DhtV4;
//! use std::net::SocketAddrV4;
//! use std::str::FromStr;
//!
//! #[tokio::main]
//! async fn main() -> io::Result<()> {
//! let external_ip = public_ip::addr_v4().await.unwrap();
//! let dht = DhtV4::bootstrap_with_random_id(
//! SocketAddrV4::from_str("0.0.0.0:51413").unwrap(),
//! external_ip,
//! vec![
//! // dht.tansmissionbt.com
//! "87.98.162.88:6881".parse().unwrap(),
//! // router.utorrent.com
//! "67.215.246.10:6881".parse().unwrap(),
//! // router.bittorrent.com, ironically that this almost never responds
//! "82.221.103.244:6881".parse().unwrap(),
//! // dht.aelitis.com
//! "174.129.43.152:6881".parse().unwrap(),
//! ],
//! ).await?;
//! let client = dht.client();
//!
//! // make sure this is alive
//! tokio::spawn(dht.run());
//!
//! // now you can do hackerman things with the client
//!
//! Ok(())
//! }
//! ```
pub
pub
pub