Le app di Chrome possono fungere da client di rete per le connessioni TCP e UDP. Questo documento mostra come utilizzare TCP e UDP per inviare e ricevere dati sulla rete. Per ulteriori informazioni, consulta le API Sockets UDP, Socket TCP e Sockets TCP Server.
Requisiti del file manifest
Per le app di Chrome che utilizzano TCP o UDP, aggiungi la voce socket al manifest e specifica le regole di autorizzazione del punto di arrivo IP. Ad esempio:
"sockets": {
"udp": {
"send": ["host-pattern1", ...],
"bind": ["host-pattern2", ...],
...
},
"tcp" : {
"connect": ["host-pattern1", ...],
...
},
"tcpServer" : {
"listen": ["host-pattern1", ...],
...
}
}
La sintassi delle voci "host-pattern" del socket segue queste regole:
<host-pattern> := <host> | ':' <port> | <host> ':' <port>
<host> := '*' | '*.' <anychar except '/' and '*'>+
<port> := '*' | <port number between 1 and 65535>)
Per una descrizione dettagliata della sintassi, consulta la sezione Chiave manifest socket.
Esempi di voci manifest del socket:
{ "tcp": { "connect" : "*:23" } }
: connessione sulla porta 23 di qualsiasi host{ "tcp": { "connect" : ["*:23", "*:80"] } }
: connessione sulla porta 23 o 80 di qualsiasi host{ "tcp": { "connect" : "www.example.com:23" } }
: porta di connessione 23 di www.example.com{ "tcp": { "connect" : "" } }
: connessione di qualsiasi porta di qualsiasi host{ "udp": { "send" : ":99" } }
: invio del pacchetto UDP alla porta 99 di qualsiasi host{ "udp": { "bind" : ":8899" } }
: associazione della porta locale 8899 per la ricezione dei pacchetti UDP{ "tcpServer": { "listen" : ":8080" } }
: TCP in ascolto sulla porta locale 8080
Utilizzo di TCP
Le app di Chrome possono connettersi a qualsiasi servizio che supporti il protocollo TCP.
Collegamento a una presa
Ecco un esempio che mostra come eseguire la connessione (sockets.tcp.connect) a una presa:
chrome.sockets.tcp.create({}, function(createInfo) {
chrome.sockets.tcp.connect(createInfo.socketId,
IP, PORT, onConnectedCallback);
});
Mantieni un handle a socketId
in modo da poter ricevere e inviare in un secondo momento dati (sockets.tcp.send) a questo socket.
Ricezione da e invio a un socket
La ricezione da (sockets.tcp.onReceive) e l'invio a un socket utilizza oggetti ArrayBuffer. Per saperne di più su ArrayBuffers, consulta la panoramica Array di tipo JavaScript e il tutorial Come convertire ArrayBuffer in e da una stringa.
chrome.sockets.tcp.send(socketId, arrayBuffer, onSentCallback);
chrome.sockets.tcp.onReceive.addListener(function(info) {
if (info.socketId != socketId)
return;
// info.data is an arrayBuffer.
});
Disconnessione da una presa di corrente
Ecco come eseguire la disconnessione (sockets.tcp.disconnect):
chrome.sockets.tcp.disconnect(socketId);
Utilizzo di UDP
Le app di Chrome possono connettersi a qualsiasi servizio che supporti UDP.
Invio dati
Ecco un esempio che mostra come inviare i dati (sockets.udp.send) sulla rete utilizzando UDP:
// Create the Socket
chrome.sockets.udp.create({}, function(socketInfo) {
// The socket is created, now we can send some data
var socketId = socketInfo.socketId;
chrome.sockets.udp.send(socketId, arrayBuffer,
'127.0.0.1', 1337, function(sendInfo) {
console.log("sent " + sendInfo.bytesSent);
});
});
Ricezione di dati
Questo esempio è molto simile all'esempio "Invio di dati", con la differenza che configuriamo un gestore di eventi per la ricezione dei dati.
var socketId;
// Handle the "onReceive" event.
var onReceive = function(info) {
if (info.socketId !== socketId)
return;
console.log(info.data);
};
// Create the Socket
chrome.sockets.udp.create({}, function(socketInfo) {
socketId = socketInfo.socketId;
// Setup event handler and bind socket.
chrome.sockets.udp.onReceive.addListener(onReceive);
chrome.sockets.udp.bind(socketId,
"0.0.0.0", 0, function(result) {
if (result < 0) {
console.log("Error binding socket.");
return;
}
chrome.sockets.udp.send(socketId, arrayBuffer,
'127.0.0.1', 1337, function(sendInfo) {
console.log("sent " + sendInfo.bytesSent);
});
});
});
Utilizzo del server TCP
Le app di Chrome possono agire come server TCP utilizzando l'API sockets.tcpServer.
Creazione di un socket server TCP
Crea un socket server TCP con sockets.tcpServer.create.
chrome.sockets.tcpServer.create({}, function(createInfo) {
listenAndAccept(createInfo.socketId);
});
Accettazione delle connessioni client in corso...
Ecco un esempio che mostra come accettare connessioni (sockets.tcpServer.listen) su un socket server TCP:
function listenAndAccept(socketId) {
chrome.sockets.tcpServer.listen(socketId,
IP, PORT, function(resultCode) {
onListenCallback(socketId, resultCode)
});
}
Mantieni un handle a socketId
in modo da poter accettare nuove connessioni in un secondo momento (sockets.tcpServer.onAccept) .
var serverSocketId;
function onListenCallback(socketId, resultCode) {
if (resultCode < 0) {
console.log("Error listening:" +
chrome.runtime.lastError.message);
return;
}
serverSocketId = socketId;
chrome.sockets.tcpServer.onAccept.addListener(onAccept)
}
Quando viene stabilita una nuova connessione, onAccept
viene richiamato con il valore clientSocketId
della nuova connessione TCP. L'ID socket client deve essere utilizzato con l'API sockets.tcp. Il socket della nuova connessione è in pausa per impostazione predefinita. Riattivalo con sockets.tcp.setPaused per iniziare a ricevere dati.
function onAccept(info) {
if (info.socketId != serverSocketId)
return;
// A new TCP connection has been established.
chrome.sockets.tcp.send(info.clientSocketId, data,
function(resultCode) {
console.log("Data sent to new TCP client connection.")
});
// Start receiving data.
chrome.sockets.tcp.onReceive.addListener(function(recvInfo) {
if (recvInfo.socketId != info.clientSocketId)
return;
// recvInfo.data is an arrayBuffer.
});
chrome.sockets.tcp.setPaused(false);
}
Smetti di accettare connessioni client
Chiama sockets.tcp.disconnect sull'ID socket del server per non accettare più nuove connessioni.
chrome.sockets.tcpServer.onAccept.removeListener(onAccept);
chrome.sockets.tcpServer.disconnect(serverSocketId);