types

type Addon interface {
	// A client has connected to mitmproxy. Note that a connection can correspond to multiple HTTP requests.
	ClientConnected(*conn.ClientConn)

	// A client connection has been closed (either by us or the client).
	ClientDisconnected(*conn.ClientConn)

	// Mitmproxy has connected to a server.
	ServerConnected(*conn.Context)

	// A server connection has been closed (either by us or the server).
	ServerDisconnected(*conn.Context)

	// The TLS handshake with the server has been completed successfully.
	TLSEstablishedServer(*conn.Context)

	// HTTP request headers were successfully read. At this point, the body is empty.
	Requestheaders(*Flow)

	// The full HTTP request has been read.
	Request(*Flow)

	// HTTP response headers were successfully read. At this point, the body is empty.
	Responseheaders(*Flow)

	// The full HTTP response has been read.
	Response(*Flow)

	// Stream request body modifier
	StreamRequestModifier(*Flow, io.Reader) io.Reader

	// Stream response body modifier
	StreamResponseModifier(*Flow, io.Reader) io.Reader

	// onAccessProxyServer
	AccessProxyServer(req *http.Request, res http.ResponseWriter)
}

type AddonNotifier interface {
	NotifyClientDisconnected(client *conn.ClientConn)
	NotifyServerDisconnected(connCtx *conn.Context)
}

type AddonRegistry interface {
	Get() []Addon
}

type BaseAddon struct{}

type ClientFactory interface {
	// CreateMainClient creates the main fallback/separate client.
	// Used when the request has been modified (different host/scheme) or when
	// UseSeparateClient is set. This client goes through the upstream proxy and supports
	// HTTP/2. It creates new connections rather than reusing existing ones.
	CreateMainClient(upstreamManager UpstreamManager, insecureSkipVerify bool) *http.Client

	// CreateHTTP2Client creates an HTTP/2 server connection client.
	// Created specifically for HTTP/2 connections when the negotiated protocol
	// is "h2". Uses http2.Transport and reuses the existing TLS connection
	// rather than creating new connections.
	CreateHTTP2Client(tlsConn *tls.Conn) *http.Client

	// CreatePlainHTTPClient creates a plain HTTP connection client.
	// Created for plain HTTP (non-TLS) connections. Explicitly disables HTTP/2
	// and reuses the existing plain connection via custom DialContext function.
	// This avoids creating new connections for each request on the same HTTP connection.
	CreatePlainHTTPClient(conn net.Conn) *http.Client

	// CreateHTTPSClient creates an HTTPS/TLS connection client.
	// Created for HTTPS connections after TLS handshake. Reuses the established
	// TLS connection via custom DialTLSContext function and allows HTTP/2
	// negotiation. This maintains persistent connections to upstream servers.
	CreateHTTPSClient(tlsConn *tls.Conn) *http.Client
}

type DefaultClientFactory struct{}

type Flow struct {
	ID          uuid.UUID
	ConnContext *conn.Context
	Request     *Request
	Response    *Response

	// https://docs.mitmproxy.org/stable/overview-features/#streaming
	// If true, Request.Body and Response.Body are not buffered, and will not enter subsequent Addon.Request and Addon.Response
	Stream            bool
	UseSeparateClient bool // use separate http client to send http request
	// contains filtered or unexported fields
}

type Request struct {
	Method string
	URL    *url.URL
	Proto  string
	Header http.Header
	Body   []byte
	// contains filtered or unexported fields
}

type Response struct {
	StatusCode int         `json:"statusCode"`
	Header     http.Header `json:"header"`
	Body       []byte      `json:"-"`
	BodyReader io.Reader

	Close bool // connection close
}

type UpstreamManager interface {
	// RealUpstreamProxy returns a function that resolves upstream proxy for HTTP client transport.
	// This is used by the HTTP client to determine the proxy for each request.
	// The returned function extracts the original request from the context and uses it
	// to determine the appropriate proxy.
	RealUpstreamProxy() func(*http.Request) (*url.URL, error)
}