Updated plugin interface

- Updated plugin interface to support static path routing
- Added autosave for statistic data (workaround for #561)

.gitignore

@@ -49,3 +49,4 @@ src/log/
 # plugins
 example/plugins/ztnc/ztnc.db
 example/plugins/ztnc/authtoken.secret
+example/plugins/ztnc/ztnc.db.lock

example/plugins/build_all.sh

@@ -1,6 +1,16 @@
 #!/bin/bash
+# This script builds all the plugins in the current directory
+
+echo "Copying zoraxy_plugin to all mods"
+for dir in ./*; do
+    if [ -d "$dir" ]; then
+        cp -r ../mod/plugins/zoraxy_plugin "$dir/mod"
+    fi
+done
+
 
 # Iterate over all directories in the current directory
+echo "Running go mod tidy and go build for all directories"
 for dir in */; do
     if [ -d "$dir" ]; then
         echo "Processing directory: $dir"
@@ -19,4 +29,4 @@ for dir in */; do
     fi
 done
 
-echo "Build process completed for all directories."
+echo "Build process completed for all directories."

example/plugins/debugger/main.go

@@ -9,8 +9,9 @@ import (
 )
 
 const (
-	PLUGIN_ID = "org.aroz.zoraxy.debugger"
-	UI_PATH   = "/debug"
+	PLUGIN_ID              = "org.aroz.zoraxy.debugger"
+	UI_PATH                = "/debug"
+	STATIC_CAPTURE_INGRESS = "/s_capture"
 )
 
 func main() {
@@ -28,15 +29,15 @@ func main() {
 		VersionMinor:  0,
 		VersionPatch:  0,
 
-		GlobalCapturePaths: []plugin.CaptureRule{
+		StaticCapturePaths: []plugin.StaticCaptureRule{
 			{
-				CapturePath:     "/debug_test", //Capture all traffic of all HTTP proxy rule
-				IncludeSubPaths: true,
+				CapturePath: "/test_a",
+			},
+			{
+				CapturePath: "/test_b",
 			},
 		},
-		GlobalCaptureIngress: "",
-		AlwaysCapturePaths:   []plugin.CaptureRule{},
-		AlwaysCaptureIngress: "",
+		StaticCaptureIngress: "/s_capture",
 
 		UIPath: UI_PATH,
 
@@ -50,21 +51,42 @@ func main() {
 		panic(err)
 	}
 
-	// Register the shutdown handler
-	plugin.RegisterShutdownHandler(func() {
-		// Do cleanup here if needed
-		fmt.Println("Debugger Terminated")
-	})
+	//Create a path handler for the capture paths
+	pathRouter := plugin.NewPathRouter()
+	pathRouter.SetDebugPrintMode(true)
+	pathRouter.RegisterPathHandler("/test_a", http.HandlerFunc(HandleCaptureA))
+	pathRouter.RegisterPathHandler("/test_b", http.HandlerFunc(HandleCaptureB))
+	pathRouter.SetDefaultHandler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		//In theory this should never be called
+		//but just in case the request is not captured by the path handlers
+		//this will be the fallback handler
+		w.Header().Set("Content-Type", "text/html")
+		w.Write([]byte("This request is captured by the default handler!<br>Request URI: " + r.URL.String()))
+	}))
+	pathRouter.RegisterHandle(STATIC_CAPTURE_INGRESS, http.DefaultServeMux)
 
 	http.HandleFunc(UI_PATH+"/", RenderDebugUI)
-	http.HandleFunc("/gcapture", HandleIngressCapture)
 	fmt.Println("Debugger started at http://127.0.0.1:" + strconv.Itoa(runtimeCfg.Port))
 	http.ListenAndServe("127.0.0.1:"+strconv.Itoa(runtimeCfg.Port), nil)
 }
 
 // Handle the captured request
-func HandleIngressCapture(w http.ResponseWriter, r *http.Request) {
-	fmt.Fprint(w, "Capture request received")
+func HandleCaptureA(w http.ResponseWriter, r *http.Request) {
+	for key, values := range r.Header {
+		for _, value := range values {
+			fmt.Printf("%s: %s\n", key, value)
+		}
+	}
 	w.Header().Set("Content-Type", "text/html")
-	w.Write([]byte("This request is captured by the debugger"))
+	w.Write([]byte("This request is captured by A handler!<br>Request URI: " + r.URL.String()))
+}
+
+func HandleCaptureB(w http.ResponseWriter, r *http.Request) {
+	for key, values := range r.Header {
+		for _, value := range values {
+			fmt.Printf("%s: %s\n", key, value)
+		}
+	}
+	w.Header().Set("Content-Type", "text/html")
+	w.Write([]byte("This request is captured by the B handler!<br>Request URI: " + r.URL.String()))
 }

example/plugins/debugger/mod/zoraxy_plugin/embed_webserver.go

@@ -6,6 +6,7 @@ import (
 	"io/fs"
 	"net/http"
 	"net/url"
+	"os"
 	"strings"
 	"time"
 )
@@ -15,6 +16,8 @@ type PluginUiRouter struct {
 	TargetFs       *embed.FS //The embed.FS where the UI files are stored
 	TargetFsPrefix string    //The prefix of the embed.FS where the UI files are stored, e.g. /web
 	HandlerPrefix  string    //The prefix of the handler used to route this router, e.g. /ui
+
+	terminateHandler func() //The handler to be called when the plugin is terminated
 }
 
 // NewPluginEmbedUIRouter creates a new PluginUiRouter with embed.FS
@@ -104,3 +107,22 @@ func (p *PluginUiRouter) Handler() http.Handler {
 		p.populateCSRFToken(r, http.FileServer(http.FS(subFS))).ServeHTTP(w, r)
 	})
 }
+
+// RegisterTerminateHandler registers the terminate handler for the PluginUiRouter
+// The terminate handler will be called when the plugin is terminated from Zoraxy plugin manager
+// if mux is nil, the handler will be registered to http.DefaultServeMux
+func (p *PluginUiRouter) RegisterTerminateHandler(termFunc func(), mux *http.ServeMux) {
+	p.terminateHandler = termFunc
+	if mux == nil {
+		mux = http.DefaultServeMux
+	}
+	mux.HandleFunc(p.HandlerPrefix+"/term", func(w http.ResponseWriter, r *http.Request) {
+		p.terminateHandler()
+		w.WriteHeader(http.StatusOK)
+		go func() {
+			//Make sure the response is sent before the plugin is terminated
+			time.Sleep(100 * time.Millisecond)
+			os.Exit(0)
+		}()
+	})
+}

example/plugins/debugger/mod/zoraxy_plugin/static_router.go

@@ -0,0 +1,103 @@
+package zoraxy_plugin
+
+import (
+	"fmt"
+	"net/http"
+	"sort"
+	"strings"
+)
+
+type PathRouter struct {
+	enableDebugPrint bool
+	pathHandlers     map[string]http.Handler
+	defaultHandler   http.Handler
+}
+
+// NewPathRouter creates a new PathRouter
+func NewPathRouter() *PathRouter {
+	return &PathRouter{
+		enableDebugPrint: false,
+		pathHandlers:     make(map[string]http.Handler),
+	}
+}
+
+// RegisterPathHandler registers a handler for a path
+func (p *PathRouter) RegisterPathHandler(path string, handler http.Handler) {
+	path = strings.TrimSuffix(path, "/")
+	p.pathHandlers[path] = handler
+}
+
+// RemovePathHandler removes a handler for a path
+func (p *PathRouter) RemovePathHandler(path string) {
+	delete(p.pathHandlers, path)
+}
+
+// SetDefaultHandler sets the default handler for the router
+// This handler will be called if no path handler is found
+func (p *PathRouter) SetDefaultHandler(handler http.Handler) {
+	p.defaultHandler = handler
+}
+
+// SetDebugPrintMode sets the debug print mode
+func (p *PathRouter) SetDebugPrintMode(enable bool) {
+	p.enableDebugPrint = enable
+}
+
+func (p *PathRouter) RegisterHandle(capture_ingress string, mux *http.ServeMux) {
+	if !strings.HasSuffix(capture_ingress, "/") {
+		capture_ingress = capture_ingress + "/"
+	}
+	mux.Handle(capture_ingress, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		p.ServeHTTP(w, r)
+	}))
+}
+
+func (p *PathRouter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	capturePath := r.Header.Get("X-Zoraxy-Capture")
+	if capturePath != "" {
+		if p.enableDebugPrint {
+			fmt.Printf("Using capture path: %s\n", capturePath)
+		}
+		originalURI := r.Header.Get("X-Zoraxy-Uri")
+		r.URL.Path = originalURI
+		if handler, ok := p.pathHandlers[capturePath]; ok {
+			handler.ServeHTTP(w, r)
+			return
+		}
+	}
+	p.defaultHandler.ServeHTTP(w, r)
+}
+
+func (p *PathRouter) PrintRequestDebugMessage(r *http.Request) {
+	if p.enableDebugPrint {
+		fmt.Printf("Capture Request with path: %s \n\n**Request Headers** \n\n", r.URL.Path)
+		keys := make([]string, 0, len(r.Header))
+		for key := range r.Header {
+			keys = append(keys, key)
+		}
+		sort.Strings(keys)
+		for _, key := range keys {
+			for _, value := range r.Header[key] {
+				fmt.Printf("%s: %s\n", key, value)
+			}
+		}
+
+		fmt.Printf("\n\n**Request Details**\n\n")
+		fmt.Printf("Method: %s\n", r.Method)
+		fmt.Printf("URL: %s\n", r.URL.String())
+		fmt.Printf("Proto: %s\n", r.Proto)
+		fmt.Printf("Host: %s\n", r.Host)
+		fmt.Printf("RemoteAddr: %s\n", r.RemoteAddr)
+		fmt.Printf("RequestURI: %s\n", r.RequestURI)
+		fmt.Printf("ContentLength: %d\n", r.ContentLength)
+		fmt.Printf("TransferEncoding: %v\n", r.TransferEncoding)
+		fmt.Printf("Close: %v\n", r.Close)
+		fmt.Printf("Form: %v\n", r.Form)
+		fmt.Printf("PostForm: %v\n", r.PostForm)
+		fmt.Printf("MultipartForm: %v\n", r.MultipartForm)
+		fmt.Printf("Trailer: %v\n", r.Trailer)
+		fmt.Printf("RemoteAddr: %s\n", r.RemoteAddr)
+		fmt.Printf("RequestURI: %s\n", r.RequestURI)
+
+	}
+}

