Comunicaciones de red

Las apps de Chrome pueden actuar como un cliente de red para conexiones TCP y UDP. En este documento, se muestra cómo usar TCP y UDP para enviar y recibir datos a través de la red. Para obtener más información, consulta las API de Sockets UDP, Sockets TCP y Servidor TCP de sockets.

Requisitos del manifiesto

Para las Apps de Chrome que usan TCP o UDP, agrega la entrada sockets al manifiesto y especifica las reglas de permisos de extremo de IP. Por ejemplo:

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

La sintaxis de las entradas de “host-pattern” del socket sigue estas reglas:

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

Consulta Clave del manifiesto de sockets para obtener una descripción detallada de la sintaxis.

Ejemplos de entradas de manifiesto de socket:

  • { "tcp": { "connect" : "*:23" } }: conexión en el puerto 23 de cualquier host
  • { "tcp": { "connect" : ["*:23", "*:80"] } }: conexión en el puerto 23 u 80 de cualquier host
  • { "tcp": { "connect" : "www.example.com:23" } }: conecta el puerto 23 de www.example.com.
  • { "tcp": { "connect" : "" } }: conecta cualquier puerto de cualquier host.
  • { "udp": { "send" : ":99" } }: envía un paquete UDP al puerto 99 de cualquier host.
  • { "udp": { "bind" : ":8899" } }: vincula el puerto local 8899 para recibir paquetes UDP
  • { "tcpServer": { "listen" : ":8080" } }–TCP escucha en el puerto local 8080

Usa TCP

Las apps de Chrome pueden establecer conexiones con cualquier servicio que admita TCP.

Conéctate a un socket

A continuación, puedes ver un ejemplo de cómo conectarte (sockets.tcp.connect) a un socket:

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

Mantén un controlador para socketId de modo que puedas recibir y enviar datos más tarde (sockets.tcp.send) a este socket.

Cómo recibir mensajes desde un socket y enviarlo a él

Recibir desde (sockets.tcp.onReceive) y enviar a un socket usa objetos ArrayBuffer. Para obtener información sobre ArrayBuffers, consulta la descripción general, los Arrays escritos en JavaScript y el instructivo Cómo convertir ArrayBuffer a una 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.
});

Desconéctate de un socket

Aquí te mostramos cómo desconectarte (sockets.tcp.disconnect):

chrome.sockets.tcp.disconnect(socketId);

Usa UDP

Las Apps de Chrome pueden establecer conexiones con cualquier servicio que admita UDP.

Cómo enviar datos

Aquí te mostramos un ejemplo de cómo enviar datos (sockets.udp.send) a través de la red usando 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);
  });
});

Cómo recibir datos

Este ejemplo es muy similar al ejemplo “Enviar datos”, salvo que configuramos un controlador de eventos para recibir datos.

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

Usa el servidor TCP

Las apps de Chrome pueden actuar como servidores TCP mediante la API sockets.tcpServer.

Crea un socket de servidor TCP

Crea un socket de servidor TCP con sockets.tcpServer.create.

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

Acepta conexiones de clientes

En el siguiente ejemplo, se muestra cómo aceptar conexiones (sockets.tcpServer.listen) en un socket de servidor TCP:

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

Mantén un controlador para socketId para que luego puedas aceptar conexiones nuevas (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)
}

Cuando se establece una nueva conexión, onAccept se invoca con el clientSocketId de la nueva conexión TCP. El ID del socket de cliente debe usarse con la API sockets.tcp. El socket de la nueva conexión está pausado de forma predeterminada. Reanuda con sockets.tcp.setPaused para comenzar a recibir datos.

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

Dejar de aceptar conexiones de clientes

Llama a sockets.tcp.disconnect en el ID de socket de servidor para dejar de aceptar conexiones nuevas.

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