Korrekte Art und Weise, IP-Adressen des Clients von http.Request (Golang) abzurufen

Was ist der richtige Weg, um alle Clients IP-Adressen aus http.Request? In PHP es gibt eine Menge von Variablendass ich prüfen soll. Ist es das gleiche auf Gehen?

Eines, das ich gefunden habe ist:

req.RemoteAddr

Ist und die Anfrage-und Kleinschreibung? zum Beispiel x-forwarded-for ist das gleiche wie X-Forwarded-For und X-FORWARDED-FOR? (aus req.Header.Get("X-FORWARDED-FOR"))

InformationsquelleAutor der Frage Kokizzu | 2014-12-01

go http ip

38

Blick auf http.Anfrage finden Sie die folgenden member-Variablen:
```
//HTTP defines that header names are case-insensitive.
//The request parser implements this by canonicalizing the
//name, making the first character and any characters
//following a hyphen uppercase and the rest lowercase.
//
//For client requests certain headers are automatically
//added and may override values in Header.
//
//See the documentation for the Request.Write method.
Header Header

//RemoteAddr allows HTTP servers and other software to record
//the network address that sent the request, usually for
//logging. This field is not filled in by ReadRequest and
//has no defined format. The HTTP server in this package
//sets RemoteAddr to an "IP:port" address before invoking a
//handler.
//This field is ignored by the HTTP client.
RemoteAddr string
```
Können Sie RemoteAddr um dem remote-client die IP-Adresse und den port (das format "IP:port"), das ist die Adresse des ursprünglichen Anforderer oder der Letzte proxy (zum Beispiel ein load-balancer, das Leben vor dem server).

Dies ist alles, was Sie für sicher.

Dann können Sie untersuchen die Header, die sind der groß-und Kleinschreibung (pro Dokumentation oben), was bedeutet, alle Ihre Beispiele funktionieren und erzielen Sie dasselbe Ergebnis:
```
req.Header.Get("X-Forwarded-For") //capitalisation
req.Header.Get("x-forwarded-for") //doesn't
req.Header.Get("X-FORWARDED-FOR") //matter
```
Dies ist, weil intern http.Header.Get wird die Normalisierung der Schlüssel für Sie. (Wenn Sie Zugriff auf header-Karte direkt, und nicht durch Getmüssten Sie http.CanonicalHeaderKey erste.)

Schließlich "X-Forwarded-For" ist wohl das Feld, das Sie wollen, werfen Sie einen Blick auf, um zu packen, mehr Informationen über die client-IP. Dies hängt stark von der HTTP-software auf dem remote-Seite aber als Kunde kann nichts in dort, wenn Sie möchte. Beachten Sie auch, die erwartet - format dieses Feld ist Komma+Leerzeichen getrennte Liste von IP-Adressen. Sie müssen analysieren es ein wenig, um eine einzelne IP-Wahl (wohl der erste in der Liste), zum Beispiel:
```
//Assuming format is as expected
ips := strings.Split("10.0.0.1, 10.0.0.2, 10.0.0.3", ", ")
for _, ip := range ips {
    fmt.Println(ip)
}
```
produzieren:
```
10.0.0.1
10.0.0.2
10.0.0.3
```
InformationsquelleAutor der Antwort tomasz

Hier ein komplett funktionsfähiges Beispiel

package main

import (  
    //Standard library packages
    "fmt"
    "strconv"
    "log"
    "net"
    "net/http"

    //Third party packages
    "github.com/julienschmidt/httprouter"
    "github.com/skratchdot/open-golang/open"
)