example/plugins/debugger/mod/zoraxy_plugin/zoraxy_plugin.go

@@ -4,9 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
-	"os/signal"
 	"strings"
-	"syscall"
 )
 
 /*
@@ -24,9 +22,9 @@ const (
 	PluginType_Utilities PluginType = 1 //Utilities Plugin, used for utilities like Zerotier or Static Web Server that do not require interception with the dpcore
 )
 
-type CaptureRule struct {
-	CapturePath     string `json:"capture_path"`
-	IncludeSubPaths bool   `json:"include_sub_paths"`
+type StaticCaptureRule struct {
+	CapturePath string `json:"capture_path"`
+	//To be expanded
 }
 
 type ControlStatusCode int
@@ -74,23 +72,24 @@ type IntroSpect struct {
 	*/
 
 	/*
-		Global Capture Settings
-
-		Once plugin is enabled these rules always applies, no matter which HTTP Proxy rule it is enabled on
-		This captures the whole traffic of Zoraxy
+		Static Capture Settings
 
+		Once plugin is enabled these rules always applies to the enabled HTTP Proxy rule
+		This is faster than dynamic capture, but less flexible
 	*/
-	GlobalCapturePaths   []CaptureRule `json:"global_capture_path"`    //Global traffic capture path of your plugin
-	GlobalCaptureIngress string        `json:"global_capture_ingress"` //Global traffic capture ingress path of your plugin (e.g. /g_handler)
+	StaticCapturePaths   []StaticCaptureRule `json:"static_capture_paths"`   //Static capture paths of your plugin, see Zoraxy documentation for more details
+	StaticCaptureIngress string              `json:"static_capture_ingress"` //Static capture ingress path of your plugin (e.g. /s_handler)
 
 	/*
-		Always Capture Settings
+		Dynamic Capture Settings
 
-		Once the plugin is enabled on a given HTTP Proxy rule,
-		these always applies
+		Once plugin is enabled, these rules will be captured and forward to plugin sniff
+		if the plugin sniff returns 280, the traffic will be captured
+		otherwise, the traffic will be forwarded to the next plugin
+		This is slower than static capture, but more flexible
 	*/
-	AlwaysCapturePaths   []CaptureRule `json:"always_capture_path"`    //Always capture path of your plugin when enabled on a HTTP Proxy rule (e.g. /myapp)
-	AlwaysCaptureIngress string        `json:"always_capture_ingress"` //Always capture ingress path of your plugin when enabled on a HTTP Proxy rule (e.g. /a_handler)
+	DynamicCaptureSniff   string `json:"dynamic_capture_sniff"`   //Dynamic capture sniff path of your plugin (e.g. /d_sniff)
+	DynamicCaptureIngress string `json:"dynamic_capture_ingress"` //Dynamic capture ingress path of your plugin (e.g. /d_handler)
 
 	/* UI Path for your plugin */
 	UIPath string `json:"ui_path"` //UI path of your plugin (e.g. /ui), will proxy the whole subpath tree to Zoraxy Web UI as plugin UI
@@ -174,25 +173,3 @@ func ServeAndRecvSpec(pluginSpect *IntroSpect) (*ConfigureSpec, error) {
 	ServeIntroSpect(pluginSpect)
 	return RecvConfigureSpec()
 }
-
-/*
-
-Shutdown handler
-
-This function will register a shutdown handler for the plugin
-The shutdown callback will be called when the plugin is shutting down
-You can use this to clean up resources like closing database connections
-*/
-
-func RegisterShutdownHandler(shutdownCallback func()) {
-	// Set up a channel to receive OS signals
-	sigChan := make(chan os.Signal, 1)
-	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
-
-	// Start a goroutine to listen for signals
-	go func() {
-		<-sigChan
-		shutdownCallback()
-		os.Exit(0)
-	}()
-}

example/plugins/helloworld/main.go

@@ -7,7 +7,7 @@ import (
 	"net/http"
 	"strconv"
 
-	plugin "example.com/zoraxy/helloworld/zoraxy_plugin"
+	plugin "example.com/zoraxy/helloworld/mod/zoraxy_plugin"
 )
 
 const (

example/plugins/helloworld/mod/zoraxy_plugin/static_router.go

@@ -0,0 +1,103 @@
+package zoraxy_plugin
+
+import (
+	"fmt"
+	"net/http"
+	"sort"
+	"strings"
+)
+
+type PathRouter struct {
+	enableDebugPrint bool
+	pathHandlers     map[string]http.Handler
+	defaultHandler   http.Handler
+}
+
+// NewPathRouter creates a new PathRouter
+func NewPathRouter() *PathRouter {
+	return &PathRouter{
+		enableDebugPrint: false,
+		pathHandlers:     make(map[string]http.Handler),
+	}
+}
+
+// RegisterPathHandler registers a handler for a path
+func (p *PathRouter) RegisterPathHandler(path string, handler http.Handler) {
+	path = strings.TrimSuffix(path, "/")
+	p.pathHandlers[path] = handler
+}
+
+// RemovePathHandler removes a handler for a path
+func (p *PathRouter) RemovePathHandler(path string) {
+	delete(p.pathHandlers, path)
+}
+
+// SetDefaultHandler sets the default handler for the router
+// This handler will be called if no path handler is found
+func (p *PathRouter) SetDefaultHandler(handler http.Handler) {
+	p.defaultHandler = handler
+}
+
+// SetDebugPrintMode sets the debug print mode
+func (p *PathRouter) SetDebugPrintMode(enable bool) {
+	p.enableDebugPrint = enable
+}
+
+func (p *PathRouter) RegisterHandle(capture_ingress string, mux *http.ServeMux) {
+	if !strings.HasSuffix(capture_ingress, "/") {
+		capture_ingress = capture_ingress + "/"
+	}
+	mux.Handle(capture_ingress, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		p.ServeHTTP(w, r)
+	}))
+}
+
+func (p *PathRouter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	capturePath := r.Header.Get("X-Zoraxy-Capture")
+	if capturePath != "" {
+		if p.enableDebugPrint {
+			fmt.Printf("Using capture path: %s\n", capturePath)
+		}
+		originalURI := r.Header.Get("X-Zoraxy-Uri")
+		r.URL.Path = originalURI
+		if handler, ok := p.pathHandlers[capturePath]; ok {
+			handler.ServeHTTP(w, r)
+			return
+		}
+	}
+	p.defaultHandler.ServeHTTP(w, r)
+}
+
+func (p *PathRouter) PrintRequestDebugMessage(r *http.Request) {
+	if p.enableDebugPrint {
+		fmt.Printf("Capture Request with path: %s \n\n**Request Headers** \n\n", r.URL.Path)
+		keys := make([]string, 0, len(r.Header))
+		for key := range r.Header {
+			keys = append(keys, key)
+		}
+		sort.Strings(keys)
+		for _, key := range keys {
+			for _, value := range r.Header[key] {
+				fmt.Printf("%s: %s\n", key, value)
+			}
+		}
+
+		fmt.Printf("\n\n**Request Details**\n\n")
+		fmt.Printf("Method: %s\n", r.Method)
+		fmt.Printf("URL: %s\n", r.URL.String())
+		fmt.Printf("Proto: %s\n", r.Proto)
+		fmt.Printf("Host: %s\n", r.Host)
+		fmt.Printf("RemoteAddr: %s\n", r.RemoteAddr)
+		fmt.Printf("RequestURI: %s\n", r.RequestURI)
+		fmt.Printf("ContentLength: %d\n", r.ContentLength)
+		fmt.Printf("TransferEncoding: %v\n", r.TransferEncoding)
+		fmt.Printf("Close: %v\n", r.Close)
+		fmt.Printf("Form: %v\n", r.Form)
+		fmt.Printf("PostForm: %v\n", r.PostForm)
+		fmt.Printf("MultipartForm: %v\n", r.MultipartForm)
+		fmt.Printf("Trailer: %v\n", r.Trailer)
+		fmt.Printf("RemoteAddr: %s\n", r.RemoteAddr)
+		fmt.Printf("RequestURI: %s\n", r.RequestURI)
+
+	}
+}

example/plugins/helloworld/mod/zoraxy_plugin/zoraxy_plugin.go

@@ -22,9 +22,9 @@ const (
 	PluginType_Utilities PluginType = 1 //Utilities Plugin, used for utilities like Zerotier or Static Web Server that do not require interception with the dpcore
 )
 
