Conectando-se ao soquete TCP a partir do navegador usando javascript

111

Eu tenho um aplicativo vb.net que abre um soquete e escuta nele.

Preciso me comunicar por meio deste soquete com esse aplicativo usando um javascript em execução em um navegador. Isto é, eu preciso enviar alguns dados neste soquete para que o aplicativo que está ouvindo neste soquete possa pegar esses dados, fazer algumas coisas usando algumas chamadas remotas e obter mais alguns dados e colocá-los de volta no soquete que meu javascript precisa leia e imprima no navegador.

Eu tentei, socket.io, websockify, mas nenhum provou ser útil.

Daí a pergunta: o que estou tentando é mesmo possível? Existe uma maneira que um javascript rodando em um navegador pode se conectar a um socket tcp e enviar alguns dados e ouvir mais alguma resposta de dados no socket e imprimi-lo no navegador.

Se isso for possível, alguém pode me apontar na direção certa que me ajudaria a estabelecer a meta.

peixe-espada
fonte
3
Não, você está limitado a WebSockets
Bergi,
2
@Bergi - HTTP é um protocolo sobre tcp, então por que uma conexão HTTP pode ser feita, mas não TCP?
AlikElzin-kilaka
@kilaka: Porque as APIs (padrão) disponíveis em um ambiente de navegador são limitadas a elas .
Bergi
Possível duplicata: stackoverflow.com/questions/9154035/…
AlikElzin-kilaka
6
Vejo um novo padrão surgindo na espinha do Javascript: w3.org/TR/raw-sockets .
AlikElzin-kilaka 01 de

Respostas:

57

Quanto ao seu problema, atualmente você terá que depender de XHR ou websockets para isso.

Atualmente, nenhum navegador popular implementou qualquer api de sockets raw para javascript que permite criar e acessar sockets raw, mas um rascunho para a implementação de API de sockets raw em JavaScript está em andamento. Dê uma olhada nestes links:
http://www.w3.org/TR/raw-sockets/
https://developer.mozilla.org/en-US/docs/Web/API/TCPSocket

O Chrome agora tem suporte para soquetes TCP e UDP brutos em suas APIs 'experimentais'. Esses recursos estão disponíveis apenas para extensões e, embora documentados, estão ocultos por enquanto. Dito isso, alguns desenvolvedores já estão criando projetos interessantes usando-o, como este cliente de IRC .

Para acessar esta API, você precisará habilitar o sinalizador experimental no manifesto de sua extensão. Usar sockets é bastante simples, por exemplo:

chrome.experimental.socket.create('tcp', '127.0.0.1', 8080, function(socketInfo) {
  chrome.experimental.socket.connect(socketInfo.socketId, function (result) {
        chrome.experimental.socket.write(socketInfo.socketId, "Hello, world!");         
    });
});
Robin Rizvi
fonte
Quais navegadores oferecem suporte a sockets raw?
AlikElzin-kilaka de
2
Algum aumento de desempenho em comparação com Websockets e Rawsockets?
NiCk Newman
3
Não é permitir javascript no navegador para se conectar a uma porta tcp, uma brecha de segurança? Imagine o javascript em seu firefox / chrome conectando-se a qualquer coisa que você execute localmente (digamos, MySQL DB) e publique dados em um site maligno?
Arun Avanathan
@ArunAvanathan tudo o que você faz com ajax, você pode fazer com soquetes e vice-versa ... nenhum problema de segurança, como eu acho.
Firas Abd Alrahman de
1
@FirasAbdAlrahman Acho que existem várias políticas de segurança que regem o comportamento do navegador para HTTP / S. Portanto, a conexão de soquete do navegador sobre TCP não é o mesmo que HTTP / S.
Arun Avanathan
30

Isso será possível por meio da interface do navegador, conforme mostrado abaixo:

navigator.tcpPermission.requestPermission({remoteAddress:"127.0.0.1", remotePort:6789}).then(
  () => {
    // Permission was granted
    // Create a new TCP client socket and connect to remote host
    var mySocket = new TCPSocket("127.0.0.1", 6789);

    // Send data to server
    mySocket.writeable.write("Hello World").then(
        () => {

            // Data sent sucessfully, wait for response
            console.log("Data has been sent to server");
            mySocket.readable.getReader().read().then(
                ({ value, done }) => {
                    if (!done) {
                        // Response received, log it:
                        console.log("Data received from server:" + value);
                    }

                    // Close the TCP connection
                    mySocket.close();
                }
            );
        },
        e => console.error("Sending error: ", e)
    );
  }
);

Mais detalhes estão descritos na documentação w3.org tcp-udp-sockets.

http://raw-sockets.sysapps.org/#interface-tcpsocket

https://www.w3.org/TR/tcp-udp-sockets/

Outra alternativa é usar Chrome Sockets

Criando conexões

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

Enviando dados

chrome.sockets.tcp.send(socketId, arrayBuffer, onSentCallback);

Recebendo dados

chrome.sockets.tcp.onReceive.addListener(function(info) {
  if (info.socketId != socketId)
    return;
  // info.data is an arrayBuffer.
});

