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

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.

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

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

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

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

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>

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

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.
   4. A página visualizável pelo navegador se conecta ao servidor WS usando JS.
   5. Repita a etapa 3, mas para a página baseada em JS
   6. A página baseada em JS envia um comando para o servidor, incluindo para qual ponte ele deve ir.
   7. O servidor encaminha o comando para a ponte.
   8. A ponte abre um soquete TCP / IP e interage com ele (envia uma mensagem, obtém uma resposta).
   9. A ponte envia uma resposta ao servidor por meio do WS
   10. O WS encaminha a resposta para a página visualizável pelo navegador
   11. O JS processa a resposta e reage de acordo
   12. 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.