Python socket receive - les paquets entrants ont toujours une taille différente

la réponse de Larry Hastings contient quelques bons conseils généraux sur les sockets, mais il y a quelques erreurs en ce qui concerne la façon dont la méthode recv(bufsize) fonctionne dans le module de socket Python.

donc, pour clarifier, puisque cela peut être déroutant pour d'autres qui cherchent de l'aide:

1. le paramètre bufsize pour la méthode recv(bufsize) n'est pas facultatif. Vous obtiendrez une erreur si vous appelez recv() (sans le param).
2. le bufferlen dans recv(bufsize) est un maximum taille. Le recv renverra volontiers moins d'octets s'il y en a moins disponibles.

voir la documentation pour plus de détails.

maintenant, si vous recevez des données d'un client et que vous voulez savoir quand vous avez reçu toutes les données, vous allez probablement devoir les ajouter à votre protocole -- comme Larry le suggère. Voir ce recette pour les stratégies de détermination de la fin de message.

comme le souligne cette recette, pour certains protocoles, le client se déconnectera simplement quand il aura fini d'envoyer des données. Dans ces cas, votre boucle while True devrait fonctionner correctement. Si le client ne pas déconnecter, vous aurez besoin de comprendre un moyen de signaler votre longueur de contenu, délimiter vos messages, ou mettre en œuvre un timeout.

je serais heureux d'essayer d'aider de plus, si vous pouviez afficher votre code client exact et une description de votre protocole de test.

vous pouvez alternativement utiliser recv(x_bytes, socket.MSG_WAITALL) , qui semble fonctionner seulement sur Unix, et retournera exactement x_bytes .

C'est la nature de TCP: le protocole remplit des paquets (couche inférieure étant des paquets IP) et les envoie. Vous pouvez avoir un certain degré de contrôle sur le MTU (Maximum Transfer Unit).

en d'autres termes: vous devez concevoir un protocole qui chevauche TCP où votre" délimitation de charge utile " est définie. Par "délimitation de la charge utile", je veux dire la façon dont vous extrayez l'Unité de message que votre protocole supporte. Cela peut être aussi simple que "toutes les chaînes à terminaison nulle".

notez que raison exacte pourquoi votre code est gelé est et non parce que vous avez placé une requête trop élevée.Taille du tampon recv (). Ici est expliqué ce qui signifie la taille du tampon dans la socket.recv (buffer_size)

ce code fonctionnera jusqu'à ce qu'il reçoive un message TCP vide (si vous imprimez ce message vide, il affichera b'' ):

while True:    
  data = self.request.recv(1024)
  if not data: break

et note, qu'il y a no way pour envoyer un message TCP vide. socket.send(b'') ne marchera pas.

pourquoi? Parce que le message vide est envoyé seulement quand vous tapez socket.close() , donc votre script Boucle aussi longtemps que vous ne fermez pas votre connexion. Comme Hans l fait remarquer ici quelques bonnes méthodes pour terminer le message .

je sais que c'est vieux, mais j'espère que cela aide quelqu'un.

en utilisant des sockets python réguliers j'ai trouvé que vous pouvez envoyer et recevoir des informations dans des paquets en utilisant sendto et recvfrom

# tcp_echo_server.py
import socket

ADDRESS = ''
PORT = 54321

connections = []
host = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
host.setblocking(0)
host.bind((ADDRESS, PORT))
host.listen(10)  # 10 is how many clients it accepts

def close_socket(connection):
    try:
        connection.shutdown(socket.SHUT_RDWR)
    except:
        pass
    try:
        connection.close()
    except:
        pass

def read():
    for i in reversed(range(len(connections))):
        try:
            data, sender = connections[i][0].recvfrom(1500)
            return data
        except (BlockingIOError, socket.timeout, OSError):
            pass
        except (ConnectionResetError, ConnectionAbortedError):
            close_socket(connections[i][0])
            connections.pop(i)
    return b''  # return empty if no data found

def write(data):
    for i in reversed(range(len(connections))):
        try:
            connections[i][0].sendto(data, connections[i][1])
        except (BlockingIOError, socket.timeout, OSError):
            pass
        except (ConnectionResetError, ConnectionAbortedError):
            close_socket(connections[i][0])
            connections.pop(i)

# Run the main loop
while True:
    try:
        con, addr = host.accept()
        connections.append((con, addr))
    except BlockingIOError:
        pass

    data = read()
    if data != b'':
        print(data)
        write(b'ECHO: ' + data)
        if data == b"exit":
            break

# Close the sockets
for i in reversed(range(len(connections))):
    close_socket(connections[i][0])
    connections.pop(i)
close_socket(host)

le client est similaire

# tcp_client.py
import socket

ADDRESS = "localhost"
PORT = 54321

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((ADDRESS, PORT))
s.setblocking(0)

def close_socket(connection):
    try:
        connection.shutdown(socket.SHUT_RDWR)
    except:
        pass
    try:
        connection.close()
    except:
        pass

def read():
    """Read data and return the read bytes."""
    try:
        data, sender = s.recvfrom(1500)
        return data
    except (BlockingIOError, socket.timeout, AttributeError, OSError):
        return b''
    except (ConnectionResetError, ConnectionAbortedError, AttributeError):
        close_socket(s)
        return b''

def write(data):
    try:
        s.sendto(data, (ADDRESS, PORT))
    except (ConnectionResetError, ConnectionAbortedError):
        close_socket(s)

while True:
    msg = input("Enter a message: ")
    write(msg.encode('utf-8'))

    data = read()
    if data != b"":
        print("Message Received:", data)

    if msg == "exit":
        break

close_socket(s)