Herstellen einer Verbindung zu TCP Socket über einen Browser mithilfe von Javascript

Ich habe eine vb.net-Anwendung, die einen Socket öffnet und darauf hört.

Ich muss über diesen Socket mit dieser Anwendung über ein Javascript kommunizieren, das in einem Browser ausgeführt wird. Das heißt, ich muss einige Daten über diesen Socket senden, damit die App, die diesen Socket abhört, diese Daten aufnehmen, einige Dinge mit einigen Fernaufrufen erledigen und weitere Daten abrufen und sie wieder auf den Socket setzen kann, den mein Javascript benötigt Lesen und drucken Sie es im Browser.

Ich habe versucht, socket.io, websockify, aber keine hat sich als nützlich erwiesen.

Daher ist die Frage, was ich versuche, überhaupt möglich? Gibt es eine Möglichkeit, dass ein in einem Browser ausgeführtes Javascript eine Verbindung zu einem TCP-Socket herstellen und einige Daten senden und auf eine weitere Datenantwort auf dem Socket warten und diese an den Browser drucken kann?

Wenn dies möglich ist, kann mich jemand in die richtige Richtung weisen, die mir helfen würde, das Ziel festzulegen.

Für Ihr Problem müssen Sie sich derzeit auf XHR oder Websockets verlassen.

Derzeit hat kein beliebter Browser eine solche Raw-Sockets-API für Javascript implementiert, mit der Sie Raw-Sockets erstellen und darauf zugreifen können. Ein Entwurf für die Implementierung der Raw-Sockets-API in JavaScript ist jedoch im Gange. Schauen Sie sich diese Links an:
http://www.w3.org/TR/raw-sockets/
https://developer.mozilla.org/en-US/docs/Web/API/TCPSocket

Chrome unterstützt jetzt unformatierte TCP- und UDP-Sockets in seinen "experimentellen" APIs. Diese Funktionen sind nur für Erweiterungen verfügbar und werden, obwohl dokumentiert, momentan ausgeblendet. Allerdings erstellen einige Entwickler bereits interessante Projekte damit, wie z. B. diesen IRC-Client .

Um auf diese API zugreifen zu können, müssen Sie das experimentelle Flag im Manifest Ihrer Erweiterung aktivieren. Die Verwendung von Sockets ist ziemlich einfach, zum Beispiel:

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

Dies ist über die Navigationsoberfläche wie folgt möglich:

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

Weitere Details finden Sie in der Dokumentation zu w3.org tcp-udp-sockets.

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

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

Eine andere Alternative ist die Verwendung von Chrome Sockets

Verbindungen herstellen

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

Daten senden

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

Daten empfangen

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

Sie können auch versuchen, zu verwenden HTML5 Web Sockets(obwohl dies keine direkte TCP-Kommunikation ist):

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

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

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

Ihr Server muss auch mit einem WebSocket-Server wie pywebsocket lauschen. Alternativ können Sie Ihren eigenen Server schreiben, wie bei Mozilla beschrieben

Das ws2s- Projekt zielt darauf ab, Socket auf browser-seitige js zu bringen. Es ist ein Websocket-Server, der Websocket in Socket umwandelt.

ws2s schematisches Diagramm

Codebeispiel:

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

Siehe jsocket . Ich habe es selbst nicht benutzt. Seit mehr als 3 Jahren seit dem letzten Update (Stand 26.6.2014).

* Verwendet Flash :(

Aus der Dokumentation :

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

Die Lösung, nach der Sie wirklich suchen, sind Web-Sockets. Das Chromprojekt hat jedoch einige neue Technologien entwickelt, die direkte TCP-Verbindungen TCP-Chrom sind

Um das zu erreichen, was Sie wollen, müssten Sie zwei Anwendungen schreiben (z. B. in Java oder Python):

1. Bridge-App, die sich auf dem Client-Computer befindet und sowohl TCP / IP-Sockets als auch WebSockets verarbeiten kann. Es wird mit dem betreffenden TCP / IP-Socket interagieren.

2. Serverseitige App (z. B. JSP / Servlet WAR), die WebSockets kommunizieren kann. Es enthält mindestens eine HTML-Seite (gegebenenfalls einschließlich serverseitigen Verarbeitungscodes), auf die ein Browser zugreifen kann.

Es sollte so funktionieren

1. Die Bridge öffnet eine WS-Verbindung zur Web-App (da ein Server keine Verbindung zu einem Client herstellen kann).
2. Die Web-App fordert den Client auf, sich zu identifizieren
3. Der Bridge-Client sendet einige ID-Informationen an den Server, der sie speichert, um die Bridge zu identifizieren.
   4. Die vom Browser sichtbare Seite stellt über JS eine Verbindung zum WS-Server her.
   5. Wiederholen Sie Schritt 3, jedoch für die JS-basierte Seite
   6. Die JS-basierte Seite sendet einen Befehl an den Server, einschließlich der Bridge, zu der sie gehen muss.
   7. Der Server leitet den Befehl an die Bridge weiter.
   8. Die Bridge öffnet einen TCP / IP-Socket und interagiert mit ihm (sendet eine Nachricht, erhält eine Antwort).
   9. Die Bridge sendet über das WS eine Antwort an den Server
   10. Der WS leitet die Antwort an die vom Browser sichtbare Seite weiter
   11. Der JS verarbeitet die Antwort und reagiert entsprechend
   12. Wiederholen, bis einer der Clients die Verbindung trennt / entlädt

Hinweis 1: Die obigen Schritte sind eine große Vereinfachung und enthalten keine Informationen zur Fehlerbehandlung und zu KeepAlive-Anforderungen, falls der Client die Verbindung vorzeitig trennt oder der Server die Clients darüber informieren muss, dass er heruntergefahren / neu gestartet wird.

Hinweis 2: Abhängig von Ihren Anforderungen können diese Komponenten möglicherweise zu einer zusammengeführt werden, wenn sich der betreffende TCP / IP-Socket-Server (mit dem die Bridge kommuniziert) auf demselben Computer wie die Server-App befindet.