Ottieni l'indirizzo IP del client in socket.io

Quando si utilizza socket.IO in un server Node.js, esiste un modo semplice per ottenere l'indirizzo IP di una connessione in entrata? So che puoi ottenerlo da una connessione HTTP standard, ma socket.io è un po 'diverso.

Va bene, a partire da 0.7.7 questo è disponibile, ma non nel modo descritto da Lubar. Ho finito per dover analizzare alcuni log di commit sull'hub git per capirlo, ma il seguente codice funziona davvero per me ora:

var io = require('socket.io').listen(server);

io.sockets.on('connection', function (socket) {
  var address = socket.handshake.address;
  console.log('New connection from ' + address.address + ':' + address.port);
});

per 1.0.4:

io.sockets.on('connection', function (socket) {
  var socketId = socket.id;
  var clientIp = socket.request.connection.remoteAddress;

  console.log(clientIp);
});

Se si utilizza un altro server come proxy inverso, tutti i campi menzionati conterranno localhost. La soluzione più semplice è aggiungere intestazioni per ip / porta nel server proxy.

Esempio per nginx: aggiungi questo dopo il tuo proxy_pass:

proxy_set_header  X-Real-IP $remote_addr;
proxy_set_header  X-Real-Port $remote_port;

Ciò renderà le intestazioni disponibili nel server del nodo socket.io:

var ip = socket.handshake.headers["x-real-ip"];
var port = socket.handshake.headers["x-real-port"];

Si noti che l'intestazione viene convertita internamente in lettere minuscole.

Se si collega il server del nodo direttamente al client,

var ip = socket.conn.remoteAddress;

funziona con socket.io versione 1.4.6 per me.

Per l'ultima versione di socket.io utilizzare

socket.request.connection.remoteAddress

Per esempio:

