Chrome-Apps können als Netzwerkclient für TCP- und UDP-Verbindungen verwendet werden. In diesem Dokument wird beschrieben, wie Sie TCP und UDP zum Senden und Empfangen von Daten über das Netzwerk verwenden. Weitere Informationen finden Sie unter den APIs Sockets UDP, Sockets TCP und Sockets TCP Server.
Anforderungen an Manifeste
Fügen Sie bei Chrome-Apps, die TCP oder UDP verwenden, dem Manifest den Eintrag Sockets hinzu und geben Sie die Berechtigungsregeln für IP-Endpunkte an. Beispiel:
"sockets": {
"udp": {
"send": ["host-pattern1", ...],
"bind": ["host-pattern2", ...],
...
},
"tcp" : {
"connect": ["host-pattern1", ...],
...
},
"tcpServer" : {
"listen": ["host-pattern1", ...],
...
}
}
Die Syntax von Socket-Einträgen des Typs "host-pattern" folgt folgenden Regeln:
<host-pattern> := <host> | ':' <port> | <host> ':' <port>
<host> := '*' | '*.' <anychar except '/' and '*'>+
<port> := '*' | <port number between 1 and 65535>)
Eine detaillierte Beschreibung der Syntax finden Sie unter Socket-Manifestschlüssel.
Beispiele für Socket-Manifesteinträge:
{ "tcp": { "connect" : "*:23" } }
: Verbindung zu Port 23 eines beliebigen Hosts{ "tcp": { "connect" : ["*:23", "*:80"] } }
: Verbindung zu Port 23 oder 80 eines beliebigen Hosts{ "tcp": { "connect" : "www.example.com:23" } }
: Port 23 von www.example.com wird verbunden{ "tcp": { "connect" : "" } }
: Verbindung zu allen Ports eines Hosts{ "udp": { "send" : ":99" } }
: Das UDP-Paket wird an Port 99 eines beliebigen Hosts gesendet.{ "udp": { "bind" : ":8899" } }
: Lokaler Port 8899 mit Bindung, um UDP-Pakete zu empfangen{ "tcpServer": { "listen" : ":8080" } }
: TCP über den lokalen Port 8080
TCP verwenden
Chrome-Apps können Verbindungen zu jedem Dienst herstellen, der TCP unterstützt.
Mit einer Steckdose verbinden
Das folgende Beispiel zeigt, wie eine Verbindung (sockets.tcp.connect) mit einem Socket hergestellt wird:
chrome.sockets.tcp.create({}, function(createInfo) {
chrome.sockets.tcp.connect(createInfo.socketId,
IP, PORT, onConnectedCallback);
});
Behalten Sie ein Handle für socketId
bei, damit Sie später Daten (sockets.tcp.send) empfangen und an diesen Socket senden können.
Empfang von und Senden an Socket
Zum Empfangen von (sockets.tcp.onReceive) und dem Senden an einen Socket werden ArrayBuffer-Objekte verwendet. Informationen zu ArrayBuffers finden Sie in der Übersicht zu Arrays vom Typ JavaScript und in der Anleitung How to convert ArrayBuffers to and from String.
chrome.sockets.tcp.send(socketId, arrayBuffer, onSentCallback);
chrome.sockets.tcp.onReceive.addListener(function(info) {
if (info.socketId != socketId)
return;
// info.data is an arrayBuffer.
});
Verbindung zu Socket trennen
So trennen Sie die Verbindung (sockets.tcp.disconnect):
chrome.sockets.tcp.disconnect(socketId);
UDP verwenden
Chrome-Apps können Verbindungen zu jedem Dienst herstellen, der UDP unterstützt.
Daten werden gesendet
Das folgende Beispiel zeigt, wie Daten (sockets.udp.send) mit UDP über das Netzwerk gesendet werden:
// 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);
});
});
Daten werden empfangen
Dieses Beispiel ist dem Beispiel "Daten senden" sehr ähnlich, allerdings richten wir einen Event-Handler für den Empfang von Daten ein.
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);
});
});
});
TCP-Server verwenden
Chrome-Apps können mithilfe der sockets.tcpServer API als TCP-Server fungieren.
TCP-Server-Socket erstellen
Erstellen Sie einen TCP-Server-Socket mit sockets.tcpServer.create.
chrome.sockets.tcpServer.create({}, function(createInfo) {
listenAndAccept(createInfo.socketId);
});
Clientverbindungen akzeptieren
Das folgende Beispiel zeigt, wie Verbindungen (sockets.tcpServer.listen) auf einem TCP-Server-Socket akzeptiert werden:
function listenAndAccept(socketId) {
chrome.sockets.tcpServer.listen(socketId,
IP, PORT, function(resultCode) {
onListenCallback(socketId, resultCode)
});
}
Behalten Sie ein Handle zu socketId
bei, damit Sie später neue Verbindungen annehmen können (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)
}
Beim Aufbau einer neuen Verbindung wird onAccept
mit dem clientSocketId
der neuen TCP-Verbindung aufgerufen. Die Client-Socket-ID muss mit der sockets.tcp-API verwendet werden. Der Socket der neuen Verbindung ist standardmäßig pausiert. Heben Sie die Pausierung mit sockets.tcp.setPaused auf, um mit dem Empfang von Daten zu beginnen.
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);
}
Keine Clientverbindungen mehr annehmen
Rufen Sie sockets.tcp.disconnect für die Server-Socket-ID auf, um keine neuen Verbindungen mehr anzunehmen.
chrome.sockets.tcpServer.onAccept.removeListener(onAccept);
chrome.sockets.tcpServer.disconnect(serverSocketId);