Comunicazioni di rete

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