Maison  >  Article  >  développement back-end  >  Comment accéder au socket sous-jacent d’une réponse net/http ?

Comment accéder au socket sous-jacent d’une réponse net/http ?

Barbara Streisand
Barbara Streisandoriginal
2024-11-05 07:36:02170parcourir

How to Access the Underlying Socket of a net/http Response?

Comment accéder au socket sous-jacent d'une réponse net/http

Lorsque vous travaillez avec des connexions HTTP dans Go, il peut y avoir des scénarios dans lesquels les développeurs doivent accéder au réseau sous-jacent douille. Le package net/http fournit un moyen complet de gérer les requêtes et les réponses HTTP, mais il n'expose pas directement le socket sous-jacent. Voici comment récupérer le socket dans un programme Go.

Utilisation du contexte de requête (Go 1.13 et supérieur)

Avec la sortie de Go 1.13, le package net/http a introduit la possibilité de stocker le socket net.Conn dans le contexte de la demande. Cela fournit un moyen pratique et propre d'accéder au socket :

<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>

Utilisation de ConnStateEvent pour les sockets TCP

Pour les serveurs écoutant sur les ports TCP, le net.Conn.RemoteAddr().String( ) est unique pour chaque connexion. Par conséquent, il peut être utilisé comme clé d'une carte globale des connexions :

<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>

Utilisation de ConnSaveListener pour les sockets UNIX

Pour les serveurs écoutant sur les sockets UNIX, net.Conn.RemoteAddr() .String() renvoie toujours "@". Pour que cela fonctionne, vous pouvez remplacer net.Listener.Accept() et l'utiliser pour remplacer net.Conn.RemoteAddr().String(). Voici un exemple :

<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>

Conclusion

L'accès au socket sous-jacent d'un http.ResponseWriter peut être réalisé en utilisant les méthodes décrites ci-dessus. L'approche privilégiée dépend des exigences spécifiques et de la version de Go utilisée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Déclaration:
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn