Bump version to 0.2.5

Fix Windows CI builds having incorrect feature configuration
Update dependencies
2025-07-25 17:21:59 -07:00 · 2021-11-25 15:04:39 +01:00 · 2021-11-25 15:04:21 +01:00 · 2021-11-25 14:54:05 +01:00 · 2021-11-25 14:41:43 +01:00 · 2021-11-25 14:36:50 +01:00
63 changed files with 4044 additions and 1273 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,4 @@

 # Test server
 /mcserver
+/bettermc
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -69,7 +69,7 @@ check-windows:
  script:
    - cargo check --locked --verbose
    - cargo check --locked --no-default-features --features rcon --verbose
-    - cargo check --locked --no-default-features --features lobby --verbose
+    - cargo check --locked --no-default-features --features rcon,lobby --verbose

 # Build using Rust stable on Linux
 build-x86_64-linux-gnu:
@@ -247,7 +247,7 @@ test-cargo-x86_64-windows:
  script:
    - cargo test --locked --verbose
    - cargo test --locked --no-default-features --features rcon --verbose
-    - cargo test --locked --no-default-features --features lobby --verbose
+    - cargo test --locked --no-default-features --features rcon,lobby --verbose

 # Release binaries on GitLab as generic package
 release-gitlab-generic-package:
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,42 @@
 # Changelog

+## 0.2.5 (2021-11-25)
+
+- Add support Minecraft 1.16.3 to 1.17.1 with lobby join method
+- Add support for Forge client/server to lobby join method (partial)
+- Probe server on start with fake user to fetch server settings improving compatibility
+- Improve lobby compatibility, send probed server data to client when possible
+- Skip lobby join method if server probe is not yet finished
+- Generate lobby dimension configuration on the fly based on server dimensions
+- Fix unsupported lobby dimension configuration values for some Minecraft versions
+- Demote IP ban list reload message from info to debug
+- Update dependencies
+
+## 0.2.4 (2021-11-24)
+
+- Fix status response issues with missing server icon, fall back to default icon
+- Fix incorrect UUID for players in lobby logic
+- Make server directory relative to configuration file path
+- Assume SIGTERM exit code for server process to be successful on Unix
+- Update features in README
+- Update dependencies
+
+## 0.2.3 (2021-11-22)
+
+- Add support for `PROXY` header to notify Minecraft server of real client IP
+- Only enable RCON by default on Windows
+- Update dependencies
+
+## 0.2.2 (2021-11-18)
+
+- Add server favicon to status response
+
+## 0.2.1 (2021-11-17)
+
+- Add support for using host names in config address fields
+- Handle banned players within `lazymc` based on server `banned-ips.json`
+- Update dependencies
+
 ## 0.2.0 (2021-11-15)

 - Add lockout feature, enable to kick all connecting clients with a message
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -19,9 +19,9 @@ dependencies = [

 [[package]]
 name = "anyhow"
-version = "1.0.45"
+version = "1.0.48"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee10e43ae4a853c0a3591d4e2ada1719e553be18199d9da9d4a83f5927c2f5c7"
+checksum = "62e1f47f7dc0422027a4e370dd4548d4d66b26782e513e98dca1e689e058a80e"

 [[package]]
 name = "async-channel"
@@ -80,7 +80,7 @@ dependencies = [
 "slab",
 "socket2",
 "waker-fn",
- "winapi",
+ "winapi 0.3.9",
 ]

 [[package]]
@@ -148,7 +148,7 @@ checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
 dependencies = [
 "hermit-abi",
 "libc",
- "winapi",
+ "winapi 0.3.9",
 ]

 [[package]]
@@ -163,12 +163,27 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"

+[[package]]
+name = "base64"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "904dfeac50f3cdaba28fc6f57fdcddb75f49ed61346676a78c4ffe55877802fd"
+
 [[package]]
 name = "bitflags"
 version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"

+[[package]]
+name = "block-buffer"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
+dependencies = [
+ "generic-array",
+]
+
 [[package]]
 name = "blocking"
 version = "1.1.0"
@@ -219,12 +234,31 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c"

+[[package]]
+name = "cfg-if"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
+
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

+[[package]]
+name = "chrono"
+version = "0.4.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "670ad68c9088c2a963aaa298cb369688cf3f9465ce5e2d4ca10e6e0098a1ce73"
+dependencies = [
+ "libc",
+ "num-integer",
+ "num-traits",
+ "time",
+ "winapi 0.3.9",
+]
+
 [[package]]
 name = "clap"
 version = "3.0.0-beta.5"
@@ -259,7 +293,7 @@ checksum = "b3616f750b84d8f0de8a58bda93e08e2a81ad3f523089b05f1dffecab48c6cbd"
 dependencies = [
 "atty",
 "lazy_static",
- "winapi",
+ "winapi 0.3.9",
 ]

 [[package]]
@@ -273,11 +307,11 @@ dependencies = [

 [[package]]
 name = "crc32fast"
-version = "1.2.1"
+version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81156fece84ab6a9f2afdb109ce3ae577e42b1228441eded99bd77f627953b1a"
+checksum = "3825b1e8580894917dc4468cb634a1b4e9745fddc854edad72d9c04644c0319f"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
 ]

 [[package]]
@@ -286,7 +320,7 @@ version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d82cfc11ce7f2c3faef78d8a684447b40d503d9681acebed6cb728d45940c4db"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
 "lazy_static",
 ]

@@ -366,6 +400,21 @@ dependencies = [
 "syn",
 ]

+[[package]]
+name = "digest"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "doc-comment"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"
+
 [[package]]
 name = "dotenv"
 version = "0.15.0"
@@ -414,13 +463,25 @@ dependencies = [
 "instant",
 ]

+[[package]]
+name = "filetime"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "975ccf83d8d9d0d84682850a38c8169027be83368805971cc4f238c2b245bc98"
+dependencies = [
+ "cfg-if 1.0.0",
+ "libc",
+ "redox_syscall",
+ "winapi 0.3.9",
+]
+
 [[package]]
 name = "flate2"
 version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e6988e897c1c9c485f43b47a529cef42fde0547f9d8d41a7062518f1d8fc53f"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
 "crc32fast",
 "libc",
 "miniz_oxide",
@@ -432,6 +493,25 @@ version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"

+[[package]]
+name = "fsevent"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ab7d1bd1bd33cc98b0889831b72da23c0aa4df9cec7e0702f46ecea04b35db6"
+dependencies = [
+ "bitflags",
+ "fsevent-sys",
+]
+
+[[package]]
+name = "fsevent-sys"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f41b048a94555da0f42f1d632e2e19510084fb8e303b0daa2816e733fb3644a0"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "fuchsia-cprng"
 version = "0.1.1"
@@ -439,13 +519,30 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"

 [[package]]
