websocket: remove channel buffers

Only attempt to close channels once, rather than per topic
they are subscribed to.

.github/workflows/docker.yml

@@ -34,7 +34,7 @@ jobs:
       - name: Get Build Information
         id: build_info
         run: |
-          echo "::set-output name=version_tag::${GITHUB_REF/refs\/tags\//}"
+          echo "::set-output name=version_tag::${GITHUB_REF/refs\/tags\/v/}"
           echo "::set-output name=short_sha::$(git rev-parse --short HEAD)"
       - name: Release Production Build
         uses: docker/build-push-action@v2

.github/workflows/release.yml

@@ -45,7 +45,7 @@ jobs:
           git config --local user.name "Pterodactyl CI"
           git checkout -b $BRANCH
           git push -u origin $BRANCH
-          sed -i "s/	Version = \".*\"/	Version = \"${REF:11}\"/" system/const.go
+          sed -i "s/var Version = \".*\"/var Version = \"${REF:11}\"/" system/const.go
           git add system/const.go
           git commit -m "bump version for release"
           git push

CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## v1.5.5
+### Fixed
+* Fixes sending to a closed channel when sending server logs over the websocket
+* Fixes `wings diagnostics` uploading no content
+* Fixes a panic caused by the event bus closing channels multiple times when a server is deleted
+
+## v1.5.4
+### Fixed
+* Fixes SSL paths being improperly converted to lowercase in environments where the path is case-sensitive.
+* Fixes a memory leak due to the implemention of server event processing.
+
+### Changed
+* Selecting to redact information now redacts URLs from the log output when running the diagnostic command.
+
+### Added
+* Adds support for modifying the default memory overhead percentages in environments where the shipped values are not adequate.
+* Adds support for sending the `Access-Control-Request-Private-Network` header in environments where Wings will be accessed over a private network. This is defaulted to `off`.
+
+## v1.5.3
+### Fixed
+* Fixes improper event registration and error handling during socket authentication that would cause the incorrect error message to be returned to the client, or no error in some scenarios. Event registration is now delayed until the socket is fully authenticated to ensure needless listeners are not registed.
+* Fixes dollar signs always being evaluated as environment variables with no way to escape them. They can now be escaped as `$$` which will transform into a single dollar sign.
+
+### Changed
+* A websocket connection to a server will be closed by Wings if there is a send error encountered and the client will be left to handle reconnections, rather than simply logging the error and continuing to listen for new events.
+
+## v1.5.2
+### Fixed
+* Fixes servers not properly re-syncing with the Panel if they are already running causing them to be hard-stopped when terminated, rather than stopped with the configured action.
+
+### Changed
+* Changes SFTP server implementation to use ED25519 server keys rather than deprecated SHA1 RSA keys.
+
+### Added
+* Adds server uptime output in the stats event emitted to the websocket.
+
 ## v1.5.1
 ### Added
 * Global configuration option for toggling server crash detection (`system.crash_detection.enabled`)

README.md

