master
eater 4 years ago
parent ef40af30f4
commit c7cc7ff9ed
Signed by: eater
GPG Key ID: AD2560A0F84F0759

571
Cargo.lock generated

@ -21,7 +21,7 @@ version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
dependencies = [
"winapi",
"winapi 0.3.9",
]
[[package]]
@ -75,7 +75,7 @@ dependencies = [
"socket2",
"vec-arena",
"wepoll-sys-stjepang",
"winapi",
"winapi 0.3.9",
]
[[package]]
@ -135,7 +135,7 @@ checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
dependencies = [
"hermit-abi",
"libc",
"winapi",
"winapi 0.3.9",
]
[[package]]
@ -274,6 +274,32 @@ dependencies = [
"cache-padded",
]
[[package]]
name = "core-foundation"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "57d24c7a13c43e870e37c1556b74555437870a04514f7685f5b354e090567171"
dependencies = [
"core-foundation-sys",
"libc",
]
[[package]]
name = "core-foundation-sys"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b3a71ab494c0b5b860bdc8407ae08978052417070c2ced38573a9157ad75b8ac"
[[package]]
name = "crossbeam-channel"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "09ee0cc8804d5393478d743b035099520087a5186f3b93fa58cec08fa62407b6"
dependencies = [
"cfg-if",
"crossbeam-utils",
]
[[package]]
name = "crossbeam-epoch"
version = "0.8.2"
@ -300,6 +326,21 @@ dependencies = [
"lazy_static",
]
[[package]]
name = "dtoa"
version = "0.4.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "134951f4028bdadb9b84baf4232681efbf277da25144b9b0ad65df75946c422b"
[[package]]
name = "encoding_rs"
version = "0.8.24"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a51b8cf747471cb9499b6d59e59b0444f4c90eba8968c4e44874e92b5b64ace2"
dependencies = [
"cfg-if",
]
[[package]]
name = "event-listener"
version = "2.4.0"
@ -334,6 +375,43 @@ version = "1.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4bd3bdaaf0a72155260a1c098989b60db1cbb22d6a628e64f16237aa4da93cc7"
[[package]]
name = "fnv"
version = "1.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
[[package]]
name = "foreign-types"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
dependencies = [
"foreign-types-shared",
]
[[package]]
name = "foreign-types-shared"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
[[package]]
name = "fuchsia-zircon"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
dependencies = [
"bitflags",
"fuchsia-zircon-sys",
]
[[package]]
name = "fuchsia-zircon-sys"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
[[package]]
name = "futures"
version = "0.3.5"
@ -461,6 +539,25 @@ version = "0.22.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "aaf91faf136cb47367fa430cd46e37a788775e7fa104f8b4bcb3861dc389b724"
[[package]]
name = "h2"
version = "0.2.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "993f9e0baeed60001cf565546b0d3dbe6a6ad23f2bd31644a133c641eccf6d53"
dependencies = [
"bytes",
"fnv",
"futures-core",
"futures-sink",
"futures-util",
"http",
"indexmap",
"slab",
"tokio",
"tokio-util",
"tracing",
]
[[package]]
name = "hashbrown"
version = "0.8.2"
@ -485,6 +582,70 @@ version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "644f9158b2f133fd50f5fb3242878846d9eb792e445c893805ff0e3824006e35"
[[package]]
name = "http"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "28d569972648b2c512421b5f2a405ad6ac9666547189d0c5477a3f200f3e02f9"
dependencies = [
"bytes",
"fnv",
"itoa",
]
[[package]]
name = "http-body"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "13d5ff830006f7646652e057693569bfe0d51760c0085a071769d142a205111b"
dependencies = [
"bytes",
"http",
]
[[package]]
name = "httparse"
version = "1.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cd179ae861f0c2e53da70d892f5f3029f9594be0c41dc5269cd371691b1dc2f9"
[[package]]
name = "hyper"
version = "0.13.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3e68a8dd9716185d9e64ea473ea6ef63529252e3e27623295a0378a19665d5eb"
dependencies = [
"bytes",
"futures-channel",
"futures-core",
"futures-util",
"h2",
"http",
"http-body",
"httparse",
"itoa",
"pin-project",
"socket2",
"time",
"tokio",
"tower-service",
"tracing",
"want",
]
[[package]]
name = "hyper-tls"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d979acc56dcb5b8dddba3917601745e877576475aa046df3226eabdecef78eed"
dependencies = [
"bytes",
"hyper",
"native-tls",
"tokio",
"tokio-tls",
]
[[package]]
name = "idna"
version = "0.2.0"
@ -506,6 +667,21 @@ dependencies = [
"hashbrown",
]
[[package]]
name = "iovec"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b2b3ea6ff95e175473f8ffe6a7eb7c00d054240321b84c57051175fe3c1e075e"
dependencies = [
"libc",
]
[[package]]
name = "ipnet"
version = "2.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "47be2f14c678be2fdcab04ab1171db51b2762ce6f0a8ee87c8dd4a04ed216135"
[[package]]
name = "itoa"
version = "0.4.6"
@ -521,6 +697,16 @@ dependencies = [
"wasm-bindgen",
]
[[package]]
name = "kernel32-sys"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7507624b29483431c0ba2d82aece8ca6cdba9382bff4ddd0f7490560c056098d"
dependencies = [
"winapi 0.2.8",
"winapi-build",
]
[[package]]
name = "kv-log-macro"
version = "1.0.7"
@ -584,6 +770,22 @@ dependencies = [
"autocfg",
]
[[package]]
name = "mime"
version = "0.3.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2a60c7ce501c71e03a9c9c0d35b861413ae925bd979cc7a4e30d060069aaac8d"
[[package]]
name = "mime_guess"
version = "2.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2684d4c2e97d99848d30b324b00c8fcc7e5c897b7cbb5819b09e7c90e8baf212"
dependencies = [
"mime",
"unicase",
]
[[package]]
name = "miniz_oxide"
version = "0.4.0"
@ -593,6 +795,37 @@ dependencies = [
"adler",
]
[[package]]
name = "mio"
version = "0.6.22"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fce347092656428bc8eaf6201042cb551b8d67855af7374542a92a0fbfcac430"
dependencies = [
"cfg-if",
"fuchsia-zircon",
"fuchsia-zircon-sys",
"iovec",
"kernel32-sys",
"libc",
"log",
"miow",
"net2",
"slab",
"winapi 0.2.8",
]
[[package]]
name = "miow"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8c1f2f3b1cf331de6896aabf6e9d55dca90356cc9960cca7eaaf408a355ae919"
dependencies = [
"kernel32-sys",
"net2",
"winapi 0.2.8",
"ws2_32-sys",
]
[[package]]
name = "multitask"
version = "0.2.0"
@ -604,6 +837,35 @@ dependencies = [
"fastrand",
]
[[package]]
name = "native-tls"
version = "0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2b0d88c06fe90d5ee94048ba40409ef1d9315d86f6f38c2efdaad4fb50c58b2d"
dependencies = [
"lazy_static",
"libc",
"log",
"openssl",
"openssl-probe",
"openssl-sys",
"schannel",
"security-framework",
"security-framework-sys",
"tempfile",
]
[[package]]
name = "net2"
version = "0.2.34"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2ba7c918ac76704fb42afcbbb43891e72731f3dcca3bef2a19786297baf14af7"
dependencies = [
"cfg-if",
"libc",
"winapi 0.3.9",
]
[[package]]
name = "num-integer"
version = "0.1.43"
@ -645,6 +907,39 @@ version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b631f7e854af39a1739f401cf34a8a013dfe09eac4fa4dba91e9768bd28168d"
[[package]]
name = "openssl"
version = "0.10.30"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8d575eff3665419f9b83678ff2815858ad9d11567e082f5ac1814baba4e2bcb4"
dependencies = [
"bitflags",
"cfg-if",
"foreign-types",
"lazy_static",
"libc",
"openssl-sys",
]
[[package]]
name = "openssl-probe"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77af24da69f9d9341038eba93a073b1fdaaa1b788221b00a69bce9e762cb32de"
[[package]]
name = "openssl-sys"
version = "0.9.58"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a842db4709b604f0fe5d1170ae3565899be2ad3d9cbc72dedc789ac0511f78de"
dependencies = [
"autocfg",
"cc",
"libc",
"pkg-config",
"vcpkg",
]
[[package]]
name = "parking"
version = "1.0.6"
@ -695,6 +990,12 @@ version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
[[package]]
name = "pkg-config"
version = "0.3.18"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d36492546b6af1463394d46f0c834346f31548646f6ba10849802c9c9a27ac33"
[[package]]
name = "polling"
version = "0.1.6"
@ -705,7 +1006,7 @@ dependencies = [
"libc",
"log",
"wepoll-sys-stjepang",
"winapi",
"winapi 0.3.9",
]
[[package]]
@ -800,6 +1101,50 @@ dependencies = [
"crossbeam-epoch",
]
[[package]]
name = "remove_dir_all"
version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
dependencies = [
"winapi 0.3.9",
]
[[package]]
name = "reqwest"
version = "0.10.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e9eaa17ac5d7b838b7503d118fa16ad88f440498bf9ffe5424e621f93190d61e"
dependencies = [
"base64",
"bytes",
"encoding_rs",
"futures-core",
"futures-util",
"http",
"http-body",
"hyper",
"hyper-tls",
"ipnet",
"js-sys",
"lazy_static",
"log",
"mime",
"mime_guess",
"native-tls",
"percent-encoding",
"pin-project-lite",
"serde",
"serde_urlencoded",
"tokio",
"tokio-tls",
"url",
"wasm-bindgen",
"wasm-bindgen-futures",
"web-sys",
"winreg",
]
[[package]]
name = "ring"
version = "0.16.15"
@ -812,7 +1157,7 @@ dependencies = [
"spin",
"untrusted",
"web-sys",
"winapi",
"winapi 0.3.9",
]
[[package]]
@ -827,6 +1172,16 @@ version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
[[package]]
name = "schannel"
version = "0.1.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f05ba609c234e60bee0d547fe94a4c7e9da733d1c962cf6e59efa4cd9c8bc75"
dependencies = [
"lazy_static",
"winapi 0.3.9",
]
[[package]]
name = "scoped-tls"
version = "1.0.0"
@ -839,6 +1194,29 @@ version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
[[package]]
name = "security-framework"
version = "0.4.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "64808902d7d99f78eaddd2b4e2509713babc3dc3c85ad6f4c447680f3c01e535"
dependencies = [
"bitflags",
"core-foundation",
"core-foundation-sys",
"libc",
"security-framework-sys",
]
[[package]]
name = "security-framework-sys"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "17bf11d99252f512695eb468de5516e5cf75455521e69dfe343f3b74e4748405"
dependencies = [
"core-foundation-sys",
"libc",
]
[[package]]
name = "serde"
version = "1.0.115"
@ -871,6 +1249,18 @@ dependencies = [
"serde",
]
[[package]]
name = "serde_urlencoded"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9ec5d77e2d4c73717816afac02670d5c4f534ea95ed430442cad02e7a6e32c97"
dependencies = [
"dtoa",
"itoa",
"serde",
"url",
]
[[package]]
name = "slab"
version = "0.4.2"
@ -886,7 +1276,7 @@ dependencies = [
"cfg-if",
"libc",
"redox_syscall",
"winapi",
"winapi 0.3.9",
]
[[package]]
@ -924,6 +1314,20 @@ dependencies = [
"unicode-xid",
]
[[package]]
name = "tempfile"
version = "3.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7a6e24d9338a0a5be79593e2fa15a648add6138caa803e2d5bc782c371732ca9"
dependencies = [
"cfg-if",
"libc",
"rand",
"redox_syscall",
"remove_dir_all",
"winapi 0.3.9",
]
[[package]]
name = "textwrap"
version = "0.11.0"
@ -940,7 +1344,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ca8a50ef2360fbd1eeb0ecd46795a87a19024eb4b53c5dc916ca1fd95fe62438"
dependencies = [
"libc",
"winapi",
"winapi 0.3.9",
]
[[package]]
@ -949,6 +1353,48 @@ version = "0.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "238ce071d267c5710f9d31451efec16c5ee22de34df17cc05e56cbc92e967117"
[[package]]
name = "tokio"
version = "0.2.22"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5d34ca54d84bf2b5b4d7d31e901a8464f7b60ac145a284fba25ceb801f2ddccd"
dependencies = [
"bytes",
"fnv",
"futures-core",
"iovec",
"lazy_static",
"memchr",
"mio",
"num_cpus",
"pin-project-lite",
"slab",
]
[[package]]
name = "tokio-tls"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9a70f4fcd7b3b24fb194f837560168208f669ca8cb70d0c4b862944452396343"
dependencies = [
"native-tls",
"tokio",
]
[[package]]
name = "tokio-util"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "be8242891f2b6cbef26a2d7e8605133c2c554cd35b3e4948ea892d6d68436499"
dependencies = [
"bytes",
"futures-core",
"futures-sink",
"log",
"pin-project-lite",
"tokio",
]
[[package]]
name = "torment-bencode"
version = "0.1.0"
@ -1030,11 +1476,16 @@ name = "torment-manager"
version = "0.1.0"
dependencies = [
"bytes",
"crossbeam-channel",
"lazy_static",
"polling",
"rand",
"reqwest",
"ring",
"torment-core",
"torment-peer",
"torment-storage",
"torment-tracker",
"url",
]
@ -1056,6 +1507,57 @@ dependencies = [
"torment-core",
]
[[package]]
name = "torment-tracker"
version = "0.1.0"
dependencies = [
"reqwest",
"torment-bencode",
"torment-core",
"url",
]
[[package]]
name = "tower-service"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e987b6bf443f4b5b3b6f38704195592cca41c5bb7aedd3c3693c7081f8289860"
[[package]]
name = "tracing"
version = "0.1.19"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6d79ca061b032d6ce30c660fded31189ca0b9922bf483cd70759f13a2d86786c"
dependencies = [
"cfg-if",
"log",
"tracing-core",
]
[[package]]
name = "tracing-core"
version = "0.1.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4f0e00789804e99b20f12bc7003ca416309d28a6f495d6af58d1e2c2842461b5"
dependencies = [
"lazy_static",
]
[[package]]
name = "try-lock"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "59547bce71d9c38b83d9c0e92b6066c4253371f15005def0c30d9657f50c7642"
[[package]]
name = "unicase"
version = "2.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "50f37be617794602aabbeee0be4f259dc1778fabe05e2d67ee8f79326d5cb4f6"
dependencies = [
"version_check",
]
[[package]]
name = "unicode-bidi"
version = "0.3.4"
@ -1103,6 +1605,12 @@ dependencies = [
"percent-encoding",
]
[[package]]
name = "vcpkg"
version = "0.2.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6454029bf181f092ad1b853286f23e2c507d8e8194d01d92da4a55c274a5508c"
[[package]]
name = "vec-arena"
version = "0.5.2"
@ -1115,12 +1623,28 @@ version = "0.8.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f1bddf1187be692e79c5ffeab891132dfb0f236ed36a43c7ed39f1165ee20191"
[[package]]
name = "version_check"
version = "0.9.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b5a972e5669d67ba988ce3dc826706fb0a8b01471c088cb0b6110b805cc36aed"
[[package]]
name = "waker-fn"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9571542c2ce85ce642e6b58b3364da2fb53526360dfb7c211add4f5c23105ff7"
[[package]]
name = "want"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0"
dependencies = [
"log",
"try-lock",
]
[[package]]
name = "wasi"
version = "0.9.0+wasi-snapshot-preview1"
@ -1134,6 +1658,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f0563a9a4b071746dd5aedbc3a28c6fe9be4586fb3fbadb67c400d4f53c6b16c"
dependencies = [
"cfg-if",
"serde",
"serde_json",
"wasm-bindgen-macro",
]
@ -1212,6 +1738,12 @@ dependencies = [
"cc",
]
[[package]]
name = "winapi"
version = "0.2.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "167dc9d6949a9b857f3451275e911c3f44255842c1f7a76f33c55103a909087a"
[[package]]
name = "winapi"
version = "0.3.9"
@ -1222,6 +1754,12 @@ dependencies = [
"winapi-x86_64-pc-windows-gnu",
]
[[package]]
name = "winapi-build"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2d315eee3b34aca4797b2da6b13ed88266e6d612562a0c46390af8299fc699bc"
[[package]]
name = "winapi-i686-pc-windows-gnu"
version = "0.4.0"
@ -1234,6 +1772,25 @@ version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
[[package]]
name = "winreg"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0120db82e8a1e0b9fb3345a539c478767c0048d842860994d96113d5b667bd69"
dependencies = [
"winapi 0.3.9",
]
[[package]]
name = "ws2_32-sys"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d59cefebd0c892fa2dd6de581e937301d8552cb44489cdff035c6187cb63fa5e"
dependencies = [
"winapi 0.2.8",
"winapi-build",
]
[[package]]
name = "yaml-rust"
version = "0.3.5"

