Network Communications

Chrome Apps can act as a network client for TCP and UDP connections. This doc shows you how to use TCP and UDP to send and receive data over the network. For more information, see the Sockets UDP, Sockets TCP and Sockets TCP Server APIs.

Note: The previous version of the networking APIs ($(ref:socket)) has been deprecated.

API Samples: Want to play with the code? Check out the telnet and udp samples.

Manifest requirements

For Chrome Apps that use TCP or UDP, add the sockets entry to the manifest and specify the IP end point permission rules. For example:

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

The syntax of socket "host-pattern" entries follows these rules:

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

See Sockets Manifest Key for detailed description of the syntax.

Examples of socket manifest entries:

{ "tcp": { "connect" : "*:23" } } – connecting on port 23 of any hosts
{ "tcp": { "connect" : ["*:23", "*:80"] } } – connecting on port 23 or 80 of any hosts
{ "tcp": { "connect" : "www.example.com:23" } } – connecting port 23 of www.example.com
{ "tcp": { "connect" : "" } } – connecting any ports of any hosts
{ "udp": { "send" : ":99" } } – sending UDP packet to port 99 of any hosts
{ "udp": { "bind" : ":8899" } } – binding local port 8899 to receive UDP packets
{ "tcpServer": { "listen" : ":8080" } } – TCP listening on local port 8080

Using TCP

Chrome Apps can make connections to any service that supports TCP.

Connecting to a socket

Here's a sample showing how to connect ($(ref:sockets.tcp.connect)) to a socket:

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

Keep a handle to the socketId so that you can later received and send data ($(ref:sockets.tcp.send)) to this socket.

Receiving from and sending to a socket

Receiving from ($(ref:sockets.tcp.onReceive)) and sending to a socket uses ArrayBuffer objects. To learn about ArrayBuffers, check out the overview, JavaScript typed arrays, and the tutorial, How to convert ArrayBuffer to and from 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.
});

Disconnecting from a socket

Here's how to disconnect ($(ref:sockets.tcp.disconnect)):

chrome.sockets.tcp.disconnect(socketId);

Using UDP

Chrome Apps can make connections to any service that supports UDP.

Sending data

Here's a sample showing how to send data ($(ref:sockets.udp.send)) over the network using 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);
  });
});

Receiving data

This example is very similar to the 'Sending data' example, except we setup an event handler for receiving data.

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

Using TCP Server

Chrome Apps can act as TCP servers using the $(ref:sockets.tcpServer) API.

Creating a TCP server socket

Create a TCP server socket with $(ref:sockets.tcpServer.create).

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

Accepting client connections

Here's a sample showing how to accept connections ($(ref:sockets.tcpServer.listen)) on a TCP server socket:

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

Keep a handle to the socketId so that you can later accept new connections ($(ref: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)
}

When a new connection is established, onAccept is invoked with the clientSocketId of the new TCP connection. The client socket ID must be used with the $(ref:sockets.tcp) API. The socket of the new connection is paused by default. Un-pause it with $(ref:sockets.tcp.setPaused) to start receiving data.

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(info.clientSocketId, onReceive);
  chrome.sockets.tco.setPaused(false);
}

Stop accepting client connections

Call $(ref:sockets.tcp.disconnect) on the server socket ID to stop accepting new connections.

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