Update CHANGELOG.md

Previously we waited for both the request and multipart writer
to "complete", before handing any errors.  This lead to a problem
where if the request returns before all the data has been read,
the upload would become stuck and keep the server in a transferring
state when the transfer should've been aborted.

Closes https://github.com/pterodactyl/panel/issues/4578

.github/FUNDING.yaml

@@ -0,0 +1 @@
+github: [matthewpi]

.github/FUNDING.yml

@@ -1,2 +0,0 @@
-github: [DaneEveritt]
-custom: ["https://paypal.me/PterodactylSoftware"]

.github/workflows/build-test.yml

@@ -1,66 +0,0 @@
-name: Run Tests
-on:
-  push:
-    branches:
-      - 'develop'
-  pull_request:
-    branches:
-      - 'develop'
-jobs:
-  build:
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ ubuntu-20.04 ]
-        go: [ '^1.15', '^1.16' ]
-        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: ${{ matrix.go == '^1.15' && (github.ref == 'refs/heads/develop' || github.event_name == 'pull_request') }}
-        with:
-          name: wings_${{ matrix.goos }}_${{ matrix.goarch }}
-          path: build/wings_${{ matrix.goos }}_${{ matrix.goarch }}

.github/workflows/codeql.yaml

@@ -1,31 +1,42 @@
 name: CodeQL
+
 on:
   push:
     branches:
-      - 'develop'
+      - develop
   pull_request:
     branches:
-      - 'develop'
+      - develop
   schedule:
-    - cron: '0 9 * * 4'
+    - cron: "0 9 * * 4"
+
 jobs:
   analyze:
     name: Analyze
     runs-on: ubuntu-20.04
+
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
     strategy:
       fail-fast: false
       matrix:
         language:
           - go
+
     steps:
       - name: Code Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
-      - name: Checkout Head
+
-        run: git checkout HEAD^2
-        if: ${{ github.event_name == 'pull_request' }}
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v1
+        uses: github/codeql-action/init@v2
         with:
           languages: ${{ matrix.language }}
+
+      - name: Autobuild
+        uses: github/codeql-action/autobuild@v2
+
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v1
+        uses: github/codeql-action/analyze@v2

.github/workflows/docker.yaml

@@ -0,0 +1,78 @@
+name: Docker
+
+on:
+  push:
+    branches:
+      - develop
+  release:
+    types:
+      - published
+
+jobs:
+  build-and-push:
+    name: Build and 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@v3
+
+      - name: Docker metadata
+        id: docker_meta
+        uses: docker/metadata-action@v4
+        with:
+          images: ghcr.io/pterodactyl/wings
+          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@v2
+
+      - name: Setup Docker buildx
+        uses: docker/setup-buildx-action@v2
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.repository_owner }}
+          password: ${{ secrets.REGISTRY_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@v3
+        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@v3
+        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

.github/workflows/docker.yml

@@ -1,57 +0,0 @@
-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\//}"
-          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 }}
-          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 }}
-          push: ${{ github.event_name != 'pull_request' }}
-          tags: ${{ steps.docker_meta.outputs.tags }}

.github/workflows/push.yaml

@@ -0,0 +1,100 @@
+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-20.04]
+        go: ["1.18.10", "1.19.5"]
+        goos: [linux]
+        goarch: [amd64, arm64]
+
+    steps:
+      - name: Setup Go
+        uses: actions/setup-go@v3
+        with:
+          go-version: ${{ matrix.go }}
+
+      - name: Code Checkout
+        uses: actions/checkout@v3
+
+      - name: Gather environment variables
+        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
+          printf "Git Version: $(git version)\n\n"
+          echo "version_tag=${GITHUB_REF/refs\/tags\//}" >> $GITHUB_OUTPUT
+          echo "short_sha=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+          echo "go_cache=$(go env GOCACHE)" >> $GITHUB_OUTPUT
+          echo "go_mod_cache=$(go env GOMODCACHE)" >> $GITHUB_OUTPUT
+
+      - name: Build Cache
+        uses: actions/cache@v3
+        with:
+          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
+          path: |
+            ${{ steps.env.outputs.go_cache }}
+            ${{ steps.env.outputs.go_mod_cache }}
+
+      - 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-${GIT_COMMIT:0:7}" -o dist/wings ${SRC_PATH}
+          go build -v -trimpath -ldflags="-X ${SRC_PATH}/system.Version=dev-${GIT_COMMIT: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@v3
+        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@v3
+        if: ${{ github.ref == 'refs/heads/develop' || github.event_name == 'pull_request' }}
+        with:
+          name: wings_linux_${{ matrix.goarch }}_debug
+          path: dist/wings_debug

.github/workflows/release.yaml

@@ -1,41 +1,47 @@
-name: Create Release
+name: Release
+
 on:
   push:
     tags:
-      - 'v*'
+      - "v*"
+
 jobs:
   release:
+    name: Release
     runs-on: ubuntu-20.04
+
     steps:
       - name: Code Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
-      - uses: actions/setup-go@v2
+
+      - name: Setup Go
+        uses: actions/setup-go@v3
         with:
-          go-version: '^1.15'
+          go-version: "1.18.10"
-      - name: Build
+
+      - name: Build release binaries
         env:
+          CGO_ENABLED: 0
           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
+          GOARCH=amd64 go build -o dist/wings_linux_amd64 -v -trimpath -ldflags="-s -w -X github.com/pterodactyl/wings/system.Version=${REF:11}" github.com/pterodactyl/wings
-          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
+          chmod 755 dist/wings_linux_amd64
-      - name: Test
+          GOARCH=arm64 go build -o dist/wings_linux_arm64 -v -trimpath -ldflags="-s -w -X github.com/pterodactyl/wings/system.Version=${REF:11}" github.com/pterodactyl/wings
-        run: go test ./...
+          chmod 755 dist/wings_linux_arm64
-      - 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`
+          SUM=`cd dist && sha256sum wings_linux_amd64`
-          SUM2=`cd build && sha256sum wings_linux_arm64`
+          SUM2=`cd dist && 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 }}
@@ -45,39 +51,41 @@ jobs:
           git config --local user.name "Pterodactyl CI"
           git checkout -b $BRANCH
           git push -u origin $BRANCH
-          sed -i "s/	Version = \".*\"/	Version = \"${REF:11}\"/" system/const.go
+          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
+
+      - name: Create release
         id: create_release
-        uses: actions/create-release@v1
+        uses: softprops/action-gh-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') }}
+          prerelease: ${{ contains(github.ref, 'rc') || contains(github.ref, 'beta') || contains(github.ref, 'alpha') }}
-      - name: Upload amd64 Binary
+          body_path: ./RELEASE_CHANGELOG
+
+      - 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_path: dist/wings_linux_amd64
           asset_name: wings_linux_amd64
           asset_content_type: application/octet-stream
-      - name: Upload arm64 Binary
+
+      - 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_path: dist/wings_linux_arm64
           asset_name: wings_linux_arm64
           asset_content_type: application/octet-stream
+
       - name: Upload checksum
         uses: actions/upload-release-asset@v1
         env:

.gitignore

@@ -23,6 +23,8 @@
 # ignore configuration file
 /config.yml
 /config*.yml
+/config.yaml
+/config*.yaml
 
 # Ignore Vagrant stuff
 /.vagrant
@@ -49,3 +51,4 @@ debug
 .DS_Store
 *.pprof
 *.pdf
+pprof.*

CHANGELOG.md

@@ -1,5 +1,262 @@
 # Changelog
 
+## 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.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.
+* Fixes files uploaded with SFTP not being owned by the Pterodactyl user.
+* Fixes excessive memory usage when large lines are sent through the console event handler.
+
+### Changed
+* Replaced usage of `encoding/json` throughout the codebase with a more performant encoder (`goccy/go-json`) to hopefully improve overall performance for JSON operations.
+* Added custom `ContainerInspect` function to handle direct calls to Docker's CLI and make use of the new JSON encoder logic. This should reduce the total number of memory allocations and be more performant overall in a hot pathway.
+
+## v1.5.5
+### Fixed
+* Fixes sending to a closed channel when sending server logs over the websocket
+* Fixes `wings diagnostics` uploading no content
+* Fixes a panic caused by the event bus closing channels multiple times when a server is deleted
+
+## v1.5.4
+### Fixed
+* Fixes SSL paths being improperly converted to lowercase in environments where the path is case-sensitive.
+* Fixes a memory leak due to the implemention of server event processing.
+
+### Changed
+* Selecting to redact information now redacts URLs from the log output when running the diagnostic command.
+
+### Added
+* Adds support for modifying the default memory overhead percentages in environments where the shipped values are not adequate.
+* Adds support for sending the `Access-Control-Request-Private-Network` header in environments where Wings will be accessed over a private network. This is defaulted to `off`.
+
+## v1.5.3
+### Fixed
+* 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.
+
+### Changed
+* 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.
+
+## v1.5.2
+### Fixed
+* Fixes servers not properly re-syncing with the Panel if they are already running causing them to be hard-stopped when terminated, rather than stopped with the configured action.
+
+### Changed
+* Changes SFTP server implementation to use ED25519 server keys rather than deprecated SHA1 RSA keys.
+
+### Added
+* Adds server uptime output in the stats event emitted to the websocket.
+
+## v1.5.1
+### Added
+* Global configuration option for toggling server crash detection (`system.crash_detection.enabled`)
+* RPM specfile
+
+## v1.5.0
+### Fixed
+* 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.
+
+### Added
+* Exposes `8080` in the default Docker setup to better support proxy tools.
+
+### Changed
+* 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.
+
+### Removed
+* 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`.
+
+## v1.4.7
+### Fixed
+* SFTP access is now properly denied if a server is suspended.
+* Correctly uses `start_on_completion` and `crash_detection_enabled` for servers.
+
+## v1.4.6
+### Fixed
+* Environment variable starting with the same prefix no longer get merged into a single environment variable value (skipping all but the first).
+* The `start_on_completion` flag for server installs will now properly start the server.
+* Fixes socket files unintentionally causing backups to be aborted.
+* Files extracted from a backup now have their preior mode properly set on the restored files, rather than defaulting to 0644.
+* Fixes logrotate issues due to a bad user configuration on some systems.
+
+### Updated
+* The minimum Go version required to compile Wings is now `go1.16`.
+
+### Deprecated
+> Both of these deprecations will be removed in `Wings@2.0.0`.
+
+* The `Server.Id()` method has been deprecated in favor of `Server.ID()`.
+* The `directory` field on the `/api/servers/:server/files/pull` endpoint is deprecated and should be updated to use `root` instead for consistency with other endpoints.
+
+## v1.4.5
+### Changed
+* Upped the process limit for a container from `256` to `512` in order to address edge-cases for some games that spawn a lot of processes.
+
+## v1.4.4
+### Added
+* **[security]** Adds support for limiting the total number of pids any one container can have active at once to prevent malicious users from impacting other instances on the same node.
+* Server install containers now use the limits assigned to the server, or a globally defined minimum amount of memory and CPU rather than having unlimited resources.
+
+## v1.4.3
+This build was created to address `CVE-2021-33196` in `Go` which requires a new binary
+be built on the latest `go1.15` version.
+
+## v1.4.2
+### Fixed
+* Fixes the `~` character not being properly trimmed from container image names when creating a new server.
+
+### Changed
+* Implemented exponential backoff for S3 uploads when working with backups. This should resolve many issues with external S3 compatiable systems that sometimes return 5xx level errors that should be re-attempted automatically.
+* Implements exponential backoff behavior for all API calls to the Panel that do not immediately return a 401, 403, or 429 error response. This should address fragiligty in some API calls and address random call failures due to connection drops or random DNS resolution errors.
+
+## v1.4.1
+### Fixed
+* Fixes a bug that would cause the file unarchiving process to put all files in the base directory rather than the directory in which the files should be located.
+
 ## v1.4.0
 ### Fixed
 * **[Breaking]** Fixes `/api/servers` and `/api/servers/:server` not properly returning all of the relevant server information and resource usage.

Dockerfile

@@ -1,22 +1,25 @@
 # Stage 1 (Build)
-FROM golang:1.15-alpine3.12 AS builder
+FROM golang:1.18-alpine AS builder
 
 ARG VERSION
-RUN apk add --update --no-cache git make upx
+RUN apk add --update --no-cache git make
 WORKDIR /app/
 COPY go.mod go.sum /app/
 RUN go mod download
 COPY . /app/
-RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build \
+RUN CGO_ENABLED=0 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 busybox:1.33.0
+FROM gcr.io/distroless/static:latest
-RUN echo "ID=\"busybox\"" > /etc/os-release
+COPY --from=builder /etc/os-release /etc/os-release
+
 COPY --from=builder /app/wings /usr/bin/
-CMD [ "wings", "--config", "/etc/pterodactyl/config.yml" ]
+CMD [ "/usr/bin/wings", "--config", "/etc/pterodactyl/config.yml" ]
+
+EXPOSE 8080

Makefile

@@ -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)" -race
+	go build -ldflags="-X github.com/pterodactyl/wings/system.Version=$(GIT_HEAD)"
-	sudo ./wings --debug --ignore-certificate-errors --config config.yml
+	sudo ./wings --debug --ignore-certificate-errors --config config.yml --pprof --pprof-block-rate 1
 
 # Runs a remotly debuggable session for Wings allowing an IDE to connect and target
 # different breakpoints.
@@ -14,9 +14,6 @@ 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:

README.md

@@ -5,6 +5,7 @@
 [![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.
@@ -13,33 +14,31 @@ 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)
 
-| Company | About |
+I would like to extend my sincere thanks to the following sponsors for helping find Pterodactyl's development.
-| ------- | ----- |
+[Interested in becoming a sponsor?](https://github.com/sponsors/matthewpi)
-| [**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. |
+| Company                                                   | About                                                                                                                                                                                                                           |
-| [**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. |
+| [**WISP**](https://wisp.gg)                               | Extra features.                                                                                                                                                                                                                 |
-| [**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. |
+| [**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.                                                                                 |
-| [**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. |
+| [**BisectHosting**](https://www.bisecthosting.com/)       | BisectHosting provides Minecraft, Valheim and other server hosting services with the highest reliability and lightning fast support since 2012.                                                                                 |
-| [**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! |
+| [**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!                                                                                 |
-| [**XCORE**](https://xcore-server.de/) | XCORE offers High-End Servers for hosting and gaming since 2012. Fast, excellent and well-known for eSports Gaming. |
+| [**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!                                                                              |
-| [**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. |
+| [**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.                           |
-| [**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. |
+| [**Pterodactyl Market**](https://pterodactylmarket.com/)  | Pterodactyl Market is a one-and-stop shop for Pterodactyl. In our market, you can find Add-ons, Themes, Eggs, and more for Pterodactyl.                                                                                         |
-| [**DeinServerHost**](https://deinserverhost.de/) | DeinServerHost offers Dedicated, vps and Gameservers for many popular Games like Minecraft and Rust in Germany since 2013. |
+| [**UltraServers**](https://ultraservers.com/)             | Deploy premium games hosting with the click of a button. Manage and swap games with ease and let us take care of the rest. We currently support Minecraft, Rust, ARK, 7 Days to Die, Garys MOD, CS:GO, Satisfactory and others. |
-| [**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. |
+| [**Realms Hosting**](https://realmshosting.com/)          | Want to build your Gaming Empire? Use Realms Hosting today to kick start your game server hosting with outstanding DDOS Protection, 24/7 Support, Cheap Prices and a Custom Control Panel.                                      |                                                                                                                                                                                                                                |
-| [**Capitol Hosting Solutions**](https://capitolsolutions.cloud/) | 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*! |
 
 ## 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.

cmd/configure.go

@@ -2,9 +2,8 @@ package cmd
 
 import (
 	"crypto/tls"
-	"encoding/json"
 	"fmt"
-	"io/ioutil"
+	"io"
 	"net/http"
 	"net/url"
 	"os"
@@ -14,20 +13,20 @@ import (
 
 	"github.com/AlecAivazis/survey/v2"
 	"github.com/AlecAivazis/survey/v2/terminal"
-	"github.com/pterodactyl/wings/config"
+	"github.com/goccy/go-json"
 	"github.com/spf13/cobra"
+
+	"github.com/pterodactyl/wings/config"
 )
 
-var (
+var configureArgs struct {
-	configureArgs struct {
+	PanelURL      string
-		PanelURL      string
+	Token         string
-		Token         string
+	ConfigPath    string
-		ConfigPath    string
+	Node          string
-		Node          string
+	Override      bool
-		Override      bool
+	AllowInsecure bool
-		AllowInsecure bool
+}
-	}
-)
 
 var nodeIdRegex = regexp.MustCompile(`^(\d+)$`)
 
@@ -139,13 +138,13 @@ func configureCmdRun(cmd *cobra.Command, args []string) {
 		fmt.Println("The authentication credentials provided were not valid.")
 		os.Exit(1)
 	} else if res.StatusCode != http.StatusOK {
-		b, _ := ioutil.ReadAll(res.Body)
+		b, _ := io.ReadAll(res.Body)
 
 		fmt.Println("An error occurred while processing this request.\n", string(b))
 		os.Exit(1)
 	}
 
-	b, err := ioutil.ReadAll(res.Body)
+	b, err := io.ReadAll(res.Body)
 
 	cfg, err := config.NewAtPath(configPath)
 	if err != nil {

cmd/diagnostics.go

@@ -2,11 +2,9 @@ package cmd
 
 import (
 	"context"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"net/http"
 	"net/url"
 	"os/exec"
@@ -21,26 +19,28 @@ import (
 	"github.com/docker/docker/api/types"
 	"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"
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/loggers/cli"
 	"github.com/pterodactyl/wings/system"
-	"github.com/spf13/cobra"
 )
 
-const DefaultHastebinUrl = "https://ptero.co"
+const (
-const DefaultLogLines = 200
+	DefaultHastebinUrl = "https://ptero.co"
-
+	DefaultLogLines    = 200
-var (
-	diagnosticsArgs struct {
-		IncludeEndpoints   bool
-		IncludeLogs        bool
-		ReviewBeforeUpload bool
-		HastebinURL        string
-		LogLines           int
-	}
 )
 
+var diagnosticsArgs struct {
+	IncludeEndpoints   bool
+	IncludeLogs        bool
+	ReviewBeforeUpload bool
+	HastebinURL        string
+	LogLines           int
+}
+
 func newDiagnosticsCommand() *cobra.Command {
 	command := &cobra.Command{
 		Use:   "diagnostics",
@@ -58,14 +58,14 @@ func newDiagnosticsCommand() *cobra.Command {
 	return command
 }
 
-// diagnosticsCmdRun collects diagnostics about wings, it's configuration and the node.
+// diagnosticsCmdRun collects diagnostics about wings, its 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(cmd *cobra.Command, args []string) {
+func diagnosticsCmdRun(*cobra.Command, []string) {
 	questions := []*survey.Question{
 		{
 			Name:   "IncludeEndpoints",
@@ -78,7 +78,7 @@ func diagnosticsCmdRun(cmd *cobra.Command, args []string) {
 		{
 			Name: "ReviewBeforeUpload",
 			Prompt: &survey.Confirm{
-				Message: "Do you want to review the collected data before uploading to hastebin.com?",
+				Message: "Do you want to review the collected data before uploading to " + diagnosticsArgs.HastebinURL + "?",
 				Help:    "The data, especially the logs, might contain sensitive information, so you should review it. You will be asked again if you want to upload.",
 				Default: true,
 			},
@@ -96,41 +96,40 @@ func diagnosticsCmdRun(cmd *cobra.Command, args []string) {
 	output := &strings.Builder{}
 	fmt.Fprintln(output, "Pterodactyl Wings - Diagnostics Report")
 	printHeader(output, "Versions")
-	fmt.Fprintln(output, "         wings:", system.Version)
+	fmt.Fprintln(output, "               Wings:", system.Version)
 	if dockerErr == nil {
-		fmt.Fprintln(output, "Docker:", dockerVersion.Version)
+		fmt.Fprintln(output, "              Docker:", dockerVersion.Version)
 	}
 	if v, err := kernel.GetKernelVersion(); err == nil {
-		fmt.Fprintln(output, "Kernel:", v)
+		fmt.Fprintln(output, "              Kernel:", v)
 	}
 	if os, err := operatingsystem.GetOperatingSystem(); err == nil {
-		fmt.Fprintln(output, "    OS:", os)
+		fmt.Fprintln(output, "                  OS:", os)
 	}
 
 	printHeader(output, "Wings Configuration")
 	if err := config.FromFile(config.DefaultLocation); err != nil {
-
 	}
 	cfg := config.Get()
-	fmt.Fprintln(output, "    Panel Location:", redact(cfg.PanelLocation))
+	fmt.Fprintln(output, "      Panel Location:", redact(cfg.PanelLocation))
 	fmt.Fprintln(output, "")
-	fmt.Fprintln(output, " Internal Webserver:", redact(cfg.Api.Host), ":", cfg.Api.Port)
+	fmt.Fprintln(output, "  Internal Webserver:", redact(cfg.Api.Host), ":", cfg.Api.Port)
-	fmt.Fprintln(output, "        SSL Enabled:", cfg.Api.Ssl.Enabled)
+	fmt.Fprintln(output, "         SSL Enabled:", cfg.Api.Ssl.Enabled)
-	fmt.Fprintln(output, "    SSL Certificate:", redact(cfg.Api.Ssl.CertificateFile))
+	fmt.Fprintln(output, "     SSL Certificate:", redact(cfg.Api.Ssl.CertificateFile))
-	fmt.Fprintln(output, "            SSL Key:", redact(cfg.Api.Ssl.KeyFile))
+	fmt.Fprintln(output, "             SSL Key:", redact(cfg.Api.Ssl.KeyFile))
 	fmt.Fprintln(output, "")
-	fmt.Fprintln(output, "        SFTP Server:", redact(cfg.System.Sftp.Address), ":", cfg.System.Sftp.Port)
+	fmt.Fprintln(output, "         SFTP Server:", redact(cfg.System.Sftp.Address), ":", cfg.System.Sftp.Port)
-	fmt.Fprintln(output, "     SFTP Read-Only:", cfg.System.Sftp.ReadOnly)
+	fmt.Fprintln(output, "      SFTP Read-Only:", cfg.System.Sftp.ReadOnly)
 	fmt.Fprintln(output, "")
-	fmt.Fprintln(output, "     Root Directory:", cfg.System.RootDirectory)
+	fmt.Fprintln(output, "      Root Directory:", cfg.System.RootDirectory)
-	fmt.Fprintln(output, "     Logs Directory:", cfg.System.LogDirectory)
+	fmt.Fprintln(output, "      Logs Directory:", cfg.System.LogDirectory)
-	fmt.Fprintln(output, "     Data Directory:", cfg.System.Data)
+	fmt.Fprintln(output, "      Data Directory:", cfg.System.Data)
-	fmt.Fprintln(output, "  Archive Directory:", cfg.System.ArchiveDirectory)
+	fmt.Fprintln(output, "   Archive Directory:", cfg.System.ArchiveDirectory)
-	fmt.Fprintln(output, "   Backup Directory:", cfg.System.BackupDirectory)
+	fmt.Fprintln(output, "    Backup Directory:", cfg.System.BackupDirectory)
 	fmt.Fprintln(output, "")
-	fmt.Fprintln(output, "           Username:", cfg.System.Username)
+	fmt.Fprintln(output, "            Username:", cfg.System.Username)
-	fmt.Fprintln(output, "        Server Time:", time.Now().Format(time.RFC1123Z))
+	fmt.Fprintln(output, "         Server Time:", time.Now().Format(time.RFC1123Z))
-	fmt.Fprintln(output, "         Debug Mode:", cfg.Debug)
+	fmt.Fprintln(output, "          Debug Mode:", cfg.Debug)
 
 	printHeader(output, "Docker: Info")
 	if dockerErr == nil {
@@ -180,6 +179,17 @@ func diagnosticsCmdRun(cmd *cobra.Command, args []string) {
 		fmt.Fprintln(output, "Logs redacted.")
 	}
 
+	if !diagnosticsArgs.IncludeEndpoints {
+		s := output.String()
+		output.Reset()
+		s = strings.ReplaceAll(s, cfg.PanelLocation, "{redacted}")
+		s = strings.ReplaceAll(s, cfg.Api.Host, "{redacted}")
+		s = strings.ReplaceAll(s, cfg.Api.Ssl.CertificateFile, "{redacted}")
+		s = strings.ReplaceAll(s, cfg.Api.Ssl.KeyFile, "{redacted}")
+		s = strings.ReplaceAll(s, cfg.System.Sftp.Address, "{redacted}")
+		output.WriteString(s)
+	}
+
 	fmt.Println("\n---------------  generated report  ---------------")
 	fmt.Println(output.String())
 	fmt.Print("---------------   end of report    ---------------\n\n")
@@ -225,7 +235,7 @@ func uploadToHastebin(hbUrl, content string) (string, error) {
 		return "", err
 	}
 	pres := make(map[string]interface{})
-	body, err := ioutil.ReadAll(res.Body)
+	body, err := io.ReadAll(res.Body)
 	if err != nil {
 		fmt.Println("Failed to parse response.", err)
 		return "", err

cmd/root.go

@@ -1,14 +1,17 @@
 package cmd
 
 import (
+	"context"
 	"crypto/tls"
 	"errors"
 	"fmt"
 	log2 "log"
 	"net/http"
+	_ "net/http/pprof"
 	"os"
 	"path"
 	"path/filepath"
+	"runtime"
 	"strconv"
 	"strings"
 	"time"
@@ -19,18 +22,20 @@ 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"
 	"github.com/pterodactyl/wings/server"
 	"github.com/pterodactyl/wings/sftp"
 	"github.com/pterodactyl/wings/system"
-	"github.com/spf13/cobra"
-	"golang.org/x/crypto/acme"
-	"golang.org/x/crypto/acme/autocert"
 )
 
 var (
@@ -40,7 +45,7 @@ var (
 
 var rootCommand = &cobra.Command{
 	Use:   "wings",
-	Short: "Runs the API server allowing programatic control of game servers for Pterodactyl Panel.",
+	Short: "Runs the API server allowing programmatic control of game servers for Pterodactyl Panel.",
 	PreRun: func(cmd *cobra.Command, args []string) {
 		initConfig()
 		initLogging()
@@ -73,8 +78,10 @@ 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().String("profiler", "", "the profiler to run for this instance")
+	rootCommand.Flags().Bool("pprof", false, "if the pprof profiler should be enabled. The profiler will bind to localhost:6060 by default")
-	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().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("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")
 
@@ -84,25 +91,6 @@ 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")
@@ -122,12 +110,6 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 		log.WithField("error", err).Fatal("failed to configure system directories for pterodactyl")
 		return
 	}
-	if err := config.EnableLogRotation(); err != nil {
-		log.WithField("error", err).Fatal("failed to configure log rotation on the system")
-		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")
 	}
@@ -136,6 +118,10 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 		"uid":      config.Get().System.User.Uid,
 		"gid":      config.Get().System.User.Gid,
 	}).Info("configured system user successfully")
+	if err := config.EnableLogRotation(); err != nil {
+		log.WithField("error", err).Fatal("failed to configure log rotation on the system")
+		return
+	}
 
 	pclient := remote.New(
 		config.Get().PanelLocation,
@@ -145,6 +131,10 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 		}),
 	)
 
+	if err := database.Initialize(); err != nil {
+		log.WithField("error", err).Fatal("failed to initialize database")
+	}
+
 	manager, err := server.NewManager(cmd.Context(), pclient)
 	if err != nil {
 		log.WithField("error", err).Fatal("failed to load server configurations")
@@ -160,7 +150,7 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 
 	// Just for some nice log output.
 	for _, s := range manager.All() {
-		log.WithField("server", s.Id()).Info("finished loading configuration for server")
+		log.WithField("server", s.ID()).Info("finished loading configuration for server")
 	}
 
 	states, err := manager.ReadStates()
@@ -171,7 +161,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 it's last tracked state.
+	// on its last tracked state.
 	go func() {
 		for {
 			select {
@@ -202,14 +192,24 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 		pool.Submit(func() {
 			s.Log().Info("configuring server environment and restoring to previous state")
 			var st string
-			if state, exists := states[s.Id()]; exists {
+			if state, exists := states[s.ID()]; exists {
 				st = state
 			}
 
-			r, err := s.Environment.IsRunning()
+			// Use a timed context here to avoid booting issues where Docker hangs for a
+			// specific container that would cause Wings to be un-bootable until the entire
+			// machine is rebooted. It is much better for us to just have a single failed
+			// server instance than an entire offline node.
+			//
+			// @see https://github.com/pterodactyl/panel/issues/2475
+			// @see https://github.com/pterodactyl/panel/issues/3358
+			ctx, cancel := context.WithTimeout(cmd.Context(), time.Second*30)
+			defer cancel()
+
+			r, err := s.Environment.IsRunning(ctx)
 			// We ignore missing containers because we don't want to actually block booting of wings at this
-			// point. If we didn't do this and you pruned all of the images and then started wings you could
+			// point. If we didn't do this, and you pruned all the images and then started wings you could
-			// end up waiting a long period of time for all of the images to be re-pulled on Wings boot rather
+			// end up waiting a long period of time for all the images to be re-pulled on Wings boot rather
 			// than when the server itself is started.
 			if err != nil && !client.IsErrNotFound(err) {
 				s.Log().WithField("error", err).Error("error checking server environment status")
@@ -235,7 +235,7 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 				s.Log().Info("detected server is running, re-attaching to process...")
 
 				s.Environment.SetState(environment.ProcessRunningState)
-				if err := s.Environment.Attach(); err != nil {
+				if err := s.Environment.Attach(ctx); err != nil {
 					s.Log().WithField("error", err).Warn("failed to attach to running server environment")
 				}
 			} else {
@@ -244,19 +244,33 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 				// state being tracked.
 				s.Environment.SetState(environment.ProcessOfflineState)
 			}
+
+			if state := s.Environment.State(); state == environment.ProcessStartingState || state == environment.ProcessRunningState {
+				s.Log().Debug("re-syncing server configuration for already running server")
+				if err := s.Sync(); err != nil {
+					s.Log().WithError(err).Error("failed to re-sync server configuration")
+				}
+			}
 		})
 	}
 
-	// Wait until all of the servers are ready to go before we fire up the SFTP and HTTP servers.
+	// Wait until all the servers are ready to go before we fire up the SFTP and HTTP servers.
 	pool.StopWait()
 	defer func() {
-		// Cancel the context on all of the running servers at this point, even though the
+		// Cancel the context on all the running servers at this point, even though the
 		// program is just shutting down.
 		for _, s := range manager.All() {
 			s.CtxCancel()
 		}
 	}()
 
+	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 {
@@ -267,7 +281,7 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 
 	go func() {
 		log.Info("updating server states on Panel: marking installing/restoring servers as normal")
-		// Update all of the servers on the Panel to be in a valid state if they're
+		// Update all the servers on the Panel to be in a valid state if they're
 		// currently marked as installing/restoring now that Wings is restarted.
 		if err := pclient.ResetServersState(cmd.Context()); err != nil {
 			log.WithField("error", err).Error("failed to reset server states on Panel: some instances may be stuck in an installing/restoring state unexpectedly")
@@ -276,12 +290,12 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 
 	sys := config.Get().System
 	// Ensure the archive directory exists.
-	if err := os.MkdirAll(sys.ArchiveDirectory, 0755); err != nil {
+	if err := os.MkdirAll(sys.ArchiveDirectory, 0o755); err != nil {
 		log.WithField("error", err).Error("failed to create archive directory")
 	}
 
 	// Ensure the backup directory exists.
-	if err := os.MkdirAll(sys.BackupDirectory, 0755); err != nil {
+	if err := os.MkdirAll(sys.BackupDirectory, 0o755); err != nil {
 		log.WithField("error", err).Error("failed to create backup directory")
 	}
 
@@ -307,6 +321,20 @@ 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{
@@ -334,10 +362,10 @@ 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(strings.ToLower(api.Ssl.CertificateFile), strings.ToLower(api.Ssl.KeyFile)); err != nil {
+		if err := s.ListenAndServeTLS(api.Ssl.CertificateFile, api.Ssl.KeyFile); err != nil {
 			log.WithFields(log.Fields{"auto_tls": false, "error": err}).Fatal("failed to configure HTTPS server")
 		}
 		return
@@ -349,7 +377,7 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 }
 
 // Reads the configuration from the disk and then sets up the global singleton
-// with all of the configuration values.
+// with all the configuration values.
 func initConfig() {
 	if !strings.HasPrefix(configPath, "/") {
 		d, err := os.Getwd()
@@ -374,7 +402,7 @@ func initConfig() {
 // in the code without having to pass around a logger instance.
 func initLogging() {
 	dir := config.Get().System.LogDirectory
-	if err := os.MkdirAll(path.Join(dir, "/install"), 0700); err != nil {
+	if err := os.MkdirAll(path.Join(dir, "/install"), 0o700); err != nil {
 		log2.Fatalf("cmd/root: failed to create install directory path: %s", err)
 	}
 	p := filepath.Join(dir, "/wings.log")

config/config.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"crypto/tls"
 	"fmt"
-	"io/ioutil"
 	"os"
 	"os/exec"
 	"os/user"
@@ -17,12 +16,13 @@ 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"
-	"github.com/pterodactyl/wings/system"
 	"gopkg.in/yaml.v2"
+
+	"github.com/pterodactyl/wings/system"
 )
 
 const DefaultLocation = "/etc/pterodactyl/config.yml"
@@ -47,13 +47,15 @@ var DefaultTLSConfig = &tls.Config{
 	CurvePreferences:         []tls.CurveID{tls.X25519, tls.CurveP256},
 }
 
-var mu sync.RWMutex
+var (
-var _config *Configuration
+	mu            sync.RWMutex
-var _jwtAlgo *jwt.HMACSHA
+	_config       *Configuration
-var _debugViaFlag bool
+	_jwtAlgo      *jwt.HMACSHA
+	_debugViaFlag bool
+)
 
 // Locker specific to writing the configuration to the disk, this happens
-// in areas that might already be locked so we don't want to crash the process.
+// in areas that might already be locked, so we don't want to crash the process.
 var _writeLock sync.Mutex
 
 // SftpConfiguration defines the configuration of the internal SFTP server.
@@ -87,8 +89,11 @@ type ApiConfiguration struct {
 	// servers.
 	DisableRemoteDownload bool `json:"disable_remote_download" yaml:"disable_remote_download"`
 
-	// The maximum size for files uploaded through the Panel in bytes.
+	// The maximum size for files uploaded through the Panel in MB.
-	UploadLimit int `default:"100" json:"upload_limit" yaml:"upload_limit"`
+	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"`
 }
 
 // RemoteQueryConfiguration defines the configuration settings for remote requests