-type CaptureRule struct {
-	CapturePath     string `json:"capture_path"`
-	IncludeSubPaths bool   `json:"include_sub_paths"`
+type StaticCaptureRule struct {
+	CapturePath string `json:"capture_path"`
+	//To be expanded
 }
 
 type ControlStatusCode int
@@ -72,23 +72,24 @@ type IntroSpect struct {
 	*/
 
 	/*
-		Global Capture Settings
-
-		Once plugin is enabled these rules always applies, no matter which HTTP Proxy rule it is enabled on
-		This captures the whole traffic of Zoraxy
+		Static Capture Settings
 
+		Once plugin is enabled these rules always applies to the enabled HTTP Proxy rule
+		This is faster than dynamic capture, but less flexible
 	*/
-	GlobalCapturePaths   []CaptureRule `json:"global_capture_path"`    //Global traffic capture path of your plugin
-	GlobalCaptureIngress string        `json:"global_capture_ingress"` //Global traffic capture ingress path of your plugin (e.g. /g_handler)
+	StaticCapturePaths   []StaticCaptureRule `json:"static_capture_paths"`   //Static capture paths of your plugin, see Zoraxy documentation for more details
+	StaticCaptureIngress string              `json:"static_capture_ingress"` //Static capture ingress path of your plugin (e.g. /s_handler)
 
 	/*
-		Always Capture Settings
+		Dynamic Capture Settings
 
-		Once the plugin is enabled on a given HTTP Proxy rule,
-		these always applies
+		Once plugin is enabled, these rules will be captured and forward to plugin sniff
+		if the plugin sniff returns 280, the traffic will be captured
+		otherwise, the traffic will be forwarded to the next plugin
+		This is slower than static capture, but more flexible
 	*/
-	AlwaysCapturePaths   []CaptureRule `json:"always_capture_path"`    //Always capture path of your plugin when enabled on a HTTP Proxy rule (e.g. /myapp)
-	AlwaysCaptureIngress string        `json:"always_capture_ingress"` //Always capture ingress path of your plugin when enabled on a HTTP Proxy rule (e.g. /a_handler)
+	DynamicCaptureSniff   string `json:"dynamic_capture_sniff"`   //Dynamic capture sniff path of your plugin (e.g. /d_sniff)
+	DynamicCaptureIngress string `json:"dynamic_capture_ingress"` //Dynamic capture ingress path of your plugin (e.g. /d_handler)
 
 	/* UI Path for your plugin */
 	UIPath string `json:"ui_path"` //UI path of your plugin (e.g. /ui), will proxy the whole subpath tree to Zoraxy Web UI as plugin UI

example/plugins/static_capture/go.mod

@@ -0,0 +1,3 @@
+module aroz.org/zoraxy/example/static_capture
+
+go 1.23.6

example/plugins/static_capture/main.go

@@ -0,0 +1,104 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+	"strconv"
+
+	plugin "aroz.org/zoraxy/example/static_capture/mod/zoraxy_plugin"
+)
+
+const (
+	PLUGIN_ID              = "org.aroz.zoraxy.static_capture"
+	UI_PATH                = "/ui"
+	STATIC_CAPTURE_INGRESS = "/static_capture"
+)
+
+func main() {
+	// Serve the plugin intro spect
+	// This will print the plugin intro spect and exit if the -introspect flag is provided
+	runtimeCfg, err := plugin.ServeAndRecvSpec(&plugin.IntroSpect{
+		ID:            PLUGIN_ID,
+		Name:          "Static Capture Example",
+		Author:        "aroz.org",
+		AuthorContact: "https://aroz.org",
+		Description:   "An example plugin implementing static capture",
+		URL:           "https://zoraxy.aroz.org",
+		Type:          plugin.PluginType_Router,
+		VersionMajor:  1,
+		VersionMinor:  0,
+		VersionPatch:  0,
+
+		/*
+			Static Capture Settings
+
+			Once plugin is enabled these rules always applies to the enabled HTTP Proxy rule
+			This is faster than dynamic capture, but less flexible
+
+			In this example, we will capture two paths
+			/test_a and /test_b. Once this plugin is enabled on a HTTP proxy rule, let say
+			https://example.com the plugin will capture all requests to
+			https://example.com/test_a and https://example.com/test_b
+			and reverse proxy it to the StaticCaptureIngress path of your plugin like
+			/static_capture/test_a and /static_capture/test_b
+		*/
+		StaticCapturePaths: []plugin.StaticCaptureRule{
+			{
+				CapturePath: "/test_a/",
+			},
+			{
+				CapturePath: "/test_b/",
+			},
+		},
+		StaticCaptureIngress: STATIC_CAPTURE_INGRESS,
+
+		UIPath: UI_PATH,
+	})
+	if err != nil {
+		//Terminate or enter standalone mode here
+		panic(err)
+	}
+
+	/*
+		Static Capture Router
+
+		The plugin library already provided a path router to handle the static capture
+		paths. The path router will capture the requests to the specified paths and
+		restore the original request path before forwarding it to the handler.
+
+		In this example, we will create a path router to handle the two capture paths
+		/test_a and /test_b. The path router will capture the requests to these paths
+		and print the request headers to the console.
+	*/
+	pathRouter := plugin.NewPathRouter()
+	pathRouter.SetDebugPrintMode(true)
+	pathRouter.RegisterPathHandler("/test_a/", http.HandlerFunc(HandleCaptureA))
+	pathRouter.RegisterPathHandler("/test_b/", http.HandlerFunc(HandleCaptureB))
+	pathRouter.SetDefaultHandler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		//In theory this should never be called
+		//but just in case the request is not captured by the path handlers
+		//like if you have forgotten to register the handler for the capture path
+		w.Header().Set("Content-Type", "text/html")
+		w.Write([]byte("This request is captured by the default handler!<br>Request URI: " + r.URL.String()))
+	}))
+	//Lastly, register the path routing to the default http mux (or the mux you are using)
+	pathRouter.RegisterHandle(STATIC_CAPTURE_INGRESS, http.DefaultServeMux)
+
+	//Create a path handler for the UI
+	http.HandleFunc(UI_PATH+"/", RenderDebugUI)
+	fmt.Println("Debugger started at http://127.0.0.1:" + strconv.Itoa(runtimeCfg.Port))
+	http.ListenAndServe("127.0.0.1:"+strconv.Itoa(runtimeCfg.Port), nil)
+}
+
+// Handle the captured request
+func HandleCaptureA(w http.ResponseWriter, r *http.Request) {
+	fmt.Println("Request captured by A handler")
+	w.Header().Set("Content-Type", "text/html")
+	w.Write([]byte("This request is captured by A handler!<br>Request URI: " + r.URL.String()))
+}
+
+func HandleCaptureB(w http.ResponseWriter, r *http.Request) {
+	fmt.Println("Request captured by B handler")
+	w.Header().Set("Content-Type", "text/html")
+	w.Write([]byte("This request is captured by the B handler!<br>Request URI: " + r.URL.String()))
+}

example/plugins/static_capture/mod/zoraxy_plugin/README.txt

@@ -0,0 +1,19 @@
+# Zoraxy Plugin
+
+## Overview
+This module serves as a template for building your own plugins for the Zoraxy Reverse Proxy. By copying this module to your plugin mod folder, you can create a new plugin with the necessary structure and components.
+
+## Instructions
+
+1. **Copy the Module:**
+    - Copy the entire `zoraxy_plugin` module to your plugin mod folder.
+
+2. **Include the Structure:**
+    - Ensure that you maintain the directory structure and file organization as provided in this module.
+
+3. **Modify as Needed:**
+    - Customize the copied module to implement the desired functionality for your plugin.
+
+## Directory Structure
+ zoraxy_plugin: Handle -introspect and -configuration process required for plugin loading and startup
+ embed_webserver: Handle embeded web server routing and injecting csrf token to your plugin served UI pages

example/plugins/static_capture/mod/zoraxy_plugin/embed_webserver.go

@@ -0,0 +1,128 @@
+package zoraxy_plugin
+
+import (
+	"embed"
+	"fmt"
+	"io/fs"
+	"net/http"
+	"net/url"
+	"os"
+	"strings"
+	"time"
+)
+
+type PluginUiRouter struct {
+	PluginID       string    //The ID of the plugin
+	TargetFs       *embed.FS //The embed.FS where the UI files are stored
+	TargetFsPrefix string    //The prefix of the embed.FS where the UI files are stored, e.g. /web
+	HandlerPrefix  string    //The prefix of the handler used to route this router, e.g. /ui
+
+	terminateHandler func() //The handler to be called when the plugin is terminated
+}
+
+// NewPluginEmbedUIRouter creates a new PluginUiRouter with embed.FS
+// The targetFsPrefix is the prefix of the embed.FS where the UI files are stored
+// The targetFsPrefix should be relative to the root of the embed.FS
+// The targetFsPrefix should start with a slash (e.g. /web) that corresponds to the root folder of the embed.FS
+// The handlerPrefix is the prefix of the handler used to route this router
+// The handlerPrefix should start with a slash (e.g. /ui) that matches the http.Handle path
+// All prefix should not end with a slash
+func NewPluginEmbedUIRouter(pluginID string, targetFs *embed.FS, targetFsPrefix string, handlerPrefix string) *PluginUiRouter {
+	//Make sure all prefix are in /prefix format
+	if !strings.HasPrefix(targetFsPrefix, "/") {
+		targetFsPrefix = "/" + targetFsPrefix
+	}
+	targetFsPrefix = strings.TrimSuffix(targetFsPrefix, "/")
+
+	if !strings.HasPrefix(handlerPrefix, "/") {
+		handlerPrefix = "/" + handlerPrefix
+	}
+	handlerPrefix = strings.TrimSuffix(handlerPrefix, "/")
+
+	//Return the PluginUiRouter
+	return &PluginUiRouter{
+		PluginID:       pluginID,
+		TargetFs:       targetFs,
+		TargetFsPrefix: targetFsPrefix,
+		HandlerPrefix:  handlerPrefix,
+	}
+}
+
+func (p *PluginUiRouter) populateCSRFToken(r *http.Request, fsHandler http.Handler) http.Handler {
+	//Get the CSRF token from header
+	csrfToken := r.Header.Get("X-Zoraxy-Csrf")
+	if csrfToken == "" {
+		csrfToken = "missing-csrf-token"
+	}
+
+	//Return the middleware
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		// Check if the request is for an HTML file
+		if strings.HasSuffix(r.URL.Path, "/") {
+			// Redirect to the index.html
+			http.Redirect(w, r, r.URL.Path+"index.html", http.StatusFound)
+			return
+		}
+		if strings.HasSuffix(r.URL.Path, ".html") {
+			//Read the target file from embed.FS
+			targetFilePath := strings.TrimPrefix(r.URL.Path, "/")
+			targetFilePath = p.TargetFsPrefix + "/" + targetFilePath
+			targetFilePath = strings.TrimPrefix(targetFilePath, "/")
+			targetFileContent, err := fs.ReadFile(*p.TargetFs, targetFilePath)
+			if err != nil {
+				http.Error(w, "File not found", http.StatusNotFound)
+				return
+			}
+			body := string(targetFileContent)
+			body = strings.ReplaceAll(body, "{{.csrfToken}}", csrfToken)
+			http.ServeContent(w, r, r.URL.Path, time.Now(), strings.NewReader(body))
+			return
+		}
+
+		//Call the next handler
+		fsHandler.ServeHTTP(w, r)
+	})
+
+}
+
+// GetHttpHandler returns the http.Handler for the PluginUiRouter
+func (p *PluginUiRouter) Handler() http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		//Remove the plugin UI handler path prefix
+		rewrittenURL := r.RequestURI
+		rewrittenURL = strings.TrimPrefix(rewrittenURL, p.HandlerPrefix)
+		rewrittenURL = strings.ReplaceAll(rewrittenURL, "//", "/")
+		r.URL, _ = url.Parse(rewrittenURL)
+		r.RequestURI = rewrittenURL
+
+		//Serve the file from the embed.FS
+		subFS, err := fs.Sub(*p.TargetFs, strings.TrimPrefix(p.TargetFsPrefix, "/"))
+		if err != nil {
+			fmt.Println(err.Error())
+			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+			return
+		}
+
+		// Replace {{csrf_token}} with the actual CSRF token and serve the file
+		p.populateCSRFToken(r, http.FileServer(http.FS(subFS))).ServeHTTP(w, r)
+	})
+}
+
+// RegisterTerminateHandler registers the terminate handler for the PluginUiRouter
+// The terminate handler will be called when the plugin is terminated from Zoraxy plugin manager
+// if mux is nil, the handler will be registered to http.DefaultServeMux
+func (p *PluginUiRouter) RegisterTerminateHandler(termFunc func(), mux *http.ServeMux) {
+	p.terminateHandler = termFunc
+	if mux == nil {
+		mux = http.DefaultServeMux
+	}
+	mux.HandleFunc(p.HandlerPrefix+"/term", func(w http.ResponseWriter, r *http.Request) {
+		p.terminateHandler()
+		w.WriteHeader(http.StatusOK)
+		go func() {
+			//Make sure the response is sent before the plugin is terminated
+			time.Sleep(100 * time.Millisecond)
+			os.Exit(0)
+		}()
+	})
+}

