working commit

app/handler/aaafunc.go

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2026 Oleg Borodin <onborodin@gmail.com>
+ */
+package handler
+
+import (
+	"context"
+	"fmt"
+
+	"mproxy/app/router"
+	"mproxy/pkg/auxhttp"
+)
+
+const (
+	authTag = "authpass"
+	userTag = "accountID"
+)
+
+func (hand *Handler) AuthMiddleware(next router.Handler) router.Handler {
+	var handlerFunc router.HandlerFunc
+
+	handlerFunc = func(rctx *router.Context) {
+		success, err := hand.CheckAccess(rctx)
+		if success {
+			rctx.SetBool(authTag, true)
+		}
+		if err != nil {
+			hand.logg.Errorf("Authorization middleware error: %v", err)
+		}
+		next.ServeHTTP(rctx)
+	}
+	return handlerFunc
+}
+
+// Authentification
+func (hand *Handler) CheckAccess(rctx *router.Context) (bool, error) {
+	var err error
+	var success bool
+	var username string
+	var password string
+
+	authHeader := rctx.GetHeader("Proxy-Authorization")
+	hand.logg.Debugf("Proxy-Authorization: [%s]", authHeader)
+	if authHeader != "" {
+		username, password, err = auxhttp.ParseBasicAuth(authHeader)
+		if err != nil {
+			return success, err
+		}
+		success, err := hand.ValidatePassword(rctx.Ctx, username, password)
+		if err != nil {
+			return false, err
+		}
+		if !success {
+			err = fmt.Errorf("Incorrect username or password")
+			return false, err
+		}
+		return success, err
+	}
+	return success, err
+}
+
+func (hand *Handler) ValidatePassword(ctx context.Context, username, password string) (bool, error) {
+	var err error
+	valid := true
+	return valid, err
+}

app/handler/connect.go

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2026 Oleg Borodin <onborodin@gmail.com>
+ */
+package handler
+
+import (
+	"net/http"
+
+	"mproxy/app/proxoper"
+	"mproxy/app/router"
+)
+
+func (hand *Handler) ConnectTo(rctx *router.Context) {
+	hostaddr, _ := rctx.GetSubpath("hostaddr")
+	params := &proxoper.ConnectToParams{
+		Hostaddr: hostaddr,
+	}
+	ctx := rctx.GetContext()
+	_, err := hand.prop.ConnectTo(ctx, params)
+	if err != nil {
+		hand.logg.Errorf("ConnectTo error: %v", err)
+		rctx.SetStatus(http.StatusInternalServerError)
+		return
+	}
+	rctx.SetStatus(http.StatusOK)
+	return
+}

app/handler/handler.go

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2026 Oleg Borodin <onborodin@gmail.com>
+ */
+package handler
+
+import (
+	"mproxy/app/logger"
+	"mproxy/app/router"
+
+	"mproxy/app/proxoper"
+	"mproxy/app/servoper"
+
+	yaml "go.yaml.in/yaml/v4"
+)
+
+type HandlerParams struct {
+	ServOper *servoper.Operator
+	ProxOper *proxoper.Operator
+}
+
+type Handler struct {
+	logg *logger.Logger
+	seop *servoper.Operator
+	prop *proxoper.Operator
+}
+
+func NewHandler(params *HandlerParams) (*Handler, error) {
+	var err error
+	hand := &Handler{
+		seop: params.ServOper,
+		prop: params.ProxOper,
+	}
+	hand.logg = logger.NewLoggerWithSubject("handler")
+	return hand, err
+}
+
+func (hand *Handler) DumpHeaders(label string, rctx *router.Context) {
+	headers := rctx.GetHeaders()
+	yamlData, _ := yaml.Marshal(headers)
+	hand.logg.Debugf("%s:\n%s\n", label, string(yamlData))
+}

app/handler/notfound.go

@@ -0,0 +1,15 @@
+/*
+ * Copyright 2026 Oleg Borodin <onborodin@gmail.com>
+ */
+package handler
+
+import (
+	"net/http"
+
+	"mproxy/app/router"
+)
+
+func (hand *Handler) NotFound(rctx *router.Context) {
+	hand.logg.Warningf("Route for [%s %s] not found", rctx.Request.Method, rctx.Request.URL.String())
+	rctx.SetStatus(http.StatusNotFound)
+}

app/handler/response.go

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2026 Oleg Borodin <onborodin@gmail.com>
+ */
+package handler
+
+import (
+	"net/http"
+
+	"mproxy/app/router"
+)
+
+type Response[T any] struct {
+	Error   bool   `json:"error"             yaml:"error"`
+	Message string `json:"message,omitempty" yaml:"message,omitempty"`
+	Result  T      `json:"result,omitempty"  yaml:"result,result"`
+}
+
+func NewResponse[T any]() *Response[T] {
+	return &Response[T]{}
+}
+
+func (hand *Handler) SendResult(rctx *router.Context, result any) {
+	response := &Response[any]{
+		Error:  false,
+		Result: result,
+	}
+	rctx.SendJSON(http.StatusOK, response)
+}
+
+func (hand *Handler) SendError(rctx *router.Context, err error) {
+	response := &Response[any]{
+		Error:   true,
+		Message: err.Error(),
+	}
+	rctx.SendJSON(http.StatusOK, response)
+}

app/handler/service.go

@@ -0,0 +1,15 @@
+/*
+ * Copyright 2026 Oleg Borodin <onborodin@gmail.com>
+ */
+package handler
+
+import (
+	"mproxy/app/router"
+	"mproxy/app/servoper"
+)
+
+func (hand *Handler) SendHello(rctx *router.Context) {
+	params := &servoper.SendHelloParams{}
+	res, _ := hand.seop.SendHello(params)
+	hand.SendResult(rctx, res)
+}