var socket = io.listen(server);
socket.on('connection', function (client) {
  var client_ip_address = socket.request.connection.remoteAddress;
}

attenzione che il codice seguente restituisce l'IP del server, non l'IP del client

var address = socket.handshake.address;
console.log('New connection from ' + address.address + ':' + address.port);

Utilizzando la 1.0.6versione più recente di Socket.IOe la mia app distribuita su Heroku, ottengo il client IPe portusando il headersin socket handshake:

var socketio = require('socket.io').listen(server);

socketio.on('connection', function(socket) {

  var sHeaders = socket.handshake.headers;
  console.info('[%s:%s] CONNECT', sHeaders['x-forwarded-for'], sHeaders['x-forwarded-port']);

}

Da socket.io 1.1.0, utilizzo:

io.on('connection', function (socket) {
  console.log('connection :', socket.request.connection._peername);
  // connection : { address: '192.168.1.86', family: 'IPv4', port: 52837 }
}

Modifica : si noti che questo non fa parte dell'API ufficiale e pertanto non funzionerà nelle versioni future di socket.io.

Vedi anche questo link pertinente: engine.io issue

La versione 0.7.7 di Socket.IO ora afferma di restituire l'indirizzo IP del client. Ho avuto successo con:

var socket = io.listen(server);
socket.on('connection', function (client) {
  var ip_address = client.connection.remoteAddress;
}

Questo sembra funzionare:

var io = require('socket.io').listen(80);
io.sockets.on('connection', function (socket) {
  var endpoint = socket.manager.handshaken[socket.id].address;
  console.log('Client connected from: ' + endpoint.address + ":" + endpoint.port);
});

Ho scoperto che all'interno del socket.handshake.headers c'è un indirizzo inoltrato che non appare sul mio computer locale. E sono stato in grado di ottenere l'indirizzo remoto utilizzando:

socket.handshake.headers['x-forwarded-for']

Questo è sul lato server e non sul lato client.

Dalla lettura del codice sorgente socket.io sembra che il metodo "Listen" prenda argomenti (server, opzioni, fn) e se "server" è un'istanza di un server HTTP / S, lo avvolgerà semplicemente per te.

Quindi potreste presumibilmente dargli un server vuoto che ascolta l'evento 'connection' e gestisce il socket remoteAddress; tuttavia, le cose potrebbero essere molto difficili se è necessario associare quell'indirizzo a un oggetto Socket socket.io effettivo.

var http = require('http')
  , io = require('socket.io');
io.listen(new http.Server().on('connection', function(sock) {
  console.log('Client connected from: ' + sock.remoteAddress);
}).listen(80));

Potrebbe essere più semplice inviare una patch a socket.io in cui il proprio oggetto Socket viene esteso con la proprietà remoteAddress assegnata al momento della connessione ...

Molto facile. In primo luogo

io.sockets.on('connection', function (socket) {

console.log(socket);

Vedrai tutti i campi del socket. quindi usa CTRL + F e cerca l'indirizzo della parola. Infine, quando trovi il campo remoteAddress usa i punti per filtrare i dati. nel mio caso lo è

console.log(socket.conn.remoteAddress);

In socket.io 2.0 : puoi usare:

socket.conn.transport.socket._socket.remoteAddress

lavora con transports: ['websocket']

Funziona con l'ultima versione 2.3.0 :

io.on('connection', socket => {
   const ip = socket.handshake.headers[x-forwarded-for] || socket.conn.remoteAddress.split(":")[3];
   console.log(ip);
});

su socket.io1.3.4 hai le seguenti possibilità.

socket.handshake.address,

socket.conn.remoteAddress o

socket.request.client._peername.address

Nella versione v2.3.0

questo lavoro per me:

socket.handshake.headers['x-forwarded-for'].split(',')[0]

uso socket.request.connection.remoteAddress

L'ultima versione funziona con:

console.log(socket.handshake.address);

Benvenuto nel 2019, dove il dattiloscritto prende lentamente il sopravvento sul mondo. Altre risposte sono ancora perfettamente valide. Tuttavia, volevo solo mostrarti come è possibile configurarlo in un ambiente tipizzato.

Nel caso in cui non l'hai ancora fatto. Si dovrebbe prima installare alcune dipendenze (cioè dalla linea di comando: npm install <dependency-goes-here> --save-dev)

  "devDependencies": {
    ...
    "@types/express": "^4.17.2",
    ...
    "@types/socket.io": "^2.1.4",
    "@types/socket.io-client": "^1.4.32",
    ...
    "ts-node": "^8.4.1",
    "typescript": "^3.6.4"
  }

Ho definito le importazioni usando le importazioni ES6 (che dovresti prima abilitare nel tuo tsconfig.jsonfile).

import * as SocketIO from "socket.io";
import * as http from "http";
import * as https from "https";
import * as express from "express";

Poiché uso il dattiloscritto, ora ho la digitazione completa, su tutto ciò che faccio con questi oggetti.

Quindi, ovviamente, prima devi avere un server http:

const handler = express();

const httpServer = (useHttps) ?
  https.createServer(serverOptions, handler) :
  http.createServer(handler);

Immagino tu abbia già fatto tutto questo. E probabilmente hai già aggiunto socket io ad esso:

const io = SocketIO(httpServer);
httpServer.listen(port, () => console.log("listening") );
io.on('connection', (socket) => onSocketIoConnection(socket));

Successivamente, per la gestione di nuove connessioni socket-io, è possibile inserire il SocketIO.Sockettipo sul suo parametro.

function onSocketIoConnection(socket: SocketIO.Socket) {      
  // I usually create a custom kind of session object here.
  // then I pass this session object to the onMessage and onDisconnect methods.

  socket.on('message', (msg) => onMessage(...));
  socket.once('disconnect', (reason) => onDisconnect(...));
}

E infine, poiché ora abbiamo la digitazione completa, possiamo facilmente recuperare l'ip dal nostro socket, senza indovinare:

const ip = socket.conn.remoteAddress;
console.log(`client ip: ${ip}`);

In 1.3.5:

var clientIP = socket.handshake.headers.host;