bump version for release

This updates the docker client to include the fix added with
https://github.com/moby/moby/pull/45962 which solves a breaking change
to Go due to CVE-2023-29406.

.github/workflows/codeql.yaml

@@ -13,7 +13,7 @@ on:
 jobs:
   analyze:
     name: Analyze
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
 
     permissions:
       actions: read
@@ -28,7 +28,7 @@ jobs:
 
     steps:
       - name: Code Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Initialize CodeQL
         uses: github/codeql-action/init@v2

.github/workflows/docker.yaml

@@ -4,34 +4,40 @@ on:
   push:
     branches:
       - develop
-    tags:
-      - "v*"
+  release:
+    types:
+      - published
 
 jobs:
   build-and-push:
     name: Build and Push
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.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: Code checkout
+        uses: actions/checkout@v4
 
-      - name: Docker Meta
+      - name: Docker metadata
         id: docker_meta
-        uses: crazy-max/ghaction-docker-meta@v1
+        uses: docker/metadata-action@v5
         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: Set up QEMU
-        uses: docker/setup-qemu-action@v2
+      - name: Setup QEMU
+        uses: docker/setup-qemu-action@v3
 
-      - name: Install buildx
-        uses: docker/setup-buildx-action@v2
+      - name: Setup Docker buildx
+        uses: docker/setup-buildx-action@v3
 
       - name: Login to GitHub Container Registry
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
@@ -40,12 +46,12 @@ jobs:
       - name: Get Build Information
         id: build_info
         run: |
-          echo "::set-output name=version_tag::${GITHUB_REF/refs\/tags\/v/}"
-          echo "::set-output name=short_sha::$(git rev-parse --short HEAD)"
+          echo "version_tag=${GITHUB_REF/refs\/tags\/v/}" >> $GITHUB_OUTPUT
+          echo "short_sha=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
 
-      - name: Build and push (latest)
-        uses: docker/build-push-action@v2
-        if: "!contains(github.ref, 'develop')"
+      - name: Build and Push (tag)
+        uses: docker/build-push-action@v5
+        if: "github.event_name == 'release' && github.event.action == 'published'"
         with:
           context: .
           file: ./Dockerfile
@@ -56,9 +62,9 @@ jobs:
           labels: ${{ steps.docker_meta.outputs.labels }}
           tags: ${{ steps.docker_meta.outputs.tags }}
 
-      - name: Build and push (develop)
-        uses: docker/build-push-action@v2
-        if: "contains(github.ref, 'develop')"
+      - name: Build and Push (develop)
+        uses: docker/build-push-action@v5
+        if: "github.event_name == 'push' && contains(github.ref, 'develop')"
         with:
           context: .
           file: ./Dockerfile

.github/workflows/push.yaml

@@ -15,44 +15,19 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-20.04]
-        go: ["1.18.8", "1.19.3"]
+        os: [ubuntu-22.04]
+        go: ["1.20.10", "1.21.3"]
         goos: [linux]
         goarch: [amd64, arm64]
 
     steps:
       - name: Setup Go
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v4
         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: Code checkout
+        uses: actions/checkout@v4
 
       - name: go mod download
         env:
@@ -86,14 +61,14 @@ jobs:
           go test -race $(go list ./...)
 
       - name: Upload Release Artifact
-        uses: actions/upload-artifact@v2
+        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@v2
+        uses: actions/upload-artifact@v3
         if: ${{ github.ref == 'refs/heads/develop' || github.event_name == 'pull_request' }}
         with:
           name: wings_linux_${{ matrix.goarch }}_debug

.github/workflows/release.yaml

@@ -8,16 +8,16 @@ on:
 jobs:
   release:
     name: Release
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
 
     steps:
       - name: Code Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Setup Go
-        uses: actions/setup-go@v3
+        uses: actions/setup-go@v4
         with:
-          go-version: "1.18.8"
+          go-version: "1.20.10"
 
       - name: Build release binaries
         env:
@@ -34,7 +34,6 @@ jobs:
           REF: ${{ github.ref }}
         run: |
           sed -n "/^## ${REF:10}/,/^## /{/^## /b;p}" CHANGELOG.md > ./RELEASE_CHANGELOG
-          echo "version_name=`sed -nr "s/^## (${REF:10} .*)$/\1/p" CHANGELOG.md`" > $GITHUB_OUTPUT
 
       - name: Create checksum and add to changelog
         run: |
@@ -59,15 +58,13 @@ jobs:
 
       - 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') }}
+          body_path: ./RELEASE_CHANGELOG
 
       - name: Upload amd64 binary
         uses: actions/upload-release-asset@v1

CHANGELOG.md

@@ -1,5 +1,86 @@
 # Changelog
 