Você também pode tentar usar HTML5 Web Sockets(embora não seja uma comunicação TCP direta):

var connection = new WebSocket('ws://IPAddress:Port');

connection.onopen = function () {
  connection.send('Ping'); // Send the message 'Ping' to the server
};

http://www.html5rocks.com/en/tutorials/websockets/basics/

Seu servidor também deve estar ouvindo com um servidor WebSocket como o pywebsocket, alternativamente, você pode escrever o seu próprio conforme descrito no Mozilla

Darren
fonte
25
Para elaborar um pouco mais esta resposta: o servidor também deve estar ouvindo com um servidor WebSocket. WebSockets não pode se conectar diretamente a um socket TCP bruto. websockify é uma ferramenta que atua como proxy WebSocket-to-TCP: fica em seu servidor e escuta as conexões WebSocket e, em seguida, encaminha a comunicação WebSocket de e para um socket TCP especificado.
apsillers
58
Isso não responde à pergunta - websocket é um protocolo sobre TCP (como HTTP, por exemplo) e não uma comunicação TCP direta.
AlikElzin-kilaka
1
mas como colocar a mensagem na janela do navegador? :(
shzyincu
3
Esta resposta está totalmente errada e deve ser excluída.
Brad
1
@Brad esta resposta me ajudou e deve ter ajudado alguns outros também tendo 22 votos positivos.
user1378687 01 de
6

O projeto ws2s visa trazer o soquete para o js do lado do navegador. É um servidor websocket que transforma websocket em socket.

diagrama esquemático ws2s

insira a descrição da imagem aqui

amostra de código:

var socket = new WS2S("wss://ws2s.feling.io/").newSocket()

socket.onReady = () => {
  socket.connect("feling.io", 80)
  socket.send("GET / HTTP/1.1\r\nHost: feling.io\r\nConnection: close\r\n\r\n")
}

socket.onRecv = (data) => {
  console.log('onRecv', data)
}
Chenyan
fonte
5

Veja jsocket . Eu mesmo não usei. Faz mais de 3 anos desde a última atualização (em 26/06/2014).

* Usa flash :(

Da documentação :

<script type='text/javascript'>
    // Host we are connecting to
    var host = 'localhost'; 
    // Port we are connecting on
    var port = 3000;

    var socket = new jSocket();

    // When the socket is added the to document 
    socket.onReady = function(){
            socket.connect(host, port);             
    }

    // Connection attempt finished
    socket.onConnect = function(success, msg){
            if(success){
                    // Send something to the socket
                    socket.write('Hello world');            
            }else{
                    alert('Connection to the server could not be estabilished: ' + msg);            
            }       
    }
    socket.onData = function(data){
            alert('Received from socket: '+data);   
    }

    // Setup our socket in the div with the id="socket"
    socket.setup('mySocket');       
</script>
AlikElzin-kilaka
fonte
0

A solução que você realmente está procurando são os soquetes web. No entanto, o projeto de cromo desenvolveu algumas novas tecnologias que são conexões diretas de TCP TCP cromo

Sdedelbrock
fonte
0

Para conseguir o que deseja, você teria que escrever dois aplicativos (em Java ou Python, por exemplo):

  1. Aplicativo de ponte que fica na máquina do cliente e pode lidar com soquetes TCP / IP e WebSockets. Ele irá interagir com o soquete TCP / IP em questão.

  2. Aplicativo do lado do servidor (como um JSP / Servlet WAR) que pode falar com WebSockets. Inclui pelo menos uma página HTML (incluindo código de processamento do lado do servidor, se necessário) para ser acessada por um navegador.

Deve funcionar assim

  1. A ponte abrirá uma conexão WS com o aplicativo da web (porque um servidor não pode se conectar a um cliente).
  2. O aplicativo da Web pedirá ao cliente que se identifique
  3. O cliente da ponte envia algumas informações de ID ao servidor, que as armazena para identificar a ponte.
    1. A página visualizável pelo navegador se conecta ao servidor WS usando JS.
    2. Repita a etapa 3, mas para a página baseada em JS
    3. A página baseada em JS envia um comando para o servidor, incluindo para qual ponte ele deve ir.
    4. O servidor encaminha o comando para a ponte.
    5. A ponte abre um soquete TCP / IP e interage com ele (envia uma mensagem, obtém uma resposta).
    6. A ponte envia uma resposta ao servidor por meio do WS
    7. O WS encaminha a resposta para a página visualizável pelo navegador
    8. O JS processa a resposta e reage de acordo
    9. Repita até que o cliente desconecte / descarregue

Nota 1: As etapas acima são uma grande simplificação e não incluem informações sobre tratamento de erros e solicitações keepAlive, no caso de o cliente se desconectar prematuramente ou o servidor precisar informar aos clientes que está fechando / reiniciando.

Nota 2: Dependendo de suas necessidades, pode ser possível mesclar esses componentes em um se o servidor de soquete TCP / IP em questão (com o qual a ponte fala) estiver na mesma máquina que o aplicativo do servidor.

Agi Hammerthief
fonte