@ -8,5 +8,6 @@ members = [
"torment-peer",
"torment-storage",
"torment-manager",
"torment-daemon"
"torment-daemon",
"torment-tracker",
]

@ -1,4 +1,4 @@
use bytes::{Bytes, BytesMut};
use bytes::{Buf, Bytes, BytesMut};
use rand::random;
use std::cmp::min;
use std::convert::TryInto;
@ -9,7 +9,6 @@ use torment_core::infohash::v1::U160;
use torment_core::infohash::InfoHashCapable;
use torment_core::metainfo::Torrent;
use torment_core::peer_id;
use torment_peer::message::Message::Request;
use torment_peer::message::{Handshake, Message, SelectionMessage};
use torment_peer::{Peer, PeerProtocol};
use torment_storage::ToStorageMap;
@ -26,9 +25,10 @@ pub fn download(torrent: Torrent, peers: Vec<SocketAddr>) {
let id = U160::from(peer_id(random()));
let our_header = Handshake::new(id, torrent.info_hash());
stream.write(&our_header.to_bytes());
stream.write(&our_header.to_bytes()).unwrap();
let mut buffer = [0u8; 4096];
let mut done_header = false;
#[allow(unused_assignments)]
let mut header = Handshake::new(U160::random(), U160::random());
let mut peer = None;
let mut message_buffer = BytesMut::with_capacity(4096 * 10);
@ -71,12 +71,12 @@ pub fn download(torrent: Torrent, peers: Vec<SocketAddr>) {
continue;
}
let mut peer = peer.as_mut().unwrap();
let peer = peer.as_mut().unwrap();
message_buffer.extend_from_slice(&buffer[..size]);
while message_buffer.len() >= 4 {
let length = u32::from_be_bytes(message_buffer[..4].try_into().unwrap());
if length == 0 {
message_buffer.split_to(4);
message_buffer.advance(4);
continue;
}
@ -89,7 +89,9 @@ pub fn download(torrent: Torrent, peers: Vec<SocketAddr>) {
let msg = Message::from_bytes(message.slice(4..)).expect("Failed parsing message");
// println!("=> {:?}", msg);
if msg == Message::Unchoke {
stream.write_all(&Message::Interested.to_length_prefixed_bytes());
stream
.write_all(&Message::Interested.to_length_prefixed_bytes())
.unwrap();
}
peer.process(msg);
}

@ -0,0 +1 @@
pub const REQUEST_SIZE: usize = 16384;

@ -10,11 +10,15 @@ use std::fmt::{Display, Formatter};
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
use std::str::FromStr;
mod consts;
pub mod infohash;
pub mod ip;
pub mod metainfo;
pub mod peer_storage;
pub mod utils;
pub use consts::*;
pub fn peer_id(input: [u8; 12]) -> [u8; 20] {
let peer_id = format!(
"eT{:0>2}{:0>2}{:0>2}AAAAAAAAAAAA",
@ -121,34 +125,44 @@ impl ContactInfo {
}
#[derive(Clone, Ord, PartialOrd, Eq, PartialEq)]
pub struct Bitfield(BytesMut);
pub struct Bitfield(BytesMut, usize);
impl Bitfield {
pub fn new<T: AsRef<[u8]>>(field: T) -> Bitfield {
Bitfield(BytesMut::from(field.as_ref()))
pub fn size(&self) -> usize {
self.1
}
pub fn new<T: AsRef<[u8]>>(field: T, size: usize) -> Bitfield {
Bitfield(BytesMut::from(field.as_ref()), size)
}
pub fn with_size(size: usize) -> Bitfield {
Bitfield({
let mut field = BytesMut::new();
field.resize((size / 8) + if size % 8 > 0 { 1 } else { 0 }, 0);
field
})
Bitfield(
{
let mut field = BytesMut::new();
field.resize((size / 8) + if size % 8 > 0 { 1 } else { 0 }, 0);
field
},
size,
)
}
pub fn set(&mut self, index: u32) {
debug_assert!(index < self.1 as u32, "index out of bounds");
let byte_index = index / 8;
let bitmask = 1 << (7 - index % 8);
let bitmask = 1 << (7 - (index % 8));
self.0[byte_index as usize] |= bitmask;
}
pub fn unset(&mut self, index: u32) {
debug_assert!(index < self.1 as u32, "index out of bounds");
let byte_index = index / 8;
let bitmask = 1 << (8 - index % 8);
let bitmask = 1 << (7 - (index % 8));
self.0[byte_index as usize] &= !bitmask;
}
pub fn get(&self, index: u32) -> bool {
debug_assert!(index < self.1 as u32, "index out of bounds");
let byte_index = index / 8;
let bitmask = 1 << (7 - (index % 8));
(self.0[byte_index as usize] & bitmask) > 0
@ -161,13 +175,40 @@ impl Bitfield {
self.0[i] |= field[i]
}
}
pub fn all(&self) -> bool {
for i in 0..self.0.len() {
let byte = self.0[i];
if i + 1 == self.0.len() {
let left = self.1 % 8;
if left != 0 {
return byte == 255 ^ (255 >> left);
}
}
if byte != u8::MAX {
return false;
}
}
return true;
}
}
impl Debug for Bitfield {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(f, "Bitfield(")?;
for byte in &self.0 {
write!(f, "{:b}", byte)?;
for i in 0..self.0.len() {
let byte = self.0[i];
if i + 1 == self.0.len() {
write!(
f,
"{}",
&format!("{:0>8b}", byte)[0..(if self.1 % 8 == 0 { 8 } else { self.1 % 8 })]
)?;
} else {
write!(f, "{:b}", byte)?;
}
}
write!(f, ")")
@ -180,9 +221,6 @@ impl AsRef<[u8]> for Bitfield {
}
}
#[derive(Debug, Default)]
pub struct PeerStorage {}
#[derive(Ord, PartialOrd, Eq, PartialEq, Copy, Clone)]
pub enum LookupFilter {
IPv6,
@ -190,17 +228,6 @@ pub enum LookupFilter {
All,
}
impl PeerStorage {
pub fn new() -> PeerStorage {
PeerStorage {}
}
pub fn add_peers(&mut self, _info_hash: U160, _peers: Vec<SocketAddr>) {}
pub fn get_peers(&self, _info_hash: U160, _filter: LookupFilter) -> Vec<SocketAddr> {
vec![]
}
}
#[cfg(test)]
mod tests {
use crate::{compact_peer_id, peer_id, Bitfield};
@ -213,6 +240,7 @@ mod tests {
assert_eq!(&compact_peer_id(), b"eT\x00\x01");
}
#[test]
fn test_bitfield() {
let mut field = Bitfield::with_size(3);
field.set(0);
@ -225,5 +253,12 @@ mod tests {
field.add(other_field);
assert_eq!(true, field.get(2));
assert!(!field.all());
field.set(1);
field.set(0);
println!("{} = {:?}", field.as_ref()[0], field);
assert!(field.all());
}
}

@ -79,7 +79,7 @@ impl Torrent {
.or(name)
.unwrap_or(info.info_hash.to_string());
let announce_list = if let Some(announce) = dict.get(b"announce-list") {
let mut announce_list = if let Some(announce) = dict.get(b"announce-list") {
announce
.list()
.map(|list| -> Result<Vec<HashSet<Url>>, MetaInfoParsingError> {
@ -110,6 +110,18 @@ impl Torrent {
vec![]
};
if let Some(item) = dict.get(b"announce") {
if let Some(Ok(url)) = item.string() {
if let Ok(url) = Url::parse(&url) {
if announce_list.is_empty() {
announce_list.push(HashSet::new());
}
announce_list[0].insert(url);
}
}
}
Ok(Torrent {
name,
announce_list,

@ -0,0 +1,122 @@
use crate::infohash::v1::U160;
use crate::LookupFilter;
use std::collections::{HashMap, HashSet};
use std::net::SocketAddr;
use std::ops::Add;
use std::sync::{Arc, RwLock};
use std::time::{Duration, Instant};
use url::Url;
#[derive(Debug, Default)]
pub struct PeerStorage {
torrents: HashMap<U160, PeerCollection>,
}
#[derive(Debug, Default)]
pub struct PeerCollection {
sets: Vec<PeerSet>,
peers: HashSet<SocketAddr>,
peers6: HashSet<SocketAddr>,
}
#[derive(Debug)]
pub struct PeerSet {
source: PeerStorageSource,
expires: Instant,
peers: Vec<SocketAddr>,
}
impl PeerCollection {
fn add_peers(&mut self, peers: Vec<SocketAddr>, source: PeerStorageSource) {
let set = PeerSet {
source,
peers,
expires: Instant::now().add(Duration::from_secs(60 * 30)),
};
for peer in &set.peers {
if peer.is_ipv4() {
self.peers.insert(*peer);
} else {
self.peers6.insert(*peer);
}
}
self.sets.push(set);
}
}
#[derive(Debug, Clone)]
pub enum PeerStorageSource {
DHT,
Tracker(Url),
}
impl PeerStorage {
pub fn new() -> PeerStorage {
PeerStorage {
torrents: Default::default(),
}
}
pub fn add_peers(
&mut self,
info_hash: U160,
peers: Vec<SocketAddr>,
source: PeerStorageSource,
) {
self.torrents
.entry(info_hash)
.or_default()
.add_peers(peers, source)
}
pub fn get_peers(&self, info_hash: U160, filter: LookupFilter) -> Vec<SocketAddr> {
let collection = if let Some(collection) = self.torrents.get(&info_hash) {
collection
} else {
return vec![];
};
let mut buffer = vec![];
if filter != LookupFilter::IPv6 {
buffer.extend(&collection.peers);
}
if filter != LookupFilter::IPv4 {
buffer.extend(&collection.peers6);
}
buffer
}
}
#[derive(Debug, Clone)]
pub struct PeerStorageHolder {
inner: Arc<RwLock<PeerStorage>>,
}
impl PeerStorageHolder {
pub fn new(peer_storage: PeerStorage) -> PeerStorageHolder {
PeerStorageHolder {
inner: Arc::new(RwLock::new(peer_storage)),
}
}
pub fn get_peers(&self, info_hash: U160, filter: LookupFilter) -> Vec<SocketAddr> {
self.inner.read().unwrap().get_peers(info_hash, filter)
}
pub fn add_peers(
&mut self,
info_hash: U160,
peers: Vec<SocketAddr>,
source: PeerStorageSource,
) {
self.inner
.write()
.unwrap()
.add_peers(info_hash, peers, source)
}
}

@ -259,6 +259,10 @@ impl<K: Debug + Clone + Ord> Debug for EphemeralSet<K> {
}
impl<K: Clone + Ord + Debug> EphemeralSet<K> {
pub fn len(&self) -> usize {
self.0.len()
}
pub fn new() -> Self {
EphemeralSet(EphemeralMap::new())
}

@ -1,151 +1,42 @@
use bytes::BytesMut;
use polling::{Event, Poller};
use std::collections::HashMap;
use std::convert::TryInto;
use rand::random;
use std::fs::File;
use std::io::{Read, Write};
use std::net::TcpStream;
use std::option::Option::Some;
use std::path::PathBuf;
use std::process::exit;
use std::result::Result::Ok;
use std::time::Duration;
use std::io::Read;
use std::net::IpAddr;
use std::str::FromStr;
use torment_core::infohash::v1::U160;
use torment_core::metainfo::Torrent;
use torment_core::peer_id;
use torment_core::peer_storage::{PeerStorage, PeerStorageHolder};
use torment_manager::session_manager::SessionManager;
use torment_manager::torment_instance::TormentInstance;
use torment_manager::torrent_manager::{TorrentManager, TorrentTarget};
use torment_peer::message::{Handshake, Message};
use torment_peer::PeerProtocol::TCP;
struct TcpState {
builder: BytesMut,
handshake: Option<Handshake>,
stream: TcpStream,
}
use torment_manager::tracker_manager::TrackerManager;
fn main() {
let mut session_manager = SessionManager::new();
let ip = IpAddr::from_str("0.0.0.0").unwrap();
let peer_id = U160::from(peer_id(random()));
let mut session_manager = SessionManager::new(ip, 50002, peer_id);
let mut buffer = vec![];
File::open("/home/eater/Downloads/[Commie] Senyuu. - 23 [150B93D5].mkv.torrent")
let mut file = vec![];
File::open("test.torrent")
.unwrap()
.read_to_end(&mut buffer)
.read_to_end(&mut file)
.unwrap();
let torrent = Torrent::from_bytes(file, Some("test".to_string())).unwrap();
println!("Downloading {:#?}", torrent);
let torrent_manager = TorrentManager::from_torrent(
Torrent::from_bytes(
buffer,
Some("[Commie] Senyuu. - 23 [150B93D5].mkv".to_string()),
)
.unwrap(),
torrent,
TorrentTarget {
path: PathBuf::from("/tmp"),
path: "/tmp/test".into(),
is_base_path: true,
},
None,
Some(session_manager.tracker_manager_mut()),
);
let peer_id = U160::from(peer_id(rand::random()));
let info_hash = torrent_manager.info_hash();
session_manager.add_torrent_manager(torrent_manager);
let mut tcp_stream_ktorrent = TcpStream::connect("127.0.0.1:6881").unwrap();
tcp_stream_ktorrent.set_nodelay(true).unwrap();
tcp_stream_ktorrent
.write_all(Handshake::new(peer_id, info_hash).to_bytes().as_ref())
.unwrap();
let mut tcp_stream_transmission = TcpStream::connect("192.168.188.100:51413").unwrap();
tcp_stream_transmission.set_nodelay(true).unwrap();
tcp_stream_transmission
.write_all(Handshake::new(peer_id, info_hash).to_bytes().as_ref())
.unwrap();
let mut buffer = vec![0u8; 4096 * 10];
let mut poller = Poller::new().unwrap();
poller.insert(&tcp_stream_ktorrent).unwrap();
poller.insert(&tcp_stream_transmission).unwrap();
poller.interest(&tcp_stream_ktorrent, Event::readable(0));
poller.interest(&tcp_stream_transmission, Event::readable(1));
let mut items = vec![
TcpState {
builder: Default::default(),
handshake: None,
stream: tcp_stream_ktorrent,
},
TcpState {
builder: Default::default(),
handshake: None,
stream: tcp_stream_transmission,
},
];
let mut peer_map: HashMap<(U160, U160), usize> = Default::default();
loop {
let mut events: Vec<Event> = vec![];
poller.wait(&mut events, Some(Duration::from_secs(10)));
for event in events {
println!("Event => {:?}", event);
if !event.readable {
continue;
}
let item = &mut items[event.key];
let packet = item.stream.read(&mut buffer).unwrap();
item.builder.extend_from_slice(&buffer[..packet]);
let handshake = if let Some(handshake) = &item.handshake {
handshake
} else {
if item.builder.len() >= 68 {
item.handshake =
Some(Handshake::from_bytes(item.builder.split_to(68).freeze()).unwrap());
let handshake = item.handshake.as_ref().unwrap();
println!("{} => {:?}", item.stream.peer_addr().unwrap(), handshake);
peer_map.insert((handshake.info_hash(), handshake.peer_id()), event.key);
session_manager.handshake(*handshake, item.stream.peer_addr().unwrap(), TCP);
handshake
} else {
continue;
}
};
while item.builder.len() >= 4 {
let len = u32::from_be_bytes(item.builder[..4].try_into().unwrap());
if len + 4 > item.builder.len() as u32 {
break;
}
if len == 0 {
item.builder.split_to(4);
continue;
}
let message_bytes = item.builder.split_to((4 + len) as usize).freeze();
let msg = Message::from_bytes(message_bytes.slice(4..)).unwrap();
println!("{} => {:?}", item.stream.peer_addr().unwrap(), msg);
if !session_manager.process(info_hash, handshake.peer_id(), msg) {
exit(1);
}
}
poller.interest(&item.stream, Event::readable(event.key));
}
while let Some(queued) = session_manager.next() {
if let Some(key) = peer_map.get(&(queued.info_hash, queued.peer_id)) {
let item = &mut items[*key];
println!("{} <= {:?}", queued.addr, queued.message);
item.stream
.write_all(&queued.message.to_length_prefixed_bytes())
.unwrap();
}
}
println!("=> Running house keeping");
session_manager.house_keeping();
}
let mut instance = TormentInstance::new(50002, session_manager);
instance.logic_loop();
}

@ -6,6 +6,7 @@ use std::net::SocketAddr;
use std::pin::Pin;
use std::str::FromStr;
use std::time::{Duration, Instant};
use torment_core::peer_storage::{PeerStorage, PeerStorageHolder};
use torment_dht::host_node::HostNode;
use torment_dht::krpc::{FromBencode, Message, ToBencode};
@ -22,7 +23,8 @@ async fn main() {
let socket = UdpSocket::bind(SocketAddr::from_str("[::]:50002").unwrap())
.await
.unwrap();
let mut node = HostNode::new(Default::default(), Some(50002));
let peer_storage = PeerStorage::new();
let mut node = HostNode::new(PeerStorageHolder::new(peer_storage), Some(50002));
node.add_bootstrap(SocketAddr::from_str("67.215.246.10:6881").unwrap(), None);
node.add_bootstrap(
SocketAddr::from_str("[2001:41d0:c:5ac:5::1]:6881").unwrap(),

@ -6,13 +6,12 @@ use std::collections::{HashSet, VecDeque};
use std::convert::TryInto;
use std::net::{IpAddr, SocketAddr};
use std::ops::Add;
use std::rc::Rc;
use std::sync::RwLock;
use std::time::{Duration, Instant};
use torment_core::infohash::v1::U160;
use torment_core::ip::IpAddrExt;
use torment_core::peer_storage::{PeerStorageHolder, PeerStorageSource};
use torment_core::utils::{EphemeralMap, EphemeralSet};
use torment_core::{ContactInfo, LookupFilter, PeerStorage};
use torment_core::{ContactInfo, LookupFilter};
#[derive(Debug)]
enum OpenRequest {
@ -34,7 +33,7 @@ pub struct HostNode {
ipv6_table: Table,
nodes: EphemeralMap<(U160, IpAddr, u16), PeerNode>,
queue: VecDeque<(Message, SocketAddr)>,
peer_storage: Rc<RwLock<PeerStorage>>,
peer_storage: PeerStorageHolder,
}
#[derive(Debug)]
@ -92,7 +91,7 @@ impl PeerNode {
}
impl HostNode {
pub fn new(peer_storage: Rc<RwLock<PeerStorage>>, port: Option<u16>) -> HostNode {
pub fn new(peer_storage: PeerStorageHolder, port: Option<u16>) -> HostNode {
let id = U160::random();
HostNode {
id,
@ -108,7 +107,7 @@ impl HostNode {
}
pub fn from_persistent_state(
peer_storage: Rc<RwLock<PeerStorage>>,
peer_storage: PeerStorageHolder,
port: Option<u16>,
state: PersistentState,
) -> HostNode {
@ -351,10 +350,11 @@ impl HostNode {
}
if get_peers.values.len() > 0 {
self.peer_storage
.write()
.unwrap()
.add_peers(info_hash, get_peers.values.clone());
self.peer_storage.add_peers(
info_hash,
get_peers.values.clone(),
PeerStorageSource::DHT,
);
}
for node in &get_peers.nodes.nodes {
@ -502,7 +502,7 @@ impl HostNode {
get_peers
.want
.unwrap_or_else(|| if from.is_ipv4() { Want::N4 } else { Want::N6 });
let peers = self.peer_storage.read().unwrap().get_peers(
let peers = self.peer_storage.get_peers(
get_peers.info_hash,
if table == Want::N4 {
LookupFilter::IPv4
@ -611,7 +611,7 @@ impl HostNode {
self.queue
.push_back((Message::error(t, 203, "Bad token".to_string()), from))
} else {
self.peer_storage.write().unwrap().add_peers(
self.peer_storage.add_peers(
announce.info_hash,
vec![SocketAddr::new(
from.ip(),
@ -621,6 +621,7 @@ impl HostNode {
announce.port
},
)],
PeerStorageSource::DHT,
);
self.queue
.push_back((Message::response_empty(self.id, t), from))
@ -686,13 +687,12 @@ mod test {
use crate::host_node::HostNode;
use crate::krpc::Message;
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
use std::rc::Rc;
use std::sync::RwLock;
use torment_core::infohash::v1::U160;
use torment_core::{ContactInfo, PeerStorage};
use torment_core::peer_storage::{PeerStorage, PeerStorageHolder};
use torment_core::ContactInfo;
fn get_host() -> HostNode {
let peer_storage = Rc::new(RwLock::new(PeerStorage::new()));
let peer_storage = PeerStorageHolder::new(PeerStorage::new());
HostNode::new(peer_storage, None)
}

@ -10,7 +10,12 @@ edition = "2018"
torment-core = { path = "../torment-core" }
torment-peer = { path = "../torment-peer" }
torment-storage = { path = "../torment-storage" }
torment-tracker = { path = "../torment-tracker" }
reqwest = { version = "0.10.8", features = ["blocking"] }
crossbeam-channel = "0.4.3"
bytes = "0.5.6"
url = "2.1.1"
lazy_static = "1.4.0"
ring = "0.16.15"
ring = "0.16.15"
polling = "0.1.6"
rand = "0.7.3"

@ -0,0 +1,2 @@
pub const MAX_OPEN_REQUESTS: usize = 250;
pub const MAX_CONNECTIONS_PER_THREAD: usize = 100;

@ -1,3 +1,6 @@
mod consts;
pub mod session_manager;
pub mod torment_instance;
pub mod torrent_manager;
pub mod tracker_manager;
pub use consts::*;

@ -1,8 +1,10 @@
use crate::torrent_manager::TorrentManager;
use std::collections::{HashMap, VecDeque};
use std::net::SocketAddr;
use crate::tracker_manager::TrackerManager;
use std::collections::{HashMap, HashSet, VecDeque};
use std::net::{IpAddr, SocketAddr};
use std::option::Option::Some;
use torment_core::infohash::v1::U160;
use torment_core::peer_storage::{PeerStorage, PeerStorageHolder};
use torment_peer::message::{Handshake, Message};
use torment_peer::PeerProtocol;
@ -14,17 +16,60 @@ pub struct QueuedMessage {
}
pub struct SessionManager {
id: U160,
torrents: HashMap<U160, TorrentManager>,
torrents_ids: HashSet<U160>,
peer_socket: HashMap<(U160, U160), SocketAddr>,
message_queue: VecDeque<QueuedMessage>,
tracker_manager: TrackerManager,
pub peer_storage: PeerStorageHolder,
}
impl SessionManager {
pub fn peer_count(&self, info_hash: U160) -> usize {
self.torrents[&info_hash].peer_count()
}
pub fn torrents(&self) -> Vec<U160> {
self.torrents_ids.iter().copied().collect()
}
pub fn torrent_manager(&self, info_hash: U160) -> &TorrentManager {
&self.torrents[&info_hash]
}
pub fn id(&self) -> U160 {
self.id
}
pub fn tracker_manager(&self) -> &TrackerManager {
&self.tracker_manager
}
pub fn tracker_manager_mut(&mut self) -> &mut TrackerManager {
&mut self.tracker_manager
}
pub fn is_done(&self, info_hash: U160) -> bool {
if let Some(torrent) = self.torrents.get(&info_hash) {
torrent.is_done()
} else {
false
}
}
pub fn dump_queue(&mut self) -> VecDeque<QueuedMessage> {
std::mem::replace(&mut self.message_queue, VecDeque::new())
}
pub fn add_torrent_manager(&mut self, torrent: TorrentManager) {
self.torrents_ids.insert(torrent.info_hash());
self.torrents.insert(torrent.info_hash(), torrent);
}
#[allow(dead_code)]
fn remove_torrent_manager(&mut self, info_hash: U160) -> Option<TorrentManager> {
self.torrents_ids.remove(&info_hash);
self.torrents.remove(&info_hash)
}
@ -46,7 +91,8 @@ impl SessionManager {
pub fn process(&mut self, torrent: U160, peer_id: U160, message: Message) -> bool {
if let Some(torrent_manager) = self.torrents.get_mut(&torrent) {
if torrent_manager.process(peer_id, message) {
while let Some((peer_id, message)) = torrent_manager.next() {
let queue = torrent_manager.dump_queue();
for (peer_id, message) in queue {
if let Some(addr) = self.peer_socket.get(&(peer_id, torrent)).copied() {
self.message_queue.push_back(QueuedMessage {
message,
@ -66,9 +112,14 @@ impl SessionManager {
}
}
pub fn new() -> SessionManager {
pub fn new(ip: IpAddr, port: u16, peer_id: U160) -> SessionManager {
let peer_storage = PeerStorageHolder::new(PeerStorage::new());
SessionManager {
id: peer_id,
torrents: Default::default(),
tracker_manager: TrackerManager::new(ip, port, peer_id, peer_storage.clone()),
peer_storage,
torrents_ids: Default::default(),
peer_socket: Default::default(),
message_queue: Default::default(),
}
@ -79,8 +130,33 @@ impl SessionManager {
}
pub fn house_keeping(&mut self) {
for (_, torrent) in &mut self.torrents {
for (info_hash, torrent) in &mut self.torrents {
torrent.house_keeping();
let queue = torrent.dump_queue();
for (peer_id, message) in queue {
if let Some(addr) = self.peer_socket.get(&(peer_id, *info_hash)).copied() {
self.message_queue.push_back(QueuedMessage {
message,
addr,
peer_id,
info_hash: *info_hash,
});
}
}
}
}
pub fn announce(&mut self) {
println!("Announcing torrents...");
for info_hash in self.torrents_ids.clone() {
let trackers = self.torrents[&info_hash].trackers().clone();
for tracker_tier in trackers {
for tracker in tracker_tier {
self.tracker_manager
.announce(tracker, &self.torrents[&info_hash]);
}
}
}
}
}

@ -0,0 +1,432 @@
#![allow(dead_code)]
use crate::session_manager::SessionManager;
use bytes::{Buf, Bytes, BytesMut};
use crossbeam_channel::{bounded, unbounded, Receiver, Sender};
use polling::{Event, Poller};
use rand::seq::SliceRandom;
use std::cmp::max;
use std::collections::{HashMap, HashSet, VecDeque};
use std::convert::TryInto;
use std::io::{ErrorKind, Read, Write};
use std::net::{IpAddr, Ipv6Addr, SocketAddr, TcpListener, TcpStream};
use std::ops::Add;
use std::option::Option::Some;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use std::thread::JoinHandle;
use std::time::{Duration, Instant};
use torment_core::infohash::v1::U160;
use torment_core::LookupFilter;
use torment_peer::message::{Handshake, Message};
use torment_peer::PeerProtocol;
use torment_peer::PeerProtocol::TCP;
pub struct TormentInstance {
id: U160,
port: u16,
dht_enabled: bool,
connections: OffshoreConnections,
tracking: HashMap<SocketAddr, (U160, U160)>,
handshake_sent: HashSet<SocketAddr>,
session: SessionManager,
}
struct OffshoreConnections {
control_receiver: Receiver<ControlMessage>,
thread: JoinHandle<()>,
thread_sender: Sender<ControlMessage>,
}
enum ControlMessage {
Data(SocketAddr, Bytes),
Handshake(Handshake, SocketAddr, PeerProtocol),
Own(TcpStream, SocketAddr),
Disown(SocketAddr),
}
struct Stream {
buffer: BytesMut,
addr: SocketAddr,
stream: TcpStream,
handshake_received: bool,
id: usize,
handshake_sent: bool,
}
fn connection_pool_thread(
port: u16,
control_sender: Sender<ControlMessage>,
thread_receiver: Receiver<ControlMessage>,
) {
let mut streams: HashMap<SocketAddr, Stream> = HashMap::new();
let counter = AtomicUsize::new(0);
let mut index: HashMap<usize, SocketAddr> = HashMap::new();
let listener =
TcpListener::bind(SocketAddr::new(IpAddr::V6(Ipv6Addr::UNSPECIFIED), port)).unwrap();
let (notify_sender, notify_receiver) = bounded(1);
let (notify_restart_sender, notify_restart_receiver) = bounded(1);
let poller = Arc::new(Poller::new().unwrap());
let thread_receiver_clone = thread_receiver.clone();
let poller_clone = Arc::clone(&poller);
std::thread::Builder::new()
.name(format!("io/notify"))
.spawn(move || {
for message in thread_receiver {
// println!("Received channel message, notifying wait");
poller_clone.notify().unwrap();
notify_sender.send(message).unwrap();
notify_restart_receiver.recv().unwrap();
}
});
poller.insert(&listener).unwrap();
poller.interest(&listener, Event::readable(usize::MAX));
let mut buffer = [0u8; 1024 * 1024];
loop {
let mut events = vec![];
match poller.wait(&mut events, None) {
Ok(_) => {}
Err(err) if err.kind() == ErrorKind::Interrupted => {}
Err(err) => Err(err).unwrap(),
}
// println!("Events => {:?}", events);
for event in events {
if !event.readable {
continue;
}
if event.key == usize::MAX {
while let Ok((stream, addr)) = listener.accept() {
let id = counter.fetch_add(1, Ordering::AcqRel);
stream.set_nodelay(true).unwrap();
poller.insert(&stream).unwrap();
poller.interest(&stream, Event::readable(id)).unwrap();
streams.insert(
addr,
Stream {
addr,
handshake_received: false,
handshake_sent: false,
buffer: BytesMut::new(),
stream,
id,
},
);
index.insert(id, addr);
}
poller
.interest(&listener, Event::readable(usize::MAX))
.unwrap();
continue;
}
let addr = index[&event.key];
let size = streams
.get_mut(&addr)
.unwrap()
.stream
.read(&mut buffer)
.unwrap_or(0);
if size == 0 {
control_sender.send(ControlMessage::Disown(addr)).unwrap();
index.remove(&event.key);
if let Some(stream) = streams.remove(&addr) {
poller.remove(&stream.stream).unwrap();
}
println!("{} == Disconnected", addr);
continue;
}
// println!("{} => {} bytes", addr, size);
let stream = streams.get_mut(&addr).unwrap();
stream.buffer.extend_from_slice(&buffer[0..size]);
if stream.buffer.len() >= 68 && !stream.handshake_received {
let handshake = Handshake::from_bytes(stream.buffer.split_to(68).freeze());
let handshake = match handshake {
Err(_) => {
control_sender.send(ControlMessage::Disown(addr)).unwrap();
index.remove(&event.key);
if let Some(stream) = streams.remove(&addr) {
poller.remove(&stream.stream).unwrap();
}
continue;
}
Ok(hand) => hand,
};
println!("{} => {:?}", stream.addr, handshake);
control_sender
.send(ControlMessage::Handshake(handshake, stream.addr, TCP))
.unwrap();
stream.handshake_received = true;
}
poller
.interest(&stream.stream, Event::readable(event.key))
.unwrap();
if !stream.handshake_received {
continue;
}
while stream.buffer.len() >= 4 {
let len = u32::from_be_bytes(stream.buffer[..4].try_into().unwrap());
if len == 0 {
stream.buffer.advance(4);
continue;
}
if len + 4 > stream.buffer.len() as u32 {
break;
}
let mut message_bytes = stream.buffer.split_to((4 + len) as usize);
message_bytes.advance(4);
control_sender
.send(ControlMessage::Data(stream.addr, message_bytes.freeze()))
.unwrap();
}
}
let mut msgs = vec![];
if let Ok(message) = notify_receiver.try_recv() {
msgs.push(message);
}
while let Ok(message) = thread_receiver_clone.try_recv() {
msgs.push(message);
}
for message in msgs {
match message {
ControlMessage::Data(target, data) => {
let ok = if let Some(stream) = streams.get_mut(&target) {
if stream.stream.write_all(&data).is_err() {
control_sender
.send(ControlMessage::Disown(stream.addr))
.unwrap();
false
} else {
true
}
} else {
true
};
if !ok {
if let Some(stream) = streams.remove(&target) {
poller.remove(&stream.stream).unwrap();
index.remove(&stream.id);
println!("{} == Disconnected", stream.addr);
}
}
}
ControlMessage::Disown(addr) => {
if let Some(stream) = streams.remove(&addr) {
index.remove(&stream.id);
poller.remove(&stream.stream).unwrap();
}
}
ControlMessage::Own(stream, addr) => {
let id = counter.fetch_add(1, Ordering::AcqRel);
poller.insert(&stream).unwrap();
poller.interest(&stream, Event::readable(id)).unwrap();
streams.insert(
addr,
Stream {
addr,
handshake_received: false,
handshake_sent: true,
buffer: BytesMut::new(),
stream,
id,
},
);
index.insert(id, addr);
}
_ => {}
};
}
notify_restart_sender.send(()).unwrap();
}
}
impl TormentInstance {
pub fn new(port: u16, session: SessionManager) -> TormentInstance {
let (control_sender, control_receiver) = unbounded();
let (thread_sender, thread_receiver) = unbounded();
let thread = std::thread::Builder::new()
.name(format!("io/poll"))
.spawn(move || connection_pool_thread(port, control_sender, thread_receiver))
.unwrap();
TormentInstance {
id: session.id(),
port,
dht_enabled: false,
connections: OffshoreConnections {
control_receiver,
thread,
thread_sender,
},
tracking: Default::default(),
handshake_sent: Default::default(),
session,
}
}
pub fn tracker_logic(&mut self) {
self.session.announce();
self.session.tracker_manager_mut().house_keeping();
for torrent in self.session.torrents() {
let peer_count = self.session.peer_count(torrent);
if peer_count > 25 {
continue;
}
let mut peers = self
.session
.peer_storage
.get_peers(torrent, LookupFilter::All);
println!("have {} peers for {}", peers.len(), torrent);
peers.shuffle(&mut rand::thread_rng());
let mut todo = max(0, 25 - peer_count);
while todo > 0 && peers.len() > 0 {
let peer = peers.pop().unwrap();
if self.tracking.contains_key(&peer) {
continue;
}
let thread_sender = self.connections.thread_sender.clone();
let peer_id = self.id;
self.handshake_sent.insert(peer);
std::thread::spawn(move || {
// println!("Trying connection with {}", peer);
if let Ok(mut stream) = TcpStream::connect(peer) {
stream.set_nodelay(true).unwrap();
stream
.write_all(&Handshake::new(peer_id, torrent).to_bytes())
.unwrap();
// println!("{} <= Connecting", peer);
thread_sender
.send(ControlMessage::Own(stream, peer))
.unwrap();
}
});
todo -= 1;
}
}
}
pub fn logic_loop(&mut self) {
let mut next_house_keeping = Instant::now();
loop {
if next_house_keeping < Instant::now() {
self.session.house_keeping();
self.tracker_logic();
next_house_keeping = Instant::now().add(Duration::from_secs(10));
}
while next_house_keeping > Instant::now() {
if let Ok(message) = self
.connections
.control_receiver
.recv_timeout(Duration::from_secs(1))
{
match message {
ControlMessage::Handshake(handshake, addr, protocol) => {
let handshake_sent = self.handshake_sent.remove(&addr);
self.tracking
.insert(addr, (handshake.peer_id(), handshake.info_hash()));
if self.session.handshake(handshake, addr, protocol) {
if !handshake_sent {
self.connections
.thread_sender
.send(ControlMessage::Data(
addr,
Bytes::from(
Handshake::new(self.id, handshake.info_hash())
.to_bytes()
.to_vec(),
),
))
.unwrap();
}
}
}
ControlMessage::Data(sock_addr, data) => {
if let Some((peer_id, info_hash)) =
self.tracking.get(&sock_addr).copied()
{
let message = Message::from_bytes(data);
// println!("{} => {:?}", sock_addr, message);
if message.is_err() {
continue;
}
self.session.process(info_hash, peer_id, message.unwrap());
} else {
// println!("{} => ????", sock_addr);
}
}
_ => {}
}
}
let queue: HashMap<_, VecDeque<_>> =
self.session
.dump_queue()
.into_iter()
.fold(HashMap::new(), |mut map, item| {
map.entry(item.addr).or_default().push_back(item.message);
map
});
for (addr, messages) in queue {
let mut bytes = BytesMut::new();
for msg in messages {
// println!("{} <= {:?}", addr, msg);
bytes.extend_from_slice(&msg.to_length_prefixed_bytes());
}
self.connections
.thread_sender
.send(ControlMessage::Data(addr, bytes.freeze()))
.unwrap()
}
}
}
}
}

@ -1,15 +1,19 @@
use crate::tracker_manager::{TrackerId, TrackerManager};
use crate::MAX_OPEN_REQUESTS;
use bytes::Bytes;
use ring::digest::{digest, SHA1_FOR_LEGACY_USE_ONLY};
use std::cmp::max;
use std::collections::{HashMap, HashSet, VecDeque};
use std::net::SocketAddr;
use std::ops::Index;
use std::ops::Add;
use std::option::Option::Some;
use std::path::PathBuf;
use std::time::{Duration, Instant};
use torment_core::infohash::v1::U160;
use torment_core::metainfo::{MetaInfo, Torrent};
use torment_core::Bitfield;
use torment_peer::message::{Handshake, Message, PieceMessage, SelectionMessage};
use torment_core::utils::EphemeralSet;
use torment_core::{Bitfield, REQUEST_SIZE};
use torment_peer::message::{Handshake, Message, PieceMessage};
use torment_peer::{Peer, PeerProtocol};
use torment_storage::{StorageMap, ToStorageMap};
@ -46,15 +50,53 @@ pub struct TorrentManager {
peers: HashMap<U160, Peer>,
queue: VecDeque<(U160, Message)>,
storage_map: StorageMap,
requests_queue: VecDeque<u32>,
open_requests: HashMap<u32, EphemeralSet<u32>>,
uploaded: usize,
downloaded: usize,
}
pub const REQUEST_SIZE: usize = 16384;
impl TorrentManager {
pub fn peer_count(&self) -> usize {
self.peers.len()
}
pub fn trackers(&self) -> &Vec<Vec<TrackerId>> {
&self.trackers
}
pub fn info_hash(&self) -> U160 {
self.info_hash
}
pub fn is_done(&self) -> bool {
self.bitfield.all()
}
pub fn uploaded(&self) -> usize {
self.uploaded
}
pub fn downloaded(&self) -> usize {
self.downloaded
}
pub fn bytes_left(&self) -> i64 {
let mut size = self.storage_map.size() as i64;
let piece_length = self.storage_map.get_piece_length(0) as i64;
for i in 0..self.bitfield.size() as u32 {
if self.bitfield.get(i) {
size -= piece_length;
}
}
max(0, size)
}
pub fn dump_queue(&mut self) -> VecDeque<(U160, Message)> {
std::mem::replace(&mut self.queue, VecDeque::new())
}
pub fn from_torrent(
torrent: Torrent,
target: TorrentTarget,
@ -84,9 +126,13 @@ impl TorrentManager {
torrent: Some(torrent.clone()),
}),
storage_map: torrent.to_storage_map(&target.path, target.is_base_path),
requests_queue: Default::default(),
target,
peers: HashMap::new(),
queue: Default::default(),
open_requests: Default::default(),
uploaded: 0,
downloaded: 0,
}
}
@ -107,7 +153,8 @@ impl TorrentManager {
}
let meta_info = self.meta_info();
let peer = Peer::new(addr, protocol, handshake, meta_info);
let mut peer = Peer::new(addr, protocol, handshake, meta_info);
peer.send_bitfield(&self.bitfield);
self.peers.insert(peer.id(), peer);
true
@ -127,12 +174,12 @@ impl TorrentManager {
pub fn process(&mut self, peer_id: U160, message: Message) -> bool {
let mut queue = vec![];
if let Message::Piece(piece) = &message {
self.downloaded += piece.piece.len()
}
let ok = if let Some(peer) = self.peers.get_mut(&peer_id) {
if peer.process(message) {
while let Some(message) = peer.next() {
self.queue.push_back((peer_id, message));
}
while let Some(piece) = peer.next_piece() {
if self.storage_map.has_piece(piece.index() as usize) {
continue;
@ -151,6 +198,10 @@ impl TorrentManager {
}
}
while let Some(_) = peer.next_have() {
// Something i guess
}
while let Some(piece_request) = peer.next_request() {
if !self.bitfield.get(piece_request.index()) {
continue;
@ -175,6 +226,9 @@ impl TorrentManager {
))
}
self.queue_requests(peer_id);
let msgs = self.peers.get_mut(&peer_id).unwrap().dump_queue();
self.queue_messages(peer_id, msgs);
true
} else {
false
@ -183,6 +237,7 @@ impl TorrentManager {
false
};
// offload to io thread?
for have in queue {
let piece_hash = self.meta_info().hash(have);
let piece_data = self.storage_map.read_piece(have).unwrap();
@ -203,7 +258,6 @@ impl TorrentManager {
if !self.peers[&key].has_piece(have as u32) && self.peers[&key].we_choked() {
self.peers.get_mut(&key).unwrap().set_we_choked(false);
self.queue.push_back((key, Message::Unchoke));
}
}
}
@ -211,65 +265,133 @@ impl TorrentManager {
ok
}
fn queue_messages(&mut self, peer_id: U160, messages: VecDeque<Message>) {
for msg in messages {
if let Message::Piece(piece) = &msg {
self.uploaded += piece.piece.len();
}
self.queue.push_back((peer_id, msg));
}
}
pub fn next(&mut self) -> Option<(U160, Message)> {
self.queue.pop_front()
}
pub fn house_keeping(&mut self) {
let mut peers = self
.peers
.iter()
.filter_map(|(_, peer)| {
if peer.has()1
if peer.is_choked() {
None
} else {
Some(peer.id())
}
})
.collect::<HashSet<_>>();
let pieces = self.meta_info().pieces() as u32;
for i in 0u32..pieces {
if self.bitfield.get(i) {
fn get_next_request_piece_for_peer(&mut self, peer: &U160) -> Option<(u32, u32, u32)> {
let mut queue_index = 0;
while let Some(index) = self.requests_queue.get(queue_index).copied() {
if !self.peers[peer].has_piece(index) {
queue_index += 1;
continue;
}
let length = self.storage_map.get_piece_length(i as usize);
let mut offset = 0;
let bits = self.storage_map.get_bits_in_pieces(index as usize);
if self.open_requests.get(&index).map_or(0, |set| set.len()) >= bits {
self.requests_queue.remove(0);
}
for peer in &peers.clone() {
if !self.peers[peer].has_piece(i) {
let set = self
.open_requests
.entry(index)
.or_insert(EphemeralSet::new());
for i in 0..bits as u32 {
let bit_offset = i * REQUEST_SIZE as u32;
if set.contains(&bit_offset) {
continue;
}
while offset < length && self.peers[peer].count_open_requests() < 25 {
if !self.storage_map.has_piece_bit(i as usize, offset) {
let request_length = if (offset + REQUEST_SIZE) > length {
length - offset
} else {
REQUEST_SIZE
};
set.insert(bit_offset, Instant::now().add(Duration::from_secs(10)));
return Some((
index,
bit_offset,
self.storage_map
.get_bit_length(index as usize, bit_offset as usize),
));
}
}
let msg = SelectionMessage::new(i, offset as u32, request_length as u32);
None
}
if self.peers.get_mut(peer).unwrap().requested(msg) {
self.queue.push_back((*peer, Message::Request(msg)));
}
}
pub fn house_keeping(&mut self) {
let mut map: HashMap<u32, usize> = HashMap::new();
let mut interested_peers = HashSet::new();
if self.peers.len() <= 0 {
return;
}
offset += REQUEST_SIZE;
}
let mut done = 0;
if self.peers[peer].count_open_requests() >= 25 {
peers.remove(peer);
}
for i in 0..self.meta_info().pieces() as u32 {
if self.bitfield.get(i) {
done += 1;
// Don't need to queue anything
continue;
}
if offset >= length {
break;
let mut entries = 0;
for (_, peer) in &mut self.peers {
if peer.has_piece(i) {
entries += 1;
interested_peers.insert(peer.id());
}
}
if entries == 0 {
// Can't queue entries without peers
continue;
}
map.insert(i, entries);
}
println!(
"{}%",
(done as f64 / self.meta_info().pieces() as f64) * 100f64
);
let mut pieces: Vec<_> = map.keys().copied().collect();
pieces.sort_by_key(|piece| map[piece]);
self.requests_queue = VecDeque::from(pieces);
for (_, peer) in &mut self.peers {
if !interested_peers.contains(&peer.id()) || self.requests_queue.len() == 0 {
peer.lost_interest();
continue;
}
peer.interested();
if peer.is_choked() {
// Don't send requests if they're choked
continue;
}
}
let peer_ids = self.peers.keys().copied().collect::<Vec<_>>();
for peer_id in peer_ids {
self.queue_requests(peer_id);
let message_queue = self.peers.get_mut(&peer_id).unwrap().dump_queue();
self.queue_messages(peer_id, message_queue);
}
}
fn queue_requests(&mut self, peer_id: U160) {
if self.peers[&peer_id].is_choked() {
return;
}
let amount = MAX_OPEN_REQUESTS - self.peers[&peer_id].count_open_requests();
for _ in 0..amount {
if let Some((index, offset, length)) = self.get_next_request_piece_for_peer(&peer_id) {
self.peers
.get_mut(&peer_id)
.unwrap()
.request(index, offset, length);
} else {
break;
}
}
}
}

@ -1,20 +1,94 @@
use crate::torrent_manager::TorrentManager;
use crossbeam_channel::{unbounded, Receiver, Sender};
use reqwest::blocking::Client;
use reqwest::header::HeaderMap;
use std::collections::HashMap;
use std::net::IpAddr;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::RwLock;
use std::thread::JoinHandle;
use torment_core::infohash::v1::U160;
use torment_core::peer_storage::PeerStorageHolder;
use torment_tracker::{
block_do_announce, Tracker, TrackerAnnounceRequest, TrackerAnnounceResponse,
};
use url::Url;
pub struct TrackerManager {
id: U160,
ip: IpAddr,
port: u16,
counter: AtomicUsize,
trackers: HashMap<usize, Tracker>,
trackers: HashMap<usize, RwLock<Tracker>>,
url_index: HashMap<String, usize>,
peer_storage: PeerStorageHolder,
tracker_offshore_state: TrackerOffshoreState,
}
pub struct Tracker {
url: Url,
struct TrackerOffshoreState {
threads: Vec<JoinHandle<()>>,
tracker_request_sender: Sender<(usize, TrackerAnnounceRequest)>,
tracker_request_receiver: Receiver<(usize, TrackerAnnounceRequest)>,
tracker_response_sender: Sender<(usize, TrackerAnnounceResponse)>,
tracker_response_receiver: Receiver<(usize, TrackerAnnounceResponse)>,
}
impl TrackerOffshoreState {
fn new() -> TrackerOffshoreState {
let (req_send, req_recv) = unbounded();
let (resp_send, resp_recv) = unbounded();
TrackerOffshoreState {
threads: vec![],
tracker_request_sender: req_send,
tracker_request_receiver: req_recv,
tracker_response_sender: resp_send,
tracker_response_receiver: resp_recv,
}
}
}
pub type TrackerId = usize;
fn tracker_thread(
input: Receiver<(usize, TrackerAnnounceRequest)>,
output: Sender<(usize, TrackerAnnounceResponse)>,
) {
let mut map = HeaderMap::new();
map.insert(
reqwest::header::USER_AGENT,
format!("eater's Torment/{}", env!("CARGO_PKG_VERSION"))
.parse()
.unwrap(),
);
let client = Client::builder().default_headers(map).build().unwrap();
for (tracker_id, req) in input {
output
.send((tracker_id, block_do_announce(req, &client)))
.unwrap();
}
}
impl TrackerManager {
pub fn new(
ip: IpAddr,
port: u16,
peer_id: U160,
peer_storage: PeerStorageHolder,
) -> TrackerManager {
TrackerManager {
id: peer_id,
ip,
port,
counter: Default::default(),
trackers: Default::default(),
url_index: Default::default(),
peer_storage,
tracker_offshore_state: TrackerOffshoreState::new(),
}
}
pub fn get_tracker_id(&mut self, url: &Url) -> Option<TrackerId> {
// dht is not a tracker bye
if url.scheme() == "dht" {
@ -28,7 +102,68 @@ impl TrackerManager {
let new_id = self.counter.fetch_add(1, Ordering::AcqRel);
self.url_index.insert(url_str.to_string(), new_id);
self.trackers.insert(
new_id,
RwLock::new(Tracker::new(url.clone(), self.peer_storage.clone())),
);
Some(new_id)
}
pub fn announce(&mut self, tracker_id: usize, torrent: &TorrentManager) {
let id = torrent.info_hash();
{
let tracker = &self.trackers[&tracker_id].read().unwrap();
if !tracker.needs_update(id) {
return;
}
}
let tracker = &mut self.trackers[&tracker_id].write().unwrap();
println!(
"Queueing announce {} on {}",
torrent.info_hash(),
tracker.url()
);
let req = tracker.create_update_request(
id,
self.id,
self.ip,
self.port,
torrent.uploaded(),
torrent.downloaded(),
torrent.bytes_left(),
);
self.tracker_offshore_state
.tracker_request_sender
.send((tracker_id, req))
.unwrap()
}
pub fn house_keeping(&mut self) {
while self.tracker_offshore_state.threads.len() < 5 {
let sender = self.tracker_offshore_state.tracker_response_sender.clone();
let receiver = self.tracker_offshore_state.tracker_request_receiver.clone();
self.tracker_offshore_state.threads.push(
std::thread::Builder::new()
.name(format!(
"tracker/{}",
self.tracker_offshore_state.threads.len()
))
.spawn(|| tracker_thread(receiver, sender))
.unwrap(),
);
}
while let Ok((tracker_id, resp)) = self
.tracker_offshore_state
.tracker_response_receiver
.try_recv()
{
self.trackers[&tracker_id].write().unwrap().process(resp);
}
}
}

@ -48,6 +48,7 @@ pub struct Peer {
requested_queue: HashSet<SelectionMessage>,
received_pieces: VecDeque<PieceMessage>,
queue: VecDeque<Message>,
have_queue: VecDeque<u32>,
}
impl Peer {
@ -55,6 +56,10 @@ impl Peer {
self.id
}
pub fn dump_queue(&mut self) -> VecDeque<Message> {
std::mem::replace(&mut self.queue, VecDeque::new())
}
pub fn new(
address: SocketAddr,
protocol: PeerProtocol,
@ -74,6 +79,7 @@ impl Peer {
requested_queue: Default::default(),
received_pieces: Default::default(),
queue: Default::default(),
have_queue: Default::default(),
}
}
@ -87,7 +93,10 @@ impl Peer {
Message::Unchoke => self.their_state.chocked = false,
Message::Interested => self.their_state.interested = true,
Message::NotInterested => self.their_state.interested = false,
Message::Have(nr) => self.has.set(nr),
Message::Have(nr) => {
self.has.set(nr);
self.have_queue.push_back(nr);
}
Message::Bitfield(bitfield) => self.has.add(bitfield),
Message::Request(selection) => {
self.request_queue.push_back(selection);
@ -130,17 +139,68 @@ impl Peer {
}
pub fn set_we_choked(&mut self, choked: bool) {
if self.our_state.chocked != choked {
self.queue.push_back(if choked {
Message::Choke
} else {
Message::Unchoke
})
}
self.our_state.chocked = choked;
}
pub fn send_bitfield(&mut self, bitfield: &Bitfield) {
self.queue.push_back(Message::Bitfield(bitfield.clone()));
}
pub fn set_we_interested(&mut self, interested: bool) {
self.our_state.interested = interested;
}
pub fn request(&mut self, index: u32, offset: u32, length: u32) {
let msg = SelectionMessage::new(index, offset, length);
if self.requested(msg) {
self.queue.push_back(Message::Request(msg));
}
}
pub fn requested(&mut self, selection: SelectionMessage) -> bool {
self.requested_queue.insert(selection)
}
pub fn unchoke(&mut self) {
if !self.our_state.chocked {
return;
}
self.queue.push_back(Message::Unchoke);
}
pub fn choke(&mut self) {
if self.our_state.chocked {
return;
}
self.queue.push_back(Message::Choke);
}
pub fn interested(&mut self) {
if self.our_state.interested {
return;
}
self.our_state.interested = true;
self.queue.push_back(Message::Interested);
}
pub fn lost_interest(&mut self) {
if !self.our_state.interested {
return;
}
self.queue.push_back(Message::NotInterested);
}
pub fn next_piece(&mut self) -> Option<PieceMessage> {
self.received_pieces.pop_front()
}
@ -157,6 +217,7 @@ impl Peer {
pub fn addr(&self) -> SocketAddr {
self.address
}
pub fn has_piece(&self, index: u32) -> bool {
self.has.get(index as u32)
}
@ -164,12 +225,8 @@ impl Peer {
pub fn next(&mut self) -> Option<Message> {
self.queue.pop_front()
}
}
#[cfg(test)]
mod tests {
#[test]
fn it_works() {
assert_eq!(2 + 2, 4);
pub fn next_have(&mut self) -> Option<u32> {
self.have_queue.pop_front()
}
}

@ -49,7 +49,7 @@ impl Message {
Message::Have(u32::from_be_bytes(bytes[1..5].try_into().unwrap()))
}
5 => Message::Bitfield(Bitfield::new(bytes.slice(1..))),
5 => Message::Bitfield(Bitfield::new(bytes.slice(1..), bytes.len() - 1)),
6 | 8 => {
if bytes.len() < 13 {

@ -1,20 +1,16 @@
use bytes::{Bytes, BytesMut};
use lazy_static::lazy_static;
use remem::{ItemGuard, Pool};
use std::borrow::Borrow;
use std::cmp::min;
use std::collections::{BTreeMap, HashMap, HashSet};
use std::fmt::{Debug, Formatter};
use std::fs::{DirBuilder, File, OpenOptions};
use std::io;
use std::io::{Read, Seek, SeekFrom, Write};
use std::ops::{Add, Deref, Range};
use std::path::{Path, PathBuf, MAIN_SEPARATOR};
use std::rc::Rc;
use std::sync::Mutex;
use std::time::{Duration, Instant};
use torment_core::metainfo::{MetaInfo, MetaInfoObject, Torrent};
use torment_core::utils::EphemeralMap;
use torment_core::metainfo::{MetaInfoObject, Torrent};
use torment_core::REQUEST_SIZE;
lazy_static! {
static ref MEMORY_POOL: Pool<Vec<u8>> = Pool::new(|| vec![0u8; 4194304]);
@ -24,6 +20,7 @@ lazy_static! {
pub struct StorageMap {
base_path: PathBuf,
piece_length: usize,
bits_in_piece: usize,
pieces: usize,
open_files: HashMap<usize, Rc<Mutex<File>>>,
buffer: HashMap<usize, StoragePiece>,
@ -33,14 +30,14 @@ pub struct StorageMap {
pub struct StoragePiece {
index: usize,
pieces: usize,
bits: usize,
ranges: HashSet<usize>,
buffer: ItemGuard<'static, Vec<u8>>,
}
impl StoragePiece {
fn is_complete(&self) -> bool {
self.pieces == self.ranges.len()
self.bits == self.ranges.len()
}
}
@ -55,7 +52,6 @@ impl Debug for StoragePiece {
impl StorageMap {
fn get_offsets(&self, offset: usize, length: usize) -> Vec<usize> {
let x = 0..1;
let end = offset + length;
let mut range = self.mapping.range(offset..);
let mut items = vec![];
@ -142,7 +138,7 @@ impl StorageMap {
pub fn read_piece(&mut self, index: usize) -> io::Result<Vec<u8>> {
let mut bytes = vec![0; self.get_piece_length(index)];
self.read(index, 0, &mut bytes);
self.read(index, 0, &mut bytes)?;
Ok(bytes)
}
@ -166,21 +162,14 @@ impl StorageMap {
let item = if let Some(item) = self.buffer.get_mut(&index) {
item
} else {
let request_size = 2usize.pow(14);
let piece_length = self.get_piece_length(index);
let pieces = (piece_length / request_size)
+ if piece_length % request_size > 0 {
1
} else {
0
};
let bits = self.get_bits_in_pieces(index);
self.buffer.insert(index, {
StoragePiece {
index,
ranges: Default::default(),
buffer: MEMORY_POOL.get(),
pieces,
bits,
}
});
@ -209,16 +198,40 @@ impl StorageMap {
}
pub fn get_piece_length(&self, index: usize) -> usize {
if index + 1 == self.pieces {
let len = (self.size % self.piece_length);
if len == 0 {
self.piece_length
if index + 1 < self.pieces {
return self.piece_length;
}
let len = self.size % self.piece_length;
if len == 0 {
self.piece_length
} else {
len
}
}
pub fn get_bits_in_pieces(&self, index: usize) -> usize {
if index + 1 < self.pieces {
return self.bits_in_piece;
}
let piece_length = self.get_piece_length(index);
(piece_length / REQUEST_SIZE)
+ if piece_length % REQUEST_SIZE > 0 {
1
} else {
len
0
}
} else {
self.piece_length
}
pub fn get_bit_length(&self, index: usize, offset: usize) -> u32 {
let piece_length = self.get_piece_length(index);
if offset + REQUEST_SIZE <= piece_length {
return REQUEST_SIZE as u32;
}
(piece_length % REQUEST_SIZE) as u32
}
pub fn has_piece_bit(&self, index: usize, offset: usize) -> bool {
@ -330,15 +343,25 @@ impl StorageMapBuilder {
}
pub fn build(self) -> StorageMap {
let pieces = (self.offset / self.piece_length)
+ if self.offset % self.piece_length > 0 {
1
} else {
0
};
let bits_in_piece = (self.piece_length / REQUEST_SIZE)
+ if (self.piece_length % REQUEST_SIZE) > 0 {
1
} else {
0
};
StorageMap {
base_path: self.base_path,
piece_length: self.piece_length,
pieces: (self.offset / self.piece_length)
+ if self.offset % self.piece_length > 0 {
1
} else {
0
},
pieces,
bits_in_piece,
open_files: Default::default(),
buffer: Default::default(),
mapping: self.items,

@ -0,0 +1,13 @@
[package]
name = "torment-tracker"
version = "0.1.0"
authors = ["eater <=@eater.me>"]
edition = "2018"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
torment-core = { path = "../torment-core" }
torment-bencode = { path = "../torment-bencode" }
reqwest = { version = "0.10", features = ["blocking"] }
url = "2.1.1"

@ -0,0 +1,269 @@
use reqwest::blocking::Client;
use reqwest::{Method, Url};
use std::collections::HashMap;
use std::convert::TryInto;
use std::net::{IpAddr, SocketAddr};
use std::ops::Add;
use std::str::FromStr;
use std::time::{Duration, Instant};
use torment_bencode::BencodeValue;
use torment_core::infohash::v1::U160;
use torment_core::infohash::InfoHashCapable;
use torment_core::peer_storage::{PeerStorageHolder, PeerStorageSource};
use torment_core::CompactContact;
pub struct Tracker {
url: Url,
is_udp: bool,
// last_scrape: Option<Instant>,
last_announce: HashMap<U160, Instant>,
requested_interval: Duration,
failure: HashMap<U160, String>,
peer_storage: PeerStorageHolder,
// supports_scrape: bool,
}
pub enum TrackerAnnounceRequest {
HTTP(Url, U160),
UDP(Url, U160),
}
#[derive(Debug)]
pub struct TrackerAnnounceResponse {
info_hash: U160,
// url: Url,
interval: Option<Duration>,
source: PeerStorageSource,
result: Result<Vec<SocketAddr>, String>,
}
impl Tracker {
pub fn url(&self) -> &Url {
&self.url
}
pub fn new(url: Url, peer_storage: PeerStorageHolder) -> Tracker {
Tracker {
is_udp: url.scheme() == "udp",
url,
last_announce: HashMap::new(),
requested_interval: Duration::from_secs(30 * 60),
failure: HashMap::new(),
peer_storage,
}
}
pub fn needs_update(&self, info_hash: U160) -> bool {
self.last_announce
.get(&info_hash)
.map(|inst| inst.add(self.requested_interval) < Instant::now())
.unwrap_or(true)
}
pub fn process(&mut self, response: TrackerAnnounceResponse) {
match response.result {
Ok(peers) => {
self.peer_storage
.add_peers(response.info_hash, peers, response.source);
}
Err(err) => {
self.failure.insert(response.info_hash, err);
}
}
if let Some(interval) = response.interval {
self.requested_interval = interval;
} else {
self.requested_interval = Duration::from_secs(60 * 30);
}
}
pub fn create_update_request(
&mut self,
info_hash: U160,
peer_id: U160,
ip: IpAddr,
port: u16,
uploaded: usize,
downloaded: usize,
left: i64,
) -> TrackerAnnounceRequest {
if self.is_udp {
return TrackerAnnounceRequest::UDP(self.url.clone(), info_hash);
}
let mut url = self.url.clone();
info_hash.to_byte_array();
{
let mut query = url.query_pairs_mut();
query.append_pair("ip", &format!("{}", ip));
query.append_pair("port", &format!("{}", port));
query.append_pair("uploaded", &format!("{}", uploaded));
query.append_pair("downloaded", &format!("{}", downloaded));
query.append_pair("left", &format!("{}", left));
}
let encoded_info_hash = url::form_urlencoded::byte_serialize(&info_hash.to_bytes()).fold(
String::new(),
|mut coll, curr| {
coll.push_str(curr);
coll
},
);
let encoded_peer_id = url::form_urlencoded::byte_serialize(&peer_id.to_bytes()).fold(
String::new(),
|mut coll, curr| {
coll.push_str(curr);
coll
},
);
let query = url.query().unwrap_or("");
url.set_query(Some(&format!(
"{}&info_hash={}&peer_id={}",
query, encoded_info_hash, encoded_peer_id
)));
self.last_announce.insert(info_hash, Instant::now());
TrackerAnnounceRequest::HTTP(url, info_hash)
}
}
pub fn block_do_announce(
request: TrackerAnnounceRequest,
client: &Client,
) -> TrackerAnnounceResponse {
let (url, info_hash) = match request {
TrackerAnnounceRequest::HTTP(url, info_hash) => (url, info_hash),
TrackerAnnounceRequest::UDP(url, info_hash) => {
return TrackerAnnounceResponse {
info_hash,
interval: None,
source: PeerStorageSource::Tracker(url.clone()),
// url,
result: Err(format!("UDP trackers not supported")),
};
}
};
println!("Announcing {} on {}", info_hash, url);
let res = block_do_http_response_parse(url.clone(), client);
TrackerAnnounceResponse {
info_hash,
source: PeerStorageSource::Tracker(url.clone()),
// url,
interval: res.as_ref().map(|x| x.0).ok(),
result: res.map(|x| x.1),
}
}
pub fn block_do_http_response_parse(
url: Url,
http_client: &Client,
) -> Result<(Duration, Vec<SocketAddr>), String> {
let resp = match http_client.request(Method::GET, url).send() {
Ok(resp) => resp,
Err(err) => {
return Err(format!("{}", err));
}
};
let body = resp.bytes();
if let Err(err) = body {
return Err(format!("{}", err));
}
let body = body.unwrap();
let body = BencodeValue::decode(body);
if let Err(err) = body {
return Err(format!("Bencoding error: {}", err));
}
let body = body.unwrap();
let body = body.dict();
if body.is_none() {
return Err(format!("Tracker gave invalid response"));
}
let body = body.unwrap();
if let Some(failure) = body.get(b"failure reason") {
let failure = failure.string().and_then(|x| x.ok()).unwrap_or(format!(
"Tracker failed to respond with valid failure, but did respond with a failure"
));
return Err(failure);
}
let interval = body
.get(b"interval")
.and_then(|item| item.int())
.unwrap_or(30 * 60);
let interval = Duration::from_secs(interval as u64);
let peers = body.get(b"peers");
if peers.is_none() {
return Ok((interval, vec![]));
}
let peers = peers.unwrap();
let peers: Vec<SocketAddr> = match peers {
BencodeValue::List(old) => {
let mut buffer = vec![];
for item in old.iter() {
let dict = if let Some(dict) = item.dict() {
dict
} else {
continue;
};
let ip = if let Some(BencodeValue::Bytes(ip)) = dict.get(b"ip") {
ip.clone()
} else {
continue;
};
let ip = if let Some(ip) = IpAddr::from_str(&String::from_utf8_lossy(&ip)).ok() {
ip
} else {
continue;
};
let port: u16 = if let Some(BencodeValue::Int(nr)) = dict.get(b"port") {
if *nr < u16::MAX as i64 {
if let Ok(port) = (*nr).try_into() {
port
} else {
continue;
}
} else {
continue;
}
} else {
continue;
};
buffer.push(SocketAddr::new(ip, port));
}
buffer
}
BencodeValue::Bytes(compact) => compact
.chunks(6)
.filter_map(|x| SocketAddr::from_compact_contact(x).ok())
.collect(),
_ => {
return Err(format!("Tracker failed to respond with valid response"));
}
};
Ok((interval, peers))
}
Loading…
Cancel
Save