bump version for release

2026-04-11 12:34:03 -05:00 · 2022-01-23 23:39:46 +00:00
135 changed files with 5415 additions and 7522 deletions
--- a/.editorconfig
+++ b/.editorconfig
@@ -1,21 +0,0 @@
-root = true
-
-[*]
-indent_style = tab
-indent_size = 4
-tab_width = 4
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[*.go]
-max_line_length = 100
-
-[*.md]
-trim_trailing_whitespace = false
-
-[*.{md,nix,yaml}]
-indent_style = space
-indent_size = 2
-tab_width = 2
--- a/.envrc
+++ b/.envrc
@@ -1,8 +0,0 @@
-#!/usr/bin/env sh
-
-# Load the flake's `devShells.${currentSystem}.default`.
-if ! use flake .; then
-	echo 'The development shell was unable to be built.' >&2
-	echo 'The development environment was not loaded.' >&2
-	echo 'Please make the necessary changes in flake.nix to fix any issues and hit enter to try again.' >&2
-fi
--- a/.github/FUNDING.yaml
+++ b/.github/FUNDING.yaml
@@ -1 +0,0 @@
-github: [pterodactyl]
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -0,0 +1,2 @@
+github: [ DaneEveritt ]
+custom: [ "https://paypal.me/PterodactylSoftware" ]
--- a/.github/dependabot.yaml
+++ b/.github/dependabot.yaml
@@ -1,10 +0,0 @@
-version: 2
-updates:
-  - package-ecosystem: github-actions
-    directory: /
-    schedule:
-      interval: monthly
-  - package-ecosystem: gomod
-    directory: /
-    schedule:
-      interval: weekly
--- a/.github/workflows/build-test.yml
+++ b/.github/workflows/build-test.yml
@@ -0,0 +1,66 @@
+name: Run Tests
+on:
+  push:
+    branches:
+      - develop
+  pull_request:
+    branches:
+      - develop
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ ubuntu-20.04 ]
+        go: [ '^1.17' ]
+        goos: [ linux ]
+        goarch: [ amd64, arm64 ]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Code Checkout
+        uses: actions/checkout@v2
+      - name: Setup Go v${{ matrix.go }}
+        uses: actions/setup-go@v2
+        with:
+          go-version: ${{ matrix.go }}
+      - name: Print Environment
+        id: env
+        run: |
+          printf "Go Executable Path: $(which go)\n"
+          printf "Go Version: $(go version)\n"
+          printf "\n\nGo Environment:\n\n"
+          go env
+          printf "\n\nSystem Environment:\n\n"
+          env
+
+          echo "::set-output name=version_tag::${GITHUB_REF/refs\/tags\//}"
+          echo "::set-output name=short_sha::$(git rev-parse --short HEAD)"
+          echo "::set-output name=go_cache::$(go env GOCACHE)"
+      - name: Build Cache
+        uses: actions/cache@v2
+        with:
+          path: ${{ steps.env.outputs.go_cache }}
+          key: ${{ runner.os }}-${{ matrix.go }}-go-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-${{ matrix.go }}-go
+      - name: Get Dependencies
+        run: |
+          go get -v -t -d ./...
+      - name: Build
+        env:
+          GOOS: ${{ matrix.goos }}
+          GOARCH: ${{ matrix.goarch }}
+          CGO_ENABLED: 0
+          SRC_PATH: github.com/pterodactyl/wings
+        run: |
+          go build -v -trimpath -ldflags="-s -w -X ${SRC_PATH}/system.Version=dev-${GIT_COMMIT:0:7}" -o build/wings_${{ matrix.goos }}_${{ matrix.goarch }} wings.go
+          upx build/wings_${{ matrix.goos }}_${{ matrix.goarch }}
+          chmod +x build/wings_${{ matrix.goos }}_${{ matrix.goarch }}
+      - name: Test
+        run: go test ./...
+      - name: Upload Artifact
+        uses: actions/upload-artifact@v2
+        if: ${{ github.ref == 'refs/heads/develop' || github.event_name == 'pull_request' }}
+        with:
+          name: wings_${{ matrix.goos }}_${{ matrix.goarch }}
+          path: build/wings_${{ matrix.goos }}_${{ matrix.goarch }}
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -0,0 +1,30 @@
+name: CodeQL
+on:
+  push:
+    branches:
+      - develop
+  pull_request:
+    branches:
+      - develop
+  schedule:
+    - cron: '0 9 * * 4'
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'go' ]
+    steps:
+      - uses: actions/checkout@v2
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v1
+        with:
+          languages: ${{ matrix.language }}
+      - uses: github/codeql-action/autobuild@v1
+      - uses: github/codeql-action/analyze@v1
--- a/.github/workflows/codeql.yaml
+++ b/.github/workflows/codeql.yaml
@@ -1,38 +0,0 @@
-name: CodeQL
-
-on:
-  push:
-    branches:
-      - develop
-  pull_request:
-    branches:
-      - develop
-  schedule:
-    - cron: "0 9 * * 4"
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-24.04
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - language: go
-            build-mode: autobuild
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-    steps:
-      - name: Code checkout
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
-
-      - name: Initialize CodeQL
-        uses: github/codeql-action/init@0499de31b99561a6d14a36a5f662c2a54f91beee # v3.29.5
-        with:
-          languages: ${{ matrix.language }}
-          build-mode: ${{ matrix.build-mode }}
-
-      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@0499de31b99561a6d14a36a5f662c2a54f91beee # v3.29.5
--- a/.github/workflows/docker.yaml
+++ b/.github/workflows/docker.yaml
@@ -1,81 +0,0 @@
-name: Docker
-
-on:
-  push:
-    branches:
-      - develop
-  release:
-    types:
-      - published
-
-jobs:
-  build-and-push:
-    name: Build and Push
-    runs-on: ubuntu-24.04
-    # Always run against a tag, even if the commit into the tag has [docker skip] within the commit message.
-    if: "!contains(github.ref, 'develop') || (!contains(github.event.head_commit.message, 'skip docker') && !contains(github.event.head_commit.message, 'docker skip'))"
-    permissions:
-      contents: read
-      packages: write
-    steps:
-      - name: Code checkout
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
-
-      - name: Docker metadata
-        id: docker_meta
-        uses: docker/metadata-action@c299e40c65443455700f0fdfc63efafe5b349051 # v5.10.0
-        with:
-          images: ghcr.io/${{ github.repository }}
-          flavor: |
-            latest=false
-          tags: |
-            type=raw,value=latest,enable=${{ github.event_name == 'release' && github.event.action == 'published' && github.event.release.prerelease == false }}
-            type=ref,event=tag
-            type=ref,event=branch
-
-      - name: Setup QEMU
-        uses: docker/setup-qemu-action@c7c53464625b32c7a7e944ae62b3e17d2b600130 # v3.7.0
-
-      - name: Setup Docker buildx
-        uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3.12.0
-
-      - name: Login to GitHub Container Registry
-        uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Get Build Information
-        id: build_info
-        run: |
-          echo "version_tag=${GITHUB_REF/refs\/tags\/v/}" >> "$GITHUB_OUTPUT"
-          echo "short_sha=$(git rev-parse --short HEAD)" >> "$GITHUB_OUTPUT"
-
-      - name: Build and Push (tag)
-        uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
-        if: "github.event_name == 'release' && github.event.action == 'published'"
-        with:
-          context: .
-          file: ./Dockerfile
-          push: true
-          platforms: linux/amd64,linux/arm64
-          build-args: |
-            VERSION=${{ steps.build_info.outputs.version_tag }}
-          labels: ${{ steps.docker_meta.outputs.labels }}
-          tags: ${{ steps.docker_meta.outputs.tags }}
-
-      - name: Build and Push (develop)
-        uses: docker/build-push-action@263435318d21b8e681c14492fe198d362a7d2c83 # v6.18.0
-        if: "github.event_name == 'push' && contains(github.ref, 'develop')"
-        with:
-          context: .
-          file: ./Dockerfile
-          push: ${{ github.event_name != 'pull_request' }}
-          platforms: linux/amd64,linux/arm64
-          build-args: |
-            VERSION=dev-${{ steps.build_info.outputs.short_sha }}
-          labels: ${{ steps.docker_meta.outputs.labels }}
-          tags: ${{ steps.docker_meta.outputs.tags }}
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
--- a/.github/workflows/docker.yml
+++ b/.github/workflows/docker.yml
@@ -0,0 +1,58 @@
+name: Publish Docker Image
+on:
+  push:
+    branches:
+      - develop
+    tags:
+      - 'v*'
+jobs:
+  push:
+    name: Push
+    runs-on: ubuntu-20.04
+    # Always run against a tag, even if the commit into the tag has [docker skip] within the commit message.
+    if: "!contains(github.ref, 'develop') || (!contains(github.event.head_commit.message, 'skip docker') && !contains(github.event.head_commit.message, 'docker skip'))"
+    steps:
+      - name: Code Checkout
+        uses: actions/checkout@v2
+      - name: Docker Meta
+        id: docker_meta
+        uses: crazy-max/ghaction-docker-meta@v1
+        with:
+          images: ghcr.io/pterodactyl/wings
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v1
+      - name: Install buildx
+        uses: docker/setup-buildx-action@v1
+        with:
+          version: v0.5.1
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v1
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.REGISTRY_TOKEN }}
+      - name: Get Build Information
+        id: build_info
+        run: |
+          echo "::set-output name=version_tag::${GITHUB_REF/refs\/tags\/v/}"
+          echo "::set-output name=short_sha::$(git rev-parse --short HEAD)"
+      - name: Release Production Build
+        uses: docker/build-push-action@v2
+        if: "!contains(github.ref, 'develop')"
+        with:
+          build-args: |
+            VERSION=${{ steps.build_info.outputs.version_tag }}
+          labels: ${{ steps.docker_meta.outputs.labels }}
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: ${{ steps.docker_meta.outputs.tags }}
+      - name: Release Development Build
+        uses: docker/build-push-action@v2
+        if: "contains(github.ref, 'develop')"
+        with:
+          build-args: |
+            VERSION=dev-${{ steps.build_info.outputs.short_sha }}
+          labels: ${{ steps.docker_meta.outputs.labels }}
+          platforms: linux/amd64,linux/arm64
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.docker_meta.outputs.tags }}
--- a/.github/workflows/push.yaml
+++ b/.github/workflows/push.yaml
@@ -1,76 +0,0 @@
-name: Push
-
-on:
-  push:
-    branches:
-      - develop
-  pull_request:
-    branches:
-      - develop
-
-jobs:
-  build-and-test:
-    name: Build and Test
-    runs-on: ${{ matrix.os }}
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-24.04]
-        go: ["1.25.6"]
-        goos: [linux]
-        goarch: [amd64, arm64]
-    permissions:
-      contents: read
-    steps:
-      - name: Code checkout
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
-
-      - name: Setup Go
-        uses: actions/setup-go@7a3fe6cf4cb3a834922a1244abfce67bcef6a0c5 # v6.2.0
-        with:
-          go-version: ${{ matrix.go }}
-
-      - name: go mod download
-        env:
-          CGO_ENABLED: 0
-        run: |
-          go mod download
-
-      - name: Build
-        env:
-          GOOS: ${{ matrix.goos }}
-          GOARCH: ${{ matrix.goarch }}
-          CGO_ENABLED: 0
-          SRC_PATH: github.com/pterodactyl/wings
-        run: |
-          go build -v -trimpath -ldflags="-s -w -X ${SRC_PATH}/system.Version=dev-${GITHUB_SHA:0:7}" -o dist/wings ${SRC_PATH}
-          go build -v -trimpath -ldflags="-X ${SRC_PATH}/system.Version=dev-${GITHUB_SHA:0:7}" -o dist/wings_debug ${SRC_PATH}
-          chmod 755 dist/*
-
-      - name: go test
-        if: ${{ matrix.goarch == 'amd64' }}
-        env:
-          CGO_ENABLED: 0
-        run: |
-          go test $(go list ./...)
-
-      - name: go test -race
-        if: ${{ matrix.goarch == 'amd64' }}
-        env:
-          CGO_ENABLED: 1
-        run: |
-          go test -race $(go list ./...)
-
-      - name: Upload Release Artifact
-        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
-        if: ${{ (github.ref == 'refs/heads/develop' || github.event_name == 'pull_request') }}
-        with:
-          name: wings_linux_${{ matrix.goarch }}
-          path: dist/wings
-
-      - name: Upload Debug Artifact
-        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
-        if: ${{ (github.ref == 'refs/heads/develop' || github.event_name == 'pull_request') }}
-        with:
-          name: wings_linux_${{ matrix.goarch }}_debug
-          path: dist/wings_debug
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@@ -1,56 +0,0 @@
-name: Release
-on:
-  push:
-    tags:
-      - "v*"
-jobs:
-  release:
-    name: Release
-    runs-on: ubuntu-24.04
-    permissions:
-      contents: write
-    steps:
-      - name: Code checkout
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
-
-      - name: Setup Go
-        uses: actions/setup-go@7a3fe6cf4cb3a834922a1244abfce67bcef6a0c5 # v6.2.0
-        with:
-          go-version: 1.25.6
-
-      - name: Build release binaries
-        env:
-          CGO_ENABLED: 0
-        run: |
-          GOARCH=amd64 go build -o dist/wings_linux_amd64 -v -trimpath -ldflags="-s -w -X github.com/pterodactyl/wings/system.Version=${{ github.ref_name }}" github.com/pterodactyl/wings
-          chmod 755 dist/wings_linux_amd64
-          GOARCH=arm64 go build -o dist/wings_linux_arm64 -v -trimpath -ldflags="-s -w -X github.com/pterodactyl/wings/system.Version=${{ github.ref_name }}" github.com/pterodactyl/wings
-          chmod 755 dist/wings_linux_arm64
-
-      - name: Create release branch
-        env:
-          VERSION: ${{ github.ref_name }}
-        run: |
-          BRANCH=release/${{ env.VERSION }}
-          git config --local user.email "ci@pterodactyl.io"
-          git config --local user.name "Pterodactyl CI"
-          git checkout -b $BRANCH
-          git push -u origin $BRANCH
-          sed -i "s/var Version = \".*\"/var Version = \"${VERSION:1}\"/" system/const.go
-          git add system/const.go
-          git commit -m "ci(release): bump version"
-          git push
-
-      - name: write changelog
-        run: |
-          sed -n "/^## ${{ github.ref_name }}/,/^## /{/^## /b;p}" CHANGELOG.md > ./RELEASE_CHANGELOG
-
-      - uses: softprops/action-gh-release@a06a81a03ee405af7f2048a818ed3f03bbf83c7b # v2.5.0
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          draft: true
-          prerelease: ${{ contains(github.ref_name, 'rc') || contains(github.ref_name, 'beta') || contains(github.ref_name, 'alpha') }}
-          body_path: ./RELEASE_CHANGELOG
-          files: |
-            dist/*
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -0,0 +1,89 @@
+name: Create Release
+on:
+  push:
+    tags:
+      - 'v*'
+jobs:
+  release:
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Code Checkout
+        uses: actions/checkout@v2
+      - uses: actions/setup-go@v2
+        with:
+          go-version: '^1.17'
+      - name: Build
+        env:
+          REF: ${{ github.ref }}
+        run: |
+          CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags="-s -w -X github.com/pterodactyl/wings/system.Version=${REF:11}" -o build/wings_linux_amd64 -v wings.go
+          CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -ldflags="-s -w -X github.com/pterodactyl/wings/system.Version=${REF:11}" -o build/wings_linux_arm64 -v wings.go
+      - name: Test
+        run: go test ./...
+      - name: Compress binary and make it executable
+        run: |
+          upx build/wings_linux_amd64 && chmod +x build/wings_linux_amd64
+          upx build/wings_linux_arm64 && chmod +x build/wings_linux_arm64
+      - name: Extract changelog
+        env:
+          REF: ${{ github.ref }}
+        run: |
+          sed -n "/^## ${REF:10}/,/^## /{/^## /b;p}" CHANGELOG.md > ./RELEASE_CHANGELOG
+          echo ::set-output name=version_name::`sed -nr "s/^## (${REF:10} .*)$/\1/p" CHANGELOG.md`
+      - name: Create checksum and add to changelog
+        run: |
+          SUM=`cd build && sha256sum wings_linux_amd64`
+          SUM2=`cd build && sha256sum wings_linux_arm64`
+          echo -e "\n#### SHA256 Checksum\n\`\`\`\n$SUM\n$SUM2\n\`\`\`\n" >> ./RELEASE_CHANGELOG
+          echo -e "$SUM\n$SUM2" > checksums.txt
+      - name: Create release branch
+        env:
+          REF: ${{ github.ref }}
+        run: |
+          BRANCH=release/${REF:10}
+          git config --local user.email "ci@pterodactyl.io"
+          git config --local user.name "Pterodactyl CI"
+          git checkout -b $BRANCH
+          git push -u origin $BRANCH
+          sed -i "s/var Version = \".*\"/var Version = \"${REF:11}\"/" system/const.go
+          git add system/const.go
+          git commit -m "bump version for release"
+          git push
+      - name: Create Release
+        id: create_release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ github.ref }}
+          release_name: ${{ steps.extract_changelog.outputs.version_name }}
+          body_path: ./RELEASE_CHANGELOG
+          draft: true
+          prerelease: ${{ contains(github.ref, 'beta') || contains(github.ref, 'alpha') }}
+      - name: Upload amd64 Binary
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: build/wings_linux_amd64
+          asset_name: wings_linux_amd64
+          asset_content_type: application/octet-stream
+      - name: Upload arm64 Binary
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: build/wings_linux_arm64
+          asset_name: wings_linux_arm64
+          asset_content_type: application/octet-stream
+      - name: Upload checksum
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: ./checksums.txt
+          asset_name: checksums.txt
+          asset_content_type: text/plain
--- a/.gitignore
+++ b/.gitignore
@@ -23,8 +23,6 @@
 # ignore configuration file
 /config.yml
 /config*.yml
-/config.yaml
-/config*.yaml

 # Ignore Vagrant stuff
 /.vagrant
@@ -51,4 +49,3 @@ debug
 .DS_Store
 *.pprof
 *.pdf
-pprof.*
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,227 +1,5 @@
 # Changelog

-## v1.12.1
-### Added
-* Add mount for /etc/machine-id for servers for Hytale ([#292](https://github.com/pterodactyl/wings/pull/292))
-
-## v1.12.0
-### Fixed
-* [CVE-2025-68954](https://github.com/pterodactyl/panel/security/advisories/GHSA-8c39-xppg-479c)
-* [CVE-2025-69199](https://github.com/pterodactyl/panel/security/advisories/GHSA-8w7m-w749-rx98)
-* [CVE-2026-21696](https://github.com/pterodactyl/wings/security/advisories/GHSA-2497-gp99-2m74)
-* Fixes folders not being sorted before files when returning list of directory contents ([#5078](https://github.com/pterodactyl/panel/issues/5078))
-* User-defined labels not being passed to environment ([#191](https://github.com/pterodactyl/wings/pulls/191))
-* Fixes handling of termination signals for containers ([#192](https://github.com/pterodactyl/wings/pulls/192))
-* Fixes logic to use base2 (1024, *bibyte) when calculating memory limits ([#190](https://github.com/pterodactyl/wings/pulls/190))
-* Fixes hard-links being counted multiple times when calculating disk usage ([#181](https://github.com/pterodactyl/wings/pulls/181))
-
-### Added
-* Support relative file paths for the Wings config ([#180](https://github.com/pterodactyl/wings/pull/180))
-* Support mounting generated `/etc/passwd` files to containers ([#197](https://github.com/pterodactyl/wings/pulls/197))
-
-## v1.11.13
-### Fixed
-* Auto-configure not working ([#5087](https://github.com/pterodactyl/panel/issues/5087))
-* Individual files unable to be decompressed ([#5034](https://github.com/pterodactyl/panel/issues/5034))
-
-## v1.11.12
-### Fixed
-* Arbitrary File Write/Read ([GHSA-gqmf-jqgv-v8fw](https://github.com/pterodactyl/wings/security/advisories/GHSA-gqmf-jqgv-v8fw))
-* Server-side Request Forgery (SSRF) during remote file pull ([GHSA-qq22-jj8x-4wwv](https://github.com/pterodactyl/wings/security/advisories/GHSA-qq22-jj8x-4wwv))
-* Invalid `Content-Type` being used with the `wings diagnostics` command ([#186](https://github.com/pterodactyl/wings/pull/186))
-
-## v1.11.11
-### Fixed
-* Backups missing content when a `.pteroignore` file is used
-* Archives originating from a subdirectory not containing any files ([#5030](https://github.com/pterodactyl/panel/issues/5030))
-
-## v1.11.10
-### Fixed
-* Archives randomly ignoring files and directories ([#5027](https://github.com/pterodactyl/panel/issues/5027))
-* Crash when deleting or transferring a server ([#5028](https://github.com/pterodactyl/panel/issues/5028))
-
-## v1.11.9
-### Changed
-* Release binaries are now built with Go 1.21.8
-* Updated Go dependencies
-
-### Fixed
-* [CVE-2024-27102](https://www.cve.org/CVERecord?id=CVE-2024-27102)
-
-## v1.11.8
-### Changed
-* Release binaries are now built with Go 1.20.10 (resolves [CVE-2023-44487](https://www.cve.org/CVERecord?id=CVE-2023-44487))
-* Updated Go dependencies
-
-## v1.11.7
-### Changed
-* Updated Go dependencies (this resolves an issue related to `http: invalid Host header` with Docker)
-* Wings is now built with go1.19.11
-
-## v1.11.6
-### Fixed
-* CVE-2023-32080
-
-## v1.11.5
-### Added
-* Added a config option to disable Wings config.yml updates from the Panel (https://github.com/pterodactyl/wings/commit/ec6d6d83ea3eb14995c24f001233e85b37ffb87b)
-
-### Changed
-* Wings is now built with Go 1.19.7
-
-### Fixed
-* Fixed archives containing partially matched file names (https://github.com/pterodactyl/wings/commit/43b3496f0001cec231c80af1f9a9b3417d04e8d4)
-
-## v1.11.4
-### Fixed
-* CVE-2023-25168
-
-## v1.11.3
-### Fixed
-* CVE-2023-25152
-
-## v1.11.2
-### Fixed
-* Backups being restored from remote storage (s3) erroring out due to a closed stream.
-* Fix IP validation logic for activity logs filtering out valid IPs instead of invalid IPs
-
-## v1.11.1
-### Changed
-* Release binaries are now built with Go 1.18.10
-* Timeout when stopping a server before a transfer begins has been reduced to 15 seconds from 1 minute
-* Removed insecure SSH protocols for use with the SFTP server
-
-### Fixed
-* Unnecessary Docker client connections being left open, causing a slow leak of file descriptors
-* Files being left open in parts of the server's filesystem, causing a leak of file descriptors
-* IPv6 addresses being corrupted by flawed port stripping logic for activity logs, old entries with malformed IPs will be deleted from the local SQLite database automatically
-* A server that times out while being stopped at the beginning of a transfer no longer causes the server to become stuck in a transferring state
-
-## v1.11.0
-### Added (since 1.7.2)
-* More detailed information returned by the `/api/system` endpoint when using the `?v=2` query parameter.
-
-### Changed (since 1.7.2)
-* Send re-installation status separately from installation status.
-* Wings release versions will now follow the major and minor version of the Panel.
-* Transfers no longer buffer to disk, instead they are fully streamed with only a small amount of memory used for buffering.
-* Release binaries are no longer compressed with UPX.
-* Use `POST` instead of `GET` for sending the status of a transfer to the Panel.
-
-### Fixed (since 1.7.2)
-* Fixed servers outgoing IP not being updated whenever a server's primary allocation is changed when using the Force Outgoing IP option.
-* Fixed servers being terminated rather than gracefully stopped when a signal is used to stop the container rather than a command.
-* Fixed file not found errors being treated as an internal error, they are now treated as a 404.
-* Wings can be run with Podman instead of Docker, this is still experimental and not recommended for production use.
-* Archive progress is now reported correctly.
-* Labels for containers can now be set by the Panel.
-* Fixed servers becoming deadlocked when the target node of a transfer goes offline.
-
-## v1.11.0-rc.2
-### Added
-* More detailed information returned by the `/api/system` endpoint when using the `?v=2` query parameter.
-
-### Changed
-* Send reinstallation status separately from installation status.
-
-### Fixed
-* Fixed servers outgoing IP not being updated whenever a server's primary allocation is changed when using the Force Outgoing IP option.
-* Fixed servers being terminated rather than gracefully stopped when a signal is used to stop the container rather than a command.
-* Fixed file not found errors being treated as an internal error, they are now treated as a 404.
-
-## v1.11.0-rc.1
-### Changed
-* Wings release versions will now follow the major and minor version of the panel.
-* Transfers no longer buffer to disk, instead they are fully streamed with only a small amount of memory used for buffering.
-* Release binaries are no longer compressed with UPX.
-
-### Fixed
-* Wings can be run with podman instead of Docker, this is still experimental and not recommended for production use.
-* Archive progress is now reported correctly.
-* Labels for containers can now be set by the Panel.
-
-## v1.7.5
-### Fixed
-* CVE-2023-32080
-
-## v1.7.4
-### Fixed
-* CVE-2023-25168
-
-## v1.7.3
-### Fixed
-* CVE-2023-25152
-
-## v1.7.2
-### Fixed
-* The S3 backup driver now supports Cloudflare R2
-
-### Added
-* During a server transfer, there is a new "Archiving" status that outputs the progress of creating the server transfer archive.
-* Adds a configuration option to control the list of trusted proxies that can be used to determine the client IP address.
-* Adds a configuration option to control the Docker username space setting when Wings creates containers.
-
-### Changed
-* Releases are now built using `Go 1.18` — the minimum version required to build Wings is now `Go 1.18`.
-
-## v1.7.1
-### Fixed
-* YAML parser has been updated to fix some strange issues
-
-### Added
-* Added `Force Outgoing IP` option for servers to ensure outgoing traffic uses the server's IP address
-* Adds an option to control the level of gzip compression for backups
-
-## v1.7.0
-### Fixed
-* Fixes multi-platform support for Wings' Docker image.
-
-### Added
-* Adds support for tracking of SFTP actions, power actions, server commands, and file uploads by utilizing a local SQLite database and processing events before sending them to the Panel.
-* Adds support for configuring the MTU on the `pterodactyl0` network.
-
-## v1.6.4
-### Fixed
-* Fixes a bug causing CPU limiting to not be properly applied to servers.
-* Fixes a bug causing zip archives to decompress without taking into account nested folder structures.
-
-## v1.6.3
-### Fixed
-* Fixes SFTP authentication failing for administrative users due to a permissions adjustment on the Panel.
-
-## v1.6.2
-### Fixed
-* Fixes file upload size not being properly enforced.
-* Fixes a bug that prevented listing a directory when it contained a named pipe. Also added a check to prevent attempting to read a named pipe directly.
-* Fixes a bug with the archiver logic that would include folders that had the same name prefix. (for example, requesting only `map` would also include `map2` and `map3`)
-* Requests to the Panel that return a client error (4xx response code) no longer trigger an exponential backoff, they immediately stop the request.
-
-### Changed
-* CPU limit fields are only set on the Docker container if they have been specified for the server — otherwise they are left empty.
-
-### Added
-* Added the ability to define the location of the temporary folder used by Wings — defaults to `/tmp/pterodactyl`.
-* Adds the ability to authenticate for SFTP using public keys (requires `Panel@1.8.0`).
-
-## v1.6.1
-### Fixed
-* Fixes error that would sometimes occur when starting a server that would cause the temporary power action lock to never be released due to a blocked channel.
-* Fixes a bug causing the CPU usage of Wings to get stuck at 100% when a server is deleted while the installation process is running.
-
-### Changed
-* Cleans up a lot of the logic for handling events between the server and environment process to make it easier to make modifications to down the road.
-* Cleans up logic handling the `StopAndWait` logic for stopping a server gracefully before terminating the process if it does not respond.
-
-## v1.6.0
-### Fixed
-* Internal logic for processing a server start event has been adjusted to attach to the Docker container before attempting to start the container. This should fix issues where a server would get stuck after pulling the container image.
-* Fixes a bug in the console output that was dropping console lines when a large number of lines were sent at once.
-
-### Changed
-* Removed the console throttle logic that would terminate a server instance that was sending too much data. This logic has been replaced with simpler logic that only throttles the console, it does not try to terminate the server. In addition, this change has reduced the number of go-routines needed by the application and dramatically simplified internal logic.
-* Removed the `--profiler` flag and replaced it with `--pprof` which will start an internal server listening on `localhost:6060` allowing you to use Go's standard `pprof` tooling.
-* Replaced the `json` log driver for Docker containers with `local` to reduce the amount of overhead when it comes to streaming logs from instances.
-
 ## v1.5.6
 ### Fixed
 * Rewrote handler logic for the power actions lock to hopefully address issues people have been having when a server crashes and they're unable to start it again until restarting Wings.
--- a/14
+++ b/14
@@ -1,28 +1,26 @@
 # Stage 1 (Build)
-FROM golang:1.25.6-alpine AS builder
+FROM --platform=$BUILDPLATFORM golang:1.17-alpine AS builder

 ARG VERSION
-RUN apk add --update --no-cache git make mailcap
+RUN apk add --update --no-cache git make upx
 WORKDIR /app/
 COPY go.mod go.sum /app/
 RUN go mod download
 COPY . /app/
-RUN CGO_ENABLED=0 go build \
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build \
    -ldflags="-s -w -X github.com/pterodactyl/wings/system.Version=$VERSION" \
    -v \
    -trimpath \
    -o wings \
    wings.go
+RUN upx wings
 RUN echo "ID=\"distroless\"" > /etc/os-release

 # Stage 2 (Final)
 FROM gcr.io/distroless/static:latest
 COPY --from=builder /etc/os-release /etc/os-release
-COPY --from=builder /etc/mime.types /etc/mime.types

 COPY --from=builder /app/wings /usr/bin/
+CMD [ "/usr/bin/wings", "--config", "/etc/pterodactyl/config.yml" ]

-ENTRYPOINT ["/usr/bin/wings"]
-CMD ["--config", "/etc/pterodactyl/config.yml"]
-
-EXPOSE 8080 2022
+EXPOSE 8080
--- a/7
+++ b/7
@@ -5,8 +5,8 @@ build:
 	GOOS=linux GOARCH=arm64 go build -ldflags="-s -w" -gcflags "all=-trimpath=$(pwd)" -o build/wings_linux_arm64 -v wings.go

 debug:
-	go build -ldflags="-X github.com/pterodactyl/wings/system.Version=$(GIT_HEAD)"
-	sudo ./wings --debug --ignore-certificate-errors --config config.yml --pprof --pprof-block-rate 1
+	go build -ldflags="-X github.com/pterodactyl/wings/system.Version=$(GIT_HEAD)" -race
+	sudo ./wings --debug --ignore-certificate-errors --config config.yml

 # Runs a remotly debuggable session for Wings allowing an IDE to connect and target
 # different breakpoints.
@@ -14,6 +14,9 @@ rmdebug:
 	go build -gcflags "all=-N -l" -ldflags="-X github.com/pterodactyl/wings/system.Version=$(GIT_HEAD)" -race
 	sudo dlv --listen=:2345 --headless=true --api-version=2 --accept-multiclient exec ./wings -- --debug --ignore-certificate-errors --config config.yml

+compress:
+	upx --brute build/wings_*
+
 cross-build: clean build compress

 clean:
--- a/README.md
+++ b/README.md
@@ -5,7 +5,6 @@
 [![Go Report Card](https://goreportcard.com/badge/github.com/pterodactyl/wings)](https://goreportcard.com/report/github.com/pterodactyl/wings)

 # Pterodactyl Wings
-
 Wings is Pterodactyl's server control plane, built for the rapidly changing gaming industry and designed to be
 highly performant and secure. Wings provides an HTTP API allowing you to interface directly with running server
 instances, fetch server logs, generate backups, and control all aspects of the server lifecycle.
@@ -14,28 +13,36 @@ In addition, Wings ships with a built-in SFTP server allowing your system to rem
 dependencies, and allowing users to authenticate with the same credentials they would normally use to access the Panel.

 ## Sponsors
+I would like to extend my sincere thanks to the following sponsors for helping find Pterodactyl's developement.
+[Interested in becoming a sponsor?](https://github.com/sponsors/DaneEveritt)

-I would like to extend my sincere thanks to the following sponsors for helping fund Pterodactyl's development.
-[Interested in becoming a sponsor?](https://github.com/sponsors/pterodactyl)
-
-| Company                                                                           | About                                                                                                                                                                                                                                           |
-|-----------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| [**Aussie Server Hosts**](https://aussieserverhosts.com/)                         | No frills Australian Owned and operated High Performance Server hosting for some of the most demanding games serving Australia and New Zealand.                                                                                                 |
-| [**BisectHosting**](https://www.bisecthosting.com/)                               | BisectHosting provides Minecraft, Valheim and other server hosting services with the highest reliability and lightning fast support since 2012.                                                                                                 |
-| [**MineStrator**](https://minestrator.com/)                                       | Looking for the most highend French hosting company for your minecraft server? More than 24,000 members on our discord trust us. Give us a try!                                                                                                 |
-| [**HostEZ**](https://hostez.io)                                                   | US & EU Rust & Minecraft Hosting. DDoS Protected bare metal, VPS and colocation with low latency, high uptime and maximum availability. EZ!                                                                                                     |
-| [**Blueprint**](https://blueprint.zip/?utm_source=pterodactyl&utm_medium=sponsor) | Create and install Pterodactyl addons and themes with the growing Blueprint framework - the package-manager for Pterodactyl. Use multiple modifications at once without worrying about conflicts and make use of the large extension ecosystem. |
-| [**indifferent broccoli**](https://indifferentbroccoli.com/)                      | indifferent broccoli is a game server hosting and rental company. With us, you get top-notch computer power for your gaming sessions. We destroy lag, latency, and complexity--letting you focus on the fun stuff.                              |
+| Company | About |
+| ------- | ----- |
+| [**WISP**](https://wisp.gg) | Extra features. |
+| [**MixmlHosting**](https://mixmlhosting.com) | MixmlHosting provides high quality Virtual Private Servers along with game servers, all at a affordable price. |
+| [**BisectHosting**](https://www.bisecthosting.com/) | BisectHosting provides Minecraft, Valheim and other server hosting services with the highest reliability and lightning fast support since 2012. |
+| [**Bloom.host**](https://bloom.host) | Bloom.host offers dedicated core VPS and Minecraft hosting with Ryzen 9 processors. With owned-hardware, we offer truly unbeatable prices on high-performance hosting. |
+| [**MineStrator**](https://minestrator.com/) | Looking for a French highend hosting company for you minecraft server? More than 14,000 members on our discord, trust us. |
+| [**DedicatedMC**](https://dedicatedmc.io/) | DedicatedMC provides Raw Power hosting at affordable pricing, making sure to never compromise on your performance and giving you the best performance money can buy. |
+| [**Skynode**](https://www.skynode.pro/) | Skynode provides blazing fast game servers along with a top-notch user experience. Whatever our clients are looking for, we're able to provide it! |
+| [**XCORE**](https://xcore-server.de/) | XCORE offers High-End Servers for hosting and gaming since 2012. Fast, excellent and well-known for eSports Gaming. |
+| [**RoyaleHosting**](https://royalehosting.net/) | Build your dreams and deploy them with RoyaleHosting’s reliable servers and network. Easy to use, provisioned in a couple of minutes. |
+| [**Spill Hosting**](https://spillhosting.no/) | Spill Hosting is a Norwegian hosting service, which aims for inexpensive services on quality servers. Premium i9-9900K processors will run your game like a dream. |
+| [**DeinServerHost**](https://deinserverhost.de/) | DeinServerHost offers Dedicated, vps and Gameservers for many popular Games like Minecraft and Rust in Germany since 2013. |
+| [**HostBend**](https://hostbend.com/) | HostBend offers a variety of solutions for developers, students, and others who have a tight budget but don't want to compromise quality and support. |
+| [**Capitol Hosting Solutions**](https://chs.gg/) | CHS is *the* budget friendly hosting company for Australian and American gamers, offering a variety of plans from Web Hosting to Game Servers; Custom Solutions too! |
+| [**ByteAnia**](https://byteania.com/?utm_source=pterodactyl) | ByteAnia offers the best performing and most affordable **Ryzen 5000 Series hosting** on the market for *unbeatable prices*! |
+| [**Aussie Server Hosts**](https://aussieserverhosts.com/) | No frills Australian Owned and operated High Performance Server hosting for some of the most demanding games serving Australia and New Zealand. |
+| [**VibeGAMES**](https://vibegames.net/) | VibeGAMES is a game server provider that specializes in DDOS protection for the games we offer. We have multiple locations in the US, Brazil, France, Germany, Singapore, Australia and South Africa.|
+| [**RocketNode**](https://rocketnode.net) | RocketNode is a VPS and Game Server provider that offers the best performing VPS and Game hosting Solutions at affordable prices! |

 ## Documentation
-
 * [Panel Documentation](https://pterodactyl.io/panel/1.0/getting_started.html)
 * [Wings Documentation](https://pterodactyl.io/wings/1.0/installing.html)
 * [Community Guides](https://pterodactyl.io/community/about.html)
 * Or, get additional help [via Discord](https://discord.gg/pterodactyl)

 ## Reporting Issues
-
 Please use the [pterodactyl/panel](https://github.com/pterodactyl/panel) repository to report any issues or make
 feature requests for Wings. In addition, the [security policy](https://github.com/pterodactyl/panel/security/policy) listed
 within that repository also applies to Wings.
--- a/cmd/configure.go
+++ b/cmd/configure.go
@@ -2,7 +2,6 @@ package cmd

 import (
 	"crypto/tls"
-	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
@@ -14,6 +13,7 @@ import (

 	"github.com/AlecAivazis/survey/v2"
 	"github.com/AlecAivazis/survey/v2/terminal"
+	"github.com/goccy/go-json"
 	"github.com/spf13/cobra"

 	"github.com/pterodactyl/wings/config"
@@ -125,7 +125,7 @@ func configureCmdRun(cmd *cobra.Command, args []string) {
 	}

 	fmt.Printf("%+v", req.Header)
-	fmt.Println(req.URL.String())
+	fmt.Printf(req.URL.String())

 	res, err := c.Do(req)
 	if err != nil {
@@ -155,9 +155,6 @@ func configureCmdRun(cmd *cobra.Command, args []string) {
 		panic(err)
 	}

-	// Manually specify the Panel URL as it won't be decoded from JSON.
-	cfg.PanelLocation = configureArgs.PanelURL
-
 	if err = config.WriteToDisk(cfg); err != nil {
 		panic(err)
 	}
--- a/cmd/diagnostics.go
+++ b/cmd/diagnostics.go
@@ -2,7 +2,6 @@ package cmd

 import (
 	"context"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
@@ -18,9 +17,9 @@ import (
 	"github.com/AlecAivazis/survey/v2/terminal"
 	"github.com/apex/log"
 	"github.com/docker/docker/api/types"
-	dockersystem "github.com/docker/docker/api/types/system"
 	"github.com/docker/docker/pkg/parsers/kernel"
 	"github.com/docker/docker/pkg/parsers/operatingsystem"
+	"github.com/goccy/go-json"
 	"github.com/spf13/cobra"

 	"github.com/pterodactyl/wings/config"
@@ -59,14 +58,14 @@ func newDiagnosticsCommand() *cobra.Command {
 	return command
 }

-// diagnosticsCmdRun collects diagnostics about wings, its configuration and the node.
+// diagnosticsCmdRun collects diagnostics about wings, it's configuration and the node.
 // We collect:
 // - wings and docker versions
 // - relevant parts of daemon configuration
 // - the docker debug output
 // - running docker containers
 // - logs
-func diagnosticsCmdRun(*cobra.Command, []string) {
+func diagnosticsCmdRun(cmd *cobra.Command, args []string) {
 	questions := []*survey.Question{
 		{
 			Name:   "IncludeEndpoints",
@@ -207,18 +206,18 @@ func diagnosticsCmdRun(*cobra.Command, []string) {
 	}
 }

-func getDockerInfo() (types.Version, dockersystem.Info, error) {
+func getDockerInfo() (types.Version, types.Info, error) {
 	client, err := environment.Docker()
 	if err != nil {
-		return types.Version{}, dockersystem.Info{}, err
+		return types.Version{}, types.Info{}, err
 	}
 	dockerVersion, err := client.ServerVersion(context.Background())
 	if err != nil {
-		return types.Version{}, dockersystem.Info{}, err
+		return types.Version{}, types.Info{}, err
 	}
 	dockerInfo, err := client.Info(context.Background())
 	if err != nil {
-		return types.Version{}, dockersystem.Info{}, err
+		return types.Version{}, types.Info{}, err
 	}
 	return dockerVersion, dockerInfo, nil
 }
@@ -230,8 +229,8 @@ func uploadToHastebin(hbUrl, content string) (string, error) {
 		return "", err
 	}
 	u.Path = path.Join(u.Path, "documents")
-	res, err := http.Post(u.String(), "text/plain", r)
-	if err != nil || res.StatusCode < 200 || res.StatusCode >= 300 {
+	res, err := http.Post(u.String(), "plain/text", r)
+	if err != nil || res.StatusCode != 200 {
 		fmt.Println("Failed to upload report to ", u.String(), err)
 		return "", err
 	}
--- a/cmd/root.go
+++ b/cmd/root.go
@@ -7,13 +7,11 @@ import (
 	"fmt"
 	log2 "log"
 	"net/http"
-	_ "net/http/pprof"
 	"os"
 	"path"
 	"path/filepath"
-	"runtime"
 	"strconv"
-	"syscall"
+	"strings"
 	"time"

 	"github.com/NYTimes/logrotate"
@@ -22,14 +20,13 @@ import (
 	"github.com/docker/docker/client"
 	"github.com/gammazero/workerpool"
 	"github.com/mitchellh/colorstring"
+	"github.com/pkg/profile"
 	"github.com/spf13/cobra"
 	"golang.org/x/crypto/acme"
 	"golang.org/x/crypto/acme/autocert"

 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
-	"github.com/pterodactyl/wings/internal/cron"
-	"github.com/pterodactyl/wings/internal/database"
 	"github.com/pterodactyl/wings/loggers/cli"
 	"github.com/pterodactyl/wings/remote"
 	"github.com/pterodactyl/wings/router"
@@ -78,10 +75,8 @@ func init() {
 	rootCommand.PersistentFlags().BoolVar(&debug, "debug", false, "pass in order to run wings in debug mode")

 	// Flags specifically used when running the API.
-	rootCommand.Flags().Bool("pprof", false, "if the pprof profiler should be enabled. The profiler will bind to localhost:6060 by default")
-	rootCommand.Flags().Int("pprof-block-rate", 0, "enables block profile support, may have performance impacts")
-	rootCommand.Flags().Int("pprof-port", 6060, "If provided with --pprof, the port it will run on")
-	rootCommand.Flags().Bool("auto-tls", false, "pass in order to have wings generate and manage its own SSL certificates using Let's Encrypt")
+	rootCommand.Flags().String("profiler", "", "the profiler to run for this instance")
+	rootCommand.Flags().Bool("auto-tls", false, "pass in order to have wings generate and manage it's own SSL certificates using Let's Encrypt")
 	rootCommand.Flags().String("tls-hostname", "", "required with --auto-tls, the FQDN for the generated SSL certificate")
 	rootCommand.Flags().Bool("ignore-certificate-errors", false, "ignore certificate verification errors when executing API calls")

@@ -91,6 +86,25 @@ func init() {
 }

 func rootCmdRun(cmd *cobra.Command, _ []string) {
+	switch cmd.Flag("profiler").Value.String() {
+	case "cpu":
+		defer profile.Start(profile.CPUProfile).Stop()
+	case "mem":
+		defer profile.Start(profile.MemProfile).Stop()
+	case "alloc":
+		defer profile.Start(profile.MemProfile, profile.MemProfileAllocs).Stop()
+	case "heap":
+		defer profile.Start(profile.MemProfile, profile.MemProfileHeap).Stop()
+	case "routines":
+		defer profile.Start(profile.GoroutineProfile).Stop()
+	case "mutex":
+		defer profile.Start(profile.MutexProfile).Stop()
+	case "threads":
+		defer profile.Start(profile.ThreadcreationProfile).Stop()
+	case "block":
+		defer profile.Start(profile.BlockProfile).Stop()
+	}
+
 	printLogo()
 	log.Debug("running in debug mode")
 	log.WithField("config_file", configPath).Info("loading configuration from file")
@@ -104,20 +118,15 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {

 	if err := config.ConfigureTimezone(); err != nil {
 		log.WithField("error", err).Fatal("failed to detect system timezone or use supplied configuration value")
-		return
 	}
 	log.WithField("timezone", config.Get().System.Timezone).Info("configured wings with system timezone")
 	if err := config.ConfigureDirectories(); err != nil {
 		log.WithField("error", err).Fatal("failed to configure system directories for pterodactyl")
 		return
 	}
+	log.WithField("username", config.Get().System.User).Info("checking for pterodactyl system user")
 	if err := config.EnsurePterodactylUser(); err != nil {
 		log.WithField("error", err).Fatal("failed to create pterodactyl system user")
-		return
-	}
-	if err := config.ConfigurePasswd(); err != nil {
-		log.WithField("error", err).Fatal("failed to configure container passwd file")
-		return
 	}
 	log.WithFields(log.Fields{
 		"username": config.Get().System.Username,
@@ -129,37 +138,25 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 		return
 	}

-	t := config.Get().Token
 	pclient := remote.New(
 		config.Get().PanelLocation,
-		remote.WithCredentials(t.ID, t.Token),
+		remote.WithCredentials(config.Get().AuthenticationTokenId, config.Get().AuthenticationToken),
 		remote.WithHttpClient(&http.Client{
 			Timeout: time.Second * time.Duration(config.Get().RemoteQuery.Timeout),
 		}),
 	)

-	if err := database.Initialize(); err != nil {
-		log.WithField("error", err).Fatal("failed to initialize database")
-		return
-	}
-
 	manager, err := server.NewManager(cmd.Context(), pclient)
 	if err != nil {
 		log.WithField("error", err).Fatal("failed to load server configurations")
-		return
 	}

 	if err := environment.ConfigureDocker(cmd.Context()); err != nil {
 		log.WithField("error", err).Fatal("failed to configure docker environment")
-		return
 	}

 	if err := config.WriteToDisk(config.Get()); err != nil {
-		if !errors.Is(err, syscall.EROFS) {
-			log.WithField("error", err).Error("failed to write configuration to disk")
-		} else {
-			log.WithField("error", err).Debug("failed to write configuration to disk")
-		}
+		log.WithField("error", err).Fatal("failed to write configuration to disk")
 	}

 	// Just for some nice log output.
@@ -175,7 +172,7 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 	ticker := time.NewTicker(time.Minute)
 	// Every minute, write the current server states to the disk to allow for a more
 	// seamless hard-reboot process in which wings will re-sync server states based
-	// on its last tracked state.
+	// on it's last tracked state.
 	go func() {
 		for {
 			select {
@@ -197,9 +194,9 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 	for _, serv := range manager.All() {
 		s := serv

-		// For each server ensure the minimal environment is configured for the server.
-		if err := s.CreateEnvironment(); err != nil {
-			s.Log().WithField("error", err).Error("could not create base environment for server...")
+		// For each server we encounter make sure the root data directory exists.
+		if err := s.EnsureDataDirectoryExists(); err != nil {
+			s.Log().Error("could not create root data directory for server: not loading server...")
 			continue
 		}

@@ -278,13 +275,6 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 		}
 	}()

-	if s, err := cron.Scheduler(cmd.Context(), manager); err != nil {
-		log.WithField("error", err).Fatal("failed to initialize cron system")
-	} else {
-		log.WithField("subsystem", "cron").Info("starting cron processes")
-		s.StartAsync()
-	}
-
 	go func() {
 		// Run the SFTP server.
 		if err := sftp.New(manager).Run(); err != nil {
@@ -335,20 +325,6 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 		TLSConfig: config.DefaultTLSConfig,
 	}

-	profile, _ := cmd.Flags().GetBool("pprof")
-	if profile {
-		if r, _ := cmd.Flags().GetInt("pprof-block-rate"); r > 0 {
-			runtime.SetBlockProfileRate(r)
-		}
-		// Catch at least 1% of mutex contention issues.
-		runtime.SetMutexProfileFraction(100)
-
-		profilePort, _ := cmd.Flags().GetInt("pprof-port")
-		go func() {
-			http.ListenAndServe(fmt.Sprintf("localhost:%d", profilePort), nil)
-		}()
-	}
-
 	// Check if the server should run with TLS but using autocert.
 	if autotls {
 		m := autocert.Manager{
@@ -376,7 +352,7 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 		return
 	}

-	// Check if main http server should run with TLS. Otherwise, reset the TLS
+	// Check if main http server should run with TLS. Otherwise reset the TLS
 	// config on the server and then serve it over normal HTTP.
 	if api.Ssl.Enabled {
 		if err := s.ListenAndServeTLS(api.Ssl.CertificateFile, api.Ssl.KeyFile); err != nil {
@@ -393,14 +369,13 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 // Reads the configuration from the disk and then sets up the global singleton
 // with all the configuration values.
 func initConfig() {
-	if !filepath.IsAbs(configPath) {
-		d, err := filepath.Abs(configPath)
+	if !strings.HasPrefix(configPath, "/") {
+		d, err := os.Getwd()
 		if err != nil {
-			log2.Fatalf("cmd/root: failed to get path to config file: %s", err)
+			log2.Fatalf("cmd/root: could not determine directory: %s", err)
 		}
-		configPath = d
+		configPath = path.Clean(path.Join(d, configPath))
 	}
-
 	err := config.FromFile(configPath)
 	if err != nil {
 		if errors.Is(err, os.ErrNotExist) {
@@ -455,18 +430,18 @@ in all copies or substantial portions of the Software.%s`), system.Version, time
 }

 func exitWithConfigurationNotice() {
-	fmt.Printf(colorstring.Color(`
+	fmt.Print(colorstring.Color(`
 [_red_][white][bold]Error: Configuration File Not Found[reset]

 Wings was not able to locate your configuration file, and therefore is not
 able to complete its boot process. Please ensure you have copied your instance
 configuration file into the default location below.

-Default Location: %s
+Default Location: /etc/pterodactyl/config.yml

 [yellow]This is not a bug with this software. Please do not make a bug report
 for this issue, it will be closed.[reset]

-`), config.DefaultLocation)
+`))
 	os.Exit(1)
 }
--- a/config/config.go
+++ b/config/config.go
@@ -1,7 +1,6 @@
 package config

 import (
-	"bytes"
 	"context"
 	"crypto/tls"
 	"fmt"
@@ -17,8 +16,8 @@ import (
 	"time"

 	"emperror.dev/errors"
-	"github.com/acobaugh/osrelease"
 	"github.com/apex/log"
+	"github.com/cobaugh/osrelease"
 	"github.com/creasty/defaults"
 	"github.com/gbrlsnchs/jwt/v3"
 	"gopkg.in/yaml.v2"
@@ -88,13 +87,10 @@ type ApiConfiguration struct {
 	// Determines if functionality for allowing remote download of files into server directories
 	// is enabled on this instance. If set to "true" remote downloads will not be possible for
 	// servers.
-	DisableRemoteDownload bool `json:"-" yaml:"disable_remote_download"`
+	DisableRemoteDownload bool `json:"disable_remote_download" yaml:"disable_remote_download"`

-	// The maximum size for files uploaded through the Panel in MB.
-	UploadLimit int64 `default:"100" json:"upload_limit" yaml:"upload_limit"`
-
-	// A list of IP address of proxies that may send a X-Forwarded-For header to set the true clients IP
-	TrustedProxies []string `json:"trusted_proxies" yaml:"trusted_proxies"`
+	// The maximum size for files uploaded through the Panel in bytes.
+	UploadLimit int `default:"100" json:"upload_limit" yaml:"upload_limit"`
 }

 // RemoteQueryConfiguration defines the configuration settings for remote requests
@@ -122,23 +118,19 @@ type RemoteQueryConfiguration struct {
 // SystemConfiguration defines basic system configuration settings.
 type SystemConfiguration struct {
 	// The root directory where all of the pterodactyl data is stored at.
-	RootDirectory string `default:"/var/lib/pterodactyl" json:"-" yaml:"root_directory"`
+	RootDirectory string `default:"/var/lib/pterodactyl" yaml:"root_directory"`

 	// Directory where logs for server installations and other wings events are logged.
-	LogDirectory string `default:"/var/log/pterodactyl" json:"-" yaml:"log_directory"`
+	LogDirectory string `default:"/var/log/pterodactyl" yaml:"log_directory"`

 	// Directory where the server data is stored at.
-	Data string `default:"/var/lib/pterodactyl/volumes" json:"-" yaml:"data"`
+	Data string `default:"/var/lib/pterodactyl/volumes" yaml:"data"`

 	// Directory where server archives for transferring will be stored.
-	ArchiveDirectory string `default:"/var/lib/pterodactyl/archives" json:"-" yaml:"archive_directory"`
+	ArchiveDirectory string `default:"/var/lib/pterodactyl/archives" yaml:"archive_directory"`

 	// Directory where local backups will be stored on the machine.
-	BackupDirectory string `default:"/var/lib/pterodactyl/backups" json:"-" yaml:"backup_directory"`
-
-	// TmpDirectory specifies where temporary files for Pterodactyl installation processes
-	// should be created. This supports environments running docker-in-docker.
-	TmpDirectory string `default:"/tmp/pterodactyl" json:"-" yaml:"tmp_directory"`
+	BackupDirectory string `default:"/var/lib/pterodactyl/backups" yaml:"backup_directory"`

 	// The user that should own all of the server files, and be used for containers.
 	Username string `default:"pterodactyl" yaml:"username"`
@@ -153,62 +145,9 @@ type SystemConfiguration struct {
 	// Definitions for the user that gets created to ensure that we can quickly access
 	// this information without constantly having to do a system lookup.
 	User struct {
-		// Rootless controls settings related to rootless container daemons.
-		Rootless struct {
-			// Enabled controls whether rootless containers are enabled.
-			Enabled bool `yaml:"enabled" default:"false"`
-			// ContainerUID controls the UID of the user inside the container.
-			// This should likely be set to 0 so the container runs as the user
-			// running Wings.
-			ContainerUID int `yaml:"container_uid" default:"0"`
-			// ContainerGID controls the GID of the user inside the container.
-			// This should likely be set to 0 so the container runs as the user
-			// running Wings.
-			ContainerGID int `yaml:"container_gid" default:"0"`
-		} `yaml:"rootless"`
-
-		Uid int `yaml:"uid"`
-		Gid int `yaml:"gid"`
-	} `yaml:"user"`
-
-	// Passwd controls the mounting of a generated passwd files into containers started by Wings.
-	Passwd struct {
-		// Enable controls whether generated passwd files should be mounted into containers.
-		//
-		// By default this option is disabled and Wings will not mount any
-		// additional passwd files into containers.
-		Enable bool `yaml:"enabled" default:"false"`
-
-		// Directory is the directory on disk where the generated passwd files will be stored.
-		// This directory may be temporary as it will be re-created whenever Wings is started.
-		//
-		// This path **WILL** be both written to by Wings and mounted into containers created by
-		// Wings. If you are running Wings itself in a container, this path will need to be mounted
-		// into the Wings container as the exact path on the host, which should match the value
-		// specified here. If you are using SELinux, you will need to make sure this file has the
-		// correct SELinux context in order for containers to use it.
-		Directory string `yaml:"directory" default:"/run/wings/etc"`
-	} `yaml:"passwd"`
-
-	// MachineID controls the mounting of a generated `/etc/machine-id` file into containers started by Wings.
-	MachineID struct {
-		// Enable controls whether a generated machine-id file should be mounted
-		// into containers.
-		//
-		// By default this option is enabled and Wings will mount an additional
-		// machine-id file into containers.
-		Enable bool `yaml:"enabled" default:"true"`
-
-		// Directory is the directory on disk where the generated machine-id files will be stored.
-		// This directory may be temporary as it will be re-created whenever Wings is started.
-		//
-		// This path **WILL** be both written to by Wings and mounted into containers created by
-		// Wings. If you are running Wings itself in a container, this path will need to be mounted
-		// into the Wings container as the exact path on the host, which should match the value
-		// specified here. If you are using SELinux, you will need to make sure this file has the
-		// correct SELinux context in order for containers to use it.
-		Directory string `yaml:"directory" default:"/run/wings/machine-id"`
-	} `yaml:"machine_id"`
+		Uid int
+		Gid int
+	}

 	// The amount of time in seconds that can elapse before a server's disk space calculation is
 	// considered stale and a re-check should occur. DANGER: setting this value too low can seriously
@@ -220,15 +159,6 @@ type SystemConfiguration struct {
 	// disk usage is not a concern.
 	DiskCheckInterval int64 `default:"150" yaml:"disk_check_interval"`

-	// ActivitySendInterval is the amount of time that should ellapse between aggregated server activity
-	// being sent to the Panel. By default this will send activity collected over the last minute. Keep
-	// in mind that only a fixed number of activity log entries, defined by ActivitySendCount, will be sent
-	// in each run.
-	ActivitySendInterval int `default:"60" yaml:"activity_send_interval"`
-
-	// ActivitySendCount is the number of activity events to send per batch.
-	ActivitySendCount int `default:"100" yaml:"activity_send_count"`
-
 	// If set to true, file permissions for a server will be checked when the process is
 	// booted. This can cause boot delays if the server has a large amount of files. In most
 	// cases disabling this should not have any major impact unless external processes are
@@ -276,15 +206,6 @@ type Backups struct {
 	//
 	// Defaults to 0 (unlimited)
 	WriteLimit int `default:"0" yaml:"write_limit"`
-
-	// CompressionLevel determines how much backups created by wings should be compressed.
-	//
-	// "none" -> no compression will be applied
-	// "best_speed" -> uses gzip level 1 for fast speed
-	// "best_compression" -> uses gzip level 9 for minimal disk space useage
-	//
-	// Defaults to "best_speed" (level 1)
-	CompressionLevel string `default:"best_speed" yaml:"compression_level"`
 }

 type Transfers struct {
@@ -301,24 +222,29 @@ type ConsoleThrottles struct {
 	// Whether or not the throttler is enabled for this instance.
 	Enabled bool `json:"enabled" yaml:"enabled" default:"true"`

-	// The total number of lines that can be output in a given Period period before
+	// The total number of lines that can be output in a given LineResetInterval period before
 	// a warning is triggered and counted against the server.
 	Lines uint64 `json:"lines" yaml:"lines" default:"2000"`

+	// The total number of throttle activations that can accumulate before a server is considered
+	// to be breaching and will be stopped. This value is decremented by one every DecayInterval.
+	MaximumTriggerCount uint64 `json:"maximum_trigger_count" yaml:"maximum_trigger_count" default:"5"`
+
 	// The amount of time after which the number of lines processed is reset to 0. This runs in
 	// a constant loop and is not affected by the current console output volumes. By default, this
 	// will reset the processed line count back to 0 every 100ms.
-	Period uint64 `json:"line_reset_interval" yaml:"line_reset_interval" default:"100"`
-}
+	LineResetInterval uint64 `json:"line_reset_interval" yaml:"line_reset_interval" default:"100"`

-type Token struct {
-	ID    string
-	Token string
+	// The amount of time in milliseconds that must pass without an output warning being triggered
+	// before a throttle activation is decremented.
+	DecayInterval uint64 `json:"decay_interval" yaml:"decay_interval" default:"10000"`
+
+	// The amount of time that a server is allowed to be stopping for before it is terminated
+	// forcefully if it triggers output throttles.
+	StopGracePeriod uint `json:"stop_grace_period" yaml:"stop_grace_period" default:"15"`
 }

 type Configuration struct {
-	Token Token `json:"-" yaml:"-"`
-
 	// The location from which this configuration instance was instantiated.
 	path string

@@ -349,7 +275,7 @@ type Configuration struct {

 	// The location where the panel is running that this daemon should connect to
 	// to collect data and send events.
-	PanelLocation string                   `json:"-" yaml:"remote"`
+	PanelLocation string                   `json:"remote" yaml:"remote"`
 	RemoteQuery   RemoteQueryConfiguration `json:"remote_query" yaml:"remote_query"`

 	// AllowedMounts is a list of allowed host-system mount points.
@@ -366,9 +292,6 @@ type Configuration struct {
 	// is only required by users running Wings without SSL certificates and using internal IP
 	// addresses in order to connect. Most users should NOT enable this setting.
 	AllowCORSPrivateNetwork bool `json:"allow_cors_private_network" yaml:"allow_cors_private_network"`
-
-	// IgnorePanelConfigUpdates causes confiuration updates that are sent by the panel to be ignored.
-	IgnorePanelConfigUpdates bool `json:"ignore_panel_config_updates" yaml:"ignore_panel_config_updates"`
 }

 // NewAtPath creates a new struct and set the path where it should be stored.
@@ -391,16 +314,11 @@ func NewAtPath(path string) (*Configuration, error) {
 // will be paused until it is complete.
 func Set(c *Configuration) {
 	mu.Lock()
-	defer mu.Unlock()
-	token := c.Token.Token
-	if token == "" {
-		c.Token.Token = c.AuthenticationToken
-		token = c.Token.Token
-	}
-	if _config == nil || _config.Token.Token != token {
-		_jwtAlgo = jwt.NewHS256([]byte(token))
+	if _config == nil || _config.AuthenticationToken != c.AuthenticationToken {
+		_jwtAlgo = jwt.NewHS256([]byte(c.AuthenticationToken))
 	}
 	_config = c
+	mu.Unlock()
 }

 // SetDebugViaFlag tracks if the application is running in debug mode because of
@@ -408,9 +326,9 @@ func Set(c *Configuration) {
 // change to the disk.
 func SetDebugViaFlag(d bool) {
 	mu.Lock()
-	defer mu.Unlock()
 	_config.Debug = d
 	_debugViaFlag = d
+	mu.Unlock()
 }

 // Get returns the global configuration instance. This is a thread-safe operation
@@ -435,8 +353,8 @@ func Get() *Configuration {
 // the global configuration.
 func Update(callback func(c *Configuration)) {
 	mu.Lock()
-	defer mu.Unlock()
 	callback(_config)
+	mu.Unlock()
 }

 // GetJwtAlgorithm returns the in-memory JWT algorithm.
@@ -494,19 +412,6 @@ func EnsurePterodactylUser() error {
 		return nil
 	}

-	if _config.System.User.Rootless.Enabled {
-		log.Info("rootless mode is enabled, skipping user creation...")
-		u, err := user.Current()
-		if err != nil {
-			return err
-		}
-		_config.System.Username = u.Username
-		_config.System.User.Uid = system.MustInt(u.Uid)
-		_config.System.User.Gid = system.MustInt(u.Gid)
-		return nil
-	}
-
-	log.WithField("username", _config.System.Username).Info("checking for pterodactyl system user")
 	u, err := user.Lookup(_config.System.Username)
 	// If an error is returned but it isn't the unknown user error just abort
 	// the process entirely. If we did find a user, return it immediately.
@@ -545,37 +450,6 @@ func EnsurePterodactylUser() error {
 	return nil
 }

-// ConfigurePasswd generates required passwd files for use with containers started by Wings.
-func ConfigurePasswd() error {
-	passwd := _config.System.Passwd
-	if !passwd.Enable {
-		return nil
-	}
-
-	v := []byte(fmt.Sprintf(
-		`root:x:0:
-container:x:%d:
-nogroup:x:65534:`,
-		_config.System.User.Gid,
-	))
-	if err := os.WriteFile(filepath.Join(passwd.Directory, "group"), v, 0o644); err != nil {
-		return fmt.Errorf("failed to write file to %s/group: %v", passwd.Directory, err)
-	}
-
-	v = []byte(fmt.Sprintf(
-		`root:x:0:0::/root:/bin/sh
-container:x:%d:%d::/home/container:/bin/sh
-nobody:x:65534:65534::/var/empty:/bin/sh
-`,
-		_config.System.User.Uid,
-		_config.System.User.Gid,
-	))
-	if err := os.WriteFile(filepath.Join(passwd.Directory, "passwd"), v, 0o644); err != nil {
-		return fmt.Errorf("failed to write file to %s/passwd: %v", passwd.Directory, err)
-	}
-	return nil
-}
-
 // FromFile reads the configuration from the provided file and stores it in the
 // global singleton for this instance.
 func FromFile(path string) error {
@@ -592,26 +466,6 @@ func FromFile(path string) error {
 		return err
 	}

-	c.Token = Token{
-		ID:    os.Getenv("WINGS_TOKEN_ID"),
-		Token: os.Getenv("WINGS_TOKEN"),
-	}
-	if c.Token.ID == "" {
-		c.Token.ID = c.AuthenticationTokenId
-	}
-	if c.Token.Token == "" {
-		c.Token.Token = c.AuthenticationToken
-	}
-
-	c.Token.ID, err = Expand(c.Token.ID)
-	if err != nil {
-		return err
-	}
-	c.Token.Token, err = Expand(c.Token.Token)
-	if err != nil {
-		return err
-	}
-
 	// Store this configuration in the global state.
 	Set(c)
 	return nil
@@ -650,11 +504,6 @@ func ConfigureDirectories() error {
 		return err
 	}

-	log.WithField("path", _config.System.TmpDirectory).Debug("ensuring temporary data directory exists")
-	if err := os.MkdirAll(_config.System.TmpDirectory, 0o700); err != nil {
-		return err
-	}
-
 	log.WithField("path", _config.System.ArchiveDirectory).Debug("ensuring archive data directory exists")
 	if err := os.MkdirAll(_config.System.ArchiveDirectory, 0o700); err != nil {
 		return err
@@ -665,20 +514,6 @@ func ConfigureDirectories() error {
 		return err
 	}

-	if _config.System.Passwd.Enable {
-		log.WithField("path", _config.System.Passwd.Directory).Debug("ensuring passwd directory exists")
-		if err := os.MkdirAll(_config.System.Passwd.Directory, 0o755); err != nil {
-			return err
-		}
-	}
-
-	if _config.System.MachineID.Enable {
-		log.WithField("path", _config.System.MachineID.Directory).Debug("ensuring machine-id directory exists")
-		if err := os.MkdirAll(_config.System.MachineID.Directory, 0o755); err != nil {
-			return err
-		}
-	}
-
 	return nil
 }

@@ -793,36 +628,3 @@ func getSystemName() (string, error) {
 	}
 	return release["ID"], nil
 }
-
-// Expand expands an input string by calling [os.ExpandEnv] to expand all
-// environment variables, then checks if the value is prefixed with `file://`
-// to support reading the value from a file.
-//
-// NOTE: the order of expanding environment variables first then checking if
-// the value references a file is important. This behaviour allows a user to
-// pass a value like `file://${CREDENTIALS_DIRECTORY}/token` to allow us to
-// work with credentials loaded by systemd's `LoadCredential` (or `LoadCredentialEncrypted`)
-// options without the user needing to assume the path of `CREDENTIALS_DIRECTORY`
-// or use a preStart script to read the files for us.
-func Expand(v string) (string, error) {
-	// Expand environment variables within the string.
-	//
-	// NOTE: this may cause issues if the string contains `$` and doesn't intend
-	// on getting expanded, however we are using this for our tokens which are
-	// all alphanumeric characters only.
-	v = os.ExpandEnv(v)
-
-	// Handle files.
-	const filePrefix = "file://"
-	if strings.HasPrefix(v, filePrefix) {
-		p := v[len(filePrefix):]
-
-		b, err := os.ReadFile(p)
-		if err != nil {
-			return "", nil
-		}
-		v = string(bytes.TrimRight(bytes.TrimRight(b, "\r"), "\n"))
-	}
-
-	return v, nil
-}
--- a/config/config_docker.go
+++ b/config/config_docker.go
@@ -2,11 +2,10 @@ package config

 import (
 	"encoding/base64"
-	"encoding/json"
 	"sort"

-	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/registry"
+	"github.com/docker/docker/api/types"
+	"github.com/goccy/go-json"
 )

 type dockerNetworkInterfaces struct {
@@ -37,7 +36,6 @@ type DockerNetworkConfiguration struct {
 	Mode       string                  `default:"pterodactyl_nw" yaml:"network_mode"`
 	IsInternal bool                    `default:"false" yaml:"is_internal"`
 	EnableICC  bool                    `default:"true" yaml:"enable_icc"`
-	NetworkMTU int64                   `default:"1500" yaml:"network_mtu"`
 	Interfaces dockerNetworkInterfaces `yaml:"interfaces"`
 }

@@ -79,30 +77,6 @@ type DockerConfiguration struct {
 	Overhead Overhead `json:"overhead" yaml:"overhead"`

 	UsePerformantInspect bool `default:"true" json:"use_performant_inspect" yaml:"use_performant_inspect"`
-
-	// Sets the user namespace mode for the container when user namespace remapping option is
-	// enabled.
-	//
-	// If the value is blank, the daemon's user namespace remapping configuration is used,
-	// if the value is "host", then the pterodactyl containers are started with user namespace
-	// remapping disabled
-	UsernsMode string `default:"" json:"userns_mode" yaml:"userns_mode"`
-
-	LogConfig struct {
-		Type   string            `default:"local" json:"type" yaml:"type"`
-		Config map[string]string `default:"{\"max-size\":\"5m\",\"max-file\":\"1\",\"compress\":\"false\",\"mode\":\"non-blocking\"}" json:"config" yaml:"config"`
-	} `json:"log_config" yaml:"log_config"`
-}
-
-func (c DockerConfiguration) ContainerLogConfig() container.LogConfig {
-	if c.LogConfig.Type == "" {
-		return container.LogConfig{}
-	}
-
-	return container.LogConfig{
-		Type:   c.LogConfig.Type,
-		Config: c.LogConfig.Config,
-	}
 }

 // RegistryConfiguration defines the authentication credentials for a given
@@ -115,7 +89,7 @@ type RegistryConfiguration struct {
 // Base64 returns the authentication for a given registry as a base64 encoded
 // string value.
 func (c RegistryConfiguration) Base64() (string, error) {
-	b, err := json.Marshal(registry.AuthConfig{
+	b, err := json.Marshal(types.AuthConfig{
 		Username: c.Username,
 		Password: c.Password,
 	})
--- a/docker-compose.example.yml
+++ b/docker-compose.example.yml
@@ -23,7 +23,6 @@ services:
      - "/var/log/pterodactyl/:/var/log/pterodactyl/"
      - "/tmp/pterodactyl/:/tmp/pterodactyl/"
      - "/etc/ssl/certs:/etc/ssl/certs:ro"
-	  - "/run/wings:/run/wings"
      # you may need /srv/daemon-data if you are upgrading from an old daemon
      #- "/srv/daemon-data/:/srv/daemon-data/"
      # Required for ssl if you use let's encrypt. uncomment to use.
--- a/environment/allocations.go
+++ b/environment/allocations.go
@@ -12,11 +12,6 @@ import (
 // Defines the allocations available for a given server. When using the Docker environment
 // driver these correspond to mappings for the container that allow external connections.
 type Allocations struct {
-	// ForceOutgoingIP causes a dedicated bridge network to be created for the
-	// server with a special option, causing Docker to SNAT outgoing traffic to
-	// the DefaultMapping's IP. This is important to servers which rely on external
-	// services that check the IP of the server (Source Engine servers, for example).
-	ForceOutgoingIP bool `json:"force_outgoing_ip"`
 	// Defines the default allocation that should be used for this server. This is
 	// what will be used for {SERVER_IP} and {SERVER_PORT} when modifying configuration
 	// files or the startup arguments for a server.
--- a/environment/config.go
+++ b/environment/config.go
@@ -8,7 +8,6 @@ type Settings struct {
 	Mounts      []Mount
 	Allocations Allocations
 	Limits      Limits
-	Labels      map[string]string
 }

 // Defines the actual configuration struct for the environment with all of the settings
@@ -69,14 +68,6 @@ func (c *Configuration) Mounts() []Mount {
 	return c.settings.Mounts
 }

-// Labels returns the container labels associated with this instance.
-func (c *Configuration) Labels() map[string]string {
-	c.mu.RLock()
-	defer c.mu.RUnlock()
-
-	return c.settings.Labels
-}
-
 // Returns the environment variables associated with this instance.
 func (c *Configuration) EnvironmentVariables() []string {
 	c.mu.RLock()
--- a/environment/docker.go
+++ b/environment/docker.go
@@ -7,6 +7,7 @@ import (

 	"emperror.dev/errors"
 	"github.com/apex/log"
+	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/network"
 	"github.com/docker/docker/client"

@@ -38,14 +39,14 @@ func ConfigureDocker(ctx context.Context) error {
 	}

 	nw := config.Get().Docker.Network
-	resource, err := cli.NetworkInspect(ctx, nw.Name, network.InspectOptions{})
+	resource, err := cli.NetworkInspect(ctx, nw.Name, types.NetworkInspectOptions{})
 	if err != nil {
-		if !client.IsErrNotFound(err) {
-			return err
-		}
-
-		log.Info("creating missing pterodactyl0 interface, this could take a few seconds...")
-		if err := createDockerNetwork(ctx, cli); err != nil {
+		if client.IsErrNotFound(err) {
+			log.Info("creating missing pterodactyl0 interface, this could take a few seconds...")
+			if err := createDockerNetwork(ctx, cli); err != nil {
+				return err
+			}
+		} else {
 			return err
 		}
 	}
@@ -71,10 +72,9 @@ func ConfigureDocker(ctx context.Context) error {
 // Creates a new network on the machine if one does not exist already.
 func createDockerNetwork(ctx context.Context, cli *client.Client) error {
 	nw := config.Get().Docker.Network
-	enableIPv6 := true
-	_, err := cli.NetworkCreate(ctx, nw.Name, network.CreateOptions{
+	_, err := cli.NetworkCreate(ctx, nw.Name, types.NetworkCreate{
 		Driver:     nw.Driver,
-		EnableIPv6: &enableIPv6,
+		EnableIPv6: true,
 		Internal:   nw.IsInternal,
 		IPAM: &network.IPAM{
 			Config: []network.IPAMConfig{{
@@ -92,7 +92,7 @@ func createDockerNetwork(ctx context.Context, cli *client.Client) error {
 			"com.docker.network.bridge.enable_ip_masquerade": "true",
 			"com.docker.network.bridge.host_binding_ipv4":    "0.0.0.0",
 			"com.docker.network.bridge.name":                 "pterodactyl0",
-			"com.docker.network.driver.mtu":                  strconv.FormatInt(nw.NetworkMTU, 10),
+			"com.docker.network.driver.mtu":                  "1500",
 		},
 	})
 	if err != nil {
--- a/environment/docker/api.go
+++ b/environment/docker/api.go
@@ -2,7 +2,6 @@ package docker

 import (
 	"context"
-	"encoding/json"
 	"io"
 	"net/http"
 	"reflect"
@@ -14,7 +13,7 @@ import (
 	"github.com/docker/docker/api/types/versions"
 	"github.com/docker/docker/client"
 	"github.com/docker/docker/errdefs"
-
+	"github.com/goccy/go-json"
 	"github.com/pterodactyl/wings/config"
 )

@@ -74,9 +73,6 @@ func (e *Environment) ContainerInspect(ctx context.Context) (types.ContainerJSON

 	res, err := e.client.HTTPClient().Do(req)
 	if err != nil {
-		if res == nil {
-			return st, errdefs.Unknown(err)
-		}
 		return st, errdefs.FromStatusCode(err, res.StatusCode)
 	}

@@ -117,4 +113,4 @@ func parseErrorFromResponse(res *http.Response, body []byte) error {
 	}

 	return errors.Wrap(errors.New(emsg), "Error response from daemon")
-}
+}
--- a/environment/docker/container.go
+++ b/environment/docker/container.go
@@ -12,11 +12,11 @@ import (
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/buger/jsonparser"
+	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/container"
-	"github.com/docker/docker/api/types/image"
 	"github.com/docker/docker/api/types/mount"
-	"github.com/docker/docker/api/types/network"
 	"github.com/docker/docker/client"
+	"github.com/docker/docker/daemon/logger/jsonfilelog"

 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
@@ -38,19 +38,23 @@ func (nw noopWriter) Write(b []byte) (int, error) {
 }

 // Attach attaches to the docker container itself and ensures that we can pipe
-// data in and out of the process stream. This should always be called before
-// you have started the container, but after you've ensured it exists.
+// data in and out of the process stream. This should not be used for reading
+// console data as you *will* miss important output at the beginning because of
+// the time delay with attaching to the output.
 //
 // Calling this function will poll resources for the container in the background
-// until the container is stopped. The context provided to this function is used
-// for the purposes of attaching to the container, a second context is created
-// within the function for managing polling.
+// until the provided context is canceled by the caller. Failure to cancel said
+// context will cause background memory leaks as the goroutine will not exit.
 func (e *Environment) Attach(ctx context.Context) error {
 	if e.IsAttached() {
 		return nil
 	}

-	opts := container.AttachOptions{
+	if err := e.followOutput(); err != nil {
+		return err
+	}
+
+	opts := types.ContainerAttachOptions{
 		Stdin:  true,
 		Stdout: true,
 		Stderr: true,
@@ -59,7 +63,7 @@ func (e *Environment) Attach(ctx context.Context) error {

 	// Set the stream again with the container.
 	if st, err := e.client.ContainerAttach(ctx, e.Id, opts); err != nil {
-		return errors.WrapIf(err, "environment/docker: error while attaching to container")
+		return err
 	} else {
 		e.SetStream(&st)
 	}
@@ -86,13 +90,20 @@ func (e *Environment) Attach(ctx context.Context) error {
 			}
 		}()

-		if err := system.ScanReader(e.stream.Reader, func(v []byte) {
-			e.logCallbackMx.Lock()
-			defer e.logCallbackMx.Unlock()
-			e.logCallback(v)
-		}); err != nil && err != io.EOF {
-			log.WithField("error", err).WithField("container_id", e.Id).Warn("error processing scanner line in console output")
-			return
+		// Block the completion of this routine until the container is no longer running. This allows
+		// the pollResources function to run until it needs to be stopped. Because the container
+		// can be polled for resource usage, even when stopped, we need to have this logic present
+		// in order to cancel the context and therefore stop the routine that is spawned.
+		//
+		// For now, DO NOT use client#ContainerWait from the Docker package. There is a nasty
+		// bug causing containers to hang on deletion and cause servers to lock up on the system.
+		//
+		// This weird code isn't intuitive, but it keeps the function from ending until the container
+		// is stopped and therefore the stream reader ends up closed.
+		// @see https://github.com/moby/moby/issues/41827
+		c := new(noopWriter)
+		if _, err := io.Copy(c, e.stream.Reader); err != nil {
+			e.log().WithField("error", err).Error("could not copy from environment stream to noop writer")
 		}
 	}()

@@ -104,7 +115,7 @@ func (e *Environment) Attach(ctx context.Context) error {
 // container. This allows memory, cpu, and IO limitations to be adjusted on the
 // fly for individual instances.
 func (e *Environment) InSituUpdate() error {
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
 	defer cancel()

 	if _, err := e.ContainerInspect(ctx); err != nil {
@@ -136,15 +147,13 @@ func (e *Environment) InSituUpdate() error {
 // currently available for it. If the container already exists it will be
 // returned.
 func (e *Environment) Create() error {
-	ctx := context.Background()
-
 	// If the container already exists don't hit the user with an error, just return
 	// the current information about it which is what we would do when creating the
 	// container anyways.
-	if _, err := e.ContainerInspect(ctx); err == nil {
+	if _, err := e.ContainerInspect(context.Background()); err == nil {
 		return nil
 	} else if !client.IsErrNotFound(err) {
-		return errors.WrapIf(err, "environment/docker: failed to inspect container")
+		return errors.Wrap(err, "environment/docker: failed to inspect container")
 	}

 	// Try to pull the requested image before creating the container.
@@ -152,30 +161,21 @@ func (e *Environment) Create() error {
 		return errors.WithStackIf(err)
 	}

-	cfg := config.Get()
 	a := e.Configuration.Allocations()
+
 	evs := e.Configuration.EnvironmentVariables()
 	for i, v := range evs {
 		// Convert 127.0.0.1 to the pterodactyl0 network interface if the environment is Docker
 		// so that the server operates as expected.
 		if v == "SERVER_IP=127.0.0.1" {
-			evs[i] = "SERVER_IP=" + cfg.Docker.Network.Interface
+			evs[i] = "SERVER_IP=" + config.Get().Docker.Network.Interface
 		}
 	}

-	// Merge user-provided labels with system labels
-	confLabels := e.Configuration.Labels()
-	labels := make(map[string]string, 2+len(confLabels))
-
-	for key := range confLabels {
-		labels[key] = confLabels[key]
-	}
-	labels["Service"] = "Pterodactyl"
-	labels["ContainerType"] = "server_process"
-
 	conf := &container.Config{
 		Hostname:     e.Id,
-		Domainname:   cfg.Docker.Domainname,
+		Domainname:   config.Get().Docker.Domainname,
+		User:         strconv.Itoa(config.Get().System.User.Uid) + ":" + strconv.Itoa(config.Get().System.User.Gid),
 		AttachStdin:  true,
 		AttachStdout: true,
 		AttachStderr: true,
@@ -184,45 +184,13 @@ func (e *Environment) Create() error {
 		ExposedPorts: a.Exposed(),
 		Image:        strings.TrimPrefix(e.meta.Image, "~"),
 		Env:          e.Configuration.EnvironmentVariables(),
-		Labels:       labels,
+		Labels: map[string]string{
+			"Service":       "Pterodactyl",
+			"ContainerType": "server_process",
+		},
 	}

-	// Set the user running the container properly depending on what mode we are operating in.
-	if cfg.System.User.Rootless.Enabled {
-		conf.User = fmt.Sprintf("%d:%d", cfg.System.User.Rootless.ContainerUID, cfg.System.User.Rootless.ContainerGID)
-	} else {
-		conf.User = strconv.Itoa(cfg.System.User.Uid) + ":" + strconv.Itoa(cfg.System.User.Gid)
-	}
-
-	networkMode := container.NetworkMode(cfg.Docker.Network.Mode)
-	if a.ForceOutgoingIP {
-		e.log().Debug("environment/docker: forcing outgoing IP address")
-		networkName := "ip-" + strings.ReplaceAll(strings.ReplaceAll(a.DefaultMapping.Ip, ".", "-"), ":", "-")
-		networkMode = container.NetworkMode(networkName)
-
-		if _, err := e.client.NetworkInspect(ctx, networkName, network.InspectOptions{}); err != nil {
-			if !client.IsErrNotFound(err) {
-				return err
-			}
-
-			enableIPv6 := false
-			if _, err := e.client.NetworkCreate(ctx, networkName, network.CreateOptions{
-				Driver:     "bridge",
-				EnableIPv6: &enableIPv6,
-				Internal:   false,
-				Attachable: false,
-				Ingress:    false,
-				ConfigOnly: false,
-				Options: map[string]string{
-					"encryption": "false",
-					"com.docker.network.bridge.default_bridge": "false",
-					"com.docker.network.host_ipv4":             a.DefaultMapping.Ip,
-				},
-			}); err != nil {
-				return err
-			}
-		}
-	}
+	tmpfsSize := strconv.Itoa(int(config.Get().Docker.TmpfsSize))

 	hostConf := &container.HostConfig{
 		PortBindings: a.DockerBindings(),
@@ -234,20 +202,27 @@ func (e *Environment) Create() error {
 		// Configure the /tmp folder mapping in containers. This is necessary for some
 		// games that need to make use of it for downloads and other installation processes.
 		Tmpfs: map[string]string{
-			"/tmp": "rw,exec,nosuid,size=" + strconv.Itoa(int(cfg.Docker.TmpfsSize)) + "M",
+			"/tmp": "rw,exec,nosuid,size=" + tmpfsSize + "M",
 		},

 		// Define resource limits for the container based on the data passed through
 		// from the Panel.
 		Resources: e.Configuration.Limits().AsContainerResources(),

-		DNS: cfg.Docker.Network.Dns,
+		DNS: config.Get().Docker.Network.Dns,

 		// Configure logging for the container to make it easier on the Daemon to grab
 		// the server output. Ensure that we don't use too much space on the host machine
 		// since we only need it for the last few hundred lines of output and don't care
 		// about anything else in it.
-		LogConfig: cfg.Docker.ContainerLogConfig(),
+		LogConfig: container.LogConfig{
+			Type: jsonfilelog.Name,
+			Config: map[string]string{
+				"max-size": "5m",
+				"max-file": "1",
+				"compress": "false",
+			},
+		},

 		SecurityOpt:    []string{"no-new-privileges"},
 		ReadonlyRootfs: true,
@@ -255,11 +230,10 @@ func (e *Environment) Create() error {
 			"setpcap", "mknod", "audit_write", "net_raw", "dac_override",
 			"fowner", "fsetid", "net_bind_service", "sys_chroot", "setfcap",
 		},
-		NetworkMode: networkMode,
-		UsernsMode:  container.UsernsMode(cfg.Docker.UsernsMode),
+		NetworkMode: container.NetworkMode(config.Get().Docker.Network.Mode),
 	}

-	if _, err := e.client.ContainerCreate(ctx, conf, hostConf, nil, nil, e.Id); err != nil {
+	if _, err := e.client.ContainerCreate(context.Background(), conf, hostConf, nil, nil, e.Id); err != nil {
 		return errors.Wrap(err, "environment/docker: failed to create container")
 	}

@@ -272,7 +246,7 @@ func (e *Environment) Destroy() error {
 	// We set it to stopping than offline to prevent crash detection from being triggered.
 	e.SetState(environment.ProcessStoppingState)

-	err := e.client.ContainerRemove(context.Background(), e.Id, container.RemoveOptions{
+	err := e.client.ContainerRemove(context.Background(), e.Id, types.ContainerRemoveOptions{
 		RemoveVolumes: true,
 		RemoveLinks:   false,
 		Force:         true,
@@ -318,7 +292,7 @@ func (e *Environment) SendCommand(c string) error {
 // is running or not, it will simply try to read the last X bytes of the file
 // and return them.
 func (e *Environment) Readlog(lines int) ([]string, error) {
-	r, err := e.client.ContainerLogs(context.Background(), e.Id, container.LogsOptions{
+	r, err := e.client.ContainerLogs(context.Background(), e.Id, types.ContainerLogsOptions{
 		ShowStdout: true,
 		ShowStderr: true,
 		Tail:       strconv.Itoa(lines),
@@ -337,6 +311,59 @@ func (e *Environment) Readlog(lines int) ([]string, error) {
 	return out, nil
 }

+// Attaches to the log for the container. This avoids us missing crucial output
+// that happens in the split seconds before the code moves from 'Starting' to
+// 'Attaching' on the process.
+func (e *Environment) followOutput() error {
+	if exists, err := e.Exists(); !exists {
+		if err != nil {
+			return err
+		}
+		return errors.New(fmt.Sprintf("no such container: %s", e.Id))
+	}
+
+	opts := types.ContainerLogsOptions{
+		ShowStderr: true,
+		ShowStdout: true,
+		Follow:     true,
+		Since:      time.Now().Format(time.RFC3339),
+	}
+
+	reader, err := e.client.ContainerLogs(context.Background(), e.Id, opts)
+	if err != nil {
+		return err
+	}
+
+	go e.scanOutput(reader)
+
+	return nil
+}
+
+func (e *Environment) scanOutput(reader io.ReadCloser) {
+	defer reader.Close()
+
+	if err := system.ScanReader(reader, func(v []byte) {
+		e.logCallbackMx.Lock()
+		defer e.logCallbackMx.Unlock()
+		e.logCallback(v)
+	}); err != nil && err != io.EOF {
+		log.WithField("error", err).WithField("container_id", e.Id).Warn("error processing scanner line in console output")
+		return
+	}
+
+	// Return here if the server is offline or currently stopping.
+	if e.State() == environment.ProcessStoppingState || e.State() == environment.ProcessOfflineState {
+		return
+	}
+
+	// Close the current reader before starting a new one, the defer will still run,
+	// but it will do nothing if we already closed the stream.
+	_ = reader.Close()
+
+	// Start following the output of the server again.
+	go e.followOutput()
+}
+
 // Pulls the image from Docker. If there is an error while pulling the image
 // from the source but the image already exists locally, we will report that
 // error to the logger but continue with the process.
@@ -345,25 +372,25 @@ func (e *Environment) Readlog(lines int) ([]string, error) {
 // late, and we don't need to block all the servers from booting just because
 // of that. I'd imagine in a lot of cases an outage shouldn't affect users too
 // badly. It'll at least keep existing servers working correctly if anything.
-func (e *Environment) ensureImageExists(img string) error {
+func (e *Environment) ensureImageExists(image string) error {
 	e.Events().Publish(environment.DockerImagePullStarted, "")
 	defer e.Events().Publish(environment.DockerImagePullCompleted, "")

 	// Images prefixed with a ~ are local images that we do not need to try and pull.
-	if strings.HasPrefix(img, "~") {
+	if strings.HasPrefix(image, "~") {
 		return nil
 	}

 	// Give it up to 15 minutes to pull the image. I think this should cover 99.8% of cases where an
 	// image pull might fail. I can't imagine it will ever take more than 15 minutes to fully pull
 	// an image. Let me know when I am inevitably wrong here...
-	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Minute)
+	ctx, cancel := context.WithTimeout(context.Background(), time.Minute*15)
 	defer cancel()

 	// Get a registry auth configuration from the config.
 	var registryAuth *config.RegistryConfiguration
 	for registry, c := range config.Get().Docker.Registries {
-		if !strings.HasPrefix(img, registry) {
+		if !strings.HasPrefix(image, registry) {
 			continue
 		}

@@ -373,7 +400,7 @@ func (e *Environment) ensureImageExists(img string) error {
 	}

 	// Get the ImagePullOptions.
-	imagePullOptions := image.PullOptions{All: false}
+	imagePullOptions := types.ImagePullOptions{All: false}
 	if registryAuth != nil {
 		b64, err := registryAuth.Base64()
 		if err != nil {
@@ -384,23 +411,23 @@ func (e *Environment) ensureImageExists(img string) error {
 		imagePullOptions.RegistryAuth = b64
 	}

-	out, err := e.client.ImagePull(ctx, img, imagePullOptions)
+	out, err := e.client.ImagePull(ctx, image, imagePullOptions)
 	if err != nil {
-		images, ierr := e.client.ImageList(ctx, image.ListOptions{})
+		images, ierr := e.client.ImageList(ctx, types.ImageListOptions{})
 		if ierr != nil {
 			// Well damn, something has gone really wrong here, just go ahead and abort there
 			// isn't much anything we can do to try and self-recover from this.
 			return errors.Wrap(ierr, "environment/docker: failed to list images")
 		}

-		for _, img2 := range images {
-			for _, t := range img2.RepoTags {
-				if t != img {
+		for _, img := range images {
+			for _, t := range img.RepoTags {
+				if t != image {
 					continue
 				}

 				log.WithFields(log.Fields{
-					"image":        img,
+					"image":        image,
 					"container_id": e.Id,
 					"err":          err.Error(),
 				}).Warn("unable to pull requested image from remote source, however the image exists locally")
@@ -411,11 +438,11 @@ func (e *Environment) ensureImageExists(img string) error {
 			}
 		}

-		return errors.Wrapf(err, "environment/docker: failed to pull \"%s\" image for server", img)
+		return errors.Wrapf(err, "environment/docker: failed to pull \"%s\" image for server", image)
 	}
 	defer out.Close()

-	log.WithField("image", img).Debug("pulling docker image... this could take a bit of time")
+	log.WithField("image", image).Debug("pulling docker image... this could take a bit of time")

 	// I'm not sure what the best approach here is, but this will block execution until the image
 	// is done being pulled, which is what we need.
@@ -433,21 +460,40 @@ func (e *Environment) ensureImageExists(img string) error {
 		return err
 	}

-	log.WithField("image", img).Debug("completed docker image pull")
+	log.WithField("image", image).Debug("completed docker image pull")

 	return nil
 }

 func (e *Environment) convertMounts() []mount.Mount {
-	mounts := e.Configuration.Mounts()
-	out := make([]mount.Mount, len(mounts))
-	for i, m := range mounts {
-		out[i] = mount.Mount{
+	var out []mount.Mount
+
+	for _, m := range e.Configuration.Mounts() {
+		out = append(out, mount.Mount{
 			Type:     mount.TypeBind,
 			Source:   m.Source,
 			Target:   m.Target,
 			ReadOnly: m.ReadOnly,
-		}
+		})
 	}
+
 	return out
 }
+
+func (e *Environment) resources() container.Resources {
+	l := e.Configuration.Limits()
+	pids := l.ProcessLimit()
+
+	return container.Resources{
+		Memory:            l.BoundedMemoryLimit(),
+		MemoryReservation: l.MemoryLimit * 1_000_000,
+		MemorySwap:        l.ConvertedSwap(),
+		CPUQuota:          l.ConvertedCpuLimit(),
+		CPUPeriod:         100_000,
+		CPUShares:         1024,
+		BlkioWeight:       l.IoWeight,
+		OomKillDisable:    &l.OOMDisabled,
+		CpusetCpus:        l.Threads,
+		PidsLimit:         &pids,
+	}
+}
--- a/environment/docker/environment.go
+++ b/environment/docker/environment.go
@@ -10,7 +10,6 @@ import (
 	"github.com/apex/log"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/client"
-
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/events"
 	"github.com/pterodactyl/wings/remote"
@@ -27,7 +26,8 @@ type Metadata struct {
 var _ environment.ProcessEnvironment = (*Environment)(nil)

 type Environment struct {
-	mu sync.RWMutex
+	mu      sync.RWMutex
+	eventMu sync.Once

 	// The public identifier for this environment. In this case it is the Docker container
 	// name that will be used for all instances created under it.
@@ -73,7 +73,6 @@ func New(id string, m *Metadata, c *environment.Configuration) (*Environment, er
 		meta:          m,
 		client:        cli,
 		st:            system.NewAtomicString(environment.ProcessOfflineState),
-		emitter:       events.NewBus(),
 	}

 	return e, nil
@@ -87,33 +86,34 @@ func (e *Environment) Type() string {
 	return "docker"
 }

-// SetStream sets the current stream value from the Docker client. If a nil
-// value is provided we assume that the stream is no longer operational and the
-// instance is effectively offline.
+// Set if this process is currently attached to the process.
 func (e *Environment) SetStream(s *types.HijackedResponse) {
 	e.mu.Lock()
+	defer e.mu.Unlock()
+
 	e.stream = s
-	e.mu.Unlock()
 }

-// IsAttached determines if this process is currently attached to the
-// container instance by checking if the stream is nil or not.
+// Determine if the this process is currently attached to the container.
 func (e *Environment) IsAttached() bool {
 	e.mu.RLock()
 	defer e.mu.RUnlock()
+
 	return e.stream != nil
 }

-// Events returns an event bus for the environment.
 func (e *Environment) Events() *events.Bus {
+	e.eventMu.Do(func() {
+		e.emitter = events.NewBus()
+	})
+
 	return e.emitter
 }

-// Exists determines if the container exists in this environment. The ID passed
-// through should be the server UUID since containers are created utilizing the
-// server UUID as the name and docker will work fine when using the container
-// name as the lookup parameter in addition to the longer ID auto-assigned when
-// the container is created.
+// Determines if the container exists in this environment. The ID passed through should be the
+// server UUID since containers are created utilizing the server UUID as the name and docker
+// will work fine when using the container name as the lookup parameter in addition to the longer
+// ID auto-assigned when the container is created.
 func (e *Environment) Exists() (bool, error) {
 	_, err := e.ContainerInspect(context.Background())
 	if err != nil {
@@ -122,8 +122,10 @@ func (e *Environment) Exists() (bool, error) {
 		if client.IsErrNotFound(err) {
 			return false, nil
 		}
+
 		return false, err
 	}
+
 	return true, nil
 }

@@ -144,7 +146,7 @@ func (e *Environment) IsRunning(ctx context.Context) (bool, error) {
 	return c.State.Running, nil
 }

-// ExitState returns the container exit state, the exit code and whether or not
+// Determine the container exit state and return the exit code and whether or not
 // the container was killed by the OOM killer.
 func (e *Environment) ExitState() (uint32, bool, error) {
 	c, err := e.ContainerInspect(context.Background())
@@ -161,13 +163,15 @@ func (e *Environment) ExitState() (uint32, bool, error) {
 		if client.IsErrNotFound(err) {
 			return 1, false, nil
 		}
-		return 0, false, errors.WrapIf(err, "environment/docker: failed to inspect container")
+
+		return 0, false, err
 	}
+
 	return uint32(c.State.ExitCode), c.State.OOMKilled, nil
 }

-// Config returns the environment configuration allowing a process to make
-// modifications of the environment on the fly.
+// Returns the environment configuration allowing a process to make modifications of the
+// environment on the fly.
 func (e *Environment) Config() *environment.Configuration {
 	e.mu.RLock()
 	defer e.mu.RUnlock()
@@ -175,11 +179,12 @@ func (e *Environment) Config() *environment.Configuration {
 	return e.Configuration
 }

-// SetStopConfiguration sets the stop configuration for the environment.
+// Sets the stop configuration for the environment.
 func (e *Environment) SetStopConfiguration(c remote.ProcessStopConfiguration) {
 	e.mu.Lock()
+	defer e.mu.Unlock()
+
 	e.meta.Stop = c
-	e.mu.Unlock()
 }

 func (e *Environment) SetImage(i string) {
--- a/environment/docker/power.go
+++ b/environment/docker/power.go
@@ -4,10 +4,12 @@ import (
 	"context"
 	"os"
 	"strings"
+	"syscall"
 	"time"

 	"emperror.dev/errors"
 	"github.com/apex/log"
+	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/client"

@@ -25,7 +27,7 @@ import (
 // is running does not result in the server becoming un-bootable.
 func (e *Environment) OnBeforeStart(ctx context.Context) error {
 	// Always destroy and re-create the server container to ensure that synced data from the Panel is used.
-	if err := e.client.ContainerRemove(ctx, e.Id, container.RemoveOptions{RemoveVolumes: true}); err != nil {
+	if err := e.client.ContainerRemove(ctx, e.Id, types.ContainerRemoveOptions{RemoveVolumes: true}); err != nil {
 		if !client.IsErrNotFound(err) {
 			return errors.WrapIf(err, "environment/docker: failed to remove container during pre-boot")
 		}
@@ -37,7 +39,7 @@ func (e *Environment) OnBeforeStart(ctx context.Context) error {
 	//
 	// This won't actually run an installation process however, it is just here to ensure the
 	// environment gets created properly if it is missing and the server is started. We're making
-	// an assumption that all the files will still exist at this point.
+	// an assumption that all of the files will still exist at this point.
 	if err := e.Create(); err != nil {
 		return err
 	}
@@ -101,32 +103,22 @@ func (e *Environment) Start(ctx context.Context) error {
 	// exists on the system, and rebuild the container if that is required for server booting to
 	// occur.
 	if err := e.OnBeforeStart(ctx); err != nil {
-		return errors.WrapIf(err, "environment/docker: failed to run pre-boot process")
+		return errors.WithStackIf(err)
 	}

 	// If we cannot start & attach to the container in 30 seconds something has gone
-	// quite sideways, and we should stop trying to avoid a hanging situation.
+	// quite sideways and we should stop trying to avoid a hanging situation.
 	actx, cancel := context.WithTimeout(ctx, time.Second*30)
 	defer cancel()

-	// You must attach to the instance _before_ you start the container. If you do this
-	// in the opposite order you'll enter a deadlock condition where we're attached to
-	// the instance successfully, but the container has already stopped and you'll get
-	// the entire program into a very confusing state.
-	//
-	// By explicitly attaching to the instance before we start it, we can immediately
-	// react to errors/output stopping/etc. when starting.
-	if err := e.Attach(actx); err != nil {
-		return errors.WrapIf(err, "environment/docker: failed to attach to container")
-	}
-
-	if err := e.client.ContainerStart(actx, e.Id, container.StartOptions{}); err != nil {
+	if err := e.client.ContainerStart(actx, e.Id, types.ContainerStartOptions{}); err != nil {
 		return errors.WrapIf(err, "environment/docker: failed to start container")
 	}

 	// No errors, good to continue through.
 	sawError = false
-	return nil
+
+	return e.Attach(actx)
 }

 // Stop stops the container that the server is running in. This will allow up to
@@ -136,60 +128,49 @@ func (e *Environment) Start(ctx context.Context) error {
 // You most likely want to be using WaitForStop() rather than this function,
 // since this will return as soon as the command is sent, rather than waiting
 // for the process to be completed stopped.
-func (e *Environment) Stop(ctx context.Context) error {
+//
+// TODO: pass context through from the server instance.
+func (e *Environment) Stop() error {
 	e.mu.RLock()
 	s := e.meta.Stop
 	e.mu.RUnlock()

+	// A native "stop" as the Type field value will just skip over all of this
+	// logic and end up only executing the container stop command (which may or
+	// may not work as expected).
+	if s.Type == "" || s.Type == remote.ProcessStopSignal {
+		if s.Type == "" {
+			log.WithField("container_id", e.Id).Warn("no stop configuration detected for environment, using termination procedure")
+		}
+
+		signal := os.Kill
+		// Handle a few common cases, otherwise just fall through and just pass along
+		// the os.Kill signal to the process.
+		switch strings.ToUpper(s.Value) {
+		case "SIGABRT":
+			signal = syscall.SIGABRT
+		case "SIGINT":
+			signal = syscall.SIGINT
+		case "SIGTERM":
+			signal = syscall.SIGTERM
+		}
+		return e.Terminate(signal)
+	}
+
 	// If the process is already offline don't switch it back to stopping. Just leave it how
 	// it is and continue through to the stop handling for the process.
 	if e.st.Load() != environment.ProcessOfflineState {
 		e.SetState(environment.ProcessStoppingState)
 	}

-	// Handle signal based actions
-	if s.Type == remote.ProcessStopSignal {
-		log.WithField("signal_value", s.Value).Debug("stopping server using signal")
-
-		// Handle some common signals - Default to SIGKILL
-		signal := "SIGKILL"
-		switch strings.ToUpper(s.Value) {
-		case "SIGABRT":
-			signal = "SIGABRT"
-		case "SIGINT", "C":
-			signal = "SIGINT"
-		case "SIGTERM":
-			signal = "SIGTERM"
-		case "SIGKILL":
-			signal = "SIGKILL"
-		default:
-			log.Info("Unrecognised signal requested, defaulting to SIGKILL")
-		}
-
-		return e.SignalContainer(ctx, signal)
-
-	}
-
-	// Handle command based stops
 	// Only attempt to send the stop command to the instance if we are actually attached to
 	// the instance. If we are not for some reason, just send the container stop event.
 	if e.IsAttached() && s.Type == remote.ProcessStopCommand {
 		return e.SendCommand(s.Value)
 	}

-	if s.Type == "" {
-		log.WithField("container_id", e.Id).Warn("no stop configuration detected for environment, using native docker stop")
-	}
-
-	// Fallback to a native docker stop. As we aren't passing a signal to ContainerStop docker will
-	// attempt to stop the container using the default stop signal, SIGTERM, unless
-	// another signal was specified in the Dockerfile
-	//
-	// Using a negative timeout here will allow the container to stop gracefully,
-	// rather than forcefully terminating it.  Value is in seconds, but -1 is
-	// treated as indefinitely.
-	timeout := -1
-	if err := e.client.ContainerStop(ctx, e.Id, container.StopOptions{Timeout: &timeout}); err != nil {
+	t := time.Second * 30
+	if err := e.client.ContainerStop(context.Background(), e.Id, &t); err != nil {
 		// If the container does not exist just mark the process as stopped and return without
 		// an error.
 		if client.IsErrNotFound(err) {
@@ -207,75 +188,54 @@ func (e *Environment) Stop(ctx context.Context) error {
 // command. If the server does not stop after seconds have passed, an error will
 // be returned, or the instance will be terminated forcefully depending on the
 // value of the second argument.
-//
-// Calls to Environment.Terminate() in this function use the context passed
-// through since we don't want to prevent termination of the server instance
-// just because the context.WithTimeout() has expired.
-func (e *Environment) WaitForStop(ctx context.Context, duration time.Duration, terminate bool) error {
-	tctx, cancel := context.WithTimeout(context.Background(), duration)
-	defer cancel()
-
-	// If the parent context is canceled, abort the timed context for termination.
-	go func() {
-		select {
-		case <-ctx.Done():
-			cancel()
-		case <-tctx.Done():
-			// When the timed context is canceled, terminate this routine since we no longer
-			// need to worry about the parent routine being canceled.
-			break
-		}
-	}()
-
-	doTermination := func(s string) error {
-		e.log().WithField("step", s).WithField("duration", duration).Warn("container stop did not complete in time, terminating process...")
-		return e.Terminate(ctx, "SIGKILL")
-	}
-
-	// We pass through the timed context for this stop action so that if one of the
-	// internal docker calls fails to ever finish before we've exhausted the time limit
-	// the resources get cleaned up, and the exection is stopped.
-	if err := e.Stop(tctx); err != nil {
-		if terminate && errors.Is(err, context.DeadlineExceeded) {
-			return doTermination("stop")
-		}
+func (e *Environment) WaitForStop(seconds uint, terminate bool) error {
+	if err := e.Stop(); err != nil {
 		return err
 	}

+	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(seconds)*time.Second)
+	defer cancel()
+
 	// Block the return of this function until the container as been marked as no
 	// longer running. If this wait does not end by the time seconds have passed,
 	// attempt to terminate the container, or return an error.
-	ok, errChan := e.client.ContainerWait(tctx, e.Id, container.WaitConditionNotRunning)
+	ok, errChan := e.client.ContainerWait(ctx, e.Id, container.WaitConditionNotRunning)
 	select {
 	case <-ctx.Done():
-		if err := ctx.Err(); err != nil {
+		if ctxErr := ctx.Err(); ctxErr != nil {
 			if terminate {
-				return doTermination("parent-context")
+				log.WithField("container_id", e.Id).Info("server did not stop in time, executing process termination")
+
+				return e.Terminate(os.Kill)
 			}
-			return err
+
+			return ctxErr
 		}
 	case err := <-errChan:
 		// If the error stems from the container not existing there is no point in wasting
 		// CPU time to then try and terminate it.
-		if err == nil || client.IsErrNotFound(err) {
-			return nil
-		}
-		if terminate {
-			if !errors.Is(err, context.DeadlineExceeded) {
-				e.log().WithField("error", err).Warn("error while waiting for container stop; terminating process")
+		if err != nil && !client.IsErrNotFound(err) {
+			if terminate {
+				l := log.WithField("container_id", e.Id)
+				if errors.Is(err, context.DeadlineExceeded) {
+					l.Warn("deadline exceeded for container stop; terminating process")
+				} else {
+					l.WithField("error", err).Warn("error while waiting for container stop; terminating process")
+				}
+
+				return e.Terminate(os.Kill)
 			}
-			return doTermination("wait")
+			return errors.WrapIf(err, "environment/docker: error waiting on container to enter \"not-running\" state")
 		}
-		return errors.WrapIf(err, "environment/docker: error waiting on container to enter \"not-running\" state")
 	case <-ok:
 	}

 	return nil
 }

-// Sends the specified signal to the container in an attempt to stop it.
-func (e *Environment) SignalContainer(ctx context.Context, signal string) error {
-	c, err := e.ContainerInspect(ctx)
+// Terminate forcefully terminates the container using the signal provided.
+func (e *Environment) Terminate(signal os.Signal) error {
+	c, err := e.ContainerInspect(context.Background())
 	if err != nil {
 		// Treat missing containers as an okay error state, means it is obviously
 		// already terminated at this point.
@@ -299,23 +259,10 @@ func (e *Environment) SignalContainer(ctx context.Context, signal string) error

 	// We set it to stopping than offline to prevent crash detection from being triggered.
 	e.SetState(environment.ProcessStoppingState)
-	if err := e.client.ContainerKill(ctx, e.Id, signal); err != nil && !client.IsErrNotFound(err) {
+	sig := strings.TrimSuffix(strings.TrimPrefix(signal.String(), "signal "), "ed")
+	if err := e.client.ContainerKill(context.Background(), e.Id, sig); err != nil && !client.IsErrNotFound(err) {
 		return errors.WithStack(err)
 	}
-
-	return nil
-}
-
-// Terminate forcefully terminates the container using the signal provided.
-// then sets its state to stopped.
-func (e *Environment) Terminate(ctx context.Context, signal string) error {
-	// Send the signal to the container to kill it
-	if err := e.SignalContainer(ctx, signal); err != nil {
-		return errors.WithStack(err)
-	}
-
-	// We expect Terminate to instantly kill the container
-	// so go ahead and mark it as dead and clean up
 	e.SetState(environment.ProcessOfflineState)

 	return nil
--- a/environment/docker/stats.go
+++ b/environment/docker/stats.go
@@ -2,13 +2,13 @@ package docker

 import (
 	"context"
-	"encoding/json"
 	"io"
 	"math"
 	"time"

 	"emperror.dev/errors"
-	"github.com/docker/docker/api/types/container"
+	"github.com/docker/docker/api/types"
+	"github.com/goccy/go-json"

 	"github.com/pterodactyl/wings/environment"
 )
@@ -57,7 +57,7 @@ func (e *Environment) pollResources(ctx context.Context) error {
 		case <-ctx.Done():
 			return ctx.Err()
 		default:
-			var v container.StatsResponse
+			var v types.StatsJSON
 			if err := dec.Decode(&v); err != nil {
 				if err != io.EOF && !errors.Is(err, context.Canceled) {
 					e.log().WithField("error", err).Warn("error while processing Docker stats output for container")
@@ -95,7 +95,7 @@ func (e *Environment) pollResources(ctx context.Context) error {
 	}
 }

-// The "docker stats" CLI call does not return the same value as the [container.MemoryStats].Usage
+// The "docker stats" CLI call does not return the same value as the types.MemoryStats.Usage
 // value which can be rather confusing to people trying to compare panel usage to
 // their stats output.
 //
@@ -103,7 +103,7 @@ func (e *Environment) pollResources(ctx context.Context) error {
 // bothering me about it. It should also reflect a slightly more correct memory value anyways.
 //
 // @see https://github.com/docker/cli/blob/96e1d1d6/cli/command/container/stats_helpers.go#L227-L249
-func calculateDockerMemory(stats container.MemoryStats) uint64 {
+func calculateDockerMemory(stats types.MemoryStats) uint64 {
 	if v, ok := stats.Stats["total_inactive_file"]; ok && v < stats.Usage {
 		return stats.Usage - v
 	}
@@ -119,7 +119,7 @@ func calculateDockerMemory(stats container.MemoryStats) uint64 {
 // by the defined CPU limits on the container.
 //
 // @see https://github.com/docker/cli/blob/aa097cf1aa19099da70930460250797c8920b709/cli/command/container/stats_helpers.go#L166
-func calculateDockerAbsoluteCpu(pStats container.CPUStats, stats container.CPUStats) float64 {
+func calculateDockerAbsoluteCpu(pStats types.CPUStats, stats types.CPUStats) float64 {
 	// Calculate the change in CPU usage between the current and previous reading.
 	cpuDelta := float64(stats.CPUUsage.TotalUsage) - float64(pStats.CPUUsage.TotalUsage)

@@ -134,11 +134,7 @@ func calculateDockerAbsoluteCpu(pStats container.CPUStats, stats container.CPUSt

 	percent := 0.0
 	if systemDelta > 0.0 && cpuDelta > 0.0 {
-		percent = (cpuDelta / systemDelta) * 100.0
-
-		if cpus > 0 {
-			percent *= cpus
-		}
+		percent = (cpuDelta / systemDelta) * cpus * 100.0
 	}

 	return math.Round(percent*1000) / 1000
--- a/environment/environment.go
+++ b/environment/environment.go
@@ -2,7 +2,7 @@ package environment

 import (
 	"context"
-	"time"
+	"os"

 	"github.com/pterodactyl/wings/events"
 )
@@ -58,20 +58,18 @@ type ProcessEnvironment interface {
 	// can be started an error should be returned.
 	Start(ctx context.Context) error

-	// Stop stops a server instance. If the server is already stopped an error will
-	// not be returned, this function will act as a no-op.
-	Stop(ctx context.Context) error
+	// Stops a server instance. If the server is already stopped an error should
+	// not be returned.
+	Stop() error

-	// WaitForStop waits for a server instance to stop gracefully. If the server is
-	// still detected as running after "duration", an error will be returned, or the server
-	// will be terminated depending on the value of the second argument. If the context
-	// provided is canceled the underlying wait conditions will be stopped and the
-	// entire loop will be ended (potentially without stopping or terminating).
-	WaitForStop(ctx context.Context, duration time.Duration, terminate bool) error
+	// Waits for a server instance to stop gracefully. If the server is still detected
+	// as running after seconds, an error will be returned, or the server will be terminated
+	// depending on the value of the second argument.
+	WaitForStop(seconds uint, terminate bool) error

-	// Terminate stops a running server instance using the provided signal. This function
-	// is a no-op if the server is already stopped.
-	Terminate(ctx context.Context, signal string) error
+	// Terminates a running server instance using the provided signal. If the server
+	// is not running no error should be returned.
+	Terminate(signal os.Signal) error

 	// Destroys the environment removing any containers that were created (in Docker
 	// environments at least).
--- a/environment/settings.go
+++ b/environment/settings.go
@@ -34,7 +34,7 @@ type Mount struct {
 // Limits is the build settings for a given server that impact docker container
 // creation and resource limits for a server instance.
 type Limits struct {
-	// The total amount of memory in mebibytes that this server is allowed to
+	// The total amount of memory in megabytes that this server is allowed to
 	// use on the host system.
 	MemoryLimit int64 `json:"memory_limit"`

@@ -79,7 +79,7 @@ func (l Limits) MemoryOverheadMultiplier() float64 {
 }

 func (l Limits) BoundedMemoryLimit() int64 {
-	return int64(math.Round(float64(l.MemoryLimit) * l.MemoryOverheadMultiplier() * 1024 * 1024))
+	return int64(math.Round(float64(l.MemoryLimit) * l.MemoryOverheadMultiplier() * 1_000_000))
 }

 // ConvertedSwap returns the amount of swap available as a total in bytes. This
@@ -90,7 +90,7 @@ func (l Limits) ConvertedSwap() int64 {
 		return -1
 	}

-	return (l.Swap * 1024 * 1024) + l.BoundedMemoryLimit()
+	return (l.Swap * 1_000_000) + l.BoundedMemoryLimit()
 }

 // ProcessLimit returns the process limit for a container. This is currently
@@ -99,36 +99,21 @@ func (l Limits) ProcessLimit() int64 {
 	return config.Get().Docker.ContainerPidLimit
 }

-// AsContainerResources returns the available resources for a container in a format
-// that Docker understands.
 func (l Limits) AsContainerResources() container.Resources {
 	pids := l.ProcessLimit()
-	resources := container.Resources{
+
+	return container.Resources{
 		Memory:            l.BoundedMemoryLimit(),
-		MemoryReservation: l.MemoryLimit * 1024 * 1024,
+		MemoryReservation: l.MemoryLimit * 1_000_000,
 		MemorySwap:        l.ConvertedSwap(),
+		CPUQuota:          l.ConvertedCpuLimit(),
+		CPUPeriod:         100_000,
+		CPUShares:         1024,
 		BlkioWeight:       l.IoWeight,
 		OomKillDisable:    &l.OOMDisabled,
+		CpusetCpus:        l.Threads,
 		PidsLimit:         &pids,
 	}
-
-	// If the CPU Limit is not set, don't send any of these fields through. Providing
-	// them seems to break some Java services that try to read the available processors.
-	//
-	// @see https://github.com/pterodactyl/panel/issues/3988
-	if l.CpuLimit > 0 {
-		resources.CPUQuota = l.CpuLimit * 1_000
-		resources.CPUPeriod = 100_000
-		resources.CPUShares = 1024
-	}
-
-	// Similar to above, don't set the specific assigned CPUs if we didn't actually limit
-	// the server to any of them.
-	if l.Threads != "" {
-		resources.CpusetCpus = l.Threads
-	}
-
-	return resources
 }

 type Variables map[string]interface{}
--- a/events/events.go
+++ b/events/events.go
@@ -1,14 +1,12 @@
 package events

 import (
-	"encoding/json"
 	"strings"
-
-	"emperror.dev/errors"
-
-	"github.com/pterodactyl/wings/system"
+	"sync"
 )

+type Listener chan Event
+
 // Event represents an Event sent over a Bus.
 type Event struct {
 	Topic string
@@ -17,55 +15,137 @@ type Event struct {

 // Bus represents an Event Bus.
 type Bus struct {
-	*system.SinkPool
+	listenersMx sync.Mutex
+	listeners   map[string][]Listener
 }

-// NewBus returns a new empty Bus. This is simply a nicer wrapper around the
-// system.SinkPool implementation that allows for more simplistic usage within
-// the codebase.
-//
-// All of the events emitted out of this bus are byte slices that can be decoded
-// back into an events.Event interface.
+// NewBus returns a new empty Event Bus.
 func NewBus() *Bus {
 	return &Bus{
-		system.NewSinkPool(),
+		listeners: make(map[string][]Listener),
+	}
+}
+
+// Off unregisters a listener from the specified topics on the Bus.
+func (b *Bus) Off(listener Listener, topics ...string) {
+	b.listenersMx.Lock()
+	defer b.listenersMx.Unlock()
+
+	var closed bool
+
+	for _, topic := range topics {
+		ok := b.off(topic, listener)
+		if !closed && ok {
+			close(listener)
+			closed = true
+		}
+	}
+}
+
+func (b *Bus) off(topic string, listener Listener) bool {
+	listeners, ok := b.listeners[topic]
+	if !ok {
+		return false
+	}
+	for i, l := range listeners {
+		if l != listener {
+			continue
+		}
+
+		listeners = append(listeners[:i], listeners[i+1:]...)
+		b.listeners[topic] = listeners
+		return true
+	}
+	return false
+}
+
+// On registers a listener to the specified topics on the Bus.
+func (b *Bus) On(listener Listener, topics ...string) {
+	b.listenersMx.Lock()
+	defer b.listenersMx.Unlock()
+
+	for _, topic := range topics {
+		b.on(topic, listener)
+	}
+}
+
+func (b *Bus) on(topic string, listener Listener) {
+	listeners, ok := b.listeners[topic]
+	if !ok {
+		b.listeners[topic] = []Listener{listener}
+	} else {
+		b.listeners[topic] = append(listeners, listener)
 	}
 }

 // Publish publishes a message to the Bus.
 func (b *Bus) Publish(topic string, data interface{}) {
-	// Some of our actions for the socket support passing a more specific namespace,
+	// Some of our topics for the socket support passing a more specific namespace,
 	// such as "backup completed:1234" to indicate which specific backup was completed.
 	//
 	// In these cases, we still need to send the event using the standard listener
 	// name of "backup completed".
 	if strings.Contains(topic, ":") {
 		parts := strings.SplitN(topic, ":", 2)
+
 		if len(parts) == 2 {
 			topic = parts[0]
 		}
 	}

-	enc, err := json.Marshal(Event{Topic: topic, Data: data})
-	if err != nil {
-		panic(errors.WithStack(err))
+	b.listenersMx.Lock()
+	defer b.listenersMx.Unlock()
+
+	listeners, ok := b.listeners[topic]
+	if !ok {
+		return
 	}
-	b.Push(enc)
+	if len(listeners) < 1 {
+		return
+	}
+
+	var wg sync.WaitGroup
+	event := Event{Topic: topic, Data: data}
+	for _, listener := range listeners {
+		l := listener
+		wg.Add(1)
+		go func(l Listener, event Event) {
+			defer wg.Done()
+			l <- event
+		}(l, event)
+	}
+	wg.Wait()
 }

-// MustDecode decodes the event byte slice back into an events.Event struct or
-// panics if an error is encountered during this process.
-func MustDecode(data []byte) (e Event) {
-	if err := DecodeTo(data, &e); err != nil {
-		panic(err)
+// Destroy destroys the Event Bus by unregistering and closing all listeners.
+func (b *Bus) Destroy() {
+	b.listenersMx.Lock()
+	defer b.listenersMx.Unlock()
+
+	// Track what listeners have already been closed. Because the same listener
+	// can be listening on multiple topics, we need a way to essentially
+	// "de-duplicate" all the listeners across all the topics.
+	var closed []Listener
+
+	for _, listeners := range b.listeners {
+		for _, listener := range listeners {
+			if contains(closed, listener) {
+				continue
+			}
+
+			close(listener)
+			closed = append(closed, listener)
+		}
 	}
-	return
+
+	b.listeners = make(map[string][]Listener)
 }

-// DecodeTo decodes a byte slice of event data into the given interface.
-func DecodeTo(data []byte, v interface{}) error {
-	if err := json.Unmarshal(data, &v); err != nil {
-		return errors.Wrap(err, "events: failed to decode byte slice")
+func contains(closed []Listener, listener Listener) bool {
+	for _, c := range closed {
+		if c == listener {
+			return true
+		}
 	}
-	return nil
+	return false
 }
--- a/events/events_test.go
+++ b/events/events_test.go
@@ -9,90 +9,162 @@ import (

 func TestNewBus(t *testing.T) {
 	g := Goblin(t)
+	bus := NewBus()

-	g.Describe("Events", func() {
-		var bus *Bus
-		g.BeforeEach(func() {
-			bus = NewBus()
-		})
-
-		g.Describe("NewBus", func() {
-			g.It("is not nil", func() {
-				g.Assert(bus).IsNotNil("Bus expected to not be nil")
-			})
-		})
-
-		g.Describe("Publish", func() {
-			const topic = "test"
-			const message = "this is a test message!"
-
-			g.It("publishes message", func() {
-				bus := NewBus()
-
-				listener := make(chan []byte)
-				bus.On(listener)
-
-				done := make(chan struct{}, 1)
-				go func() {
-					select {
-					case v := <-listener:
-						m := MustDecode(v)
-						g.Assert(m.Topic).Equal(topic)
-						g.Assert(m.Data).Equal(message)
-					case <-time.After(1 * time.Second):
-						g.Fail("listener did not receive message in time")
-					}
-					done <- struct{}{}
-				}()
-				bus.Publish(topic, message)
-				<-done
-
-				// Cleanup
-				bus.Off(listener)
-			})
-
-			g.It("publishes message to all listeners", func() {
-				bus := NewBus()
-
-				listener := make(chan []byte)
-				listener2 := make(chan []byte)
-				listener3 := make(chan []byte)
-				bus.On(listener)
-				bus.On(listener2)
-				bus.On(listener3)
-
-				done := make(chan struct{}, 1)
-				go func() {
-					for i := 0; i < 3; i++ {
-						select {
-						case v := <-listener:
-							m := MustDecode(v)
-							g.Assert(m.Topic).Equal(topic)
-							g.Assert(m.Data).Equal(message)
-						case v := <-listener2:
-							m := MustDecode(v)
-							g.Assert(m.Topic).Equal(topic)
-							g.Assert(m.Data).Equal(message)
-						case v := <-listener3:
-							m := MustDecode(v)
-							g.Assert(m.Topic).Equal(topic)
-							g.Assert(m.Data).Equal(message)
-						case <-time.After(1 * time.Second):
-							g.Fail("all listeners did not receive the message in time")
-							i = 3
-						}
-					}
-
-					done <- struct{}{}
-				}()
-				bus.Publish(topic, message)
-				<-done
-
-				// Cleanup
-				bus.Off(listener)
-				bus.Off(listener2)
-				bus.Off(listener3)
-			})
+	g.Describe("NewBus", func() {
+		g.It("is not nil", func() {
+			g.Assert(bus).IsNotNil("Bus expected to not be nil")
+			g.Assert(bus.listeners).IsNotNil("Bus#listeners expected to not be nil")
+		})
+	})
+}
+
+func TestBus_Off(t *testing.T) {
+	g := Goblin(t)
+
+	const topic = "test"
+
+	g.Describe("Off", func() {
+		g.It("unregisters listener", func() {
+			bus := NewBus()
+
+			g.Assert(bus.listeners[topic]).IsNotNil()
+			g.Assert(len(bus.listeners[topic])).IsZero()
+			listener := make(chan Event)
+			bus.On(listener, topic)
+			g.Assert(len(bus.listeners[topic])).Equal(1, "Listener was not registered")
+
+			bus.Off(listener, topic)
+			g.Assert(len(bus.listeners[topic])).Equal(0, "Topic still has one or more listeners")
+		})
+
+		g.It("unregisters correct listener", func() {
+			bus := NewBus()
+
+			listener := make(chan Event)
+			listener2 := make(chan Event)
+			listener3 := make(chan Event)
+			bus.On(listener, topic)
+			bus.On(listener2, topic)
+			bus.On(listener3, topic)
+			g.Assert(len(bus.listeners[topic])).Equal(3, "Listeners were not registered")
+
+			bus.Off(listener, topic)
+			bus.Off(listener3, topic)
+			g.Assert(len(bus.listeners[topic])).Equal(1, "Expected 1 listener to remain")
+
+			if bus.listeners[topic][0] != listener2 {
+				// A normal Assert does not properly compare channels.
+				g.Fail("wrong listener unregistered")
+			}
+
+			// Cleanup
+			bus.Off(listener2, topic)
+		})
+	})
+}
+
+func TestBus_On(t *testing.T) {
+	g := Goblin(t)
+
+	const topic = "test"
+
+	g.Describe("On", func() {
+		g.It("registers listener", func() {
+			bus := NewBus()
+
+			g.Assert(bus.listeners[topic]).IsNotNil()
+			g.Assert(len(bus.listeners[topic])).IsZero()
+			listener := make(chan Event)
+			bus.On(listener, topic)
+			g.Assert(len(bus.listeners[topic])).Equal(1, "Listener was not registered")
+
+			if bus.listeners[topic][0] != listener {
+				// A normal Assert does not properly compare channels.
+				g.Fail("wrong listener registered")
+			}
+
+			// Cleanup
+			bus.Off(listener, topic)
+		})
+	})
+}
+
+func TestBus_Publish(t *testing.T) {
+	g := Goblin(t)
+
+	const topic = "test"
+	const message = "this is a test message!"
+
+	g.Describe("Publish", func() {
+		g.It("publishes message", func() {
+			bus := NewBus()
+
+			g.Assert(bus.listeners[topic]).IsNotNil()
+			g.Assert(len(bus.listeners[topic])).IsZero()
+			listener := make(chan Event)
+			bus.On(listener, topic)
+			g.Assert(len(bus.listeners[topic])).Equal(1, "Listener was not registered")
+
+			done := make(chan struct{}, 1)
+			go func() {
+				select {
+				case m := <-listener:
+					g.Assert(m.Topic).Equal(topic)
+					g.Assert(m.Data).Equal(message)
+				case <-time.After(1 * time.Second):
+					g.Fail("listener did not receive message in time")
+				}
+				done <- struct{}{}
+			}()
+			bus.Publish(topic, message)
+			<-done
+
+			// Cleanup
+			bus.Off(listener, topic)
+		})
+
+		g.It("publishes message to all listeners", func() {
+			bus := NewBus()
+
+			g.Assert(bus.listeners[topic]).IsNotNil()
+			g.Assert(len(bus.listeners[topic])).IsZero()
+			listener := make(chan Event)
+			listener2 := make(chan Event)
+			listener3 := make(chan Event)
+			bus.On(listener, topic)
+			bus.On(listener2, topic)
+			bus.On(listener3, topic)
+			g.Assert(len(bus.listeners[topic])).Equal(3, "Listener was not registered")
+
+			done := make(chan struct{}, 1)
+			go func() {
+				for i := 0; i < 3; i++ {
+					select {
+					case m := <-listener:
+						g.Assert(m.Topic).Equal(topic)
+						g.Assert(m.Data).Equal(message)
+					case m := <-listener2:
+						g.Assert(m.Topic).Equal(topic)
+						g.Assert(m.Data).Equal(message)
+					case m := <-listener3:
+						g.Assert(m.Topic).Equal(topic)
+						g.Assert(m.Data).Equal(message)
+					case <-time.After(1 * time.Second):
+						g.Fail("all listeners did not receive the message in time")
+						i = 3
+					}
+				}
+
+				done <- struct{}{}
+			}()
+			bus.Publish(topic, message)
+			<-done
+
+			// Cleanup
+			bus.Off(listener, topic)
+			bus.Off(listener2, topic)
+			bus.Off(listener3, topic)
 		})
 	})
 }
--- a/flake.lock
+++ b/flake.lock
@@ -1,82 +0,0 @@
-{
-  "nodes": {
-    "flake-parts": {
-      "inputs": {
-        "nixpkgs-lib": "nixpkgs-lib"
-      },
-      "locked": {
-        "lastModified": 1768135262,
-        "narHash": "sha256-PVvu7OqHBGWN16zSi6tEmPwwHQ4rLPU9Plvs8/1TUBY=",
-        "owner": "hercules-ci",
-        "repo": "flake-parts",
-        "rev": "80daad04eddbbf5a4d883996a73f3f542fa437ac",
-        "type": "github"
-      },
-      "original": {
-        "owner": "hercules-ci",
-        "repo": "flake-parts",
-        "type": "github"
-      }
-    },
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1768127708,
-        "narHash": "sha256-1Sm77VfZh3mU0F5OqKABNLWxOuDeHIlcFjsXeeiPazs=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "ffbc9f8cbaacfb331b6017d5a5abb21a492c9a38",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "nixos-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "nixpkgs-lib": {
-      "locked": {
-        "lastModified": 1765674936,
-        "narHash": "sha256-k00uTP4JNfmejrCLJOwdObYC9jHRrr/5M/a/8L2EIdo=",
-        "owner": "nix-community",
-        "repo": "nixpkgs.lib",
-        "rev": "2075416fcb47225d9b68ac469a5c4801a9c4dd85",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-community",
-        "repo": "nixpkgs.lib",
-        "type": "github"
-      }
-    },
-    "root": {
-      "inputs": {
-        "flake-parts": "flake-parts",
-        "nixpkgs": "nixpkgs",
-        "treefmt-nix": "treefmt-nix"
-      }
-    },
-    "treefmt-nix": {
-      "inputs": {
-        "nixpkgs": [
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1768158989,
-        "narHash": "sha256-67vyT1+xClLldnumAzCTBvU0jLZ1YBcf4vANRWP3+Ak=",
-        "owner": "numtide",
-        "repo": "treefmt-nix",
-        "rev": "e96d59dff5c0d7fddb9d113ba108f03c3ef99eca",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "treefmt-nix",
-        "type": "github"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}
--- a/flake.nix
+++ b/flake.nix
@@ -1,54 +0,0 @@
-{
-  description = "Wings";
-
-  inputs = {
-    flake-parts.url = "github:hercules-ci/flake-parts";
-    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
-
-    treefmt-nix = {
-      url = "github:numtide/treefmt-nix";
-      inputs.nixpkgs.follows = "nixpkgs";
-    };
-  };
-
-  outputs = {...} @ inputs:
-    inputs.flake-parts.lib.mkFlake {inherit inputs;} {
-      systems = inputs.nixpkgs.lib.systems.flakeExposed;
-
-      imports = [
-        inputs.treefmt-nix.flakeModule
-      ];
-
-      perSystem = {system, ...}: let
-        pkgs = import inputs.nixpkgs {inherit system;};
-      in {
-         devShells.default = pkgs.mkShell {
-          buildInputs = with pkgs; [
-            go_1_24
-            gofumpt
-            golangci-lint
-            gotools
-          ];
-        };
-
-        treefmt = {
-          projectRootFile = "flake.nix";
-
-          programs = {
-            alejandra.enable = true;
-            deadnix.enable = true;
-            gofumpt = {
-              enable = true;
-              extra = true;
-            };
-            shellcheck.enable = true;
-            shfmt = {
-              enable = true;
-              indent_size = 0; # 0 causes shfmt to use tabs
-            };
-            yamlfmt.enable = true;
-          };
-        };
-      };
-    };
-}
--- a/go.mod
+++ b/go.mod
@@ -1,142 +1,118 @@
 module github.com/pterodactyl/wings

-go 1.25.6
+go 1.17

 require (
-	emperror.dev/errors v0.8.1
-	github.com/AlecAivazis/survey/v2 v2.3.7
-	github.com/Jeffail/gabs/v2 v2.7.0
+	emperror.dev/errors v0.8.0
+	github.com/AlecAivazis/survey/v2 v2.2.15
+	github.com/Jeffail/gabs/v2 v2.6.1
 	github.com/NYTimes/logrotate v1.0.0
-	github.com/acobaugh/osrelease v0.1.0
 	github.com/apex/log v1.9.0
-	github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2
-	github.com/beevik/etree v1.5.0
+	github.com/asaskevich/govalidator v0.0.0-20210307081110-f21760c49a8d
+	github.com/beevik/etree v1.1.0
 	github.com/buger/jsonparser v1.1.1
-	github.com/cenkalti/backoff/v4 v4.3.0
-	github.com/creasty/defaults v1.8.0
-	github.com/docker/docker v28.3.3+incompatible
-	github.com/docker/go-connections v0.5.0
-	github.com/fatih/color v1.18.0
-	github.com/franela/goblin v0.0.0-20211003143422-0a4f594942bf
-	github.com/gabriel-vasile/mimetype v1.4.8
-	github.com/gammazero/workerpool v1.1.3
+	github.com/cenkalti/backoff/v4 v4.1.1
+	github.com/cobaugh/osrelease v0.0.0-20181218015638-a93a0a55a249
+	github.com/creasty/defaults v1.5.1
+	github.com/docker/docker v20.10.7+incompatible
+	github.com/docker/go-connections v0.4.0
+	github.com/fatih/color v1.12.0
+	github.com/franela/goblin v0.0.0-20200825194134-80c0062ed6cd
+	github.com/gabriel-vasile/mimetype v1.3.1
+	github.com/gammazero/workerpool v1.1.2
 	github.com/gbrlsnchs/jwt/v3 v3.0.1
-	github.com/gin-gonic/gin v1.10.1
-	github.com/glebarez/sqlite v1.11.0
-	github.com/go-co-op/gocron v1.37.0
-	github.com/goccy/go-json v0.10.5
-	github.com/google/uuid v1.6.0
-	github.com/gorilla/websocket v1.5.3
-	github.com/iancoleman/strcase v0.3.0
-	github.com/icza/dyno v0.0.0-20230330125955-09f820a8d9c0
-	github.com/juju/ratelimit v1.0.2
-	github.com/karrick/godirwalk v1.17.0
-	github.com/klauspost/pgzip v1.2.6
-	github.com/magiconair/properties v1.8.9
-	github.com/mattn/go-colorable v0.1.14
-	github.com/mholt/archives v0.1.5
+	github.com/gin-gonic/gin v1.7.2
+	github.com/google/uuid v1.3.0
+	github.com/gorilla/websocket v1.4.2
+	github.com/iancoleman/strcase v0.2.0
+	github.com/icza/dyno v0.0.0-20210726202311-f1bafe5d9996
+	github.com/juju/ratelimit v1.0.1
+	github.com/karrick/godirwalk v1.16.1
+	github.com/klauspost/pgzip v1.2.5
+	github.com/magiconair/properties v1.8.5
+	github.com/mattn/go-colorable v0.1.8
+	github.com/mholt/archiver/v3 v3.5.0
 	github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db
 	github.com/patrickmn/go-cache v2.1.0+incompatible
-	github.com/pkg/sftp v1.13.10
-	github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06
-	github.com/spf13/cobra v1.9.1
-	github.com/stretchr/testify v1.10.0
-	golang.org/x/crypto v0.46.0
-	golang.org/x/sync v0.19.0
-	golang.org/x/time v0.0.0-20220922220347-f3bd1da661af
-	gopkg.in/ini.v1 v1.67.0
+	github.com/pkg/profile v1.6.0
+	github.com/pkg/sftp v1.13.2
+	github.com/sabhiram/go-gitignore v0.0.0-20201211210132-54b8a0bf510f
+	github.com/spf13/cobra v1.2.1
+	github.com/stretchr/testify v1.7.0
+	golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97
+	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
+	gopkg.in/ini.v1 v1.62.0
 	gopkg.in/yaml.v2 v2.4.0
-	gopkg.in/yaml.v3 v3.0.1
-	gorm.io/gorm v1.26.0
 )

+require github.com/goccy/go-json v0.9.4
+
+require golang.org/x/sys v0.0.0-20211110154304-99a53858aa08 // indirect
+
 require (
-	github.com/Microsoft/go-winio v0.6.2 // indirect
-	github.com/Microsoft/hcsshim v0.12.9 // indirect
-	github.com/STARRY-S/zip v0.2.3 // indirect
-	github.com/andybalholm/brotli v1.2.0 // indirect
-	github.com/bodgit/plumbing v1.3.0 // indirect
-	github.com/bodgit/sevenzip v1.6.1 // indirect
-	github.com/bodgit/windows v1.0.1 // indirect
-	github.com/bytedance/sonic v1.13.1 // indirect
-	github.com/bytedance/sonic/loader v0.2.4 // indirect
-	github.com/cloudwego/base64x v0.1.5 // indirect
-	github.com/containerd/errdefs v0.3.0 // indirect
-	github.com/containerd/errdefs/pkg v0.3.0 // indirect
-	github.com/containerd/log v0.1.0 // indirect
+	github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 // indirect
+	github.com/Microsoft/go-winio v0.5.0 // indirect
+	github.com/Microsoft/hcsshim v0.8.20 // indirect
+	github.com/andybalholm/brotli v1.0.3 // indirect
+	github.com/beorn7/perks v1.0.1 // indirect
+	github.com/cespare/xxhash/v2 v2.1.1 // indirect
+	github.com/containerd/containerd v1.5.5 // indirect
+	github.com/containerd/fifo v1.0.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/distribution/reference v0.6.0 // indirect
-	github.com/docker/go-units v0.5.0 // indirect
-	github.com/dsnet/compress v0.0.2-0.20230904184137-39efe44ab707 // indirect
-	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/felixge/httpsnoop v1.0.4 // indirect
-	github.com/gammazero/deque v1.0.0 // indirect
-	github.com/gin-contrib/sse v1.0.0 // indirect
-	github.com/glebarez/go-sqlite v1.22.0 // indirect
-	github.com/go-logr/logr v1.4.2 // indirect
-	github.com/go-logr/stdr v1.2.2 // indirect
-	github.com/go-playground/locales v0.14.1 // indirect
-	github.com/go-playground/universal-translator v0.18.1 // indirect
-	github.com/go-playground/validator/v10 v10.25.0 // indirect
+	github.com/docker/distribution v2.7.1+incompatible // indirect
+	github.com/docker/go-metrics v0.0.1 // indirect
+	github.com/docker/go-units v0.4.0 // indirect
+	github.com/dsnet/compress v0.0.1 // indirect
+	github.com/fsnotify/fsnotify v1.4.9 // indirect
+	github.com/gammazero/deque v0.1.0 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/go-playground/locales v0.13.0 // indirect
+	github.com/go-playground/universal-translator v0.17.0 // indirect
+	github.com/go-playground/validator/v10 v10.8.0 // indirect
 	github.com/gogo/protobuf v1.3.2 // indirect
-	github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect
-	github.com/inconshreveable/mousetrap v1.1.0 // indirect
-	github.com/jinzhu/inflection v1.0.0 // indirect
-	github.com/jinzhu/now v1.1.5 // indirect
-	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/golang/protobuf v1.5.2 // indirect
+	github.com/golang/snappy v0.0.4 // indirect
+	github.com/gorilla/mux v1.7.4 // indirect
+	github.com/inconshreveable/mousetrap v1.0.0 // indirect
+	github.com/json-iterator/go v1.1.11 // indirect
 	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
-	github.com/klauspost/compress v1.18.0 // indirect
-	github.com/klauspost/cpuid/v2 v2.2.10 // indirect
+	github.com/klauspost/compress v1.13.2 // indirect
 	github.com/kr/fs v0.1.0 // indirect
-	github.com/leodido/go-urn v1.4.0 // indirect
-	github.com/magefile/mage v1.15.0 // indirect
-	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/leodido/go-urn v1.2.1 // indirect
+	github.com/magefile/mage v1.11.0 // indirect
+	github.com/mattn/go-isatty v0.0.13 // indirect
+	github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 // indirect
 	github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d // indirect
-	github.com/mikelolasagasti/xz v1.0.1 // indirect
-	github.com/minio/minlz v1.0.1 // indirect
-	github.com/moby/docker-image-spec v1.3.1 // indirect
-	github.com/moby/sys/atomicwriter v0.1.0 // indirect
-	github.com/moby/term v0.0.0-20220808134915-39b0c02b01ae // indirect
+	github.com/moby/term v0.0.0-20210619224110-3f7ff695adc6 // indirect
 	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
-	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/modern-go/reflect2 v1.0.1 // indirect
 	github.com/morikuni/aec v1.0.0 // indirect
-	github.com/ncruces/go-strftime v0.1.9 // indirect
-	github.com/nwaples/rardecode/v2 v2.2.0 // indirect
+	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
+	github.com/nwaples/rardecode v1.1.1 // indirect
 	github.com/opencontainers/go-digest v1.0.0 // indirect
-	github.com/opencontainers/image-spec v1.1.1 // indirect
-	github.com/pelletier/go-toml/v2 v2.2.3 // indirect
-	github.com/pierrec/lz4/v4 v4.1.22 // indirect
+	github.com/opencontainers/image-spec v1.0.1 // indirect
+	github.com/pierrec/lz4/v4 v4.1.8 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
-	github.com/robfig/cron/v3 v3.0.1 // indirect
-	github.com/sirupsen/logrus v1.9.3 // indirect
-	github.com/sorairolake/lzip-go v0.3.8 // indirect
-	github.com/spf13/afero v1.15.0 // indirect
-	github.com/spf13/pflag v1.0.6 // indirect
-	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
-	github.com/ugorji/go/codec v1.2.12 // indirect
-	github.com/ulikunitz/xz v0.5.15 // indirect
-	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.60.0 // indirect
-	go.opentelemetry.io/otel v1.35.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.24.0 // indirect
-	go.opentelemetry.io/otel/metric v1.35.0 // indirect
-	go.opentelemetry.io/otel/trace v1.35.0 // indirect
-	go.uber.org/atomic v1.11.0 // indirect
-	go.uber.org/multierr v1.11.0 // indirect
-	go4.org v0.0.0-20230225012048-214862532bf5 // indirect
-	golang.org/x/arch v0.15.0 // indirect
-	golang.org/x/exp v0.0.0-20250305212735-054e65f0b394 // indirect
-	golang.org/x/net v0.47.0 // indirect
-	golang.org/x/sys v0.39.0 // indirect
-	golang.org/x/term v0.38.0 // indirect
-	golang.org/x/text v0.32.0 // indirect
-	golang.org/x/xerrors v0.0.0-20240903120638-7835f813f4da // indirect
-	google.golang.org/protobuf v1.36.5 // indirect
-	gotest.tools/v3 v3.0.2 // indirect
-	modernc.org/libc v1.61.13 // indirect
-	modernc.org/mathutil v1.7.1 // indirect
-	modernc.org/memory v1.8.2 // indirect
-	modernc.org/sqlite v1.36.0 // indirect
+	github.com/prometheus/client_golang v1.11.0 // indirect
+	github.com/prometheus/client_model v0.2.0 // indirect
+	github.com/prometheus/common v0.30.0 // indirect
+	github.com/prometheus/procfs v0.7.1 // indirect
+	github.com/sirupsen/logrus v1.8.1 // indirect
+	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/ugorji/go/codec v1.1.7 // indirect
+	github.com/ulikunitz/xz v0.5.10 // indirect
+	github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8 // indirect
+	go.uber.org/atomic v1.9.0 // indirect
+	go.uber.org/multierr v1.7.0 // indirect
+	golang.org/x/net v0.0.0-20210726213435-c6fcb2dbf985 // indirect
+	golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b // indirect
+	golang.org/x/text v0.3.6 // indirect
+	golang.org/x/time v0.0.0-20210723032227-1f47c861a9ac // indirect
+	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
+	google.golang.org/genproto v0.0.0-20210729151513-df9385d47c1b // indirect
+	google.golang.org/grpc v1.39.0 // indirect
+	google.golang.org/protobuf v1.27.1 // indirect
+	gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f // indirect
+	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect
 )
--- a/go.sum
+++ b/go.sum
--- a/server/installer/errors.go
+++ b/server/installer/errors.go
--- a/server/installer/installer.go
+++ b/server/installer/installer.go
@@ -5,7 +5,6 @@ import (

 	"emperror.dev/errors"
 	"github.com/asaskevich/govalidator"
-
 	"github.com/pterodactyl/wings/remote"
 	"github.com/pterodactyl/wings/server"
 )
--- a/internal/cron/activity_cron.go
+++ b/internal/cron/activity_cron.go
@@ -1,99 +0,0 @@
-package cron
-
-import (
-	"context"
-	"net"
-
-	"emperror.dev/errors"
-
-	"github.com/pterodactyl/wings/internal/database"
-	"github.com/pterodactyl/wings/internal/models"
-	"github.com/pterodactyl/wings/server"
-	"github.com/pterodactyl/wings/system"
-)
-
-type activityCron struct {
-	mu      *system.AtomicBool
-	manager *server.Manager
-	max     int
-}
-
-// Run executes the cronjob and ensures we fetch and send all the stored activity to the
-// Panel instance. Once activity is sent it is deleted from the local database instance. Any
-// SFTP specific events are not handled in this cron, they're handled separately to account
-// for de-duplication and event merging.
-func (ac *activityCron) Run(ctx context.Context) error {
-	// Don't execute this cron if there is currently one running. Once this task is completed
-	// go ahead and mark it as no longer running.
-	if !ac.mu.SwapIf(true) {
-		return errors.WithStack(ErrCronRunning)
-	}
-	defer ac.mu.Store(false)
-
-	var activity []models.Activity
-	tx := database.Instance().WithContext(ctx).
-		Where("event NOT LIKE ?", "server:sftp.%").
-		Limit(ac.max).
-		Find(&activity)
-	if tx.Error != nil {
-		return errors.WithStack(tx.Error)
-	}
-	if len(activity) == 0 {
-		return nil
-	}
-
-	// ids to delete from the database.
-	ids := make([]int, 0, len(activity))
-	// activities to send to the panel.
-	activities := make([]models.Activity, 0, len(activity))
-	for _, v := range activity {
-		// Delete any activity that has an invalid IP address. This is a fix for
-		// a bug that truncated the last octet of an IPv6 address in the database.
-		if ip := net.ParseIP(v.IP); ip == nil {
-			ids = append(ids, v.ID)
-			continue
-		}
-		activities = append(activities, v)
-	}
-
-	// Delete any invalid activies
-	if len(ids) > 0 {
-		tx = database.Instance().WithContext(ctx).Where("id IN ?", ids).Delete(&models.Activity{})
-		if tx.Error != nil {
-			return errors.WithStack(tx.Error)
-		}
-	}
-
-	if len(activities) == 0 {
-		return nil
-	}
-
-	if err := ac.manager.Client().SendActivityLogs(ctx, activities); err != nil {
-		return errors.WrapIf(err, "cron: failed to send activity events to Panel")
-	}
-
-	ids = make([]int, len(activities))
-	for i, v := range activities {
-		ids[i] = v.ID
-	}
-
-	// SQLite has a limitation of how many parameters we can specify in a single
-	// query, so we need to delete the activies in chunks of 32,000 instead of
-	// all at once.
-	i := 0
-	idsLen := len(ids)
-	for i < idsLen {
-		start := i
-		end := min(i+32000, idsLen)
-		batchSize := end - start
-
-		tx = database.Instance().WithContext(ctx).Where("id IN ?", ids[start:end]).Delete(&models.Activity{})
-		if tx.Error != nil {
-			return errors.WithStack(tx.Error)
-		}
-
-		i += batchSize
-	}
-
-	return nil
-}
--- a/internal/cron/cron.go
+++ b/internal/cron/cron.go
@@ -1,73 +0,0 @@
-package cron
-
-import (
-	"context"
-	"time"
-
-	"emperror.dev/errors"
-	"github.com/apex/log"
-	"github.com/go-co-op/gocron"
-
-	"github.com/pterodactyl/wings/config"
-	"github.com/pterodactyl/wings/server"
-	"github.com/pterodactyl/wings/system"
-)
-
-const ErrCronRunning = errors.Sentinel("cron: job already running")
-
-var o system.AtomicBool
-
-// Scheduler configures the internal cronjob system for Wings and returns the scheduler
-// instance to the caller. This should only be called once per application lifecycle, additional
-// calls will result in an error being returned.
-func Scheduler(ctx context.Context, m *server.Manager) (*gocron.Scheduler, error) {
-	if !o.SwapIf(true) {
-		return nil, errors.New("cron: cannot call scheduler more than once in application lifecycle")
-	}
-	location, err := time.LoadLocation(config.Get().System.Timezone)
-	if err != nil {
-		return nil, errors.Wrap(err, "cron: failed to parse configured system timezone")
-	}
-
-	activity := activityCron{
-		mu:      system.NewAtomicBool(false),
-		manager: m,
-		max:     config.Get().System.ActivitySendCount,
-	}
-
-	sftp := sftpCron{
-		mu:      system.NewAtomicBool(false),
-		manager: m,
-		max:     config.Get().System.ActivitySendCount,
-	}
-
-	s := gocron.NewScheduler(location)
-	l := log.WithField("subsystem", "cron")
-
-	interval := time.Duration(config.Get().System.ActivitySendInterval) * time.Second
-	l.WithField("interval", interval).Info("configuring system crons")
-
-	_, _ = s.Tag("activity").Every(interval).Do(func() {
-		l.WithField("cron", "activity").Debug("sending internal activity events to Panel")
-		if err := activity.Run(ctx); err != nil {
-			if errors.Is(err, ErrCronRunning) {
-				l.WithField("cron", "activity").Warn("activity process is already running, skipping...")
-			} else {
-				l.WithField("cron", "activity").WithField("error", err).Error("activity process failed to execute")
-			}
-		}
-	})
-
-	_, _ = s.Tag("sftp").Every(interval).Do(func() {
-		l.WithField("cron", "sftp").Debug("sending sftp events to Panel")
-		if err := sftp.Run(ctx); err != nil {
-			if errors.Is(err, ErrCronRunning) {
-				l.WithField("cron", "sftp").Warn("sftp events process already running, skipping...")
-			} else {
-				l.WithField("cron", "sftp").WithField("error", err).Error("sftp events process failed to execute")
-			}
-		}
-	})
-
-	return s, nil
-}
--- a/internal/cron/sftp_cron.go
+++ b/internal/cron/sftp_cron.go
@@ -1,195 +0,0 @@
-package cron
-
-import (
-	"context"
-	"reflect"
-
-	"emperror.dev/errors"
-	"gorm.io/gorm"
-
-	"github.com/pterodactyl/wings/internal/database"
-	"github.com/pterodactyl/wings/internal/models"
-	"github.com/pterodactyl/wings/server"
-	"github.com/pterodactyl/wings/system"
-)
-
-type sftpCron struct {
-	mu      *system.AtomicBool
-	manager *server.Manager
-	max     int
-}
-
-type mapKey struct {
-	User      string
-	Server    string
-	IP        string
-	Event     models.Event
-	Timestamp string
-}
-
-type eventMap struct {
-	max int
-	ids []int
-	m   map[mapKey]*models.Activity
-}
-
-// Run executes the SFTP reconciliation cron. This job will pull all of the SFTP specific events
-// and merge them together across user, server, ip, and event. This allows a SFTP event that deletes
-// tens or hundreds of files to be tracked as a single "deletion" event so long as they all occur
-// within the same one minute period of time (starting at the first timestamp for the group). Without
-// this we'd end up flooding the Panel event log with excessive data that is of no use to end users.
-func (sc *sftpCron) Run(ctx context.Context) error {
-	if !sc.mu.SwapIf(true) {
-		return errors.WithStack(ErrCronRunning)
-	}
-	defer sc.mu.Store(false)
-
-	var o int
-	activity, err := sc.fetchRecords(ctx, o)
-	if err != nil {
-		return err
-	}
-	o += len(activity)
-
-	events := &eventMap{
-		m:   map[mapKey]*models.Activity{},
-		ids: []int{},
-		max: sc.max,
-	}
-
-	for {
-		if len(activity) == 0 {
-			break
-		}
-		slen := len(events.ids)
-		for _, a := range activity {
-			events.Push(a)
-		}
-		if len(events.ids) > slen {
-			// Execute the query again, we found some events so we want to continue
-			// with this. Start at the next offset.
-			activity, err = sc.fetchRecords(ctx, o)
-			if err != nil {
-				return errors.WithStack(err)
-			}
-			o += len(activity)
-		} else {
-			break
-		}
-	}
-
-	if len(events.m) == 0 {
-		return nil
-	}
-	if err := sc.manager.Client().SendActivityLogs(ctx, events.Elements()); err != nil {
-		return errors.Wrap(err, "failed to send sftp activity logs to Panel")
-	}
-
-	// SQLite has a limitation of how many parameters we can specify in a single
-	// query, so we need to delete the activies in chunks of 32,000 instead of
-	// all at once.
-	i := 0
-	idsLen := len(events.ids)
-	var tx *gorm.DB
-	for i < idsLen {
-		start := i
-		end := min(i+32000, idsLen)
-		batchSize := end - start
-
-		tx = database.Instance().WithContext(ctx).Where("id IN ?", events.ids[start:end]).Delete(&models.Activity{})
-		if tx.Error != nil {
-			return errors.WithStack(tx.Error)
-		}
-
-		i += batchSize
-	}
-
-	return nil
-}
-
-// fetchRecords returns a group of activity events starting at the given offset. This is used
-// since we might need to make multiple database queries to select enough events to properly
-// fill up our request to the given maximum. This is due to the fact that this cron merges any
-// activity that line up across user, server, ip, and event into a single activity record when
-// sending the data to the Panel.
-func (sc *sftpCron) fetchRecords(ctx context.Context, offset int) (activity []models.Activity, err error) {
-	tx := database.Instance().WithContext(ctx).
-		Where("event LIKE ?", "server:sftp.%").
-		Order("event DESC").
-		Offset(offset).
-		Limit(sc.max).
-		Find(&activity)
-	if tx.Error != nil {
-		err = errors.WithStack(tx.Error)
-	}
-	return
-}
-
-// Push adds an activity to the event mapping, or de-duplicates it and merges the files metadata
-// into the existing entity that exists.
-func (em *eventMap) Push(a models.Activity) {
-	m := em.forActivity(a)
-	// If no activity entity is returned we've hit the cap for the number of events to
-	// send along to the Panel. Just skip over this record and we'll account for it in
-	// the next iteration.
-	if m == nil {
-		return
-	}
-	em.ids = append(em.ids, a.ID)
-	// Always reduce this to the first timestamp that was recorded for the set
-	// of events, and not
-	if a.Timestamp.Before(m.Timestamp) {
-		m.Timestamp = a.Timestamp
-	}
-	list := m.Metadata["files"].([]interface{})
-	if s, ok := a.Metadata["files"]; ok {
-		v := reflect.ValueOf(s)
-		if v.Kind() != reflect.Slice || v.IsNil() {
-			return
-		}
-		for i := 0; i < v.Len(); i++ {
-			list = append(list, v.Index(i).Interface())
-		}
-		// You must set it again at the end of the process, otherwise you've only updated the file
-		// slice in this one loop since it isn't passed by reference. This is just shorter than having
-		// to explicitly keep casting it to the slice.
-		m.Metadata["files"] = list
-	}
-}
-
-// Elements returns the finalized activity models.
-func (em *eventMap) Elements() (out []models.Activity) {
-	for _, v := range em.m {
-		out = append(out, *v)
-	}
-	return
-}
-
-// forActivity returns an event entity from our map which allows existing matches to be
-// updated with additional files.
-func (em *eventMap) forActivity(a models.Activity) *models.Activity {
-	key := mapKey{
-		User:   a.User.String,
-		Server: a.Server,
-		IP:     a.IP,
-		Event:  a.Event,
-		// We group by the minute, don't care about the seconds for this logic.
-		Timestamp: a.Timestamp.Format("2006-01-02_15:04"),
-	}
-	if v, ok := em.m[key]; ok {
-		return v
-	}
-	// Cap the size of the events map at the defined maximum events to send to the Panel. Just
-	// return nil and let the caller handle it.
-	if len(em.m) >= em.max {
-		return nil
-	}
-	// Doesn't exist in our map yet, create a copy of the activity passed into this
-	// function and then assign it into the map with an empty metadata value.
-	v := a
-	v.Metadata = models.ActivityMeta{
-		"files": make([]interface{}, 0),
-	}
-	em.m[key] = &v
-	return &v
-}
--- a/internal/database/database.go
+++ b/internal/database/database.go
@@ -1,61 +0,0 @@
-package database
-
-import (
-	"path/filepath"
-	"time"
-
-	"emperror.dev/errors"
-	"github.com/glebarez/sqlite"
-	"gorm.io/gorm"
-	"gorm.io/gorm/logger"
-
-	"github.com/pterodactyl/wings/config"
-	"github.com/pterodactyl/wings/internal/models"
-	"github.com/pterodactyl/wings/system"
-)
-
-var (
-	o  system.AtomicBool
-	db *gorm.DB
-)
-
-// Initialize configures the local SQLite database for Wings and ensures that the models have
-// been fully migrated.
-func Initialize() error {
-	if !o.SwapIf(true) {
-		panic("database: attempt to initialize more than once during application lifecycle")
-	}
-	p := filepath.Join(config.Get().System.RootDirectory, "wings.db")
-	instance, err := gorm.Open(sqlite.Open(p), &gorm.Config{
-		Logger: logger.Default.LogMode(logger.Silent),
-	})
-	if err != nil {
-		return errors.Wrap(err, "database: could not open database file")
-	}
-	db = instance
-	if sql, err := db.DB(); err != nil {
-		return errors.WithStack(err)
-	} else {
-		sql.SetMaxOpenConns(1)
-		sql.SetConnMaxLifetime(time.Hour)
-	}
-	if tx := db.Exec("PRAGMA synchronous = OFF"); tx.Error != nil {
-		return errors.WithStack(tx.Error)
-	}
-	if tx := db.Exec("PRAGMA journal_mode = MEMORY"); tx.Error != nil {
-		return errors.WithStack(tx.Error)
-	}
-	if err := db.AutoMigrate(&models.Activity{}); err != nil {
-		return errors.WithStack(err)
-	}
-	return nil
-}
-
-// Instance returns the gorm database instance that was configured when the application was
-// booted.
-func Instance() *gorm.DB {
-	if db == nil {
-		panic("database: attempt to access instance before initialized")
-	}
-	return db
-}
--- a/internal/models/activity.go
+++ b/internal/models/activity.go
@@ -1,71 +0,0 @@
-package models
-
-import (
-	"net"
-	"strings"
-	"time"
-
-	"gorm.io/gorm"
-)
-
-type Event string
-
-type ActivityMeta map[string]interface{}
-
-// Activity defines an activity log event for a server entity performed by a user. This is
-// used for tracking commands, power actions, and SFTP events so that they can be reconciled
-// and sent back to the Panel instance to be displayed to the user.
-type Activity struct {
-	ID int `gorm:"primaryKey;not null" json:"-"`
-	// User is UUID of the user that triggered this event, or an empty string if the event
-	// cannot be tied to a specific user, in which case we will assume it was the system
-	// user.
-	User JsonNullString `gorm:"type:uuid" json:"user"`
-	// Server is the UUID of the server this event is associated with.
-	Server string `gorm:"type:uuid;not null" json:"server"`
-	// Event is a string that describes what occurred, and is used by the Panel instance to
-	// properly associate this event in the activity logs.
-	Event Event `gorm:"index;not null" json:"event"`
-	// Metadata is either a null value, string, or a JSON blob with additional event specific
-	// metadata that can be provided.
-	Metadata ActivityMeta `gorm:"serializer:json" json:"metadata"`
-	// IP is the IP address that triggered this event, or an empty string if it cannot be
-	// determined properly. This should be the connecting user's IP address, and not the
-	// internal system IP.
-	IP        string    `gorm:"not null" json:"ip"`
-	Timestamp time.Time `gorm:"not null" json:"timestamp"`
-}
-
-// SetUser sets the current user that performed the action. If an empty string is provided
-// it is cast into a null value when stored.
-func (a Activity) SetUser(u string) *Activity {
-	var ns JsonNullString
-	if u == "" {
-		if err := ns.Scan(nil); err != nil {
-			panic(err)
-		}
-	} else {
-		if err := ns.Scan(u); err != nil {
-			panic(err)
-		}
-	}
-	a.User = ns
-	return &a
-}
-
-// BeforeCreate executes before we create any activity entry to ensure the IP address
-// is trimmed down to remove any extraneous data, and the timestamp is set to the current
-// system time and then stored as UTC.
-func (a *Activity) BeforeCreate(_ *gorm.DB) error {
-	if ip, _, err := net.SplitHostPort(strings.TrimSpace(a.IP)); err == nil {
-		a.IP = ip
-	}
-	if a.Timestamp.IsZero() {
-		a.Timestamp = time.Now()
-	}
-	a.Timestamp = a.Timestamp.UTC()
-	if a.Metadata == nil {
-		a.Metadata = ActivityMeta{}
-	}
-	return nil
-}
--- a/internal/models/models.go
+++ b/internal/models/models.go
@@ -1,32 +0,0 @@
-package models
-
-import (
-	"database/sql"
-	"encoding/json"
-
-	"emperror.dev/errors"
-)
-
-type JsonNullString struct {
-	sql.NullString
-}
-
-func (v JsonNullString) MarshalJSON() ([]byte, error) {
-	if v.Valid {
-		return json.Marshal(v.String)
-	} else {
-		return json.Marshal(nil)
-	}
-}
-
-func (v *JsonNullString) UnmarshalJSON(data []byte) error {
-	var s *string
-	if err := json.Unmarshal(data, &s); err != nil {
-		return errors.WithStack(err)
-	}
-	if s != nil {
-		v.String = *s
-	}
-	v.Valid = s != nil
-	return nil
-}
--- a/internal/progress/progress.go
+++ b/internal/progress/progress.go
@@ -1,90 +0,0 @@
-package progress
-
-import (
-	"io"
-	"strings"
-	"sync/atomic"
-
-	"github.com/pterodactyl/wings/system"
-)
-
-// Progress is used to track the progress of any I/O operation that are being
-// performed.
-type Progress struct {
-	// written is the total size of the files that have been written to the writer.
-	written uint64
-	// Total is the total size of the archive in bytes.
-	total uint64
-
-	// Writer .
-	Writer io.Writer
-}
-
-// NewProgress returns a new progress tracker for the given total size.
-func NewProgress(total uint64) *Progress {
-	return &Progress{total: total}
-}
-
-// Written returns the total number of bytes written.
-// This function should be used when the progress is tracking data being written.
-func (p *Progress) Written() uint64 {
-	return atomic.LoadUint64(&p.written)
-}
-
-// Total returns the total size in bytes.
-func (p *Progress) Total() uint64 {
-	return atomic.LoadUint64(&p.total)
-}
-
-// SetTotal sets the total size of the archive in bytes. This function is safe
-// to call concurrently and can be used to update the total size if it changes,
-// such as when the total size is simultaneously being calculated as data is
-// being written through the progress writer.
-func (p *Progress) SetTotal(total uint64) {
-	atomic.StoreUint64(&p.total, total)
-}
-
-// Write totals the number of bytes that have been written to the writer.
-func (p *Progress) Write(v []byte) (int, error) {
-	n := len(v)
-	atomic.AddUint64(&p.written, uint64(n))
-	if p.Writer != nil {
-		return p.Writer.Write(v)
-	}
-	return n, nil
-}
-
-// Progress returns a formatted progress string for the current progress.
-func (p *Progress) Progress(width int) string {
-	// current = 100 (Progress, dynamic)
-	// total = 1000 (Content-Length, dynamic)
-	// width = 25 (Number of ticks to display, static)
-	// widthPercentage = 100 / width (What percentage does each tick represent, static)
-	//
-	// percentageDecimal = current / total = 0.1
-	// percentage = percentageDecimal * 100 = 10%
-	// ticks = percentage / widthPercentage = 2.5
-	//
-	// ticks is a float64, so we cast it to an int which rounds it down to 2.
-
-	// Values are cast to floats to prevent integer division.
-	current := p.Written()
-	total := p.Total()
-	// width := is passed as a parameter
-	widthPercentage := float64(100) / float64(width)
-	percentageDecimal := float64(current) / float64(total)
-	percentage := percentageDecimal * 100
-	ticks := int(percentage / widthPercentage)
-
-	// Ensure that we never get a negative number of ticks, this will prevent strings#Repeat
-	// from panicking.  A negative number of ticks is likely to happen when the total size is
-	// inaccurate, such as when we are going off of rough disk usage calculation.
-	if ticks < 0 {
-		ticks = 0
-	} else if ticks > width {
-		ticks = width
-	}
-
-	bar := strings.Repeat("=", ticks) + strings.Repeat(" ", width-ticks)
-	return "[" + bar + "] " + system.FormatBytes(current) + " / " + system.FormatBytes(total)
-}
--- a/internal/progress/progress_test.go
+++ b/internal/progress/progress_test.go
@@ -1,50 +0,0 @@
-package progress_test
-
-import (
-	"bytes"
-	"testing"
-
-	"github.com/franela/goblin"
-
-	"github.com/pterodactyl/wings/internal/progress"
-)
-
-func TestProgress(t *testing.T) {
-	g := goblin.Goblin(t)
-
-	g.Describe("Progress", func() {
-		g.It("properly initializes", func() {
-			total := uint64(1000)
-			p := progress.NewProgress(total)
-			g.Assert(p).IsNotNil()
-			g.Assert(p.Total()).Equal(total)
-			g.Assert(p.Written()).Equal(uint64(0))
-		})
-
-		g.It("increments written when Write is called", func() {
-			v := []byte("hello")
-			p := progress.NewProgress(1000)
-			_, err := p.Write(v)
-			g.Assert(err).IsNil()
-			g.Assert(p.Written()).Equal(uint64(len(v)))
-		})
-
-		g.It("renders a progress bar", func() {
-			v := bytes.Repeat([]byte{' '}, 100)
-			p := progress.NewProgress(1000)
-			_, err := p.Write(v)
-			g.Assert(err).IsNil()
-			g.Assert(p.Written()).Equal(uint64(len(v)))
-			g.Assert(p.Progress(25)).Equal("[==                       ] 100 B / 1000 B")
-		})
-
-		g.It("renders a progress bar when written exceeds total", func() {
-			v := bytes.Repeat([]byte{' '}, 1001)
-			p := progress.NewProgress(1000)
-			_, err := p.Write(v)
-			g.Assert(err).IsNil()
-			g.Assert(p.Written()).Equal(uint64(len(v)))
-			g.Assert(p.Progress(25)).Equal("[=========================] 1001 B / 1000 B")
-		})
-	})
-}
--- a/internal/quota_writer.go
+++ b/internal/quota_writer.go
@@ -1,115 +0,0 @@
-// SPDX-License-Identifier: MIT
-// SPDX-FileCopyrightText: Copyright (c) 2024 Matthew Penner
-
-package internal
-
-import (
-	"io"
-	"os"
-	"sync/atomic"
-)
-
-// CountedWriter is a writer that counts the amount of data written to the
-// underlying writer.
-type CountedWriter struct {
-	file    *os.File
-	counter atomic.Int64
-	err     error
-}
-
-// NewCountedWriter returns a new countedWriter that counts the amount of bytes
-// written to the underlying writer.
-func NewCountedWriter(f *os.File) *CountedWriter {
-	return &CountedWriter{file: f}
-}
-
-// BytesWritten returns the amount of bytes that have been written to the
-// underlying writer.
-func (w *CountedWriter) BytesWritten() int64 {
-	return w.counter.Load()
-}
-
-// Error returns the error from the writer if any. If the error is an EOF, nil
-// will be returned.
-func (w *CountedWriter) Error() error {
-	if w.err == io.EOF {
-		return nil
-	}
-	return w.err
-}
-
-// Write writes bytes to the underlying writer while tracking the total amount
-// of bytes written.
-func (w *CountedWriter) Write(p []byte) (int, error) {
-	if w.err != nil {
-		return 0, io.EOF
-	}
-
-	// Write is a very simple operation for us to handle.
-	n, err := w.file.Write(p)
-	w.counter.Add(int64(n))
-	w.err = err
-
-	// TODO: is this how we actually want to handle errors with this?
-	if err == io.EOF {
-		return n, io.EOF
-	}
-	return n, nil
-}
-
-func (w *CountedWriter) ReadFrom(r io.Reader) (n int64, err error) {
-	cr := NewCountedReader(r)
-	n, err = w.file.ReadFrom(cr)
-	w.counter.Add(n)
-	return
-}
-
-// CountedReader is a reader that counts the amount of data read from the
-// underlying reader.
-type CountedReader struct {
-	reader io.Reader
-
-	counter atomic.Int64
-	err     error
-}
-
-var _ io.Reader = (*CountedReader)(nil)
-
-// NewCountedReader returns a new countedReader that counts the amount of bytes
-// read from the underlying reader.
-func NewCountedReader(r io.Reader) *CountedReader {
-	return &CountedReader{reader: r}
-}
-
-// BytesRead returns the amount of bytes that have been read from the underlying
-// reader.
-func (r *CountedReader) BytesRead() int64 {
-	return r.counter.Load()
-}
-
-// Error returns the error from the reader if any. If the error is an EOF, nil
-// will be returned.
-func (r *CountedReader) Error() error {
-	if r.err == io.EOF {
-		return nil
-	}
-	return r.err
-}
-
-// Read reads bytes from the underlying reader while tracking the total amount
-// of bytes read.
-func (r *CountedReader) Read(p []byte) (int, error) {
-	if r.err != nil {
-		return 0, io.EOF
-	}
-
-	n, err := r.reader.Read(p)
-	r.counter.Add(int64(n))
-	r.err = err
-
-	// TODO: is this how we actually want to handle errors with this?
-	if err == io.EOF {
-		return n, io.EOF
-	}
-	return n, nil
-}
--- a/parser/helpers.go
+++ b/parser/helpers.go
@@ -2,6 +2,8 @@ package parser

 import (
 	"bytes"
+	"io"
+	"os"
 	"regexp"
 	"strconv"
 	"strings"
@@ -27,14 +29,24 @@ var configMatchRegex = regexp.MustCompile(`{{\s?config\.([\w.-]+)\s?}}`)
 // matching:
 //
 // <Root>
-//
-//	<Property value="testing"/>
-//
+//   <Property value="testing"/>
 // </Root>
 //
 // noinspection RegExpRedundantEscape
 var xmlValueMatchRegex = regexp.MustCompile(`^\[([\w]+)='(.*)'\]$`)

+// Gets the []byte representation of a configuration file to be passed through to other
+// handler functions. If the file does not currently exist, it will be created.
+func readFileBytes(path string) ([]byte, error) {
+	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0o644)
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	return io.ReadAll(file)
+}
+
 // Gets the value of a key based on the value type defined.
 func (cfr *ConfigurationFileReplacement) getKeyValue(value string) interface{} {
 	if cfr.ReplaceWith.Type() == jsonparser.Boolean {
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -2,10 +2,8 @@ package parser

 import (
 	"bufio"
-	"bytes"
-	"encoding/json"
-	"io"
 	"os"
+	"path/filepath"
 	"strconv"
 	"strings"

@@ -15,8 +13,9 @@ import (
 	"github.com/buger/jsonparser"
 	"github.com/icza/dyno"
 	"github.com/magiconair/properties"
+	"github.com/goccy/go-json"
 	"gopkg.in/ini.v1"
-	"gopkg.in/yaml.v3"
+	"gopkg.in/yaml.v2"

 	"github.com/pterodactyl/wings/config"
 )
@@ -75,26 +74,6 @@ func (cv *ReplaceValue) String() string {
 	}
 }

-func (cv *ReplaceValue) Bytes() []byte {
-	switch cv.Type() {
-	case jsonparser.String:
-		var stackbuf [64]byte
-		bU, err := jsonparser.Unescape(cv.value, stackbuf[:])
-		if err != nil {
-			panic(errors.Wrap(err, "parser: could not parse value"))
-		}
-		return bU
-	case jsonparser.Null:
-		return []byte("<nil>")
-	case jsonparser.Boolean:
-		return cv.value
-	case jsonparser.Number:
-		return cv.value
-	default:
-		return []byte("<invalid>")
-	}
-}
-
 type ConfigurationParser string

 func (cp ConfigurationParser) String() string {
@@ -161,14 +140,14 @@ func (cfr *ConfigurationFileReplacement) UnmarshalJSON(data []byte) error {
 	iv, err := jsonparser.GetString(data, "if_value")
 	// We only check keypath here since match & replace_with should be present on all of
 	// them, however if_value is optional.
-	if err != nil && !errors.Is(err, jsonparser.KeyPathNotFoundError) {
+	if err != nil && err != jsonparser.KeyPathNotFoundError {
 		return err
 	}
 	cfr.IfValue = iv

 	rw, dt, _, err := jsonparser.Get(data, "replace_with")
 	if err != nil {
-		if !errors.Is(err, jsonparser.KeyPathNotFoundError) {
+		if err != jsonparser.KeyPathNotFoundError {
 			return err
 		}

@@ -188,12 +167,11 @@ func (cfr *ConfigurationFileReplacement) UnmarshalJSON(data []byte) error {
 	return nil
 }

-// Parse parses a given configuration file and updates all the values within
-// as defined in the API response from the Panel.
-func (f *ConfigurationFile) Parse(file *os.File) error {
-	// log.WithField("path", path).WithField("parser", f.Parser.String()).Debug("parsing server configuration file")
+// Parses a given configuration file and updates all of the values within as defined
+// in the API response from the Panel.
+func (f *ConfigurationFile) Parse(path string, internal bool) error {
+	log.WithField("path", path).WithField("parser", f.Parser.String()).Debug("parsing server configuration file")

-	// What the fuck is going on here?
 	if mb, err := json.Marshal(config.Get()); err != nil {
 		return err
 	} else {
@@ -204,24 +182,56 @@ func (f *ConfigurationFile) Parse(file *os.File) error {

 	switch f.Parser {
 	case Properties:
-		err = f.parsePropertiesFile(file)
+		err = f.parsePropertiesFile(path)
+		break
 	case File:
-		err = f.parseTextFile(file)
+		err = f.parseTextFile(path)
+		break
 	case Yaml, "yml":
-		err = f.parseYamlFile(file)
+		err = f.parseYamlFile(path)
+		break
 	case Json:
-		err = f.parseJsonFile(file)
+		err = f.parseJsonFile(path)
+		break
 	case Ini:
-		err = f.parseIniFile(file)
+		err = f.parseIniFile(path)
+		break
 	case Xml:
-		err = f.parseXmlFile(file)
+		err = f.parseXmlFile(path)
+		break
 	}
+
+	if errors.Is(err, os.ErrNotExist) {
+		// File doesn't exist, we tried creating it, and same error is returned? Pretty
+		// sure this pathway is impossible, but if not, abort here.
+		if internal {
+			return nil
+		}
+
+		b := strings.TrimSuffix(path, filepath.Base(path))
+		if err := os.MkdirAll(b, 0o755); err != nil {
+			return errors.WithMessage(err, "failed to create base directory for missing configuration file")
+		} else {
+			if _, err := os.Create(path); err != nil {
+				return errors.WithMessage(err, "failed to create missing configuration file")
+			}
+		}
+
+		return f.Parse(path, true)
+	}
+
 	return err
 }

 // Parses an xml file.
-func (f *ConfigurationFile) parseXmlFile(file *os.File) error {
+func (f *ConfigurationFile) parseXmlFile(path string) error {
 	doc := etree.NewDocument()
+	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0o644)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
 	if _, err := doc.ReadFrom(file); err != nil {
 		return err
 	}
@@ -281,27 +291,41 @@ func (f *ConfigurationFile) parseXmlFile(file *os.File) error {
 		}
 	}

-	if _, err := file.Seek(0, io.SeekStart); err != nil {
-		return err
-	}
+	// If you don't truncate the file you'll end up duplicating the data in there (or just appending
+	// to the end of the file. We don't want to do that.
 	if err := file.Truncate(0); err != nil {
 		return err
 	}

+	// Move the cursor to the start of the file to avoid weird spacing issues.
+	file.Seek(0, 0)
+
 	// Ensure the XML is indented properly.
 	doc.Indent(2)

-	// Write the XML to the file.
-	if _, err := doc.WriteTo(file); err != nil {
+	// Truncate the file before attempting to write the changes.
+	if err := os.Truncate(path, 0); err != nil {
 		return err
 	}
-	return nil
+
+	// Write the XML to the file.
+	_, err = doc.WriteTo(file)
+
+	return err
 }

 // Parses an ini file.
-func (f *ConfigurationFile) parseIniFile(file *os.File) error {
-	// Wrap the file in a NopCloser so the ini package doesn't close the file.
-	cfg, err := ini.Load(io.NopCloser(file))
+func (f *ConfigurationFile) parseIniFile(path string) error {
+	// Ini package can't handle a non-existent file, so handle that automatically here
+	// by creating it if not exists. Then, immediately close the file since we will use
+	// other methods to write the new contents.
+	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0o644)
+	if err != nil {
+		return err
+	}
+	file.Close()
+
+	cfg, err := ini.Load(path)
 	if err != nil {
 		return err
 	}
@@ -364,24 +388,14 @@ func (f *ConfigurationFile) parseIniFile(file *os.File) error {
 		}
 	}

-	if _, err := file.Seek(0, io.SeekStart); err != nil {
-		return err
-	}
-	if err := file.Truncate(0); err != nil {
-		return err
-	}
-
-	if _, err := cfg.WriteTo(file); err != nil {
-		return err
-	}
-	return nil
+	return cfg.SaveTo(path)
 }

 // Parses a json file updating any matching key/value pairs. If a match is not found, the
 // value is set regardless in the file. See the commentary in parseYamlFile for more details
 // about what is happening during this process.
-func (f *ConfigurationFile) parseJsonFile(file *os.File) error {
-	b, err := io.ReadAll(file)
+func (f *ConfigurationFile) parseJsonFile(path string) error {
+	b, err := readFileBytes(path)
 	if err != nil {
 		return err
 	}
@@ -391,24 +405,14 @@ func (f *ConfigurationFile) parseJsonFile(file *os.File) error {
 		return err
 	}

-	if _, err := file.Seek(0, io.SeekStart); err != nil {
-		return err
-	}
-	if err := file.Truncate(0); err != nil {
-		return err
-	}
-
-	// Write the data to the file.
-	if _, err := io.Copy(file, bytes.NewReader(data.BytesIndent("", "    "))); err != nil {
-		return errors.Wrap(err, "parser: failed to write properties file to disk")
-	}
-	return nil
+	output := []byte(data.StringIndent("", "    "))
+	return os.WriteFile(path, output, 0o644)
 }

 // Parses a yaml file and updates any matching key/value pairs before persisting
 // it back to the disk.
-func (f *ConfigurationFile) parseYamlFile(file *os.File) error {
-	b, err := io.ReadAll(file)
+func (f *ConfigurationFile) parseYamlFile(path string) error {
+	b, err := readFileBytes(path)
 	if err != nil {
 		return err
 	}
@@ -439,56 +443,35 @@ func (f *ConfigurationFile) parseYamlFile(file *os.File) error {
 		return err
 	}

-	if _, err := file.Seek(0, io.SeekStart); err != nil {
-		return err
-	}
-	if err := file.Truncate(0); err != nil {
-		return err
-	}
-
-	// Write the data to the file.
-	if _, err := io.Copy(file, bytes.NewReader(marshaled)); err != nil {
-		return errors.Wrap(err, "parser: failed to write properties file to disk")
-	}
-	return nil
+	return os.WriteFile(path, marshaled, 0o644)
 }

 // Parses a text file using basic find and replace. This is a highly inefficient method of
 // scanning a file and performing a replacement. You should attempt to use anything other
 // than this function where possible.
-func (f *ConfigurationFile) parseTextFile(file *os.File) error {
-	b := bytes.NewBuffer(nil)
-	s := bufio.NewScanner(file)
-	var replaced bool
-	for s.Scan() {
-		line := s.Bytes()
-		replaced = false
+func (f *ConfigurationFile) parseTextFile(path string) error {
+	input, err := os.ReadFile(path)
+	if err != nil {
+		return err
+	}
+
+	lines := strings.Split(string(input), "\n")
+	for i, line := range lines {
 		for _, replace := range f.Replace {
 			// If this line doesn't match what we expect for the replacement, move on to the next
 			// line. Otherwise, update the line to have the replacement value.
-			if !bytes.HasPrefix(line, []byte(replace.Match)) {
+			if !strings.HasPrefix(line, replace.Match) {
 				continue
 			}
-			b.Write(replace.ReplaceWith.Bytes())
-			replaced = true
+
+			lines[i] = replace.ReplaceWith.String()
 		}
-		if !replaced {
-			b.Write(line)
-		}
-		b.WriteByte('\n')
 	}

-	if _, err := file.Seek(0, io.SeekStart); err != nil {
-		return err
-	}
-	if err := file.Truncate(0); err != nil {
+	if err := os.WriteFile(path, []byte(strings.Join(lines, "\n")), 0o644); err != nil {
 		return err
 	}

-	// Write the data to the file.
-	if _, err := io.Copy(file, b); err != nil {
-		return errors.Wrap(err, "parser: failed to write properties file to disk")
-	}
 	return nil
 }

@@ -518,29 +501,31 @@ func (f *ConfigurationFile) parseTextFile(file *os.File) error {
 //
 // @see https://github.com/pterodactyl/panel/issues/2308 (original)
 // @see https://github.com/pterodactyl/panel/issues/3009 ("bug" introduced as result)
-func (f *ConfigurationFile) parsePropertiesFile(file *os.File) error {
-	b, err := io.ReadAll(file)
-	if err != nil {
-		return err
-	}
-
-	s := bytes.NewBuffer(nil)
-	scanner := bufio.NewScanner(bytes.NewReader(b))
-	// Scan until we hit a line that is not a comment that actually has content
-	// on it. Keep appending the comments until that time.
-	for scanner.Scan() {
-		text := scanner.Bytes()
-		if len(text) > 0 && text[0] != '#' {
-			break
+func (f *ConfigurationFile) parsePropertiesFile(path string) error {
+	var s strings.Builder
+	// Open the file and attempt to load any comments that currenty exist at the start
+	// of the file. This is kind of a hack, but should work for a majority of users for
+	// the time being.
+	if fd, err := os.Open(path); err != nil {
+		return errors.Wrap(err, "parser: could not open file for reading")
+	} else {
+		scanner := bufio.NewScanner(fd)
+		// Scan until we hit a line that is not a comment that actually has content
+		// on it. Keep appending the comments until that time.
+		for scanner.Scan() {
+			text := scanner.Text()
+			if len(text) > 0 && text[0] != '#' {
+				break
+			}
+			s.WriteString(text + "\n")
+		}
+		_ = fd.Close()
+		if err := scanner.Err(); err != nil {
+			return errors.WithStackIf(err)
 		}
-		s.Write(text)
-		s.WriteByte('\n')
-	}
-	if err := scanner.Err(); err != nil {
-		return errors.WithStackIf(err)
 	}

-	p, err := properties.Load(b, properties.UTF8)
+	p, err := properties.LoadFile(path, properties.UTF8)
 	if err != nil {
 		return errors.Wrap(err, "parser: could not load properties file for configuration update")
 	}
@@ -578,16 +563,17 @@ func (f *ConfigurationFile) parsePropertiesFile(file *os.File) error {
 		s.WriteString(key + "=" + strings.Trim(strconv.QuoteToASCII(value), "\"") + "\n")
 	}

-	if _, err := file.Seek(0, io.SeekStart); err != nil {
-		return err
-	}
-	if err := file.Truncate(0); err != nil {
+	// Open the file for writing.
+	w, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0o644)
+	if err != nil {
 		return err
 	}
+	defer w.Close()

 	// Write the data to the file.
-	if _, err := io.Copy(file, s); err != nil {
+	if _, err := w.Write([]byte(s.String())); err != nil {
 		return errors.Wrap(err, "parser: failed to write properties file to disk")
 	}
+
 	return nil
 }
--- a/remote/http.go
+++ b/remote/http.go
@@ -3,7 +3,6 @@ package remote
 import (
 	"bytes"
 	"context"
-	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
@@ -11,11 +10,10 @@ import (
 	"strings"
 	"time"

-	"github.com/pterodactyl/wings/internal/models"
-
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/cenkalti/backoff/v4"
+	"github.com/goccy/go-json"

 	"github.com/pterodactyl/wings/system"
 )
@@ -29,10 +27,9 @@ type Client interface {
 	SetArchiveStatus(ctx context.Context, uuid string, successful bool) error
 	SetBackupStatus(ctx context.Context, backup string, data BackupRequest) error
 	SendRestorationStatus(ctx context.Context, backup string, successful bool) error
-	SetInstallationStatus(ctx context.Context, uuid string, data InstallStatusRequest) error
+	SetInstallationStatus(ctx context.Context, uuid string, successful bool) error
 	SetTransferStatus(ctx context.Context, uuid string, successful bool) error
 	ValidateSftpCredentials(ctx context.Context, request SftpAuthRequest) (SftpAuthResponse, error)
-	SendActivityLogs(ctx context.Context, activity []models.Activity) error
 }

 type client struct {
@@ -131,19 +128,10 @@ func (c *client) requestOnce(ctx context.Context, method, path string, body io.R
 // and adds the required authentication headers to the request that is being
 // created. Errors returned will be of the RequestError type if there was some
 // type of response from the API that can be parsed.
-func (c *client) request(ctx context.Context, method, path string, body *bytes.Buffer, opts ...func(r *http.Request)) (*Response, error) {
+func (c *client) request(ctx context.Context, method, path string, body io.Reader, opts ...func(r *http.Request)) (*Response, error) {
 	var res *Response
 	err := backoff.Retry(func() error {
-		var b bytes.Buffer
-		if body != nil {
-			// We have to create a copy of the body, otherwise attempting this request again will
-			// send no data if there was initially a body since the "requestOnce" method will read
-			// the whole buffer, thus leaving it empty at the end.
-			if _, err := b.Write(body.Bytes()); err != nil {
-				return backoff.Permanent(errors.Wrap(err, "http: failed to copy body buffer"))
-			}
-		}
-		r, err := c.requestOnce(ctx, method, path, &b, opts...)
+		r, err := c.requestOnce(ctx, method, path, body, opts...)
 		if err != nil {
 			if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
 				return backoff.Permanent(err)
@@ -154,10 +142,12 @@ func (c *client) request(ctx context.Context, method, path string, body *bytes.B
 		if r.HasError() {
 			// Close the request body after returning the error to free up resources.
 			defer r.Body.Close()
-			// Don't keep attempting to access this endpoint if the response is a 4XX
-			// level error which indicates a client mistake. Only retry when the error
-			// is due to a server issue (5XX error).
-			if r.StatusCode >= 400 && r.StatusCode < 500 {
+			// Don't keep spamming the endpoint if we've already made too many requests or
+			// if we're not even authenticated correctly. Retrying generally won't fix either
+			// of these issues.
+			if r.StatusCode == http.StatusForbidden ||
+				r.StatusCode == http.StatusTooManyRequests ||
+				r.StatusCode == http.StatusUnauthorized {
 				return backoff.Permanent(r.Error())
 			}
 			return r.Error()
--- a/remote/servers.go
+++ b/remote/servers.go
@@ -6,8 +6,6 @@ import (
 	"strconv"
 	"sync"

-	"github.com/pterodactyl/wings/internal/models"
-
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"golang.org/x/sync/errgroup"
@@ -19,7 +17,7 @@ const (
 	ProcessStopNativeStop = "stop"
 )

-// GetServers returns all the servers that are present on the Panel making
+// GetServers returns all of the servers that are present on the Panel making
 // parallel API calls to the endpoint if more than one page of servers is
 // returned.
 func (c *client) GetServers(ctx context.Context, limit int) ([]RawServerData, error) {
@@ -58,7 +56,7 @@ func (c *client) GetServers(ctx context.Context, limit int) ([]RawServerData, er
 //
 // This handles Wings exiting during either of these processes which will leave
 // things in a bad state within the Panel. This API call is executed once Wings
-// has fully booted all the servers.
+// has fully booted all of the servers.
 func (c *client) ResetServersState(ctx context.Context) error {
 	res, err := c.Post(ctx, "/servers/reset", nil)
 	if err != nil {
@@ -92,8 +90,8 @@ func (c *client) GetInstallationScript(ctx context.Context, uuid string) (Instal
 	return config, err
 }

-func (c *client) SetInstallationStatus(ctx context.Context, uuid string, data InstallStatusRequest) error {
-	resp, err := c.Post(ctx, fmt.Sprintf("/servers/%s/install", uuid), data)
+func (c *client) SetInstallationStatus(ctx context.Context, uuid string, successful bool) error {
+	resp, err := c.Post(ctx, fmt.Sprintf("/servers/%s/install", uuid), d{"successful": successful})
 	if err != nil {
 		return err
 	}
@@ -115,7 +113,7 @@ func (c *client) SetTransferStatus(ctx context.Context, uuid string, successful
 	if successful {
 		state = "success"
 	}
-	resp, err := c.Post(ctx, fmt.Sprintf("/servers/%s/transfer/%s", uuid, state), nil)
+	resp, err := c.Get(ctx, fmt.Sprintf("/servers/%s/transfer/%s", uuid, state), nil)
 	if err != nil {
 		return err
 	}
@@ -127,7 +125,7 @@ func (c *client) SetTransferStatus(ctx context.Context, uuid string, successful
 // password combination provided is associated with a valid server on the instance
 // using the Panel's authentication control mechanisms. This will get itself
 // throttled if too many requests are made, allowing us to completely offload
-// all the authorization security logic to the Panel.
+// all of the authorization security logic to the Panel.
 func (c *client) ValidateSftpCredentials(ctx context.Context, request SftpAuthRequest) (SftpAuthResponse, error) {
 	var auth SftpAuthResponse
 	res, err := c.Post(ctx, "/sftp/auth", request)
@@ -180,16 +178,6 @@ func (c *client) SendRestorationStatus(ctx context.Context, backup string, succe
 	return nil
 }

-// SendActivityLogs sends activity logs back to the Panel for processing.
-func (c *client) SendActivityLogs(ctx context.Context, activity []models.Activity) error {
-	resp, err := c.Post(ctx, "/activity", d{"data": activity})
-	if err != nil {
-		return errors.WithStackIf(err)
-	}
-	_ = resp.Body.Close()
-	return nil
-}
-
 // getServersPaged returns a subset of servers from the Panel API using the
 // pagination query parameters.
 func (c *client) getServersPaged(ctx context.Context, page, limit int) ([]RawServerData, Pagination, error) {
--- a/remote/types.go
+++ b/remote/types.go
@@ -1,21 +1,15 @@
 package remote

 import (
-	"bytes"
-	"encoding/json"
 	"regexp"
 	"strings"

 	"github.com/apex/log"
+	"github.com/goccy/go-json"

 	"github.com/pterodactyl/wings/parser"
 )

-const (
-	SftpAuthPassword  = SftpAuthRequestType("password")
-	SftpAuthPublicKey = SftpAuthRequestType("public_key")
-)
-
 // A generic type allowing for easy binding use when making requests to API
 // endpoints that only expect a singular argument or something that would not
 // benefit from being a typed struct.
@@ -68,17 +62,14 @@ type RawServerData struct {
 	ProcessConfiguration json.RawMessage `json:"process_configuration"`
 }

-type SftpAuthRequestType string
-
 // SftpAuthRequest defines the request details that are passed along to the Panel
 // when determining if the credentials provided to Wings are valid.
 type SftpAuthRequest struct {
-	Type          SftpAuthRequestType `json:"type"`
-	User          string              `json:"username"`
-	Pass          string              `json:"password"`
-	IP            string              `json:"ip"`
-	SessionID     []byte              `json:"session_id"`
-	ClientVersion []byte              `json:"client_version"`
+	User          string `json:"username"`
+	Pass          string `json:"password"`
+	IP            string `json:"ip"`
+	SessionID     []byte `json:"session_id"`
+	ClientVersion []byte `json:"client_version"`
 }

 // SftpAuthResponse is returned by the Panel when a pair of SFTP credentials
@@ -87,45 +78,44 @@ type SftpAuthRequest struct {
 // user for the SFTP subsystem.
 type SftpAuthResponse struct {
 	Server      string   `json:"server"`
-	User        string   `json:"user"`
+	Token       string   `json:"token"`
 	Permissions []string `json:"permissions"`
 }

 type OutputLineMatcher struct {
-	// raw string to match against. This may or may not be prefixed with
-	// `regex:` which indicates we want to match against the regex expression.
-	raw []byte
+	// The raw string to match against. This may or may not be prefixed with
+	// regex: which indicates we want to match against the regex expression.
+	raw string
 	reg *regexp.Regexp
 }

-// Matches determines if the provided byte string matches the given regex or
-// raw string provided to the matcher.
-func (olm *OutputLineMatcher) Matches(s []byte) bool {
+// Matches determines if a given string "s" matches the given line.
+func (olm *OutputLineMatcher) Matches(s string) bool {
 	if olm.reg == nil {
-		return bytes.Contains(s, olm.raw)
+		return strings.Contains(s, olm.raw)
 	}
-	return olm.reg.Match(s)
+
+	return olm.reg.MatchString(s)
 }

 // String returns the matcher's raw comparison string.
 func (olm *OutputLineMatcher) String() string {
-	return string(olm.raw)
+	return olm.raw
 }

 // UnmarshalJSON unmarshals the startup lines into individual structs for easier
 // matching abilities.
 func (olm *OutputLineMatcher) UnmarshalJSON(data []byte) error {
-	var r string
-	if err := json.Unmarshal(data, &r); err != nil {
+	if err := json.Unmarshal(data, &olm.raw); err != nil {
 		return err
 	}

-	olm.raw = []byte(r)
-	if bytes.HasPrefix(olm.raw, []byte("regex:")) && len(olm.raw) > 6 {
-		r, err := regexp.Compile(strings.TrimPrefix(string(olm.raw), "regex:"))
+	if strings.HasPrefix(olm.raw, "regex:") && len(olm.raw) > 6 {
+		r, err := regexp.Compile(strings.TrimPrefix(olm.raw, "regex:"))
 		if err != nil {
-			log.WithField("error", err).WithField("raw", string(olm.raw)).Warn("failed to compile output line marked as being regex")
+			log.WithField("error", err).WithField("raw", olm.raw).Warn("failed to compile output line marked as being regex")
 		}
+
 		olm.reg = r
 	}

@@ -139,9 +129,9 @@ type ProcessStopConfiguration struct {
 }

 // ProcessConfiguration defines the process configuration for a given server
-// instance. This sets what Wings is looking for to mark a server as done
-// starting what to do when stopping, and what changes to make to the
-// configuration file for a server.
+// instance. This sets what Wings is looking for to mark a server as done starting
+// what to do when stopping, and what changes to make to the configuration file
+// for a server.
 type ProcessConfiguration struct {
 	Startup struct {
 		Done            []*OutputLineMatcher `json:"done"`
@@ -157,20 +147,9 @@ type BackupRemoteUploadResponse struct {
 	PartSize int64    `json:"part_size"`
 }

-type BackupPart struct {
-	ETag       string `json:"etag"`
-	PartNumber int    `json:"part_number"`
-}
-
 type BackupRequest struct {
-	Checksum     string       `json:"checksum"`
-	ChecksumType string       `json:"checksum_type"`
-	Size         int64        `json:"size"`
-	Successful   bool         `json:"successful"`
-	Parts        []BackupPart `json:"parts"`
-}
-
-type InstallStatusRequest struct {
-	Successful bool `json:"successful"`
-	Reinstall  bool `json:"reinstall"`
+	Checksum     string `json:"checksum"`
+	ChecksumType string `json:"checksum_type"`
+	Size         int64  `json:"size"`
+	Successful   bool   `json:"successful"`
 }
--- a/router/downloader/downloader.go
+++ b/router/downloader/downloader.go
@@ -2,10 +2,8 @@ package downloader

 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"io"
-	"mime"
 	"net"
 	"net/http"
 	"net/url"
@@ -16,62 +14,25 @@ import (

 	"emperror.dev/errors"
 	"github.com/google/uuid"
+	"github.com/goccy/go-json"

 	"github.com/pterodactyl/wings/server"
 )

-var client *http.Client
-
-func init() {
-	dialer := &net.Dialer{
-		LocalAddr: nil,
-	}
-
-	trnspt := http.DefaultTransport.(*http.Transport).Clone()
-	trnspt.DialContext = func(ctx context.Context, network, addr string) (net.Conn, error) {
-		c, err := dialer.DialContext(ctx, network, addr)
-		if err != nil {
-			return nil, errors.WithStack(err)
-		}
-
-		ipStr, _, err := net.SplitHostPort(c.RemoteAddr().String())
-		if err != nil {
-			return c, errors.WithStack(err)
-		}
-		ip := net.ParseIP(ipStr)
-		if ip == nil {
-			return c, errors.WithStack(ErrInvalidIPAddress)
-		}
-		if ip.IsLoopback() || ip.IsLinkLocalUnicast() || ip.IsLinkLocalMulticast() || ip.IsInterfaceLocalMulticast() {
-			return c, errors.WithStack(ErrInternalResolution)
-		}
-		for _, block := range internalRanges {
-			if !block.Contains(ip) {
-				continue
-			}
-			return c, errors.WithStack(ErrInternalResolution)
-		}
-		return c, nil
-	}
-
-	client = &http.Client{
-		Timeout: time.Hour * 12,
-
-		Transport: trnspt,
-
-		// Disallow any redirect on an HTTP call. This is a security requirement: do not modify
-		// this logic without first ensuring that the new target location IS NOT within the current
-		// instance's local network.
-		//
-		// This specific error response just causes the client to not follow the redirect and
-		// returns the actual redirect response to the caller. Not perfect, but simple and most
-		// people won't be using URLs that redirect anyways hopefully?
-		//
-		// We'll re-evaluate this down the road if needed.
-		CheckRedirect: func(req *http.Request, via []*http.Request) error {
-			return http.ErrUseLastResponse
-		},
-	}
+var client = &http.Client{
+	Timeout: time.Hour * 12,
+	// Disallow any redirect on an HTTP call. This is a security requirement: do not modify
+	// this logic without first ensuring that the new target location IS NOT within the current
+	// instance's local network.
+	//
+	// This specific error response just causes the client to not follow the redirect and
+	// returns the actual redirect response to the caller. Not perfect, but simple and most
+	// people won't be using URLs that redirect anyways hopefully?
+	//
+	// We'll re-evaluate this down the road if needed.
+	CheckRedirect: func(req *http.Request, via []*http.Request) error {
+		return http.ErrUseLastResponse
+	},
 }

 var instance = &Downloader{
@@ -116,13 +77,10 @@ func (c *Counter) Write(p []byte) (int, error) {
 type DownloadRequest struct {
 	Directory string
 	URL       *url.URL
-	FileName  string
-	UseHeader bool
 }

 type Download struct {
 	Identifier string
-	path       string
 	mu         sync.RWMutex
 	req        DownloadRequest
 	server     *server.Server
@@ -181,6 +139,12 @@ func (dl *Download) Execute() error {
 	dl.cancelFunc = &cancel
 	defer dl.Cancel()

+	// Always ensure that we're checking the destination for the download to avoid a malicious
+	// user from accessing internal network resources.
+	if err := dl.isExternalNetwork(ctx); err != nil {
+		return err
+	}
+
 	// At this point we have verified the destination is not within the local network, so we can
 	// now make a request to that URL and pull down the file, saving it to the server's data
 	// directory.
@@ -199,38 +163,21 @@ func (dl *Download) Execute() error {
 		return errors.New("downloader: got bad response status from endpoint: " + res.Status)
 	}

-	if res.ContentLength < 1 {
-		return errors.New("downloader: request is missing ContentLength")
-	}
-
-	if dl.req.UseHeader {
-		if contentDisposition := res.Header.Get("Content-Disposition"); contentDisposition != "" {
-			_, params, err := mime.ParseMediaType(contentDisposition)
-			if err != nil {
-				return errors.WrapIf(err, "downloader: invalid \"Content-Disposition\" header")
-			}
-
-			if v, ok := params["filename"]; ok {
-				dl.path = v
-			}
-		}
-	}
-	if dl.path == "" {
-		if dl.req.FileName != "" {
-			dl.path = dl.req.FileName
-		} else {
-			parts := strings.Split(dl.req.URL.Path, "/")
-			dl.path = parts[len(parts)-1]
+	// If there is a Content-Length header on this request go ahead and check that we can
+	// even write the whole file before beginning this process. If there is no header present
+	// we'll just have to give it a spin and see how it goes.
+	if res.ContentLength > 0 {
+		if err := dl.server.Filesystem().HasSpaceFor(res.ContentLength); err != nil {
+			return errors.WrapIf(err, "downloader: failed to write file: not enough space")
 		}
 	}

-	p := dl.Path()
+	fnameparts := strings.Split(dl.req.URL.Path, "/")
+	p := filepath.Join(dl.req.Directory, fnameparts[len(fnameparts)-1])
 	dl.server.Log().WithField("path", p).Debug("writing remote file to disk")

-	// Write the file while tracking the progress, Write will check that the
-	// size of the file won't exceed the disk limit.
 	r := io.TeeReader(res.Body, dl.counter(res.ContentLength))
-	if err := dl.server.Filesystem().Write(p, r, res.ContentLength, 0o644); err != nil {
+	if err := dl.server.Filesystem().Writefile(p, r); err != nil {
 		return errors.WrapIf(err, "downloader: failed to write file to server directory")
 	}
 	return nil
@@ -258,10 +205,6 @@ func (dl *Download) Progress() float64 {
 	return dl.progress
 }

-func (dl *Download) Path() string {
-	return filepath.Join(dl.req.Directory, dl.path)
-}
-
 // Handles a write event by updating the progress completed percentage and firing off
 // events to the server websocket as needed.
 func (dl *Download) counter(contentLength int64) *Counter {
@@ -275,6 +218,59 @@ func (dl *Download) counter(contentLength int64) *Counter {
 	}
 }

+// Verifies that a given download resolves to a location not within the current local
+// network for the machine. If the final destination of a resource is within the local
+// network an ErrInternalResolution error is returned.
+func (dl *Download) isExternalNetwork(ctx context.Context) error {
+	dialer := &net.Dialer{
+		LocalAddr: nil,
+	}
+
+	host := dl.req.URL.Host
+
+	// This cluster-fuck of math and integer shit converts an integer IP into a proper IPv4.
+	// For example: 16843009 would become 1.1.1.1
+	//if i, err := strconv.ParseInt(host, 10, 64); err == nil {
+	//	host = strconv.FormatInt((i>>24)&0xFF, 10) + "." + strconv.FormatInt((i>>16)&0xFF, 10) + "." + strconv.FormatInt((i>>8)&0xFF, 10) + "." + strconv.FormatInt(i&0xFF, 10)
+	//}
+
+	if _, _, err := net.SplitHostPort(host); err != nil {
+		if !strings.Contains(err.Error(), "missing port in address") {
+			return errors.WithStack(err)
+		}
+		switch dl.req.URL.Scheme {
+		case "http":
+			host += ":80"
+		case "https":
+			host += ":443"
+		}
+	}
+
+	c, err := dialer.DialContext(ctx, "tcp", host)
+	if err != nil {
+		return errors.WithStack(err)
+	}
+	_ = c.Close()
+
+	ipStr, _, err := net.SplitHostPort(c.RemoteAddr().String())
+	if err != nil {
+		return errors.WithStack(err)
+	}
+	ip := net.ParseIP(ipStr)
+	if ip == nil {
+		return errors.WithStack(ErrInvalidIPAddress)
+	}
+	if ip.IsLoopback() || ip.IsLinkLocalUnicast() || ip.IsLinkLocalMulticast() || ip.IsInterfaceLocalMulticast() {
+		return errors.WithStack(ErrInternalResolution)
+	}
+	for _, block := range internalRanges {
+		if block.Contains(ip) {
+			return errors.WithStack(ErrInternalResolution)
+		}
+	}
+	return nil
+}
+
 // Downloader represents a global downloader that keeps track of all currently processing downloads
 // for the machine.
 type Downloader struct {
--- a/router/error.go
+++ b/router/error.go
@@ -0,0 +1,157 @@
+package router
+
+import (
+	"fmt"
+	"net/http"
+	"os"
+	"strings"
+
+	"emperror.dev/errors"
+	"github.com/apex/log"
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+
+	"github.com/pterodactyl/wings/server"
+	"github.com/pterodactyl/wings/server/filesystem"
+)
+
+type RequestError struct {
+	err     error
+	uuid    string
+	message string
+	server  *server.Server
+}
+
+// Attaches an error to the gin.Context object for the request and ensures that it
+// has a proper stacktrace associated with it when doing so.
+//
+// If you just call c.Error(err) without using this function you'll likely end up
+// with an error that has no annotated stack on it.
+func WithError(c *gin.Context, err error) error {
+	return c.Error(errors.WithStackDepthIf(err, 1))
+}
+
+// Generates a new tracked error, which simply tracks the specific error that
+// is being passed in, and also assigned a UUID to the error so that it can be
+// cross referenced in the logs.
+func NewTrackedError(err error) *RequestError {
+	return &RequestError{
+		err:  err,
+		uuid: uuid.Must(uuid.NewRandom()).String(),
+	}
+}
+
+// Same as NewTrackedError, except this will also attach the server instance that
+// generated this server for the purposes of logging.
+func NewServerError(err error, s *server.Server) *RequestError {
+	return &RequestError{
+		err:    err,
+		uuid:   uuid.Must(uuid.NewRandom()).String(),
+		server: s,
+	}
+}
+
+func (e *RequestError) logger() *log.Entry {
+	if e.server != nil {
+		return e.server.Log().WithField("error_id", e.uuid).WithField("error", e.err)
+	}
+	return log.WithField("error_id", e.uuid).WithField("error", e.err)
+}
+
+// Sets the output message to display to the user in the error.
+func (e *RequestError) SetMessage(msg string) *RequestError {
+	e.message = msg
+	return e
+}
+
+// Aborts the request with the given status code, and responds with the error. This
+// will also include the error UUID in the output so that the user can report that
+// and link the response to a specific error in the logs.
+func (e *RequestError) AbortWithStatus(status int, c *gin.Context) {
+	// In instances where the status has already been set just use that existing status
+	// since we cannot change it at this point, and trying to do so will emit a gin warning
+	// into the program output.
+	if c.Writer.Status() != 200 {
+		status = c.Writer.Status()
+	}
+
+	// If this error is because the resource does not exist, we likely do not need to log
+	// the error anywhere, just return a 404 and move on with our lives.
+	if errors.Is(e.err, os.ErrNotExist) {
+		c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
+			"error": "The requested resource was not found on the system.",
+		})
+		return
+	}
+
+	if strings.HasPrefix(e.err.Error(), "invalid URL escape") {
+		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
+			"error": "Some of the data provided in the request appears to be escaped improperly.",
+		})
+		return
+	}
+
+	// If this is a Filesystem error just return it without all of the tracking code nonsense
+	// since we don't need to be logging it into the logs or anything, its just a normal error
+	// that the user can solve on their end.
+	if st, msg := e.getAsFilesystemError(); st != 0 {
+		c.AbortWithStatusJSON(st, gin.H{"error": msg})
+		return
+	}
+
+	// Otherwise, log the error to zap, and then report the error back to the user.
+	if status >= 500 {
+		e.logger().Error("unexpected error while handling HTTP request")
+	} else {
+		e.logger().Debug("non-server error encountered while handling HTTP request")
+	}
+
+	if e.message == "" {
+		e.message = "An unexpected error was encountered while processing this request."
+	}
+
+	c.AbortWithStatusJSON(status, gin.H{"error": e.message, "error_id": e.uuid})
+}
+
+// Helper function to just abort with an internal server error. This is generally the response
+// from most errors encountered by the API.
+func (e *RequestError) Abort(c *gin.Context) {
+	e.AbortWithStatus(http.StatusInternalServerError, c)
+}
+
+// Looks at the given RequestError and determines if it is a specific filesystem error that
+// we can process and return differently for the user.
+func (e *RequestError) getAsFilesystemError() (int, string) {
+	// Some external things end up calling fmt.Errorf() on our filesystem errors
+	// which ends up just unleashing chaos on the system. For the sake of this
+	// fallback to using text checks...
+	if filesystem.IsErrorCode(e.err, filesystem.ErrCodeDenylistFile) || strings.Contains(e.err.Error(), "filesystem: file access prohibited") {
+		return http.StatusForbidden, "This file cannot be modified: present in egg denylist."
+	}
+	if filesystem.IsErrorCode(e.err, filesystem.ErrCodePathResolution) || strings.Contains(e.err.Error(), "resolves to a location outside the server root") {
+		return http.StatusNotFound, "The requested resource was not found on the system."
+	}
+	if filesystem.IsErrorCode(e.err, filesystem.ErrCodeIsDirectory) || strings.Contains(e.err.Error(), "filesystem: is a directory") {
+		return http.StatusBadRequest, "Cannot perform that action: file is a directory."
+	}
+	if filesystem.IsErrorCode(e.err, filesystem.ErrCodeDiskSpace) || strings.Contains(e.err.Error(), "filesystem: not enough disk space") {
+		return http.StatusBadRequest, "Cannot perform that action: not enough disk space available."
+	}
+	if strings.HasSuffix(e.err.Error(), "file name too long") {
+		return http.StatusBadRequest, "Cannot perform that action: file name is too long."
+	}
+	if e, ok := e.err.(*os.SyscallError); ok && e.Syscall == "readdirent" {
+		return http.StatusNotFound, "The requested directory does not exist."
+	}
+	return 0, ""
+}
+
+// Handle specific filesystem errors for a server.
+func (e *RequestError) AbortFilesystemError(c *gin.Context) {
+	e.Abort(c)
+}
+
+// Format the error to a string and include the UUID.
+func (e *RequestError) Error() string {
+	return fmt.Sprintf("%v (uuid: %s)", e.err, e.uuid)
+}
--- a/router/middleware/middleware.go
+++ b/router/middleware/middleware.go
@@ -1,9 +1,11 @@
 package middleware

 import (
+	"context"
 	"crypto/subtle"
 	"io"
 	"net/http"
+	"os"
 	"strings"

 	"emperror.dev/errors"
@@ -14,8 +16,133 @@ import (
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/remote"
 	"github.com/pterodactyl/wings/server"
+	"github.com/pterodactyl/wings/server/filesystem"
 )

+// RequestError is a custom error type returned when something goes wrong with
+// any of the HTTP endpoints.
+type RequestError struct {
+	err    error
+	status int
+	msg    string
+}
+
+// NewError returns a new RequestError for the provided error.
+func NewError(err error) *RequestError {
+	return &RequestError{
+		// Attach a stacktrace to the error if it is missing at this point and mark it
+		// as originating from the location where NewError was called, rather than this
+		// specific point in the code.
+		err: errors.WithStackDepthIf(err, 1),
+	}
+}
+
+// SetMessage allows for a custom error message to be set on an existing
+// RequestError instance.
+func (re *RequestError) SetMessage(m string) {
+	re.msg = m
+}
+
+// SetStatus sets the HTTP status code for the error response. By default this
+// is a HTTP-500 error.
+func (re *RequestError) SetStatus(s int) {
+	re.status = s
+}
+
+// Abort aborts the given HTTP request with the specified status code and then
+// logs the event into the logs. The error that is output will include the unique
+// request ID if it is present.
+func (re *RequestError) Abort(c *gin.Context, status int) {
+	reqId := c.Writer.Header().Get("X-Request-Id")
+
+	// Generate the base logger instance, attaching the unique request ID and
+	// the URL that was requested.
+	event := log.WithField("request_id", reqId).WithField("url", c.Request.URL.String())
+	// If there is a server present in the gin.Context stack go ahead and pull it
+	// and attach that server UUID to the logs as well so that we can see what specific
+	// server triggered this error.
+	if s, ok := c.Get("server"); ok {
+		if s, ok := s.(*server.Server); ok {
+			event = event.WithField("server_id", s.ID())
+		}
+	}
+
+	if c.Writer.Status() == 200 {
+		// Handle context deadlines being exceeded a little differently since we want
+		// to report a more user-friendly error and a proper error code. The "context
+		// canceled" error is generally when a request is terminated before all of the
+		// logic is finished running.
+		if errors.Is(re.err, context.DeadlineExceeded) {
+			re.SetStatus(http.StatusGatewayTimeout)
+			re.SetMessage("The server could not process this request in time, please try again.")
+		} else if strings.Contains(re.Cause().Error(), "context canceled") {
+			re.SetStatus(http.StatusBadRequest)
+			re.SetMessage("Request aborted by client.")
+		}
+	}
+
+	// c.Writer.Status() will be a non-200 value if the headers have already been sent
+	// to the requester but an error is encountered. This can happen if there is an issue
+	// marshaling a struct placed into a c.JSON() call (or c.AbortWithJSON() call).
+	if status >= 500 || c.Writer.Status() != 200 {
+		event.WithField("status", status).WithField("error", re.err).Error("error while handling HTTP request")
+	} else {
+		event.WithField("status", status).WithField("error", re.err).Debug("error handling HTTP request (not a server error)")
+	}
+	if re.msg == "" {
+		re.msg = "An unexpected error was encountered while processing this request"
+	}
+	// Now abort the request with the error message and include the unique request
+	// ID that was present to make things super easy on people who don't know how
+	// or cannot view the response headers (where X-Request-Id would be present).
+	c.AbortWithStatusJSON(status, gin.H{"error": re.msg, "request_id": reqId})
+}
+
+// Cause returns the underlying error.
+func (re *RequestError) Cause() error {
+	return re.err
+}
+
+// Error returns the underlying error message for this request.
+func (re *RequestError) Error() string {
+	return re.err.Error()
+}
+
+// Looks at the given RequestError and determines if it is a specific filesystem
+// error that we can process and return differently for the user.
+//
+// Some external things end up calling fmt.Errorf() on our filesystem errors
+// which ends up just unleashing chaos on the system. For the sake of this,
+// fallback to using text checks.
+//
+// If the error passed into this call is nil or does not match empty values will
+// be returned to the caller.
+func (re *RequestError) asFilesystemError() (int, string) {
+	err := re.Cause()
+	if err == nil {
+		return 0, ""
+	}
+	if filesystem.IsErrorCode(err, filesystem.ErrCodeDenylistFile) || strings.Contains(err.Error(), "filesystem: file access prohibited") {
+		return http.StatusForbidden, "This file cannot be modified: present in egg denylist."
+	}
+	if filesystem.IsErrorCode(err, filesystem.ErrCodePathResolution) || strings.Contains(err.Error(), "resolves to a location outside the server root") {
+		return http.StatusNotFound, "The requested resource was not found on the system."
+	}
+	if filesystem.IsErrorCode(err, filesystem.ErrCodeIsDirectory) || strings.Contains(err.Error(), "filesystem: is a directory") {
+		return http.StatusBadRequest, "Cannot perform that action: file is a directory."
+	}
+	if filesystem.IsErrorCode(err, filesystem.ErrCodeDiskSpace) || strings.Contains(err.Error(), "filesystem: not enough disk space") {
+		return http.StatusBadRequest, "There is not enough disk space available to perform that action."
+	}
+	if strings.HasSuffix(err.Error(), "file name too long") {
+		return http.StatusBadRequest, "Cannot perform that action: file name is too long."
+	}
+	if e, ok := err.(*os.SyscallError); ok && e.Syscall == "readdirent" {
+		return http.StatusNotFound, "The requested directory does not exist."
+	}
+	return 0, ""
+}
+
 // AttachRequestID attaches a unique ID to the incoming HTTP request so that any
 // errors that are generated or returned to the client will include this reference
 // allowing for an easier time identifying the specific request that failed for
@@ -53,7 +180,7 @@ func AttachApiClient(client remote.Client) gin.HandlerFunc {
 }

 // CaptureAndAbort aborts the request and attaches the provided error to the gin
-// context, so it can be reported properly. If the error is missing a stacktrace
+// context so it can be reported properly. If the error is missing a stacktrace
 // at the time it is called the stack will be attached.
 func CaptureAndAbort(c *gin.Context, err error) {
 	c.Abort()
@@ -168,6 +295,7 @@ func RequireAuthorization() gin.HandlerFunc {
 		// We don't put this value outside this function since the node's authentication
 		// token can be changed on the fly and the config.Get() call returns a copy, so
 		// if it is rotated this value will never properly get updated.
+		token := config.Get().AuthenticationToken
 		auth := strings.SplitN(c.GetHeader("Authorization"), " ", 2)
 		if len(auth) != 2 || auth[0] != "Bearer" {
 			c.Header("WWW-Authenticate", "Bearer")
@@ -178,7 +306,7 @@ func RequireAuthorization() gin.HandlerFunc {
 		// All requests to Wings must be authorized with the authentication token present in
 		// the Wings configuration file. Remeber, all requests to Wings come from the Panel
 		// backend, or using a signed JWT for temporary authentication.
-		if subtle.ConstantTimeCompare([]byte(auth[1]), []byte(config.Get().Token.Token)) != 1 {
+		if subtle.ConstantTimeCompare([]byte(auth[1]), []byte(token)) != 1 {
 			c.AbortWithStatusJSON(http.StatusForbidden, gin.H{"error": "You are not authorized to access this endpoint."})
 			return
 		}
--- a/router/middleware/request_error.go
+++ b/router/middleware/request_error.go
@@ -1,141 +0,0 @@
-package middleware
-
-import (
-	"context"
-	"net/http"
-	"os"
-	"strings"
-
-	"emperror.dev/errors"
-	"github.com/apex/log"
-	"github.com/gin-gonic/gin"
-
-	"github.com/pterodactyl/wings/server"
-	"github.com/pterodactyl/wings/server/filesystem"
-)
-
-// RequestError is a custom error type returned when something goes wrong with
-// any of the HTTP endpoints.
-type RequestError struct {
-	err    error
-	status int
-	msg    string
-}
-
-// NewError returns a new RequestError for the provided error.
-func NewError(err error) *RequestError {
-	return &RequestError{
-		// Attach a stacktrace to the error if it is missing at this point and mark it
-		// as originating from the location where NewError was called, rather than this
-		// specific point in the code.
-		err: errors.WithStackDepthIf(err, 1),
-	}
-}
-
-// SetMessage allows for a custom error message to be set on an existing
-// RequestError instance.
-func (re *RequestError) SetMessage(m string) {
-	re.msg = m
-}
-
-// SetStatus sets the HTTP status code for the error response. By default this
-// is a HTTP-500 error.
-func (re *RequestError) SetStatus(s int) {
-	re.status = s
-}
-
-// Abort aborts the given HTTP request with the specified status code and then
-// logs the event into the logs. The error that is output will include the unique
-// request ID if it is present.
-func (re *RequestError) Abort(c *gin.Context, status int) {
-	reqId := c.Writer.Header().Get("X-Request-Id")
-
-	// Generate the base logger instance, attaching the unique request ID and
-	// the URL that was requested.
-	event := log.WithField("request_id", reqId).WithField("url", c.Request.URL.String())
-	// If there is a server present in the gin.Context stack go ahead and pull it
-	// and attach that server UUID to the logs as well so that we can see what specific
-	// server triggered this error.
-	if s, ok := c.Get("server"); ok {
-		if s, ok := s.(*server.Server); ok {
-			event = event.WithField("server_id", s.ID())
-		}
-	}
-
-	if c.Writer.Status() == 200 {
-		// Handle context deadlines being exceeded a little differently since we want
-		// to report a more user-friendly error and a proper error code. The "context
-		// canceled" error is generally when a request is terminated before all of the
-		// logic is finished running.
-		if errors.Is(re.err, context.DeadlineExceeded) {
-			re.SetStatus(http.StatusGatewayTimeout)
-			re.SetMessage("The server could not process this request in time, please try again.")
-		} else if strings.Contains(re.Cause().Error(), "context canceled") {
-			re.SetStatus(http.StatusBadRequest)
-			re.SetMessage("Request aborted by client.")
-		}
-	}
-
-	// c.Writer.Status() will be a non-200 value if the headers have already been sent
-	// to the requester but an error is encountered. This can happen if there is an issue
-	// marshaling a struct placed into a c.JSON() call (or c.AbortWithJSON() call).
-	if status >= 500 || c.Writer.Status() != 200 {
-		event.WithField("status", status).WithField("error", re.err).Error("error while handling HTTP request")
-	} else {
-		event.WithField("status", status).WithField("error", re.err).Debug("error handling HTTP request (not a server error)")
-	}
-	if re.msg == "" {
-		re.msg = "An unexpected error was encountered while processing this request"
-	}
-	// Now abort the request with the error message and include the unique request
-	// ID that was present to make things super easy on people who don't know how
-	// or cannot view the response headers (where X-Request-Id would be present).
-	c.AbortWithStatusJSON(status, gin.H{"error": re.msg, "request_id": reqId})
-}
-
-// Cause returns the underlying error.
-func (re *RequestError) Cause() error {
-	return re.err
-}
-
-// Error returns the underlying error message for this request.
-func (re *RequestError) Error() string {
-	return re.err.Error()
-}
-
-// Looks at the given RequestError and determines if it is a specific filesystem
-// error that we can process and return differently for the user.
-//
-// Some external things end up calling fmt.Errorf() on our filesystem errors
-// which ends up just unleashing chaos on the system. For the sake of this,
-// fallback to using text checks.
-//
-// If the error passed into this call is nil or does not match empty values will
-// be returned to the caller.
-func (re *RequestError) asFilesystemError() (int, string) {
-	err := re.Cause()
-	if err == nil {
-		return 0, ""
-	}
-	if filesystem.IsErrorCode(err, filesystem.ErrNotExist) ||
-		filesystem.IsPathError(err) ||
-		filesystem.IsLinkError(err) {
-		return http.StatusNotFound, "The requested file or folder does not exist on the system."
-	}
-	if filesystem.IsErrorCode(err, filesystem.ErrCodeDenylistFile) || strings.Contains(err.Error(), "filesystem: file access prohibited") {
-		return http.StatusForbidden, "This file cannot be modified: present in egg denylist."
-	}
-	if filesystem.IsErrorCode(err, filesystem.ErrCodeIsDirectory) || strings.Contains(err.Error(), "filesystem: is a directory") {
-		return http.StatusBadRequest, "Cannot perform that action: file is a directory."
-	}
-	if filesystem.IsErrorCode(err, filesystem.ErrCodeDiskSpace) || strings.Contains(err.Error(), "filesystem: not enough disk space") {
-		return http.StatusBadRequest, "There is not enough disk space available to perform that action."
-	}
-	if strings.HasSuffix(err.Error(), "file name too long") {
-		return http.StatusBadRequest, "Cannot perform that action: file name is too long."
-	}
-	if e, ok := err.(*os.SyscallError); ok && e.Syscall == "readdirent" {
-		return http.StatusNotFound, "The requested directory does not exist."
-	}
-	return 0, ""
-}
--- a/router/router.go
+++ b/router/router.go
@@ -1,11 +1,9 @@
 package router

 import (
-	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/gin-gonic/gin"

-	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/remote"
 	"github.com/pterodactyl/wings/router/middleware"
 	wserver "github.com/pterodactyl/wings/server"
@@ -17,10 +15,6 @@ func Configure(m *wserver.Manager, client remote.Client) *gin.Engine {

 	router := gin.New()
 	router.Use(gin.Recovery())
-	if err := router.SetTrustedProxies(config.Get().Api.TrustedProxies); err != nil {
-		panic(errors.WithStack(err))
-		return nil
-	}
 	router.Use(middleware.AttachRequestID(), middleware.CaptureErrors(), middleware.SetAccessControlHeaders())
 	router.Use(middleware.AttachServerManager(m), middleware.AttachApiClient(client))
 	// @todo log this into a different file so you can setup IP blocking for abusive requests and such.
@@ -44,7 +38,7 @@ func Configure(m *wserver.Manager, client remote.Client) *gin.Engine {
 	router.GET("/download/file", getDownloadFile)
 	router.POST("/upload/file", postServerUploadFiles)

-	// This route is special it sits above all the other requests because we are
+	// This route is special it sits above all of the other requests because we are
 	// using a JWT to authorize access to it, therefore it needs to be publicly
 	// accessible.
 	router.GET("/api/servers/:server/ws", middleware.ServerExists(), getServerWebsocket)
@@ -52,17 +46,16 @@ func Configure(m *wserver.Manager, client remote.Client) *gin.Engine {
 	// This request is called by another daemon when a server is going to be transferred out.
 	// This request does not need the AuthorizationMiddleware as the panel should never call it
 	// and requests are authenticated through a JWT the panel issues to the other daemon.
-	router.POST("/api/transfers", postTransfers)
+	router.GET("/api/servers/:server/archive", middleware.ServerExists(), getServerArchive)

-	// All the routes beyond this mount will use an authorization middleware
+	// All of the routes beyond this mount will use an authorization middleware
 	// and will not be accessible without the correct Authorization header provided.
 	protected := router.Use(middleware.RequireAuthorization())
 	protected.POST("/api/update", postUpdateConfiguration)
 	protected.GET("/api/system", getSystemInformation)
 	protected.GET("/api/servers", getAllServers)
 	protected.POST("/api/servers", postCreateServer)
-	protected.DELETE("/api/transfers/:server", deleteTransfer)
-	protected.POST("/api/deauthorize-user", postDeauthorizeUser)
+	protected.POST("/api/transfer", postTransfer)

 	// These are server specific routes, and require that the request be authorized, and
 	// that the server exist on the Daemon.
@@ -82,8 +75,7 @@ func Configure(m *wserver.Manager, client remote.Client) *gin.Engine {

 		// This archive request causes the archive to start being created
 		// this should only be triggered by the panel.
-		server.POST("/transfer", postServerTransfer)
-		server.DELETE("/transfer", deleteServerTransfer)
+		server.POST("/archive", postServerArchive)

 		files := server.Group("/files")
 		{
--- a/router/router_download.go
+++ b/router/router_download.go
@@ -8,7 +8,6 @@ import (
 	"strconv"

 	"github.com/gin-gonic/gin"
-	"github.com/google/uuid"

 	"github.com/pterodactyl/wings/router/middleware"
 	"github.com/pterodactyl/wings/router/tokens"
@@ -20,64 +19,9 @@ func getDownloadBackup(c *gin.Context) {
 	client := middleware.ExtractApiClient(c)
 	manager := middleware.ExtractManager(c)

-	// Get the payload from the token.
 	token := tokens.BackupPayload{}
 	if err := tokens.ParseToken([]byte(c.Query("token")), &token); err != nil {
-		middleware.CaptureAndAbort(c, err)
-		return
-	}
-
-	// Get the server using the UUID from the token.
-	if _, ok := manager.Get(token.ServerUuid); !ok || !token.IsUniqueRequest() {
-		c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
-			"error": "The requested resource was not found on this server.",
-		})
-		return
-	}
-
-	// Validate that the BackupUuid field is actually a UUID and not some random characters or a
-	// file path.
-	if _, err := uuid.Parse(token.BackupUuid); err != nil {
-		middleware.CaptureAndAbort(c, err)
-		return
-	}
-
-	// Locate the backup on the local disk.
-	b, st, err := backup.LocateLocal(client, token.BackupUuid)
-	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
-				"error": "The requested backup was not found on this server.",
-			})
-			return
-		}
-
-		middleware.CaptureAndAbort(c, err)
-		return
-	}
-
-	// The use of `os` here is safe as backups are not stored within server access
-	// directories, and this path is program-controlled, not user input.
-	f, err := os.Open(b.Path())
-	if err != nil {
-		middleware.CaptureAndAbort(c, err)
-		return
-	}
-	defer f.Close()
-
-	c.Header("Content-Length", strconv.Itoa(int(st.Size())))
-	c.Header("Content-Disposition", "attachment; filename="+strconv.Quote(st.Name()))
-	c.Header("Content-Type", "application/octet-stream")
-
-	_, _ = bufio.NewReader(f).WriteTo(c.Writer)
-}
-
-// Handles downloading a specific file for a server.
-func getDownloadFile(c *gin.Context) {
-	manager := middleware.ExtractManager(c)
-	token := tokens.FilePayload{}
-	if err := tokens.ParseToken([]byte(c.Query("token")), &token); err != nil {
-		middleware.CaptureAndAbort(c, err)
+		NewTrackedError(err).Abort(c)
 		return
 	}

@@ -89,22 +33,73 @@ func getDownloadFile(c *gin.Context) {
 		return
 	}

-	f, st, err := s.Filesystem().File(token.FilePath)
+	b, st, err := backup.LocateLocal(client, token.BackupUuid)
 	if err != nil {
-		middleware.CaptureAndAbort(c, err)
+		if errors.Is(err, os.ErrNotExist) {
+			c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
+				"error": "The requested backup was not found on this server.",
+			})
+			return
+		}
+
+		NewServerError(err, s).Abort(c)
+		return
+	}
+
+	f, err := os.Open(b.Path())
+	if err != nil {
+		NewServerError(err, s).Abort(c)
 		return
 	}
 	defer f.Close()
-	if st.IsDir() {
+
+	c.Header("Content-Length", strconv.Itoa(int(st.Size())))
+	c.Header("Content-Disposition", "attachment; filename="+strconv.Quote(st.Name()))
+	c.Header("Content-Type", "application/octet-stream")
+
+	bufio.NewReader(f).WriteTo(c.Writer)
+}
+
+// Handles downloading a specific file for a server.
+func getDownloadFile(c *gin.Context) {
+	manager := middleware.ExtractManager(c)
+	token := tokens.FilePayload{}
+	if err := tokens.ParseToken([]byte(c.Query("token")), &token); err != nil {
+		NewTrackedError(err).Abort(c)
+		return
+	}
+
+	s, ok := manager.Get(token.ServerUuid)
+	if !ok || !token.IsUniqueRequest() {
 		c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
 			"error": "The requested resource was not found on this server.",
 		})
 		return
 	}

+	p, _ := s.Filesystem().SafePath(token.FilePath)
+	st, err := os.Stat(p)
+	// If there is an error or we're somehow trying to download a directory, just
+	// respond with the appropriate error.
+	if err != nil {
+		NewServerError(err, s).Abort(c)
+		return
+	} else if st.IsDir() {
+		c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
+			"error": "The requested resource was not found on this server.",
+		})
+		return
+	}
+
+	f, err := os.Open(p)
+	if err != nil {
+		NewServerError(err, s).Abort(c)
+		return
+	}
+
 	c.Header("Content-Length", strconv.Itoa(int(st.Size())))
 	c.Header("Content-Disposition", "attachment; filename="+strconv.Quote(st.Name()))
 	c.Header("Content-Type", "application/octet-stream")

-	_, _ = bufio.NewReader(f).WriteTo(c.Writer)
+	bufio.NewReader(f).WriteTo(c.Writer)
 }
--- a/router/router_server.go
+++ b/router/router_server.go
@@ -9,12 +9,10 @@ import (
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/gin-gonic/gin"
-
 	"github.com/pterodactyl/wings/router/downloader"
 	"github.com/pterodactyl/wings/router/middleware"
 	"github.com/pterodactyl/wings/router/tokens"
 	"github.com/pterodactyl/wings/server"
-	"github.com/pterodactyl/wings/server/transfer"
 )

 // Returns a single server from the collection of servers.
@@ -35,7 +33,7 @@ func getServerLogs(c *gin.Context) {

 	out, err := s.ReadLogfile(l)
 	if err != nil {
-		middleware.CaptureAndAbort(c, err)
+		NewServerError(err, s).Abort(c)
 		return
 	}

@@ -109,7 +107,7 @@ func postServerCommands(c *gin.Context) {
 	s := ExtractServer(c)

 	if running, err := s.Environment.IsRunning(c.Request.Context()); err != nil {
-		middleware.CaptureAndAbort(c, err)
+		NewServerError(err, s).Abort(c)
 		return
 	} else if !running {
 		c.AbortWithStatusJSON(http.StatusBadGateway, gin.H{
@@ -143,7 +141,7 @@ func postServerSync(c *gin.Context) {
 	s := ExtractServer(c)

 	if err := s.Sync(); err != nil {
-		middleware.CaptureAndAbort(c, err)
+		WithError(c, err)
 	} else {
 		c.Status(http.StatusNoContent)
 	}
@@ -153,15 +151,9 @@ func postServerSync(c *gin.Context) {
 func postServerInstall(c *gin.Context) {
 	s := ExtractServer(c)

-	go func(s *server.Server) {
-		s.Log().Info("syncing server state with remote source before executing installation process")
-		if err := s.Sync(); err != nil {
-			s.Log().WithField("error", err).Error("failed to sync server state with Panel")
-			return
-		}
-
-		if err := s.Install(); err != nil {
-			s.Log().WithField("error", err).Error("failed to execute server installation process")
+	go func(serv *server.Server) {
+		if err := serv.Install(true); err != nil {
+			serv.Log().WithField("error", err).Error("failed to execute server installation process")
 		}
 	}(s)

@@ -188,24 +180,13 @@ func postServerReinstall(c *gin.Context) {
 	c.Status(http.StatusAccepted)
 }

-// Deletes a server from the wings daemon and dissociate its objects.
+// Deletes a server from the wings daemon and dissociate it's objects.
 func deleteServer(c *gin.Context) {
 	s := middleware.ExtractServer(c)

 	// Immediately suspend the server to prevent a user from attempting
 	// to start it while this process is running.
 	s.Config().SetSuspended(true)
-
-	// Notify all websocket clients that the server is being deleted.
-	// This is useful for two reasons, one to tell clients not to bother
-	// retrying to connect to the websocket.  And two, for transfers when
-	// the server has been successfully transferred to another node, and
-	// the client needs to switch to the new node.
-	if s.IsTransferring() {
-		s.Events().Publish(server.TransferStatusEvent, transfer.StatusCompleted)
-	}
-	s.Events().Publish(server.DeletedEvent, nil)
-
 	s.CleanupForDestroy()

 	// Remove any pending remote file downloads for the server.
@@ -217,7 +198,7 @@ func deleteServer(c *gin.Context) {
 	// forcibly terminate it before removing the container, so we do not need to handle
 	// that here.
 	if err := s.Environment.Destroy(); err != nil {
-		middleware.CaptureAndAbort(c, err)
+		WithError(c, err)
 		return
 	}

@@ -225,18 +206,13 @@ func deleteServer(c *gin.Context) {
 	// done in a separate process since failure is not the end of the world and can be
 	// manually cleaned up after the fact.
 	//
-	// In addition, servers with large numbers of files can take some time to finish deleting,
+	// In addition, servers with large amounts of files can take some time to finish deleting
 	// so we don't want to block the HTTP call while waiting on this.
-	p := s.Filesystem().Path()
 	go func(p string) {
 		if err := os.RemoveAll(p); err != nil {
 			log.WithFields(log.Fields{"path": p, "error": err}).Warn("failed to remove server files during deletion process")
 		}
-	}(p)
-
-	if err := s.Filesystem().Close(); err != nil {
-		log.WithFields(log.Fields{"server": s.ID(), "error": err}).Warn("failed to close filesystem root")
-	}
+	}(s.Filesystem().Path())

 	middleware.ExtractManager(c).Remove(func(server *server.Server) bool {
 		return server.ID() == s.ID()
@@ -251,8 +227,6 @@ func deleteServer(c *gin.Context) {
 // Adds any of the JTIs passed through in the body to the deny list for the websocket
 // preventing any JWT generated before the current time from being used to connect to
 // the socket or send along commands.
-//
-// deprecated: prefer /api/deauthorize-user
 func postServerDenyWSTokens(c *gin.Context) {
 	var data struct {
 		JTIs []string `json:"jtis"`
--- a/router/router_server_files.go
+++ b/router/router_server_files.go
@@ -18,8 +18,6 @@ import (
 	"github.com/gin-gonic/gin"
 	"golang.org/x/sync/errgroup"

-	"github.com/pterodactyl/wings/config"
-	"github.com/pterodactyl/wings/internal/models"
 	"github.com/pterodactyl/wings/router/downloader"
 	"github.com/pterodactyl/wings/router/middleware"
 	"github.com/pterodactyl/wings/router/tokens"
@@ -30,21 +28,13 @@ import (
 // getServerFileContents returns the contents of a file on the server.
 func getServerFileContents(c *gin.Context) {
 	s := middleware.ExtractServer(c)
-	f, st, err := s.Filesystem().File(c.Query("file"))
+	p := "/" + strings.TrimLeft(c.Query("file"), "/")
+	f, st, err := s.Filesystem().File(p)
 	if err != nil {
 		middleware.CaptureAndAbort(c, err)
 		return
 	}
 	defer f.Close()
-	// Don't allow a named pipe to be opened.
-	//
-	// @see https://github.com/pterodactyl/panel/issues/4059
-	if st.Mode()&os.ModeNamedPipe != 0 {
-		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
-			"error": "Cannot open files of this type.",
-		})
-		return
-	}

 	c.Header("X-Mime-Type", st.Mimetype)
 	c.Header("Content-Length", strconv.Itoa(int(st.Size())))
@@ -78,7 +68,7 @@ func getServerListDirectory(c *gin.Context) {
 	s := ExtractServer(c)
 	dir := c.Query("directory")
 	if stats, err := s.Filesystem().ListDirectory(dir); err != nil {
-		middleware.CaptureAndAbort(c, err)
+		WithError(c, err)
 	} else {
 		c.JSON(http.StatusOK, stats)
 	}
@@ -130,10 +120,6 @@ func putServerRenameFiles(c *gin.Context) {
 					// Return nil if the error is an is not exists.
 					// NOTE: os.IsNotExist() does not work if the error is wrapped.
 					if errors.Is(err, os.ErrNotExist) {
-						s.Log().WithField("error", err).
-							WithField("from_path", pf).
-							WithField("to_path", pt).
-							Warn("failed to rename: source or target does not exist")
 						return nil
 					}
 					return err
@@ -151,7 +137,7 @@ func putServerRenameFiles(c *gin.Context) {
 			return
 		}

-		middleware.CaptureAndAbort(c, err)
+		NewServerError(err, s).AbortFilesystemError(c)
 		return
 	}

@@ -171,11 +157,11 @@ func postServerCopyFile(c *gin.Context) {
 	}

 	if err := s.Filesystem().IsIgnored(data.Location); err != nil {
-		middleware.CaptureAndAbort(c, err)
+		NewServerError(err, s).Abort(c)
 		return
 	}
 	if err := s.Filesystem().Copy(data.Location); err != nil {
-		middleware.CaptureAndAbort(c, err)
+		NewServerError(err, s).AbortFilesystemError(c)
 		return
 	}

@@ -220,7 +206,7 @@ func postServerDeleteFiles(c *gin.Context) {
 	}

 	if err := g.Wait(); err != nil {
-		middleware.CaptureAndAbort(c, err)
+		NewServerError(err, s).Abort(c)
 		return
 	}

@@ -235,19 +221,10 @@ func postServerWriteFile(c *gin.Context) {
 	f = "/" + strings.TrimLeft(f, "/")

 	if err := s.Filesystem().IsIgnored(f); err != nil {
-		middleware.CaptureAndAbort(c, err)
+		NewServerError(err, s).Abort(c)
 		return
 	}
-
-	// A content length of -1 means the actual length is unknown.
-	if c.Request.ContentLength == -1 {
-		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
-			"error": "Missing Content-Length",
-		})
-		return
-	}
-
-	if err := s.Filesystem().Write(f, c.Request.Body, c.Request.ContentLength, 0o644); err != nil {
+	if err := s.Filesystem().Writefile(f, c.Request.Body); err != nil {
 		if filesystem.IsErrorCode(err, filesystem.ErrCodeIsDirectory) {
 			c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
 				"error": "Cannot write file, name conflicts with an existing directory by the same name.",
@@ -255,7 +232,7 @@ func postServerWriteFile(c *gin.Context) {
 			return
 		}

-		middleware.CaptureAndAbort(c, err)
+		NewServerError(err, s).AbortFilesystemError(c)
 		return
 	}

@@ -278,12 +255,9 @@ func postServerPullRemoteFile(c *gin.Context) {
 	s := ExtractServer(c)
 	var data struct {
 		// Deprecated
-		Directory  string `binding:"required_without=RootPath,omitempty" json:"directory"`
-		RootPath   string `binding:"required_without=Directory,omitempty" json:"root"`
-		URL        string `binding:"required" json:"url"`
-		FileName   string `json:"file_name"`
-		UseHeader  bool   `json:"use_header"`
-		Foreground bool   `json:"foreground"`
+		Directory string `binding:"required_without=RootPath,omitempty" json:"directory"`
+		RootPath  string `binding:"required_without=Directory,omitempty" json:"root"`
+		URL       string `binding:"required" json:"url"`
 	}
 	if err := c.BindJSON(&data); err != nil {
 		return
@@ -302,12 +276,12 @@ func postServerPullRemoteFile(c *gin.Context) {
 			})
 			return
 		}
-		middleware.CaptureAndAbort(c, err)
+		WithError(c, err)
 		return
 	}

 	if err := s.Filesystem().HasSpaceErr(true); err != nil {
-		middleware.CaptureAndAbort(c, err)
+		WithError(c, err)
 		return
 	}
 	// Do not allow more than three simultaneous remote file downloads at one time.
@@ -321,41 +295,21 @@ func postServerPullRemoteFile(c *gin.Context) {
 	dl := downloader.New(s, downloader.DownloadRequest{
 		Directory: data.RootPath,
 		URL:       u,
-		FileName:  data.FileName,
-		UseHeader: data.UseHeader,
 	})

-	download := func() error {
+	// Execute this pull in a separate thread since it may take a long time to complete.
+	go func() {
 		s.Log().WithField("download_id", dl.Identifier).WithField("url", u.String()).Info("starting pull of remote file to disk")
 		if err := dl.Execute(); err != nil {
 			s.Log().WithField("download_id", dl.Identifier).WithField("error", err).Error("failed to pull remote file")
-			return err
 		} else {
 			s.Log().WithField("download_id", dl.Identifier).Info("completed pull of remote file")
 		}
-		return nil
-	}
-	if !data.Foreground {
-		go func() {
-			_ = download()
-		}()
-		c.JSON(http.StatusAccepted, gin.H{
-			"identifier": dl.Identifier,
-		})
-		return
-	}
+	}()

-	if err := download(); err != nil {
-		middleware.CaptureAndAbort(c, err)
-		return
-	}
-
-	st, err := s.Filesystem().Stat(dl.Path())
-	if err != nil {
-		middleware.CaptureAndAbort(c, err)
-		return
-	}
-	c.JSON(http.StatusOK, &st)
+	c.JSON(http.StatusAccepted, gin.H{
+		"identifier": dl.Identifier,
+	})
 }

 // Stops a remote file download if it exists and belongs to this server.
@@ -388,7 +342,7 @@ func postServerCreateDirectory(c *gin.Context) {
 			return
 		}

-		middleware.CaptureAndAbort(c, err)
+		NewServerError(err, s).Abort(c)
 		return
 	}

@@ -421,15 +375,9 @@ func postServerCompressFiles(c *gin.Context) {
 		return
 	}

-	f, err := s.Filesystem().CompressFiles(c.Request.Context(), data.RootPath, data.Files)
+	f, err := s.Filesystem().CompressFiles(data.RootPath, data.Files)
 	if err != nil {
-		if errors.Is(err, filesystem.ErrNoSpaceAvailable) {
-			c.AbortWithStatusJSON(http.StatusConflict, gin.H{
-				"error": "This server does not have enough available disk space to generate a compressed archive.",
-			})
-		} else {
-			middleware.CaptureAndAbort(c, err)
-		}
+		NewServerError(err, s).AbortFilesystemError(c)
 		return
 	}

@@ -453,9 +401,20 @@ func postServerDecompressFiles(c *gin.Context) {

 	s := middleware.ExtractServer(c)
 	lg := middleware.ExtractLogger(c).WithFields(log.Fields{"root_path": data.RootPath, "file": data.File})
+	lg.Debug("checking if space is available for file decompression")
+	err := s.Filesystem().SpaceAvailableForDecompression(data.RootPath, data.File)
+	if err != nil {
+		if filesystem.IsErrorCode(err, filesystem.ErrCodeUnknownArchive) {
+			lg.WithField("error", err).Warn("failed to decompress file: unknown archive format")
+			c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{"error": "The archive provided is in a format Wings does not understand."})
+			return
+		}
+		middleware.CaptureAndAbort(c, err)
+		return
+	}

 	lg.Info("starting file decompression")
-	if err := s.Filesystem().DecompressFile(context.Background(), data.RootPath, data.File); err != nil {
+	if err := s.Filesystem().DecompressFile(data.RootPath, data.File); err != nil {
 		// If the file is busy for some reason just return a nicer error to the user since there is not
 		// much we specifically can do. They'll need to stop the running server process in order to overwrite
 		// a file like this.
@@ -536,7 +495,7 @@ func postServerChmodFile(c *gin.Context) {
 			return
 		}

-		middleware.CaptureAndAbort(c, err)
+		NewServerError(err, s).AbortFilesystemError(c)
 		return
 	}

@@ -548,7 +507,7 @@ func postServerUploadFiles(c *gin.Context) {

 	token := tokens.UploadPayload{}
 	if err := tokens.ParseToken([]byte(c.Query("token")), &token); err != nil {
-		middleware.CaptureAndAbort(c, err)
+		NewTrackedError(err).Abort(c)
 		return
 	}

@@ -578,30 +537,23 @@ func postServerUploadFiles(c *gin.Context) {

 	directory := c.Query("directory")

-	maxFileSize := config.Get().Api.UploadLimit
-	maxFileSizeBytes := maxFileSize * 1024 * 1024
 	var totalSize int64
 	for _, header := range headers {
-		if header.Size > maxFileSizeBytes {
-			c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
-				"error": "File " + header.Filename + " is larger than the maximum file upload size of " + strconv.FormatInt(maxFileSize, 10) + " MB.",
-			})
-			return
-		}
 		totalSize += header.Size
 	}

 	for _, header := range headers {
+		p, err := s.Filesystem().SafePath(filepath.Join(directory, header.Filename))
+		if err != nil {
+			NewServerError(err, s).Abort(c)
+			return
+		}
+
 		// We run this in a different method so I can use defer without any of
 		// the consequences caused by calling it in a loop.
-		if err := handleFileUpload(filepath.Join(directory, header.Filename), s, header); err != nil {
-			middleware.CaptureAndAbort(c, err)
+		if err := handleFileUpload(p, s, header); err != nil {
+			NewServerError(err, s).Abort(c)
 			return
-		} else {
-			s.SaveActivity(s.NewRequestActivity(token.UserUuid, c.ClientIP()), server.ActivityFileUploaded, models.ActivityMeta{
-				"file":      header.Filename,
-				"directory": filepath.Clean(directory),
-			})
 		}
 	}
 }
@@ -616,8 +568,9 @@ func handleFileUpload(p string, s *server.Server, header *multipart.FileHeader)
 	if err := s.Filesystem().IsIgnored(p); err != nil {
 		return err
 	}
-	if err := s.Filesystem().Write(p, file, header.Size, 0o644); err != nil {
+	if err := s.Filesystem().Writefile(p, file); err != nil {
 		return err
 	}
+
 	return nil
 }
--- a/router/router_server_transfer.go
+++ b/router/router_server_transfer.go
@@ -1,130 +0,0 @@
-package router
-
-import (
-	"context"
-	"net/http"
-	"strings"
-	"time"
-
-	"emperror.dev/errors"
-	"github.com/gin-gonic/gin"
-
-	"github.com/pterodactyl/wings/environment"
-	"github.com/pterodactyl/wings/router/middleware"
-	"github.com/pterodactyl/wings/server"
-	"github.com/pterodactyl/wings/server/installer"
-	"github.com/pterodactyl/wings/server/transfer"
-)
-
-// Data passed over to initiate a server transfer.
-type serverTransferRequest struct {
-	URL    string                  `binding:"required" json:"url"`
-	Token  string                  `binding:"required" json:"token"`
-	Server installer.ServerDetails `json:"server"`
-}
-
-// postServerTransfer handles the start of a transfer for a server.
-func postServerTransfer(c *gin.Context) {
-	var data serverTransferRequest
-	if err := c.BindJSON(&data); err != nil {
-		return
-	}
-
-	s := ExtractServer(c)
-
-	// Check if the server is already being transferred.
-	// There will be another endpoint for resetting this value either by deleting the
-	// server, or by canceling the transfer.
-	if s.IsTransferring() {
-		c.AbortWithStatusJSON(http.StatusConflict, gin.H{
-			"error": "A transfer is already in progress for this server.",
-		})
-		return
-	}
-
-	manager := middleware.ExtractManager(c)
-
-	notifyPanelOfFailure := func() {
-		if err := manager.Client().SetTransferStatus(context.Background(), s.ID(), false); err != nil {
-			s.Log().WithField("subsystem", "transfer").
-				WithField("status", false).
-				WithError(err).
-				Error("failed to set transfer status")
-		}
-
-		s.Events().Publish(server.TransferStatusEvent, "failure")
-		s.SetTransferring(false)
-	}
-
-	// Block the server from starting while we are transferring it.
-	s.SetTransferring(true)
-
-	// Ensure the server is offline. Sometimes a "No such container" error gets through
-	// which means the server is already stopped. We can ignore that.
-	if s.Environment.State() != environment.ProcessOfflineState {
-		if err := s.Environment.WaitForStop(
-			s.Context(),
-			time.Second*15,
-			false,
-		); err != nil && !strings.Contains(strings.ToLower(err.Error()), "no such container") {
-			s.SetTransferring(false)
-			middleware.CaptureAndAbort(c, errors.Wrap(err, "failed to stop server for transfer"))
-			return
-		}
-	}
-
-	// Create a new transfer instance for this server.
-	trnsfr := transfer.New(context.Background(), s)
-	transfer.Outgoing().Add(trnsfr)
-
-	go func() {
-		defer transfer.Outgoing().Remove(trnsfr)
-
-		if _, err := trnsfr.PushArchiveToTarget(data.URL, data.Token); err != nil {
-			notifyPanelOfFailure()
-
-			if err == context.Canceled {
-				trnsfr.Log().Debug("canceled")
-				trnsfr.SendMessage("Canceled.")
-				return
-			}
-
-			trnsfr.Log().WithError(err).Error("failed to push archive to target")
-			return
-		}
-
-		// DO NOT NOTIFY THE PANEL OF SUCCESS HERE. The only node that should send
-		// a success status is the destination node.  When we send a failure status,
-		// the panel will automatically cancel the transfer and attempt to reset
-		// the server state on the destination node, we just need to make sure
-		// we clean up our statuses for failure.
-
-		trnsfr.Log().Debug("transfer complete")
-	}()
-
-	c.Status(http.StatusAccepted)
-}
-
-// deleteServerTransfer cancels an outgoing transfer for a server.
-func deleteServerTransfer(c *gin.Context) {
-	s := ExtractServer(c)
-
-	if !s.IsTransferring() {
-		c.AbortWithStatusJSON(http.StatusConflict, gin.H{
-			"error": "Server is not currently being transferred.",
-		})
-		return
-	}
-
-	trnsfr := transfer.Outgoing().Get(s.ID())
-	if trnsfr == nil {
-		c.AbortWithStatusJSON(http.StatusConflict, gin.H{
-			"error": "Server is not currently being transferred.",
-		})
-		return
-	}
-
-	trnsfr.Cancel()
-
-	c.Status(http.StatusAccepted)
-}
--- a/router/router_server_ws.go
+++ b/router/router_server_ws.go
@@ -2,17 +2,14 @@ package router

 import (
 	"context"
-	"encoding/json"
-	"net/http"
 	"time"

-	"emperror.dev/errors"
 	"github.com/gin-gonic/gin"
 	ws "github.com/gorilla/websocket"
+	"github.com/goccy/go-json"
+
 	"github.com/pterodactyl/wings/router/middleware"
 	"github.com/pterodactyl/wings/router/websocket"
-	"github.com/pterodactyl/wings/server"
-	"golang.org/x/time/rate"
 )

 var expectedCloseCodes = []int{
@@ -28,27 +25,6 @@ func getServerWebsocket(c *gin.Context) {
 	manager := middleware.ExtractManager(c)
 	s, _ := manager.Get(c.Param("server"))

-	// Limit the total number of websockets that can be opened at any one time for
-	// a server instance. This applies across all users connected to the server, and
-	// is not applied on a per-user basis.
-	//
-	// todo: it would be great to make this per-user instead, but we need to modify
-	//  how we even request this endpoint in order for that to be possible. Some type
-	//  of signed identifier in the URL that is verified on this end and set by the
-	//  panel using a shared secret is likely the easiest option. The benefit of that
-	//  is that we can both scope things to the user before authentication, and also
-	//  verify that the JWT provided by the panel is assigned to the same user.
-	if s.Websockets().Len() >= 30 {
-		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
-			"error": "Too many open websocket connections.",
-		})
-
-		return
-	}
-
-	c.Header("Content-Security-Policy", "default-src 'self'")
-	c.Header("X-Frame-Options", "DENY")
-
 	// Create a context that can be canceled when the user disconnects from this
 	// socket that will also cancel listeners running in separate threads. If the
 	// connection itself is terminated listeners using this context will also be
@@ -56,66 +32,41 @@ func getServerWebsocket(c *gin.Context) {
 	ctx, cancel := context.WithCancel(c.Request.Context())
 	defer cancel()

-	handler, err := websocket.GetHandler(s, c.Writer, c.Request, c)
+	handler, err := websocket.GetHandler(s, c.Writer, c.Request)
 	if err != nil {
-		middleware.CaptureAndAbort(c, err)
+		NewServerError(err, s).Abort(c)
 		return
 	}
+	defer handler.Connection.Close()

 	// Track this open connection on the server so that we can close them all programmatically
 	// if the server is deleted.
 	s.Websockets().Push(handler.Uuid(), &cancel)
 	handler.Logger().Debug("opening connection to server websocket")
-	defer s.Websockets().Remove(handler.Uuid())

-	go func() {
-		select {
-		// When the main context is canceled (through disconnect, server deletion, or server
-		// suspension) close the connection itself.
-		case <-ctx.Done():
-			handler.Logger().Debug("closing connection to server websocket")
-			if err := handler.Connection.Close(); err != nil {
-				handler.Logger().WithError(err).Error("failed to close websocket connection")
-			}
-			break
-		}
+	defer func() {
+		s.Websockets().Remove(handler.Uuid())
+		handler.Logger().Debug("closing connection to server websocket")
 	}()

+	// If the server is deleted we need to send a close message to the connected client
+	// so that they disconnect since there will be no more events sent along. Listen for
+	// the request context being closed to break this loop, otherwise this routine will
+	// be left hanging in the background.
 	go func() {
 		select {
 		case <-ctx.Done():
-			return
-		// If the server is deleted we need to send a close message to the connected client
-		// so that they disconnect since there will be no more events sent along. Listen for
-		// the request context being closed to break this loop, otherwise this routine will
-		// be left hanging in the background.
+			break
 		case <-s.Context().Done():
-			cancel()
+			handler.Connection.WriteControl(ws.CloseMessage, ws.FormatCloseMessage(ws.CloseGoingAway, "server deleted"), time.Now().Add(time.Second*5))
 			break
 		}
 	}()

-	// Due to how websockets are handled we need to connect to the socket
-	// and _then_ abort it if the server is suspended. You cannot capture
-	// the HTTP response in the websocket client, thus we connect and then
-	// immediately close with failure.
-	if s.IsSuspended() {
-		_ = handler.Connection.WriteMessage(ws.CloseMessage, ws.FormatCloseMessage(4409, "server is suspended"))
-
-		return
-	}
-
-	// There is a separate rate limiter that applies to individual message types
-	// within the actual websocket logic handler. _This_ rate limiter just exists
-	// to avoid enormous floods of data through the socket since we need to parse
-	// JSON each time. This rate limit realistically should never be hit since this
-	// would require sending 50+ messages a second over the websocket (no more than
-	// 10 per 200ms).
-	var throttled bool
-	rl := rate.NewLimiter(rate.Every(time.Millisecond*200), 10)
-
 	for {
-		t, p, err := handler.Connection.ReadMessage()
+		j := websocket.Message{}
+
+		_, p, err := handler.Connection.ReadMessage()
 		if err != nil {
 			if ws.IsUnexpectedCloseError(err, expectedCloseCodes...) {
 				handler.Logger().WithField("error", err).Warn("error handling websocket message for server")
@@ -123,39 +74,16 @@ func getServerWebsocket(c *gin.Context) {
 			break
 		}

-		if !rl.Allow() {
-			if !throttled {
-				throttled = true
-				_ = handler.Connection.WriteJSON(websocket.Message{Event: websocket.ThrottledEvent, Args: []string{"global"}})
-			}
-			continue
-		}
-
-		throttled = false
-
-		// If the message isn't a format we expect, or the length of the message is far larger
-		// than we'd ever expect, drop it. The websocket upgrader logic does enforce a maximum
-		// _compressed_ message size of 4Kb but that could decompress to a much larger amount
-		// of data.
-		if t != ws.TextMessage || len(p) > 32_768 {
-			continue
-		}
-
 		// Discard and JSON parse errors into the void and don't continue processing this
 		// specific socket request. If we did a break here the client would get disconnected
 		// from the socket, which is NOT what we want to do.
-		var j websocket.Message
 		if err := json.Unmarshal(p, &j); err != nil {
 			continue
 		}

 		go func(msg websocket.Message) {
 			if err := handler.HandleInbound(ctx, msg); err != nil {
-				if errors.Is(err, server.ErrSuspended) {
-					cancel()
-				} else {
-					_ = handler.SendErrorJson(msg, err)
-				}
+				handler.SendErrorJson(msg, err)
 			}
 		}(j)
 	}
--- a/router/router_system.go
+++ b/router/router_system.go
@@ -8,12 +8,11 @@ import (

 	"github.com/apex/log"
 	"github.com/gin-gonic/gin"
-	"github.com/pterodactyl/wings/router/tokens"

 	"github.com/pterodactyl/wings/config"
+	"github.com/pterodactyl/wings/installer"
 	"github.com/pterodactyl/wings/router/middleware"
 	"github.com/pterodactyl/wings/server"
-	"github.com/pterodactyl/wings/server/installer"
 	"github.com/pterodactyl/wings/system"
 )

@@ -21,31 +20,15 @@ import (
 func getSystemInformation(c *gin.Context) {
 	i, err := system.GetSystemInformation()
 	if err != nil {
-		middleware.CaptureAndAbort(c, err)
+		NewTrackedError(err).Abort(c)
+
 		return
 	}

-	if c.Query("v") == "2" {
-		c.JSON(http.StatusOK, i)
-		return
-	}
-
-	c.JSON(http.StatusOK, struct {
-		Architecture  string `json:"architecture"`
-		CPUCount      int    `json:"cpu_count"`
-		KernelVersion string `json:"kernel_version"`
-		OS            string `json:"os"`
-		Version       string `json:"version"`
-	}{
-		Architecture:  i.System.Architecture,
-		CPUCount:      i.System.CPUThreads,
-		KernelVersion: i.System.KernelVersion,
-		OS:            i.System.OSType,
-		Version:       i.Version,
-	})
+	c.JSON(http.StatusOK, i)
 }

-// Returns all the servers that are registered and configured correctly on
+// Returns all of the servers that are registered and configured correctly on
 // this wings instance.
 func getAllServers(c *gin.Context) {
 	servers := middleware.ExtractManager(c).All()
@@ -92,7 +75,7 @@ func postCreateServer(c *gin.Context) {
 			return
 		}

-		if err := i.Server().Install(); err != nil {
+		if err := i.Server().Install(false); err != nil {
 			log.WithFields(log.Fields{"server": i.Server().ID(), "error": err}).Error("failed to run install process for server")
 			return
 		}
@@ -114,21 +97,9 @@ func postCreateServer(c *gin.Context) {
 	c.Status(http.StatusAccepted)
 }

-type postUpdateConfigurationResponse struct {
-	Applied bool `json:"applied"`
-}
-
 // Updates the running configuration for this Wings instance.
 func postUpdateConfiguration(c *gin.Context) {
 	cfg := config.Get()
-
-	if cfg.IgnorePanelConfigUpdates {
-		c.JSON(http.StatusOK, postUpdateConfigurationResponse{
-			Applied: false,
-		})
-		return
-	}
-
 	if err := c.BindJSON(&cfg); err != nil {
 		return
 	}
@@ -146,44 +117,11 @@ func postUpdateConfiguration(c *gin.Context) {
 	// Try to write this new configuration to the disk before updating our global
 	// state with it.
 	if err := config.WriteToDisk(cfg); err != nil {
-		middleware.CaptureAndAbort(c, err)
+		WithError(c, err)
 		return
 	}
 	// Since we wrote it to the disk successfully now update the global configuration
 	// state to use this new configuration struct.
 	config.Set(cfg)
-	c.JSON(http.StatusOK, postUpdateConfigurationResponse{
-		Applied: true,
-	})
-}
-
-func postDeauthorizeUser(c *gin.Context) {
-	var data struct {
-		User    string   `json:"user"`
-		Servers []string `json:"servers"`
-	}
-
-	if err := c.BindJSON(&data); err != nil {
-		return
-	}
-
-	// todo: disconnect websockets more gracefully
-	m := middleware.ExtractManager(c)
-	if len(data.Servers) > 0 {
-		for _, uuid := range data.Servers {
-			if s, ok := m.Get(uuid); ok {
-				tokens.DenyForServer(s.ID(), data.User)
-				s.Websockets().CancelAll()
-				s.Sftp().Cancel(data.User)
-			}
-		}
-	} else {
-		for _, s := range m.All() {
-			tokens.DenyForServer(s.ID(), data.User)
-			s.Websockets().CancelAll()
-			s.Sftp().Cancel(data.User)
-		}
-	}
-
 	c.Status(http.StatusNoContent)
 }
--- a/router/router_transfer.go
+++ b/router/router_transfer.go
@@ -1,33 +1,65 @@
 package router

 import (
-	"bytes"
+	"bufio"
 	"context"
 	"crypto/sha256"
 	"encoding/hex"
-	"errors"
 	"fmt"
 	"io"
-	"mime"
-	"mime/multipart"
 	"net/http"
 	"os"
+	"path/filepath"
+	"strconv"
 	"strings"
+	"sync/atomic"
+	"time"

+	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/gin-gonic/gin"
 	"github.com/google/uuid"
+	"github.com/juju/ratelimit"
+	"github.com/mholt/archiver/v3"
+	"github.com/mitchellh/colorstring"

+	"github.com/pterodactyl/wings/config"
+	"github.com/pterodactyl/wings/installer"
+	"github.com/pterodactyl/wings/remote"
 	"github.com/pterodactyl/wings/router/middleware"
 	"github.com/pterodactyl/wings/router/tokens"
 	"github.com/pterodactyl/wings/server"
-	"github.com/pterodactyl/wings/server/installer"
-	"github.com/pterodactyl/wings/server/transfer"
+	"github.com/pterodactyl/wings/server/filesystem"
+	"github.com/pterodactyl/wings/system"
 )

-// postTransfers .
-func postTransfers(c *gin.Context) {
+// Number of ticks in the progress bar
+const ticks = 25
+
+// 100% / number of ticks = percentage represented by each tick
+const tickPercentage = 100 / ticks
+
+type downloadProgress struct {
+	size     int64
+	progress int64
+}
+
+// Data passed over to initiate a server transfer.
+type serverTransferRequest struct {
+	ServerID string                  `binding:"required" json:"server_id"`
+	URL      string                  `binding:"required" json:"url"`
+	Token    string                  `binding:"required" json:"token"`
+	Server   installer.ServerDetails `json:"server"`
+}
+
+func getArchivePath(sID string) string {
+	return filepath.Join(config.Get().System.ArchiveDirectory, sID+".tar.gz")
+}
+
+// Returns the archive for a server so that it can be transferred to a new node.
+func getServerArchive(c *gin.Context) {
 	auth := strings.SplitN(c.GetHeader("Authorization"), " ", 2)
+
 	if len(auth) != 2 || auth[0] != "Bearer" {
 		c.Header("WWW-Authenticate", "Bearer")
 		c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{
@@ -38,239 +70,441 @@ func postTransfers(c *gin.Context) {

 	token := tokens.TransferPayload{}
 	if err := tokens.ParseToken([]byte(auth[1]), &token); err != nil {
-		middleware.CaptureAndAbort(c, err)
+		NewTrackedError(err).Abort(c)
+		return
+	}
+
+	s := ExtractServer(c)
+	if token.Subject != s.ID() {
+		c.AbortWithStatusJSON(http.StatusForbidden, gin.H{
+			"error": "Missing required token subject, or subject is not valid for the requested server.",
+		})
+		return
+	}
+
+	archivePath := getArchivePath(s.ID())
+
+	// Stat the archive file.
+	st, err := os.Lstat(archivePath)
+	if err != nil {
+		if !errors.Is(err, os.ErrNotExist) {
+			_ = WithError(c, err)
+			return
+		}
+		c.AbortWithStatus(http.StatusNotFound)
+		return
+	}
+
+	// Compute sha1 checksum.
+	h := sha256.New()
+	f, err := os.Open(archivePath)
+	if err != nil {
+		return
+	}
+	if _, err := io.Copy(h, bufio.NewReader(f)); err != nil {
+		_ = f.Close()
+		_ = WithError(c, err)
+		return
+	}
+	if err := f.Close(); err != nil {
+		_ = WithError(c, err)
+		return
+	}
+	checksum := hex.EncodeToString(h.Sum(nil))
+
+	// Stream the file to the client.
+	f, err = os.Open(archivePath)
+	if err != nil {
+		_ = WithError(c, err)
+		return
+	}
+	defer f.Close()
+
+	c.Header("X-Checksum", checksum)
+	c.Header("X-Mime-Type", "application/tar+gzip")
+	c.Header("Content-Length", strconv.Itoa(int(st.Size())))
+	c.Header("Content-Disposition", "attachment; filename="+strconv.Quote(s.ID()+".tar.gz"))
+	c.Header("Content-Type", "application/octet-stream")
+
+	_, _ = bufio.NewReader(f).WriteTo(c.Writer)
+}
+
+func postServerArchive(c *gin.Context) {
+	s := middleware.ExtractServer(c)
+	manager := middleware.ExtractManager(c)
+
+	go func(s *server.Server) {
+		l := log.WithField("server", s.ID())
+
+		// This function automatically adds the Source Node prefix and Timestamp to the log
+		// output before sending it over the websocket.
+		sendTransferLog := func(data string) {
+			output := colorstring.Color(fmt.Sprintf("[yellow][bold]%s [Pterodactyl Transfer System] [Source Node]:[default] %s", time.Now().Format(time.RFC1123), data))
+			s.Events().Publish(server.TransferLogsEvent, output)
+		}
+
+		s.Events().Publish(server.TransferStatusEvent, "starting")
+		sendTransferLog("Attempting to archive server...")
+
+		hasError := true
+		defer func() {
+			if !hasError {
+				return
+			}
+
+			// Mark the server as not being transferred so it can actually be used.
+			s.SetTransferring(false)
+			s.Events().Publish(server.TransferStatusEvent, "failure")
+
+			sendTransferLog("Attempting to notify panel of archive failure..")
+			if err := manager.Client().SetArchiveStatus(s.Context(), s.ID(), false); err != nil {
+				if !remote.IsRequestError(err) {
+					sendTransferLog("Failed to notify panel of archive failure: " + err.Error())
+					l.WithField("error", err).Error("failed to notify panel of failed archive status")
+					return
+				}
+
+				sendTransferLog("Panel returned an error while notifying it of a failed archive: " + err.Error())
+				l.WithField("error", err.Error()).Error("panel returned an error when notifying it of a failed archive status")
+				return
+			}
+
+			sendTransferLog("Successfully notified panel of failed archive status")
+			l.Info("successfully notified panel of failed archive status")
+		}()
+
+		// Mark the server as transferring to prevent problems.
+		s.SetTransferring(true)
+
+		// Ensure the server is offline. Sometimes a "No such container" error gets through
+		// which means the server is already stopped. We can ignore that.
+		if err := s.Environment.WaitForStop(60, false); err != nil && !strings.Contains(strings.ToLower(err.Error()), "no such container") {
+			sendTransferLog("Failed to stop server, aborting transfer..")
+			l.WithField("error", err).Error("failed to stop server")
+			return
+		}
+
+		// Create an archive of the entire server's data directory.
+		a := &filesystem.Archive{
+			BasePath: s.Filesystem().Path(),
+		}
+
+		// Attempt to get an archive of the server.
+		if err := a.Create(getArchivePath(s.ID())); err != nil {
+			sendTransferLog("An error occurred while archiving the server: " + err.Error())
+			l.WithField("error", err).Error("failed to get transfer archive for server")
+			return
+		}
+
+		sendTransferLog("Successfully created archive, attempting to notify panel..")
+		l.Info("successfully created server transfer archive, notifying panel..")
+
+		if err := manager.Client().SetArchiveStatus(s.Context(), s.ID(), true); err != nil {
+			if !remote.IsRequestError(err) {
+				sendTransferLog("Failed to notify panel of archive success: " + err.Error())
+				l.WithField("error", err).Error("failed to notify panel of successful archive status")
+				return
+			}
+
+			sendTransferLog("Panel returned an error while notifying it of a successful archive: " + err.Error())
+			l.WithField("error", err.Error()).Error("panel returned an error when notifying it of a successful archive status")
+			return
+		}
+
+		hasError = false
+
+		// This log may not be displayed by the client due to the status event being sent before or at the same time.
+		sendTransferLog("Successfully notified panel of successful archive status")
+
+		l.Info("successfully notified panel of successful transfer archive status")
+		s.Events().Publish(server.TransferStatusEvent, "archived")
+	}(s)
+
+	c.Status(http.StatusAccepted)
+}
+
+func (w *downloadProgress) Write(v []byte) (int, error) {
+	n := len(v)
+	atomic.AddInt64(&w.progress, int64(n))
+	return n, nil
+}
+
+// Log helper function to attach all errors and info output to a consistently formatted
+// log string for easier querying.
+func (str serverTransferRequest) log() *log.Entry {
+	return log.WithField("subsystem", "transfers").WithField("server_id", str.ServerID)
+}
+
+// Downloads an archive from the machine that the server currently lives on.
+func (str serverTransferRequest) downloadArchive() (*http.Response, error) {
+	client := http.Client{Timeout: 0}
+	req, err := http.NewRequest(http.MethodGet, str.URL, nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Authorization", str.Token)
+	res, err := client.Do(req) // lgtm [go/request-forgery]
+	if err != nil {
+		return nil, err
+	}
+	return res, nil
+}
+
+// Returns the path to the local archive on the system.
+func (str serverTransferRequest) path() string {
+	return getArchivePath(str.ServerID)
+}
+
+// Creates the archive location on this machine by first checking that the required file
+// does not already exist. If it does exist, the file is deleted and then re-created as
+// an empty file.
+func (str serverTransferRequest) createArchiveFile() (*os.File, error) {
+	p := str.path()
+	if _, err := os.Stat(p); err != nil {
+		if !os.IsNotExist(err) {
+			return nil, err
+		}
+	} else if err := os.Remove(p); err != nil {
+		return nil, err
+	}
+	return os.Create(p)
+}
+
+// Deletes the archive from the local filesystem. This is executed as a deferred function.
+func (str serverTransferRequest) removeArchivePath() {
+	p := str.path()
+	str.log().Debug("deleting temporary transfer archive")
+	if err := os.Remove(p); err != nil && !os.IsNotExist(err) {
+		str.log().WithField("path", p).WithField("error", err).Error("failed to delete temporary transfer archive file")
+		return
+	}
+	str.log().Debug("deleted temporary transfer archive successfully")
+}
+
+// Verifies that the SHA-256 checksum of the file on the local filesystem matches the
+// expected value from the transfer request. The string value returned is the computed
+// checksum on the system.
+func (str serverTransferRequest) verifyChecksum(matches string) (bool, string, error) {
+	f, err := os.Open(str.path())
+	if err != nil {
+		return false, "", err
+	}
+	defer f.Close()
+	h := sha256.New()
+	if _, err := io.Copy(h, bufio.NewReader(f)); err != nil {
+		return false, "", err
+	}
+	checksum := hex.EncodeToString(h.Sum(nil))
+	return checksum == matches, checksum, nil
+}
+
+// Sends a notification to the Panel letting it know what the status of this transfer is.
+func (str serverTransferRequest) sendTransferStatus(client remote.Client, successful bool) error {
+	lg := str.log().WithField("transfer_successful", successful)
+	lg.Info("notifying Panel of server transfer state")
+	if err := client.SetTransferStatus(context.Background(), str.ServerID, successful); err != nil {
+		lg.WithField("error", err).Error("error notifying panel of transfer state")
+		return err
+	}
+	lg.Debug("notified panel of transfer state")
+	return nil
+}
+
+// Initiates a transfer between two nodes for a server by downloading an archive from the
+// remote node and then applying the server details to this machine.
+func postTransfer(c *gin.Context) {
+	var data serverTransferRequest
+	if err := c.BindJSON(&data); err != nil {
 		return
 	}

 	manager := middleware.ExtractManager(c)
-	u, err := uuid.Parse(token.Subject)
+	u, err := uuid.Parse(data.ServerID)
 	if err != nil {
-		middleware.CaptureAndAbort(c, err)
+		WithError(c, err)
 		return
 	}
+	// Force the server ID to be a valid UUID string at this point. If it is not an error
+	// is returned to the caller. This limits injection vulnerabilities that would cause
+	// the str.path() function to return a location not within the server archive directory.
+	data.ServerID = u.String()

-	// Get or create a new transfer instance for this server.
-	var (
-		ctx    context.Context
-		cancel context.CancelFunc
-	)
-	trnsfr := transfer.Incoming().Get(u.String())
-	if trnsfr == nil {
-		// TODO: should this use the request context?
-		trnsfr = transfer.New(c, nil)
+	data.log().Info("handling incoming server transfer request")
+	go func(data *serverTransferRequest) {
+		hasError := true

-		ctx, cancel = context.WithCancel(trnsfr.Context())
-		defer cancel()
-
-		i, err := installer.New(ctx, manager, installer.ServerDetails{
-			UUID:              u.String(),
-			StartOnCompletion: false,
-		})
+		// Create a new server installer. This will only configure the environment and not
+		// run the installer scripts.
+		i, err := installer.New(context.Background(), manager, data.Server)
 		if err != nil {
-			if err := manager.Client().SetTransferStatus(context.Background(), trnsfr.Server.ID(), false); err != nil {
-				trnsfr.Log().WithField("status", false).WithError(err).Error("failed to set transfer status")
-			}
-			middleware.CaptureAndAbort(c, err)
+			_ = data.sendTransferStatus(manager.Client(), false)
+			data.log().WithField("error", err).Error("failed to validate received server data")
 			return
 		}

+		// This function automatically adds the Target Node prefix and Timestamp to the log output before sending it
+		// over the websocket.
+		sendTransferLog := func(data string) {
+			output := colorstring.Color(fmt.Sprintf("[yellow][bold]%s [Pterodactyl Transfer System] [Target Node]:[default] %s", time.Now().Format(time.RFC1123), data))
+			i.Server().Events().Publish(server.TransferLogsEvent, output)
+		}
+
+		// Mark the server as transferring to prevent problems later on during the process and
+		// then push the server into the global server collection for this instance.
 		i.Server().SetTransferring(true)
 		manager.Add(i.Server())
+		defer func(s *server.Server) {
+			// In the event that this transfer call fails, remove the server from the global
+			// server tracking so that we don't have a dangling instance.
+			if err := data.sendTransferStatus(manager.Client(), !hasError); hasError || err != nil {
+				sendTransferLog("Server transfer failed, check Wings logs for additional information.")
+				s.Events().Publish(server.TransferStatusEvent, "failure")
+				manager.Remove(func(match *server.Server) bool {
+					return match.ID() == s.ID()
+				})

-		// We add the transfer to the list of transfers once we have a server instance to use.
-		trnsfr.Server = i.Server()
-		transfer.Incoming().Add(trnsfr)
-	} else {
-		ctx, cancel = context.WithCancel(trnsfr.Context())
-		defer cancel()
-	}
-
-	// Any errors past this point (until the transfer is complete) will abort
-	// the transfer.
-
-	successful := false
-	defer func(ctx context.Context, trnsfr *transfer.Transfer) {
-		// Remove the transfer from the list of incoming transfers.
-		transfer.Incoming().Remove(trnsfr)
-
-		if !successful {
-			trnsfr.Server.Events().Publish(server.TransferStatusEvent, "failure")
-			manager.Remove(func(match *server.Server) bool {
-				return match.ID() == trnsfr.Server.ID()
-			})
-		}
-
-		if err := manager.Client().SetTransferStatus(context.Background(), trnsfr.Server.ID(), successful); err != nil {
-			// Only delete the files if the transfer actually failed, otherwise we could have
-			// unrecoverable data-loss.
-			if !successful && err != nil {
-				// Delete all extracted files.
-				go func(trnsfr *transfer.Transfer) {
-					_ = trnsfr.Server.Filesystem().Close()
-					if err := os.RemoveAll(trnsfr.Server.Filesystem().Path()); err != nil {
-						if !errors.Is(err, os.ErrNotExist) {
-							trnsfr.Log().WithError(err).Warn("failed to delete local server files")
-						}
+				// If the transfer status was successful but the request failed, act like the transfer failed.
+				if !hasError && err != nil {
+					// Delete all extracted files.
+					if err := os.RemoveAll(s.Filesystem().Path()); err != nil && !os.IsNotExist(err) {
+						data.log().WithField("error", err).Warn("failed to delete local server files directory")
 					}
-				}(trnsfr)
+				}
+			} else {
+				s.SetTransferring(false)
+				s.Events().Publish(server.TransferStatusEvent, "success")
+				sendTransferLog("Transfer completed.")
 			}
+		}(i.Server())

-			trnsfr.Log().WithField("status", successful).WithError(err).Error("failed to set transfer status on panel")
+		data.log().Info("downloading server archive from current server node")
+		sendTransferLog("Received incoming transfer from Panel, attempting to download archive from source node...")
+		res, err := data.downloadArchive()
+		if err != nil {
+			sendTransferLog("Failed to retrieve server archive from remote node: " + err.Error())
+			data.log().WithField("error", err).Error("failed to download archive for server transfer")
+			return
+		}
+		defer res.Body.Close()
+		if res.StatusCode != http.StatusOK {
+			data.log().WithField("error", err).WithField("status", res.StatusCode).Error("unexpected error response from transfer endpoint")
 			return
 		}

-		trnsfr.Server.SetTransferring(false)
-		trnsfr.Server.Events().Publish(server.TransferStatusEvent, "success")
-	}(ctx, trnsfr)
-
-	mediaType, params, err := mime.ParseMediaType(c.GetHeader("Content-Type"))
-	if err != nil {
-		trnsfr.Log().Debug("failed to parse content type header")
-		middleware.CaptureAndAbort(c, err)
-		return
-	}
-
-	if !strings.HasPrefix(mediaType, "multipart/") {
-		trnsfr.Log().Debug("invalid content type")
-		middleware.CaptureAndAbort(c, fmt.Errorf("invalid content type \"%s\", expected \"multipart/form-data\"", mediaType))
-		return
-	}
-
-	// Used to calculate the hash of the file as it is being uploaded.
-	h := sha256.New()
-
-	// Used to read the file and checksum from the request body.
-	mr := multipart.NewReader(c.Request.Body, params["boundary"])
-
-	// Loop through the parts of the request body and process them.
-	var (
-		hasArchive       bool
-		hasChecksum      bool
-		checksumVerified bool
-	)
-out:
-	for {
-		select {
-		case <-ctx.Done():
-			break out
-		default:
-			p, err := mr.NextPart()
-			if err == io.EOF {
-				break out
-			}
-			if err != nil {
-				middleware.CaptureAndAbort(c, err)
-				return
-			}
-
-			name := p.FormName()
-			switch name {
-			case "archive":
-				trnsfr.Log().Debug("received archive")
-
-				if _, err := trnsfr.Server.EnsureDataDirectoryExists(); err != nil {
-					middleware.CaptureAndAbort(c, err)
-					return
-				}
-
-				tee := io.TeeReader(p, h)
-				if err := trnsfr.Server.Filesystem().ExtractStreamUnsafe(ctx, "/", tee); err != nil {
-					middleware.CaptureAndAbort(c, err)
-					return
-				}
-
-				hasArchive = true
-			case "checksum":
-				trnsfr.Log().Debug("received checksum")
-
-				if !hasArchive {
-					middleware.CaptureAndAbort(c, errors.New("archive must be sent before the checksum"))
-					return
-				}
-
-				hasChecksum = true
-
-				v, err := io.ReadAll(p)
-				if err != nil {
-					middleware.CaptureAndAbort(c, err)
-					return
-				}
-
-				expected := make([]byte, hex.DecodedLen(len(v)))
-				n, err := hex.Decode(expected, v)
-				if err != nil {
-					middleware.CaptureAndAbort(c, err)
-					return
-				}
-				actual := h.Sum(nil)
-
-				trnsfr.Log().WithFields(log.Fields{
-					"expected": hex.EncodeToString(expected),
-					"actual":   hex.EncodeToString(actual),
-				}).Debug("checksums")
-
-				if !bytes.Equal(expected[:n], actual) {
-					middleware.CaptureAndAbort(c, errors.New("checksums don't match"))
-					return
-				}
-
-				trnsfr.Log().Debug("checksums match")
-				checksumVerified = true
-			default:
-				continue
-			}
+		size := res.ContentLength
+		if size == 0 {
+			data.log().WithField("error", err).Error("received an archive response with Content-Length of 0")
+			return
+		}
+		sendTransferLog("Got server archive response from remote node. (Content-Length: " + strconv.Itoa(int(size)) + ")")
+		sendTransferLog("Creating local archive file...")
+		file, err := data.createArchiveFile()
+		if err != nil {
+			data.log().WithField("error", err).Error("failed to create archive file on local filesystem")
+			return
 		}
-	}

-	if !hasArchive || !hasChecksum {
-		middleware.CaptureAndAbort(c, errors.New("missing archive or checksum"))
-		return
-	}
+		sendTransferLog("Writing archive to disk...")
+		data.log().Info("writing transfer archive to disk...")

-	if !checksumVerified {
-		middleware.CaptureAndAbort(c, errors.New("checksums don't match"))
-		return
-	}
+		// Copy the file.
+		progress := &downloadProgress{size: size}
+		ticker := time.NewTicker(3 * time.Second)
+		go func(progress *downloadProgress, t *time.Ticker) {
+			for range ticker.C {
+				// p = 100 (Downloaded)
+				// size = 1000 (Content-Length)
+				// p / size = 0.1
+				// * 100 = 10% (Multiply by 100 to get a percentage of the download)
+				// 10% / tickPercentage = (10% / (100 / 25)) (Divide by tick percentage to get the number of ticks)
+				// 2.5 (Number of ticks as a float64)
+				// 2 (convert to an integer)
+				p := atomic.LoadInt64(&progress.progress)
+				// We have to cast these numbers to float in order to get a float result from the division.
+				width := ((float64(p) / float64(size)) * 100) / tickPercentage
+				bar := strings.Repeat("=", int(width)) + strings.Repeat(" ", ticks-int(width))
+				sendTransferLog("Downloading [" + bar + "] " + system.FormatBytes(p) + " / " + system.FormatBytes(progress.size))
+			}
+		}(progress, ticker)

-	// Transfer is almost complete, we just want to ensure the environment is
-	// configured correctly.  We might want to not fail the transfer at this
-	// stage, but we will just to be safe.
+		var reader io.Reader
+		downloadLimit := float64(config.Get().System.Transfers.DownloadLimit) * 1024 * 1024
+		if downloadLimit > 0 {
+			// Wrap the body with a reader that is limited to the defined download limit speed.
+			reader = ratelimit.Reader(res.Body, ratelimit.NewBucketWithRate(downloadLimit, int64(downloadLimit)))
+		} else {
+			reader = res.Body
+		}

-	// Ensure the server environment gets configured.
-	if err := trnsfr.Server.CreateEnvironment(); err != nil {
-		middleware.CaptureAndAbort(c, err)
-		return
-	}
+		buf := make([]byte, 1024*4)
+		if _, err := io.CopyBuffer(file, io.TeeReader(reader, progress), buf); err != nil {
+			ticker.Stop()
+			_ = file.Close()

-	// Changing this causes us to notify the panel about a successful transfer,
-	// rather than failing the transfer like we do by default.
-	successful = true
+			sendTransferLog("Failed while writing archive file to disk: " + err.Error())
+			data.log().WithField("error", err).Error("failed to copy archive file to disk")
+			return
+		}
+		ticker.Stop()

-	// The rest of the logic for ensuring the server is unlocked and everything
-	// is handled in the deferred function above.
-	trnsfr.Log().Debug("done!")
-}
+		// Show 100% completion.
+		humanSize := system.FormatBytes(progress.size)
+		sendTransferLog("Downloading [" + strings.Repeat("=", ticks) + "] " + humanSize + " / " + humanSize)

-// deleteTransfer cancels an incoming transfer for a server.
-func deleteTransfer(c *gin.Context) {
-	s := ExtractServer(c)
+		if err := file.Close(); err != nil {
+			data.log().WithField("error", err).Error("unable to close archive file on local filesystem")
+			return
+		}
+		data.log().Info("finished writing transfer archive to disk")
+		sendTransferLog("Successfully wrote archive to disk.")

-	if !s.IsTransferring() {
-		c.AbortWithStatusJSON(http.StatusConflict, gin.H{
-			"error": "Server is not currently being transferred.",
-		})
-		return
-	}
+		// Whenever the transfer fails or succeeds, delete the temporary transfer archive that
+		// was created on the disk.
+		defer data.removeArchivePath()

-	trnsfr := transfer.Incoming().Get(s.ID())
-	if trnsfr == nil {
-		c.AbortWithStatusJSON(http.StatusConflict, gin.H{
-			"error": "Server is not currently being transferred.",
-		})
-		return
-	}
+		sendTransferLog("Verifying checksum of downloaded archive...")
+		data.log().Info("computing checksum of downloaded archive file")
+		expected := res.Header.Get("X-Checksum")
+		if matches, computed, err := data.verifyChecksum(expected); err != nil {
+			data.log().WithField("error", err).Error("encountered an error while calculating local filesystem archive checksum")
+			return
+		} else if !matches {
+			sendTransferLog("@@@@@ CHECKSUM VERIFICATION FAILED @@@@@")
+			sendTransferLog("  -   Source Checksum: " + expected)
+			sendTransferLog("  - Computed Checksum: " + computed)
+			data.log().WithField("expected_sum", expected).WithField("computed_checksum", computed).Error("checksum mismatch when verifying integrity of local archive")
+			return
+		}

-	trnsfr.Cancel()
+		// Create the server's environment.
+		sendTransferLog("Creating server environment, this could take a while..")
+		data.log().Info("creating server environment")
+		if err := i.Server().CreateEnvironment(); err != nil {
+			data.log().WithField("error", err).Error("failed to create server environment")
+			return
+		}
+
+		sendTransferLog("Server environment has been created, extracting transfer archive..")
+		data.log().Info("server environment configured, extracting transfer archive")
+		if err := archiver.NewTarGz().Unarchive(data.path(), i.Server().Filesystem().Path()); err != nil {
+			// Un-archiving failed, delete the server's data directory.
+			if err := os.RemoveAll(i.Server().Filesystem().Path()); err != nil && !os.IsNotExist(err) {
+				data.log().WithField("error", err).Warn("failed to delete local server files directory")
+			}
+			data.log().WithField("error", err).Error("failed to extract server archive")
+			return
+		}
+
+		// We mark the process as being successful here as if we fail to send a transfer success,
+		// then a transfer failure won't probably be successful either.
+		//
+		// It may be useful to retry sending the transfer success every so often just in case of a small
+		// hiccup or the fix of whatever error causing the success request to fail.
+		hasError = false
+
+		data.log().Info("archive extracted successfully, notifying Panel of status")
+		sendTransferLog("Archive extracted successfully.")
+	}(&data)

 	c.Status(http.StatusAccepted)
 }
--- a/router/tokens/upload.go
+++ b/router/tokens/upload.go
@@ -8,7 +8,6 @@ type UploadPayload struct {
 	jwt.Payload

 	ServerUuid string `json:"server_uuid"`
-	UserUuid   string `json:"user_uuid"`
 	UniqueId   string `json:"unique_id"`
 }

--- a/router/tokens/websocket.go
+++ b/router/tokens/websocket.go
@@ -7,6 +7,7 @@ import (

 	"github.com/apex/log"
 	"github.com/gbrlsnchs/jwt/v3"
+	"github.com/goccy/go-json"
 )

 // The time at which Wings was booted. No JWT's created before this time are allowed to
@@ -24,38 +25,25 @@ var wingsBootTime = time.Now()
 // This is used to allow the Panel to revoke tokens en-masse for a given user & server
 // combination since the JTI for tokens is just MD5(user.id + server.uuid). When a server
 // is booted this listing is fetched from the panel and the Websocket is dynamically updated.
-//
-// deprecated: prefer use of userDenylist
 var denylist sync.Map
-var userDenylist sync.Map

 // Adds a JTI to the denylist by marking any JWTs generated before the current time as
 // being invalid if they use the same JTI.
-//
-// deprecated: prefer the use of DenyForServer
 func DenyJTI(jti string) {
 	log.WithField("jti", jti).Debugf("adding \"%s\" to JTI denylist", jti)

 	denylist.Store(jti, time.Now())
 }

-// DenyForServer adds a user UUID to the denylist marking any existing JWTs issued
-// to the user as being invalid. This is associated with the user.
-func DenyForServer(s string, u string) {
-	log.WithField("user_uuid", u).WithField("server_uuid", s).Debugf("denying all JWTs created at or before current time for user \"%s\"", u)
-
-	userDenylist.Store(strings.Join([]string{s, u}, ":"), time.Now())
-}
-
-// WebsocketPayload defines the JWT payload for a websocket connection. This JWT is passed along to
-// the websocket after it has been connected to by sending an "auth" event.
+// A JWT payload for Websocket connections. This JWT is passed along to the Websocket after
+// it has been connected to by sending an "auth" event.
 type WebsocketPayload struct {
 	jwt.Payload
 	sync.RWMutex

-	UserUUID    string   `json:"user_uuid"`
-	ServerUUID  string   `json:"server_uuid"`
-	Permissions []string `json:"permissions"`
+	UserID      json.Number `json:"user_id"`
+	ServerUUID  string      `json:"server_uuid"`
+	Permissions []string    `json:"permissions"`
 }

 // Returns the JWT payload.
@@ -92,21 +80,12 @@ func (p *WebsocketPayload) Denylisted() bool {

 	// Finally, if the token was issued before a time that is currently denied for this
 	// token instance, ignore the permissions response.
-	//
-	// This list is deprecated, but we maintain the check here so that custom instances
-	// are able to continue working. We'll remove it in a future release.
 	if t, ok := denylist.Load(p.JWTID); ok {
 		if p.IssuedAt.Time.Before(t.(time.Time)) {
 			return true
 		}
 	}

-	if t, ok := userDenylist.Load(strings.Join([]string{p.ServerUUID, p.UserUUID}, ":")); ok {
-		if p.IssuedAt.Time.Before(t.(time.Time)) {
-			return true
-		}
-	}
-
 	return false
 }

--- a/router/websocket/limiter.go
+++ b/router/websocket/limiter.go
@@ -1,91 +0,0 @@
-package websocket
-
-import (
-	"sync"
-	"time"
-
-	"golang.org/x/time/rate"
-)
-
-type LimiterBucket struct {
-	mu        sync.RWMutex
-	limits    map[Event]*rate.Limiter
-	throttles map[Event]bool
-}
-
-func (h *Handler) IsThrottled(e Event) bool {
-	l := h.limiter.For(e)
-
-	h.limiter.mu.Lock()
-	defer h.limiter.mu.Unlock()
-
-	if l.Allow() {
-		h.limiter.throttles[e] = false
-
-		return false
-	}
-
-	// If not allowed, track the throttling and send an event over the wire
-	// if one wasn't already sent in the same throttling period.
-	if v, ok := h.limiter.throttles[e]; !v || !ok {
-		h.limiter.throttles[e] = true
-		h.Logger().WithField("event", e).Debug("throttling websocket due to event volume")
-
-		_ = h.unsafeSendJson(&Message{Event: ThrottledEvent, Args: []string{string(e)}})
-	}
-
-	return true
-}
-
-func NewLimiter() *LimiterBucket {
-	return &LimiterBucket{
-		limits:    make(map[Event]*rate.Limiter, 4),
-		throttles: make(map[Event]bool, 4),
-	}
-}
-
-// For returns the internal rate limiter for the given event type. In most
-// cases this is a shared rate limiter for events, but certain "heavy" or low-frequency
-// events implement their own limiters.
-func (l *LimiterBucket) For(e Event) *rate.Limiter {
-	name := limiterName(e)
-
-	l.mu.RLock()
-	if v, ok := l.limits[name]; ok {
-		l.mu.RUnlock()
-		return v
-	}
-
-	l.mu.RUnlock()
-	l.mu.Lock()
-	defer l.mu.Unlock()
-
-	limit, burst := limitValuesFor(e)
-	l.limits[name] = rate.NewLimiter(limit, burst)
-
-	return l.limits[name]
-}
-
-// limitValuesFor returns the underlying limit and burst value for the given event.
-func limitValuesFor(e Event) (rate.Limit, int) {
-	// Twice every five seconds.
-	if e == AuthenticationEvent || e == SendServerLogsEvent {
-		return rate.Every(time.Second * 5), 2
-	}
-
-	// 10 per second.
-	if e == SendCommandEvent {
-		return rate.Every(time.Second), 10
-	}
-
-	// 4 per second.
-	return rate.Every(time.Second), 4
-}
-
-func limiterName(e Event) Event {
-	if e == AuthenticationEvent || e == SendServerLogsEvent || e == SendCommandEvent {
-		return e
-	}
-
-	return "_default"
-}
--- a/router/websocket/listeners.go
+++ b/router/websocket/listeners.go
@@ -2,15 +2,13 @@ package websocket

 import (
 	"context"
-	"encoding/json"
 	"sync"
 	"time"

 	"emperror.dev/errors"
+	"github.com/goccy/go-json"

 	"github.com/pterodactyl/wings/events"
-	"github.com/pterodactyl/wings/system"
-
 	"github.com/pterodactyl/wings/server"
 )

@@ -90,13 +88,12 @@ func (h *Handler) listenForServerEvents(ctx context.Context) error {
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()

-	eventChan := make(chan []byte)
-	logOutput := make(chan []byte, 8)
-	installOutput := make(chan []byte, 4)
-
-	h.server.Events().On(eventChan) // TODO: make a sinky
-	h.server.Sink(system.LogSink).On(logOutput)
-	h.server.Sink(system.InstallSink).On(installOutput)
+	eventChan := make(chan events.Event)
+	logOutput := make(chan []byte)
+	installOutput := make(chan []byte)
+	h.server.Events().On(eventChan, e...)
+	h.server.Sink(server.LogSink).On(logOutput)
+	h.server.Sink(server.InstallSink).On(installOutput)

 	onError := func(evt string, err2 error) {
 		h.Logger().WithField("event", evt).WithField("error", err2).Error("failed to send event over server websocket")
@@ -113,25 +110,21 @@ func (h *Handler) listenForServerEvents(ctx context.Context) error {
 		select {
 		case <-ctx.Done():
 			break
-		case b := <-logOutput:
-			sendErr := h.SendJson(Message{Event: server.ConsoleOutputEvent, Args: []string{string(b)}})
+		case e := <-logOutput:
+			sendErr := h.SendJson(Message{Event: server.ConsoleOutputEvent, Args: []string{string(e)}})
 			if sendErr == nil {
 				continue
 			}
 			onError(server.ConsoleOutputEvent, sendErr)
-		case b := <-installOutput:
-			sendErr := h.SendJson(Message{Event: server.InstallOutputEvent, Args: []string{string(b)}})
+		case e := <-installOutput:
+			sendErr := h.SendJson(Message{Event: server.InstallOutputEvent, Args: []string{string(e)}})
 			if sendErr == nil {
 				continue
 			}
 			onError(server.InstallOutputEvent, sendErr)
-		case b := <-eventChan:
-			var e events.Event
-			if err := events.DecodeTo(b, &e); err != nil {
-				continue
-			}
+		case e := <-eventChan:
 			var sendErr error
-			message := Message{Event: Event(e.Topic)}
+			message := Message{Event: e.Topic}
 			if str, ok := e.Data.(string); ok {
 				message.Args = []string{str}
 			} else if b, ok := e.Data.([]byte); ok {
@@ -149,15 +142,15 @@ func (h *Handler) listenForServerEvents(ctx context.Context) error {
 					continue
 				}
 			}
-			onError(string(message.Event), sendErr)
+			onError(message.Event, sendErr)
 		}
 		break
 	}

 	// These functions will automatically close the channel if it hasn't been already.
-	h.server.Events().Off(eventChan)
-	h.server.Sink(system.LogSink).Off(logOutput)
-	h.server.Sink(system.InstallSink).Off(installOutput)
+	h.server.Events().Off(eventChan, e...)
+	h.server.Sink(server.LogSink).Off(logOutput)
+	h.server.Sink(server.InstallSink).Off(installOutput)

 	// If the internal context is stopped it is either because the parent context
 	// got canceled or because we ran into an error. If the "err" variable is nil
--- a/router/websocket/message.go
+++ b/router/websocket/message.go
@@ -1,24 +1,21 @@
 package websocket

-type Event string
-
 const (
-	AuthenticationSuccessEvent = Event("auth success")
-	TokenExpiringEvent         = Event("token expiring")
-	TokenExpiredEvent          = Event("token expired")
-	AuthenticationEvent        = Event("auth")
-	SetStateEvent              = Event("set state")
-	SendServerLogsEvent        = Event("send logs")
-	SendCommandEvent           = Event("send command")
-	SendStatsEvent             = Event("send stats")
-	ErrorEvent                 = Event("daemon error")
-	JwtErrorEvent              = Event("jwt error")
-	ThrottledEvent             = Event("throttled")
+	AuthenticationSuccessEvent = "auth success"
+	TokenExpiringEvent         = "token expiring"
+	TokenExpiredEvent          = "token expired"
+	AuthenticationEvent        = "auth"
+	SetStateEvent              = "set state"
+	SendServerLogsEvent        = "send logs"
+	SendCommandEvent           = "send command"
+	SendStatsEvent             = "send stats"
+	ErrorEvent                 = "daemon error"
+	JwtErrorEvent              = "jwt error"
 )

 type Message struct {
 	// The event to perform.
-	Event Event `json:"event"`
+	Event string `json:"event"`

 	// The data to pass along, only used by power/command currently. Other requests
 	// should either omit the field or pass an empty value as it is ignored.
--- a/router/websocket/websocket.go
+++ b/router/websocket/websocket.go
@@ -2,7 +2,6 @@ package websocket

 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"net/http"
 	"strings"
@@ -12,12 +11,9 @@ import (
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/gbrlsnchs/jwt/v3"
-	"github.com/gin-gonic/gin"
 	"github.com/google/uuid"
 	"github.com/gorilla/websocket"
-	"github.com/pterodactyl/wings/internal/models"
-
-	"github.com/pterodactyl/wings/system"
+	"github.com/goccy/go-json"

 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
@@ -43,9 +39,7 @@ type Handler struct {
 	Connection   *websocket.Conn `json:"-"`
 	jwt          *tokens.WebsocketPayload
 	server       *server.Server
-	ra           server.RequestActivity
 	uuid         uuid.UUID
-	limiter      *LimiterBucket
 }

 var (
@@ -82,9 +76,8 @@ func NewTokenPayload(token []byte) (*tokens.WebsocketPayload, error) {
 }

 // GetHandler returns a new websocket handler using the context provided.
-func GetHandler(s *server.Server, w http.ResponseWriter, r *http.Request, c *gin.Context) (*Handler, error) {
+func GetHandler(s *server.Server, w http.ResponseWriter, r *http.Request) (*Handler, error) {
 	upgrader := websocket.Upgrader{
-		EnableCompression: true,
 		// Ensure that the websocket request is originating from the Panel itself,
 		// and not some other location.
 		CheckOrigin: func(r *http.Request) bool {
@@ -111,16 +104,11 @@ func GetHandler(s *server.Server, w http.ResponseWriter, r *http.Request, c *gin
 		return nil, err
 	}

-	conn.SetReadLimit(4096)
-	_ = conn.SetCompressionLevel(5)
-
 	return &Handler{
 		Connection: conn,
 		jwt:        nil,
 		server:     s,
-		ra:         s.NewRequestActivity("", c.ClientIP()),
 		uuid:       u,
-		limiter:    NewLimiter(),
 	}, nil
 }

@@ -155,7 +143,7 @@ func (h *Handler) SendJson(v Message) error {

 		// If the user does not have permission to see backup events, do not emit
 		// them over the socket.
-		if strings.HasPrefix(string(v.Event), server.BackupCompletedEvent) {
+		if strings.HasPrefix(v.Event, server.BackupCompletedEvent) {
 			if !j.HasPermission(PermissionReceiveBackups) {
 				return nil
 			}
@@ -275,21 +263,12 @@ func (h *Handler) GetJwt() *tokens.WebsocketPayload {
 // setJwt sets the JWT for the websocket in a race-safe manner.
 func (h *Handler) setJwt(token *tokens.WebsocketPayload) {
 	h.Lock()
-	h.ra = h.ra.SetUser(token.UserUUID)
 	h.jwt = token
 	h.Unlock()
 }

 // HandleInbound handles an inbound socket request and route it to the proper action.
 func (h *Handler) HandleInbound(ctx context.Context, m Message) error {
-	if h.server.IsSuspended() {
-		return server.ErrSuspended
-	}
-
-	if h.IsThrottled(m.Event) {
-		return nil
-	}
-
 	if m.Event != AuthenticationEvent {
 		if err := h.TokenValid(); err != nil {
 			h.unsafeSendJson(Message{
@@ -374,7 +353,7 @@ func (h *Handler) HandleInbound(ctx context.Context, m Message) error {
 			}

 			err := h.server.HandlePowerAction(action)
-			if errors.Is(err, system.ErrLockerLocked) {
+			if errors.Is(err, context.DeadlineExceeded) {
 				m, _ := h.GetErrorMessage("another power action is currently being processed for this server, please try again later")

 				_ = h.SendJson(Message{
@@ -385,10 +364,6 @@ func (h *Handler) HandleInbound(ctx context.Context, m Message) error {
 				return nil
 			}

-			if err == nil {
-				h.server.SaveActivity(h.ra, models.Event(server.ActivityPowerPrefix+action), nil)
-			}
-
 			return err
 		}
 	case SendServerLogsEvent:
@@ -445,13 +420,7 @@ func (h *Handler) HandleInbound(ctx context.Context, m Message) error {
 				}
 			}

-			if err := h.server.Environment.SendCommand(strings.Join(m.Args, "")); err != nil {
-				return err
-			}
-			h.server.SaveActivity(h.ra, server.ActivityConsoleCommand, models.ActivityMeta{
-				"command": strings.Join(m.Args, ""),
-			})
-			return nil
+			return h.server.Environment.SendCommand(strings.Join(m.Args, ""))
 		}
 	}

--- a/rpm/ptero-wings.spec
+++ b/rpm/ptero-wings.spec
@@ -0,0 +1,121 @@
+Name:       ptero-wings
+Version:    1.5.3
+Release:    1%{?dist}
+Summary:    The server control plane for Pterodactyl Panel. Written from the ground-up with security, speed, and stability in mind.
+BuildArch:  x86_64
+License:    MIT
+URL:        https://github.com/pterodactyl/wings
+Source0:    https://github.com/pterodactyl/wings/releases/download/v%{version}/wings_linux_amd64
+
+%if 0%{?rhel} && 0%{?rhel} <= 8
+BuildRequires:  systemd
+%else
+BuildRequires:  systemd-rpm-macros
+%endif
+
+
+%description
+Wings is Pterodactyl's server control plane, built for the rapidly
+changing gaming industry and designed to be highly performant and
+secure. Wings provides an HTTP API allowing you to interface directly
+with running server instances, fetch server logs, generate backups,
+and control all aspects of the server lifecycle.
+
+In addition, Wings ships with a built-in SFTP server allowing your
+system to remain free of Pterodactyl specific dependencies, and
+allowing users to authenticate with the same credentials they would
+normally use to access the Panel.
+
+%prep
+
+%build
+#nothing required
+
+%install
+mkdir -p %{buildroot}%{_bindir}
+mkdir -p %{buildroot}%{_unitdir}
+cp %{_sourcedir}/wings_linux_amd64 %{buildroot}%{_bindir}/wings
+
+cat > %{buildroot}%{_unitdir}/wings.service << EOF
+[Unit]
+Description=Pterodactyl Wings Daemon
+After=docker.service
+Requires=docker.service
+PartOf=docker.service
+StartLimitIntervalSec=600
+
+[Service]
+WorkingDirectory=/etc/pterodactyl
+ExecStart=/usr/bin/wings
+ExecReload=/bin/kill -HUP $MAINPID
+Restart=on-failure
+StartLimitInterval=180
+StartLimitBurst=30
+RestartSec=5s
+
+[Install]
+WantedBy=multi-user.target
+EOF
+
+%files
+%attr(0755, root, root) %{_prefix}/bin/wings
+%attr(0644, root, root) %{_unitdir}/wings.service
+
+%post
+
+# Reload systemd
+systemctl daemon-reload
+
+# Create the required directory structure
+mkdir -p /etc/pterodactyl
+mkdir -p /var/lib/pterodactyl/{archives,backups,volumes}
+mkdir -p /var/log/pterodactyl/install
+
+%preun
+
+systemctl is-active %{name} >/dev/null 2>&1
+if [ $? -eq 0 ]; then
+    systemctl stop %{name}
+fi
+
+systemctl is-enabled %{name} >/dev/null 2>&1
+if [ $? -eq 0 ]; then
+    systemctl disable %{name}
+fi
+
+%postun
+rm -rf /var/log/pterodactyl
+
+%verifyscript
+
+wings --version
+
+%changelog
+* Wed Oct 27 2021 Capitol Hosting Solutions Systems Engineering <syseng@chs.gg> - 1.5.3-1
+- specfile by Capitol Hosting Solutions, Upstream by Pterodactyl
+- Rebased for https://github.com/pterodactyl/wings/releases/tag/v1.5.3
+- Fixes improper event registration and error handling during socket authentication that would cause the incorrect error message to be returned to the client, or no error in some scenarios. Event registration is now delayed until the socket is fully authenticated to ensure needless listeners are not registed.
+- Fixes dollar signs always being evaluated as environment variables with no way to escape them. They can now be escaped as $$ which will transform into a single dollar sign.
+- A websocket connection to a server will be closed by Wings if there is a send error encountered and the client will be left to handle reconnections, rather than simply logging the error and continuing to listen for new events.
+
+* Sun Sep 12 2021 Capitol Hosting Solutions Systems Engineering <syseng@chs.gg> - 1.5.0-1
+- specfile by Capitol Hosting Solutions, Upstream by Pterodactyl
+- Rebased for https://github.com/pterodactyl/wings/releases/tag/v1.5.0
+- Fixes a race condition when setting the application name in the console output for a server.
+- Fixes a server being reinstalled causing the file_denylist parameter for an Egg to be ignored until Wings is restarted.
+- Fixes YAML file parser not correctly setting boolean values.
+- Fixes potential issue where the underlying websocket connection is closed but the parent request context is not yet canceled causing a write over a closed connection.
+- Fixes race condition when closing all active websocket connections when a server is deleted.
+- Fixes logic to determine if a server's context is closed out and send a websocket close message to connected clients. Previously this fired off whenever the request itself was closed, and not when the server context was closed.
+- Exposes 8080 in the wings Dockerfile to better support reverse proxy tools.
+- Releases are now built using Go 1.17 — the minimum version required to build Wings remains Go 1.16.
+- Simplifed the logic powering server updates to only pull information from the Panel rather than trying to accept updated values. All parts of Wings needing the most up-to-date server details should call Server#Sync() to fetch the latest stored build information.
+- Installer#New() no longer requires passing all of the server data as a byte slice, rather a new Installer#ServerDetails struct is exposed which can be passed and accepts a UUID and if the server should be started after the installer finishes.
+- Removes complicated (and unused) logic during the server installation process that was a hold-over from legacy Wings architectures.
+- Removes the PATCH /api/servers/:server endpoint — if you were previously using this API call it should be replaced with POST /api/servers/:server/sync.
+
+* Wed Aug 25 2021 Capitol Hosting Solutions Systems Engineering <syseng@chs.gg> - 1.4.7-1
+- specfile by Capitol Hosting Solutions, Upstream by Pterodactyl
+- Rebased for https://github.com/pterodactyl/wings/releases/tag/v1.4.7
+- SFTP access is now properly denied if a server is suspended.
+- Correctly uses start_on_completion and crash_detection_enabled for servers.
--- a/server/activity.go
+++ b/server/activity.go
@@ -1,66 +0,0 @@
-package server
-
-import (
-	"context"
-	"time"
-
-	"emperror.dev/errors"
-
-	"github.com/pterodactyl/wings/internal/database"
-	"github.com/pterodactyl/wings/internal/models"
-)
-
-const ActivityPowerPrefix = "server:power."
-
-const (
-	ActivityConsoleCommand      = models.Event("server:console.command")
-	ActivitySftpWrite           = models.Event("server:sftp.write")
-	ActivitySftpCreate          = models.Event("server:sftp.create")
-	ActivitySftpCreateDirectory = models.Event("server:sftp.create-directory")
-	ActivitySftpRename          = models.Event("server:sftp.rename")
-	ActivitySftpDelete          = models.Event("server:sftp.delete")
-	ActivityFileUploaded        = models.Event("server:file.uploaded")
-)
-
-// RequestActivity is a wrapper around a LoggedEvent that is able to track additional request
-// specific metadata including the specific user and IP address associated with all subsequent
-// events. The internal logged event structure can be extracted by calling RequestEvent.Event().
-type RequestActivity struct {
-	server string
-	user   string
-	ip     string
-}
-
-// Event returns the underlying logged event from the RequestEvent instance and sets the
-// specific event and metadata on it.
-func (ra RequestActivity) Event(event models.Event, metadata models.ActivityMeta) *models.Activity {
-	a := models.Activity{Server: ra.server, IP: ra.ip, Event: event, Metadata: metadata}
-
-	return a.SetUser(ra.user)
-}
-
-// SetUser clones the RequestActivity struct and sets a new user value on the copy
-// before returning it.
-func (ra RequestActivity) SetUser(u string) RequestActivity {
-	c := ra
-	c.user = u
-	return c
-}
-
-func (s *Server) NewRequestActivity(user string, ip string) RequestActivity {
-	return RequestActivity{server: s.ID(), user: user, ip: ip}
-}
-
-// SaveActivity saves an activity entry to the database in a background routine. If an error is
-// encountered it is logged but not returned to the caller.
-func (s *Server) SaveActivity(a RequestActivity, event models.Event, metadata models.ActivityMeta) {
-	ctx, cancel := context.WithTimeout(s.Context(), time.Second*3)
-	go func() {
-		defer cancel()
-		if tx := database.Instance().WithContext(ctx).Create(a.Event(event, metadata)); tx.Error != nil {
-			s.Log().WithField("error", errors.WithStack(tx.Error)).
-				WithField("event", event).
-				Error("activity: failed to save event")
-		}
-	}()
-}
--- a/server/backup.go
+++ b/server/backup.go
@@ -24,6 +24,7 @@ func (s *Server) notifyPanelOfBackup(uuid string, ad *backup.ArchiveDetails, suc
 				"backup": uuid,
 				"error":  err,
 			}).Error("failed to notify panel of backup status due to wings error")
+
 			return err
 		}

@@ -126,7 +127,7 @@ func (s *Server) RestoreBackup(b backup.BackupInterface, reader io.ReadCloser) (
 	defer func() {
 		s.Config().SetSuspended(false)
 		if reader != nil {
-			_ = reader.Close()
+			reader.Close()
 		}
 	}()
 	// Send an API call to the Panel as soon as this function is done running so that
@@ -141,7 +142,7 @@ func (s *Server) RestoreBackup(b backup.BackupInterface, reader io.ReadCloser) (
 	// instance, otherwise you'll likely hit all types of write errors due to the
 	// server being suspended.
 	if s.Environment.State() != environment.ProcessOfflineState {
-		if err = s.Environment.WaitForStop(s.Context(), 2*time.Minute, false); err != nil {
+		if err = s.Environment.WaitForStop(120, false); err != nil {
 			if !client.IsErrNotFound(err) {
 				return errors.WrapIf(err, "server/backup: restore: failed to wait for container stop")
 			}
@@ -151,31 +152,15 @@ func (s *Server) RestoreBackup(b backup.BackupInterface, reader io.ReadCloser) (
 	// Attempt to restore the backup to the server by running through each entry
 	// in the file one at a time and writing them to the disk.
 	s.Log().Debug("starting file writing process for backup restoration")
-	err = b.Restore(s.Context(), reader, func(file string, info fs.FileInfo, r io.ReadCloser) error {
-		defer r.Close()
-		if file == "." {
-			return nil
-		}
-
+	err = b.Restore(s.Context(), reader, func(file string, r io.Reader, mode fs.FileMode, atime, mtime time.Time) error {
 		s.Events().Publish(DaemonMessageEvent, "(restoring): "+file)
-		if info.IsDir() {
-			if err := s.Filesystem().Mkdir(file, info.Mode().Perm()); err != nil {
-				if !errors.Is(err, os.ErrExist) {
-					return errors.WithStack(err)
-				}
-			}
-		} else {
-			if !info.Mode().IsRegular() {
-				return nil
-			}
-
-			if err := s.Filesystem().Write(file, r, info.Size(), info.Mode().Perm()); err != nil {
-				return errors.WithStack(err)
-			}
+		if err := s.Filesystem().Writefile(file, r); err != nil {
+			return err
 		}
-
-		atime := info.ModTime()
-		return s.Filesystem().Chtimes(file, atime, atime)
+		if err := s.Filesystem().Chmod(file, mode); err != nil {
+			return err
+		}
+		return s.Filesystem().Chtimes(file, atime, mtime)
 	})

 	return errors.WithStackIf(err)
--- a/server/backup/backup.go
+++ b/server/backup/backup.go
@@ -8,22 +8,16 @@ import (
 	"io/fs"
 	"os"
 	"path"
+	"time"

 	"emperror.dev/errors"
 	"github.com/apex/log"
-	"github.com/mholt/archives"
 	"golang.org/x/sync/errgroup"

 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/remote"
 )

-var format = archives.CompressedArchive{
-	Compression: archives.Gz{},
-	Archival:    archives.Tar{},
-	Extraction:  archives.Tar{},
-}
-
 type AdapterType string

 const (
@@ -33,12 +27,12 @@ const (

 // RestoreCallback is a generic restoration callback that exists for both local
 // and remote backups allowing the files to be restored.
-type RestoreCallback func(file string, info fs.FileInfo, r io.ReadCloser) error
+type RestoreCallback func(file string, r io.Reader, mode fs.FileMode, atime, mtime time.Time) error

 // noinspection GoNameStartsWithPackageName
 type BackupInterface interface {
 	// SetClient sets the API request client on the backup interface.
-	SetClient(remote.Client)
+	SetClient(c remote.Client)
 	// Identifier returns the UUID of this backup as tracked by the panel
 	// instance.
 	Identifier() string
@@ -47,7 +41,7 @@ type BackupInterface interface {
 	WithLogContext(map[string]interface{})
 	// Generate creates a backup in whatever the configured source for the
 	// specific implementation is.
-	Generate(context.Context, string, string) (*ArchiveDetails, error)
+	Generate(ctx context.Context, basePath string, ignore string) (*ArchiveDetails, error)
 	// Ignored returns the ignored files for this backup instance.
 	Ignored() string
 	// Checksum returns a SHA1 checksum for the generated backup.
@@ -59,13 +53,13 @@ type BackupInterface interface {
 	// to store it until it is moved to the final spot.
 	Path() string
 	// Details returns details about the archive.
-	Details(context.Context, []remote.BackupPart) (*ArchiveDetails, error)
+	Details(ctx context.Context) (*ArchiveDetails, error)
 	// Remove removes a backup file.
 	Remove() error
 	// Restore is called when a backup is ready to be restored to the disk from
 	// the given source. Not every backup implementation will support this nor
 	// will every implementation require a reader be provided.
-	Restore(context.Context, io.Reader, RestoreCallback) error
+	Restore(ctx context.Context, reader io.Reader, callback RestoreCallback) error
 }

 type Backup struct {
@@ -125,8 +119,8 @@ func (b *Backup) Checksum() ([]byte, error) {

 // Details returns both the checksum and size of the archive currently stored on
 // the disk to the caller.
-func (b *Backup) Details(ctx context.Context, parts []remote.BackupPart) (*ArchiveDetails, error) {
-	ad := ArchiveDetails{ChecksumType: "sha1", Parts: parts}
+func (b *Backup) Details(ctx context.Context) (*ArchiveDetails, error) {
+	ad := ArchiveDetails{ChecksumType: "sha1"}
 	g, ctx := errgroup.WithContext(ctx)

 	g.Go(func() error {
@@ -168,10 +162,9 @@ func (b *Backup) log() *log.Entry {
 }

 type ArchiveDetails struct {
-	Checksum     string              `json:"checksum"`
-	ChecksumType string              `json:"checksum_type"`
-	Size         int64               `json:"size"`
-	Parts        []remote.BackupPart `json:"parts"`
+	Checksum     string `json:"checksum"`
+	ChecksumType string `json:"checksum_type"`
+	Size         int64  `json:"size"`
 }

 // ToRequest returns a request object.
@@ -181,6 +174,5 @@ func (ad *ArchiveDetails) ToRequest(successful bool) remote.BackupRequest {
 		ChecksumType: ad.ChecksumType,
 		Size:         ad.Size,
 		Successful:   successful,
-		Parts:        ad.Parts,
 	}
 }
--- a/server/backup/backup_local.go
+++ b/server/backup/backup_local.go
@@ -4,13 +4,10 @@ import (
 	"context"
 	"io"
 	"os"
-	"strings"

 	"emperror.dev/errors"
-	"github.com/juju/ratelimit"
-	"github.com/mholt/archives"
+	"github.com/mholt/archiver/v3"

-	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/remote"
 	"github.com/pterodactyl/wings/server/filesystem"
 )
@@ -61,28 +58,18 @@ func (b *LocalBackup) WithLogContext(c map[string]interface{}) {
 // Generate generates a backup of the selected files and pushes it to the
 // defined location for this instance.
 func (b *LocalBackup) Generate(ctx context.Context, basePath, ignore string) (*ArchiveDetails, error) {
-	r, err := os.OpenRoot(basePath)
-	if err != nil {
-		return nil, errors.Wrap(err, "server/backup: failed to open root directory")
-	}
-	defer r.Close()
-	a, err := filesystem.NewArchive(r, "/", filesystem.WithIgnored(strings.Split(ignore, "\n")))
-	if err != nil {
-		return nil, errors.WrapIf(err, "server/backup: failed to create archive")
+	a := &filesystem.Archive{
+		BasePath: basePath,
+		Ignore:   ignore,
 	}

 	b.log().WithField("path", b.Path()).Info("creating backup for server")
-	f, err := os.OpenFile(b.Path(), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o644)
-	if err != nil {
-		return nil, errors.Wrap(err, "server/backup: failed to open file for writing")
-	}
-	defer f.Close()
-	if err := a.Create(ctx, f); err != nil {
+	if err := a.Create(b.Path()); err != nil {
 		return nil, err
 	}
 	b.log().Info("created backup successfully")

-	ad, err := b.Details(ctx, nil)
+	ad, err := b.Details(ctx)
 	if err != nil {
 		return nil, errors.WrapIf(err, "backup: failed to get archive details for local backup")
 	}
@@ -92,28 +79,16 @@ func (b *LocalBackup) Generate(ctx context.Context, basePath, ignore string) (*A
 // Restore will walk over the archive and call the callback function for each
 // file encountered.
 func (b *LocalBackup) Restore(ctx context.Context, _ io.Reader, callback RestoreCallback) error {
-	f, err := os.Open(b.Path())
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	var reader io.Reader = f
-	// Steal the logic we use for making backups which will be applied when restoring
-	// this specific backup. This allows us to prevent overloading the disk unintentionally.
-	if writeLimit := int64(config.Get().System.Backups.WriteLimit * 1024 * 1024); writeLimit > 0 {
-		reader = ratelimit.Reader(f, ratelimit.NewBucketWithRate(float64(writeLimit), writeLimit))
-	}
-	if err := format.Extract(ctx, reader, func(ctx context.Context, f archives.FileInfo) error {
-		r, err := f.Open()
-		if err != nil {
-			return err
+	return archiver.Walk(b.Path(), func(f archiver.File) error {
+		select {
+		case <-ctx.Done():
+			// Stop walking if the context is canceled.
+			return archiver.ErrStopWalk
+		default:
+			if f.IsDir() {
+				return nil
+			}
+			return callback(filesystem.ExtractNameFromArchive(f), f, f.Mode(), f.ModTime(), f.ModTime())
 		}
-		defer r.Close()
-
-		return callback(f.NameInArchive, f.FileInfo, r)
-	}); err != nil {
-		return err
-	}
-	return nil
+	})
 }
--- a/server/backup/backup_s3.go
+++ b/server/backup/backup_s3.go
@@ -1,23 +1,25 @@
 package backup

 import (
+	"archive/tar"
+	"compress/gzip"
 	"context"
 	"fmt"
 	"io"
 	"net/http"
 	"os"
 	"strconv"
-	"strings"
 	"time"

 	"emperror.dev/errors"
 	"github.com/cenkalti/backoff/v4"
+
+	"github.com/pterodactyl/wings/server/filesystem"
+
 	"github.com/juju/ratelimit"
-	"github.com/mholt/archives"

 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/remote"
-	"github.com/pterodactyl/wings/server/filesystem"
 )

 type S3Backup struct {
@@ -52,37 +54,27 @@ func (s *S3Backup) WithLogContext(c map[string]interface{}) {
 func (s *S3Backup) Generate(ctx context.Context, basePath, ignore string) (*ArchiveDetails, error) {
 	defer s.Remove()

-	r, err := os.OpenRoot(basePath)
-	if err != nil {
-		return nil, errors.Wrap(err, "backup: failed to open root directory")
-	}
-	defer r.Close()
-	a, err := filesystem.NewArchive(r, "/", filesystem.WithIgnored(strings.Split(ignore, "\n")))
-	if err != nil {
-		return nil, errors.WrapIf(err, "backup: failed to create archive")
+	a := &filesystem.Archive{
+		BasePath: basePath,
+		Ignore:   ignore,
 	}

 	s.log().WithField("path", s.Path()).Info("creating backup for server")
-	f, err := os.OpenFile(s.Path(), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o644)
-	if err != nil {
-		return nil, errors.Wrap(err, "backup: failed to open file for writing")
-	}
-	defer f.Close()
-	if err := a.Create(ctx, f); err != nil {
+	if err := a.Create(s.Path()); err != nil {
 		return nil, err
 	}
 	s.log().Info("created backup successfully")

-	_ = f.Sync()
-	if _, err := f.Seek(0, io.SeekStart); err != nil {
-		return nil, errors.Wrap(err, "backup: failed to seek on file")
-	}
-
-	parts, err := s.generateRemoteRequest(ctx, f)
+	rc, err := os.Open(s.Path())
 	if err != nil {
+		return nil, errors.Wrap(err, "backup: could not read archive from disk")
+	}
+	defer rc.Close()
+
+	if err := s.generateRemoteRequest(ctx, rc); err != nil {
 		return nil, err
 	}
-	ad, err := s.Details(ctx, parts)
+	ad, err := s.Details(ctx)
 	if err != nil {
 		return nil, errors.WrapIf(err, "backup: failed to get archive details after upload")
 	}
@@ -103,35 +95,50 @@ func (s *S3Backup) Restore(ctx context.Context, r io.Reader, callback RestoreCal
 	if writeLimit := int64(config.Get().System.Backups.WriteLimit * 1024 * 1024); writeLimit > 0 {
 		reader = ratelimit.Reader(r, ratelimit.NewBucketWithRate(float64(writeLimit), writeLimit))
 	}
-	if err := format.Extract(ctx, reader, func(ctx context.Context, f archives.FileInfo) error {
-		r, err := f.Open()
+	gr, err := gzip.NewReader(reader)
+	if err != nil {
+		return err
+	}
+	defer gr.Close()
+	tr := tar.NewReader(gr)
+	for {
+		select {
+		case <-ctx.Done():
+			return nil
+		default:
+			// Do nothing, fall through to the next block of code in this loop.
+		}
+		header, err := tr.Next()
 		if err != nil {
+			if err == io.EOF {
+				break
+			}
 			return err
 		}
-		defer r.Close()
-
-		return callback(f.NameInArchive, f.FileInfo, r)
-	}); err != nil {
-		return err
+		if header.Typeflag == tar.TypeReg {
+			if err := callback(header.Name, tr, header.FileInfo().Mode(), header.AccessTime, header.ModTime); err != nil {
+				return err
+			}
+		}
 	}
 	return nil
 }

 // Generates the remote S3 request and begins the upload.
-func (s *S3Backup) generateRemoteRequest(ctx context.Context, rc io.ReadCloser) ([]remote.BackupPart, error) {
+func (s *S3Backup) generateRemoteRequest(ctx context.Context, rc io.ReadCloser) error {
 	defer rc.Close()

 	s.log().Debug("attempting to get size of backup...")
 	size, err := s.Backup.Size()
 	if err != nil {
-		return nil, err
+		return err
 	}
 	s.log().WithField("size", size).Debug("got size of backup")

 	s.log().Debug("attempting to get S3 upload urls from Panel...")
 	urls, err := s.client.GetBackupRemoteUploadURLs(context.Background(), s.Backup.Uuid, size)
 	if err != nil {
-		return nil, err
+		return err
 	}
 	s.log().Debug("got S3 upload urls from the Panel")
 	s.log().WithField("parts", len(urls.Parts)).Info("attempting to upload backup to s3 endpoint...")
@@ -149,26 +156,22 @@ func (s *S3Backup) generateRemoteRequest(ctx context.Context, rc io.ReadCloser)
 		}

 		// Attempt to upload the part.
-		etag, err := uploader.uploadPart(ctx, part, partSize)
-		if err != nil {
+		if _, err := uploader.uploadPart(ctx, part, partSize); err != nil {
 			s.log().WithField("part_id", i+1).WithError(err).Warn("failed to upload part")
-			return nil, err
+			return err
 		}
-		uploader.uploadedParts = append(uploader.uploadedParts, remote.BackupPart{
-			ETag:       etag,
-			PartNumber: i + 1,
-		})
+
 		s.log().WithField("part_id", i+1).Info("successfully uploaded backup part")
 	}
+
 	s.log().WithField("parts", len(urls.Parts)).Info("backup has been successfully uploaded")

-	return uploader.uploadedParts, nil
+	return nil
 }

 type s3FileUploader struct {
 	io.ReadCloser
-	client        *http.Client
-	uploadedParts []remote.BackupPart
+	client *http.Client
 }

 // newS3FileUploader returns a new file uploader instance.
@@ -241,6 +244,7 @@ func (fu *s3FileUploader) uploadPart(ctx context.Context, part string, size int6

 		return nil
 	}, fu.backoff(ctx))
+
 	if err != nil {
 		if v, ok := err.(*backoff.PermanentError); ok {
 			return "", v.Unwrap()
--- a/server/config_parser.go
+++ b/server/config_parser.go
@@ -1,34 +1,31 @@
 package server

 import (
-	"os"
 	"runtime"

 	"github.com/gammazero/workerpool"
 )

-// UpdateConfigurationFiles updates all of the defined configuration files for
-// a server automatically to ensure that they always use the specified values.
+// Parent function that will update all of the defined configuration files for a server
+// automatically to ensure that they always use the specified values.
 func (s *Server) UpdateConfigurationFiles() {
 	pool := workerpool.New(runtime.NumCPU())
-	files := s.ProcessConfiguration().ConfigurationFiles

+	files := s.ProcessConfiguration().ConfigurationFiles
 	for _, cf := range files {
 		f := cf

 		pool.Submit(func() {
-			fd, err := s.Filesystem().Touch(f.FileName, os.O_RDWR|os.O_CREATE, 0o644)
+			p, err := s.Filesystem().SafePath(f.FileName)
 			if err != nil {
-				s.Log().WithField("file_name", f.FileName).WithField("error", err).Error("failed to open configuration file")
+				s.Log().WithField("error", err).Error("failed to generate safe path for configuration file")
+
 				return
 			}
-			defer fd.Close()

-			if err := f.Parse(fd); err != nil {
-				s.Log().WithField("error", err).WithField("file_name", f.FileName).Error("failed to parse and update server configuration file")
+			if err := f.Parse(p, false); err != nil {
+				s.Log().WithField("error", err).Error("failed to parse and update server configuration file")
 			}
-
-			s.Log().WithField("file_name", f.FileName).Debug("finished processing server configuration file")
 		})
 	}

--- a/server/configuration.go
+++ b/server/configuration.go
@@ -16,11 +16,6 @@ type EggConfiguration struct {
 	FileDenylist []string `json:"file_denylist"`
 }

-type ConfigurationMeta struct {
-	Name        string `json:"name"`
-	Description string `json:"description"`
-}
-
 type Configuration struct {
 	mu sync.RWMutex

@@ -29,8 +24,6 @@ type Configuration struct {
 	// docker containers as well as in log output.
 	Uuid string `json:"uuid"`

-	Meta ConfigurationMeta `json:"meta"`
-
 	// Whether or not the server is in a suspended state. Suspended servers cannot
 	// be started or modified except in certain scenarios by an admin user.
 	Suspended bool `json:"suspended"`
@@ -46,9 +39,6 @@ type Configuration struct {
 	// server process.
 	EnvVars environment.Variables `json:"environment"`

-	// Labels is a map of container labels that should be applied to the running server process.
-	Labels map[string]string `json:"labels"`
-
 	Allocations           environment.Allocations `json:"allocations"`
 	Build                 environment.Limits      `json:"build"`
 	CrashDetectionEnabled bool                    `json:"crash_detection_enabled"`
--- a/server/connections.go
+++ b/server/connections.go
@@ -1,19 +0,0 @@
-package server
-
-import (
-	"github.com/pterodactyl/wings/system"
-)
-
-// Sftp returns the SFTP connection bag for the server instance. This bag tracks
-// all open SFTP connections by individual user and allows for a single user or
-// all users to be disconnected by other processes.
-func (s *Server) Sftp() *system.ContextBag {
-	s.Lock()
-	defer s.Unlock()
-
-	if s.sftpBag == nil {
-		s.sftpBag = system.NewContextBag(s.Context())
-	}
-
-	return s.sftpBag
-}
--- a/server/console.go
+++ b/server/console.go
@@ -1,10 +1,13 @@
 package server

 import (
+	"context"
 	"fmt"
 	"sync"
+	"sync/atomic"
 	"time"

+	"emperror.dev/errors"
 	"github.com/mitchellh/colorstring"

 	"github.com/pterodactyl/wings/config"
@@ -15,8 +18,118 @@ import (
 // the configuration every time we need to send output along to the websocket for
 // a server.
 var appName string
+
 var appNameSync sync.Once

+var ErrTooMuchConsoleData = errors.New("console is outputting too much data")
+
+type ConsoleThrottler struct {
+	mu sync.Mutex
+	config.ConsoleThrottles
+
+	// The total number of activations that have occurred thus far.
+	activations uint64
+
+	// The total number of lines that have been sent since the last reset timer period.
+	count uint64
+
+	// Wether or not the console output is being throttled. It is up to calling code to
+	// determine what to do if it is.
+	isThrottled *system.AtomicBool
+
+	// The total number of lines processed so far during the given time period.
+	timerCancel *context.CancelFunc
+}
+
+// Resets the state of the throttler.
+func (ct *ConsoleThrottler) Reset() {
+	atomic.StoreUint64(&ct.count, 0)
+	atomic.StoreUint64(&ct.activations, 0)
+	ct.isThrottled.Store(false)
+}
+
+// Triggers an activation for a server. You can also decrement the number of activations
+// by passing a negative number.
+func (ct *ConsoleThrottler) markActivation(increment bool) uint64 {
+	if !increment {
+		if atomic.LoadUint64(&ct.activations) == 0 {
+			return 0
+		}
+
+		// This weird dohicky subtracts 1 from the activation count.
+		return atomic.AddUint64(&ct.activations, ^uint64(0))
+	}
+
+	return atomic.AddUint64(&ct.activations, 1)
+}
+
+// Determines if the console is currently being throttled. Calls to this function can be used to
+// determine if output should be funneled along to the websocket processes.
+func (ct *ConsoleThrottler) Throttled() bool {
+	return ct.isThrottled.Load()
+}
+
+// Starts a timer that runs in a seperate thread and will continually decrement the lines processed
+// and number of activations, regardless of the current console message volume. All of the timers
+// are canceled if the context passed through is canceled.
+func (ct *ConsoleThrottler) StartTimer(ctx context.Context) {
+	system.Every(ctx, time.Duration(int64(ct.LineResetInterval))*time.Millisecond, func(_ time.Time) {
+		ct.isThrottled.Store(false)
+		atomic.StoreUint64(&ct.count, 0)
+	})
+
+	system.Every(ctx, time.Duration(int64(ct.DecayInterval))*time.Millisecond, func(_ time.Time) {
+		ct.markActivation(false)
+	})
+}
+
+// Handles output from a server's console. This code ensures that a server is not outputting
+// an excessive amount of data to the console that could indicate a malicious or run-away process
+// and lead to performance issues for other users.
+//
+// This was much more of a problem for the NodeJS version of the daemon which struggled to handle
+// large volumes of output. However, this code is much more performant so I generally feel a lot
+// better about it's abilities.
+//
+// However, extreme output is still somewhat of a DoS attack vector against this software since we
+// are still logging it to the disk temporarily and will want to avoid dumping a huge amount of
+// data all at once. These values are all configurable via the wings configuration file, however the
+// defaults have been in the wild for almost two years at the time of this writing, so I feel quite
+// confident in them.
+//
+// This function returns an error if the server should be stopped due to violating throttle constraints
+// and a boolean value indicating if a throttle is being violated when it is checked.
+func (ct *ConsoleThrottler) Increment(onTrigger func()) error {
+	if !ct.Enabled {
+		return nil
+	}
+
+	// Increment the line count and if we have now output more lines than are allowed, trigger a throttle
+	// activation. Once the throttle is triggered and has passed the kill at value we will trigger a server
+	// stop automatically.
+	if atomic.AddUint64(&ct.count, 1) >= ct.Lines && !ct.Throttled() {
+		ct.isThrottled.Store(true)
+		if ct.markActivation(true) >= ct.MaximumTriggerCount {
+			return ErrTooMuchConsoleData
+		}
+
+		onTrigger()
+	}
+
+	return nil
+}
+
+// Returns the throttler instance for the server or creates a new one.
+func (s *Server) Throttler() *ConsoleThrottler {
+	s.throttleOnce.Do(func() {
+		s.throttler = &ConsoleThrottler{
+			isThrottled:      system.NewAtomicBool(false),
+			ConsoleThrottles: config.Get().Throttles,
+		}
+	})
+	return s.throttler
+}
+
 // PublishConsoleOutputFromDaemon sends output to the server console formatted
 // to appear correctly as being sent from Wings.
 func (s *Server) PublishConsoleOutputFromDaemon(data string) {
@@ -28,55 +141,3 @@ func (s *Server) PublishConsoleOutputFromDaemon(data string) {
 		colorstring.Color(fmt.Sprintf("[yellow][bold][%s Daemon]:[default] %s", appName, data)),
 	)
 }
-
-// Throttler returns the throttler instance for the server or creates a new one.
-func (s *Server) Throttler() *ConsoleThrottle {
-	s.throttleOnce.Do(func() {
-		throttles := config.Get().Throttles
-		period := time.Duration(throttles.Period) * time.Millisecond
-
-		s.throttler = newConsoleThrottle(throttles.Lines, period)
-		s.throttler.strike = func() {
-			s.PublishConsoleOutputFromDaemon("Server is outputting console data too quickly -- throttling...")
-		}
-	})
-	return s.throttler
-}
-
-type ConsoleThrottle struct {
-	limit  *system.Rate
-	lock   *system.Locker
-	strike func()
-}
-
-func newConsoleThrottle(lines uint64, period time.Duration) *ConsoleThrottle {
-	return &ConsoleThrottle{
-		limit: system.NewRate(lines, period),
-		lock:  system.NewLocker(),
-	}
-}
-
-// Allow checks if the console is allowed to process more output data, or if too
-// much has already been sent over the line. If there is too much output the
-// strike callback function is triggered, but only if it has not already been
-// triggered at this point in the process.
-//
-// If output is allowed, the lock on the throttler is released and the next time
-// it is triggered the strike function will be re-executed.
-func (ct *ConsoleThrottle) Allow() bool {
-	if !ct.limit.Try() {
-		if err := ct.lock.Acquire(); err == nil {
-			if ct.strike != nil {
-				ct.strike()
-			}
-		}
-		return false
-	}
-	ct.lock.Release()
-	return true
-}
-
-// Reset resets the console throttler internal rate limiter and overage counter.
-func (ct *ConsoleThrottle) Reset() {
-	ct.limit.Reset()
-}
--- a/server/console_test.go
+++ b/server/console_test.go
@@ -1,62 +0,0 @@
-package server
-
-import (
-	"testing"
-	"time"
-
-	"github.com/franela/goblin"
-)
-
-func TestName(t *testing.T) {
-	g := goblin.Goblin(t)
-
-	g.Describe("ConsoleThrottler", func() {
-		g.It("keeps count of the number of overages in a time period", func() {
-			t := newConsoleThrottle(1, time.Second)
-			g.Assert(t.Allow()).IsTrue()
-			g.Assert(t.Allow()).IsFalse()
-			g.Assert(t.Allow()).IsFalse()
-		})
-
-		g.It("calls strike once per time period", func() {
-			t := newConsoleThrottle(1, time.Millisecond*20)
-
-			var times int
-			t.strike = func() {
-				times = times + 1
-			}
-
-			t.Allow()
-			t.Allow()
-			t.Allow()
-			time.Sleep(time.Millisecond * 100)
-			t.Allow()
-			t.Reset()
-			t.Allow()
-			t.Allow()
-			t.Allow()
-
-			g.Assert(times).Equal(2)
-		})
-
-		g.It("is properly reset", func() {
-			t := newConsoleThrottle(10, time.Second)
-
-			for i := 0; i < 10; i++ {
-				g.Assert(t.Allow()).IsTrue()
-			}
-			g.Assert(t.Allow()).IsFalse()
-			t.Reset()
-			g.Assert(t.Allow()).IsTrue()
-		})
-	})
-}
-
-func BenchmarkConsoleThrottle(b *testing.B) {
-	t := newConsoleThrottle(10, time.Millisecond*10)
-
-	b.ReportAllocs()
-	for i := 0; i < b.N; i++ {
-		t.Allow()
-	}
-}
--- a/server/crash.go
+++ b/server/crash.go
@@ -6,8 +6,6 @@ import (
 	"sync"
 	"time"

-	"emperror.dev/errors"
-
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
 )
@@ -59,7 +57,7 @@ func (s *Server) handleServerCrash() error {

 	exitCode, oomKilled, err := s.Environment.ExitState()
 	if err != nil {
-		return errors.Wrap(err, "failed to get exit state for server process")
+		return err
 	}

 	// If the system is not configured to detect a clean exit code as a crash, and the
@@ -87,5 +85,5 @@ func (s *Server) handleServerCrash() error {

 	s.crasher.SetLastCrash(time.Now())

-	return errors.Wrap(s.HandlePowerAction(PowerActionStart), "failed to start server after crash detection")
+	return s.HandlePowerAction(PowerActionStart)
 }
--- a/server/events.go
+++ b/server/events.go
@@ -2,10 +2,10 @@ package server

 import (
 	"github.com/pterodactyl/wings/events"
-	"github.com/pterodactyl/wings/system"
 )

-// Defines all the possible output events for a server.
+// Defines all of the possible output events for a server.
+// noinspection GoNameStartsWithPackageName
 const (
 	DaemonMessageEvent          = "daemon message"
 	InstallOutputEvent          = "install output"
@@ -18,10 +18,9 @@ const (
 	BackupCompletedEvent        = "backup completed"
 	TransferLogsEvent           = "transfer logs"
 	TransferStatusEvent         = "transfer status"
-	DeletedEvent                = "deleted"
 )

-// Events returns the server's emitter instance.
+// Returns the server's emitter instance.
 func (s *Server) Events() *events.Bus {
 	s.emitterLock.Lock()
 	defer s.emitterLock.Unlock()
@@ -32,24 +31,3 @@ func (s *Server) Events() *events.Bus {

 	return s.emitter
 }
-
-// Sink returns the instantiated and named sink for a server. If the sink has
-// not been configured yet this function will cause a panic condition.
-func (s *Server) Sink(name system.SinkName) *system.SinkPool {
-	sink, ok := s.sinks[name]
-	if !ok {
-		s.Log().Fatalf("attempt to access nil sink: %s", name)
-	}
-	return sink
-}
-
-// DestroyAllSinks iterates over all of the sinks configured for the server and
-// destroys their instances. Note that this will cause a panic if you attempt
-// to call Server.Sink() again after. This function is only used when a server
-// is being deleted from the system.
-func (s *Server) DestroyAllSinks() {
-	s.Log().Info("destroying all registered sinks for server instance")
-	for _, sink := range s.sinks {
-		sink.Destroy()
-	}
-}
--- a/server/filesystem/archive.go
+++ b/server/filesystem/archive.go
@@ -2,7 +2,6 @@ package filesystem

 import (
 	"archive/tar"
-	"context"
 	"io"
 	"io/fs"
 	"os"
@@ -11,18 +10,17 @@ import (
 	"sync"

 	"emperror.dev/errors"
+	"github.com/apex/log"
 	"github.com/juju/ratelimit"
+	"github.com/karrick/godirwalk"
 	"github.com/klauspost/pgzip"
 	ignore "github.com/sabhiram/go-gitignore"

 	"github.com/pterodactyl/wings/config"
-	"github.com/pterodactyl/wings/internal/progress"
 )

 const memory = 4 * 1024

-var ErrNoSpaceAvailable = errors.Sentinel("archive: no space available on disk")
-
 var pool = sync.Pool{
 	New: func() interface{} {
 		b := make([]byte, memory)
@@ -30,105 +28,31 @@ var pool = sync.Pool{
 	},
 }

-// TarProgress .
-type TarProgress struct {
-	*tar.Writer
-	p *progress.Progress
-}
-
-// NewTarProgress returns a new progress writer for the tar file. This is a wrapper
-// around the standard writer with a progress instance embedded.
-func NewTarProgress(w *tar.Writer, p *progress.Progress) *TarProgress {
-	if p != nil {
-		p.Writer = w
-	}
-	return &TarProgress{
-		Writer: w,
-		p:      p,
-	}
-}
-
-// Write .
-func (p *TarProgress) Write(v []byte) (int, error) {
-	if p.p == nil {
-		return p.Writer.Write(v)
-	}
-	return p.p.Write(v)
-}
-
-type ArchiveOption func(a *Archive) error
-
 type Archive struct {
-	root     *os.Root
-	dir      string
-	pw       *TarProgress
-	ignored  *ignore.GitIgnore
-	matching *ignore.GitIgnore
-	p        *progress.Progress
+	// BasePath is the absolute path to create the archive from where Files and Ignore are
+	// relative to.
+	BasePath string
+
+	// Ignore is a gitignore string (most likely read from a file) of files to ignore
+	// from the archive.
+	Ignore string
+
+	// Files specifies the files to archive, this takes priority over the Ignore option, if
+	// unspecified, all files in the BasePath will be archived unless Ignore is set.
+	Files []string
 }

-// NewArchive returns a new archive instance that can be used for generating an
-// archive of files and folders within the provided os.Root. The "dir" value is
-// a child directory within the `os.Root` instance.
-func NewArchive(r *os.Root, dir string, opts ...ArchiveOption) (*Archive, error) {
-	a := &Archive{root: r, dir: dir}
-	for _, opt := range opts {
-		if err := opt(a); err != nil {
-			return nil, errors.Wrap(err, "server/filesystem: archive: failed to apply callback option")
-		}
+// Create creates an archive at dst with all of the files defined in the
+// included files struct.
+func (a *Archive) Create(dst string) error {
+	f, err := os.OpenFile(dst, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o600)
+	if err != nil {
+		return err
 	}
-	return a, nil
-}
+	defer f.Close()

-func WithProgress(p *progress.Progress) ArchiveOption {
-	return func(a *Archive) error {
-		a.p = p
-		return nil
-	}
-}
-
-func WithIgnored(files []string) ArchiveOption {
-	return func(a *Archive) error {
-		if a.matching != nil {
-			return errors.NewPlain("cannot create an archive with both ignored and matching configurations")
-		}
-
-		a.ignored = ignore.CompileIgnoreLines(files...)
-
-		return nil
-	}
-}
-
-func WithMatching(files []string) ArchiveOption {
-	return func(a *Archive) error {
-		if a.ignored != nil {
-			return errors.NewPlain("cannot create an archive with both ignored and matching configurations")
-		}
-
-		lines := make([]string, len(files))
-		for _, f := range files {
-			// The old archiver logic just accepted an array of paths to include in the
-			// archive and did rudimentary logic to determine if they should be included.
-			// This newer logic makes use of the gitignore (flipped to make it an allowlist),
-			// but to do that we need to make sure all the provided values here start with a
-			// slash; otherwise files/folders nested deeply might be unintentionally included.
-			lines = append(lines, "/"+strings.TrimPrefix(f, "/"))
-		}
-
-		a.matching = ignore.CompileIgnoreLines(lines...)
-
-		return nil
-	}
-}
-
-func (a *Archive) Progress() *progress.Progress {
-	return a.p
-}
-
-// Create .
-func (a *Archive) Create(ctx context.Context, f *os.File) error {
 	// Select a writer based off of the WriteLimit configuration option. If there is no
-	// write limit use the file as the writer.
+	// write limit, use the file as the writer.
 	var writer io.Writer
 	if writeLimit := int64(config.Get().System.Backups.WriteLimit * 1024 * 1024); writeLimit > 0 {
 		// Token bucket with a capacity of "writeLimit" MiB, adding "writeLimit" MiB/s
@@ -138,25 +62,8 @@ func (a *Archive) Create(ctx context.Context, f *os.File) error {
 		writer = f
 	}

-	return a.Stream(ctx, writer)
-}
-
-// Stream walks the given root directory and generates an archive from the
-// provided files.
-func (a *Archive) Stream(ctx context.Context, w io.Writer) error {
-	// Choose which compression level to use based on the compression_level configuration option
-	var compressionLevel int
-	switch config.Get().System.Backups.CompressionLevel {
-	case "none":
-		compressionLevel = pgzip.NoCompression
-	case "best_compression":
-		compressionLevel = pgzip.BestCompression
-	default:
-		compressionLevel = pgzip.BestSpeed
-	}
-
 	// Create a new gzip writer around the file.
-	gw, _ := pgzip.NewWriterLevel(w, compressionLevel)
+	gw, _ := pgzip.NewWriterLevel(writer, pgzip.BestSpeed)
 	_ = gw.SetConcurrency(1<<20, 1)
 	defer gw.Close()

@@ -164,55 +71,91 @@ func (a *Archive) Stream(ctx context.Context, w io.Writer) error {
 	tw := tar.NewWriter(gw)
 	defer tw.Close()

-	a.pw = NewTarProgress(tw, a.p)
-	defer a.pw.Close()
-
-	r, err := a.root.OpenRoot(normalize(a.dir))
-	if err != nil {
-		return errors.Wrap(err, "server/filesystem: archive: failed to acquire root dir instance")
+	// Configure godirwalk.
+	options := &godirwalk.Options{
+		FollowSymbolicLinks: false,
+		Unsorted:            true,
+		Callback:            a.callback(tw),
 	}
-	defer r.Close()

-	base := strings.TrimRight(r.Name(), "./")
-	return filepath.WalkDir(base, a.walker(ctx, base))
+	// If we're specifically looking for only certain files, or have requested
+	// that certain files be ignored we'll update the callback function to reflect
+	// that request.
+	if len(a.Files) == 0 && len(a.Ignore) > 0 {
+		i := ignore.CompileIgnoreLines(strings.Split(a.Ignore, "\n")...)
+
+		options.Callback = a.callback(tw, func(_ string, rp string) error {
+			if i.MatchesPath(rp) {
+				return godirwalk.SkipThis
+			}
+
+			return nil
+		})
+	} else if len(a.Files) > 0 {
+		options.Callback = a.withFilesCallback(tw)
+	}
+
+	// Recursively walk the path we are archiving.
+	return godirwalk.Walk(a.BasePath, options)
 }

 // Callback function used to determine if a given file should be included in the archive
 // being generated.
-func (a *Archive) walker(ctx context.Context, base string) fs.WalkDirFunc {
-	return func(path string, de fs.DirEntry, err error) error {
-		if ctx.Err() != nil {
-			return ctx.Err()
-		}
-
-		if err != nil {
-			return fs.SkipDir
-		}
-
-		path = strings.TrimPrefix(path, base)
-		if a.ignored != nil && a.ignored.MatchesPath(path) {
+func (a *Archive) callback(tw *tar.Writer, opts ...func(path string, relative string) error) func(path string, de *godirwalk.Dirent) error {
+	return func(path string, de *godirwalk.Dirent) error {
+		// Skip directories because we walking them recursively.
+		if de.IsDir() {
 			return nil
 		}

-		if a.matching != nil && !a.matching.MatchesPath(path) {
-			return nil
+		relative := filepath.ToSlash(strings.TrimPrefix(path, a.BasePath+string(filepath.Separator)))
+
+		// Call the additional options passed to this callback function. If any of them return
+		// a non-nil error we will exit immediately.
+		for _, opt := range opts {
+			if err := opt(path, relative); err != nil {
+				return err
+			}
 		}

 		// Add the file to the archive, if it is nested in a directory,
 		// the directory will be automatically "created" in the archive.
-		return a.addToArchive(path)
+		return a.addToArchive(path, relative, tw)
 	}
 }

+// Pushes only files defined in the Files key to the final archive.
+func (a *Archive) withFilesCallback(tw *tar.Writer) func(path string, de *godirwalk.Dirent) error {
+	return a.callback(tw, func(p string, rp string) error {
+		for _, f := range a.Files {
+			// If the given doesn't match, or doesn't have the same prefix continue
+			// to the next item in the loop.
+			if p != f && !strings.HasPrefix(p, f) {
+				continue
+			}
+
+			// Once we have a match return a nil value here so that the loop stops and the
+			// call to this function will correctly include the file in the archive. If there
+			// are no matches we'll never make it to this line, and the final error returned
+			// will be the godirwalk.SkipThis error.
+			return nil
+		}
+
+		return godirwalk.SkipThis
+	})
+}
+
 // Adds a given file path to the final archive being created.
-func (a *Archive) addToArchive(p string) error {
-	p = normalize(p)
-	s, err := a.root.Lstat(p)
+func (a *Archive) addToArchive(p string, rp string, w *tar.Writer) error {
+	// Lstat the file, this will give us the same information as Stat except that it will not
+	// follow a symlink to it's target automatically. This is important to avoid including
+	// files that exist outside the server root unintentionally in the backup.
+	s, err := os.Lstat(p)
 	if err != nil {
 		if os.IsNotExist(err) {
 			return nil
 		}
-		return errors.Wrap(err, "server/filesystem: archive: failed to stat file")
+		return errors.WrapIff(err, "failed executing os.Lstat on '%s'", rp)
 	}

 	// Skip socket files as they are unsupported by archive/tar.
@@ -224,27 +167,34 @@ func (a *Archive) addToArchive(p string) error {
 	// Resolve the symlink target if the file is a symlink.
 	var target string
 	if s.Mode()&fs.ModeSymlink != 0 {
-		// This intentionally uses [os.Readlink] and not the [os.Root] instance. We need to
-		// know the actual target for the symlink, even if outside the server directory, so
-		// that we can restore it properly.
-		//
-		// This target is only used for the sake of keeping everything correct in the archive;
-		// we never read the target file contents.
-		target, err = os.Readlink(filepath.Join(a.root.Name(), p))
+		// Read the target of the symlink. If there are any errors we will dump them out to
+		// the logs, but we're not going to stop the backup. There are far too many cases of
+		// symlinks causing all sorts of unnecessary pain in this process. Sucks to suck if
+		// it doesn't work.
+		target, err = os.Readlink(s.Name())
 		if err != nil {
-			target = ""
+			// Ignore the not exist errors specifically, since theres nothing important about that.
+			if !os.IsNotExist(err) {
+				log.WithField("path", rp).WithField("readlink_err", err.Error()).Warn("failed reading symlink for target path; skipping...")
+			}
+			return nil
 		}
 	}

-	// Get the tar FileInfoHeader to add the file to the archive.
-	header, err := tar.FileInfoHeader(s, target)
+	// Get the tar FileInfoHeader in order to add the file to the archive.
+	header, err := tar.FileInfoHeader(s, filepath.ToSlash(target))
 	if err != nil {
-		return errors.Wrap(err, "server/filesystem: archive: failed to get file info header")
+		return errors.WrapIff(err, "failed to get tar#FileInfoHeader for '%s'", rp)
 	}

-	header.Name = p
-	if err := a.pw.WriteHeader(header); err != nil {
-		return errors.Wrap(err, "server/filesystem: archive: failed to write tar header")
+	// Fix the header name if the file is not a symlink.
+	if s.Mode()&fs.ModeSymlink == 0 {
+		header.Name = rp
+	}
+
+	// Write the tar FileInfoHeader to the archive.
+	if err := w.WriteHeader(header); err != nil {
+		return errors.WrapIff(err, "failed to write tar#FileInfoHeader for '%s'", rp)
 	}

 	// If the size of the file is less than 1 (most likely for symlinks), skip writing the file.
@@ -265,17 +215,19 @@ func (a *Archive) addToArchive(p string) error {
 		}()
 	}

-	f, err := a.root.Open(p)
+	// Open the file.
+	f, err := os.Open(p)
 	if err != nil {
 		if os.IsNotExist(err) {
 			return nil
 		}
-		return errors.Wrap(err, "server/filesystem: archive: failed to open file for copying")
+		return errors.WrapIff(err, "failed to open '%s' for copying", header.Name)
 	}
 	defer f.Close()

-	if _, err := io.CopyBuffer(a.pw, io.LimitReader(f, header.Size), buf); err != nil {
-		return errors.Wrap(err, "server/filesystem: archive: failed to copy file to archive")
+	// Copy the file's contents to the archive using our buffer.
+	if _, err := io.CopyBuffer(w, io.LimitReader(f, header.Size), buf); err != nil {
+		return errors.WrapIff(err, "failed to copy '%s' to archive", header.Name)
 	}

 	return nil
--- a/server/filesystem/archive_test.go
+++ b/server/filesystem/archive_test.go
@@ -1,161 +0,0 @@
-package filesystem
-
-import (
-	"context"
-	iofs "io/fs"
-	"os"
-	"path/filepath"
-	"sort"
-	"strings"
-	"testing"
-
-	. "github.com/franela/goblin"
-	"github.com/mholt/archives"
-)
-
-func TestArchive_Stream(t *testing.T) {
-	g := Goblin(t)
-	fs := NewFs()
-
-	g.Describe("Archive", func() {
-		g.AfterEach(func() {
-			fs.reset()
-		})
-
-		g.It("creates archive with intended files", func() {
-			g.Assert(fs.CreateDirectory("test", "/")).IsNil()
-			g.Assert(fs.CreateDirectory("test2", "/")).IsNil()
-
-			err := fs.Writefile("test/file.txt", strings.NewReader("hello, world!\n"))
-			g.Assert(err).IsNil()
-
-			err = fs.Writefile("test2/file.txt", strings.NewReader("hello, world!\n"))
-			g.Assert(err).IsNil()
-
-			err = fs.Writefile("test_file.txt", strings.NewReader("hello, world!\n"))
-			g.Assert(err).IsNil()
-
-			err = fs.Writefile("test_file.txt.old", strings.NewReader("hello, world!\n"))
-			g.Assert(err).IsNil()
-
-			archivePath := filepath.Join(fs.rootPath, "../archive.tar.gz")
-			f, err := os.Create(archivePath)
-			if err != nil {
-				panic(err)
-			}
-			defer f.Close()
-
-			a, err := NewArchive(fs.root, ".", WithMatching([]string{"test", "test_file.txt"}))
-
-			g.Assert(a.Create(context.Background(), f)).IsNil()
-
-			// Open the archive.
-			genericFs, err := archives.FileSystem(context.Background(), archivePath, nil)
-			g.Assert(err).IsNil()
-
-			// Assert that we are opening an archive.
-			afs, ok := genericFs.(iofs.ReadDirFS)
-			g.Assert(ok).IsTrue()
-
-			// Get the names of the files recursively from the archive.
-			files, err := getFiles(afs, ".")
-			g.Assert(err).IsNil()
-
-			// Ensure the files in the archive match what we are expecting.
-			expected := []string{
-				"test_file.txt",
-				"test/file.txt",
-			}
-
-			// Sort the slices to ensure the comparison never fails if the
-			// contents are sorted differently.
-			sort.Strings(expected)
-			sort.Strings(files)
-
-			g.Assert(files).Equal(expected)
-		})
-
-		g.It("does not archive files outside of root", func() {
-			if err := os.MkdirAll(filepath.Join(fs.rootPath, "../outer"), 0o755); err != nil {
-				panic(err)
-			}
-
-			fs.write("test.txt", []byte("test"))
-			fs.write("../danger-1.txt", []byte("danger"))
-			fs.write("../outer/danger-2.txt", []byte("danger"))
-
-			if err := os.Symlink("../danger-1.txt", filepath.Join(fs.rootPath, "symlink.txt")); err != nil {
-				panic(err)
-			}
-
-			if err := os.Symlink("../outer", filepath.Join(fs.rootPath, "danger-dir")); err != nil {
-				panic(err)
-			}
-
-			archivePath := filepath.Join(fs.rootPath, "../archive.tar.gz")
-			f, err := os.Create(archivePath)
-			if err != nil {
-				panic(err)
-			}
-			defer f.Close()
-
-			a, err := NewArchive(fs.root, ".")
-			if err != nil {
-				panic(err)
-			}
-
-			err = a.Create(context.Background(), f)
-			g.Assert(err).IsNil()
-
-			// Open the archive.
-			genericFs, err := archives.FileSystem(context.Background(), archivePath, nil)
-			g.Assert(err).IsNil()
-
-			// Assert that we are opening an archive.
-			afs, ok := genericFs.(iofs.ReadDirFS)
-			g.Assert(ok).IsTrue()
-
-			// Get the names of the files recursively from the archive.
-			files, err := getFiles(afs, ".")
-			g.Assert(err).IsNil()
-			// We expect the actual symlinks themselves, but not the contents of the directory
-			// or the file itself. We're storing the symlinked file in the archive so that
-			// expanding it back is the same, but you won't have the inner contents.
-			g.Assert(files).Equal([]string{"danger-dir", "symlink.txt", "test.txt"})
-		})
-	})
-}
-
-func getFiles(f iofs.ReadDirFS, name string) ([]string, error) {
-	var v []string
-
-	entries, err := f.ReadDir(name)
-	if err != nil {
-		return nil, err
-	}
-
-	for _, e := range entries {
-		entryName := e.Name()
-		if name != "." {
-			entryName = filepath.Join(name, entryName)
-		}
-
-		if e.IsDir() {
-			files, err := getFiles(f, entryName)
-			if err != nil {
-				return nil, err
-			}
-
-			if files == nil {
-				return nil, nil
-			}
-
-			v = append(v, files...)
-			continue
-		}
-
-		v = append(v, entryName)
-	}
-
-	return v, nil
-}
--- a/server/filesystem/chmod.go
+++ b/server/filesystem/chmod.go
@@ -1,82 +0,0 @@
-package filesystem
-
-import (
-	"fmt"
-	fs2 "io/fs"
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
-
-	"emperror.dev/errors"
-	"github.com/pterodactyl/wings/config"
-)
-
-func (fs *Filesystem) Chmod(path string, mode os.FileMode) error {
-	path = strings.TrimLeft(filepath.Clean(path), "/")
-	if path == "" {
-		path = "."
-	}
-	if err := fs.root.Chmod(path, mode); err != nil {
-		return errors.Wrap(err, "server/filesystem: chmod: failed to chmod path")
-	}
-
-	return nil
-}
-
-// Chown recursively iterates over a file or directory and sets the permissions on all the
-// underlying files. Iterate over all the files and directories. If it is a file go ahead
-// and perform the chown operation. Otherwise dig deeper into the directory until we've run
-// out of directories to dig into.
-func (fs *Filesystem) Chown(p string) error {
-	p = normalize(p)
-	uid := config.Get().System.User.Uid
-	gid := config.Get().System.User.Gid
-	if err := fs.root.Chown(p, uid, gid); err != nil {
-		return errors.WrapIf(err, "server/filesystem: chown: failed to chown path")
-	}
-
-	// If this is not a directory, we can now return from the function; there is nothing
-	// left that we need to do.
-	if st, err := fs.root.Stat(p); err != nil || !st.IsDir() {
-		if err == nil || errors.Is(err, os.ErrNotExist) {
-			return nil
-		}
-
-		return errors.WrapIf(err, "server/filesystem: chown: failed to stat path")
-	}
-
-	rt := fs.rootPath
-	if p == "." {
-		r, err := fs.root.OpenRoot(p)
-		if err != nil {
-			return errors.WithStack(err)
-		}
-		defer r.Close()
-		rt = r.Name()
-	}
-
-	// If this was a directory, begin walking over its contents recursively and ensure that all
-	// the subfiles and directories get their permissions updated as well.
-	return filepath.WalkDir(rt, func(path string, _ fs2.DirEntry, err error) error {
-		path = normalize(path)
-		if path == "." {
-			return nil
-		}
-
-		if err := fs.root.Chown(path, uid, gid); err != nil {
-			return errors.Wrap(err, fmt.Sprintf("server/filesystem: chown: failed to chown file"))
-		}
-
-		return nil
-	})
-}
-
-func (fs *Filesystem) Chtimes(path string, atime, mtime time.Time) error {
-	path = strings.TrimLeft(filepath.Clean(path), "/")
-	if err := fs.root.Chtimes(path, atime, mtime); err != nil {
-		return errors.Wrap(err, "server/filesystem: chtimes: failed to chtimes path")
-	}
-
-	return nil
-}
--- a/server/filesystem/compress.go
+++ b/server/filesystem/compress.go
@@ -1,200 +1,184 @@
 package filesystem

 import (
-	"context"
+	"archive/tar"
+	"archive/zip"
+	"compress/gzip"
 	"fmt"
-	"io"
 	"os"
+	"path"
 	"path/filepath"
 	"strings"
+	"sync/atomic"
 	"time"

 	"emperror.dev/errors"
-	"github.com/mholt/archives"
-	"github.com/pterodactyl/wings/internal"
+	"github.com/mholt/archiver/v3"
 )

-type extractOptions struct {
-	dir    string
-	file   string
-	format archives.Format
-	r      io.Reader
-}
-
-// CompressFiles compresses all the files matching the given paths in the
+// CompressFiles compresses all of the files matching the given paths in the
 // specified directory. This function also supports passing nested paths to only
 // compress certain files and folders when working in a larger directory. This
 // effectively creates a local backup, but rather than ignoring specific files
-// and folders, it takes an allowlist of files and folders.
+// and folders, it takes an allow-list of files and folders.
 //
 // All paths are relative to the dir that is passed in as the first argument,
 // and the compressed file will be placed at that location named
 // `archive-{date}.tar.gz`.
-func (fs *Filesystem) CompressFiles(ctx context.Context, dir string, paths []string) (os.FileInfo, error) {
-	a, err := NewArchive(fs.root, dir, WithMatching(paths))
+func (fs *Filesystem) CompressFiles(dir string, paths []string) (os.FileInfo, error) {
+	cleanedRootDir, err := fs.SafePath(dir)
 	if err != nil {
-		return nil, errors.WrapIf(err, "server/filesystem: compress: failed to create archive instance")
-	}
-
-	n := fmt.Sprintf("archive-%s.tar.gz", strings.ReplaceAll(time.Now().Format(time.RFC3339), ":", ""))
-	f, err := fs.root.OpenFile(normalize(filepath.Join(dir, n)), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o644)
-	if err != nil {
-		return nil, errors.Wrap(err, "server/filesystem: compress: failed to open file for writing")
-	}
-	defer f.Close()
-
-	cw := internal.NewCountedWriter(f)
-	// todo: eventing on the counted writer so that we can slowly increase the disk
-	//  used value on the server as the file gets written?
-	if err := a.Stream(ctx, cw); err != nil {
-		return nil, errors.Wrap(err, "server/filesystem: compress: failed to write to disk")
-	}
-	if err := fs.HasSpaceFor(cw.BytesWritten()); err != nil {
-		_ = fs.root.Remove(normalize(filepath.Join(dir, n)))
 		return nil, err
 	}
-	fs.addDisk(cw.BytesWritten())

-	return f.Stat()
-}
-
-// DecompressFile will decompress a file in a given directory by using the
-// archiver tool to infer the file type and go from there. This will walk over
-// all the files within the given archive and ensure that there is not a
-// zip-slip attack being attempted by validating that the final path is within
-// the server data directory.
-func (fs *Filesystem) DecompressFile(ctx context.Context, dir string, file string) error {
-	f, err := fs.root.Open(normalize(filepath.Join(dir, file)))
-	if err != nil {
-		return errors.Wrap(err, "server/filesystem: decompress: failed to open file")
-	}
-	defer f.Close()
-
-	format, input, err := archives.Identify(ctx, filepath.Base(file), f)
-	if err != nil {
-		if errors.Is(err, archives.NoMatch) {
-			return newFilesystemError(ErrCodeUnknownArchive, err)
-		}
-		return errors.Wrap(err, "server/filesystem: decompress: failed to identify archive format")
+	// Take all of the paths passed in and merge them together with the root directory we've gotten.
+	for i, p := range paths {
+		paths[i] = filepath.Join(cleanedRootDir, p)
 	}

-	return fs.extractStream(ctx, extractOptions{dir: dir, file: file, format: format, r: input})
+	cleaned, err := fs.ParallelSafePath(paths)
+	if err != nil {
+		return nil, err
+	}
+
+	a := &Archive{BasePath: cleanedRootDir, Files: cleaned}
+	d := path.Join(
+		cleanedRootDir,
+		fmt.Sprintf("archive-%s.tar.gz", strings.ReplaceAll(time.Now().Format(time.RFC3339), ":", "")),
+	)
+
+	if err := a.Create(d); err != nil {
+		return nil, err
+	}
+
+	f, err := os.Stat(d)
+	if err != nil {
+		_ = os.Remove(d)
+		return nil, err
+	}
+
+	if err := fs.HasSpaceFor(f.Size()); err != nil {
+		_ = os.Remove(d)
+		return nil, err
+	}
+
+	fs.addDisk(f.Size())
+
+	return f, nil
 }

-func (fs *Filesystem) extractStream(ctx context.Context, opts extractOptions) error {
-	// See if it's a compressed archive, such as TAR or a ZIP
-	ex, ok := opts.format.(archives.Extractor)
-	if !ok {
-		// If not, check if it's a single-file compression, such as
-		// .log.gz, .sql.gz, and so on
-		de, ok := opts.format.(archives.Decompressor)
-		if !ok {
-			return nil
-		}
-
-		p := filepath.Join(opts.dir, strings.TrimSuffix(opts.file, opts.format.Extension()))
-		if err := fs.IsIgnored(p); err != nil {
-			return nil
-		}
-
-		reader, err := de.OpenReader(opts.r)
-		if err != nil {
-			return errors.Wrap(err, "server/filesystem: decompress: failed to open reader")
-		}
-		defer reader.Close()
-
-		// Open the file for creation/writing
-		f, err := fs.root.OpenFile(normalize(p), os.O_WRONLY|os.O_CREATE, 0o644)
-		if err != nil {
-			return errors.Wrap(err, "server/filesystem: decompress: failed to open file")
-		}
-		defer f.Close()
-
-		// Read in 4 KB chunks
-		buf := make([]byte, 4096)
-		for {
-			n, err := reader.Read(buf)
-			if n > 0 {
-				if err := fs.HasSpaceFor(int64(n)); err != nil {
-					return err
-				}
-				if _, err := f.Write(buf[:n]); err != nil {
-					return errors.Wrap(err, "server/filesystem: decompress: failed to write")
-				}
-				fs.addDisk(int64(n))
-			}
-
-			if err != nil {
-				if err == io.EOF {
-					break
-				}
-				return errors.Wrap(err, "server/filesystem: decompress: failed to read")
-			}
-		}
-
+// SpaceAvailableForDecompression looks through a given archive and determines
+// if decompressing it would put the server over its allocated disk space limit.
+func (fs *Filesystem) SpaceAvailableForDecompression(dir string, file string) error {
+	// Don't waste time trying to determine this if we know the server will have the space for
+	// it since there is no limit.
+	if fs.MaxDisk() <= 0 {
 		return nil
 	}

-	// Decompress and extract archive
-	return ex.Extract(ctx, opts.r, func(ctx context.Context, f archives.FileInfo) error {
-		if f.IsDir() {
-			return nil
-		}
-		p := filepath.Join(opts.dir, f.NameInArchive)
-		if err := fs.IsIgnored(p); err != nil {
-			return nil
-		}
-		r, err := f.Open()
-		if err != nil {
-			return err
-		}
-		defer r.Close()
-		if f.Mode()&os.ModeSymlink != 0 {
-			// Try to create the symlink if it is in the archive, but don't hold up the process
-			// if the file cannot be created. In that case just skip over it entirely.
-			if f.LinkTarget != "" {
-				p2 := strings.TrimLeft(filepath.Clean(p), string(filepath.Separator))
-				if p2 == "" {
-					p2 = "."
-				}
-				// We don't use [fs.Symlink] here because that normalizes the source directory for
-				// consistency with the codebase. In this case when decompressing we want to just
-				// accept the source without any normalization.
-				if err := fs.root.Symlink(f.LinkTarget, p2); err != nil {
-					if errors.Is(err, os.ErrNotExist) || IsPathError(err) || IsLinkError(err) {
-						return nil
-					}
-					return errors.Wrap(err, "server/filesystem: decompress: failed to create symlink")
-				}
-			}
-			return nil
-		}
+	source, err := fs.SafePath(filepath.Join(dir, file))
+	if err != nil {
+		return err
+	}

-		if err := fs.Write(p, r, f.Size(), f.Mode().Perm()); err != nil {
-			return errors.Wrap(err, "server/filesystem: decompress: failed to write file")
-		}
+	// Get the cached size in a parallel process so that if it is not cached we are not
+	// waiting an unnecessary amount of time on this call.
+	dirSize, err := fs.DiskUsage(false)

-		// Update the file modification time to the one set in the archive.
-		if err := fs.Chtimes(p, f.ModTime(), f.ModTime()); err != nil {
-			return errors.Wrap(err, "server/filesystem: decompress: failed to update file modification time")
+	var size int64
+	// Walk over the archive and figure out just how large the final output would be from unarchiving it.
+	err = archiver.Walk(source, func(f archiver.File) error {
+		if atomic.AddInt64(&size, f.Size())+dirSize > fs.MaxDisk() {
+			return newFilesystemError(ErrCodeDiskSpace, nil)
 		}
-
 		return nil
 	})
-}
-
-// ExtractStreamUnsafe .
-func (fs *Filesystem) ExtractStreamUnsafe(ctx context.Context, dir string, r io.Reader) error {
-	format, input, err := archives.Identify(ctx, "archive.tar.gz", r)
 	if err != nil {
-		if errors.Is(err, archives.NoMatch) {
+		if IsUnknownArchiveFormatError(err) {
 			return newFilesystemError(ErrCodeUnknownArchive, err)
 		}
 		return err
 	}
-	return fs.extractStream(ctx, extractOptions{
-		dir:    dir,
-		format: format,
-		r:      input,
-	})
+	return err
+}
+
+// DecompressFile will decompress a file in a given directory by using the
+// archiver tool to infer the file type and go from there. This will walk over
+// all of the files within the given archive and ensure that there is not a
+// zip-slip attack being attempted by validating that the final path is within
+// the server data directory.
+func (fs *Filesystem) DecompressFile(dir string, file string) error {
+	source, err := fs.SafePath(filepath.Join(dir, file))
+	if err != nil {
+		return err
+	}
+	// Ensure that the source archive actually exists on the system.
+	if _, err := os.Stat(source); err != nil {
+		return errors.WithStack(err)
+	}
+
+	// Walk all of the files in the archiver file and write them to the disk. If any
+	// directory is encountered it will be skipped since we handle creating any missing
+	// directories automatically when writing files.
+	err = archiver.Walk(source, func(f archiver.File) error {
+		if f.IsDir() {
+			return nil
+		}
+		p := filepath.Join(dir, ExtractNameFromArchive(f))
+		// If it is ignored, just don't do anything with the file and skip over it.
+		if err := fs.IsIgnored(p); err != nil {
+			return nil
+		}
+		if err := fs.Writefile(p, f); err != nil {
+			return wrapError(err, source)
+		}
+		// Update the file permissions to the one set in the archive.
+		if err := fs.Chmod(p, f.Mode()); err != nil {
+			return wrapError(err, source)
+		}
+		// Update the file modification time to the one set in the archive.
+		if err := fs.Chtimes(p, f.ModTime(), f.ModTime()); err != nil {
+			return wrapError(err, source)
+		}
+		return nil
+	})
+	if err != nil {
+		if IsUnknownArchiveFormatError(err) {
+			return newFilesystemError(ErrCodeUnknownArchive, err)
+		}
+		return err
+	}
+	return nil
+}
+
+// ExtractNameFromArchive looks at an archive file to try and determine the name
+// for a given element in an archive. Because of... who knows why, each file type
+// uses different methods to determine the file name.
+//
+// If there is a archiver.File#Sys() value present we will try to use the name
+// present in there, otherwise falling back to archiver.File#Name() if all else
+// fails. Without this logic present, some archive types such as zip/tars/etc.
+// will write all of the files to the base directory, rather than the nested
+// directory that is expected.
+//
+// For files like ".rar" types, there is no f.Sys() value present, and the value
+// of archiver.File#Name() will be what you need.
+func ExtractNameFromArchive(f archiver.File) string {
+	sys := f.Sys()
+	// Some archive types won't have a value returned when you call f.Sys() on them,
+	// such as ".rar" archives for example. In those cases the only thing you can do
+	// is hope that "f.Name()" is actually correct for them.
+	if sys == nil {
+		return f.Name()
+	}
+	switch s := sys.(type) {
+	case *tar.Header:
+		return s.Name
+	case *gzip.Header:
+		return s.Name
+	case *zip.FileHeader:
+		return s.Name
+	default:
+		return f.Name()
+	}
 }
--- a/server/filesystem/compress_test.go
+++ b/server/filesystem/compress_test.go
@@ -0,0 +1,54 @@
+package filesystem
+
+import (
+	"os"
+	"sync/atomic"
+	"testing"
+
+	. "github.com/franela/goblin"
+)
+
+// Given an archive named test.{ext}, with the following file structure:
+//	test/
+//	|──inside/
+//	|────finside.txt
+//	|──outside.txt
+// this test will ensure that it's being decompressed as expected
+func TestFilesystem_DecompressFile(t *testing.T) {
+	g := Goblin(t)
+	fs, rfs := NewFs()
+
+	g.Describe("Decompress", func() {
+		for _, ext := range []string{"zip", "rar", "tar", "tar.gz"} {
+			g.It("can decompress a "+ext, func() {
+				// copy the file to the new FS
+				c, err := os.ReadFile("./testdata/test." + ext)
+				g.Assert(err).IsNil()
+				err = rfs.CreateServerFile("./test."+ext, c)
+				g.Assert(err).IsNil()
+
+				// decompress
+				err = fs.DecompressFile("/", "test."+ext)
+				g.Assert(err).IsNil()
+
+				// make sure everything is where it is supposed to be
+				_, err = rfs.StatServerFile("test/outside.txt")
+				g.Assert(err).IsNil()
+
+				st, err := rfs.StatServerFile("test/inside")
+				g.Assert(err).IsNil()
+				g.Assert(st.IsDir()).IsTrue()
+
+				_, err = rfs.StatServerFile("test/inside/finside.txt")
+				g.Assert(err).IsNil()
+				g.Assert(st.IsDir()).IsTrue()
+			})
+		}
+
+		g.AfterEach(func() {
+			rfs.reset()
+			atomic.StoreInt64(&fs.diskUsed, 0)
+			atomic.StoreInt64(&fs.diskLimit, 0)
+		})
+	})
+}
--- a/server/filesystem/disk_space.go
+++ b/server/filesystem/disk_space.go
@@ -1,10 +1,6 @@
 package filesystem

 import (
-	fs2 "io/fs"
-	"os"
-	"path/filepath"
-	"slices"
 	"sync"
 	"sync/atomic"
 	"syscall"
@@ -12,13 +8,13 @@ import (

 	"emperror.dev/errors"
 	"github.com/apex/log"
+	"github.com/karrick/godirwalk"
 )

 type SpaceCheckingOpts struct {
 	AllowStaleResponse bool
 }

-// TODO: can this be replaced with some sort of atomic? Like atomic.Pointer?
 type usageLookupTime struct {
 	sync.RWMutex
 	value time.Time
@@ -39,13 +35,12 @@ func (ult *usageLookupTime) Get() time.Time {
 	return ult.value
 }

-// MaxDisk returns the maximum amount of disk space that this Filesystem
-// instance is allowed to use.
+// Returns the maximum amount of disk space that this Filesystem instance is allowed to use.
 func (fs *Filesystem) MaxDisk() int64 {
 	return atomic.LoadInt64(&fs.diskLimit)
 }

-// SetDiskLimit sets the disk space limit for this Filesystem instance.
+// Sets the disk space limit for this Filesystem instance.
 func (fs *Filesystem) SetDiskLimit(i int64) {
 	atomic.SwapInt64(&fs.diskLimit, i)
 }
@@ -59,23 +54,24 @@ func (fs *Filesystem) HasSpaceErr(allowStaleValue bool) error {
 	return nil
 }

-// HasSpaceAvailable checks if the directory a file is trying to be added to has enough
-// space available for the file to be written to. Because determining the amount of space
-// being used by a server is a taxing operation, we will load it all up into a cache and
-// pull from that as long as the key is not expired.
+// Determines if the directory a file is trying to be added to has enough space available
+// for the file to be written to.
 //
-// This operation will potentially be blocked unless allowStaleValue is set to true. See
-// the documentation on DiskUsage for how this affects the call.
+// Because determining the amount of space being used by a server is a taxing operation we
+// will load it all up into a cache and pull from that as long as the key is not expired.
+//
+// This operation will potentially block unless allowStaleValue is set to true. See the
+// documentation on DiskUsage for how this affects the call.
 func (fs *Filesystem) HasSpaceAvailable(allowStaleValue bool) bool {
 	size, err := fs.DiskUsage(allowStaleValue)
 	if err != nil {
-		log.WithField("root", fs.Path()).WithField("error", err).Warn("failed to determine root fs directory size")
+		log.WithField("root", fs.root).WithField("error", err).Warn("failed to determine root fs directory size")
 	}

 	// If space is -1 or 0 just return true, means they're allowed unlimited.
 	//
 	// Technically we could skip disk space calculation because we don't need to check if the
-	// server exceeds its limit but because this method caches the disk usage it would be best
+	// server exceeds it's limit but because this method caches the disk usage it would be best
 	// to calculate the disk usage and always return true.
 	if fs.MaxDisk() == 0 {
 		return true
@@ -118,7 +114,7 @@ func (fs *Filesystem) DiskUsage(allowStaleValue bool) (int64, error) {
 			// currently performing a lookup, just do the disk usage calculation in the background.
 			go func(fs *Filesystem) {
 				if _, err := fs.updateCachedDiskUsage(); err != nil {
-					log.WithField("root", fs.rootPath).WithField("error", err).Warn("failed to update fs disk usage from within routine")
+					log.WithField("root", fs.root).WithField("error", err).Warn("failed to update fs disk usage from within routine")
 				}
 			}(fs)
 		}
@@ -158,55 +154,41 @@ func (fs *Filesystem) updateCachedDiskUsage() (int64, error) {
 	return size, err
 }

-// DirectorySize determines the directory size of a given location. Returns the size
-// in bytes. This can be a fairly taxing operation on locations with tons of files,
-// so it is recommended that you cache the output.
+// Determines the directory size of a given location by running parallel tasks to iterate
+// through all of the folders. Returns the size in bytes. This can be a fairly taxing operation
+// on locations with tons of files, so it is recommended that you cache the output.
 func (fs *Filesystem) DirectorySize(dir string) (int64, error) {
-	dir = normalize(dir)
-	if dir != "." {
-		if _, err := fs.root.Lstat(dir); err != nil {
-			return 0, err
-		}
-	}
-
-	rt := fs.root
-	if dir != "." {
-		r, err := fs.root.OpenRoot(dir)
-		if err != nil {
-			return 0, errors.Wrap(err, "server/filesystem: directorysize: failed to open root directory")
-		}
-		defer r.Close()
-		rt = r
+	d, err := fs.SafePath(dir)
+	if err != nil {
+		return 0, err
 	}

 	var size int64
-	var links []uint64
+	var st syscall.Stat_t
+
+	err = godirwalk.Walk(d, &godirwalk.Options{
+		Unsorted: true,
+		Callback: func(p string, e *godirwalk.Dirent) error {
+			// If this is a symlink then resolve the final destination of it before trying to continue walking
+			// over its contents. If it resolves outside the server data directory just skip everything else for
+			// it. Otherwise, allow it to continue.
+			if e.IsSymlink() {
+				if _, err := fs.SafePath(p); err != nil {
+					if IsErrorCode(err, ErrCodePathResolution) {
+						return godirwalk.SkipThis
+					}
+
+					return err
+				}
+			}
+
+			if !e.IsDir() {
+				syscall.Lstat(p, &st)
+				atomic.AddInt64(&size, st.Size)
+			}

-	err := filepath.WalkDir(rt.Name(), func(path string, d fs2.DirEntry, err error) error {
-		if !d.Type().IsRegular() {
 			return nil
-		}
-
-		st, err := d.Info()
-		if err != nil {
-			if errors.Is(err, os.ErrNotExist) {
-				return nil
-			}
-			return err
-		}
-
-		s := st.Sys().(*syscall.Stat_t)
-		if s.Nlink > 1 {
-			// Hard links have the same inode number, don't add them more than once.
-			if slices.Contains(links, s.Ino) {
-				return nil
-			}
-			links = append(links, s.Ino)
-		}
-
-		size += st.Size()
-
-		return nil
+		},
 	})

 	return size, errors.WrapIf(err, "server/filesystem: directorysize: failed to walk directory")
--- a/server/filesystem/errors.go
+++ b/server/filesystem/errors.go
@@ -3,6 +3,8 @@ package filesystem
 import (
 	"fmt"
 	"os"
+	"path/filepath"
+	"strings"

 	"emperror.dev/errors"
 	"github.com/apex/log"
@@ -14,9 +16,9 @@ const (
 	ErrCodeIsDirectory    ErrorCode = "E_ISDIR"
 	ErrCodeDiskSpace      ErrorCode = "E_NODISK"
 	ErrCodeUnknownArchive ErrorCode = "E_UNKNFMT"
+	ErrCodePathResolution ErrorCode = "E_BADPATH"
 	ErrCodeDenylistFile   ErrorCode = "E_DENYLIST"
 	ErrCodeUnknownError   ErrorCode = "E_UNKNOWN"
-	ErrNotExist           ErrorCode = "E_NOTEXIST"
 )

 type Error struct {
@@ -61,8 +63,12 @@ func (e *Error) Error() string {
 			r = "<empty>"
 		}
 		return fmt.Sprintf("filesystem: file access prohibited: [%s] is on the denylist", r)
-	case ErrNotExist:
-		return "filesystem: does not exist"
+	case ErrCodePathResolution:
+		r := e.resolved
+		if r == "" {
+			r = "<empty>"
+		}
+		return fmt.Sprintf("filesystem: server path [%s] resolves to a location outside the server root: %s", e.path, r)
 	case ErrCodeUnknownError:
 		fallthrough
 	default:
@@ -81,6 +87,30 @@ func (fs *Filesystem) error(err error) *log.Entry {
 	return log.WithField("subsystem", "filesystem").WithField("root", fs.root).WithField("error", err)
 }

+// Handle errors encountered when walking through directories.
+//
+// If there is a path resolution error just skip the item entirely. Only return this for a
+// directory, otherwise return nil. Returning this error for a file will stop the walking
+// for the remainder of the directory. This is assuming an os.FileInfo struct was even returned.
+func (fs *Filesystem) handleWalkerError(err error, f os.FileInfo) error {
+	if !IsErrorCode(err, ErrCodePathResolution) {
+		return err
+	}
+	if f != nil && f.IsDir() {
+		return filepath.SkipDir
+	}
+	return nil
+}
+
+// IsFilesystemError checks if the given error is one of the Filesystem errors.
+func IsFilesystemError(err error) bool {
+	var fserr *Error
+	if err != nil && errors.As(err, &fserr) {
+		return true
+	}
+	return false
+}
+
 // IsErrorCode checks if "err" is a filesystem Error type. If so, it will then
 // drop in and check that the error code is the same as the provided ErrorCode
 // passed in "code".
@@ -92,12 +122,26 @@ func IsErrorCode(err error, code ErrorCode) bool {
 	return false
 }

-func IsPathError(err error) bool {
-	var pe *os.PathError
-	return errors.As(err, &pe)
+// IsUnknownArchiveFormatError checks if the error is due to the archive being
+// in an unexpected file format.
+func IsUnknownArchiveFormatError(err error) bool {
+	if err != nil && strings.HasPrefix(err.Error(), "format ") {
+		return true
+	}
+	return false
 }

-func IsLinkError(err error) bool {
-	var le *os.LinkError
-	return errors.As(err, &le)
+// NewBadPathResolution returns a new BadPathResolution error.
+func NewBadPathResolution(path string, resolved string) error {
+	return errors.WithStackDepth(&Error{code: ErrCodePathResolution, path: path, resolved: resolved}, 1)
+}
+
+// wrapError wraps the provided error as a Filesystem error and attaches the
+// provided resolved source to it. If the error is already a Filesystem error
+// no action is taken.
+func wrapError(err error, resolved string) error {
+	if err == nil || IsFilesystemError(err) {
+		return err
+	}
+	return errors.WithStackDepth(&Error{code: ErrCodeUnknownError, err: err, resolved: resolved}, 1)
 }
--- a/server/filesystem/errors_test.go
+++ b/server/filesystem/errors_test.go
@@ -39,4 +39,19 @@ func TestFilesystem_PathResolutionError(t *testing.T) {
 			g.Assert(fserr.Unwrap()).Equal(underlying)
 		})
 	})
+
+	g.Describe("NewBadPathResolutionError", func() {
+		g.It("is can detect itself as an error correctly", func() {
+			err := NewBadPathResolution("foo", "bar")
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
+			g.Assert(err.Error()).Equal("filesystem: server path [foo] resolves to a location outside the server root: bar")
+			g.Assert(IsErrorCode(&Error{code: ErrCodeIsDirectory}, ErrCodePathResolution)).IsFalse()
+		})
+
+		g.It("returns <empty> if no destination path is provided", func() {
+			err := NewBadPathResolution("foo", "")
+			g.Assert(err).IsNotNil()
+			g.Assert(err.Error()).Equal("filesystem: server path [foo] resolves to a location outside the server root: <empty>")
+		})
+	})
 }
--- a/server/filesystem/filesystem.go
+++ b/server/filesystem/filesystem.go
@@ -3,7 +3,7 @@ package filesystem
 import (
 	"bufio"
 	"io"
-	fs2 "io/fs"
+	"io/ioutil"
 	"os"
 	"path"
 	"path/filepath"
@@ -11,11 +11,12 @@ import (
 	"strconv"
 	"strings"
 	"sync"
+	"sync/atomic"
 	"time"

 	"emperror.dev/errors"
-	"github.com/apex/log"
 	"github.com/gabriel-vasile/mimetype"
+	"github.com/karrick/godirwalk"
 	ignore "github.com/sabhiram/go-gitignore"

 	"github.com/pterodactyl/wings/config"
@@ -34,131 +35,117 @@ type Filesystem struct {
 	diskLimit int64

 	// The root data directory path for this Filesystem instance.
-	root     *os.Root
-	rootPath string
+	root string

 	isTest bool
 }

 // New creates a new Filesystem instance for a given server.
-func New(path string, size int64, denylist []string) (*Filesystem, error) {
-	r, err := os.OpenRoot(path)
-	if err != nil {
-		return nil, errors.Wrap(err, "server/filesystem: failed to open root")
-	}
-
-	fs := &Filesystem{
-		root:              r,
-		rootPath:          path,
+func New(root string, size int64, denylist []string) *Filesystem {
+	return &Filesystem{
+		root:              root,
 		diskLimit:         size,
 		diskCheckInterval: time.Duration(config.Get().System.DiskCheckInterval),
 		lastLookupTime:    &usageLookupTime{},
 		lookupInProgress:  system.NewAtomicBool(false),
 		denylist:          ignore.CompileIgnoreLines(denylist...),
 	}
-
-	return fs, nil
-}
-
-// normalize takes the input path, runs it through filepath.Clean and trims any
-// leading forward slashes (since the os.Root method calls will fail otherwise).
-// If the resulting path is an empty string, "." is returned which os.Root will
-// understand as the base directory.
-func normalize(path string) string {
-	c := strings.TrimLeft(filepath.Clean(path), string(filepath.Separator))
-	if c == "" {
-		return "."
-	}
-	return c
 }

 // Path returns the root path for the Filesystem instance.
 func (fs *Filesystem) Path() string {
-	return fs.rootPath
-}
-
-// Close closes the underlying os.Root instance for the server.
-func (fs *Filesystem) Close() error {
-	if err := fs.root.Close(); err != nil {
-		return errors.Wrap(err, "server/filesystem: failed to close root")
-	}
-	return nil
+	return fs.root
 }

 // File returns a reader for a file instance as well as the stat information.
 func (fs *Filesystem) File(p string) (*os.File, Stat, error) {
-	p = normalize(p)
-	st, err := fs.Stat(p)
+	cleaned, err := fs.SafePath(p)
 	if err != nil {
-		if errors.Is(err, os.ErrNotExist) {
-			return nil, Stat{}, newFilesystemError(ErrNotExist, err)
-		}
-		return nil, Stat{}, errors.WithStackIf(err)
+		return nil, Stat{}, err
+	}
+	st, err := fs.Stat(cleaned)
+	if err != nil {
+		return nil, Stat{}, err
 	}
 	if st.IsDir() {
 		return nil, Stat{}, newFilesystemError(ErrCodeIsDirectory, nil)
 	}
-	f, err := fs.root.Open(p)
+	f, err := os.Open(cleaned)
 	if err != nil {
-		return nil, Stat{}, errors.WithStackIf(err)
+		return nil, Stat{}, err
 	}
 	return f, st, nil
 }

-// Touch acts by creating the given file and path on the disk if it is not present
-// already. If it is present, the file is opened using the defaults which will truncate
-// the contents. The opened file is then returned to the caller.
-func (fs *Filesystem) Touch(p string, flag int, mode os.FileMode) (*os.File, error) {
-	p = normalize(p)
-	o := &fileOpener{root: fs.root}
-	f, err := o.open(p, flag, mode)
+// Acts by creating the given file and path on the disk if it is not present already. If
+// it is present, the file is opened using the defaults which will truncate the contents.
+// The opened file is then returned to the caller.
+func (fs *Filesystem) Touch(p string, flag int) (*os.File, error) {
+	cleaned, err := fs.SafePath(p)
+	if err != nil {
+		return nil, err
+	}
+	f, err := os.OpenFile(cleaned, flag, 0o644)
 	if err == nil {
 		return f, nil
 	}
-	if f != nil {
-		_ = f.Close()
-	}
 	// If the error is not because it doesn't exist then we just need to bail at this point.
 	if !errors.Is(err, os.ErrNotExist) {
 		return nil, errors.Wrap(err, "server/filesystem: touch: failed to open file handle")
 	}
 	// Only create and chown the directory if it doesn't exist.
-	if _, err := fs.root.Stat(filepath.Dir(p)); errors.Is(err, os.ErrNotExist) {
+	if _, err := os.Stat(filepath.Dir(cleaned)); errors.Is(err, os.ErrNotExist) {
 		// Create the path leading up to the file we're trying to create, setting the final perms
 		// on it as we go.
-		if err := fs.root.MkdirAll(filepath.Dir(p), 0o755); err != nil {
-			return nil, errors.WrapIf(err, "server/filesystem: touch: failed to create directory tree")
+		if err := os.MkdirAll(filepath.Dir(cleaned), 0o755); err != nil {
+			return nil, errors.Wrap(err, "server/filesystem: touch: failed to create directory tree")
 		}
-		if err := fs.Chown(filepath.Dir(p)); err != nil {
-			return nil, errors.WrapIf(err, "server/filesystem: touch: failed to chown directory tree")
+		if err := fs.Chown(filepath.Dir(cleaned)); err != nil {
+			return nil, err
 		}
 	}
+	o := &fileOpener{}
 	// Try to open the file now that we have created the pathing necessary for it, and then
 	// Chown that file so that the permissions don't mess with things.
-	f, err = o.open(p, flag, mode)
+	f, err = o.open(cleaned, flag, 0o644)
 	if err != nil {
-		return nil, errors.Wrap(err, "server/filesystem: touch: failed to open file handle")
+		return nil, errors.Wrap(err, "server/filesystem: touch: failed to open file with wait")
 	}
-	_ = fs.Chown(p)
+	_ = fs.Chown(cleaned)
 	return f, nil
 }

+// Reads a file on the system and returns it as a byte representation in a file
+// reader. This is not the most memory efficient usage since it will be reading the
+// entirety of the file into memory.
+func (fs *Filesystem) Readfile(p string, w io.Writer) error {
+	file, _, err := fs.File(p)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+	_, err = bufio.NewReader(file).WriteTo(w)
+	return err
+}
+
 // Writefile writes a file to the system. If the file does not already exist one
 // will be created. This will also properly recalculate the disk space used by
 // the server when writing new files or modifying existing ones.
-//
-// deprecated 1.12.1 prefer the use of Filesystem.Write()
 func (fs *Filesystem) Writefile(p string, r io.Reader) error {
-	p = normalize(p)
+	cleaned, err := fs.SafePath(p)
+	if err != nil {
+		return err
+	}
+
 	var currentSize int64
 	// If the file does not exist on the system already go ahead and create the pathway
 	// to it and an empty file. We'll then write to it later on after this completes.
-	stat, err := fs.root.Stat(p)
+	stat, err := os.Stat(cleaned)
 	if err != nil && !os.IsNotExist(err) {
 		return errors.Wrap(err, "server/filesystem: writefile: failed to stat file")
 	} else if err == nil {
 		if stat.IsDir() {
-			return errors.WithStack(&Error{code: ErrCodeIsDirectory, resolved: stat.Name()})
+			return errors.WithStack(&Error{code: ErrCodeIsDirectory, resolved: cleaned})
 		}
 		currentSize = stat.Size()
 	}
@@ -173,7 +160,7 @@ func (fs *Filesystem) Writefile(p string, r io.Reader) error {

 	// Touch the file and return the handle to it at this point. This will create the file,
 	// any necessary directories, and set the proper owner of the file.
-	file, err := fs.Touch(p, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0o644)
+	file, err := fs.Touch(cleaned, os.O_RDWR|os.O_CREATE|os.O_TRUNC)
 	if err != nil {
 		return err
 	}
@@ -185,91 +172,118 @@ func (fs *Filesystem) Writefile(p string, r io.Reader) error {
 	// Adjust the disk usage to account for the old size and the new size of the file.
 	fs.addDisk(sz - currentSize)

-	return fs.Chown(p)
+	return fs.Chown(cleaned)
 }

-func (fs *Filesystem) Mkdir(p string, mode os.FileMode) error {
-	if err := fs.root.Mkdir(normalize(p), mode); err != nil {
-		return errors.Wrap(err, "server/filesystem: mkdir: failed to make directory")
-	}
-	return nil
-}
-
-// Write writes a file to the disk.
-func (fs *Filesystem) Write(p string, r io.Reader, newSize int64, mode os.FileMode) error {
-	st, err := fs.root.Stat(normalize(p))
+// Creates a new directory (name) at a specified path (p) for the server.
+func (fs *Filesystem) CreateDirectory(name string, p string) error {
+	cleaned, err := fs.SafePath(path.Join(p, name))
 	if err != nil {
-		if !errors.Is(err, os.ErrNotExist) {
-			return errors.Wrap(err, "server/filesystem: write: failed to stat file")
-		}
+		return err
 	}
+	return os.MkdirAll(cleaned, 0o755)
+}

-	var c int64
-	if err == nil {
-		if st.IsDir() {
-			return errors.WithStack(&Error{code: ErrCodeIsDirectory, resolved: normalize(p)})
-		}
-		c = st.Size()
-	}
-
-	if err := fs.HasSpaceFor(newSize - c); err != nil {
+// Moves (or renames) a file or directory.
+func (fs *Filesystem) Rename(from string, to string) error {
+	cleanedFrom, err := fs.SafePath(from)
+	if err != nil {
 		return err
 	}

-	f, err := fs.Touch(p, os.O_RDWR|os.O_CREATE|os.O_TRUNC, mode)
+	cleanedTo, err := fs.SafePath(to)
 	if err != nil {
-		return errors.Wrap(err, "server/filesystem: write: failed to touch file")
-	}
-	defer f.Close()
-
-	if newSize == 0 {
-		fs.addDisk(-c)
-	} else {
-		// Do not use CopyBuffer here; it is wasteful as the file implements
-		// io.ReaderFrom, which causes it to not use the buffer anyway.
-		n, err := io.Copy(f, io.LimitReader(r, newSize))
-		// Always adjust the disk to account for cases where a partial copy occurs
-		// and there is some new content on the disk.
-		fs.addDisk(n - c)
-		if err != nil {
-			return errors.Wrap(err, "server/filesystem: write: failed to write file")
-		}
+		return err
 	}

-	// todo: might be unnecessary due to the `fs.Touch` call already doing this?
-	return fs.Chown(p)
-}
-
-// CreateDirectory creates a new directory ("name") at a specified path ("p") for the server.
-func (fs *Filesystem) CreateDirectory(name string, p string) error {
-	return fs.root.MkdirAll(path.Join(normalize(p), name), 0o755)
-}
-
-// Rename moves (or renames) a file or directory.
-func (fs *Filesystem) Rename(from string, to string) error {
-	to = normalize(to)
-	from = normalize(from)
-
-	if from == "." || to == "." {
+	// If the target file or directory already exists the rename function will fail, so just
+	// bail out now.
+	if _, err := os.Stat(cleanedTo); err == nil {
 		return os.ErrExist
 	}

-	// If the target file or directory already exists the rename function will
-	// fail, so just bail out now.
-	if _, err := fs.root.Stat(to); err == nil {
-		return os.ErrExist
+	if cleanedTo == fs.Path() {
+		return errors.New("attempting to rename into an invalid directory space")
 	}

-	d := strings.TrimLeft(filepath.Dir(to), "/")
+	d := strings.TrimSuffix(cleanedTo, path.Base(cleanedTo))
 	// Ensure that the directory we're moving into exists correctly on the system. Only do this if
 	// we're not at the root directory level.
-	if d != "" {
-		if err := fs.root.MkdirAll(d, 0o755); err != nil {
-			return errors.Wrap(err, "server/filesystem: failed to create directory tree")
+	if d != fs.Path() {
+		if mkerr := os.MkdirAll(d, 0o755); mkerr != nil {
+			return errors.WithMessage(mkerr, "failed to create directory structure for file rename")
 		}
 	}

-	return fs.root.Rename(from, to)
+	return os.Rename(cleanedFrom, cleanedTo)
+}
+
+// Recursively iterates over a file or directory and sets the permissions on all of the
+// underlying files. Iterate over all of the files and directories. If it is a file just
+// go ahead and perform the chown operation. Otherwise dig deeper into the directory until
+// we've run out of directories to dig into.
+func (fs *Filesystem) Chown(path string) error {
+	cleaned, err := fs.SafePath(path)
+	if err != nil {
+		return err
+	}
+
+	if fs.isTest {
+		return nil
+	}
+
+	uid := config.Get().System.User.Uid
+	gid := config.Get().System.User.Gid
+
+	// Start by just chowning the initial path that we received.
+	if err := os.Chown(cleaned, uid, gid); err != nil {
+		return errors.Wrap(err, "server/filesystem: chown: failed to chown path")
+	}
+
+	// If this is not a directory we can now return from the function, there is nothing
+	// left that we need to do.
+	if st, err := os.Stat(cleaned); err != nil || !st.IsDir() {
+		return nil
+	}
+
+	// If this was a directory, begin walking over its contents recursively and ensure that all
+	// of the subfiles and directories get their permissions updated as well.
+	err = godirwalk.Walk(cleaned, &godirwalk.Options{
+		Unsorted: true,
+		Callback: func(p string, e *godirwalk.Dirent) error {
+			// Do not attempt to chown a symlink. Go's os.Chown function will affect the symlink
+			// so if it points to a location outside the data directory the user would be able to
+			// (un)intentionally modify that files permissions.
+			if e.IsSymlink() {
+				if e.IsDir() {
+					return godirwalk.SkipThis
+				}
+
+				return nil
+			}
+
+			return os.Chown(p, uid, gid)
+		},
+	})
+
+	return errors.Wrap(err, "server/filesystem: chown: failed to chown during walk function")
+}
+
+func (fs *Filesystem) Chmod(path string, mode os.FileMode) error {
+	cleaned, err := fs.SafePath(path)
+	if err != nil {
+		return err
+	}
+
+	if fs.isTest {
+		return nil
+	}
+
+	if err := os.Chmod(cleaned, mode); err != nil {
+		return err
+	}
+
+	return nil
 }

 // Begin looping up to 50 times to try and create a unique copy file name. This will take
@@ -311,8 +325,12 @@ func (fs *Filesystem) findCopySuffix(dir string, name string, extension string)
 // Copies a given file to the same location and appends a suffix to the file to indicate that
 // it has been copied.
 func (fs *Filesystem) Copy(p string) error {
-	p = normalize(p)
-	s, err := fs.root.Stat(p)
+	cleaned, err := fs.SafePath(p)
+	if err != nil {
+		return err
+	}
+
+	s, err := os.Stat(cleaned)
 	if err != nil {
 		return err
 	} else if s.IsDir() || !s.Mode().IsRegular() {
@@ -326,8 +344,8 @@ func (fs *Filesystem) Copy(p string) error {
 		return err
 	}

-	base := filepath.Base(p)
-	relative := strings.TrimSuffix(strings.TrimPrefix(p, fs.Path()), base)
+	base := filepath.Base(cleaned)
+	relative := strings.TrimSuffix(strings.TrimPrefix(cleaned, fs.Path()), base)
 	extension := filepath.Ext(base)
 	name := strings.TrimSuffix(base, extension)

@@ -339,7 +357,7 @@ func (fs *Filesystem) Copy(p string) error {
 		name = strings.TrimSuffix(name, ".tar")
 	}

-	source, err := fs.root.Open(p)
+	source, err := os.Open(cleaned)
 	if err != nil {
 		return err
 	}
@@ -353,134 +371,75 @@ func (fs *Filesystem) Copy(p string) error {
 	return fs.Writefile(path.Join(relative, n), source)
 }

-// Symlink creates a symbolic link between the source and target paths. [os.Root].Symlink
-// allows for the creation of a symlink that targets a file outside the root directory.
-// This isn't the end of the world because the read is blocked through this system, and
-// within a container it would just point to something in the readonly filesystem.
-//
-// There are also valid use-cases where a symlink might need to point to a file outside
-// the server data directory for a server to operate correctly. Since everything in the
-// filesystem runs through os.Root though we're protected from accidentally reading a
-// sensitive file on the _host_ OS.
-func (fs *Filesystem) Symlink(source, target string) error {
-	source = normalize(source)
-	target = normalize(target)
-
-	// os.Root#Symlink allows for the creation of a symlink that targets a file outside
-	// the root directory. This isn't the end of the world because the read is blocked
-	// through this system, and within a container it would just point to something in the
-	// readonly filesystem.
-	//
-	// However, just to avoid this propagating everywhere, *attempt* to block anything that
-	// would be pointing to a location outside the root directory.
-	if _, err := fs.root.Stat(source); err != nil {
-		return errors.Wrap(err, "server/filesystem: symlink: failed to stat source")
-	}
-
-	// Yes -- this gap between the stat and symlink allows a TOCTOU vulnerability to exist,
-	// but again we're layering this with the remaining logic that prevents this filesystem
-	// from reading any symlinks or acting on any file that points outside the root as defined
-	// by os.Root. The check above is mostly to prevent stupid mistakes or basic attempts to
-	// get around this. If someone *really* wants to make these symlinks, they can. They can
-	// also just create them from the running server process, and we still need to rely on our
-	// own internal FS logic to detect and block those reads, which it does. Therefore, I am
-	// not deeply concerned with this.
-	if err := fs.root.Symlink(source, target); err != nil {
-		return errors.Wrap(err, "server/filesystem: symlink: failed to create symlink")
-	}
-
-	return nil
-}
-
-// ReadDir returns all the contents of the given directory.
-func (fs *Filesystem) ReadDir(p string) ([]fs2.DirEntry, error) {
-	d, ok := fs.root.FS().(fs2.ReadDirFS)
-	if !ok {
-		return []fs2.DirEntry{}, errors.New("server/filesystem: readdir: could not init root fs")
-	}
-
-	e, err := d.ReadDir(normalize(p))
-	if err != nil {
-		return []fs2.DirEntry{}, errors.Wrap(err, "server/filesystem: readdir: failed to read directory")
-	}
-
-	return e, nil
-}
-
 // TruncateRootDirectory removes _all_ files and directories from a server's
 // data directory and resets the used disk space to zero.
 func (fs *Filesystem) TruncateRootDirectory() error {
-	err := filepath.WalkDir(fs.rootPath, func(path string, d fs2.DirEntry, err error) error {
-		p := normalize(strings.TrimPrefix(path, fs.rootPath))
-		if p == "." {
-			return nil
-		}
-
-		if err := fs.root.RemoveAll(p); err != nil {
-			return err
-		}
-
-		if d.IsDir() {
-			return filepath.SkipDir
-		}
-
-		return nil
-	})
-
-	if err != nil {
-		go func() {
-			// If there was an error, re-calculate the disk usage right away to account
-			// for any partially removed files.
-			_, _ = fs.updateCachedDiskUsage()
-		}()
-
-		return errors.Wrap(err, "server/filesystem: truncate: failed to walk root directory")
+	if err := os.RemoveAll(fs.Path()); err != nil {
+		return err
 	}
-
-	// Set the disk space back to zero.
-	fs.addDisk(fs.diskUsed * -1)
-
+	if err := os.Mkdir(fs.Path(), 0o755); err != nil {
+		return err
+	}
+	atomic.StoreInt64(&fs.diskUsed, 0)
 	return nil
 }

 // Delete removes a file or folder from the system. Prevents the user from
 // accidentally (or maliciously) removing their root server data directory.
 func (fs *Filesystem) Delete(p string) error {
-	p = normalize(p)
-	if p == "." {
-		return errors.New("server/filesystem: delete: cannot delete root directory")
+	wg := sync.WaitGroup{}
+	// This is one of the few (only?) places in the codebase where we're explicitly not using
+	// the SafePath functionality when working with user provided input. If we did, you would
+	// not be able to delete a file that is a symlink pointing to a location outside of the data
+	// directory.
+	//
+	// We also want to avoid resolving a symlink that points _within_ the data directory and thus
+	// deleting the actual source file for the symlink rather than the symlink itself. For these
+	// purposes just resolve the actual file path using filepath.Join() and confirm that the path
+	// exists within the data directory.
+	resolved := fs.unsafeFilePath(p)
+	if !fs.unsafeIsInDataDirectory(resolved) {
+		return NewBadPathResolution(p, resolved)
 	}

-	st, err := fs.root.Lstat(p)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return nil
-		}
-		return errors.Wrap(err, "server/filesystem: delete: failed to stat file")
+	// Block any whoopsies.
+	if resolved == fs.Path() {
+		return errors.New("cannot delete root server directory")
 	}

-	if st.IsDir() {
-		if s, err := fs.DirectorySize(p); err == nil {
-			fs.addDisk(-s)
+	if st, err := os.Lstat(resolved); err != nil {
+		if !os.IsNotExist(err) {
+			fs.error(err).Warn("error while attempting to stat file before deletion")
 		}
 	} else {
-		fs.addDisk(-st.Size())
+		if !st.IsDir() {
+			fs.addDisk(-st.Size())
+		} else {
+			wg.Add(1)
+			go func(wg *sync.WaitGroup, st os.FileInfo, resolved string) {
+				defer wg.Done()
+				if s, err := fs.DirectorySize(resolved); err == nil {
+					fs.addDisk(-s)
+				}
+			}(&wg, st, resolved)
+		}
 	}

-	return fs.root.RemoveAll(p)
+	wg.Wait()
+
+	return os.RemoveAll(resolved)
 }

 type fileOpener struct {
 	busy uint
-	root *os.Root
 }

 // Attempts to open a given file up to "attempts" number of times, using a backoff. If the file
 // cannot be opened because of a "text file busy" error, we will attempt until the number of attempts
 // has been exhaused, at which point we will abort with an error.
-func (fo *fileOpener) open(path string, flags int, mode os.FileMode) (*os.File, error) {
+func (fo *fileOpener) open(path string, flags int, perm os.FileMode) (*os.File, error) {
 	for {
-		f, err := fo.root.OpenFile(path, flags, mode)
+		f, err := os.OpenFile(path, flags, perm)

 		// If there is an error because the text file is busy, go ahead and sleep for a few
 		// hundred milliseconds and then try again up to three times before just returning the
@@ -497,14 +456,17 @@ func (fo *fileOpener) open(path string, flags int, mode os.FileMode) (*os.File,
 	}
 }

-// ListDirectory lists the contents of a given directory and returns stat information
-// about each file and folder within it. If you only need to know the contents of the
-// directory and do not need mimetype information, call [Filesystem.ReadDir] directly
-// instead.
+// ListDirectory lists the contents of a given directory and returns stat
+// information about each file and folder within it.
 func (fs *Filesystem) ListDirectory(p string) ([]Stat, error) {
-	files, err := fs.ReadDir(p)
+	cleaned, err := fs.SafePath(p)
 	if err != nil {
-		return []Stat{}, err
+		return nil, err
+	}
+
+	files, err := ioutil.ReadDir(cleaned)
+	if err != nil {
+		return nil, err
 	}

 	var wg sync.WaitGroup
@@ -514,46 +476,35 @@ func (fs *Filesystem) ListDirectory(p string) ([]Stat, error) {
 	// break the panel badly.
 	out := make([]Stat, len(files))

-	// Iterate over all the files and directories returned and perform an async process
+	// Iterate over all of the files and directories returned and perform an async process
 	// to get the mime-type for them all.
 	for i, file := range files {
 		wg.Add(1)

-		go func(idx int, d fs2.DirEntry) {
+		go func(idx int, f os.FileInfo) {
 			defer wg.Done()

-			fi, err := d.Info()
-			if err != nil {
-				log.WithField("error", err).WithField("path", filepath.Join(p, d.Name())).Warn("failed to retrieve directory entry info")
-				return
-			}
+			var m *mimetype.MIME
+			d := "inode/directory"
+			if !f.IsDir() {
+				cleanedp := filepath.Join(cleaned, f.Name())
+				if f.Mode()&os.ModeSymlink != 0 {
+					cleanedp, _ = fs.SafePath(filepath.Join(cleaned, f.Name()))
+				}

-			if fi.IsDir() {
-				out[idx] = Stat{FileInfo: fi, Mimetype: "inode/directory"}
-				return
-			}
-
-			st := Stat{FileInfo: fi, Mimetype: "application/octet-stream"}
-
-			// Don't try to detect the type on a pipe — this will just hang the application,
-			// and you'll never get a response back.
-			//
-			// @see https://github.com/pterodactyl/panel/issues/4059
-			if fi.Mode()&os.ModeNamedPipe == 0 {
-				if f, err := fs.root.Open(normalize(filepath.Join(p, d.Name()))); err != nil {
-					if !IsPathError(err) && !IsLinkError(err) {
-						log.WithField("error", err).WithField("path", filepath.Join(p, d.Name())).Warn("error opening file for mimetype detection")
-					}
+				if cleanedp != "" {
+					m, _ = mimetype.DetectFile(filepath.Join(cleaned, f.Name()))
 				} else {
-					if m, err := mimetype.DetectReader(f); err == nil {
-						st.Mimetype = m.String()
-					} else {
-						log.WithField("error", err).WithField("path", filepath.Join(p, d.Name())).Warn("failed to detect mimetype for file")
-					}
-					_ = f.Close()
+					// Just pass this for an unknown type because the file could not safely be resolved within
+					// the server data path.
+					d = "application/octet-stream"
 				}
 			}

+			st := Stat{FileInfo: f, Mimetype: d}
+			if m != nil {
+				st.Mimetype = m.String()
+			}
 			out[idx] = st
 		}(i, file)
 	}
@@ -577,3 +528,20 @@ func (fs *Filesystem) ListDirectory(p string) ([]Stat, error) {

 	return out, nil
 }
+
+func (fs *Filesystem) Chtimes(path string, atime, mtime time.Time) error {
+	cleaned, err := fs.SafePath(path)
+	if err != nil {
+		return err
+	}
+
+	if fs.isTest {
+		return nil
+	}
+
+	if err := os.Chtimes(cleaned, atime, mtime); err != nil {
+		return err
+	}
+
+	return nil
+}
--- a/server/filesystem/filesystem_test.go
+++ b/server/filesystem/filesystem_test.go
@@ -1,13 +1,11 @@
 package filesystem

 import (
-	"bufio"
 	"bytes"
 	"errors"
 	"math/rand"
 	"os"
 	"path/filepath"
-	"strings"
 	"sync/atomic"
 	"testing"
 	"unicode/utf8"
@@ -17,12 +15,7 @@ import (
 	"github.com/pterodactyl/wings/config"
 )

-type testFs struct {
-	*Filesystem
-	tmpDir string
-}
-
-func NewFs() *testFs {
+func NewFs() (*Filesystem, *rootFs) {
 	config.Set(&config.Configuration{
 		AuthenticationToken: "abc",
 		System: config.SystemConfiguration{
@@ -35,103 +28,104 @@ func NewFs() *testFs {
 	if err != nil {
 		panic(err)
 	}
+	// defer os.RemoveAll(tmpDir)

-	fs, err := New(tmpDir, 0, []string{})
-	if err != nil {
-		panic(err)
-	}
+	rfs := rootFs{root: tmpDir}
+
+	rfs.reset()
+
+	fs := New(filepath.Join(tmpDir, "/server"), 0, []string{})
 	fs.isTest = true

-	tfs := &testFs{Filesystem: fs, tmpDir: tmpDir}
-	tfs.reset()
-
-	return tfs
+	return fs, &rfs
 }

-func getFileContent(file *os.File) string {
-	var w bytes.Buffer
-	if _, err := bufio.NewReader(file).WriteTo(&w); err != nil {
-		panic(err)
-	}
-	return w.String()
+type rootFs struct {
+	root string
 }

-func (tfs *testFs) reset() {
-	if err := tfs.root.Close(); err != nil {
-		panic(err)
-	}
-	if !strings.HasPrefix(tfs.tmpDir, "/tmp/pterodactyl") {
-		panic("filesystem_test: attempting to delete outside root directory: " + tfs.tmpDir)
+func (rfs *rootFs) CreateServerFile(p string, c []byte) error {
+	f, err := os.Create(filepath.Join(rfs.root, "/server", p))
+
+	if err == nil {
+		f.Write(c)
+		f.Close()
 	}

-	if err := os.RemoveAll(tfs.tmpDir); err != nil {
+	return err
+}
+
+func (rfs *rootFs) CreateServerFileFromString(p string, c string) error {
+	return rfs.CreateServerFile(p, []byte(c))
+}
+
+func (rfs *rootFs) StatServerFile(p string) (os.FileInfo, error) {
+	return os.Stat(filepath.Join(rfs.root, "/server", p))
+}
+
+func (rfs *rootFs) reset() {
+	if err := os.RemoveAll(filepath.Join(rfs.root, "/server")); err != nil {
 		if !os.IsNotExist(err) {
 			panic(err)
 		}
 	}

-	if !strings.HasPrefix(tfs.rootPath, tfs.tmpDir) {
-		panic("filesystem_test: mismatch between root and tmp paths")
-	}
-
-	tfs.rootPath = filepath.Join(tfs.tmpDir, "/server")
-	if err := os.MkdirAll(tfs.rootPath, 0o755); err != nil {
-		panic(err)
-	}
-
-	r, err := os.OpenRoot(tfs.rootPath)
-	if err != nil {
-		panic(err)
-	}
-
-	tfs.root = r
-}
-
-func (tfs *testFs) write(name string, data []byte) {
-	p := filepath.Clean(filepath.Join(tfs.rootPath, name))
-	// Ensure we're always writing into a location that would also be cleaned up
-	// by the reset() function.
-	if !strings.HasPrefix(p, filepath.Dir(tfs.rootPath)) {
-		panic("filesystem_test: attempting to write outside of root directory: " + p)
-	}
-
-	if err := os.WriteFile(filepath.Join(tfs.rootPath, name), data, 0o644); err != nil {
+	if err := os.Mkdir(filepath.Join(rfs.root, "/server"), 0o755); err != nil {
 		panic(err)
 	}
 }

-func TestFilesystem_Openfile(t *testing.T) {
+func TestFilesystem_Readfile(t *testing.T) {
 	g := Goblin(t)
-	fs := NewFs()
+	fs, rfs := NewFs()

-	g.Describe("File", func() {
-		g.It("returns custom error when file does not exist", func() {
-			_, _, err := fs.File("foo/bar.txt")
+	g.Describe("Readfile", func() {
+		buf := &bytes.Buffer{}

-			g.Assert(err).IsNotNil()
-			g.Assert(IsErrorCode(err, ErrNotExist)).IsTrue()
-		})
-
-		g.It("returns file stat information", func() {
-			fs.write("foo.txt", []byte("hello world"))
-
-			f, st, err := fs.File("foo.txt")
+		g.It("opens a file if it exists on the system", func() {
+			err := rfs.CreateServerFileFromString("test.txt", "testing")
 			g.Assert(err).IsNil()

-			g.Assert(st.Name()).Equal("foo.txt")
-			g.Assert(f).IsNotNil()
-			_ = f.Close()
+			err = fs.Readfile("test.txt", buf)
+			g.Assert(err).IsNil()
+			g.Assert(buf.String()).Equal("testing")
+		})
+
+		g.It("returns an error if the file does not exist", func() {
+			err := fs.Readfile("test.txt", buf)
+			g.Assert(err).IsNotNil()
+			g.Assert(errors.Is(err, os.ErrNotExist)).IsTrue()
+		})
+
+		g.It("returns an error if the \"file\" is a directory", func() {
+			err := os.Mkdir(filepath.Join(rfs.root, "/server/test.txt"), 0o755)
+			g.Assert(err).IsNil()
+
+			err = fs.Readfile("test.txt", buf)
+			g.Assert(err).IsNotNil()
+			g.Assert(IsErrorCode(err, ErrCodeIsDirectory)).IsTrue()
+		})
+
+		g.It("cannot open a file outside the root directory", func() {
+			err := rfs.CreateServerFileFromString("/../test.txt", "testing")
+			g.Assert(err).IsNil()
+
+			err = fs.Readfile("/../test.txt", buf)
+			g.Assert(err).IsNotNil()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
 		})

 		g.AfterEach(func() {
-			fs.reset()
+			buf.Truncate(0)
+			atomic.StoreInt64(&fs.diskUsed, 0)
+			rfs.reset()
 		})
 	})
 }

 func TestFilesystem_Writefile(t *testing.T) {
 	g := Goblin(t)
-	fs := NewFs()
+	fs, rfs := NewFs()

 	g.Describe("Open and WriteFile", func() {
 		buf := &bytes.Buffer{}
@@ -146,10 +140,9 @@ func TestFilesystem_Writefile(t *testing.T) {
 			err := fs.Writefile("test.txt", r)
 			g.Assert(err).IsNil()

-			f, _, err := fs.File("test.txt")
+			err = fs.Readfile("test.txt", buf)
 			g.Assert(err).IsNil()
-			defer f.Close()
-			g.Assert(getFileContent(f)).Equal("test file content")
+			g.Assert(buf.String()).Equal("test file content")
 			g.Assert(atomic.LoadInt64(&fs.diskUsed)).Equal(r.Size())
 		})

@@ -159,10 +152,9 @@ func TestFilesystem_Writefile(t *testing.T) {
 			err := fs.Writefile("/some/nested/test.txt", r)
 			g.Assert(err).IsNil()

-			f, _, err := fs.File("/some/nested/test.txt")
+			err = fs.Readfile("/some/nested/test.txt", buf)
 			g.Assert(err).IsNil()
-			defer f.Close()
-			g.Assert(getFileContent(f)).Equal("test file content")
+			g.Assert(buf.String()).Equal("test file content")
 		})

 		g.It("can create a new file inside a nested directory without a trailing slash", func() {
@@ -171,22 +163,17 @@ func TestFilesystem_Writefile(t *testing.T) {
 			err := fs.Writefile("some/../foo/bar/test.txt", r)
 			g.Assert(err).IsNil()

-			f, _, err := fs.File("foo/bar/test.txt")
+			err = fs.Readfile("foo/bar/test.txt", buf)
 			g.Assert(err).IsNil()
-			defer f.Close()
-			g.Assert(getFileContent(f)).Equal("test file content")
+			g.Assert(buf.String()).Equal("test file content")
 		})

 		g.It("cannot create a file outside the root directory", func() {
 			r := bytes.NewReader([]byte("test file content"))

-			err := fs.Writefile("../../etc/test.txt", r)
+			err := fs.Writefile("/some/../foo/../../test.txt", r)
 			g.Assert(err).IsNotNil()
-			g.Assert(IsPathError(err)).IsTrue()
-
-			err = fs.Writefile("a/../../../test.txt", r)
-			g.Assert(err).IsNotNil()
-			g.Assert(IsPathError(err)).IsTrue()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
 		})

 		g.It("cannot write a file that exceeds the disk limits", func() {
@@ -203,6 +190,28 @@ func TestFilesystem_Writefile(t *testing.T) {
 			g.Assert(IsErrorCode(err, ErrCodeDiskSpace)).IsTrue()
 		})

+		/*g.It("updates the total space used when a file is appended to", func() {
+			atomic.StoreInt64(&fs.diskUsed, 100)
+
+			b := make([]byte, 100)
+			_, _ = rand.Read(b)
+
+			r := bytes.NewReader(b)
+			err := fs.Writefile("test.txt", r)
+			g.Assert(err).IsNil()
+			g.Assert(atomic.LoadInt64(&fs.diskUsed)).Equal(int64(200))
+
+			// If we write less data than already exists, we should expect the total
+			// disk used to be decremented.
+			b = make([]byte, 50)
+			_, _ = rand.Read(b)
+
+			r = bytes.NewReader(b)
+			err = fs.Writefile("test.txt", r)
+			g.Assert(err).IsNil()
+			g.Assert(atomic.LoadInt64(&fs.diskUsed)).Equal(int64(150))
+		})*/
+
 		g.It("truncates the file when writing new contents", func() {
 			r := bytes.NewReader([]byte("original data"))
 			err := fs.Writefile("test.txt", r)
@@ -212,15 +221,14 @@ func TestFilesystem_Writefile(t *testing.T) {
 			err = fs.Writefile("test.txt", r)
 			g.Assert(err).IsNil()

-			f, _, err := fs.File("test.txt")
+			err = fs.Readfile("test.txt", buf)
 			g.Assert(err).IsNil()
-			defer f.Close()
-			g.Assert(getFileContent(f)).Equal("new data")
+			g.Assert(buf.String()).Equal("new data")
 		})

 		g.AfterEach(func() {
 			buf.Truncate(0)
-			fs.reset()
+			rfs.reset()

 			atomic.StoreInt64(&fs.diskUsed, 0)
 			atomic.StoreInt64(&fs.diskLimit, 0)
@@ -230,14 +238,14 @@ func TestFilesystem_Writefile(t *testing.T) {

 func TestFilesystem_CreateDirectory(t *testing.T) {
 	g := Goblin(t)
-	fs := NewFs()
+	fs, rfs := NewFs()

 	g.Describe("CreateDirectory", func() {
 		g.It("should create missing directories automatically", func() {
 			err := fs.CreateDirectory("test", "foo/bar/baz")
 			g.Assert(err).IsNil()

-			st, err := os.Stat(filepath.Join(fs.rootPath, "foo/bar/baz/test"))
+			st, err := rfs.StatServerFile("foo/bar/baz/test")
 			g.Assert(err).IsNil()
 			g.Assert(st.IsDir()).IsTrue()
 			g.Assert(st.Name()).Equal("test")
@@ -247,7 +255,7 @@ func TestFilesystem_CreateDirectory(t *testing.T) {
 			err := fs.CreateDirectory("test", "/foozie/barzie/bazzy/")
 			g.Assert(err).IsNil()

-			st, err := os.Stat(filepath.Join(fs.rootPath, "foozie/barzie/bazzy/test"))
+			st, err := rfs.StatServerFile("foozie/barzie/bazzy/test")
 			g.Assert(err).IsNil()
 			g.Assert(st.IsDir()).IsTrue()
 			g.Assert(st.Name()).Equal("test")
@@ -256,7 +264,7 @@ func TestFilesystem_CreateDirectory(t *testing.T) {
 		g.It("should not allow the creation of directories outside the root", func() {
 			err := fs.CreateDirectory("test", "e/../../something")
 			g.Assert(err).IsNotNil()
-			g.Assert(IsPathError(err)).IsTrue()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
 		})

 		g.It("should not increment the disk usage", func() {
@@ -266,24 +274,27 @@ func TestFilesystem_CreateDirectory(t *testing.T) {
 		})

 		g.AfterEach(func() {
-			fs.reset()
+			rfs.reset()
 		})
 	})
 }

 func TestFilesystem_Rename(t *testing.T) {
 	g := Goblin(t)
-	fs := NewFs()
+	fs, rfs := NewFs()

 	g.Describe("Rename", func() {
 		g.BeforeEach(func() {
-			fs.write("source.txt", []byte("text content"))
+			if err := rfs.CreateServerFileFromString("source.txt", "text content"); err != nil {
+				panic(err)
+			}
 		})

 		g.It("returns an error if the target already exists", func() {
-			fs.write("target.txt", []byte("taget content"))
+			err := rfs.CreateServerFileFromString("target.txt", "taget content")
+			g.Assert(err).IsNil()

-			err := fs.Rename("source.txt", "target.txt")
+			err = fs.Rename("source.txt", "target.txt")
 			g.Assert(err).IsNotNil()
 			g.Assert(errors.Is(err, os.ErrExist)).IsTrue()
 		})
@@ -295,7 +306,7 @@ func TestFilesystem_Rename(t *testing.T) {
 		})

 		g.It("returns an error if the source destination is the root directory", func() {
-			err := fs.Rename("/", "destination.txt")
+			err := fs.Rename("source.txt", "/")
 			g.Assert(err).IsNotNil()
 			g.Assert(errors.Is(err, os.ErrExist)).IsTrue()
 		})
@@ -303,42 +314,43 @@ func TestFilesystem_Rename(t *testing.T) {
 		g.It("does not allow renaming to a location outside the root", func() {
 			err := fs.Rename("source.txt", "../target.txt")
 			g.Assert(err).IsNotNil()
-			g.Assert(IsPathError(err)).IsTrue()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
 		})

 		g.It("does not allow renaming from a location outside the root", func() {
-			err := fs.Rename("../ext-source.txt", "target.txt")
+			err := rfs.CreateServerFileFromString("/../ext-source.txt", "taget content")
+
+			err = fs.Rename("/../ext-source.txt", "target.txt")
 			g.Assert(err).IsNotNil()
-			g.Assert(IsLinkError(err)).IsTrue()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
 		})

 		g.It("allows a file to be renamed", func() {
 			err := fs.Rename("source.txt", "target.txt")
 			g.Assert(err).IsNil()

-			_, err = os.Stat(filepath.Join(fs.rootPath, "source.txt"))
+			_, err = rfs.StatServerFile("source.txt")
 			g.Assert(err).IsNotNil()
 			g.Assert(errors.Is(err, os.ErrNotExist)).IsTrue()

-			st, err := os.Stat(filepath.Join(fs.rootPath, "target.txt"))
+			st, err := rfs.StatServerFile("target.txt")
 			g.Assert(err).IsNil()
 			g.Assert(st.Name()).Equal("target.txt")
 			g.Assert(st.Size()).IsNotZero()
 		})

 		g.It("allows a folder to be renamed", func() {
-			if err := os.Mkdir(filepath.Join(fs.rootPath, "/source_dir"), 0o755); err != nil {
-				panic(err)
-			}
-
-			err := fs.Rename("source_dir", "target_dir")
+			err := os.Mkdir(filepath.Join(rfs.root, "/server/source_dir"), 0o755)
 			g.Assert(err).IsNil()

-			_, err = os.Stat(filepath.Join(fs.rootPath, "source_dir"))
+			err = fs.Rename("source_dir", "target_dir")
+			g.Assert(err).IsNil()
+
+			_, err = rfs.StatServerFile("source_dir")
 			g.Assert(err).IsNotNil()
 			g.Assert(errors.Is(err, os.ErrNotExist)).IsTrue()

-			st, err := os.Stat(filepath.Join(fs.rootPath, "target_dir"))
+			st, err := rfs.StatServerFile("target_dir")
 			g.Assert(err).IsNil()
 			g.Assert(st.IsDir()).IsTrue()
 		})
@@ -353,24 +365,27 @@ func TestFilesystem_Rename(t *testing.T) {
 			err := fs.Rename("source.txt", "nested/folder/target.txt")
 			g.Assert(err).IsNil()

-			st, err := os.Stat(filepath.Join(fs.rootPath, "nested/folder/target.txt"))
+			st, err := rfs.StatServerFile("nested/folder/target.txt")
 			g.Assert(err).IsNil()
 			g.Assert(st.Name()).Equal("target.txt")
 		})

 		g.AfterEach(func() {
-			fs.reset()
+			rfs.reset()
 		})
 	})
 }

 func TestFilesystem_Copy(t *testing.T) {
 	g := Goblin(t)
-	fs := NewFs()
+	fs, rfs := NewFs()

 	g.Describe("Copy", func() {
 		g.BeforeEach(func() {
-			fs.write("source.txt", []byte("text content"))
+			if err := rfs.CreateServerFileFromString("source.txt", "text content"); err != nil {
+				panic(err)
+			}
+
 			atomic.StoreInt64(&fs.diskUsed, int64(utf8.RuneCountInString("test content")))
 		})

@@ -381,23 +396,31 @@ func TestFilesystem_Copy(t *testing.T) {
 		})

 		g.It("should return an error if the source is outside the root", func() {
-			err := fs.Copy("../ext-source.txt")
+			err := rfs.CreateServerFileFromString("/../ext-source.txt", "text content")
+
+			err = fs.Copy("../ext-source.txt")
 			g.Assert(err).IsNotNil()
-			g.Assert(IsPathError(err)).IsTrue()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
 		})

 		g.It("should return an error if the source directory is outside the root", func() {
-			err := fs.Copy("../nested/in/dir/ext-source.txt")
+			err := os.MkdirAll(filepath.Join(rfs.root, "/nested/in/dir"), 0o755)
+			g.Assert(err).IsNil()
+
+			err = rfs.CreateServerFileFromString("/../nested/in/dir/ext-source.txt", "external content")
+			g.Assert(err).IsNil()
+
+			err = fs.Copy("../nested/in/dir/ext-source.txt")
 			g.Assert(err).IsNotNil()
-			g.Assert(IsPathError(err)).IsTrue()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()

 			err = fs.Copy("nested/in/../../../nested/in/dir/ext-source.txt")
 			g.Assert(err).IsNotNil()
-			g.Assert(IsPathError(err)).IsTrue()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
 		})

 		g.It("should return an error if the source is a directory", func() {
-			err := os.Mkdir(filepath.Join(fs.rootPath, "/dir"), 0o755)
+			err := os.Mkdir(filepath.Join(rfs.root, "/server/dir"), 0o755)
 			g.Assert(err).IsNil()

 			err = fs.Copy("dir")
@@ -417,10 +440,10 @@ func TestFilesystem_Copy(t *testing.T) {
 			err := fs.Copy("source.txt")
 			g.Assert(err).IsNil()

-			_, err = os.Stat(filepath.Join(fs.rootPath, "source.txt"))
+			_, err = rfs.StatServerFile("source.txt")
 			g.Assert(err).IsNil()

-			_, err = os.Stat(filepath.Join(fs.rootPath, "source copy.txt"))
+			_, err = rfs.StatServerFile("source copy.txt")
 			g.Assert(err).IsNil()
 		})

@@ -434,7 +457,7 @@ func TestFilesystem_Copy(t *testing.T) {
 			r := []string{"source.txt", "source copy.txt", "source copy 1.txt"}

 			for _, name := range r {
-				_, err = os.Stat(filepath.Join(fs.rootPath, name))
+				_, err = rfs.StatServerFile(name)
 				g.Assert(err).IsNil()
 			}

@@ -442,24 +465,24 @@ func TestFilesystem_Copy(t *testing.T) {
 		})

 		g.It("should create a copy inside of a directory", func() {
-			if err := os.MkdirAll(filepath.Join(fs.rootPath, "/nested/in/dir"), 0o755); err != nil {
-				panic(err)
-			}
-
-			fs.write("nested/in/dir/source.txt", []byte("test content"))
-
-			err := fs.Copy("nested/in/dir/source.txt")
+			err := os.MkdirAll(filepath.Join(rfs.root, "/server/nested/in/dir"), 0o755)
 			g.Assert(err).IsNil()

-			_, err = os.Stat(filepath.Join(fs.rootPath, "nested/in/dir/source.txt"))
+			err = rfs.CreateServerFileFromString("nested/in/dir/source.txt", "test content")
 			g.Assert(err).IsNil()

-			_, err = os.Stat(filepath.Join(fs.rootPath, "nested/in/dir/source copy.txt"))
+			err = fs.Copy("nested/in/dir/source.txt")
+			g.Assert(err).IsNil()
+
+			_, err = rfs.StatServerFile("nested/in/dir/source.txt")
+			g.Assert(err).IsNil()
+
+			_, err = rfs.StatServerFile("nested/in/dir/source copy.txt")
 			g.Assert(err).IsNil()
 		})

 		g.AfterEach(func() {
-			fs.reset()
+			rfs.reset()

 			atomic.StoreInt64(&fs.diskUsed, 0)
 			atomic.StoreInt64(&fs.diskLimit, 0)
@@ -467,115 +490,38 @@ func TestFilesystem_Copy(t *testing.T) {
 	})
 }

-func TestFilesystem_Symlink(t *testing.T) {
-	g := Goblin(t)
-	fs := NewFs()
-
-	g.Describe("Symlink", func() {
-		g.It("should create a symlink", func() {
-			fs.write("source.txt", []byte("text content"))
-
-			err := fs.Symlink("source.txt", "symlink.txt")
-			g.Assert(err).IsNil()
-
-			st, err := os.Lstat(filepath.Join(fs.rootPath, "symlink.txt"))
-			g.Assert(err).IsNil()
-			g.Assert(st.Mode()&os.ModeSymlink != 0).IsTrue()
-		})
-
-		g.It("should return an error if the source is outside the root", func() {
-			err := fs.Symlink("../source.txt", "symlink.txt")
-			g.Assert(err).IsNotNil()
-			g.Assert(IsPathError(err)).IsTrue()
-		})
-
-		g.It("should return an error if the dest is outside the root", func() {
-			fs.write("source.txt", []byte("text content"))
-
-			err := fs.Symlink("source.txt", "../symlink.txt")
-			g.Assert(err).IsNotNil()
-			g.Assert(IsLinkError(err)).IsTrue()
-		})
-
-		g.AfterEach(func() {
-			fs.reset()
-		})
-	})
-}
-
-func TestFilesystem_ReadDir(t *testing.T) {
-	g := Goblin(t)
-	fs := NewFs()
-
-	g.Describe("ReadDir", func() {
-		g.Before(func() {
-			if err := os.Mkdir(filepath.Join(fs.rootPath, "child"), 0o755); err != nil {
-				panic(err)
-			}
-
-			fs.write("one.txt", []byte("one"))
-			fs.write("two.txt", []byte("two"))
-			fs.write("child/three.txt", []byte("two"))
-		})
-
-		g.After(func() {
-			fs.reset()
-		})
-
-		g.It("should return the contents of the root directory", func() {
-			d, err := fs.ReadDir("/")
-			g.Assert(err).IsNil()
-			g.Assert(len(d)).Equal(3)
-
-			// os.Root#ReadDir sorts them by name.
-			g.Assert(d[0].Name()).Equal("child")
-			g.Assert(d[0].IsDir()).IsTrue()
-			g.Assert(d[1].Name()).Equal("one.txt")
-			g.Assert(d[2].Name()).Equal("two.txt")
-		})
-
-		g.It("should return the contents of a child directory", func() {
-			d, err := fs.ReadDir("child")
-			g.Assert(err).IsNil()
-			g.Assert(len(d)).Equal(1)
-			g.Assert(d[0].Name()).Equal("three.txt")
-		})
-
-		g.It("should return an error if the directory is outside the root", func() {
-			_, err := fs.ReadDir("../server")
-			g.Assert(err).IsNotNil()
-			g.Assert(IsPathError(err)).IsTrue()
-		})
-	})
-}
-
 func TestFilesystem_Delete(t *testing.T) {
 	g := Goblin(t)
-	fs := NewFs()
+	fs, rfs := NewFs()

 	g.Describe("Delete", func() {
 		g.BeforeEach(func() {
-			fs.write("source.txt", []byte("text content"))
+			if err := rfs.CreateServerFileFromString("source.txt", "test content"); err != nil {
+				panic(err)
+			}
+
 			atomic.StoreInt64(&fs.diskUsed, int64(utf8.RuneCountInString("test content")))
 		})

 		g.It("does not delete files outside the root directory", func() {
-			err := fs.Delete("../ext-source.txt")
+			err := rfs.CreateServerFileFromString("/../ext-source.txt", "external content")
+
+			err = fs.Delete("../ext-source.txt")
 			g.Assert(err).IsNotNil()
-			g.Assert(IsPathError(err)).IsTrue()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
 		})

 		g.It("does not allow the deletion of the root directory", func() {
 			err := fs.Delete("/")
 			g.Assert(err).IsNotNil()
-			g.Assert(err.Error()).Equal("server/filesystem: delete: cannot delete root directory")
+			g.Assert(err.Error()).Equal("cannot delete root server directory")
 		})

 		g.It("does not return an error if the target does not exist", func() {
 			err := fs.Delete("missing.txt")
 			g.Assert(err).IsNil()

-			st, err := os.Stat(filepath.Join(fs.rootPath, "source.txt"))
+			st, err := rfs.StatServerFile("source.txt")
 			g.Assert(err).IsNil()
 			g.Assert(st.Name()).Equal("source.txt")
 		})
@@ -584,7 +530,7 @@ func TestFilesystem_Delete(t *testing.T) {
 			err := fs.Delete("source.txt")
 			g.Assert(err).IsNil()

-			_, err = os.Stat(filepath.Join(fs.rootPath, "source.txt"))
+			_, err = rfs.StatServerFile("source.txt")
 			g.Assert(err).IsNotNil()
 			g.Assert(errors.Is(err, os.ErrNotExist)).IsTrue()

@@ -598,106 +544,29 @@ func TestFilesystem_Delete(t *testing.T) {
 				"foo/bar/baz/source.txt",
 			}

-			if err := os.MkdirAll(filepath.Join(fs.rootPath, "/foo/bar/baz"), 0o755); err != nil {
-				panic(err)
-			}
+			err := os.MkdirAll(filepath.Join(rfs.root, "/server/foo/bar/baz"), 0o755)
+			g.Assert(err).IsNil()

 			for _, s := range sources {
-				fs.write(s, []byte("test content"))
+				err = rfs.CreateServerFileFromString(s, "test content")
+				g.Assert(err).IsNil()
 			}

 			atomic.StoreInt64(&fs.diskUsed, int64(utf8.RuneCountInString("test content")*3))

-			err := fs.Delete("foo")
+			err = fs.Delete("foo")
 			g.Assert(err).IsNil()
 			g.Assert(atomic.LoadInt64(&fs.diskUsed)).Equal(int64(0))

 			for _, s := range sources {
-				_, err = os.Stat(filepath.Join(fs.rootPath, s))
+				_, err = rfs.StatServerFile(s)
 				g.Assert(err).IsNotNil()
 				g.Assert(errors.Is(err, os.ErrNotExist)).IsTrue()
 			}
 		})

-		g.It("deletes a symlink but not it's target within the root directory", func() {
-			// Symlink to a file inside the root server data directory.
-			if err := os.Symlink(filepath.Join(fs.rootPath, "source.txt"), filepath.Join(fs.rootPath, "symlink.txt")); err != nil {
-				panic(err)
-			}
-
-			// Delete the symlink itself.
-			err := fs.Delete("symlink.txt")
-			g.Assert(err).IsNil()
-
-			// Ensure the symlink was deleted.
-			_, err = os.Lstat(filepath.Join(fs.rootPath, "symlink.txt"))
-			g.Assert(err).IsNotNil()
-
-			// Ensure the symlink target still exists.
-			_, err = os.Lstat(filepath.Join(fs.rootPath, "source.txt"))
-			g.Assert(err).IsNil()
-		})
-
-		g.It("does not delete files symlinked outside of the root directory", func() {
-			// Create a file outside the root directory.
-			fs.write("../external.txt", []byte("test content"))
-
-			// Create a symlink to the file outside the root directory.
-			if err := os.Symlink(filepath.Join(fs.rootPath, "../external.txt"), filepath.Join(fs.rootPath, "symlink.txt")); err != nil {
-				panic(err)
-			}
-
-			// Delete the symlink. (This should pass as we will delete the symlink itself, not the target)
-			err := fs.Delete("symlink.txt")
-			g.Assert(err).IsNil()
-
-			// Ensure the file outside the root directory still exists.
-			_, err = os.Lstat(filepath.Join(fs.rootPath, "../external.txt"))
-			g.Assert(err).IsNil()
-		})
-
-		g.It("does not delete files symlinked through a directory outside of the root directory", func() {
-			// Create a directory outside the root directory.
-			if err := os.Mkdir(filepath.Join(fs.rootPath, "../external"), 0o755); err != nil {
-				panic(err)
-			}
-
-			fs.write("../external/source.txt", []byte("test content"))
-
-			// Symlink the directory that is outside the root to a file inside the root.
-			if err := os.Symlink(filepath.Join(fs.rootPath, "../external"), filepath.Join(fs.rootPath, "/symlink")); err != nil {
-				panic(err)
-			}
-
-			// Delete a file inside the symlinked directory.
-			err := fs.Delete("symlink/source.txt")
-			g.Assert(err).IsNotNil()
-			g.Assert(IsPathError(err)).IsTrue()
-
-			// Ensure the file outside the root directory still exists.
-			_, err = os.Lstat(filepath.Join(fs.rootPath, "../external/source.txt"))
-			g.Assert(err).IsNil()
-		})
-
-		g.It("returns an error when trying to delete a non-existent file symlinked through a directory outside of the root directory", func() {
-			// Create a directory outside the root directory.
-			if err := os.Mkdir(filepath.Join(fs.rootPath, "../external"), 0o755); err != nil {
-				panic(err)
-			}
-
-			// Symlink the directory that is outside the root to a file inside the root.
-			if err := os.Symlink(filepath.Join(fs.rootPath, "../external"), filepath.Join(fs.rootPath, "/symlink")); err != nil {
-				panic(err)
-			}
-
-			// Delete a file inside the symlinked directory.
-			err := fs.Delete("symlink/source.txt")
-			g.Assert(err).IsNotNil()
-			g.Assert(IsPathError(err)).IsTrue()
-		})
-
 		g.AfterEach(func() {
-			fs.reset()
+			rfs.reset()

 			atomic.StoreInt64(&fs.diskUsed, 0)
 			atomic.StoreInt64(&fs.diskLimit, 0)
--- a/server/filesystem/path.go
+++ b/server/filesystem/path.go
@@ -1,16 +1,158 @@
 package filesystem

 import (
+	"context"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+
 	"emperror.dev/errors"
+	"golang.org/x/sync/errgroup"
 )

-// IsIgnored checks if the given file or path is in the server's file denylist. If so, an Error
+// Checks if the given file or path is in the server's file denylist. If so, an Error
 // is returned, otherwise nil is returned.
 func (fs *Filesystem) IsIgnored(paths ...string) error {
 	for _, p := range paths {
-		if fs.denylist.MatchesPath(p) {
-			return errors.WithStack(&Error{code: ErrCodeDenylistFile, path: p})
+		sp, err := fs.SafePath(p)
+		if err != nil {
+			return err
+		}
+		if fs.denylist.MatchesPath(sp) {
+			return errors.WithStack(&Error{code: ErrCodeDenylistFile, path: p, resolved: sp})
 		}
 	}
 	return nil
 }
+
+// Normalizes a directory being passed in to ensure the user is not able to escape
+// from their data directory. After normalization if the directory is still within their home
+// path it is returned. If they managed to "escape" an error will be returned.
+//
+// This logic is actually copied over from the SFTP server code. Ideally that eventually
+// either gets ported into this application, or is able to make use of this package.
+func (fs *Filesystem) SafePath(p string) (string, error) {
+	var nonExistentPathResolution string
+
+	// Start with a cleaned up path before checking the more complex bits.
+	r := fs.unsafeFilePath(p)
+
+	// At the same time, evaluate the symlink status and determine where this file or folder
+	// is truly pointing to.
+	ep, err := filepath.EvalSymlinks(r)
+	if err != nil && !os.IsNotExist(err) {
+		return "", errors.Wrap(err, "server/filesystem: failed to evaluate symlink")
+	} else if os.IsNotExist(err) {
+		// The requested directory doesn't exist, so at this point we need to iterate up the
+		// path chain until we hit a directory that _does_ exist and can be validated.
+		parts := strings.Split(filepath.Dir(r), "/")
+
+		var try string
+		// Range over all of the path parts and form directory pathings from the end
+		// moving up until we have a valid resolution or we run out of paths to try.
+		for k := range parts {
+			try = strings.Join(parts[:(len(parts)-k)], "/")
+
+			if !fs.unsafeIsInDataDirectory(try) {
+				break
+			}
+
+			t, err := filepath.EvalSymlinks(try)
+			if err == nil {
+				nonExistentPathResolution = t
+				break
+			}
+		}
+	}
+
+	// If the new path doesn't start with their root directory there is clearly an escape
+	// attempt going on, and we should NOT resolve this path for them.
+	if nonExistentPathResolution != "" {
+		if !fs.unsafeIsInDataDirectory(nonExistentPathResolution) {
+			return "", NewBadPathResolution(p, nonExistentPathResolution)
+		}
+
+		// If the nonExistentPathResolution variable is not empty then the initial path requested
+		// did not exist and we looped through the pathway until we found a match. At this point
+		// we've confirmed the first matched pathway exists in the root server directory, so we
+		// can go ahead and just return the path that was requested initially.
+		return r, nil
+	}
+
+	// If the requested directory from EvalSymlinks begins with the server root directory go
+	// ahead and return it. If not we'll return an error which will block any further action
+	// on the file.
+	if fs.unsafeIsInDataDirectory(ep) {
+		return ep, nil
+	}
+
+	return "", NewBadPathResolution(p, r)
+}
+
+// Generate a path to the file by cleaning it up and appending the root server path to it. This
+// DOES NOT guarantee that the file resolves within the server data directory. You'll want to use
+// the fs.unsafeIsInDataDirectory(p) function to confirm.
+func (fs *Filesystem) unsafeFilePath(p string) string {
+	// Calling filepath.Clean on the joined directory will resolve it to the absolute path,
+	// removing any ../ type of resolution arguments, and leaving us with a direct path link.
+	//
+	// This will also trim the existing root path off the beginning of the path passed to
+	// the function since that can get a bit messy.
+	return filepath.Clean(filepath.Join(fs.Path(), strings.TrimPrefix(p, fs.Path())))
+}
+
+// Check that that path string starts with the server data directory path. This function DOES NOT
+// validate that the rest of the path does not end up resolving out of this directory, or that the
+// targeted file or folder is not a symlink doing the same thing.
+func (fs *Filesystem) unsafeIsInDataDirectory(p string) bool {
+	return strings.HasPrefix(strings.TrimSuffix(p, "/")+"/", strings.TrimSuffix(fs.Path(), "/")+"/")
+}
+
+// Executes the fs.SafePath function in parallel against an array of paths. If any of the calls
+// fails an error will be returned.
+func (fs *Filesystem) ParallelSafePath(paths []string) ([]string, error) {
+	var cleaned []string
+
+	// Simple locker function to avoid racy appends to the array of cleaned paths.
+	m := new(sync.Mutex)
+	push := func(c string) {
+		m.Lock()
+		cleaned = append(cleaned, c)
+		m.Unlock()
+	}
+
+	// Create an error group that we can use to run processes in parallel while retaining
+	// the ability to cancel the entire process immediately should any of it fail.
+	g, ctx := errgroup.WithContext(context.Background())
+
+	// Iterate over all of the paths and generate a cleaned path, if there is an error for any
+	// of the files, abort the process.
+	for _, p := range paths {
+		// Create copy so we can use it within the goroutine correctly.
+		pi := p
+
+		// Recursively call this function to continue digging through the directory tree within
+		// a separate goroutine. If the context is canceled abort this process.
+		g.Go(func() error {
+			select {
+			case <-ctx.Done():
+				return ctx.Err()
+			default:
+				// If the callback returns true, go ahead and keep walking deeper. This allows
+				// us to programmatically continue deeper into directories, or stop digging
+				// if that pathway knows it needs nothing else.
+				if c, err := fs.SafePath(pi); err != nil {
+					return err
+				} else {
+					push(c)
+				}
+
+				return nil
+			}
+		})
+	}
+
+	// Block until all of the routines finish and have returned a value.
+	return cleaned, g.Wait()
+}
--- a/server/filesystem/path_test.go
+++ b/server/filesystem/path_test.go
@@ -12,11 +12,85 @@ import (

 func TestFilesystem_Path(t *testing.T) {
 	g := Goblin(t)
-	fs := NewFs()
+	fs, rfs := NewFs()

 	g.Describe("Path", func() {
 		g.It("returns the root path for the instance", func() {
-			g.Assert(fs.Path()).Equal(fs.rootPath)
+			g.Assert(fs.Path()).Equal(filepath.Join(rfs.root, "/server"))
+		})
+	})
+}
+
+func TestFilesystem_SafePath(t *testing.T) {
+	g := Goblin(t)
+	fs, rfs := NewFs()
+	prefix := filepath.Join(rfs.root, "/server")
+
+	g.Describe("SafePath", func() {
+		g.It("returns a cleaned path to a given file", func() {
+			p, err := fs.SafePath("test.txt")
+			g.Assert(err).IsNil()
+			g.Assert(p).Equal(prefix + "/test.txt")
+
+			p, err = fs.SafePath("/test.txt")
+			g.Assert(err).IsNil()
+			g.Assert(p).Equal(prefix + "/test.txt")
+
+			p, err = fs.SafePath("./test.txt")
+			g.Assert(err).IsNil()
+			g.Assert(p).Equal(prefix + "/test.txt")
+
+			p, err = fs.SafePath("/foo/../test.txt")
+			g.Assert(err).IsNil()
+			g.Assert(p).Equal(prefix + "/test.txt")
+
+			p, err = fs.SafePath("/foo/bar")
+			g.Assert(err).IsNil()
+			g.Assert(p).Equal(prefix + "/foo/bar")
+		})
+
+		g.It("handles root directory access", func() {
+			p, err := fs.SafePath("/")
+			g.Assert(err).IsNil()
+			g.Assert(p).Equal(prefix)
+
+			p, err = fs.SafePath("")
+			g.Assert(err).IsNil()
+			g.Assert(p).Equal(prefix)
+		})
+
+		g.It("removes trailing slashes from paths", func() {
+			p, err := fs.SafePath("/foo/bar/")
+			g.Assert(err).IsNil()
+			g.Assert(p).Equal(prefix + "/foo/bar")
+		})
+
+		g.It("handles deeply nested directories that do not exist", func() {
+			p, err := fs.SafePath("/foo/bar/baz/quaz/../../ducks/testing.txt")
+			g.Assert(err).IsNil()
+			g.Assert(p).Equal(prefix + "/foo/bar/ducks/testing.txt")
+		})
+
+		g.It("blocks access to files outside the root directory", func() {
+			p, err := fs.SafePath("../test.txt")
+			g.Assert(err).IsNotNil()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
+			g.Assert(p).Equal("")
+
+			p, err = fs.SafePath("/../test.txt")
+			g.Assert(err).IsNotNil()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
+			g.Assert(p).Equal("")
+
+			p, err = fs.SafePath("./foo/../../test.txt")
+			g.Assert(err).IsNotNil()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
+			g.Assert(p).Equal("")
+
+			p, err = fs.SafePath("..")
+			g.Assert(err).IsNotNil()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
+			g.Assert(p).Equal("")
 		})
 	})
 }
@@ -27,49 +101,41 @@ func TestFilesystem_Path(t *testing.T) {
 // the calls and ensure they all fail with the same reason.
 func TestFilesystem_Blocks_Symlinks(t *testing.T) {
 	g := Goblin(t)
-	fs := NewFs()
+	fs, rfs := NewFs()

-	fs.write("../malicious.txt", []byte("external content"))
-	if err := os.Mkdir(filepath.Join(fs.rootPath, "../malicious_dir"), 0o777); err != nil {
+	if err := rfs.CreateServerFileFromString("/../malicious.txt", "external content"); err != nil {
 		panic(err)
 	}

-	links := map[string]string{
-		"../malicious.txt":                "/symlinked.txt",
-		"../malicious_does_not_exist.txt": "/symlinked_does_not_exist.txt",
-		"/symlinked_does_not_exist.txt":   "/symlinked_does_not_exist2.txt",
-		"../malicious_dir":                "/external_dir",
+	if err := os.Mkdir(filepath.Join(rfs.root, "/malicious_dir"), 0o777); err != nil {
+		panic(err)
 	}

-	for src, dst := range links {
-		if err := os.Symlink(filepath.Join(fs.rootPath, src), filepath.Join(fs.rootPath, dst)); err != nil {
-			panic(err)
-		}
+	if err := os.Symlink(filepath.Join(rfs.root, "malicious.txt"), filepath.Join(rfs.root, "/server/symlinked.txt")); err != nil {
+		panic(err)
 	}

+	if err := os.Symlink(filepath.Join(rfs.root, "/malicious_dir"), filepath.Join(rfs.root, "/server/external_dir")); err != nil {
+		panic(err)
+	}
+
+	g.Describe("Readfile", func() {
+		g.It("cannot read a file symlinked outside the root", func() {
+			b := bytes.Buffer{}
+
+			err := fs.Readfile("symlinked.txt", &b)
+			g.Assert(err).IsNotNil()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
+		})
+	})
+
 	g.Describe("Writefile", func() {
 		g.It("cannot write to a file symlinked outside the root", func() {
 			r := bytes.NewReader([]byte("testing"))

 			err := fs.Writefile("symlinked.txt", r)
 			g.Assert(err).IsNotNil()
-			g.Assert(IsPathError(err)).IsTrue()
-		})
-
-		g.It("cannot write to a non-existent file symlinked outside the root", func() {
-			r := bytes.NewReader([]byte("testing what the fuck"))
-
-			err := fs.Writefile("symlinked_does_not_exist.txt", r)
-			g.Assert(err).IsNotNil()
-			g.Assert(IsPathError(err)).IsTrue()
-		})
-
-		g.It("cannot write to chained symlinks with target that does not exist outside the root", func() {
-			r := bytes.NewReader([]byte("testing what the fuck"))
-
-			err := fs.Writefile("symlinked_does_not_exist2.txt", r)
-			g.Assert(err).IsNotNil()
-			g.Assert(IsPathError(err)).IsTrue()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
 		})

 		g.It("cannot write a file to a directory symlinked outside the root", func() {
@@ -77,7 +143,7 @@ func TestFilesystem_Blocks_Symlinks(t *testing.T) {

 			err := fs.Writefile("external_dir/foo.txt", r)
 			g.Assert(err).IsNotNil()
-			g.Assert(IsPathError(err)).IsTrue()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
 		})
 	})

@@ -85,61 +151,41 @@ func TestFilesystem_Blocks_Symlinks(t *testing.T) {
 		g.It("cannot create a directory outside the root", func() {
 			err := fs.CreateDirectory("my_dir", "external_dir")
 			g.Assert(err).IsNotNil()
-			g.Assert(IsPathError(err)).IsTrue()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
 		})

 		g.It("cannot create a nested directory outside the root", func() {
-			err := fs.CreateDirectory("my/nested/dir", "../external_dir/foo/bar")
+			err := fs.CreateDirectory("my/nested/dir", "external_dir/foo/bar")
 			g.Assert(err).IsNotNil()
-			g.Assert(IsPathError(err)).IsTrue()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
 		})

 		g.It("cannot create a nested directory outside the root", func() {
-			err := fs.CreateDirectory("my/nested/dir", "../external_dir/server")
+			err := fs.CreateDirectory("my/nested/dir", "external_dir/server")
 			g.Assert(err).IsNotNil()
-			g.Assert(IsPathError(err)).IsTrue()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
 		})
 	})

 	g.Describe("Rename", func() {
-		// You can rename the symlink file itself, which does not impact the
-		// underlying symlinked target file outside the server directory.
-		g.It("can rename a file symlinked outside the directory root", func() {
+		g.It("cannot rename a file symlinked outside the directory root", func() {
 			err := fs.Rename("symlinked.txt", "foo.txt")
-			g.Assert(err).IsNil()
-
-			st, err := os.Lstat(filepath.Join(fs.rootPath, "foo.txt"))
-			g.Assert(err).IsNil()
-			g.Assert(st.Mode()&os.ModeSymlink != 0).IsTrue()
-
-			st, err = os.Lstat(filepath.Join(fs.rootPath, "../malicious.txt"))
-			g.Assert(err).IsNil()
-			g.Assert(st.Mode()&os.ModeSymlink == 0).IsTrue()
+			g.Assert(err).IsNotNil()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
 		})

-		// The same as above, acts on the source directory and not the target directory,
-		// therefore, this is allowed.
-		g.It("can rename a directory symlinked outside the root", func() {
+		g.It("cannot rename a symlinked directory outside the root", func() {
 			err := fs.Rename("external_dir", "foo")
-			g.Assert(err).IsNil()
-
-			st, err := os.Lstat(filepath.Join(fs.rootPath, "foo"))
-			g.Assert(err).IsNil()
-			g.Assert(st.IsDir()).IsTrue()
-			g.Assert(st.Mode()&os.ModeSymlink != 0).IsTrue()
-
-			st, err = os.Lstat(filepath.Join(fs.rootPath, "../external_dir"))
-			g.Assert(err).IsNil()
-			g.Assert(st.IsDir()).IsTrue()
-			g.Assert(st.Mode()&os.ModeSymlink == 0).IsTrue()
+			g.Assert(err).IsNotNil()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
 		})

 		g.It("cannot rename a file to a location outside the directory root", func() {
-			fs.write("my_file.txt", []byte("internal content"))
+			rfs.CreateServerFileFromString("my_file.txt", "internal content")

-			err := fs.Rename("my_file.txt", "../external_dir/my_file.txt")
+			err := fs.Rename("my_file.txt", "external_dir/my_file.txt")
 			g.Assert(err).IsNotNil()
-			g.Assert(IsPathError(err)).IsTrue()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
 		})
 	})

@@ -147,13 +193,13 @@ func TestFilesystem_Blocks_Symlinks(t *testing.T) {
 		g.It("cannot chown a file symlinked outside the directory root", func() {
 			err := fs.Chown("symlinked.txt")
 			g.Assert(err).IsNotNil()
-			g.Assert(IsPathError(err)).IsTrue()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
 		})

 		g.It("cannot chown a directory symlinked outside the directory root", func() {
 			err := fs.Chown("external_dir")
 			g.Assert(err).IsNotNil()
-			g.Assert(IsPathError(err)).IsTrue()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
 		})
 	})

@@ -161,7 +207,7 @@ func TestFilesystem_Blocks_Symlinks(t *testing.T) {
 		g.It("cannot copy a file symlinked outside the directory root", func() {
 			err := fs.Copy("symlinked.txt")
 			g.Assert(err).IsNotNil()
-			g.Assert(IsPathError(err)).IsTrue()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
 		})
 	})

@@ -170,14 +216,14 @@ func TestFilesystem_Blocks_Symlinks(t *testing.T) {
 			err := fs.Delete("symlinked.txt")
 			g.Assert(err).IsNil()

-			_, err = os.Stat(filepath.Join(fs.rootPath, "../malicious.txt"))
+			_, err = os.Stat(filepath.Join(rfs.root, "malicious.txt"))
 			g.Assert(err).IsNil()

-			_, err = os.Stat(filepath.Join(fs.rootPath, "symlinked.txt"))
+			_, err = rfs.StatServerFile("symlinked.txt")
 			g.Assert(err).IsNotNil()
 			g.Assert(errors.Is(err, os.ErrNotExist)).IsTrue()
 		})
 	})

-	fs.reset()
+	rfs.reset()
 }
--- a/server/filesystem/stat.go
+++ b/server/filesystem/stat.go
@@ -5,7 +5,6 @@ import (
 	"strconv"
 	"time"

-	"emperror.dev/errors"
 	"github.com/gabriel-vasile/mimetype"
 	"github.com/goccy/go-json"
 )
@@ -37,7 +36,7 @@ func (s *Stat) MarshalJSON() ([]byte, error) {
 		Size:      s.Size(),
 		Directory: s.IsDir(),
 		File:      !s.IsDir(),
-		Symlink:   s.Mode().Type()&os.ModeSymlink != 0,
+		Symlink:   s.Mode().Perm()&os.ModeSymlink != 0,
 		Mime:      s.Mimetype,
 	})
 }
@@ -45,22 +44,24 @@ func (s *Stat) MarshalJSON() ([]byte, error) {
 // Stat stats a file or folder and returns the base stat object from go along
 // with the MIME data that can be used for editing files.
 func (fs *Filesystem) Stat(p string) (Stat, error) {
-	p = normalize(p)
-	s, err := fs.root.Stat(p)
+	cleaned, err := fs.SafePath(p)
 	if err != nil {
-		return Stat{}, errors.Wrap(err, "server/filesystem: stat: failed to stat file")
+		return Stat{}, err
+	}
+	return fs.unsafeStat(cleaned)
+}
+
+func (fs *Filesystem) unsafeStat(p string) (Stat, error) {
+	s, err := os.Stat(p)
+	if err != nil {
+		return Stat{}, err
 	}

 	var m *mimetype.MIME
 	if !s.IsDir() {
-		f, err := fs.root.Open(p)
+		m, err = mimetype.DetectFile(p)
 		if err != nil {
-			return Stat{}, errors.Wrap(err, "server/filesystem: stat: failed to open file")
-		}
-		defer f.Close()
-		m, err = mimetype.DetectReader(f)
-		if err != nil {
-			return Stat{}, errors.Wrap(err, "server/filesystem: stat: failed to detect mimetype")
+			return Stat{}, err
 		}
 	}

@@ -74,11 +75,3 @@ func (fs *Filesystem) Stat(p string) (Stat, error) {

 	return st, nil
 }
-
-func (fs *Filesystem) Stat2(p string) (os.FileInfo, error) {
-	st, err := fs.root.Stat(normalize(p))
-	if err != nil {
-		return st, errors.Wrap(err, "server/filesystem: stat2: failed to stat file")
-	}
-	return st, nil
-}
--- a/Show More
+++ b/Show More