wip: migrate to mono-repo. SPN has already been moved to spn/

spn/ships/http_shared.go

@@ -0,0 +1,188 @@
+package ships
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net"
+	"net/http"
+	"sync"
+	"time"
+
+	"github.com/safing/portbase/log"
+	"github.com/safing/portmaster/spn/conf"
+)
+
+type sharedServer struct {
+	server *http.Server
+
+	handlers     map[string]http.HandlerFunc
+	handlersLock sync.RWMutex
+}
+
+// ServeHTTP forwards requests to registered handler or uses defaults.
+func (shared *sharedServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	shared.handlersLock.Lock()
+	defer shared.handlersLock.Unlock()
+
+	// Get and forward to registered handler.
+	handler, ok := shared.handlers[r.URL.Path]
+	if ok {
+		handler(w, r)
+		return
+	}
+
+	// If there is registered handler and path is "/", respond with info page.
+	if r.Method == http.MethodGet && r.URL.Path == "/" {
+		ServeInfoPage(w, r)
+		return
+	}
+
+	// Otherwise, respond with error.
+	http.Error(w, "", http.StatusNotFound)
+}
+
+var (
+	sharedHTTPServers     = make(map[uint16]*sharedServer)
+	sharedHTTPServersLock sync.Mutex
+)
+
+func addHTTPHandler(port uint16, path string, handler http.HandlerFunc) error {
+	// Check params.
+	if port == 0 {
+		return errors.New("cannot listen on port 0")
+	}
+
+	// Default to root path.
+	if path == "" {
+		path = "/"
+	}
+
+	sharedHTTPServersLock.Lock()
+	defer sharedHTTPServersLock.Unlock()
+
+	// Get http server of the port.
+	shared, ok := sharedHTTPServers[port]
+	if ok {
+		// Set path to handler.
+		shared.handlersLock.Lock()
+		defer shared.handlersLock.Unlock()
+
+		// Check if path is already registered.
+		_, ok := shared.handlers[path]
+		if ok {
+			return errors.New("path already registered")
+		}
+
+		// Else, register handler at path.
+		shared.handlers[path] = handler
+		return nil
+	}
+
+	// Shared server does not exist - create one.
+	shared = &sharedServer{
+		handlers: make(map[string]http.HandlerFunc),
+	}
+
+	// Add first handler.
+	shared.handlers[path] = handler
+
+	// Define new server.
+	server := &http.Server{
+		Addr:              fmt.Sprintf(":%d", port),
+		Handler:           shared,
+		ReadTimeout:       1 * time.Minute,
+		ReadHeaderTimeout: 10 * time.Second,
+		WriteTimeout:      1 * time.Minute,
+		IdleTimeout:       1 * time.Minute,
+		MaxHeaderBytes:    4096,
+		// ErrorLog:          &log.Logger{}, // FIXME
+		BaseContext: func(net.Listener) context.Context { return module.Ctx },
+	}
+	shared.server = server
+
+	// Start listeners.
+	bindIPs := conf.GetBindIPs()
+	listeners := make([]net.Listener, 0, len(bindIPs))
+	for _, bindIP := range bindIPs {
+		listener, err := net.ListenTCP("tcp", &net.TCPAddr{
+			IP:   bindIP,
+			Port: int(port),
+		})
+		if err != nil {
+			return fmt.Errorf("failed to listen: %w", err)
+		}
+
+		listeners = append(listeners, listener)
+		log.Infof("spn/ships: http transport pier established on %s", listener.Addr())
+	}
+
+	// Add shared http server to list.
+	sharedHTTPServers[port] = shared
+
+	// Start servers in service workers.
+	for _, listener := range listeners {
+		serviceListener := listener
+		module.StartServiceWorker(
+			fmt.Sprintf("shared http server listener on %s", listener.Addr()), 0,
+			func(ctx context.Context) error {
+				err := shared.server.Serve(serviceListener)
+				if !errors.Is(http.ErrServerClosed, err) {
+					return err
+				}
+				return nil
+			},
+		)
+	}
+
+	return nil
+}
+
+func removeHTTPHandler(port uint16, path string) error {
+	// Check params.
+	if port == 0 {
+		return nil
+	}
+
+	// Default to root path.
+	if path == "" {
+		path = "/"
+	}
+
+	sharedHTTPServersLock.Lock()
+	defer sharedHTTPServersLock.Unlock()
+
+	// Get http server of the port.
+	shared, ok := sharedHTTPServers[port]
+	if !ok {
+		return nil
+	}
+
+	// Set path to handler.
+	shared.handlersLock.Lock()
+	defer shared.handlersLock.Unlock()
+
+	// Check if path is registered.
+	_, ok = shared.handlers[path]
+	if !ok {
+		return nil
+	}
+
+	// Remove path from handler.
+	delete(shared.handlers, path)
+
+	// Shutdown shared HTTP server if no more handlers are registered.
+	if len(shared.handlers) == 0 {
+		ctx, cancel := context.WithTimeout(
+			context.Background(),
+			10*time.Second,
+		)
+		defer cancel()
+		return shared.server.Shutdown(ctx)
+	}
+
+	// Remove shared HTTP server from map.
+	delete(sharedHTTPServers, port)
+
+	return nil
+}