Connessione a TCP Socket dal browser utilizzando javascript

Ho un'applicazione vb.net che apre un socket e lo ascolta.

Ho bisogno di comunicare tramite questo socket a quell'applicazione utilizzando un javascript in esecuzione su un browser. Cioè ho bisogno di inviare alcuni dati su questo socket in modo che l'app che è in ascolto su questo socket possa prendere quei dati, fare alcune cose usando alcune chiamate remote e ottenere altri dati e rimetterli sul socket che il mio javascript ha bisogno di leggilo e stampalo nel browser.

Ho provato, socket.io, websockify ma nessuno si è rivelato utile.

Da qui la domanda, è possibile quello che sto provando? C'è un modo in cui un javascript in esecuzione in un browser può connettersi a un socket tcp e inviare alcuni dati e ascoltarlo per qualche risposta in più sui dati sul socket e stamparlo nel browser.

Se questo è possibile, qualcuno può indicarmi la giusta direzione che mi aiuterebbe a stabilire l'obiettivo.

Per quanto riguarda il tuo problema, attualmente dovrai dipendere da XHR o websocket per questo.

Attualmente nessun browser popolare ha implementato alcuna API di socket raw per javascript che ti consenta di creare e accedere a socket raw, ma è in corso una bozza per l'implementazione di api raw sockets in JavaScript. Dai un'occhiata a questi link:
http://www.w3.org/TR/raw-sockets/
https://developer.mozilla.org/en-US/docs/Web/API/TCPSocket

Chrome ora supporta i socket TCP e UDP non elaborati nelle sue API "sperimentali". Queste funzionalità sono disponibili solo per le estensioni e, sebbene documentate, per il momento sono nascoste. Detto questo, alcuni sviluppatori stanno già creando progetti interessanti che lo utilizzano, come questo client IRC .

Per accedere a questa API, devi abilitare il flag sperimentale nel file manifest della tua estensione. L'uso dei socket è piuttosto semplice, ad esempio:

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

Ciò sarà possibile tramite l'interfaccia del navigatore come mostrato di seguito:

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

Maggiori dettagli sono descritti nella documentazione di w3.org tcp-udp-sockets.

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

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

Un'altra alternativa è utilizzare Chrome Socket

Creazione di connessioni

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

Invio di dati

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

Ricevendo dati

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

Puoi anche provare a usare HTML5 Web Sockets(sebbene questa non sia una comunicazione TCP diretta):

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/

Il tuo server deve anche essere in ascolto con un server WebSocket come pywebsocket, in alternativa puoi scrivere il tuo come descritto su Mozilla

Il progetto WS2S ha lo scopo di portare socket a js lato browser. È un server websocket che trasforma websocket in socket.

diagramma schematico ws2s

codice di esempio:

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

Vedi jsocket . Non l'ho usato io stesso. Sono passati più di 3 anni dall'ultimo aggiornamento (al 26/6/2014).

* Utilizza flash :(

Dalla documentazione :

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

La soluzione che stai veramente cercando sono i web socket. Tuttavia, il progetto chromium ha sviluppato alcune nuove tecnologie che sono connessioni TCP dirette TCP chromium

Per ottenere ciò che desideri, dovresti scrivere due applicazioni (in Java o Python, ad esempio):

1. App Bridge che si trova sulla macchina del client e può gestire sia socket TCP / IP che WebSocket. Interagirà con il socket TCP / IP in questione.

2. App lato server (come un JSP / Servlet WAR) che può parlare con WebSocket. Include almeno una pagina HTML (incluso il codice di elaborazione lato server, se necessario) a cui accedere da un browser.

Dovrebbe funzionare in questo modo

1. Il Bridge aprirà una connessione WS all'app Web (perché un server non può connettersi a un client).
2. L'app Web chiederà al client di identificarsi
3. Il client bridge invia alcune informazioni sull'ID al server, che le memorizza per identificare il bridge.
   4. La pagina visualizzabile dal browser si connette al server WS utilizzando JS.
   5. Ripetere il passaggio 3, ma per la pagina basata su JS
   6. La pagina basata su JS invia un comando al server, incluso il bridge a cui deve andare.
   7. Il server inoltra il comando al bridge.
   8. Il bridge apre un socket TCP / IP e interagisce con esso (invia un messaggio, riceve una risposta).
   9. The Bridge invia una risposta al server tramite il WS
   10. Il WS inoltra la risposta alla pagina visualizzabile dal browser
   11. Il JS elabora la risposta e reagisce di conseguenza
   12. Ripetere fino a quando uno dei client si disconnette / scarica

Nota 1: i passaggi precedenti sono una grande semplificazione e non includono informazioni sulla gestione degli errori e sulle richieste keepAlive, nel caso in cui il client si disconnetta prematuramente o il server debba informare i client che si sta spegnendo / riavviando.

Nota 2: a seconda delle esigenze, potrebbe essere possibile unire questi componenti in uno solo se il server socket TCP / IP in questione (con cui parla il bridge) si trova sulla stessa macchina dell'app server.