protocole de transfert websocket problème

Je suis à l'aide de python pour mettre en œuvre un simple serveur websocket.
La poignée de main que j'utilise vient de http://en.wikipedia.org/w/index.php?title=WebSockets&oldid=372387414.

La poignée de main lui-même semble fonctionner, mais quand j'ai cliquer sur "envoyer", j'obtiens une erreur javascript:

Erreur non interceptée: INVALID_STATE_ERR: DOM Exception 11

Voici le code html:

<!doctype html>
<html>
    <head>
        <title>ws_json</title>

    </head>
    <body onload="handleLoad();" onunload="handleUnload();">
        <input type="text" id='input' />
        <input type="button" value="submit" onclick="handleSubmit()" />
        <div id="display"></div>

        <script type="text/javascript">
            function showmsg(str){
                display = document.getElementById("display");
                display.innerHTML += "<p>" + str + "</p>";
            }

            function send(str){
                ws.send(str.length);
                ws.send(str);
            }

            function handleSubmit(){
                input = document.getElementById('input');
                send(input.value);
                input.focus();
                input.value = '';
            }

            function handleLoad(){
                ws = new WebSocket("ws://localhost:8888/");
                ws.onopen = function(){
                    showmsg("websocket opened.");
                }

                ws.onclose = function(){
                    showmsg("websocket closed.");
                }
            }

            function handleUnload(){
                ws.close();
            }
        </script>
    </body>
</html>

Et voici le code python:

import socket
import threading
import json

PORT = 8888
LOCATION = "localhost:8888"

def handler(s):

    print " in handler "

    ip, _ = s.getpeername()
    print "New connection from %s" % ip
    request = s.recv(1024)

    print "\n%s\n" % request
    print s.getpeername()

    # send response
    response = "HTTP/1.1 101 Web Socket Protocol Handshake\r\n"
    response += "Upgrade: WebSocket\r\n"
    response += "Connection: Upgrade\r\n"
    try:
        peername = s.getpeername()
        response += "Sec-WebSocket-Origin: http://%s\r\n" % peername[0] # % request[request.index("Origin: ")+8:-4]
    except ValueError:
        print "Bad Request"
        raise socket.error
    response += "Sec-WebSocket-Location: ws://%s\r\n" % LOCATION
    response += "Sec-WebSocket-Protocol: sample"
    response = response.strip() + "\r\n\r\n"

    print response
    s.send(response)

    while True:
        length = s.recv(1)
        print length
        if not length:
            break
        length = int(length)
        print "Length: %i" % length
        data = s.recv(length)
        print "Received: %s" % data
        print ""

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(('localhost', PORT))
s.listen(5)

print "server is running..."
while True:
    sock, addr = s.accept()
    threading.Thread(target=handler, args=(sock, )).start()

Personne ne sait ce que je fais mal?

Je ne peux pas tester votre code sans le WebSocket classe. où est-il défini? Firefox 3.6.3 n'a pas l'air de savoir ce qu'il est.
Chrome Dev, et Firefox 4 est censé avoir.
Comment avez-vous offrir une prime si vous n'avez pas 100 rep?
Comment est la même ws objet référencé par ces deux fonctions, handleLoad() et send(str)? Est-il une variable globale déclarée quelque part d'autre que je ne suis pas le voir?
En Javascript globales sont tout juste d'être nommé, les habitants sont créés avec le mot-clé var

OriginalL'auteur lowerkey | 2010-07-10

6

J'ai testé votre code sur Firefox 4 et j'ai obtenu le même message d'erreur au moment de frapper envoyer, cependant, avant que j'ai eu

Firefox ne peut pas établir une connexion
pour le serveur ws://localhost:8888/.

qui est probablement la raison pour laquelle l'objet WebSocket a été détruit. Je soupçonne que votre poignée de main de réponse manque de quelque chose, de sorte que Firefox est la fermeture de la socket.

À partir de l'article de Wikipédia sur les Websockets:

La Sec-WebSocket-Clé1 et
Sec-WebSocket-Clé2 les champs et les
huit octets après les champs sont
aléatoire des jetons qui utilise le serveur pour
construire un 16 octets jeton à la fin
de sa poignée de main pour prouver qu'il a
lire le client de la poignée de main.

Votre réponse du serveur ne disposez pas de ce numéro spécial à l'arrière, Donc je pense que nous avons besoin de comprendre comment le générer, et de l'inclure.

EDIT: Comment générer un nombre

Permet de commencer avec key1, key2, et les 8 octets à la fin de la poignée de main
```
key1 = "18x 6]8vM;54 *(5:  {   U1]8  z [  8"
key2 = "1_ tx7X d  <  nw  334J702) 7]o}` 0"
end8 = "Tm[K T2u"
```
Nous faire un numéro pour chacune des clés, en ignorant tous les caractères qui n'est pas un chiffre de 0 à 9. En Python:
```
def numFromKey(key):
    return int(filter(lambda c: c in map(str,range(10)),key))
```
ensuite, nous divisons ce nombre par le nombre de places dans la clé d'original de chaîne, donc, ici, est une est une fonction qui compte les espaces dans une chaîne de caractères.
```
def spacesIn(key):
    return len(filter(lambda c: c==' ',key))
```
Les deux nombres résultant de l'clés sont les suivantes:
```
pkey1 = numFromKey(key1)/spacesIn(key1)
pkey2 = numFromKey(key2)/spacesIn(key2)
```
Maintenant nous avons besoin de concaténer les octets de pkey1, pkey2, et end8. Le traité clés doivent être représentés sur 32 bits Big Endian numéros.
```
from struct import pack
catstring = pack('>L',pkey1) + pack('>L',pkey2) + end8
```
Puis nous prenons le hash md5 de ces octets à obtenir le nombre magique que nous punaise sur la fin de la poignée de main
```
import md5
magic = md5.new(catstring).digest()
```
C'est comment je pense qu'il fonctionne au moins

Merci pour l'info, n'aurait jamais pensé que moi-même. J'ai trouvé ceci sur google: golang.org/src/pkg/websocket/server.go il explique comment générer une clé. Travail sur la compréhension de ce que nous parlons.
Voici une meilleure description de la poignée de main: tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76#page-7
Je suis arrivé à une solution similaire, mais je vais avoir des problèmes d'encodage des résultats de l'algorithme md5 en utf-8.
pastebin.com/Q4GPcM09 Voici mon code pour la poignée de main, mais comme je l'ai dit il y a un problème avec l'encodage utf-8.
Il y a un rubis de mise en œuvre ici: github.com/igrigorik/em-websocket/blob/master/lib/em-websocket/... pour le codage d'un hachage MD5 comme UTF-8; le qui ne devrait pas être nécessaire, car l'ASCII est un sous-ensemble de l'UTF-8. Si une chaîne de caractères ASCII (hachages MD5 seulement contenir [0-9a-f]) est automatiquement valide UTF-8.

OriginalL'auteur Nathan
0

À partir de la Version 8, ce protocole est obsolète, veuillez vous référer à:

http://tools.ietf.org/id/draft-ietf-hybi-thewebsocketprotocol-12.txt

pour la nouvelle version du protocole.

Merci pour l'astuce. Cela a été un moment...

OriginalL'auteur Bojan Jovanovic

Vous devez vous connecter pour publier un commentaire.