Wie greife ich auf den zugrunde liegenden Socket einer Netz-/http-Antwort zu?

So greifen Sie auf den zugrunde liegenden Socket einer Netz-/HTTP-Antwort zu

Bei der Arbeit mit HTTP-Verbindungen in Go kann es Szenarios geben, in denen Entwickler auf das zugrunde liegende Netzwerk zugreifen müssen Buchse. Das net/http-Paket bietet eine umfassende Möglichkeit, HTTP-Anfragen und -Antworten zu verarbeiten, stellt den zugrunde liegenden Socket jedoch nicht direkt zur Verfügung. So rufen Sie den Socket in einem Go-Programm ab.

Verwenden des Anforderungskontexts (Go 1.13 und höher)

Mit der Veröffentlichung von Go 1.13 führte das Paket net/http die Möglichkeit zum Speichern von ein net.Conn im Anforderungskontext. Dies bietet eine bequeme und saubere Möglichkeit, auf den Socket zuzugreifen:

<code class="go">package main

import (
    "context"
    "net/http"
    "net"
    "log"
)

type contextKey struct {
    key string
}

var ConnContextKey = &contextKey{"http-conn"}

func SaveConnInContext(ctx context.Context, c net.Conn) (context.Context) {
    return context.WithValue(ctx, ConnContextKey, c)
}

func GetConn(r *http.Request) (net.Conn) {
    return r.Context().Value(ConnContextKey).(net.Conn)
}

func main() {
    http.HandleFunc("/", myHandler)

    server := http.Server{
        Addr: ":8080",
        ConnContext: SaveConnInContext,
    }
    server.ListenAndServe()
}

func myHandler(w http.ResponseWriter, r *http.Request) {
    conn := GetConn(r)
    ...
}</code>

Verwenden von ConnStateEvent für TCP-Sockets

Für Server, die TCP-Ports überwachen, ist net.Conn.RemoteAddr().String( ) ist für jede Verbindung eindeutig. Daher kann es als Schlüssel für eine globale Verbindungskarte verwendet werden:

<code class="go">package main

import (
    "net/http"
    "net"
    "fmt"
    "log"
)

var conns = make(map[string]net.Conn)

func ConnStateEvent(conn net.Conn, event http.ConnState) {
    if event == http.StateActive {
        conns[conn.RemoteAddr().String()] = conn
    } else if event == http.StateHijacked || event == http.StateClosed {
        delete(conns, conn.RemoteAddr().String())
    }
}

func GetConn(r *http.Request) (net.Conn) {
    return conns[r.RemoteAddr]
}

func main() {
    http.HandleFunc("/", myHandler)

    server := http.Server{
        Addr: ":8080",
        ConnState: ConnStateEvent,
    }
    server.ListenAndServe()
}

func myHandler(w http.ResponseWriter, r *http.Request) {
    conn := GetConn(r)
    ...
}</code>

Verwendung von ConnSaveListener für UNIX-Sockets

Für Server, die auf UNIX-Sockets lauschen, net.Conn.RemoteAddr() .String() gibt immer „@“ zurück. Damit es funktioniert, können Sie net.Listener.Accept() überschreiben und damit net.Conn.RemoteAddr().String() überschreiben. Hier ist ein Beispiel:

<code class="go">package main

import (
    "net/http"
    "net"
    "os"
    "golang.org/x/sys/unix"
    "fmt"
    "log"
)

func main() {
    http.HandleFunc("/", myHandler)

    listenPath := "/var/run/go_server.sock"
    l, err := NewUnixListener(listenPath)
    if err != nil {
        log.Fatal(err)
    }
    defer os.Remove(listenPath)

    server := http.Server{
        ConnState: ConnStateEvent,
    }
    server.Serve(NewConnSaveListener(l))
}

func myHandler(w http.ResponseWriter, r *http.Request) {
    conn := GetConn(r)
    if unixConn, isUnix := conn.(*net.UnixConn); isUnix {
        f, _ := unixConn.File()
        pcred, _ := unix.GetsockoptUcred(int(f.Fd()), unix.SOL_SOCKET, unix.SO_PEERCRED)
        f.Close()
        log.Printf("Remote UID: %d", pcred.Uid)
    }
}

var conns = make(map[string]net.Conn)

type connSaveListener struct {
    net.Listener
}

func NewConnSaveListener(wrap net.Listener) (net.Listener) {
    return connSaveListener{wrap}
}

func (self connSaveListener) Accept() (net.Conn, error) {
    conn, err := self.Listener.Accept()
    ptrStr := fmt.Sprintf("%d", &conn)
    conns[ptrStr] = conn
    return remoteAddrPtrConn{conn, ptrStr}, err
}

func GetConn(r *http.Request) (net.Conn) {
    return conns[r.RemoteAddr]
}

func ConnStateEvent(conn net.Conn, event http.ConnState) {
    if event == http.StateHijacked || event == http.StateClosed {
        delete(conns, conn.RemoteAddr().String())
    }
}

type remoteAddrPtrConn struct {
    net.Conn
    ptrStr string
}

func (self remoteAddrPtrConn) RemoteAddr() (net.Addr) {
    return remoteAddrPtr{self.ptrStr}
}

type remoteAddrPtr struct {
    ptrStr string
}

func (remoteAddrPtr) Network() (string) {
    return ""
}

func (self remoteAddrPtr) String() (string) {
    return self.ptrStr
}

func NewUnixListener(path string) (net.Listener, error) {
    if err := unix.Unlink(path); err != nil & os.IsNotExist(err) {
        return nil, err
    }
    mask := unix.Umask(0777)
    defer unix.Umask(mask)

    l, err := net.Listen("unix", path)
    if err != nil {
        return nil, err
    }

    if err := os.Chmod(path, 0660); err != nil {
        l.Close()
        return nil, err
    }

    return l, nil
}</code>

Fazit

Der Zugriff auf den zugrunde liegenden Socket eines http.ResponseWriter kann mit den oben beschriebenen Methoden erreicht werden. Der bevorzugte Ansatz hängt von den spezifischen Anforderungen und der verwendeten Go-Version ab.

Das obige ist der detaillierte Inhalt vonWie greife ich auf den zugrunde liegenden Socket einer Netz-/http-Antwort zu?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!