Replace error handling package with emperror; add better reporting for errors escaping server root

server/archiver.go

@@ -2,9 +2,9 @@ package server
 
 import (
 	"crypto/sha256"
+	"emperror.dev/errors"
 	"encoding/hex"
 	"github.com/mholt/archiver/v3"
-	"github.com/pkg/errors"
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/server/filesystem"
 	"io"
@@ -41,7 +41,7 @@ func (a *Archiver) Exists() bool {
 func (a *Archiver) Stat() (*filesystem.Stat, error) {
 	s, err := os.Stat(a.Path())
 	if err != nil {
-		return nil, errors.WithStack(err)
+		return nil, errors.WithStackIf(err)
 	}
 
 	return &filesystem.Stat{
@@ -99,7 +99,7 @@ func (a *Archiver) DeleteIfExists() error {
 	}
 
 	if err := os.Remove(a.Path()); err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	return nil

server/backup.go

@@ -2,8 +2,8 @@ package server
 
 import (
 	"bufio"
+	"emperror.dev/errors"
 	"github.com/apex/log"
-	"github.com/pkg/errors"
 	"github.com/pterodactyl/wings/api"
 	"github.com/pterodactyl/wings/server/backup"
 	"os"
@@ -80,7 +80,7 @@ func (s *Server) Backup(b backup.BackupInterface) error {
 	// Get the included files based on the root path and the ignored files provided.
 	inc, err := s.GetIncludedBackupFiles(b.Ignored())
 	if err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	ad, err := b.Generate(inc, s.Filesystem().Path())
@@ -100,7 +100,7 @@ func (s *Server) Backup(b backup.BackupInterface) error {
 			"file_size":     0,
 		})
 
-		return errors.Wrap(err, "error while generating server backup")
+		return errors.WrapIf(err, "error while generating server backup")
 	}
 
 	// Try to notify the panel about the status of this backup. If for some reason this request

server/backup/archiver.go

@@ -3,9 +3,9 @@ package backup
 import (
 	"archive/tar"
 	"context"
+	"emperror.dev/errors"
 	"github.com/apex/log"
 	gzip "github.com/klauspost/pgzip"
-	"github.com/pkg/errors"
 	"github.com/remeh/sizedwaitgroup"
 	"golang.org/x/sync/errgroup"
 	"io"
@@ -26,7 +26,7 @@ type Archive struct {
 func (a *Archive) Create(dst string, ctx context.Context) error {
 	f, err := os.OpenFile(dst, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
 	if err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 	defer f.Close()
 
@@ -58,7 +58,7 @@ func (a *Archive) Create(dst string, ctx context.Context) error {
 
 			select {
 			case <-ctx.Done():
-				return errors.WithStack(ctx.Err())
+				return errors.WithStackIf(ctx.Err())
 			default:
 				return a.addToArchive(p, tw)
 			}
@@ -75,7 +75,7 @@ func (a *Archive) Create(dst string, ctx context.Context) error {
 			log.WithField("location", dst).Warn("failed to delete corrupted backup archive")
 		}
 
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	return nil
@@ -91,7 +91,7 @@ func (a *Archive) addToArchive(p string, w *tar.Writer) error {
 			return nil
 		}
 
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 	defer f.Close()
 
@@ -102,7 +102,7 @@ func (a *Archive) addToArchive(p string, w *tar.Writer) error {
 			return nil
 		}
 
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	header := &tar.Header{
@@ -120,12 +120,12 @@ func (a *Archive) addToArchive(p string, w *tar.Writer) error {
 	defer a.Unlock()
 
 	if err := w.WriteHeader(header); err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	buf := make([]byte, 4*1024)
 	if _, err := io.CopyBuffer(w, f, buf); err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	return nil

server/backup/backup.go

@@ -2,9 +2,9 @@ package backup
 
 import (
 	"crypto/sha1"
+	"emperror.dev/errors"
 	"encoding/hex"
 	"github.com/apex/log"
-	"github.com/pkg/errors"
 	"github.com/pterodactyl/wings/api"
 	"github.com/pterodactyl/wings/config"
 	"io"
@@ -87,7 +87,7 @@ func (b *Backup) Path() string {
 func (b *Backup) Size() (int64, error) {
 	st, err := os.Stat(b.Path())
 	if err != nil {
-		return 0, errors.WithStack(err)
+		return 0, errors.WithStackIf(err)
 	}
 
 	return st.Size(), nil
@@ -99,7 +99,7 @@ func (b *Backup) Checksum() ([]byte, error) {
 
 	f, err := os.Open(b.Path())
 	if err != nil {
-		return nil, errors.WithStack(err)
+		return nil, errors.WithStackIf(err)
 	}
 	defer f.Close()
 

server/backup/backup_local.go

@@ -2,7 +2,7 @@ package backup
 
 import (
 	"context"
-	"github.com/pkg/errors"
+	"emperror.dev/errors"
 	"os"
 )
 
@@ -24,7 +24,7 @@ func LocateLocal(uuid string) (*LocalBackup, os.FileInfo, error) {
 
 	st, err := os.Stat(b.Path())
 	if err != nil {
-		return nil, nil, errors.WithStack(err)
+		return nil, nil, errors.WithStackIf(err)
 	}
 
 	if st.IsDir() {
@@ -48,7 +48,7 @@ func (b *LocalBackup) Generate(included *IncludedFiles, prefix string) (*Archive
 	}
 
 	if err := a.Create(b.Path(), context.Background()); err != nil {
-		return nil, errors.WithStack(err)
+		return nil, errors.WithStackIf(err)
 	}
 
 	return b.Details(), nil

server/backup/backup_request.go

@@ -1,8 +1,8 @@
 package backup
 
 import (
+	"emperror.dev/errors"
 	"fmt"
-	"github.com/pkg/errors"
 )
 
 type Request struct {

server/backup/backup_s3.go

@@ -3,9 +3,9 @@ package backup
 import (
 	"bytes"
 	"context"
+	"emperror.dev/errors"
 	"fmt"
 	"github.com/apex/log"
-	"github.com/pkg/errors"
 	"github.com/pterodactyl/wings/api"
 	"io"
 	"net/http"
@@ -31,17 +31,17 @@ func (s *S3Backup) Generate(included *IncludedFiles, prefix string) (*ArchiveDet
 	}
 
 	if err := a.Create(s.Path(), context.Background()); err != nil {
-		return nil, errors.WithStack(err)
+		return nil, errors.WithStackIf(err)
 	}
 
 	rc, err := os.Open(s.Path())
 	if err != nil {
-		return nil, errors.WithStack(err)
+		return nil, errors.WithStackIf(err)
 	}
 	defer rc.Close()
 
 	if err := s.generateRemoteRequest(rc); err != nil {
-		return nil, errors.WithStack(err)
+		return nil, errors.WithStackIf(err)
 	}
 
 	return s.Details(), err

server/console.go

@@ -2,9 +2,9 @@ package server
 
 import (
 	"context"
+	"emperror.dev/errors"
 	"fmt"
 	"github.com/mitchellh/colorstring"
-	"github.com/pkg/errors"
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/system"
 	"sync"
@@ -12,7 +12,7 @@ import (
 	"time"
 )
 
-var ErrTooMuchConsoleData = errors.New("console is outputting too much data")
+var ErrTooMuchConsoleData = errors.Sentinel("console is outputting too much data")
 
 type ConsoleThrottler struct {
 	mu sync.Mutex

server/crash.go

@@ -1,8 +1,8 @@
 package server
 
 import (
+	"emperror.dev/errors"
 	"fmt"
-	"github.com/pkg/errors"
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
 	"sync"
@@ -57,7 +57,7 @@ func (s *Server) handleServerCrash() error {
 
 	exitCode, oomKilled, err := s.Environment.ExitState()
 	if err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	// If the system is not configured to detect a clean exit code as a crash, and the

server/errors.go

@@ -1,9 +1,9 @@
 package server
 
-import "github.com/pkg/errors"
+import "emperror.dev/errors"
 
-var ErrIsRunning = errors.New("server is running")
-var ErrSuspended = errors.New("server is currently in a suspended state")
+var ErrIsRunning = errors.Sentinel("server is running")
+var ErrSuspended = errors.Sentinel("server is currently in a suspended state")
 
 type crashTooFrequent struct {
 }

server/filesystem.go

@@ -1,7 +1,7 @@
 package server
 
 import (
-	"github.com/pkg/errors"
+	"emperror.dev/errors"
 	"github.com/pterodactyl/wings/server/filesystem"
 	"os"
 )
@@ -13,12 +13,12 @@ func (s *Server) Filesystem() *filesystem.Filesystem {
 // Ensures that the data directory for the server instance exists.
 func (s *Server) EnsureDataDirectoryExists() error {
 	if _, err := os.Stat(s.fs.Path()); err != nil && !os.IsNotExist(err) {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	} else if err != nil {
 		// Create the server data directory because it does not currently exist
 		// on the system.
 		if err := os.MkdirAll(s.fs.Path(), 0700); err != nil {
-			return errors.WithStack(err)
+			return errors.WithStackIf(err)
 		}
 
 		if err := s.fs.Chown("/"); err != nil {

server/filesystem/compress.go

@@ -2,9 +2,9 @@ package filesystem
 
 import (
 	"context"
+	"emperror.dev/errors"
 	"fmt"
 	"github.com/karrick/godirwalk"
-	"github.com/pkg/errors"
 	"github.com/pterodactyl/wings/server/backup"
 	ignore "github.com/sabhiram/go-gitignore"
 	"os"
@@ -41,7 +41,7 @@ func (fs *Filesystem) GetIncludedFiles(dir string, ignored []string) (*backup.In
 			if e.IsSymlink() {
 				sp, err = fs.SafePath(p)
 				if err != nil {
-					if errors.Is(err, ErrBadPathResolution) {
+					if IsBadPathResolutionError(err) {
 						return godirwalk.SkipThis
 					}
 
@@ -65,7 +65,7 @@ func (fs *Filesystem) GetIncludedFiles(dir string, ignored []string) (*backup.In
 		},
 	})
 
-	return inc, errors.WithStack(err)
+	return inc, errors.WithStackIf(err)
 }
 
 // Compresses all of the files matching the given paths in the specified directory. This function
@@ -115,7 +115,7 @@ func (fs *Filesystem) CompressFiles(dir string, paths []string) (os.FileInfo, er
 						// use the resolved location for the rest of this function.
 						sp, err = fs.SafePath(p)
 						if err != nil {
-							if errors.Is(err, ErrBadPathResolution) {
+							if IsBadPathResolutionError(err) {
 								return godirwalk.SkipThis
 							}
 
@@ -141,7 +141,7 @@ func (fs *Filesystem) CompressFiles(dir string, paths []string) (os.FileInfo, er
 	d := path.Join(cleanedRootDir, fmt.Sprintf("archive-%s.tar.gz", strings.ReplaceAll(time.Now().Format(time.RFC3339), ":", "")))
 
 	if err := a.Create(d, context.Background()); err != nil {
-		return nil, errors.WithStack(err)
+		return nil, errors.WithStackIf(err)
 	}
 
 	f, err := os.Stat(d)

server/filesystem/decompress.go

@@ -4,9 +4,9 @@ import (
 	"archive/tar"
 	"archive/zip"
 	"compress/gzip"
+	"emperror.dev/errors"
 	"fmt"
 	"github.com/mholt/archiver/v3"
-	"github.com/pkg/errors"
 	"os"
 	"path/filepath"
 	"reflect"
@@ -47,10 +47,10 @@ func (fs *Filesystem) SpaceAvailableForDecompression(dir string, file string) (b
 			return false, ErrUnknownArchiveFormat
 		}
 
-		return false, errors.WithStack(err)
+		return false, errors.WithStackIf(err)
 	}
 
-	return true, errors.WithStack(err)
+	return true, errors.WithStackIf(err)
 }
 
 // Decompress a file in a given directory by using the archiver tool to infer the file
@@ -60,12 +60,12 @@ func (fs *Filesystem) SpaceAvailableForDecompression(dir string, file string) (b
 func (fs *Filesystem) DecompressFile(dir string, file string) error {
 	source, err := fs.SafePath(filepath.Join(dir, file))
 	if err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	// Make sure the file exists basically.
 	if _, err := os.Stat(source); err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	// Walk over all of the files spinning up an additional go-routine for each file we've encountered
@@ -93,17 +93,17 @@ func (fs *Filesystem) DecompressFile(dir string, file string) error {
 
 		p, err := fs.SafePath(filepath.Join(dir, name))
 		if err != nil {
-			return errors.Wrap(err, "failed to generate a safe path to server file")
+			return errors.WrapIf(err, "failed to generate a safe path to server file")
 		}
 
-		return errors.Wrap(fs.Writefile(p, f), "could not extract file from archive")
+		return errors.WrapIf(fs.Writefile(p, f), "could not extract file from archive")
 	})
 	if err != nil {
 		if strings.HasPrefix(err.Error(), "format ") {
-			return errors.WithStack(ErrUnknownArchiveFormat)
+			return errors.WithStackIf(ErrUnknownArchiveFormat)
 		}
 
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	return nil

server/filesystem/disk_space.go

@@ -1,9 +1,9 @@
 package filesystem
 
 import (
+	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/karrick/godirwalk"
-	"github.com/pkg/errors"
 	"sync"
 	"sync/atomic"
 	"syscall"
@@ -153,7 +153,7 @@ func (fs *Filesystem) updateCachedDiskUsage() (int64, error) {
 func (fs *Filesystem) DirectorySize(dir string) (int64, error) {
 	d, err := fs.SafePath(dir)
 	if err != nil {
-		return 0, errors.WithStack(err)
+		return 0, errors.WithStackIf(err)
 	}
 
 	var size int64
@@ -167,7 +167,7 @@ func (fs *Filesystem) DirectorySize(dir string) (int64, error) {
 			// it. Otherwise, allow it to continue.
 			if e.IsSymlink() {
 				if _, err := fs.SafePath(p); err != nil {
-					if errors.Is(err, ErrBadPathResolution) {
+					if IsBadPathResolutionError(err) {
 						return godirwalk.SkipThis
 					}
 
@@ -184,7 +184,7 @@ func (fs *Filesystem) DirectorySize(dir string) (int64, error) {
 		},
 	})
 
-	return size, errors.WithStack(err)
+	return size, errors.WithStackIf(err)
 }
 
 // Helper function to determine if a server has space available for a file of a given size.

server/filesystem/errors.go

@@ -1,16 +1,43 @@
 package filesystem
 
 import (
+	"emperror.dev/errors"
+	"fmt"
 	"github.com/apex/log"
-	"github.com/pkg/errors"
 	"os"
 	"path/filepath"
 )
 
-var ErrIsDirectory = errors.New("filesystem: is a directory")
-var ErrNotEnoughDiskSpace = errors.New("filesystem: not enough disk space")
-var ErrBadPathResolution = errors.New("filesystem: invalid path resolution")
-var ErrUnknownArchiveFormat = errors.New("filesystem: unknown archive format")
+var ErrIsDirectory = errors.Sentinel("filesystem: is a directory")
+var ErrNotEnoughDiskSpace = errors.Sentinel("filesystem: not enough disk space")
+var ErrUnknownArchiveFormat = errors.Sentinel("filesystem: unknown archive format")
+
+type BadPathResolutionError struct {
+	path     string
+	resolved string
+}
+
+// Returns the specific error for a bad path resolution.
+func (b *BadPathResolutionError) Error() string {
+	r := b.resolved
+	if r == "" {
+		r = "<empty>"
+	}
+	return fmt.Sprintf("filesystem: server path [%s] resolves to a location outside the server root: %s", b.path, r)
+}
+
+// Returns a new BadPathResolution error.
+func NewBadPathResolution(path string, resolved string) *BadPathResolutionError {
+	return &BadPathResolutionError{path, resolved}
+}
+
+// Determines if the given error is a bad path resolution error.
+func IsBadPathResolutionError(err error) bool {
+	if _, ok := err.(*BadPathResolutionError); ok {
+		return true
+	}
+	return false
+}
 
 // Generates an error logger instance with some basic information.
 func (fs *Filesystem) error(err error) *log.Entry {
@@ -23,8 +50,8 @@ func (fs *Filesystem) error(err error) *log.Entry {
 // directory, otherwise return nil. Returning this error for a file will stop the walking
 // for the remainder of the directory. This is assuming an os.FileInfo struct was even returned.
 func (fs *Filesystem) handleWalkerError(err error, f os.FileInfo) error {
-	if !errors.Is(err, ErrBadPathResolution) {
-		return err
+	if !IsBadPathResolutionError(err) {
+		return errors.WithStackIf(err)
 	}
 
 	if f != nil && f.IsDir() {
@@ -32,4 +59,4 @@ func (fs *Filesystem) handleWalkerError(err error, f os.FileInfo) error {
 	}
 
 	return nil
-}
+}

server/filesystem/filesystem.go

@@ -2,9 +2,9 @@ package filesystem
 
 import (
 	"bufio"
+	"emperror.dev/errors"
 	"github.com/gabriel-vasile/mimetype"
 	"github.com/karrick/godirwalk"
-	"github.com/pkg/errors"
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/system"
 	"io"
@@ -80,7 +80,7 @@ func (fs *Filesystem) Readfile(p string, w io.Writer) error {
 func (fs *Filesystem) Writefile(p string, r io.Reader) error {
 	cleaned, err := fs.SafePath(p)
 	if err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	var currentSize int64
@@ -88,15 +88,15 @@ func (fs *Filesystem) Writefile(p string, r io.Reader) error {
 	// to it and an empty file. We'll then write to it later on after this completes.
 	if stat, err := os.Stat(cleaned); err != nil {
 		if !os.IsNotExist(err) {
-			return errors.WithStack(err)
+			return errors.WithStackIf(err)
 		}
 
 		if err := os.MkdirAll(filepath.Dir(cleaned), 0755); err != nil {
-			return errors.WithStack(err)
+			return errors.WithStackIf(err)
 		}
 
 		if err := fs.Chown(filepath.Dir(cleaned)); err != nil {
-			return errors.WithStack(err)
+			return errors.WithStackIf(err)
 		}
 	} else {
 		if stat.IsDir() {
@@ -119,7 +119,7 @@ func (fs *Filesystem) Writefile(p string, r io.Reader) error {
 	// truncate the existing file.
 	file, err := o.open(cleaned, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
 	if err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 	defer file.Close()
 
@@ -138,7 +138,7 @@ func (fs *Filesystem) Writefile(p string, r io.Reader) error {
 func (fs *Filesystem) CreateDirectory(name string, p string) error {
 	cleaned, err := fs.SafePath(path.Join(p, name))
 	if err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	return os.MkdirAll(cleaned, 0755)
@@ -148,12 +148,12 @@ func (fs *Filesystem) CreateDirectory(name string, p string) error {
 func (fs *Filesystem) Rename(from string, to string) error {
 	cleanedFrom, err := fs.SafePath(from)
 	if err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	cleanedTo, err := fs.SafePath(to)
 	if err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	// If the target file or directory already exists the rename function will fail, so just
@@ -171,7 +171,7 @@ func (fs *Filesystem) Rename(from string, to string) error {
 	// we're not at the root directory level.
 	if d != fs.Path() {
 		if mkerr := os.MkdirAll(d, 0755); mkerr != nil {
-			return errors.Wrap(mkerr, "failed to create directory structure for file rename")
+			return errors.WrapIf(mkerr, "failed to create directory structure for file rename")
 		}
 	}
 
@@ -185,7 +185,7 @@ func (fs *Filesystem) Rename(from string, to string) error {
 func (fs *Filesystem) Chown(path string) error {
 	cleaned, err := fs.SafePath(path)
 	if err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	if fs.isTest {
@@ -197,7 +197,7 @@ func (fs *Filesystem) Chown(path string) error {
 
 	// Start by just chowning the initial path that we received.
 	if err := os.Chown(cleaned, uid, gid); err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	// If this is not a directory we can now return from the function, there is nothing
@@ -268,12 +268,12 @@ func (fs *Filesystem) findCopySuffix(dir string, name string, extension string)
 func (fs *Filesystem) Copy(p string) error {
 	cleaned, err := fs.SafePath(p)
 	if err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	s, err := os.Stat(cleaned)
 	if err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	} else if s.IsDir() || !s.Mode().IsRegular() {
 		// If this is a directory or not a regular file, just throw a not-exist error
 		// since anything calling this function should understand what that means.
@@ -300,7 +300,7 @@ func (fs *Filesystem) Copy(p string) error {
 
 	source, err := os.Open(cleaned)
 	if err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 	defer source.Close()
 
@@ -324,7 +324,7 @@ func (fs *Filesystem) Delete(p string) error {
 	// exists within the data directory.
 	resolved := fs.unsafeFilePath(p)
 	if !fs.unsafeIsInDataDirectory(resolved) {
-		return ErrBadPathResolution
+		return NewBadPathResolution(p, resolved)
 	}
 
 	// Block any whoopsies.

server/filesystem/filesystem_test.go

@@ -134,22 +134,22 @@ func TestFilesystem_SafePath(t *testing.T) {
 		g.It("blocks access to files outside the root directory", func() {
 			p, err := fs.SafePath("../test.txt")
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 			g.Assert(p).Equal("")
 
 			p, err = fs.SafePath("/../test.txt")
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 			g.Assert(p).Equal("")
 
 			p, err = fs.SafePath("./foo/../../test.txt")
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 			g.Assert(p).Equal("")
 
 			p, err = fs.SafePath("..")
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 			g.Assert(p).Equal("")
 		})
 	})
@@ -185,7 +185,7 @@ func TestFilesystem_Blocks_Symlinks(t *testing.T) {
 
 			err := fs.Readfile("symlinked.txt", &b)
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 		})
 	})
 
@@ -195,7 +195,7 @@ func TestFilesystem_Blocks_Symlinks(t *testing.T) {
 
 			err := fs.Writefile("symlinked.txt", r)
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 		})
 
 		g.It("cannot write a file to a directory symlinked outside the root", func() {
@@ -203,7 +203,7 @@ func TestFilesystem_Blocks_Symlinks(t *testing.T) {
 
 			err := fs.Writefile("external_dir/foo.txt", r)
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 		})
 	})
 
@@ -211,19 +211,19 @@ func TestFilesystem_Blocks_Symlinks(t *testing.T) {
 		g.It("cannot create a directory outside the root", func() {
 			err := fs.CreateDirectory("my_dir", "external_dir")
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 		})
 
 		g.It("cannot create a nested directory outside the root", func() {
 			err := fs.CreateDirectory("my/nested/dir", "external_dir/foo/bar")
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 		})
 
 		g.It("cannot create a nested directory outside the root", func() {
 			err := fs.CreateDirectory("my/nested/dir", "external_dir/server")
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 		})
 	})
 
@@ -231,13 +231,13 @@ func TestFilesystem_Blocks_Symlinks(t *testing.T) {
 		g.It("cannot rename a file symlinked outside the directory root", func() {
 			err := fs.Rename("symlinked.txt", "foo.txt")
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 		})
 
 		g.It("cannot rename a symlinked directory outside the root", func() {
 			err := fs.Rename("external_dir", "foo")
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 		})
 
 		g.It("cannot rename a file to a location outside the directory root", func() {
@@ -245,7 +245,7 @@ func TestFilesystem_Blocks_Symlinks(t *testing.T) {
 
 			err := fs.Rename("my_file.txt", "external_dir/my_file.txt")
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 		})
 	})
 
@@ -253,13 +253,13 @@ func TestFilesystem_Blocks_Symlinks(t *testing.T) {
 		g.It("cannot chown a file symlinked outside the directory root", func() {
 			err := fs.Chown("symlinked.txt")
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 		})
 
 		g.It("cannot chown a directory symlinked outside the directory root", func() {
 			err := fs.Chown("external_dir")
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 		})
 	})
 
@@ -267,7 +267,7 @@ func TestFilesystem_Blocks_Symlinks(t *testing.T) {
 		g.It("cannot copy a file symlinked outside the directory root", func() {
 			err := fs.Copy("symlinked.txt")
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 		})
 	})
 
@@ -325,7 +325,7 @@ func TestFilesystem_Readfile(t *testing.T) {
 
 			err = fs.Readfile("/../test.txt", buf)
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 		})
 
 		g.AfterEach(func() {
@@ -386,7 +386,7 @@ func TestFilesystem_Writefile(t *testing.T) {
 
 			err := fs.Writefile("/some/../foo/../../test.txt", r)
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 		})
 
 		g.It("cannot write a file that exceeds the disk limits", func() {
@@ -477,7 +477,7 @@ func TestFilesystem_CreateDirectory(t *testing.T) {
 		g.It("should not allow the creation of directories outside the root", func() {
 			err := fs.CreateDirectory("test", "e/../../something")
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 		})
 
 		g.It("should not increment the disk usage", func() {
@@ -527,7 +527,7 @@ func TestFilesystem_Rename(t *testing.T) {
 		g.It("does not allow renaming to a location outside the root", func() {
 			err := fs.Rename("source.txt", "../target.txt")
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 		})
 
 		g.It("does not allow renaming from a location outside the root", func() {
@@ -535,7 +535,7 @@ func TestFilesystem_Rename(t *testing.T) {
 
 			err = fs.Rename("/../ext-source.txt", "target.txt")
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 		})
 
 		g.It("allows a file to be renamed", func() {
@@ -613,7 +613,7 @@ func TestFilesystem_Copy(t *testing.T) {
 
 			err = fs.Copy("../ext-source.txt")
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 		})
 
 		g.It("should return an error if the source directory is outside the root", func() {
@@ -625,11 +625,11 @@ func TestFilesystem_Copy(t *testing.T) {
 
 			err = fs.Copy("../nested/in/dir/ext-source.txt")
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 
 			err = fs.Copy("nested/in/../../../nested/in/dir/ext-source.txt")
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 		})
 
 		g.It("should return an error if the source is a directory", func() {
@@ -721,7 +721,7 @@ func TestFilesystem_Delete(t *testing.T) {
 
 			err = fs.Delete("../ext-source.txt")
 			g.Assert(err).IsNotNil()
-			g.Assert(errors.Is(err, ErrBadPathResolution)).IsTrue()
+			g.Assert(IsBadPathResolutionError(err)).IsTrue()
 		})
 
 		g.It("does not allow the deletion of the root directory", func() {

server/filesystem/path.go

@@ -2,6 +2,7 @@ package filesystem
 
 import (
 	"context"
+	"emperror.dev/errors"
 	"golang.org/x/sync/errgroup"
 	"os"
 	"path/filepath"
@@ -23,9 +24,9 @@ func (fs *Filesystem) SafePath(p string) (string, error) {
 
 	// At the same time, evaluate the symlink status and determine where this file or folder
 	// is truly pointing to.
-	p, err := filepath.EvalSymlinks(r)
+	ep, err := filepath.EvalSymlinks(r)
 	if err != nil && !os.IsNotExist(err) {
-		return "", err
+		return "", errors.WithStackIf(err)
 	} 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.
@@ -53,7 +54,7 @@ func (fs *Filesystem) SafePath(p string) (string, error) {
 	// attempt going on, and we should NOT resolve this path for them.
 	if nonExistentPathResolution != "" {
 		if !fs.unsafeIsInDataDirectory(nonExistentPathResolution) {
-			return "", ErrBadPathResolution
+			return "", NewBadPathResolution(p, nonExistentPathResolution)
 		}
 
 		// If the nonExistentPathResolution variable is not empty then the initial path requested
@@ -66,11 +67,11 @@ func (fs *Filesystem) SafePath(p string) (string, error) {
 	// 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(p) {
-		return p, nil
+	if fs.unsafeIsInDataDirectory(ep) {
+		return ep, nil
 	}
 
-	return "", ErrBadPathResolution
+	return "", NewBadPathResolution(p, r)
 }
 
 // Generate a path to the file by cleaning it up and appending the root server path to it. This

server/filesystem/stat.go

@@ -1,6 +1,7 @@
 package filesystem
 
 import (
+	"emperror.dev/errors"
 	"encoding/json"
 	"github.com/gabriel-vasile/mimetype"
 	"os"
@@ -50,14 +51,14 @@ func (fs *Filesystem) Stat(p string) (*Stat, error) {
 func (fs *Filesystem) unsafeStat(p string) (*Stat, error) {
 	s, err := os.Stat(p)
 	if err != nil {
-		return nil, err
+		return nil, errors.WithStackIf(err)
 	}
 
 	var m *mimetype.MIME
 	if !s.IsDir() {
 		m, err = mimetype.DetectFile(p)
 		if err != nil {
-			return nil, err
+			return nil, errors.WithStackIf(err)
 		}
 	}
 

server/install.go

@@ -4,12 +4,12 @@ import (
 	"bufio"
 	"bytes"
 	"context"
+	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/container"
 	"github.com/docker/docker/api/types/mount"
 	"github.com/docker/docker/client"
-	"github.com/pkg/errors"
 	"github.com/pterodactyl/wings/api"
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
@@ -90,7 +90,7 @@ func (s *Server) internalInstall() error {
 	script, err := api.New().GetInstallationScript(s.Id())
 	if err != nil {
 		if !api.IsRequestError(err) {
-			return errors.WithStack(err)
+			return errors.WithStackIf(err)
 		}
 
 		return errors.New(err.Error())
@@ -98,7 +98,7 @@ func (s *Server) internalInstall() error {
 
 	p, err := NewInstallationProcess(s, &script)
 	if err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	s.Log().Info("beginning installation process for server")
@@ -130,7 +130,7 @@ func NewInstallationProcess(s *Server, script *api.InstallationScript) (*Install
 	s.installer.cancel = &cancel
 
 	if c, err := environment.DockerClient(); err != nil {
-		return nil, errors.WithStack(err)
+		return nil, errors.WithStackIf(err)
 	} else {
 		proc.client = c
 		proc.context = ctx
@@ -193,7 +193,7 @@ func (ip *InstallationProcess) RemoveContainer() {
 	})
 
 	if err != nil && !client.IsErrNotFound(err) {
-		ip.Server.Log().WithField("error", errors.WithStack(err)).Warn("failed to delete server install container")
+		ip.Server.Log().WithField("error", errors.WithStackIf(err)).Warn("failed to delete server install container")
 	}
 }
 
@@ -218,14 +218,14 @@ func (ip *InstallationProcess) Run() error {
 	}()
 
 	if err := ip.BeforeExecute(); err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	cid, err := ip.Execute()
 	if err != nil {
 		ip.RemoveContainer()
 
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	// If this step fails, log a warning but don't exit out of the process. This is completely
@@ -248,12 +248,12 @@ func (ip *InstallationProcess) writeScriptToDisk() error {
 	// Make sure the temp directory root exists before trying to make a directory within it. The
 	// ioutil.TempDir call expects this base to exist, it won't create it for you.
 	if err := os.MkdirAll(ip.tempDir(), 0700); err != nil {
-		return errors.Wrap(err, "could not create temporary directory for install process")
+		return errors.WrapIf(err, "could not create temporary directory for install process")
 	}
 
 	f, err := os.OpenFile(filepath.Join(ip.tempDir(), "install.sh"), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
 	if err != nil {
-		return errors.Wrap(err, "failed to write server installation script to disk before mount")
+		return errors.WrapIf(err, "failed to write server installation script to disk before mount")
 	}
 	defer f.Close()
 
@@ -265,7 +265,7 @@ func (ip *InstallationProcess) writeScriptToDisk() error {
 	}
 
 	if err := scanner.Err(); err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	w.Flush()
@@ -277,7 +277,7 @@ func (ip *InstallationProcess) writeScriptToDisk() error {
 func (ip *InstallationProcess) pullInstallationImage() error {
 	r, err := ip.client.ImagePull(ip.context, ip.Script.ContainerImage, types.ImagePullOptions{})
 	if err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	// Block continuation until the image has been pulled successfully.
@@ -287,7 +287,7 @@ func (ip *InstallationProcess) pullInstallationImage() error {
 	}
 
 	if err := scanner.Err(); err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	return nil
@@ -298,11 +298,11 @@ func (ip *InstallationProcess) pullInstallationImage() error {
 // manner, if either one fails the error is returned.
 func (ip *InstallationProcess) BeforeExecute() error {
 	if err := ip.writeScriptToDisk(); err != nil {
-		return errors.Wrap(err, "failed to write installation script to disk")
+		return errors.WrapIf(err, "failed to write installation script to disk")
 	}
 
 	if err := ip.pullInstallationImage(); err != nil {
-		return errors.Wrap(err, "failed to pull updated installation container image for server")
+		return errors.WrapIf(err, "failed to pull updated installation container image for server")
 	}
 
 	opts := types.ContainerRemoveOptions{
@@ -312,7 +312,7 @@ func (ip *InstallationProcess) BeforeExecute() error {
 
 	if err := ip.client.ContainerRemove(ip.context, ip.Server.Id()+"_installer", opts); err != nil {
 		if !client.IsErrNotFound(err) {
-			return errors.Wrap(err, "failed to remove existing install container for server")
+			return errors.WrapIf(err, "failed to remove existing install container for server")
 		}
 	}
 
@@ -338,12 +338,12 @@ func (ip *InstallationProcess) AfterExecute(containerId string) error {
 	})
 
 	if err != nil && !client.IsErrNotFound(err) {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	f, err := os.OpenFile(ip.GetLogPath(), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
 	if err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 	defer f.Close()
 
@@ -372,15 +372,15 @@ func (ip *InstallationProcess) AfterExecute(containerId string) error {
 | ------------------------------
 `)
 	if err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	if err := tmpl.Execute(f, ip); err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	if _, err := io.Copy(f, reader); err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	return nil
@@ -448,7 +448,7 @@ func (ip *InstallationProcess) Execute() (string, error) {
 
 	r, err := ip.client.ContainerCreate(ip.context, conf, hostConf, nil, ip.Server.Id()+"_installer")
 	if err != nil {
-		return "", errors.WithStack(err)
+		return "", errors.WithStackIf(err)
 	}
 
 	ip.Server.Log().WithField("container_id", r.ID).Info("running installation script for server in container")
@@ -468,7 +468,7 @@ func (ip *InstallationProcess) Execute() (string, error) {
 	select {
 	case err := <-eChan:
 		if err != nil {
-			return "", errors.WithStack(err)
+			return "", errors.WithStackIf(err)
 		}
 	case <-sChan:
 	}
@@ -487,7 +487,7 @@ func (ip *InstallationProcess) StreamOutput(id string) error {
 	})
 
 	if err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	defer reader.Close()
@@ -500,7 +500,7 @@ func (ip *InstallationProcess) StreamOutput(id string) error {
 	if err := s.Err(); err != nil {
 		ip.Server.Log().WithFields(log.Fields{
 			"container_id": id,
-			"error":        errors.WithStack(err),
+			"error":        errors.WithStackIf(err),
 		}).Warn("error processing scanner line in installation output for server")
 	}
 
@@ -515,7 +515,7 @@ func (s *Server) SyncInstallState(successful bool) error {
 	err := api.New().SendInstallationStatus(s.Id(), successful)
 	if err != nil {
 		if !api.IsRequestError(err) {
-			return errors.WithStack(err)
+			return errors.WithStackIf(err)
 		}
 
 		return errors.New(err.Error())

server/listeners.go

@@ -1,9 +1,9 @@
 package server
 
 import (
+	"emperror.dev/errors"
 	"encoding/json"
 	"github.com/apex/log"
-	"github.com/pkg/errors"
 	"github.com/pterodactyl/wings/api"
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
@@ -77,7 +77,7 @@ func (s *Server) StartEventListeners() {
 							s.Environment.SetState(environment.ProcessRunningState)
 						}
 
-						s.Log().WithField("error", errors.WithStack(err)).Error("failed to terminate environment after triggering throttle")
+						s.Log().WithField("error", errors.WithStackIf(err)).Error("failed to terminate environment after triggering throttle")
 					}
 				}()
 			}
@@ -106,7 +106,7 @@ func (s *Server) StartEventListeners() {
 	stats := func(e events.Event) {
 		st := new(environment.Stats)
 		if err := json.Unmarshal([]byte(e.Data), st); err != nil {
-			s.Log().WithField("error", errors.WithStack(err)).Warn("failed to unmarshal server environment stats")
+			s.Log().WithField("error", errors.WithStackIf(err)).Warn("failed to unmarshal server environment stats")
 			return
 		}
 

server/loader.go

@@ -1,12 +1,12 @@
 package server
 
 import (
+	"emperror.dev/errors"
 	"encoding/json"
 	"fmt"
 	"github.com/apex/log"
 	"github.com/creasty/defaults"
 	"github.com/gammazero/workerpool"
-	"github.com/pkg/errors"
 	"github.com/pterodactyl/wings/api"
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
@@ -35,7 +35,7 @@ func LoadDirectory() error {
 	configs, err := api.New().GetServers()
 	if err != nil {
 		if !api.IsRequestError(err) {
-			return errors.WithStack(err)
+			return errors.WithStackIf(err)
 		}
 
 		return errors.New(err.Error())
@@ -89,12 +89,12 @@ func LoadDirectory() error {
 func FromConfiguration(data api.ServerConfigurationResponse) (*Server, error) {
 	cfg := Configuration{}
 	if err := defaults.Set(&cfg); err != nil {
-		return nil, errors.Wrap(err, "failed to set struct defaults for server configuration")
+		return nil, errors.WrapIf(err, "failed to set struct defaults for server configuration")
 	}
 
 	s := new(Server)
 	if err := defaults.Set(s); err != nil {
-		return nil, errors.Wrap(err, "failed to set struct defaults for server")
+		return nil, errors.WrapIf(err, "failed to set struct defaults for server")
 	}
 
 	s.cfg = cfg

server/power.go

@@ -2,7 +2,7 @@ package server
 
 import (
 	"context"
-	"github.com/pkg/errors"
+	"emperror.dev/errors"
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
 	"github.com/pterodactyl/wings/server/filesystem"
@@ -80,13 +80,13 @@ func (s *Server) HandlePowerAction(action PowerAction, waitSeconds ...int) error
 			// time than that passes an error will be propagated back up the chain and this
 			// request will be aborted.
 			if err := s.powerLock.Acquire(ctx, 1); err != nil {
-				return errors.Wrap(err, "could not acquire lock on power state")
+				return errors.WrapIf(err, "could not acquire lock on power state")
 			}
 		} else {
 			// If no wait duration was provided we will attempt to immediately acquire the lock
 			// and bail out with a context deadline error if it is not acquired immediately.
 			if ok := s.powerLock.TryAcquire(1); !ok {
-				return errors.Wrap(context.DeadlineExceeded, "could not acquire lock on power state")
+				return errors.WrapIf(context.DeadlineExceeded, "could not acquire lock on power state")
 			}
 		}
 
@@ -149,7 +149,7 @@ func (s *Server) HandlePowerAction(action PowerAction, waitSeconds ...int) error
 func (s *Server) onBeforeStart() error {
 	s.Log().Info("syncing server configuration with panel")
 	if err := s.Sync(); err != nil {
-		return errors.Wrap(err, "unable to sync server data from Panel instance")
+		return errors.WrapIf(err, "unable to sync server data from Panel instance")
 	}
 
 	// Disallow start & restart if the server is suspended. Do this check after performing a sync
@@ -185,7 +185,7 @@ func (s *Server) onBeforeStart() error {
 		s.PublishConsoleOutputFromDaemon("Ensuring file permissions are set correctly, this could take a few seconds...")
 		// Ensure all of the server file permissions are set correctly before booting the process.
 		if err := s.Filesystem().Chown("/"); err != nil {
-			return errors.Wrap(err, "failed to chown root server directory during pre-boot process")
+			return errors.WrapIf(err, "failed to chown root server directory during pre-boot process")
 		}
 	}
 

server/server.go

@@ -2,9 +2,9 @@ package server
 
 import (
 	"context"
+	"emperror.dev/errors"
 	"fmt"
 	"github.com/apex/log"
-	"github.com/pkg/errors"
 	"github.com/pterodactyl/wings/api"
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
@@ -115,7 +115,7 @@ func (s *Server) Sync() error {
 	cfg, err := api.New().GetServerConfiguration(s.Id())
 	if err != nil {
 		if !api.IsRequestError(err) {
-			return errors.WithStack(err)
+			return errors.WithStackIf(err)
 		}
 
 		if err.(*api.RequestError).Status == "404" {
@@ -131,7 +131,7 @@ func (s *Server) Sync() error {
 func (s *Server) SyncWithConfiguration(cfg api.ServerConfigurationResponse) error {
 	// Update the data structure and persist it to the disk.
 	if err := s.UpdateDataStructure(cfg.Settings); err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	s.Lock()
@@ -171,7 +171,7 @@ func (s *Server) IsBootable() bool {
 func (s *Server) CreateEnvironment() error {
 	// Ensure the data directory exists before getting too far through this process.
 	if err := s.EnsureDataDirectoryExists(); err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	return s.Environment.Create()

server/state.go

@@ -1,8 +1,8 @@
 package server
 
 import (
+	"emperror.dev/errors"
 	"encoding/json"
-	"github.com/pkg/errors"
 	"github.com/pterodactyl/wings/config"
 	"github.com/pterodactyl/wings/environment"
 	"io"
@@ -22,14 +22,14 @@ func CachedServerStates() (map[string]string, error) {
 	// Open the states file.
 	f, err := os.OpenFile(config.Get().System.GetStatesPath(), os.O_RDONLY|os.O_CREATE, 0644)
 	if err != nil {
-		return nil, errors.WithStack(err)
+		return nil, errors.WithStackIf(err)
 	}
 	defer f.Close()
 
 	// Convert the json object to a map.
 	states := map[string]string{}
 	if err := json.NewDecoder(f).Decode(&states); err != nil && err != io.EOF {
-		return nil, errors.WithStack(err)
+		return nil, errors.WithStackIf(err)
 	}
 
 	return states, nil
@@ -46,7 +46,7 @@ func saveServerStates() error {
 	// Convert the map to a json object.
 	data, err := json.Marshal(states)
 	if err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	stateMutex.Lock()
@@ -54,7 +54,7 @@ func saveServerStates() error {
 
 	// Write the data to the file
 	if err := ioutil.WriteFile(config.Get().System.GetStatesPath(), data, 0644); err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	return nil

server/update.go

@@ -1,10 +1,10 @@
 package server
 
 import (
+	"emperror.dev/errors"
 	"encoding/json"
 	"github.com/buger/jsonparser"
 	"github.com/imdario/mergo"
-	"github.com/pkg/errors"
 	"github.com/pterodactyl/wings/environment"
 )
 
@@ -18,7 +18,7 @@ import (
 func (s *Server) UpdateDataStructure(data []byte) error {
 	src := new(Configuration)
 	if err := json.Unmarshal(data, src); err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	// Don't allow obviously corrupted data to pass through into this function. If the UUID
@@ -47,7 +47,7 @@ func (s *Server) UpdateDataStructure(data []byte) error {
 	// Merge the new data object that we have received with the existing server data object
 	// and then save it to the disk so it is persistent.
 	if err := mergo.Merge(&c, src, mergo.WithOverride); err != nil {
-		return errors.WithStack(err)
+		return errors.WithStackIf(err)
 	}
 
 	// Don't explode if we're setting CPU limits to 0. Mergo sees that as an empty value
@@ -65,7 +65,7 @@ func (s *Server) UpdateDataStructure(data []byte) error {
 	// request is going to be boolean. Allegedly.
 	if v, err := jsonparser.GetBoolean(data, "container", "oom_disabled"); err != nil {
 		if err != jsonparser.KeyPathNotFoundError {
-			return errors.WithStack(err)
+			return errors.WithStackIf(err)
 		}
 	} else {
 		c.Build.OOMDisabled = v
@@ -74,7 +74,7 @@ func (s *Server) UpdateDataStructure(data []byte) error {
 	// Mergo also cannot handle this boolean value.
 	if v, err := jsonparser.GetBoolean(data, "suspended"); err != nil {
 		if err != jsonparser.KeyPathNotFoundError {
-			return errors.WithStack(err)
+			return errors.WithStackIf(err)
 		}
 	} else {
 		c.Suspended = v
@@ -82,7 +82,7 @@ func (s *Server) UpdateDataStructure(data []byte) error {
 
 	if v, err := jsonparser.GetBoolean(data, "skip_egg_scripts"); err != nil {
 		if err != jsonparser.KeyPathNotFoundError {
-			return errors.WithStack(err)
+			return errors.WithStackIf(err)
 		}
 	} else {
 		c.SkipEggScripts = v

server/websockets.go

@@ -7,7 +7,7 @@ import (
 )
 
 type WebsocketBag struct {
-	mu sync.Mutex
+	mu    sync.Mutex
 	conns map[uuid.UUID]*context.CancelFunc
 }
 
@@ -58,4 +58,4 @@ func (w *WebsocketBag) CancelAll() {
 
 	// Reset the connections.
 	w.conns = make(map[uuid.UUID]*context.CancelFunc)
-}
+}