Aplikacje Chrome mogą działać jako klient sieciowy w przypadku połączeń TCP i UDP. W tym dokumencie opisujemy, jak używać protokołów TCP i UDP do wysyłania i odbierania danych w sieci. Więcej informacji znajdziesz na stronach interfejsów API typu Sockets UDP, Sockets TCP i Sockets TCP Server.
Wymagania dotyczące pliku manifestu
W przypadku aplikacji Chrome używających protokołu TCP lub UDP dodaj do pliku manifestu wpis sockets (sockets) i określ reguły uprawnień do punktów końcowych adresów IP. Na przykład:
"sockets": {
"udp": {
"send": ["host-pattern1", ...],
"bind": ["host-pattern2", ...],
...
},
"tcp" : {
"connect": ["host-pattern1", ...],
...
},
"tcpServer" : {
"listen": ["host-pattern1", ...],
...
}
}
Składnia pozycji „host-pattern” gniazda jest zgodna z tymi regułami:
<host-pattern> := <host> | ':' <port> | <host> ':' <port>
<host> := '*' | '*.' <anychar except '/' and '*'>+
<port> := '*' | <port number between 1 and 65535>)
Szczegółowy opis składni znajdziesz w sekcji Klucz pliku manifestu Sockets.
Przykłady wpisów w pliku manifestu gniazd:
{ "tcp": { "connect" : "*:23" } }
– łączenie przez port 23 dowolnego hosta{ "tcp": { "connect" : ["*:23", "*:80"] } }
– łączenie przez port 23 lub 80 dowolnego hosta{ "tcp": { "connect" : "www.example.com:23" } }
– port 23 na stronie www.example.com{ "tcp": { "connect" : "" } }
– łączenie portów dowolnych hostów{ "udp": { "send" : ":99" } }
– wysyłanie pakietu UDP na port 99 dowolnego hosta{ "udp": { "bind" : ":8899" } }
– powiązanie portu lokalnego 8899 w celu odbierania pakietów UDP{ "tcpServer": { "listen" : ":8080" } }
– nasłuchiwanie TCP na lokalnym porcie 8080
Korzystanie z TCP
Aplikacje Chrome mogą nawiązywać połączenia z dowolną usługą obsługującą protokół TCP.
Łączę z gniazdkiem
Oto przykład sposobu połączenia się z gniazdem (sockets.tcp.connect):
chrome.sockets.tcp.create({}, function(createInfo) {
chrome.sockets.tcp.connect(createInfo.socketId,
IP, PORT, onConnectedCallback);
});
Użyj nicka socketId
, aby później móc odbierać i wysyłać do niego dane (sockets.tcp.send).
Odbieranie i wysyłanie do gniazda
Odbieranie z (sockets.tcp.onReceive) i wysyłanie do gniazda wykorzystuje obiekty SlateBuffer. Więcej informacji o funkcji TrackBuffer znajdziesz w omówieniu tablic o typach JavaScript oraz samouczku Jak przekonwertować obiekt TrackBuffer na obiekt String i z niego.
chrome.sockets.tcp.send(socketId, arrayBuffer, onSentCallback);
chrome.sockets.tcp.onReceive.addListener(function(info) {
if (info.socketId != socketId)
return;
// info.data is an arrayBuffer.
});
Odłączanie od gniazdka
Aby odłączyć kontroler (sockets.tcp.disconnect):
chrome.sockets.tcp.disconnect(socketId);
Korzystanie z UDP
Aplikacje Chrome mogą nawiązywać połączenia z dowolną usługą obsługującą UDP.
Wysyłanie danych
Oto przykład wysyłania danych przez sieć (sockets.udp.send) przy użyciu protokołu 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);
});
});
Odbieranie danych
Ten przykład jest bardzo podobny do przykładu „Wysyłanie danych” z tą różnicą, że skonfigurowano moduł obsługi zdarzeń do odbierania danych.
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);
});
});
});
Korzystanie z serwera TCP
Aplikacje Chrome mogą działać jako serwery TCP przy użyciu interfejsu API sockets.tcpServer.
Tworzenie gniazda serwera TCP
Utwórz gniazdo serwera TCP za pomocą polecenia sockets.tcpServer.create.
chrome.sockets.tcpServer.create({}, function(createInfo) {
listenAndAccept(createInfo.socketId);
});
Akceptowanie połączeń z klientami
Oto przykład, jak akceptować połączenia (sockets.tcpServer.listen) na serwerze TCP:
function listenAndAccept(socketId) {
chrome.sockets.tcpServer.listen(socketId,
IP, PORT, function(resultCode) {
onListenCallback(socketId, resultCode)
});
}
Zachowaj nick dla socketId
, by móc później akceptować nowe połączenia (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)
}
Po nawiązaniu nowego połączenia onAccept
jest wywoływane z clientSocketId
nowego połączenia TCP. Identyfikatora gniazda klienta należy używać z interfejsem API sockets.tcp. Gniazdo nowego połączenia jest domyślnie wstrzymane. Wznów je, używając polecenia sockets.tcp.setPaused, aby zacząć odbierać dane.
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);
}
Przestań akceptować połączenia z klientami
Wywołaj sockets.tcp.disconnect z identyfikatorem gniazda serwera, aby przestać akceptować nowe połączenia.
chrome.sockets.tcpServer.onAccept.removeListener(onAccept);
chrome.sockets.tcpServer.disconnect(serverSocketId);