example/plugins/static_capture/mod/zoraxy_plugin/static_router.go

@@ -0,0 +1,103 @@
+package zoraxy_plugin
+
+import (
+	"fmt"
+	"net/http"
+	"sort"
+	"strings"
+)
+
+type PathRouter struct {
+	enableDebugPrint bool
+	pathHandlers     map[string]http.Handler
+	defaultHandler   http.Handler
+}
+
+// NewPathRouter creates a new PathRouter
+func NewPathRouter() *PathRouter {
+	return &PathRouter{
+		enableDebugPrint: false,
+		pathHandlers:     make(map[string]http.Handler),
+	}
+}
+
+// RegisterPathHandler registers a handler for a path
+func (p *PathRouter) RegisterPathHandler(path string, handler http.Handler) {
+	path = strings.TrimSuffix(path, "/")
+	p.pathHandlers[path] = handler
+}
+
+// RemovePathHandler removes a handler for a path
+func (p *PathRouter) RemovePathHandler(path string) {
+	delete(p.pathHandlers, path)
+}
+
+// SetDefaultHandler sets the default handler for the router
+// This handler will be called if no path handler is found
+func (p *PathRouter) SetDefaultHandler(handler http.Handler) {
+	p.defaultHandler = handler
+}
+
+// SetDebugPrintMode sets the debug print mode
+func (p *PathRouter) SetDebugPrintMode(enable bool) {
+	p.enableDebugPrint = enable
+}
+
+func (p *PathRouter) RegisterHandle(capture_ingress string, mux *http.ServeMux) {
+	if !strings.HasSuffix(capture_ingress, "/") {
+		capture_ingress = capture_ingress + "/"
+	}
+	mux.Handle(capture_ingress, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		p.ServeHTTP(w, r)
+	}))
+}
+
+func (p *PathRouter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	capturePath := r.Header.Get("X-Zoraxy-Capture")
+	if capturePath != "" {
+		if p.enableDebugPrint {
+			fmt.Printf("Using capture path: %s\n", capturePath)
+		}
+		originalURI := r.Header.Get("X-Zoraxy-Uri")
+		r.URL.Path = originalURI
+		if handler, ok := p.pathHandlers[capturePath]; ok {
+			handler.ServeHTTP(w, r)
+			return
+		}
+	}
+	p.defaultHandler.ServeHTTP(w, r)
+}
+
+func (p *PathRouter) PrintRequestDebugMessage(r *http.Request) {
+	if p.enableDebugPrint {
+		fmt.Printf("Capture Request with path: %s \n\n**Request Headers** \n\n", r.URL.Path)
+		keys := make([]string, 0, len(r.Header))
+		for key := range r.Header {
+			keys = append(keys, key)
+		}
+		sort.Strings(keys)
+		for _, key := range keys {
+			for _, value := range r.Header[key] {
+				fmt.Printf("%s: %s\n", key, value)
+			}
+		}
+
+		fmt.Printf("\n\n**Request Details**\n\n")
+		fmt.Printf("Method: %s\n", r.Method)
+		fmt.Printf("URL: %s\n", r.URL.String())
+		fmt.Printf("Proto: %s\n", r.Proto)
+		fmt.Printf("Host: %s\n", r.Host)
+		fmt.Printf("RemoteAddr: %s\n", r.RemoteAddr)
+		fmt.Printf("RequestURI: %s\n", r.RequestURI)
+		fmt.Printf("ContentLength: %d\n", r.ContentLength)
+		fmt.Printf("TransferEncoding: %v\n", r.TransferEncoding)
+		fmt.Printf("Close: %v\n", r.Close)
+		fmt.Printf("Form: %v\n", r.Form)
+		fmt.Printf("PostForm: %v\n", r.PostForm)
+		fmt.Printf("MultipartForm: %v\n", r.MultipartForm)
+		fmt.Printf("Trailer: %v\n", r.Trailer)
+		fmt.Printf("RemoteAddr: %s\n", r.RemoteAddr)
+		fmt.Printf("RequestURI: %s\n", r.RequestURI)
+
+	}
+}

example/plugins/static_capture/mod/zoraxy_plugin/zoraxy_plugin.go

@@ -0,0 +1,175 @@
+package zoraxy_plugin
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"strings"
+)
+
+/*
+	Plugins Includes.go
+
+	This file is copied from Zoraxy source code
+	You can always find the latest version under mod/plugins/includes.go
+	Usually this file are backward compatible
+*/
+
+type PluginType int
+
+const (
+	PluginType_Router    PluginType = 0 //Router Plugin, used for handling / routing / forwarding traffic
+	PluginType_Utilities PluginType = 1 //Utilities Plugin, used for utilities like Zerotier or Static Web Server that do not require interception with the dpcore
+)
+
+type StaticCaptureRule struct {
+	CapturePath string `json:"capture_path"`
+	//To be expanded
+}
+
+type ControlStatusCode int
+
+const (
+	ControlStatusCode_CAPTURED  ControlStatusCode = 280 //Traffic captured by plugin, ask Zoraxy not to process the traffic
+	ControlStatusCode_UNHANDLED ControlStatusCode = 284 //Traffic not handled by plugin, ask Zoraxy to process the traffic
+	ControlStatusCode_ERROR     ControlStatusCode = 580 //Error occurred while processing the traffic, ask Zoraxy to process the traffic and log the error
+)
+
+type SubscriptionEvent struct {
+	EventName   string `json:"event_name"`
+	EventSource string `json:"event_source"`
+	Payload     string `json:"payload"` //Payload of the event, can be empty
+}
+
+type RuntimeConstantValue struct {
+	ZoraxyVersion string `json:"zoraxy_version"`
+	ZoraxyUUID    string `json:"zoraxy_uuid"`
+}
+
+/*
+IntroSpect Payload
+
+When the plugin is initialized with -introspect flag,
+the plugin shell return this payload as JSON and exit
+*/
+type IntroSpect struct {
+	/* Plugin metadata */
+	ID            string     `json:"id"`             //Unique ID of your plugin, recommended using your own domain in reverse like com.yourdomain.pluginname
+	Name          string     `json:"name"`           //Name of your plugin
+	Author        string     `json:"author"`         //Author name of your plugin
+	AuthorContact string     `json:"author_contact"` //Author contact of your plugin, like email
+	Description   string     `json:"description"`    //Description of your plugin
+	URL           string     `json:"url"`            //URL of your plugin
+	Type          PluginType `json:"type"`           //Type of your plugin, Router(0) or Utilities(1)
+	VersionMajor  int        `json:"version_major"`  //Major version of your plugin
+	VersionMinor  int        `json:"version_minor"`  //Minor version of your plugin
+	VersionPatch  int        `json:"version_patch"`  //Patch version of your plugin
+
+	/*
+
+		Endpoint Settings
+
+	*/
+
+	/*
+		Static Capture Settings
+
+		Once plugin is enabled these rules always applies to the enabled HTTP Proxy rule
+		This is faster than dynamic capture, but less flexible
+	*/
+	StaticCapturePaths   []StaticCaptureRule `json:"static_capture_paths"`   //Static capture paths of your plugin, see Zoraxy documentation for more details
+	StaticCaptureIngress string              `json:"static_capture_ingress"` //Static capture ingress path of your plugin (e.g. /s_handler)
+
+	/*
+		Dynamic Capture Settings
+
+		Once plugin is enabled, these rules will be captured and forward to plugin sniff
+		if the plugin sniff returns 280, the traffic will be captured
+		otherwise, the traffic will be forwarded to the next plugin
+		This is slower than static capture, but more flexible
+	*/
+	DynamicCaptureSniff   string `json:"dynamic_capture_sniff"`   //Dynamic capture sniff path of your plugin (e.g. /d_sniff)
+	DynamicCaptureIngress string `json:"dynamic_capture_ingress"` //Dynamic capture ingress path of your plugin (e.g. /d_handler)
+
+	/* UI Path for your plugin */
+	UIPath string `json:"ui_path"` //UI path of your plugin (e.g. /ui), will proxy the whole subpath tree to Zoraxy Web UI as plugin UI
+
+	/* Subscriptions Settings */
+	SubscriptionPath    string            `json:"subscription_path"`    //Subscription event path of your plugin (e.g. /notifyme), a POST request with SubscriptionEvent as body will be sent to this path when the event is triggered
+	SubscriptionsEvents map[string]string `json:"subscriptions_events"` //Subscriptions events of your plugin, see Zoraxy documentation for more details
+}
+
+/*
+ServeIntroSpect Function
+
+This function will check if the plugin is initialized with -introspect flag,
+if so, it will print the intro spect and exit
+
+Place this function at the beginning of your plugin main function
+*/
+func ServeIntroSpect(pluginSpect *IntroSpect) {
+	if len(os.Args) > 1 && os.Args[1] == "-introspect" {
+		//Print the intro spect and exit
+		jsonData, _ := json.MarshalIndent(pluginSpect, "", " ")
+		fmt.Println(string(jsonData))
+		os.Exit(0)
+	}
+}
+
+/*
+ConfigureSpec Payload
+
+Zoraxy will start your plugin with -configure flag,
+the plugin shell read this payload as JSON and configure itself
+by the supplied values like starting a web server at given port
+that listens to 127.0.0.1:port
+*/
+type ConfigureSpec struct {
+	Port         int                  `json:"port"`          //Port to listen
+	RuntimeConst RuntimeConstantValue `json:"runtime_const"` //Runtime constant values
+	//To be expanded
+}
+
+/*
+RecvExecuteConfigureSpec Function
+
+This function will read the configure spec from Zoraxy
+and return the ConfigureSpec object
+
+Place this function after ServeIntroSpect function in your plugin main function
+*/
+func RecvConfigureSpec() (*ConfigureSpec, error) {
+	for i, arg := range os.Args {
+		if strings.HasPrefix(arg, "-configure=") {
+			var configSpec ConfigureSpec
+			if err := json.Unmarshal([]byte(arg[11:]), &configSpec); err != nil {
+				return nil, err
+			}
+			return &configSpec, nil
+		} else if arg == "-configure" {
+			var configSpec ConfigureSpec
+			var nextArg string
+			if len(os.Args) > i+1 {
+				nextArg = os.Args[i+1]
+				if err := json.Unmarshal([]byte(nextArg), &configSpec); err != nil {
+					return nil, err
+				}
+			} else {
+				return nil, fmt.Errorf("No port specified after -configure flag")
+			}
+			return &configSpec, nil
+		}
+	}
+	return nil, fmt.Errorf("No -configure flag found")
+}
+
+/*
+ServeAndRecvSpec Function
+
+This function will serve the intro spect and return the configure spec
+See the ServeIntroSpect and RecvConfigureSpec for more details
+*/
+func ServeAndRecvSpec(pluginSpect *IntroSpect) (*ConfigureSpec, error) {
+	ServeIntroSpect(pluginSpect)
+	return RecvConfigureSpec()
+}

