mirror of
https://github.com/router-for-me/CLIProxyAPI.git
synced 2026-11-22 01:42:39 +08:00
- Compress finalized Codex OAuth request bodies with zstd on the verified ChatGPT backend path, with size/benefit gating, header-body alignment, and one uncompressed retry on 400/415 rejection. - Negotiate downstream HTTP response compression under server.response-compression (zstd/gzip with q-values, SSE-safe flushing, commit-time Vary merging) and enable negotiated permessage-deflate on Codex and downstream WebSockets. - Advertise Accept-Encoding to Codex upstreams and decode gzip/deflate/br/zstd upstream responses through a shared decoder before parsing or relaying. Closes: #6905
182 lines
5.4 KiB
Go
182 lines
5.4 KiB
Go
package helps
|
|
|
|
import (
|
|
"bufio"
|
|
"compress/flate"
|
|
"compress/gzip"
|
|
"compress/zlib"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"strings"
|
|
|
|
"github.com/andybalholm/brotli"
|
|
"github.com/klauspost/compress/zstd"
|
|
log "github.com/sirupsen/logrus"
|
|
)
|
|
|
|
type compositeReadCloser struct {
|
|
io.Reader
|
|
closers []func() error
|
|
}
|
|
|
|
func (c *compositeReadCloser) Close() error {
|
|
var firstErr error
|
|
for i := range c.closers {
|
|
if c.closers[i] == nil {
|
|
continue
|
|
}
|
|
if errClose := c.closers[i](); errClose != nil && firstErr == nil {
|
|
firstErr = errClose
|
|
}
|
|
}
|
|
return firstErr
|
|
}
|
|
|
|
// peekableBody wraps a bufio.Reader around the original ReadCloser so that
|
|
// magic bytes can be inspected without consuming them from the stream.
|
|
type peekableBody struct {
|
|
*bufio.Reader
|
|
closer io.Closer
|
|
}
|
|
|
|
func (p *peekableBody) Close() error {
|
|
return p.closer.Close()
|
|
}
|
|
|
|
// DecodeResponseBody decodes declared encodings in reverse order, or sniffs gzip/zstd without a header.
|
|
// Closing the returned body also closes all decoders and the original body, including on setup errors.
|
|
func DecodeResponseBody(body io.ReadCloser, header http.Header) (io.ReadCloser, error) {
|
|
contentEncoding := strings.Join(header.Values("Content-Encoding"), ",")
|
|
if body == nil {
|
|
return nil, fmt.Errorf("response body is nil")
|
|
}
|
|
if contentEncoding == "" {
|
|
// No Content-Encoding header. Attempt best-effort magic-byte detection to
|
|
// handle misbehaving upstreams that compress without setting the header.
|
|
// Only gzip (1f 8b) and zstd (28 b5 2f fd) have reliable magic sequences;
|
|
// br and deflate have none and are left as-is.
|
|
// The bufio wrapper preserves unread bytes so callers always see the full
|
|
// stream regardless of whether decompression was applied.
|
|
pb := &peekableBody{Reader: bufio.NewReader(body), closer: body}
|
|
magic, peekErr := pb.Peek(4)
|
|
if peekErr == nil || (peekErr == io.EOF && len(magic) >= 2) {
|
|
switch {
|
|
case len(magic) >= 2 && magic[0] == 0x1f && magic[1] == 0x8b:
|
|
gzipReader, gzErr := gzip.NewReader(pb)
|
|
if gzErr != nil {
|
|
if errClose := pb.Close(); errClose != nil {
|
|
log.Errorf("response decoder: close body error: %v", errClose)
|
|
}
|
|
return nil, fmt.Errorf("magic-byte gzip: failed to create reader: %w", gzErr)
|
|
}
|
|
return &compositeReadCloser{
|
|
Reader: gzipReader,
|
|
closers: []func() error{
|
|
gzipReader.Close,
|
|
pb.Close,
|
|
},
|
|
}, nil
|
|
case len(magic) >= 4 && magic[0] == 0x28 && magic[1] == 0xb5 && magic[2] == 0x2f && magic[3] == 0xfd:
|
|
decoder, zdErr := zstd.NewReader(pb)
|
|
if zdErr != nil {
|
|
if errClose := pb.Close(); errClose != nil {
|
|
log.Errorf("response decoder: close body error: %v", errClose)
|
|
}
|
|
return nil, fmt.Errorf("magic-byte zstd: failed to create reader: %w", zdErr)
|
|
}
|
|
return &compositeReadCloser{
|
|
Reader: decoder,
|
|
closers: []func() error{
|
|
func() error { decoder.Close(); return nil },
|
|
pb.Close,
|
|
},
|
|
}, nil
|
|
}
|
|
}
|
|
return pb, nil
|
|
}
|
|
encodings := strings.Split(contentEncoding, ",")
|
|
reader := io.Reader(body)
|
|
decoderClosers := make([]func() error, 0, len(encodings))
|
|
cleanup := func() {
|
|
for i := len(decoderClosers) - 1; i >= 0; i-- {
|
|
if errClose := decoderClosers[i](); errClose != nil {
|
|
log.Errorf("response decoder: close decoder error: %v", errClose)
|
|
}
|
|
}
|
|
if errClose := body.Close(); errClose != nil {
|
|
log.Errorf("response decoder: close body error: %v", errClose)
|
|
}
|
|
}
|
|
for index := len(encodings) - 1; index >= 0; index-- {
|
|
encoding := strings.TrimSpace(strings.ToLower(encodings[index]))
|
|
switch encoding {
|
|
case "", "identity":
|
|
continue
|
|
case "gzip":
|
|
gzipReader, errGzip := gzip.NewReader(reader)
|
|
if errGzip != nil {
|
|
cleanup()
|
|
return nil, fmt.Errorf("failed to create gzip reader: %w", errGzip)
|
|
}
|
|
reader = gzipReader
|
|
decoderClosers = append(decoderClosers, gzipReader.Close)
|
|
case "deflate":
|
|
deflateReader, errDeflate := newResponseDeflateReader(reader)
|
|
if errDeflate != nil {
|
|
cleanup()
|
|
return nil, errDeflate
|
|
}
|
|
reader = deflateReader
|
|
decoderClosers = append(decoderClosers, deflateReader.Close)
|
|
case "br":
|
|
reader = brotli.NewReader(reader)
|
|
case "zstd":
|
|
decoder, errZstd := zstd.NewReader(reader)
|
|
if errZstd != nil {
|
|
cleanup()
|
|
return nil, fmt.Errorf("failed to create zstd reader: %w", errZstd)
|
|
}
|
|
reader = decoder
|
|
decoderClosers = append(decoderClosers, func() error {
|
|
decoder.Close()
|
|
return nil
|
|
})
|
|
default:
|
|
cleanup()
|
|
return nil, fmt.Errorf("unsupported content encoding %q", encoding)
|
|
}
|
|
}
|
|
if len(decoderClosers) == 0 && reader == body {
|
|
return body, nil
|
|
}
|
|
closers := make([]func() error, 0, len(decoderClosers)+1)
|
|
for index := len(decoderClosers) - 1; index >= 0; index-- {
|
|
closers = append(closers, decoderClosers[index])
|
|
}
|
|
closers = append(closers, body.Close)
|
|
return &compositeReadCloser{Reader: reader, closers: closers}, nil
|
|
}
|
|
|
|
func newResponseDeflateReader(reader io.Reader) (io.ReadCloser, error) {
|
|
buffered := bufio.NewReader(reader)
|
|
header, errPeek := buffered.Peek(2)
|
|
if errPeek == nil && isZlibHeader(header) {
|
|
zlibReader, errZlib := zlib.NewReader(buffered)
|
|
if errZlib != nil {
|
|
return nil, fmt.Errorf("failed to create zlib deflate reader: %w", errZlib)
|
|
}
|
|
return zlibReader, nil
|
|
}
|
|
return flate.NewReader(buffered), nil
|
|
}
|
|
|
|
func isZlibHeader(header []byte) bool {
|
|
if len(header) < 2 {
|
|
return false
|
|
}
|
|
cmf, flg := header[0], header[1]
|
|
return cmf&0x0f == 8 && cmf>>4 <= 7 && (uint16(cmf)<<8|uint16(flg))%31 == 0
|
|
}
|