Communications réseau

Les applications Chrome peuvent jouer le rôle de client réseau pour les connexions TCP et UDP. Ce document explique comment utiliser TCP et UDP pour envoyer et recevoir des données sur le réseau. Pour en savoir plus, consultez les API Sockets UDP, Sockets TCP et Sockets TCP Server.

Exigences du fichier manifeste

Pour les applications Chrome qui utilisent TCP ou UDP, ajoutez l'entrée sockets au fichier manifeste et spécifiez les règles d'autorisation des points de terminaison IP. Exemple :

"sockets": {
    "udp": {
      "send": ["host-pattern1", ...],
      "bind": ["host-pattern2", ...],
      ...
    },
    "tcp" : {
      "connect": ["host-pattern1", ...],
      ...
    },
    "tcpServer" : {
      "listen": ["host-pattern1", ...],
      ...
    }
  }

La syntaxe des entrées de socket "host-pattern" suit les règles suivantes:

<host-pattern> := <host> | ':' <port> | <host> ':' <port>
<host> := '*' | '*.' <anychar except '/' and '*'>+
<port> := '*' | <port number between 1 and 65535>)

Consultez Clé manifeste de socket pour obtenir une description détaillée de la syntaxe.

Exemples d'entrées de fichier manifeste de socket:

  • { "tcp": { "connect" : "*:23" } } : connexion sur le port 23 de tous les hôtes
  • { "tcp": { "connect" : ["*:23", "*:80"] } } : connexion sur le port 23 ou 80 de n'importe quel hôte
  • { "tcp": { "connect" : "www.example.com:23" } } : connexion du port 23 de www.example.com
  • { "tcp": { "connect" : "" } } : connecte tous les ports de tous les hôtes
  • { "udp": { "send" : ":99" } } : envoi d'un paquet UDP sur le port 99 de n'importe quel hôte
  • { "udp": { "bind" : ":8899" } } : liaison du port local 8899 pour recevoir des paquets UDP
  • { "tcpServer": { "listen" : ":8080" } } : écoute TCP sur le port local 8080

Utiliser TCP

Les applications Chrome peuvent se connecter à n'importe quel service compatible avec TCP.

Connexion à un socket

Voici un exemple montrant comment se connecter (sockets.tcp.connect) à un socket:

chrome.sockets.tcp.create({}, function(createInfo) {
  chrome.sockets.tcp.connect(createInfo.socketId,
    IP, PORT, onConnectedCallback);
});

Conservez un handle vers socketId pour pouvoir recevoir et envoyer ultérieurement des données (sockets.tcp.send) à ce socket.

Recevoir et envoyer à un socket

La réception depuis (sockets.tcp.onReceive) et l'envoi à un socket utilisent des objets ArrayBuffer. Pour en savoir plus sur les objets ArrayBuffer, consultez la présentation des tableaux typés JavaScript, ainsi que le tutoriel Comment convertir un objet ArrayBuffer en chaîne.

chrome.sockets.tcp.send(socketId, arrayBuffer, onSentCallback);

chrome.sockets.tcp.onReceive.addListener(function(info) {
  if (info.socketId != socketId)
    return;
  // info.data is an arrayBuffer.
});

Déconnexion d'un support

Voici comment vous déconnecter (sockets.tcp.disconnect):

chrome.sockets.tcp.disconnect(socketId);

Utiliser UDP

Les applications Chrome peuvent se connecter à n'importe quel service compatible avec UDP.

Envoyer des données

Voici un exemple montrant comment envoyer des données (sockets.udp.send) sur le réseau à l'aide d'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);
  });
});

Recevoir des données

Cet exemple est très semblable à l'exemple "Envoi de données", sauf que nous configurons un gestionnaire d'événements pour recevoir des données.

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

À l'aide du serveur TCP

Les applications Chrome peuvent agir en tant que serveurs TCP à l'aide de l'API sockets.tcpServer.

Créer un socket de serveur TCP

Créez un socket de serveur TCP avec sockets.tcpServer.create.

chrome.sockets.tcpServer.create({}, function(createInfo) {
  listenAndAccept(createInfo.socketId);
});

Accepter des connexions client

Voici un exemple montrant comment accepter des connexions (sockets.tcpServer.listen) sur un socket de serveur TCP:

function listenAndAccept(socketId) {
  chrome.sockets.tcpServer.listen(socketId,
    IP, PORT, function(resultCode) {
      onListenCallback(socketId, resultCode)
  });
}

Conservez un handle vers socketId pour pouvoir accepter ultérieurement de nouvelles connexions (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)
}

Lorsqu'une nouvelle connexion est établie, onAccept est appelé avec le clientSocketId de la nouvelle connexion TCP. L'ID de socket client doit être utilisé avec l'API sockets.tcp. Le socket de la nouvelle connexion est suspendu par défaut. Réactivez-la avec sockets.tcp.setPaused pour commencer à recevoir des données.

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

Ne plus accepter les connexions client

Appelez sockets.tcp.disconnect sur l'ID de socket du serveur pour ne plus accepter de nouvelles connexions.

chrome.sockets.tcpServer.onAccept.removeListener(onAccept);
chrome.sockets.tcpServer.disconnect(serverSocketId);