Netzwerkkommunikation

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