//https://blog.golang.org/context/userip/userip.go
func getIP(w http.ResponseWriter, req *http.Request, _ httprouter.Params){
    fmt.Fprintf(w, "<h1>static file server</h1><p><a href='./static'>folder</p></a>")

    ip, port, err := net.SplitHostPort(req.RemoteAddr)
    if err != nil {
        //return nil, fmt.Errorf("userip: %q is not IP:port", req.RemoteAddr)

        fmt.Fprintf(w, "userip: %q is not IP:port", req.RemoteAddr)
    }

    userIP := net.ParseIP(ip)
    if userIP == nil {
        //return nil, fmt.Errorf("userip: %q is not IP:port", req.RemoteAddr)
        fmt.Fprintf(w, "userip: %q is not IP:port", req.RemoteAddr)
        return
    }

    //This will only be defined when site is accessed via non-anonymous proxy
    //and takes precedence over RemoteAddr
    //Header.Get is case-insensitive
    forward := req.Header.Get("X-Forwarded-For")

    fmt.Fprintf(w, "<p>IP: %s</p>", ip)
    fmt.Fprintf(w, "<p>Port: %s</p>", port)
    fmt.Fprintf(w, "<p>Forwarded for: %s</p>", forward)
}


func main() {  
    myport := strconv.Itoa(10002);


    //Instantiate a new router
    r := httprouter.New()

    r.GET("/ip", getIP)

    //Add a handler on /test
    r.GET("/test", func(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
        //Simply write some test data for now
        fmt.Fprint(w, "Welcome!\n")
    })  


    l, err := net.Listen("tcp", "localhost:" + myport)
    if err != nil {
        log.Fatal(err)
    }
    //The browser can connect now because the listening socket is open.


    //err = open.Start("http://localhost:"+ myport + "/test")
    err = open.Start("http://localhost:"+ myport + "/ip")
    if err != nil {
         log.Println(err)
    }

    //Start the blocking server loop.
    log.Fatal(http.Serve(l, r)) 
}

InformationsquelleAutor der Antwort Stefan Steiger

1

In PHP gibt es eine Menge von Variablen, die ich prüfen soll. Ist es das gleiche auf Gehen?

Dieser hat nichts zu tun mit Gehen (oder PHP, für diese Angelegenheit). Es hängt nur davon ab, was der client, proxy, load-balancer, oder den server zu senden. Bekommen, die Sie brauchen, abhängig von Ihrer Umgebung.

http.Request.RemoteAddr enthält die remote-IP-Adresse. Es kann oder kann nicht Ihren tatsächlichen Kunden.

Ist und die Anfrage-und Kleinschreibung? zum Beispiel x-forwarded-for ist das gleiche wie X-Forwarded-For und X-FORWARDED-FOR? (aus erf.Header.Get("X-FORWARDED-FOR"))

Nein, warum nicht versuchen, es selbst? http://play.golang.org/p/YMf_UBvDsH

InformationsquelleAutor der Antwort JimB
-5

Dieser arbeitete für mich. Ich laufen gehen in 8081-und einen Antrag von port 8080.
```
fmt.Printf("r: %+v\n", r) //Print all fields that you get in request
```
Ausgabe:

r: &{Method:POST URL:/E-Mail-Proto:HTTP/1.1 ProtoMajor:1 ProtoMinor:1 Header:anzeigen[User-Agent:[Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_1) AppleWebKit/602.2.11 (KHTML, like Gecko) Version/10.0.1 Safari/602.2.11] Accept-Language:[de-de] Accept-Encoding:[gzip, deflate] Verbindung: [- keep-alive] Accept:[/] Referer:[http://127.0.0.1:8080/%5D Content-Length:[9] Content-Type:[application/x-www-form-urlencoded; charset=UTF-8] Ursprung:[http://127.0.0.1:8080%5D%5D Körper:0xc420012800 ContentLength:9 TransferEncoding:[] Close:false Host:127.0.0.1:8081 Form:map[] PostForm:map[] MultipartForm: Trailer:map[] RemoteAddr:127.0.0.1:62232 RequestURI:/E-Mail-TLS: Abbrechen: Antwort: ctx:0xc420017860}

Den Referrer und Herkunft haben meine client-IP.
```
ip := r.Referer() //Get Referer value
fmt.Println(ip) //print ip
```
Ausgabe:

http://127.0.0.1:8080/

InformationsquelleAutor der Antwort deepakssn

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.