L'envoi de données binaires sur les sockets avec Python

Je suis à la recherche d'un script de base de demandes au cours des Protocole SPDY. Le protocole définit les cadres de vous envoyer comme étant composée de données binaires très précis de la longueur et de l'ordre des octets.

Je n'ai jamais écrit de petits programmes qui envoient des chaînes à travers des sockets (HTTP). Comment puis-je mettre en place une SPDY trame de contrôle d'en-tête par exemple? J'ai essayé d'utiliser le bitstring bibliothèque numpy et de contrôler la taille de toutes les différentes sections d'un cadre de contrôle de l'en-tête par exemple, mais rien ne fonctionne vraiment. L'actuel SPDY bibliothèque pour python utilise cython et les types de données C et je l'ai trouvé pour être très imprévisible. Je me demandais comment je peux aller sur la construction de simples demandes pur python ou tout simplement comment puis-je aller sur la construction de quelque chose, précisément comme le protocole définit et en l'envoyant à travers un socket?

InformationsquelleAutor ubiQ | 2013-08-19
  1. 23

    Généralement bytearray classe sera votre ami (si j'ai bien compris votre question correctement). Vous pouvez l'envoyer via socket:

    my_bytes = bytearray()
my_bytes.append(123)
my_bytes.append(125)

// my_bytes is b'{}' now

s.send(my_bytes)

    Suivre les spécifications de protocole et de créer octet par octet. Cela fonctionne aussi lorsque vous recevez des données:

    data = s.recv(2048)
my_bytes = bytearray(data)

    Je ne sais pas beaucoup sur le protocole SPDY, mais par exemple le bit de contrôle est la première peu (pas d'octets) dans le message. Vous pouvez le récupérer à partir de my_bytes via le binaire ET par exemple:

    control_frame = my_bytes[0] & 128

    c'est parce que 128 est 10000000 en binaire et donc binaire ET vous donnera les premiers bits uniquement (n'oubliez pas que chaque octet contient 8 bits c'est pourquoi nous avons 7 zéros).

    C'est la façon dont les choses sont faites manuellement. Bien sûr, je suggère d'utiliser certains de la bibliothèque car l'écriture d'un bon gestionnaire de protocole va prendre beaucoup de temps, vous pouvez trouver qu'il est assez difficile et il pourrait ne pas être efficace (en fonction de vos besoins, bien sûr).

    • merci je suis à la recherche dans ce, comment puis-je imprimer les bits dans l'objet bytearray comme lisible une chaîne de caractères si je suis initialisation de chacun comme 0b...?
    • Bits? Bit est 0 ou 1. Si vous souhaitez imprimer un objet bytearray tout simplement print my_bytes. L'interpréteur Python doit convertir automatiquement chaque octet de sa représentation sous forme de chaîne. Note qu'il pourrait ne pas être "lisible" (dépend de ce que cela signifie exactement).
    • Je veux lire comme une chaîne de caractères dans la console, mais c'est pour la sortie binaire brut atm
    • Qu'est-ce exactement avez-vous mis dans ce tableau? Montrez-moi un peu de code. Notez que seuls les octets entre 32 et 126 sont imprimables (ASCII).
    • control_header = bytearray() control_header.append(0b1) # control_flag control_header.append(0b000000000000010) # version control_header.append(0b0000000000000001) # type control_header.append(0b00000000) # drapeaux control_header.append(0b000000000000000000000000) # longueur d'impression my_bytes
    • Yep, comme je l'ai dit: seuls les octets entre 32 et 126 sont imprimables. en.wikipedia.org/wiki/ASCII#ASCII_printable_characters
    • ah ok je comprends, merci pour l'aide
    • Notez également l'erreur que vous faites: les deux bit de contrôle de version et prendre 2 octets. Mais la version a 15 bits, c'est à dire si votre version est à dire v = 0b000000000000010 et votre bit de contrôle c = 0b1 alors votre premier octet est first = (c << 7) + (v >> 8) (qui signifie "ajouter 7 zéros à c et ajouter le résultat à la première moitié de v") et vous devriez faire control_header.append(first). Puis control_header.append(v & 255) (qui signifie "ajouter la deuxième moitié de v comme un deuxième octet"). Comme je l'ai dit: la mise en œuvre d'un protocole peut être très difficile.

    InformationsquelleAutor freakish
  2. 3

    Vous pouvez également utiliser le struct module pour définir le format d'en-tête avec une chaîne et d'analyser directement.

    Pour générer un paquet:

    fmt = 'B I 4b'
your_binary_data = pack(fmt, header_data)
sock.sendall(your_binary_data)

    Où fmt indique le format d'en-tête ('B I 4b' est juste un, clairement pas de travail pour votre SPDY en-tête, par exemple). Malheureusement, vous aurez à traiter avec des non-octet-alligned champs d'en-tête, probablement par l'analyse de gros morceaux, puis en les divisant en fonction de votre format.

    De côté que, pour analyser l'en-tête:

    unpacker = struct.Struct('B I 4b')
unpacked_data = unpacker.unpack(s.recv(unpacker.size))

    unpacked_data contiendra un tuple avec l'analyse des données.

    La struct module effectue des conversions entre Python valeurs et C les structures représentées comme Python cordes. Je n'ai aucune garantie quant à l'efficacité de cette approche, mais il m'a aidé à analyser les différents protocoles simplement en ajustant la fmt chaîne.

    InformationsquelleAutor Niko