-name = "futures"
-version = "0.3.17"
+name = "fuchsia-zircon"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a12aa0eb539080d55c3f2d45a67c3b58b6b0773c1a3ca2dfec66d58c97fd66ca"
+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.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8cd0210d8c325c245ff06fd95a3b13689a1a276ac8cfa8e8720cb840bfb84b9e"
 dependencies = [
 "futures-channel",
 "futures-core",
+ "futures-executor",
 "futures-io",
 "futures-sink",
 "futures-task",
@@ -454,9 +551,9 @@ dependencies = [

 [[package]]
 name = "futures-channel"
-version = "0.3.17"
+version = "0.3.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5da6ba8c3bb3c165d3c7319fc1cc8304facf1fb8db99c5de877183c08a273888"
+checksum = "7fc8cd39e3dbf865f7340dce6a2d401d24fd37c6fe6c4f0ee0de8bfca2252d27"
 dependencies = [
 "futures-core",
 "futures-sink",
@@ -464,15 +561,26 @@ dependencies = [

 [[package]]
 name = "futures-core"
-version = "0.3.17"
+version = "0.3.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88d1c26957f23603395cd326b0ffe64124b818f4449552f960d815cfba83a53d"
+checksum = "629316e42fe7c2a0b9a65b47d159ceaa5453ab14e8f0a3c5eedbb8cd55b4a445"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b808bf53348a36cab739d7e04755909b9fcaaa69b7d7e588b37b6ec62704c97"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]

 [[package]]
 name = "futures-io"
-version = "0.3.17"
+version = "0.3.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "522de2a0fe3e380f1bc577ba0474108faf3f6b18321dbf60b3b9c39a75073377"
+checksum = "e481354db6b5c353246ccf6a728b0c5511d752c08da7260546fc0933869daa11"

 [[package]]
 name = "futures-lite"
@@ -491,28 +599,41 @@ dependencies = [

 [[package]]
 name = "futures-sink"
-version = "0.3.17"
+version = "0.3.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36ea153c13024fe480590b3e3d4cad89a0cfacecc24577b68f86c6ced9c2bc11"
+checksum = "996c6442437b62d21a32cd9906f9c41e7dc1e19a9579843fad948696769305af"

 [[package]]
 name = "futures-task"
-version = "0.3.17"
+version = "0.3.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d3d00f4eddb73e498a54394f228cd55853bdf059259e8e7bc6e69d408892e99"
+checksum = "dabf1872aaab32c886832f2276d2f5399887e2bd613698a02359e4ea83f8de12"

 [[package]]
 name = "futures-util"
-version = "0.3.17"
+version = "0.3.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36568465210a3a6ee45e1f165136d68671471a501e632e9a98d96872222b5481"
+checksum = "41d22213122356472061ac0f1ab2cee28d2bac8491410fd68c2af53d1cedb83e"
 dependencies = [
- "autocfg 1.0.1",
+ "futures-channel",
 "futures-core",
+ "futures-io",
 "futures-sink",
 "futures-task",
+ "memchr",
 "pin-project-lite",
 "pin-utils",
+ "slab",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "501466ecc8a30d1d3b7fc9229b122b2ce8ed6e9d9223f1138d4babb253e51817"
+dependencies = [
+ "typenum",
+ "version_check",
 ]

 [[package]]
@@ -521,7 +642,7 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
 "libc",
 "wasi",
 ]
@@ -579,13 +700,42 @@ dependencies = [
 "hashbrown",
 ]

+[[package]]
+name = "inotify"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4816c66d2c8ae673df83366c18341538f234a26d65a9ecea5c348b453ac1d02f"
+dependencies = [
+ "bitflags",
+ "inotify-sys",
+ "libc",
+]
+
+[[package]]
+name = "inotify-sys"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e05c02b5e89bff3b946cedeca278abc628fe811e604f027c45a8aa3cf793d0eb"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "instant"
 version = "0.1.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
+]
+
+[[package]]
+name = "iovec"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2b3ea6ff95e175473f8ffe6a7eb7c00d054240321b84c57051175fe3c1e075e"
+dependencies = [
+ "libc",
 ]

 [[package]]
@@ -603,6 +753,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"
@@ -618,12 +778,21 @@ version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"

+[[package]]
+name = "lazycell"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
+
 [[package]]
 name = "lazymc"
-version = "0.2.0"
+version = "0.2.5"
 dependencies = [
 "anyhow",
+ "async-std",
+ "base64",
 "bytes",
+ "chrono",
 "clap",
 "colored",
 "derive_builder",
@@ -632,27 +801,31 @@ dependencies = [
 "futures",
 "libc",
 "log",
+ "md-5",
 "minecraft-protocol",
 "named-binary-tag",
+ "notify",
 "pretty_env_logger",
+ "proxy-protocol",
 "quartz_nbt",
 "rand 0.8.4",
 "rcon",
 "serde",
+ "serde_json",
 "shlex",
 "thiserror",
 "tokio",
 "toml",
 "uuid",
 "version-compare",
- "winapi",
+ "winapi 0.3.9",
 ]

 [[package]]
 name = "libc"
-version = "0.2.107"
+version = "0.2.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbe5e23404da5b4f555ef85ebed98fb4083e55a00c317800bc2a50ede9f3d219"
+checksum = "8521a1b57e76b1ec69af7599e75e38e7b7fad6610f037db8c79b127201b5d119"

 [[package]]
 name = "linked-hash-map"
@@ -666,10 +839,21 @@ version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
 "value-bag",
 ]

+[[package]]
+name = "md-5"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b5a279bb9607f9f53c22d496eade00d138d1bdcccd07d74650387cf94942a15"
+dependencies = [
+ "block-buffer",
+ "digest",
+ "opaque-debug",
+]
+
 [[package]]
 name = "md5"
 version = "0.6.1"
@@ -685,7 +869,7 @@ checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
 [[package]]
 name = "minecraft-protocol"
 version = "0.1.0"
-source = "git+https://github.com/timvisee/rust-minecraft-protocol?rev=d26a525#d26a525c7b29b61d2db64805181fb5471ea4317a"
+source = "git+https://github.com/timvisee/rust-minecraft-protocol?rev=edfdf87#edfdf876c0c21be02afdd885e3400983f3137ec9"
 dependencies = [
 "byteorder",
 "minecraft-protocol-derive",
@@ -698,7 +882,7 @@ dependencies = [
 [[package]]
 name = "minecraft-protocol-derive"
 version = "0.0.0"
-source = "git+https://github.com/timvisee/rust-minecraft-protocol?rev=d26a525#d26a525c7b29b61d2db64805181fb5471ea4317a"
+source = "git+https://github.com/timvisee/rust-minecraft-protocol?rev=edfdf87#edfdf876c0c21be02afdd885e3400983f3137ec9"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -715,6 +899,25 @@ dependencies = [
 "autocfg 1.0.1",
 ]

+[[package]]
+name = "mio"
+version = "0.6.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4afd66f5b91bf2a3bc13fad0e21caedac168ca4c707504e75585648ae80e4cc4"
+dependencies = [
+ "cfg-if 0.1.10",
+ "fuchsia-zircon",
+ "fuchsia-zircon-sys",
+ "iovec",
+ "kernel32-sys",
+ "libc",
+ "log",
+ "miow 0.2.2",
+ "net2",
+ "slab",
+ "winapi 0.2.8",
+]
+
 [[package]]
 name = "mio"
 version = "0.7.14"
@@ -723,9 +926,33 @@ checksum = "8067b404fe97c70829f082dec8bcf4f71225d7eaea1d8645349cb76fa06205cc"
 dependencies = [
 "libc",
 "log",
- "miow",
+ "miow 0.3.7",
 "ntapi",
- "winapi",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "mio-extras"
+version = "2.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52403fe290012ce777c4626790c8951324a2b9e3316b3143779c72b029742f19"
+dependencies = [
+ "lazycell",
+ "log",
+ "mio 0.6.23",
+ "slab",
+]
+
+[[package]]
+name = "miow"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebd808424166322d4a38da87083bfddd3ac4c131334ed55856112eb06d46944d"
+dependencies = [
+ "kernel32-sys",
+ "net2",
+ "winapi 0.2.8",
+ "ws2_32-sys",
 ]

 [[package]]
@@ -734,7 +961,7 @@ version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21"
 dependencies = [
- "winapi",
+ "winapi 0.3.9",
 ]

 [[package]]
@@ -748,13 +975,61 @@ dependencies = [
 "linked-hash-map",
 ]

+[[package]]
+name = "net2"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "391630d12b68002ae1e25e8f974306474966550ad82dac6886fb8910c19568ae"
+dependencies = [
+ "cfg-if 0.1.10",
+ "libc",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "notify"
+version = "4.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae03c8c853dba7bfd23e571ff0cff7bc9dceb40a4cd684cd1681824183f45257"
+dependencies = [
+ "bitflags",
+ "filetime",
+ "fsevent",
+ "fsevent-sys",
+ "inotify",
+ "libc",
+ "mio 0.6.23",
+ "mio-extras",
+ "walkdir",
+ "winapi 0.3.9",
+]
+
 [[package]]
 name = "ntapi"
 version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f6bb902e437b6d86e03cce10a7e2af662292c5dfef23b65899ea3ac9354ad44"
 dependencies = [
- "winapi",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db"
+dependencies = [
+ "autocfg 1.0.1",
+ "num-traits",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290"
+dependencies = [
+ "autocfg 1.0.1",
 ]

 [[package]]
@@ -773,6 +1048,12 @@ version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "692fcb63b64b1758029e0a96ee63e049ce8c5948587f2f7208df04625e5f6b56"

+[[package]]
+name = "opaque-debug"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
+
 [[package]]
 name = "os_str_bytes"
 version = "4.2.0"
@@ -806,11 +1087,11 @@ version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "685404d509889fade3e86fe3a5803bca2ec09b0c0778d5ada6ec8bf7a8de5259"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
 "libc",
 "log",
 "wepoll-ffi",
- "winapi",
+ "winapi 0.3.9",
 ]

 [[package]]
@@ -862,6 +1143,16 @@ dependencies = [
 "unicode-xid",
 ]

+[[package]]
+name = "proxy-protocol"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e50c72c21c738f5c5f350cc33640aee30bf7cd20f9d9da20ed41bce2671d532"
+dependencies = [
+ "bytes",
+ "snafu",
+]
+
 [[package]]
 name = "quartz_nbt"
 version = "0.2.4"
@@ -917,7 +1208,7 @@ dependencies = [
 "rand_os",
 "rand_pcg",
 "rand_xorshift",
- "winapi",
+ "winapi 0.3.9",
 ]

 [[package]]
@@ -1011,7 +1302,7 @@ checksum = "1166d5c91dc97b88d1decc3285bb0a99ed84b05cfd0bc2341bdf2d43fc41e39b"
 dependencies = [
 "libc",
 "rand_core 0.4.2",
- "winapi",
+ "winapi 0.3.9",
 ]

 [[package]]
@@ -1025,7 +1316,7 @@ dependencies = [
 "libc",
 "rand_core 0.4.2",
 "rdrand",
- "winapi",
+ "winapi 0.3.9",
 ]

 [[package]]
@@ -1049,9 +1340,9 @@ dependencies = [

 [[package]]
 name = "rcon"
-version = "0.5.1"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "465a6f903164a399084787547a026b83e7937bc576d8acdbd9e41ebf5de90a85"
+checksum = "6b7fdd146f86bd90fa2d4cf83a28b45f058e90bcf11ed0cce134e757928771e6"
 dependencies = [
 "async-std",
 "bytes",
@@ -1067,6 +1358,15 @@ dependencies = [
 "rand_core 0.3.1",
 ]

+[[package]]
+name = "redox_syscall"
+version = "0.2.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8383f39639269cde97d255a32bdb68c047337295414940c68bdd30c2e13203ff"
+dependencies = [
+ "bitflags",
+]
+
 [[package]]
 name = "regex"
 version = "1.5.4"
@@ -1096,6 +1396,15 @@ version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"

+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
 [[package]]
 name = "serde"
 version = "1.0.130"
@@ -1118,9 +1427,9 @@ dependencies = [

 [[package]]
 name = "serde_json"
-version = "1.0.70"
+version = "1.0.72"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e277c495ac6cd1a01a58d0a0c574568b4d1ddf14f59965c6a58b8d96400b54f3"
+checksum = "d0ffa0837f2dfa6fb90868c2b5468cad482e175f7dad97e7421951e663f2b527"
 dependencies = [
 "itoa",
 "ryu",
@@ -1148,6 +1457,27 @@ version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9def91fd1e018fe007022791f865d0ccc9b3a0d5001e01aabb8b40e46000afb5"

+[[package]]
+name = "snafu"
+version = "0.6.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eab12d3c261b2308b0d80c26fffb58d17eba81a4be97890101f416b478c79ca7"
+dependencies = [
+ "doc-comment",
+ "snafu-derive",
+]
+
+[[package]]
+name = "snafu-derive"
+version = "0.6.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1508efa03c362e23817f96cde18abed596a25219a8b2c66e8db33c03543d315b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "socket2"
 version = "0.4.2"
@@ -1155,7 +1485,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5dc90fe6c7be1a323296982db1836d1ea9e47b6839496dde9a541bc496df3516"
 dependencies = [
 "libc",
- "winapi",
+ "winapi 0.3.9",
 ]

 [[package]]
@@ -1166,9 +1496,9 @@ checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"

 [[package]]
 name = "syn"
-version = "1.0.81"
+version = "1.0.82"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2afee18b8beb5a596ecb4a2dce128c719b4ba399d34126b9e4396e3f9860966"
+checksum = "8daf5dd0bb60cbd4137b1b587d2fc0ae729bc07cf01cd70b36a1ed5ade3b9d59"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1226,29 +1556,39 @@ dependencies = [
 ]

 [[package]]
-name = "tokio"
-version = "1.13.0"
+name = "time"
+version = "0.1.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "588b2d10a336da58d877567cd8fb8a14b463e2104910f8132cd054b4b96e29ee"
+checksum = "ca8a50ef2360fbd1eeb0ecd46795a87a19024eb4b53c5dc916ca1fd95fe62438"
+dependencies = [
+ "libc",
+ "winapi 0.3.9",
+]
+
+[[package]]
+name = "tokio"
+version = "1.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70e992e41e0d2fb9f755b37446f20900f64446ef54874f40a60c78f021ac6144"
 dependencies = [
 "autocfg 1.0.1",
 "bytes",
 "libc",
 "memchr",
- "mio",
+ "mio 0.7.14",
 "num_cpus",
 "once_cell",
 "pin-project-lite",
 "signal-hook-registry",
 "tokio-macros",
- "winapi",
+ "winapi 0.3.9",
 ]

 [[package]]
 name = "tokio-macros"
-version = "1.5.1"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "114383b041aa6212c579467afa0075fbbdd0718de036100bc0ba7961d8cb9095"
+checksum = "c9efc1aba077437943f7515666aa2b882dfabfbfdf89c819ea75a8d6e9eaba5e"
 dependencies = [
 "proc-macro2",
 "quote",
@@ -1264,6 +1604,12 @@ dependencies = [
 "serde",
 ]

+[[package]]
+name = "typenum"
+version = "1.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b63708a265f51345575b27fe43f9500ad611579e764c79edbc2037b1121959ec"
+
 [[package]]
 name = "unicase"
 version = "2.6.0"
@@ -1324,6 +1670,17 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9d5b2c62b4012a3e1eca5a7e077d13b3bf498c4073e33ccd58626607748ceeca"

+[[package]]
+name = "walkdir"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56"
+dependencies = [
+ "same-file",
+ "winapi 0.3.9",
+ "winapi-util",
+]
+
 [[package]]
 name = "wasi"
 version = "0.10.2+wasi-snapshot-preview1"
@@ -1336,7 +1693,7 @@ version = "0.2.78"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "632f73e236b219150ea279196e54e610f5dbafa5d61786303d4da54f84e47fce"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
 "wasm-bindgen-macro",
 ]

@@ -1361,7 +1718,7 @@ version = "0.4.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e8d7523cb1f2a4c96c1317ca690031b714a51cc14e05f712446691f413f5d39"
 dependencies = [
- "cfg-if",
+ "cfg-if 1.0.0",
 "js-sys",
 "wasm-bindgen",
 "web-sys",
@@ -1415,6 +1772,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"
@@ -1425,6 +1788,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"
@@ -1437,7 +1806,7 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
 dependencies = [
- "winapi",
+ "winapi 0.3.9",
 ]

 [[package]]
@@ -1445,3 +1814,13 @@ name = "winapi-x86_64-pc-windows-gnu"
 version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[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",
+]
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "lazymc"
-version = "0.2.0"
+version = "0.2.5"
 authors = ["Tim Visee <3a4fb3964f@sinenomine.email>"]
 license = "GPL-3.0"
 readme = "README.md"
@@ -24,38 +24,45 @@ default = ["rcon", "lobby"]
 # RCON support
 # Allow use of RCON to manage (stop) server.
 # Required on Windows.
-rcon = ["rust_rcon"]
+rcon = ["rust_rcon", "async-std"]

 # Lobby support
 # Add lobby join method, keeps client in fake lobby world until server is ready.
-lobby = ["named-binary-tag", "quartz_nbt", "uuid"]
+lobby = ["md-5", "uuid"]

 [dependencies]
 anyhow = "1.0"
+base64 = "0.13"
 bytes = "1.1"
+chrono = "0.4"
 clap = { version = "3.0.0-beta.5", default-features = false, features = [ "std", "cargo", "color", "env", "suggestions", "unicode" ]}
 colored = "2.0"
 derive_builder = "0.10"
 dotenv = "0.15"
 flate2 = { version = "1.0", default-features = false, features = ["default"] }
-futures = { version = "0.3", default-features = false }
+futures = { version = "0.3", default-features = false, features = ["executor"] }
 log = "0.4"
-minecraft-protocol = { git = "https://github.com/timvisee/rust-minecraft-protocol", rev = "d26a525" }
+minecraft-protocol = { git = "https://github.com/timvisee/rust-minecraft-protocol", rev = "edfdf87" }
+named-binary-tag = "0.6"
+notify = "4.0"
 pretty_env_logger = "0.4"
+proxy-protocol = "0.5"
+quartz_nbt = "0.2"
 rand = "0.8"
 serde = "1.0"
+serde_json = "1.0"
 shlex = "1.1"
 thiserror = "1.0"
-tokio = { version = "1", default-features = false, features = ["rt-multi-thread", "io-util", "net", "macros", "time", "process", "signal", "sync"] }
+tokio = { version = "1", default-features = false, features = ["rt-multi-thread", "io-util", "net", "macros", "time", "process", "signal", "sync", "fs"] }
 toml = "0.5"
 version-compare = "0.1"

 # Feature: rcon
-rust_rcon = { package = "rcon", version = "0.5", optional = true }
+rust_rcon = { package = "rcon", version = "0.5.2", optional = true }
+async-std = { version = "1.9.0", default-features = false, optional = true }

 # Feature: lobby
-named-binary-tag = { version = "0.6", optional = true }
-quartz_nbt = { version = "0.2", optional = true }
+md-5 = { version = "0.9", optional = true }
 uuid = { version = "0.7", optional = true, features = ["v3"] }

 [target.'cfg(unix)'.dependencies]
--- a/README.md
+++ b/README.md
@@ -35,7 +35,7 @@ https://user-images.githubusercontent.com/856222/141378688-882082be-9efa-4cfe-81
 ## Features

 - Very efficient, lightweight & low-profile (~3KB RAM)
- Supports Minecraft Java Edition 1.6+, supports modded (e.g. Forge, FTB)
+- Supports Minecraft Java Edition 1.7.2+, supports modded (e.g. Forge, FTB)
 - Configure joining client occupation methods:
  - Hold: hold clients when server starts, relay when ready, without them noticing
  - Kick: kick clients when server starts, with a starting message
@@ -43,7 +43,9 @@ https://user-images.githubusercontent.com/856222/141378688-882082be-9efa-4cfe-81
  - _Lobby: keep client in emulated server with lobby world, teleport to real server when ready ([experimental*](./docs/join-method-lobby.md))_
 - Customizable MOTD and login messages
 - Automatically manages `server.properties` (host, port and RCON settings)
- Graceful server sleep/shutdown through RCON (with `SIGTERM` fallback on Linux/Unix)
+- Automatically block banned IPs from server within lazymc
+- Graceful server sleep/shutdown through RCON or `SIGTERM`
+- Real client IP on Minecraft server with `PROXY` header ([usage](./docs/proxy-ip.md))
 - Restart server on crash
 - Lockout mode

@@ -75,8 +77,8 @@ chmod a+x ./lazymc
 ./lazymc --help
 ```

-When `lazymc` is set-up, change into your server directory if you haven't
-already. Then set up the [configuration](./res/lazymc.toml) and start it up:
+When lazymc is set-up, change into your server directory if you haven't already.
+Then set up the [configuration](./res/lazymc.toml) and start it up:

 ```bash
 # Change into your server directory (if you haven't already)
@@ -93,20 +95,14 @@ nano lazymc.toml
 lazymc start
 ```

-Before you use this in production, please ensure starting and stopping the
-server works as expected by connecting to it once. Watch `lazymc`s output while
-it starts and stops. If stopping results in errors, fix this first to prevent
-corrupting world/user data.
+Please see [extras](./docs/extras.md) for recommendations and additional things
+to set up (e.g. how to fix incorrect client IPs and IP banning on your server).

-Follow this repository with the _Watch_ button on the top right to be notified of new releases.
-
-Everything should now be ready to go! Connect with your Minecraft client to wake
-your server up!
+After you've read through the [extras](./docs/extras.md), everything should now
+be ready to go! Connect with your Minecraft client to wake your server up!

 _Note: If a binary for your system isn't provided, please [compile from
-source](#compile-from-source)._
-
-_Note: Installation options are limited at this moment. More will be added
+source](#compile-from-source). Installation options are limited at this moment. More will be added
 later._

 [latest-release]: https://github.com/timvisee/lazymc/releases/latest
@@ -144,7 +140,7 @@ cargo build --release

 ## Third-party usage & implementations

-A list of third-party implementations, projects using `lazymc`, that you might
+A list of third-party implementations, projects using lazymc, that you might
 find useful:

 - Docker: [crbanman/papermc-lazymc](https://hub.docker.com/r/crbanman/papermc-lazymc) _(PaperMC with lazymc in Docker)_
--- a/TODO.md
+++ b/TODO.md
@@ -9,9 +9,8 @@

 - Use server whitelist/blacklist
 - Console error if server already started on port, not through `lazymc`
- Kick with message if proxy-to-server connection fails for new client. 
+- Kick with message if proxy-to-server connection fails for new client.
 - Test configuration on start (server dir exists, command not empty)
- Also quit `lazymc` after CTRL+C signal, after server has stopped
 - Dynamically increase/decrease server polling interval based on server state
 - Server polling through query (`enable-query` in `server.properties`, uses GameSpy4 protocol)

--- a/build.rs
+++ b/build.rs
@@ -1,7 +0,0 @@
-fn main() {
-    // Must enable rcon on Windows
-    #[cfg(all(windows, not(feature = "rcon")))]
-    {
-        println!("cargo:warning=lazymc: you must enable rcon feature on Windows");
-    }
-}
--- a/docs/command-bash.md
+++ b/docs/command-bash.md
@@ -0,0 +1,41 @@
+# Use bash script to start server
+
+You may use a `bash` script to start your server rather than invoking `java`
+directly. This requires some changes though to ensure your server properly shuts
+down.
+
+When lazymc stops your server it sends a [`SIGTERM`][sigterm] signal to the
+invoked server process to gracefully shut it down. `bash` ignores this signal by
+default and keeps the Minecraft server running.
+
+You must configure `bash` to [forward][forward-signal] the signal to properly
+shutdown the Minecraft server as well.
+
+[sigterm]: https://en.wikipedia.org/wiki/Signal_(IPC)#SIGTERM
+[forward-signal]: https://unix.stackexchange.com/a/434269/61092
+
+## Example
+
+Here's a minimal example, trapping the signal and forwarding it to the server.
+Be sure to set the correct server JAR file and appropriate memory limits.
+
+[`start-server`](../res/start-server):
+
+```bash
+#!/bin/bash
+
+# Server JAR file, set this to your own
+FILE=server.jar
+
+# Trap SIGTERM, forward it to server process ID
+trap 'kill -TERM $PID' TERM INT
+
+# Start server
+java -Xms1G -Xmx1G -jar $FILE --nogui &
+
+# Remember server process ID, wait for it to quit, then reset the trap
+PID=$!
+wait $PID
+trap - TERM INT
+wait $PID
+```
--- a/docs/command_bash.md
+++ b/docs/command_bash.md
@@ -1,41 +0,0 @@
-# Use bash script to start server
-
-You may use a `bash` script to start your server rather than invoking `java`
-directly. This requires some changes though to ensure your server properly shuts
-down.
-
-When `lazymc` stops your server it sends a [`SIGTERM`][sigterm] signal to the
-invoked server process to gracefully shut it down. `bash` ignores this signal by
-default and keeps the Minecraft server running.
-
-You must configure `bash` to [forward][forward-signal] the signal to properly
-shutdown the Minecraft server as well.
-
-[sigterm]: https://en.wikipedia.org/wiki/Signal_(IPC)#SIGTERM
-[forward-signal]: https://unix.stackexchange.com/a/434269/61092
-
-## Example
-
-Here's a minimal example, trapping the signal and forwarding it to the server.
-Be sure to set the correct server JAR file and appropriate memory limits.
-
-[`start-server`](../res/start-server):
-
-```bash
-#!/bin/bash
-
-# Server JAR file, set this to your own
-FILE=server.jar
-
-# Trap SIGTERM, forward it to server process ID
-trap 'kill -TERM $PID' TERM INT
-
-# Start server
-java -Xms1G -Xmx1G -jar $FILE --nogui &
-
-# Remember server process ID, wait for it to quit, then reset the trap
-PID=$!
-wait $PID
-trap - TERM INT
-wait $PID
-```
--- a/docs/command_bash.md
+++ b/docs/command_bash.md
@@ -0,0 +1 @@
+command-bash.md
--- a/docs/extras.md
+++ b/docs/extras.md
@@ -0,0 +1,28 @@
+# Extras
+
+Some extra steps and recommendations when using lazymc:
+
+Before you use this in production, always ensure starting and stopping the
+server works as expected by connecting to it once. Watch lazymc's output while
+it starts and stops. If stopping results in errors, fix this first to prevent
+corrupting world/user data.
+
+Follow this repository with the _Watch_ button on the top right to be notified
+of new releases.
+
+## Recommended
+
+- [Protocol version](./protocol-version.md):
+  _set correct Minecraft protocol version for the best client compatability_
+- [Proxy IP](./proxy-ip.md):
+  _fix incorrect client IPs on Minecraft server, notify server of correct IP with `PROXY` header_
+
+## Tips
+
+- [bash with start command](./command_bash.md):
+  _how to properly use a bash script as server start command_
+
+## Experimental features
+
+- [Join method: lobby](./join-method-lobby.md):
+  _keep clients in fake lobby world while server starts, teleport to real server when ready_
--- a/docs/join-method-lobby.md
+++ b/docs/join-method-lobby.md
@@ -7,7 +7,7 @@ The lobby join method allows you to keep clients in a lobby world while the
 server is starting. When the server is ready, the player is _teleported_ to the
 real server.

-`lazymc` emulates a fake server with an empty lobby world. The player is put in
+lazymc emulates a fake server with an empty lobby world. The player is put in
 this world, floating in space. A custom message is shown on the client to notify
 we're waiting on the server to start.

@@ -21,9 +21,11 @@ enable this in a production environment.

 Current limitations:

- Only works with offline mode
- Only works with vanilla Minecraft clients, does not work with modded (e.g. Forge, FTB)
- Probably only works with Minecraft 1.16-1.17.1 (tested with 1.17.1)
+- Server must be in offline mode (`online-mode=false`)
+- Server must use Minecraft version 1.16.3 to 1.17.1 (tested with 1.17.1)
+- Server must use vanilla Minecraft
+  - May work with Forge (set `server.forge = true`), depends on used mods, test before use
+  - Does not work with other mods, such as FTB
 - This method will consume the client, following configured join methods won't be used.

 At this time it is unknown if some of the above limitations will ever be lifted,
@@ -85,3 +87,25 @@ ready_sound = "block.note_block.chime"

 _Note: this might have changed, see the latest configuration
 [here](../res/lazymc.toml)._
+
+## Probe issue with whitelist
+
+lazymc may report a _probe_ error on first start when a whitelist is enabled
+on your server.
+
+lazymc uses a probe to fetch some required details from your Minecraft
+server, such as a mod list. When probing, the server is started once when lazymc
+starts. It then connects to the Minecraft server with the _probe_ user
+(username: `_lazymc_probe`) and disconnects when everything needed is fetched.
+
+If you use a whitelist on your server it will cause issues if the probe user
+isn't whitelisted. Simply whitelist the probe user with the following command
+and restart lazymc to fix the issue:
+
+```
+/whitelist add _lazymc_probe
+```
+
+Probing isn't enabled by default. You may enable this by setting
+`server.probe_on_start = true`. Other configuration settings might
+automatically enable proving if required for your setup.
--- a/docs/protocol-version.md
+++ b/docs/protocol-version.md
@@ -0,0 +1,39 @@
+# Protocol version
+
+The Minecraft protocol uses a version number to distinguish between different
+protocol versions. Each new Minecraft version having a change in its protocol
+gets a new protocol version.
+
+## List of versions
+
+- https://wiki.vg/Protocol_version_numbers#Versions_after_the_Netty_rewrite
+
+## Configuration
+
+In lazymc you may configure what protocol version to use:
+
+[`lazymc.toml`](../res/lazymc.toml):
+
+```bash
+# -- snip --
+
+[public]
+# Server version & protocol hint.
+# Sent to clients until actual server version is known.
+# See: https://git.io/J1Fvx
+version = "1.17.1"
+protocol = 756
+
+# -- snip --
+```
+
+It is highly recommended to set these to match that of your server version to
+allow the best compatibility with clients.
+
+- Set `public.protocol` to the number matching that of your server version
+  (see [this](#list-of-versions) list)
+- Set `public.version` to any string you like. Shows up in read in clients that
+  have an incompatibel protocol version number
+
+These are used as hint. lazymc will automatically use the protocol version of
+your Minecraft server once it has started at least once.
--- a/docs/proxy-ip.md
+++ b/docs/proxy-ip.md
@@ -0,0 +1,79 @@
+# Proxy IP
+
+lazymc acts as a proxy most of the time. Because of this the Minecraft server
+will think all clients connect from the same IP, being the IP lazymc proxies
+from.
+
+This breaks IP banning (`/ban-ip`, amongst other IP related things). This may be
+a problematic issue for your server.
+
+Luckily, this can be fixed with the [proxy header](#proxy-header). lazymc has
+support for this, and can be used with a companion plugin on your server.
+
+## Proxy header
+
+The `PROXY` header may be used to notify the Minecraft server of the real client
+IP.
+
+When a new connection is opened to the Minecraft server, the Minecraft server
+will read the `PROXY` header with client-IP information. Once read, it will set
+the correct client IP internally and will resume communicating with the client
+normally.
+
+To enable this with lazymc you must do two things:
+- [Modify the lazymc configuration](#configuration)
+- [Install a companion plugin](#server-plugin)
+
+## Configuration
+
+To use the `PROXY` header with your Minecraft server, set `server.send_proxy_v2`
+to `true`.
+
+[`lazymc.toml`](../res/lazymc.toml):
+
+```toml
+# -- snip --
+
+[server]
+send_proxy_v2 = true
+
+# -- snip --
+```
+
+Other related properties, you probably won't need to touch, include:
+
+- `server.send_proxy_v2`: set to `true` to enable `PROXY` header for Minecraft server
+- `join.forward.send_proxy_v2`: set to `true` to enable `PROXY` header forwarded server, if `forward` join method is used
+- `rcon.send_proxy_v2`: set to `true` to enable `PROXY` header for RCON connections for Minecraft server
+
+## Server plugin
+
+Install one of these plugins as companion on your server to enable support for
+the `PROXY` header. This requires Minecraft server software supporting plugins,
+the vanilla Minecraft server does not support this.
+
+If lazymc connects to a Spigot compatible server, use any of:
+
+- https://github.com/riku6460/SpigotProxy ([JAR](https://github.com/riku6460/SpigotProxy/releases/latest))
+- https://github.com/timvisee/spigot-proxy
+
+If lazymc connects to a BungeeCord server, use any of:
+
+- https://github.com/MinelinkNetwork/BungeeProxy
+
+## Warning: connection failures
+
+Use of the `PROXY` header must be enabled or disabled on both lazymc and your
+Minecraft server using a companion plugin.
+
+If either of the two is missing or misconfigured, it will result in connection
+failures due to a missing or unrecognized header.
+
+## Warning: fake IP
+
+When enabling the `PROXY` header on your Minecraft server, malicious parties may
+send this header to fake their real IP.
+
+To solve this, make sure the Minecraft server is only publicly reachable through
+lazymc. This can be done by setting the Minecraft server IP to a local address
+only, or by setting up firewall rules.
--- a/docs/usage-windows.md
+++ b/docs/usage-windows.md
@@ -14,8 +14,8 @@ Open a terminal, go to the server directory, and make sure you can execute it:
 .\lazymc --help
 ```

-When `lazymc` is ready, set up the [configuration](./res/lazymc.toml) and start
-it up:
+When lazymc is ready, set up the [configuration](./res/lazymc.toml) and start it
+up:

 ```bash
 # In your Minecraft server directory:
@@ -31,18 +31,14 @@ notepad lazymc.toml
 .\lazymc start
 ```

-Before you use this in production, please ensure starting and stopping the
-server works as expected by connecting to it once. Watch `lazymc`s output while
-it starts and stops. If stopping results in errors, fix this first to prevent
-corrupting world/user data.
+Please see [extras](./extras.md) for recommendations and additional things
+to set up (e.g. how to fix incorrect client IPs and IP banning on your server).

-Follow this repository with the _Watch_ button on the top right to be notified of new releases.
-
-Everything should now be ready to go! Connect with your Minecraft client to wake
-your server up!
+After you've read through the [extras](./extras.md), everything should now
+be ready to go! Connect with your Minecraft client to wake your server up!

 _Note: if you put `lazymc` in `PATH`, or if you
 [install](../README.md#compile-from-source) it through Cargo, you can invoke
-`lazymc` everywhere directly without the `.\` prefix.
+`lazymc` everywhere directly without the `.\` prefix._

 [latest-release]: https://github.com/timvisee/lazymc/releases/latest
--- a/res/lazymc.toml
+++ b/res/lazymc.toml
@@ -8,7 +8,7 @@
 # You can probably leave the rest as-is.
 #
 # You may generate a new configuration with: lazymc config generate
-# Or find the latest at: https://is.gd/WWBIQu
+# Or find the latest at: https://git.io/J1Fvq

 [public]
 # Public address. IP and port users connect to.
@@ -17,7 +17,7 @@

 # Server version & protocol hint.
 # Sent to clients until actual server version is known.
-# See: https://is.gd/FTQKTP
+# See: https://git.io/J1Fvx
 #version = "1.17.1"
 #protocol = 756

@@ -30,7 +30,7 @@
 directory = "."

 # Command to start the server.
-# Warning: if using a bash script read: https://is.gd/k8SQYv
+# Warning: if using a bash script read: https://git.io/JMIKH
 command = "java -Xmx1G -Xms1G -jar server.jar --nogui"

 # Immediately wake server when starting lazymc.
@@ -39,10 +39,29 @@ command = "java -Xmx1G -Xms1G -jar server.jar --nogui"
 # Immediately wake server after crash.
 #wake_on_crash = false

+# Probe required server details when starting lazymc, wakes server on start.
+# Improves client compatibility. Automatically enabled if required by other config properties.
+#probe_on_start = false
+
+# Set to true if this server runs Forge.
+#forge = false
+
 # Server start/stop timeout in seconds. Force kill server process if it takes too long.
 #start_timeout = 300
 #stop_timeout = 150

+# Block banned IPs as listed in banned-ips.json in server directory.
+#block_banned_ips = true
+
+# Drop connections from banned IPs.
+# Banned IPs won't be able to ping or request server status.
+# On connect, clients show a 'Disconnected' message rather than the ban reason.
+#drop_banned_ips = false
+
+# Add HAProxy v2 header to proxied connections.
+# See: https://git.io/J1bYb
+#send_proxy_v2 = false
+
 [time]
 # Sleep after number of seconds.
 #sleep_after = 60
@@ -97,6 +116,10 @@ command = "java -Xmx1G -Xms1G -jar server.jar --nogui"
 # The target server will receive original client handshake and login request as received by lazymc.
 #address = "127.0.0.1:25565"

+# Add HAProxy v2 header to forwarded connections.
+# See: https://git.io/J1bYb
+#send_proxy_v2 = false
+
 [join.lobby]
 # Lobby occupation method.
 # The client joins a fake lobby server with an empty world, floating in space.
@@ -104,15 +127,18 @@ command = "java -Xmx1G -Xms1G -jar server.jar --nogui"
 # The client will be teleported to the real server once it is ready.
 # This may keep the client occupied forever if no timeout is set.
 # Consumes client, not allowing other join methods afterwards.
+# See: https://git.io/JMIi4

 # !!! WARNING !!!
 # This is highly experimental, incomplete and unstable.
 # This may break the game and crash clients.
 # Don't enable this unless you know what you're doing.
 #
-# - Only works with offline mode
-# - Only works with vanilla Minecraft clients, does not work with modded
-# - Only tested with Minecraft 1.17.1
+# - Server must be in offline mode
+# - Server must use Minecraft version 1.16.3 to 1.17.1 (tested with 1.17.1)
+# - Server must use vanilla Minecraft
+#   - May work with Forge, enable in config, depends on used mods, test before use
+#   - Does not work with other mods, such as FTB

 # Maximum time in seconds in the lobby while the server starts.
 #timeout = 600
@@ -133,7 +159,7 @@ command = "java -Xmx1G -Xms1G -jar server.jar --nogui"
 [rcon]
 # Enable sleeping server through RCON.
 # Must be enabled on Windows.
-#enabled = true
+#enabled = false # default: false, true on Windows

 # Server RCON port. Must differ from public and server port.
 #port = 25575
@@ -143,6 +169,10 @@ command = "java -Xmx1G -Xms1G -jar server.jar --nogui"
 #password = ""
 #randomize_password = true

+# Add HAProxy v2 header to RCON connections.
+# See: https://git.io/J1bYb
+#send_proxy_v2 = false
+
 [advanced]
 # Automatically update values in Minecraft server.properties file as required.
 #rewrite_server_properties = true
@@ -150,4 +180,4 @@ command = "java -Xmx1G -Xms1G -jar server.jar --nogui"
 [config]
 # lazymc version this configuration is for.
 # Don't change unless you know what you're doing.
-version = "0.2.0"
+version = "0.2.5"
--- a/res/start-server
+++ b/res/start-server
@@ -1,5 +1,7 @@
 #!/bin/bash

+# See: https://git.io/JMIKH
+
 # Server JAR file, set this to your own
 FILE=server.jar

--- a/res/unknown_server.png
+++ b/res/unknown_server.png
--- a/res/unknown_server_optimized.png
+++ b/res/unknown_server_optimized.png
--- a/src/action/start.rs
+++ b/src/action/start.rs
@@ -3,7 +3,7 @@ use std::sync::Arc;

 use clap::ArgMatches;

-use crate::config::{self, Config};
+use crate::config::{self, Config, Server as ConfigServer};
 use crate::mc::server_properties;
 use crate::proto;
 use crate::service;
@@ -120,7 +120,7 @@ fn rewrite_server_properties(config: &Config) {
    }

    // Ensure server directory is set, it must exist
-    let dir = match &config.server.directory {
+    let dir = match ConfigServer::server_directory(config) {
        Some(dir) => dir,
        None => {
            warn!(target: "lazymc", "Not rewriting {} file, server directory not configured (server.directory)", server_properties::FILE);
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,7 +1,7 @@
 use std::fs;
 use std::io;
 use std::net::SocketAddr;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;

 use clap::ArgMatches;
 use serde::Deserialize;
@@ -9,12 +9,13 @@ use version_compare::Cmp;

 use crate::proto;
 use crate::util::error::{quit_error, quit_error_msg, ErrorHintsBuilder};
+use crate::util::serde::to_socket_addrs;

 /// Default configuration file location.
 pub const CONFIG_FILE: &str = "lazymc.toml";

 /// Configuration version user should be using, or warning will be shown.
-const CONFIG_VERSION: &str = "0.2.0";
+const CONFIG_VERSION: &str = "0.2.1";

 /// Load config from file, based on CLI arguments.
 ///
@@ -62,6 +63,12 @@ pub fn load(matches: &ArgMatches) -> Config {
 /// Configuration.
 #[derive(Debug, Deserialize)]
 pub struct Config {
+    /// Configuration path if known.
+    ///
+    /// Should be used as base directory for filesystem operations.
+    #[serde(skip)]
+    pub path: Option<PathBuf>,
+
    /// Public configuration.
    #[serde(default)]
    pub public: Public,
@@ -100,9 +107,9 @@ pub struct Config {

 impl Config {
    /// Load configuration from file.
-    pub fn load<P: AsRef<Path>>(path: P) -> Result<Self, io::Error> {
-        let data = fs::read(path)?;
-        let config: Config = toml::from_slice(&data)?;
+    pub fn load(path: PathBuf) -> Result<Self, io::Error> {
+        let data = fs::read(&path)?;
+        let mut config: Config = toml::from_slice(&data)?;

        // Show warning if config version is problematic
        match &config.config.version {
@@ -117,6 +124,7 @@ impl Config {
                Ok(true) => {}
            },
        }
+        config.path.replace(path);

        Ok(config)
    }
@@ -127,6 +135,7 @@ impl Config {
 #[serde(default)]
 pub struct Public {
    /// Public address.
+    #[serde(deserialize_with = "to_socket_addrs")]
    pub address: SocketAddr,

    /// Minecraft protocol version name hint.
@@ -150,14 +159,19 @@ impl Default for Public {
 #[derive(Debug, Deserialize)]
 pub struct Server {
    /// Server directory.
+    ///
+    /// Private because you should use `Server::server_directory()` instead.
    #[serde(default = "option_pathbuf_dot")]
-    pub directory: Option<PathBuf>,
+    directory: Option<PathBuf>,

    /// Start command.
    pub command: String,

    /// Server address.
-    #[serde(default = "server_address_default")]
+    #[serde(
+        deserialize_with = "to_socket_addrs",
+        default = "server_address_default"
+    )]
    pub address: SocketAddr,

    /// Immediately wake server when starting lazymc.
@@ -168,6 +182,14 @@ pub struct Server {
    #[serde(default)]
    pub wake_on_crash: bool,

+    /// Probe required server details when starting lazymc, wakes server on start.
+    #[serde(default)]
+    pub probe_on_start: bool,
+
+    /// Whether this server runs forge.
+    #[serde(default)]
+    pub forge: bool,
+
    /// Server starting timeout. Force kill server process if it takes longer.
    #[serde(default = "u32_300")]
    pub start_timeout: u32,
@@ -175,6 +197,31 @@ pub struct Server {
    /// Server stopping timeout. Force kill server process if it takes longer.
    #[serde(default = "u32_150")]
    pub stop_timeout: u32,
+
+    /// Block banned IPs as listed in banned-ips.json in server directory.
+    #[serde(default = "bool_true")]
+    pub block_banned_ips: bool,
+
+    /// Drop connections from banned IPs.
+    #[serde(default)]
+    pub drop_banned_ips: bool,
+
+    /// Add HAProxy v2 header to proxied connections.
+    #[serde(default)]
+    pub send_proxy_v2: bool,
+}
+
+impl Server {
+    /// Get the server directory.
+    ///
+    /// This does not check whether it exists.
+    pub fn server_directory(config: &Config) -> Option<PathBuf> {
+        // Get directory, relative to config directory if known
+        match config.path.as_ref().and_then(|p| p.parent()) {
+            Some(config_dir) => Some(config_dir.join(config.server.directory.as_ref()?)),
+            None => config.server.directory.clone(),
+        }
+    }
 }

 /// Time configuration.
@@ -318,13 +365,19 @@ impl Default for JoinHold {
 #[serde(default)]
 pub struct JoinForward {
    /// IP and port to forward to.
+    #[serde(deserialize_with = "to_socket_addrs")]
    pub address: SocketAddr,
+
+    /// Add HAProxy v2 header to proxied connections.
+    #[serde(default)]
+    pub send_proxy_v2: bool,
 }

 impl Default for JoinForward {
    fn default() -> Self {
        Self {
            address: "127.0.0.1:25565".parse().unwrap(),
+            send_proxy_v2: false,
        }
    }
 }
@@ -387,15 +440,19 @@ pub struct Rcon {

    /// Randomize server RCON password on each start.
    pub randomize_password: bool,
+
+    /// Add HAProxy v2 header to RCON connections.
+    pub send_proxy_v2: bool,
 }

 impl Default for Rcon {
    fn default() -> Self {
        Self {
-            enabled: true,
+            enabled: cfg!(windows),
            port: 25575,
            password: "".into(),
            randomize_password: true,
+            send_proxy_v2: false,
        }
    }
 }
@@ -445,3 +502,7 @@ fn u32_300() -> u32 {
 fn u32_150() -> u32 {
    300
 }
+
+fn bool_true() -> bool {
+    true
+}
--- a/src/forge.rs
+++ b/src/forge.rs
@@ -0,0 +1,255 @@
+#[cfg(feature = "lobby")]
+use std::sync::Arc;
+#[cfg(feature = "lobby")]
+use std::time::Duration;
+
+#[cfg(feature = "lobby")]
+use bytes::BytesMut;
+use minecraft_protocol::decoder::Decoder;
+use minecraft_protocol::encoder::Encoder;
+use minecraft_protocol::version::forge_v1_13::login::{Acknowledgement, LoginWrapper, ModList};
+use minecraft_protocol::version::v1_14_4::login::{LoginPluginRequest, LoginPluginResponse};
+use minecraft_protocol::version::PacketId;
+#[cfg(feature = "lobby")]
+use tokio::io::AsyncWriteExt;
+use tokio::net::tcp::WriteHalf;
+#[cfg(feature = "lobby")]
+use tokio::net::TcpStream;
+#[cfg(feature = "lobby")]
+use tokio::time;
+
+use crate::forge;
+use crate::proto::client::Client;
+#[cfg(feature = "lobby")]
+use crate::proto::client::ClientState;
+use crate::proto::packet;
+use crate::proto::packet::RawPacket;
+#[cfg(feature = "lobby")]
+use crate::proto::packets;
+#[cfg(feature = "lobby")]
+use crate::server::Server;
+
+/// Forge status magic.
+pub const STATUS_MAGIC: &str = "\0FML2\0";
+
+/// Forge plugin wrapper login plugin request channel.
+pub const CHANNEL_LOGIN_WRAPPER: &str = "fml:loginwrapper";
+
+/// Forge handshake channel.
+pub const CHANNEL_HANDSHAKE: &str = "fml:handshake";
+
+/// Timeout for draining Forge plugin responses from client.
+#[cfg(feature = "lobby")]
+const CLIENT_DRAIN_FORGE_TIMEOUT: Duration = Duration::from_secs(5);
+
+/// Respond with Forge login wrapper packet.
+pub async fn respond_forge_login_packet(
+    client: &Client,
+    writer: &mut WriteHalf<'_>,
+    message_id: i32,
+    forge_channel: String,
+    forge_packet: impl PacketId + Encoder,
+) -> Result<(), ()> {
+    // Encode Forge packet to data
+    let mut forge_data = Vec::new();
+    forge_packet.encode(&mut forge_data).map_err(|_| ())?;
+
+    // Encode Forge payload
+    let forge_payload =
+        RawPacket::new(forge_packet.packet_id(), forge_data).encode_without_len(client)?;
+
+    // Wrap Forge payload in login wrapper
+    let mut payload = Vec::new();
+    let packet = LoginWrapper {
+        channel: forge_channel,
+        packet: forge_payload,
+    };
+    packet.encode(&mut payload).map_err(|_| ())?;
+
+    // Write login plugin request with forge payload
+    packet::write_packet(
+        LoginPluginResponse {
+            message_id,
+            successful: true,
+            data: payload,
+        },
+        client,
+        writer,
+    )
+    .await
+}
+
+/// Respond to a Forge login plugin request.
+pub async fn respond_login_plugin_request(
+    client: &Client,
+    packet: LoginPluginRequest,
+    writer: &mut WriteHalf<'_>,
+) -> Result<(), ()> {
+    // Decode Forge login wrapper packet
+    let (message_id, login_wrapper, packet) =
+        forge::decode_forge_login_packet(client, packet).await?;
+
+    // Determine whether we received the mod list
+    let is_unknown_header = login_wrapper.channel != forge::CHANNEL_HANDSHAKE;
+    let is_mod_list = !is_unknown_header && packet.id == ModList::PACKET_ID;
+
+    // If not the mod list, just acknowledge
+    if !is_mod_list {
+        trace!(target: "lazymc::forge", "Acknowledging login plugin request");
+        forge::respond_forge_login_packet(
+            client,
+            writer,
+            message_id,
+            login_wrapper.channel,
+            Acknowledgement {},
+        )
+        .await
+        .map_err(|_| {
+            error!(target: "lazymc::forge", "Failed to send Forge login plugin request acknowledgement");
+        })?;
+        return Ok(());
+    }
+
+    trace!(target: "lazymc::forge", "Sending mod list reply to server with same contents");
+
+    // Parse mod list, transform into reply
+    let mod_list = ModList::decode(&mut packet.data.as_slice()).map_err(|err| {
+        error!(target: "lazymc::forge", "Failed to decode Forge mod list: {:?}", err);
+    })?;
+    let mod_list_reply = mod_list.into_reply();
+
+    // We got mod list, respond with reply
+    forge::respond_forge_login_packet(
+        client,
+        writer,
+        message_id,
+        login_wrapper.channel,
+        mod_list_reply,
+    )
+    .await
+    .map_err(|_| {
+        error!(target: "lazymc::forge", "Failed to send Forge login plugin mod list reply");
+    })?;
+
+    Ok(())
+}
+
+/// Decode a Forge login wrapper packet from login plugin request.
+///
+/// Returns (`message_id`, `login_wrapper`, `packet`).
+pub async fn decode_forge_login_packet(
+    client: &Client,
+    plugin_request: LoginPluginRequest,
+) -> Result<(i32, LoginWrapper, RawPacket), ()> {
+    // Validate channel
+    assert_eq!(plugin_request.channel, CHANNEL_LOGIN_WRAPPER);
+
+    // Decode login wrapped packet
+    let login_wrapper =
+        LoginWrapper::decode(&mut plugin_request.data.as_slice()).map_err(|err| {
+            error!(target: "lazymc::forge", "Failed to decode Forge LoginWrapper packet: {:?}", err);
+        })?;
+
+    // Parse packet
+    let packet = RawPacket::decode_without_len(client, &login_wrapper.packet).map_err(|err| {
+        error!(target: "lazymc::forge", "Failed to decode Forge LoginWrapper packet contents: {:?}", err);
+    })?;
+
+    Ok((plugin_request.message_id, login_wrapper, packet))
+}
+
+/// Replay the Forge login payload for a client.
+#[cfg(feature = "lobby")]
+pub async fn replay_login_payload(
+    client: &Client,
+    inbound: &mut TcpStream,
+    server: Arc<Server>,
+    inbound_buf: &mut BytesMut,
+) -> Result<(), ()> {
+    debug!(target: "lazymc::lobby", "Replaying Forge login procedure for lobby client...");
+
+    // Replay each Forge packet
+    for packet in server.forge_payload.read().await.as_slice() {
+        inbound.write_all(packet).await.map_err(|err| {
+            error!(target: "lazymc::lobby", "Failed to send Forge join payload to lobby client, will likely cause issues: {}", err);
+        })?;
+    }
+
+    // Drain all responses
+    let count = server.forge_payload.read().await.len();
+    drain_forge_responses(client, inbound, inbound_buf, count).await?;
+
+    trace!(target: "lazymc::lobby", "Forge join payload replayed");
+
+    Ok(())
+}
+
+/// Drain Forge login plugin response packets from stream.
+#[cfg(feature = "lobby")]
+async fn drain_forge_responses(
+    client: &Client,
+    inbound: &mut TcpStream,
+    buf: &mut BytesMut,
+    mut count: usize,
+) -> Result<(), ()> {
+    let (mut reader, mut _writer) = inbound.split();
+
+    loop {
+        // We're done if count is zero
+        if count == 0 {
+            trace!(target: "lazymc::forge", "Drained all plugin responses from client");
+            return Ok(());
+        }
+
+        // Read packet from stream with timeout
+        let read_packet_task = packet::read_packet(client, buf, &mut reader);
+        let timeout = time::timeout(CLIENT_DRAIN_FORGE_TIMEOUT, read_packet_task).await;
+        let read_packet_task = match timeout {
+            Ok(result) => result,
+            Err(_) => {
+                error!(target: "lazymc::forge", "Expected more plugin responses from client, but didn't receive anything in a while, may be problematic");
+                return Ok(());
+            }
+        };
+
+        // Read packet from stream
+        let (packet, _raw) = match read_packet_task {
+            Ok(Some(packet)) => packet,
+            Ok(None) => break,
+            Err(_) => {
+                error!(target: "lazymc::forge", "Closing connection, error occurred");
+                break;
+            }
+        };
+
+        // Grab client state
+        let client_state = client.state();
+
+        // Catch login plugin resposne
+        if client_state == ClientState::Login
+            && packet.id == packets::login::SERVER_LOGIN_PLUGIN_RESPONSE
+        {
+            trace!(target: "lazymc::forge", "Voiding plugin response from client");
+            count -= 1;
+            continue;
+        }
+
+        // TODO: instantly return on this packet?
+        // // Hijack login success
+        // if client_state == ClientState::Login && packet.id == packets::login::CLIENT_LOGIN_SUCCESS {
+        //     trace!(target: "lazymc::forge", "Got login success from server connection, change to play mode");
+
+        //     // Switch to play state
+        //     tmp_client.set_state(ClientState::Play);
+
+        //     return Ok(forge_payload);
+        // }
+
+        // Show unhandled packet warning
+        debug!(target: "lazymc::forge", "Got unhandled packet from server in record_forge_response:");
+        debug!(target: "lazymc::forge", "- State: {:?}", client_state);
+        debug!(target: "lazymc::forge", "- Packet ID: 0x{:02X} ({})", packet.id, packet.id);
+    }
+
+    Err(())
+}
--- a/src/join/forward.rs
+++ b/src/join/forward.rs
@@ -0,0 +1,32 @@
+use std::sync::Arc;
+
+use bytes::BytesMut;
+use tokio::net::TcpStream;
+
+use crate::config::*;
+use crate::proxy::ProxyHeader;
+use crate::service;
+
+use super::MethodResult;
+
+/// Forward the client.
+pub async fn occupy(
+    config: Arc<Config>,
+    inbound: TcpStream,
+    inbound_history: &mut BytesMut,
+) -> Result<MethodResult, ()> {
+    trace!(target: "lazymc", "Using forward method to occupy joining client");
+
+    debug!(target: "lazymc", "Forwarding client to {:?}!", config.join.forward.address);
+
+    service::server::route_proxy_address_queue(
+        inbound,
+        ProxyHeader::Proxy.not_none(config.join.forward.send_proxy_v2),
+        config.join.forward.address,
+        inbound_history.clone(),
+    );
+
+    // TODO: do not consume, continue on proxy connect failure
+
+    Ok(MethodResult::Consumed)
+}
--- a/src/join/hold.rs
+++ b/src/join/hold.rs
@@ -0,0 +1,101 @@
+use std::ops::Deref;
+use std::sync::Arc;
+use std::time::Duration;
+
+use bytes::BytesMut;
+use tokio::net::TcpStream;
+use tokio::time;
+
+use crate::config::*;
+use crate::server::{Server, State};
+use crate::service;
+
+use super::MethodResult;
+
+/// Hold the client.
+pub async fn occupy(
+    config: Arc<Config>,
+    server: Arc<Server>,
+    inbound: TcpStream,
+    inbound_history: &mut BytesMut,
+) -> Result<MethodResult, ()> {
+    trace!(target: "lazymc", "Using hold method to occupy joining client");
+
+    // Server must be starting
+    if server.state() != State::Starting {
+        return Ok(MethodResult::Continue(inbound));
+    }
+
+    // Start holding, consume client
+    if hold(&config, &server).await? {
+        service::server::route_proxy_queue(inbound, config, inbound_history.clone());
+        return Ok(MethodResult::Consumed);
+    }
+
+    Ok(MethodResult::Continue(inbound))
+}
+
+/// Hold a client while server starts.
+///
+/// Returns holding status. `true` if client is held and it should be proxied, `false` it was held
+/// but it timed out.
+async fn hold<'a>(config: &Config, server: &Server) -> Result<bool, ()> {
+    trace!(target: "lazymc", "Started holding client");
+
+    // A task to wait for suitable server state
+    // Waits for started state, errors if stopping/stopped state is reached
+    let task_wait = async {
+        let mut state = server.state_receiver();
+        loop {
+            // Wait for state change
+            state.changed().await.unwrap();
+
+            match state.borrow().deref() {
+                // Still waiting on server start
+                State::Starting => {
+                    trace!(target: "lazymc", "Server not ready, holding client for longer");
+                    continue;
+                }
+
+                // Server started, start relaying and proxy
+                State::Started => {
+                    break true;
+                }
+
+                // Server stopping, this shouldn't happen, kick
+                State::Stopping => {
+                    warn!(target: "lazymc", "Server stopping for held client, disconnecting");
+                    break false;
+                }
+
+                // Server stopped, this shouldn't happen, disconnect
+                State::Stopped => {
+                    error!(target: "lazymc", "Server stopped for held client, disconnecting");
+                    break false;
+                }
+            }
+        }
+    };
+
+    // Wait for server state with timeout
+    let timeout = Duration::from_secs(config.join.hold.timeout as u64);
+    match time::timeout(timeout, task_wait).await {
+        // Relay client to proxy
+        Ok(true) => {
+            info!(target: "lazymc", "Server ready for held client, relaying to server");
+            Ok(true)
+        }
+
+        // Server stopping/stopped, this shouldn't happen, kick
+        Ok(false) => {
+            warn!(target: "lazymc", "Server stopping for held client");
+            Ok(false)
+        }
+
+        // Timeout reached, kick with starting message
+        Err(_) => {
+            warn!(target: "lazymc", "Held client reached timeout of {}s", config.join.hold.timeout);
+            Ok(false)
+        }
+    }
+}
--- a/src/join/kick.rs
+++ b/src/join/kick.rs
@@ -0,0 +1,33 @@
+use tokio::net::TcpStream;
+
+use crate::config::*;
+use crate::net;
+use crate::proto::action;
+use crate::proto::client::Client;
+use crate::server::{self, Server};
+
+use super::MethodResult;
+
+/// Kick the client.
+pub async fn occupy(
+    client: &Client,
+    config: &Config,
+    server: &Server,
+    mut inbound: TcpStream,
+) -> Result<MethodResult, ()> {
+    trace!(target: "lazymc", "Using kick method to occupy joining client");
+
+    // Select message and kick
+    let msg = match server.state() {
+        server::State::Starting | server::State::Stopped | server::State::Started => {
+            &config.join.kick.starting
+        }
+        server::State::Stopping => &config.join.kick.stopping,
+    };
+    action::kick(client, msg, &mut inbound.split().1).await?;
+
+    // Gracefully close connection
+    net::close_tcp_stream(inbound).await.map_err(|_| ())?;
+
+    Ok(MethodResult::Consumed)
+}
--- a/src/join/lobby.rs
+++ b/src/join/lobby.rs
@@ -0,0 +1,46 @@
+use std::sync::Arc;
+
+use bytes::BytesMut;
+use tokio::net::TcpStream;
+
+use crate::config::*;
+use crate::lobby;
+use crate::proto::client::{Client, ClientInfo};
+use crate::server::Server;
+
+use super::MethodResult;
+
+/// Lobby the client.
+pub async fn occupy(
+    client: &Client,
+    client_info: ClientInfo,
+    config: Arc<Config>,
+    server: Arc<Server>,
+    inbound: TcpStream,
+    inbound_queue: BytesMut,
+) -> Result<MethodResult, ()> {
+    trace!(target: "lazymc", "Using lobby method to occupy joining client");
+
+    // Must be ready to lobby
+    if must_still_probe(&config, &server).await {
+        warn!(target: "lazymc", "Client connected but lobby is not ready, using next join method, probing not completed");
+        return Ok(MethodResult::Continue(inbound));
+    }
+
+    // Start lobby
+    lobby::serve(client, client_info, inbound, config, server, inbound_queue).await?;
+
+    // TODO: do not consume client here, allow other join method on fail
+
+    Ok(MethodResult::Consumed)
+}
+
+/// Check whether we still have to probe before we can use the lobby.
+async fn must_still_probe(config: &Config, server: &Server) -> bool {
+    must_probe(config) && server.probed_join_game.read().await.is_none()
+}
+
+/// Check whether we must have probed data.
+fn must_probe(config: &Config) -> bool {
+    config.server.forge
+}
--- a/src/join/mod.rs
+++ b/src/join/mod.rs
@@ -0,0 +1,106 @@
+use std::sync::Arc;
+
+use bytes::BytesMut;
+use tokio::net::TcpStream;
+
+use crate::config::*;
+use crate::net;
+use crate::proto::client::{Client, ClientInfo, ClientState};
+use crate::server::Server;
+
+pub mod forward;
+pub mod hold;
+pub mod kick;
+#[cfg(feature = "lobby")]
+pub mod lobby;
+
+/// A result returned by a join occupy method.
+pub enum MethodResult {
+    /// Client is consumed.
+    Consumed,
+
+    /// Method is done, continue with the next.
+    Continue(TcpStream),
+}
+
+/// Start occupying client.
+///
+/// This assumes the login start packet has just been received.
+pub async fn occupy(
+    client: Client,
+    #[allow(unused_variables)] client_info: ClientInfo,
+    config: Arc<Config>,
+    server: Arc<Server>,
+    mut inbound: TcpStream,
+    mut inbound_history: BytesMut,
+    #[allow(unused_variables)] login_queue: BytesMut,
+) -> Result<(), ()> {
+    // Assert state is correct
+    assert_eq!(
+        client.state(),
+        ClientState::Login,
+        "when occupying client, it should be in login state"
+    );
+
+    // Go through all configured join methods
+    for method in &config.join.methods {
+        // Invoke method, take result
+        let result = match method {
+            // Kick method, immediately kick client
+            Method::Kick => kick::occupy(&client, &config, &server, inbound).await?,
+
+            // Hold method, hold client connection while server starts
+            Method::Hold => {
+                hold::occupy(
+                    config.clone(),
+                    server.clone(),
+                    inbound,
+                    &mut inbound_history,
+                )
+                .await?
+            }
+
+            // Forward method, forward client connection while server starts
+            Method::Forward => {
+                forward::occupy(config.clone(), inbound, &mut inbound_history).await?
+            }
+
+            // Lobby method, keep client in lobby while server starts
+            #[cfg(feature = "lobby")]
+            Method::Lobby => {
+                lobby::occupy(
+                    &client,
+                    client_info.clone(),
+                    config.clone(),
+                    server.clone(),
+                    inbound,
+                    login_queue.clone(),
+                )
+                .await?
+            }
+
+            // Lobby method, keep client in lobby while server starts
+            #[cfg(not(feature = "lobby"))]
+            Method::Lobby => {
+                error!(target: "lazymc", "Lobby join method not supported in this lazymc build");
+                MethodResult::Continue(inbound)
+            }
+        };
+
+        // Handle method result
+        match result {
+            MethodResult::Consumed => return Ok(()),
+            MethodResult::Continue(stream) => {
+                inbound = stream;
+                continue;
+            }
+        }
+    }
+
+    debug!(target: "lazymc", "No method left to occupy joining client, disconnecting");
+
+    // Gracefully close connection
+    net::close_tcp_stream(inbound).await.map_err(|_| ())?;
+
+    Ok(())
+}
--- a/src/lobby.rs
+++ b/src/lobby.rs
@@ -1,39 +1,33 @@
 use std::io::ErrorKind;
 use std::ops::Deref;
-use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::Arc;
 use std::time::Duration;

 use bytes::BytesMut;
 use futures::FutureExt;
-use minecraft_protocol::data::chat::{Message, Payload};
 use minecraft_protocol::decoder::Decoder;
-use minecraft_protocol::encoder::Encoder;
-use minecraft_protocol::version::v1_14_4::handshake::Handshake;
-use minecraft_protocol::version::v1_14_4::login::{LoginStart, LoginSuccess, SetCompression};
-use minecraft_protocol::version::v1_17_1::game::{
-    ClientBoundKeepAlive, JoinGame, NamedSoundEffect, PlayerPositionAndLook, PluginMessage,
-    Respawn, SetTitleSubtitle, SetTitleText, SetTitleTimes, TimeUpdate,
+use minecraft_protocol::version::v1_14_4::login::{
+    LoginPluginRequest, LoginPluginResponse, LoginStart, LoginSuccess, SetCompression,
 };
-use nbt::CompoundTag;
-use tokio::io::{self, AsyncWriteExt};
+use tokio::io::AsyncWriteExt;
 use tokio::net::tcp::{ReadHalf, WriteHalf};
 use tokio::net::TcpStream;
 use tokio::select;
 use tokio::time;
-use uuid::Uuid;

 use crate::config::*;
-use crate::mc;
-use crate::proto::{self, Client, ClientInfo, ClientState, RawPacket};
+use crate::forge;
+use crate::mc::uuid;
+use crate::net;
+use crate::proto;
+use crate::proto::client::{Client, ClientInfo, ClientState};
+use crate::proto::packets::play::join_game::JoinGameData;
+use crate::proto::{packet, packets};
 use crate::proxy;
 use crate::server::{Server, State};

 /// Interval to send keep-alive packets at.
-const KEEP_ALIVE_INTERVAL: Duration = Duration::from_secs(10);
-
-/// Auto incrementing ID source for keep alive packets.
-static KEEP_ALIVE_ID: AtomicU64 = AtomicU64::new(0);
+pub const KEEP_ALIVE_INTERVAL: Duration = Duration::from_secs(10);

 /// Timeout for creating new server connection for lobby client.
 const SERVER_CONNECT_TIMEOUT: Duration = Duration::from_secs(2 * 60);
@@ -51,18 +45,13 @@ const SERVER_JOIN_GAME_TIMEOUT: Duration = Duration::from_secs(20);
 /// See warning at: https://wiki.vg/Protocol#Login_Success
 const SERVER_WARMUP: Duration = Duration::from_secs(1);

-/// Server brand to send to client in lobby world.
-///
-/// Shown in F3 menu. Updated once client is relayed to real server.
-const SERVER_BRAND: &[u8] = b"lazymc";
-
 /// Serve lobby service for given client connection.
 ///
 /// The client must be in the login state, or this will error.
 // TODO: do not drop error here, return Box<dyn Error>
 // TODO: on error, nicely kick client with message
 pub async fn serve(
-    client: Client,
+    client: &Client,
    client_info: ClientInfo,
    mut inbound: TcpStream,
    config: Arc<Config>,
@@ -88,7 +77,7 @@ pub async fn serve(

    loop {
        // Read packet from stream
-        let (packet, _raw) = match proto::read_packet(&client, &mut inbound_buf, &mut reader).await
+        let (packet, _raw) = match packet::read_packet(client, &mut inbound_buf, &mut reader).await
        {
            Ok(Some(packet)) => packet,
            Ok(None) => break,
@@ -102,44 +91,61 @@ pub async fn serve(
        let client_state = client.state();

        // Hijack login start
-        if client_state == ClientState::Login
-            && packet.id == proto::packets::login::SERVER_LOGIN_START
-        {
+        if client_state == ClientState::Login && packet.id == packets::login::SERVER_LOGIN_START {
            // Parse login start packet
            let login_start = LoginStart::decode(&mut packet.data.as_slice()).map_err(|_| ())?;

            debug!(target: "lazymc::lobby", "Login on lobby server (user: {})", login_start.name);

+            // Replay Forge payload
+            if config.server.forge {
+                forge::replay_login_payload(client, &mut inbound, server.clone(), &mut inbound_buf)
+                    .await?;
+                let (_returned_reader, returned_writer) = inbound.split();
+                writer = returned_writer;
+            }
+
            // Respond with set compression if compression is enabled based on threshold
            if proto::COMPRESSION_THRESHOLD >= 0 {
                trace!(target: "lazymc::lobby", "Enabling compression for lobby client because server has it enabled (threshold: {})", proto::COMPRESSION_THRESHOLD);
-                respond_set_compression(&client, &mut writer, proto::COMPRESSION_THRESHOLD).await?;
+                respond_set_compression(client, &mut writer, proto::COMPRESSION_THRESHOLD).await?;
                client.set_compression(proto::COMPRESSION_THRESHOLD);
            }

            // Respond with login success, switch to play state
-            respond_login_success(&client, &mut writer, &login_start).await?;
+            respond_login_success(client, &mut writer, &login_start).await?;
            client.set_state(ClientState::Play);

            trace!(target: "lazymc::lobby", "Client login success, sending required play packets for lobby world");

            // Send packets to client required to get into workable play state for lobby world
-            send_lobby_play_packets(&client, &mut writer, &server).await?;
+            send_lobby_play_packets(client, &client_info, &mut writer, &server).await?;

-            // Wait for server to come online, then set up new connection to it
-            stage_wait(&client, &server, &config, &mut writer).await?;
+            // Wait for server to come online
+            stage_wait(client, &client_info, &server, &config, &mut writer).await?;
+
+            // Start new connection to server
+            let server_client_info = client_info.clone();
            let (server_client, mut outbound, mut server_buf) =
-                connect_to_server(client_info, &config).await?;
+                connect_to_server(&server_client_info, &inbound, &config).await?;
+            let (returned_reader, returned_writer) = inbound.split();
+            reader = returned_reader;
+            writer = returned_writer;

            // Grab join game packet from server
-            let join_game =
-                wait_for_server_join_game(&server_client, &mut outbound, &mut server_buf).await?;
+            let join_game_data = wait_for_server_join_game(
+                &server_client,
+                &server_client_info,
+                &mut outbound,
+                &mut server_buf,
+            )
+            .await?;

            // Reset lobby title
-            send_lobby_title(&client, &mut writer, "").await?;
+            packets::play::title::send(client, &client_info, &mut writer, "").await?;

            // Play ready sound if configured
-            play_lobby_ready_sound(&client, &mut writer, &config).await?;
+            play_lobby_ready_sound(client, &client_info, &mut writer, &config).await?;

            // Wait a second because Notchian servers are slow
            // See: https://wiki.vg/Protocol#Login_Success
@@ -147,7 +153,8 @@ pub async fn serve(
            time::sleep(SERVER_WARMUP).await;

            // Send respawn packet, initiates teleport to real server world
-            send_respawn_from_join(&client, &mut writer, join_game).await?;
+            packets::play::respawn::lobby_send(client, &client_info, &mut writer, join_game_data)
+                .await?;

            // Drain inbound connection so we don't confuse the server
            // TODO: can we void everything? we might need to forward everything to server except
@@ -162,21 +169,14 @@ pub async fn serve(
            return Ok(());
        }

-        // TODO: when receiving Login Plugin Request, respond with empty payload
-        // See: https://wiki.vg/Protocol#Login_Plugin_Request
-
        // Show unhandled packet warning
-        debug!(target: "lazymc", "Received unhandled packet:");
+        debug!(target: "lazymc", "Got unhandled packet:");
        debug!(target: "lazymc", "- State: {:?}", client_state);
        debug!(target: "lazymc", "- Packet ID: 0x{:02X} ({})", packet.id, packet.id);
    }

    // Gracefully close connection
-    match writer.shutdown().await {
-        Ok(_) => {}
-        Err(err) if err.kind() == io::ErrorKind::NotConnected => {}
-        Err(_) => return Err(()),
-    }
+    net::close_tcp_stream(inbound).await.map_err(|_| ())?;

    Ok(())
 }
@@ -187,16 +187,7 @@ async fn respond_set_compression(
    writer: &mut WriteHalf<'_>,
    threshold: i32,
 ) -> Result<(), ()> {
-    let packet = SetCompression { threshold };
-
-    let mut data = Vec::new();
-    packet.encode(&mut data).map_err(|_| ())?;
-
-    let response =
-        RawPacket::new(proto::packets::login::CLIENT_SET_COMPRESSION, data).encode(client)?;
-    writer.write_all(&response).await.map_err(|_| ())?;
-
-    Ok(())
+    packet::write_packet(SetCompression { threshold }, client, writer).await
 }

 /// Respond to client with login success packet
@@ -206,27 +197,21 @@ async fn respond_login_success(
    writer: &mut WriteHalf<'_>,
    login_start: &LoginStart,
 ) -> Result<(), ()> {
-    let packet = LoginSuccess {
-        uuid: Uuid::new_v3(
-            &Uuid::new_v3(&Uuid::nil(), b"OfflinePlayer"),
-            login_start.name.as_bytes(),
-        ),
-        username: login_start.name.clone(),
-    };
-
-    let mut data = Vec::new();
-    packet.encode(&mut data).map_err(|_| ())?;
-
-    let response =
-        RawPacket::new(proto::packets::login::CLIENT_LOGIN_SUCCESS, data).encode(client)?;
-    writer.write_all(&response).await.map_err(|_| ())?;
-
-    Ok(())
+    packet::write_packet(
+        LoginSuccess {
+            uuid: uuid::offline_player_uuid(&login_start.name),
+            username: login_start.name.clone(),
+        },
+        client,
+        writer,
+    )
+    .await
 }

 /// Play lobby ready sound effect if configured.
 async fn play_lobby_ready_sound(
    client: &Client,
+    client_info: &ClientInfo,
    writer: &mut WriteHalf<'_>,
    config: &Config,
 ) -> Result<(), ()> {
@@ -238,8 +223,8 @@ async fn play_lobby_ready_sound(
        }

        // Play sound effect
-        send_lobby_player_pos(client, writer).await?;
-        send_lobby_sound_effect(client, writer, sound_name).await?;
+        packets::play::player_pos::send(client, client_info, writer).await?;
+        packets::play::sound::send(client, client_info, writer, sound_name).await?;
    }

    Ok(())
@@ -248,268 +233,23 @@ async fn play_lobby_ready_sound(
 /// Send packets to client to get workable play state for lobby world.
 async fn send_lobby_play_packets(
    client: &Client,
+    client_info: &ClientInfo,
    writer: &mut WriteHalf<'_>,
    server: &Server,
 ) -> Result<(), ()> {
    // See: https://wiki.vg/Protocol_FAQ#What.27s_the_normal_login_sequence_for_a_client.3F

    // Send initial game join
-    send_lobby_join_game(client, writer, server).await?;
+    packets::play::join_game::lobby_send(client, client_info, writer, server).await?;

    // Send server brand
-    send_lobby_brand(client, writer).await?;
+    packets::play::server_brand::send(client, client_info, writer).await?;

    // Send spawn and player position, disables 'download terrain' screen
-    send_lobby_player_pos(client, writer).await?;
+    packets::play::player_pos::send(client, client_info, writer).await?;

    // Notify client of world time, required once before keep-alive packets
-    send_lobby_time_update(client, writer).await?;
-
-    Ok(())
-}
-
-/// Send initial join game packet to client for lobby.
-async fn send_lobby_join_game(
-    client: &Client,
-    writer: &mut WriteHalf<'_>,
-    server: &Server,
-) -> Result<(), ()> {
-    // Send Minecrafts default states, slightly customised for lobby world
-    let packet = {
-        let status = server.status().await;
-
-        JoinGame {
-            // Player ID must be unique, if it collides with another server entity ID the player gets
-            // in a weird state and cannot move
-            entity_id: 0,
-            // TODO: use real server value
-            hardcore: false,
-            game_mode: 3,
-            previous_game_mode: -1i8 as u8,
-            world_names: vec![
-                "minecraft:overworld".into(),
-                "minecraft:the_nether".into(),
-                "minecraft:the_end".into(),
-            ],
-            dimension_codec: snbt_to_compound_tag(include_str!("../res/dimension_codec.snbt")),
-            dimension: snbt_to_compound_tag(include_str!("../res/dimension.snbt")),
-            world_name: "lazymc:lobby".into(),
-            hashed_seed: 0,
-            max_players: status.as_ref().map(|s| s.players.max as i32).unwrap_or(20),
-            // TODO: use real server value
-            view_distance: 10,
-            // TODO: use real server value
-            reduced_debug_info: false,
-            // TODO: use real server value
-            enable_respawn_screen: true,
-            is_debug: true,
-            is_flat: false,
-        }
-    };
-
-    let mut data = Vec::new();
-    packet.encode(&mut data).map_err(|_| ())?;
-
-    let response = RawPacket::new(proto::packets::play::CLIENT_JOIN_GAME, data).encode(client)?;
-    writer.write_all(&response).await.map_err(|_| ())?;
-
-    Ok(())
-}
-
-/// Send lobby brand to client.
-async fn send_lobby_brand(client: &Client, writer: &mut WriteHalf<'_>) -> Result<(), ()> {
-    let packet = PluginMessage {
-        channel: "minecraft:brand".into(),
-        data: SERVER_BRAND.into(),
-    };
-
-    let mut data = Vec::new();
-    packet.encode(&mut data).map_err(|_| ())?;
-
-    let response =
-        RawPacket::new(proto::packets::play::CLIENT_PLUGIN_MESSAGE, data).encode(client)?;
-    writer.write_all(&response).await.map_err(|_| ())?;
-
-    Ok(())
-}
-
-/// Send lobby player position to client.
-async fn send_lobby_player_pos(client: &Client, writer: &mut WriteHalf<'_>) -> Result<(), ()> {
-    // Send player location, disables download terrain screen
-    let packet = PlayerPositionAndLook {
-        x: 0.0,
-        y: 0.0,
-        z: 0.0,
-        yaw: 0.0,
-        pitch: 90.0,
-        flags: 0b00000000,
-        teleport_id: 0,
-        dismount_vehicle: true,
-    };
-
-    let mut data = Vec::new();
-    packet.encode(&mut data).map_err(|_| ())?;
-
-    let response =
-        RawPacket::new(proto::packets::play::CLIENT_PLAYER_POS_LOOK, data).encode(client)?;
-    writer.write_all(&response).await.map_err(|_| ())?;
-
-    Ok(())
-}
-
-/// Send lobby time update to client.
-async fn send_lobby_time_update(client: &Client, writer: &mut WriteHalf<'_>) -> Result<(), ()> {
-    const MC_TIME_NOON: i64 = 6000;
-
-    // Send time update, required once for keep-alive packets
-    let packet = TimeUpdate {
-        world_age: MC_TIME_NOON,
-        time_of_day: MC_TIME_NOON,
-    };
-
-    let mut data = Vec::new();
-    packet.encode(&mut data).map_err(|_| ())?;
-
-    let response = RawPacket::new(proto::packets::play::CLIENT_TIME_UPDATE, data).encode(client)?;
-    writer.write_all(&response).await.map_err(|_| ())?;
-
-    Ok(())
-}
-
-/// Send keep alive packet to client.
-///
-/// Required periodically in play mode to prevent client timeout.
-async fn send_keep_alive(client: &Client, writer: &mut WriteHalf<'_>) -> Result<(), ()> {
-    let packet = ClientBoundKeepAlive {
-        // Keep sending new IDs
-        id: KEEP_ALIVE_ID.fetch_add(1, Ordering::Relaxed),
-    };
-
-    let mut data = Vec::new();
-    packet.encode(&mut data).map_err(|_| ())?;
-
-    let response = RawPacket::new(proto::packets::play::CLIENT_KEEP_ALIVE, data).encode(client)?;
-    writer.write_all(&response).await.map_err(|_| ())?;
-
-    // TODO: verify we receive keep alive response with same ID from client
-
-    Ok(())
-}
-
-/// Send lobby title packets to client.
-///
-/// This will show the given text for two keep-alive periods. Use a newline for the subtitle.
-///
-/// If an empty string is given, the title times will be reset to default.
-async fn send_lobby_title(
-    client: &Client,
-    writer: &mut WriteHalf<'_>,
-    text: &str,
-) -> Result<(), ()> {
-    // Grab title and subtitle bits
-    let title = text.lines().next().unwrap_or("");
-    let subtitle = text.lines().skip(1).collect::<Vec<_>>().join("\n");
-
-    // Set title
-    let packet = SetTitleText {
-        text: Message::new(Payload::text(title)),
-    };
-
-    let mut data = Vec::new();
-    packet.encode(&mut data).map_err(|_| ())?;
-
-    let response =
-        RawPacket::new(proto::packets::play::CLIENT_SET_TITLE_TEXT, data).encode(client)?;
-    writer.write_all(&response).await.map_err(|_| ())?;
-
-    // Set subtitle
-    let packet = SetTitleSubtitle {
-        text: Message::new(Payload::text(&subtitle)),
-    };
-
-    let mut data = Vec::new();
-    packet.encode(&mut data).map_err(|_| ())?;
-
-    let response =
-        RawPacket::new(proto::packets::play::CLIENT_SET_TITLE_SUBTITLE, data).encode(client)?;
-    writer.write_all(&response).await.map_err(|_| ())?;
-
-    // Set title times
-    let packet = if title.is_empty() && subtitle.is_empty() {
-        // Defaults: https://minecraft.fandom.com/wiki/Commands/title#Detail
-        SetTitleTimes {
-            fade_in: 10,
-            stay: 70,
-            fade_out: 20,
-        }
-    } else {
-        SetTitleTimes {
-            fade_in: 0,
-            stay: KEEP_ALIVE_INTERVAL.as_secs() as i32 * mc::TICKS_PER_SECOND as i32 * 2,
-            fade_out: 0,
-        }
-    };
-
-    let mut data = Vec::new();
-    packet.encode(&mut data).map_err(|_| ())?;
-
-    let response =
-        RawPacket::new(proto::packets::play::CLIENT_SET_TITLE_TIMES, data).encode(client)?;
-    writer.write_all(&response).await.map_err(|_| ())?;
-
-    Ok(())
-}
-
-/// Send lobby ready sound effect to client.
-async fn send_lobby_sound_effect(
-    client: &Client,
-    writer: &mut WriteHalf<'_>,
-    sound_name: &str,
-) -> Result<(), ()> {
-    let packet = NamedSoundEffect {
-        sound_name: sound_name.into(),
-        sound_category: 0,
-        effect_pos_x: 0,
-        effect_pos_y: 0,
-        effect_pos_z: 0,
-        volume: 1.0,
-        pitch: 1.0,
-    };
-
-    let mut data = Vec::new();
-    packet.encode(&mut data).map_err(|_| ())?;
-
-    let response =
-        RawPacket::new(proto::packets::play::CLIENT_NAMED_SOUND_EFFECT, data).encode(client)?;
-    writer.write_all(&response).await.map_err(|_| ())?;
-
-    Ok(())
-}
-
-/// Send respawn packet to client to jump from lobby into now loaded server.
-///
-/// The required details will be fetched from the `join_game` packet as provided by the server.
-async fn send_respawn_from_join(
-    client: &Client,
-    writer: &mut WriteHalf<'_>,
-    join_game: JoinGame,
-) -> Result<(), ()> {
-    let packet = Respawn {
-        dimension: join_game.dimension,
-        world_name: join_game.world_name,
-        hashed_seed: join_game.hashed_seed,
-        game_mode: join_game.game_mode,
-        previous_game_mode: join_game.previous_game_mode,
-        is_debug: join_game.is_debug,
-        is_flat: join_game.is_flat,
-        copy_metadata: false,
-    };
-
-    let mut data = Vec::new();
-    packet.encode(&mut data).map_err(|_| ())?;
-
-    let response = RawPacket::new(proto::packets::play::CLIENT_RESPAWN, data).encode(client)?;
-    writer.write_all(&response).await.map_err(|_| ())?;
+    packets::play::time_update::send(client, client_info, writer).await?;

    Ok(())
 }
@@ -519,6 +259,7 @@ async fn send_respawn_from_join(
 /// This will keep sending keep-alive and title packets to the client until it is dropped.
 async fn keep_alive_loop(
    client: &Client,
+    client_info: &ClientInfo,
    writer: &mut WriteHalf<'_>,
    config: &Config,
 ) -> Result<(), ()> {
@@ -530,8 +271,10 @@ async fn keep_alive_loop(
        trace!(target: "lazymc::lobby", "Sending keep-alive sequence to lobby client");

        // Send keep alive and title packets
-        send_keep_alive(client, writer).await?;
-        send_lobby_title(client, writer, &config.join.lobby.message).await?;
+        packets::play::keep_alive::send(client, client_info, writer).await?;
+        packets::play::title::send(client, client_info, writer, &config.join.lobby.message).await?;
+
+        // TODO: verify we receive correct keep alive response
    }
 }

@@ -542,12 +285,13 @@ async fn keep_alive_loop(
 /// During this stage we keep sending keep-alive and title packets to the client to keep it active.
 async fn stage_wait(
    client: &Client,
+    client_info: &ClientInfo,
    server: &Server,
    config: &Config,
    writer: &mut WriteHalf<'_>,
 ) -> Result<(), ()> {
    select! {
-        a = keep_alive_loop(client, writer, config) => a,
+        a = keep_alive_loop(client, client_info, writer, config) => a,
        b = wait_for_server(server, config) => b,
    }
 }
@@ -611,12 +355,13 @@ async fn wait_for_server(server: &Server, config: &Config) -> Result<(), ()> {
 ///
 /// This will initialize the connection to the play state. Client details are used.
 async fn connect_to_server(
-    client_info: ClientInfo,
+    client_info: &ClientInfo,
+    inbound: &TcpStream,
    config: &Config,
 ) -> Result<(Client, TcpStream, BytesMut), ()> {
    time::timeout(
        SERVER_CONNECT_TIMEOUT,
-        connect_to_server_no_timeout(client_info, config),
+        connect_to_server_no_timeout(client_info, inbound, config),
    )
    .await
    .map_err(|_| {
@@ -629,7 +374,8 @@ async fn connect_to_server(
 /// This will initialize the connection to the play state. Client details are used.
 // TODO: clean this up
 async fn connect_to_server_no_timeout(
-    client_info: ClientInfo,
+    client_info: &ClientInfo,
+    inbound: &TcpStream,
    config: &Config,
 ) -> Result<(Client, TcpStream, BytesMut), ()> {
    // Open connection
@@ -638,44 +384,53 @@ async fn connect_to_server_no_timeout(
        .await
        .map_err(|_| ())?;

-    let (mut reader, mut writer) = outbound.split();
+    // Add proxy header
+    if config.server.send_proxy_v2 {
+        trace!(target: "lazymc::lobby", "Sending client proxy header for server connection");
+        outbound
+            .write_all(&proxy::stream_proxy_header(inbound).map_err(|_| ())?)
+            .await
+            .map_err(|_| ())?;
+    }

-    let tmp_client = Client::default();
+    // Construct temporary server client
+    let tmp_client = match outbound.local_addr() {
+        Ok(addr) => Client::new(addr),
+        Err(_) => Client::dummy(),
+    };
    tmp_client.set_state(ClientState::Login);

-    // Handshake packet
-    let packet = Handshake {
-        protocol_version: client_info.protocol_version.unwrap(),
-        server_addr: config.server.address.ip().to_string(),
-        server_port: config.server.address.port(),
-        next_state: ClientState::Login.to_id(),
-    };
+    let (mut reader, mut writer) = outbound.split();

-    let mut data = Vec::new();
-    packet.encode(&mut data).map_err(|_| ())?;
-
-    let request =
-        RawPacket::new(proto::packets::handshake::SERVER_HANDSHAKE, data).encode(&tmp_client)?;
-    writer.write_all(&request).await.map_err(|_| ())?;
+    // Replay client handshake packet
+    assert_eq!(
+        client_info.handshake.as_ref().unwrap().next_state,
+        ClientState::Login.to_id(),
+        "Client handshake should have login as next state"
+    );
+    packet::write_packet(
+        client_info.handshake.clone().unwrap(),
+        &tmp_client,
+        &mut writer,
+    )
+    .await?;

    // Request login start
-    let packet = LoginStart {
-        name: client_info.username.ok_or(())?,
-    };
-
-    let mut data = Vec::new();
-    packet.encode(&mut data).map_err(|_| ())?;
-
-    let request =
-        RawPacket::new(proto::packets::login::SERVER_LOGIN_START, data).encode(&tmp_client)?;
-    writer.write_all(&request).await.map_err(|_| ())?;
+    packet::write_packet(
+        LoginStart {
+            name: client_info.username.clone().ok_or(())?,
+        },
+        &tmp_client,
+        &mut writer,
+    )
+    .await?;

    // Incoming buffer
    let mut buf = BytesMut::new();

    loop {
        // Read packet from stream
-        let (packet, _raw) = match proto::read_packet(&tmp_client, &mut buf, &mut reader).await {
+        let (packet, _raw) = match packet::read_packet(&tmp_client, &mut buf, &mut reader).await {
            Ok(Some(packet)) => packet,
            Ok(None) => break,
            Err(_) => {
@@ -688,14 +443,11 @@ async fn connect_to_server_no_timeout(
        let client_state = tmp_client.state();

        // Catch set compression
-        if client_state == ClientState::Login
-            && packet.id == proto::packets::login::CLIENT_SET_COMPRESSION
+        if client_state == ClientState::Login && packet.id == packets::login::CLIENT_SET_COMPRESSION
        {
            // Decode compression packet
            let set_compression =
-                SetCompression::decode(&mut packet.data.as_slice()).map_err(|err| {
-                    dbg!(err);
-                })?;
+                SetCompression::decode(&mut packet.data.as_slice()).map_err(|_| ())?;

            // Client and server compression threshold should match, show warning if not
            if set_compression.threshold != proto::COMPRESSION_THRESHOLD {
@@ -712,11 +464,59 @@ async fn connect_to_server_no_timeout(
            continue;
        }

-        // Hijack login success
+        // Catch encryption requests
        if client_state == ClientState::Login
-            && packet.id == proto::packets::login::CLIENT_LOGIN_SUCCESS
+            && packet.id == packets::login::CLIENT_ENCRYPTION_REQUEST
        {
-            trace!(target: "lazymc::lobby", "Received login success from server connection, change to play mode");
+            error!(
+                target: "lazymc::lobby",
+                "Got encryption request from server, this is unsupported. Server must be in offline mode to use lobby.",
+            );
+
+            break;
+        }
+
+        // Hijack login plugin request
+        if client_state == ClientState::Login
+            && packet.id == packets::login::CLIENT_LOGIN_PLUGIN_REQUEST
+        {
+            // Decode login plugin request
+            let plugin_request =
+                LoginPluginRequest::decode(&mut packet.data.as_slice()).map_err(|err| {
+                    dbg!(err);
+                })?;
+
+            // Respond with Forge messages
+            if config.server.forge {
+                trace!(target: "lazymc::lobby", "Got login plugin request from server, responding with Forge reply");
+
+                // Respond to Forge login plugin request
+                forge::respond_login_plugin_request(&tmp_client, plugin_request, &mut writer)
+                    .await?;
+
+                continue;
+            }
+
+            warn!(target: "lazymc::lobby", "Got unexpected login plugin request from server, you may need to enable Forge support");
+
+            // Write unsuccesful login plugin response
+            packet::write_packet(
+                LoginPluginResponse {
+                    message_id: plugin_request.message_id,
+                    successful: false,
+                    data: vec![],
+                },
+                &tmp_client,
+                &mut writer,
+            )
+            .await?;
+
+            continue;
+        }
+
+        // Hijack login success
+        if client_state == ClientState::Login && packet.id == packets::login::CLIENT_LOGIN_SUCCESS {
+            trace!(target: "lazymc::lobby", "Got login success from server connection, change to play mode");

            // TODO: parse this packet to ensure it's fine
            // let login_success =
@@ -736,18 +536,29 @@ async fn connect_to_server_no_timeout(
            return Ok((tmp_client, outbound, buf));
        }

+        // Hijack disconnect
+        if client_state == ClientState::Login && packet.id == packets::login::CLIENT_DISCONNECT {
+            error!(target: "lazymc::lobby", "Got disconnect from server connection");
+
+            // // Decode disconnect packet
+            // let login_disconnect =
+            //     LoginDisconnect::decode(&mut packet.data.as_slice()).map_err(|err| {
+            //         dbg!(err);
+            //     })?;
+
+            // TODO: report/forward error to client
+
+            break;
+        }
+
        // Show unhandled packet warning
-        debug!(target: "lazymc::lobby", "Received unhandled packet from server in connect_to_server:");
+        debug!(target: "lazymc::lobby", "Got unhandled packet from server in connect_to_server:");
        debug!(target: "lazymc::lobby", "- State: {:?}", client_state);
        debug!(target: "lazymc::lobby", "- Packet ID: 0x{:02X} ({})", packet.id, packet.id);
    }

    // Gracefully close connection
-    match writer.shutdown().await {
-        Ok(_) => {}
-        Err(err) if err.kind() == io::ErrorKind::NotConnected => {}
-        Err(_) => return Err(()),
-    }
+    net::close_tcp_stream(outbound).await.map_err(|_| ())?;

    Err(())
 }
@@ -757,12 +568,13 @@ async fn connect_to_server_no_timeout(
 /// This parses, consumes and returns the packet.
 async fn wait_for_server_join_game(
    client: &Client,
+    client_info: &ClientInfo,
    outbound: &mut TcpStream,
    buf: &mut BytesMut,
-) -> Result<JoinGame, ()> {
+) -> Result<JoinGameData, ()> {
    time::timeout(
        SERVER_JOIN_GAME_TIMEOUT,
-        wait_for_server_join_game_no_timeout(client, outbound, buf),
+        wait_for_server_join_game_no_timeout(client, client_info, outbound, buf),
    )
    .await
    .map_err(|_| {
@@ -777,14 +589,15 @@ async fn wait_for_server_join_game(
 // TODO: do not drop error here, return Box<dyn Error>
 async fn wait_for_server_join_game_no_timeout(
    client: &Client,
+    client_info: &ClientInfo,
    outbound: &mut TcpStream,
    buf: &mut BytesMut,
-) -> Result<JoinGame, ()> {
-    let (mut reader, mut writer) = outbound.split();
+) -> Result<JoinGameData, ()> {
+    let (mut reader, mut _writer) = outbound.split();

    loop {
        // Read packet from stream
-        let (packet, _raw) = match proto::read_packet(client, buf, &mut reader).await {
+        let (packet, _raw) = match packet::read_packet(client, buf, &mut reader).await {
            Ok(Some(packet)) => packet,
            Ok(None) => break,
            Err(_) => {
@@ -794,25 +607,22 @@ async fn wait_for_server_join_game_no_timeout(
        };

        // Catch join game
-        if packet.id == proto::packets::play::CLIENT_JOIN_GAME {
-            let join_game = JoinGame::decode(&mut packet.data.as_slice()).map_err(|err| {
-                dbg!(err);
+        if packets::play::join_game::is_packet(client_info, packet.id) {
+            // Parse join game data
+            let join_game_data = JoinGameData::from_packet(client_info, packet).map_err(|err| {
+                warn!(target: "lazymc::lobby", "Failed to parse join game packet: {:?}", err);
            })?;

-            return Ok(join_game);
+            return Ok(join_game_data);
        }

        // Show unhandled packet warning
-        debug!(target: "lazymc::lobby", "Received unhandled packet from server in wait_for_server_join_game:");
+        debug!(target: "lazymc::lobby", "Got unhandled packet from server in wait_for_server_join_game:");
        debug!(target: "lazymc::lobby", "- Packet ID: 0x{:02X} ({})", packet.id, packet.id);
    }

    // Gracefully close connection
-    match writer.shutdown().await {
-        Ok(_) => {}
-        Err(err) if err.kind() == io::ErrorKind::NotConnected => {}
-        Err(_) => return Err(()),
-    }
+    net::close_tcp_stream_ref(outbound).await.map_err(|_| ())?;

    Err(())
 }
@@ -852,21 +662,3 @@ async fn drain_stream(reader: &mut ReadHalf<'_>) -> Result<(), ()> {
        }
    }
 }
-
-/// Read NBT CompoundTag from SNBT.
-fn snbt_to_compound_tag(data: &str) -> CompoundTag {
-    use nbt::decode::read_compound_tag;
-    use quartz_nbt::io::{write_nbt, Flavor};
-    use quartz_nbt::snbt;
-
-    // Parse SNBT data
-    let compound = snbt::parse(data).expect("failed to parse SNBT");
-
-    // Encode to binary
-    let mut binary = Vec::new();
-    write_nbt(&mut binary, None, &compound, Flavor::Uncompressed)
-        .expect("failed to encode NBT CompoundTag as binary");
-
-    // Parse binary with usable NBT create
-    read_compound_tag(&mut &*binary).unwrap()
-}
--- a/src/main.rs
+++ b/src/main.rs
@@ -10,11 +10,15 @@ extern crate log;
 pub(crate) mod action;
 pub(crate) mod cli;
 pub(crate) mod config;
+pub(crate) mod forge;
+pub(crate) mod join;
 #[cfg(feature = "lobby")]
 pub(crate) mod lobby;
 pub(crate) mod mc;
 pub(crate) mod monitor;
+pub(crate) mod net;
 pub(crate) mod os;
+pub(crate) mod probe;
 pub(crate) mod proto;
 pub(crate) mod proxy;
 pub(crate) mod server;
@@ -27,6 +31,10 @@ use std::env;

 use clap::App;

+// Compile time feature compatability check.
+#[cfg(all(windows, not(feature = "rcon")))]
+compile_error!("Must enable \"rcon\" feature on Windows.");
+
 /// Default log level if none is set.
 const LOG_DEFAULT: &str = "info";

--- a/src/mc/ban.rs
+++ b/src/mc/ban.rs
@@ -0,0 +1,99 @@
+use std::collections::HashMap;
+use std::error::Error;
+use std::fs;
+use std::net::IpAddr;
+use std::path::Path;
+
+use chrono::{DateTime, Utc};
+use serde::Deserialize;
+
+/// File name.
+pub const FILE: &str = "banned-ips.json";
+
+/// The forever expiry literal.
+const EXPIRY_FOREVER: &str = "forever";
+
+/// List of banned IPs.
+#[derive(Debug, Default)]
+pub struct BannedIps {
+    /// List of banned IPs.
+    ips: HashMap<IpAddr, BannedIp>,
+}
+
+impl BannedIps {
+    /// Get ban entry if IP if it exists.
+    ///
+    /// This uses the latest known `banned-ips.json` contents if known.
+    /// If this feature is disabled, this will always return false.
+    pub fn get(&self, ip: &IpAddr) -> Option<BannedIp> {
+        self.ips.get(ip).cloned()
+    }
+
+    /// Check whether the given IP is banned.
+    ///
+    /// This uses the latest known `banned-ips.json` contents if known.
+    /// If this feature is disabled, this will always return false.
+    pub fn is_banned(&self, ip: &IpAddr) -> bool {
+        self.ips.get(ip).map(|ip| ip.is_banned()).unwrap_or(false)
+    }
+}
+
+/// A banned IP entry.
+#[derive(Debug, Deserialize, Clone)]
+pub struct BannedIp {
+    /// Banned IP.
+    pub ip: IpAddr,
+
+    /// Ban creation time.
+    pub created: Option<String>,
+
+    /// Ban source.
+    pub source: Option<String>,
+
+    /// Ban expiry time.
+    pub expires: Option<String>,
+
+    /// Ban reason.
+    pub reason: Option<String>,
+}
+
+impl BannedIp {
+    /// Check if this entry is currently banned.
+    pub fn is_banned(&self) -> bool {
+        // Get expiry time
+        let expires = match &self.expires {
+            Some(expires) => expires,
+            None => return true,
+        };
+
+        // If expiry is forever, the user is banned
+        if expires.trim().to_lowercase() == EXPIRY_FOREVER {
+            return true;
+        }
+
+        // Parse expiry time, check if it has passed
+        let expiry = match DateTime::parse_from_str(expires, "%Y-%m-%d %H:%M:%S %z") {
+            Ok(expiry) => expiry,
+            Err(err) => {
+                error!(target: "lazymc", "Failed to parse ban expiry '{}', assuming still banned: {}", expires, err);
+                return true;
+            }
+        };
+
+        expiry > Utc::now()
+    }
+}
+
+/// Load banned IPs from file.
+pub fn load(path: &Path) -> Result<BannedIps, Box<dyn Error>> {
+    // Load file contents
+    let contents = fs::read_to_string(path)?;
+
+    // Parse contents
+    let ips: Vec<BannedIp> = serde_json::from_str(&contents)?;
+    debug!(target: "lazymc", "Loaded {} banned IPs", ips.len());
+
+    // Transform into map
+    let ips = ips.into_iter().map(|ip| (ip.ip, ip)).collect();
+    Ok(BannedIps { ips })
+}
--- a/src/mc/dimension.rs
+++ b/src/mc/dimension.rs
@@ -0,0 +1,112 @@
+use nbt::CompoundTag;
+
+/// Create lobby dimension from the given codec.
+///
+/// This creates a dimension suitable for the lobby that should be suitable for the current server
+/// version.
+pub fn lobby_dimension(codec: &CompoundTag) -> CompoundTag {
+    // Retrieve dimension types from codec
+    let dimension_types = match codec.get_compound_tag("minecraft:dimension_type") {
+        Ok(types) => types,
+        Err(_) => return lobby_default_dimension(),
+    };
+
+    // Get base dimension
+    let mut base = lobby_base_dimension(dimension_types);
+
+    // Change known properties on base to get more desirable dimension
+    base.insert_i8("piglin_safe", 1);
+    base.insert_f32("ambient_light", 0.0);
+    // base.insert_str("infiniburn", "minecraft:infiniburn_end");
+    base.insert_i8("respawn_anchor_works", 0);
+    base.insert_i8("has_skylight", 0);
+    base.insert_i8("bed_works", 0);
+    base.insert_str("effects", "minecraft:the_end");
+    base.insert_i64("fixed_time", 0);
+    base.insert_i8("has_raids", 0);
+    base.insert_i32("min_y", 0);
+    base.insert_i32("height", 16);
+    base.insert_i32("logical_height", 16);
+    base.insert_f64("coordinate_scale", 1.0);
+    base.insert_i8("ultrawarm", 0);
+    base.insert_i8("has_ceiling", 0);
+
+    base
+}
+
+/// Get lobby base dimension.
+///
+/// This retrieves the most desirable dimension to use as base for the lobby from the given list of
+/// `dimension_types`.
+///
+/// If no dimension is found in the given tag, a default one will be returned.
+fn lobby_base_dimension(dimension_types: &CompoundTag) -> CompoundTag {
+    // The dimension types we prefer the most, in order
+    let preferred = vec![
+        "minecraft:the_end",
+        "minecraft:the_nether",
+        "minecraft:the_overworld",
+    ];
+
+    let dimensions = dimension_types.get_compound_tag_vec("value").unwrap();
+
+    for name in preferred {
+        if let Some(dimension) = dimensions
+            .iter()
+            .find(|d| d.get_str("name").map(|n| n == name).unwrap_or(false))
+        {
+            if let Ok(dimension) = dimension.get_compound_tag("element") {
+                return dimension.clone();
+            }
+        }
+    }
+
+    // Return first dimension
+    if let Some(dimension) = dimensions.first() {
+        if let Ok(dimension) = dimension.get_compound_tag("element") {
+            return dimension.clone();
+        }
+    }
+
+    // Fall back to default dimension
+    lobby_default_dimension()
+}
+
+/// Default lobby dimension codec from resource file.
+///
+/// This likely breaks if the Minecraft version doesn't match exactly.
+/// Please use an up-to-date coded from the server instead.
+pub fn default_dimension_codec() -> CompoundTag {
+    snbt_to_compound_tag(include_str!("../../res/dimension_codec.snbt"))
+}
+
+/// Default lobby dimension from resource file.
+///
+/// This likely breaks if the Minecraft version doesn't match exactly.
+/// Please use `lobby_dimension` with an up-to-date coded from the server instead.
+fn lobby_default_dimension() -> CompoundTag {
+    snbt_to_compound_tag(include_str!("../../res/dimension.snbt"))
+}
+
+/// Read NBT CompoundTag from SNBT.
+fn snbt_to_compound_tag(data: &str) -> CompoundTag {
+    use quartz_nbt::io::{write_nbt, Flavor};
+    use quartz_nbt::snbt;
+
+    // Parse SNBT data
+    let compound = snbt::parse(data).expect("failed to parse SNBT");
+
+    // Encode to binary
+    let mut binary = Vec::new();
+    write_nbt(&mut binary, None, &compound, Flavor::Uncompressed)
+        .expect("failed to encode NBT CompoundTag as binary");
+
+    // Parse binary with usable NBT create
+    bin_to_compound_tag(&binary)
+}
+
+/// Read NBT CompoundTag from SNBT.
+fn bin_to_compound_tag(data: &[u8]) -> CompoundTag {
+    use nbt::decode::read_compound_tag;
+    read_compound_tag(&mut &*data).unwrap()
+}
--- a/src/mc/favicon.rs
+++ b/src/mc/favicon.rs
@@ -0,0 +1,26 @@
+use crate::proto::client::ClientInfo;
+
+/// Protocol version since when favicons are supported.
+const FAVICON_PROTOCOL_VERSION: u32 = 4;
+
+/// Get default server status favicon.
+pub fn default_favicon() -> String {
+    encode_favicon(include_bytes!("../../res/unknown_server_optimized.png"))
+}
+
+/// Encode favicon bytes to a string Minecraft can read.
+///
+/// This assumes the favicon data to be a valid PNG image.
+pub fn encode_favicon(data: &[u8]) -> String {
+    format!("{}{}", "data:image/png;base64,", base64::encode(data))
+}
+
+/// Check whether the status response favicon is supported based on the given client info.
+///
+/// Defaults to `true` if unsure.
+pub fn supports_favicon(client_info: &ClientInfo) -> bool {
+    client_info
+        .protocol
+        .map(|p| p >= FAVICON_PROTOCOL_VERSION)
+        .unwrap_or(true)
+}
--- a/src/mc/mod.rs
+++ b/src/mc/mod.rs
@@ -1,6 +1,12 @@
+pub mod ban;
+#[cfg(feature = "lobby")]
+pub mod dimension;
+pub mod favicon;
 #[cfg(feature = "rcon")]
 pub mod rcon;
 pub mod server_properties;
+#[cfg(feature = "lobby")]
+pub mod uuid;

 /// Minecraft ticks per second.
 #[allow(unused)]
--- a/src/mc/rcon.rs
+++ b/src/mc/rcon.rs
@@ -1,8 +1,13 @@
 use std::time::Duration;

+use async_std::net::TcpStream;
+use async_std::prelude::*;
 use rust_rcon::{Connection, Error as RconError};
 use tokio::time;

+use crate::config::Config;
+use crate::proxy;
+
 /// Minecraft RCON quirk.
 ///
 /// Wait this time between RCON operations.
@@ -17,16 +22,39 @@ pub struct Rcon {

 impl Rcon {
    /// Connect to a host.
-    pub async fn connect(addr: &str, pass: &str) -> Result<Self, Box<dyn std::error::Error>> {
+    pub async fn connect(
+        config: &Config,
+        addr: &str,
+        pass: &str,
+    ) -> Result<Self, Box<dyn std::error::Error>> {
+        // Connect to our TCP stream
+        let mut stream = TcpStream::connect(addr).await?;
+
+        // Add proxy header
+        if config.rcon.send_proxy_v2 {
+            trace!(target: "lazymc::rcon", "Sending local proxy header for RCON connection");
+            stream.write_all(&proxy::local_proxy_header()?).await?;
+        }
+
        // Start connection
        let con = Connection::builder()
            .enable_minecraft_quirks(true)
-            .connect(addr, pass)
+            .connect_stream(stream, pass)
            .await?;

        Ok(Self { con })
    }

+    /// Connect to a host from the given configuration.
+    pub async fn connect_config(config: &Config) -> Result<Self, Box<dyn std::error::Error>> {
+        // RCON address
+        let mut addr = config.server.address;
+        addr.set_port(config.rcon.port);
+        let addr = addr.to_string();
+
+        Self::connect(config, &addr, &config.rcon.password).await
+    }
+
    /// Send command over RCON.
    pub async fn cmd(&mut self, cmd: &str) -> Result<String, RconError> {
        // Minecraft quirk
--- a/src/mc/server_properties.rs
+++ b/src/mc/server_properties.rs
@@ -11,39 +11,39 @@ const EOL: &str = "\r\n";
 /// Try to rewrite changes in server.properties file in dir.
 ///
 /// Prints an error and stops on failure.
-pub fn rewrite_dir(dir: &Path, changes: HashMap<&str, String>) {
+pub fn rewrite_dir<P: AsRef<Path>>(dir: P, changes: HashMap<&str, String>) {
    if changes.is_empty() {
        return;
    }

    // Ensure directory exists
-    if !dir.is_dir() {
+    if !dir.as_ref().is_dir() {
        warn!(target: "lazymc",
            "Not rewriting {} file, configured server directory doesn't exist: {}",
            FILE,
-            dir.to_str().unwrap_or("?")
+            dir.as_ref().to_str().unwrap_or("?")
        );
        return;
    }

    // Rewrite file
-    rewrite_file(&dir.join(FILE), changes)
+    rewrite_file(dir.as_ref().join(FILE), changes)
 }

 /// Try to rewrite changes in server.properties file.
 ///
 /// Prints an error and stops on failure.
-pub fn rewrite_file(file: &Path, changes: HashMap<&str, String>) {
+pub fn rewrite_file<P: AsRef<Path>>(file: P, changes: HashMap<&str, String>) {
    if changes.is_empty() {
        return;
    }

    // File must exist
-    if !file.is_file() {
+    if !file.as_ref().is_file() {
        warn!(target: "lazymc",
            "Not writing {} file, not found at: {}",
            FILE,
-            file.to_str().unwrap_or("?"),
+            file.as_ref().to_str().unwrap_or("?"),
        );
        return;
    }
--- a/src/mc/uuid.rs
+++ b/src/mc/uuid.rs
@@ -0,0 +1,33 @@
+use md5::{Digest, Md5};
+use uuid::Uuid;
+
+/// Offline player namespace.
+const OFFLINE_PLAYER_NAMESPACE: &str = "OfflinePlayer:";
+
+/// Get UUID for given player username.
+fn player_uuid(username: &str) -> Uuid {
+    java_name_uuid_from_bytes(username.as_bytes())
+}
+
+/// Get UUID for given offline player username.
+pub fn offline_player_uuid(username: &str) -> Uuid {
+    player_uuid(&format!("{}{}", OFFLINE_PLAYER_NAMESPACE, username))
+}
+
+/// Java's `UUID.nameUUIDFromBytes`
+///
+/// Static factory to retrieve a type 3 (name based) `Uuid` based on the specified byte array.
+///
+/// Ported from: https://git.io/J1b6A
+fn java_name_uuid_from_bytes(data: &[u8]) -> Uuid {
+    let mut hasher = Md5::new();
+    hasher.update(data);
+    let mut md5: [u8; 16] = hasher.finalize().into();
+
+    md5[6] &= 0x0f; // clear version
+    md5[6] |= 0x30; // set to version 3
+    md5[8] &= 0x3f; // clear variant
+    md5[8] |= 0x80; // set to IETF variant
+
+    Uuid::from_bytes(md5)
+}
--- a/src/monitor.rs
+++ b/src/monitor.rs
@@ -1,5 +1,3 @@
-// TODO: remove all unwraps/expects here!
-
 use std::net::SocketAddr;
 use std::sync::Arc;
 use std::time::Duration;
@@ -7,16 +5,19 @@ use std::time::Duration;
 use bytes::BytesMut;
 use minecraft_protocol::data::server_status::ServerStatus;
 use minecraft_protocol::decoder::Decoder;
-use minecraft_protocol::encoder::Encoder;
 use minecraft_protocol::version::v1_14_4::handshake::Handshake;
-use minecraft_protocol::version::v1_14_4::status::{PingRequest, PingResponse, StatusResponse};
+use minecraft_protocol::version::v1_14_4::status::{
+    PingRequest, PingResponse, StatusRequest, StatusResponse,
+};
 use rand::Rng;
 use tokio::io::AsyncWriteExt;
 use tokio::net::TcpStream;
 use tokio::time;

 use crate::config::Config;
-use crate::proto::{self, Client, ClientState, RawPacket};
+use crate::proto::client::{Client, ClientState};
+use crate::proto::{packet, packets};
+use crate::proxy;
 use crate::server::{Server, State};

 /// Monitor ping inverval in seconds.
@@ -26,7 +27,7 @@ const MONITOR_POLL_INTERVAL: Duration = Duration::from_secs(2);
 const STATUS_TIMEOUT: u64 = 20;

 /// Ping request timeout in seconds.
-const PING_TIMEOUT: u64 = 20;
+const PING_TIMEOUT: u64 = 10;

 /// Monitor server.
 pub async fn monitor_server(config: Arc<Config>, server: Arc<Server>) {
@@ -86,6 +87,7 @@ pub async fn poll_server(

    // Try ping fallback if server is currently started
    if server.state() == State::Started {
+        debug!(target: "lazymc::monitor", "Failed to get status from started server, trying ping...");
        do_ping(config, addr).await?;
    }

@@ -96,8 +98,17 @@ pub async fn poll_server(
 async fn fetch_status(config: &Config, addr: SocketAddr) -> Result<ServerStatus, ()> {
    let mut stream = TcpStream::connect(addr).await.map_err(|_| ())?;

+    // Add proxy header
+    if config.server.send_proxy_v2 {
+        trace!(target: "lazymc::monitor", "Sending local proxy header for server connection");
+        stream
+            .write_all(&proxy::local_proxy_header().map_err(|_| ())?)
+            .await
+            .map_err(|_| ())?;
+    }
+
    // Dummy client
-    let client = Client::default();
+    let client = Client::dummy();

    send_handshake(&client, &mut stream, config, addr).await?;
    request_status(&client, &mut stream).await?;
@@ -108,8 +119,17 @@ async fn fetch_status(config: &Config, addr: SocketAddr) -> Result<ServerStatus,
 async fn do_ping(config: &Config, addr: SocketAddr) -> Result<(), ()> {
    let mut stream = TcpStream::connect(addr).await.map_err(|_| ())?;

+    // Add proxy header
+    if config.server.send_proxy_v2 {
+        trace!(target: "lazymc::monitor", "Sending local proxy header for server connection");
+        stream
+            .write_all(&proxy::local_proxy_header().map_err(|_| ())?)
+            .await
+            .map_err(|_| ())?;
+    }
+
    // Dummy client
-    let client = Client::default();
+    let client = Client::dummy();

    send_handshake(&client, &mut stream, config, addr).await?;
    let token = send_ping(&client, &mut stream).await?;
@@ -123,45 +143,28 @@ async fn send_handshake(
    config: &Config,
    addr: SocketAddr,
 ) -> Result<(), ()> {
-    let handshake = Handshake {
-        protocol_version: config.public.protocol as i32,
-        server_addr: addr.ip().to_string(),
-        server_port: addr.port(),
-        next_state: ClientState::Status.to_id(),
-    };
-
-    let mut packet = Vec::new();
-    handshake.encode(&mut packet).map_err(|_| ())?;
-
-    let raw = RawPacket::new(proto::packets::handshake::SERVER_HANDSHAKE, packet)
-        .encode(client)
-        .map_err(|_| ())?;
-    stream.write_all(&raw).await.map_err(|_| ())?;
-
-    Ok(())
+    packet::write_packet(
+        Handshake {
+            protocol_version: config.public.protocol as i32,
+            server_addr: addr.ip().to_string(),
+            server_port: addr.port(),
+            next_state: ClientState::Status.to_id(),
+        },
+        client,
+        &mut stream.split().1,
+    )
+    .await
 }

 /// Send status request.
 async fn request_status(client: &Client, stream: &mut TcpStream) -> Result<(), ()> {
-    let raw = RawPacket::new(proto::packets::status::SERVER_STATUS, vec![])
-        .encode(client)
-        .map_err(|_| ())?;
-    stream.write_all(&raw).await.map_err(|_| ())?;
-    Ok(())
+    packet::write_packet(StatusRequest {}, client, &mut stream.split().1).await
 }

 /// Send status request.
 async fn send_ping(client: &Client, stream: &mut TcpStream) -> Result<u64, ()> {
    let token = rand::thread_rng().gen();
-    let ping = PingRequest { time: token };
-
-    let mut packet = Vec::new();
-    ping.encode(&mut packet).map_err(|_| ())?;
-
-    let raw = RawPacket::new(proto::packets::status::SERVER_PING, packet)
-        .encode(client)
-        .map_err(|_| ())?;
-    stream.write_all(&raw).await.map_err(|_| ())?;
+    packet::write_packet(PingRequest { time: token }, client, &mut stream.split().1).await?;
    Ok(token)
 }

@@ -173,14 +176,14 @@ async fn wait_for_status(client: &Client, stream: &mut TcpStream) -> Result<Serv

    loop {
        // Read packet from stream
-        let (packet, _raw) = match proto::read_packet(client, &mut buf, &mut reader).await {
+        let (packet, _raw) = match packet::read_packet(client, &mut buf, &mut reader).await {
            Ok(Some(packet)) => packet,
            Ok(None) => break,
            Err(_) => continue,
        };

        // Catch status response
-        if packet.id == proto::packets::status::CLIENT_STATUS {
+        if packet.id == packets::status::CLIENT_STATUS {
            let status = StatusResponse::decode(&mut packet.data.as_slice()).map_err(|_| ())?;
            return Ok(status.server_status);
        }
@@ -209,14 +212,14 @@ async fn wait_for_ping(client: &Client, stream: &mut TcpStream, token: u64) -> R

    loop {
        // Read packet from stream
-        let (packet, _raw) = match proto::read_packet(client, &mut buf, &mut reader).await {
+        let (packet, _raw) = match packet::read_packet(client, &mut buf, &mut reader).await {
            Ok(Some(packet)) => packet,
            Ok(None) => break,
            Err(_) => continue,
        };

        // Catch ping response
-        if packet.id == proto::packets::status::CLIENT_PING {
+        if packet.id == packets::status::CLIENT_PING {
            let ping = PingResponse::decode(&mut packet.data.as_slice()).map_err(|_| ())?;

            // Ping token must match
--- a/src/net.rs
+++ b/src/net.rs
@@ -0,0 +1,22 @@
+use std::error::Error;
+use std::io;
+use tokio::io::AsyncWriteExt;
+use tokio::net::TcpStream;
+
+/// Gracefully close given TCP stream.
+///
+/// Intended as helper to make code less messy. This also succeeds if already closed.
+pub async fn close_tcp_stream(mut stream: TcpStream) -> Result<(), Box<dyn Error>> {
+    close_tcp_stream_ref(&mut stream).await
+}
+
+/// Gracefully close given TCP stream.
+///
+/// Intended as helper to make code less messy. This also succeeds if already closed.
+pub async fn close_tcp_stream_ref(stream: &mut TcpStream) -> Result<(), Box<dyn Error>> {
+    match stream.shutdown().await {
+        Ok(_) => Ok(()),
+        Err(err) if err.kind() == io::ErrorKind::NotConnected => Ok(()),
+        Err(err) => Err(err.into()),
+    }
+}
--- a/src/probe.rs
+++ b/src/probe.rs
@@ -0,0 +1,366 @@
+use std::ops::Deref;
+use std::sync::Arc;
+use std::time::Duration;
+
+use bytes::BytesMut;
+use minecraft_protocol::decoder::Decoder;
+use minecraft_protocol::version::v1_14_4::handshake::Handshake;
+use minecraft_protocol::version::v1_14_4::login::{
+    LoginPluginRequest, LoginPluginResponse, LoginStart, SetCompression,
+};
+use tokio::net::TcpStream;
+use tokio::time;
+
+use crate::config::Config;
+use crate::forge;
+use crate::net;
+use crate::proto::client::{Client, ClientInfo, ClientState};
+use crate::proto::packets::play::join_game::JoinGameData;
+use crate::proto::{self, packet, packets};
+use crate::server::{Server, State};
+
+/// Minecraft username to use for probing the server.
+const PROBE_USER: &str = "_lazymc_probe";
+
+/// Timeout for probe user connecting to the server.
+const PROBE_CONNECT_TIMEOUT: Duration = Duration::from_secs(30);
+
+/// Maximum time the probe may wait for the server to come online.
+const PROBE_ONLINE_TIMEOUT: Duration = Duration::from_secs(10 * 60);
+
+/// Timeout for receiving join game packet.
+///
+/// When the play state is reached, the server should immeditely respond with a join game packet.
+/// This defines the maximum timeout for waiting on it.
+const PROBE_JOIN_GAME_TIMEOUT: Duration = Duration::from_secs(20);
+
+/// Connect to the Minecraft server and probe useful details from it.
+pub async fn probe(config: Arc<Config>, server: Arc<Server>) -> Result<(), ()> {
+    debug!(target: "lazymc::probe", "Starting server probe...");
+
+    // Start server if not starting already
+    if Server::start(config.clone(), server.clone(), None).await {
+        info!(target: "lazymc::probe", "Starting server to probe...");
+    }
+
+    // Wait for server to come online
+    if !wait_until_online(&server).await? {
+        warn!(target: "lazymc::probe", "Couldn't probe server, failed to wait for server to come online");
+        return Err(());
+    }
+
+    debug!(target: "lazymc::probe", "Connecting to server to probe details...");
+
+    // Connect to server, record Forge payload
+    let forge_payload = connect_to_server(&config, &server).await?;
+    *server.forge_payload.write().await = forge_payload;
+
+    Ok(())
+}
+
+/// Wait for the server to come online.
+///
+/// Returns `true` when it is online.
+async fn wait_until_online<'a>(server: &Server) -> Result<bool, ()> {
+    trace!(target: "lazymc::probe", "Waiting for server to come online...");
+
+    // A task to wait for suitable server state
+    // Waits for started state, errors if stopping/stopped state is reached
+    let task_wait = async {
+        let mut state = server.state_receiver();
+        loop {
+            // Wait for state change
+            state.changed().await.unwrap();
+
+            match state.borrow().deref() {
+                // Still waiting on server start
+                State::Starting => {
+                    continue;
+                }
+
+                // Server started, start relaying and proxy
+                State::Started => {
+                    break true;
+                }
+
+                // Server stopping, this shouldn't happen, skip
+                State::Stopping => {
+                    warn!(target: "lazymc::probe", "Server stopping while trying to probe, skipping");
+                    break false;
+                }
+
+                // Server stopped, this shouldn't happen, skip
+                State::Stopped => {
+                    error!(target: "lazymc::probe", "Server stopped while trying to probe, skipping");
+                    break false;
+                }
+            }
+        }
+    };
+
+    // Wait for server state with timeout
+    match time::timeout(PROBE_ONLINE_TIMEOUT, task_wait).await {
+        Ok(online) => Ok(online),
+
+        // Timeout reached, kick with starting message
+        Err(_) => {
+            warn!(target: "lazymc::probe", "Probe waited for server to come online but timed out after {}s", PROBE_ONLINE_TIMEOUT.as_secs());
+            Ok(false)
+        }
+    }
+}
+
+/// Create connection to the server, with timeout.
+///
+/// This will initialize the connection to the play state. Client details are used.
+///
+/// Returns recorded Forge login payload if any.
+async fn connect_to_server(config: &Config, server: &Server) -> Result<Vec<Vec<u8>>, ()> {
+    time::timeout(
+        PROBE_CONNECT_TIMEOUT,
+        connect_to_server_no_timeout(config, server),
+    )
+    .await
+    .map_err(|_| {
+        error!(target: "lazymc::probe", "Probe tried to connect to server but timed out after {}s", PROBE_CONNECT_TIMEOUT.as_secs());
+    })?
+}
+
+/// Create connection to the server, with no timeout.
+///
+/// This will initialize the connection to the play state. Client details are used.
+///
+/// Returns recorded Forge login payload if any.
+// TODO: clean this up
+async fn connect_to_server_no_timeout(
+    config: &Config,
+    server: &Server,
+) -> Result<Vec<Vec<u8>>, ()> {
+    // Open connection
+    // TODO: on connect fail, ping server and redirect to serve_status if offline
+    let mut outbound = TcpStream::connect(config.server.address)
+        .await
+        .map_err(|_| ())?;
+
+    // Construct temporary server client
+    let tmp_client = match outbound.local_addr() {
+        Ok(addr) => Client::new(addr),
+        Err(_) => Client::dummy(),
+    };
+    tmp_client.set_state(ClientState::Login);
+
+    // Construct client info
+    let mut tmp_client_info = ClientInfo::empty();
+    tmp_client_info.protocol.replace(config.public.protocol);
+
+    let (mut reader, mut writer) = outbound.split();
+
+    // Select server address to use, add magic if Forge
+    let server_addr = if config.server.forge {
+        format!(
+            "{}{}",
+            config.server.address.ip().to_string(),
+            forge::STATUS_MAGIC,
+        )
+    } else {
+        config.server.address.ip().to_string()
+    };
+
+    // Send handshake packet
+    packet::write_packet(
+        Handshake {
+            protocol_version: config.public.protocol as i32,
+            server_addr,
+            server_port: config.server.address.port(),
+            next_state: ClientState::Login.to_id(),
+        },
+        &tmp_client,
+        &mut writer,
+    )
+    .await?;
+
+    // Request login start
+    packet::write_packet(
+        LoginStart {
+            name: PROBE_USER.into(),
+        },
+        &tmp_client,
+        &mut writer,
+    )
+    .await?;
+
+    // Incoming buffer, record Forge plugin request payload
+    let mut buf = BytesMut::new();
+    let mut forge_payload = Vec::new();
+
+    loop {
+        // Read packet from stream
+        let (packet, raw) = match packet::read_packet(&tmp_client, &mut buf, &mut reader).await {
+            Ok(Some(packet)) => packet,
+            Ok(None) => break,
+            Err(_) => {
+                error!(target: "lazymc::forge", "Closing connection, error occurred");
+                break;
+            }
+        };
+
+        // Grab client state
+        let client_state = tmp_client.state();
+
+        // Catch set compression
+        if client_state == ClientState::Login && packet.id == packets::login::CLIENT_SET_COMPRESSION
+        {
+            // Decode compression packet
+            let set_compression =
+                SetCompression::decode(&mut packet.data.as_slice()).map_err(|_| ())?;
+
+            // Client and server compression threshold should match, show warning if not
+            if set_compression.threshold != proto::COMPRESSION_THRESHOLD {
+                error!(
+                    target: "lazymc::forge",
+                    "Compression threshold sent to lobby client does not match threshold from server, this may cause errors (client: {}, server: {})",
+                    proto::COMPRESSION_THRESHOLD,
+                    set_compression.threshold
+                );
+            }
+
+            // Set client compression
+            tmp_client.set_compression(set_compression.threshold);
+            continue;
+        }
+
+        // Catch login plugin request
+        if client_state == ClientState::Login
+            && packet.id == packets::login::CLIENT_LOGIN_PLUGIN_REQUEST
+        {
+            // Decode login plugin request packet
+            let plugin_request = LoginPluginRequest::decode(&mut packet.data.as_slice()).map_err(|err| {
+                error!(target: "lazymc::probe", "Failed to decode login plugin request from server, cannot respond properly: {:?}", err);
+            })?;
+
+            // Handle plugin requests for Forge
+            if config.server.forge {
+                // Record Forge login payload
+                forge_payload.push(raw);
+
+                // Respond to Forge login plugin request
+                forge::respond_login_plugin_request(&tmp_client, plugin_request, &mut writer)
+                    .await?;
+                continue;
+            }
+
+            warn!(target: "lazymc::probe", "Got unexpected login plugin request, responding with error");
+
+            // Respond with plugin response failure
+            packet::write_packet(
+                LoginPluginResponse {
+                    message_id: plugin_request.message_id,
+                    successful: false,
+                    data: vec![],
+                },
+                &tmp_client,
+                &mut writer,
+            )
+            .await?;
+
+            continue;
+        }
+
+        // Hijack login success
+        if client_state == ClientState::Login && packet.id == packets::login::CLIENT_LOGIN_SUCCESS {
+            trace!(target: "lazymc::probe", "Got login success from server connection, change to play mode");
+
+            // Switch to play state
+            tmp_client.set_state(ClientState::Play);
+
+            // Wait to catch join game packet
+            let join_game_data =
+                wait_for_server_join_game(&tmp_client, &tmp_client_info, &mut outbound, &mut buf)
+                    .await?;
+            server
+                .probed_join_game
+                .write()
+                .await
+                .replace(join_game_data);
+
+            // Gracefully close connection
+            let _ = net::close_tcp_stream(outbound).await;
+
+            return Ok(forge_payload);
+        }
+
+        // Show unhandled packet warning
+        debug!(target: "lazymc::forge", "Got unhandled packet from server in connect_to_server:");
+        debug!(target: "lazymc::forge", "- State: {:?}", client_state);
+        debug!(target: "lazymc::forge", "- Packet ID: 0x{:02X} ({})", packet.id, packet.id);
+    }
+
+    // Gracefully close connection
+    net::close_tcp_stream(outbound).await.map_err(|_| ())?;
+
+    Err(())
+}
+
+/// Wait for join game packet on server connection, with timeout.
+///
+/// This parses, consumes and returns the packet.
+async fn wait_for_server_join_game(
+    client: &Client,
+    client_info: &ClientInfo,
+    outbound: &mut TcpStream,
+    buf: &mut BytesMut,
+) -> Result<JoinGameData, ()> {
+    time::timeout(
+        PROBE_JOIN_GAME_TIMEOUT,
+        wait_for_server_join_game_no_timeout(client, client_info, outbound, buf),
+    )
+    .await
+    .map_err(|_| {
+        error!(target: "lazymc::probe", "Waiting for for game data from server for probe client timed out after {}s", PROBE_JOIN_GAME_TIMEOUT.as_secs());
+    })?
+}
+
+/// Wait for join game packet on server connection, with no timeout.
+///
+/// This parses, consumes and returns the packet.
+// TODO: clean this up
+// TODO: do not drop error here, return Box<dyn Error>
+async fn wait_for_server_join_game_no_timeout(
+    client: &Client,
+    client_info: &ClientInfo,
+    outbound: &mut TcpStream,
+    buf: &mut BytesMut,
+) -> Result<JoinGameData, ()> {
+    let (mut reader, mut _writer) = outbound.split();
+
+    loop {
+        // Read packet from stream
+        let (packet, _raw) = match packet::read_packet(client, buf, &mut reader).await {
+            Ok(Some(packet)) => packet,
+            Ok(None) => break,
+            Err(_) => {
+                error!(target: "lazymc::probe", "Closing connection, error occurred");
+                break;
+            }
+        };
+
+        // Catch join game
+        if packets::play::join_game::is_packet(client_info, packet.id) {
+            // Parse join game data
+            let join_game_data = JoinGameData::from_packet(client_info, packet).map_err(|err| {
+                warn!(target: "lazymc::probe", "Failed to parse join game packet: {:?}", err);
+            })?;
+
+            return Ok(join_game_data);
+        }
+
+        // Show unhandled packet warning
+        debug!(target: "lazymc::probe", "Got unhandled packet from server in wait_for_server_join_game:");
+        debug!(target: "lazymc::probe", "- Packet ID: 0x{:02X} ({})", packet.id, packet.id);
+    }
+
+    // Gracefully close connection
+    net::close_tcp_stream_ref(outbound).await.map_err(|_| ())?;
+
+    Err(())
+}
--- a/src/proto.rs
+++ b/src/proto.rs
@@ -1,380 +0,0 @@
-use std::io::prelude::*;
-use std::sync::atomic::{AtomicI32, Ordering};
-use std::sync::Mutex;
-
-use bytes::BytesMut;
-use flate2::read::ZlibDecoder;
-use flate2::write::ZlibEncoder;
-use flate2::Compression;
-use tokio::io;
-use tokio::io::AsyncReadExt;
-use tokio::net::tcp::ReadHalf;
-
-use crate::types;
-
-/// Default minecraft protocol version name.
-///
-/// Just something to default to when real server version isn't known or when no hint is specified
-/// in the configuration.
-///
-/// Should be kept up-to-date with latest supported Minecraft version by lazymc.
-pub const PROTO_DEFAULT_VERSION: &str = "1.17.1";
-
-/// Default minecraft protocol version.
-///
-/// Just something to default to when real server version isn't known or when no hint is specified
-/// in the configuration.
-///
-/// Should be kept up-to-date with latest supported Minecraft version by lazymc.
-pub const PROTO_DEFAULT_PROTOCOL: u32 = 756;
-
-/// Compression threshold to use.
-// TODO: read this from server.properties instead
-pub const COMPRESSION_THRESHOLD: i32 = 256;
-
-/// Default buffer size when reading packets.
-const BUF_SIZE: usize = 8 * 1024;
-
-/// Minecraft protocol packet IDs.
-#[allow(unused)]
-pub mod packets {
-    pub mod handshake {
-        pub const SERVER_HANDSHAKE: i32 = 0;
-    }
-
-    pub mod status {
-        pub const CLIENT_STATUS: i32 = 0;
-        pub const CLIENT_PING: i32 = 1;
-        pub const SERVER_STATUS: i32 = 0;
-        pub const SERVER_PING: i32 = 1;
-    }
-
-    pub mod login {
-        pub const CLIENT_DISCONNECT: i32 = 0x00;
-        pub const CLIENT_LOGIN_SUCCESS: i32 = 0x02;
-        pub const CLIENT_SET_COMPRESSION: i32 = 0x03;
-        pub const SERVER_LOGIN_START: i32 = 0x00;
-    }
-
-    pub mod play {
-        pub const CLIENT_CHAT_MSG: i32 = 0x0F;
-        pub const CLIENT_PLUGIN_MESSAGE: i32 = 0x18;
-        pub const CLIENT_NAMED_SOUND_EFFECT: i32 = 0x19;
-        pub const CLIENT_DISCONNECT: i32 = 0x1A;
-        pub const CLIENT_KEEP_ALIVE: i32 = 0x21;
-        pub const CLIENT_JOIN_GAME: i32 = 0x26;
-        pub const CLIENT_PLAYER_POS_LOOK: i32 = 0x38;
-        pub const CLIENT_RESPAWN: i32 = 0x3D;
-        pub const CLIENT_SPAWN_POS: i32 = 0x4B;
-        pub const CLIENT_SET_TITLE_SUBTITLE: i32 = 0x57;
-        pub const CLIENT_TIME_UPDATE: i32 = 0x58;
-        pub const CLIENT_SET_TITLE_TEXT: i32 = 0x59;
-        pub const CLIENT_SET_TITLE_TIMES: i32 = 0x5A;
-        pub const SERVER_CLIENT_SETTINGS: i32 = 0x05;
-        pub const SERVER_PLUGIN_MESSAGE: i32 = 0x0A;
-        pub const SERVER_PLAYER_POS: i32 = 0x11;
-        pub const SERVER_PLAYER_POS_ROT: i32 = 0x12;
-    }
-}
-
-/// Client state.
-///
-/// Note: this does not keep track of encryption states.
-#[derive(Debug)]
-pub struct Client {
-    /// Current client state.
-    pub state: Mutex<ClientState>,
-
-    /// Compression state.
-    ///
-    /// 0 or positive if enabled, negative if disabled.
-    pub compression: AtomicI32,
-}
-
-impl Client {
-    /// Get client state.
-    pub fn state(&self) -> ClientState {
-        *self.state.lock().unwrap()
-    }
-
-    /// Set client state.
-    pub fn set_state(&self, state: ClientState) {
-        *self.state.lock().unwrap() = state;
-    }
-
-    /// Get compression threshold.
-    pub fn compressed(&self) -> i32 {
-        self.compression.load(Ordering::Relaxed)
-    }
-
-    /// Whether compression is used.
-    pub fn is_compressed(&self) -> bool {
-        self.compressed() >= 0
-    }
-
-    /// Set compression value.
-    #[allow(unused)]
-    pub fn set_compression(&self, threshold: i32) {
-        trace!(target: "lazymc", "Client now uses compression threshold of {}", threshold);
-        self.compression.store(threshold, Ordering::Relaxed);
-    }
-}
-
-impl Default for Client {
-    fn default() -> Self {
-        Self {
-            state: Default::default(),
-            compression: AtomicI32::new(-1),
-        }
-    }
-}
-
-/// Protocol state a client may be in.
-///
-/// Note: this does not include the `play` state, because this is never used anymore when a client
-/// reaches this state.
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub enum ClientState {
-    /// Initial client state.
-    Handshake,
-
-    /// State to query server status.
-    Status,
-
-    /// State to login to server.
-    Login,
-
-    /// State to play on the server.
-    #[allow(unused)]
-    Play,
-}
-
-impl ClientState {
-    /// From state ID.
-    pub fn from_id(id: i32) -> Option<Self> {
-        match id {
-            0 => Some(Self::Handshake),
-            1 => Some(Self::Status),
-            2 => Some(Self::Login),
-            _ => None,
-        }
-    }
-
-    /// Get state ID.
-    pub fn to_id(self) -> i32 {
-        match self {
-            Self::Handshake => 0,
-            Self::Status => 1,
-            Self::Login => 2,
-            Self::Play => -1,
-        }
-    }
-}
-
-impl Default for ClientState {
-    fn default() -> Self {
-        Self::Handshake
-    }
-}
-
-/// Client info, useful during connection handling.
-#[derive(Debug, Default)]
-pub struct ClientInfo {
-    /// Client protocol version.
-    pub protocol_version: Option<i32>,
-
-    /// Client username.
-    pub username: Option<String>,
-}
-
-impl ClientInfo {
-    pub fn empty() -> Self {
-        Self::default()
-    }
-}
-
-/// Raw Minecraft packet.
-///
-/// Having a packet ID and a raw data byte array.
-pub struct RawPacket {
-    /// Packet ID.
-    pub id: i32,
-
-    /// Packet data.
-    pub data: Vec<u8>,
-}
-
-impl RawPacket {
-    /// Construct new raw packet.
-    pub fn new(id: i32, data: Vec<u8>) -> Self {
-        Self { id, data }
-    }
-
-    /// Read packet ID from buffer, use remaining buffer as data.
-    fn read_packet_id_data(mut buf: &[u8]) -> Result<Self, ()> {
-        // Read packet ID, select buf
-        let (read, packet_id) = types::read_var_int(buf)?;
-        buf = &buf[read..];
-
-        Ok(Self::new(packet_id, buf.to_vec()))
-    }
-
-    /// Decode packet from raw buffer.
-    ///
-    /// This decodes both compressed and uncompressed packets based on the client threshold
-    /// preference.
-    pub fn decode(client: &Client, mut buf: &[u8]) -> Result<Self, ()> {
-        // Read length
-        let (read, len) = types::read_var_int(buf)?;
-        buf = &buf[read..][..len as usize];
-
-        // If no compression is used, read remaining packet ID and data
-        if !client.is_compressed() {
-            // Read packet ID and data
-            return Self::read_packet_id_data(buf);
-        }
-
-        // Read data length
-        let (read, data_len) = types::read_var_int(buf)?;
-        buf = &buf[read..];
-
-        // If data length is zero, the rest is not compressed
-        if data_len == 0 {
-            return Self::read_packet_id_data(buf);
-        }
-
-        // Decompress packet ID and data section
-        let mut decompressed = Vec::with_capacity(data_len as usize);
-        ZlibDecoder::new(buf)
-            .read_to_end(&mut decompressed)
-            .map_err(|err| {
-                error!(target: "lazymc", "Packet decompression error: {}", err);
-            })?;
-
-        // Decompressed data must match length
-        if decompressed.len() != data_len as usize {
-            error!(target: "lazymc", "Decompressed packet has different length than expected ({}b != {}b)", decompressed.len(), data_len);
-            return Err(());
-        }
-
-        // Read decompressed packet ID
-        Self::read_packet_id_data(&decompressed)
-    }
-
-    /// Encode packet to raw buffer.
-    ///
-    /// This compresses packets based on the client threshold preference.
-    pub fn encode(&self, client: &Client) -> Result<Vec<u8>, ()> {
-        let threshold = client.compressed();
-        if threshold >= 0 {
-            self.encode_compressed(threshold)
-        } else {
-            self.encode_uncompressed()
-        }
-    }
-
-    /// Encode compressed packet to raw buffer.
-    fn encode_compressed(&self, threshold: i32) -> Result<Vec<u8>, ()> {
-        // Packet payload: packet ID and data buffer
-        let mut payload = types::encode_var_int(self.id)?;
-        payload.extend_from_slice(&self.data);
-
-        // Determine whether to compress, encode data length bytes
-        let data_len = payload.len() as i32;
-        let compress = data_len > threshold;
-        let mut data_len_bytes =
-            types::encode_var_int(if compress { data_len } else { 0 }).unwrap();
-
-        // Compress payload
-        if compress {
-            let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default());
-            encoder.write_all(&payload).map_err(|err| {
-                error!(target: "lazymc", "Failed to compress packet: {}", err);
-            })?;
-            payload = encoder.finish().map_err(|err| {
-                error!(target: "lazymc", "Failed to compress packet: {}", err);
-            })?;
-        }
-
-        // Encapsulate payload with packet and data length
-        let len = data_len_bytes.len() as i32 + payload.len() as i32;
-        let mut packet = types::encode_var_int(len)?;
-        packet.append(&mut data_len_bytes);
-        packet.append(&mut payload);
-
-        Ok(packet)
-    }
-
-    /// Encode uncompressed packet to raw buffer.
-    fn encode_uncompressed(&self) -> Result<Vec<u8>, ()> {
-        let mut data = types::encode_var_int(self.id)?;
-        data.extend_from_slice(&self.data);
-
-        let len = data.len() as i32;
-        let mut packet = types::encode_var_int(len)?;
-        packet.append(&mut data);
-
-        Ok(packet)
-    }
-}
-
-/// Read raw packet from stream.
-pub async fn read_packet(
-    client: &Client,
-    buf: &mut BytesMut,
-    stream: &mut ReadHalf<'_>,
-) -> Result<Option<(RawPacket, Vec<u8>)>, ()> {
-    // Keep reading until we have at least 2 bytes
-    while buf.len() < 2 {
-        // Read packet from socket
-        let mut tmp = Vec::with_capacity(BUF_SIZE);
-        match stream.read_buf(&mut tmp).await {
-            Ok(_) => {}
-            Err(err) if err.kind() == io::ErrorKind::ConnectionReset => return Ok(None),
-            Err(err) => {
-                dbg!(err);
-                return Err(());
-            }
-        }
-
-        if tmp.is_empty() {
-            return Ok(None);
-        }
-        buf.extend(tmp);
-    }
-
-    // Attempt to read packet length
-    let (consumed, len) = match types::read_var_int(buf) {
-        Ok(result) => result,
-        Err(err) => {
-            error!(target: "lazymc", "Malformed packet, could not read packet length");
-            return Err(err);
-        }
-    };
-
-    // Keep reading until we have all packet bytes
-    while buf.len() < consumed + len as usize {
-        // Read packet from socket
-        let mut tmp = Vec::with_capacity(BUF_SIZE);
-        match stream.read_buf(&mut tmp).await {
-            Ok(_) => {}
-            Err(err) if err.kind() == io::ErrorKind::ConnectionReset => return Ok(None),
-            Err(err) => {
-                dbg!(err);
-                return Err(());
-            }
-        }
-
-        if tmp.is_empty() {
-            return Ok(None);
-        }
-
-        buf.extend(tmp);
-    }
-
-    // Parse packet, use full buffer since we'll read the packet length again
-    let raw = buf.split_to(consumed + len as usize);
-    let packet = RawPacket::decode(client, &raw)?;
-
-    Ok(Some((packet, raw.to_vec())))
-}
--- a/src/proto/action.rs
+++ b/src/proto/action.rs
@@ -0,0 +1,36 @@
+use minecraft_protocol::data::chat::{Message, Payload};
+use minecraft_protocol::version::v1_14_4::game::GameDisconnect;
+use minecraft_protocol::version::v1_14_4::login::LoginDisconnect;
+use tokio::net::tcp::WriteHalf;
+
+use crate::proto::client::{Client, ClientState};
+use crate::proto::packet;
+
+/// Kick client with a message.
+///
+/// Should close connection afterwards.
+pub async fn kick(client: &Client, msg: &str, writer: &mut WriteHalf<'_>) -> Result<(), ()> {
+    match client.state() {
+        ClientState::Login => {
+            packet::write_packet(
+                LoginDisconnect {
+                    reason: Message::new(Payload::text(msg)),
+                },
+                client,
+                writer,
+            )
+            .await
+        }
+        ClientState::Play => {
+            packet::write_packet(
+                GameDisconnect {
+                    reason: Message::new(Payload::text(msg)),
+                },
+                client,
+                writer,
+            )
+            .await
+        }
+        _ => Err(()),
+    }
+}
--- a/src/proto/client.rs
+++ b/src/proto/client.rs
@@ -0,0 +1,138 @@
+use std::net::SocketAddr;
+use std::sync::atomic::{AtomicI32, Ordering};
+use std::sync::Mutex;
+
+use minecraft_protocol::version::v1_14_4::handshake::Handshake;
+
+/// Client state.
+///
+/// Note: this does not keep track of encryption states.
+#[derive(Debug)]
+pub struct Client {
+    /// Client peer address.
+    pub peer: SocketAddr,
+
+    /// Current client state.
+    pub state: Mutex<ClientState>,
+
+    /// Compression state.
+    ///
+    /// 0 or positive if enabled, negative if disabled.
+    pub compression: AtomicI32,
+}
+
+impl Client {
+    /// Construct new client with given peer address.
+    pub fn new(peer: SocketAddr) -> Self {
+        Self {
+            peer,
+            state: Default::default(),
+            compression: AtomicI32::new(-1),
+        }
+    }
+
+    /// Construct dummy client.
+    pub fn dummy() -> Self {
+        Self::new("0.0.0.0:0".parse().unwrap())
+    }
+
+    /// Get client state.
+    pub fn state(&self) -> ClientState {
+        *self.state.lock().unwrap()
+    }
+
+    /// Set client state.
+    pub fn set_state(&self, state: ClientState) {
+        *self.state.lock().unwrap() = state;
+    }
+
+    /// Get compression threshold.
+    pub fn compressed(&self) -> i32 {
+        self.compression.load(Ordering::Relaxed)
+    }
+
+    /// Whether compression is used.
+    pub fn is_compressed(&self) -> bool {
+        self.compressed() >= 0
+    }
+
+    /// Set compression value.
+    #[allow(unused)]
+    pub fn set_compression(&self, threshold: i32) {
+        trace!(target: "lazymc", "Client now uses compression threshold of {}", threshold);
+        self.compression.store(threshold, Ordering::Relaxed);
+    }
+}
+
+/// Protocol state a client may be in.
+///
+/// Note: this does not include the `play` state, because this is never used anymore when a client
+/// reaches this state.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum ClientState {
+    /// Initial client state.
+    Handshake,
+
+    /// State to query server status.
+    Status,
+
+    /// State to login to server.
+    Login,
+
+    /// State to play on the server.
+    #[allow(unused)]
+    Play,
+}
+
+impl ClientState {
+    /// From state ID.
+    pub fn from_id(id: i32) -> Option<Self> {
+        match id {
+            0 => Some(Self::Handshake),
+            1 => Some(Self::Status),
+            2 => Some(Self::Login),
+            _ => None,
+        }
+    }
+
+    /// Get state ID.
+    pub fn to_id(self) -> i32 {
+        match self {
+            Self::Handshake => 0,
+            Self::Status => 1,
+            Self::Login => 2,
+            Self::Play => -1,
+        }
+    }
+}
+
+impl Default for ClientState {
+    fn default() -> Self {
+        Self::Handshake
+    }
+}
+
+/// Client info, useful during connection handling.
+#[derive(Debug, Clone, Default)]
+pub struct ClientInfo {
+    /// Used protocol version.
+    pub protocol: Option<u32>,
+
+    /// Handshake as received from client.
+    pub handshake: Option<Handshake>,
+
+    /// Client username.
+    pub username: Option<String>,
+}
+
+impl ClientInfo {
+    pub fn empty() -> Self {
+        Self::default()
+    }
+
+    /// Get protocol version.
+    pub fn protocol(&self) -> Option<u32> {
+        self.protocol
+            .or_else(|| self.handshake.as_ref().map(|h| h.protocol_version as u32))
+    }
+}
--- a/src/proto/mod.rs
+++ b/src/proto/mod.rs
@@ -0,0 +1,27 @@
+pub mod action;
+pub mod client;
+pub mod packet;
+pub mod packets;
+
+/// Default minecraft protocol version name.
+///
+/// Just something to default to when real server version isn't known or when no hint is specified
+/// in the configuration.
+///
+/// Should be kept up-to-date with latest supported Minecraft version by lazymc.
+pub const PROTO_DEFAULT_VERSION: &str = "1.17.1";
+
+/// Default minecraft protocol version.
+///
+/// Just something to default to when real server version isn't known or when no hint is specified
+/// in the configuration.
+///
+/// Should be kept up-to-date with latest supported Minecraft version by lazymc.
+pub const PROTO_DEFAULT_PROTOCOL: u32 = 756;
+
+/// Compression threshold to use.
+// TODO: read this from server.properties instead
+pub const COMPRESSION_THRESHOLD: i32 = 256;
+
+/// Default buffer size when reading packets.
+pub(super) const BUF_SIZE: usize = 8 * 1024;
--- a/src/proto/packet.rs
+++ b/src/proto/packet.rs
@@ -0,0 +1,235 @@
+use std::fmt::Debug;
+use std::io::prelude::*;
+
+use bytes::BytesMut;
+use flate2::read::ZlibDecoder;
+use flate2::write::ZlibEncoder;
+use flate2::Compression;
+use minecraft_protocol::encoder::Encoder;
+use minecraft_protocol::version::PacketId;
+use tokio::io;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::tcp::{ReadHalf, WriteHalf};
+
+use crate::proto::client::Client;
+use crate::proto::BUF_SIZE;
+use crate::types;
+
+/// Raw Minecraft packet.
+///
+/// Having a packet ID and a raw data byte array.
+pub struct RawPacket {
+    /// Packet ID.
+    pub id: u8,
+
+    /// Packet data.
+    pub data: Vec<u8>,
+}
+
+impl RawPacket {
+    /// Construct new raw packet.
+    pub fn new(id: u8, data: Vec<u8>) -> Self {
+        Self { id, data }
+    }
+
+    /// Read packet ID from buffer, use remaining buffer as data.
+    fn read_packet_id_data(mut buf: &[u8]) -> Result<Self, ()> {
+        // Read packet ID, select buf
+        let (read, packet_id) = types::read_var_int(buf)?;
+        buf = &buf[read..];
+
+        Ok(Self::new(packet_id as u8, buf.to_vec()))
+    }
+
+    /// Decode packet from raw buffer.
+    ///
+    /// This decodes both compressed and uncompressed packets based on the client threshold
+    /// preference.
+    pub fn decode_with_len(client: &Client, mut buf: &[u8]) -> Result<Self, ()> {
+        // Read length
+        let (read, len) = types::read_var_int(buf)?;
+        buf = &buf[read..][..len as usize];
+
+        // TODO: assert buffer length!
+
+        Self::decode_without_len(client, buf)
+    }
+
+    /// Decode packet from raw buffer without packet length.
+    ///
+    /// This decodes both compressed and uncompressed packets based on the client threshold
+    /// preference.
+    /// The length is given, and not included in the buffer itself.
+    pub fn decode_without_len(client: &Client, mut buf: &[u8]) -> Result<Self, ()> {
+        // If no compression is used, read remaining packet ID and data
+        if !client.is_compressed() {
+            // Read packet ID and data
+            return Self::read_packet_id_data(buf);
+        }
+
+        // Read data length
+        let (read, data_len) = types::read_var_int(buf)?;
+        buf = &buf[read..];
+
+        // If data length is zero, the rest is not compressed
+        if data_len == 0 {
+            return Self::read_packet_id_data(buf);
+        }
+
+        // Decompress packet ID and data section
+        let mut decompressed = Vec::with_capacity(data_len as usize);
+        ZlibDecoder::new(buf)
+            .read_to_end(&mut decompressed)
+            .map_err(|err| {
+                error!(target: "lazymc", "Packet decompression error: {}", err);
+            })?;
+
+        // Decompressed data must match length
+        if decompressed.len() != data_len as usize {
+            error!(target: "lazymc", "Decompressed packet has different length than expected ({}b != {}b)", decompressed.len(), data_len);
+            return Err(());
+        }
+
+        // Read decompressed packet ID
+        Self::read_packet_id_data(&decompressed)
+    }
+
+    /// Encode packet to raw buffer.
+    ///
+    /// This compresses packets based on the client threshold preference.
+    pub fn encode_with_len(&self, client: &Client) -> Result<Vec<u8>, ()> {
+        // Encode packet without length
+        let mut payload = self.encode_without_len(client)?;
+
+        // Add length header
+        let mut packet = types::encode_var_int(payload.len() as i32)?;
+        packet.append(&mut payload);
+        Ok(packet)
+    }
+
+    /// Encode packet to raw buffer without length header.
+    ///
+    /// This compresses packets based on the client threshold preference.
+    pub fn encode_without_len(&self, client: &Client) -> Result<Vec<u8>, ()> {
+        let threshold = client.compressed();
+        if threshold >= 0 {
+            self.encode_compressed(threshold)
+        } else {
+            self.encode_uncompressed()
+        }
+    }
+
+    /// Encode compressed packet to raw buffer.
+    fn encode_compressed(&self, threshold: i32) -> Result<Vec<u8>, ()> {
+        // Packet payload: packet ID and data buffer
+        let mut payload = types::encode_var_int(self.id as i32)?;
+        payload.extend_from_slice(&self.data);
+
+        // Determine whether to compress, encode data length bytes
+        let data_len = payload.len() as i32;
+        let compress = data_len > threshold;
+        let data_len_header = if compress { data_len } else { 0 };
+
+        // Compress payload
+        if compress {
+            let mut encoder = ZlibEncoder::new(Vec::new(), Compression::default());
+            encoder.write_all(&payload).map_err(|err| {
+                error!(target: "lazymc", "Failed to compress packet: {}", err);
+            })?;
+            payload = encoder.finish().map_err(|err| {
+                error!(target: "lazymc", "Failed to compress packet: {}", err);
+            })?;
+        }
+
+        // Add data length header
+        let mut packet = types::encode_var_int(data_len_header).unwrap();
+        packet.append(&mut payload);
+
+        Ok(packet)
+    }
+
+    /// Encode uncompressed packet to raw buffer.
+    fn encode_uncompressed(&self) -> Result<Vec<u8>, ()> {
+        let mut packet = types::encode_var_int(self.id as i32)?;
+        packet.extend_from_slice(&self.data);
+
+        Ok(packet)
+    }
+}
+
+/// Read raw packet from stream.
+pub async fn read_packet(
+    client: &Client,
+    buf: &mut BytesMut,
+    stream: &mut ReadHalf<'_>,
+) -> Result<Option<(RawPacket, Vec<u8>)>, ()> {
+    // Keep reading until we have at least 2 bytes
+    while buf.len() < 2 {
+        // Read packet from socket
+        let mut tmp = Vec::with_capacity(BUF_SIZE);
+        match stream.read_buf(&mut tmp).await {
+            Ok(_) => {}
+            Err(err) if err.kind() == io::ErrorKind::ConnectionReset => return Ok(None),
+            Err(err) => {
+                dbg!(err);
+                return Err(());
+            }
+        }
+
+        if tmp.is_empty() {
+            return Ok(None);
+        }
+        buf.extend(tmp);
+    }
+
+    // Attempt to read packet length
+    let (consumed, len) = match types::read_var_int(buf) {
+        Ok(result) => result,
+        Err(err) => {
+            error!(target: "lazymc", "Malformed packet, could not read packet length");
+            return Err(err);
+        }
+    };
+
+    // Keep reading until we have all packet bytes
+    while buf.len() < consumed + len as usize {
+        // Read packet from socket
+        let mut tmp = Vec::with_capacity(BUF_SIZE);
+        match stream.read_buf(&mut tmp).await {
+            Ok(_) => {}
+            Err(err) if err.kind() == io::ErrorKind::ConnectionReset => return Ok(None),
+            Err(err) => {
+                dbg!(err);
+                return Err(());
+            }
+        }
+
+        if tmp.is_empty() {
+            return Ok(None);
+        }
+
+        buf.extend(tmp);
+    }
+
+    // Parse packet, use full buffer since we'll read the packet length again
+    // TODO: use decode_without_len, strip len from buffer
+    let raw = buf.split_to(consumed + len as usize);
+    let packet = RawPacket::decode_with_len(client, &raw)?;
+
+    Ok(Some((packet, raw.to_vec())))
+}
+
+/// Write packet to stream writer.
+pub async fn write_packet(
+    packet: impl PacketId + Encoder + Debug,
+    client: &Client,
+    writer: &mut WriteHalf<'_>,
+) -> Result<(), ()> {
+    let mut data = Vec::new();
+    packet.encode(&mut data).map_err(|_| ())?;
+
+    let response = RawPacket::new(packet.packet_id(), data).encode_with_len(client)?;
+    writer.write_all(&response).await.map_err(|_| ())?;
+
+    Ok(())
+}
--- a/src/proto/packets/mod.rs
+++ b/src/proto/packets/mod.rs
@@ -0,0 +1,33 @@
+//! Minecraft protocol packet IDs.
+
+pub mod play;
+
+pub mod handshake {
+    use minecraft_protocol::version::v1_14_4::handshake::*;
+
+    pub const SERVER_HANDSHAKE: u8 = Handshake::PACKET_ID;
+}
+
+pub mod status {
+    use minecraft_protocol::version::v1_14_4::status::*;
+
+    pub const CLIENT_STATUS: u8 = StatusResponse::PACKET_ID;
+    pub const CLIENT_PING: u8 = PingResponse::PACKET_ID;
+    pub const SERVER_STATUS: u8 = StatusRequest::PACKET_ID;
+    pub const SERVER_PING: u8 = PingRequest::PACKET_ID;
+}
+
+pub mod login {
+    use minecraft_protocol::version::v1_14_4::login::*;
+
+    #[cfg(feature = "lobby")]
+    pub const CLIENT_DISCONNECT: u8 = LoginDisconnect::PACKET_ID;
+    pub const CLIENT_LOGIN_SUCCESS: u8 = LoginSuccess::PACKET_ID;
+    pub const CLIENT_SET_COMPRESSION: u8 = SetCompression::PACKET_ID;
+    #[cfg(feature = "lobby")]
+    pub const CLIENT_ENCRYPTION_REQUEST: u8 = EncryptionRequest::PACKET_ID;
+    pub const CLIENT_LOGIN_PLUGIN_REQUEST: u8 = LoginPluginRequest::PACKET_ID;
+    pub const SERVER_LOGIN_START: u8 = LoginStart::PACKET_ID;
+    #[cfg(feature = "lobby")]
+    pub const SERVER_LOGIN_PLUGIN_RESPONSE: u8 = LoginPluginResponse::PACKET_ID;
+}
--- a/src/proto/packets/play/join_game.rs
+++ b/src/proto/packets/play/join_game.rs
@@ -0,0 +1,208 @@
+use minecraft_protocol::decoder::Decoder;
+use minecraft_protocol::error::DecodeError;
+use minecraft_protocol::version::{v1_16_3, v1_17};
+use nbt::CompoundTag;
+#[cfg(feature = "lobby")]
+use tokio::net::tcp::WriteHalf;
+
+#[cfg(feature = "lobby")]
+use crate::mc::dimension;
+#[cfg(feature = "lobby")]
+use crate::proto::client::Client;
+use crate::proto::client::ClientInfo;
+#[cfg(feature = "lobby")]
+use crate::proto::packet;
+use crate::proto::packet::RawPacket;
+#[cfg(feature = "lobby")]
+use crate::server::Server;
+
+/// Data extracted from `JoinGame` packet.
+#[derive(Debug, Clone)]
+pub struct JoinGameData {
+    pub hardcore: Option<bool>,
+    pub game_mode: Option<u8>,
+    pub previous_game_mode: Option<u8>,
+    pub world_names: Option<Vec<String>>,
+    pub dimension: Option<CompoundTag>,
+    pub dimension_codec: Option<CompoundTag>,
+    pub world_name: Option<String>,
+    pub hashed_seed: Option<i64>,
+    pub max_players: Option<i32>,
+    pub view_distance: Option<i32>,
+    pub reduced_debug_info: Option<bool>,
+    pub enable_respawn_screen: Option<bool>,
+    pub is_debug: Option<bool>,
+    pub is_flat: Option<bool>,
+}
+
+impl JoinGameData {
+    /// Extract join game data from given packet.
+    pub fn from_packet(client_info: &ClientInfo, packet: RawPacket) -> Result<Self, DecodeError> {
+        match client_info.protocol() {
+            Some(p) if p < v1_17::PROTOCOL => {
+                Ok(v1_16_3::game::JoinGame::decode(&mut packet.data.as_slice())?.into())
+            }
+            _ => Ok(v1_17::game::JoinGame::decode(&mut packet.data.as_slice())?.into()),
+        }
+    }
+}
+
+impl From<v1_16_3::game::JoinGame> for JoinGameData {
+    fn from(join_game: v1_16_3::game::JoinGame) -> Self {
+        Self {
+            hardcore: Some(join_game.hardcore),
+            game_mode: Some(join_game.game_mode),
+            previous_game_mode: Some(join_game.previous_game_mode),
+            world_names: Some(join_game.world_names.clone()),
+            dimension: Some(join_game.dimension),
+            dimension_codec: Some(join_game.dimension_codec),
+            world_name: Some(join_game.world_name),
+            hashed_seed: Some(join_game.hashed_seed),
+            max_players: Some(join_game.max_players),
+            view_distance: Some(join_game.view_distance),
+            reduced_debug_info: Some(join_game.reduced_debug_info),
+            enable_respawn_screen: Some(join_game.enable_respawn_screen),
+            is_debug: Some(join_game.is_debug),
+            is_flat: Some(join_game.is_flat),
+        }
+    }
+}
+
+impl From<v1_17::game::JoinGame> for JoinGameData {
+    fn from(join_game: v1_17::game::JoinGame) -> Self {
+        Self {
+            hardcore: Some(join_game.hardcore),
+            game_mode: Some(join_game.game_mode),
+            previous_game_mode: Some(join_game.previous_game_mode),
+            world_names: Some(join_game.world_names.clone()),
+            dimension: Some(join_game.dimension),
+            dimension_codec: Some(join_game.dimension_codec),
+            world_name: Some(join_game.world_name),
+            hashed_seed: Some(join_game.hashed_seed),
+            max_players: Some(join_game.max_players),
+            view_distance: Some(join_game.view_distance),
+            reduced_debug_info: Some(join_game.reduced_debug_info),
+            enable_respawn_screen: Some(join_game.enable_respawn_screen),
+            is_debug: Some(join_game.is_debug),
+            is_flat: Some(join_game.is_flat),
+        }
+    }
+}
+
+/// Check whether the packet ID matches.
+pub fn is_packet(client_info: &ClientInfo, packet_id: u8) -> bool {
+    match client_info.protocol() {
+        Some(p) if p < v1_17::PROTOCOL => packet_id == v1_16_3::game::JoinGame::PACKET_ID,
+        _ => packet_id == v1_17::game::JoinGame::PACKET_ID,
+    }
+}
+
+/// Send initial join game packet to client for lobby.
+#[cfg(feature = "lobby")]
+pub async fn lobby_send(
+    client: &Client,
+    client_info: &ClientInfo,
+    writer: &mut WriteHalf<'_>,
+    server: &Server,
+) -> Result<(), ()> {
+    let status = server.status().await;
+    let join_game = server.probed_join_game.read().await;
+
+    // Get dimension codec and build lobby dimension
+    let dimension_codec: CompoundTag = if let Some(join_game) = join_game.as_ref() {
+        join_game
+            .dimension_codec
+            .clone()
+            .unwrap_or_else(dimension::default_dimension_codec)
+    } else {
+        dimension::default_dimension_codec()
+    };
+
+    // Get other values from status and probed join game data
+    let dimension: CompoundTag = dimension::lobby_dimension(&dimension_codec);
+    let hardcore = join_game.as_ref().and_then(|p| p.hardcore).unwrap_or(false);
+    let world_names = join_game
+        .as_ref()
+        .and_then(|p| p.world_names.clone())
+        .unwrap_or_else(|| {
+            vec![
+                "minecraft:overworld".into(),
+                "minecraft:the_nether".into(),
+                "minecraft:the_end".into(),
+            ]
+        });
+    let max_players = status
+        .as_ref()
+        .map(|s| s.players.max as i32)
+        .or_else(|| join_game.as_ref().and_then(|p| p.max_players))
+        .unwrap_or(20);
+    let view_distance = join_game
+        .as_ref()
+        .and_then(|p| p.view_distance)
+        .unwrap_or(10);
+    let reduced_debug_info = join_game
+        .as_ref()
+        .and_then(|p| p.reduced_debug_info)
+        .unwrap_or(false);
+    let enable_respawn_screen = join_game
+        .as_ref()
+        .and_then(|p| p.enable_respawn_screen)
+        .unwrap_or(true);
+    let is_debug = join_game.as_ref().and_then(|p| p.is_debug).unwrap_or(false);
+    let is_flat = join_game.as_ref().and_then(|p| p.is_flat).unwrap_or(false);
+
+    match client_info.protocol() {
+        Some(p) if p < v1_17::PROTOCOL => {
+            packet::write_packet(
+                v1_16_3::game::JoinGame {
+                    // Player ID must be unique, if it collides with another server entity ID the player gets
+                    // in a weird state and cannot move
+                    entity_id: 0,
+                    hardcore,
+                    game_mode: 3,
+                    previous_game_mode: -1i8 as u8,
+                    world_names,
+                    dimension_codec,
+                    dimension,
+                    world_name: "lazymc:lobby".into(),
+                    hashed_seed: 0,
+                    max_players,
+                    view_distance,
+                    reduced_debug_info,
+                    enable_respawn_screen,
+                    is_debug,
+                    is_flat,
+                },
+                client,
+                writer,
+            )
+            .await
+        }
+        _ => {
+            packet::write_packet(
+                v1_17::game::JoinGame {
+                    // Player ID must be unique, if it collides with another server entity ID the player gets
+                    // in a weird state and cannot move
+                    entity_id: 0,
+                    hardcore,
+                    game_mode: 3,
+                    previous_game_mode: -1i8 as u8,
+                    world_names,
+                    dimension_codec,
+                    dimension,
+                    world_name: "lazymc:lobby".into(),
+                    hashed_seed: 0,
+                    max_players,
+                    view_distance,
+                    reduced_debug_info,
+                    enable_respawn_screen,
+                    is_debug,
+                    is_flat,
+                },
+                client,
+                writer,
+            )
+            .await
+        }
+    }
+}
--- a/src/proto/packets/play/keep_alive.rs
+++ b/src/proto/packets/play/keep_alive.rs
@@ -0,0 +1,29 @@
+use std::sync::atomic::{AtomicU64, Ordering};
+
+use minecraft_protocol::version::{v1_16_3, v1_17};
+use tokio::net::tcp::WriteHalf;
+
+use crate::proto::client::{Client, ClientInfo};
+use crate::proto::packet;
+
+/// Auto incrementing ID source for keep alive packets.
+static KEEP_ALIVE_ID: AtomicU64 = AtomicU64::new(0);
+
+/// Send keep alive packet to client.
+///
+/// Required periodically in play mode to prevent client timeout.
+pub async fn send(
+    client: &Client,
+    client_info: &ClientInfo,
+    writer: &mut WriteHalf<'_>,
+) -> Result<(), ()> {
+    // Keep sending new IDs
+    let id = KEEP_ALIVE_ID.fetch_add(1, Ordering::Relaxed);
+
+    match client_info.protocol() {
+        Some(p) if p < v1_17::PROTOCOL => {
+            packet::write_packet(v1_16_3::game::ClientBoundKeepAlive { id }, client, writer).await
+        }
+        _ => packet::write_packet(v1_17::game::ClientBoundKeepAlive { id }, client, writer).await,
+    }
+}
--- a/src/proto/packets/play/mod.rs
+++ b/src/proto/packets/play/mod.rs
@@ -0,0 +1,15 @@
+pub mod join_game;
+#[cfg(feature = "lobby")]
+pub mod keep_alive;
+#[cfg(feature = "lobby")]
+pub mod player_pos;
+#[cfg(feature = "lobby")]
+pub mod respawn;
+#[cfg(feature = "lobby")]
+pub mod server_brand;
+#[cfg(feature = "lobby")]
+pub mod sound;
+#[cfg(feature = "lobby")]
+pub mod time_update;
+#[cfg(feature = "lobby")]
+pub mod title;
--- a/src/proto/packets/play/player_pos.rs
+++ b/src/proto/packets/play/player_pos.rs
@@ -0,0 +1,48 @@
+use minecraft_protocol::version::{v1_16_3, v1_17};
+use tokio::net::tcp::WriteHalf;
+
+use crate::proto::client::{Client, ClientInfo};
+use crate::proto::packet;
+
+/// Move player to world origin.
+pub async fn send(
+    client: &Client,
+    client_info: &ClientInfo,
+    writer: &mut WriteHalf<'_>,
+) -> Result<(), ()> {
+    match client_info.protocol() {
+        Some(p) if p < v1_17::PROTOCOL => {
+            packet::write_packet(
+                v1_16_3::game::PlayerPositionAndLook {
+                    x: 0.0,
+                    y: 0.0,
+                    z: 0.0,
+                    yaw: 0.0,
+                    pitch: 90.0,
+                    flags: 0b00000000,
+                    teleport_id: 0,
+                },
+                client,
+                writer,
+            )
+            .await
+        }
+        _ => {
+            packet::write_packet(
+                v1_17::game::PlayerPositionAndLook {
+                    x: 0.0,
+                    y: 0.0,
+                    z: 0.0,
+                    yaw: 0.0,
+                    pitch: 90.0,
+                    flags: 0b00000000,
+                    teleport_id: 0,
+                    dismount_vehicle: true,
+                },
+                client,
+                writer,
+            )
+            .await
+        }
+    }
+}
--- a/src/proto/packets/play/respawn.rs
+++ b/src/proto/packets/play/respawn.rs
@@ -0,0 +1,70 @@
+use minecraft_protocol::version::{v1_16_3, v1_17};
+use tokio::net::tcp::WriteHalf;
+
+use super::join_game::JoinGameData;
+use crate::mc::dimension;
+use crate::proto::client::{Client, ClientInfo};
+use crate::proto::packet;
+
+/// Send respawn packet to client to jump from lobby into now loaded server.
+///
+/// The required details will be fetched from the `join_game` packet as provided by the server.
+pub async fn lobby_send(
+    client: &Client,
+    client_info: &ClientInfo,
+    writer: &mut WriteHalf<'_>,
+    data: JoinGameData,
+) -> Result<(), ()> {
+    match client_info.protocol() {
+        Some(p) if p < v1_17::PROTOCOL => {
+            packet::write_packet(
+                v1_16_3::game::Respawn {
+                    dimension: data.dimension.unwrap_or_else(|| {
+                        dimension::lobby_dimension(
+                            &data
+                                .dimension_codec
+                                .unwrap_or_else(dimension::default_dimension_codec),
+                        )
+                    }),
+                    world_name: data
+                        .world_name
+                        .unwrap_or_else(|| "minecraft:overworld".into()),
+                    hashed_seed: data.hashed_seed.unwrap_or(0),
+                    game_mode: data.game_mode.unwrap_or(0),
+                    previous_game_mode: data.previous_game_mode.unwrap_or(-1i8 as u8),
+                    is_debug: data.is_debug.unwrap_or(false),
+                    is_flat: data.is_flat.unwrap_or(false),
+                    copy_metadata: false,
+                },
+                client,
+                writer,
+            )
+            .await
+        }
+        _ => {
+            packet::write_packet(
+                v1_17::game::Respawn {
+                    dimension: data.dimension.unwrap_or_else(|| {
+                        dimension::lobby_dimension(
+                            &data
+                                .dimension_codec
+                                .unwrap_or_else(dimension::default_dimension_codec),
+                        )
+                    }),
+                    world_name: data
+                        .world_name
+                        .unwrap_or_else(|| "minecraft:overworld".into()),
+                    hashed_seed: data.hashed_seed.unwrap_or(0),
+                    game_mode: data.game_mode.unwrap_or(0),
+                    previous_game_mode: data.previous_game_mode.unwrap_or(-1i8 as u8),
+                    is_debug: data.is_debug.unwrap_or(false),
+                    is_flat: data.is_flat.unwrap_or(false),
+                    copy_metadata: false,
+                },
+                client,
+                writer,
+            )
+            .await
+        }
+    }
+}
--- a/src/proto/packets/play/server_brand.rs
+++ b/src/proto/packets/play/server_brand.rs
@@ -0,0 +1,45 @@
+use minecraft_protocol::version::{v1_16_3, v1_17};
+use tokio::net::tcp::WriteHalf;
+
+use crate::proto::client::{Client, ClientInfo};
+use crate::proto::packet;
+
+/// Minecraft channel to set brand.
+const CHANNEL: &str = "minecraft:brand";
+
+/// Server brand to send to client in lobby world.
+///
+/// Shown in F3 menu. Updated once client is relayed to real server.
+const SERVER_BRAND: &[u8] = b"lazymc";
+
+/// Send lobby brand to client.
+pub async fn send(
+    client: &Client,
+    client_info: &ClientInfo,
+    writer: &mut WriteHalf<'_>,
+) -> Result<(), ()> {
+    match client_info.protocol() {
+        Some(p) if p < v1_17::PROTOCOL => {
+            packet::write_packet(
+                v1_16_3::game::ClientBoundPluginMessage {
+                    channel: CHANNEL.into(),
+                    data: SERVER_BRAND.into(),
+                },
+                client,
+                writer,
+            )
+            .await
+        }
+        _ => {
+            packet::write_packet(
+                v1_17::game::ClientBoundPluginMessage {
+                    channel: CHANNEL.into(),
+                    data: SERVER_BRAND.into(),
+                },
+                client,
+                writer,
+            )
+            .await
+        }
+    }
+}
--- a/src/proto/packets/play/sound.rs
+++ b/src/proto/packets/play/sound.rs
@@ -0,0 +1,48 @@
+use minecraft_protocol::version::{v1_16_3, v1_17};
+use tokio::net::tcp::WriteHalf;
+
+use crate::proto::client::{Client, ClientInfo};
+use crate::proto::packet;
+
+/// Play a sound effect at world origin.
+pub async fn send(
+    client: &Client,
+    client_info: &ClientInfo,
+    writer: &mut WriteHalf<'_>,
+    sound_name: &str,
+) -> Result<(), ()> {
+    match client_info.protocol() {
+        Some(p) if p < v1_17::PROTOCOL => {
+            packet::write_packet(
+                v1_16_3::game::NamedSoundEffect {
+                    sound_name: sound_name.into(),
+                    sound_category: 0,
+                    effect_pos_x: 0,
+                    effect_pos_y: 0,
+                    effect_pos_z: 0,
+                    volume: 1.0,
+                    pitch: 1.0,
+                },
+                client,
+                writer,
+            )
+            .await
+        }
+        _ => {
+            packet::write_packet(
+                v1_17::game::NamedSoundEffect {
+                    sound_name: sound_name.into(),
+                    sound_category: 0,
+                    effect_pos_x: 0,
+                    effect_pos_y: 0,
+                    effect_pos_z: 0,
+                    volume: 1.0,
+                    pitch: 1.0,
+                },
+                client,
+                writer,
+            )
+            .await
+        }
+    }
+}
--- a/src/proto/packets/play/time_update.rs
+++ b/src/proto/packets/play/time_update.rs
@@ -0,0 +1,41 @@
+use minecraft_protocol::version::{v1_16_3, v1_17};
+use tokio::net::tcp::WriteHalf;
+
+use crate::proto::client::{Client, ClientInfo};
+use crate::proto::packet;
+
+/// Send lobby time update to client.
+///
+/// Sets world time to 0.
+///
+/// Required once for keep-alive packets.
+pub async fn send(
+    client: &Client,
+    client_info: &ClientInfo,
+    writer: &mut WriteHalf<'_>,
+) -> Result<(), ()> {
+    match client_info.protocol() {
+        Some(p) if p < v1_17::PROTOCOL => {
+            packet::write_packet(
+                v1_16_3::game::TimeUpdate {
+                    world_age: 0,
+                    time_of_day: 0,
+                },
+                client,
+                writer,
+            )
+            .await
+        }
+        _ => {
+            packet::write_packet(
+                v1_17::game::TimeUpdate {
+                    world_age: 0,
+                    time_of_day: 0,
+                },
+                client,
+                writer,
+            )
+            .await
+        }
+    }
+}
--- a/src/proto/packets/play/title.rs
+++ b/src/proto/packets/play/title.rs
@@ -0,0 +1,141 @@
+use minecraft_protocol::data::chat::{Message, Payload};
+use minecraft_protocol::version::{v1_16_3, v1_17};
+use tokio::net::tcp::WriteHalf;
+
+#[cfg(feature = "lobby")]
+use crate::lobby::KEEP_ALIVE_INTERVAL;
+use crate::mc;
+use crate::proto::client::{Client, ClientInfo};
+use crate::proto::packet;
+
+#[cfg(feature = "lobby")]
+const DISPLAY_TIME: i32 = KEEP_ALIVE_INTERVAL.as_secs() as i32 * mc::TICKS_PER_SECOND as i32 * 2;
+#[cfg(not(feature = "lobby"))]
+const DISPLAY_TIME: i32 = 10 * mc::TICKS_PER_SECOND as i32 * 2;
+
+/// Send lobby title packets to client.
+///
+/// This will show the given text for two keep-alive periods. Use a newline for the subtitle.
+///
+/// If an empty string is given, the title times will be reset to default.
+pub async fn send(
+    client: &Client,
+    client_info: &ClientInfo,
+    writer: &mut WriteHalf<'_>,
+    text: &str,
+) -> Result<(), ()> {
+    // Grab title and subtitle bits
+    let title = text.lines().next().unwrap_or("");
+    let subtitle = text.lines().skip(1).collect::<Vec<_>>().join("\n");
+
+    match client_info.protocol() {
+        Some(p) if p < v1_17::PROTOCOL => send_v1_16_3(client, writer, title, &subtitle).await,
+        _ => send_v1_17(client, writer, title, &subtitle).await,
+    }
+}
+
+async fn send_v1_16_3(
+    client: &Client,
+    writer: &mut WriteHalf<'_>,
+    title: &str,
+    subtitle: &str,
+) -> Result<(), ()> {
+    use v1_16_3::game::{Title, TitleAction};
+
+    // Set title
+    packet::write_packet(
+        Title {
+            action: TitleAction::SetTitle {
+                text: Message::new(Payload::text(title)),
+            },
+        },
+        client,
+        writer,
+    )
+    .await?;
+
+    // Set subtitle
+    packet::write_packet(
+        Title {
+            action: TitleAction::SetSubtitle {
+                text: Message::new(Payload::text(subtitle)),
+            },
+        },
+        client,
+        writer,
+    )
+    .await?;
+
+    // Set title times
+    packet::write_packet(
+        Title {
+            action: if title.is_empty() && subtitle.is_empty() {
+                // Defaults: https://minecraft.fandom.com/wiki/Commands/title#Detail
+                TitleAction::SetTimesAndDisplay {
+                    fade_in: 10,
+                    stay: 70,
+                    fade_out: 20,
+                }
+            } else {
+                TitleAction::SetTimesAndDisplay {
+                    fade_in: 0,
+                    stay: DISPLAY_TIME,
+                    fade_out: 0,
+                }
+            },
+        },
+        client,
+        writer,
+    )
+    .await
+}
+
+async fn send_v1_17(
+    client: &Client,
+    writer: &mut WriteHalf<'_>,
+    title: &str,
+    subtitle: &str,
+) -> Result<(), ()> {
+    use v1_17::game::{SetTitleSubtitle, SetTitleText, SetTitleTimes};
+
+    // Set title
+    packet::write_packet(
+        SetTitleText {
+            text: Message::new(Payload::text(title)),
+        },
+        client,
+        writer,
+    )
+    .await?;
+
+    // Set subtitle
+    packet::write_packet(
+        SetTitleSubtitle {
+            text: Message::new(Payload::text(subtitle)),
+        },
+        client,
+        writer,
+    )
+    .await?;
+
+    // Set title times
+    packet::write_packet(
+        if title.is_empty() && subtitle.is_empty() {
+            // Defaults: https://minecraft.fandom.com/wiki/Commands/title#Detail
+            SetTitleTimes {
+                fade_in: 10,
+                stay: 70,
+                fade_out: 20,
+            }
+        } else {
+            SetTitleTimes {
+                fade_in: 0,
+                stay: DISPLAY_TIME,
+                fade_out: 0,
+            }
+        },
+        client,
+        writer,
+    )
+    .await
+}
--- a/src/proxy.rs
+++ b/src/proxy.rs
@@ -1,13 +1,22 @@
 use std::error::Error;
 use std::net::SocketAddr;

+use bytes::BytesMut;
+use proxy_protocol::version2::{ProxyAddresses, ProxyCommand, ProxyTransportProtocol};
+use proxy_protocol::EncodeError;
 use tokio::io;
 use tokio::io::AsyncWriteExt;
 use tokio::net::TcpStream;

+use crate::net;
+
 /// Proxy the inbound stream to a target address.
-pub async fn proxy(inbound: TcpStream, addr_target: SocketAddr) -> Result<(), Box<dyn Error>> {
-    proxy_with_queue(inbound, addr_target, &[]).await
+pub async fn proxy(
+    inbound: TcpStream,
+    proxy_header: ProxyHeader,
+    addr_target: SocketAddr,
+) -> Result<(), Box<dyn Error>> {
+    proxy_with_queue(inbound, proxy_header, addr_target, &[]).await
 }

 /// Proxy the inbound stream to a target address.
@@ -15,12 +24,26 @@ pub async fn proxy(inbound: TcpStream, addr_target: SocketAddr) -> Result<(), Bo
 /// Send the queue to the target server before proxying.
 pub async fn proxy_with_queue(
    inbound: TcpStream,
+    proxy_header: ProxyHeader,
    addr_target: SocketAddr,
    queue: &[u8],
 ) -> Result<(), Box<dyn Error>> {
    // Set up connection to server
    // TODO: on connect fail, ping server and redirect to serve_status if offline
-    let outbound = TcpStream::connect(addr_target).await?;
+    let mut outbound = TcpStream::connect(addr_target).await?;
+
+    // Add proxy header
+    match proxy_header {
+        ProxyHeader::None => {}
+        ProxyHeader::Local => {
+            let header = local_proxy_header()?;
+            outbound.write_all(&header).await?;
+        }
+        ProxyHeader::Proxy => {
+            let header = stream_proxy_header(&inbound)?;
+            outbound.write_all(&header).await?;
+        }
+    }

    // Start proxy on both streams
    proxy_inbound_outbound_with_queue(inbound, outbound, &[], queue).await
@@ -64,5 +87,81 @@ pub async fn proxy_inbound_outbound_with_queue(

    tokio::try_join!(client_to_server, server_to_client)?;

+    // Gracefully close connection if not done already
+    net::close_tcp_stream(inbound).await?;
+
    Ok(())
 }
+
+/// Proxy header.
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum ProxyHeader {
+    /// Do not add proxy header.
+    None,
+
+    /// Header for locally initiated connection.
+    #[allow(unused)]
+    Local,
+
+    /// Header for proxied connection.
+    Proxy,
+}
+
+impl ProxyHeader {
+    /// Changes to `None` if `false` if given.
+    ///
+    /// `None` stays `None`.
+    pub fn not_none(self, not_none: bool) -> Self {
+        if not_none {
+            self
+        } else {
+            Self::None
+        }
+    }
+}
+
+/// Get the proxy header for a locally initiated connection.
+///
+/// This header may be sent over the outbound stream to signal client information.
+pub fn local_proxy_header() -> Result<BytesMut, EncodeError> {
+    // Build proxy header
+    let header = proxy_protocol::ProxyHeader::Version2 {
+        command: ProxyCommand::Local,
+        transport_protocol: ProxyTransportProtocol::Stream,
+        addresses: ProxyAddresses::Unspec,
+    };
+
+    proxy_protocol::encode(header)
+}
+
+/// Get the proxy header for the given inbound stream.
+///
+/// This header may be sent over the outbound stream to signal client information.
+pub fn stream_proxy_header(inbound: &TcpStream) -> Result<BytesMut, EncodeError> {
+    // Get peer and local address
+    let peer = inbound
+        .peer_addr()
+        .expect("Peer address not known for TCP stream");
+    let local = inbound
+        .local_addr()
+        .expect("Local address not known for TCP stream");
+
+    // Build proxy header
+    let header = proxy_protocol::ProxyHeader::Version2 {
+        command: ProxyCommand::Proxy,
+        transport_protocol: ProxyTransportProtocol::Stream,
+        addresses: match (peer, local) {
+            (SocketAddr::V4(source), SocketAddr::V4(destination)) => ProxyAddresses::Ipv4 {
+                source,
+                destination,
+            },
+            (SocketAddr::V6(source), SocketAddr::V6(destination)) => ProxyAddresses::Ipv6 {
+                source,
+                destination,
+            },
+            (_, _) => unreachable!(),
+        },
+    };
+
+    proxy_protocol::encode(header)
+}
--- a/src/server.rs
+++ b/src/server.rs
@@ -1,3 +1,4 @@
+use std::net::IpAddr;
 use std::sync::atomic::{AtomicU8, Ordering};
 use std::sync::Arc;
 use std::time::{Duration, Instant};
@@ -11,8 +12,10 @@ use tokio::sync::Semaphore;
 use tokio::sync::{Mutex, RwLock, RwLockReadGuard};
 use tokio::time;

-use crate::config::Config;
+use crate::config::{Config, Server as ConfigServer};
+use crate::mc::ban::{BannedIp, BannedIps};
 use crate::os;
+use crate::proto::packets::play::join_game::JoinGameData;

 /// Server cooldown after the process quit.
 /// Used to give it some more time to quit forgotten threads, such as for RCON.
@@ -25,44 +28,9 @@ const SERVER_QUIT_COOLDOWN: Duration = Duration::from_millis(2500);
 #[cfg(feature = "rcon")]
 const RCON_COOLDOWN: Duration = Duration::from_secs(15);

-/// Server state.
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub enum State {
-    /// Server is stopped.
-    Stopped,
-
-    /// Server is starting.
-    Starting,
-
-    /// Server is online and responding.
-    Started,
-
-    /// Server is stopping.
-    Stopping,
-}
-
-impl State {
-    /// From u8, panics if invalid.
-    pub fn from_u8(state: u8) -> Self {
-        match state {
-            0 => Self::Stopped,
-            1 => Self::Starting,
-            2 => Self::Started,
-            3 => Self::Stopping,
-            _ => panic!("invalid State u8"),
-        }
-    }
-
-    /// To u8.
-    pub fn to_u8(self) -> u8 {
-        match self {
-            Self::Stopped => 0,
-            Self::Starting => 1,
-            Self::Started => 2,
-            Self::Stopping => 3,
-        }
-    }
-}
+/// Exit code when SIGTERM is received on Unix.
+#[cfg(unix)]
+const UNIX_EXIT_SIGTERM: i32 = 130;

 /// Shared server state.
 #[derive(Debug)]
@@ -102,6 +70,9 @@ pub struct Server {
    /// Used as starting/stopping timeout.
    kill_at: RwLock<Option<Instant>>,

+    /// List of banned IPs.
+    banned_ips: RwLock<BannedIps>,
+
    /// Lock for exclusive RCON operations.
    #[cfg(feature = "rcon")]
    rcon_lock: Semaphore,
@@ -109,6 +80,14 @@ pub struct Server {
    /// Last time server was stopped over RCON.
    #[cfg(feature = "rcon")]
    rcon_last_stop: Mutex<Option<Instant>>,
+
+    /// Probed join game data.
+    pub probed_join_game: RwLock<Option<JoinGameData>>,
+
+    /// Forge payload.
+    ///
+    /// Sent to clients when they connect to lobby. Recorded from server by probe.
+    pub forge_payload: RwLock<Vec<Vec<u8>>>,
 }

 impl Server {
@@ -345,6 +324,37 @@ impl Server {
            .filter(|d| *d > 0)
            .map(|d| Instant::now() + Duration::from_secs(d as u64));
    }
+
+    /// Check whether the given IP is banned.
+    ///
+    /// This uses the latest known `banned-ips.json` contents if known.
+    /// If this feature is disabled, this will always return false.
+    pub async fn is_banned_ip(&self, ip: &IpAddr) -> bool {
+        self.banned_ips.read().await.is_banned(ip)
+    }
+
+    /// Get user ban entry.
+    pub async fn ban_entry(&self, ip: &IpAddr) -> Option<BannedIp> {
+        self.banned_ips.read().await.get(ip)
+    }
+
+    /// Check whether the given IP is banned.
+    ///
+    /// This uses the latest known `banned-ips.json` contents if known.
+    /// If this feature is disabled, this will always return false.
+    pub fn is_banned_ip_blocking(&self, ip: &IpAddr) -> bool {
+        futures::executor::block_on(async { self.is_banned_ip(ip).await })
+    }
+
+    /// Update the list of banned IPs.
+    pub async fn set_banned_ips(&self, ips: BannedIps) {
+        *self.banned_ips.write().await = ips;
+    }
+
+    /// Update the list of banned IPs.
+    pub fn set_banned_ips_blocking(&self, ips: BannedIps) {
+        futures::executor::block_on(async { self.set_banned_ips(ips).await })
+    }
 }

 impl Default for Server {
@@ -360,10 +370,52 @@ impl Default for Server {
            last_active: Default::default(),
            keep_online_until: Default::default(),
            kill_at: Default::default(),
+            banned_ips: Default::default(),
            #[cfg(feature = "rcon")]
            rcon_lock: Semaphore::new(1),
            #[cfg(feature = "rcon")]
            rcon_last_stop: Default::default(),
+            probed_join_game: Default::default(),
+            forge_payload: Default::default(),
+        }
+    }
+}
+
+/// Server state.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum State {
+    /// Server is stopped.
+    Stopped,
+
+    /// Server is starting.
+    Starting,
+
+    /// Server is online and responding.
+    Started,
+
+    /// Server is stopping.
+    Stopping,
+}
+
+impl State {
+    /// From u8, panics if invalid.
+    pub fn from_u8(state: u8) -> Self {
+        match state {
+            0 => Self::Stopped,
+            1 => Self::Starting,
+            2 => Self::Started,
+            3 => Self::Stopping,
+            _ => panic!("invalid State u8"),
+        }
+    }
+
+    /// To u8.
+    pub fn to_u8(self) -> u8 {
+        match self {
+            Self::Stopped => 0,
+            Self::Starting => 1,
+            Self::Started => 2,
+            Self::Stopping => 3,
        }
    }
 }
@@ -380,7 +432,7 @@ pub async fn invoke_server_cmd(
    cmd.kill_on_drop(true);

    // Set working directory
-    if let Some(ref dir) = config.server.directory {
+    if let Some(ref dir) = ConfigServer::server_directory(&config) {
        cmd.current_dir(dir);
    }

@@ -406,6 +458,11 @@ pub async fn invoke_server_cmd(
            debug!(target: "lazymc", "Server process stopped successfully ({})", status);
            false
        }
+        #[cfg(unix)]
+        Ok(status) if status.code() == Some(UNIX_EXIT_SIGTERM) => {
+            debug!(target: "lazymc", "Server process stopped successfully by SIGTERM ({})", status);
+            false
+        }
        Ok(status) => {
            warn!(target: "lazymc", "Server process stopped with error code ({})", status);
            state.state() == State::Started
@@ -461,13 +518,8 @@ async fn stop_server_rcon(config: &Config, server: &Server) -> bool {
        return false;
    }

-    // RCON address
-    let mut addr = config.server.address;
-    addr.set_port(config.rcon.port);
-    let addr = addr.to_string();
-
    // Create RCON client
-    let mut rcon = match Rcon::connect(&addr, &config.rcon.password).await {
+    let mut rcon = match Rcon::connect_config(config).await {
        Ok(rcon) => rcon,
        Err(err) => {
            error!(target: "lazymc", "Failed to RCON server to sleep: {}", err);
@@ -485,11 +537,11 @@ async fn stop_server_rcon(config: &Config, server: &Server) -> bool {
    server.rcon_last_stop.lock().await.replace(Instant::now());
    server.update_state(State::Stopping, config).await;

-    drop(rcon_lock);
-
    // Gracefully close connection
    rcon.close().await;

+    drop(rcon_lock);
+
    true
 }

--- a/src/service/ban_reload.rs
+++ b/src/service/ban_reload.rs
@@ -0,0 +1,119 @@
+use std::path::Path;
+use std::sync::mpsc::channel;
+use std::sync::Arc;
+use std::thread;
+use std::time::Duration;
+
+use notify::{watcher, DebouncedEvent, RecursiveMode, Watcher};
+
+use crate::config::{Config, Server as ConfigServer};
+use crate::mc::ban;
+use crate::server::Server;
+
+/// File debounce time.
+const WATCH_DEBOUNCE: Duration = Duration::from_secs(2);
+
+/// Service to reload banned IPs when its file changes.
+pub fn service(config: Arc<Config>, server: Arc<Server>) {
+    // TODO: check what happens when file doesn't exist at first?
+
+    // Ensure we need to reload banned IPs
+    if !config.server.block_banned_ips && !config.server.drop_banned_ips {
+        return;
+    }
+
+    // Ensure server directory is set, it must exist
+    let dir = match ConfigServer::server_directory(&config) {
+        Some(dir) => dir,
+        None => {
+            warn!(target: "lazymc", "Not blocking banned IPs, server directory not configured, unable to find {} file", ban::FILE);
+            return;
+        }
+    };
+
+    // Determine file path, ensure it exists
+    let path = dir.join(crate::mc::ban::FILE);
+    if !path.is_file() {
+        warn!(target: "lazymc", "Not blocking banned IPs, {} file does not exist", ban::FILE);
+        return;
+    }
+
+    // Load banned IPs once
+    match ban::load(&path) {
+        Ok(ips) => server.set_banned_ips_blocking(ips),
+        Err(err) => {
+            error!(target: "lazymc", "Failed to load banned IPs from {}: {}", ban::FILE, err);
+        }
+    }
+
+    // Show warning if 127.0.0.1 is banned
+    if server.is_banned_ip_blocking(&("127.0.0.1".parse().unwrap())) {
+        warn!(target: "lazymc", "Local address 127.0.0.1 IP banned, probably not what you want");
+        warn!(target: "lazymc", "Use '/pardon-ip 127.0.0.1' on the server to unban");
+    }
+
+    // Keep watching
+    while watch(&server, &path) {}
+}
+
+/// Watch the given file.
+fn watch(server: &Server, path: &Path) -> bool {
+    // The file must exist
+    if !path.is_file() {
+        warn!(target: "lazymc", "File {} does not exist, not watching changes", ban::FILE);
+        return false;
+    }
+
+    // Create watcher for banned IPs file
+    let (tx, rx) = channel();
+    let mut watcher =
+        watcher(tx, WATCH_DEBOUNCE).expect("failed to create watcher for banned-ips.json");
+    if let Err(err) = watcher.watch(path, RecursiveMode::NonRecursive) {
+        error!(target: "lazymc", "An error occured while creating watcher for {}: {}", ban::FILE, err);
+        return true;
+    }
+
+    loop {
+        // Take next event
+        let event = rx.recv().unwrap();
+
+        // Decide whether to reload and rewatch
+        let (reload, rewatch) = match event {
+            // Reload on write
+            DebouncedEvent::NoticeWrite(_) | DebouncedEvent::Write(_) => (true, false),
+
+            // Reload and rewatch on rename/remove
+            DebouncedEvent::NoticeRemove(_)
+            | DebouncedEvent::Remove(_)
+            | DebouncedEvent::Rename(_, _)
+            | DebouncedEvent::Rescan
+            | DebouncedEvent::Create(_) => {
+                trace!(target: "lazymc", "File banned-ips.json removed, trying to rewatch after 1 second");
+                thread::sleep(WATCH_DEBOUNCE);
+                (true, true)
+            }
+
+            // Ignore chmod changes
+            DebouncedEvent::Chmod(_) => (false, false),
+
+            // Rewatch on error
+            DebouncedEvent::Error(_, _) => (false, true),
+        };
+
+        // Reload banned IPs
+        if reload {
+            debug!(target: "lazymc", "Reloading list of banned IPs...");
+            match ban::load(path) {
+                Ok(ips) => server.set_banned_ips_blocking(ips),
+                Err(err) => {
+                    error!(target: "lazymc", "Failed reload list of banned IPs from {}: {}", ban::FILE, err);
+                }
+            }
+        }
+
+        // Rewatch
+        if rewatch {
+            return true;
+        }
+    }
+}
--- a/src/service/mod.rs
+++ b/src/service/mod.rs
@@ -1,3 +1,5 @@
+pub mod ban_reload;
 pub mod monitor;
+pub mod probe;
 pub mod server;
 pub mod signal;
--- a/src/service/probe.rs
+++ b/src/service/probe.rs
@@ -0,0 +1,33 @@
+use std::sync::Arc;
+
+use crate::config::{Config, Method};
+use crate::probe;
+use crate::server::Server;
+
+/// Probe server.
+pub async fn service(config: Arc<Config>, state: Arc<Server>) {
+    // Only probe if enabled or if we must
+    if !config.server.probe_on_start && !must_probe(&config) {
+        return;
+    }
+
+    // Probe
+    match probe::probe(config, state).await {
+        Ok(_) => info!(target: "lazymc::probe", "Succesfully probed server"),
+        Err(_) => {
+            error!(target: "lazymc::probe", "Failed to probe server, this may limit lazymc features")
+        }
+    }
+}
+
+/// Check whether we must probe.
+fn must_probe(config: &Config) -> bool {
+    // Must probe with lobby and Forge
+    if config.server.forge && config.join.methods.contains(&Method::Lobby) {
+        warn!(target: "lazymc::probe", "Starting server to probe for Forge lobby...");
+        warn!(target: "lazymc::probe", "Set 'server.probe_on_start = true' to remove this warning");
+        return true;
+    }
+
+    false
+}
--- a/src/service/server.rs
+++ b/src/service/server.rs
@@ -6,8 +6,8 @@ use futures::FutureExt;
 use tokio::net::{TcpListener, TcpStream};

 use crate::config::Config;
-use crate::proto::Client;
-use crate::proxy;
+use crate::proto::client::Client;
+use crate::proxy::{self, ProxyHeader};
 use crate::server::{self, Server};
 use crate::service;
 use crate::status;
@@ -46,7 +46,7 @@ pub async fn service(config: Arc<Config>) -> Result<(), ()> {
        );
    }

-    // Spawn server monitor and signal handler services
+    // Spawn services: monitor, signal handler
    tokio::spawn(service::monitor::service(config.clone(), server.clone()));
    tokio::spawn(service::signal::service(config.clone(), server.clone()));

@@ -55,6 +55,13 @@ pub async fn service(config: Arc<Config>) -> Result<(), ()> {
        Server::start(config.clone(), server.clone(), None).await;
    }

+    // Spawn additional services: probe and ban manager
+    tokio::spawn(service::probe::service(config.clone(), server.clone()));
+    tokio::task::spawn_blocking({
+        let (config, server) = (config.clone(), server.clone());
+        || service::ban_reload::service(config, server)
+    });
+
    // Route all incomming connections
    while let Ok((inbound, _)) = listener.accept().await {
        route(inbound, config.clone(), server.clone());
@@ -66,19 +73,37 @@ pub async fn service(config: Arc<Config>) -> Result<(), ()> {
 /// Route inbound TCP stream to correct service, spawning a new task.
 #[inline]
 fn route(inbound: TcpStream, config: Arc<Config>, server: Arc<Server>) {
-    let should_proxy = server.state() == server::State::Started && !config.lockout.enabled;
+    // Get user peer address
+    let peer = match inbound.peer_addr() {
+        Ok(peer) => peer,
+        Err(err) => {
+            warn!(target: "lazymc", "Connection from unknown peer address, disconnecting: {}", err);
+            return;
+        }
+    };
+
+    // Check ban state, just drop connection if enabled
+    let banned = server.is_banned_ip_blocking(&peer.ip());
+    if config.server.drop_banned_ips {
+        info!(target: "lazymc", "Connection from banned IP {}, dropping", peer.ip());
+        return;
+    }
+
+    // Route connection through proper channel
+    let should_proxy =
+        !banned && server.state() == server::State::Started && !config.lockout.enabled;
    if should_proxy {
        route_proxy(inbound, config)
    } else {
-        route_status(inbound, config, server)
+        route_status(inbound, config, server, peer)
    }
 }

 /// Route inbound TCP stream to status server, spawning a new task.
 #[inline]
-fn route_status(inbound: TcpStream, config: Arc<Config>, server: Arc<Server>) {
+fn route_status(inbound: TcpStream, config: Arc<Config>, server: Arc<Server>, peer: SocketAddr) {
    // When server is not online, spawn a status server
-    let client = Client::default();
+    let client = Client::new(peer);
    let service = status::serve(client, inbound, config, server).map(|r| {
        if let Err(err) = r {
            warn!(target: "lazymc", "Failed to serve status: {:?}", err);
@@ -92,7 +117,12 @@ fn route_status(inbound: TcpStream, config: Arc<Config>, server: Arc<Server>) {
 #[inline]
 fn route_proxy(inbound: TcpStream, config: Arc<Config>) {
    // When server is online, proxy all
-    let service = proxy::proxy(inbound, config.server.address).map(|r| {
+    let service = proxy::proxy(
+        inbound,
+        ProxyHeader::Proxy.not_none(config.server.send_proxy_v2),
+        config.server.address,
+    )
+    .map(|r| {
        if let Err(err) = r {
            warn!(target: "lazymc", "Failed to proxy: {}", err);
        }
@@ -104,15 +134,25 @@ fn route_proxy(inbound: TcpStream, config: Arc<Config>) {
 /// Route inbound TCP stream to proxy with queued data, spawning a new task.
 #[inline]
 pub fn route_proxy_queue(inbound: TcpStream, config: Arc<Config>, queue: BytesMut) {
-    route_proxy_address_queue(inbound, config.server.address, queue);
+    route_proxy_address_queue(
+        inbound,
+        ProxyHeader::Proxy.not_none(config.server.send_proxy_v2),
+        config.server.address,
+        queue,
+    );
 }

 /// Route inbound TCP stream to proxy with given address and queued data, spawning a new task.
 #[inline]
-pub fn route_proxy_address_queue(inbound: TcpStream, addr: SocketAddr, queue: BytesMut) {
+pub fn route_proxy_address_queue(
+    inbound: TcpStream,
+    proxy_header: ProxyHeader,
+    addr: SocketAddr,
+    queue: BytesMut,
+) {
    // When server is online, proxy all
    let service = async move {
-        proxy::proxy_with_queue(inbound, addr, &queue)
+        proxy::proxy_with_queue(inbound, proxy_header, addr, &queue)
            .map(|r| {
                if let Err(err) = r {
                    warn!(target: "lazymc", "Failed to proxy: {}", err);
--- a/src/status.rs
+++ b/src/status.rs
@@ -1,6 +1,4 @@
-use std::ops::Deref;
 use std::sync::Arc;
-use std::time::Duration;

 use bytes::BytesMut;
 use minecraft_protocol::data::chat::{Message, Payload};
@@ -8,19 +6,29 @@ use minecraft_protocol::data::server_status::*;
 use minecraft_protocol::decoder::Decoder;
 use minecraft_protocol::encoder::Encoder;
 use minecraft_protocol::version::v1_14_4::handshake::Handshake;
-use minecraft_protocol::version::v1_14_4::login::{LoginDisconnect, LoginStart};
+use minecraft_protocol::version::v1_14_4::login::LoginStart;
 use minecraft_protocol::version::v1_14_4::status::StatusResponse;
-use tokio::io::{self, AsyncWriteExt};
-use tokio::net::tcp::WriteHalf;
+use tokio::fs;
+use tokio::io::AsyncWriteExt;
 use tokio::net::TcpStream;
-use tokio::time;

-use crate::config::*;
-#[cfg(feature = "lobby")]
-use crate::lobby;
-use crate::proto::{self, Client, ClientInfo, ClientState, RawPacket};
-use crate::server::{self, Server, State};
-use crate::service;
+use crate::config::{Config, Server as ConfigServer};
+use crate::join;
+use crate::mc::favicon;
+use crate::proto::action;
+use crate::proto::client::{Client, ClientInfo, ClientState};
+use crate::proto::packet::{self, RawPacket};
+use crate::proto::packets;
+use crate::server::{self, Server};
+
+/// The ban message prefix.
+const BAN_MESSAGE_PREFIX: &str = "Your IP address is banned from this server.\nReason: ";
+
+/// Default ban reason if unknown.
+const DEFAULT_BAN_REASON: &str = "Banned by an operator.";
+
+/// Server icon file path.
+const SERVER_ICON_FILE: &str = "server-icon.png";

 /// Proxy the given inbound stream to a target address.
 // TODO: do not drop error here, return Box<dyn Error>
@@ -35,16 +43,13 @@ pub async fn serve(
    // Incoming buffer and packet holding queue
    let mut buf = BytesMut::new();

-    // Remember inbound packets, used for client holding and forwarding
-    let remember_inbound = config.join.methods.contains(&Method::Hold)
-        || config.join.methods.contains(&Method::Forward);
+    // Remember inbound packets, track client info
    let mut inbound_history = BytesMut::new();
-
    let mut client_info = ClientInfo::empty();

    loop {
        // Read packet from stream
-        let (packet, raw) = match proto::read_packet(&client, &mut buf, &mut reader).await {
+        let (packet, raw) = match packet::read_packet(&client, &mut buf, &mut reader).await {
            Ok(Some(packet)) => packet,
            Ok(None) => break,
            Err(_) => {
@@ -58,7 +63,7 @@ pub async fn serve(

        // Hijack handshake
        if client_state == ClientState::Handshake
-            && packet.id == proto::packets::handshake::SERVER_HANDSHAKE
+            && packet.id == packets::handshake::SERVER_HANDSHAKE
        {
            // Parse handshake
            let handshake = match Handshake::decode(&mut packet.data.as_slice()) {
@@ -80,12 +85,13 @@ pub async fn serve(

            // Update client info and client state
            client_info
-                .protocol_version
-                .replace(handshake.protocol_version);
+                .protocol
+                .replace(handshake.protocol_version as u32);
+            client_info.handshake.replace(handshake);
            client.set_state(new_state);

-            // If login handshake and holding is enabled, hold packets
-            if new_state == ClientState::Login && remember_inbound {
+            // If loggin in with handshake, remember inbound
+            if new_state == ClientState::Login {
                inbound_history.extend(raw);
            }

@@ -93,30 +99,27 @@ pub async fn serve(
        }

        // Hijack server status packet
-        if client_state == ClientState::Status && packet.id == proto::packets::status::SERVER_STATUS
-        {
-            let server_status = server_status(&config, &server).await;
+        if client_state == ClientState::Status && packet.id == packets::status::SERVER_STATUS {
+            let server_status = server_status(&client_info, &config, &server).await;
            let packet = StatusResponse { server_status };

            let mut data = Vec::new();
            packet.encode(&mut data).map_err(|_| ())?;

-            let response = RawPacket::new(0, data).encode(&client)?;
+            let response = RawPacket::new(0, data).encode_with_len(&client)?;
            writer.write_all(&response).await.map_err(|_| ())?;

            continue;
        }

        // Hijack ping packet
-        if client_state == ClientState::Status && packet.id == proto::packets::status::SERVER_PING {
+        if client_state == ClientState::Status && packet.id == packets::status::SERVER_PING {
            writer.write_all(&raw).await.map_err(|_| ())?;
            continue;
        }

        // Hijack login start
-        if client_state == ClientState::Login
-            && packet.id == proto::packets::login::SERVER_LOGIN_START
-        {
+        if client_state == ClientState::Login && packet.id == packets::login::SERVER_LOGIN_START {
            // Try to get login username, update client info
            // TODO: we should always parse this packet successfully
            let username = LoginStart::decode(&mut packet.data.as_slice())
@@ -132,201 +135,77 @@ pub async fn serve(
                    }
                    None => info!(target: "lazymc", "Kicked player because lockout is enabled"),
                }
-                kick(&client, &config.lockout.message, &mut writer).await?;
+                action::kick(&client, &config.lockout.message, &mut writer).await?;
                break;
            }

+            // Kick if client is banned
+            if let Some(ban) = server.ban_entry(&client.peer.ip()).await {
+                if ban.is_banned() {
+                    let msg = if let Some(reason) = ban.reason {
+                        info!(target: "lazymc", "Login from banned IP {} ({}), disconnecting", client.peer.ip(), &reason);
+                        reason.to_string()
+                    } else {
+                        info!(target: "lazymc", "Login from banned IP {}, disconnecting", client.peer.ip());
+                        DEFAULT_BAN_REASON.to_string()
+                    };
+                    action::kick(
+                        &client,
+                        &format!("{}{}", BAN_MESSAGE_PREFIX, msg),
+                        &mut writer,
+                    )
+                    .await?;
+                    break;
+                }
+            }
+
            // Start server if not starting yet
            Server::start(config.clone(), server.clone(), username).await;

-            // Use join occupy methods
-            for method in &config.join.methods {
-                match method {
-                    // Kick method, immediately kick client
-                    Method::Kick => {
-                        trace!(target: "lazymc", "Using kick method to occupy joining client");
+            // Remember inbound packets
+            inbound_history.extend(&raw);
+            inbound_history.extend(&buf);

-                        // Select message and kick
-                        let msg = match server.state() {
-                            server::State::Starting
-                            | server::State::Stopped
-                            | server::State::Started => &config.join.kick.starting,
-                            server::State::Stopping => &config.join.kick.stopping,
-                        };
-                        kick(&client, msg, &mut writer).await?;
-                        break;
-                    }
+            // Build inbound packet queue with everything from login start (including this)
+            let mut login_queue = BytesMut::with_capacity(raw.len() + buf.len());
+            login_queue.extend(&raw);
+            login_queue.extend(&buf);

-                    // Hold method, hold client connection while server starts
-                    Method::Hold => {
-                        trace!(target: "lazymc", "Using hold method to occupy joining client");
+            // Buf is fully consumed here
+            buf.clear();

-                        // Server must be starting
-                        if server.state() != State::Starting {
-                            continue;
-                        }
-
-                        // Hold login packet and remaining read bytes
-                        inbound_history.extend(&raw);
-                        inbound_history.extend(buf.split_off(0));
-
-                        // Start holding
-                        if hold(&config, &server).await? {
-                            service::server::route_proxy_queue(inbound, config, inbound_history);
-                            return Ok(());
-                        }
-                    }
-
-                    // Forward method, forward client connection while server starts
-                    Method::Forward => {
-                        trace!(target: "lazymc", "Using forward method to occupy joining client");
-
-                        // Hold login packet and remaining read bytes
-                        inbound_history.extend(&raw);
-                        inbound_history.extend(buf.split_off(0));
-
-                        // Forward client
-                        debug!(target: "lazymc", "Forwarding client to {:?}!", config.join.forward.address);
-
-                        service::server::route_proxy_address_queue(
-                            inbound,
-                            config.join.forward.address,
-                            inbound_history,
-                        );
-                        return Ok(());
-
-                        // TODO: do not consume client here, allow other join method on fail
-                    }
-
-                    // Lobby method, keep client in lobby while server starts
-                    #[cfg(feature = "lobby")]
-                    Method::Lobby => {
-                        trace!(target: "lazymc", "Using lobby method to occupy joining client");
-
-                        // Build queue with login packet and any additionally received
-                        let mut queue = BytesMut::with_capacity(raw.len() + buf.len());
-                        queue.extend(raw);
-                        queue.extend(buf.split_off(0));
-
-                        // Start lobby
-                        lobby::serve(client, client_info, inbound, config, server, queue).await?;
-                        return Ok(());
-                        // TODO: do not consume client here, allow other join method on fail
-                    }
-
-                    // Lobby method, keep client in lobby while server starts
-                    #[cfg(not(feature = "lobby"))]
-                    Method::Lobby => {
-                        error!(target: "lazymc", "Lobby join method not supported in this lazymc build");
-                    }
-                }
-            }
-
-            debug!(target: "lazymc", "No method left to occupy joining client, disconnecting");
-
-            // Done occupying client, just disconnect
-            break;
+            // Start occupying client
+            join::occupy(
+                client,
+                client_info,
+                config,
+                server,
+                inbound,
+                inbound_history,
+                login_queue,
+            )
+            .await?;
+            return Ok(());
        }

        // Show unhandled packet warning
-        debug!(target: "lazymc", "Received unhandled packet:");
+        debug!(target: "lazymc", "Got unhandled packet:");
        debug!(target: "lazymc", "- State: {:?}", client_state);
        debug!(target: "lazymc", "- Packet ID: {}", packet.id);
    }

-    // Gracefully close connection
-    match writer.shutdown().await {
-        Ok(_) => {}
-        Err(err) if err.kind() == io::ErrorKind::NotConnected => {}
-        Err(_) => return Err(()),
-    }
-
    Ok(())
 }

-/// Hold a client while server starts.
-///
-/// Returns holding status. `true` if client is held and it should be proxied, `false` it was held
-/// but it timed out.
-pub async fn hold<'a>(config: &Config, server: &Server) -> Result<bool, ()> {
-    trace!(target: "lazymc", "Started holding client");
-
-    // A task to wait for suitable server state
-    // Waits for started state, errors if stopping/stopped state is reached
-    let task_wait = async {
-        let mut state = server.state_receiver();
-        loop {
-            // Wait for state change
-            state.changed().await.unwrap();
-
-            match state.borrow().deref() {
-                // Still waiting on server start
-                State::Starting => {
-                    trace!(target: "lazymc", "Server not ready, holding client for longer");
-                    continue;
-                }
-
-                // Server started, start relaying and proxy
-                State::Started => {
-                    break true;
-                }
-
-                // Server stopping, this shouldn't happen, kick
-                State::Stopping => {
-                    warn!(target: "lazymc", "Server stopping for held client, disconnecting");
-                    break false;
-                }
-
-                // Server stopped, this shouldn't happen, disconnect
-                State::Stopped => {
-                    error!(target: "lazymc", "Server stopped for held client, disconnecting");
-                    break false;
-                }
-            }
-        }
-    };
-
-    // Wait for server state with timeout
-    let timeout = Duration::from_secs(config.join.hold.timeout as u64);
-    match time::timeout(timeout, task_wait).await {
-        // Relay client to proxy
-        Ok(true) => {
-            info!(target: "lazymc", "Server ready for held client, relaying to server");
-            Ok(true)
-        }
-
-        // Server stopping/stopped, this shouldn't happen, kick
-        Ok(false) => {
-            warn!(target: "lazymc", "Server stopping for held client");
-            Ok(false)
-        }
-
-        // Timeout reached, kick with starting message
-        Err(_) => {
-            warn!(target: "lazymc", "Held client reached timeout of {}s", config.join.hold.timeout);
-            Ok(false)
-        }
-    }
-}
-
-/// Kick client with a message.
-///
-/// Should close connection afterwards.
-async fn kick(client: &Client, msg: &str, writer: &mut WriteHalf<'_>) -> Result<(), ()> {
-    let packet = LoginDisconnect {
-        reason: Message::new(Payload::text(msg)),
-    };
-
-    let mut data = Vec::new();
-    packet.encode(&mut data).map_err(|_| ())?;
-
-    let response = RawPacket::new(proto::packets::login::CLIENT_DISCONNECT, data).encode(client)?;
-    writer.write_all(&response).await.map_err(|_| ())
-}
-
 /// Build server status object to respond to client with.
-async fn server_status(config: &Config, server: &Server) -> ServerStatus {
+async fn server_status(client_info: &ClientInfo, config: &Config, server: &Server) -> ServerStatus {
    let status = server.status().await;
+    let server_state = server.state();
+
+    // Respond with real server status if started
+    if server_state == server::State::Started && status.is_some() {
+        return status.as_ref().unwrap().clone();
+    }

    // Select version and player max from last known server status
    let (version, max) = match status.as_ref() {
@@ -345,7 +224,7 @@ async fn server_status(config: &Config, server: &Server) -> ServerStatus {
        if config.motd.from_server && status.is_some() {
            status.as_ref().unwrap().description.clone()
        } else {
-            Message::new(Payload::text(match server.state() {
+            Message::new(Payload::text(match server_state {
                server::State::Stopped | server::State::Started => &config.motd.sleeping,
                server::State::Starting => &config.motd.starting,
                server::State::Stopping => &config.motd.stopping,
@@ -353,6 +232,17 @@ async fn server_status(config: &Config, server: &Server) -> ServerStatus {
        }
    };

+    // Extract favicon from real server status, load from disk, or use default
+    let mut favicon = None;
+    if favicon::supports_favicon(client_info) {
+        if config.motd.from_server && status.is_some() {
+            favicon = status.as_ref().unwrap().favicon.clone()
+        }
+        if favicon.is_none() {
+            favicon = Some(server_favicon(config).await);
+        }
+    }
+
    // Build status resposne
    ServerStatus {
        version,
@@ -362,5 +252,36 @@ async fn server_status(config: &Config, server: &Server) -> ServerStatus {
            max,
            sample: vec![],
        },
+        favicon,
    }
 }
+
+/// Get server status favicon.
+///
+/// This always returns a favicon, returning the default one if none is set.
+async fn server_favicon(config: &Config) -> String {
+    // Get server dir
+    let dir = match ConfigServer::server_directory(config) {
+        Some(dir) => dir,
+        None => return favicon::default_favicon(),
+    };
+
+    // Server icon file, ensure it exists
+    let path = dir.join(SERVER_ICON_FILE);
+    if !path.is_file() {
+        return favicon::default_favicon();
+    }
+
+    // Read icon data
+    let data = match fs::read(path).await.map_err(|err| {
+        error!(target: "lazymc", "Failed to read favicon from {}: {}", SERVER_ICON_FILE, err);
+    }) {
+        Ok(data) => data,
+        Err(err) => {
+            error!(target: "lazymc::status", "Failed to load server icon from disk, using default: {:?}", err);
+            return favicon::default_favicon();
+        }
+    };
+
+    favicon::encode_favicon(&data)
+}
--- a/src/util/mod.rs
+++ b/src/util/mod.rs
@@ -1,5 +1,6 @@
 pub mod cli;
 pub mod error;
+pub mod serde;
 pub mod style;

 use std::env;
--- a/src/util/serde.rs
+++ b/src/util/serde.rs
@@ -0,0 +1,30 @@
+use std::net::{SocketAddr, ToSocketAddrs};
+
+use serde::de::{Error, Unexpected};
+use serde::{Deserialize, Deserializer};
+
+/// Deserialize a `Vec` into a `HashMap` by key.
+pub fn to_socket_addrs<'de, D>(d: D) -> Result<SocketAddr, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    // Deserialize string
+    let addr = String::deserialize(d)?;
+
+    // Try to socket address to resolve
+    match addr.to_socket_addrs() {
+        Ok(mut addr) => {
+            if let Some(addr) = addr.next() {
+                return Ok(addr);
+            }
+        }
+        Err(err) => {
+            dbg!(err);
+        }
+    }
+
+    // Parse raw IP address
+    addr.parse().map_err(|_| {
+        Error::invalid_value(Unexpected::Str(&addr), &"IP or resolvable host and port")
+    })
+}
Author	SHA1	Message	Date
timvisee	69de7a95bf	Bump version to 0.2.5	2021-11-25 15:04:39 +01:00
timvisee	3e7e5c4c03	Fix Windows CI builds having incorrect feature configuration	2021-11-25 15:04:21 +01:00
timvisee	4d774cd254	Update dependencies	2021-11-25 14:54:05 +01:00
timvisee	a1324d22a7	Various fixes and improvements	2021-11-25 14:41:43 +01:00
timvisee	a500f50064	Use probed server settings in lobby join game packet	2021-11-25 14:36:50 +01:00
timvisee	4ef1481f2b	Fix unsupported dimension data in lobby, use proper default world name	2021-11-25 14:21:29 +01:00
timvisee	addfb1c135	Don't use lobby join method if server isn't probed yet when required	2021-11-25 14:20:58 +01:00
timvisee	956c428251	Add compile time feature compatibility check, remove from build.rs	2021-11-25 14:00:59 +01:00
timvisee	270362b152	Use consistent documentation file names	2021-11-25 13:51:24 +01:00
timvisee	93f75adc5c	Update lobby limitations, describe whitelist issue with probe user	2021-11-25 13:50:15 +01:00
timvisee	40fe5b5dd2	Cleanup documentation	2021-11-25 13:42:57 +01:00
timvisee	e7d2c6f64c	Resolve clippy warnings	2021-11-25 13:39:52 +01:00
timvisee	084c3c5f8b	Fix compilation error	2021-11-25 13:27:44 +01:00
timvisee	d39ad9c913	Update TODO	2021-11-25 12:59:52 +01:00
timvisee	00b6cddd78	Change ban list reload log message from info to debug	2021-11-25 12:59:51 +01:00
timvisee	b8744aaf57	Fix protocol versions being handled incorrectly	2021-11-25 12:59:51 +01:00
timvisee	51d3ecf148	Report online mode error if lobby receives server encryption request	2021-11-25 12:59:51 +01:00
timvisee	75c7a09249	Handle unrecognized login plugin requests messages in lobby	2021-11-25 12:59:50 +01:00
timvisee	f6d60318e8	Support Minecraft v1.16.3 to v1.17.1 in lobby and probe logic	2021-11-25 12:59:50 +01:00
timvisee	b404ab0a87	Support multiple Minecraft protocol versions in lobby and probe logic	2021-11-25 12:59:50 +01:00
timvisee	cf6bd526d9	Dynamically build lobby dimension from probed server dimension codec	2021-11-25 12:59:48 +01:00
timvisee	f513957bff	Add config option to enable server probing on start	2021-11-25 12:59:32 +01:00
timvisee	9b1f2a7011	Probe server on lazymc start to get up-to-date server details for Forge	2021-11-25 12:59:32 +01:00
timvisee	8b09faae3d	Constrain supported lobby versions	2021-11-25 12:59:32 +01:00
timvisee	e23a61ab0f	Replay client handshake when lobby connects to real server	2021-11-25 12:59:31 +01:00
timvisee	78a36978f5	Fix broken italic text in Windows usage guide	2021-11-24 14:09:03 +01:00
timvisee	0ba46caf5c	Bump version to 0.2.4	2021-11-24 14:05:27 +01:00
timvisee	6b23490919	Resolve clippy warnings	2021-11-24 14:02:08 +01:00
timvisee	9e08ed6cda	Update dependencies	2021-11-24 13:57:19 +01:00
timvisee	3271db1cb3	Resolve compile warning	2021-11-24 13:55:23 +01:00
timvisee	cf0e3ef15b	Make server directory relative to configuration file directory	2021-11-24 13:53:38 +01:00
timvisee	ee21eb45fd	Bump minimum supported Minecraft version to 1.7.2	2021-11-24 13:28:06 +01:00
timvisee	aebb5563e0	Only send status response favicon to client versions that support it	2021-11-24 13:27:42 +01:00
timvisee	20fb6ee715	Always include favicon in status response, fall back to default icon See https://github.com/timvisee/lazymc/issues/11#issuecomment-977814539	2021-11-24 13:20:49 +01:00
timvisee	ea2dbc905c	Add Minecraft default server icon, extracted from Minecraft 1.17.1	2021-11-24 13:02:41 +01:00
timvisee	eb66265670	Handle SIGTERM exit code as successful	2021-11-23 13:00:10 +01:00
timvisee	df101ce53b	Fix typo in Cargo.toml key	2021-11-22 20:38:30 +01:00
timvisee	8f2ce9b4b8	Fix compilation error without lobby feature	2021-11-22 20:36:46 +01:00
timvisee	20902e6a94	Derive correct UUID for offline players in lobby logic (2/2)	2021-11-22 20:20:08 +01:00
timvisee	3e933f7566	Derive correct UUID for offline players in lobby logic	2021-11-22 20:14:29 +01:00
timvisee	46fa594065	Update features in README	2021-11-22 19:00:36 +01:00
timvisee	1d92964802	Bump version to 0.2.3	2021-11-22 18:55:50 +01:00
timvisee	9b8d569628	Update dependencies	2021-11-22 18:53:52 +01:00
timvisee	94f2fa01e2	Update TODO	2021-11-22 18:53:23 +01:00
timvisee	9b71052b61	Add extras document with recommendations and tips after installing	2021-11-22 18:51:06 +01:00
timvisee	0049ad456c	Bump rcon to 0.5.2, which now includes changes from our fork	2021-11-22 18:36:12 +01:00
timvisee	0f2d7720af	Add documentation for proper IP proxying with PROXY header	2021-11-22 18:35:40 +01:00
timvisee	723ebabcfb	Minor monitoring tweaks	2021-11-22 17:57:44 +01:00
timvisee	f95682fcd5	Only enable RCON by default on Windows	2021-11-22 17:57:28 +01:00
timvisee	d5c854d16f	Add option to send HAProxy header with RCON connections	2021-11-22 17:55:51 +01:00
timvisee	493e24ff4d	Send proxy header with monitor requests	2021-11-22 16:53:35 +01:00
timvisee	6916800aeb	Add `send_proxy_v2` option to send HAProxy header to server	2021-11-22 14:37:07 +01:00
timvisee	e7c31f2619	Add protocol version documentation	2021-11-22 13:37:21 +01:00
timvisee	7da467ff8c	Bump version to 0.2.2	2021-11-18 11:37:02 +01:00
timvisee	c9d7af0e3c	Add server favicon to status responses	2021-11-18 11:35:49 +01:00
timvisee	0715baed8c	Bump version to 0.2.1	2021-11-17 20:31:22 +01:00
timvisee	1f4ec11ad1	Resolve clippy warnings	2021-11-17 20:26:49 +01:00
timvisee	acf6768b49	Show warning if 127.0.0.1 is IP banned	2021-11-17 20:25:49 +01:00
timvisee	75f7b62b16	Kick user with proper ban message, tweak IP file change debounce time	2021-11-17 20:21:22 +01:00
timvisee	9cc1958bbd	Automatically reload banned IPs when file changes	2021-11-17 20:15:30 +01:00
timvisee	785bd2f33e	Make banned IP format less strict to support possible future changes	2021-11-17 18:46:45 +01:00
timvisee	b168dcefde	Respect IP ban expiry times	2021-11-17 18:42:26 +01:00
timvisee	74d772ab42	Respond with real server MOTD if it is currently started	2021-11-17 18:28:55 +01:00
timvisee	a71b3cb24f	Add option to drop all connections from banned IPs This instantly disconnects clients from banned IPs. Clients won't be able to request or ping the server status. Clients won't get a kick message with their ban reason either. Clients simply get a 'Disconnected' message on login.	2021-11-17 18:23:17 +01:00
timvisee	28dbcdbfd6	Show MOTD for banned players, kick with reason on login	2021-11-17 18:14:02 +01:00
timvisee	e816d4ff6c	Use more efficient structure to manage banned IPs	2021-11-17 17:46:51 +01:00
timvisee	168cbceb4c	Disconnect banned IPs based on server banned-ips.json file	2021-11-17 17:36:28 +01:00
timvisee	b1bd9e1837	Add support for host names in config address fields, resolve them to IP	2021-11-17 16:14:05 +01:00
timvisee	ec24f088b2	Fix lobby error due to invalid packet IDs	2021-11-16 18:09:45 +01:00
timvisee	6321999489	Update dependencies	2021-11-16 17:58:09 +01:00
timvisee	47fe7d0387	Extract all packet writing logic to single function	2021-11-16 17:57:34 +01:00
timvisee	7df3829e00	Use u8 for packet IDs	2021-11-16 17:13:30 +01:00
timvisee	b06f26b3e8	Refactor, cleanup status logic, extract join occupy logic into modules	2021-11-16 17:05:44 +01:00