package server import ( "crypto/rand" "encoding/hex" "encoding/json" "errors" "io" "net/http" "net/url" "os" "path/filepath" "regexp" "strings" ) // maxChatUploadBytes bounds one file sent through POST /chat-uploads. Files // travel over plain HTTP, outside the 2 MiB websocket frame, so a prompt can // carry photos, logs and archives the inline base64 route cannot. const maxChatUploadBytes = 100 << 20 // chatUploadHeader carries the file's name. Being a custom header, it also // keeps a cross-site page from posting here without a CORS preflight, which // neither the server nor its proxies answer. const chatUploadHeader = "X-Pipelines-Upload-Name" var chatUploadName = regexp.MustCompile(`^up-[0-9a-f]{32}-[^/\\]+$`) type chatUploadReply struct { Upload string `json:"upload"` Name string `json:"name"` Mime string `json:"mime"` Size int64 `json:"size"` } // serveChatUpload stores the request body as one private chat attachment and // returns the name a later chat prompt references in ChatAttachment.Upload. func serveChatUpload(w http.ResponseWriter, r *http.Request) { fail := func(status int, message string) { http.Error(w, message, status) } rawName := r.Header.Get(chatUploadHeader) if rawName == "" { fail(http.StatusBadRequest, "missing "+chatUploadHeader) return } if r.Header.Get("Sec-Fetch-Site") == "cross-site" { fail(http.StatusForbidden, "cross-site upload refused") return } decoded, err := url.PathUnescape(rawName) if err != nil { decoded = rawName } name := safeChatAttachmentName(decoded) if r.ContentLength > maxChatUploadBytes { fail(http.StatusRequestEntityTooLarge, "attachment exceeds the 100 MiB limit") return } mime := strings.TrimSpace(r.Header.Get("Content-Type")) if mime == "" { mime = "application/octet-stream" } var token [16]byte if _, err := rand.Read(token[:]); err != nil { fail(http.StatusInternalServerError, "upload id unavailable") return } stored := "up-" + hex.EncodeToString(token[:]) + "-" + name chatAttachmentStore.Lock() root, dir, used, usedFiles, err := openChatAttachmentStore() if err != nil { chatAttachmentStore.Unlock() fail(http.StatusInternalServerError, err.Error()) return } defer root.Close() if usedFiles+1 > chatAttachmentFileQuota || used+max(r.ContentLength, 0) > chatAttachmentQuota { chatAttachmentStore.Unlock() fail(http.StatusInsufficientStorage, "chat attachment storage quota exceeded; retry after retention cleanup") return } file, err := root.OpenFile(stored, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o600) if err != nil { chatAttachmentStore.Unlock() fail(http.StatusInternalServerError, "write attachment: "+err.Error()) return } // Leased while it is written so retention cannot collect it mid-upload. path := filepath.Join(dir, stored) chatAttachmentStore.leased[path] = true chatAttachmentStore.Unlock() release := func(remove bool) { chatAttachmentStore.Lock() delete(chatAttachmentStore.leased, path) if remove { _ = root.Remove(stored) } chatAttachmentStore.Unlock() } size, err := io.Copy(file, io.LimitReader(r.Body, maxChatUploadBytes+1)) if err == nil && size > maxChatUploadBytes { err = errors.New("attachment exceeds the 100 MiB limit") } if err == nil { err = file.Sync() } if closeErr := file.Close(); err == nil { err = closeErr } if err == nil && size == 0 { err = errors.New("attachment is empty") } if err != nil { release(true) status := http.StatusBadRequest if size > maxChatUploadBytes { status = http.StatusRequestEntityTooLarge } fail(status, err.Error()) return } release(false) w.Header().Set("Content-Type", "application/json") w.Header().Set("Cache-Control", "no-store") _ = json.NewEncoder(w).Encode(chatUploadReply{Upload: stored, Name: name, Mime: mime, Size: size}) }