+## v1.11.8
+### Changed
+* Release binaries are now built with Go 1.20.10 (resolves [CVE-2023-44487](https://www.cve.org/CVERecord?id=CVE-2023-44487))
+* Updated Go dependencies
+
+## v1.11.7
+### Changed
+* Updated Go dependencies (this resolves an issue related to `http: invalid Host header` with Docker)
+* Wings is now built with go1.19.11
+
+## v1.11.6
+### Fixed
+* CVE-2023-32080
+
+## v1.11.5
+### Added
+* Added a config option to disable Wings config.yml updates from the Panel (https://github.com/pterodactyl/wings/commit/ec6d6d83ea3eb14995c24f001233e85b37ffb87b)
+
+### Changed
+* Wings is now built with Go 1.19.7
+
+### Fixed
+* Fixed archives containing partially matched file names (https://github.com/pterodactyl/wings/commit/43b3496f0001cec231c80af1f9a9b3417d04e8d4)
+
+## v1.11.4
+### Fixed
+* CVE-2023-25168
+
+## v1.11.3
+### Fixed
+* CVE-2023-25152
+
+## v1.11.2
+### Fixed
+* Backups being restored from remote storage (s3) erroring out due to a closed stream.
+* Fix IP validation logic for activity logs filtering out valid IPs instead of invalid IPs
+
+## v1.11.1
+### Changed
+* Release binaries are now built with Go 1.18.10
+* Timeout when stopping a server before a transfer begins has been reduced to 15 seconds from 1 minute
+* Removed insecure SSH protocols for use with the SFTP server
+
+### Fixed
+* Unnecessary Docker client connections being left open, causing a slow leak of file descriptors
+* Files being left open in parts of the server's filesystem, causing a leak of file descriptors
+* IPv6 addresses being corrupted by flawed port stripping logic for activity logs, old entries with malformed IPs will be deleted from the local SQLite database automatically
+* A server that times out while being stopped at the beginning of a transfer no longer causes the server to become stuck in a transferring state
+
+## v1.11.0
+### Added (since 1.7.2)
+* More detailed information returned by the `/api/system` endpoint when using the `?v=2` query parameter.
+
+### Changed (since 1.7.2)
+* Send re-installation status separately from installation status.
+* Wings release versions will now follow the major and minor version of the Panel.
+* Transfers no longer buffer to disk, instead they are fully streamed with only a small amount of memory used for buffering.
+* Release binaries are no longer compressed with UPX.
+* Use `POST` instead of `GET` for sending the status of a transfer to the Panel.
+
+### Fixed (since 1.7.2)
+* Fixed servers outgoing IP not being updated whenever a server's primary allocation is changed when using the Force Outgoing IP option.
+* Fixed servers being terminated rather than gracefully stopped when a signal is used to stop the container rather than a command.
+* Fixed file not found errors being treated as an internal error, they are now treated as a 404.
+* Wings can be run with Podman instead of Docker, this is still experimental and not recommended for production use.
+* Archive progress is now reported correctly.
+* Labels for containers can now be set by the Panel.
+* Fixed servers becoming deadlocked when the target node of a transfer goes offline.
+
+## v1.11.0-rc.2
+### Added
+* More detailed information returned by the `/api/system` endpoint when using the `?v=2` query parameter.
+
+### Changed
+* Send reinstallation status separately from installation status.
+
+### Fixed
+* Fixed servers outgoing IP not being updated whenever a server's primary allocation is changed when using the Force Outgoing IP option.
+* Fixed servers being terminated rather than gracefully stopped when a signal is used to stop the container rather than a command.
+* Fixed file not found errors being treated as an internal error, they are now treated as a 404.
+
 ## v1.11.0-rc.1
 ### Changed
 * Wings release versions will now follow the major and minor version of the panel.
@@ -11,6 +92,18 @@
 * Archive progress is now reported correctly.
 * Labels for containers can now be set by the Panel.
 
+## v1.7.5
+### Fixed
+* CVE-2023-32080
+
+## v1.7.4
+### Fixed
+* CVE-2023-25168
+
+## v1.7.3
+### Fixed
+* CVE-2023-25152
+
 ## v1.7.2
 ### Fixed
 * The S3 backup driver now supports Cloudflare R2

Dockerfile

@@ -1,5 +1,5 @@
 # Stage 1 (Build)
-FROM golang:1.18-alpine AS builder
+FROM golang:1.19-alpine AS builder
 
 ARG VERSION
 RUN apk add --update --no-cache git make

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,31 +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.
+
+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)
 
-| Company | About |
-| ------- | ----- |
-| [**WISP**](https://wisp.gg) | Extra features. |
-| [**BisectHosting**](https://www.bisecthosting.com/) | BisectHosting provides Minecraft, Valheim and other server hosting services with the highest reliability and lightning fast support since 2012. |
-| [**Fragnet**](https://fragnet.net) | Providing low latency, high-end game hosting solutions to gamers, game studios and eSports platforms. |
-| [**Tempest**](https://tempest.net/) | Tempest Hosting is a subsidiary of Path Network, Inc. offering unmetered DDoS protected 10Gbps dedicated servers, starting at just $80/month. Full anycast, tons of filters. |
-| [**Bloom.host**](https://bloom.host) | Bloom.host offers dedicated core VPS and Minecraft hosting with Ryzen 9 processors. With owned-hardware, we offer truly unbeatable prices on high-performance hosting. |
-| [**MineStrator**](https://minestrator.com/) | Looking for the most highend French hosting company for your minecraft server? More than 24,000 members on our discord trust us. Give us a try! |
-| [**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! |
-| [**DeinServerHost**](https://deinserverhost.de/) | DeinServerHost offers Dedicated, vps and Gameservers for many popular Games like Minecraft and Rust in Germany since 2013. |
-| [**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. |
-| [**HostEZ**](https://hostez.io) | Providing North America Valheim, Minecraft and other popular games with low latency, high uptime and maximum availability. EZ! |
-| [**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.|
-| [**Gamenodes**](https://gamenodes.nl) | Gamenodes love quality. For Minecraft, Discord Bots and other services, among others. With our own programmers, we provide just that little bit of extra service! |
+| Company                                                               | About                                                                                                                                                                                                 |
+|-----------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| [**WISP**](https://wisp.gg)                                           | Extra features.                                                                                                                                                                                       |
+| [**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.                                                       |
+| [**WemX**](https://wemx.net/)                                         | WemX helps automate your hosting company or SaaS business by automating billing, user management, authentication, and much more.                                                                      |
+| [**BisectHosting**](https://www.bisecthosting.com/)                   | BisectHosting provides Minecraft, Valheim and other server hosting services with the highest reliability and lightning fast support since 2012.                                                       |
+| [**MineStrator**](https://minestrator.com/)                           | Looking for the most highend French hosting company for your minecraft server? More than 24,000 members on our discord trust us. Give us a try!                                                       |
+| [**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. |
+| [**DutchIS**](https://dutchis.net?ref=pterodactyl)                    | DutchIS provides instant infrastructure such as pay per use VPS hosting. Start your game hosting journey on DutchIS.                                                                                  |
+| [**Skoali**](https://skoali.com/)                                     | Skoali is a French company that hosts game servers and other types of services (VPS, WEB, Dedicated servers, ...). We also have a free plan for Minecraft and Garry's Mod.                            |
+| [**Rabbit Computing**](https://www.rabbitcomputing.com/link.php?id=5) | Rabbit Computing offers powerful VPS servers, highly available game hosting, and fully unlimited web hosting. Use code README for 20% off your first three months!                                    |
 
 ## 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.

config/config.go

@@ -319,6 +319,9 @@ type Configuration struct {
 	// is only required by users running Wings without SSL certificates and using internal IP
 	// addresses in order to connect. Most users should NOT enable this setting.
 	AllowCORSPrivateNetwork bool `json:"allow_cors_private_network" yaml:"allow_cors_private_network"`
+
+	// IgnorePanelConfigUpdates causes confiuration updates that are sent by the panel to be ignored.
+	IgnorePanelConfigUpdates bool `json:"ignore_panel_config_updates" yaml:"ignore_panel_config_updates"`
 }
 
 // NewAtPath creates a new struct and set the path where it should be stored.

environment/docker/container.go

@@ -58,7 +58,7 @@ func (e *Environment) Attach(ctx context.Context) error {
 
 	// Set the stream again with the container.
 	if st, err := e.client.ContainerAttach(ctx, e.Id, opts); err != nil {
-		return err
+		return errors.WrapIf(err, "environment/docker: error while attaching to container")
 	} else {
 		e.SetStream(&st)
 	}
@@ -143,7 +143,7 @@ func (e *Environment) Create() error {
 	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.
@@ -196,7 +196,7 @@ func (e *Environment) Create() error {
 	networkMode := container.NetworkMode(cfg.Docker.Network.Mode)
 	if a.ForceOutgoingIP {
 		e.log().Debug("environment/docker: forcing outgoing IP address")
-		networkName := strings.ReplaceAll(e.Id, "-", "")
+		networkName := "ip-" + strings.ReplaceAll(strings.ReplaceAll(a.DefaultMapping.Ip, ".", "-"), ":", "-")
 		networkMode = container.NetworkMode(networkName)
 
 		if _, err := e.client.NetworkInspect(ctx, networkName, types.NetworkInspectOptions{}); err != nil {

environment/docker/environment.go

@@ -161,7 +161,7 @@ func (e *Environment) ExitState() (uint32, bool, error) {
 		if client.IsErrNotFound(err) {
 			return 1, false, nil
 		}
-		return 0, false, err
+		return 0, false, errors.WrapIf(err, "environment/docker: failed to inspect container")
 	}
 	return uint32(c.State.ExitCode), c.State.OOMKilled, nil
 }

environment/docker/power.go

@@ -103,7 +103,7 @@ func (e *Environment) Start(ctx context.Context) error {
 	// exists on the system, and rebuild the container if that is required for server booting to
 	// occur.
 	if err := e.OnBeforeStart(ctx); err != nil {
-		return errors.WithStackIf(err)
+		return errors.WrapIf(err, "environment/docker: failed to run pre-boot process")
 	}
 
 	// If we cannot start & attach to the container in 30 seconds something has gone
@@ -119,7 +119,7 @@ func (e *Environment) Start(ctx context.Context) error {
 	// 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 err
+		return errors.WrapIf(err, "environment/docker: failed to attach to container")
 	}
 
 	if err := e.client.ContainerStart(actx, e.Id, types.ContainerStartOptions{}); err != nil {
@@ -179,8 +179,12 @@ func (e *Environment) Stop(ctx context.Context) error {
 
 	// Allow the stop action to run for however long it takes, similar to executing a command
 	// and using a different logic pathway to wait for the container to stop successfully.
-	t := time.Duration(-1)
-	if err := e.client.ContainerStop(ctx, e.Id, &t); err != nil {
+	//
+	// Using a negative timeout here will allow the container to stop gracefully,
+	// rather than forcefully terminating it.  Value is in seconds, but -1 is
+	// treated as indefinitely.
+	timeout := -1
+	if err := e.client.ContainerStop(ctx, e.Id, container.StopOptions{Timeout: &timeout}); err != nil {
 		// If the container does not exist just mark the process as stopped and return without
 		// an error.
 		if client.IsErrNotFound(err) {

go.mod

@@ -4,85 +4,88 @@ go 1.18
 
 require (
 	emperror.dev/errors v0.8.1
-	github.com/AlecAivazis/survey/v2 v2.3.6
-	github.com/Jeffail/gabs/v2 v2.6.1
+	github.com/AlecAivazis/survey/v2 v2.3.7
+	github.com/Jeffail/gabs/v2 v2.7.0
 	github.com/NYTimes/logrotate v1.0.0
 	github.com/acobaugh/osrelease v0.1.0
 	github.com/apex/log v1.9.0
-	github.com/asaskevich/govalidator v0.0.0-20210307081110-f21760c49a8d
-	github.com/beevik/etree v1.1.0
+	github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2
+	github.com/beevik/etree v1.2.0
 	github.com/buger/jsonparser v1.1.1
-	github.com/cenkalti/backoff/v4 v4.1.3
-	github.com/creasty/defaults v1.6.0
-	github.com/docker/docker v20.10.18+incompatible
+	github.com/cenkalti/backoff/v4 v4.2.1
+	github.com/creasty/defaults v1.7.0
+	github.com/docker/docker v24.0.6+incompatible
 	github.com/docker/go-connections v0.4.0
-	github.com/fatih/color v1.13.0
-	github.com/franela/goblin v0.0.0-20200825194134-80c0062ed6cd
-	github.com/gabriel-vasile/mimetype v1.4.1
+	github.com/fatih/color v1.15.0
+	github.com/franela/goblin v0.0.0-20211003143422-0a4f594942bf
+	github.com/gabriel-vasile/mimetype v1.4.2
 	github.com/gammazero/workerpool v1.1.3
 	github.com/gbrlsnchs/jwt/v3 v3.0.1
-	github.com/gin-gonic/gin v1.8.1
-	github.com/glebarez/sqlite v1.4.8
-	github.com/go-co-op/gocron v1.17.0
-	github.com/goccy/go-json v0.9.11
-	github.com/google/uuid v1.3.0
+	github.com/gin-gonic/gin v1.9.1
+	github.com/glebarez/sqlite v1.9.0
+	github.com/go-co-op/gocron v1.35.2
+	github.com/goccy/go-json v0.10.2
+	github.com/google/uuid v1.3.1
 	github.com/gorilla/websocket v1.5.0
-	github.com/iancoleman/strcase v0.2.0
-	github.com/icza/dyno v0.0.0-20220812133438-f0b6f8a18845
+	github.com/iancoleman/strcase v0.3.0
+	github.com/icza/dyno v0.0.0-20230330125955-09f820a8d9c0
 	github.com/juju/ratelimit v1.0.2
 	github.com/karrick/godirwalk v1.17.0
-	github.com/klauspost/compress v1.15.11
-	github.com/klauspost/pgzip v1.2.5
-	github.com/magiconair/properties v1.8.6
+	github.com/klauspost/compress v1.17.0
+	github.com/klauspost/pgzip v1.2.6
+	github.com/magiconair/properties v1.8.7
 	github.com/mattn/go-colorable v0.1.13
-	github.com/mholt/archiver/v4 v4.0.0-alpha.7
+	github.com/mholt/archiver/v4 v4.0.0-alpha.8
 	github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db
 	github.com/patrickmn/go-cache v2.1.0+incompatible
-	github.com/pkg/sftp v1.13.5
+	github.com/pkg/sftp v1.13.6
 	github.com/sabhiram/go-gitignore v0.0.0-20210923224102-525f6e181f06
-	github.com/spf13/cobra v1.5.0
-	github.com/stretchr/testify v1.8.0
-	golang.org/x/crypto v0.0.0-20220926161630-eccd6366d1be
-	golang.org/x/sync v0.0.0-20220929204114-8fcdb60fdcc0
+	github.com/spf13/cobra v1.7.0
+	github.com/stretchr/testify v1.8.4
+	golang.org/x/crypto v0.14.0
+	golang.org/x/sync v0.4.0
 	gopkg.in/ini.v1 v1.67.0
 	gopkg.in/yaml.v2 v2.4.0
 	gopkg.in/yaml.v3 v3.0.1
-	gorm.io/gorm v1.23.10
+	gorm.io/gorm v1.25.5
 )
 
 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/Microsoft/go-winio v0.6.1 // indirect
+	github.com/Microsoft/hcsshim v0.11.1 // indirect
+	github.com/andybalholm/brotli v1.0.5 // indirect
+	github.com/bodgit/plumbing v1.3.0 // indirect
+	github.com/bodgit/sevenzip v1.4.3 // indirect
+	github.com/bodgit/windows v1.0.1 // indirect
+	github.com/bytedance/sonic v1.10.2 // indirect
+	github.com/chenzhuoyu/base64x v0.0.0-20230717121745-296ad89f973d // indirect
+	github.com/chenzhuoyu/iasm v0.9.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/distribution/reference v0.5.0 // indirect
+	github.com/docker/distribution v2.8.3+incompatible // 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/dustin/go-humanize v1.0.1 // indirect
+	github.com/gammazero/deque v0.2.1 // 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/glebarez/go-sqlite v1.21.2 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.15.5 // 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/hashicorp/errwrap v1.1.0 // indirect
+	github.com/hashicorp/go-multierror v1.1.1 // indirect
+	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
 	github.com/json-iterator/go v1.1.12 // indirect
 	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.5 // 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/leodido/go-urn v1.2.4 // indirect
+	github.com/magefile/mage v1.15.0 // indirect
+	github.com/mattn/go-isatty v0.0.19 // 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
@@ -90,35 +93,35 @@ require (
 	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/opencontainers/image-spec v1.1.0-rc5 // indirect
+	github.com/pelletier/go-toml/v2 v2.1.0 // indirect
+	github.com/pierrec/lz4/v4 v4.1.18 // 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/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
 	github.com/robfig/cron/v3 v3.0.1 // indirect
-	github.com/sirupsen/logrus v1.9.0 // indirect
+	github.com/sirupsen/logrus v1.9.3 // 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
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/ugorji/go/codec v1.2.11 // indirect
+	github.com/ulikunitz/xz v0.5.11 // indirect
+	go.uber.org/atomic v1.11.0 // indirect
+	go.uber.org/multierr v1.11.0 // indirect
+	go4.org v0.0.0-20230225012048-214862532bf5 // indirect
+	golang.org/x/arch v0.5.0 // indirect
+	golang.org/x/mod v0.13.0 // indirect
+	golang.org/x/net v0.17.0 // indirect
+	golang.org/x/sys v0.13.0 // indirect
+	golang.org/x/term v0.13.0 // indirect
+	golang.org/x/text v0.13.0 // indirect
 	golang.org/x/time v0.0.0-20220922220347-f3bd1da661af // indirect
-	golang.org/x/tools v0.1.12 // indirect
+	golang.org/x/tools v0.14.0 // 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
+	google.golang.org/protobuf v1.31.0 // indirect
+	gotest.tools/v3 v3.0.2 // indirect
+	modernc.org/libc v1.24.1 // indirect
+	modernc.org/mathutil v1.6.0 // indirect
+	modernc.org/memory v1.7.2 // indirect
+	modernc.org/sqlite v1.26.0 // indirect
 )

internal/cron/activity_cron.go

@@ -2,6 +2,7 @@ package cron
 
 import (
 	"context"
+	"net"
 
 	"emperror.dev/errors"
 
@@ -17,9 +18,9 @@ type activityCron struct {
 	max     int
 }
 
-// Run executes the cronjob and ensures we fetch and send all of the stored activity to the
+// 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 seperately to account
+// 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
@@ -34,7 +35,6 @@ func (ac *activityCron) Run(ctx context.Context) error {
 		Where("event NOT LIKE ?", "server:sftp.%").
 		Limit(ac.max).
 		Find(&activity)
-
 	if tx.Error != nil {
 		return errors.WithStack(tx.Error)
 	}
@@ -42,15 +42,42 @@ func (ac *activityCron) Run(ctx context.Context) error {
 		return nil
 	}
 
-	if err := ac.manager.Client().SendActivityLogs(ctx, activity); err != 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")
 	}
 
-	var ids []int
-	for _, v := range activity {
-		ids = append(ids, v.ID)
+	// 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)

internal/models/activity.go

@@ -1,11 +1,11 @@
 package models
 
 import (
+	"net"
+	"strings"
 	"time"
 
 	"gorm.io/gorm"
-
-	"github.com/pterodactyl/wings/system"
 )
 
 type Event string
@@ -57,7 +57,9 @@ func (a Activity) SetUser(u string) *Activity {
 // 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 {
-	a.IP = system.TrimIPSuffix(a.IP)
+	if ip, _, err := net.SplitHostPort(strings.TrimSpace(a.IP)); err == nil {
+		a.IP = ip
+	}
 	if a.Timestamp.IsZero() {
 		a.Timestamp = time.Now()
 	}

remote/http.go

@@ -29,7 +29,7 @@ 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

remote/servers.go

@@ -19,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) {
@@ -58,7 +58,7 @@ func (c *client) GetServers(ctx context.Context, limit int) ([]RawServerData, er
 //
 // This handles Wings exiting during either of these processes which will leave
 // things in a bad state within the Panel. This API call is executed once Wings
-// has fully booted all 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)
 	if err != nil {
@@ -92,8 +92,8 @@ func (c *client) GetInstallationScript(ctx context.Context, uuid string) (Instal
 	return config, err
 }
 
-func (c *client) SetInstallationStatus(ctx context.Context, uuid string, successful bool) error {
-	resp, err := c.Post(ctx, fmt.Sprintf("/servers/%s/install", uuid), d{"successful": successful})
+func (c *client) SetInstallationStatus(ctx context.Context, uuid string, data InstallStatusRequest) error {
+	resp, err := c.Post(ctx, fmt.Sprintf("/servers/%s/install", uuid), data)
 	if err != nil {
 		return err
 	}
@@ -115,7 +115,7 @@ 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
 	}
@@ -127,7 +127,7 @@ func (c *client) SetTransferStatus(ctx context.Context, uuid string, successful
 // password combination provided is associated with a valid server on the instance
 // using the Panel's authentication control mechanisms. This will get itself
 // throttled if too many requests are made, allowing us to completely offload
-// all 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)

remote/types.go

@@ -92,8 +92,8 @@ type SftpAuthResponse struct {
 }
 
 type OutputLineMatcher struct {
-	// The raw string to match against. This may or may not be prefixed with
-	// regex: which indicates we want to match against the regex expression.
+	// raw string to match against. This may or may not be prefixed with
+	// `regex:` which indicates we want to match against the regex expression.
 	raw []byte
 	reg *regexp.Regexp
 }
@@ -139,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
-// what to do when stopping, and what changes to make to the configuration file
-// for a server.
+// instance. This sets what Wings is looking for to mark a server as done
+// starting what to do when stopping, and what changes to make to the
+// configuration file for a server.
 type ProcessConfiguration struct {
 	Startup struct {
 		Done            []*OutputLineMatcher `json:"done"`
@@ -169,3 +169,8 @@ type BackupRequest struct {
 	Successful   bool         `json:"successful"`
 	Parts        []BackupPart `json:"parts"`
 }
+
+type InstallStatusRequest struct {
+	Successful bool `json:"successful"`
+	Reinstall  bool `json:"reinstall"`
+}

router/error.go

@@ -1,157 +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/middleware.go

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

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,6 +1,7 @@
 package router
 
 import (
+	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/gin-gonic/gin"
 
@@ -16,7 +17,10 @@ func Configure(m *wserver.Manager, client remote.Client) *gin.Engine {
 
 	router := gin.New()
 	router.Use(gin.Recovery())
-	_ = router.SetTrustedProxies(config.Get().Api.TrustedProxies)
+	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.

router/router_download.go

@@ -21,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 || !token.IsUniqueRequest() {
+	if _, ok := manager.Get(token.ServerUuid); !ok || !token.IsUniqueRequest() {
 		c.AbortWithStatusJSON(http.StatusNotFound, gin.H{
 			"error": "The requested resource was not found on this server.",
 		})
@@ -42,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()
@@ -57,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.
@@ -65,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
 	}
 
@@ -82,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{
@@ -93,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

@@ -35,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
 	}
 
@@ -109,7 +109,7 @@ func postServerCommands(c *gin.Context) {
 	s := ExtractServer(c)
 
 	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{
@@ -143,7 +143,7 @@ func postServerSync(c *gin.Context) {
 	s := ExtractServer(c)
 
 	if err := s.Sync(); err != nil {
-		WithError(c, err)
+		middleware.CaptureAndAbort(c, err)
 	} else {
 		c.Status(http.StatusNoContent)
 	}
@@ -153,9 +153,15 @@ func postServerSync(c *gin.Context) {
 func postServerInstall(c *gin.Context) {
 	s := ExtractServer(c)
 
-	go func(serv *server.Server) {
-		if err := serv.Install(true); err != nil {
-			serv.Log().WithField("error", err).Error("failed to execute server installation process")
+	go func(s *server.Server) {
+		s.Log().Info("syncing server state with remote source before executing installation process")
+		if err := s.Sync(); err != nil {
+			s.Log().WithField("error", err).Error("failed to sync server state with Panel")
+			return
+		}
+
+		if err := s.Install(); err != nil {
+			s.Log().WithField("error", err).Error("failed to execute server installation process")
 		}
 	}(s)
 
@@ -211,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
 	}
 

router/router_server_files.go

@@ -79,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)
 	}
@@ -152,7 +152,7 @@ func putServerRenameFiles(c *gin.Context) {
 			return
 		}
 
-		NewServerError(err, s).AbortFilesystemError(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
@@ -172,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
 	}
 
@@ -221,7 +221,7 @@ func postServerDeleteFiles(c *gin.Context) {
 	}
 
 	if err := g.Wait(); err != nil {
-		NewServerError(err, s).Abort(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
@@ -236,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 {
@@ -247,7 +247,7 @@ func postServerWriteFile(c *gin.Context) {
 			return
 		}
 
-		NewServerError(err, s).AbortFilesystemError(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
@@ -294,12 +294,12 @@ 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.
@@ -338,13 +338,13 @@ func postServerPullRemoteFile(c *gin.Context) {
 	}
 
 	if err := download(); err != nil {
-		NewServerError(err, s).Abort(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
 	st, err := s.Filesystem().Stat(dl.Path())
 	if err != nil {
-		NewServerError(err, s).AbortFilesystemError(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 	c.JSON(http.StatusOK, &st)
@@ -380,7 +380,7 @@ func postServerCreateDirectory(c *gin.Context) {
 			return
 		}
 
-		NewServerError(err, s).Abort(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
@@ -415,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
 	}
 
@@ -533,7 +533,7 @@ func postServerChmodFile(c *gin.Context) {
 			return
 		}
 
-		NewServerError(err, s).AbortFilesystemError(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
@@ -545,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
 	}
 
@@ -591,14 +591,14 @@ func postServerUploadFiles(c *gin.Context) {
 	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{

router/router_server_transfer.go

@@ -6,6 +6,7 @@ import (
 	"strings"
 	"time"
 
+	"emperror.dev/errors"
 	"github.com/gin-gonic/gin"
 
 	"github.com/pterodactyl/wings/environment"
@@ -63,11 +64,11 @@ func postServerTransfer(c *gin.Context) {
 	if s.Environment.State() != environment.ProcessOfflineState {
 		if err := s.Environment.WaitForStop(
 			s.Context(),
-			time.Minute,
+			time.Second*15,
 			false,
 		); err != nil && !strings.Contains(strings.ToLower(err.Error()), "no such container") {
-			notifyPanelOfFailure()
-			s.Log().WithError(err).Error("failed to stop server for transfer")
+			s.SetTransferring(false)
+			middleware.CaptureAndAbort(c, errors.Wrap(err, "failed to stop server for transfer"))
 			return
 		}
 	}

router/router_server_ws.go

@@ -34,7 +34,7 @@ func getServerWebsocket(c *gin.Context) {
 
 	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()
@@ -58,7 +58,7 @@ func getServerWebsocket(c *gin.Context) {
 		case <-ctx.Done():
 			break
 		case <-s.Context().Done():
-			handler.Connection.WriteControl(ws.CloseMessage, ws.FormatCloseMessage(ws.CloseGoingAway, "server deleted"), time.Now().Add(time.Second*5))
+			_ = handler.Connection.WriteControl(ws.CloseMessage, ws.FormatCloseMessage(ws.CloseGoingAway, "server deleted"), time.Now().Add(time.Second*5))
 			break
 		}
 	}()
@@ -83,7 +83,7 @@ func getServerWebsocket(c *gin.Context) {
 
 		go func(msg websocket.Message) {
 			if err := handler.HandleInbound(ctx, msg); err != nil {
-				handler.SendErrorJson(msg, err)
+				_ = handler.SendErrorJson(msg, err)
 			}
 		}(j)
 	}

router/router_system.go

@@ -20,12 +20,28 @@ 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 the servers that are registered and configured correctly on
@@ -75,7 +91,7 @@ func postCreateServer(c *gin.Context) {
 			return
 		}
 
-		if err := i.Server().Install(false); err != nil {
+		if err := i.Server().Install(); err != nil {
 			log.WithFields(log.Fields{"server": i.Server().ID(), "error": err}).Error("failed to run install process for server")
 			return
 		}
@@ -97,9 +113,21 @@ func postCreateServer(c *gin.Context) {
 	c.Status(http.StatusAccepted)
 }
 
+type postUpdateConfigurationResponse struct {
+	Applied bool `json:"applied"`
+}
+
 // Updates the running configuration for this Wings instance.
 func postUpdateConfiguration(c *gin.Context) {
 	cfg := config.Get()
+
+	if cfg.IgnorePanelConfigUpdates {
+		c.JSON(http.StatusOK, postUpdateConfigurationResponse{
+			Applied: false,
+		})
+		return
+	}
+
 	if err := c.BindJSON(&cfg); err != nil {
 		return
 	}
@@ -117,11 +145,13 @@ func postUpdateConfiguration(c *gin.Context) {
 	// Try to write this new configuration to the disk before updating our global
 	// state with it.
 	if err := config.WriteToDisk(cfg); err != nil {
-		_ = WithError(c, err)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 	// Since we wrote it to the disk successfully now update the global configuration
 	// state to use this new configuration struct.
 	config.Set(cfg)
-	c.Status(http.StatusNoContent)
+	c.JSON(http.StatusOK, postUpdateConfigurationResponse{
+		Applied: true,
+	})
 }

router/router_transfer.go

@@ -38,14 +38,14 @@ func postTransfers(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 {
-		NewTrackedError(err).Abort(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
@@ -70,7 +70,7 @@ func postTransfers(c *gin.Context) {
 			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")
 			}
-			NewTrackedError(err).Abort(c)
+			middleware.CaptureAndAbort(c, err)
 			return
 		}
 
@@ -123,13 +123,13 @@ func postTransfers(c *gin.Context) {
 	mediaType, params, err := mime.ParseMediaType(c.GetHeader("Content-Type"))
 	if err != nil {
 		trnsfr.Log().Debug("failed to parse content type header")
-		NewTrackedError(err).Abort(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 
 	if !strings.HasPrefix(mediaType, "multipart/") {
 		trnsfr.Log().Debug("invalid content type")
-		NewTrackedError(fmt.Errorf("invalid content type \"%s\", expected \"multipart/form-data\"", mediaType)).Abort(c)
+		middleware.CaptureAndAbort(c, fmt.Errorf("invalid content type \"%s\", expected \"multipart/form-data\"", mediaType))
 		return
 	}
 
@@ -156,7 +156,7 @@ out:
 				break out
 			}
 			if err != nil {
-				NewTrackedError(err).Abort(c)
+				middleware.CaptureAndAbort(c, err)
 				return
 			}
 
@@ -166,13 +166,13 @@ out:
 				trnsfr.Log().Debug("received archive")
 
 				if err := trnsfr.Server.EnsureDataDirectoryExists(); err != nil {
-					NewTrackedError(err).Abort(c)
+					middleware.CaptureAndAbort(c, err)
 					return
 				}
 
 				tee := io.TeeReader(p, h)
 				if err := trnsfr.Server.Filesystem().ExtractStreamUnsafe(ctx, "/", tee); err != nil {
-					NewTrackedError(err).Abort(c)
+					middleware.CaptureAndAbort(c, err)
 					return
 				}
 
@@ -181,7 +181,7 @@ out:
 				trnsfr.Log().Debug("received checksum")
 
 				if !hasArchive {
-					NewTrackedError(errors.New("archive must be sent before the checksum")).Abort(c)
+					middleware.CaptureAndAbort(c, errors.New("archive must be sent before the checksum"))
 					return
 				}
 
@@ -189,14 +189,14 @@ out:
 
 				v, err := io.ReadAll(p)
 				if err != nil {
-					NewTrackedError(err).Abort(c)
+					middleware.CaptureAndAbort(c, err)
 					return
 				}
 
 				expected := make([]byte, hex.DecodedLen(len(v)))
 				n, err := hex.Decode(expected, v)
 				if err != nil {
-					NewTrackedError(err).Abort(c)
+					middleware.CaptureAndAbort(c, err)
 					return
 				}
 				actual := h.Sum(nil)
@@ -207,7 +207,7 @@ out:
 				}).Debug("checksums")
 
 				if !bytes.Equal(expected[:n], actual) {
-					NewTrackedError(errors.New("checksums don't match")).Abort(c)
+					middleware.CaptureAndAbort(c, errors.New("checksums don't match"))
 					return
 				}
 
@@ -220,12 +220,12 @@ out:
 	}
 
 	if !hasArchive || !hasChecksum {
-		NewTrackedError(errors.New("missing archive or checksum")).Abort(c)
+		middleware.CaptureAndAbort(c, errors.New("missing archive or checksum"))
 		return
 	}
 
 	if !checksumVerified {
-		NewTrackedError(errors.New("checksums don't match")).Abort(c)
+		middleware.CaptureAndAbort(c, errors.New("checksums don't match"))
 		return
 	}
 
@@ -235,7 +235,7 @@ out:
 
 	// Ensure the server environment gets configured.
 	if err := trnsfr.Server.CreateEnvironment(); err != nil {
-		NewTrackedError(err).Abort(c)
+		middleware.CaptureAndAbort(c, err)
 		return
 	}
 

server/backup/backup_local.go

@@ -85,6 +85,7 @@ func (b *LocalBackup) Restore(ctx context.Context, _ io.Reader, callback Restore
 	if err != nil {
 		return err
 	}
+	defer f.Close()
 
 	var reader io.Reader = f
 	// Steal the logic we use for making backups which will be applied when restoring

server/console.go

@@ -37,7 +37,7 @@ func (s *Server) Throttler() *ConsoleThrottle {
 
 		s.throttler = newConsoleThrottle(throttles.Lines, period)
 		s.throttler.strike = func() {
-			s.PublishConsoleOutputFromDaemon(fmt.Sprintf("Server is outputting console data too quickly -- throttling..."))
+			s.PublishConsoleOutputFromDaemon("Server is outputting console data too quickly -- throttling...")
 		}
 	})
 	return s.throttler

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/filesystem/archive.go

@@ -3,6 +3,7 @@ package filesystem
 import (
 	"archive/tar"
 	"context"
+	"fmt"
 	"io"
 	"io/fs"
 	"os"
@@ -66,6 +67,8 @@ 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.
+	//
+	// All items in Files must be absolute within BasePath.
 	Files []string
 
 	// Progress wraps the writer of the archive to pass through the progress tracker.
@@ -97,6 +100,14 @@ func (a *Archive) Create(ctx context.Context, dst string) error {
 
 // Stream .
 func (a *Archive) Stream(ctx context.Context, w io.Writer) error {
+	for _, f := range a.Files {
+		if strings.HasPrefix(f, a.BasePath) {
+			continue
+		}
+
+		return fmt.Errorf("archive: all entries in Files must be absolute and within BasePath: %s\n", f)
+	}
+
 	// Choose which compression level to use based on the compression_level configuration option
 	var compressionLevel int
 	switch config.Get().System.Backups.CompressionLevel {
@@ -190,9 +201,11 @@ func (a *Archive) callback(tw *TarProgress, opts ...func(path string, relative s
 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(strings.TrimSuffix(p, "/")+"/", f) {
+			// Allow exact file matches, otherwise check if file is within a parent directory.
+			//
+			// The slashes are added in the prefix checks to prevent partial name matches from being
+			// included in the archive.
+			if f != p && !strings.HasPrefix(strings.TrimSuffix(p, "/")+"/", strings.TrimSuffix(f, "/")+"/") {
 				continue
 			}
 

server/filesystem/archive_test.go

@@ -0,0 +1,131 @@
+package filesystem
+
+import (
+	"context"
+	iofs "io/fs"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"testing"
+
+	. "github.com/franela/goblin"
+	"github.com/mholt/archiver/v4"
+)
+
+func TestArchive_Stream(t *testing.T) {
+	g := Goblin(t)
+	fs, rfs := NewFs()
+
+	g.Describe("Archive", func() {
+		g.AfterEach(func() {
+			// Reset the filesystem after each run.
+			rfs.reset()
+		})
+
+		g.It("throws an error when passed invalid file paths", func() {
+			a := &Archive{
+				BasePath: fs.Path(),
+				Files: []string{
+					// To use the archiver properly, this needs to be filepath.Join(BasePath, "yeet")
+					// However, this test tests that we actually validate that behavior.
+					"yeet",
+				},
+			}
+
+			g.Assert(a.Create(context.Background(), "")).IsNotNil()
+		})
+
+		g.It("creates archive with intended files", func() {
+			g.Assert(fs.CreateDirectory("test", "/")).IsNil()
+			g.Assert(fs.CreateDirectory("test2", "/")).IsNil()
+
+			err := fs.Writefile("test/file.txt", strings.NewReader("hello, world!\n"))
+			g.Assert(err).IsNil()
+
+			err = fs.Writefile("test2/file.txt", strings.NewReader("hello, world!\n"))
+			g.Assert(err).IsNil()
+
+			err = fs.Writefile("test_file.txt", strings.NewReader("hello, world!\n"))
+			g.Assert(err).IsNil()
+
+			err = fs.Writefile("test_file.txt.old", strings.NewReader("hello, world!\n"))
+			g.Assert(err).IsNil()
+
+			a := &Archive{
+				BasePath: fs.Path(),
+				Files: []string{
+					filepath.Join(fs.Path(), "test"),
+					filepath.Join(fs.Path(), "test_file.txt"),
+				},
+			}
+
+			// Create the archive.
+			archivePath := filepath.Join(rfs.root, "archive.tar.gz")
+			g.Assert(a.Create(context.Background(), archivePath)).IsNil()
+
+			// Ensure the archive exists.
+			_, err = os.Stat(archivePath)
+			g.Assert(err).IsNil()
+
+			// Open the archive.
+			genericFs, err := archiver.FileSystem(context.Background(), archivePath)
+			g.Assert(err).IsNil()
+
+			// Assert that we are opening an archive.
+			afs, ok := genericFs.(archiver.ArchiveFS)
+			g.Assert(ok).IsTrue()
+
+			// Get the names of the files recursively from the archive.
+			files, err := getFiles(afs, ".")
+			g.Assert(err).IsNil()
+
+			// Ensure the files in the archive match what we are expecting.
+			expected := []string{
+				"test_file.txt",
+				"test/file.txt",
+			}
+
+			// Sort the slices to ensure the comparison never fails if the
+			// contents are sorted differently.
+			sort.Strings(expected)
+			sort.Strings(files)
+
+			g.Assert(files).Equal(expected)
+		})
+	})
+}
+
+func getFiles(f iofs.ReadDirFS, name string) ([]string, error) {
+	var v []string
+
+	entries, err := f.ReadDir(name)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, e := range entries {
+		entryName := e.Name()
+		if name != "." {
+			entryName = filepath.Join(name, entryName)
+		}
+
+		if e.IsDir() {
+			files, err := getFiles(f, entryName)
+			if err != nil {
+				return nil, err
+			}
+
+			if files == nil {
+				return nil, nil
+			}
+			
+			v = append(v, files...)
+			continue
+		}
+
+		v = append(v, entryName)
+	}
+
+	return v, nil
+}

server/filesystem/compress.go

@@ -91,7 +91,7 @@ func (fs *Filesystem) SpaceAvailableForDecompression(ctx context.Context, dir st
 	// waiting an unnecessary amount of time on this call.
 	dirSize, err := fs.DiskUsage(false)
 
-	fsys, err := archiver.FileSystem(source)
+	fsys, err := archiver.FileSystem(ctx, source)
 	if err != nil {
 		if errors.Is(err, archiver.ErrNoMatch) {
 			return newFilesystemError(ErrCodeUnknownArchive, err)
@@ -148,7 +148,7 @@ func (fs *Filesystem) DecompressFileUnsafe(ctx context.Context, dir string, file
 	if err != nil {
 		return err
 	}
-	// TODO: defer file close?
+	defer f.Close()
 
 	// Identify the type of archive we are dealing with.
 	format, input, err := archiver.Identify(filepath.Base(file), f)

server/filesystem/disk_space.go

@@ -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

@@ -18,6 +18,7 @@ const (
 	ErrCodePathResolution ErrorCode = "E_BADPATH"
 	ErrCodeDenylistFile   ErrorCode = "E_DENYLIST"
 	ErrCodeUnknownError   ErrorCode = "E_UNKNOWN"
+	ErrNotExist           ErrorCode = "E_NOTEXIST"
 )
 
 type Error struct {
@@ -68,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:

server/filesystem/filesystem.go

@@ -61,25 +61,28 @@ 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
-// it is present, the file is opened using the defaults which will truncate the contents.
-// The opened file is then returned to the caller.
+// Touch acts by creating the given file and path on the disk if it is not present
+// already. If  it is present, the file is opened using the defaults which will truncate
+// the contents. The opened file is then returned to the caller.
 func (fs *Filesystem) Touch(p string, flag int) (*os.File, error) {
 	cleaned, err := fs.SafePath(p)
 	if err != nil {
@@ -89,6 +92,9 @@ func (fs *Filesystem) Touch(p string, flag int) (*os.File, error) {
 	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")
@@ -159,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.
@@ -217,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
 	}
@@ -226,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
@@ -255,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")
 }
 
@@ -377,10 +387,9 @@ func (fs *Filesystem) TruncateRootDirectory() error {
 // Delete removes a file or folder from the system. Prevents the user from
 // accidentally (or maliciously) removing their root server data directory.
 func (fs *Filesystem) Delete(p string) error {
-	wg := sync.WaitGroup{}
 	// This is one of the few (only?) places in the codebase where we're explicitly not using
 	// the SafePath functionality when working with user provided input. If we did, you would
-	// not be able to delete a file that is a symlink pointing to a location outside of the data
+	// not be able to delete a file that is a symlink pointing to a location outside the data
 	// directory.
 	//
 	// We also want to avoid resolving a symlink that points _within_ the data directory and thus
@@ -397,25 +406,65 @@ func (fs *Filesystem) Delete(p string) error {
 		return errors.New("cannot delete root server directory")
 	}
 
-	if st, err := os.Lstat(resolved); err != nil {
+	st, err := os.Lstat(resolved)
+	if err != nil {
 		if !os.IsNotExist(err) {
 			fs.error(err).Warn("error while attempting to stat file before deletion")
+			return err
 		}
-	} else {
-		if !st.IsDir() {
-			fs.addDisk(-st.Size())
-		} else {
-			wg.Add(1)
-			go func(wg *sync.WaitGroup, st os.FileInfo, resolved string) {
-				defer wg.Done()
-				if s, err := fs.DirectorySize(resolved); err == nil {
-					fs.addDisk(-s)
+
+		// The following logic is used to handle a case where a user attempts to
+		// delete a file that does not exist through a directory symlink.
+		// We don't want to reveal that the file does not exist, so we validate
+		// the path of the symlink and return a bad path error if it is invalid.
+
+		// The requested file or directory doesn't exist, so at this point we
+		// need to iterate up the path chain until we hit a directory that
+		// _does_ exist and can be validated.
+		parts := strings.Split(filepath.Dir(resolved), "/")
+
+		// Range over all the path parts and form directory paths from the end
+		// moving up until we have a valid resolution, or we run out of paths to
+		// try.
+		for k := range parts {
+			try := strings.Join(parts[:(len(parts)-k)], "/")
+			if !fs.unsafeIsInDataDirectory(try) {
+				break
+			}
+
+			t, err := filepath.EvalSymlinks(try)
+			if err == nil {
+				if !fs.unsafeIsInDataDirectory(t) {
+					return NewBadPathResolution(p, t)
 				}
-			}(&wg, st, resolved)
+				break
+			}
+		}
+
+		// Always return early if the file does not exist.
+		return nil
+	}
+
+	// If the file is not a symlink, we need to check that it is not within a
+	// symlinked directory that points outside the data directory.
+	if st.Mode()&os.ModeSymlink == 0 {
+		ep, err := filepath.EvalSymlinks(resolved)
+		if err != nil {
+			if !os.IsNotExist(err) {
+				return err
+			}
+		} else if !fs.unsafeIsInDataDirectory(ep) {
+			return NewBadPathResolution(p, ep)
 		}
 	}
 
-	wg.Wait()
+	if st.IsDir() {
+		if s, err := fs.DirectorySize(resolved); err == nil {
+			fs.addDisk(-s)
+		}
+	} else {
+		fs.addDisk(-st.Size())
+	}
 
 	return os.RemoveAll(resolved)
 }

server/filesystem/filesystem_test.go

@@ -84,6 +84,35 @@ func (rfs *rootFs) reset() {
 	}
 }
 
+func TestFilesystem_Openfile(t *testing.T) {
+	g := Goblin(t)
+	fs, rfs := NewFs()
+
+	g.Describe("File", func() {
+		g.It("returns custom error when file does not exist", func() {
+			_, _, err := fs.File("foo/bar.txt")
+
+			g.Assert(err).IsNotNil()
+			g.Assert(IsErrorCode(err, ErrNotExist)).IsTrue()
+		})
+
+		g.It("returns file stat information", func() {
+			_ = rfs.CreateServerFile("foo.txt", []byte("hello world"))
+
+			f, st, err := fs.File("foo.txt")
+			g.Assert(err).IsNil()
+
+			g.Assert(st.Name()).Equal("foo.txt")
+			g.Assert(f).IsNotNil()
+			_ = f.Close()
+		})
+
+		g.AfterEach(func() {
+			rfs.reset()
+		})
+	})
+}
+
 func TestFilesystem_Writefile(t *testing.T) {
 	g := Goblin(t)
 	fs, rfs := NewFs()
@@ -508,6 +537,80 @@ func TestFilesystem_Delete(t *testing.T) {
 			}
 		})
 
+		g.It("deletes a symlink but not it's target within the root directory", func() {
+			// Symlink to a file inside the root directory.
+			err := os.Symlink(filepath.Join(rfs.root, "server/source.txt"), filepath.Join(rfs.root, "server/symlink.txt"))
+			g.Assert(err).IsNil()
+
+			// Delete the symlink itself.
+			err = fs.Delete("symlink.txt")
+			g.Assert(err).IsNil()
+
+			// Ensure the symlink was deleted.
+			_, err = os.Lstat(filepath.Join(rfs.root, "server/symlink.txt"))
+			g.Assert(err).IsNotNil()
+
+			// Ensure the symlink target still exists.
+			_, err = os.Lstat(filepath.Join(rfs.root, "server/source.txt"))
+			g.Assert(err).IsNil()
+		})
+
+		g.It("does not delete files symlinked outside of the root directory", func() {
+			// Create a file outside the root directory.
+			err := rfs.CreateServerFileFromString("/../source.txt", "test content")
+			g.Assert(err).IsNil()
+
+			// Create a symlink to the file outside the root directory.
+			err = os.Symlink(filepath.Join(rfs.root, "source.txt"), filepath.Join(rfs.root, "/server/symlink.txt"))
+			g.Assert(err).IsNil()
+
+			// Delete the symlink. (This should pass as we will delete the symlink itself, not it's target)
+			err = fs.Delete("symlink.txt")
+			g.Assert(err).IsNil()
+
+			// Ensure the file outside the root directory still exists.
+			_, err = os.Lstat(filepath.Join(rfs.root, "source.txt"))
+			g.Assert(err).IsNil()
+		})
+
+		g.It("does not delete files symlinked through a directory outside of the root directory", func() {
+			// Create a directory outside the root directory.
+			err := os.Mkdir(filepath.Join(rfs.root, "foo"), 0o755)
+			g.Assert(err).IsNil()
+
+			// Create a file inside the directory that is outside the root.
+			err = rfs.CreateServerFileFromString("/../foo/source.txt", "test content")
+			g.Assert(err).IsNil()
+
+			// Symlink the directory that is outside the root to a file inside the root.
+			err = os.Symlink(filepath.Join(rfs.root, "foo"), filepath.Join(rfs.root, "server/symlink"))
+			g.Assert(err).IsNil()
+
+			// Delete a file inside the symlinked directory.
+			err = fs.Delete("symlink/source.txt")
+			g.Assert(err).IsNotNil()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
+
+			// Ensure the file outside the root directory still exists.
+			_, err = os.Lstat(filepath.Join(rfs.root, "foo/source.txt"))
+			g.Assert(err).IsNil()
+		})
+
+		g.It("returns an error when trying to delete a non-existent file symlinked through a directory outside of the root directory", func() {
+			// Create a directory outside the root directory.
+			err := os.Mkdir(filepath.Join(rfs.root, "foo2"), 0o755)
+			g.Assert(err).IsNil()
+
+			// Symlink the directory that is outside the root to a file inside the root.
+			err = os.Symlink(filepath.Join(rfs.root, "foo2"), filepath.Join(rfs.root, "server/symlink"))
+			g.Assert(err).IsNil()
+
+			// Delete a file inside the symlinked directory.
+			err = fs.Delete("symlink/source.txt")
+			g.Assert(err).IsNotNil()
+			g.Assert(IsErrorCode(err, ErrCodePathResolution)).IsTrue()
+		})
+
 		g.AfterEach(func() {
 			rfs.reset()
 

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
-		// path chain until we hit a directory that _does_ exist and can be validated.
-		parts := strings.Split(filepath.Dir(r), "/")
-
-		var try string
-		// Range over all of the path parts and form directory pathings from the end
-		// moving up until we have a valid resolution or we run out of paths to try.
-		for k := range parts {
-			try = strings.Join(parts[:(len(parts)-k)], "/")
-
-			if !fs.unsafeIsInDataDirectory(try) {
-				break
-			}
-
-			t, err := filepath.EvalSymlinks(try)
-			if err == nil {
-				nonExistentPathResolution = t
-				break
-			}
+		// The target of one of the symlinks (EvalSymlinks is recursive) does not exist.
+		// So we get what target path does not exist and check if it's within the data
+		// directory. If it is, we return the original path, otherwise we return an error.
+		pErr, ok := err.(*iofs.PathError)
+		if !ok {
+			return "", errors.Wrap(err, "server/filesystem: failed to evaluate symlink")
 		}
-	}
-
-	// 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
+		ep = pErr.Path
 	}
 
 	// 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)

server/filesystem/path_test.go

@@ -115,6 +115,14 @@ func TestFilesystem_Blocks_Symlinks(t *testing.T) {
 		panic(err)
 	}
 
+	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)
+	}
+
+	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 {
+		panic(err)
+	}
+
 	if err := os.Symlink(filepath.Join(rfs.root, "/malicious_dir"), filepath.Join(rfs.root, "/server/external_dir")); err != nil {
 		panic(err)
 	}
@@ -128,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"))
 

server/install.go

@@ -4,7 +4,6 @@ import (
 	"bufio"
 	"bytes"
 	"context"
-	"fmt"
 	"html/template"
 	"io"
 	"os"
@@ -32,19 +31,17 @@ import (
 //
 // Pass true as the first argument in order to execute a server sync before the
 // process to ensure the latest information is used.
-func (s *Server) Install(sync bool) error {
-	if sync {
-		s.Log().Info("syncing server state with remote source before executing installation process")
-		if err := s.Sync(); err != nil {
-			return errors.WrapIf(err, "install: failed to sync server state with Panel")
-		}
-	}
+func (s *Server) Install() error {
+	return s.install(false)
+}
 
+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
-		// is actually going to run, otherwise all sorts of weird rapid UI behavior happens since there isn't
-		// an actual install process being executed.
+		// Send the start event so the Panel can automatically update. We don't
+		// send this unless the process is actually going to run, otherwise all
+		// sorts of weird rapid UI behavior happens since there isn't an actual
+		// install process being executed.
 		s.Events().Publish(InstallStartedEvent, "")
 
 		err = s.internalInstall()
@@ -53,12 +50,13 @@ 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
-		// error to this log entry. Otherwise ignore it in this log since whatever is calling
-		// this function should handle the error and will end up logging the same one.
+		// If the request was successful but there was an error with this request,
+		// attach the error to this log entry. Otherwise, ignore it in this log
+		// since whatever is calling this function should handle the error and
+		// will end up logging the same one.
 		if err == nil {
 			l.WithField("error", err)
 		}
@@ -66,19 +64,20 @@ func (s *Server) Install(sync bool) error {
 		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
-	// with a blank value which is a bit confusing.
+	// Ensure that the server is marked as offline at this point, otherwise you
+	// 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
-	// the install is completed.
+	// Push an event to the websocket, so we can auto-refresh the information in
+	// the panel once the installation is completed.
 	s.Events().Publish(InstallCompletedEvent, "")
 
 	return errors.WithStackIf(err)
 }
 
-// Reinstalls a server's software by utilizing the install script for the server egg. This
-// does not touch any existing files for the server, other than what the script modifies.
+// Reinstall reinstalls a server's software by utilizing the installation script
+// 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")
@@ -87,7 +86,12 @@ func (s *Server) Reinstall() error {
 		}
 	}
 
-	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.
@@ -116,8 +120,9 @@ type InstallationProcess struct {
 	client *client.Client
 }
 
-// Generates a new installation process struct that will be used to create containers,
-// and otherwise perform installation commands for a server.
+// NewInstallationProcess returns a new installation process struct that will be
+// 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,
@@ -133,8 +138,8 @@ func NewInstallationProcess(s *Server, script *remote.InstallationScript) (*Inst
 	return proc, nil
 }
 
-// Determines if the server is actively running the installation process by checking the status
-// of the installer lock.
+// IsInstalling returns if the server is actively running the installation
+// process by checking the status of the installer lock.
 func (s *Server) IsInstalling() bool {
 	return s.installing.Load()
 }
@@ -155,7 +160,7 @@ 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.Server.Context(), ip.Server.ID()+"_installer", types.ContainerRemoveOptions{
 		RemoveVolumes: true,
@@ -328,14 +333,14 @@ 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")
 }
 
-// Cleans up after the execution of the installation process. This grabs the logs from the
-// process to store in the server configuration directory, and then destroys the associated
-// installation container.
+// AfterExecute cleans up after the execution of the installation process.
+// This grabs the logs from the process to store in the server configuration
+// directory, and then destroys the associated installation container.
 func (ip *InstallationProcess) AfterExecute(containerId string) error {
 	defer ip.RemoveContainer()
 
@@ -421,10 +426,6 @@ func (ip *InstallationProcess) Execute() (string, error) {
 	}
 
 	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{
@@ -447,7 +448,6 @@ func (ip *InstallationProcess) Execute() (string, error) {
 		},
 		DNS:         cfg.Docker.Network.Dns,
 		LogConfig:   cfg.Docker.ContainerLogConfig(),
-		Privileged:  true,
 		NetworkMode: container.NetworkMode(cfg.Docker.Network.Mode),
 		UsernsMode:  container.UsernsMode(cfg.Docker.UsernsMode),
 	}
@@ -525,7 +525,7 @@ func (ip *InstallationProcess) StreamOutput(ctx context.Context, id string) erro
 	return nil
 }
 
-// resourceLimits returns the install container specific resource limits. This
+// resourceLimits returns resource limits for the installation container. This
 // looks at the globally defined install container limits and attempts to use
 // the higher of the two (defined limits & server limits). This allows for servers
 // with super low limits (e.g. Discord bots with 128Mb of memory) to perform more
@@ -537,8 +537,8 @@ func (ip *InstallationProcess) StreamOutput(ctx context.Context, id string) erro
 func (ip *InstallationProcess) resourceLimits() container.Resources {
 	limits := config.Get().Docker.InstallerLimits
 
-	// Create a copy of the configuration so we're not accidentally making changes
-	// to the underlying server build data.
+	// 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 {
@@ -562,10 +562,12 @@ func (ip *InstallationProcess) resourceLimits() container.Resources {
 	return resources
 }
 
-// SyncInstallState makes a HTTP request to the Panel instance notifying it that
+// 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. A boolean value of "true" means everything was successful, "false"
-// means something went wrong and the server must be deleted and re-created.
-func (s *Server) SyncInstallState(successful bool) error {
-	return s.client.SetInstallationStatus(s.Context(), s.ID(), successful)
+// 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/server.go

@@ -147,6 +147,7 @@ func (s *Server) Context() context.Context {
 // server instance.
 func (s *Server) GetEnvironmentVariables() []string {
 	out := []string{
+		// TODO: allow this to be overridden by the user.
 		fmt.Sprintf("TZ=%s", config.Get().System.Timezone),
 		fmt.Sprintf("STARTUP=%s", s.Config().Invocation),
 		fmt.Sprintf("SERVER_MEMORY=%d", s.MemoryLimit()),

server/transfer/source.go

@@ -128,6 +128,13 @@ func (t *Transfer) PushArchiveToTarget(url, token string) ([]byte, error) {
 	t.Log().Debug("sending archive to destination")
 	client := http.Client{Timeout: 0}
 	res, err := client.Do(req)
+	if err != nil {
+		t.Log().Debug("error while sending archive to destination")
+		return nil, err
+	}
+	if res.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("unexpected status code from destination: %d", res.StatusCode)
+	}
 	t.Log().Debug("waiting for stream to complete")
 	select {
 	case <-ctx.Done():

sftp/server.go

@@ -68,6 +68,21 @@ func (c *SFTPServer) Run() error {
 	}
 
 	conf := &ssh.ServerConfig{
+		Config: ssh.Config{
+			KeyExchanges: []string{
+				"curve25519-sha256", "curve25519-sha256@libssh.org",
+				"ecdh-sha2-nistp256", "ecdh-sha2-nistp384", "ecdh-sha2-nistp521",
+				"diffie-hellman-group14-sha256",
+			},
+			Ciphers: []string{
+				"aes128-gcm@openssh.com",
+				"chacha20-poly1305@openssh.com",
+				"aes128-ctr", "aes192-ctr", "aes256-ctr",
+			},
+			MACs: []string{
+				"hmac-sha2-256-etm@openssh.com", "hmac-sha2-256",
+			},
+		},
 		NoClientAuth: false,
 		MaxAuthTries: 6,
 		PasswordCallback: func(conn ssh.ConnMetadata, password []byte) (*ssh.Permissions, error) {

system/const.go

@@ -1,3 +1,3 @@
 package system
 
-var Version = "1.11.0-rc.1"
+var Version = "1.11.8"

system/sink_pool_test.go

@@ -15,7 +15,16 @@ func MutexLocked(m *sync.RWMutex) bool {
 
 	state := v.FieldByName("w").FieldByName("state")
 
-	return state.Int()&1 == 1 || v.FieldByName("readerCount").Int() > 0
+	readerCountField := v.FieldByName("readerCount")
+	// go1.20 changed readerCount to an atomic
+	// ref; https://github.com/golang/go/commit/e509452727b469d89a3fc4a7d1cbf9d3f110efee
+	var readerCount int64
+	if readerCountField.Kind() == reflect.Struct {
+		readerCount = readerCountField.FieldByName("v").Int()
+	} else {
+		readerCount = readerCountField.Int()
+	}
+	return state.Int()&1 == 1 || readerCount > 0
 }
 
 func TestSink(t *testing.T) {

system/strings.go

@@ -1,29 +0,0 @@
-package system
-
-import (
-	"math/rand"
-	"regexp"
-	"strings"
-)
-
-var ipTrimRegex = regexp.MustCompile(`(:\d*)?$`)
-
-const characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890"
-
-// RandomString generates a random string of alpha-numeric characters using a
-// pseudo-random number generator. The output of this function IS NOT cryptographically
-// secure, it is used solely for generating random strings outside a security context.
-func RandomString(n int) string {
-	var b strings.Builder
-	b.Grow(n)
-	for i := 0; i < n; i++ {
-		b.WriteByte(characters[rand.Intn(len(characters))])
-	}
-	return b.String()
-}
-
-// TrimIPSuffix removes the internal port value from an IP address to ensure we're only
-// ever working directly with the IP address.
-func TrimIPSuffix(s string) string {
-	return ipTrimRegex.ReplaceAllString(s, "")
-}

system/system.go

@@ -1,17 +1,57 @@
 package system
 
 import (
+	"context"
 	"runtime"
 
+	"github.com/acobaugh/osrelease"
+	"github.com/docker/docker/api/types"
+	"github.com/docker/docker/client"
 	"github.com/docker/docker/pkg/parsers/kernel"
 )
 
 type Information struct {
-	Version       string `json:"version"`
-	KernelVersion string `json:"kernel_version"`
+	Version string            `json:"version"`
+	Docker  DockerInformation `json:"docker"`
+	System  System            `json:"system"`
+}
+
+type DockerInformation struct {
+	Version    string           `json:"version"`
+	Cgroups    DockerCgroups    `json:"cgroups"`
+	Containers DockerContainers `json:"containers"`
+	Storage    DockerStorage    `json:"storage"`
+	Runc       DockerRunc       `json:"runc"`
+}
+
+type DockerCgroups struct {
+	Driver  string `json:"driver"`
+	Version string `json:"version"`
+}
+
+type DockerContainers struct {
+	Total   int `json:"total"`
+	Running int `json:"running"`
+	Paused  int `json:"paused"`
+	Stopped int `json:"stopped"`
+}
+
+type DockerStorage struct {
+	Driver     string `json:"driver"`
+	Filesystem string `json:"filesystem"`
+}
+
+type DockerRunc struct {
+	Version string `json:"version"`
+}
+
+type System struct {
 	Architecture  string `json:"architecture"`
+	CPUThreads    int    `json:"cpu_threads"`
+	MemoryBytes   int64  `json:"memory_bytes"`
+	KernelVersion string `json:"kernel_version"`
 	OS            string `json:"os"`
-	CpuCount      int    `json:"cpu_count"`
+	OSType        string `json:"os_type"`
 }
 
 func GetSystemInformation() (*Information, error) {
@@ -20,13 +60,84 @@ func GetSystemInformation() (*Information, error) {
 		return nil, err
 	}
 
-	s := &Information{
-		Version:       Version,
-		KernelVersion: k.String(),
-		Architecture:  runtime.GOARCH,
-		OS:            runtime.GOOS,
-		CpuCount:      runtime.NumCPU(),
+	version, info, err := GetDockerInfo(context.Background())
+	if err != nil {
+		return nil, err
 	}
 
-	return s, nil
+	release, err := osrelease.Read()
+	if err != nil {
+		return nil, err
+	}
+
+	var os string
+	if release["PRETTY_NAME"] != "" {
+		os = release["PRETTY_NAME"]
+	} else if release["NAME"] != "" {
+		os = release["NAME"]
+	} else {
+		os = info.OperatingSystem
+	}
+
+	var filesystem string
+	for _, v := range info.DriverStatus {
+		if v[0] != "Backing Filesystem" {
+			continue
+		}
+		filesystem = v[1]
+		break
+	}
+
+	return &Information{
+		Version: Version,
+		Docker: DockerInformation{
+			Version: version.Version,
+			Cgroups: DockerCgroups{
+				Driver:  info.CgroupDriver,
+				Version: info.CgroupVersion,
+			},
+			Containers: DockerContainers{
+				Total:   info.Containers,
+				Running: info.ContainersRunning,
+				Paused:  info.ContainersPaused,
+				Stopped: info.ContainersStopped,
+			},
+			Storage: DockerStorage{
+				Driver:     info.Driver,
+				Filesystem: filesystem,
+			},
+			Runc: DockerRunc{
+				Version: info.RuncCommit.ID,
+			},
+		},
+		System: System{
+			Architecture:  runtime.GOARCH,
+			CPUThreads:    runtime.NumCPU(),
+			MemoryBytes:   info.MemTotal,
+			KernelVersion: k.String(),
+			OS:            os,
+			OSType:        runtime.GOOS,
+		},
+	}, nil
+}
+
+func GetDockerInfo(ctx context.Context) (types.Version, types.Info, error) {
+	// TODO: find a way to re-use the client from the docker environment.
+	c, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())
+	if err != nil {
+		return types.Version{}, types.Info{}, err
+	}
+	defer c.Close()
+
+	dockerVersion, err := c.ServerVersion(ctx)
+	if err != nil {
+		return types.Version{}, types.Info{}, err
+	}
+
+	dockerInfo, err := c.Info(ctx)
+	if err != nil {
+		return types.Version{}, types.Info{}, err
+	}
+
+	return dockerVersion, dockerInfo, nil
 }