example/plugins/static_capture/ui_info.go

@@ -0,0 +1,26 @@
+package main
+
+import (
+	_ "embed"
+	"fmt"
+	"net/http"
+	"sort"
+)
+
+// Render the debug UI
+func RenderDebugUI(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprint(w, "**static_capture Debug Interface**\n\n[Recv Headers] \n")
+
+	headerKeys := make([]string, 0, len(r.Header))
+	for name := range r.Header {
+		headerKeys = append(headerKeys, name)
+	}
+	sort.Strings(headerKeys)
+	for _, name := range headerKeys {
+		values := r.Header[name]
+		for _, value := range values {
+			fmt.Fprintf(w, "%s: %s\n", name, value)
+		}
+	}
+	w.Header().Set("Content-Type", "text/html")
+}

example/plugins/ztnc/mod/zoraxy_plugin/static_router.go

@@ -0,0 +1,103 @@
+package zoraxy_plugin
+
+import (
+	"fmt"
+	"net/http"
+	"sort"
+	"strings"
+)
+
+type PathRouter struct {
+	enableDebugPrint bool
+	pathHandlers     map[string]http.Handler
+	defaultHandler   http.Handler
+}
+
+// NewPathRouter creates a new PathRouter
+func NewPathRouter() *PathRouter {
+	return &PathRouter{
+		enableDebugPrint: false,
+		pathHandlers:     make(map[string]http.Handler),
+	}
+}
+
+// RegisterPathHandler registers a handler for a path
+func (p *PathRouter) RegisterPathHandler(path string, handler http.Handler) {
+	path = strings.TrimSuffix(path, "/")
+	p.pathHandlers[path] = handler
+}
+
+// RemovePathHandler removes a handler for a path
+func (p *PathRouter) RemovePathHandler(path string) {
+	delete(p.pathHandlers, path)
+}
+
+// SetDefaultHandler sets the default handler for the router
+// This handler will be called if no path handler is found
+func (p *PathRouter) SetDefaultHandler(handler http.Handler) {
+	p.defaultHandler = handler
+}
+
+// SetDebugPrintMode sets the debug print mode
+func (p *PathRouter) SetDebugPrintMode(enable bool) {
+	p.enableDebugPrint = enable
+}
+
+func (p *PathRouter) RegisterHandle(capture_ingress string, mux *http.ServeMux) {
+	if !strings.HasSuffix(capture_ingress, "/") {
+		capture_ingress = capture_ingress + "/"
+	}
+	mux.Handle(capture_ingress, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		p.ServeHTTP(w, r)
+	}))
+}
+
+func (p *PathRouter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	capturePath := r.Header.Get("X-Zoraxy-Capture")
+	if capturePath != "" {
+		if p.enableDebugPrint {
+			fmt.Printf("Using capture path: %s\n", capturePath)
+		}
+		originalURI := r.Header.Get("X-Zoraxy-Uri")
+		r.URL.Path = originalURI
+		if handler, ok := p.pathHandlers[capturePath]; ok {
+			handler.ServeHTTP(w, r)
+			return
+		}
+	}
+	p.defaultHandler.ServeHTTP(w, r)
+}
+
+func (p *PathRouter) PrintRequestDebugMessage(r *http.Request) {
+	if p.enableDebugPrint {
+		fmt.Printf("Capture Request with path: %s \n\n**Request Headers** \n\n", r.URL.Path)
+		keys := make([]string, 0, len(r.Header))
+		for key := range r.Header {
+			keys = append(keys, key)
+		}
+		sort.Strings(keys)
+		for _, key := range keys {
+			for _, value := range r.Header[key] {
+				fmt.Printf("%s: %s\n", key, value)
+			}
+		}
+
+		fmt.Printf("\n\n**Request Details**\n\n")
+		fmt.Printf("Method: %s\n", r.Method)
+		fmt.Printf("URL: %s\n", r.URL.String())
+		fmt.Printf("Proto: %s\n", r.Proto)
+		fmt.Printf("Host: %s\n", r.Host)
+		fmt.Printf("RemoteAddr: %s\n", r.RemoteAddr)
+		fmt.Printf("RequestURI: %s\n", r.RequestURI)
+		fmt.Printf("ContentLength: %d\n", r.ContentLength)
+		fmt.Printf("TransferEncoding: %v\n", r.TransferEncoding)
+		fmt.Printf("Close: %v\n", r.Close)
+		fmt.Printf("Form: %v\n", r.Form)
+		fmt.Printf("PostForm: %v\n", r.PostForm)
+		fmt.Printf("MultipartForm: %v\n", r.MultipartForm)
+		fmt.Printf("Trailer: %v\n", r.Trailer)
+		fmt.Printf("RemoteAddr: %s\n", r.RemoteAddr)
+		fmt.Printf("RequestURI: %s\n", r.RequestURI)
+
+	}
+}

example/plugins/ztnc/mod/zoraxy_plugin/zoraxy_plugin.go

@@ -22,9 +22,9 @@ const (
 	PluginType_Utilities PluginType = 1 //Utilities Plugin, used for utilities like Zerotier or Static Web Server that do not require interception with the dpcore
 )
 
