tracker/http: update local filesystem serving system

Author: crimist

config/config.go

@@ -26,7 +26,8 @@ type Configuration struct {
 			Read  time.Duration
 			Write time.Duration
 		}
-		Threads int
+		Threads   int
+		ServePath string
 	}
 	UDP struct {
 		Enabled bool

config/embed.go

@@ -4,7 +4,6 @@ import (
 	"embed"
 	"os"
 	"path/filepath"
-	"strings"
 	"syscall"
 
 	"github.com/pkg/errors"
@@ -36,54 +35,3 @@ func writeEmbeddedConfig(path string) error {
 
 	return nil
 }
-
-type EmbeddedCache map[string]string
-
-func stripNewlineTabs(data string) string {
-	data = strings.ReplaceAll(data, "\t", "")
-	data = strings.ReplaceAll(data, "\n", "")
-	return data
-}
-
-func GenerateEmbeddedCache() (EmbeddedCache, error) {
-	dir, err := embeddedFS.ReadDir("embedded")
-	if err != nil {
-		return nil, errors.Wrap(err, "failed to read embed directory to populate cache")
-	}
-
-	cache := make(EmbeddedCache, len(dir))
-
-	for _, entry := range dir {
-		if entry.IsDir() {
-			continue
-		}
-
-		filename := entry.Name()
-
-		// don't expose configuration
-		if filename == "trakx.yaml" {
-			continue
-		}
-
-		data, err := embeddedFS.ReadFile("embedded/" + filename)
-		if err != nil {
-			return nil, errors.Wrapf(err, "failed to open file %v from embedded", "embedded/"+filename)
-		}
-
-		// trim data from html files to save bandwidth
-		dataStr := string(data)
-		if strings.HasSuffix(filename, ".html") {
-			dataStr = stripNewlineTabs(dataStr)
-		}
-
-		zap.L().Debug("adding file to embedded cache", zap.String("filename", filename))
-		cache["/"+filename] = dataStr
-	}
-
-	// if index exists copy to /
-	if indexData, ok := cache["/index.html"]; ok {
-		cache["/"] = indexData
-	}
-
-	return cache, nil
-}

refactoring.md

@@ -4,13 +4,10 @@
 
 ## Current
 
-* Refactor HTTP tracker tests based on udp tracker tests
-* Add UDP tracker scrape tests
+* Refactor tracker main()
 
 ## Future
 
-* Consider ripping out embedded HTTP files, a reverse proxy should handle that, can provide example with existing files and Caddyfile
-* Refactor tracker main()
 * Refactor controller / command line interface - KISS!
 * Deal w/ every TODO
 * Implement new features

tracker/http/helpers.go

@@ -8,13 +8,14 @@ import (
 )
 
 var (
-	httpSuccessBytes = []byte("HTTP/1.1 200\r\n\r\n")
+	httpSuccess      = "HTTP/1.1 200 OK\r\n\r\n"
+	httpSuccessBytes = []byte(httpSuccess)
 )
 
 // string concats are optimized in go so these are faster than []byte appends etc.
 
 func writeSuccess(c net.Conn, body string) {
-	c.Write(utils.StringToBytesUnsafe("HTTP/1.1 200\r\n\r\n" + body))
+	c.Write(utils.StringToBytesUnsafe(httpSuccess + body))
 }
 
 func writeStatus(c net.Conn, status string) {

tracker/http/httptracker.go

@@ -6,9 +6,13 @@ import (
 	"net"
 	"net/http"
 	"net/netip"
+	"os"
+	"path"
+	"path/filepath"
+	"strconv"
+	"strings"
 	"time"
 
-	"github.com/crimist/trakx/config"
 	"github.com/crimist/trakx/stats"
 	"github.com/crimist/trakx/storage"
 	"github.com/crimist/trakx/tracker"
@@ -27,16 +31,17 @@ type Tracker struct {
 	shutdown      chan struct{}
 	stats         *stats.Statistics
 	expvarHandler http.Handler
-	embeddedCache config.EmbeddedCache
+	servePath     string
 }
 
-func NewTracker(peerDB storage.Database, stats *stats.Statistics, config tracker.TrackerConfig) *Tracker {
+func NewTracker(peerDB storage.Database, servePath string, stats *stats.Statistics, config tracker.TrackerConfig) *Tracker {
 	return &Tracker{
 		config:        config,
 		peerdb:        peerDB,
 		shutdown:      make(chan struct{}),
 		stats:         stats,
 		expvarHandler: expvar.Handler(),
+		servePath:     servePath,
 	}
 }
 
@@ -51,11 +56,6 @@ func (tracker *Tracker) Serve(ip net.IP, port int, routines int) error {
 	}
 	zap.L().Debug("Serving HTTP tracker on", zap.String("address", listener.Addr().String()))
 
-	tracker.embeddedCache, err = config.GenerateEmbeddedCache()
-	if err != nil {
-		return errors.Wrap(err, "failed to generate embedded cache")
-	}
-
 	// TODO: figure out what optimal number of goroutines is (benchmark)
 	// Going to need to write a tool that can simulate a large number of clients
 	for i := 0; i < routines; i++ {
@@ -222,10 +222,61 @@ func (tracker *Tracker) process(conn net.Conn, data []byte) {
 			conn: conn,
 		}, nil)
 	default:
-		if data, ok := tracker.embeddedCache[reqData.Path]; ok {
-			writeSuccess(conn, data)
-		} else {
+		if tracker.servePath == "" {
 			writeStatus(conn, "404")
+			break
+		}
+
+		cleanPath := filepath.FromSlash(path.Clean("/" + reqData.Path))
+		filePath := filepath.Join(tracker.servePath, cleanPath)
+
+		if !strings.HasPrefix(filePath, tracker.servePath) {
+			writeStatus(conn, "403")
+			tracker.stats.ClientErrors.Add(1)
+			break
+		}
+
+		fileInfo, err := os.Stat(filePath)
+		if err != nil {
+			if os.IsNotExist(err) {
+				writeStatus(conn, "404")
+			} else {
+				zap.L().Debug("Error accessing file", zap.Error(err), zap.String("path", filePath))
+				writeStatus(conn, "500")
+			}
+			break
 		}
+
+		if fileInfo.IsDir() {
+			writeStatus(conn, "403")
+			break
+		}
+
+		fileContent, err := os.ReadFile(filePath)
+		if err != nil {
+			zap.L().Debug("Error reading file", zap.Error(err), zap.String("path", filePath))
+			writeStatus(conn, "500")
+			break
+		}
+
+		contentType := "application/octet-stream"
+		switch filepath.Ext(filePath) {
+		case ".html", ".htm":
+			contentType = "text/html"
+		case ".css":
+			contentType = "text/css"
+		case ".js":
+			contentType = "application/javascript"
+		case ".jpg", ".jpeg":
+			contentType = "image/jpeg"
+		case ".png":
+			contentType = "image/png"
+		case ".gif":
+			contentType = "image/gif"
+		case ".txt":
+			contentType = "text/plain"
+		}
+
+		conn.Write([]byte("HTTP/1.1 200 OK\r\nContent-Type: " + contentType + "\r\nContent-Length: " + strconv.Itoa(len(fileContent)) + "\r\n\r\n" + string(fileContent)))
 	}
 }

tracker/http/httptracker_test.go

@@ -5,6 +5,7 @@ import (
 	"net"
 	"net/http"
 	"os"
+	"path/filepath"
 	"testing"
 	"time"
 
@@ -70,8 +71,13 @@ func TestMain(m *testing.M) {
 		zap.L().Fatal("TCP tracker received shutdown")
 	}
 
+	servePath, err := filepath.Abs(".")
+	if err != nil {
+		zap.L().Fatal("failed to get absolute path", zap.Error(err))
+	}
+
 	stats := stats.NewStats(0)
-	tracker := NewTracker(peerDB, stats, testTrackerConfig)
+	tracker := NewTracker(peerDB, servePath, stats, testTrackerConfig)
 	go func() {
 		err = tracker.Serve(nil, testNetworkPort, 1)
 		if err != nil {
@@ -162,3 +168,52 @@ func TestHeartbeat(t *testing.T) {
 		t.Errorf("Expected code 200, got %d", resp.StatusCode)
 	}
 }
+
+func TestServe(t *testing.T) {
+	resp, err := http.Get(fmt.Sprintf("http://%s:%d/.", testNetAddress4, testNetworkPort))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if resp.StatusCode != 403 {
+		t.Errorf("Expected code 403, got %d", resp.StatusCode)
+	}
+
+	resp, err = http.Get(fmt.Sprintf("http://%s:%d/../", testNetAddress4, testNetworkPort))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if resp.StatusCode != 403 {
+		t.Errorf("Expected code 403, got %d", resp.StatusCode)
+	}
+
+	resp, err = http.Get(fmt.Sprintf("http://%s:%d/../../../../../../../../../../../etc/passwd", testNetAddress4, testNetworkPort))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if resp.StatusCode != 404 {
+		t.Errorf("Expected code 404, got %d", resp.StatusCode)
+	}
+
+	resp, err = http.Get(fmt.Sprintf("http://%s:%d/httptracker_test.go", testNetAddress4, testNetworkPort))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if resp.StatusCode != 200 {
+		t.Errorf("Expected code 200, got %d", resp.StatusCode)
+	}
+
+	body := make([]byte, 65535)
+	n, err := resp.Body.Read(body)
+	if err != nil {
+		t.Fatal("Failed to read response body", err)
+	}
+	body = body[:n]
+
+	if string(body[:13]) != "package http\n" {
+		t.Errorf("Expected file to read 'package http\\n', got %s", body)
+	}
+}