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