From 186594ed3adabe2f2f0597336e7eff5d615a839d Mon Sep 17 00:00:00 2001 From: protonmatter Date: Tue, 17 Nov 2026 15:57:43 -0500 Subject: [PATCH] Cap every non-multipart body and answer an oversized one with 413. Handlers that decode JSON directly were still unbounded, and a body past the cap was reported as a bad request. --- server/asset_intercept.go | 6 +- server/auth.go | 6 +- server/conversations.go | 4 +- server/customtool.go | 4 +- server/decode_limit_test.go | 49 +++++++++++++- server/intercept.go | 16 ++--- server/server.go | 2 +- server/server_mgmt.go | 129 ++++++++++++++++++++++++++++-------- server/sync_scopesentry.go | 4 +- server/task_archives.go | 4 +- server/task_assets.go | 2 +- server/task_categories.go | 6 +- server/task_intercept.go | 6 +- server/task_metadata.go | 2 +- server/traffic_rewrite.go | 6 +- server/triggers.go | 4 +- server/workspace.go | 4 +- 17 files changed, 186 insertions(+), 68 deletions(-) diff --git a/server/asset_intercept.go b/server/asset_intercept.go index 56b677e..53091f5 100644 --- a/server/asset_intercept.go +++ b/server/asset_intercept.go @@ -36,7 +36,7 @@ func (s *Server) assetInterceptCreateRule(w http.ResponseWriter, r *http.Request return } var req assetInterceptRuleReq - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } @@ -63,7 +63,7 @@ func (s *Server) assetInterceptUpdateRule(w http.ResponseWriter, r *http.Request return } var req assetInterceptRuleReq - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } @@ -109,7 +109,7 @@ func (s *Server) assetInterceptToggleRule(w http.ResponseWriter, r *http.Request var req struct { Enabled bool `json:"enabled"` } - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } diff --git a/server/auth.go b/server/auth.go index b76a1d2..bf7335a 100644 --- a/server/auth.go +++ b/server/auth.go @@ -297,7 +297,7 @@ func (s *Server) authInit(w http.ResponseWriter, r *http.Request) { Password string `json:"password"` SetupToken string `json:"setup_token"` } - if err := decode(r, &req); err != nil || req.Password == "" { + if err := decode(w, r, &req); err != nil || req.Password == "" { writeErr(w, 400, "Password cannot be empty") return } @@ -354,7 +354,7 @@ func (s *Server) authChangePassword(w http.ResponseWriter, r *http.Request) { OldPassword string `json:"old_password"` NewPassword string `json:"new_password"` } - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, "Invalid request format") return } @@ -416,7 +416,7 @@ func (s *Server) login(w http.ResponseWriter, r *http.Request, getSetting func(s Username string `json:"username"` Password string `json:"password"` } - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, "Invalid request format") return } diff --git a/server/conversations.go b/server/conversations.go index 92acd1a..7c0d916 100644 --- a/server/conversations.go +++ b/server/conversations.go @@ -27,7 +27,7 @@ const ( func decodeConversationRequest(w http.ResponseWriter, r *http.Request, value any) bool { r.Body = http.MaxBytesReader(w, r.Body, maxConversationRequestBytes) - if err := decode(r, value); err != nil { + if err := decode(w, r, value); err != nil { var tooLarge *http.MaxBytesError if errors.As(err, &tooLarge) { writeErr(w, http.StatusRequestEntityTooLarge, "Request body too large") @@ -396,7 +396,7 @@ func (s *Server) pgSendConversationMessage(w http.ResponseWriter, r *http.Reques Message string `json:"message"` Attachments []chatAttachment `json:"attachments,omitempty"` // files uploaded via method 1 (paths relative to the conversation working dir) } - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } diff --git a/server/customtool.go b/server/customtool.go index e10f09a..09531ae 100644 --- a/server/customtool.go +++ b/server/customtool.go @@ -52,7 +52,7 @@ func (s *Server) pgCreateCustomTool(w http.ResponseWriter, r *http.Request) { return } var req customToolReq - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } @@ -104,7 +104,7 @@ func (s *Server) pgUpdateCustomTool(w http.ResponseWriter, r *http.Request) { return } var req customToolReq - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } diff --git a/server/decode_limit_test.go b/server/decode_limit_test.go index eb8eda0..dc8dd08 100644 --- a/server/decode_limit_test.go +++ b/server/decode_limit_test.go @@ -1,6 +1,8 @@ package server import ( + "encoding/json" + "errors" "net/http" "net/http/httptest" "strings" @@ -8,18 +10,59 @@ import ( ) func TestDecodeAcceptsSmallBody(t *testing.T) { + w := httptest.NewRecorder() r := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(`{"x":"ok"}`)) var v map[string]string - if err := decode(r, &v); err != nil || v["x"] != "ok" { + if err := decode(w, r, &v); err != nil || v["x"] != "ok" { t.Fatalf("decode: %v %+v", err, v) } } func TestDecodeCapsBody(t *testing.T) { + w := httptest.NewRecorder() body := strings.NewReader(`{"x":"` + strings.Repeat("a", decodeMaxBytes) + `"}`) r := httptest.NewRequest(http.MethodPost, "/", body) var v map[string]string - if err := decode(r, &v); err == nil { - t.Fatal("body over the limit was accepted") + err := decode(w, r, &v) + if !errors.Is(err, errBodyTooLarge) { + t.Fatalf("err=%v, want the body cap", err) + } +} + +func TestRawJSONBodyOverTheCapIs413(t *testing.T) { + h := limitRequestBody(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + var v map[string]string + if err := json.NewDecoder(r.Body).Decode(&v); err != nil { + writeErr(w, 400, err.Error()) + return + } + writeJSON(w, 200, v) + })) + small := httptest.NewRecorder() + h.ServeHTTP(small, httptest.NewRequest(http.MethodPost, "/", strings.NewReader(`{"x":"ok"}`))) + if small.Code != 200 { + t.Fatalf("small body status=%d", small.Code) + } + large := httptest.NewRecorder() + req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(`{"x":"`+strings.Repeat("a", decodeMaxBytes)+`"}`)) + h.ServeHTTP(large, req) + if large.Code != http.StatusRequestEntityTooLarge { + t.Fatalf("status=%d body=%s, want 413", large.Code, large.Body.String()) + } +} + +func TestMultipartBodyIsNotGivenTheJSONCap(t *testing.T) { + h := limitRequestBody(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if _, ok := r.Body.(*limitedBody); ok { + t.Errorf("multipart body was given the JSON cap") + } + w.WriteHeader(http.StatusNoContent) + })) + r := httptest.NewRequest(http.MethodPost, "/", strings.NewReader("not-read")) + r.Header.Set("Content-Type", "multipart/form-data; boundary=abc") + w := httptest.NewRecorder() + h.ServeHTTP(w, r) + if w.Code != http.StatusNoContent { + t.Fatalf("status=%d", w.Code) } } diff --git a/server/intercept.go b/server/intercept.go index b4b3542..179d0c4 100644 --- a/server/intercept.go +++ b/server/intercept.go @@ -141,7 +141,7 @@ func (s *Server) interceptCreateRule(w http.ResponseWriter, r *http.Request) { return } var req interceptRuleReq - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } @@ -169,7 +169,7 @@ func (s *Server) interceptUpdateRule(w http.ResponseWriter, r *http.Request) { return } var req interceptRuleReq - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } @@ -217,7 +217,7 @@ func (s *Server) interceptToggleRule(w http.ResponseWriter, r *http.Request) { var req struct { Enabled bool `json:"enabled"` } - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } @@ -400,7 +400,7 @@ func (s *Server) interceptDecide(w http.ResponseWriter, r *http.Request) { var req struct { Decision string `json:"decision"` // "allowed" | "denied" } - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } @@ -445,7 +445,7 @@ func (s *Server) interceptBatchDecide(w http.ResponseWriter, r *http.Request) { IDs []int64 `json:"ids"` Decision string `json:"decision"` // "allowed" | "denied" } - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } @@ -647,7 +647,7 @@ func (s *Server) targetGateSetExemptions(w http.ResponseWriter, r *http.Request) var req struct { Exemptions []db.TargetExemption `json:"exemptions"` } - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } @@ -697,7 +697,7 @@ func (s *Server) interceptSetToolConfig(w http.ResponseWriter, r *http.Request) var req struct { EnabledTools []string `json:"enabled_tools"` } - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } @@ -722,7 +722,7 @@ func (s *Server) interceptGetJudgeConfig(w http.ResponseWriter, r *http.Request) // interceptSetJudgeConfig persists the judge configuration. func (s *Server) interceptSetJudgeConfig(w http.ResponseWriter, r *http.Request) { var req intercept.JudgeConfig - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } diff --git a/server/server.go b/server/server.go index 7956221..d68739e 100644 --- a/server/server.go +++ b/server/server.go @@ -992,7 +992,7 @@ func (s *Server) Handler() http.Handler { root := http.NewServeMux() root.Handle("/api/", api) root.Handle("/", s.webuiHandler()) - return root + return limitRequestBody(root) } // --- handlers --- diff --git a/server/server_mgmt.go b/server/server_mgmt.go index 903f1a2..bada08f 100644 --- a/server/server_mgmt.go +++ b/server/server_mgmt.go @@ -9,6 +9,7 @@ import ( "fmt" "io" "log" + "mime" "net/http" "net/url" "os" @@ -79,14 +80,88 @@ func pathInt(r *http.Request, name string) (int64, bool) { return n, err == nil } -// decodeMaxBytes is the default JSON body cap. Handlers that already wrapped -// the body with a smaller MaxBytesReader keep that smaller cap. Multipart -// uploads do not use decode. +// decodeMaxBytes is the default JSON body cap. Multipart uploads are not capped +// here; those handlers set their own limit. A smaller MaxBytesReader installed +// by a handler still wins, because it sits inside this one. const decodeMaxBytes = 32 << 20 -func decode(r *http.Request, v any) error { - r.Body = http.MaxBytesReader(nil, r.Body, decodeMaxBytes) - return json.NewDecoder(r.Body).Decode(v) +// errBodyTooLarge is decode's error for a body past the cap. Callers that answer +// 400 are turned into 413 by limitRequestBody once the read has hit the cap. +var errBodyTooLarge = errors.New("Request body too large") + +// limitedBody records a MaxBytesError so a later 400 can be answered as 413. +type limitedBody struct { + io.ReadCloser + tooLarge bool +} + +func (b *limitedBody) Read(p []byte) (int, error) { + n, err := b.ReadCloser.Read(p) + var tooLarge *http.MaxBytesError + if errors.As(err, &tooLarge) { + b.tooLarge = true + } + return n, err +} + +type bodyLimitWriter struct { + http.ResponseWriter + tooLarge func() bool +} + +func (b *bodyLimitWriter) WriteHeader(code int) { + if code == http.StatusBadRequest && b.tooLarge != nil && b.tooLarge() { + code = http.StatusRequestEntityTooLarge + } + b.ResponseWriter.WriteHeader(code) +} + +func (b *bodyLimitWriter) Flush() { + if f, ok := b.ResponseWriter.(http.Flusher); ok { + f.Flush() + } +} + +func (b *bodyLimitWriter) Unwrap() http.ResponseWriter { return b.ResponseWriter } + +// limitRequestBody caps a non-multipart body at decodeMaxBytes and passes the +// real ResponseWriter into MaxBytesReader. A handler that then answers 400 for +// that read is rewritten to 413. +func limitRequestBody(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if r.Body == nil || r.Body == http.NoBody || isMultipart(r) { + next.ServeHTTP(w, r) + return + } + body := &limitedBody{ReadCloser: http.MaxBytesReader(w, r.Body, decodeMaxBytes)} + r.Body = body + next.ServeHTTP(&bodyLimitWriter{ResponseWriter: w, tooLarge: func() bool { return body.tooLarge }}, r) + }) +} + +func isMultipart(r *http.Request) bool { + media, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return false + } + return strings.HasPrefix(media, "multipart/") +} + +func decode(w http.ResponseWriter, r *http.Request, v any) error { + if r.Body != nil { + if _, already := r.Body.(*limitedBody); !already { + r.Body = &limitedBody{ReadCloser: http.MaxBytesReader(w, r.Body, decodeMaxBytes)} + } + } + err := json.NewDecoder(r.Body).Decode(v) + var tooLarge *http.MaxBytesError + if errors.As(err, &tooLarge) { + if lb, ok := r.Body.(*limitedBody); ok { + lb.tooLarge = true + } + return errBodyTooLarge + } + return err } // ---------- tasks (delete) ---------- @@ -146,7 +221,7 @@ func (s *Server) pgDeleteTask(w http.ResponseWriter, r *http.Request) { return } var opts DeleteTaskOptions - if err := decode(r, &opts); err != nil && err != io.EOF { + if err := decode(w, r, &opts); err != nil && err != io.EOF { writeErr(w, 400, "invalid JSON: "+err.Error()) return } @@ -258,7 +333,7 @@ func (s *Server) pgCreateAgent(w http.ResponseWriter, r *http.Request) { return } var req struct{ Key, Name, Description string } - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } @@ -298,7 +373,7 @@ func (s *Server) pgUpdateAgent(w http.ResponseWriter, r *http.Request) { return } var req struct{ Name, Description string } - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } @@ -524,7 +599,7 @@ func (s *Server) pgSavePrompt(w http.ResponseWriter, r *http.Request) { return } var body struct{ Template, Note string } - if err := decode(r, &body); err != nil { + if err := decode(w, r, &body); err != nil { writeErr(w, 400, err.Error()) return } @@ -573,7 +648,7 @@ func (s *Server) pgSaveWrapup(w http.ResponseWriter, r *http.Request) { Prompt string `json:"prompt"` MaxTurns *int `json:"max_turns"` } - if err := decode(r, &body); err != nil { + if err := decode(w, r, &body); err != nil { writeErr(w, 400, err.Error()) return } @@ -627,7 +702,7 @@ func (s *Server) pgSaveTaskTimeoutWrapup(w http.ResponseWriter, r *http.Request) Prompt string `json:"prompt"` MaxTurns *int `json:"max_turns"` } - if err := decode(r, &body); err != nil { + if err := decode(w, r, &body); err != nil { writeErr(w, 400, err.Error()) return } @@ -697,7 +772,7 @@ func (s *Server) pgPreviewPrompt(w http.ResponseWriter, r *http.Request) { Template string `json:"template"` Sample map[string]string `json:"sample"` } - _ = decode(r, &body) + _ = decode(w, r, &body) vars, _ := pg.PromptVars(a.ID) if body.Template == "" { body.Template, _ = pg.CurrentPrompt(a.ID) @@ -732,7 +807,7 @@ func (s *Server) pgSetAgentVisibility(w http.ResponseWriter, r *http.Request) { MCP []int64 `json:"mcp"` Skill []string `json:"skill"` } - if err := decode(r, &body); err != nil { + if err := decode(w, r, &body); err != nil { writeErr(w, 400, err.Error()) return } @@ -805,7 +880,7 @@ func (s *Server) pgUpdateTool(w http.ResponseWriter, r *http.Request) { Agents []string `json:"agents"` Enabled bool `json:"enabled"` } - if err := decode(r, &body); err != nil { + if err := decode(w, r, &body); err != nil { writeErr(w, 400, err.Error()) return } @@ -971,7 +1046,7 @@ func (s *Server) pgSaveMCP(w http.ResponseWriter, r *http.Request) { return } var m db.MCPServer - if err := decode(r, &m); err != nil { + if err := decode(w, r, &m); err != nil { writeErr(w, 400, err.Error()) return } @@ -1190,7 +1265,7 @@ func (s *Server) fsCreateSkill(w http.ResponseWriter, r *http.Request) { MCPs []string `json:"mcps"` // optional; MCP servers this skill unlocks Instructions string `json:"instructions"` // optional; scaffolded if empty } - if err := decode(r, &body); err != nil { + if err := decode(w, r, &body); err != nil { writeErr(w, 400, err.Error()) return } @@ -1275,7 +1350,7 @@ func (s *Server) fsUpdateSkillMeta(w http.ResponseWriter, r *http.Request) { License *string `json:"license"` Compatibility *string `json:"compatibility"` } - if err := decode(r, &body); err != nil { + if err := decode(w, r, &body); err != nil { writeErr(w, 400, err.Error()) return } @@ -1796,7 +1871,7 @@ func (s *Server) fsWriteFile(w http.ResponseWriter, r *http.Request) { var body struct { Content string `json:"content"` } - if err := decode(r, &body); err != nil { + if err := decode(w, r, &body); err != nil { writeErr(w, 400, err.Error()) return } @@ -1827,7 +1902,7 @@ func (s *Server) fsCreateDir(w http.ResponseWriter, r *http.Request) { var body struct { Path string `json:"path"` } - if err := decode(r, &body); err != nil { + if err := decode(w, r, &body); err != nil { writeErr(w, 400, err.Error()) return } @@ -1896,7 +1971,7 @@ func (s *Server) pgToggleSkillVisibility(w http.ResponseWriter, r *http.Request) SkillName string `json:"skill_name"` Visible bool `json:"visible"` } - if err := decode(r, &body); err != nil { + if err := decode(w, r, &body); err != nil { writeErr(w, 400, err.Error()) return } @@ -1934,7 +2009,7 @@ func (s *Server) pgToggleVisibility(w http.ResponseWriter, r *http.Request) { ResourceID int64 `json:"resource_id"` Visible bool `json:"visible"` } - if err := decode(r, &body); err != nil { + if err := decode(w, r, &body); err != nil { writeErr(w, 400, err.Error()) return } @@ -1975,7 +2050,7 @@ func (s *Server) pgSaveProfile(w http.ResponseWriter, r *http.Request) { APIKey string `json:"api_key"` Streaming *bool `json:"streaming"` } - if err := decode(r, &body); err != nil { + if err := decode(w, r, &body); err != nil { writeErr(w, 400, err.Error()) return } @@ -2044,7 +2119,7 @@ func (s *Server) pgSaveLLMRetryPolicy(w http.ResponseWriter, r *http.Request) { return } var pol db.LLMRetryPolicy - if err := decode(r, &pol); err != nil { + if err := decode(w, r, &pol); err != nil { writeErr(w, 400, err.Error()) return } @@ -2116,7 +2191,7 @@ func (s *Server) pgActivateProfile(w http.ResponseWriter, r *http.Request) { var body struct { ID int64 `json:"id"` } - if err := decode(r, &body); err != nil { + if err := decode(w, r, &body); err != nil { writeErr(w, 400, err.Error()) return } @@ -2149,7 +2224,7 @@ func (s *Server) pgLLMPoolReset(w http.ResponseWriter, r *http.Request) { var body struct { ID int64 `json:"id"` // 0 / omitted = all } - if err := decode(r, &body); err != nil { + if err := decode(w, r, &body); err != nil { writeErr(w, 400, err.Error()) return } @@ -2176,7 +2251,7 @@ func (s *Server) pgListModels(w http.ResponseWriter, r *http.Request) { Proxy string `json:"proxy"` ProfileID *int64 `json:"profile_id"` // fallback: use stored key from this profile } - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } diff --git a/server/sync_scopesentry.go b/server/sync_scopesentry.go index 76372b5..849357c 100644 --- a/server/sync_scopesentry.go +++ b/server/sync_scopesentry.go @@ -124,7 +124,7 @@ func (s *Server) syncSSDatasource(w http.ResponseWriter, r *http.Request) { URL string `json:"url"` APIKey string `json:"api_key"` } - _ = decode(r, &body) // empty body = just create the placeholder + _ = decode(w, r, &body) // empty body = just create the placeholder body.URL = strings.TrimSpace(body.URL) body.APIKey = strings.TrimSpace(body.APIKey) @@ -266,7 +266,7 @@ func (s *Server) syncSSRun(w http.ResponseWriter, r *http.Request) { return } var req ssSyncReq - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, "invalid JSON: "+err.Error()) return } diff --git a/server/task_archives.go b/server/task_archives.go index b73dfb2..836c2d8 100644 --- a/server/task_archives.go +++ b/server/task_archives.go @@ -512,7 +512,7 @@ func (s *Server) queueTaskArchiveDelete(w http.ResponseWriter, r *http.Request) func (s *Server) queueTaskArchivesBatch(w http.ResponseWriter, r *http.Request) { var request archiveBatchRequest - if err := decode(r, &request); err != nil { + if err := decode(w, r, &request); err != nil { writeErr(w, 400, err.Error()) return } @@ -552,7 +552,7 @@ func (s *Server) queueTaskArchivesBatch(w http.ResponseWriter, r *http.Request) func (s *Server) queueTaskArchiveActionBatch(w http.ResponseWriter, r *http.Request, action string) { var request archiveBatchRequest - if err := decode(r, &request); err != nil { + if err := decode(w, r, &request); err != nil { writeErr(w, 400, err.Error()) return } diff --git a/server/task_assets.go b/server/task_assets.go index bdca4a5..bc66c97 100644 --- a/server/task_assets.go +++ b/server/task_assets.go @@ -33,7 +33,7 @@ func (s *Server) attachTaskAssets(w http.ResponseWriter, r *http.Request) { SourceSummary string `json:"source_summary"` Scope companyScopeInputs `json:"scope"` } - if err := decode(r, &request); err != nil { + if err := decode(w, r, &request); err != nil { var tooLarge *http.MaxBytesError if errors.As(err, &tooLarge) { writeErr(w, http.StatusRequestEntityTooLarge, "request body too large") diff --git a/server/task_categories.go b/server/task_categories.go index fee8e45..03d2ad9 100644 --- a/server/task_categories.go +++ b/server/task_categories.go @@ -21,7 +21,7 @@ type taskCategoryRequest struct { func decodeTaskCategoryRequest(w http.ResponseWriter, r *http.Request) (*taskCategoryRequest, bool) { r.Body = http.MaxBytesReader(w, r.Body, maxTaskCategoryRequestBytes) var request taskCategoryRequest - if err := decode(r, &request); err != nil { + if err := decode(w, r, &request); err != nil { var tooLarge *http.MaxBytesError if errors.As(err, &tooLarge) { writeErr(w, http.StatusRequestEntityTooLarge, "request body too large") @@ -150,7 +150,7 @@ func (s *Server) updateTaskCategory(w http.ResponseWriter, r *http.Request) { var request struct { CategoryID json.RawMessage `json:"category_id"` } - if err := decode(r, &request); err != nil { + if err := decode(w, r, &request); err != nil { writeErr(w, http.StatusBadRequest, err.Error()) return } @@ -184,7 +184,7 @@ func (s *Server) updateTasksCategoryBatch(w http.ResponseWriter, r *http.Request TaskIDs []string `json:"task_ids"` CategoryID json.RawMessage `json:"category_id"` } - if err := decode(r, &request); err != nil { + if err := decode(w, r, &request); err != nil { var tooLarge *http.MaxBytesError if errors.As(err, &tooLarge) { writeErr(w, http.StatusRequestEntityTooLarge, "request body too large") diff --git a/server/task_intercept.go b/server/task_intercept.go index c6eeefb..4635b1b 100644 --- a/server/task_intercept.go +++ b/server/task_intercept.go @@ -91,7 +91,7 @@ func (s *Server) taskInterceptCreateRule(w http.ResponseWriter, r *http.Request) return } var req taskInterceptRuleReq - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } @@ -123,7 +123,7 @@ func (s *Server) taskInterceptUpdateRule(w http.ResponseWriter, r *http.Request) return } var req taskInterceptRuleReq - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } @@ -180,7 +180,7 @@ func (s *Server) taskInterceptToggleRule(w http.ResponseWriter, r *http.Request) var req struct { Enabled bool `json:"enabled"` } - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } diff --git a/server/task_metadata.go b/server/task_metadata.go index 7bcd738..dde601a 100644 --- a/server/task_metadata.go +++ b/server/task_metadata.go @@ -30,7 +30,7 @@ func (s *Server) updateTaskMetadata(w http.ResponseWriter, r *http.Request) { PlanQuietMode *bool `json:"plan_quiet_mode"` TargetGate *bool `json:"target_gate"` } - if err := decode(r, &request); err != nil { + if err := decode(w, r, &request); err != nil { var tooLarge *http.MaxBytesError if errors.As(err, &tooLarge) { writeErr(w, http.StatusRequestEntityTooLarge, "request body too large") diff --git a/server/traffic_rewrite.go b/server/traffic_rewrite.go index b937794..8038fc3 100644 --- a/server/traffic_rewrite.go +++ b/server/traffic_rewrite.go @@ -216,7 +216,7 @@ func (s *Server) rewriteCreateRule(w http.ResponseWriter, r *http.Request) { return } var req rewriteRuleReq - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } @@ -249,7 +249,7 @@ func (s *Server) rewriteUpdateRule(w http.ResponseWriter, r *http.Request) { return } var req rewriteRuleReq - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } @@ -308,7 +308,7 @@ func (s *Server) rewriteToggleRule(w http.ResponseWriter, r *http.Request) { var req struct { Enabled bool `json:"enabled"` } - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } diff --git a/server/triggers.go b/server/triggers.go index 1064066..0b60837 100644 --- a/server/triggers.go +++ b/server/triggers.go @@ -60,7 +60,7 @@ func (s *Server) pgCreateTrigger(w http.ResponseWriter, r *http.Request) { return } var req triggerReq - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } @@ -96,7 +96,7 @@ func (s *Server) pgUpdateTrigger(w http.ResponseWriter, r *http.Request) { return } var req triggerReq - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } diff --git a/server/workspace.go b/server/workspace.go index df78e3e..0307343 100644 --- a/server/workspace.go +++ b/server/workspace.go @@ -139,7 +139,7 @@ func (s *Server) wsWrite(w http.ResponseWriter, r *http.Request) { Path string `json:"path"` Content string `json:"content"` } - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return } @@ -168,7 +168,7 @@ func (s *Server) wsMkdir(w http.ResponseWriter, r *http.Request) { var req struct { Path string `json:"path"` } - if err := decode(r, &req); err != nil { + if err := decode(w, r, &req); err != nil { writeErr(w, 400, err.Error()) return }