Method ServeHTTP

x/ipc/hijack.go:115–165

ServeHTTP hijacks the underlying connection of a http request. The underlying connection can then be reused to send any data, i.e., it gives a universal duplex connection to the client. Important notes to keep this stable: - The hijacked `net.Conn` is only guaranteed to be valid while the request ha

(w http.ResponseWriter, r *http.Request)

// https://github.com/moby/moby/blob/e2ead4526d9416bd90502c710751839e55d739f2/daemon/server/router/container/exec.go#L118
// https://cs.opensource.google/go/go/+/master:src/net/http/httputil/reverseproxy.go;l=750;drc=4ab1aec00799f91e96182cbbffd1de405cd52e93
func (h *hijackHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	// Important: Do not write anything (e.g. headers) before the hijack!
	hj, ok := w.(http.Hijacker)
	if !ok {
		http.Error(w, "hijacking connection", http.StatusInternalServerError)
		return
	}

	conn, brw, hijackErr := hj.Hijack()
	if errors.Is(hijackErr, http.ErrNotSupported) {
		h.logger.Errorf("can't switch protocols using non-Hijacker ResponseWriter")
		return
	}

	if hijackErr != nil {
		h.logger.Errorf("Hijack failed on protocol switch: %v", hijackErr)
		return
	}

	defer func() { _ = conn.Close() }() // Might have already been called inside the callback -> ignore double close error

	done := make(chan struct{})
	go func() {
		defer close(done)

		resp := &http.Response{
			StatusCode: http.StatusSwitchingProtocols,
			Proto:      r.Proto,
			Header:     w.Header(),
		}
		resp.Header.Set("Connection", "upgrade")
		resp.Header.Set("Upgrade", "tcp")
		if err := resp.Write(brw); err != nil {
			h.logger.Errorf("writing response: %v", err)
			return
		}
		if err := brw.Flush(); err != nil {
			h.logger.Errorf("flushing response: %v", err)
			return
		}

		// The server still owns net.Conn. When this handler returns, conn gets closed.
		// However, the callback might have to call Close() to abort/unblock any pending/blocking Read().
		h.cb(r.Context(), conn)
	}()

	select {
	case <-done:
	case <-r.Context().Done():
	}
}

func NewHijackAcceptor(logger logging.Logger, cb func(context.Context, io.ReadWriteCloser)) (string, http.Handler) {
	return hijackPath, &hijackHandler{logger: logger, cb: cb, ackTimeout: hijackTimeout}