Communications réseau

Les applications Chrome peuvent servir de client réseau pour les connexions TCP et UDP. Ce document vous explique comment utiliser TCP et UDP pour envoyer et recevoir des données sur le réseau. Pour plus d'informations, consultez la page Sockets API UDP, Sockets TCP et Sockets TCP Server.

Exigences concernant le fichier manifeste

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

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

Syntaxe du socket "host-pattern" entrées suit les règles suivantes:

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

Consultez la section Clé de fichier manifeste Sockets 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" : "" } } : connexion de tous les ports de tous les hôtes
  • { "udp": { "send" : ":99" } } : envoi d'un paquet UDP au port 99 de tous les hôtes
  • { "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 établir des connexions avec n'importe quel service compatible avec TCP.

Connexion à une prise

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

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

Conservez un identifiant pour le socketId afin de pouvoir recevoir et envoyer des données ultérieurement (sockets.tcp.send) à ce socket.

Réception depuis et vers un socket

La réception depuis (sockets.tcp.onReceive) et l'envoi à un socket utilisent des objets ArrayBuffer. À Découvrez les objets ArrayBuffer, consultez la présentation, les tableaux typés JavaScript et le tutoriel, Comment convertir un objet ArrayBuffer en String ou à partir de celui-ci

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'une prise

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

chrome.sockets.tcp.disconnect(socketId);

Utiliser UDP

Les applications Chrome peuvent établir des connexions avec n'importe quel service compatible avec le protocole UDP.

Envoi de 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 ressemble beaucoup à la procédure d'envoi de données, l'exemple précédent, 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);
      });
  });
});

Utiliser un serveur TCP

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

Créer un socket serveur TCP

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

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

Accepter les connexions client

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

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

Conservez un handle vers le socketId afin de pouvoir accepter plus tard 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 du nouveau TCP. . L'ID de socket client doit être utilisé avec l'API sockets.tcp. Le socket du nouveau est suspendue par défaut. Réactivez-le avec sockets.tcp.setPaused pour commencer à recevoir 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 serveur pour cesser d'accepter de nouvelles connexions.

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