Comunicações de rede

Os apps do Chrome podem atuar como um cliente de rede para conexões TCP e UDP. Este documento mostra como usar TCP e UDP para enviar e receber dados pela rede. Para mais informações, consulte as APIs Soquetes UDP, Soquetes TCP e Servidor de soquetes TCP.

Requisitos do manifesto

Para apps do Chrome que usam TCP ou UDP, adicione a entrada sockets ao manifesto e especifique as regras de permissão de endpoint de IP. Exemplo:

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

A sintaxe das entradas "host-pattern" do soquete segue estas regras:

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

Consulte Chave de manifesto de soquetes para ver uma descrição detalhada da sintaxe.

Exemplos de entradas do manifesto do soquete:

  • { "tcp": { "connect" : "*:23" } }: conexão na porta 23 de qualquer host.
  • { "tcp": { "connect" : ["*:23", "*:80"] } }: conexão na porta 23 ou 80 de qualquer host.
  • { "tcp": { "connect" : "www.example.com:23" } }: conectando a porta 23 de www.example.com
  • { "tcp": { "connect" : "" } }: como conectar qualquer porta de qualquer host.
  • { "udp": { "send" : ":99" } }: enviando pacote UDP para a porta 99 de qualquer host
  • { "udp": { "bind" : ":8899" } }: vincule a porta local 8899 para receber pacotes UDP.
  • { "tcpServer": { "listen" : ":8080" } }: escuta TCP na porta local 8080

Como usar o TCP

Os apps do Chrome podem fazer conexões com qualquer serviço compatível com TCP.

Como se conectar a uma tomada

O exemplo a seguir mostra como se conectar (sockets.tcp.connect) a um soquete:

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

Mantenha um identificador para o socketId para que você possa receber e enviar mais tarde dados (sockets.tcp.send) a esse soquete.

Receber e enviar para um soquete

O recebimento de (sockets.tcp.onReceive) e o envio para um soquete usa objetos ArrayBuffer. Para saber mais sobre ArrayBuffers, confira a visão geral, matrizes tipadas em JavaScript e o tutorial, Como converter um ArrayBuffer de e para uma 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.
});

Como se desconectar de uma tomada

Veja como desconectar (sockets.tcp.disconnect):

chrome.sockets.tcp.disconnect(socketId);

Como usar o UDP

Os Aplicativos do Google Chrome podem fazer conexões com qualquer serviço compatível com UDP.

Enviar dados

Este é um exemplo de como enviar dados (sockets.udp.send) pela rede usando o 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);
  });
});

Recebimento de dados

Este exemplo é muito semelhante ao "Enviando dados", exceto pelo fato de que configuramos um manipulador de eventos para receber dados.

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

Como usar o servidor TCP

Os apps do Chrome podem atuar como servidores TCP com a API sockets.tcpServer.

Como criar um soquete de servidor TCP

Crie um soquete de servidor TCP com sockets.tcpServer.create.

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

Como aceitar conexões de clientes

Veja um exemplo de como aceitar conexões (sockets.tcpServer.listen) em um soquete de servidor TCP:

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

Mantenha um identificador para socketId para poder aceitar novas conexões mais tarde (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 uma nova conexão é estabelecida, onAccept é invocado com o clientSocketId da nova conexão TCP. O ID do soquete do cliente precisa ser usado com a API sockets.tcp. O soquete da nova conexão é pausado por padrão. Retome-o com sockets.tcp.setPaused para começar a receber dados.

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

Parar de aceitar conexões de cliente

Chame sockets.tcp.disconnect no código do soquete do servidor para parar de aceitar novas conexões.

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