-type CaptureRule struct {
-	CapturePath     string `json:"capture_path"`
-	IncludeSubPaths bool   `json:"include_sub_paths"`
+type StaticCaptureRule struct {
+	CapturePath string `json:"capture_path"`
+	//To be expanded
 }
 
 type ControlStatusCode int
@@ -72,23 +72,24 @@ type IntroSpect struct {
 	*/
 
 	/*
-		Global Capture Settings
-
-		Once plugin is enabled these rules always applies, no matter which HTTP Proxy rule it is enabled on
-		This captures the whole traffic of Zoraxy
+		Static Capture Settings
 
+		Once plugin is enabled these rules always applies to the enabled HTTP Proxy rule
+		This is faster than dynamic capture, but less flexible
 	*/
-	GlobalCapturePaths   []CaptureRule `json:"global_capture_path"`    //Global traffic capture path of your plugin
-	GlobalCaptureIngress string        `json:"global_capture_ingress"` //Global traffic capture ingress path of your plugin (e.g. /g_handler)
+	StaticCapturePaths   []StaticCaptureRule `json:"static_capture_paths"`   //Static capture paths of your plugin, see Zoraxy documentation for more details
+	StaticCaptureIngress string              `json:"static_capture_ingress"` //Static capture ingress path of your plugin (e.g. /s_handler)
 
 	/*
-		Always Capture Settings
+		Dynamic Capture Settings
 
-		Once the plugin is enabled on a given HTTP Proxy rule,
-		these always applies
+		Once plugin is enabled, these rules will be captured and forward to plugin sniff
+		if the plugin sniff returns 280, the traffic will be captured
+		otherwise, the traffic will be forwarded to the next plugin
+		This is slower than static capture, but more flexible
 	*/
-	AlwaysCapturePaths   []CaptureRule `json:"always_capture_path"`    //Always capture path of your plugin when enabled on a HTTP Proxy rule (e.g. /myapp)
-	AlwaysCaptureIngress string        `json:"always_capture_ingress"` //Always capture ingress path of your plugin when enabled on a HTTP Proxy rule (e.g. /a_handler)
+	DynamicCaptureSniff   string `json:"dynamic_capture_sniff"`   //Dynamic capture sniff path of your plugin (e.g. /d_sniff)
+	DynamicCaptureIngress string `json:"dynamic_capture_ingress"` //Dynamic capture ingress path of your plugin (e.g. /d_handler)
 
 	/* UI Path for your plugin */
 	UIPath string `json:"ui_path"` //UI path of your plugin (e.g. /ui), will proxy the whole subpath tree to Zoraxy Web UI as plugin UI

src/def.go

@@ -23,7 +23,6 @@ import (
 	"imuslab.com/zoraxy/mod/dynamicproxy/redirection"
 	"imuslab.com/zoraxy/mod/email"
 	"imuslab.com/zoraxy/mod/forwardproxy"
-	"imuslab.com/zoraxy/mod/ganserv"
 	"imuslab.com/zoraxy/mod/geodb"
 	"imuslab.com/zoraxy/mod/info/logger"
 	"imuslab.com/zoraxy/mod/info/logviewer"
@@ -43,23 +42,24 @@ import (
 const (
 	/* Build Constants */
 	SYSTEM_NAME       = "Zoraxy"
-	SYSTEM_VERSION    = "3.1.9"
-	DEVELOPMENT_BUILD = false /* Development: Set to false to use embedded web fs */
+	SYSTEM_VERSION    = "3.2.0"
+	DEVELOPMENT_BUILD = true /* Development: Set to false to use embedded web fs */
 
 	/* System Constants */
-	TMP_FOLDER                 = "./tmp"
-	WEBSERV_DEFAULT_PORT       = 5487
-	MDNS_HOSTNAME_PREFIX       = "zoraxy_" /* Follow by node UUID */
-	MDNS_IDENTIFY_DEVICE_TYPE  = "Network Gateway"
-	MDNS_IDENTIFY_DOMAIN       = "zoraxy.aroz.org"
-	MDNS_IDENTIFY_VENDOR       = "imuslab.com"
-	MDNS_SCAN_TIMEOUT          = 30 /* Seconds */
-	MDNS_SCAN_UPDATE_INTERVAL  = 15 /* Minutes */
-	GEODB_CACHE_CLEAR_INTERVAL = 15 /* Minutes */
-	ACME_AUTORENEW_CONFIG_PATH = "./conf/acme_conf.json"
-	CSRF_COOKIENAME            = "zoraxy_csrf"
-	LOG_PREFIX                 = "zr"
-	LOG_EXTENSION              = ".log"
+	TMP_FOLDER                   = "./tmp"
+	WEBSERV_DEFAULT_PORT         = 5487
+	MDNS_HOSTNAME_PREFIX         = "zoraxy_" /* Follow by node UUID */
+	MDNS_IDENTIFY_DEVICE_TYPE    = "Network Gateway"
+	MDNS_IDENTIFY_DOMAIN         = "zoraxy.aroz.org"
+	MDNS_IDENTIFY_VENDOR         = "imuslab.com"
+	MDNS_SCAN_TIMEOUT            = 30 /* Seconds */
+	MDNS_SCAN_UPDATE_INTERVAL    = 15 /* Minutes */
+	GEODB_CACHE_CLEAR_INTERVAL   = 15 /* Minutes */
+	ACME_AUTORENEW_CONFIG_PATH   = "./conf/acme_conf.json"
+	CSRF_COOKIENAME              = "zoraxy_csrf"
+	LOG_PREFIX                   = "zr"
+	LOG_EXTENSION                = ".log"
+	STATISTIC_AUTO_SAVE_INTERVAL = 600 /* Seconds */
 
 	/* Configuration Folder Storage Path Constants */
 	CONF_HTTP_PROXY   = "./conf/proxy"
@@ -132,7 +132,6 @@ var (
 	statisticCollector *statistic.Collector      //Collecting statistic from visitors
 	uptimeMonitor      *uptime.Monitor           //Uptime monitor service worker
 	mdnsScanner        *mdns.MDNSHost            //mDNS discovery services
-	ganManager         *ganserv.NetworkManager   //Global Area Network Manager
 	webSshManager      *sshprox.Manager          //Web SSH connection service
 	streamProxyManager *streamproxy.Manager      //Stream Proxy Manager for TCP / UDP forwarding
 	acmeHandler        *acme.ACMEHandler         //Handler for ACME Certificate renew

src/go.mod

@@ -27,6 +27,7 @@ require (
 	cloud.google.com/go/auth v0.13.0 // indirect
 	cloud.google.com/go/auth/oauth2adapt v0.2.6 // indirect
 	github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resourcegraph/armresourcegraph v0.9.0 // indirect
+	github.com/armon/go-radix v1.0.0 // indirect
 	github.com/benbjohnson/clock v1.3.0 // indirect
 	github.com/ebitengine/purego v0.8.2 // indirect
 	github.com/go-ole/go-ole v1.2.6 // indirect

src/go.sum

@@ -88,6 +88,8 @@ github.com/andybalholm/brotli v1.0.4/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHG
 github.com/armon/circbuf v0.0.0-20150827004946-bbbad097214e/go.mod h1:3U/XgcO3hCbHZ8TKRvWD2dDTCfh9M9ya+I9JpbB7O8o=
 github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da/go.mod h1:Q73ZrmVTwzkszR9V5SSuryQ31EELlFMUz1kKyl939pY=
 github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
+github.com/armon/go-radix v1.0.0 h1:F4z6KzEeeQIMeLFa97iZU6vupzoecKdU5TX24SNppXI=
+github.com/armon/go-radix v1.0.0/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
 github.com/aws/aws-sdk-go-v2 v1.32.7 h1:ky5o35oENWi0JYWUZkB7WYvVPP+bcRF5/Iq7JWSb5Rw=
 github.com/aws/aws-sdk-go-v2 v1.32.7/go.mod h1:P5WJBrYqqbWVaOxgH0X/FYYD47/nooaPOZPlQdmiN2U=
 github.com/aws/aws-sdk-go-v2/config v1.28.7 h1:GduUnoTXlhkgnxTD93g1nv4tVPILbdNQOzav+Wpg7AE=

src/mod/dynamicproxy/Server.go

@@ -23,6 +23,7 @@ import (
 		- Rate Limitor
 		- SSO Auth
 		- Basic Auth
+		- Plugin Router
 		- Vitrual Directory Proxy
 		- Subdomain Proxy
 	- Root router (default site router)
@@ -83,13 +84,19 @@ func (h *ProxyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 			}
 		}
 
-		//Validate basic auth
+		//Validate auth (basic auth or SSO auth)
 		respWritten := handleAuthProviderRouting(sep, w, r, h)
 		if respWritten {
 			//Request handled by subroute
 			return
 		}
 
+		//Plugin routing
+		if h.Parent.Option.PluginManager.HandleRoute(w, r, sep.Tags) {
+			//Request handled by subroute
+			return
+		}
+
 		//Check if any virtual directory rules matches
 		proxyingPath := strings.TrimSpace(r.RequestURI)
 		targetProxyEndpoint := sep.GetVirtualDirectoryHandlerFromRequestURI(proxyingPath)

src/mod/dynamicproxy/typedef.go

@@ -22,6 +22,7 @@ import (
 	"imuslab.com/zoraxy/mod/dynamicproxy/rewrite"
 	"imuslab.com/zoraxy/mod/geodb"
 	"imuslab.com/zoraxy/mod/info/logger"
+	"imuslab.com/zoraxy/mod/plugins"
 	"imuslab.com/zoraxy/mod/statistic"
 	"imuslab.com/zoraxy/mod/tlscert"
 )
@@ -59,6 +60,7 @@ type RouterOption struct {
 	StatisticCollector *statistic.Collector      //Statistic collector for storing stats on incoming visitors
 	WebDirectory       string                    //The static web server directory containing the templates folder
 	LoadBalancer       *loadbalance.RouteManager //Load balancer that handle load balancing of proxy target
+	PluginManager      *plugins.Manager          //Plugin manager for handling plugin routing
 
 	/* Authentication Providers */
 	AutheliaRouter *authelia.AutheliaRouter //Authelia router for Authelia authentication

src/mod/plugins/forwarder.go

@@ -1,26 +0,0 @@
-package plugins
-
-import "net/http"
-
-/*
-	Forwarder.go
-
-	This file handles the dynamic proxy routing forwarding
-	request to plugin capture path that handles the matching
-	request path registered when the plugin started
-*/
-
-func (m *Manager) GetHandlerPlugins(w http.ResponseWriter, r *http.Request) {
-
-}
-
-func (m *Manager) GetHandlerPluginsSubsets(w http.ResponseWriter, r *http.Request) {
-
-}
-
-func (p *Plugin) HandlePluginRoute(w http.ResponseWriter, r *http.Request) {
-	//Find the plugin that matches the request path
-	//If no plugin found, return 404
-	//If found, forward the request to the plugin
-
-}

src/mod/plugins/lifecycle.go

@@ -92,6 +92,9 @@ func (m *Manager) StartPlugin(pluginID string) error {
 	// Store the cmd object so it can be accessed later for stopping the plugin
 	plugin.(*Plugin).process = cmd
 	plugin.(*Plugin).Enabled = true
+
+	//Create a new static forwarder router for each of the static capture paths
+	plugin.(*Plugin).StartAllStaticPathRouters()
 	return nil
 }
 
@@ -198,6 +201,7 @@ func (m *Manager) StopPlugin(pluginID string) error {
 	//Remove the UI proxy
 	thisPlugin.uiProxy = nil
 	plugin.(*Plugin).Enabled = false
+	plugin.(*Plugin).StopAllStaticPathRouters()
 	return nil
 }
 

src/mod/plugins/plugins.go

@@ -11,10 +11,16 @@ package plugins
 
 import (
 	"errors"
+	"fmt"
+	"net/http"
+	"net/url"
 	"os"
 	"path/filepath"
+	"strconv"
+	"strings"
 	"sync"
 
+	"imuslab.com/zoraxy/mod/dynamicproxy/dpcore"
 	"imuslab.com/zoraxy/mod/utils"
 )
 
@@ -33,6 +39,7 @@ func NewPluginManager(options *ManagerOptions) *Manager {
 
 	return &Manager{
 		LoadedPlugins: sync.Map{},
+		TagPluginMap:  sync.Map{},
 		Options:       options,
 	}
 }
@@ -54,6 +61,7 @@ func (m *Manager) LoadPluginsFromDisk() error {
 				continue
 			}
 			thisPlugin.RootDir = filepath.ToSlash(pluginPath)
+			thisPlugin.staticRouteProxy = make(map[string]*dpcore.ReverseProxy)
 			m.LoadedPlugins.Store(thisPlugin.Spec.ID, thisPlugin)
 			m.Log("Loaded plugin: "+thisPlugin.Spec.Name, nil)
 
@@ -67,6 +75,9 @@ func (m *Manager) LoadPluginsFromDisk() error {
 		}
 	}
 
+	//Generate the static forwarder radix tree
+	m.UpdateTagsToTree()
+
 	return nil
 }
 
@@ -86,6 +97,8 @@ func (m *Manager) EnablePlugin(pluginID string) error {
 		return err
 	}
 	m.Options.Database.Write("plugins", pluginID, true)
+	//Generate the static forwarder radix tree
+	m.UpdateTagsToTree()
 	return nil
 }
 
@@ -96,6 +109,8 @@ func (m *Manager) DisablePlugin(pluginID string) error {
 	if err != nil {
 		return err
 	}
+	//Generate the static forwarder radix tree
+	m.UpdateTagsToTree()
 	return nil
 }
 
@@ -121,6 +136,16 @@ func (m *Manager) ListLoadedPlugins() ([]*Plugin, error) {
 	return plugins, nil
 }
 
+// Log a message with the plugin name
+func (m *Manager) LogForPlugin(p *Plugin, message string, err error) {
+	processID := -1
+	if p.process != nil && p.process.Process != nil {
+		// Get the process ID of the plugin
+		processID = p.process.Process.Pid
+	}
+	m.Log("["+p.Spec.Name+":"+strconv.Itoa(processID)+"] "+message, err)
+}
+
 // Terminate all plugins and exit
 func (m *Manager) Close() {
 	m.LoadedPlugins.Range(func(key, value interface{}) bool {
@@ -134,3 +159,65 @@ func (m *Manager) Close() {
 	//Wait until all loaded plugin process are terminated
 	m.BlockUntilAllProcessExited()
 }
+
+/* Plugin Functions */
+func (m *Plugin) StartAllStaticPathRouters() {
+	// Create a dpcore object for each of the static capture paths of the plugin
+	for _, captureRule := range m.Spec.StaticCapturePaths {
+		//Make sure the captureRule consists / prefix and no trailing /
+		if captureRule.CapturePath == "" {
+			continue
+		}
+		if !strings.HasPrefix(captureRule.CapturePath, "/") {
+			captureRule.CapturePath = "/" + captureRule.CapturePath
+		}
+		captureRule.CapturePath = strings.TrimSuffix(captureRule.CapturePath, "/")
+
+		// Create a new dpcore object to forward the traffic to the plugin
+		targetURL, err := url.Parse("http://127.0.0.1:" + strconv.Itoa(m.AssignedPort) + m.Spec.StaticCaptureIngress)
+		if err != nil {
+			fmt.Println("Failed to parse target URL: "+targetURL.String(), err)
+			continue
+		}
+		thisRouter := dpcore.NewDynamicProxyCore(targetURL, captureRule.CapturePath, &dpcore.DpcoreOptions{})
+		m.staticRouteProxy[captureRule.CapturePath] = thisRouter
+	}
+}
+
+func (m *Plugin) StopAllStaticPathRouters() {
+
+}
+
+func (p *Plugin) HandleRoute(w http.ResponseWriter, r *http.Request, longestPrefix string) {
+	longestPrefix = strings.TrimSuffix(longestPrefix, "/")
+	targetRouter := p.staticRouteProxy[longestPrefix]
+	if targetRouter == nil {
+		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+		fmt.Println("Error: target router not found for prefix", longestPrefix)
+		return
+	}
+
+	originalRequestURI := r.RequestURI
+
+	//Rewrite the request path to the plugin UI path
+	rewrittenURL := r.RequestURI
+	rewrittenURL = strings.TrimPrefix(rewrittenURL, longestPrefix)
+	rewrittenURL = strings.ReplaceAll(rewrittenURL, "//", "/")
+	if rewrittenURL == "" {
+		rewrittenURL = "/"
+	}
+	r.URL, _ = url.Parse(rewrittenURL)
+
+	targetRouter.ServeHTTP(w, r, &dpcore.ResponseRewriteRuleSet{
+		UseTLS:       false,
+		OriginalHost: r.Host,
+		ProxyDomain:  "127.0.0.1:" + strconv.Itoa(p.AssignedPort),
+		NoCache:      true,
+		PathPrefix:   longestPrefix,
+		UpstreamHeaders: [][]string{
+			{"X-Zoraxy-Capture", longestPrefix},
+			{"X-Zoraxy-URI", originalRequestURI},
+		},
+	})
+
+}

src/mod/plugins/static_forwarder.go

@@ -0,0 +1,82 @@
+package plugins
+
+import (
+	"errors"
+	"sync"
+
+	"github.com/armon/go-radix"
+)
+
+/*
+	Static Forwarder
+
+	This file handles the dynamic proxy routing forwarding
+	request to plugin capture path that handles the matching
+	request path registered when the plugin started
+*/
+
+func (m *Manager) UpdateTagsToTree() {
+	//build the tag to plugin pointer sync.Map
+	m.TagPluginMap = sync.Map{}
+	for tag, pluginIds := range m.Options.PluginGroups {
+		tree := m.GetForwarderRadixTreeFromPlugins(pluginIds)
+		m.TagPluginMap.Store(tag, tree)
+	}
+}
+
+// GenerateForwarderRadixTree generates the radix tree for static forwarders
+func (m *Manager) GetForwarderRadixTreeFromPlugins(pluginIds []string) *radix.Tree {
+	// Create a new radix tree
+	r := radix.New()
+
+	// Iterate over the loaded plugins and insert their paths into the radix tree
+	m.LoadedPlugins.Range(func(key, value interface{}) bool {
+		plugin := value.(*Plugin)
+		if !plugin.Enabled {
+			//Ignore disabled plugins
+			return true
+		}
+
+		// Check if the plugin ID is in the list of plugin IDs
+		includeThisPlugin := false
+		for _, id := range pluginIds {
+			if plugin.Spec.ID == id {
+				includeThisPlugin = true
+			}
+		}
+		if !includeThisPlugin {
+			return true
+		}
+
+		//For each of the plugin, insert the requested static capture paths
+		if len(plugin.Spec.StaticCapturePaths) > 0 {
+			for _, captureRule := range plugin.Spec.StaticCapturePaths {
+				_, ok := r.Get(captureRule.CapturePath)
+				m.LogForPlugin(plugin, "Assigned static capture path: "+captureRule.CapturePath, nil)
+				if !ok {
+					//If the path does not exist, create a new list
+					newPluginList := make([]*Plugin, 0)
+					newPluginList = append(newPluginList, plugin)
+					r.Insert(captureRule.CapturePath, newPluginList)
+				} else {
+					//The path has already been assigned to another plugin
+					pluginList, _ := r.Get(captureRule.CapturePath)
+					//pluginList = append(pluginList.([]*Plugin), plugin)
+					//r.Insert(captureRule.CapturePath, pluginList)
+
+					//Warn the path is already assigned to another plugin
+					if plugin.Spec.ID == pluginList.([]*Plugin)[0].Spec.ID {
+						m.Log("Duplicate path register for plugin: "+plugin.Spec.Name+" ("+plugin.Spec.ID+")", errors.New("duplcated path: "+captureRule.CapturePath))
+						continue
+					}
+					incompatiblePluginAInfo := pluginList.([]*Plugin)[0].Spec.Name + " (" + pluginList.([]*Plugin)[0].Spec.ID + ")"
+					incompatiblePluginBInfo := plugin.Spec.Name + " (" + plugin.Spec.ID + ")"
+					m.Log("Incompatible plugins: "+incompatiblePluginAInfo+" and "+incompatiblePluginBInfo, errors.New("incompatible plugins found for path: "+captureRule.CapturePath))
+				}
+			}
+		}
+		return true
+	})
+
+	return r
+}

src/mod/plugins/static_router.go

@@ -0,0 +1,47 @@
+package plugins
+
+import (
+	"net/http"
+	"sync"
+
+	"github.com/armon/go-radix"
+)
+
+// HandleRoute handles the request to the plugin
+// return true if the request is handled by the plugin
+func (m *Manager) HandleRoute(w http.ResponseWriter, r *http.Request, tags []string) bool {
+	if len(tags) == 0 {
+		return false
+	}
+
+	//For each tag, check if the request path matches the static capture path
+	var wg sync.WaitGroup                      //Wait group for the goroutines
+	var handler []*Plugin                      //The handler for the request, can be multiple plugins
+	var longestPrefixAcrossAlltags string = "" //The longest prefix across all tags
+	for _, tag := range tags {
+		wg.Add(1)
+		go func(thisTag string) {
+			defer wg.Done()
+			//Get the radix tree for the tag
+			tree, ok := m.TagPluginMap.Load(thisTag)
+			if !ok {
+				return
+			}
+			//Check if the request path matches the static capture path
+			longestPrefix, pluginList, ok := tree.(*radix.Tree).LongestPrefix(r.URL.Path)
+			if ok {
+				if longestPrefix > longestPrefixAcrossAlltags {
+					longestPrefixAcrossAlltags = longestPrefix
+					handler = pluginList.([]*Plugin)
+				}
+			}
+		}(tag)
+	}
+	wg.Wait()
+	if len(handler) > 0 {
+		//Handle the request
+		handler[0].HandleRoute(w, r, longestPrefixAcrossAlltags)
+		return true
+	}
+	return false
+}

src/mod/plugins/typdef.go

@@ -21,13 +21,15 @@ type Plugin struct {
 	Enabled bool                     //Whether the plugin is enabled
 
 	//Runtime
-	AssignedPort int                  //The assigned port for the plugin
-	uiProxy      *dpcore.ReverseProxy //The reverse proxy for the plugin UI
-	process      *exec.Cmd            //The process of the plugin
+	AssignedPort     int                             //The assigned port for the plugin
+	uiProxy          *dpcore.ReverseProxy            //The reverse proxy for the plugin UI
+	staticRouteProxy map[string]*dpcore.ReverseProxy //Storing longest prefix => dpcore map for static route
+	process          *exec.Cmd                       //The process of the plugin
 }
 
 type ManagerOptions struct {
-	PluginDir    string
+	PluginDir    string              //The directory where the plugins are stored
+	PluginGroups map[string][]string //The plugin groups,key is the tag name and the value is an array of plugin IDs
 	SystemConst  *zoraxyPlugin.RuntimeConstantValue
 	Database     *database.Database
 	Logger       *logger.Logger
@@ -36,5 +38,6 @@ type ManagerOptions struct {
 
 type Manager struct {
 	LoadedPlugins sync.Map //Storing *Plugin
+	TagPluginMap  sync.Map //Storing *radix.Tree for each plugin tag
 	Options       *ManagerOptions
 }

src/mod/plugins/uirouter.go

@@ -38,6 +38,9 @@ func (m *Manager) HandlePluginUI(pluginID string, w http.ResponseWriter, r *http
 	rewrittenURL := r.RequestURI
 	rewrittenURL = strings.TrimPrefix(rewrittenURL, matchingPath)
 	rewrittenURL = strings.ReplaceAll(rewrittenURL, "//", "/")
+	if rewrittenURL == "" {
+		rewrittenURL = "/"
+	}
 	r.URL, _ = url.Parse(rewrittenURL)
 
 	//Call the plugin UI handler

src/mod/plugins/zoraxy_plugin/static_router.go

@@ -0,0 +1,103 @@
+package zoraxy_plugin
+
+import (
+	"fmt"
+	"net/http"
+	"sort"
+	"strings"
+)
+
+type PathRouter struct {
+	enableDebugPrint bool
+	pathHandlers     map[string]http.Handler
+	defaultHandler   http.Handler
+}
+
+// NewPathRouter creates a new PathRouter
+func NewPathRouter() *PathRouter {
+	return &PathRouter{
+		enableDebugPrint: false,
+		pathHandlers:     make(map[string]http.Handler),
+	}
+}
+
+// RegisterPathHandler registers a handler for a path
+func (p *PathRouter) RegisterPathHandler(path string, handler http.Handler) {
+	path = strings.TrimSuffix(path, "/")
+	p.pathHandlers[path] = handler
+}
+
+// RemovePathHandler removes a handler for a path
+func (p *PathRouter) RemovePathHandler(path string) {
+	delete(p.pathHandlers, path)
+}
+
+// SetDefaultHandler sets the default handler for the router
+// This handler will be called if no path handler is found
+func (p *PathRouter) SetDefaultHandler(handler http.Handler) {
+	p.defaultHandler = handler
+}
+
+// SetDebugPrintMode sets the debug print mode
+func (p *PathRouter) SetDebugPrintMode(enable bool) {
+	p.enableDebugPrint = enable
+}
+
+func (p *PathRouter) RegisterHandle(capture_ingress string, mux *http.ServeMux) {
+	if !strings.HasSuffix(capture_ingress, "/") {
+		capture_ingress = capture_ingress + "/"
+	}
+	mux.Handle(capture_ingress, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		p.ServeHTTP(w, r)
+	}))
+}
+
+func (p *PathRouter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	capturePath := r.Header.Get("X-Zoraxy-Capture")
+	if capturePath != "" {
+		if p.enableDebugPrint {
+			fmt.Printf("Using capture path: %s\n", capturePath)
+		}
+		originalURI := r.Header.Get("X-Zoraxy-Uri")
+		r.URL.Path = originalURI
+		if handler, ok := p.pathHandlers[capturePath]; ok {
+			handler.ServeHTTP(w, r)
+			return
+		}
+	}
+	p.defaultHandler.ServeHTTP(w, r)
+}
+
+func (p *PathRouter) PrintRequestDebugMessage(r *http.Request) {
+	if p.enableDebugPrint {
+		fmt.Printf("Capture Request with path: %s \n\n**Request Headers** \n\n", r.URL.Path)
+		keys := make([]string, 0, len(r.Header))
+		for key := range r.Header {
+			keys = append(keys, key)
+		}
+		sort.Strings(keys)
+		for _, key := range keys {
+			for _, value := range r.Header[key] {
+				fmt.Printf("%s: %s\n", key, value)
+			}
+		}
+
+		fmt.Printf("\n\n**Request Details**\n\n")
+		fmt.Printf("Method: %s\n", r.Method)
+		fmt.Printf("URL: %s\n", r.URL.String())
+		fmt.Printf("Proto: %s\n", r.Proto)
+		fmt.Printf("Host: %s\n", r.Host)
+		fmt.Printf("RemoteAddr: %s\n", r.RemoteAddr)
+		fmt.Printf("RequestURI: %s\n", r.RequestURI)
+		fmt.Printf("ContentLength: %d\n", r.ContentLength)
+		fmt.Printf("TransferEncoding: %v\n", r.TransferEncoding)
+		fmt.Printf("Close: %v\n", r.Close)
+		fmt.Printf("Form: %v\n", r.Form)
+		fmt.Printf("PostForm: %v\n", r.PostForm)
+		fmt.Printf("MultipartForm: %v\n", r.MultipartForm)
+		fmt.Printf("Trailer: %v\n", r.Trailer)
+		fmt.Printf("RemoteAddr: %s\n", r.RemoteAddr)
+		fmt.Printf("RequestURI: %s\n", r.RequestURI)
+
+	}
+}

src/mod/plugins/zoraxy_plugin/zoraxy_plugin.go

@@ -22,9 +22,9 @@ const (
 	PluginType_Utilities PluginType = 1 //Utilities Plugin, used for utilities like Zerotier or Static Web Server that do not require interception with the dpcore
 )
 
-type CaptureRule struct {
-	CapturePath     string `json:"capture_path"`
-	IncludeSubPaths bool   `json:"include_sub_paths"`
+type StaticCaptureRule struct {
+	CapturePath string `json:"capture_path"`
+	//To be expanded
 }
 
 type ControlStatusCode int
@@ -72,23 +72,24 @@ type IntroSpect struct {
 	*/
 
 	/*
-		Global Capture Settings
-
-		Once plugin is enabled these rules always applies, no matter which HTTP Proxy rule it is enabled on
-		This captures the whole traffic of Zoraxy
+		Static Capture Settings
 
+		Once plugin is enabled these rules always applies to the enabled HTTP Proxy rule
+		This is faster than dynamic capture, but less flexible
 	*/
-	GlobalCapturePaths   []CaptureRule `json:"global_capture_path"`    //Global traffic capture path of your plugin
-	GlobalCaptureIngress string        `json:"global_capture_ingress"` //Global traffic capture ingress path of your plugin (e.g. /g_handler)
+	StaticCapturePaths   []StaticCaptureRule `json:"static_capture_paths"`   //Static capture paths of your plugin, see Zoraxy documentation for more details
+	StaticCaptureIngress string              `json:"static_capture_ingress"` //Static capture ingress path of your plugin (e.g. /s_handler)
 
 	/*
-		Always Capture Settings
+		Dynamic Capture Settings
 
-		Once the plugin is enabled on a given HTTP Proxy rule,
-		these always applies
+		Once plugin is enabled, these rules will be captured and forward to plugin sniff
+		if the plugin sniff returns 280, the traffic will be captured
+		otherwise, the traffic will be forwarded to the next plugin
+		This is slower than static capture, but more flexible
 	*/
-	AlwaysCapturePaths   []CaptureRule `json:"always_capture_path"`    //Always capture path of your plugin when enabled on a HTTP Proxy rule (e.g. /myapp)
-	AlwaysCaptureIngress string        `json:"always_capture_ingress"` //Always capture ingress path of your plugin when enabled on a HTTP Proxy rule (e.g. /a_handler)
+	DynamicCaptureSniff   string `json:"dynamic_capture_sniff"`   //Dynamic capture sniff path of your plugin (e.g. /d_sniff)
+	DynamicCaptureIngress string `json:"dynamic_capture_ingress"` //Dynamic capture ingress path of your plugin (e.g. /d_handler)
 
 	/* UI Path for your plugin */
 	UIPath string `json:"ui_path"` //UI path of your plugin (e.g. /ui), will proxy the whole subpath tree to Zoraxy Web UI as plugin UI

src/mod/statistic/statistic.go

@@ -50,6 +50,8 @@ type CollectorOption struct {
 
 type Collector struct {
 	rtdataStopChan chan bool
+	autoSaveTicker *time.Ticker
+	autSaveStop    chan bool
 	DailySummary   *DailySummary
 	Option         *CollectorOption
 }
@@ -78,6 +80,35 @@ func NewStatisticCollector(option CollectorOption) (*Collector, error) {
 	return &thisCollector, nil
 }
 
+// Set the autosave duration, the collector will save the daily summary to database
+// set saveInterval to 0 to disable autosave
+func (c *Collector) SetAutoSave(saveInterval int) {
+	//Stop the current ticker if exists
+	if c.autSaveStop != nil {
+		c.autSaveStop <- true
+	}
+
+	if saveInterval == 0 {
+		return
+	}
+
+	c.autSaveStop = make(chan bool)
+	ticker := time.NewTicker(time.Duration(saveInterval) * time.Second)
+	c.autoSaveTicker = ticker
+
+	go func() {
+		for {
+			select {
+			case <-ticker.C:
+				c.SaveSummaryOfDay()
+			case <-c.autSaveStop:
+				ticker.Stop()
+				return
+			}
+		}
+	}()
+}
+
 // Write the current in-memory summary to database file
 func (c *Collector) SaveSummaryOfDay() {
 	//When it is called in 0:00am, make sure it is stored as yesterday key
@@ -122,7 +153,6 @@ func (c *Collector) Close() {
 
 	//Write the buffered data into database
 	c.SaveSummaryOfDay()
-
 }
 
 // Main function to record all the inbound traffics

src/reverseproxy.go

@@ -108,6 +108,7 @@ func ReverseProxtInit() {
 		NoCache:            developmentMode,
 		ListenOnPort80:     listenOnPort80,
 		ForceHttpsRedirect: forceHttpsRedirect,
+		/* Routing Service Managers */
 		TlsManager:         tlsCertManager,
 		RedirectRuleTable:  redirectTable,
 		GeodbStore:         geodbStore,
@@ -116,7 +117,9 @@ func ReverseProxtInit() {
 		AccessController:   accessController,
 		AutheliaRouter:     autheliaRouter,
 		LoadBalancer:       loadBalancer,
-		Logger:             SystemWideLogger,
+		PluginManager:      pluginManager,
+		/* Utilities */
+		Logger: SystemWideLogger,
 	})
 	if err != nil {
 		SystemWideLogger.PrintAndLog("proxy-config", "Unable to create dynamic proxy router", err)