@@ -130,6 +135,10 @@ type SystemConfiguration struct {
 	// Directory where local backups will be stored on the machine.
 	BackupDirectory string `default:"/var/lib/pterodactyl/backups" 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" yaml:"tmp_directory"`
+
 	// The user that should own all of the server files, and be used for containers.
 	Username string `default:"pterodactyl" yaml:"username"`
 
@@ -143,9 +152,23 @@ 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 {
-		Uid int
+		// Rootless controls settings related to rootless container daemons.
-		Gid int
+		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"`
 
 	// 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
@@ -157,6 +180,15 @@ 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
@@ -180,6 +212,9 @@ type SystemConfiguration struct {
 }
 
 type CrashDetection struct {
+	// CrashDetectionEnabled sets if crash detection is enabled globally for all servers on this node.
+	CrashDetectionEnabled bool `default:"true" yaml:"enabled"`
+
 	// Determines if Wings should detect a server that stops with a normal exit code of
 	// "0" as being crashed if the process stopped without any Wings interaction. E.g.
 	// the user did not press the stop button, but the process stopped cleanly.
@@ -201,6 +236,15 @@ 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 {
@@ -217,26 +261,14 @@ 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 LineResetInterval period before
+	// The total number of lines that can be output in a given Period 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.
-	LineResetInterval uint64 `json:"line_reset_interval" yaml:"line_reset_interval" default:"100"`
+	Period uint64 `json:"line_reset_interval" yaml:"line_reset_interval" default:"100"`
-
-	// 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 {
@@ -281,6 +313,12 @@ type Configuration struct {
 	// The Panel URL is automatically allowed, this is only needed for adding
 	// additional origins.
 	AllowedOrigins []string `json:"allowed_origins" yaml:"allowed_origins"`
+
+	// AllowCORSPrivateNetwork sets the `Access-Control-Request-Private-Network` header which
+	// allows client browsers to make requests to internal IP addresses over HTTP.  This setting
+	// 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"`
 }
 
 // NewAtPath creates a new struct and set the path where it should be stored.
@@ -374,7 +412,7 @@ func WriteToDisk(c *Configuration) error {
 	if err != nil {
 		return err
 	}
-	if err := ioutil.WriteFile(c.path, b, 0600); err != nil {
+	if err := os.WriteFile(c.path, b, 0o600); err != nil {
 		return err
 	}
 	return nil
@@ -394,13 +432,26 @@ func EnsurePterodactylUser() error {
 	}
 
 	// Our way of detecting if wings is running inside of Docker.
-	if sysName == "busybox" {
+	if sysName == "distroless" {
 		_config.System.Username = system.FirstNotEmpty(os.Getenv("WINGS_USERNAME"), "pterodactyl")
 		_config.System.User.Uid = system.MustInt(system.FirstNotEmpty(os.Getenv("WINGS_UID"), "988"))
 		_config.System.User.Gid = system.MustInt(system.FirstNotEmpty(os.Getenv("WINGS_GID"), "988"))
 		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.
@@ -442,7 +493,7 @@ func EnsurePterodactylUser() error {
 // FromFile reads the configuration from the provided file and stores it in the
 // global singleton for this instance.
 func FromFile(path string) error {
-	b, err := ioutil.ReadFile(path)
+	b, err := os.ReadFile(path)
 	if err != nil {
 		return err
 	}
@@ -450,18 +501,17 @@ func FromFile(path string) error {
 	if err != nil {
 		return err
 	}
-	// Replace environment variables within the configuration file with their
+
-	// values from the host system.
-	b = []byte(os.ExpandEnv(string(b)))
 	if err := yaml.Unmarshal(b, c); err != nil {
 		return err
 	}
+
 	// Store this configuration in the global state.
 	Set(c)
 	return nil
 }
 
-// ConfigureDirectories ensures that all of the system directories exist on the
+// ConfigureDirectories ensures that all the system directories exist on the
 // system. These directories are created so that only the owner can read the data,
 // and no other users.
 //
@@ -469,7 +519,7 @@ func FromFile(path string) error {
 func ConfigureDirectories() error {
 	root := _config.System.RootDirectory
 	log.WithField("path", root).Debug("ensuring root data directory exists")
-	if err := os.MkdirAll(root, 0700); err != nil {
+	if err := os.MkdirAll(root, 0o700); err != nil {
 		return err
 	}
 
@@ -490,17 +540,17 @@ func ConfigureDirectories() error {
 	}
 
 	log.WithField("path", _config.System.Data).Debug("ensuring server data directory exists")
-	if err := os.MkdirAll(_config.System.Data, 0700); err != nil {
+	if err := os.MkdirAll(_config.System.Data, 0o700); err != nil {
 		return err
 	}
 
 	log.WithField("path", _config.System.ArchiveDirectory).Debug("ensuring archive data directory exists")
-	if err := os.MkdirAll(_config.System.ArchiveDirectory, 0700); err != nil {
+	if err := os.MkdirAll(_config.System.ArchiveDirectory, 0o700); err != nil {
 		return err
 	}
 
 	log.WithField("path", _config.System.BackupDirectory).Debug("ensuring backup data directory exists")
-	if err := os.MkdirAll(_config.System.BackupDirectory, 0700); err != nil {
+	if err := os.MkdirAll(_config.System.BackupDirectory, 0o700); err != nil {
 		return err
 	}
 
@@ -538,8 +588,7 @@ func EnableLogRotation() error {
 	}
 	defer f.Close()
 
-	t, err := template.New("logrotate").Parse(`
+	t, err := template.New("logrotate").Parse(`{{.LogDirectory}}/wings.log {
-{{.LogDirectory}}/wings.log {
     size 10M
     compress
     delaycompress
@@ -547,9 +596,8 @@ func EnableLogRotation() error {
     maxage 7
     missingok
     notifempty
-    create 0640 {{.User.Uid}} {{.User.Gid}}
     postrotate
-        killall -SIGHUP wings
+        /usr/bin/systemctl kill -s HUP wings.service >/dev/null 2>&1 || true
     endscript
 }`)
 	if err != nil {
@@ -575,7 +623,7 @@ func ConfigureTimezone() error {
 		_config.System.Timezone = tz
 	}
 	if _config.System.Timezone == "" {
-		b, err := ioutil.ReadFile("/etc/timezone")
+		b, err := os.ReadFile("/etc/timezone")
 		if err != nil {
 			if !os.IsNotExist(err) {
 				return errors.WithMessage(err, "config: failed to open timezone file")

config/config_docker.go

@@ -2,9 +2,11 @@ package config
 
 import (
 	"encoding/base64"
-	"encoding/json"
+	"sort"
 
 	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/api/types/container"
+	"github.com/goccy/go-json"
 )
 
 type dockerNetworkInterfaces struct {
@@ -35,6 +37,7 @@ 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"`
 }
 
@@ -51,10 +54,55 @@ type DockerConfiguration struct {
 	// Registries .
 	Registries map[string]RegistryConfiguration `json:"registries" yaml:"registries"`
 
-	// The size of the /tmp directory when mounted into a container. Please be aware that Docker
+	// TmpfsSize specifies the size for the /tmp directory mounted into containers. Please be
-	// utilizes host memory for this value, and that we do not keep track of the space used here
+	// aware that Docker utilizes the host's system memory for this value, and that we do not
-	// so avoid allocating too much to a server.
+	// keep track of the space used there, so avoid allocating too much to a server.
 	TmpfsSize uint `default:"100" json:"tmpfs_size" yaml:"tmpfs_size"`
+
+	// ContainerPidLimit sets the total number of processes that can be active in a container
+	// at any given moment. This is a security concern in shared-hosting environments where a
+	// malicious process could create enough processes to cause the host node to run out of
+	// available pids and crash.
+	ContainerPidLimit int64 `default:"512" json:"container_pid_limit" yaml:"container_pid_limit"`
+
+	// InstallerLimits defines the limits on the installer containers that prevents a server's
+	// installation process from unintentionally consuming more resources than expected. This
+	// is used in conjunction with the server's defined limits. Whichever value is higher will
+	// take precedence in the installer containers.
+	InstallerLimits struct {
+		Memory int64 `default:"1024" json:"memory" yaml:"memory"`
+		Cpu    int64 `default:"100" json:"cpu" yaml:"cpu"`
+	} `json:"installer_limits" yaml:"installer_limits"`
+
+	// Overhead controls the memory overhead given to all containers to circumvent certain
+	// software such as the JVM not staying below the maximum memory limit.
+	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
@@ -76,3 +124,62 @@ func (c RegistryConfiguration) Base64() (string, error) {
 	}
 	return base64.URLEncoding.EncodeToString(b), nil
 }
+
+// Overhead controls the memory overhead given to all containers to circumvent certain
+// software such as the JVM not staying below the maximum memory limit.
+type Overhead struct {
+	// Override controls if the overhead limits should be overridden by the values in the config file.
+	Override bool `default:"false" json:"override" yaml:"override"`
+
+	// DefaultMultiplier sets the default multiplier for if no Multipliers are able to be applied.
+	DefaultMultiplier float64 `default:"1.05" json:"default_multiplier" yaml:"default_multiplier"`
+
+	// Multipliers allows overriding DefaultMultiplier depending on the amount of memory
+	// configured for a server.
+	//
+	// Default values (used if Override is `false`)
+	// - Less than 2048 MB of memory, multiplier of 1.15 (15%)
+	// - Less than 4096 MB of memory, multiplier of 1.10 (10%)
+	// - Otherwise, multiplier of 1.05 (5%) - specified in DefaultMultiplier
+	//
+	// If the defaults were specified in the config they would look like:
+	// ```yaml
+	// multipliers:
+	//   2048: 1.15
+	//   4096: 1.10
+	// ```
+	Multipliers map[int]float64 `json:"multipliers" yaml:"multipliers"`
+}
+
+func (o Overhead) GetMultiplier(memoryLimit int64) float64 {
+	// Default multiplier values.
+	if !o.Override {
+		if memoryLimit <= 2048 {
+			return 1.15
+		} else if memoryLimit <= 4096 {
+			return 1.10
+		}
+		return 1.05
+	}
+
+	// This plucks the keys of the Multipliers map, so they can be sorted from
+	// smallest to largest in order to correctly apply the proper multiplier.
+	i := 0
+	multipliers := make([]int, len(o.Multipliers))
+	for k := range o.Multipliers {
+		multipliers[i] = k
+		i++
+	}
+	sort.Ints(multipliers)
+
+	// Loop through the memory values in order (smallest to largest)
+	for _, m := range multipliers {
+		// If the server's memory limit exceeds the modifier's limit, don't apply it.
+		if memoryLimit > int64(m) {
+			continue
+		}
+		return o.Multipliers[m]
+	}
+
+	return o.DefaultMultiplier
+}

environment/allocations.go

@@ -5,12 +5,18 @@ import (
 	"strconv"
 
 	"github.com/docker/go-connections/nat"
+
 	"github.com/pterodactyl/wings/config"
 )
 
 // 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.
@@ -19,7 +25,7 @@ type Allocations struct {
 		Port int    `json:"port"`
 	} `json:"default"`
 
-	// Mappings contains all of the ports that should be assigned to a given server
+	// Mappings contains all the ports that should be assigned to a given server
 	// attached to the IP they correspond to.
 	Mappings map[string][]int `json:"mappings"`
 }
@@ -30,7 +36,7 @@ type Allocations struct {
 //
 // You'll want to use DockerBindings() if you need to re-map 127.0.0.1 to the Docker interface.
 func (a *Allocations) Bindings() nat.PortMap {
-	var out = nat.PortMap{}
+	out := nat.PortMap{}
 
 	for ip, ports := range a.Mappings {
 		for _, port := range ports {
@@ -62,7 +68,7 @@ func (a *Allocations) DockerBindings() nat.PortMap {
 	iface := config.Get().Docker.Network.Interface
 
 	out := a.Bindings()
-	// Loop over all of the bindings for this container, and convert any that reference 127.0.0.1
+	// Loop over all the bindings for this container, and convert any that reference 127.0.0.1
 	// to use the pterodactyl0 network interface IP, as that is the true local for what people are
 	// trying to do when creating servers.
 	for p, binds := range out {
@@ -93,7 +99,7 @@ func (a *Allocations) DockerBindings() nat.PortMap {
 // To accomplish this, we'll just get the values from "DockerBindings" and then set them
 // to empty structs. Because why not.
 func (a *Allocations) Exposed() nat.PortSet {
-	var out = nat.PortSet{}
+	out := nat.PortSet{}
 
 	for port := range a.DockerBindings() {
 		out[port] = struct{}{}

environment/config.go

@@ -8,6 +8,7 @@ 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
@@ -68,6 +69,14 @@ 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()

environment/docker.go

@@ -10,11 +10,14 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/network"
 	"github.com/docker/docker/client"
+
 	"github.com/pterodactyl/wings/config"
 )
 
-var _conce sync.Once
+var (
-var _client *client.Client
+	_conce  sync.Once
+	_client *client.Client
+)
 
 // Docker returns a docker client to be used throughout the codebase. Once a
 // client has been created it will be returned for all subsequent calls to this
@@ -38,12 +41,12 @@ func ConfigureDocker(ctx context.Context) error {
 	nw := config.Get().Docker.Network
 	resource, err := cli.NetworkInspect(ctx, nw.Name, types.NetworkInspectOptions{})
 	if err != nil {
-		if client.IsErrNotFound(err) {
+		if !client.IsErrNotFound(err) {
-			log.Info("creating missing pterodactyl0 interface, this could take a few seconds...")
+			return err
-			if err := createDockerNetwork(ctx, cli); err != nil {
+		}
-				return err
+
-			}
+		log.Info("creating missing pterodactyl0 interface, this could take a few seconds...")
-		} else {
+		if err := createDockerNetwork(ctx, cli); err != nil {
 			return err
 		}
 	}
@@ -89,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":                  "1500",
+			"com.docker.network.driver.mtu":                  strconv.FormatInt(nw.NetworkMTU, 10),
 		},
 	})
 	if err != nil {

environment/docker/api.go

@@ -0,0 +1,120 @@
+package docker
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"reflect"
+	"strings"
+	"sync"
+
+	"emperror.dev/errors"
+	"github.com/docker/docker/api/types"
+	"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"
+)
+
+var (
+	o           sync.Once
+	cli         cliSettings
+	fastEnabled bool
+)
+
+type cliSettings struct {
+	enabled bool
+	proto   string
+	host    string
+	scheme  string
+	version string
+}
+
+func configure(c *client.Client) {
+	o.Do(func() {
+		fastEnabled = config.Get().Docker.UsePerformantInspect
+
+		r := reflect.ValueOf(c).Elem()
+		cli.proto = r.FieldByName("proto").String()
+		cli.host = r.FieldByName("addr").String()
+		cli.scheme = r.FieldByName("scheme").String()
+		cli.version = r.FieldByName("version").String()
+	})
+}
+
+// ContainerInspect is a rough equivalent of Docker's client.ContainerInspect()
+// but re-written to use a more performant JSON decoder. This is important since
+// a large number of requests to this endpoint are spawned by Wings, and the
+// standard "encoding/json" shows its performance woes badly even with single
+// containers running.
+func (e *Environment) ContainerInspect(ctx context.Context) (types.ContainerJSON, error) {
+	configure(e.client)
+
+	// Support feature flagging of this functionality so that if something goes
+	// wrong for now it is easy enough for people to switch back to the older method
+	// of fetching stats.
+	if !fastEnabled {
+		return e.client.ContainerInspect(ctx, e.Id)
+	}
+
+	var st types.ContainerJSON
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, "/containers/"+e.Id+"/json", nil)
+	if err != nil {
+		return st, errors.WithStack(err)
+	}
+
+	if cli.proto == "unix" || cli.proto == "npipe" {
+		req.Host = "docker"
+	}
+
+	req.URL.Host = cli.host
+	req.URL.Scheme = cli.scheme
+
+	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)
+	}
+
+	body, err := io.ReadAll(res.Body)
+	if err != nil {
+		return st, errors.Wrap(err, "failed to read response body from Docker")
+	}
+	if err := parseErrorFromResponse(res, body); err != nil {
+		return st, errdefs.FromStatusCode(err, res.StatusCode)
+	}
+	if err := json.Unmarshal(body, &st); err != nil {
+		return st, errors.WithStack(err)
+	}
+	return st, nil
+}
+
+// parseErrorFromResponse is a re-implementation of Docker's
+// client.checkResponseErr() function.
+func parseErrorFromResponse(res *http.Response, body []byte) error {
+	if res.StatusCode >= 200 && res.StatusCode < 400 {
+		return nil
+	}
+
+	var ct string
+	if res.Header != nil {
+		ct = res.Header.Get("Content-Type")
+	}
+
+	var emsg string
+	if (cli.version == "" || versions.GreaterThan(cli.version, "1.23")) && ct == "application/json" {
+		var errResp types.ErrorResponse
+		if err := json.Unmarshal(body, &errResp); err != nil {
+			return errors.WithStack(err)
+		}
+		emsg = strings.TrimSpace(errResp.Message)
+	} else {
+		emsg = strings.TrimSpace(string(body))
+	}
+
+	return errors.Wrap(errors.New(emsg), "Error response from daemon")
+}

environment/docker/container.go

@@ -3,7 +3,6 @@ package docker
 import (
 	"bufio"
 	"context"
-	"encoding/json"
 	"fmt"
 	"io"
 	"strconv"
@@ -12,11 +11,12 @@ 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/mount"
 	"github.com/docker/docker/client"
-	"github.com/docker/docker/daemon/logger/jsonfilelog"
+
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/system"
@@ -37,22 +37,18 @@ 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 not be used for reading
+// data in and out of the process stream. This should always be called before
-// console data as you *will* miss important output at the beginning because of
+// you have started the container, but after you've ensured it exists.
-// the time delay with attaching to the output.
 //
 // Calling this function will poll resources for the container in the background
-// until the provided context is canceled by the caller. Failure to cancel said
+// until the container is stopped. The context provided to this function is used
-// context will cause background memory leaks as the goroutine will not exit.
+// for the purposes of attaching to the container, a second context is created
-func (e *Environment) Attach() error {
+// within the function for managing polling.
+func (e *Environment) Attach(ctx context.Context) error {
 	if e.IsAttached() {
 		return nil
 	}
 
-	if err := e.followOutput(); err != nil {
-		return err
-	}
-
 	opts := types.ContainerAttachOptions{
 		Stdin:  true,
 		Stdout: true,
@@ -61,14 +57,17 @@ func (e *Environment) Attach() error {
 	}
 
 	// Set the stream again with the container.
-	if st, err := e.client.ContainerAttach(context.Background(), e.Id, opts); err != nil {
+	if st, err := e.client.ContainerAttach(ctx, e.Id, opts); err != nil {
-		return err
+		return errors.WrapIf(err, "environment/docker: error while attaching to container")
 	} else {
 		e.SetStream(&st)
 	}
 
 	go func() {
-		ctx, cancel := context.WithCancel(context.Background())
+		// Don't use the context provided to the function, that'll cause the polling to
+		// exit unexpectedly. We want a custom context for this, the one passed to the
+		// function is to avoid a hang situation when trying to attach to a container.
+		pollCtx, cancel := context.WithCancel(context.Background())
 		defer cancel()
 		defer e.stream.Close()
 		defer func() {
@@ -77,7 +76,7 @@ func (e *Environment) Attach() error {
 		}()
 
 		go func() {
-			if err := e.pollResources(ctx); err != nil {
+			if err := e.pollResources(pollCtx); err != nil {
 				if !errors.Is(err, context.Canceled) {
 					e.log().WithField("error", err).Error("error during environment resource polling")
 				} else {
@@ -86,20 +85,13 @@ func (e *Environment) Attach() error {
 			}
 		}()
 
-		// Block the completion of this routine until the container is no longer running. This allows
+		if err := system.ScanReader(e.stream.Reader, func(v []byte) {
-		// the pollResources function to run until it needs to be stopped. Because the container
+			e.logCallbackMx.Lock()
-		// can be polled for resource usage, even when stopped, we need to have this logic present
+			defer e.logCallbackMx.Unlock()
-		// in order to cancel the context and therefore stop the routine that is spawned.
+			e.logCallback(v)
-		//
+		}); err != nil && err != io.EOF {
-		// For now, DO NOT use client#ContainerWait from the Docker package. There is a nasty
+			log.WithField("error", err).WithField("container_id", e.Id).Warn("error processing scanner line in console output")
-		// bug causing containers to hang on deletion and cause servers to lock up on the system.
+			return
-		//
-		// 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")
 		}
 	}()
 
@@ -114,7 +106,7 @@ func (e *Environment) InSituUpdate() error {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
 	defer cancel()
 
-	if _, err := e.client.ContainerInspect(ctx, e.Id); err != nil {
+	if _, err := e.ContainerInspect(ctx); err != nil {
 		// If the container doesn't exist for some reason there really isn't anything
 		// we can do to fix that in this process (it doesn't make sense at least). In those
 		// cases just return without doing anything since we still want to save the configuration
@@ -132,24 +124,26 @@ func (e *Environment) InSituUpdate() error {
 	//
 	// @see https://github.com/moby/moby/issues/41946
 	if _, err := e.client.ContainerUpdate(ctx, e.Id, container.UpdateConfig{
-		Resources: e.resources(),
+		Resources: e.Configuration.Limits().AsContainerResources(),
 	}); err != nil {
 		return errors.Wrap(err, "environment/docker: could not update container")
 	}
 	return nil
 }
 
-// Create creates a new container for the server using all of the data that is
+// Create creates a new container for the server using all the data that is
 // 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.client.ContainerInspect(context.Background(), e.Id); err == nil {
+	if _, err := e.ContainerInspect(ctx); err == nil {
 		return nil
 	} else if !client.IsErrNotFound(err) {
-		return errors.Wrap(err, "environment/docker: failed to inspect container")
+		return errors.WrapIf(err, "environment/docker: failed to inspect container")
 	}
 
 	// Try to pull the requested image before creating the container.
@@ -157,68 +151,101 @@ 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=" + config.Get().Docker.Network.Interface
+			evs[i] = "SERVER_IP=" + cfg.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:   config.Get().Docker.Domainname,
+		Domainname:   cfg.Docker.Domainname,
-		User:         strconv.Itoa(config.Get().System.User.Uid),
 		AttachStdin:  true,
 		AttachStdout: true,
 		AttachStderr: true,
 		OpenStdin:    true,
 		Tty:          true,
 		ExposedPorts: a.Exposed(),
-		Image:        e.meta.Image,
+		Image:        strings.TrimPrefix(e.meta.Image, "~"),
 		Env:          e.Configuration.EnvironmentVariables(),
-		Labels: map[string]string{
+		Labels:       labels,
-			"Service":       "Pterodactyl",
-			"ContainerType": "server_process",
-		},
 	}
 
-	tmpfsSize := strconv.Itoa(int(config.Get().Docker.TmpfsSize))
+	// 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, types.NetworkInspectOptions{}); err != nil {
+			if !client.IsErrNotFound(err) {
+				return err
+			}
+
+			if _, err := e.client.NetworkCreate(ctx, networkName, types.NetworkCreate{
+				Driver:     "bridge",
+				EnableIPv6: false,
+				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
+			}
+		}
+	}
 
 	hostConf := &container.HostConfig{
 		PortBindings: a.DockerBindings(),
 
 		// Configure the mounts for this container. First mount the server data directory
-		// into the container as a r/w bind.
+		// into the container as an r/w bind.
 		Mounts: e.convertMounts(),
 
 		// 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=" + tmpfsSize + "M",
+			"/tmp": "rw,exec,nosuid,size=" + strconv.Itoa(int(cfg.Docker.TmpfsSize)) + "M",
 		},
 
 		// Define resource limits for the container based on the data passed through
 		// from the Panel.
-		Resources: e.resources(),
+		Resources: e.Configuration.Limits().AsContainerResources(),
 
-		DNS: config.Get().Docker.Network.Dns,
+		DNS: cfg.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: container.LogConfig{
+		LogConfig: cfg.Docker.ContainerLogConfig(),
-			Type: jsonfilelog.Name,
-			Config: map[string]string{
-				"max-size": "5m",
-				"max-file": "1",
-				"compress": "false",
-			},
-		},
 
 		SecurityOpt:    []string{"no-new-privileges"},
 		ReadonlyRootfs: true,
@@ -226,10 +253,11 @@ func (e *Environment) Create() error {
 			"setpcap", "mknod", "audit_write", "net_raw", "dac_override",
 			"fowner", "fsetid", "net_bind_service", "sys_chroot", "setfcap",
 		},
-		NetworkMode: container.NetworkMode(config.Get().Docker.Network.Mode),
+		NetworkMode: networkMode,
+		UsernsMode:  container.UsernsMode(cfg.Docker.UsernsMode),
 	}
 
-	if _, err := e.client.ContainerCreate(context.Background(), conf, hostConf, nil, nil, e.Id); err != nil {
+	if _, err := e.client.ContainerCreate(ctx, conf, hostConf, nil, nil, e.Id); err != nil {
 		return errors.Wrap(err, "environment/docker: failed to create container")
 	}
 
@@ -307,72 +335,12 @@ 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()
-
-	events := e.Events()
-
-	err := system.ScanReader(reader, func(line string) {
-		events.Publish(environment.ConsoleOutputEvent, line)
-	})
-
-	if 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()
-}
-
-type imagePullStatus struct {
-	Status   string `json:"status"`
-	Progress string `json:"progress"`
-}
-
 // 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.
 //
 // The reasoning behind this is that Quay has had some serious outages as of
-// late, and we don't need to block all of the servers from booting just because
+// 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(image string) error {
@@ -452,12 +420,11 @@ func (e *Environment) ensureImageExists(image string) error {
 	scanner := bufio.NewScanner(out)
 
 	for scanner.Scan() {
-		s := imagePullStatus{}
+		b := scanner.Bytes()
-		fmt.Println(scanner.Text())
+		status, _ := jsonparser.GetString(b, "status")
+		progress, _ := jsonparser.GetString(b, "progress")
 
-		if err := json.Unmarshal(scanner.Bytes(), &s); err == nil {
+		e.Events().Publish(environment.DockerImagePullStatus, status+" "+progress)
-			e.Events().Publish(environment.DockerImagePullStatus, s.Status+" "+s.Progress)
-		}
 	}
 
 	if err := scanner.Err(); err != nil {
@@ -483,19 +450,3 @@ func (e *Environment) convertMounts() []mount.Mount {
 
 	return out
 }
-
-func (e *Environment) resources() container.Resources {
-	l := e.Configuration.Limits()
-
-	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,
-	}
-}

environment/docker/environment.go

@@ -10,6 +10,7 @@ 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"
@@ -21,13 +22,12 @@ type Metadata struct {
 	Stop  remote.ProcessStopConfiguration
 }
 
-// Ensure that the Docker environment is always implementing all of the methods
+// Ensure that the Docker environment is always implementing all the methods
 // from the base environment interface.
 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.
@@ -48,7 +48,10 @@ type Environment struct {
 	// Holds the stats stream used by the polling commands so that we can easily close it out.
 	stats io.ReadCloser
 
-	emitter *events.EventBus
+	emitter *events.Bus
+
+	logCallbackMx sync.Mutex
+	logCallback   func([]byte)
 
 	// Tracks the environment state.
 	st *system.AtomicString
@@ -70,6 +73,7 @@ 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
@@ -83,71 +87,67 @@ func (e *Environment) Type() string {
 	return "docker"
 }
 
-// Set if this process is currently attached to the process.
+// 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.
 func (e *Environment) SetStream(s *types.HijackedResponse) {
 	e.mu.Lock()
-	defer e.mu.Unlock()
-
 	e.stream = s
+	e.mu.Unlock()
 }
 
-// Determine if the this process is currently attached to the container.
+// IsAttached determines if this process is currently attached to the
+// container instance by checking if the stream is nil or not.
 func (e *Environment) IsAttached() bool {
 	e.mu.RLock()
 	defer e.mu.RUnlock()
-
 	return e.stream != nil
 }
 
-func (e *Environment) Events() *events.EventBus {
+// Events returns an event bus for the environment.
-	e.eventMu.Do(func() {
+func (e *Environment) Events() *events.Bus {
-		e.emitter = events.New()
-	})
-
 	return e.emitter
 }
 
-// Determines if the container exists in this environment. The ID passed through should be the
+// Exists determines if the container exists in this environment. The ID passed
-// server UUID since containers are created utilizing the server UUID as the name and docker
+// through should be the server UUID since containers are created utilizing the
-// will work fine when using the container name as the lookup parameter in addition to the longer
+// server UUID as the name and docker will work fine when using the container
-// ID auto-assigned when the container is created.
+// 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.client.ContainerInspect(context.Background(), e.Id)
+	_, err := e.ContainerInspect(context.Background())
-
 	if err != nil {
 		// If this error is because the container instance wasn't found via Docker we
 		// can safely ignore the error and just return false.
 		if client.IsErrNotFound(err) {
 			return false, nil
 		}
-
 		return false, err
 	}
-
 	return true, nil
 }
 
-// Determines if the server's docker container is currently running. If there is no container
+// IsRunning determines if the server's docker container is currently running.
-// present, an error will be raised (since this shouldn't be a case that ever happens under
+// If there is no container present, an error will be raised (since this
-// correctly developed circumstances).
+// shouldn't be a case that ever happens under correctly developed
+// circumstances).
 //
-// You can confirm if the instance wasn't found by using client.IsErrNotFound from the Docker
+// You can confirm if the instance wasn't found by using client.IsErrNotFound
-// API.
+// from the Docker API.
 //
 // @see docker/client/errors.go
-func (e *Environment) IsRunning() (bool, error) {
+func (e *Environment) IsRunning(ctx context.Context) (bool, error) {
-	c, err := e.client.ContainerInspect(context.Background(), e.Id)
+	c, err := e.ContainerInspect(ctx)
 	if err != nil {
 		return false, err
 	}
-
 	return c.State.Running, nil
 }
 
-// Determine the container exit state and return the exit code and whether or not
+// ExitState returns the container exit state, 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.client.ContainerInspect(context.Background(), e.Id)
+	c, err := e.ContainerInspect(context.Background())
 	if err != nil {
 		// I'm not entirely sure how this can happen to be honest. I tried deleting a
 		// container _while_ a server was running and wings gracefully saw the crash and
@@ -161,15 +161,13 @@ 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
 }
 
-// Returns the environment configuration allowing a process to make modifications of the
+// Config returns the environment configuration allowing a process to make
-// environment on the fly.
+// modifications of the environment on the fly.
 func (e *Environment) Config() *environment.Configuration {
 	e.mu.RLock()
 	defer e.mu.RUnlock()
@@ -177,12 +175,11 @@ func (e *Environment) Config() *environment.Configuration {
 	return e.Configuration
 }
 
-// Sets the stop configuration for the environment.
+// SetStopConfiguration 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) {
@@ -214,3 +211,10 @@ func (e *Environment) SetState(state string) {
 		e.Events().Publish(environment.StateChangeEvent, state)
 	}
 }
+
+func (e *Environment) SetLogCallback(f func([]byte)) {
+	e.logCallbackMx.Lock()
+	defer e.logCallbackMx.Unlock()
+
+	e.logCallback = f
+}

environment/docker/power.go

@@ -12,20 +12,22 @@ import (
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/client"
+
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/remote"
 )
 
-// Run before the container starts and get the process configuration from the Panel.
+// OnBeforeStart run before the container starts and get the process
-// This is important since we use this to check configuration files as well as ensure
+// configuration from the Panel. This is important since we use this to check
-// we always have the latest version of an egg available for server processes.
+// configuration files as well as ensure we always have the latest version of
+// an egg available for server processes.
 //
-// This process will also confirm that the server environment exists and is in a bootable
+// This process will also confirm that the server environment exists and is in
-// state. This ensures that unexpected container deletion while Wings is running does
+// a bootable state. This ensures that unexpected container deletion while Wings
-// not result in the server becoming un-bootable.
+// is running does not result in the server becoming un-bootable.
-func (e *Environment) OnBeforeStart() error {
+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(context.Background(), e.Id, types.ContainerRemoveOptions{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() 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 of the files will still exist at this point.
+	// an assumption that all the files will still exist at this point.
 	if err := e.Create(); err != nil {
 		return err
 	}
@@ -45,10 +47,10 @@ func (e *Environment) OnBeforeStart() error {
 	return nil
 }
 
-// Starts the server environment and begins piping output to the event listeners for the
+// Start will start the server environment and begins piping output to the event
-// console. If a container does not exist, or needs to be rebuilt that will happen in the
+// listeners for the console. If a container does not exist, or needs to be
-// call to OnBeforeStart().
+// rebuilt that will happen in the call to OnBeforeStart().
-func (e *Environment) Start() error {
+func (e *Environment) Start(ctx context.Context) error {
 	sawError := false
 
 	// If sawError is set to true there was an error somewhere in the pipeline that
@@ -64,7 +66,7 @@ func (e *Environment) Start() error {
 		}
 	}()
 
-	if c, err := e.client.ContainerInspect(context.Background(), e.Id); err != nil {
+	if c, err := e.ContainerInspect(ctx); err != nil {
 		// Do nothing if the container is not found, we just don't want to continue
 		// to the next block of code here. This check was inlined here to guard against
 		// a nil-pointer when checking c.State below.
@@ -78,10 +80,10 @@ func (e *Environment) Start() error {
 		if c.State.Running {
 			e.SetState(environment.ProcessRunningState)
 
-			return e.Attach()
+			return e.Attach(ctx)
 		}
 
-		// Truncate the log file so we don't end up outputting a bunch of useless log information
+		// Truncate the log file, so we don't end up outputting a bunch of useless log information
 		// to the websocket and whatnot. Check first that the path and file exist before trying
 		// to truncate them.
 		if _, err := os.Stat(c.LogPath); err == nil {
@@ -100,21 +102,33 @@ func (e *Environment) Start() error {
 	// Run the before start function and wait for it to finish. This will validate that the container
 	// exists on the system, and rebuild the container if that is required for server booting to
 	// occur.
-	if err := e.OnBeforeStart(); err != nil {
+	if err := e.OnBeforeStart(ctx); err != nil {
-		return errors.WithStackIf(err)
+		return errors.WrapIf(err, "environment/docker: failed to run pre-boot process")
 	}
 
-	ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
+	// 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.
+	actx, cancel := context.WithTimeout(ctx, time.Second*30)
 	defer cancel()
 
-	if err := e.client.ContainerStart(ctx, e.Id, types.ContainerStartOptions{}); err != nil {
+	// 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, 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()
 }
 
 // Stop stops the container that the server is running in. This will allow up to
@@ -124,9 +138,7 @@ func (e *Environment) Start() 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()
@@ -150,7 +162,7 @@ func (e *Environment) Stop() error {
 		case "SIGTERM":
 			signal = syscall.SIGTERM
 		}
-		return e.Terminate(signal)
+		return e.Terminate(ctx, signal)
 	}
 
 	// If the process is already offline don't switch it back to stopping. Just leave it how
@@ -165,8 +177,14 @@ func (e *Environment) Stop() error {
 		return e.SendCommand(s.Value)
 	}
 
-	t := time.Second * 30
+	// Allow the stop action to run for however long it takes, similar to executing a command
-	if err := e.client.ContainerStop(context.Background(), e.Id, &t); err != nil {
+	// and using a different logic pathway to wait for the container to stop successfully.
+	//
+	// Using a negative timeout here will allow the container to stop gracefully,
+	// rather than forcefully terminating it, this value MUST be at least 1
+	// second, otherwise it will be ignored.
+	timeout := -1 * time.Second
+	if err := e.client.ContainerStop(ctx, e.Id, &timeout); err != nil {
 		// If the container does not exist just mark the process as stopped and return without
 		// an error.
 		if client.IsErrNotFound(err) {
@@ -184,45 +202,66 @@ func (e *Environment) Stop() 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.
-func (e *Environment) WaitForStop(seconds uint, terminate bool) error {
+//
-	if err := e.Stop(); err != nil {
+// Calls to Environment.Terminate() in this function use the context passed
-		return err
+// 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, os.Kill)
 	}
 
-	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(seconds)*time.Second)
+	// We pass through the timed context for this stop action so that if one of the
-	defer cancel()
+	// 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")
+		}
+		return err
+	}
 
 	// 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(ctx, e.Id, container.WaitConditionNotRunning)
+	ok, errChan := e.client.ContainerWait(tctx, e.Id, container.WaitConditionNotRunning)
 	select {
 	case <-ctx.Done():
-		if ctxErr := ctx.Err(); ctxErr != nil {
+		if err := ctx.Err(); err != nil {
 			if terminate {
-				log.WithField("container_id", e.Id).Info("server did not stop in time, executing process termination")
+				return doTermination("parent-context")
-
-				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) {
+		if err == nil || client.IsErrNotFound(err) {
-			if terminate {
+			return nil
-				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 errors.WrapIf(err, "environment/docker: error waiting on container to enter \"not-running\" state")
 		}
+		if terminate {
+			if !errors.Is(err, context.DeadlineExceeded) {
+				e.log().WithField("error", err).Warn("error while waiting for container stop; terminating process")
+			}
+			return doTermination("wait")
+		}
+		return errors.WrapIf(err, "environment/docker: error waiting on container to enter \"not-running\" state")
 	case <-ok:
 	}
 
@@ -230,8 +269,8 @@ func (e *Environment) WaitForStop(seconds uint, terminate bool) error {
 }
 
 // Terminate forcefully terminates the container using the signal provided.
-func (e *Environment) Terminate(signal os.Signal) error {
+func (e *Environment) Terminate(ctx context.Context, signal os.Signal) error {
-	c, err := e.client.ContainerInspect(context.Background(), e.Id)
+	c, err := e.ContainerInspect(ctx)
 	if err != nil {
 		// Treat missing containers as an okay error state, means it is obviously
 		// already terminated at this point.
@@ -242,7 +281,7 @@ func (e *Environment) Terminate(signal os.Signal) error {
 	}
 
 	if !c.State.Running {
-		// If the container is not running but we're not already in a stopped state go ahead
+		// If the container is not running, but we're not already in a stopped state go ahead
 		// and update things to indicate we should be completely stopped now. Set to stopping
 		// first so crash detection is not triggered.
 		if e.st.Load() != environment.ProcessOfflineState {
@@ -256,7 +295,7 @@ func (e *Environment) Terminate(signal os.Signal) error {
 	// We set it to stopping than offline to prevent crash detection from being triggered.
 	e.SetState(environment.ProcessStoppingState)
 	sig := strings.TrimSuffix(strings.TrimPrefix(signal.String(), "signal "), "ed")
-	if err := e.client.ContainerKill(context.Background(), e.Id, sig); err != nil && !client.IsErrNotFound(err) {
+	if err := e.client.ContainerKill(ctx, e.Id, sig); err != nil && !client.IsErrNotFound(err) {
 		return errors.WithStack(err)
 	}
 	e.SetState(environment.ProcessOfflineState)

environment/docker/stats.go

@@ -2,14 +2,34 @@ package docker
 
 import (
 	"context"
-	"emperror.dev/errors"
-	"encoding/json"
-	"github.com/docker/docker/api/types"
-	"github.com/pterodactyl/wings/environment"
 	"io"
 	"math"
+	"time"
+
+	"emperror.dev/errors"
+	"github.com/docker/docker/api/types"
+	"github.com/goccy/go-json"
+
+	"github.com/pterodactyl/wings/environment"
 )
 
+// Uptime returns the current uptime of the container in milliseconds. If the
+// container is not currently running this will return 0.
+func (e *Environment) Uptime(ctx context.Context) (int64, error) {
+	ins, err := e.ContainerInspect(ctx)
+	if err != nil {
+		return 0, errors.Wrap(err, "environment: could not inspect container")
+	}
+	if !ins.State.Running {
+		return 0, nil
+	}
+	started, err := time.Parse(time.RFC3339, ins.State.StartedAt)
+	if err != nil {
+		return 0, errors.Wrap(err, "environment: failed to parse container start time")
+	}
+	return time.Since(started).Milliseconds(), nil
+}
+
 // Attach to the instance and then automatically emit an event whenever the resource usage for the
 // server process changes.
 func (e *Environment) pollResources(ctx context.Context) error {
@@ -26,6 +46,11 @@ func (e *Environment) pollResources(ctx context.Context) error {
 	}
 	defer stats.Body.Close()
 
+	uptime, err := e.Uptime(ctx)
+	if err != nil {
+		e.log().WithField("error", err).Warn("failed to calculate container uptime")
+	}
+
 	dec := json.NewDecoder(stats.Body)
 	for {
 		select {
@@ -48,7 +73,12 @@ func (e *Environment) pollResources(ctx context.Context) error {
 				return nil
 			}
 
+			if !v.PreRead.IsZero() {
+				uptime = uptime + v.Read.Sub(v.PreRead).Milliseconds()
+			}
+
 			st := environment.Stats{
+				Uptime:      uptime,
 				Memory:      calculateDockerMemory(v.MemoryStats),
 				MemoryLimit: v.MemoryStats.Limit,
 				CpuAbsolute: calculateDockerAbsoluteCpu(v.PreCPUStats, v.CPUStats),
@@ -60,11 +90,7 @@ func (e *Environment) pollResources(ctx context.Context) error {
 				st.Network.TxBytes += nw.TxBytes
 			}
 
-			if b, err := json.Marshal(st); err != nil {
+			e.Events().Publish(environment.ResourceEvent, st)
-				e.log().WithField("error", err).Warn("error while marshaling stats object for environment")
-			} else {
-				e.Events().Publish(environment.ResourceEvent, string(b))
-			}
 		}
 	}
 }
@@ -73,9 +99,8 @@ func (e *Environment) pollResources(ctx context.Context) error {
 // value which can be rather confusing to people trying to compare panel usage to
 // their stats output.
 //
-// This math is straight up lifted from their CLI repository in order to show the same
+// This math is from their CLI repository in order to show the same values to avoid people
-// values to avoid people bothering me about it. It should also reflect a slightly more
+// bothering me about it. It should also reflect a slightly more correct memory value anyways.
-// correct memory value anyways.
 //
 // @see https://github.com/docker/cli/blob/96e1d1d6/cli/command/container/stats_helpers.go#L227-L249
 func calculateDockerMemory(stats types.MemoryStats) uint64 {
@@ -109,7 +134,11 @@ func calculateDockerAbsoluteCpu(pStats types.CPUStats, stats types.CPUStats) flo
 
 	percent := 0.0
 	if systemDelta > 0.0 && cpuDelta > 0.0 {
-		percent = (cpuDelta / systemDelta) * cpus * 100.0
+		percent = (cpuDelta / systemDelta) * 100.0
+
+		if cpus > 0 {
+			percent *= cpus
+		}
 	}
 
 	return math.Round(percent*1000) / 1000

environment/environment.go

@@ -1,13 +1,14 @@
 package environment
 
 import (
+	"context"
 	"os"
+	"time"
 
 	"github.com/pterodactyl/wings/events"
 )
 
 const (
-	ConsoleOutputEvent       = "console output"
 	StateChangeEvent         = "state change"
 	ResourceEvent            = "resources"
 	DockerImagePullStarted   = "docker image pull started"
@@ -34,16 +35,16 @@ type ProcessEnvironment interface {
 	// Returns an event emitter instance that can be hooked into to listen for different
 	// events that are fired by the environment. This should not allow someone to publish
 	// events, only subscribe to them.
-	Events() *events.EventBus
+	Events() *events.Bus
 
 	// Determines if the server instance exists. For example, in a docker environment
 	// this should confirm that the container is created and in a bootable state. In
 	// a basic CLI environment this can probably just return true right away.
 	Exists() (bool, error)
 
-	// Determines if the environment is currently active and running a server process
+	// IsRunning determines if the environment is currently active and running
-	// for this specific server instance.
+	// a server process for this specific server instance.
-	IsRunning() (bool, error)
+	IsRunning(ctx context.Context) (bool, error)
 
 	// Performs an update of server resource limits without actually stopping the server
 	// process. This only executes if the environment supports it, otherwise it is
@@ -52,24 +53,26 @@ type ProcessEnvironment interface {
 
 	// Runs before the environment is started. If an error is returned starting will
 	// not occur, otherwise proceeds as normal.
-	OnBeforeStart() error
+	OnBeforeStart(ctx context.Context) error
 
 	// Starts a server instance. If the server instance is not in a state where it
 	// can be started an error should be returned.
-	Start() error
+	Start(ctx context.Context) error
 
-	// Stops a server instance. If the server is already stopped an error should
+	// Stop stops a server instance. If the server is already stopped an error will
-	// not be returned.
+	// not be returned, this function will act as a no-op.
-	Stop() error
+	Stop(ctx context.Context) error
 
-	// Waits for a server instance to stop gracefully. If the server is still detected
+	// WaitForStop waits for a server instance to stop gracefully. If the server is
-	// as running after seconds, an error will be returned, or the server will be terminated
+	// still detected as running after "duration", an error will be returned, or the server
-	// depending on the value of the second argument.
+	// will be terminated depending on the value of the second argument. If the context
-	WaitForStop(seconds uint, terminate bool) error
+	// 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
 
-	// Terminates a running server instance using the provided signal. If the server
+	// Terminate stops a running server instance using the provided signal. This function
-	// is not running no error should be returned.
+	// is a no-op if the server is already stopped.
-	Terminate(signal os.Signal) error
+	Terminate(ctx context.Context, signal os.Signal) error
 
 	// Destroys the environment removing any containers that were created (in Docker
 	// environments at least).
@@ -84,10 +87,10 @@ type ProcessEnvironment interface {
 	// server.
 	Create() error
 
-	// Attaches to the server console environment and allows piping the output to a
+	// Attach attaches to the server console environment and allows piping the output
-	// websocket or other internal tool to monitor output. Also allows you to later
+	// to a websocket or other internal tool to monitor output. Also allows you to later
 	// send data into the environment's stdin.
-	Attach() error
+	Attach(ctx context.Context) error
 
 	// Sends the provided command to the running server instance.
 	SendCommand(string) error
@@ -103,4 +106,11 @@ type ProcessEnvironment interface {
 	// handle this itself, but there are some scenarios where it is helpful for the server
 	// to update the state externally (e.g. starting -> started).
 	SetState(string)
+
+	// Uptime returns the current environment uptime in milliseconds. This is
+	// the time that has passed since it was last started.
+	Uptime(ctx context.Context) (int64, error)
+
+	// SetLogCallback sets the callback that the container's log output will be passed to.
+	SetLogCallback(func([]byte))
 }

environment/settings.go

@@ -6,6 +6,9 @@ import (
 	"strconv"
 
 	"github.com/apex/log"
+	"github.com/docker/docker/api/types/container"
+
+	"github.com/pterodactyl/wings/config"
 )
 
 type Mount struct {
@@ -23,13 +26,13 @@ type Mount struct {
 	// that we're mounting into the container at the Target location.
 	Source string `json:"source"`
 
-	// Whether or not the directory is being mounted as read-only. It is up to the environment to
+	// Whether the directory is being mounted as read-only. It is up to the environment to
 	// handle this value correctly and ensure security expectations are met with its usage.
 	ReadOnly bool `json:"read_only"`
 }
 
-// The build settings for a given server that impact docker container creation and
+// Limits is the build settings for a given server that impact docker container
-// resource limits for a server instance.
+// creation and resource limits for a server instance.
 type Limits struct {
 	// The total amount of memory in megabytes that this server is allowed to
 	// use on the host system.
@@ -56,51 +59,85 @@ type Limits struct {
 	OOMDisabled bool `json:"oom_disabled"`
 }
 
-// Converts the CPU limit for a server build into a number that can be better understood
+// ConvertedCpuLimit converts the CPU limit for a server build into a number
-// by the Docker environment. If there is no limit set, return -1 which will indicate to
+// that can be better understood by the Docker environment. If there is no limit
-// Docker that it has unlimited CPU quota.
+// set, return -1 which will indicate to Docker that it has unlimited CPU quota.
-func (r *Limits) ConvertedCpuLimit() int64 {
+func (l Limits) ConvertedCpuLimit() int64 {
-	if r.CpuLimit == 0 {
+	if l.CpuLimit == 0 {
 		return -1
 	}
 
-	return r.CpuLimit * 1000
+	return l.CpuLimit * 1000
 }
 
-// Set the hard limit for memory usage to be 5% more than the amount of memory assigned to
+// MemoryOverheadMultiplier sets the hard limit for memory usage to be 5% more
-// the server. If the memory limit for the server is < 4G, use 10%, if less than 2G use
+// than the amount of memory assigned to the server. If the memory limit for the
-// 15%. This avoids unexpected crashes from processes like Java which run over the limit.
+// server is < 4G, use 10%, if less than 2G use 15%. This avoids unexpected
-func (r *Limits) MemoryOverheadMultiplier() float64 {
+// crashes from processes like Java which run over the limit.
-	if r.MemoryLimit <= 2048 {
+func (l Limits) MemoryOverheadMultiplier() float64 {
-		return 1.15
+	return config.Get().Docker.Overhead.GetMultiplier(l.MemoryLimit)
-	} else if r.MemoryLimit <= 4096 {
-		return 1.10
-	}
-
-	return 1.05
 }
 
-func (r *Limits) BoundedMemoryLimit() int64 {
+func (l Limits) BoundedMemoryLimit() int64 {
-	return int64(math.Round(float64(r.MemoryLimit) * r.MemoryOverheadMultiplier() * 1_000_000))
+	return int64(math.Round(float64(l.MemoryLimit) * l.MemoryOverheadMultiplier() * 1_000_000))
 }
 
-// Returns the amount of swap available as a total in bytes. This is returned as the amount
+// ConvertedSwap returns the amount of swap available as a total in bytes. This
-// of memory available to the server initially, PLUS the amount of additional swap to include
+// is returned as the amount of memory available to the server initially, PLUS
-// which is the format used by Docker.
+// the amount of additional swap to include which is the format used by Docker.
-func (r *Limits) ConvertedSwap() int64 {
+func (l Limits) ConvertedSwap() int64 {
-	if r.Swap < 0 {
+	if l.Swap < 0 {
 		return -1
 	}
 
-	return (r.Swap * 1_000_000) + r.BoundedMemoryLimit()
+	return (l.Swap * 1_000_000) + l.BoundedMemoryLimit()
+}
+
+// ProcessLimit returns the process limit for a container. This is currently
+// defined at a system level and not on a per-server basis.
+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{
+		Memory:            l.BoundedMemoryLimit(),
+		MemoryReservation: l.MemoryLimit * 1_000_000,
+		MemorySwap:        l.ConvertedSwap(),
+		BlkioWeight:       l.IoWeight,
+		OomKillDisable:    &l.OOMDisabled,
+		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{}
 
-// Ugly hacky function to handle environment variables that get passed through as not-a-string
+// Get is an ugly hacky function to handle environment variables that get passed
-// from the Panel. Ideally we'd just say only pass strings, but that is a fragile idea and if a
+// through as not-a-string from the Panel. Ideally we'd just say only pass
-// string wasn't passed through you'd cause a crash or the server to become unavailable. For now
+// strings, but that is a fragile idea and if a string wasn't passed through
-// try to handle the most likely values from the JSON and hope for the best.
+// you'd cause a crash or the server to become unavailable. For now try to
+// handle the most likely values from the JSON and hope for the best.
 func (v Variables) Get(key string) string {
 	val, ok := v[key]
 	if !ok {

environment/stats.go

@@ -1,8 +1,6 @@
 package environment
 
-// Defines the current resource usage for a given server instance. If a server is offline you
+// Stats defines the current resource usage for a given server instance.
-// should obviously expect memory and CPU usage to be 0. However, disk will always be returned
-// since that is not dependent on the server being running to collect that data.
 type Stats struct {
 	// The total amount of memory, in bytes, that this server instance is consuming. This is
 	// calculated slightly differently than just using the raw Memory field that the stats
@@ -12,19 +10,18 @@ type Stats struct {
 
 	// The total amount of memory this container or resource can use. Inside Docker this is
 	// going to be higher than you'd expect because we're automatically allocating overhead
-	// abilities for the container, so its not going to be a perfect match.
+	// abilities for the container, so it's not going to be a perfect match.
 	MemoryLimit uint64 `json:"memory_limit_bytes"`
 
 	// The absolute CPU usage is the amount of CPU used in relation to the entire system and
 	// does not take into account any limits on the server process itself.
 	CpuAbsolute float64 `json:"cpu_absolute"`
 
-	// The current disk space being used by the server. This is cached to prevent slow lookup
-	// issues on frequent refreshes.
-	// Disk int64 `json:"disk_bytes"`
-
 	// Current network transmit in & out for a container.
 	Network NetworkStats `json:"network"`
+
+	// The current uptime of the container, in milliseconds.
+	Uptime int64 `json:"uptime"`
 }
 
 type NetworkStats struct {

events/events.go

@@ -1,122 +1,71 @@
 package events
 
 import (
-	"encoding/json"
 	"strings"
-	"sync"
 
-	"github.com/gammazero/workerpool"
+	"emperror.dev/errors"
+	"github.com/goccy/go-json"
+
+	"github.com/pterodactyl/wings/system"
 )
 
+// Event represents an Event sent over a Bus.
 type Event struct {
-	Data  string
 	Topic string
+	Data  interface{}
 }
 
-type EventBus struct {
+// Bus represents an Event Bus.
-	mu    sync.RWMutex
+type Bus struct {
-	pools map[string]*CallbackPool
+	*system.SinkPool
 }
 
-func New() *EventBus {
+// NewBus returns a new empty Bus. This is simply a nicer wrapper around the
-	return &EventBus{
+// system.SinkPool implementation that allows for more simplistic usage within
-		pools: make(map[string]*CallbackPool),
+// the codebase.
+//
+// All of the events emitted out of this bus are byte slices that can be decoded
+// back into an events.Event interface.
+func NewBus() *Bus {
+	return &Bus{
+		system.NewSinkPool(),
 	}
 }
 
-// Publish data to a given topic.
+// Publish publishes a message to the Bus.
-func (e *EventBus) Publish(topic string, data string) {
+func (b *Bus) Publish(topic string, data interface{}) {
-	t := topic
+	// 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 the send the event using the standard listener
+	// 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 {
-			t = parts[0]
+			topic = parts[0]
 		}
 	}
 
-	e.mu.RLock()
+	enc, err := json.Marshal(Event{Topic: topic, Data: data})
-	defer e.mu.RUnlock()
+	if err != nil {
-
+		panic(errors.WithStack(err))
-	// Acquire a read lock and loop over all of the channels registered for the topic. This
-	// avoids a panic crash if the process tries to unregister the channel while this routine
-	// is running.
-	if cp, ok := e.pools[t]; ok {
-		for _, callback := range cp.callbacks {
-			c := *callback
-			evt := Event{Data: data, Topic: topic}
-			// Using the workerpool with one worker allows us to execute events in a FIFO manner. Running
-			// this using goroutines would cause things such as console output to just output in random order
-			// if more than one event is fired at the same time.
-			//
-			// However, the pool submission does not block the execution of this function itself, allowing
-			// us to call publish without blocking any of the other pathways.
-			//
-			// @see https://github.com/pterodactyl/panel/issues/2303
-			cp.pool.Submit(func() {
-				c(evt)
-			})
-		}
 	}
+	b.Push(enc)
 }
 
-// Publishes a JSON message to a given topic.
+// MustDecode decodes the event byte slice back into an events.Event struct or
-func (e *EventBus) PublishJson(topic string, data interface{}) error {
+// panics if an error is encountered during this process.
-	b, err := json.Marshal(data)
+func MustDecode(data []byte) (e Event) {
-	if err != nil {
+	if err := DecodeTo(data, &e); err != nil {
-		return err
+		panic(err)
 	}
+	return
+}
 
-	e.Publish(topic, string(b))
+// 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")
+	}
 	return nil
 }
-
-// Register a callback function that will be executed each time one of the events using the topic
-// name is called.
-func (e *EventBus) On(topic string, callback *func(Event)) {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-
-	// Check if this topic has been registered at least once for the event listener, and if
-	// not create an empty struct for the topic.
-	if _, exists := e.pools[topic]; !exists {
-		e.pools[topic] = &CallbackPool{
-			callbacks: make([]*func(Event), 0),
-			pool:      workerpool.New(1),
-		}
-	}
-
-	// If this callback is not already registered as an event listener, go ahead and append
-	// it to the array of callbacks for this topic.
-	e.pools[topic].Add(callback)
-}
-
-// Removes an event listener from the bus.
-func (e *EventBus) Off(topic string, callback *func(Event)) {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-
-	if cp, ok := e.pools[topic]; ok {
-		cp.Remove(callback)
-	}
-}
-
-// Removes all of the event listeners that have been registered for any topic. Also stops the worker
-// pool to close that routine.
-func (e *EventBus) Destroy() {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-
-	// Stop every pool that exists for a given callback topic.
-	for _, cp := range e.pools {
-		cp.pool.Stop()
-	}
-
-	e.pools = make(map[string]*CallbackPool)
-}

events/events_test.go

@@ -0,0 +1,98 @@
+package events
+
+import (
+	"testing"
+	"time"
+
+	. "github.com/franela/goblin"
+)
+
+func TestNewBus(t *testing.T) {
+	g := Goblin(t)
+
+	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)
+			})
+		})
+	})
+}

events/pool.go

@@ -1,50 +0,0 @@
-package events
-
-import (
-	"reflect"
-
-	"github.com/gammazero/workerpool"
-)
-
-type CallbackPool struct {
-	callbacks []*func(Event)
-	pool      *workerpool.WorkerPool
-}
-
-// Pushes a new callback into the array of listeners for the pool.
-func (cp *CallbackPool) Add(callback *func(Event)) {
-	if cp.index(reflect.ValueOf(callback)) < 0 {
-		cp.callbacks = append(cp.callbacks, callback)
-	}
-}
-
-// Removes a callback from the array of registered callbacks if it exists.
-func (cp *CallbackPool) Remove(callback *func(Event)) {
-	i := cp.index(reflect.ValueOf(callback))
-
-	// If i < 0 it means there was no index found for the given callback, meaning it was
-	// never registered or was already unregistered from the listeners. Also double check
-	// that we didn't somehow escape the length of the topic callback (not sure how that
-	// would happen, but lets avoid a panic condition).
-	if i < 0 || i >= len(cp.callbacks) {
-		return
-	}
-
-	// We can assume that the topic still exists at this point since we acquire an exclusive
-	// lock on the process, and the "e.index" function cannot return a value >= 0 if there is
-	// no topic already existing.
-	cp.callbacks = append(cp.callbacks[:i], cp.callbacks[i+1:]...)
-}
-
-// Finds the index of a given callback in the topic by comparing all of the registered callback
-// pointers to the passed function. This function does not aquire a lock as it should only be called
-// within the confines of a function that has already acquired a lock for the duration of the lookup.
-func (cp *CallbackPool) index(v reflect.Value) int {
-	for i, handler := range cp.callbacks {
-		if reflect.ValueOf(handler).Pointer() == v.Pointer() {
-			return i
-		}
-	}
-
-	return -1
-}

go.mod

@@ -1,82 +1,124 @@
 module github.com/pterodactyl/wings
 
-go 1.14
+go 1.18
 
 require (
-	emperror.dev/errors v0.8.0
+	emperror.dev/errors v0.8.1
-	github.com/AlecAivazis/survey/v2 v2.2.7
+	github.com/AlecAivazis/survey/v2 v2.3.6
-	github.com/Jeffail/gabs/v2 v2.6.0
+	github.com/Jeffail/gabs/v2 v2.6.1
-	github.com/Microsoft/go-winio v0.4.16 // indirect
-	github.com/Microsoft/hcsshim v0.8.14 // indirect
 	github.com/NYTimes/logrotate v1.0.0
-	github.com/andybalholm/brotli v1.0.1 // indirect
+	github.com/acobaugh/osrelease v0.1.0
 	github.com/apex/log v1.9.0
-	github.com/asaskevich/govalidator v0.0.0-20200907205600-7a23bdc65eef
+	github.com/asaskevich/govalidator v0.0.0-20210307081110-f21760c49a8d
 	github.com/beevik/etree v1.1.0
-	github.com/buger/jsonparser v1.1.0
+	github.com/buger/jsonparser v1.1.1
-	github.com/cobaugh/osrelease v0.0.0-20181218015638-a93a0a55a249
+	github.com/cenkalti/backoff/v4 v4.1.3
-	github.com/containerd/containerd v1.4.3 // indirect
+	github.com/creasty/defaults v1.6.0
-	github.com/containerd/fifo v0.0.0-20201026212402-0724c46b320c // indirect
+	github.com/docker/docker v20.10.18+incompatible
-	github.com/creasty/defaults v1.5.1
-	github.com/docker/distribution v2.7.1+incompatible // indirect
-	github.com/docker/docker v20.10.1+incompatible
 	github.com/docker/go-connections v0.4.0
-	github.com/docker/go-metrics v0.0.1 // indirect
+	github.com/fatih/color v1.13.0
-	github.com/fatih/color v1.10.0
 	github.com/franela/goblin v0.0.0-20200825194134-80c0062ed6cd
-	github.com/fsnotify/fsnotify v1.4.9 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.1
-	github.com/gabriel-vasile/mimetype v1.1.2
+	github.com/gammazero/workerpool v1.1.3
-	github.com/gammazero/deque v0.0.0-20201010052221-3932da5530cc // indirect
+	github.com/gbrlsnchs/jwt/v3 v3.0.1
-	github.com/gammazero/workerpool v1.1.1
+	github.com/gin-gonic/gin v1.8.1
-	github.com/gbrlsnchs/jwt/v3 v3.0.0
+	github.com/glebarez/sqlite v1.4.8
-	github.com/gin-gonic/gin v1.6.3
+	github.com/go-co-op/gocron v1.17.0
-	github.com/go-playground/validator/v10 v10.4.1 // indirect
+	github.com/goccy/go-json v0.9.11
-	github.com/golang/snappy v0.0.2 // indirect
+	github.com/google/uuid v1.3.0
-	github.com/google/go-cmp v0.5.2 // indirect
+	github.com/gorilla/websocket v1.5.0
-	github.com/google/uuid v1.1.2
+	github.com/iancoleman/strcase v0.2.0
-	github.com/gorilla/mux v1.7.4 // indirect
+	github.com/icza/dyno v0.0.0-20220812133438-f0b6f8a18845
-	github.com/gorilla/websocket v1.4.2
+	github.com/juju/ratelimit v1.0.2
-	github.com/iancoleman/strcase v0.1.2
+	github.com/karrick/godirwalk v1.17.0
-	github.com/icza/dyno v0.0.0-20200205103839-49cb13720835
+	github.com/klauspost/compress v1.15.11
-	github.com/imdario/mergo v0.3.9
-	github.com/juju/ratelimit v1.0.1
-	github.com/karrick/godirwalk v1.16.1
-	github.com/klauspost/compress v1.11.4 // indirect
 	github.com/klauspost/pgzip v1.2.5
-	github.com/leodido/go-urn v1.2.1 // indirect
+	github.com/magiconair/properties v1.8.6
-	github.com/magefile/mage v1.10.0 // indirect
+	github.com/mattn/go-colorable v0.1.13
-	github.com/magiconair/properties v1.8.4
+	github.com/mholt/archiver/v4 v4.0.0-alpha.7
-	github.com/mattn/go-colorable v0.1.8
-	github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d // indirect
-	github.com/mholt/archiver/v3 v3.5.0
 	github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db
-	github.com/moby/term v0.0.0-20201216013528-df9cb8a40635 // indirect
-	github.com/morikuni/aec v1.0.0 // indirect
-	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
-	github.com/opencontainers/go-digest v1.0.0 // indirect
-	github.com/opencontainers/image-spec v1.0.1 // indirect
 	github.com/patrickmn/go-cache v2.1.0+incompatible
-	github.com/pierrec/lz4/v4 v4.1.2 // indirect
+	github.com/pkg/sftp v1.13.5
-	github.com/pkg/profile v1.5.0
+	github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06
-	github.com/pkg/sftp v1.12.0
+	github.com/spf13/cobra v1.5.0
-	github.com/prometheus/client_golang v1.9.0 // indirect
+	github.com/stretchr/testify v1.8.0
-	github.com/sabhiram/go-gitignore v0.0.0-20201211210132-54b8a0bf510f
+	golang.org/x/crypto v0.0.0-20220926161630-eccd6366d1be
-	github.com/sirupsen/logrus v1.7.0 // indirect
+	golang.org/x/sync v0.0.0-20220929204114-8fcdb60fdcc0
-	github.com/spf13/cobra v1.1.1
+	gopkg.in/ini.v1 v1.67.0
-	github.com/stretchr/testify v1.6.1
-	github.com/ugorji/go v1.2.2 // indirect
-	github.com/ulikunitz/xz v0.5.9 // indirect
-	golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad
-	golang.org/x/net v0.0.0-20201224014010-6772e930b67b // indirect
-	golang.org/x/sync v0.0.0-20201207232520-09787c993a3a
-	golang.org/x/sys v0.0.0-20201223074533-0d417f636930 // indirect
-	golang.org/x/term v0.0.0-20201210144234-2321bbc49cbf // indirect
-	golang.org/x/text v0.3.4 // indirect
-	golang.org/x/time v0.0.0-20201208040808-7e3f01d25324 // indirect
-	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
-	google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d // indirect
-	google.golang.org/grpc v1.34.0 // indirect
-	gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f // indirect
-	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.23.10
+)
+
+require (
+	github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 // indirect
+	github.com/Microsoft/go-winio v0.6.0 // indirect
+	github.com/Microsoft/hcsshim v0.9.4 // indirect
+	github.com/andybalholm/brotli v1.0.4 // indirect
+	github.com/beorn7/perks v1.0.1 // indirect
+	github.com/cespare/xxhash/v2 v2.1.2 // indirect
+	github.com/containerd/fifo v1.0.0 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/docker/distribution v2.8.1+incompatible // indirect
+	github.com/docker/go-metrics v0.0.1 // indirect
+	github.com/docker/go-units v0.5.0 // indirect
+	github.com/dsnet/compress v0.0.2-0.20210315054119-f66993602bf5 // indirect
+	github.com/fsnotify/fsnotify v1.5.4 // indirect
+	github.com/gammazero/deque v0.2.0 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/glebarez/go-sqlite v1.19.1 // indirect
+	github.com/go-playground/locales v0.14.0 // indirect
+	github.com/go-playground/universal-translator v0.18.0 // indirect
+	github.com/go-playground/validator/v10 v10.11.1 // indirect
+	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/golang/protobuf v1.5.2 // indirect
+	github.com/golang/snappy v0.0.4 // indirect
+	github.com/inconshreveable/mousetrap v1.0.1 // 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/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
+	github.com/kr/fs v0.1.0 // indirect
+	github.com/leodido/go-urn v1.2.1 // indirect
+	github.com/magefile/mage v1.14.0 // indirect
+	github.com/mattn/go-isatty v0.0.16 // indirect
+	github.com/matttproud/golang_protobuf_extensions v1.0.2 // indirect
+	github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d // indirect
+	github.com/moby/term v0.0.0-20220808134915-39b0c02b01ae // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/morikuni/aec v1.0.0 // indirect
+	github.com/nwaples/rardecode/v2 v2.0.0-beta.2 // indirect
+	github.com/opencontainers/go-digest v1.0.0 // indirect
+	github.com/opencontainers/image-spec v1.1.0-rc2 // indirect
+	github.com/pelletier/go-toml/v2 v2.0.5 // indirect
+	github.com/pierrec/lz4/v4 v4.1.17 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/prometheus/client_golang v1.13.0 // indirect
+	github.com/prometheus/client_model v0.2.0 // indirect
+	github.com/prometheus/common v0.37.0 // indirect
+	github.com/prometheus/procfs v0.8.0 // indirect
+	github.com/remyoudompheng/bigfft v0.0.0-20220927061507-ef77025ab5aa // indirect
+	github.com/robfig/cron/v3 v3.0.1 // indirect
+	github.com/sirupsen/logrus v1.9.0 // indirect
+	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/therootcompany/xz v1.0.1 // indirect
+	github.com/ugorji/go/codec v1.2.7 // indirect
+	github.com/ulikunitz/xz v0.5.10 // indirect
+	go.uber.org/atomic v1.10.0 // indirect
+	go.uber.org/multierr v1.8.0 // indirect
+	golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 // indirect
+	golang.org/x/net v0.0.0-20221004154528-8021a29435af // indirect
+	golang.org/x/sys v0.0.0-20220928140112-f11e5e49a4ec // indirect
+	golang.org/x/term v0.0.0-20220919170432-7a66f970e087 // indirect
+	golang.org/x/text v0.3.7 // indirect
+	golang.org/x/time v0.0.0-20220922220347-f3bd1da661af // indirect
+	golang.org/x/tools v0.1.12 // indirect
+	golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect
+	google.golang.org/protobuf v1.28.1 // indirect
+	modernc.org/libc v1.20.0 // indirect
+	modernc.org/mathutil v1.5.0 // indirect
+	modernc.org/memory v1.4.0 // indirect
+	modernc.org/sqlite v1.19.1 // indirect
 )

installer/installer.go

@@ -1,113 +0,0 @@
-package installer
-
-import (
-	"context"
-	"encoding/json"
-
-	"emperror.dev/errors"
-	"github.com/asaskevich/govalidator"
-	"github.com/buger/jsonparser"
-	"github.com/pterodactyl/wings/environment"
-	"github.com/pterodactyl/wings/remote"
-	"github.com/pterodactyl/wings/server"
-)
-
-type Installer struct {
-	server *server.Server
-}
-
-// New validates the received data to ensure that all of the required fields
-// have been passed along in the request. This should be manually run before
-// calling Execute().
-func New(ctx context.Context, manager *server.Manager, data []byte) (*Installer, error) {
-	if !govalidator.IsUUIDv4(getString(data, "uuid")) {
-		return nil, NewValidationError("uuid provided was not in a valid format")
-	}
-
-	cfg := &server.Configuration{
-		Uuid:           getString(data, "uuid"),
-		Suspended:      false,
-		Invocation:     getString(data, "invocation"),
-		SkipEggScripts: getBoolean(data, "skip_egg_scripts"),
-		Build: environment.Limits{
-			MemoryLimit: getInt(data, "build", "memory"),
-			Swap:        getInt(data, "build", "swap"),
-			IoWeight:    uint16(getInt(data, "build", "io")),
-			CpuLimit:    getInt(data, "build", "cpu"),
-			DiskSpace:   getInt(data, "build", "disk"),
-			Threads:     getString(data, "build", "threads"),
-		},
-		CrashDetectionEnabled: true,
-	}
-
-	cfg.Allocations.DefaultMapping.Ip = getString(data, "allocations", "default", "ip")
-	cfg.Allocations.DefaultMapping.Port = int(getInt(data, "allocations", "default", "port"))
-
-	// Unmarshal the environment variables from the request into the server struct.
-	if b, _, _, err := jsonparser.Get(data, "environment"); err != nil {
-		return nil, errors.WithStackIf(err)
-	} else {
-		cfg.EnvVars = make(environment.Variables)
-		if err := json.Unmarshal(b, &cfg.EnvVars); err != nil {
-			return nil, errors.WrapIf(err, "installer: could not unmarshal environment variables for server")
-		}
-	}
-
-	// Unmarshal the allocation mappings from the request into the server struct.
-	if b, _, _, err := jsonparser.Get(data, "allocations", "mappings"); err != nil {
-		return nil, errors.WithStackIf(err)
-	} else {
-		cfg.Allocations.Mappings = make(map[string][]int)
-		if err := json.Unmarshal(b, &cfg.Allocations.Mappings); err != nil {
-			return nil, errors.Wrap(err, "installer: could not unmarshal allocation mappings")
-		}
-	}
-
-	cfg.Container.Image = getString(data, "container", "image")
-
-	c, err := manager.Client().GetServerConfiguration(ctx, cfg.Uuid)
-	if err != nil {
-		if !remote.IsRequestError(err) {
-			return nil, errors.WithStackIf(err)
-		}
-		return nil, errors.WrapIf(err, "installer: could not get server configuration from remote API")
-	}
-
-	// Create a new server instance using the configuration we wrote to the disk
-	// so that everything gets instantiated correctly on the struct.
-	s, err := manager.InitServer(c)
-	if err != nil {
-		return nil, errors.WrapIf(err, "installer: could not init server instance")
-	}
-	return &Installer{server: s}, nil
-}
-
-// Uuid returns the UUID associated with this installer instance.
-func (i *Installer) Uuid() string {
-	return i.server.Id()
-}
-
-// Server returns the server instance.
-func (i *Installer) Server() *server.Server {
-	return i.server
-}
-
-// Returns a string value from the JSON data provided.
-func getString(data []byte, key ...string) string {
-	value, _ := jsonparser.GetString(data, key...)
-
-	return value
-}
-
-// Returns an int value from the JSON data provided.
-func getInt(data []byte, key ...string) int64 {
-	value, _ := jsonparser.GetInt(data, key...)
-
-	return value
-}
-
-func getBoolean(data []byte, key ...string) bool {
-	value, _ := jsonparser.GetBoolean(data, key...)
-
-	return value
-}

internal/cron/activity_cron.go

@@ -0,0 +1,86 @@
+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)
+	}
+
+	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")
+	}
+
+	// Add all the successful activities to the list of IDs to delete.
+	ids = make([]int, len(activities))
+	for i, v := range activities {
+		ids[i] = v.ID
+	}
+
+	// Delete all the activities that were sent to the Panel (or that were invalid).
+	tx = database.Instance().WithContext(ctx).Where("id IN ?", ids).Delete(&models.Activity{})
+	if tx.Error != nil {
+		return errors.WithStack(tx.Error)
+	}
+	return nil
+}

internal/cron/cron.go

@@ -0,0 +1,73 @@
+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
+}

internal/cron/sftp_cron.go

@@ -0,0 +1,177 @@
+package cron
+
+import (
+	"context"
+	"reflect"
+
+	"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 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")
+	}
+	if tx := database.Instance().Where("id IN ?", events.ids).Delete(&models.Activity{}); tx.Error != nil {
+		return errors.WithStack(tx.Error)
+	}
+	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
+}

internal/database/database.go

@@ -0,0 +1,61 @@
+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
+}

internal/models/activity.go

@@ -0,0 +1,71 @@
+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
+}

internal/models/models.go

@@ -0,0 +1,32 @@
+package models
+
+import (
+	"database/sql"
+
+	"emperror.dev/errors"
+	"github.com/goccy/go-json"
+)
+
+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
+}

internal/progress/progress.go

@@ -0,0 +1,90 @@
+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)
+}

internal/progress/progress_test.go

@@ -0,0 +1,50 @@
+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")
+		})
+	})
+}

loggers/cli/cli.go

@@ -1,22 +1,25 @@
 package cli
 
 import (
-	"emperror.dev/errors"
 	"fmt"
-	"github.com/apex/log"
-	"github.com/apex/log/handlers/cli"
-	color2 "github.com/fatih/color"
-	"github.com/mattn/go-colorable"
 	"io"
 	"os"
 	"strings"
 	"sync"
 	"time"
+
+	"emperror.dev/errors"
+	"github.com/apex/log"
+	"github.com/apex/log/handlers/cli"
+	color2 "github.com/fatih/color"
+	"github.com/mattn/go-colorable"
 )
 
-var Default = New(os.Stderr, true)
+var (
-var bold = color2.New(color2.Bold)
+	Default = New(os.Stderr, true)
-var boldred = color2.New(color2.Bold, color2.FgRed)
+	bold    = color2.New(color2.Bold)
+	boldred = color2.New(color2.Bold, color2.FgRed)
+)
 
 var Strings = [...]string{
 	log.DebugLevel: "DEBUG",

parser/helpers.go

@@ -2,7 +2,7 @@ package parser
 
 import (
 	"bytes"
-	"io/ioutil"
+	"io"
 	"os"
 	"regexp"
 	"strconv"
@@ -38,29 +38,29 @@ 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, 0644)
+	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0o644)
 	if err != nil {
 		return nil, err
 	}
 	defer file.Close()
 
-	return ioutil.ReadAll(file)
+	return io.ReadAll(file)
 }
 
 // Gets the value of a key based on the value type defined.
-func (cfr *ConfigurationFileReplacement) getKeyValue(value []byte) interface{} {
+func (cfr *ConfigurationFileReplacement) getKeyValue(value string) interface{} {
 	if cfr.ReplaceWith.Type() == jsonparser.Boolean {
-		v, _ := strconv.ParseBool(string(value))
+		v, _ := strconv.ParseBool(value)
 		return v
 	}
 
 	// Try to parse into an int, if this fails just ignore the error and continue
 	// through, returning the string.
-	if v, err := strconv.Atoi(string(value)); err == nil {
+	if v, err := strconv.Atoi(value); err == nil {
 		return v
 	}
 
-	return string(value)
+	return value
 }
 
 // Iterate over an unstructured JSON/YAML/etc. interface and set all of the required
@@ -97,22 +97,21 @@ func (f *ConfigurationFile) IterateOverJson(data []byte) (*gabs.Container, error
 			// If the child is a null value, nothing will happen. Seems reasonable as of the
 			// time this code is being written.
 			for _, child := range parsed.Path(strings.Trim(parts[0], ".")).Children() {
-				if err := v.SetAtPathway(child, strings.Trim(parts[1], "."), []byte(value)); err != nil {
+				if err := v.SetAtPathway(child, strings.Trim(parts[1], "."), value); err != nil {
 					if errors.Is(err, gabs.ErrNotFound) {
 						continue
 					}
-
 					return nil, errors.WithMessage(err, "failed to set config value of array child")
 				}
 			}
-		} else {
+			continue
-			if err = v.SetAtPathway(parsed, v.Match, []byte(value)); err != nil {
+		}
-				if errors.Is(err, gabs.ErrNotFound) {
-					continue
-				}
 
-				return nil, errors.WithMessage(err, "unable to set config value at pathway: "+v.Match)
+		if err := v.SetAtPathway(parsed, v.Match, value); err != nil {
+			if errors.Is(err, gabs.ErrNotFound) {
+				continue
 			}
+			return nil, errors.WithMessage(err, "unable to set config value at pathway: "+v.Match)
 		}
 	}
 
@@ -132,13 +131,10 @@ func setValueAtPath(c *gabs.Container, path string, value interface{}) error {
 	var err error
 
 	matches := checkForArrayElement.FindStringSubmatch(path)
-	if len(matches) < 3 {
-		// Only update the value if the pathway actually exists in the configuration, otherwise
-		// do nothing.
-		if c.ExistsP(path) {
-			_, err = c.SetP(value, path)
-		}
 
+	// Check if we are **NOT** updating an array element.
+	if len(matches) < 3 {
+		_, err = c.SetP(value, path)
 		return err
 	}
 
@@ -196,32 +192,34 @@ func setValueAtPath(c *gabs.Container, path string, value interface{}) error {
 
 // Sets the value at a specific pathway, but checks if we were looking for a specific
 // value or not before doing it.
-func (cfr *ConfigurationFileReplacement) SetAtPathway(c *gabs.Container, path string, value []byte) error {
+func (cfr *ConfigurationFileReplacement) SetAtPathway(c *gabs.Container, path string, value string) error {
 	if cfr.IfValue == "" {
 		return setValueAtPath(c, path, cfr.getKeyValue(value))
 	}
 
-	// If this is a regex based matching, we need to get a little more creative since
+	// Check if we are replacing instead of overwriting.
-	// we're only going to replacing part of the string, and not the whole thing.
+	if strings.HasPrefix(cfr.IfValue, "regex:") {
-	if c.ExistsP(path) && strings.HasPrefix(cfr.IfValue, "regex:") {
+		// Doing a regex replacement requires an existing value.
-		// We're doing some regex here.
+		// TODO: Do we try passing an empty string to the regex?
+		if c.ExistsP(path) {
+			return gabs.ErrNotFound
+		}
+
 		r, err := regexp.Compile(strings.TrimPrefix(cfr.IfValue, "regex:"))
 		if err != nil {
 			log.WithFields(log.Fields{"if_value": strings.TrimPrefix(cfr.IfValue, "regex:"), "error": err}).
 				Warn("configuration if_value using invalid regexp, cannot perform replacement")
-
 			return nil
 		}
 
-		// If the path exists and there is a regex match, go ahead and attempt the replacement
+		v := strings.Trim(c.Path(path).String(), "\"")
-		// using the value we got from the key. This will only replace the one match.
-		v := strings.Trim(string(c.Path(path).Bytes()), "\"")
 		if r.Match([]byte(v)) {
-			return setValueAtPath(c, path, r.ReplaceAllString(v, string(value)))
+			return setValueAtPath(c, path, r.ReplaceAllString(v, value))
 		}
-
 		return nil
-	} else if !c.ExistsP(path) || (c.ExistsP(path) && !bytes.Equal(c.Bytes(), []byte(cfr.IfValue))) {
+	}
+
+	if c.ExistsP(path) && !bytes.Equal(c.Bytes(), []byte(cfr.IfValue)) {
 		return nil
 	}
 

parser/parser.go

@@ -2,8 +2,6 @@ package parser
 
 import (
 	"bufio"
-	"encoding/json"
-	"io/ioutil"
 	"os"
 	"path/filepath"
 	"strconv"
@@ -13,11 +11,13 @@ import (
 	"github.com/apex/log"
 	"github.com/beevik/etree"
 	"github.com/buger/jsonparser"
+	"github.com/goccy/go-json"
 	"github.com/icza/dyno"
 	"github.com/magiconair/properties"
-	"github.com/pterodactyl/wings/config"
 	"gopkg.in/ini.v1"
-	"gopkg.in/yaml.v2"
+	"gopkg.in/yaml.v3"
+
+	"github.com/pterodactyl/wings/config"
 )
 
 // The file parsing options that are available for a server configuration file.
@@ -56,17 +56,22 @@ func (cv *ReplaceValue) Type() jsonparser.ValueType {
 // handle casting the UTF-8 sequence into the expected value, switching something
 // like "\u00a7Foo" into "§Foo".
 func (cv *ReplaceValue) String() string {
-	if cv.Type() != jsonparser.String {
+	switch cv.Type() {
-		if cv.Type() == jsonparser.Null {
+	case jsonparser.String:
-			return "<nil>"
+		str, err := jsonparser.ParseString(cv.value)
+		if err != nil {
+			panic(errors.Wrap(err, "parser: could not parse value"))
 		}
+		return str
+	case jsonparser.Null:
+		return "<nil>"
+	case jsonparser.Boolean:
+		return string(cv.value)
+	case jsonparser.Number:
+		return string(cv.value)
+	default:
 		return "<invalid>"
 	}
-	str, err := jsonparser.ParseString(cv.value)
-	if err != nil {
-		panic(errors.Wrap(err, "parser: could not parse value"))
-	}
-	return str
 }
 
 type ConfigurationParser string
@@ -75,8 +80,8 @@ func (cp ConfigurationParser) String() string {
 	return string(cp)
 }
 
-// Defines a configuration file for the server startup. These will be looped over
+// ConfigurationFile defines a configuration file for the server startup. These
-// and modified before the server finishes booting.
+// will be looped over and modified before the server finishes booting.
 type ConfigurationFile struct {
 	FileName string                         `json:"file"`
 	Parser   ConfigurationParser            `json:"parser"`
@@ -87,12 +92,10 @@ type ConfigurationFile struct {
 	configuration []byte
 }
 
-// Custom unmarshaler for configuration files. If there is an error while parsing out the
+// UnmarshalJSON is a custom unmarshaler for configuration files. If there is an
-// replacements, don't fail the entire operation, just log a global warning so someone can
+// error while parsing out the replacements, don't fail the entire operation,
-// find the issue, and return an empty array of replacements.
+// just log a global warning so someone can find the issue, and return an empty
-//
+// array of replacements.
-// I imagine people will notice configuration replacement isn't working correctly and then
-// the logs should help better expose that issue.
 func (f *ConfigurationFile) UnmarshalJSON(data []byte) error {
 	var m map[string]*json.RawMessage
 	if err := json.Unmarshal(data, &m); err != nil {
@@ -206,7 +209,7 @@ func (f *ConfigurationFile) Parse(path string, internal bool) error {
 		}
 
 		b := strings.TrimSuffix(path, filepath.Base(path))
-		if err := os.MkdirAll(b, 0755); err != nil {
+		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 {
@@ -223,7 +226,7 @@ func (f *ConfigurationFile) Parse(path string, internal bool) error {
 // Parses an xml file.
 func (f *ConfigurationFile) parseXmlFile(path string) error {
 	doc := etree.NewDocument()
-	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0644)
+	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0o644)
 	if err != nil {
 		return err
 	}
@@ -316,7 +319,7 @@ 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, 0644)
+	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0o644)
 	if err != nil {
 		return err
 	}
@@ -328,7 +331,29 @@ func (f *ConfigurationFile) parseIniFile(path string) error {
 	}
 
 	for _, replacement := range f.Replace {
-		path := strings.SplitN(replacement.Match, ".", 2)
+		var (
+			path         []string
+			bracketDepth int
+			v            []int32
+		)
+		for _, c := range replacement.Match {
+			switch c {
+			case '[':
+				bracketDepth++
+			case ']':
+				bracketDepth--
+			case '.':
+				if bracketDepth > 0 || len(path) == 1 {
+					v = append(v, c)
+					continue
+				}
+				path = append(path, string(v))
+				v = v[:0]
+			default:
+				v = append(v, c)
+			}
+		}
+		path = append(path, string(v))
 
 		value, err := f.LookupConfigurationValue(replacement)
 		if err != nil {
@@ -381,7 +406,7 @@ func (f *ConfigurationFile) parseJsonFile(path string) error {
 	}
 
 	output := []byte(data.StringIndent("", "    "))
-	return ioutil.WriteFile(path, output, 0644)
+	return os.WriteFile(path, output, 0o644)
 }
 
 // Parses a yaml file and updates any matching key/value pairs before persisting
@@ -418,14 +443,14 @@ func (f *ConfigurationFile) parseYamlFile(path string) error {
 		return err
 	}
 
-	return ioutil.WriteFile(path, marshaled, 0644)
+	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(path string) error {
-	input, err := ioutil.ReadFile(path)
+	input, err := os.ReadFile(path)
 	if err != nil {
 		return err
 	}
@@ -443,7 +468,7 @@ func (f *ConfigurationFile) parseTextFile(path string) error {
 		}
 	}
 
-	if err := ioutil.WriteFile(path, []byte(strings.Join(lines, "\n")), 0644); err != nil {
+	if err := os.WriteFile(path, []byte(strings.Join(lines, "\n")), 0o644); err != nil {
 		return err
 	}
 
@@ -539,7 +564,7 @@ func (f *ConfigurationFile) parsePropertiesFile(path string) error {
 	}
 
 	// Open the file for writing.
-	w, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
+	w, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0o644)
 	if err != nil {
 		return err
 	}

remote/errors.go

@@ -3,6 +3,8 @@ package remote
 import (
 	"fmt"
 	"net/http"
+
+	"emperror.dev/errors"
 )
 
 type RequestErrors struct {
@@ -16,13 +18,31 @@ type RequestError struct {
 	Detail   string `json:"detail"`
 }
 
+// IsRequestError checks if the given error is of the RequestError type.
 func IsRequestError(err error) bool {
-	_, ok := err.(*RequestError)
+	var rerr *RequestError
-
+	if err == nil {
-	return ok
+		return false
+	}
+	return errors.As(err, &rerr)
 }
 
-// Returns the error response in a string form that can be more easily consumed.
+// AsRequestError transforms the error into a RequestError if it is currently
+// one, checking the wrap status from the other error handlers. If the error
+// is not a RequestError nil is returned.
+func AsRequestError(err error) *RequestError {
+	if err == nil {
+		return nil
+	}
+	var rerr *RequestError
+	if errors.As(err, &rerr) {
+		return rerr
+	}
+	return nil
+}
+
+// Error returns the error response in a string form that can be more easily
+// consumed.
 func (re *RequestError) Error() string {
 	c := 0
 	if re.response != nil {
@@ -32,9 +52,13 @@ func (re *RequestError) Error() string {
 	return fmt.Sprintf("Error response from Panel: %s: %s (HTTP/%d)", re.Code, re.Detail, c)
 }
 
-type SftpInvalidCredentialsError struct {
+// StatusCode returns the status code of the response.
+func (re *RequestError) StatusCode() int {
+	return re.response.StatusCode
 }
 
+type SftpInvalidCredentialsError struct{}
+
 func (ice SftpInvalidCredentialsError) Error() string {
 	return "the credentials provided were invalid"
 }

remote/http.go

@@ -3,16 +3,20 @@ package remote
 import (
 	"bytes"
 	"context"
-	"encoding/json"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"net/http"
+	"strconv"
 	"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"
 )
 
@@ -25,17 +29,18 @@ 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, successful bool) error
+	SetInstallationStatus(ctx context.Context, uuid string, data InstallStatusRequest) 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 {
-	httpClient *http.Client
+	httpClient  *http.Client
-	baseUrl    string
+	baseUrl     string
-	tokenId    string
+	tokenId     string
-	token      string
+	token       string
-	attempts   int
+	maxAttempts int
 }
 
 // New returns a new HTTP request client that is used for making authenticated
@@ -46,7 +51,7 @@ func New(base string, opts ...ClientOption) Client {
 		httpClient: &http.Client{
 			Timeout: time.Second * 15,
 		},
-		attempts: 1,
+		maxAttempts: 0,
 	}
 	for _, opt := range opts {
 		opt(&c)
@@ -71,11 +76,31 @@ func WithHttpClient(httpClient *http.Client) ClientOption {
 	}
 }
 
+// Get executes a HTTP GET request.
+func (c *client) Get(ctx context.Context, path string, query q) (*Response, error) {
+	return c.request(ctx, http.MethodGet, path, nil, func(r *http.Request) {
+		q := r.URL.Query()
+		for k, v := range query {
+			q.Set(k, v)
+		}
+		r.URL.RawQuery = q.Encode()
+	})
+}
+
+// Post executes a HTTP POST request.
+func (c *client) Post(ctx context.Context, path string, data interface{}) (*Response, error) {
+	b, err := json.Marshal(data)
+	if err != nil {
+		return nil, err
+	}
+	return c.request(ctx, http.MethodPost, path, bytes.NewBuffer(b))
+}
+
 // requestOnce creates a http request and executes it once. Prefer request()
 // over this method when possible. It appends the path to the endpoint of the
 // client and adds the authentication token to the request.
 func (c *client) requestOnce(ctx context.Context, method, path string, body io.Reader, opts ...func(r *http.Request)) (*Response, error) {
-	req, err := http.NewRequest(method, c.baseUrl+path, body)
+	req, err := http.NewRequestWithContext(ctx, method, c.baseUrl+path, body)
 	if err != nil {
 		return nil, err
 	}
@@ -92,45 +117,93 @@ func (c *client) requestOnce(ctx context.Context, method, path string, body io.R
 
 	debugLogRequest(req)
 
-	res, err := c.httpClient.Do(req.WithContext(ctx))
+	res, err := c.httpClient.Do(req)
 	return &Response{res}, err
 }
 
-// request executes a http request and attempts when errors occur.
+// request executes an HTTP request against the Panel API. If there is an error
-// It appends the path to the endpoint of the client and adds the authentication token to the request.
+// encountered with the request it will be retried using an exponential backoff.
-func (c *client) request(ctx context.Context, method, path string, body io.Reader, opts ...func(r *http.Request)) (res *Response, err error) {
+// If the error returned from the Panel is due to API throttling or because there
-	for i := 0; i < c.attempts; i++ {
+// are invalid authentication credentials provided the request will _not_ be
-		res, err = c.requestOnce(ctx, method, path, body, opts...)
+// retried by the backoff.
-		if err == nil &&
+//
-			res.StatusCode < http.StatusInternalServerError &&
+// This function automatically appends the path to the current client endpoint
-			res.StatusCode != http.StatusTooManyRequests {
+// and adds the required authentication headers to the request that is being
-			break
+// 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) {
+	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...)
-	if err != nil {
+		if err != nil {
-		return nil, errors.WithStack(err)
+			if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
-	}
+				return backoff.Permanent(err)
-	return
+			}
-}
+			return errors.WrapIf(err, "http: request creation failed")
-
-// get executes a http get request.
-func (c *client) get(ctx context.Context, path string, query q) (*Response, error) {
-	return c.request(ctx, http.MethodGet, path, nil, func(r *http.Request) {
-		q := r.URL.Query()
-		for k, v := range query {
-			q.Set(k, v)
 		}
-		r.URL.RawQuery = q.Encode()
+		res = r
-	})
+		if r.HasError() {
-}
+			// Close the request body after returning the error to free up resources.
-
+			defer r.Body.Close()
-// post executes a http post request.
+			// Don't keep attempting to access this endpoint if the response is a 4XX
-func (c *client) post(ctx context.Context, path string, data interface{}) (*Response, error) {
+			// level error which indicates a client mistake. Only retry when the error
-	b, err := json.Marshal(data)
+			// is due to a server issue (5XX error).
+			if r.StatusCode >= 400 && r.StatusCode < 500 {
+				return backoff.Permanent(r.Error())
+			}
+			return r.Error()
+		}
+		return nil
+	}, c.backoff(ctx))
 	if err != nil {
+		if v, ok := err.(*backoff.PermanentError); ok {
+			return nil, v.Unwrap()
+		}
 		return nil, err
 	}
-	return c.request(ctx, http.MethodPost, path, bytes.NewBuffer(b))
+	return res, nil
+}
+
+// backoff returns an exponential backoff function for use with remote API
+// requests. This will allow an API call to be executed approximately 10 times
+// before it is finally reported back as an error.
+//
+// This allows for issues with DNS resolution, or rare race conditions due to
+// slower SQL queries on the Panel to potentially self-resolve without just
+// immediately failing the first request. The example below shows the amount of
+// time that has elapsed between each call to the handler when an error is
+// returned. You can tweak these values as needed to get the effect you desire.
+//
+// If maxAttempts is a value greater than 0 the backoff will be capped at a total
+// number of executions, or the MaxElapsedTime, whichever comes first.
+//
+// call(): 0s
+// call(): 552.330144ms
+// call(): 1.63271196s
+// call(): 2.94284202s
+// call(): 4.525234711s
+// call(): 6.865723375s
+// call(): 11.37194223s
+// call(): 14.593421816s
+// call(): 20.202045293s
+// call(): 27.36567952s <-- Stops here as MaxElapsedTime is 30 seconds
+func (c *client) backoff(ctx context.Context) backoff.BackOffContext {
+	b := backoff.NewExponentialBackOff()
+	b.MaxInterval = time.Second * 12
+	b.MaxElapsedTime = time.Second * 30
+	if c.maxAttempts > 0 {
+		return backoff.WithContext(backoff.WithMaxRetries(b, uint64(c.maxAttempts)), ctx)
+	}
+	return backoff.WithContext(b, ctx)
 }
 
 // Response is a custom response type that allows for commonly used error
@@ -157,15 +230,12 @@ func (r *Response) HasError() bool {
 func (r *Response) Read() ([]byte, error) {
 	var b []byte
 	if r.Response == nil {
-		return nil, errors.New("http: attempting to read missing response")
+		return nil, errors.New("remote: attempting to read missing response")
 	}
-
 	if r.Response.Body != nil {
-		b, _ = ioutil.ReadAll(r.Response.Body)
+		b, _ = io.ReadAll(r.Response.Body)
 	}
-
+	r.Response.Body = io.NopCloser(bytes.NewBuffer(b))
-	r.Response.Body = ioutil.NopCloser(bytes.NewBuffer(b))
-
 	return b, nil
 }
 
@@ -177,15 +247,16 @@ func (r *Response) BindJSON(v interface{}) error {
 	if err != nil {
 		return err
 	}
-
 	if err := json.Unmarshal(b, &v); err != nil {
-		return errors.Wrap(err, "http: could not unmarshal response")
+		return errors.Wrap(err, "remote: could not unmarshal response")
 	}
 	return nil
 }
 
 // Returns the first error message from the API call as a string. The error
-// message will be formatted similar to the below example:
+// message will be formatted similar to the below example. If there is no error
+// that can be parsed out of the API you'll still get a RequestError returned
+// but the RequestError.Code will be "_MissingResponseCode".
 //
 // HttpNotFoundException: The requested resource does not exist. (HTTP/404)
 func (r *Response) Error() error {
@@ -196,14 +267,18 @@ func (r *Response) Error() error {
 	var errs RequestErrors
 	_ = r.BindJSON(&errs)
 
-	e := &RequestError{}
+	e := &RequestError{
+		Code:   "_MissingResponseCode",
+		Status: strconv.Itoa(r.StatusCode),
+		Detail: "No error response returned from API endpoint.",
+	}
 	if len(errs.Errors) > 0 {
 		e = &errs.Errors[0]
 	}
 
 	e.response = r.Response
 
-	return e
+	return errors.WithStackDepth(e, 1)
 }
 
 // Logs the request into the debug log with all of the important request bits.

remote/http_test.go

@@ -12,12 +12,11 @@ import (
 func createTestClient(h http.HandlerFunc) (*client, *httptest.Server) {
 	s := httptest.NewServer(h)
 	c := &client{
-		httpClient: s.Client(),
+		httpClient:  s.Client(),
-		baseUrl:    s.URL,
+		baseUrl:     s.URL,
-
+		maxAttempts: 1,
-		attempts: 1,
+		tokenId:     "testid",
-		tokenId:  "testid",
+		token:       "testtoken",
-		token:    "testtoken",
 	}
 	return c, s
 }
@@ -47,7 +46,7 @@ func TestRequestRetry(t *testing.T) {
 		}
 		i++
 	})
-	c.attempts = 2
+	c.maxAttempts = 2
 	r, err := c.request(context.Background(), "", "", nil)
 	assert.NoError(t, err)
 	assert.NotNil(t, r)
@@ -60,12 +59,15 @@ func TestRequestRetry(t *testing.T) {
 		rw.WriteHeader(http.StatusInternalServerError)
 		i++
 	})
-	c.attempts = 2
+	c.maxAttempts = 2
 	r, err = c.request(context.Background(), "get", "", nil)
-	assert.NoError(t, err)
+	assert.Error(t, err)
-	assert.NotNil(t, r)
+	assert.Nil(t, r)
-	assert.Equal(t, http.StatusInternalServerError, r.StatusCode)
+
-	assert.Equal(t, 2, i)
+	v := AsRequestError(err)
+	assert.NotNil(t, v)
+	assert.Equal(t, http.StatusInternalServerError, v.StatusCode())
+	assert.Equal(t, 3, i)
 }
 
 func TestGet(t *testing.T) {
@@ -74,7 +76,7 @@ func TestGet(t *testing.T) {
 		assert.Len(t, r.URL.Query(), 1)
 		assert.Equal(t, "world", r.URL.Query().Get("hello"))
 	})
-	r, err := c.get(context.Background(), "/test", q{"hello": "world"})
+	r, err := c.Get(context.Background(), "/test", q{"hello": "world"})
 	assert.NoError(t, err)
 	assert.NotNil(t, r)
 }
@@ -85,9 +87,8 @@ func TestPost(t *testing.T) {
 	}
 	c, _ := createTestClient(func(rw http.ResponseWriter, r *http.Request) {
 		assert.Equal(t, http.MethodPost, r.Method)
-
 	})
-	r, err := c.post(context.Background(), "/test", test)
+	r, err := c.Post(context.Background(), "/test", test)
 	assert.NoError(t, err)
 	assert.NotNil(t, r)
 }

remote/servers.go

@@ -6,6 +6,8 @@ import (
 	"strconv"
 	"sync"
 
+	"github.com/pterodactyl/wings/internal/models"
+
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"golang.org/x/sync/errgroup"
@@ -17,7 +19,7 @@ const (
 	ProcessStopNativeStop = "stop"
 )
 
-// GetServers returns all of the servers that are present on the Panel making
+// GetServers returns all 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) {
@@ -56,64 +58,56 @@ 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 of the servers.
+// has fully booted all the servers.
 func (c *client) ResetServersState(ctx context.Context) error {
-	res, err := c.post(ctx, "/servers/reset", nil)
+	res, err := c.Post(ctx, "/servers/reset", nil)
 	if err != nil {
-		return errors.WrapIf(err, "remote/servers: failed to reset server state on Panel")
+		return errors.WrapIf(err, "remote: failed to reset server state on Panel")
 	}
-	res.Body.Close()
+	_ = res.Body.Close()
 	return nil
 }
 
 func (c *client) GetServerConfiguration(ctx context.Context, uuid string) (ServerConfigurationResponse, error) {
 	var config ServerConfigurationResponse
-	res, err := c.get(ctx, fmt.Sprintf("/servers/%s", uuid), nil)
+	res, err := c.Get(ctx, fmt.Sprintf("/servers/%s", uuid), nil)
 	if err != nil {
 		return config, err
 	}
 	defer res.Body.Close()
 
-	if res.HasError() {
-		return config, res.Error()
-	}
-
 	err = res.BindJSON(&config)
 	return config, err
 }
 
 func (c *client) GetInstallationScript(ctx context.Context, uuid string) (InstallationScript, error) {
-	res, err := c.get(ctx, fmt.Sprintf("/servers/%s/install", uuid), nil)
+	res, err := c.Get(ctx, fmt.Sprintf("/servers/%s/install", uuid), nil)
 	if err != nil {
 		return InstallationScript{}, err
 	}
 	defer res.Body.Close()
 
-	if res.HasError() {
-		return InstallationScript{}, res.Error()
-	}
-
 	var config InstallationScript
 	err = res.BindJSON(&config)
 	return config, err
 }
 
-func (c *client) SetInstallationStatus(ctx context.Context, uuid string, successful bool) error {
+func (c *client) SetInstallationStatus(ctx context.Context, uuid string, data InstallStatusRequest) error {
-	resp, err := c.post(ctx, fmt.Sprintf("/servers/%s/install", uuid), d{"successful": successful})
+	resp, err := c.Post(ctx, fmt.Sprintf("/servers/%s/install", uuid), data)
 	if err != nil {
 		return err
 	}
-	defer resp.Body.Close()
+	_ = resp.Body.Close()
-	return resp.Error()
+	return nil
 }
 
 func (c *client) SetArchiveStatus(ctx context.Context, uuid string, successful bool) error {
-	resp, err := c.post(ctx, fmt.Sprintf("/servers/%s/archive", uuid), d{"successful": successful})
+	resp, err := c.Post(ctx, fmt.Sprintf("/servers/%s/archive", uuid), d{"successful": successful})
 	if err != nil {
 		return err
 	}
-	defer resp.Body.Close()
+	_ = resp.Body.Close()
-	return resp.Error()
+	return nil
 }
 
 func (c *client) SetTransferStatus(ctx context.Context, uuid string, successful bool) error {
@@ -121,81 +115,79 @@ func (c *client) SetTransferStatus(ctx context.Context, uuid string, successful
 	if successful {
 		state = "success"
 	}
-	resp, err := c.get(ctx, fmt.Sprintf("/servers/%s/transfer/%s", uuid, state), nil)
+	resp, err := c.Post(ctx, fmt.Sprintf("/servers/%s/transfer/%s", uuid, state), nil)
 	if err != nil {
 		return err
 	}
-	defer resp.Body.Close()
+	_ = resp.Body.Close()
-	return resp.Error()
+	return nil
 }
 
 // ValidateSftpCredentials makes a request to determine if the username and
 // 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 of the authorization security logic to the Panel.
+// all 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)
+	res, err := c.Post(ctx, "/sftp/auth", request)
 	if err != nil {
+		if err := AsRequestError(err); err != nil && (err.StatusCode() >= 400 && err.StatusCode() < 500) {
+			log.WithFields(log.Fields{"subsystem": "sftp", "username": request.User, "ip": request.IP}).Warn(err.Error())
+			return auth, &SftpInvalidCredentialsError{}
+		}
 		return auth, err
 	}
 	defer res.Body.Close()
 
-	e := res.Error()
+	if err := res.BindJSON(&auth); err != nil {
-	if e != nil {
+		return auth, err
-		if res.StatusCode >= 400 && res.StatusCode < 500 {
-			log.WithFields(log.Fields{
-				"subsystem": "sftp",
-				"username":  request.User,
-				"ip":        request.IP,
-			}).Warn(e.Error())
-
-			return auth, &SftpInvalidCredentialsError{}
-		}
-
-		return auth, errors.New(e.Error())
 	}
-
+	return auth, nil
-	err = res.BindJSON(&auth)
-	return auth, err
 }
 
 func (c *client) GetBackupRemoteUploadURLs(ctx context.Context, backup string, size int64) (BackupRemoteUploadResponse, error) {
 	var data BackupRemoteUploadResponse
-	res, err := c.get(ctx, fmt.Sprintf("/backups/%s", backup), q{"size": strconv.FormatInt(size, 10)})
+	res, err := c.Get(ctx, fmt.Sprintf("/backups/%s", backup), q{"size": strconv.FormatInt(size, 10)})
 	if err != nil {
 		return data, err
 	}
 	defer res.Body.Close()
-
+	if err := res.BindJSON(&data); err != nil {
-	if res.HasError() {
+		return data, err
-		return data, res.Error()
 	}
-
+	return data, nil
-	err = res.BindJSON(&data)
-	return data, err
 }
 
 func (c *client) SetBackupStatus(ctx context.Context, backup string, data BackupRequest) error {
-	resp, err := c.post(ctx, fmt.Sprintf("/backups/%s", backup), data)
+	resp, err := c.Post(ctx, fmt.Sprintf("/backups/%s", backup), data)
 	if err != nil {
 		return err
 	}
-	defer resp.Body.Close()
+	_ = resp.Body.Close()
-	return resp.Error()
+	return nil
 }
 
 // SendRestorationStatus triggers a request to the Panel to notify it that a
 // restoration has been completed and the server should be marked as being
 // activated again.
 func (c *client) SendRestorationStatus(ctx context.Context, backup string, successful bool) error {
-	resp, err := c.post(ctx, fmt.Sprintf("/backups/%s/restore", backup), d{"successful": successful})
+	resp, err := c.Post(ctx, fmt.Sprintf("/backups/%s/restore", backup), d{"successful": successful})
 	if err != nil {
 		return err
 	}
-	defer resp.Body.Close()
+	_ = resp.Body.Close()
-	return resp.Error()
+	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
@@ -206,7 +198,7 @@ func (c *client) getServersPaged(ctx context.Context, page, limit int) ([]RawSer
 		Meta Pagination      `json:"meta"`
 	}
 
-	res, err := c.get(ctx, "/servers", q{
+	res, err := c.Get(ctx, "/servers", q{
 		"page":     strconv.Itoa(page),
 		"per_page": strconv.Itoa(limit),
 	})
@@ -214,10 +206,6 @@ func (c *client) getServersPaged(ctx context.Context, page, limit int) ([]RawSer
 		return nil, r.Meta, err
 	}
 	defer res.Body.Close()
-
-	if res.HasError() {
-		return nil, r.Meta, res.Error()
-	}
 	if err := res.BindJSON(&r); err != nil {
 		return nil, r.Meta, err
 	}

remote/types.go

@@ -1,14 +1,21 @@
 package remote
 
 import (
-	"encoding/json"
+	"bytes"
 	"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.
@@ -32,7 +39,7 @@ type Pagination struct {
 
 // ServerConfigurationResponse holds the server configuration data returned from
 // the Panel. When a server process is started, Wings communicates with the
-// Panel to fetch the latest build information as well as get all of the details
+// Panel to fetch the latest build information as well as get all the details
 // needed to parse the given Egg.
 //
 // This means we do not need to hit Wings each time part of the server is
@@ -61,14 +68,17 @@ 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 {
-	User          string `json:"username"`
+	Type          SftpAuthRequestType `json:"type"`
-	Pass          string `json:"password"`
+	User          string              `json:"username"`
-	IP            string `json:"ip"`
+	Pass          string              `json:"password"`
-	SessionID     []byte `json:"session_id"`
+	IP            string              `json:"ip"`
-	ClientVersion []byte `json:"client_version"`
+	SessionID     []byte              `json:"session_id"`
+	ClientVersion []byte              `json:"client_version"`
 }
 
 // SftpAuthResponse is returned by the Panel when a pair of SFTP credentials
@@ -77,44 +87,45 @@ type SftpAuthRequest struct {
 // user for the SFTP subsystem.
 type SftpAuthResponse struct {
 	Server      string   `json:"server"`
-	Token       string   `json:"token"`
+	User        string   `json:"user"`
 	Permissions []string `json:"permissions"`
 }
 
 type OutputLineMatcher struct {
-	// The raw string to match against. This may or may not be prefixed with
+	// raw string to match against. This may or may not be prefixed with
-	// regex: which indicates we want to match against the regex expression.
+	// `regex:` which indicates we want to match against the regex expression.
-	raw string
+	raw []byte
 	reg *regexp.Regexp
 }
 
-// Matches determines if a given string "s" matches the given line.
+// Matches determines if the provided byte string matches the given regex or
-func (olm *OutputLineMatcher) Matches(s string) bool {
+// raw string provided to the matcher.
+func (olm *OutputLineMatcher) Matches(s []byte) bool {
 	if olm.reg == nil {
-		return strings.Contains(s, olm.raw)
+		return bytes.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 olm.raw
+	return string(olm.raw)
 }
 
 // UnmarshalJSON unmarshals the startup lines into individual structs for easier
 // matching abilities.
 func (olm *OutputLineMatcher) UnmarshalJSON(data []byte) error {
-	if err := json.Unmarshal(data, &olm.raw); err != nil {
+	var r string
+	if err := json.Unmarshal(data, &r); err != nil {
 		return err
 	}
 
-	if strings.HasPrefix(olm.raw, "regex:") && len(olm.raw) > 6 {
+	olm.raw = []byte(r)
-		r, err := regexp.Compile(strings.TrimPrefix(olm.raw, "regex:"))
+	if bytes.HasPrefix(olm.raw, []byte("regex:")) && len(olm.raw) > 6 {
+		r, err := regexp.Compile(strings.TrimPrefix(string(olm.raw), "regex:"))
 		if err != nil {
-			log.WithField("error", err).WithField("raw", olm.raw).Warn("failed to compile output line marked as being regex")
+			log.WithField("error", err).WithField("raw", string(olm.raw)).Warn("failed to compile output line marked as being regex")
 		}
-
 		olm.reg = r
 	}
 
@@ -128,9 +139,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
+// instance. This sets what Wings is looking for to mark a server as done
-// what to do when stopping, and what changes to make to the configuration file
+// starting what to do when stopping, and what changes to make to the
-// for a server.
+// configuration file for a server.
 type ProcessConfiguration struct {
 	Startup struct {
 		Done            []*OutputLineMatcher `json:"done"`
@@ -146,9 +157,20 @@ type BackupRemoteUploadResponse struct {
 	PartSize int64    `json:"part_size"`
 }
 
-type BackupRequest struct {
+type BackupPart struct {
-	Checksum     string `json:"checksum"`
+	ETag       string `json:"etag"`
-	ChecksumType string `json:"checksum_type"`
+	PartNumber int    `json:"part_number"`
-	Size         int64  `json:"size"`
+}
-	Successful   bool   `json:"successful"`
+
+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"`
 }

router/downloader/downloader.go

@@ -2,26 +2,27 @@ package downloader
 
 import (
 	"context"
-	"emperror.dev/errors"
-	"encoding/json"
 	"fmt"
-	"github.com/google/uuid"
-	"github.com/pterodactyl/wings/server"
 	"io"
+	"mime"
 	"net"
 	"net/http"
 	"net/url"
 	"path/filepath"
-	"regexp"
-	"strconv"
 	"strings"
 	"sync"
 	"time"
+
+	"emperror.dev/errors"
+	"github.com/goccy/go-json"
+	"github.com/google/uuid"
+
+	"github.com/pterodactyl/wings/server"
 )
 
 var client = &http.Client{
 	Timeout: time.Hour * 12,
-	// Disallow any redirect on a HTTP call. This is a security requirement: do not modify
+	// 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.
 	//
@@ -36,18 +37,14 @@ var client = &http.Client{
 }
 
 var instance = &Downloader{
-	// Tracks all of the active downloads.
+	// Tracks all the active downloads.
 	downloadCache: make(map[string]*Download),
-	// Tracks all of the downloads active for a given server instance. This is
+	// Tracks all the downloads active for a given server instance. This is
 	// primarily used to make things quicker and keep the code a little more
 	// legible throughout here.
 	serverCache: make(map[string][]string),
 }
 
-// Regex to match the end of an IPv4/IPv6 address. This allows the port to be removed
-// so that we are just working with the raw IP address in question.
-var ipMatchRegex = regexp.MustCompile(`(:\d+)$`)
-
 // Internal IP ranges that should be blocked if the resource requested resolves within.
 var internalRanges = []*net.IPNet{
 	mustParseCIDR("127.0.0.1/8"),
@@ -60,9 +57,11 @@ var internalRanges = []*net.IPNet{
 	mustParseCIDR("fc00::/7"),
 }
 
-const ErrInternalResolution = errors.Sentinel("downloader: destination resolves to internal network location")
+const (
-const ErrInvalidIPAddress = errors.Sentinel("downloader: invalid IP address")
+	ErrInternalResolution = errors.Sentinel("downloader: destination resolves to internal network location")
-const ErrDownloadFailed = errors.Sentinel("downloader: download request failed")
+	ErrInvalidIPAddress   = errors.Sentinel("downloader: invalid IP address")
+	ErrDownloadFailed     = errors.Sentinel("downloader: download request failed")
+)
 
 type Counter struct {
 	total   int
@@ -77,12 +76,15 @@ func (c *Counter) Write(p []byte) (int, error) {
 }
 
 type DownloadRequest struct {
-	URL       *url.URL
 	Directory string
+	URL       *url.URL
+	FileName  string
+	UseHeader bool
 }
 
 type Download struct {
 	Identifier string
+	path       string
 	mu         sync.RWMutex
 	req        DownloadRequest
 	server     *server.Server
@@ -90,7 +92,7 @@ type Download struct {
 	cancelFunc *context.CancelFunc
 }
 
-// Starts a new tracked download which allows for cancellation later on by calling
+// New starts a new tracked download which allows for cancellation later on by calling
 // the Downloader.Cancel function.
 func New(s *server.Server, r DownloadRequest) *Download {
 	dl := Download{
@@ -102,14 +104,14 @@ func New(s *server.Server, r DownloadRequest) *Download {
 	return &dl
 }
 
-// Returns all of the tracked downloads for a given server instance.
+// ByServer returns all the tracked downloads for a given server instance.
 func ByServer(sid string) []*Download {
 	instance.mu.Lock()
 	defer instance.mu.Unlock()
 	var downloads []*Download
 	if v, ok := instance.serverCache[sid]; ok {
 		for _, id := range v {
-			if dl, dlok := instance.downloadCache[id]; dlok {
+			if dl, ok := instance.downloadCache[id]; ok {
 				downloads = append(downloads, dl)
 			}
 		}
@@ -117,7 +119,7 @@ func ByServer(sid string) []*Download {
 	return downloads
 }
 
-// Returns a single Download matching a given identifier. If no download is found
+// ByID returns a single Download matching a given identifier. If no download is found
 // the second argument in the response will be false.
 func ByID(dlid string) *Download {
 	return instance.find(dlid)
@@ -134,7 +136,7 @@ func (dl Download) MarshalJSON() ([]byte, error) {
 	})
 }
 
-// Executes a given download for the server and begins writing the file to the disk. Once
+// Execute executes a given download for the server and begins writing the file to the disk. Once
 // completed the download will be removed from the cache.
 func (dl *Download) Execute() error {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Hour*12)
@@ -174,8 +176,28 @@ func (dl *Download) Execute() error {
 		}
 	}
 
-	fnameparts := strings.Split(dl.req.URL.Path, "/")
+	if dl.req.UseHeader {
-	p := filepath.Join(dl.req.Directory, fnameparts[len(fnameparts)-1])
+		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]
+		}
+	}
+
+	p := dl.Path()
 	dl.server.Log().WithField("path", p).Debug("writing remote file to disk")
 
 	r := io.TeeReader(res.Body, dl.counter(res.ContentLength))
@@ -185,7 +207,7 @@ func (dl *Download) Execute() error {
 	return nil
 }
 
-// Cancels a running download and frees up the associated resources. If a file is being
+// Cancel cancels a running download and frees up the associated resources. If a file is being
 // written a partial file will remain present on the disk.
 func (dl *Download) Cancel() {
 	if dl.cancelFunc != nil {
@@ -194,12 +216,12 @@ func (dl *Download) Cancel() {
 	instance.remove(dl.Identifier)
 }
 
-// Checks if the given download belongs to the provided server.
+// BelongsTo checks if the given download belongs to the provided server.
 func (dl *Download) BelongsTo(s *server.Server) bool {
-	return dl.server.Id() == s.Id()
+	return dl.server.ID() == s.ID()
 }
 
-// Returns the current progress of the download as a float value between 0 and 1 where
+// Progress returns the current progress of the download as a float value between 0 and 1 where
 // 1 indicates that the download is completed.
 func (dl *Download) Progress() float64 {
 	dl.mu.RLock()
@@ -207,6 +229,10 @@ 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 {
@@ -232,15 +258,19 @@ func (dl *Download) isExternalNetwork(ctx context.Context) error {
 
 	// 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 {
+	//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)
+	//	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 !ipMatchRegex.MatchString(host) {
+	if _, _, err := net.SplitHostPort(host); err != nil {
-		if dl.req.URL.Scheme == "https" {
+		if !strings.Contains(err.Error(), "missing port in address") {
-			host = host + ":443"
+			return errors.WithStack(err)
-		} else {
+		}
-			host = host + ":80"
+		switch dl.req.URL.Scheme {
+		case "http":
+			host += ":80"
+		case "https":
+			host += ":443"
 		}
 	}
 
@@ -250,7 +280,11 @@ func (dl *Download) isExternalNetwork(ctx context.Context) error {
 	}
 	_ = c.Close()
 
-	ip := net.ParseIP(ipMatchRegex.ReplaceAllString(c.RemoteAddr().String(), ""))
+	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)
 	}
@@ -265,7 +299,7 @@ func (dl *Download) isExternalNetwork(ctx context.Context) error {
 	return nil
 }
 
-// Defines a global downloader struct that keeps track of all currently processing downloads
+// Downloader represents a global downloader that keeps track of all currently processing downloads
 // for the machine.
 type Downloader struct {
 	mu            sync.RWMutex
@@ -273,11 +307,11 @@ type Downloader struct {
 	serverCache   map[string][]string
 }
 
-// Tracks a download in the internal cache for this instance.
+// track tracks a download in the internal cache for this instance.
 func (d *Downloader) track(dl *Download) {
 	d.mu.Lock()
 	defer d.mu.Unlock()
-	sid := dl.server.Id()
+	sid := dl.server.ID()
 	if _, ok := d.downloadCache[dl.Identifier]; !ok {
 		d.downloadCache[dl.Identifier] = dl
 		if _, ok := d.serverCache[sid]; !ok {
@@ -287,7 +321,7 @@ func (d *Downloader) track(dl *Download) {
 	}
 }
 
-// Finds a given download entry using the provided ID and returns it.
+// find finds a given download entry using the provided ID and returns it.
 func (d *Downloader) find(dlid string) *Download {
 	d.mu.RLock()
 	defer d.mu.RUnlock()
@@ -297,24 +331,24 @@ func (d *Downloader) find(dlid string) *Download {
 	return nil
 }
 
-// Remove the given download reference from the cache storing them. This also updates
+// remove removes the given download reference from the cache storing them. This also updates
 // the slice of active downloads for a given server to not include this download.
-func (d *Downloader) remove(dlid string) {
+func (d *Downloader) remove(dlID string) {
 	d.mu.Lock()
 	defer d.mu.Unlock()
-	if _, ok := d.downloadCache[dlid]; !ok {
+	if _, ok := d.downloadCache[dlID]; !ok {
 		return
 	}
-	sid := d.downloadCache[dlid].server.Id()
+	sID := d.downloadCache[dlID].server.ID()
-	delete(d.downloadCache, dlid)
+	delete(d.downloadCache, dlID)
-	if tracked, ok := d.serverCache[sid]; ok {
+	if tracked, ok := d.serverCache[sID]; ok {
 		var out []string
 		for _, k := range tracked {
-			if k != dlid {
+			if k != dlID {
 				out = append(out, k)
 			}
 		}
-		d.serverCache[sid] = out
+		d.serverCache[sID] = out
 	}
 }
 

router/error.go

@@ -1,156 +0,0 @@
-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)
-}

router/middleware.go

@@ -2,6 +2,7 @@ package router
 
 import (
 	"github.com/gin-gonic/gin"
+
 	"github.com/pterodactyl/wings/router/middleware"
 	"github.com/pterodactyl/wings/server"
 )

router/middleware/middleware.go

@@ -1,147 +1,21 @@
 package middleware
 
 import (
-	"context"
 	"crypto/subtle"
 	"io"
 	"net/http"
-	"os"
 	"strings"
 
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/gin-gonic/gin"
 	"github.com/google/uuid"
+
 	"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
@@ -179,7 +53,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()
@@ -217,19 +91,29 @@ func CaptureErrors() gin.HandlerFunc {
 // SetAccessControlHeaders sets the access request control headers on all of
 // the requests.
 func SetAccessControlHeaders() gin.HandlerFunc {
-	origins := config.Get().AllowedOrigins
+	cfg := config.Get()
-	location := config.Get().PanelLocation
+	origins := cfg.AllowedOrigins
+	location := cfg.PanelLocation
+	allowPrivateNetwork := cfg.AllowCORSPrivateNetwork
 
 	return func(c *gin.Context) {
+		c.Header("Access-Control-Allow-Origin", location)
 		c.Header("Access-Control-Allow-Credentials", "true")
 		c.Header("Access-Control-Allow-Methods", "GET, POST, PATCH, PUT, DELETE, OPTIONS")
+		c.Header("Access-Control-Allow-Headers", "Accept, Accept-Encoding, Authorization, Cache-Control, Content-Type, Content-Length, Origin, X-Real-IP, X-CSRF-Token")
+
+		// CORS for Private Networks (RFC1918)
+		// @see https://developer.chrome.com/blog/private-network-access-update/?utm_source=devtools
+		if allowPrivateNetwork {
+			c.Header("Access-Control-Request-Private-Network", "true")
+		}
+
 		// Maximum age allowable under Chromium v76 is 2 hours, so just use that since
 		// anything higher will be ignored (even if other browsers do allow higher values).
 		//
 		// @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Max-Age#Directives
 		c.Header("Access-Control-Max-Age", "7200")
-		c.Header("Access-Control-Allow-Origin", location)
+
-		c.Header("Access-Control-Allow-Headers", "Accept, Accept-Encoding, Authorization, Cache-Control, Content-Type, Content-Length, Origin, X-Real-IP, X-CSRF-Token")
 		// Validate that the request origin is coming from an allowed origin. Because you
 		// cannot set multiple values here we need to see if the origin is one of the ones
 		// that we allow, and if so return it explicitly. Otherwise, just return the default
@@ -262,14 +146,14 @@ func ServerExists() gin.HandlerFunc {
 		if c.Param("server") != "" {
 			manager := ExtractManager(c)
 			s = manager.Find(func(s *server.Server) bool {
-				return c.Param("server") == s.Id()
+				return c.Param("server") == s.ID()
 			})
 		}
 		if s == nil {
 			c.AbortWithStatusJSON(http.StatusNotFound, gin.H{"error": "The requested resource does not exist on this instance."})
 			return
 		}
-		c.Set("logger", ExtractLogger(c).WithField("server_id", s.Id()))
+		c.Set("logger", ExtractLogger(c).WithField("server_id", s.ID()))
 		c.Set("server", s)
 		c.Next()
 	}

router/middleware/request_error.go

@@ -0,0 +1,141 @@
+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.IsErrorCode(err, filesystem.ErrCodePathResolution) ||
+		strings.Contains(err.Error(), "resolves to a location outside the server root") {
+		return http.StatusNotFound, "The requested resources was not found 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, ""
+}

router/router.go

@@ -1,19 +1,26 @@
 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"
-	"github.com/pterodactyl/wings/server"
+	wserver "github.com/pterodactyl/wings/server"
 )
 
 // Configure configures the routing infrastructure for this daemon instance.
-func Configure(m *server.Manager, client remote.Client) *gin.Engine {
+func Configure(m *wserver.Manager, client remote.Client) *gin.Engine {
 	gin.SetMode("release")
 
 	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.
@@ -37,7 +44,7 @@ func Configure(m *server.Manager, client remote.Client) *gin.Engine {
 	router.GET("/download/file", getDownloadFile)
 	router.POST("/upload/file", postServerUploadFiles)
 
-	// This route is special it sits above all of the other requests because we are
+	// This route is special it sits above all 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)
@@ -45,16 +52,16 @@ func Configure(m *server.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.GET("/api/servers/:server/archive", middleware.ServerExists(), getServerArchive)
+	router.POST("/api/transfers", postTransfers)
 
-	// All of the routes beyond this mount will use an authorization middleware
+	// All 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.POST("/api/transfer", postTransfer)
+	protected.DELETE("/api/transfers/:server", deleteTransfer)
 
 	// These are server specific routes, and require that the request be authorized, and
 	// that the server exist on the Daemon.
@@ -62,7 +69,6 @@ func Configure(m *server.Manager, client remote.Client) *gin.Engine {
 	server.Use(middleware.RequireAuthorization(), middleware.ServerExists())
 	{
 		server.GET("", getServer)
-		server.PATCH("", patchServer)
 		server.DELETE("", deleteServer)
 
 		server.GET("/logs", getServerLogs)
@@ -70,11 +76,13 @@ func Configure(m *server.Manager, client remote.Client) *gin.Engine {
 		server.POST("/commands", postServerCommands)
 		server.POST("/install", postServerInstall)
 		server.POST("/reinstall", postServerReinstall)
+		server.POST("/sync", postServerSync)
 		server.POST("/ws/deny", postServerDenyWSTokens)
 
 		// This archive request causes the archive to start being created
 		// this should only be triggered by the panel.
-		server.POST("/archive", postServerArchive)
+		server.POST("/transfer", postServerTransfer)
+		server.DELETE("/transfer", deleteServerTransfer)
 
 		files := server.Group("/files")
 		{

router/router_download.go

@@ -8,6 +8,7 @@ import (
 	"strconv"
 
 	"github.com/gin-gonic/gin"
+
 	"github.com/pterodactyl/wings/router/middleware"
 	"github.com/pterodactyl/wings/router/tokens"
 	"github.com/pterodactyl/wings/server/backup"
@@ -20,12 +21,11 @@ func getDownloadBackup(c *gin.Context) {
 
 	token := tokens.BackupPayload{}
 	if err := tokens.ParseToken([]byte(c.Query("token")), &token); err != nil {
-		NewTrackedError(err).Abort(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
-	s, ok := manager.Get(token.ServerUuid)
+	if _, ok := manager.Get(token.ServerUuid); !ok || !token.IsUniqueRequest() {
-	if !ok || !token.IsUniqueRequest() {
 		c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
 			"error": "The requested resource was not found on this server.",
 		})
@@ -41,13 +41,13 @@ func getDownloadBackup(c *gin.Context) {
 			return
 		}
 
-		NewServerError(err, s).Abort(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
 	f, err := os.Open(b.Path())
 	if err != nil {
-		NewServerError(err, s).Abort(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 	defer f.Close()
@@ -56,7 +56,7 @@ func getDownloadBackup(c *gin.Context) {
 	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)
 }
 
 // Handles downloading a specific file for a server.
@@ -64,7 +64,7 @@ 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)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
@@ -81,7 +81,7 @@ func getDownloadFile(c *gin.Context) {
 	// 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)
+		middleware.CaptureAndAbort(c, err)
 		return
 	} else if st.IsDir() {
 		c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
@@ -92,13 +92,14 @@ func getDownloadFile(c *gin.Context) {
 
 	f, err := os.Open(p)
 	if err != nil {
-		NewServerError(err, s).Abort(c)
+		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)
+	_, _ = bufio.NewReader(f).WriteTo(c.Writer)
 }

router/router_server.go

@@ -1,7 +1,6 @@
 package router
 
 import (
-	"bytes"
 	"context"
 	"net/http"
 	"os"
@@ -10,10 +9,12 @@ 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.
@@ -34,7 +35,7 @@ func getServerLogs(c *gin.Context) {
 
 	out, err := s.ReadLogfile(l)
 	if err != nil {
-		NewServerError(err, s).Abort(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
@@ -53,7 +54,8 @@ func postServerPower(c *gin.Context) {
 	s := ExtractServer(c)
 
 	var data struct {
-		Action server.PowerAction `json:"action"`
+		Action      server.PowerAction `json:"action"`
+		WaitSeconds int                `json:"wait_seconds"`
 	}
 
 	if err := c.BindJSON(&data); err != nil {
@@ -84,12 +86,16 @@ func postServerPower(c *gin.Context) {
 	// we can immediately return a response from the server. Some of these actions
 	// can take quite some time, especially stopping or restarting.
 	go func(s *server.Server) {
-		if err := s.HandlePowerAction(data.Action, 30); err != nil {
+		if data.WaitSeconds < 0 || data.WaitSeconds > 300 {
+			data.WaitSeconds = 30
+		}
+		if err := s.HandlePowerAction(data.Action, data.WaitSeconds); err != nil {
 			if errors.Is(err, context.DeadlineExceeded) {
-				s.Log().WithField("action", data.Action).
+				s.Log().WithField("action", data.Action).WithField("error", err).Warn("could not process server power action")
-					Warn("could not acquire a lock while attempting to perform a power action")
+			} else if errors.Is(err, server.ErrIsRunning) {
+				// Do nothing, this isn't something we care about for logging,
 			} else {
-				s.Log().WithFields(log.Fields{"action": data, "error": err}).
+				s.Log().WithFields(log.Fields{"action": data.Action, "wait_seconds": data.WaitSeconds, "error": err}).
 					Error("encountered error processing a server power action in the background")
 			}
 		}
@@ -102,8 +108,8 @@ func postServerPower(c *gin.Context) {
 func postServerCommands(c *gin.Context) {
 	s := ExtractServer(c)
 
-	if running, err := s.Environment.IsRunning(); err != nil {
+	if running, err := s.Environment.IsRunning(c.Request.Context()); err != nil {
-		NewServerError(err, s).Abort(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	} else if !running {
 		c.AbortWithStatusJSON(http.StatusBadGateway, gin.H{
@@ -129,30 +135,33 @@ func postServerCommands(c *gin.Context) {
 	c.Status(http.StatusNoContent)
 }
 
-// Updates information about a server internally.
+// postServerSync will accept a POST request and trigger a re-sync of the given
-func patchServer(c *gin.Context) {
+// server against the Panel. This can be manually triggered when needed by an
+// external system, or triggered by the Panel itself when modifications are made
+// to the build of a server internally.
+func postServerSync(c *gin.Context) {
 	s := ExtractServer(c)
 
-	buf := bytes.Buffer{}
+	if err := s.Sync(); err != nil {
-	buf.ReadFrom(c.Request.Body)
+		middleware.CaptureAndAbort(c, err)
-
+	} else {
-	if err := s.UpdateDataStructure(buf.Bytes()); err != nil {
+		c.Status(http.StatusNoContent)
-		NewServerError(err, s).Abort(c)
-		return
 	}
-
-	s.SyncWithEnvironment()
-
-	c.Status(http.StatusNoContent)
 }
 
 // Performs a server installation in a background thread.
 func postServerInstall(c *gin.Context) {
 	s := ExtractServer(c)
 
-	go func(serv *server.Server) {
+	go func(s *server.Server) {
-		if err := serv.Install(true); err != nil {
+		s.Log().Info("syncing server state with remote source before executing installation process")
-			serv.Log().WithField("error", err).Error("failed to execute server 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")
 		}
 	}(s)
 
@@ -179,7 +188,7 @@ func postServerReinstall(c *gin.Context) {
 	c.Status(http.StatusAccepted)
 }
 
-// Deletes a server from the wings daemon and dissociate it's objects.
+// Deletes a server from the wings daemon and dissociate its objects.
 func deleteServer(c *gin.Context) {
 	s := middleware.ExtractServer(c)
 
@@ -187,15 +196,20 @@ func deleteServer(c *gin.Context) {
 	// to start it while this process is running.
 	s.Config().SetSuspended(true)
 
-	// Stop all running background tasks for this server that are using the context on
+	// Notify all websocket clients that the server is being deleted.
-	// the server struct. This will cancel any running install processes for the server
+	// This is useful for two reasons, one to tell clients not to bother
-	// as well.
+	// retrying to connect to the websocket.  And two, for transfers when
-	s.CtxCancel()
+	// the server has been successfully transferred to another node, and
-	s.Events().Destroy()
+	// the client needs to switch to the new node.
-	s.Websockets().CancelAll()
+	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.
-	for _, dl := range downloader.ByServer(s.Id()) {
+	for _, dl := range downloader.ByServer(s.ID()) {
 		dl.Cancel()
 	}
 
@@ -203,7 +217,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 {
-		WithError(c, err)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
@@ -211,7 +225,7 @@ 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 amounts 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.
 	go func(p string) {
 		if err := os.RemoveAll(p); err != nil {
@@ -220,7 +234,7 @@ func deleteServer(c *gin.Context) {
 	}(s.Filesystem().Path())
 
 	middleware.ExtractManager(c).Remove(func(server *server.Server) bool {
-		return server.Id() == s.Id()
+		return server.ID() == s.ID()
 	})
 
 	// Deallocate the reference to this server.

router/router_server_backup.go

@@ -8,6 +8,7 @@ import (
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/gin-gonic/gin"
+
 	"github.com/pterodactyl/wings/router/middleware"
 	"github.com/pterodactyl/wings/server"
 	"github.com/pterodactyl/wings/server/backup"
@@ -42,7 +43,7 @@ func postServerBackup(c *gin.Context) {
 	// Attach the server ID and the request ID to the adapter log context for easier
 	// parsing in the logs.
 	adapter.WithLogContext(map[string]interface{}{
-		"server":     s.Id(),
+		"server":     s.ID(),
 		"request_id": c.GetString("request_id"),
 	})
 

router/router_server_files.go

@@ -16,12 +16,15 @@ import (
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"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"
 	"github.com/pterodactyl/wings/server"
 	"github.com/pterodactyl/wings/server/filesystem"
-	"golang.org/x/sync/errgroup"
 )
 
 // getServerFileContents returns the contents of a file on the server.
@@ -34,6 +37,15 @@ func getServerFileContents(c *gin.Context) {
 		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())))
@@ -67,7 +79,7 @@ func getServerListDirectory(c *gin.Context) {
 	s := ExtractServer(c)
 	dir := c.Query("directory")
 	if stats, err := s.Filesystem().ListDirectory(dir); err != nil {
-		WithError(c, err)
+		middleware.CaptureAndAbort(c, err)
 	} else {
 		c.JSON(http.StatusOK, stats)
 	}
@@ -119,6 +131,10 @@ 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
@@ -136,7 +152,7 @@ func putServerRenameFiles(c *gin.Context) {
 			return
 		}
 
-		NewServerError(err, s).AbortFilesystemError(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
@@ -156,11 +172,11 @@ func postServerCopyFile(c *gin.Context) {
 	}
 
 	if err := s.Filesystem().IsIgnored(data.Location); err != nil {
-		NewServerError(err, s).Abort(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 	if err := s.Filesystem().Copy(data.Location); err != nil {
-		NewServerError(err, s).AbortFilesystemError(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
@@ -205,7 +221,7 @@ func postServerDeleteFiles(c *gin.Context) {
 	}
 
 	if err := g.Wait(); err != nil {
-		NewServerError(err, s).Abort(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
@@ -220,7 +236,7 @@ func postServerWriteFile(c *gin.Context) {
 	f = "/" + strings.TrimLeft(f, "/")
 
 	if err := s.Filesystem().IsIgnored(f); err != nil {
-		NewServerError(err, s).Abort(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 	if err := s.Filesystem().Writefile(f, c.Request.Body); err != nil {
@@ -231,7 +247,7 @@ func postServerWriteFile(c *gin.Context) {
 			return
 		}
 
-		NewServerError(err, s).AbortFilesystemError(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
@@ -245,7 +261,7 @@ func postServerWriteFile(c *gin.Context) {
 func getServerPullingFiles(c *gin.Context) {
 	s := ExtractServer(c)
 	c.JSON(http.StatusOK, gin.H{
-		"downloads": downloader.ByServer(s.Id()),
+		"downloads": downloader.ByServer(s.ID()),
 	})
 }
 
@@ -253,13 +269,23 @@ func getServerPullingFiles(c *gin.Context) {
 func postServerPullRemoteFile(c *gin.Context) {
 	s := ExtractServer(c)
 	var data struct {
-		URL       string `binding:"required" json:"url"`
+		// Deprecated
-		Directory string `binding:"required,omitempty" json:"directory"`
+		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"`
 	}
 	if err := c.BindJSON(&data); err != nil {
 		return
 	}
 
+	// Handle the deprecated Directory field in the struct until it is removed.
+	if data.Directory != "" && data.RootPath == "" {
+		data.RootPath = data.Directory
+	}
+
 	u, err := url.Parse(data.URL)
 	if err != nil {
 		if e, ok := err.(*url.Error); ok {
@@ -268,16 +294,16 @@ func postServerPullRemoteFile(c *gin.Context) {
 			})
 			return
 		}
-		WithError(c, err)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
 	if err := s.Filesystem().HasSpaceErr(true); err != nil {
-		WithError(c, err)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 	// Do not allow more than three simultaneous remote file downloads at one time.
-	if len(downloader.ByServer(s.Id())) >= 3 {
+	if len(downloader.ByServer(s.ID())) >= 3 {
 		c.AbortWithStatusJSON(http.StatusBadRequest, gin.H{
 			"error": "This server has reached its limit of 3 simultaneous remote file downloads at once. Please wait for one to complete before trying again.",
 		})
@@ -285,23 +311,43 @@ func postServerPullRemoteFile(c *gin.Context) {
 	}
 
 	dl := downloader.New(s, downloader.DownloadRequest{
+		Directory: data.RootPath,
 		URL:       u,
-		Directory: data.Directory,
+		FileName:  data.FileName,
+		UseHeader: data.UseHeader,
 	})
 
-	// Execute this pull in a seperate thread since it may take a long time to complete.
+	download := func() error {
-	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
+	}
 
-	c.JSON(http.StatusAccepted, gin.H{
+	if err := download(); err != nil {
-		"identifier": dl.Identifier,
+		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)
 }
 
 // Stops a remote file download if it exists and belongs to this server.
@@ -334,7 +380,7 @@ func postServerCreateDirectory(c *gin.Context) {
 			return
 		}
 
-		NewServerError(err, s).Abort(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
@@ -369,7 +415,7 @@ func postServerCompressFiles(c *gin.Context) {
 
 	f, err := s.Filesystem().CompressFiles(data.RootPath, data.Files)
 	if err != nil {
-		NewServerError(err, s).AbortFilesystemError(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
@@ -394,7 +440,7 @@ 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)
+	err := s.Filesystem().SpaceAvailableForDecompression(context.Background(), 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")
@@ -406,7 +452,7 @@ func postServerDecompressFiles(c *gin.Context) {
 	}
 
 	lg.Info("starting file decompression")
-	if err := s.Filesystem().DecompressFile(data.RootPath, data.File); err != nil {
+	if err := s.Filesystem().DecompressFile(context.Background(), 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.
@@ -487,7 +533,7 @@ func postServerChmodFile(c *gin.Context) {
 			return
 		}
 
-		NewServerError(err, s).AbortFilesystemError(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
@@ -499,7 +545,7 @@ func postServerUploadFiles(c *gin.Context) {
 
 	token := tokens.UploadPayload{}
 	if err := tokens.ParseToken([]byte(c.Query("token")), &token); err != nil {
-		NewTrackedError(err).Abort(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
@@ -529,23 +575,36 @@ 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)
+			middleware.CaptureAndAbort(c, err)
 			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(p, s, header); err != nil {
-			NewServerError(err, s).Abort(c)
+			middleware.CaptureAndAbort(c, err)
 			return
+		} else {
+			s.SaveActivity(s.NewRequestActivity(token.UserUuid, c.ClientIP()), server.ActivityFileUploaded, models.ActivityMeta{
+				"file":      header.Filename,
+				"directory": filepath.Clean(directory),
+			})
 		}
 	}
 }
@@ -563,6 +622,5 @@ func handleFileUpload(p string, s *server.Server, header *multipart.FileHeader)
 	if err := s.Filesystem().Writefile(p, file); err != nil {
 		return err
 	}
-
 	return nil
 }

router/router_server_transfer.go

@@ -0,0 +1,130 @@
+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)
+}

router/router_server_ws.go

@@ -2,70 +2,74 @@ package router
 
 import (
 	"context"
-	"encoding/json"
 	"time"
 
 	"github.com/gin-gonic/gin"
+	"github.com/goccy/go-json"
 	ws "github.com/gorilla/websocket"
+
 	"github.com/pterodactyl/wings/router/middleware"
 	"github.com/pterodactyl/wings/router/websocket"
 )
 
+var expectedCloseCodes = []int{
+	ws.CloseGoingAway,
+	ws.CloseAbnormalClosure,
+	ws.CloseNormalClosure,
+	ws.CloseNoStatusReceived,
+	ws.CloseServiceRestart,
+}
+
 // Upgrades a connection to a websocket and passes events along between.
 func getServerWebsocket(c *gin.Context) {
 	manager := middleware.ExtractManager(c)
 	s, _ := manager.Get(c.Param("server"))
-	handler, err := websocket.GetHandler(s, c.Writer, c.Request)
+
+	// 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
+	// closed.
+	ctx, cancel := context.WithCancel(c.Request.Context())
+	defer cancel()
+
+	handler, err := websocket.GetHandler(s, c.Writer, c.Request, c)
 	if err != nil {
-		NewServerError(err, s).Abort(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 	defer handler.Connection.Close()
 
-	// Create a context that can be canceled when the user disconnects from this
-	// socket that will also cancel listeners running in separate threads.
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
 	// 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)
-	defer s.Websockets().Remove(handler.Uuid())
+	handler.Logger().Debug("opening connection to server websocket")
 
-	// Listen for the context being canceled and then close the websocket connection. This normally
+	defer func() {
-	// just happens because you're disconnecting from the socket in the browser, however in some
+		s.Websockets().Remove(handler.Uuid())
-	// cases we close the connections programmatically (e.g. deleting the server) and need to send
+		handler.Logger().Debug("closing connection to server websocket")
-	// a close message to the websocket so it disconnects.
+	}()
-	go func(ctx context.Context, c *ws.Conn) {
+
-	ListenerLoop:
+	// If the server is deleted we need to send a close message to the connected client
-		for {
+	// so that they disconnect since there will be no more events sent along. Listen for
-			select {
+	// the request context being closed to break this loop, otherwise this routine will
-			case <-ctx.Done():
+	// be left hanging in the background.
-				handler.Connection.WriteControl(ws.CloseMessage, ws.FormatCloseMessage(ws.CloseGoingAway, "server deleted"), time.Now().Add(time.Second*5))
+	go func() {
-				// A break right here without defining the specific loop would only break the select
+		select {
-				// and not actually break the for loop, thus causing this routine to stick around forever.
+		case <-ctx.Done():
-				break ListenerLoop
+			break
-			}
+		case <-s.Context().Done():
+			_ = handler.Connection.WriteControl(ws.CloseMessage, ws.FormatCloseMessage(ws.CloseGoingAway, "server deleted"), time.Now().Add(time.Second*5))
+			break
 		}
-	}(ctx, handler.Connection)
+	}()
-
-	go handler.ListenForServerEvents(ctx)
-	go handler.ListenForExpiration(ctx)
 
 	for {
 		j := websocket.Message{}
 
 		_, p, err := handler.Connection.ReadMessage()
 		if err != nil {
-			if !ws.IsCloseError(
+			if ws.IsUnexpectedCloseError(err, expectedCloseCodes...) {
-				err,
+				handler.Logger().WithField("error", err).Warn("error handling websocket message for server")
-				ws.CloseNormalClosure,
-				ws.CloseGoingAway,
-				ws.CloseNoStatusReceived,
-				ws.CloseServiceRestart,
-				ws.CloseAbnormalClosure,
-			) {
-				s.Log().WithField("error", err).Warn("error handling websocket message for server")
 			}
 			break
 		}
@@ -78,8 +82,8 @@ func getServerWebsocket(c *gin.Context) {
 		}
 
 		go func(msg websocket.Message) {
-			if err := handler.HandleInbound(msg); err != nil {
+			if err := handler.HandleInbound(ctx, msg); err != nil {
-				handler.SendErrorJson(msg, err)
+				_ = handler.SendErrorJson(msg, err)
 			}
 		}(j)
 	}

router/router_system.go

@@ -1,16 +1,18 @@
 package router
 
 import (
-	"bytes"
+	"context"
+	"errors"
 	"net/http"
 	"strings"
 
 	"github.com/apex/log"
 	"github.com/gin-gonic/gin"
+
 	"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"
 )
 
@@ -18,15 +20,31 @@ import (
 func getSystemInformation(c *gin.Context) {
 	i, err := system.GetSystemInformation()
 	if err != nil {
-		NewTrackedError(err).Abort(c)
+		middleware.CaptureAndAbort(c, err)
-
 		return
 	}
 
-	c.JSON(http.StatusOK, i)
+	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,
+	})
 }
 
-// Returns all of the servers that are registered and configured correctly on
+// Returns all the servers that are registered and configured correctly on
 // this wings instance.
 func getAllServers(c *gin.Context) {
 	servers := middleware.ExtractManager(c).All()
@@ -41,10 +59,13 @@ func getAllServers(c *gin.Context) {
 // for it.
 func postCreateServer(c *gin.Context) {
 	manager := middleware.ExtractManager(c)
-	buf := bytes.Buffer{}
-	buf.ReadFrom(c.Request.Body)
 
-	install, err := installer.New(c.Request.Context(), manager, buf.Bytes())
+	details := installer.ServerDetails{}
+	if err := c.BindJSON(&details); err != nil {
+		return
+	}
+
+	install, err := installer.New(c.Request.Context(), manager, details)
 	if err != nil {
 		if installer.IsValidationError(err) {
 			c.AbortWithStatusJSON(http.StatusUnprocessableEntity, gin.H{
@@ -65,14 +86,27 @@ func postCreateServer(c *gin.Context) {
 	// cycle. If there are any errors they will be logged and communicated back
 	// to the Panel where a reinstall may take place.
 	go func(i *installer.Installer) {
-		err := i.Server().CreateEnvironment()
+		if err := i.Server().CreateEnvironment(); err != nil {
-		if err != nil {
 			i.Server().Log().WithField("error", err).Error("failed to create server environment during install process")
 			return
 		}
 
-		if err := i.Server().Install(false); err != nil {
+		if err := i.Server().Install(); err != nil {
-			log.WithFields(log.Fields{"server": i.Uuid(), "error": err}).Error("failed to run install process for server")
+			log.WithFields(log.Fields{"server": i.Server().ID(), "error": err}).Error("failed to run install process for server")
+			return
+		}
+
+		if i.StartOnCompletion {
+			log.WithField("server_id", i.Server().ID()).Debug("starting server after successful installation")
+			if err := i.Server().HandlePowerAction(server.PowerActionStart, 30); err != nil {
+				if errors.Is(err, context.DeadlineExceeded) {
+					log.WithFields(log.Fields{"server_id": i.Server().ID(), "action": "start"}).Warn("could not acquire a lock while attempting to perform a power action")
+				} else {
+					log.WithFields(log.Fields{"server_id": i.Server().ID(), "action": "start", "error": err}).Error("encountered error processing a server power action in the background")
+				}
+			}
+		} else {
+			log.WithField("server_id", i.Server().ID()).Debug("skipping automatic start after successful server installation")
 		}
 	}(install)
 
@@ -85,19 +119,21 @@ func postUpdateConfiguration(c *gin.Context) {
 	if err := c.BindJSON(&cfg); err != nil {
 		return
 	}
+
 	// Keep the SSL certificates the same since the Panel will send through Lets Encrypt
 	// default locations. However, if we picked a different location manually we don't
 	// want to override that.
 	//
 	// If you pass through manual locations in the API call this logic will be skipped.
 	if strings.HasPrefix(cfg.Api.Ssl.KeyFile, "/etc/letsencrypt/live/") {
-		cfg.Api.Ssl.KeyFile = strings.ToLower(config.Get().Api.Ssl.KeyFile)
+		cfg.Api.Ssl.KeyFile = config.Get().Api.Ssl.KeyFile
-		cfg.Api.Ssl.CertificateFile = strings.ToLower(config.Get().Api.Ssl.CertificateFile)
+		cfg.Api.Ssl.CertificateFile = config.Get().Api.Ssl.CertificateFile
 	}
+
 	// Try to write this new configuration to the disk before updating our global
 	// state with it.
 	if err := config.WriteToDisk(cfg); err != nil {
-		WithError(c, err)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 	// Since we wrote it to the disk successfully now update the global configuration

router/router_transfer.go

@@ -1,65 +1,33 @@
 package router
 
 import (
-	"bufio"
+	"bytes"
 	"context"
 	"crypto/sha256"
 	"encoding/hex"
-	"encoding/json"
+	"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/filesystem"
+	"github.com/pterodactyl/wings/server/installer"
-	"github.com/pterodactyl/wings/system"
+	"github.com/pterodactyl/wings/server/transfer"
 )
 
-// Number of ticks in the progress bar
+// postTransfers .
-const ticks = 25
+func postTransfers(c *gin.Context) {
-
-// 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   json.RawMessage `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{
@@ -70,441 +38,236 @@ func getServerArchive(c *gin.Context) {
 
 	token := tokens.TransferPayload{}
 	if err := tokens.ParseToken([]byte(auth[1]), &token); err != nil {
-		NewTrackedError(err).Abort(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
+	manager := middleware.ExtractManager(c)
+	u, err := uuid.Parse(token.Subject)
+	if err != nil {
+		middleware.CaptureAndAbort(c, err)
+		return
+	}
+
+	// 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)
+
+		ctx, cancel = context.WithCancel(trnsfr.Context())
+		defer cancel()
+
+		i, err := installer.New(ctx, manager, installer.ServerDetails{
+			UUID:              u.String(),
+			StartOnCompletion: false,
+		})
+		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)
+			return
+		}
+
+		i.Server().SetTransferring(true)
+		manager.Add(i.Server())
+
+		// 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) {
+					if err := os.RemoveAll(trnsfr.Server.Filesystem().Path()); err != nil && !os.IsNotExist(err) {
+						trnsfr.Log().WithError(err).Warn("failed to delete local server files")
+					}
+				}(trnsfr)
+			}
+
+			trnsfr.Log().WithField("status", successful).WithError(err).Error("failed to set transfer status on panel")
+			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
+			}
+		}
+	}
+
+	if !hasArchive || !hasChecksum {
+		middleware.CaptureAndAbort(c, errors.New("missing archive or checksum"))
+		return
+	}
+
+	if !checksumVerified {
+		middleware.CaptureAndAbort(c, errors.New("checksums don't match"))
+		return
+	}
+
+	// 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.
+
+	// Ensure the server environment gets configured.
+	if err := trnsfr.Server.CreateEnvironment(); err != nil {
+		middleware.CaptureAndAbort(c, err)
+		return
+	}
+
+	// Changing this causes us to notify the panel about a successful transfer,
+	// rather than failing the transfer like we do by default.
+	successful = true
+
+	// The rest of the logic for ensuring the server is unlocked and everything
+	// is handled in the deferred function above.
+	trnsfr.Log().Debug("done!")
+}
+
+// deleteTransfer cancels an incoming transfer for a server.
+func deleteTransfer(c *gin.Context) {
 	s := ExtractServer(c)
-	if token.Subject != s.Id() {
+
-		c.AbortWithStatusJSON(http.StatusForbidden, gin.H{
+	if !s.IsTransferring() {
-			"error": "Missing required token subject, or subject is not valid for the requested server.",
+		c.AbortWithStatusJSON(http.StatusConflict, gin.H{
+			"error": "Server is not currently being transferred.",
 		})
 		return
 	}
 
-	archivePath := getArchivePath(s.Id())
+	trnsfr := transfer.Incoming().Get(s.ID())
-
+	if trnsfr == nil {
-	// Stat the archive file.
+		c.AbortWithStatusJSON(http.StatusConflict, gin.H{
-	st, err := os.Lstat(archivePath)
+			"error": "Server is not currently being transferred.",
-	if err != nil {
+		})
-		if !errors.Is(err, os.ErrNotExist) {
-			_ = WithError(c, err)
-			return
-		}
-		c.AbortWithStatus(http.StatusNotFound)
 		return
 	}
 
-	// Compute sha1 checksum.
+	trnsfr.Cancel()
-	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(data.ServerID)
-	if err != nil {
-		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()
-
-	data.log().Info("handling incoming server transfer request")
-	go func(data *serverTransferRequest) {
-		hasError := true
-
-		// 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 {
-			_ = 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()
-				})
-
-				// 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")
-					}
-				}
-			} else {
-				s.SetTransferring(false)
-				s.Events().Publish(server.TransferStatusEvent, "success")
-				sendTransferLog("Transfer completed.")
-			}
-		}(i.Server())
-
-		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
-		}
-
-		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
-		}
-
-		sendTransferLog("Writing archive to disk...")
-		data.log().Info("writing transfer archive to disk...")
-
-		// 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)
-
-		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
-		}
-
-		buf := make([]byte, 1024*4)
-		if _, err := io.CopyBuffer(file, io.TeeReader(reader, progress), buf); err != nil {
-			ticker.Stop()
-			_ = file.Close()
-
-			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()
-
-		// Show 100% completion.
-		humanSize := system.FormatBytes(progress.size)
-		sendTransferLog("Downloading [" + strings.Repeat("=", ticks) + "] " + humanSize + " / " + humanSize)
-
-		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.")
-
-		// Whenever the transfer fails or succeeds, delete the temporary transfer archive that
-		// was created on the disk.
-		defer data.removeArchivePath()
-
-		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
-		}
-
-		// 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)
 }

router/tokens/parser.go

@@ -1,9 +1,11 @@
 package tokens
 
 import (
-	"github.com/gbrlsnchs/jwt/v3"
-	"github.com/pterodactyl/wings/config"
 	"time"
+
+	"github.com/gbrlsnchs/jwt/v3"
+
+	"github.com/pterodactyl/wings/config"
 )
 
 type TokenData interface {

router/tokens/token_store.go

@@ -1,9 +1,10 @@
 package tokens
 
 import (
-	"github.com/patrickmn/go-cache"
 	"sync"
 	"time"
+
+	"github.com/patrickmn/go-cache"
 )
 
 type TokenStore struct {

router/tokens/upload.go

@@ -8,6 +8,7 @@ type UploadPayload struct {
 	jwt.Payload
 
 	ServerUuid string `json:"server_uuid"`
+	UserUuid   string `json:"user_uuid"`
 	UniqueId   string `json:"unique_id"`
 }
 

router/tokens/websocket.go

@@ -1,12 +1,12 @@
 package tokens
 
 import (
-	"encoding/json"
-	"github.com/apex/log"
-	"github.com/gbrlsnchs/jwt/v3"
 	"strings"
 	"sync"
 	"time"
+
+	"github.com/apex/log"
+	"github.com/gbrlsnchs/jwt/v3"
 )
 
 // The time at which Wings was booted. No JWT's created before this time are allowed to
@@ -34,15 +34,15 @@ func DenyJTI(jti string) {
 	denylist.Store(jti, time.Now())
 }
 
-// A JWT payload for Websocket connections. This JWT is passed along to the Websocket after
+// WebsocketPayload defines the JWT payload for a websocket connection. This JWT is passed along to
-// it has been connected to by sending an "auth" event.
+// the websocket after it has been connected to by sending an "auth" event.
 type WebsocketPayload struct {
 	jwt.Payload
 	sync.RWMutex
 
-	UserID      json.Number `json:"user_id"`
+	UserUUID    string   `json:"user_uuid"`
-	ServerUUID  string      `json:"server_uuid"`
+	ServerUUID  string   `json:"server_uuid"`
-	Permissions []string    `json:"permissions"`
+	Permissions []string `json:"permissions"`
 }
 
 // Returns the JWT payload.

router/websocket/listeners.go

@@ -2,21 +2,51 @@ package websocket
 
 import (
 	"context"
-	"github.com/pterodactyl/wings/events"
+	"sync"
-	"github.com/pterodactyl/wings/server"
 	"time"
+
+	"emperror.dev/errors"
+	"github.com/goccy/go-json"
+
+	"github.com/pterodactyl/wings/events"
+	"github.com/pterodactyl/wings/system"
+
+	"github.com/pterodactyl/wings/server"
 )
 
-// Checks the time to expiration on the JWT every 30 seconds until the token has
+// RegisterListenerEvents will setup the server event listeners and expiration
-// expired. If we are within 3 minutes of the token expiring, send a notice over
+// timers. This is only triggered on first authentication with the websocket,
-// the socket that it is expiring soon. If it has expired, send that notice as well.
+// reconnections will not call it.
-func (h *Handler) ListenForExpiration(ctx context.Context) {
+//
+// This needs to be called once the socket is properly authenticated otherwise
+// you'll get a flood of error spam in the output that doesn't make sense because
+// Docker events being output to the socket will fail when it hasn't been
+// properly initialized yet.
+//
+// @see https://github.com/pterodactyl/panel/issues/3295
+func (h *Handler) registerListenerEvents(ctx context.Context) {
+	h.Logger().Debug("registering event listeners for connection")
+
+	go func() {
+		if err := h.listenForServerEvents(ctx); err != nil {
+			h.Logger().Warn("error while processing server event; closing websocket connection")
+			if err := h.Connection.Close(); err != nil {
+				h.Logger().WithField("error", errors.WithStack(err)).Error("error closing websocket connection")
+			}
+		}
+	}()
+
+	go h.listenForExpiration(ctx)
+}
+
+// ListenForExpiration checks the time to expiration on the JWT every 30 seconds
+// until the token has expired. If we are within 3 minutes of the token expiring,
+// send a notice over the socket that it is expiring soon. If it has expired,
+// send that notice as well.
+func (h *Handler) listenForExpiration(ctx context.Context) {
 	// Make a ticker and completion channel that is used to continuously poll the
 	// JWT stored in the session to send events to the socket when it is expiring.
 	ticker := time.NewTicker(time.Second * 30)
-
-	// Whenever this function is complete, end the ticker, close out the channel,
-	// and then close the websocket connection.
 	defer ticker.Stop()
 
 	for {
@@ -27,9 +57,9 @@ func (h *Handler) ListenForExpiration(ctx context.Context) {
 			jwt := h.GetJwt()
 			if jwt != nil {
 				if jwt.ExpirationTime.Unix()-time.Now().Unix() <= 0 {
-					_ = h.SendJson(&Message{Event: TokenExpiredEvent})
+					_ = h.SendJson(Message{Event: TokenExpiredEvent})
 				} else if jwt.ExpirationTime.Unix()-time.Now().Unix() <= 60 {
-					_ = h.SendJson(&Message{Event: TokenExpiringEvent})
+					_ = h.SendJson(Message{Event: TokenExpiringEvent})
 				}
 			}
 		}
@@ -50,29 +80,91 @@ var e = []string{
 	server.TransferStatusEvent,
 }
 
-// Listens for different events happening on a server and sends them along
+// ListenForServerEvents will listen for different events happening on a server
-// to the connected websocket.
+// and send them along to the connected websocket client. This function will
-func (h *Handler) ListenForServerEvents(ctx context.Context) {
+// block until the context provided to it is canceled.
-	h.server.Log().Debug("listening for server events over websocket")
+func (h *Handler) listenForServerEvents(ctx context.Context) error {
-	callback := func(e events.Event) {
+	var o sync.Once
-		if err := h.SendJson(&Message{Event: e.Topic, Args: []string{e.Data}}); err != nil {
+	var err error
-			h.server.Log().WithField("error", err).Warn("error while sending server data over websocket")
+
-		}
+	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)
+
+	onError := func(evt string, err2 error) {
+		h.Logger().WithField("event", evt).WithField("error", err2).Error("failed to send event over server websocket")
+		// Avoid race conditions by only setting the error once and then canceling
+		// the context. This way if additional processing errors come through due
+		// to a massive flood of things you still only report and stop at the first.
+		o.Do(func() {
+			err = err2
+		})
+		cancel()
 	}
 
-	// Subscribe to all of the events with the same callback that will push the data out over the
+	for {
-	// websocket for the server.
-	for _, evt := range e {
-		h.server.Events().On(evt, &callback)
-	}
-
-	go func(ctx context.Context) {
 		select {
 		case <-ctx.Done():
-			// Once this context is stopped, de-register all of the listeners that have been registered.
+			break
-			for _, evt := range e {
+		case b := <-logOutput:
-				h.server.Events().Off(evt, &callback)
+			sendErr := h.SendJson(Message{Event: server.ConsoleOutputEvent, Args: []string{string(b)}})
+			if sendErr == nil {
+				continue
 			}
+			onError(server.ConsoleOutputEvent, sendErr)
+		case b := <-installOutput:
+			sendErr := h.SendJson(Message{Event: server.InstallOutputEvent, Args: []string{string(b)}})
+			if sendErr == nil {
+				continue
+			}
+			onError(server.InstallOutputEvent, sendErr)
+		case b := <-eventChan:
+			var e events.Event
+			if err := events.DecodeTo(b, &e); err != nil {
+				continue
+			}
+			var sendErr error
+			message := Message{Event: e.Topic}
+			if str, ok := e.Data.(string); ok {
+				message.Args = []string{str}
+			} else if b, ok := e.Data.([]byte); ok {
+				message.Args = []string{string(b)}
+			} else {
+				b, sendErr = json.Marshal(e.Data)
+				if sendErr == nil {
+					message.Args = []string{string(b)}
+				}
+			}
+
+			if sendErr == nil {
+				sendErr = h.SendJson(message)
+				if sendErr == nil {
+					continue
+				}
+			}
+			onError(message.Event, sendErr)
 		}
-	}(ctx)
+		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)
+
+	// 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
+	// we can assume the parent was canceled and need not perform any actions.
+	if err != nil {
+		return errors.WithStack(err)
+	}
+
+	return nil
 }

router/websocket/websocket.go

@@ -2,22 +2,29 @@ package websocket
 
 import (
 	"context"
-	"emperror.dev/errors"
-	"encoding/json"
 	"fmt"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/pterodactyl/wings/internal/models"
+
+	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/gbrlsnchs/jwt/v3"
+	"github.com/gin-gonic/gin"
+	"github.com/goccy/go-json"
 	"github.com/google/uuid"
 	"github.com/gorilla/websocket"
+
+	"github.com/pterodactyl/wings/system"
+
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/environment/docker"
 	"github.com/pterodactyl/wings/router/tokens"
 	"github.com/pterodactyl/wings/server"
-	"net/http"
-	"strings"
-	"sync"
-	"time"
 )
 
 const (
@@ -37,6 +44,7 @@ type Handler struct {
 	Connection   *websocket.Conn `json:"-"`
 	jwt          *tokens.WebsocketPayload
 	server       *server.Server
+	ra           server.RequestActivity
 	uuid         uuid.UUID
 }
 
@@ -55,11 +63,10 @@ func IsJwtError(err error) bool {
 		errors.Is(err, jwt.ErrExpValidation)
 }
 
-// Parses a JWT into a websocket token payload.
+// NewTokenPayload parses a JWT into a websocket token payload.
 func NewTokenPayload(token []byte) (*tokens.WebsocketPayload, error) {
-	payload := tokens.WebsocketPayload{}
+	var payload tokens.WebsocketPayload
-	err := tokens.ParseToken(token, &payload)
+	if err := tokens.ParseToken(token, &payload); err != nil {
-	if err != nil {
 		return nil, err
 	}
 
@@ -74,8 +81,8 @@ func NewTokenPayload(token []byte) (*tokens.WebsocketPayload, error) {
 	return &payload, nil
 }
 
-// Returns a new websocket handler using the context provided.
+// GetHandler returns a new websocket handler using the context provided.
-func GetHandler(s *server.Server, w http.ResponseWriter, r *http.Request) (*Handler, error) {
+func GetHandler(s *server.Server, w http.ResponseWriter, r *http.Request, c *gin.Context) (*Handler, error) {
 	upgrader := websocket.Upgrader{
 		// Ensure that the websocket request is originating from the Panel itself,
 		// and not some other location.
@@ -107,6 +114,7 @@ func GetHandler(s *server.Server, w http.ResponseWriter, r *http.Request) (*Hand
 		Connection: conn,
 		jwt:        nil,
 		server:     s,
+		ra:         s.NewRequestActivity("", c.ClientIP()),
 		uuid:       u,
 	}, nil
 }
@@ -115,18 +123,23 @@ func (h *Handler) Uuid() uuid.UUID {
 	return h.uuid
 }
 
-func (h *Handler) SendJson(v *Message) error {
+func (h *Handler) Logger() *log.Entry {
+	return log.WithField("subsystem", "websocket").
+		WithField("connection", h.Uuid().String()).
+		WithField("server", h.server.ID())
+}
+
+func (h *Handler) SendJson(v Message) error {
 	// Do not send JSON down the line if the JWT on the connection is not valid!
 	if err := h.TokenValid(); err != nil {
-		h.unsafeSendJson(Message{
+		_ = h.unsafeSendJson(Message{
 			Event: JwtErrorEvent,
 			Args:  []string{err.Error()},
 		})
 		return nil
 	}
 
-	j := h.GetJwt()
+	if j := h.GetJwt(); j != nil {
-	if j != nil {
 		// If we're sending installation output but the user does not have the required
 		// permissions to see the output, don't send it down the line.
 		if v.Event == server.InstallOutputEvent {
@@ -180,7 +193,7 @@ func (h *Handler) unsafeSendJson(v interface{}) error {
 	return h.Connection.WriteJSON(v)
 }
 
-// Checks if the JWT is still valid.
+// TokenValid checks if the JWT is still valid.
 func (h *Handler) TokenValid() error {
 	j := h.GetJwt()
 	if j == nil {
@@ -199,14 +212,14 @@ func (h *Handler) TokenValid() error {
 		return ErrJwtNoConnectPerm
 	}
 
-	if h.server.Id() != j.GetServerUuid() {
+	if h.server.ID() != j.GetServerUuid() {
 		return ErrJwtUuidMismatch
 	}
 
 	return nil
 }
 
-// Sends an error back to the connected websocket instance by checking the permissions
+// SendErrorJson sends an error back to the connected websocket instance by checking the permissions
 // of the token. If the user has the "receive-errors" grant we will send back the actual
 // error message, otherwise we just send back a standard error message.
 func (h *Handler) SendErrorJson(msg Message, err error, shouldLog ...bool) error {
@@ -236,7 +249,7 @@ func (h *Handler) SendErrorJson(msg Message, err error, shouldLog ...bool) error
 	return h.unsafeSendJson(wsm)
 }
 
-// Converts an error message into a more readable representation and returns a UUID
+// GetErrorMessage converts an error message into a more readable representation and returns a UUID
 // that can be cross-referenced to find the specific error that triggered.
 func (h *Handler) GetErrorMessage(msg string) (string, uuid.UUID) {
 	u := uuid.Must(uuid.NewRandom())
@@ -246,13 +259,7 @@ func (h *Handler) GetErrorMessage(msg string) (string, uuid.UUID) {
 	return m, u
 }
 
-// Sets the JWT for the websocket in a race-safe manner.
+// GetJwt returns the JWT for the websocket in a race-safe manner.
-func (h *Handler) setJwt(token *tokens.WebsocketPayload) {
-	h.Lock()
-	h.jwt = token
-	h.Unlock()
-}
-
 func (h *Handler) GetJwt() *tokens.WebsocketPayload {
 	h.RLock()
 	defer h.RUnlock()
@@ -260,8 +267,16 @@ func (h *Handler) GetJwt() *tokens.WebsocketPayload {
 	return h.jwt
 }
 
-// Handle the inbound socket request and route it to the proper server action.
+// setJwt sets the JWT for the websocket in a race-safe manner.
-func (h *Handler) HandleInbound(m Message) error {
+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 m.Event != AuthenticationEvent {
 		if err := h.TokenValid(); err != nil {
 			h.unsafeSendJson(Message{
@@ -277,13 +292,6 @@ func (h *Handler) HandleInbound(m Message) error {
 		{
 			token, err := NewTokenPayload([]byte(strings.Join(m.Args, "")))
 			if err != nil {
-				// If the error says the JWT expired, send a token expired
-				// event and hopefully the client renews the token.
-				if err == jwt.ErrExpValidation {
-					h.SendJson(&Message{Event: TokenExpiredEvent})
-					return nil
-				}
-
 				return err
 			}
 
@@ -296,10 +304,7 @@ func (h *Handler) HandleInbound(m Message) error {
 			h.setJwt(token)
 
 			// Tell the client they authenticated successfully.
-			h.unsafeSendJson(Message{
+			_ = h.unsafeSendJson(Message{Event: AuthenticationSuccessEvent})
-				Event: AuthenticationSuccessEvent,
-				Args:  []string{},
-			})
 
 			// Check if the client was refreshing their authentication token
 			// instead of authenticating for the first time.
@@ -309,10 +314,15 @@ func (h *Handler) HandleInbound(m Message) error {
 				return nil
 			}
 
+			// Now that we've authenticated with the token and confirmed that we're not
+			// reconnecting to the socket, register the event listeners for the server and
+			// the token expiration.
+			h.registerListenerEvents(ctx)
+
 			// On every authentication event, send the current server status back
 			// to the client. :)
 			state := h.server.Environment.State()
-			h.SendJson(&Message{
+			_ = h.SendJson(Message{
 				Event: server.StatusEvent,
 				Args:  []string{state},
 			})
@@ -324,7 +334,7 @@ func (h *Handler) HandleInbound(m Message) error {
 					_ = h.server.Filesystem().HasSpaceAvailable(false)
 
 					b, _ := json.Marshal(h.server.Proc())
-					h.SendJson(&Message{
+					_ = h.SendJson(Message{
 						Event: server.StatsEvent,
 						Args:  []string{string(b)},
 					})
@@ -351,10 +361,10 @@ func (h *Handler) HandleInbound(m Message) error {
 			}
 
 			err := h.server.HandlePowerAction(action)
-			if errors.Is(err, context.DeadlineExceeded) {
+			if errors.Is(err, system.ErrLockerLocked) {
 				m, _ := h.GetErrorMessage("another power action is currently being processed for this server, please try again later")
 
-				h.SendJson(&Message{
+				_ = h.SendJson(Message{
 					Event: ErrorEvent,
 					Args:  []string{m},
 				})
@@ -362,11 +372,17 @@ func (h *Handler) HandleInbound(m Message) error {
 				return nil
 			}
 
+			if err == nil {
+				h.server.SaveActivity(h.ra, models.Event(server.ActivityPowerPrefix+action), nil)
+			}
+
 			return err
 		}
 	case SendServerLogsEvent:
 		{
-			if running, _ := h.server.Environment.IsRunning(); !running {
+			ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
+			defer cancel()
+			if running, _ := h.server.Environment.IsRunning(ctx); !running {
 				return nil
 			}
 
@@ -376,7 +392,7 @@ func (h *Handler) HandleInbound(m Message) error {
 			}
 
 			for _, line := range logs {
-				h.SendJson(&Message{
+				_ = h.SendJson(Message{
 					Event: server.ConsoleOutputEvent,
 					Args:  []string{line},
 				})
@@ -387,7 +403,7 @@ func (h *Handler) HandleInbound(m Message) error {
 	case SendStatsEvent:
 		{
 			b, _ := json.Marshal(h.server.Proc())
-			h.SendJson(&Message{
+			_ = h.SendJson(Message{
 				Event: server.StatsEvent,
 				Args:  []string{string(b)},
 			})
@@ -416,7 +432,13 @@ func (h *Handler) HandleInbound(m Message) error {
 				}
 			}
 
-			return h.server.Environment.SendCommand(strings.Join(m.Args, ""))
+			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
 		}
 	}
 

server/activity.go

@@ -0,0 +1,66 @@
+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")
+		}
+	}()
+}

server/backup.go

@@ -2,12 +2,14 @@ package server
 
 import (
 	"io"
-	"io/ioutil"
+	"io/fs"
 	"os"
+	"time"
 
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/docker/docker/client"
+
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/remote"
 	"github.com/pterodactyl/wings/server/backup"
@@ -22,7 +24,6 @@ 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
 		}
 
@@ -46,7 +47,7 @@ func (s *Server) getServerwideIgnoredFiles() (string, error) {
 		// Don't read a symlinked ignore file, or a file larger than 32KiB in size.
 		return "", nil
 	}
-	b, err := ioutil.ReadAll(f)
+	b, err := io.ReadAll(f)
 	if err != nil {
 		return "", err
 	}
@@ -60,13 +61,13 @@ func (s *Server) Backup(b backup.BackupInterface) error {
 	ignored := b.Ignored()
 	if b.Ignored() == "" {
 		if i, err := s.getServerwideIgnoredFiles(); err != nil {
-			log.WithField("server", s.Id()).WithField("error", err).Warn("failed to get server-wide ignored files")
+			log.WithField("server", s.ID()).WithField("error", err).Warn("failed to get server-wide ignored files")
 		} else {
 			ignored = i
 		}
 	}
 
-	ad, err := b.Generate(s.Filesystem().Path(), ignored)
+	ad, err := b.Generate(s.Context(), s.Filesystem().Path(), ignored)
 	if err != nil {
 		if err := s.notifyPanelOfBackup(b.Identifier(), &backup.ArchiveDetails{}, false); err != nil {
 			s.Log().WithFields(log.Fields{
@@ -77,7 +78,7 @@ func (s *Server) Backup(b backup.BackupInterface) error {
 			s.Log().WithField("backup", b.Identifier()).Info("notified panel of failed backup state")
 		}
 
-		_ = s.Events().PublishJson(BackupCompletedEvent+":"+b.Identifier(), map[string]interface{}{
+		s.Events().Publish(BackupCompletedEvent+":"+b.Identifier(), map[string]interface{}{
 			"uuid":          b.Identifier(),
 			"is_successful": false,
 			"checksum":      "",
@@ -101,7 +102,7 @@ func (s *Server) Backup(b backup.BackupInterface) error {
 
 	// Emit an event over the socket so we can update the backup in realtime on
 	// the frontend for the server.
-	_ = s.Events().PublishJson(BackupCompletedEvent+":"+b.Identifier(), map[string]interface{}{
+	s.Events().Publish(BackupCompletedEvent+":"+b.Identifier(), map[string]interface{}{
 		"uuid":          b.Identifier(),
 		"is_successful": true,
 		"checksum":      ad.Checksum,
@@ -125,7 +126,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
@@ -140,7 +141,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(120, false); err != nil {
+		if err = s.Environment.WaitForStop(s.Context(), 2*time.Minute, false); err != nil {
 			if !client.IsErrNotFound(err) {
 				return errors.WrapIf(err, "server/backup: restore: failed to wait for container stop")
 			}
@@ -150,9 +151,20 @@ 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(reader, func(file string, r io.Reader) error {
+	err = b.Restore(s.Context(), reader, func(file string, info fs.FileInfo, r io.ReadCloser) error {
+		defer r.Close()
 		s.Events().Publish(DaemonMessageEvent, "(restoring): "+file)
-		return s.Filesystem().Writefile(file, r)
+
+		if err := s.Filesystem().Writefile(file, r); err != nil {
+			return err
+		}
+		if err := s.Filesystem().Chmod(file, info.Mode()); err != nil {
+			return err
+		}
+
+		atime := info.ModTime()
+		mtime := atime
+		return s.Filesystem().Chtimes(file, atime, mtime)
 	})
 
 	return errors.WithStackIf(err)

server/backup/backup.go

@@ -1,18 +1,28 @@
 package backup
 
 import (
+	"context"
 	"crypto/sha1"
 	"encoding/hex"
 	"io"
+	"io/fs"
 	"os"
 	"path"
-	"sync"
 
+	"emperror.dev/errors"
 	"github.com/apex/log"
+	"github.com/mholt/archiver/v4"
+	"golang.org/x/sync/errgroup"
+
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/remote"
 )
 
+var format = archiver.CompressedArchive{
+	Compression: archiver.Gz{},
+	Archival:    archiver.Tar{},
+}
+
 type AdapterType string
 
 const (
@@ -22,22 +32,39 @@ 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, r io.Reader) error
+type RestoreCallback func(file string, info fs.FileInfo, r io.ReadCloser) error
 
-type ArchiveDetails struct {
+// noinspection GoNameStartsWithPackageName
-	Checksum     string `json:"checksum"`
+type BackupInterface interface {
-	ChecksumType string `json:"checksum_type"`
+	// SetClient sets the API request client on the backup interface.
-	Size         int64  `json:"size"`
+	SetClient(remote.Client)
-}
+	// Identifier returns the UUID of this backup as tracked by the panel
-
+	// instance.
-// ToRequest returns a request object.
+	Identifier() string
-func (ad *ArchiveDetails) ToRequest(successful bool) remote.BackupRequest {
+	// WithLogContext attaches additional context to the log output for this
-	return remote.BackupRequest{
+	// backup.
-		Checksum:     ad.Checksum,
+	WithLogContext(map[string]interface{})
-		ChecksumType: ad.ChecksumType,
+	// Generate creates a backup in whatever the configured source for the
-		Size:         ad.Size,
+	// specific implementation is.
-		Successful:   successful,
+	Generate(context.Context, string, string) (*ArchiveDetails, error)
-	}
+	// Ignored returns the ignored files for this backup instance.
+	Ignored() string
+	// Checksum returns a SHA1 checksum for the generated backup.
+	Checksum() ([]byte, error)
+	// Size returns the size of the generated backup.
+	Size() (int64, error)
+	// Path returns the path to the backup on the machine. This is not always
+	// the final storage location of the backup, simply the location we're using
+	// 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)
+	// 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
 }
 
 type Backup struct {
@@ -54,39 +81,6 @@ type Backup struct {
 	logContext map[string]interface{}
 }
 
-// noinspection GoNameStartsWithPackageName
-type BackupInterface interface {
-	// SetClient sets the API request client on the backup interface.
-	SetClient(c remote.Client)
-	// Identifier returns the UUID of this backup as tracked by the panel
-	// instance.
-	Identifier() string
-	// WithLogContext attaches additional context to the log output for this
-	// backup.
-	WithLogContext(map[string]interface{})
-	// Generate creates a backup in whatever the configured source for the
-	// specific implementation is.
-	Generate(string, string) (*ArchiveDetails, error)
-	// Ignored returns the ignored files for this backup instance.
-	Ignored() string
-	// Checksum returns a SHA1 checksum for the generated backup.
-	Checksum() ([]byte, error)
-	// Size returns the size of the generated backup.
-	Size() (int64, error)
-	// Path returns the path to the backup on the machine. This is not always
-	// the final storage location of the backup, simply the location we're using
-	// to store it until it is moved to the final spot.
-	Path() string
-	// Details returns details about the archive.
-	Details() *ArchiveDetails
-	// 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(reader io.Reader, callback RestoreCallback) error
-}
-
 func (b *Backup) SetClient(c remote.Client) {
 	b.client = c
 }
@@ -95,12 +89,12 @@ func (b *Backup) Identifier() string {
 	return b.Uuid
 }
 
-// Returns the path for this specific backup.
+// Path returns the path for this specific backup.
 func (b *Backup) Path() string {
 	return path.Join(config.Get().System.BackupDirectory, b.Identifier()+".tar.gz")
 }
 
-// Return the size of the generated backup.
+// Size returns the size of the generated backup.
 func (b *Backup) Size() (int64, error) {
 	st, err := os.Stat(b.Path())
 	if err != nil {
@@ -110,7 +104,7 @@ func (b *Backup) Size() (int64, error) {
 	return st.Size(), nil
 }
 
-// Returns the SHA256 checksum of a backup.
+// Checksum returns the SHA256 checksum of a backup.
 func (b *Backup) Checksum() ([]byte, error) {
 	h := sha1.New()
 
@@ -128,51 +122,34 @@ func (b *Backup) Checksum() ([]byte, error) {
 	return h.Sum(nil), nil
 }
 
-// Returns details of the archive by utilizing two go-routines to get the checksum and
+// Details returns both the checksum and size of the archive currently stored on
-// the size of the archive.
+// the disk to the caller.
-func (b *Backup) Details() *ArchiveDetails {
+func (b *Backup) Details(ctx context.Context, parts []remote.BackupPart) (*ArchiveDetails, error) {
-	wg := sync.WaitGroup{}
+	ad := ArchiveDetails{ChecksumType: "sha1", Parts: parts}
-	wg.Add(2)
+	g, ctx := errgroup.WithContext(ctx)
 
-	l := log.WithField("backup_id", b.Uuid)
+	g.Go(func() error {
-
-	var checksum string
-	// Calculate the checksum for the file.
-	go func() {
-		defer wg.Done()
-
-		l.Info("computing checksum for backup...")
 		resp, err := b.Checksum()
 		if err != nil {
-			log.WithFields(log.Fields{
+			return err
-				"backup": b.Identifier(),
-				"error":  err,
-			}).Error("failed to calculate checksum for backup")
-			return
 		}
+		ad.Checksum = hex.EncodeToString(resp)
+		return nil
+	})
 
-		checksum = hex.EncodeToString(resp)
+	g.Go(func() error {
-		l.WithField("checksum", checksum).Info("computed checksum for backup")
+		s, err := b.Size()
-	}()
+		if err != nil {
-
+			return err
-	var sz int64
-	go func() {
-		defer wg.Done()
-
-		if s, err := b.Size(); err != nil {
-			return
-		} else {
-			sz = s
 		}
-	}()
+		ad.Size = s
+		return nil
+	})
 
-	wg.Wait()
+	if err := g.Wait(); err != nil {
-
+		return nil, errors.WithStackDepth(err, 1)
-	return &ArchiveDetails{
-		Checksum:     checksum,
-		ChecksumType: "sha1",
-		Size:         sz,
 	}
+	return &ad, nil
 }
 
 func (b *Backup) Ignored() string {
@@ -188,3 +165,21 @@ func (b *Backup) log() *log.Entry {
 	}
 	return l
 }
+
+type ArchiveDetails struct {
+	Checksum     string              `json:"checksum"`
+	ChecksumType string              `json:"checksum_type"`
+	Size         int64               `json:"size"`
+	Parts        []remote.BackupPart `json:"parts"`
+}
+
+// ToRequest returns a request object.
+func (ad *ArchiveDetails) ToRequest(successful bool) remote.BackupRequest {
+	return remote.BackupRequest{
+		Checksum:     ad.Checksum,
+		ChecksumType: ad.ChecksumType,
+		Size:         ad.Size,
+		Successful:   successful,
+		Parts:        ad.Parts,
+	}
+}

server/backup/backup_local.go

@@ -1,14 +1,17 @@
 package backup
 
 import (
-	"errors"
+	"context"
 	"io"
 	"os"
 
-	"github.com/pterodactyl/wings/server/filesystem"
+	"emperror.dev/errors"
+	"github.com/juju/ratelimit"
+	"github.com/mholt/archiver/v4"
 
-	"github.com/mholt/archiver/v3"
+	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/remote"
+	"github.com/pterodactyl/wings/server/filesystem"
 )
 
 type LocalBackup struct {
@@ -56,28 +59,50 @@ 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(basePath, ignore string) (*ArchiveDetails, error) {
+func (b *LocalBackup) Generate(ctx context.Context, basePath, ignore string) (*ArchiveDetails, error) {
 	a := &filesystem.Archive{
 		BasePath: basePath,
 		Ignore:   ignore,
 	}
 
-	b.log().Info("creating backup for server...")
+	b.log().WithField("path", b.Path()).Info("creating backup for server")
-	if err := a.Create(b.Path()); err != nil {
+	if err := a.Create(ctx, b.Path()); err != nil {
 		return nil, err
 	}
 	b.log().Info("created backup successfully")
 
-	return b.Details(), nil
+	ad, err := b.Details(ctx, nil)
+	if err != nil {
+		return nil, errors.WrapIf(err, "backup: failed to get archive details for local backup")
+	}
+	return ad, nil
 }
 
 // Restore will walk over the archive and call the callback function for each
 // file encountered.
-func (b *LocalBackup) Restore(_ io.Reader, callback RestoreCallback) error {
+func (b *LocalBackup) Restore(ctx context.Context, _ io.Reader, callback RestoreCallback) error {
-	return archiver.Walk(b.Path(), func(f archiver.File) error {
+	f, err := os.Open(b.Path())
-		if f.IsDir() {
+	if err != nil {
-			return 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, nil, func(ctx context.Context, f archiver.File) error {
+		r, err := f.Open()
+		if err != nil {
+			return err
 		}
-		return callback(f.Name(), f)
+		defer r.Close()
-	})
+
+		return callback(filesystem.ExtractNameFromArchive(f), f.FileInfo, r)
+	}); err != nil {
+		return err
+	}
+	return nil
 }

server/backup/backup_s3.go

@@ -1,19 +1,22 @@
 package backup
 
 import (
-	"archive/tar"
-	"compress/gzip"
 	"context"
 	"fmt"
-	"github.com/pterodactyl/wings/server/filesystem"
 	"io"
 	"net/http"
 	"os"
 	"strconv"
+	"time"
 
+	"emperror.dev/errors"
+	"github.com/cenkalti/backoff/v4"
 	"github.com/juju/ratelimit"
+	"github.com/mholt/archiver/v4"
+
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/remote"
+	"github.com/pterodactyl/wings/server/filesystem"
 )
 
 type S3Backup struct {
@@ -45,7 +48,7 @@ func (s *S3Backup) WithLogContext(c map[string]interface{}) {
 
 // Generate creates a new backup on the disk, moves it into the S3 bucket via
 // the provided presigned URL, and then deletes the backup from the disk.
-func (s *S3Backup) Generate(basePath, ignore string) (*ArchiveDetails, error) {
+func (s *S3Backup) Generate(ctx context.Context, basePath, ignore string) (*ArchiveDetails, error) {
 	defer s.Remove()
 
 	a := &filesystem.Archive{
@@ -53,85 +56,77 @@ func (s *S3Backup) Generate(basePath, ignore string) (*ArchiveDetails, error) {
 		Ignore:   ignore,
 	}
 
-	s.log().Info("creating backup for server...")
+	s.log().WithField("path", s.Path()).Info("creating backup for server")
-	if err := a.Create(s.Path()); err != nil {
+	if err := a.Create(ctx, s.Path()); err != nil {
 		return nil, err
 	}
 	s.log().Info("created backup successfully")
 
 	rc, err := os.Open(s.Path())
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "backup: could not read archive from disk")
 	}
 	defer rc.Close()
 
-	if err := s.generateRemoteRequest(rc); err != nil {
+	parts, err := s.generateRemoteRequest(ctx, rc)
+	if err != nil {
 		return nil, err
 	}
-
+	ad, err := s.Details(ctx, parts)
-	return s.Details(), nil
+	if err != nil {
+		return nil, errors.WrapIf(err, "backup: failed to get archive details after upload")
+	}
+	return ad, nil
 }
 
-// Reader provides a wrapper around an existing io.Reader
+// Restore will read from the provided reader assuming that it is a gzipped
-// but implements io.Closer in order to satisfy an io.ReadCloser.
+// tar reader. When a file is encountered in the archive the callback function
-type Reader struct {
+// will be triggered. If the callback returns an error the entire process is
-	io.Reader
+// stopped, otherwise this function will run until all files have been written.
-}
+//
+// This restoration uses a workerpool to use up to the number of CPUs available
+// on the machine when writing files to the disk.
+func (s *S3Backup) Restore(ctx context.Context, r io.Reader, callback RestoreCallback) error {
+	reader := r
+	// 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(r, ratelimit.NewBucketWithRate(float64(writeLimit), writeLimit))
+	}
+	if err := format.Extract(ctx, reader, nil, func(ctx context.Context, f archiver.File) error {
+		r, err := f.Open()
+		if err != nil {
+			return err
+		}
+		defer r.Close()
 
-func (Reader) Close() error {
+		return callback(filesystem.ExtractNameFromArchive(f), f.FileInfo, r)
+	}); err != nil {
+		return err
+	}
 	return nil
 }
 
 // Generates the remote S3 request and begins the upload.
-func (s *S3Backup) generateRemoteRequest(rc io.ReadCloser) error {
+func (s *S3Backup) generateRemoteRequest(ctx context.Context, rc io.ReadCloser) ([]remote.BackupPart, error) {
 	defer rc.Close()
 
 	s.log().Debug("attempting to get size of backup...")
 	size, err := s.Backup.Size()
 	if err != nil {
-		return err
+		return nil, 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 err
+		return nil, 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...")
 
-	handlePart := func(part string, size int64) (string, error) {
+	uploader := newS3FileUploader(rc)
-		r, err := http.NewRequest(http.MethodPut, part, nil)
-		if err != nil {
-			return "", err
-		}
-
-		r.ContentLength = size
-		r.Header.Add("Content-Length", strconv.Itoa(int(size)))
-		r.Header.Add("Content-Type", "application/x-gzip")
-
-		// Limit the reader to the size of the part.
-		r.Body = Reader{Reader: io.LimitReader(rc, size)}
-
-		// This http request can block forever due to it not having a timeout,
-		// but we are uploading up to 5GB of data, so there is not really
-		// a good way to handle a timeout on this.
-		res, err := http.DefaultClient.Do(r)
-		if err != nil {
-			return "", err
-		}
-		defer res.Body.Close()
-
-		// Handle non-200 status codes.
-		if res.StatusCode != http.StatusOK {
-			return "", fmt.Errorf("failed to put S3 object part, %d:%s", res.StatusCode, res.Status)
-		}
-
-		// Get the ETag from the uploaded part, this should be sent with the CompleteMultipartUpload request.
-		return res.Header.Get("ETag"), nil
-	}
-
 	for i, part := range urls.Parts {
 		// Get the size for the current part.
 		var partSize int64
@@ -144,52 +139,114 @@ func (s *S3Backup) generateRemoteRequest(rc io.ReadCloser) error {
 		}
 
 		// Attempt to upload the part.
-		if _, err := handlePart(part, partSize); err != nil {
+		etag, err := uploader.uploadPart(ctx, part, partSize)
+		if err != nil {
 			s.log().WithField("part_id", i+1).WithError(err).Warn("failed to upload part")
-			return err
+			return nil, 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 nil
+	return uploader.uploadedParts, nil
 }
 
-// Restore will read from the provided reader assuming that it is a gzipped
+type s3FileUploader struct {
-// tar reader. When a file is encountered in the archive the callback function
+	io.ReadCloser
-// will be triggered. If the callback returns an error the entire process is
+	client        *http.Client
-// stopped, otherwise this function will run until all files have been written.
+	uploadedParts []remote.BackupPart
+}
+
+// newS3FileUploader returns a new file uploader instance.
+func newS3FileUploader(file io.ReadCloser) *s3FileUploader {
+	return &s3FileUploader{
+		ReadCloser: file,
+		// We purposefully use a super high timeout on this request since we need to upload
+		// a 5GB file. This assumes at worst a 10Mbps connection for uploading. While technically
+		// you could go slower we're targeting mostly hosted servers that should have 100Mbps
+		// connections anyways.
+		client: &http.Client{Timeout: time.Hour * 2},
+	}
+}
+
+// backoff returns a new expoential backoff implementation using a context that
+// will also stop the backoff if it is canceled.
+func (fu *s3FileUploader) backoff(ctx context.Context) backoff.BackOffContext {
+	b := backoff.NewExponentialBackOff()
+	b.Multiplier = 2
+	b.MaxElapsedTime = time.Minute
+
+	return backoff.WithContext(b, ctx)
+}
+
+// uploadPart attempts to upload a given S3 file part to the S3 system. If a
+// 5xx error is returned from the endpoint this will continue with an exponential
+// backoff to try and successfully upload the part.
 //
-// This restoration uses a workerpool to use up to the number of CPUs available
+// Once uploaded the ETag is returned to the caller.
-// on the machine when writing files to the disk.
+func (fu *s3FileUploader) uploadPart(ctx context.Context, part string, size int64) (string, error) {
-func (s *S3Backup) Restore(r io.Reader, callback RestoreCallback) error {
+	r, err := http.NewRequestWithContext(ctx, http.MethodPut, part, nil)
-	reader := r
-	// 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(r, ratelimit.NewBucketWithRate(float64(writeLimit), writeLimit))
-	}
-	gr, err := gzip.NewReader(reader)
 	if err != nil {
-		return err
+		return "", errors.Wrap(err, "backup: could not create request for S3")
 	}
-	defer gr.Close()
+
-	tr := tar.NewReader(gr)
+	r.ContentLength = size
-	for {
+	r.Header.Add("Content-Length", strconv.Itoa(int(size)))
-		header, err := tr.Next()
+	r.Header.Add("Content-Type", "application/x-gzip")
+
+	// Limit the reader to the size of the part.
+	r.Body = Reader{Reader: io.LimitReader(fu.ReadCloser, size)}
+
+	var etag string
+	err = backoff.Retry(func() error {
+		res, err := fu.client.Do(r)
 		if err != nil {
-			if err == io.EOF {
+			if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
-				break
+				return backoff.Permanent(err)
 			}
-			return err
+			// Don't use a permanent error here, if there is a temporary resolution error with
+			// the URL due to DNS issues we want to keep re-trying.
+			return errors.Wrap(err, "backup: S3 HTTP request failed")
 		}
-		if header.Typeflag == tar.TypeReg {
+		_ = res.Body.Close()
-			if err := callback(header.Name, tr); err != nil {
+
+		if res.StatusCode != http.StatusOK {
+			err := errors.New(fmt.Sprintf("backup: failed to put S3 object: [HTTP/%d] %s", res.StatusCode, res.Status))
+			// Only attempt a backoff retry if this error is because of a 5xx error from
+			// the S3 endpoint. Any 4xx error should be treated as an error that a retry
+			// would not fix.
+			if res.StatusCode >= http.StatusInternalServerError {
 				return err
 			}
+			return backoff.Permanent(err)
 		}
+
+		// Get the ETag from the uploaded part, this should be sent with the
+		// CompleteMultipartUpload request.
+		etag = res.Header.Get("ETag")
+
+		return nil
+	}, fu.backoff(ctx))
+
+	if err != nil {
+		if v, ok := err.(*backoff.PermanentError); ok {
+			return "", v.Unwrap()
+		}
+		return "", err
 	}
+	return etag, nil
+}
+
+// Reader provides a wrapper around an existing io.Reader
+// but implements io.Closer in order to satisfy an io.ReadCloser.
+type Reader struct {
+	io.Reader
+}
+
+func (Reader) Close() error {
 	return nil
 }

server/config_parser.go

@@ -6,12 +6,14 @@ import (
 	"github.com/gammazero/workerpool"
 )
 
-// Parent function that will update all of the defined configuration files for a server
+// UpdateConfigurationFiles updates all of the defined configuration files for
-// automatically to ensure that they always use the specified values.
+// a server automatically to ensure that they always use the specified values.
 func (s *Server) UpdateConfigurationFiles() {
 	pool := workerpool.New(runtime.NumCPU())
 
+	s.Log().Debug("acquiring process configuration files...")
 	files := s.ProcessConfiguration().ConfigurationFiles
+	s.Log().Debug("acquired process configuration files")
 	for _, cf := range files {
 		f := cf
 
@@ -26,6 +28,8 @@ func (s *Server) UpdateConfigurationFiles() {
 			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("path", f.FileName).Debug("finished processing server configuration file")
 		})
 	}
 

server/configuration.go

@@ -16,6 +16,11 @@ 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
 
@@ -24,6 +29,8 @@ 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"`
@@ -33,15 +40,18 @@ type Configuration struct {
 
 	// By default this is false, however if selected within the Panel while installing or re-installing a
 	// server, specific installation scripts will be skipped for the server process.
-	SkipEggScripts bool `default:"false" json:"skip_egg_scripts"`
+	SkipEggScripts bool `json:"skip_egg_scripts"`
 
 	// An array of environment variables that should be passed along to the running
 	// 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                    `default:"true" json:"enabled" yaml:"enabled"`
+	CrashDetectionEnabled bool                    `json:"crash_detection_enabled"`
 	Mounts                []Mount                 `json:"mounts"`
 	Egg                   EggConfiguration        `json:"egg,omitempty"`
 
@@ -54,34 +64,30 @@ type Configuration struct {
 func (s *Server) Config() *Configuration {
 	s.cfg.mu.RLock()
 	defer s.cfg.mu.RUnlock()
-
 	return &s.cfg
 }
 
-// Returns the amount of disk space available to a server in bytes.
+// DiskSpace returns the amount of disk space available to a server in bytes.
 func (s *Server) DiskSpace() int64 {
 	s.cfg.mu.RLock()
 	defer s.cfg.mu.RUnlock()
-
 	return s.cfg.Build.DiskSpace * 1024.0 * 1024.0
 }
 
 func (s *Server) MemoryLimit() int64 {
 	s.cfg.mu.RLock()
 	defer s.cfg.mu.RUnlock()
-
 	return s.cfg.Build.MemoryLimit
 }
 
 func (c *Configuration) GetUuid() string {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
-
 	return c.Uuid
 }
 
 func (c *Configuration) SetSuspended(s bool) {
 	c.mu.Lock()
+	defer c.mu.Unlock()
 	c.Suspended = s
-	c.mu.Unlock()
 }

server/console.go

@@ -1,14 +1,12 @@
 package server
 
 import (
-	"context"
 	"fmt"
 	"sync"
-	"sync/atomic"
 	"time"
 
-	"emperror.dev/errors"
 	"github.com/mitchellh/colorstring"
+
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/system"
 )
@@ -17,124 +15,68 @@ 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) {
-	if appName == "" {
+	appNameSync.Do(func() {
 		appName = config.Get().AppName
-	}
+	})
 	s.Events().Publish(
 		ConsoleOutputEvent,
 		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(fmt.Sprintf("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()
+}

server/console_test.go

@@ -0,0 +1,62 @@
+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()
+	}
+}

server/crash.go

@@ -6,6 +6,8 @@ import (
 	"sync"
 	"time"
 
+	"emperror.dev/errors"
+
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
 )
@@ -57,7 +59,7 @@ func (s *Server) handleServerCrash() error {
 
 	exitCode, oomKilled, err := s.Environment.ExitState()
 	if err != nil {
-		return err
+		return errors.Wrap(err, "failed to get exit state for server process")
 	}
 
 	// If the system is not configured to detect a clean exit code as a crash, and the
@@ -85,5 +87,5 @@ func (s *Server) handleServerCrash() error {
 
 	s.crasher.SetLastCrash(time.Now())
 
-	return s.HandlePowerAction(PowerActionStart)
+	return errors.Wrap(s.HandlePowerAction(PowerActionStart), "failed to start server after crash detection")
 }

server/errors.go

@@ -12,8 +12,7 @@ var (
 	ErrServerIsRestoring    = errors.New("server is currently being restored")
 )
 
-type crashTooFrequent struct {
+type crashTooFrequent struct{}
-}
 
 func (e *crashTooFrequent) Error() string {
 	return "server has crashed too soon after the last detected crash"
@@ -25,8 +24,7 @@ func IsTooFrequentCrashError(err error) bool {
 	return ok
 }
 
-type serverDoesNotExist struct {
+type serverDoesNotExist struct{}
-}
 
 func (e *serverDoesNotExist) Error() string {
 	return "server does not exist on remote system"

server/events.go

@@ -2,10 +2,10 @@ package server
 
 import (
 	"github.com/pterodactyl/wings/events"
+	"github.com/pterodactyl/wings/system"
 )
 
-// Defines all of the possible output events for a server.
+// Defines all the possible output events for a server.
-// noinspection GoNameStartsWithPackageName
 const (
 	DaemonMessageEvent          = "daemon message"
 	InstallOutputEvent          = "install output"
@@ -18,16 +18,38 @@ const (
 	BackupCompletedEvent        = "backup completed"
 	TransferLogsEvent           = "transfer logs"
 	TransferStatusEvent         = "transfer status"
+	DeletedEvent                = "deleted"
 )
 
-// Returns the server's emitter instance.
+// Events returns the server's emitter instance.
-func (s *Server) Events() *events.EventBus {
+func (s *Server) Events() *events.Bus {
 	s.emitterLock.Lock()
 	defer s.emitterLock.Unlock()
 
 	if s.emitter == nil {
-		s.emitter = events.New()
+		s.emitter = events.NewBus()
 	}
 
 	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()
+	}
+}

server/filesystem/archive.go

@@ -2,7 +2,9 @@ package filesystem
 
 import (
 	"archive/tar"
+	"context"
 	"io"
+	"io/fs"
 	"os"
 	"path/filepath"
 	"strings"
@@ -13,8 +15,10 @@ import (
 	"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/sabhiram/go-gitignore"
+	"github.com/pterodactyl/wings/internal/progress"
 )
 
 const memory = 4 * 1024
@@ -26,6 +30,31 @@ var pool = sync.Pool{
 	},
 }
 
+// TarProgress .
+type TarProgress struct {
+	*tar.Writer
+	p *progress.Progress
+}
+
+// NewTarProgress .
+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 Archive struct {
 	// BasePath is the absolute path to create the archive from where Files and Ignore are
 	// relative to.
@@ -38,12 +67,15 @@ type Archive struct {
 	// 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
+
+	// Progress wraps the writer of the archive to pass through the progress tracker.
+	Progress *progress.Progress
 }
 
-// Create creates an archive at dst with all of the files defined in the
+// Create creates an archive at dst with all the files defined in the
-// included files struct.
+// included Files array.
-func (a *Archive) Create(dst string) error {
+func (a *Archive) Create(ctx context.Context, dst string) error {
-	f, err := os.OpenFile(dst, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
+	f, err := os.OpenFile(dst, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o600)
 	if err != nil {
 		return err
 	}
@@ -60,8 +92,26 @@ func (a *Archive) Create(dst string) error {
 		writer = f
 	}
 
+	return a.Stream(ctx, writer)
+}
+
+// Stream .
+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
+	case "best_speed":
+		fallthrough
+	default:
+		compressionLevel = pgzip.BestSpeed
+	}
+
 	// Create a new gzip writer around the file.
-	gw, _ := pgzip.NewWriterLevel(writer, pgzip.BestSpeed)
+	gw, _ := pgzip.NewWriterLevel(w, compressionLevel)
 	_ = gw.SetConcurrency(1<<20, 1)
 	defer gw.Close()
 
@@ -69,20 +119,22 @@ func (a *Archive) Create(dst string) error {
 	tw := tar.NewWriter(gw)
 	defer tw.Close()
 
+	pw := NewTarProgress(tw, a.Progress)
+
 	// Configure godirwalk.
 	options := &godirwalk.Options{
 		FollowSymbolicLinks: false,
 		Unsorted:            true,
-		Callback:            a.callback(tw),
 	}
 
 	// 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.
+	var callback godirwalk.WalkFunc
 	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 {
+		callback = a.callback(pw, func(_ string, rp string) error {
 			if i.MatchesPath(rp) {
 				return godirwalk.SkipThis
 			}
@@ -90,7 +142,19 @@ func (a *Archive) Create(dst string) error {
 			return nil
 		})
 	} else if len(a.Files) > 0 {
-		options.Callback = a.withFilesCallback(tw)
+		callback = a.withFilesCallback(pw)
+	} else {
+		callback = a.callback(pw)
+	}
+
+	// Set the callback function, wrapped with support for context cancellation.
+	options.Callback = func(path string, de *godirwalk.Dirent) error {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		default:
+			return callback(path, de)
+		}
 	}
 
 	// Recursively walk the path we are archiving.
@@ -99,9 +163,9 @@ func (a *Archive) Create(dst string) error {
 
 // Callback function used to determine if a given file should be included in the archive
 // being generated.
-func (a *Archive) callback(tw *tar.Writer, opts ...func(path string, relative string) error) func(path string, de *godirwalk.Dirent) error {
+func (a *Archive) callback(tw *TarProgress, 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.
+		// Skip directories because we are walking them recursively.
 		if de.IsDir() {
 			return nil
 		}
@@ -123,12 +187,12 @@ func (a *Archive) callback(tw *tar.Writer, opts ...func(path string, relative st
 }
 
 // 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 {
+func (a *Archive) withFilesCallback(tw *TarProgress) 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) {
+			if p != f && !strings.HasPrefix(strings.TrimSuffix(p, "/")+"/", f) {
 				continue
 			}
 
@@ -144,9 +208,9 @@ func (a *Archive) withFilesCallback(tw *tar.Writer) func(path string, de *godirw
 }
 
 // Adds a given file path to the final archive being created.
-func (a *Archive) addToArchive(p string, rp string, w *tar.Writer) error {
+func (a *Archive) addToArchive(p string, rp string, w *TarProgress) 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
+	// follow a symlink to its 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 {
@@ -156,16 +220,22 @@ func (a *Archive) addToArchive(p string, rp string, w *tar.Writer) error {
 		return errors.WrapIff(err, "failed executing os.Lstat on '%s'", rp)
 	}
 
+	// Skip socket files as they are unsupported by archive/tar.
+	// Error will come from tar#FileInfoHeader: "archive/tar: sockets not supported"
+	if s.Mode()&fs.ModeSocket != 0 {
+		return nil
+	}
+
 	// Resolve the symlink target if the file is a symlink.
 	var target string
-	if s.Mode()&os.ModeSymlink != 0 {
+	if s.Mode()&fs.ModeSymlink != 0 {
 		// 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 {
-			// Ignore the not exist errors specifically, since theres nothing important about that.
+			// Ignore the not exist errors specifically, since there is 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...")
 			}
@@ -180,7 +250,7 @@ func (a *Archive) addToArchive(p string, rp string, w *tar.Writer) error {
 	}
 
 	// Fix the header name if the file is not a symlink.
-	if s.Mode()&os.ModeSymlink == 0 {
+	if s.Mode()&fs.ModeSymlink == 0 {
 		header.Name = rp
 	}
 

server/filesystem/compress.go

@@ -1,19 +1,28 @@
 package filesystem
 
 import (
+	"archive/tar"
+	"archive/zip"
+	"compress/gzip"
+	"context"
 	"fmt"
+	"io"
+	iofs "io/fs"
 	"os"
 	"path"
 	"path/filepath"
+	"reflect"
 	"strings"
 	"sync/atomic"
 	"time"
 
 	"emperror.dev/errors"
-	"github.com/mholt/archiver/v3"
+	gzip2 "github.com/klauspost/compress/gzip"
+	zip2 "github.com/klauspost/compress/zip"
+	"github.com/mholt/archiver/v4"
 )
 
-// CompressFiles compresses all of the files matching the given paths in the
+// CompressFiles compresses all 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
@@ -28,7 +37,7 @@ func (fs *Filesystem) CompressFiles(dir string, paths []string) (os.FileInfo, er
 		return nil, err
 	}
 
-	// Take all of the paths passed in and merge them together with the root directory we've gotten.
+	// Take all 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)
 	}
@@ -44,7 +53,7 @@ func (fs *Filesystem) CompressFiles(dir string, paths []string) (os.FileInfo, er
 		fmt.Sprintf("archive-%s.tar.gz", strings.ReplaceAll(time.Now().Format(time.RFC3339), ":", "")),
 	)
 
-	if err := a.Create(d); err != nil {
+	if err := a.Create(context.Background(), d); err != nil {
 		return nil, err
 	}
 
@@ -66,7 +75,7 @@ func (fs *Filesystem) CompressFiles(dir string, paths []string) (os.FileInfo, er
 
 // 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 {
+func (fs *Filesystem) SpaceAvailableForDecompression(ctx context.Context, 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 {
@@ -82,60 +91,184 @@ func (fs *Filesystem) SpaceAvailableForDecompression(dir string, file string) er
 	// waiting an unnecessary amount of time on this call.
 	dirSize, err := fs.DiskUsage(false)
 
-	var size int64
+	fsys, err := archiver.FileSystem(source)
-	// 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
-	})
 	if err != nil {
-		if IsUnknownArchiveFormatError(err) {
+		if errors.Is(err, archiver.ErrNoMatch) {
 			return newFilesystemError(ErrCodeUnknownArchive, err)
 		}
 		return err
 	}
-	return err
+
+	var size int64
+	return iofs.WalkDir(fsys, ".", func(path string, d iofs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+
+		select {
+		case <-ctx.Done():
+			// Stop walking if the context is canceled.
+			return ctx.Err()
+		default:
+			info, err := d.Info()
+			if err != nil {
+				return err
+			}
+			if atomic.AddInt64(&size, info.Size())+dirSize > fs.MaxDisk() {
+				return newFilesystemError(ErrCodeDiskSpace, nil)
+			}
+			return nil
+		}
+	})
 }
 
 // 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
+// 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(dir string, file string) error {
+func (fs *Filesystem) DecompressFile(ctx context.Context, 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.
+	return fs.DecompressFileUnsafe(ctx, dir, source)
-	if _, err := os.Stat(source); err != nil {
+}
+
+// DecompressFileUnsafe will decompress any file on the local disk without checking
+// if it is owned by the server.  The file will be SAFELY decompressed and extracted
+// into the server's directory.
+func (fs *Filesystem) DecompressFileUnsafe(ctx context.Context, dir string, file string) error {
+	// Ensure that the archive actually exists on the system.
+	if _, err := os.Stat(file); err != nil {
 		return errors.WithStack(err)
 	}
 
-	// Walk all of the files in the archiver file and write them to the disk. If any
+	f, err := os.Open(file)
-	// 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, f.Name())
-		// 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)
-		}
-		return nil
-	})
 	if err != nil {
-		if IsUnknownArchiveFormatError(err) {
+		return err
+	}
+	defer f.Close()
+
+	// Identify the type of archive we are dealing with.
+	format, input, err := archiver.Identify(filepath.Base(file), f)
+	if err != nil {
+		if errors.Is(err, archiver.ErrNoMatch) {
 			return newFilesystemError(ErrCodeUnknownArchive, err)
 		}
 		return err
 	}
+
+	return fs.extractStream(ctx, extractStreamOptions{
+		Directory: dir,
+		Format:    format,
+		Reader:    input,
+	})
+}
+
+// ExtractStreamUnsafe .
+func (fs *Filesystem) ExtractStreamUnsafe(ctx context.Context, dir string, r io.Reader) error {
+	format, input, err := archiver.Identify("archive.tar.gz", r)
+	if err != nil {
+		if errors.Is(err, archiver.ErrNoMatch) {
+			return newFilesystemError(ErrCodeUnknownArchive, err)
+		}
+		return err
+	}
+
+	return fs.extractStream(ctx, extractStreamOptions{
+		Directory: dir,
+		Format:    format,
+		Reader:    input,
+	})
+}
+
+type extractStreamOptions struct {
+	// The directory to extract the archive to.
+	Directory string
+	// File name of the archive.
+	FileName string
+	// Format of the archive.
+	Format archiver.Format
+	// Reader for the archive.
+	Reader io.Reader
+}
+
+func (fs *Filesystem) extractStream(ctx context.Context, opts extractStreamOptions) error {
+	// Decompress and extract archive
+	if ex, ok := opts.Format.(archiver.Extractor); ok {
+		return ex.Extract(ctx, opts.Reader, nil, func(ctx context.Context, f archiver.File) error {
+			if f.IsDir() {
+				return nil
+			}
+			p := filepath.Join(opts.Directory, 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
+			}
+			r, err := f.Open()
+			if err != nil {
+				return err
+			}
+			defer r.Close()
+			if err := fs.Writefile(p, r); err != nil {
+				return wrapError(err, opts.FileName)
+			}
+			// Update the file permissions to the one set in the archive.
+			if err := fs.Chmod(p, f.Mode()); err != nil {
+				return wrapError(err, opts.FileName)
+			}
+			// 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, opts.FileName)
+			}
+			return nil
+		})
+	}
 	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 *zip.FileHeader:
+		return s.Name
+	case *zip2.FileHeader:
+		return s.Name
+	case *tar.Header:
+		return s.Name
+	case *gzip.Header:
+		return s.Name
+	case *gzip2.Header:
+		return s.Name
+	default:
+		// At this point we cannot figure out what type of archive this might be so
+		// just try to find the name field in the struct. If it is found return it.
+		field := reflect.Indirect(reflect.ValueOf(sys)).FieldByName("Name")
+		if field.IsValid() {
+			return field.String()
+		}
+		// Fallback to the basename of the file at this point. There is nothing we can really
+		// do to try and figure out what the underlying directory of the file is supposed to
+		// be since it didn't implement a name field.
+		return f.Name()
+	}
+}

server/filesystem/compress_test.go

@@ -0,0 +1,55 @@
+package filesystem
+
+import (
+	"context"
+	"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(context.Background(), "/", "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)
+		})
+	})
+}

server/filesystem/disk_space.go

@@ -71,7 +71,7 @@ func (fs *Filesystem) HasSpaceAvailable(allowStaleValue bool) bool {
 	// 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 it's limit but because this method caches the disk usage it would be best
+	// server exceeds its 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
@@ -183,7 +183,7 @@ func (fs *Filesystem) DirectorySize(dir string) (int64, error) {
 			}
 
 			if !e.IsDir() {
-				syscall.Lstat(p, &st)
+				_ = syscall.Lstat(p, &st)
 				atomic.AddInt64(&size, st.Size)
 			}
 

server/filesystem/errors.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"strings"
 
 	"emperror.dev/errors"
 	"github.com/apex/log"
@@ -19,6 +18,7 @@ const (
 	ErrCodePathResolution ErrorCode = "E_BADPATH"
 	ErrCodeDenylistFile   ErrorCode = "E_DENYLIST"
 	ErrCodeUnknownError   ErrorCode = "E_UNKNOWN"
+	ErrNotExist           ErrorCode = "E_NOTEXIST"
 )
 
 type Error struct {
@@ -69,6 +69,8 @@ func (e *Error) Error() string {
 			r = "<empty>"
 		}
 		return fmt.Sprintf("filesystem: server path [%s] resolves to a location outside the server root: %s", e.path, r)
+	case ErrNotExist:
+		return "filesystem: does not exist"
 	case ErrCodeUnknownError:
 		fallthrough
 	default:
@@ -122,15 +124,6 @@ func IsErrorCode(err error, code ErrorCode) bool {
 	return false
 }
 
-// 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
-}
-
 // NewBadPathResolution returns a new BadPathResolution error.
 func NewBadPathResolution(path string, resolved string) error {
 	return errors.WithStackDepth(&Error{code: ErrCodePathResolution, path: path, resolved: resolved}, 1)

server/filesystem/filesystem.go

@@ -17,9 +17,10 @@ import (
 	"emperror.dev/errors"
 	"github.com/gabriel-vasile/mimetype"
 	"github.com/karrick/godirwalk"
+	ignore "github.com/sabhiram/go-gitignore"
+
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/system"
-	ignore "github.com/sabhiram/go-gitignore"
 )
 
 type Filesystem struct {
@@ -60,34 +61,40 @@ func (fs *Filesystem) Path() string {
 func (fs *Filesystem) File(p string) (*os.File, Stat, error) {
 	cleaned, err := fs.SafePath(p)
 	if err != nil {
-		return nil, Stat{}, err
+		return nil, Stat{}, errors.WithStackIf(err)
 	}
 	st, err := fs.Stat(cleaned)
 	if err != nil {
-		return nil, Stat{}, err
+		if errors.Is(err, os.ErrNotExist) {
+			return nil, Stat{}, newFilesystemError(ErrNotExist, err)
+		}
+		return nil, Stat{}, errors.WithStackIf(err)
 	}
 	if st.IsDir() {
 		return nil, Stat{}, newFilesystemError(ErrCodeIsDirectory, nil)
 	}
 	f, err := os.Open(cleaned)
 	if err != nil {
-		return nil, Stat{}, err
+		return nil, Stat{}, errors.WithStackIf(err)
 	}
 	return f, st, nil
 }
 
-// Acts by creating the given file and path on the disk if it is not present already. If
+// Touch acts by creating the given file and path on the disk if it is not present
-// it is present, the file is opened using the defaults which will truncate the contents.
+// already. If  it is present, the file is opened using the defaults which will truncate
-// The opened file is then returned to the caller.
+// 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, 0644)
+	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")
@@ -96,7 +103,7 @@ func (fs *Filesystem) Touch(p string, flag int) (*os.File, error) {
 	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 := os.MkdirAll(filepath.Dir(cleaned), 0755); err != nil {
+		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(cleaned)); err != nil {
@@ -106,7 +113,7 @@ func (fs *Filesystem) Touch(p string, flag int) (*os.File, error) {
 	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(cleaned, flag, 0644)
+	f, err = o.open(cleaned, flag, 0o644)
 	if err != nil {
 		return nil, errors.Wrap(err, "server/filesystem: touch: failed to open file with wait")
 	}
@@ -114,19 +121,6 @@ func (fs *Filesystem) Touch(p string, flag int) (*os.File, error) {
 	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.
@@ -171,7 +165,7 @@ 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(cleaned)
+	return fs.unsafeChown(cleaned)
 }
 
 // Creates a new directory (name) at a specified path (p) for the server.
@@ -180,19 +174,19 @@ func (fs *Filesystem) CreateDirectory(name string, p string) error {
 	if err != nil {
 		return err
 	}
-	return os.MkdirAll(cleaned, 0755)
+	return os.MkdirAll(cleaned, 0o755)
 }
 
-// Moves (or renames) a file or directory.
+// Rename 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
+		return errors.WithStack(err)
 	}
 
 	cleanedTo, err := fs.SafePath(to)
 	if err != nil {
-		return err
+		return errors.WithStack(err)
 	}
 
 	// If the target file or directory already exists the rename function will fail, so just
@@ -209,12 +203,15 @@ func (fs *Filesystem) Rename(from string, to string) error {
 	// 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 != fs.Path() {
-		if mkerr := os.MkdirAll(d, 0755); mkerr != nil {
+		if mkerr := os.MkdirAll(d, 0o755); mkerr != nil {
 			return errors.WithMessage(mkerr, "failed to create directory structure for file rename")
 		}
 	}
 
-	return os.Rename(cleanedFrom, cleanedTo)
+	if err := os.Rename(cleanedFrom, cleanedTo); err != nil {
+		return errors.WithStack(err)
+	}
+	return nil
 }
 
 // Recursively iterates over a file or directory and sets the permissions on all of the
@@ -226,7 +223,12 @@ func (fs *Filesystem) Chown(path string) error {
 	if err != nil {
 		return err
 	}
+	return fs.unsafeChown(cleaned)
+}
 
+// unsafeChown chowns the given path, without checking if the path is safe. This should only be used
+// when the path has already been checked.
+func (fs *Filesystem) unsafeChown(path string) error {
 	if fs.isTest {
 		return nil
 	}
@@ -235,19 +237,19 @@ func (fs *Filesystem) Chown(path string) error {
 	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 {
+	if err := os.Chown(path, 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() {
+	if st, err := os.Stat(path); 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{
+	err := godirwalk.Walk(path, &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
@@ -264,7 +266,6 @@ func (fs *Filesystem) Chown(path string) error {
 			return os.Chown(p, uid, gid)
 		},
 	})
-
 	return errors.Wrap(err, "server/filesystem: chown: failed to chown during walk function")
 }
 
@@ -376,7 +377,7 @@ func (fs *Filesystem) TruncateRootDirectory() error {
 	if err := os.RemoveAll(fs.Path()); err != nil {
 		return err
 	}
-	if err := os.Mkdir(fs.Path(), 0755); err != nil {
+	if err := os.Mkdir(fs.Path(), 0o755); err != nil {
 		return err
 	}
 	atomic.StoreInt64(&fs.diskUsed, 0)
@@ -484,14 +485,18 @@ func (fs *Filesystem) ListDirectory(p string) ([]Stat, error) {
 			defer wg.Done()
 
 			var m *mimetype.MIME
-			var d = "inode/directory"
+			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 cleanedp != "" {
+				// 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 cleanedp != "" && f.Mode()&os.ModeNamedPipe == 0 {
 					m, _ = mimetype.DetectFile(filepath.Join(cleaned, f.Name()))
 				} else {
 					// Just pass this for an unknown type because the file could not safely be resolved within
@@ -527,3 +532,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
+}

server/filesystem/filesystem_test.go

@@ -1,9 +1,9 @@
 package filesystem
 
 import (
+	"bufio"
 	"bytes"
 	"errors"
-	"io/ioutil"
 	"math/rand"
 	"os"
 	"path/filepath"
@@ -12,6 +12,7 @@ import (
 	"unicode/utf8"
 
 	. "github.com/franela/goblin"
+
 	"github.com/pterodactyl/wings/config"
 )
 
@@ -24,7 +25,7 @@ func NewFs() (*Filesystem, *rootFs) {
 		},
 	})
 
-	tmpDir, err := ioutil.TempDir(os.TempDir(), "pterodactyl")
+	tmpDir, err := os.MkdirTemp(os.TempDir(), "pterodactyl")
 	if err != nil {
 		panic(err)
 	}
@@ -44,17 +45,29 @@ type rootFs struct {
 	root string
 }
 
-func (rfs *rootFs) CreateServerFile(p string, c string) error {
+func getFileContent(file *os.File) string {
+	var w bytes.Buffer
+	if _, err := bufio.NewReader(file).WriteTo(&w); err != nil {
+		panic(err)
+	}
+	return w.String()
+}
+
+func (rfs *rootFs) CreateServerFile(p string, c []byte) error {
 	f, err := os.Create(filepath.Join(rfs.root, "/server", p))
 
 	if err == nil {
-		f.Write([]byte(c))
+		f.Write(c)
 		f.Close()
 	}
 
 	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))
 }
@@ -66,54 +79,35 @@ func (rfs *rootFs) reset() {
 		}
 	}
 
-	if err := os.Mkdir(filepath.Join(rfs.root, "/server"), 0755); err != nil {
+	if err := os.Mkdir(filepath.Join(rfs.root, "/server"), 0o755); err != nil {
 		panic(err)
 	}
 }
 
-func TestFilesystem_Readfile(t *testing.T) {
+func TestFilesystem_Openfile(t *testing.T) {
 	g := Goblin(t)
 	fs, rfs := NewFs()
 
-	g.Describe("Readfile", func() {
+	g.Describe("File", func() {
-		buf := &bytes.Buffer{}
+		g.It("returns custom error when file does not exist", func() {
+			_, _, err := fs.File("foo/bar.txt")
 
-		g.It("opens a file if it exists on the system", func() {
+			g.Assert(err).IsNotNil()
-			err := rfs.CreateServerFile("test.txt", "testing")
+			g.Assert(IsErrorCode(err, ErrNotExist)).IsTrue()
-			g.Assert(err).IsNil()
-
-			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() {
+		g.It("returns file stat information", func() {
-			err := fs.Readfile("test.txt", buf)
+			_ = rfs.CreateServerFile("foo.txt", []byte("hello world"))
-			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, os.ErrNotExist)).IsTrue()
-		})
 
-		g.It("returns an error if the \"file\" is a directory", func() {
+			f, st, err := fs.File("foo.txt")
-			err := os.Mkdir(filepath.Join(rfs.root, "/server/test.txt"), 0755)
 			g.Assert(err).IsNil()
 
-			err = fs.Readfile("test.txt", buf)
+			g.Assert(st.Name()).Equal("foo.txt")
-			g.Assert(err).IsNotNil()
+			g.Assert(f).IsNotNil()
-			g.Assert(IsErrorCode(err, ErrCodeIsDirectory)).IsTrue()
+			_ = f.Close()
-		})
-
-		g.It("cannot open a file outside the root directory", func() {
-			err := rfs.CreateServerFile("/../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() {
-			buf.Truncate(0)
-			atomic.StoreInt64(&fs.diskUsed, 0)
 			rfs.reset()
 		})
 	})
@@ -136,9 +130,10 @@ func TestFilesystem_Writefile(t *testing.T) {
 			err := fs.Writefile("test.txt", r)
 			g.Assert(err).IsNil()
 
-			err = fs.Readfile("test.txt", buf)
+			f, _, err := fs.File("test.txt")
 			g.Assert(err).IsNil()
-			g.Assert(buf.String()).Equal("test file content")
+			defer f.Close()
+			g.Assert(getFileContent(f)).Equal("test file content")
 			g.Assert(atomic.LoadInt64(&fs.diskUsed)).Equal(r.Size())
 		})
 
@@ -148,9 +143,10 @@ func TestFilesystem_Writefile(t *testing.T) {
 			err := fs.Writefile("/some/nested/test.txt", r)
 			g.Assert(err).IsNil()
 
-			err = fs.Readfile("/some/nested/test.txt", buf)
+			f, _, err := fs.File("/some/nested/test.txt")
 			g.Assert(err).IsNil()
-			g.Assert(buf.String()).Equal("test file content")
+			defer f.Close()
+			g.Assert(getFileContent(f)).Equal("test file content")
 		})
 
 		g.It("can create a new file inside a nested directory without a trailing slash", func() {
@@ -159,9 +155,10 @@ func TestFilesystem_Writefile(t *testing.T) {
 			err := fs.Writefile("some/../foo/bar/test.txt", r)
 			g.Assert(err).IsNil()
 
-			err = fs.Readfile("foo/bar/test.txt", buf)
+			f, _, err := fs.File("foo/bar/test.txt")
 			g.Assert(err).IsNil()
-			g.Assert(buf.String()).Equal("test file content")
+			defer f.Close()
+			g.Assert(getFileContent(f)).Equal("test file content")
 		})
 
 		g.It("cannot create a file outside the root directory", func() {
@@ -186,28 +183,6 @@ 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)
@@ -217,9 +192,10 @@ func TestFilesystem_Writefile(t *testing.T) {
 			err = fs.Writefile("test.txt", r)
 			g.Assert(err).IsNil()
 
-			err = fs.Readfile("test.txt", buf)
+			f, _, err := fs.File("test.txt")
 			g.Assert(err).IsNil()
-			g.Assert(buf.String()).Equal("new data")
+			defer f.Close()
+			g.Assert(getFileContent(f)).Equal("new data")
 		})
 
 		g.AfterEach(func() {
@@ -281,13 +257,13 @@ func TestFilesystem_Rename(t *testing.T) {
 
 	g.Describe("Rename", func() {
 		g.BeforeEach(func() {
-			if err := rfs.CreateServerFile("source.txt", "text content"); err != nil {
+			if err := rfs.CreateServerFileFromString("source.txt", "text content"); err != nil {
 				panic(err)
 			}
 		})
 
 		g.It("returns an error if the target already exists", func() {
-			err := rfs.CreateServerFile("target.txt", "taget content")
+			err := rfs.CreateServerFileFromString("target.txt", "taget content")
 			g.Assert(err).IsNil()
 
 			err = fs.Rename("source.txt", "target.txt")
@@ -314,7 +290,7 @@ func TestFilesystem_Rename(t *testing.T) {
 		})
 
 		g.It("does not allow renaming from a location outside the root", func() {
-			err := rfs.CreateServerFile("/../ext-source.txt", "taget content")
+			err := rfs.CreateServerFileFromString("/../ext-source.txt", "taget content")
 
 			err = fs.Rename("/../ext-source.txt", "target.txt")
 			g.Assert(err).IsNotNil()
@@ -336,7 +312,7 @@ func TestFilesystem_Rename(t *testing.T) {
 		})
 
 		g.It("allows a folder to be renamed", func() {
-			err := os.Mkdir(filepath.Join(rfs.root, "/server/source_dir"), 0755)
+			err := os.Mkdir(filepath.Join(rfs.root, "/server/source_dir"), 0o755)
 			g.Assert(err).IsNil()
 
 			err = fs.Rename("source_dir", "target_dir")
@@ -378,7 +354,7 @@ func TestFilesystem_Copy(t *testing.T) {
 
 	g.Describe("Copy", func() {
 		g.BeforeEach(func() {
-			if err := rfs.CreateServerFile("source.txt", "text content"); err != nil {
+			if err := rfs.CreateServerFileFromString("source.txt", "text content"); err != nil {
 				panic(err)
 			}
 
@@ -392,7 +368,7 @@ func TestFilesystem_Copy(t *testing.T) {
 		})
 
 		g.It("should return an error if the source is outside the root", func() {
-			err := rfs.CreateServerFile("/../ext-source.txt", "text content")
+			err := rfs.CreateServerFileFromString("/../ext-source.txt", "text content")
 
 			err = fs.Copy("../ext-source.txt")
 			g.Assert(err).IsNotNil()
@@ -400,10 +376,10 @@ func TestFilesystem_Copy(t *testing.T) {
 		})
 
 		g.It("should return an error if the source directory is outside the root", func() {
-			err := os.MkdirAll(filepath.Join(rfs.root, "/nested/in/dir"), 0755)
+			err := os.MkdirAll(filepath.Join(rfs.root, "/nested/in/dir"), 0o755)
 			g.Assert(err).IsNil()
 
-			err = rfs.CreateServerFile("/../nested/in/dir/ext-source.txt", "external content")
+			err = rfs.CreateServerFileFromString("/../nested/in/dir/ext-source.txt", "external content")
 			g.Assert(err).IsNil()
 
 			err = fs.Copy("../nested/in/dir/ext-source.txt")
@@ -416,7 +392,7 @@ func TestFilesystem_Copy(t *testing.T) {
 		})
 
 		g.It("should return an error if the source is a directory", func() {
-			err := os.Mkdir(filepath.Join(rfs.root, "/server/dir"), 0755)
+			err := os.Mkdir(filepath.Join(rfs.root, "/server/dir"), 0o755)
 			g.Assert(err).IsNil()
 
 			err = fs.Copy("dir")
@@ -461,10 +437,10 @@ func TestFilesystem_Copy(t *testing.T) {
 		})
 
 		g.It("should create a copy inside of a directory", func() {
-			err := os.MkdirAll(filepath.Join(rfs.root, "/server/nested/in/dir"), 0755)
+			err := os.MkdirAll(filepath.Join(rfs.root, "/server/nested/in/dir"), 0o755)
 			g.Assert(err).IsNil()
 
-			err = rfs.CreateServerFile("nested/in/dir/source.txt", "test content")
+			err = rfs.CreateServerFileFromString("nested/in/dir/source.txt", "test content")
 			g.Assert(err).IsNil()
 
 			err = fs.Copy("nested/in/dir/source.txt")
@@ -492,7 +468,7 @@ func TestFilesystem_Delete(t *testing.T) {
 
 	g.Describe("Delete", func() {
 		g.BeforeEach(func() {
-			if err := rfs.CreateServerFile("source.txt", "test content"); err != nil {
+			if err := rfs.CreateServerFileFromString("source.txt", "test content"); err != nil {
 				panic(err)
 			}
 
@@ -500,7 +476,7 @@ func TestFilesystem_Delete(t *testing.T) {
 		})
 
 		g.It("does not delete files outside the root directory", func() {
-			err := rfs.CreateServerFile("/../ext-source.txt", "external content")
+			err := rfs.CreateServerFileFromString("/../ext-source.txt", "external content")
 
 			err = fs.Delete("../ext-source.txt")
 			g.Assert(err).IsNotNil()
@@ -540,11 +516,11 @@ func TestFilesystem_Delete(t *testing.T) {
 				"foo/bar/baz/source.txt",
 			}
 
-			err := os.MkdirAll(filepath.Join(rfs.root, "/server/foo/bar/baz"), 0755)
+			err := os.MkdirAll(filepath.Join(rfs.root, "/server/foo/bar/baz"), 0o755)
 			g.Assert(err).IsNil()
 
 			for _, s := range sources {
-				err = rfs.CreateServerFile(s, "test content")
+				err = rfs.CreateServerFileFromString(s, "test content")
 				g.Assert(err).IsNil()
 			}
 

server/filesystem/path.go

@@ -2,6 +2,7 @@ package filesystem
 
 import (
 	"context"
+	iofs "io/fs"
 	"os"
 	"path/filepath"
 	"strings"
@@ -33,8 +34,6 @@ func (fs *Filesystem) IsIgnored(paths ...string) error {
 // 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)
 
@@ -44,47 +43,24 @@ func (fs *Filesystem) SafePath(p string) (string, error) {
 	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
+		// The target of one of the symlinks (EvalSymlinks is recursive) does not exist.
-		// path chain until we hit a directory that _does_ exist and can be validated.
+		// So we get what target path does not exist and check if it's within the data
-		parts := strings.Split(filepath.Dir(r), "/")
+		// directory. If it is, we return the original path, otherwise we return an error.
-
+		pErr, ok := err.(*iofs.PathError)
-		var try string
+		if !ok {
-		// Range over all of the path parts and form directory pathings from the end
+			return "", errors.Wrap(err, "server/filesystem: failed to evaluate symlink")
-		// 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
-			}
 		}
-	}
+		ep = pErr.Path
-
-	// 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
+		// Returning the original path here instead of the resolved path ensures that
+		// whatever the user is trying to do will work as expected. If we returned the
+		// resolved path, the user would be unable to know that it is in fact a symlink.
+		return r, nil
 	}
 
 	return "", NewBadPathResolution(p, r)
@@ -115,8 +91,8 @@ func (fs *Filesystem) ParallelSafePath(paths []string) ([]string, error) {
 	var cleaned []string
 
 	// Simple locker function to avoid racy appends to the array of cleaned paths.
-	var m = new(sync.Mutex)
+	m := new(sync.Mutex)
-	var push = func(c string) {
+	push := func(c string) {
 		m.Lock()
 		cleaned = append(cleaned, c)
 		m.Unlock()

server/filesystem/path_test.go

@@ -103,11 +103,11 @@ func TestFilesystem_Blocks_Symlinks(t *testing.T) {
 	g := Goblin(t)
 	fs, rfs := NewFs()
 
-	if err := rfs.CreateServerFile("/../malicious.txt", "external content"); err != nil {
+	if err := rfs.CreateServerFileFromString("/../malicious.txt", "external content"); err != nil {
 		panic(err)
 	}
 
-	if err := os.Mkdir(filepath.Join(rfs.root, "/malicious_dir"), 0777); err != nil {
+	if err := os.Mkdir(filepath.Join(rfs.root, "/malicious_dir"), 0o777); err != nil {
 		panic(err)
 	}
 
@@ -115,19 +115,17 @@ func TestFilesystem_Blocks_Symlinks(t *testing.T) {
 		panic(err)
 	}
 
-	if err := os.Symlink(filepath.Join(rfs.root, "/malicious_dir"), filepath.Join(rfs.root, "/server/external_dir")); err != nil {
+	if err := os.Symlink(filepath.Join(rfs.root, "malicious_does_not_exist.txt"), filepath.Join(rfs.root, "/server/symlinked_does_not_exist.txt")); err != nil {
 		panic(err)
 	}
 
-	g.Describe("Readfile", func() {
+	if err := os.Symlink(filepath.Join(rfs.root, "/server/symlinked_does_not_exist.txt"), filepath.Join(rfs.root, "/server/symlinked_does_not_exist2.txt")); err != nil {
-		g.It("cannot read a file symlinked outside the root", func() {
+		panic(err)
-			b := bytes.Buffer{}
+	}
 
-			err := fs.Readfile("symlinked.txt", &b)
+	if err := os.Symlink(filepath.Join(rfs.root, "/malicious_dir"), filepath.Join(rfs.root, "/server/external_dir")); err != nil {
-			g.Assert(err).IsNotNil()
+		panic(err)
-			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
+	}
-		})
-	})
 
 	g.Describe("Writefile", func() {
 		g.It("cannot write to a file symlinked outside the root", func() {
@@ -138,6 +136,22 @@ func TestFilesystem_Blocks_Symlinks(t *testing.T) {
 			g.Assert(IsErrorCode(err, ErrCodePathResolution)).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(IsErrorCode(err, ErrCodePathResolution)).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(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
+		})
+
 		g.It("cannot write a file to a directory symlinked outside the root", func() {
 			r := bytes.NewReader([]byte("testing"))
 
@@ -181,7 +195,7 @@ func TestFilesystem_Blocks_Symlinks(t *testing.T) {
 		})
 
 		g.It("cannot rename a file to a location outside the directory root", func() {
-			rfs.CreateServerFile("my_file.txt", "internal content")
+			rfs.CreateServerFileFromString("my_file.txt", "internal content")
 
 			err := fs.Rename("my_file.txt", "external_dir/my_file.txt")
 			g.Assert(err).IsNotNil()

server/filesystem/stat.go

@@ -1,12 +1,12 @@
 package filesystem
 
 import (
-	"encoding/json"
 	"os"
 	"strconv"
 	"time"
 
 	"github.com/gabriel-vasile/mimetype"
+	"github.com/goccy/go-json"
 )
 
 type Stat struct {

server/install.go

@@ -4,12 +4,14 @@ import (
 	"bufio"
 	"bytes"
 	"context"
+	"fmt"
 	"html/template"
 	"io"
 	"os"
 	"path/filepath"
 	"strconv"
 	"strings"
+	"time"
 
 	"emperror.dev/errors"
 	"github.com/apex/log"
@@ -17,30 +19,30 @@ import (
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/mount"
 	"github.com/docker/docker/client"
+
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/remote"
 	"github.com/pterodactyl/wings/system"
 )
 
-// Executes the installation stack for a server process. Bubbles any errors up to the calling
+// Install executes the installation stack for a server process. Bubbles any
-// function which should handle contacting the panel to notify it of the server state.
+// errors up to the calling function which should handle contacting the panel to
+// notify it of the server state.
 //
-// Pass true as the first argument in order to execute a server sync before the process to
+// Pass true as the first argument in order to execute a server sync before the
-// ensure the latest information is used.
+// process to ensure the latest information is used.
-func (s *Server) Install(sync bool) error {
+func (s *Server) Install() error {
-	if sync {
+	return s.install(false)
-		s.Log().Info("syncing server state with remote source before executing installation process")
+}
-		if err := s.Sync(); err != nil {
-			return err
-		}
-	}
 
+func (s *Server) install(reinstall bool) error {
 	var err error
 	if !s.Config().SkipEggScripts {
-		// Send the start event so the Panel can automatically update. We don't send this unless the process
+		// Send the start event so the Panel can automatically update. We don't
-		// is actually going to run, otherwise all sorts of weird rapid UI behavior happens since there isn't
+		// send this unless the process is actually going to run, otherwise all
-		// an actual install process being executed.
+		// sorts of weird rapid UI behavior happens since there isn't an actual
+		// install process being executed.
 		s.Events().Publish(InstallStartedEvent, "")
 
 		err = s.internalInstall()
@@ -49,54 +51,56 @@ func (s *Server) Install(sync bool) error {
 	}
 
 	s.Log().WithField("was_successful", err == nil).Debug("notifying panel of server install state")
-	if serr := s.SyncInstallState(err == nil); serr != nil {
+	if serr := s.SyncInstallState(err == nil, reinstall); serr != nil {
 		l := s.Log().WithField("was_successful", err == nil)
 
-		// If the request was successful but there was an error with this request, attach the
+		// If the request was successful but there was an error with this request,
-		// error to this log entry. Otherwise ignore it in this log since whatever is calling
+		// attach the error to this log entry. Otherwise, ignore it in this log
-		// this function should handle the error and will end up logging the same one.
+		// since whatever is calling this function should handle the error and
+		// will end up logging the same one.
 		if err == nil {
-			l.WithField("error", serr)
+			l.WithField("error", err)
 		}
 
 		l.Warn("failed to notify panel of server install state")
 	}
 
-	// Ensure that the server is marked as offline at this point, otherwise you end up
+	// Ensure that the server is marked as offline at this point, otherwise you
-	// with a blank value which is a bit confusing.
+	// end up with a blank value which is a bit confusing.
 	s.Environment.SetState(environment.ProcessOfflineState)
 
-	// Push an event to the websocket so we can auto-refresh the information in the panel once
+	// Push an event to the websocket, so we can auto-refresh the information in
-	// the install is completed.
+	// the panel once the installation is completed.
 	s.Events().Publish(InstallCompletedEvent, "")
 
-	return err
+	return errors.WithStackIf(err)
 }
 
-// Reinstalls a server's software by utilizing the install script for the server egg. This
+// Reinstall reinstalls a server's software by utilizing the installation script
-// does not touch any existing files for the server, other than what the script modifies.
+// for the server egg. This does not touch any existing files for the server,
+// other than what the script modifies.
 func (s *Server) Reinstall() error {
 	if s.Environment.State() != environment.ProcessOfflineState {
 		s.Log().Debug("waiting for server instance to enter a stopped state")
-		if err := s.Environment.WaitForStop(10, true); err != nil {
+		if err := s.Environment.WaitForStop(s.Context(), time.Second*10, true); err != nil {
-			return err
+			return errors.WrapIf(err, "install: failed to stop running environment")
 		}
 	}
 
-	return s.Install(true)
+	s.Log().Info("syncing server state with remote source before executing re-installation process")
+	if err := s.Sync(); err != nil {
+		return errors.WrapIf(err, "install: failed to sync server state with Panel")
+	}
+
+	return s.install(true)
 }
 
 // Internal installation function used to simplify reporting back to the Panel.
 func (s *Server) internalInstall() error {
-	script, err := s.client.GetInstallationScript(s.Context(), s.Id())
+	script, err := s.client.GetInstallationScript(s.Context(), s.ID())
 	if err != nil {
-		if !remote.IsRequestError(err) {
+		return err
-			return err
-		}
-
-		return errors.New(err.Error())
 	}
-
 	p, err := NewInstallationProcess(s, &script)
 	if err != nil {
 		return err
@@ -114,13 +118,12 @@ func (s *Server) internalInstall() error {
 type InstallationProcess struct {
 	Server *Server
 	Script *remote.InstallationScript
-
+	client *client.Client
-	client  *client.Client
-	context context.Context
 }
 
-// Generates a new installation process struct that will be used to create containers,
+// NewInstallationProcess returns a new installation process struct that will be
-// and otherwise perform installation commands for a server.
+// used to create containers and otherwise perform installation commands for a
+// server.
 func NewInstallationProcess(s *Server, script *remote.InstallationScript) (*InstallationProcess, error) {
 	proc := &InstallationProcess{
 		Script: script,
@@ -131,14 +134,13 @@ func NewInstallationProcess(s *Server, script *remote.InstallationScript) (*Inst
 		return nil, err
 	} else {
 		proc.client = c
-		proc.context = s.Context()
 	}
 
 	return proc, nil
 }
 
-// Determines if the server is actively running the installation process by checking the status
+// IsInstalling returns if the server is actively running the installation
-// of the installer lock.
+// process by checking the status of the installer lock.
 func (s *Server) IsInstalling() bool {
 	return s.installing.Load()
 }
@@ -159,9 +161,9 @@ func (s *Server) SetRestoring(state bool) {
 	s.restoring.Store(state)
 }
 
-// Removes the installer container for the server.
+// RemoveContainer removes the installation container for the server.
 func (ip *InstallationProcess) RemoveContainer() error {
-	err := ip.client.ContainerRemove(ip.context, ip.Server.Id()+"_installer", types.ContainerRemoveOptions{
+	err := ip.client.ContainerRemove(ip.Server.Context(), ip.Server.ID()+"_installer", types.ContainerRemoveOptions{
 		RemoveVolumes: true,
 		Force:         true,
 	})
@@ -171,11 +173,10 @@ func (ip *InstallationProcess) RemoveContainer() error {
 	return nil
 }
 
-// Runs the installation process, this is done as in a background thread. This will configure
+// Run runs the installation process, this is done as in a background thread.
-// the required environment, and then spin up the installation container.
+// This will configure the required environment, and then spin up the
-//
+// installation container. Once the container finishes installing the results
-// Once the container finishes installing the results will be stored in an installation
+// are stored in an installation log in the server's configuration directory.
-// log in the server's configuration directory.
 func (ip *InstallationProcess) Run() error {
 	ip.Server.Log().Debug("acquiring installation process lock")
 	if !ip.Server.installing.SwapIf(true) {
@@ -211,7 +212,7 @@ func (ip *InstallationProcess) Run() error {
 
 // Returns the location of the temporary data for the installation process.
 func (ip *InstallationProcess) tempDir() string {
-	return filepath.Join(os.TempDir(), "pterodactyl/", ip.Server.Id())
+	return filepath.Join(config.Get().System.TmpDirectory, ip.Server.ID())
 }
 
 // Writes the installation script to a temporary file on the host machine so that it
@@ -219,11 +220,11 @@ func (ip *InstallationProcess) tempDir() string {
 func (ip *InstallationProcess) writeScriptToDisk() error {
 	// Make sure the temp directory root exists before trying to make a directory within it. The
 	// ioutil.TempDir call expects this base to exist, it won't create it for you.
-	if err := os.MkdirAll(ip.tempDir(), 0700); err != nil {
+	if err := os.MkdirAll(ip.tempDir(), 0o700); err != nil {
 		return errors.WithMessage(err, "could not create temporary directory for install process")
 	}
 
-	f, err := os.OpenFile(filepath.Join(ip.tempDir(), "install.sh"), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
+	f, err := os.OpenFile(filepath.Join(ip.tempDir(), "install.sh"), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0o644)
 	if err != nil {
 		return errors.WithMessage(err, "failed to write server installation script to disk before mount")
 	}
@@ -271,9 +272,9 @@ func (ip *InstallationProcess) pullInstallationImage() error {
 		imagePullOptions.RegistryAuth = b64
 	}
 
-	r, err := ip.client.ImagePull(context.Background(), ip.Script.ContainerImage, imagePullOptions)
+	r, err := ip.client.ImagePull(ip.Server.Context(), ip.Script.ContainerImage, imagePullOptions)
 	if err != nil {
-		images, ierr := ip.client.ImageList(context.Background(), types.ImageListOptions{})
+		images, ierr := ip.client.ImageList(ip.Server.Context(), 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.
@@ -316,9 +317,10 @@ func (ip *InstallationProcess) pullInstallationImage() error {
 	return nil
 }
 
-// Runs before the container is executed. This pulls down the required docker container image
+// BeforeExecute runs before the container is executed. This pulls down the
-// as well as writes the installation script to the disk. This process is executed in an async
+// required docker container image as well as writes the installation script to
-// manner, if either one fails the error is returned.
+// the disk. This process is executed in an async manner, if either one fails
+// the error is returned.
 func (ip *InstallationProcess) BeforeExecute() error {
 	if err := ip.writeScriptToDisk(); err != nil {
 		return errors.WithMessage(err, "failed to write installation script to disk")
@@ -332,19 +334,19 @@ func (ip *InstallationProcess) BeforeExecute() error {
 	return nil
 }
 
-// Returns the log path for the installation process.
+// GetLogPath returns the log path for the installation process.
 func (ip *InstallationProcess) GetLogPath() string {
-	return filepath.Join(config.Get().System.LogDirectory, "/install", ip.Server.Id()+".log")
+	return filepath.Join(config.Get().System.LogDirectory, "/install", ip.Server.ID()+".log")
 }
 
-// Cleans up after the execution of the installation process. This grabs the logs from the
+// AfterExecute cleans up after the execution of the installation process.
-// process to store in the server configuration directory, and then destroys the associated
+// This grabs the logs from the process to store in the server configuration
-// installation container.
+// directory, and then destroys the associated installation container.
 func (ip *InstallationProcess) AfterExecute(containerId string) error {
 	defer ip.RemoveContainer()
 
 	ip.Server.Log().WithField("container_id", containerId).Debug("pulling installation logs for server")
-	reader, err := ip.client.ContainerLogs(ip.context, containerId, types.ContainerLogsOptions{
+	reader, err := ip.client.ContainerLogs(ip.Server.Context(), containerId, types.ContainerLogsOptions{
 		ShowStdout: true,
 		ShowStderr: true,
 		Follow:     false,
@@ -354,7 +356,7 @@ func (ip *InstallationProcess) AfterExecute(containerId string) error {
 		return err
 	}
 
-	f, err := os.OpenFile(ip.GetLogPath(), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
+	f, err := os.OpenFile(ip.GetLogPath(), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o600)
 	if err != nil {
 		return err
 	}
@@ -370,7 +372,7 @@ func (ip *InstallationProcess) AfterExecute(containerId string) error {
 |
 | Details
 | ------------------------------
-  Server UUID:          {{.Server.Id}}
+  Server UUID:          {{.Server.ID}}
   Container Image:      {{.Script.ContainerImage}}
   Container Entrypoint: {{.Script.Entrypoint}}
 
@@ -399,12 +401,13 @@ func (ip *InstallationProcess) AfterExecute(containerId string) error {
 	return nil
 }
 
-// Executes the installation process inside a specially created docker container.
+// Execute executes the installation process inside a specially created docker
+// container.
 func (ip *InstallationProcess) Execute() (string, error) {
 	// Create a child context that is canceled once this function is done running. This
 	// will also be canceled if the parent context (from the Server struct) is canceled
 	// which occurs if the server is deleted.
-	ctx, cancel := context.WithCancel(ip.context)
+	ctx, cancel := context.WithCancel(ip.Server.Context())
 	defer cancel()
 
 	conf := &container.Config{
@@ -423,7 +426,12 @@ func (ip *InstallationProcess) Execute() (string, error) {
 		},
 	}
 
-	tmpfsSize := strconv.Itoa(int(config.Get().Docker.TmpfsSize))
+	cfg := config.Get()
+	if cfg.System.User.Rootless.Enabled {
+		conf.User = fmt.Sprintf("%d:%d", cfg.System.User.Rootless.ContainerUID, cfg.System.User.Rootless.ContainerGID)
+	}
+
+	tmpfsSize := strconv.Itoa(int(cfg.Docker.TmpfsSize))
 	hostConf := &container.HostConfig{
 		Mounts: []mount.Mount{
 			{
@@ -439,20 +447,15 @@ func (ip *InstallationProcess) Execute() (string, error) {
 				ReadOnly: false,
 			},
 		},
+		Resources: ip.resourceLimits(),
 		Tmpfs: map[string]string{
 			"/tmp": "rw,exec,nosuid,size=" + tmpfsSize + "M",
 		},
-		DNS: config.Get().Docker.Network.Dns,
+		DNS:         cfg.Docker.Network.Dns,
-		LogConfig: container.LogConfig{
+		LogConfig:   cfg.Docker.ContainerLogConfig(),
-			Type: "local",
-			Config: map[string]string{
-				"max-size": "5m",
-				"max-file": "1",
-				"compress": "false",
-			},
-		},
 		Privileged:  true,
-		NetworkMode: container.NetworkMode(config.Get().Docker.Network.Mode),
+		NetworkMode: container.NetworkMode(cfg.Docker.Network.Mode),
+		UsernsMode:  container.UsernsMode(cfg.Docker.UsernsMode),
 	}
 
 	// Ensure the root directory for the server exists properly before attempting
@@ -473,7 +476,7 @@ func (ip *InstallationProcess) Execute() (string, error) {
 		}
 	}()
 
-	r, err := ip.client.ContainerCreate(ctx, conf, hostConf, nil, nil, ip.Server.Id()+"_installer")
+	r, err := ip.client.ContainerCreate(ctx, conf, hostConf, nil, nil, ip.Server.ID()+"_installer")
 	if err != nil {
 		return "", err
 	}
@@ -510,44 +513,67 @@ func (ip *InstallationProcess) Execute() (string, error) {
 	return r.ID, nil
 }
 
-// Streams the output of the installation process to a log file in the server configuration
+// StreamOutput streams the output of the installation process to a log file in
-// directory, as well as to a websocket listener so that the process can be viewed in
+// the server configuration directory, as well as to a websocket listener so
-// the panel by administrators.
+// that the process can be viewed in the panel by administrators.
 func (ip *InstallationProcess) StreamOutput(ctx context.Context, id string) error {
-	reader, err := ip.client.ContainerLogs(ctx, id, types.ContainerLogsOptions{
+	opts := types.ContainerLogsOptions{ShowStdout: true, ShowStderr: true, Follow: true}
-		ShowStdout: true,
+	reader, err := ip.client.ContainerLogs(ctx, id, opts)
-		ShowStderr: true,
-		Follow:     true,
-	})
-
 	if err != nil {
 		return err
 	}
 	defer reader.Close()
 
-	evts := ip.Server.Events()
+	err = system.ScanReader(reader, ip.Server.Sink(system.InstallSink).Push)
-	err = system.ScanReader(reader, func(line string) {
+	if err != nil && !errors.Is(err, context.Canceled) {
-		evts.Publish(InstallOutputEvent, line)
-	})
-	if err != nil {
 		ip.Server.Log().WithFields(log.Fields{"container_id": id, "error": err}).Warn("error processing install output lines")
 	}
 	return nil
 }
 
-// Makes a HTTP request to the Panel instance notifying it that the server has
+// resourceLimits returns resource limits for the installation container. This
-// completed the installation process, and what the state of the server is. A boolean
+// looks at the globally defined install container limits and attempts to use
-// value of "true" means everything was successful, "false" means something went
+// the higher of the two (defined limits & server limits). This allows for servers
-// wrong and the server must be deleted and re-created.
+// with super low limits (e.g. Discord bots with 128Mb of memory) to perform more
-func (s *Server) SyncInstallState(successful bool) error {
+// intensive installation processes if needed.
-	err := s.client.SetInstallationStatus(s.Context(), s.Id(), successful)
+//
-	if err != nil {
+// This also avoids a server with limits such as 4GB of memory from accidentally
-		if !remote.IsRequestError(err) {
+// consuming 2-5x the defined limits during the install process and causing
-			return err
+// system instability.
-		}
+func (ip *InstallationProcess) resourceLimits() container.Resources {
+	limits := config.Get().Docker.InstallerLimits
 
-		return errors.New(err.Error())
+	// Create a copy of the configuration, so we're not accidentally making
+	// changes to the underlying server build data.
+	c := *ip.Server.Config()
+	cfg := c.Build
+	if cfg.MemoryLimit < limits.Memory {
+		cfg.MemoryLimit = limits.Memory
+	}
+	// Only apply the CPU limit if neither one is currently set to unlimited. If the
+	// installer CPU limit is unlimited don't even waste time with the logic, just
+	// set the config to unlimited for this.
+	if limits.Cpu == 0 {
+		cfg.CpuLimit = 0
+	} else if cfg.CpuLimit != 0 && cfg.CpuLimit < limits.Cpu {
+		cfg.CpuLimit = limits.Cpu
 	}
 
-	return nil
+	resources := cfg.AsContainerResources()
+	// Explicitly remove the PID limits for the installation container. These scripts are
+	// defined at an administrative level and users can't manually execute things like a
+	// fork bomb during this process.
+	resources.PidsLimit = nil
+
+	return resources
+}
+
+// SyncInstallState makes an HTTP request to the Panel instance notifying it that
+// the server has completed the installation process, and what the state of the
+// server is.
+func (s *Server) SyncInstallState(successful, reinstall bool) error {
+	return s.client.SetInstallationStatus(s.Context(), s.ID(), remote.InstallStatusRequest{
+		Successful: successful,
+		Reinstall:  reinstall,
+	})
 }

server/installer/installer.go

@@ -0,0 +1,52 @@
+package installer
+
+import (
+	"context"
+
+	"emperror.dev/errors"
+	"github.com/asaskevich/govalidator"
+
+	"github.com/pterodactyl/wings/remote"
+	"github.com/pterodactyl/wings/server"
+)
+
+type Installer struct {
+	server            *server.Server
+	StartOnCompletion bool
+}
+
+type ServerDetails struct {
+	UUID              string `json:"uuid"`
+	StartOnCompletion bool   `json:"start_on_completion"`
+}
+
+// New validates the received data to ensure that all the required fields
+// have been passed along in the request. This should be manually run before
+// calling Execute().
+func New(ctx context.Context, manager *server.Manager, details ServerDetails) (*Installer, error) {
+	if !govalidator.IsUUIDv4(details.UUID) {
+		return nil, NewValidationError("uuid provided was not in a valid format")
+	}
+
+	c, err := manager.Client().GetServerConfiguration(ctx, details.UUID)
+	if err != nil {
+		if !remote.IsRequestError(err) {
+			return nil, errors.WithStackIf(err)
+		}
+		return nil, errors.WrapIf(err, "installer: could not get server configuration from remote API")
+	}
+
+	// Create a new server instance using the configuration we wrote to the disk
+	// so that everything gets instantiated correctly on the struct.
+	s, err := manager.InitServer(c)
+	if err != nil {
+		return nil, errors.WrapIf(err, "installer: could not init server instance")
+	}
+	i := Installer{server: s, StartOnCompletion: details.StartOnCompletion}
+	return &i, nil
+}
+
+// Server returns the server instance.
+func (i *Installer) Server() *server.Server {
+	return i.server
+}