@@ -30,7 +30,7 @@ I would like to extend my sincere thanks to the following sponsors for helping f
 | [**Spill Hosting**](https://spillhosting.no/) | Spill Hosting is a Norwegian hosting service, which aims for inexpensive services on quality servers. Premium i9-9900K processors will run your game like a dream. |
 | [**DeinServerHost**](https://deinserverhost.de/) | DeinServerHost offers Dedicated, vps and Gameservers for many popular Games like Minecraft and Rust in Germany since 2013. |
 | [**HostBend**](https://hostbend.com/) | HostBend offers a variety of solutions for developers, students, and others who have a tight budget but don't want to compromise quality and support. |
-| [**Capitol Hosting Solutions**](https://capitolsolutions.cloud/) | CHS is *the* budget friendly hosting company for Australian and American gamers, offering a variety of plans from Web Hosting to Game Servers; Custom Solutions too! |
+| [**Capitol Hosting Solutions**](https://chs.gg/) | CHS is *the* budget friendly hosting company for Australian and American gamers, offering a variety of plans from Web Hosting to Game Servers; Custom Solutions too! |
 | [**ByteAnia**](https://byteania.com/?utm_source=pterodactyl) | ByteAnia offers the best performing and most affordable **Ryzen 5000 Series hosting** on the market for *unbeatable prices*! |
 | [**Aussie Server Hosts**](https://aussieserverhosts.com/) | No frills Australian Owned and operated High Performance Server hosting for some of the most demanding games serving Australia and New Zealand. |
 | [**VibeGAMES**](https://vibegames.net/) | VibeGAMES is a game server provider that specializes in DDOS protection for the games we offer. We have multiple locations in the US, Brazil, France, Germany, Singapore, Australia and South Africa.|

cmd/configure.go

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

cmd/diagnostics.go

@@ -6,7 +6,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"net/http"
 	"net/url"
 	"os/exec"
@@ -29,18 +28,18 @@ import (
 	"github.com/pterodactyl/wings/system"
 )
 
-const DefaultHastebinUrl = "https://ptero.co"
-const DefaultLogLines = 200
+const (
+	DefaultHastebinUrl = "https://ptero.co"
+	DefaultLogLines    = 200
+)
 
-var (
-	diagnosticsArgs struct {
+var diagnosticsArgs struct {
 	IncludeEndpoints   bool
 	IncludeLogs        bool
 	ReviewBeforeUpload bool
 	HastebinURL        string
 	LogLines           int
-	}
-)
+}
 
 func newDiagnosticsCommand() *cobra.Command {
 	command := &cobra.Command{
@@ -79,7 +78,7 @@ func diagnosticsCmdRun(cmd *cobra.Command, args []string) {
 		{
 			Name: "ReviewBeforeUpload",
 			Prompt: &survey.Confirm{
-				Message: "Do you want to review the collected data before uploading to hastebin.com?",
+				Message: "Do you want to review the collected data before uploading to " + diagnosticsArgs.HastebinURL + "?",
 				Help:    "The data, especially the logs, might contain sensitive information, so you should review it. You will be asked again if you want to upload.",
 				Default: true,
 			},
@@ -97,12 +96,12 @@ func diagnosticsCmdRun(cmd *cobra.Command, args []string) {
 	output := &strings.Builder{}
 	fmt.Fprintln(output, "Pterodactyl Wings - Diagnostics Report")
 	printHeader(output, "Versions")
-	fmt.Fprintln(output, "         wings:", system.Version)
+	fmt.Fprintln(output, "               Wings:", system.Version)
 	if dockerErr == nil {
-		fmt.Fprintln(output, "Docker:", dockerVersion.Version)
+		fmt.Fprintln(output, "              Docker:", dockerVersion.Version)
 	}
 	if v, err := kernel.GetKernelVersion(); err == nil {
-		fmt.Fprintln(output, "Kernel:", v)
+		fmt.Fprintln(output, "              Kernel:", v)
 	}
 	if os, err := operatingsystem.GetOperatingSystem(); err == nil {
 		fmt.Fprintln(output, "                  OS:", os)
@@ -110,7 +109,6 @@ func diagnosticsCmdRun(cmd *cobra.Command, args []string) {
 
 	printHeader(output, "Wings Configuration")
 	if err := config.FromFile(config.DefaultLocation); err != nil {
-
 	}
 	cfg := config.Get()
 	fmt.Fprintln(output, "      Panel Location:", redact(cfg.PanelLocation))
@@ -181,6 +179,17 @@ func diagnosticsCmdRun(cmd *cobra.Command, args []string) {
 		fmt.Fprintln(output, "Logs redacted.")
 	}
 
+	if !diagnosticsArgs.IncludeEndpoints {
+		s := output.String()
+		output.Reset()
+		s = strings.ReplaceAll(s, cfg.PanelLocation, "{redacted}")
+		s = strings.ReplaceAll(s, cfg.Api.Host, "{redacted}")
+		s = strings.ReplaceAll(s, cfg.Api.Ssl.CertificateFile, "{redacted}")
+		s = strings.ReplaceAll(s, cfg.Api.Ssl.KeyFile, "{redacted}")
+		s = strings.ReplaceAll(s, cfg.System.Sftp.Address, "{redacted}")
+		output.WriteString(s)
+	}
+
 	fmt.Println("\n---------------  generated report  ---------------")
 	fmt.Println(output.String())
 	fmt.Print("---------------   end of report    ---------------\n\n")
@@ -226,7 +235,7 @@ func uploadToHastebin(hbUrl, content string) (string, error) {
 		return "", err
 	}
 	pres := make(map[string]interface{})
-	body, err := ioutil.ReadAll(res.Body)
+	body, err := io.ReadAll(res.Body)
 	if err != nil {
 		fmt.Println("Failed to parse response.", err)
 		return "", err

cmd/root.go

@@ -214,7 +214,7 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 			//
 			// @see https://github.com/pterodactyl/panel/issues/2475
 			// @see https://github.com/pterodactyl/panel/issues/3358
-			ctx, cancel := context.WithTimeout(cmd.Context(), time.Second * 30)
+			ctx, cancel := context.WithTimeout(cmd.Context(), time.Second*30)
 			defer cancel()
 
 			r, err := s.Environment.IsRunning(ctx)
@@ -255,6 +255,13 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 				// state being tracked.
 				s.Environment.SetState(environment.ProcessOfflineState)
 			}
+
+			if state := s.Environment.State(); state == environment.ProcessStartingState || state == environment.ProcessRunningState {
+				s.Log().Debug("re-syncing server configuration for already running server")
+				if err := s.Sync(); err != nil {
+					s.Log().WithError(err).Error("failed to re-sync server configuration")
+				}
+			}
 		})
 	}
 
@@ -287,12 +294,12 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 
 	sys := config.Get().System
 	// Ensure the archive directory exists.
-	if err := os.MkdirAll(sys.ArchiveDirectory, 0755); err != nil {
+	if err := os.MkdirAll(sys.ArchiveDirectory, 0o755); err != nil {
 		log.WithField("error", err).Error("failed to create archive directory")
 	}
 
 	// Ensure the backup directory exists.
-	if err := os.MkdirAll(sys.BackupDirectory, 0755); err != nil {
+	if err := os.MkdirAll(sys.BackupDirectory, 0o755); err != nil {
 		log.WithField("error", err).Error("failed to create backup directory")
 	}
 
@@ -348,7 +355,7 @@ func rootCmdRun(cmd *cobra.Command, _ []string) {
 	// Check if main http server should run with TLS. Otherwise reset the TLS
 	// config on the server and then serve it over normal HTTP.
 	if api.Ssl.Enabled {
-		if err := s.ListenAndServeTLS(strings.ToLower(api.Ssl.CertificateFile), strings.ToLower(api.Ssl.KeyFile)); err != nil {
+		if err := s.ListenAndServeTLS(api.Ssl.CertificateFile, api.Ssl.KeyFile); err != nil {
 			log.WithFields(log.Fields{"auto_tls": false, "error": err}).Fatal("failed to configure HTTPS server")
 		}
 		return
@@ -385,7 +392,7 @@ func initConfig() {
 // in the code without having to pass around a logger instance.
 func initLogging() {
 	dir := config.Get().System.LogDirectory
-	if err := os.MkdirAll(path.Join(dir, "/install"), 0700); err != nil {
+	if err := os.MkdirAll(path.Join(dir, "/install"), 0o700); err != nil {
 		log2.Fatalf("cmd/root: failed to create install directory path: %s", err)
 	}
 	p := filepath.Join(dir, "/wings.log")

config/config.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"crypto/tls"
 	"fmt"
-	"io/ioutil"
 	"os"
 	"os/exec"
 	"os/user"
@@ -287,6 +286,12 @@ type Configuration struct {
 	// The Panel URL is automatically allowed, this is only needed for adding
 	// additional origins.
 	AllowedOrigins []string `json:"allowed_origins" yaml:"allowed_origins"`
+
+	// AllowCORSPrivateNetwork sets the `Access-Control-Request-Private-Network` header which
+	// allows client browsers to make requests to internal IP addresses over HTTP.  This setting
+	// is only required by users running Wings without SSL certificates and using internal IP
+	// addresses in order to connect. Most users should NOT enable this setting.
+	AllowCORSPrivateNetwork bool `json:"allow_cors_private_network" yaml:"allow_cors_private_network"`
 }
 
 // NewAtPath creates a new struct and set the path where it should be stored.
@@ -380,7 +385,7 @@ func WriteToDisk(c *Configuration) error {
 	if err != nil {
 		return err
 	}
-	if err := ioutil.WriteFile(c.path, b, 0o600); err != nil {
+	if err := os.WriteFile(c.path, b, 0o600); err != nil {
 		return err
 	}
 	return nil
@@ -448,7 +453,7 @@ func EnsurePterodactylUser() error {
 // FromFile reads the configuration from the provided file and stores it in the
 // global singleton for this instance.
 func FromFile(path string) error {
-	b, err := ioutil.ReadFile(path)
+	b, err := os.ReadFile(path)
 	if err != nil {
 		return err
 	}
@@ -456,18 +461,17 @@ func FromFile(path string) error {
 	if err != nil {
 		return err
 	}
-	// Replace environment variables within the configuration file with their
-	// values from the host system.
-	b = []byte(os.ExpandEnv(string(b)))
+
 	if err := yaml.Unmarshal(b, c); err != nil {
 		return err
 	}
+
 	// Store this configuration in the global state.
 	Set(c)
 	return nil
 }
 
-// ConfigureDirectories ensures that all of the system directories exist on the
+// ConfigureDirectories ensures that all the system directories exist on the
 // system. These directories are created so that only the owner can read the data,
 // and no other users.
 //
@@ -579,7 +583,7 @@ func ConfigureTimezone() error {
 		_config.System.Timezone = tz
 	}
 	if _config.System.Timezone == "" {
-		b, err := ioutil.ReadFile("/etc/timezone")
+		b, err := os.ReadFile("/etc/timezone")
 		if err != nil {
 			if !os.IsNotExist(err) {
 				return errors.WithMessage(err, "config: failed to open timezone file")

config/config_docker.go

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

environment/allocations.go

@@ -31,7 +31,7 @@ type Allocations struct {
 //
 // You'll want to use DockerBindings() if you need to re-map 127.0.0.1 to the Docker interface.
 func (a *Allocations) Bindings() nat.PortMap {
-	var out = nat.PortMap{}
+	out := nat.PortMap{}
 
 	for ip, ports := range a.Mappings {
 		for _, port := range ports {
@@ -94,7 +94,7 @@ func (a *Allocations) DockerBindings() nat.PortMap {
 // To accomplish this, we'll just get the values from "DockerBindings" and then set them
 // to empty structs. Because why not.
 func (a *Allocations) Exposed() nat.PortSet {
-	var out = nat.PortSet{}
+	out := nat.PortSet{}
 
 	for port := range a.DockerBindings() {
 		out[port] = struct{}{}

environment/docker.go

@@ -14,8 +14,10 @@ import (
 	"github.com/pterodactyl/wings/config"
 )
 
-var _conce sync.Once
-var _client *client.Client
+var (
+	_conce  sync.Once
+	_client *client.Client
+)
 
 // Docker returns a docker client to be used throughout the codebase. Once a
 // client has been created it will be returned for all subsequent calls to this

environment/docker/container.go

@@ -175,7 +175,7 @@ func (e *Environment) Create() error {
 	conf := &container.Config{
 		Hostname:     e.Id,
 		Domainname:   config.Get().Docker.Domainname,
-		User:         strconv.Itoa(config.Get().System.User.Uid),
+		User:         strconv.Itoa(config.Get().System.User.Uid) + ":" + strconv.Itoa(config.Get().System.User.Gid),
 		AttachStdin:  true,
 		AttachStdout: true,
 		AttachStderr: true,
@@ -342,10 +342,10 @@ func (e *Environment) followOutput() error {
 func (e *Environment) scanOutput(reader io.ReadCloser) {
 	defer reader.Close()
 
-	events := e.Events()
-
-	if err := system.ScanReader(reader, func(line string) {
-		events.Publish(environment.ConsoleOutputEvent, line)
+	if err := system.ScanReader(reader, func(v []byte) {
+		e.logCallbackMx.Lock()
+		defer e.logCallbackMx.Unlock()
+		e.logCallback(v)
 	}); err != nil && err != io.EOF {
 		log.WithField("error", err).WithField("container_id", e.Id).Warn("error processing scanner line in console output")
 		return

environment/docker/environment.go

@@ -49,7 +49,10 @@ type Environment struct {
 	// Holds the stats stream used by the polling commands so that we can easily close it out.
 	stats io.ReadCloser
 
-	emitter *events.EventBus
+	emitter *events.Bus
+
+	logCallbackMx sync.Mutex
+	logCallback   func([]byte)
 
 	// Tracks the environment state.
 	st *system.AtomicString
@@ -100,9 +103,9 @@ func (e *Environment) IsAttached() bool {
 	return e.stream != nil
 }
 
-func (e *Environment) Events() *events.EventBus {
+func (e *Environment) Events() *events.Bus {
 	e.eventMu.Do(func() {
-		e.emitter = events.New()
+		e.emitter = events.NewBus()
 	})
 
 	return e.emitter
@@ -114,7 +117,6 @@ func (e *Environment) Events() *events.EventBus {
 // ID auto-assigned when the container is created.
 func (e *Environment) Exists() (bool, error) {
 	_, err := e.client.ContainerInspect(context.Background(), e.Id)
-
 	if err != nil {
 		// If this error is because the container instance wasn't found via Docker we
 		// can safely ignore the error and just return false.
@@ -215,3 +217,10 @@ func (e *Environment) SetState(state string) {
 		e.Events().Publish(environment.StateChangeEvent, state)
 	}
 }
+
+func (e *Environment) SetLogCallback(f func([]byte)) {
+	e.logCallbackMx.Lock()
+	defer e.logCallbackMx.Unlock()
+
+	e.logCallback = f
+}

environment/docker/stats.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"io"
 	"math"
+	"time"
 
 	"emperror.dev/errors"
 	"github.com/docker/docker/api/types"
@@ -12,6 +13,23 @@ import (
 	"github.com/pterodactyl/wings/environment"
 )
 
+// Uptime returns the current uptime of the container in milliseconds. If the
+// container is not currently running this will return 0.
+func (e *Environment) Uptime(ctx context.Context) (int64, error) {
+	ins, err := e.client.ContainerInspect(ctx, e.Id)
+	if err != nil {
+		return 0, errors.Wrap(err, "environment: could not inspect container")
+	}
+	if !ins.State.Running {
+		return 0, nil
+	}
+	started, err := time.Parse(time.RFC3339, ins.State.StartedAt)
+	if err != nil {
+		return 0, errors.Wrap(err, "environment: failed to parse container start time")
+	}
+	return time.Since(started).Milliseconds(), nil
+}
+
 // Attach to the instance and then automatically emit an event whenever the resource usage for the
 // server process changes.
 func (e *Environment) pollResources(ctx context.Context) error {
@@ -28,6 +46,11 @@ func (e *Environment) pollResources(ctx context.Context) error {
 	}
 	defer stats.Body.Close()
 
+	uptime, err := e.Uptime(ctx)
+	if err != nil {
+		e.log().WithField("error", err).Warn("failed to calculate container uptime")
+	}
+
 	dec := json.NewDecoder(stats.Body)
 	for {
 		select {
@@ -50,7 +73,12 @@ func (e *Environment) pollResources(ctx context.Context) error {
 				return nil
 			}
 
+			if !v.PreRead.IsZero() {
+				uptime = uptime + v.Read.Sub(v.PreRead).Milliseconds()
+			}
+
 			st := environment.Stats{
+				Uptime:      uptime,
 				Memory:      calculateDockerMemory(v.MemoryStats),
 				MemoryLimit: v.MemoryStats.Limit,
 				CpuAbsolute: calculateDockerAbsoluteCpu(v.PreCPUStats, v.CPUStats),
@@ -62,11 +90,7 @@ func (e *Environment) pollResources(ctx context.Context) error {
 				st.Network.TxBytes += nw.TxBytes
 			}
 
-			if b, err := json.Marshal(st); err != nil {
-				e.log().WithField("error", err).Warn("error while marshaling stats object for environment")
-			} else {
-				e.Events().Publish(environment.ResourceEvent, string(b))
-			}
+			e.Events().Publish(environment.ResourceEvent, st)
 		}
 	}
 }

environment/environment.go

@@ -8,7 +8,6 @@ import (
 )
 
 const (
-	ConsoleOutputEvent       = "console output"
 	StateChangeEvent         = "state change"
 	ResourceEvent            = "resources"
 	DockerImagePullStarted   = "docker image pull started"
@@ -35,7 +34,7 @@ type ProcessEnvironment interface {
 	// Returns an event emitter instance that can be hooked into to listen for different
 	// events that are fired by the environment. This should not allow someone to publish
 	// events, only subscribe to them.
-	Events() *events.EventBus
+	Events() *events.Bus
 
 	// Determines if the server instance exists. For example, in a docker environment
 	// this should confirm that the container is created and in a bootable state. In
@@ -104,4 +103,11 @@ type ProcessEnvironment interface {
 	// handle this itself, but there are some scenarios where it is helpful for the server
 	// to update the state externally (e.g. starting -> started).
 	SetState(string)
+
+	// Uptime returns the current environment uptime in milliseconds. This is
+	// the time that has passed since it was last started.
+	Uptime(ctx context.Context) (int64, error)
+
+	// SetLogCallback sets the callback that the container's log output will be passed to.
+	SetLogCallback(func([]byte))
 }

environment/settings.go

@@ -75,13 +75,7 @@ func (l Limits) ConvertedCpuLimit() int64 {
 // server is < 4G, use 10%, if less than 2G use 15%. This avoids unexpected
 // crashes from processes like Java which run over the limit.
 func (l Limits) MemoryOverheadMultiplier() float64 {
-	if l.MemoryLimit <= 2048 {
-		return 1.15
-	} else if l.MemoryLimit <= 4096 {
-		return 1.10
-	}
-
-	return 1.05
+	return config.Get().Docker.Overhead.GetMultiplier(l.MemoryLimit)
 }
 
 func (l Limits) BoundedMemoryLimit() int64 {

environment/stats.go

@@ -1,8 +1,6 @@
 package environment
 
-// Defines the current resource usage for a given server instance. If a server is offline you
-// should obviously expect memory and CPU usage to be 0. However, disk will always be returned
-// since that is not dependent on the server being running to collect that data.
+// Stats defines the current resource usage for a given server instance.
 type Stats struct {
 	// The total amount of memory, in bytes, that this server instance is consuming. This is
 	// calculated slightly differently than just using the raw Memory field that the stats
@@ -19,12 +17,11 @@ type Stats struct {
 	// does not take into account any limits on the server process itself.
 	CpuAbsolute float64 `json:"cpu_absolute"`
 
-	// The current disk space being used by the server. This is cached to prevent slow lookup
-	// issues on frequent refreshes.
-	// Disk int64 `json:"disk_bytes"`
-
 	// Current network transmit in & out for a container.
 	Network NetworkStats `json:"network"`
+
+	// The current uptime of the container, in milliseconds.
+	Uptime int64 `json:"uptime"`
 }
 
 type NetworkStats struct {

events/events.go

@@ -1,32 +1,85 @@
 package events
 
 import (
-	"encoding/json"
 	"strings"
 	"sync"
-
-	"github.com/gammazero/workerpool"
 )
 
+type Listener chan Event
+
+// Event represents an Event sent over a Bus.
 type Event struct {
-	Data  string
 	Topic string
+	Data  interface{}
 }
 
-type EventBus struct {
-	mu    sync.RWMutex
-	pools map[string]*CallbackPool
+// Bus represents an Event Bus.
+type Bus struct {
+	listenersMx sync.Mutex
+	listeners   map[string][]Listener
 }
 
-func New() *EventBus {
-	return &EventBus{
-		pools: make(map[string]*CallbackPool),
+// NewBus returns a new empty Event Bus.
+func NewBus() *Bus {
+	return &Bus{
+		listeners: make(map[string][]Listener),
 	}
 }
 
-// Publish data to a given topic.
-func (e *EventBus) Publish(topic string, data string) {
-	t := topic
+// Off unregisters a listener from the specified topics on the Bus.
+func (b *Bus) Off(listener Listener, topics ...string) {
+	b.listenersMx.Lock()
+	defer b.listenersMx.Unlock()
+
+	var closed bool
+
+	for _, topic := range topics {
+		ok := b.off(topic, listener)
+		if !closed && ok {
+			close(listener)
+			closed = true
+		}
+	}
+}
+
+func (b *Bus) off(topic string, listener Listener) bool {
+	listeners, ok := b.listeners[topic]
+	if !ok {
+		return false
+	}
+	for i, l := range listeners {
+		if l != listener {
+			continue
+		}
+
+		listeners = append(listeners[:i], listeners[i+1:]...)
+		b.listeners[topic] = listeners
+		return true
+	}
+	return false
+}
+
+// On registers a listener to the specified topics on the Bus.
+func (b *Bus) On(listener Listener, topics ...string) {
+	b.listenersMx.Lock()
+	defer b.listenersMx.Unlock()
+
+	for _, topic := range topics {
+		b.on(topic, listener)
+	}
+}
+
+func (b *Bus) on(topic string, listener Listener) {
+	listeners, ok := b.listeners[topic]
+	if !ok {
+		b.listeners[topic] = []Listener{listener}
+	} else {
+		b.listeners[topic] = append(listeners, listener)
+	}
+}
+
+// Publish publishes a message to the Bus.
+func (b *Bus) Publish(topic string, data interface{}) {
 	// Some of our topics for the socket support passing a more specific namespace,
 	// such as "backup completed:1234" to indicate which specific backup was completed.
 	//
@@ -36,87 +89,59 @@ func (e *EventBus) Publish(topic string, data string) {
 		parts := strings.SplitN(topic, ":", 2)
 
 		if len(parts) == 2 {
-			t = parts[0]
+			topic = parts[0]
 		}
 	}
 
-	e.mu.RLock()
-	defer e.mu.RUnlock()
+	b.listenersMx.Lock()
+	defer b.listenersMx.Unlock()
 
-	// Acquire a read lock and loop over all the channels registered for the topic. This
-	// avoids a panic crash if the process tries to unregister the channel while this routine
-	// is running.
-	if cp, ok := e.pools[t]; ok {
-		for _, callback := range cp.callbacks {
-			c := *callback
-			evt := Event{Data: data, Topic: topic}
-			// Using the workerpool with one worker allows us to execute events in a FIFO manner. Running
-			// this using goroutines would cause things such as console output to just output in random order
-			// if more than one event is fired at the same time.
-			//
-			// However, the pool submission does not block the execution of this function itself, allowing
-			// us to call publish without blocking any of the other pathways.
-			//
-			// @see https://github.com/pterodactyl/panel/issues/2303
-			cp.pool.Submit(func() {
-				c(evt)
-			})
+	listeners, ok := b.listeners[topic]
+	if !ok {
+		return
 	}
+	if len(listeners) < 1 {
+		return
+	}
+
+	event := Event{Topic: topic, Data: data}
+	for _, listener := range listeners {
+		l := listener
+		go func(l Listener, event Event) {
+			l <- event
+		}(l, event)
 	}
 }
 
-// PublishJson publishes a JSON message to a given topic.
-func (e *EventBus) PublishJson(topic string, data interface{}) error {
-	b, err := json.Marshal(data)
-	if err != nil {
-		return err
+// Destroy destroys the Event Bus by unregistering and closing all listeners.
+func (b *Bus) Destroy() {
+	b.listenersMx.Lock()
+	defer b.listenersMx.Unlock()
+
+	// Track what listeners have already been closed. Because the same listener
+	// can be listening on multiple topics, we need a way to essentially
+	// "de-duplicate" all the listeners across all the topics.
+	var closed []Listener
+
+	for _, listeners := range b.listeners {
+		for _, listener := range listeners {
+			if contains(closed, listener) {
+				continue
 			}
 
-	e.Publish(topic, string(b))
+			close(listener)
+			closed = append(closed, listener)
+		}
+	}
 
-	return nil
+	b.listeners = make(map[string][]Listener)
 }
 
-// On adds a callback function that will be executed each time one of the events using the topic
-// name is called.
-func (e *EventBus) On(topic string, callback *func(Event)) {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-
-	// Check if this topic has been registered at least once for the event listener, and if
-	// not create an empty struct for the topic.
-	if _, exists := e.pools[topic]; !exists {
-		e.pools[topic] = &CallbackPool{
-			callbacks: make([]*func(Event), 0),
-			pool:      workerpool.New(1),
+func contains(closed []Listener, listener Listener) bool {
+	for _, c := range closed {
+		if c == listener {
+			return true
 		}
 	}
-
-	// If this callback is not already registered as an event listener, go ahead and append
-	// it to the array of callbacks for this topic.
-	e.pools[topic].Add(callback)
-}
-
-// Off removes an event listener from the bus.
-func (e *EventBus) Off(topic string, callback *func(Event)) {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-
-	if cp, ok := e.pools[topic]; ok {
-		cp.Remove(callback)
-	}
-}
-
-// Destroy removes all the event listeners that have been registered for any topic. Also stops the worker
-// pool to close that routine.
-func (e *EventBus) Destroy() {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-
-	// Stop every pool that exists for a given callback topic.
-	for _, cp := range e.pools {
-		cp.pool.Stop()
-	}
-
-	e.pools = make(map[string]*CallbackPool)
+	return false
 }

events/events_test.go

@@ -0,0 +1,225 @@
+package events
+
+import (
+	"testing"
+	"time"
+
+	. "github.com/franela/goblin"
+)
+
+func TestNewBus(t *testing.T) {
+	g := Goblin(t)
+	bus := NewBus()
+
+	g.Describe("NewBus", func() {
+		g.It("is not nil", func() {
+			g.Assert(bus).IsNotNil("Bus expected to not be nil")
+			g.Assert(bus.listeners).IsNotNil("Bus#listeners expected to not be nil")
+		})
+	})
+}
+
+func TestBus_Off(t *testing.T) {
+	g := Goblin(t)
+
+	const topic = "test"
+
+	g.Describe("Off", func() {
+		g.It("unregisters listener", func() {
+			bus := NewBus()
+
+			g.Assert(bus.listeners[topic]).IsNotNil()
+			g.Assert(len(bus.listeners[topic])).IsZero()
+			listener := make(chan Event)
+			bus.On(listener, topic)
+			g.Assert(len(bus.listeners[topic])).Equal(1, "Listener was not registered")
+
+			bus.Off(listener, topic)
+			g.Assert(len(bus.listeners[topic])).Equal(0, "Topic still has one or more listeners")
+		})
+
+		g.It("unregisters correct listener", func() {
+			bus := NewBus()
+
+			listener := make(chan Event)
+			listener2 := make(chan Event)
+			listener3 := make(chan Event)
+			bus.On(listener, topic)
+			bus.On(listener2, topic)
+			bus.On(listener3, topic)
+			g.Assert(len(bus.listeners[topic])).Equal(3, "Listeners were not registered")
+
+			bus.Off(listener, topic)
+			bus.Off(listener3, topic)
+			g.Assert(len(bus.listeners[topic])).Equal(1, "Expected 1 listener to remain")
+
+			if bus.listeners[topic][0] != listener2 {
+				// A normal Assert does not properly compare channels.
+				g.Fail("wrong listener unregistered")
+			}
+
+			// Cleanup
+			bus.Off(listener2, topic)
+		})
+	})
+}
+
+func TestBus_On(t *testing.T) {
+	g := Goblin(t)
+
+	const topic = "test"
+
+	g.Describe("On", func() {
+		g.It("registers listener", func() {
+			bus := NewBus()
+
+			g.Assert(bus.listeners[topic]).IsNotNil()
+			g.Assert(len(bus.listeners[topic])).IsZero()
+			listener := make(chan Event)
+			bus.On(listener, topic)
+			g.Assert(len(bus.listeners[topic])).Equal(1, "Listener was not registered")
+
+			if bus.listeners[topic][0] != listener {
+				// A normal Assert does not properly compare channels.
+				g.Fail("wrong listener registered")
+			}
+
+			// Cleanup
+			bus.Off(listener, topic)
+		})
+	})
+}
+
+func TestBus_Publish(t *testing.T) {
+	g := Goblin(t)
+
+	const topic = "test"
+	const message = "this is a test message!"
+
+	g.Describe("Publish", func() {
+		g.It("publishes message", func() {
+			bus := NewBus()
+
+			g.Assert(bus.listeners[topic]).IsNotNil()
+			g.Assert(len(bus.listeners[topic])).IsZero()
+			listener := make(chan Event)
+			bus.On(listener, topic)
+			g.Assert(len(bus.listeners[topic])).Equal(1, "Listener was not registered")
+
+			done := make(chan struct{}, 1)
+			go func() {
+				select {
+				case m := <-listener:
+					g.Assert(m.Topic).Equal(topic)
+					g.Assert(m.Data).Equal(message)
+				case <-time.After(1 * time.Second):
+					g.Fail("listener did not receive message in time")
+				}
+				done <- struct{}{}
+			}()
+			bus.Publish(topic, message)
+			<-done
+
+			// Cleanup
+			bus.Off(listener, topic)
+		})
+
+		g.It("publishes message to all listeners", func() {
+			bus := NewBus()
+
+			g.Assert(bus.listeners[topic]).IsNotNil()
+			g.Assert(len(bus.listeners[topic])).IsZero()
+			listener := make(chan Event)
+			listener2 := make(chan Event)
+			listener3 := make(chan Event)
+			bus.On(listener, topic)
+			bus.On(listener2, topic)
+			bus.On(listener3, topic)
+			g.Assert(len(bus.listeners[topic])).Equal(3, "Listener was not registered")
+
+			done := make(chan struct{}, 1)
+			go func() {
+				for i := 0; i < 3; i++ {
+					select {
+					case m := <-listener:
+						g.Assert(m.Topic).Equal(topic)
+						g.Assert(m.Data).Equal(message)
+					case m := <-listener2:
+						g.Assert(m.Topic).Equal(topic)
+						g.Assert(m.Data).Equal(message)
+					case m := <-listener3:
+						g.Assert(m.Topic).Equal(topic)
+						g.Assert(m.Data).Equal(message)
+					case <-time.After(1 * time.Second):
+						g.Fail("all listeners did not receive the message in time")
+						i = 3
+					}
+				}
+
+				done <- struct{}{}
+			}()
+			bus.Publish(topic, message)
+			<-done
+
+			// Cleanup
+			bus.Off(listener, topic)
+			bus.Off(listener2, topic)
+			bus.Off(listener3, topic)
+		})
+	})
+}
+
+func TestBus_Destroy(t *testing.T) {
+	g := Goblin(t)
+
+	g.Describe("Destroy", func() {
+		g.It("unsubscribes and closes all listeners", func() {
+			bus := NewBus()
+
+			listener := make(chan Event)
+			bus.On(listener, "test")
+
+			done := make(chan struct{}, 1)
+			go func() {
+				select {
+				case m := <-listener:
+					g.Assert(m).IsZero()
+				case <-time.After(1 * time.Second):
+					g.Fail("listener did not receive message in time")
+				}
+				done <- struct{}{}
+			}()
+			bus.Destroy()
+			<-done
+
+			g.Assert(bus.listeners).Equal(map[string][]Listener{})
+		})
+
+		// This is a check that ensures Destroy only closes each listener
+		// channel once, even if it is subscribed to multiple topics.
+		//
+		// Closing a channel multiple times will cause a runtime panic, which
+		// I'm pretty sure we don't want.
+		g.It("unsubscribes and closes channel only once", func() {
+			bus := NewBus()
+
+			listener := make(chan Event)
+			bus.On(listener, "test", "test2", "test3", "test4", "test5")
+
+			done := make(chan struct{}, 1)
+			go func() {
+				select {
+				case m := <-listener:
+					g.Assert(m).IsZero()
+				case <-time.After(1 * time.Second):
+					g.Fail("listener did not receive message in time")
+				}
+				done <- struct{}{}
+			}()
+			bus.Destroy()
+			<-done
+
+			g.Assert(bus.listeners).Equal(map[string][]Listener{})
+		})
+	})
+}

events/pool.go

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

go.mod

@@ -1,22 +1,18 @@
 module github.com/pterodactyl/wings
 
-go 1.16
+go 1.17
 
 require (
 	emperror.dev/errors v0.8.0
 	github.com/AlecAivazis/survey/v2 v2.2.15
 	github.com/Jeffail/gabs/v2 v2.6.1
-	github.com/Microsoft/go-winio v0.5.0 // indirect
-	github.com/Microsoft/hcsshim v0.8.20 // indirect
 	github.com/NYTimes/logrotate v1.0.0
-	github.com/andybalholm/brotli v1.0.3 // indirect
 	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/buger/jsonparser v1.1.1
 	github.com/cenkalti/backoff/v4 v4.1.1
 	github.com/cobaugh/osrelease v0.0.0-20181218015638-a93a0a55a249
-	github.com/containerd/containerd v1.5.5 // indirect
 	github.com/creasty/defaults v1.5.1
 	github.com/docker/docker v20.10.7+incompatible
 	github.com/docker/go-connections v0.4.0
@@ -26,48 +22,94 @@ require (
 	github.com/gammazero/workerpool v1.1.2
 	github.com/gbrlsnchs/jwt/v3 v3.0.1
 	github.com/gin-gonic/gin v1.7.2
-	github.com/go-playground/validator/v10 v10.8.0 // indirect
-	github.com/golang/snappy v0.0.4 // indirect
 	github.com/google/uuid v1.3.0
-	github.com/gorilla/mux v1.7.4 // indirect
 	github.com/gorilla/websocket v1.4.2
 	github.com/iancoleman/strcase v0.2.0
 	github.com/icza/dyno v0.0.0-20210726202311-f1bafe5d9996
-	github.com/imdario/mergo v0.3.12
 	github.com/juju/ratelimit v1.0.1
 	github.com/karrick/godirwalk v1.16.1
-	github.com/klauspost/compress v1.13.2 // indirect
 	github.com/klauspost/pgzip v1.2.5
-	github.com/magefile/mage v1.11.0 // indirect
 	github.com/magiconair/properties v1.8.5
 	github.com/mattn/go-colorable v0.1.8
-	github.com/mattn/go-isatty v0.0.13 // indirect
-	github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d // indirect
 	github.com/mholt/archiver/v3 v3.5.0
 	github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db
-	github.com/moby/term v0.0.0-20210619224110-3f7ff695adc6 // indirect
-	github.com/morikuni/aec v1.0.0 // indirect
-	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
-	github.com/nwaples/rardecode v1.1.1 // indirect
 	github.com/patrickmn/go-cache v2.1.0+incompatible
-	github.com/pierrec/lz4/v4 v4.1.8 // indirect
 	github.com/pkg/profile v1.6.0
 	github.com/pkg/sftp v1.13.2
-	github.com/prometheus/common v0.30.0 // indirect
-	github.com/prometheus/procfs v0.7.1 // indirect
 	github.com/sabhiram/go-gitignore v0.0.0-20201211210132-54b8a0bf510f
 	github.com/spf13/cobra v1.2.1
 	github.com/stretchr/testify v1.7.0
-	github.com/ulikunitz/xz v0.5.10 // indirect
-	go.uber.org/atomic v1.9.0 // indirect
-	go.uber.org/multierr v1.7.0 // indirect
 	golang.org/x/crypto v0.0.0-20210711020723-a769d52b0f97
-	golang.org/x/net v0.0.0-20210726213435-c6fcb2dbf985 // indirect
 	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
-	golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b // indirect
-	golang.org/x/time v0.0.0-20210723032227-1f47c861a9ac // indirect
-	google.golang.org/genproto v0.0.0-20210729151513-df9385d47c1b // indirect
-	gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f // indirect
 	gopkg.in/ini.v1 v1.62.0
 	gopkg.in/yaml.v2 v2.4.0
 )
+
+require (
+	github.com/Azure/go-ansiterm v0.0.0-20210617225240-d185dfc1b5a1 // indirect
+	github.com/Microsoft/go-winio v0.5.0 // indirect
+	github.com/Microsoft/hcsshim v0.8.20 // indirect
+	github.com/andybalholm/brotli v1.0.3 // indirect
+	github.com/beorn7/perks v1.0.1 // indirect
+	github.com/cespare/xxhash/v2 v2.1.1 // indirect
+	github.com/containerd/containerd v1.5.5 // indirect
+	github.com/containerd/fifo v1.0.0 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/docker/distribution v2.7.1+incompatible // indirect
+	github.com/docker/go-metrics v0.0.1 // indirect
+	github.com/docker/go-units v0.4.0 // indirect
+	github.com/dsnet/compress v0.0.1 // indirect
+	github.com/fsnotify/fsnotify v1.4.9 // indirect
+	github.com/gammazero/deque v0.1.0 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/go-playground/locales v0.13.0 // indirect
+	github.com/go-playground/universal-translator v0.17.0 // indirect
+	github.com/go-playground/validator/v10 v10.8.0 // indirect
+	github.com/gogo/protobuf v1.3.2 // indirect
+	github.com/golang/protobuf v1.5.2 // indirect
+	github.com/golang/snappy v0.0.4 // indirect
+	github.com/gorilla/mux v1.7.4 // indirect
+	github.com/inconshreveable/mousetrap v1.0.0 // indirect
+	github.com/json-iterator/go v1.1.11 // indirect
+	github.com/kballard/go-shellquote v0.0.0-20180428030007-95032a82bc51 // indirect
+	github.com/klauspost/compress v1.13.2 // indirect
+	github.com/kr/fs v0.1.0 // indirect
+	github.com/leodido/go-urn v1.2.1 // indirect
+	github.com/magefile/mage v1.11.0 // indirect
+	github.com/mattn/go-isatty v0.0.13 // indirect
+	github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 // indirect
+	github.com/mgutz/ansi v0.0.0-20200706080929-d51e80ef957d // indirect
+	github.com/moby/term v0.0.0-20210619224110-3f7ff695adc6 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.1 // indirect
+	github.com/morikuni/aec v1.0.0 // indirect
+	github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e // indirect
+	github.com/nwaples/rardecode v1.1.1 // indirect
+	github.com/opencontainers/go-digest v1.0.0 // indirect
+	github.com/opencontainers/image-spec v1.0.1 // indirect
+	github.com/pierrec/lz4/v4 v4.1.8 // indirect
+	github.com/pkg/errors v0.9.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/prometheus/client_golang v1.11.0 // indirect
+	github.com/prometheus/client_model v0.2.0 // indirect
+	github.com/prometheus/common v0.30.0 // indirect
+	github.com/prometheus/procfs v0.7.1 // indirect
+	github.com/sirupsen/logrus v1.8.1 // indirect
+	github.com/spf13/pflag v1.0.5 // indirect
+	github.com/ugorji/go/codec v1.1.7 // indirect
+	github.com/ulikunitz/xz v0.5.10 // indirect
+	github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8 // indirect
+	go.uber.org/atomic v1.9.0 // indirect
+	go.uber.org/multierr v1.7.0 // indirect
+	golang.org/x/net v0.0.0-20210726213435-c6fcb2dbf985 // indirect
+	golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c // indirect
+	golang.org/x/term v0.0.0-20210615171337-6886f2dfbf5b // indirect
+	golang.org/x/text v0.3.6 // indirect
+	golang.org/x/time v0.0.0-20210723032227-1f47c861a9ac // indirect
+	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
+	google.golang.org/genproto v0.0.0-20210729151513-df9385d47c1b // indirect
+	google.golang.org/grpc v1.39.0 // indirect
+	google.golang.org/protobuf v1.27.1 // indirect
+	gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f // indirect
+	gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b // indirect
+)

go.sum

@@ -513,8 +513,6 @@ github.com/imdario/mergo v0.3.5/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJ
 github.com/imdario/mergo v0.3.8/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=
 github.com/imdario/mergo v0.3.10/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH0dnCYA=
 github.com/imdario/mergo v0.3.11/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH0dnCYA=
-github.com/imdario/mergo v0.3.12 h1:b6R2BslTbIEToALKP7LxUvijTsNI9TAe80pLWN2g/HU=
-github.com/imdario/mergo v0.3.12/go.mod h1:jmQim1M+e3UYxmgPu/WyfjB3N3VflVyUjjjwH0dnCYA=
 github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
 github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
 github.com/j-keck/arping v0.0.0-20160618110441-2cf9dc699c56/go.mod h1:ymszkNOg6tORTn+6F6j+Jc8TOr5osrynvN6ivFWZ2GA=

loggers/cli/cli.go

@@ -15,9 +15,11 @@ import (
 	"github.com/mattn/go-colorable"
 )
 
-var Default = New(os.Stderr, true)
-var bold = color2.New(color2.Bold)
-var boldred = color2.New(color2.Bold, color2.FgRed)
+var (
+	Default = New(os.Stderr, true)
+	bold    = color2.New(color2.Bold)
+	boldred = color2.New(color2.Bold, color2.FgRed)
+)
 
 var Strings = [...]string{
 	log.DebugLevel: "DEBUG",

parser/helpers.go

@@ -2,7 +2,7 @@ package parser
 
 import (
 	"bytes"
-	"io/ioutil"
+	"io"
 	"os"
 	"regexp"
 	"strconv"
@@ -38,13 +38,13 @@ var xmlValueMatchRegex = regexp.MustCompile(`^\[([\w]+)='(.*)'\]$`)
 // Gets the []byte representation of a configuration file to be passed through to other
 // handler functions. If the file does not currently exist, it will be created.
 func readFileBytes(path string) ([]byte, error) {
-	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0644)
+	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0o644)
 	if err != nil {
 		return nil, err
 	}
 	defer file.Close()
 
-	return ioutil.ReadAll(file)
+	return io.ReadAll(file)
 }
 
 // Gets the value of a key based on the value type defined.

parser/parser.go

@@ -3,7 +3,6 @@ package parser
 import (
 	"bufio"
 	"encoding/json"
-	"io/ioutil"
 	"os"
 	"path/filepath"
 	"strconv"
@@ -212,7 +211,7 @@ func (f *ConfigurationFile) Parse(path string, internal bool) error {
 		}
 
 		b := strings.TrimSuffix(path, filepath.Base(path))
-		if err := os.MkdirAll(b, 0755); err != nil {
+		if err := os.MkdirAll(b, 0o755); err != nil {
 			return errors.WithMessage(err, "failed to create base directory for missing configuration file")
 		} else {
 			if _, err := os.Create(path); err != nil {
@@ -229,7 +228,7 @@ func (f *ConfigurationFile) Parse(path string, internal bool) error {
 // Parses an xml file.
 func (f *ConfigurationFile) parseXmlFile(path string) error {
 	doc := etree.NewDocument()
-	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0644)
+	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0o644)
 	if err != nil {
 		return err
 	}
@@ -322,7 +321,7 @@ func (f *ConfigurationFile) parseIniFile(path string) error {
 	// Ini package can't handle a non-existent file, so handle that automatically here
 	// by creating it if not exists. Then, immediately close the file since we will use
 	// other methods to write the new contents.
-	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0644)
+	file, err := os.OpenFile(path, os.O_CREATE|os.O_RDWR, 0o644)
 	if err != nil {
 		return err
 	}
@@ -334,7 +333,29 @@ func (f *ConfigurationFile) parseIniFile(path string) error {
 	}
 
 	for _, replacement := range f.Replace {
-		path := strings.SplitN(replacement.Match, ".", 2)
+		var (
+			path         []string
+			bracketDepth int
+			v            []int32
+		)
+		for _, c := range replacement.Match {
+			switch c {
+			case '[':
+				bracketDepth++
+			case ']':
+				bracketDepth--
+			case '.':
+				if bracketDepth > 0 || len(path) == 1 {
+					v = append(v, c)
+					continue
+				}
+				path = append(path, string(v))
+				v = v[:0]
+			default:
+				v = append(v, c)
+			}
+		}
+		path = append(path, string(v))
 
 		value, err := f.LookupConfigurationValue(replacement)
 		if err != nil {
@@ -387,7 +408,7 @@ func (f *ConfigurationFile) parseJsonFile(path string) error {
 	}
 
 	output := []byte(data.StringIndent("", "    "))
-	return ioutil.WriteFile(path, output, 0644)
+	return os.WriteFile(path, output, 0o644)
 }
 
 // Parses a yaml file and updates any matching key/value pairs before persisting
@@ -424,14 +445,14 @@ func (f *ConfigurationFile) parseYamlFile(path string) error {
 		return err
 	}
 
-	return ioutil.WriteFile(path, marshaled, 0644)
+	return os.WriteFile(path, marshaled, 0o644)
 }
 
 // Parses a text file using basic find and replace. This is a highly inefficient method of
 // scanning a file and performing a replacement. You should attempt to use anything other
 // than this function where possible.
 func (f *ConfigurationFile) parseTextFile(path string) error {
-	input, err := ioutil.ReadFile(path)
+	input, err := os.ReadFile(path)
 	if err != nil {
 		return err
 	}
@@ -449,7 +470,7 @@ func (f *ConfigurationFile) parseTextFile(path string) error {
 		}
 	}
 
-	if err := ioutil.WriteFile(path, []byte(strings.Join(lines, "\n")), 0644); err != nil {
+	if err := os.WriteFile(path, []byte(strings.Join(lines, "\n")), 0o644); err != nil {
 		return err
 	}
 
@@ -545,7 +566,7 @@ func (f *ConfigurationFile) parsePropertiesFile(path string) error {
 	}
 
 	// Open the file for writing.
-	w, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0644)
+	w, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0o644)
 	if err != nil {
 		return err
 	}

remote/errors.go

@@ -57,8 +57,7 @@ func (re *RequestError) StatusCode() int {
 	return re.response.StatusCode
 }
 
-type SftpInvalidCredentialsError struct {
-}
+type SftpInvalidCredentialsError struct{}
 
 func (ice SftpInvalidCredentialsError) Error() string {
 	return "the credentials provided were invalid"

remote/http.go

@@ -6,7 +6,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"net/http"
 	"strconv"
 	"strings"
@@ -224,9 +223,9 @@ func (r *Response) Read() ([]byte, error) {
 		return nil, errors.New("remote: attempting to read missing response")
 	}
 	if r.Response.Body != nil {
-		b, _ = ioutil.ReadAll(r.Response.Body)
+		b, _ = io.ReadAll(r.Response.Body)
 	}
-	r.Response.Body = ioutil.NopCloser(bytes.NewBuffer(b))
+	r.Response.Body = io.NopCloser(bytes.NewBuffer(b))
 	return b, nil
 }
 

remote/http_test.go

@@ -87,7 +87,6 @@ func TestPost(t *testing.T) {
 	}
 	c, _ := createTestClient(func(rw http.ResponseWriter, r *http.Request) {
 		assert.Equal(t, http.MethodPost, r.Method)
-
 	})
 	r, err := c.Post(context.Background(), "/test", test)
 	assert.NoError(t, err)

router/middleware/middleware.go

@@ -218,19 +218,29 @@ func CaptureErrors() gin.HandlerFunc {
 // SetAccessControlHeaders sets the access request control headers on all of
 // the requests.
 func SetAccessControlHeaders() gin.HandlerFunc {
-	origins := config.Get().AllowedOrigins
-	location := config.Get().PanelLocation
+	cfg := config.Get()
+	origins := cfg.AllowedOrigins
+	location := cfg.PanelLocation
+	allowPrivateNetwork := cfg.AllowCORSPrivateNetwork
 
 	return func(c *gin.Context) {
+		c.Header("Access-Control-Allow-Origin", location)
 		c.Header("Access-Control-Allow-Credentials", "true")
 		c.Header("Access-Control-Allow-Methods", "GET, POST, PATCH, PUT, DELETE, OPTIONS")
+		c.Header("Access-Control-Allow-Headers", "Accept, Accept-Encoding, Authorization, Cache-Control, Content-Type, Content-Length, Origin, X-Real-IP, X-CSRF-Token")
+
+		// CORS for Private Networks (RFC1918)
+		// @see https://developer.chrome.com/blog/private-network-access-update/?utm_source=devtools
+		if allowPrivateNetwork {
+			c.Header("Access-Control-Request-Private-Network", "true")
+		}
+
 		// Maximum age allowable under Chromium v76 is 2 hours, so just use that since
 		// anything higher will be ignored (even if other browsers do allow higher values).
 		//
 		// @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Max-Age#Directives
 		c.Header("Access-Control-Max-Age", "7200")
-		c.Header("Access-Control-Allow-Origin", location)
-		c.Header("Access-Control-Allow-Headers", "Accept, Accept-Encoding, Authorization, Cache-Control, Content-Type, Content-Length, Origin, X-Real-IP, X-CSRF-Token")
+
 		// Validate that the request origin is coming from an allowed origin. Because you
 		// cannot set multiple values here we need to see if the origin is one of the ones
 		// that we allow, and if so return it explicitly. Otherwise, just return the default

router/router_server.go

@@ -188,6 +188,8 @@ func deleteServer(c *gin.Context) {
 	// as well.
 	s.CtxCancel()
 	s.Events().Destroy()
+	s.LogSink().Destroy()
+	s.InstallSink().Destroy()
 	s.Websockets().CancelAll()
 
 	// Remove any pending remote file downloads for the server.

router/router_server_ws.go

@@ -24,12 +24,6 @@ var expectedCloseCodes = []int{
 func getServerWebsocket(c *gin.Context) {
 	manager := middleware.ExtractManager(c)
 	s, _ := manager.Get(c.Param("server"))
-	handler, err := websocket.GetHandler(s, c.Writer, c.Request)
-	if err != nil {
-		NewServerError(err, s).Abort(c)
-		return
-	}
-	defer handler.Connection.Close()
 
 	// Create a context that can be canceled when the user disconnects from this
 	// socket that will also cancel listeners running in separate threads. If the
@@ -38,10 +32,22 @@ func getServerWebsocket(c *gin.Context) {
 	ctx, cancel := context.WithCancel(c.Request.Context())
 	defer cancel()
 
+	handler, err := websocket.GetHandler(s, c.Writer, c.Request)
+	if err != nil {
+		NewServerError(err, s).Abort(c)
+		return
+	}
+	defer handler.Connection.Close()
+
 	// Track this open connection on the server so that we can close them all programmatically
 	// if the server is deleted.
 	s.Websockets().Push(handler.Uuid(), &cancel)
-	defer s.Websockets().Remove(handler.Uuid())
+	handler.Logger().Debug("opening connection to server websocket")
+
+	defer func() {
+		s.Websockets().Remove(handler.Uuid())
+		handler.Logger().Debug("closing connection to server websocket")
+	}()
 
 	// If the server is deleted we need to send a close message to the connected client
 	// so that they disconnect since there will be no more events sent along. Listen for
@@ -57,16 +63,13 @@ func getServerWebsocket(c *gin.Context) {
 		}
 	}()
 
-	go handler.ListenForServerEvents(ctx)
-	go handler.ListenForExpiration(ctx)
-
 	for {
 		j := websocket.Message{}
 
 		_, p, err := handler.Connection.ReadMessage()
 		if err != nil {
 			if ws.IsUnexpectedCloseError(err, expectedCloseCodes...) {
-				s.Log().WithField("error", err).Warn("error handling websocket message for server")
+				handler.Logger().WithField("error", err).Warn("error handling websocket message for server")
 			}
 			break
 		}
@@ -79,7 +82,7 @@ func getServerWebsocket(c *gin.Context) {
 		}
 
 		go func(msg websocket.Message) {
-			if err := handler.HandleInbound(msg); err != nil {
+			if err := handler.HandleInbound(ctx, msg); err != nil {
 				handler.SendErrorJson(msg, err)
 			}
 		}(j)

router/router_system.go

@@ -103,15 +103,17 @@ func postUpdateConfiguration(c *gin.Context) {
 	if err := c.BindJSON(&cfg); err != nil {
 		return
 	}
+
 	// Keep the SSL certificates the same since the Panel will send through Lets Encrypt
 	// default locations. However, if we picked a different location manually we don't
 	// want to override that.
 	//
 	// If you pass through manual locations in the API call this logic will be skipped.
 	if strings.HasPrefix(cfg.Api.Ssl.KeyFile, "/etc/letsencrypt/live/") {
-		cfg.Api.Ssl.KeyFile = strings.ToLower(config.Get().Api.Ssl.KeyFile)
-		cfg.Api.Ssl.CertificateFile = strings.ToLower(config.Get().Api.Ssl.CertificateFile)
+		cfg.Api.Ssl.KeyFile = config.Get().Api.Ssl.KeyFile
+		cfg.Api.Ssl.CertificateFile = config.Get().Api.Ssl.CertificateFile
 	}
+
 	// Try to write this new configuration to the disk before updating our global
 	// state with it.
 	if err := config.WriteToDisk(cfg); err != nil {

router/websocket/listeners.go

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

router/websocket/websocket.go

@@ -75,7 +75,7 @@ func NewTokenPayload(token []byte) (*tokens.WebsocketPayload, error) {
 	return &payload, nil
 }
 
-// Returns a new websocket handler using the context provided.
+// GetHandler returns a new websocket handler using the context provided.
 func GetHandler(s *server.Server, w http.ResponseWriter, r *http.Request) (*Handler, error) {
 	upgrader := websocket.Upgrader{
 		// Ensure that the websocket request is originating from the Panel itself,
@@ -116,18 +116,23 @@ func (h *Handler) Uuid() uuid.UUID {
 	return h.uuid
 }
 
-func (h *Handler) SendJson(v *Message) error {
+func (h *Handler) Logger() *log.Entry {
+	return log.WithField("subsystem", "websocket").
+		WithField("connection", h.Uuid().String()).
+		WithField("server", h.server.ID())
+}
+
+func (h *Handler) SendJson(v Message) error {
 	// Do not send JSON down the line if the JWT on the connection is not valid!
 	if err := h.TokenValid(); err != nil {
-		h.unsafeSendJson(Message{
+		_ = h.unsafeSendJson(Message{
 			Event: JwtErrorEvent,
 			Args:  []string{err.Error()},
 		})
 		return nil
 	}
 
-	j := h.GetJwt()
-	if j != nil {
+	if j := h.GetJwt(); j != nil {
 		// If we're sending installation output but the user does not have the required
 		// permissions to see the output, don't send it down the line.
 		if v.Event == server.InstallOutputEvent {
@@ -262,11 +267,18 @@ func (h *Handler) setJwt(token *tokens.WebsocketPayload) {
 	h.Unlock()
 }
 
+var actions = map[server.PowerAction]string{
+	server.PowerActionStart:     PermissionSendPowerStart,
+	server.PowerActionStop:      PermissionSendPowerStop,
+	server.PowerActionRestart:   PermissionSendPowerRestart,
+	server.PowerActionTerminate: PermissionSendPowerStop,
+}
+
 // HandleInbound handles an inbound socket request and route it to the proper action.
-func (h *Handler) HandleInbound(m Message) error {
+func (h *Handler) HandleInbound(ctx context.Context, m Message) error {
 	if m.Event != AuthenticationEvent {
 		if err := h.TokenValid(); err != nil {
-			h.unsafeSendJson(Message{
+			_ = h.unsafeSendJson(Message{
 				Event: JwtErrorEvent,
 				Args:  []string{err.Error()},
 			})
@@ -279,13 +291,6 @@ func (h *Handler) HandleInbound(m Message) error {
 		{
 			token, err := NewTokenPayload([]byte(strings.Join(m.Args, "")))
 			if err != nil {
-				// If the error says the JWT expired, send a token expired
-				// event and hopefully the client renews the token.
-				if err == jwt.ErrExpValidation {
-					h.SendJson(&Message{Event: TokenExpiredEvent})
-					return nil
-				}
-
 				return err
 			}
 
@@ -298,10 +303,7 @@ func (h *Handler) HandleInbound(m Message) error {
 			h.setJwt(token)
 
 			// Tell the client they authenticated successfully.
-			h.unsafeSendJson(Message{
-				Event: AuthenticationSuccessEvent,
-				Args:  []string{},
-			})
+			_ = h.unsafeSendJson(Message{Event: AuthenticationSuccessEvent})
 
 			// Check if the client was refreshing their authentication token
 			// instead of authenticating for the first time.
@@ -311,10 +313,15 @@ func (h *Handler) HandleInbound(m Message) error {
 				return nil
 			}
 
+			// Now that we've authenticated with the token and confirmed that we're not
+			// reconnecting to the socket, register the event listeners for the server and
+			// the token expiration.
+			h.registerListenerEvents(ctx)
+
 			// On every authentication event, send the current server status back
 			// to the client. :)
 			state := h.server.Environment.State()
-			h.SendJson(&Message{
+			_ = h.SendJson(Message{
 				Event: server.StatusEvent,
 				Args:  []string{state},
 			})
@@ -326,7 +333,7 @@ func (h *Handler) HandleInbound(m Message) error {
 					_ = h.server.Filesystem().HasSpaceAvailable(false)
 
 					b, _ := json.Marshal(h.server.Proc())
-					h.SendJson(&Message{
+					_ = h.SendJson(Message{
 						Event: server.StatsEvent,
 						Args:  []string{string(b)},
 					})
@@ -339,12 +346,6 @@ func (h *Handler) HandleInbound(m Message) error {
 		{
 			action := server.PowerAction(strings.Join(m.Args, ""))
 
-			actions := make(map[server.PowerAction]string)
-			actions[server.PowerActionStart] = PermissionSendPowerStart
-			actions[server.PowerActionStop] = PermissionSendPowerStop
-			actions[server.PowerActionRestart] = PermissionSendPowerRestart
-			actions[server.PowerActionTerminate] = PermissionSendPowerStop
-
 			// Check that they have permission to perform this action if it is needed.
 			if permission, exists := actions[action]; exists {
 				if !h.GetJwt().HasPermission(permission) {
@@ -356,7 +357,7 @@ func (h *Handler) HandleInbound(m Message) error {
 			if errors.Is(err, context.DeadlineExceeded) {
 				m, _ := h.GetErrorMessage("another power action is currently being processed for this server, please try again later")
 
-				h.SendJson(&Message{
+				_ = h.SendJson(Message{
 					Event: ErrorEvent,
 					Args:  []string{m},
 				})
@@ -368,7 +369,7 @@ func (h *Handler) HandleInbound(m Message) error {
 		}
 	case SendServerLogsEvent:
 		{
-			ctx, cancel := context.WithTimeout(context.Background(), time.Second * 5)
+			ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 			defer cancel()
 			if running, _ := h.server.Environment.IsRunning(ctx); !running {
 				return nil
@@ -380,7 +381,7 @@ func (h *Handler) HandleInbound(m Message) error {
 			}
 
 			for _, line := range logs {
-				h.SendJson(&Message{
+				_ = h.SendJson(Message{
 					Event: server.ConsoleOutputEvent,
 					Args:  []string{line},
 				})
@@ -391,7 +392,7 @@ func (h *Handler) HandleInbound(m Message) error {
 	case SendStatsEvent:
 		{
 			b, _ := json.Marshal(h.server.Proc())
-			h.SendJson(&Message{
+			_ = h.SendJson(Message{
 				Event: server.StatsEvent,
 				Args:  []string{string(b)},
 			})

rpm/ptero-wings.spec

@@ -1,5 +1,5 @@
 Name:       ptero-wings
-Version:    1.5.0
+Version:    1.5.3
 Release:    1%{?dist}
 Summary:    The server control plane for Pterodactyl Panel. Written from the ground-up with security, speed, and stability in mind.
 BuildArch:  x86_64
@@ -91,6 +91,13 @@ rm -rf /var/log/pterodactyl
 wings --version
 
 %changelog
+* Wed Oct 27 2021 Capitol Hosting Solutions Systems Engineering <syseng@chs.gg> - 1.5.3-1
+- specfile by Capitol Hosting Solutions, Upstream by Pterodactyl
+- Rebased for https://github.com/pterodactyl/wings/releases/tag/v1.5.3
+- Fixes improper event registration and error handling during socket authentication that would cause the incorrect error message to be returned to the client, or no error in some scenarios. Event registration is now delayed until the socket is fully authenticated to ensure needless listeners are not registed.
+- Fixes dollar signs always being evaluated as environment variables with no way to escape them. They can now be escaped as $$ which will transform into a single dollar sign.
+- A websocket connection to a server will be closed by Wings if there is a send error encountered and the client will be left to handle reconnections, rather than simply logging the error and continuing to listen for new events.
+
 * Sun Sep 12 2021 Capitol Hosting Solutions Systems Engineering <syseng@chs.gg> - 1.5.0-1
 - specfile by Capitol Hosting Solutions, Upstream by Pterodactyl
 - Rebased for https://github.com/pterodactyl/wings/releases/tag/v1.5.0

server/backup.go

@@ -3,7 +3,6 @@ package server
 import (
 	"io"
 	"io/fs"
-	"io/ioutil"
 	"os"
 	"time"
 
@@ -49,7 +48,7 @@ func (s *Server) getServerwideIgnoredFiles() (string, error) {
 		// Don't read a symlinked ignore file, or a file larger than 32KiB in size.
 		return "", nil
 	}
-	b, err := ioutil.ReadAll(f)
+	b, err := io.ReadAll(f)
 	if err != nil {
 		return "", err
 	}
@@ -80,7 +79,7 @@ func (s *Server) Backup(b backup.BackupInterface) error {
 			s.Log().WithField("backup", b.Identifier()).Info("notified panel of failed backup state")
 		}
 
-		_ = s.Events().PublishJson(BackupCompletedEvent+":"+b.Identifier(), map[string]interface{}{
+		s.Events().Publish(BackupCompletedEvent+":"+b.Identifier(), map[string]interface{}{
 			"uuid":          b.Identifier(),
 			"is_successful": false,
 			"checksum":      "",
@@ -104,7 +103,7 @@ func (s *Server) Backup(b backup.BackupInterface) error {
 
 	// Emit an event over the socket so we can update the backup in realtime on
 	// the frontend for the server.
-	_ = s.Events().PublishJson(BackupCompletedEvent+":"+b.Identifier(), map[string]interface{}{
+	s.Events().Publish(BackupCompletedEvent+":"+b.Identifier(), map[string]interface{}{
 		"uuid":          b.Identifier(),
 		"is_successful": true,
 		"checksum":      ad.Checksum,

server/errors.go

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

server/events.go

@@ -21,12 +21,12 @@ const (
 )
 
 // Returns the server's emitter instance.
-func (s *Server) Events() *events.EventBus {
+func (s *Server) Events() *events.Bus {
 	s.emitterLock.Lock()
 	defer s.emitterLock.Unlock()
 
 	if s.emitter == nil {
-		s.emitter = events.New()
+		s.emitter = events.NewBus()
 	}
 
 	return s.emitter

server/filesystem/archive.go

@@ -45,7 +45,7 @@ type Archive struct {
 // Create creates an archive at dst with all of the files defined in the
 // included files struct.
 func (a *Archive) Create(dst string) error {
-	f, err := os.OpenFile(dst, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
+	f, err := os.OpenFile(dst, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o600)
 	if err != nil {
 		return err
 	}

server/filesystem/compress_test.go

@@ -1,7 +1,7 @@
 package filesystem
 
 import (
-	"io/ioutil"
+	"os"
 	"sync/atomic"
 	"testing"
 
@@ -19,11 +19,10 @@ func TestFilesystem_DecompressFile(t *testing.T) {
 	fs, rfs := NewFs()
 
 	g.Describe("Decompress", func() {
-
 		for _, ext := range []string{"zip", "rar", "tar", "tar.gz"} {
 			g.It("can decompress a "+ext, func() {
 				// copy the file to the new FS
-				c, err := ioutil.ReadFile("./testdata/test." + ext)
+				c, err := os.ReadFile("./testdata/test." + ext)
 				g.Assert(err).IsNil()
 				err = rfs.CreateServerFile("./test."+ext, c)
 				g.Assert(err).IsNil()

server/filesystem/filesystem.go

@@ -85,7 +85,7 @@ func (fs *Filesystem) Touch(p string, flag int) (*os.File, error) {
 	if err != nil {
 		return nil, err
 	}
-	f, err := os.OpenFile(cleaned, flag, 0644)
+	f, err := os.OpenFile(cleaned, flag, 0o644)
 	if err == nil {
 		return f, nil
 	}
@@ -97,7 +97,7 @@ func (fs *Filesystem) Touch(p string, flag int) (*os.File, error) {
 	if _, err := os.Stat(filepath.Dir(cleaned)); errors.Is(err, os.ErrNotExist) {
 		// Create the path leading up to the file we're trying to create, setting the final perms
 		// on it as we go.
-		if err := os.MkdirAll(filepath.Dir(cleaned), 0755); err != nil {
+		if err := os.MkdirAll(filepath.Dir(cleaned), 0o755); err != nil {
 			return nil, errors.Wrap(err, "server/filesystem: touch: failed to create directory tree")
 		}
 		if err := fs.Chown(filepath.Dir(cleaned)); err != nil {
@@ -107,7 +107,7 @@ func (fs *Filesystem) Touch(p string, flag int) (*os.File, error) {
 	o := &fileOpener{}
 	// Try to open the file now that we have created the pathing necessary for it, and then
 	// Chown that file so that the permissions don't mess with things.
-	f, err = o.open(cleaned, flag, 0644)
+	f, err = o.open(cleaned, flag, 0o644)
 	if err != nil {
 		return nil, errors.Wrap(err, "server/filesystem: touch: failed to open file with wait")
 	}
@@ -181,7 +181,7 @@ func (fs *Filesystem) CreateDirectory(name string, p string) error {
 	if err != nil {
 		return err
 	}
-	return os.MkdirAll(cleaned, 0755)
+	return os.MkdirAll(cleaned, 0o755)
 }
 
 // Moves (or renames) a file or directory.
@@ -210,7 +210,7 @@ func (fs *Filesystem) Rename(from string, to string) error {
 	// Ensure that the directory we're moving into exists correctly on the system. Only do this if
 	// we're not at the root directory level.
 	if d != fs.Path() {
-		if mkerr := os.MkdirAll(d, 0755); mkerr != nil {
+		if mkerr := os.MkdirAll(d, 0o755); mkerr != nil {
 			return errors.WithMessage(mkerr, "failed to create directory structure for file rename")
 		}
 	}
@@ -377,7 +377,7 @@ func (fs *Filesystem) TruncateRootDirectory() error {
 	if err := os.RemoveAll(fs.Path()); err != nil {
 		return err
 	}
-	if err := os.Mkdir(fs.Path(), 0755); err != nil {
+	if err := os.Mkdir(fs.Path(), 0o755); err != nil {
 		return err
 	}
 	atomic.StoreInt64(&fs.diskUsed, 0)
@@ -485,7 +485,7 @@ func (fs *Filesystem) ListDirectory(p string) ([]Stat, error) {
 			defer wg.Done()
 
 			var m *mimetype.MIME
-			var d = "inode/directory"
+			d := "inode/directory"
 			if !f.IsDir() {
 				cleanedp := filepath.Join(cleaned, f.Name())
 				if f.Mode()&os.ModeSymlink != 0 {

server/filesystem/filesystem_test.go

@@ -3,7 +3,6 @@ package filesystem
 import (
 	"bytes"
 	"errors"
-	"io/ioutil"
 	"math/rand"
 	"os"
 	"path/filepath"
@@ -25,7 +24,7 @@ func NewFs() (*Filesystem, *rootFs) {
 		},
 	})
 
-	tmpDir, err := ioutil.TempDir(os.TempDir(), "pterodactyl")
+	tmpDir, err := os.MkdirTemp(os.TempDir(), "pterodactyl")
 	if err != nil {
 		panic(err)
 	}
@@ -71,7 +70,7 @@ func (rfs *rootFs) reset() {
 		}
 	}
 
-	if err := os.Mkdir(filepath.Join(rfs.root, "/server"), 0755); err != nil {
+	if err := os.Mkdir(filepath.Join(rfs.root, "/server"), 0o755); err != nil {
 		panic(err)
 	}
 }
@@ -99,7 +98,7 @@ func TestFilesystem_Readfile(t *testing.T) {
 		})
 
 		g.It("returns an error if the \"file\" is a directory", func() {
-			err := os.Mkdir(filepath.Join(rfs.root, "/server/test.txt"), 0755)
+			err := os.Mkdir(filepath.Join(rfs.root, "/server/test.txt"), 0o755)
 			g.Assert(err).IsNil()
 
 			err = fs.Readfile("test.txt", buf)
@@ -341,7 +340,7 @@ func TestFilesystem_Rename(t *testing.T) {
 		})
 
 		g.It("allows a folder to be renamed", func() {
-			err := os.Mkdir(filepath.Join(rfs.root, "/server/source_dir"), 0755)
+			err := os.Mkdir(filepath.Join(rfs.root, "/server/source_dir"), 0o755)
 			g.Assert(err).IsNil()
 
 			err = fs.Rename("source_dir", "target_dir")
@@ -405,7 +404,7 @@ func TestFilesystem_Copy(t *testing.T) {
 		})
 
 		g.It("should return an error if the source directory is outside the root", func() {
-			err := os.MkdirAll(filepath.Join(rfs.root, "/nested/in/dir"), 0755)
+			err := os.MkdirAll(filepath.Join(rfs.root, "/nested/in/dir"), 0o755)
 			g.Assert(err).IsNil()
 
 			err = rfs.CreateServerFileFromString("/../nested/in/dir/ext-source.txt", "external content")
@@ -421,7 +420,7 @@ func TestFilesystem_Copy(t *testing.T) {
 		})
 
 		g.It("should return an error if the source is a directory", func() {
-			err := os.Mkdir(filepath.Join(rfs.root, "/server/dir"), 0755)
+			err := os.Mkdir(filepath.Join(rfs.root, "/server/dir"), 0o755)
 			g.Assert(err).IsNil()
 
 			err = fs.Copy("dir")
@@ -466,7 +465,7 @@ func TestFilesystem_Copy(t *testing.T) {
 		})
 
 		g.It("should create a copy inside of a directory", func() {
-			err := os.MkdirAll(filepath.Join(rfs.root, "/server/nested/in/dir"), 0755)
+			err := os.MkdirAll(filepath.Join(rfs.root, "/server/nested/in/dir"), 0o755)
 			g.Assert(err).IsNil()
 
 			err = rfs.CreateServerFileFromString("nested/in/dir/source.txt", "test content")
@@ -545,7 +544,7 @@ func TestFilesystem_Delete(t *testing.T) {
 				"foo/bar/baz/source.txt",
 			}
 
-			err := os.MkdirAll(filepath.Join(rfs.root, "/server/foo/bar/baz"), 0755)
+			err := os.MkdirAll(filepath.Join(rfs.root, "/server/foo/bar/baz"), 0o755)
 			g.Assert(err).IsNil()
 
 			for _, s := range sources {

server/filesystem/path.go

@@ -115,8 +115,8 @@ func (fs *Filesystem) ParallelSafePath(paths []string) ([]string, error) {
 	var cleaned []string
 
 	// Simple locker function to avoid racy appends to the array of cleaned paths.
-	var m = new(sync.Mutex)
-	var push = func(c string) {
+	m := new(sync.Mutex)
+	push := func(c string) {
 		m.Lock()
 		cleaned = append(cleaned, c)
 		m.Unlock()

server/filesystem/path_test.go

@@ -107,7 +107,7 @@ func TestFilesystem_Blocks_Symlinks(t *testing.T) {
 		panic(err)
 	}
 
-	if err := os.Mkdir(filepath.Join(rfs.root, "/malicious_dir"), 0777); err != nil {
+	if err := os.Mkdir(filepath.Join(rfs.root, "/malicious_dir"), 0o777); err != nil {
 		panic(err)
 	}
 

server/install.go

@@ -215,11 +215,11 @@ func (ip *InstallationProcess) tempDir() string {
 func (ip *InstallationProcess) writeScriptToDisk() error {
 	// Make sure the temp directory root exists before trying to make a directory within it. The
 	// ioutil.TempDir call expects this base to exist, it won't create it for you.
-	if err := os.MkdirAll(ip.tempDir(), 0700); err != nil {
+	if err := os.MkdirAll(ip.tempDir(), 0o700); err != nil {
 		return errors.WithMessage(err, "could not create temporary directory for install process")
 	}
 
-	f, err := os.OpenFile(filepath.Join(ip.tempDir(), "install.sh"), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
+	f, err := os.OpenFile(filepath.Join(ip.tempDir(), "install.sh"), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0o644)
 	if err != nil {
 		return errors.WithMessage(err, "failed to write server installation script to disk before mount")
 	}
@@ -350,7 +350,7 @@ func (ip *InstallationProcess) AfterExecute(containerId string) error {
 		return err
 	}
 
-	f, err := os.OpenFile(ip.GetLogPath(), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
+	f, err := os.OpenFile(ip.GetLogPath(), os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0o600)
 	if err != nil {
 		return err
 	}
@@ -516,16 +516,12 @@ func (ip *InstallationProcess) StreamOutput(ctx context.Context, id string) erro
 		ShowStderr: true,
 		Follow:     true,
 	})
-
 	if err != nil {
 		return err
 	}
 	defer reader.Close()
 
-	evts := ip.Server.Events()
-	err = system.ScanReader(reader, func(line string) {
-		evts.Publish(InstallOutputEvent, line)
-	})
+	err = system.ScanReader(reader, ip.Server.InstallSink().Push)
 	if err != nil {
 		ip.Server.Log().WithFields(log.Fields{"container_id": id, "error": err}).Warn("error processing install output lines")
 	}

server/listeners.go

@@ -1,7 +1,6 @@
 package server
 
 import (
-	"encoding/json"
 	"regexp"
 	"strconv"
 	"sync"
@@ -51,15 +50,11 @@ func (dsl *diskSpaceLimiter) Trigger() {
 	})
 }
 
-// StartEventListeners adds all the internal event listeners we want to use for a server. These listeners can only be
-// removed by deleting the server as they should last for the duration of the process' lifetime.
-func (s *Server) StartEventListeners() {
-	console := func(e events.Event) {
+func (s *Server) processConsoleOutputEvent(v []byte) {
 	t := s.Throttler()
 	err := t.Increment(func() {
 		s.PublishConsoleOutputFromDaemon("Your server is outputting too much data and is being throttled.")
 	})
-
 	// An error is only returned if the server has breached the thresholds set.
 	if err != nil {
 		// If the process is already stopping, just let it continue with that action rather than attempting
@@ -88,15 +83,27 @@ func (s *Server) StartEventListeners() {
 
 	// If we are not throttled, go ahead and output the data.
 	if !t.Throttled() {
-			s.Events().Publish(ConsoleOutputEvent, e.Data)
+		s.LogSink().Push(v)
 	}
 
 	// Also pass the data along to the console output channel.
-		s.onConsoleOutput(e.Data)
-	}
+	s.onConsoleOutput(string(v))
+}
 
+// StartEventListeners adds all the internal event listeners we want to use for a server. These listeners can only be
+// removed by deleting the server as they should last for the duration of the process' lifetime.
+func (s *Server) StartEventListeners() {
+	state := make(chan events.Event)
+	stats := make(chan events.Event)
+	docker := make(chan events.Event)
+
+	go func() {
 		l := newDiskLimiter(s)
-	state := func(e events.Event) {
+
+		for {
+			select {
+			case e := <-state:
+				go func() {
 					// Reset the throttler when the process is started.
 					if e.Data == environment.ProcessStartingState {
 						l.Reset()
@@ -104,18 +111,12 @@ func (s *Server) StartEventListeners() {
 					}
 
 					s.OnStateChange()
-	}
-
-	stats := func(e events.Event) {
-		var st environment.Stats
-		if err := json.Unmarshal([]byte(e.Data), &st); err != nil {
-			s.Log().WithField("error", err).Warn("failed to unmarshal server environment stats")
-			return
-		}
-
+				}()
+			case e := <-stats:
+				go func() {
 					// Update the server resource tracking object with the resources we got here.
 					s.resources.mu.Lock()
-		s.resources.Stats = st
+					s.resources.Stats = e.Data.(environment.Stats)
 					s.resources.mu.Unlock()
 
 					// If there is no disk space available at this point, trigger the server disk limiter logic
@@ -125,25 +126,27 @@ func (s *Server) StartEventListeners() {
 					}
 
 					s.emitProcUsage()
-	}
-
-	docker := func(e events.Event) {
-		if e.Topic == environment.DockerImagePullStatus {
+				}()
+			case e := <-docker:
+				go func() {
+					switch e.Topic {
+					case environment.DockerImagePullStatus:
 						s.Events().Publish(InstallOutputEvent, e.Data)
-		} else if e.Topic == environment.DockerImagePullStarted {
+					case environment.DockerImagePullStarted:
 						s.PublishConsoleOutputFromDaemon("Pulling Docker container image, this could take a few minutes to complete...")
-		} else {
+					default:
 						s.PublishConsoleOutputFromDaemon("Finished pulling Docker container image")
 					}
+				}()
 			}
+		}
+	}()
 
 	s.Log().Debug("registering event listeners: console, state, resources...")
-	s.Environment.Events().On(environment.ConsoleOutputEvent, &console)
-	s.Environment.Events().On(environment.StateChangeEvent, &state)
-	s.Environment.Events().On(environment.ResourceEvent, &stats)
-	for _, evt := range dockerEvents {
-		s.Environment.Events().On(evt, &docker)
-	}
+	s.Environment.SetLogCallback(s.processConsoleOutputEvent)
+	s.Environment.Events().On(state, environment.StateChangeEvent)
+	s.Environment.Events().On(stats, environment.ResourceEvent)
+	s.Environment.Events().On(docker, dockerEvents...)
 }
 
 var stripAnsiRegex = regexp.MustCompile("[\u001B\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[a-zA-Z\\d]*)*)?\u0007)|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PRZcf-ntqry=><~]))")

server/manager.go

@@ -5,7 +5,6 @@ import (
 	"encoding/json"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"os"
 	"path/filepath"
 	"runtime"
@@ -137,7 +136,7 @@ func (m *Manager) PersistStates() error {
 	if err != nil {
 		return errors.WithStack(err)
 	}
-	if err := ioutil.WriteFile(config.Get().System.GetStatesPath(), data, 0644); err != nil {
+	if err := os.WriteFile(config.Get().System.GetStatesPath(), data, 0o644); err != nil {
 		return errors.WithStack(err)
 	}
 	return nil
@@ -145,7 +144,7 @@ func (m *Manager) PersistStates() error {
 
 // ReadStates returns the state of the servers.
 func (m *Manager) ReadStates() (map[string]string, error) {
-	f, err := os.OpenFile(config.Get().System.GetStatesPath(), os.O_RDONLY|os.O_CREATE, 0644)
+	f, err := os.OpenFile(config.Get().System.GetStatesPath(), os.O_RDONLY|os.O_CREATE, 0o644)
 	if err != nil {
 		return nil, errors.WithStack(err)
 	}

server/resources.go

@@ -46,12 +46,11 @@ func (ru *ResourceUsage) Reset() {
 
 	ru.Memory = 0
 	ru.CpuAbsolute = 0
+	ru.Uptime = 0
 	ru.Network.TxBytes = 0
 	ru.Network.RxBytes = 0
 }
 
 func (s *Server) emitProcUsage() {
-	if err := s.Events().PublishJson(StatsEvent, s.Proc()); err != nil {
-		s.Log().WithField("error", err).Warn("error while emitting server resource usage to listeners")
-	}
+	s.Events().Publish(StatsEvent, s.Proc())
 }

server/server.go

@@ -49,7 +49,7 @@ type Server struct {
 	fs *filesystem.Filesystem
 
 	// Events emitted by the server instance.
-	emitter *events.EventBus
+	emitter *events.Bus
 
 	// Defines the process configuration for the server instance. This is dynamically
 	// fetched from the Pterodactyl Server instance each time the server process is
@@ -70,6 +70,9 @@ type Server struct {
 	// Tracks open websocket connections for the server.
 	wsBag       *WebsocketBag
 	wsBagLocker sync.Mutex
+
+	logSink     *sinkPool
+	installSink *sinkPool
 }
 
 // New returns a new server instance with a context and all of the default
@@ -83,6 +86,9 @@ func New(client remote.Client) (*Server, error) {
 		installing:   system.NewAtomicBool(false),
 		transferring: system.NewAtomicBool(false),
 		restoring:    system.NewAtomicBool(false),
+
+		logSink:     newSinkPool(),
+		installSink: newSinkPool(),
 	}
 	if err := defaults.Set(&s); err != nil {
 		return nil, errors.Wrap(err, "server: could not set default values for struct")
@@ -349,3 +355,11 @@ func (s *Server) ToAPIResponse() APIResponse {
 		Configuration: *s.Config(),
 	}
 }
+
+func (s *Server) LogSink() *sinkPool {
+	return s.logSink
+}
+
+func (s *Server) InstallSink() *sinkPool {
+	return s.installSink
+}

server/sink.go

@@ -0,0 +1,68 @@
+package server
+
+import (
+	"sync"
+)
+
+// sinkPool represents a pool with sinks.
+type sinkPool struct {
+	mx    sync.RWMutex
+	sinks []chan []byte
+}
+
+// newSinkPool returns a new empty sinkPool.
+func newSinkPool() *sinkPool {
+	return &sinkPool{}
+}
+
+// Off removes a sink from the pool.
+func (p *sinkPool) Off(c chan []byte) {
+	p.mx.Lock()
+	defer p.mx.Unlock()
+
+	sinks := p.sinks
+
+	for i, sink := range sinks {
+		if c != sink {
+			continue
+		}
+		copy(sinks[i:], sinks[i+1:])
+		sinks[len(sinks)-1] = nil
+		sinks = sinks[:len(sinks)-1]
+		p.sinks = sinks
+		close(c)
+		return
+	}
+}
+
+// On adds a sink on the pool.
+func (p *sinkPool) On(c chan []byte) {
+	p.mx.Lock()
+	defer p.mx.Unlock()
+
+	p.sinks = append(p.sinks, c)
+}
+
+// Destroy destroys the pool by removing and closing all sinks.
+func (p *sinkPool) Destroy() {
+	p.mx.Lock()
+	defer p.mx.Unlock()
+
+	for _, c := range p.sinks {
+		close(c)
+	}
+
+	p.sinks = nil
+}
+
+// Push pushes a message to all registered sinks.
+func (p *sinkPool) Push(v []byte) {
+	p.mx.RLock()
+	for _, c := range p.sinks {
+		select {
+		// Send the log output to the channel
+		case c <- v:
+		}
+	}
+	p.mx.RUnlock()
+}

server/websockets.go

@@ -52,8 +52,7 @@ func (w *WebsocketBag) CancelAll() {
 
 	if w.conns != nil {
 		for _, cancel := range w.conns {
-			c := *cancel
-			c()
+			(*cancel)()
 		}
 	}
 

sftp/handler.go

@@ -142,12 +142,12 @@ func (h *Handler) Filecmd(request *sftp.Request) error {
 		}
 		mode := request.Attributes().FileMode().Perm()
 		// If the client passes an invalid FileMode just use the default 0644.
-		if mode == 0000 {
-			mode = os.FileMode(0644)
+		if mode == 0o000 {
+			mode = os.FileMode(0o644)
 		}
 		// Force directories to be 0755.
 		if request.Attributes().FileMode().IsDir() {
-			mode = 0755
+			mode = 0o755
 		}
 		if err := h.fs.Chmod(request.Filepath, mode); err != nil {
 			if errors.Is(err, os.ErrNotExist) {
@@ -260,7 +260,6 @@ func (h *Handler) Filelist(request *sftp.Request) (sftp.ListerAt, error) {
 		files, err := ioutil.ReadDir(p)
 		if err != nil {
 			h.logger.WithField("source", request.Filepath).WithField("error", err).Error("error while listing directory")
-
 			return nil, sftp.ErrSSHFxFailure
 		}
 		return ListerAt(files), nil

sftp/server.go

@@ -3,11 +3,9 @@ package sftp
 import (
 	"context"
 	"crypto/rand"
-	"crypto/rsa"
 	"crypto/x509"
 	"encoding/pem"
 	"io"
-	"io/ioutil"
 	"net"
 	"os"
 	"path"
@@ -18,6 +16,7 @@ import (
 	"emperror.dev/errors"
 	"github.com/apex/log"
 	"github.com/pkg/sftp"
+	"golang.org/x/crypto/ed25519"
 	"golang.org/x/crypto/ssh"
 
 	"github.com/pterodactyl/wings/config"
@@ -48,18 +47,20 @@ func New(m *server.Manager) *SFTPServer {
 	}
 }
 
-// Starts the SFTP server and add a persistent listener to handle inbound SFTP connections.
+// Run starts the SFTP server and add a persistent listener to handle inbound
+// SFTP connections. This will automatically generate an ED25519 key if one does
+// not already exist on the system for host key verification purposes.
 func (c *SFTPServer) Run() error {
-	if _, err := os.Stat(path.Join(c.BasePath, ".sftp/id_rsa")); os.IsNotExist(err) {
-		if err := c.generatePrivateKey(); err != nil {
+	if _, err := os.Stat(c.PrivateKeyPath()); os.IsNotExist(err) {
+		if err := c.generateED25519PrivateKey(); err != nil {
 			return err
 		}
 	} else if err != nil {
-		return errors.Wrap(err, "sftp/server: could not stat private key file")
+		return errors.Wrap(err, "sftp: could not stat private key file")
 	}
-	pb, err := ioutil.ReadFile(path.Join(c.BasePath, ".sftp/id_rsa"))
+	pb, err := os.ReadFile(c.PrivateKeyPath())
 	if err != nil {
-		return errors.Wrap(err, "sftp/server: could not read private key file")
+		return errors.Wrap(err, "sftp: could not read private key file")
 	}
 	private, err := ssh.ParsePrivateKey(pb)
 	if err != nil {
@@ -78,7 +79,9 @@ func (c *SFTPServer) Run() error {
 		return err
 	}
 
-	log.WithField("listen", c.Listen).Info("sftp server listening for connections")
+	public := string(ssh.MarshalAuthorizedKey(private.PublicKey()))
+	log.WithField("listen", c.Listen).WithField("public_key", strings.Trim(public, "\n")).Info("sftp server listening for connections")
+
 	for {
 		if conn, _ := listener.Accept(); conn != nil {
 			go func(conn net.Conn) {
@@ -148,26 +151,30 @@ func (c *SFTPServer) AcceptInbound(conn net.Conn, config *ssh.ServerConfig) {
 	}
 }
 
-// Generates a private key that will be used by the SFTP server.
-func (c *SFTPServer) generatePrivateKey() error {
-	key, err := rsa.GenerateKey(rand.Reader, 2048)
+// Generates a new ED25519 private key that is used for host authentication when
+// a user connects to the SFTP server.
+func (c *SFTPServer) generateED25519PrivateKey() error {
+	_, priv, err := ed25519.GenerateKey(rand.Reader)
 	if err != nil {
-		return errors.WithStack(err)
+		return errors.Wrap(err, "sftp: failed to generate ED25519 private key")
 	}
-	if err := os.MkdirAll(path.Join(c.BasePath, ".sftp"), 0755); err != nil {
-		return errors.Wrap(err, "sftp/server: could not create .sftp directory")
+	if err := os.MkdirAll(path.Dir(c.PrivateKeyPath()), 0o755); err != nil {
+		return errors.Wrap(err, "sftp: could not create internal sftp data directory")
 	}
-	o, err := os.OpenFile(path.Join(c.BasePath, ".sftp/id_rsa"), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0600)
+	o, err := os.OpenFile(c.PrivateKeyPath(), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0o600)
 	if err != nil {
 		return errors.WithStack(err)
 	}
 	defer o.Close()
 
-	err = pem.Encode(o, &pem.Block{
-		Type:  "RSA PRIVATE KEY",
-		Bytes: x509.MarshalPKCS1PrivateKey(key),
-	})
-	return errors.WithStack(err)
+	b, err := x509.MarshalPKCS8PrivateKey(priv)
+	if err != nil {
+		return errors.Wrap(err, "sftp: failed to marshal private key into bytes")
+	}
+	if err := pem.Encode(o, &pem.Block{Type: "PRIVATE KEY", Bytes: b}); err != nil {
+		return errors.Wrap(err, "sftp: failed to write ED25519 private key to disk")
+	}
+	return nil
 }
 
 // A function capable of validating user credentials with the Panel API.
@@ -209,3 +216,8 @@ func (c *SFTPServer) passwordCallback(conn ssh.ConnMetadata, pass []byte) (*ssh.
 
 	return sshPerm, nil
 }
+
+// PrivateKeyPath returns the path the host private key for this server instance.
+func (c *SFTPServer) PrivateKeyPath() string {
+	return path.Join(c.BasePath, ".sftp/id_ed25519")
+}

sftp/utils.go

@@ -6,15 +6,15 @@ import (
 )
 
 const (
-	// Extends the default SFTP server to return a quota exceeded error to the client.
+	// ErrSSHQuotaExceeded extends the default SFTP server to return a quota exceeded error to the client.
 	//
 	// @see https://tools.ietf.org/id/draft-ietf-secsh-filexfer-13.txt
-	ErrSSHQuotaExceeded = fxerr(15)
+	ErrSSHQuotaExceeded = fxErr(15)
 )
 
 type ListerAt []os.FileInfo
 
-// Returns the number of entries copied and an io.EOF error if we made it to the end of the file list.
+// ListAt returns the number of entries copied and an io.EOF error if we made it to the end of the file list.
 // Take a look at the pkg/sftp godoc for more information about how this function should work.
 func (l ListerAt) ListAt(f []os.FileInfo, offset int64) (int, error) {
 	if offset >= int64(len(l)) {
@@ -28,9 +28,9 @@ func (l ListerAt) ListAt(f []os.FileInfo, offset int64) (int, error) {
 	}
 }
 
-type fxerr uint32
+type fxErr uint32
 
-func (e fxerr) Error() string {
+func (e fxErr) Error() string {
 	switch e {
 	case ErrSSHQuotaExceeded:
 		return "Quota Exceeded"

system/const.go

@@ -1,6 +1,3 @@
 package system
 
-var (
-	// The current version of this software.
-	Version = "0.0.1"
-)
+var Version = "develop"

system/utils.go

@@ -8,15 +8,16 @@ import (
 	"fmt"
 	"io"
 	"strconv"
-	"strings"
 	"sync"
 	"time"
 
 	"emperror.dev/errors"
 )
 
-var cr = []byte(" \r")
-var crr = []byte("\r\n")
+var (
+	cr  = []byte(" \r")
+	crr = []byte("\r\n")
+)
 
 // FirstNotEmpty returns the first string passed in that is not an empty value.
 func FirstNotEmpty(v ...string) string {
@@ -36,14 +37,14 @@ func MustInt(v string) int {
 	return i
 }
 
-func ScanReader(r io.Reader, callback func(line string)) error {
+func ScanReader(r io.Reader, callback func(line []byte)) error {
 	br := bufio.NewReader(r)
 	// Avoid constantly re-allocating memory when we're flooding lines through this
 	// function by using the same buffer for the duration of the call and just truncating
 	// the value back to 0 every loop.
-	var str strings.Builder
+	buf := &bytes.Buffer{}
 	for {
-		str.Reset()
+		buf.Reset()
 		var err error
 		var line []byte
 		var isPrefix bool
@@ -55,7 +56,7 @@ func ScanReader(r io.Reader, callback func(line string)) error {
 			// in line with that it thinks is the terminal size. Those returns break a lot of output handling,
 			// so we'll just replace them with proper new-lines and then split it later and send each line as
 			// its own event in the response.
-			str.Write(bytes.Replace(line, cr, crr, -1))
+			buf.Write(bytes.Replace(line, cr, crr, -1))
 			// Finish this loop and begin outputting the line if there is no prefix (the line fit into
 			// the default buffer), or if we hit the end of the line.
 			if !isPrefix || err == io.EOF {
@@ -67,10 +68,13 @@ func ScanReader(r io.Reader, callback func(line string)) error {
 				return err
 			}
 		}
+		// Ensure that the scanner is always able to read the last line.
+		_, _ = buf.Write([]byte("\r\n"))
 		// Publish the line for this loop. Break on new-line characters so every line is sent as a single
 		// output event, otherwise you get funky handling in the browser console.
-		for _, line := range strings.Split(str.String(), "\r\n") {
-			callback(line)
+		s := bufio.NewScanner(buf)
+		for s.Scan() {
+			callback(s.Bytes())
 		}
 		// If the error we got previously that lead to the line being output is an io.EOF we want to
 		// exit the entire looping process.