so erhalten Sie eine socket-Nachricht mit einer leeren Daten?

habe ich einen socket-client und socket-server.

(der server ist in python, und ist synchroneous.)

manchmal sind die Kunden senden eine leere Zeichenfolge. bin ich verpflichtet, zu identifizieren, diese situation, und eine Antwort zurück.

mit diesem code, den der server hält nur auf warten, und die Kunden erhalten nichts zurück, es sei denn, er sendet etwas mroe "Fett" 😉

wie kann ich erfassen die leere Nachricht? ist es überhaupt möglich?

das ist mein server code:

import SocketServer

def multi_threaded_socket_server():

    class MyRequestHandler(SocketServer.BaseRequestHandler):
        def handle(self):
            while True:
                print 'waiting for client calls...'
                received = self.request.recv( PACKET_SIZE )
                (handle request... )

Ist das TCP oder UDP?

InformationsquelleAutor Berry Tsakala | 2010-07-29

python sockets

7
- In TCP gibt es keine solche Sache wie eine leere Nachricht, so dass null bedeutet, dass ein peer trennen.
- UDP, es gibt keine solche Sache wie eine peer-Verbindung trennen, also null bedeutet eine leere Datagramm.
Als Sie beschreiben ein multi-threaded-socket-server, es würde zu sein scheinen, TCP, in welchem Falle Ihre Anforderung nicht sinnvoll. Sie können nicht senden Sie eine leere Nachricht über TCP. Sie müssten eine überlagerte Protokoll für alles.
- Bitte erklären. Keine Fehler hier.
InformationsquelleAutor user207421
0

Wenn die leere Zeichenfolge bedeutet, dass 0 bytes an, die socket-library auf der client-Seite könnte es ignorieren, weil ein Paket mit 0 bytes Daten ist ein disconnect-Paket.
- Die socket-Bibliothek auf dem client gar nicht sehen, wie es wird nie ankommen.
InformationsquelleAutor C.Evenhuis
0

Vorausgesetzt, TCP, haben Sie zu entwerfen ein Protokoll, das anzeigt, wenn Sie erhalten haben, eine vollständige Nachricht. send() ist nicht garantiert, senden jedes byte (überprüfen Sie den Rückgabewert) und recv() garantiert nicht, Lesen Sie die Anzahl der angeforderten bytes.

Design ein Protokoll, enthält eine Möglichkeit, um zu bestimmen, eine vollständige Nachricht empfangen wurde. Gemeinsame Wege sind zu senden, die Größe der Nachricht, oder verwenden Sie eine spezielle Sequenz am Ende, der angibt, die Nachricht vollständig ist. Beachten Sie auch socket s sendall () - Methode wird alle bytes senden der Nachricht.

Beispiele:
```
sendall('\x05Hello')  # length first
sendall('Hello\x00')  # nul-termination
```
Für das empfangen, Puffern recv() aufruft, bis eine vollständige Nachricht vorhanden ist.

Erhalten-Algorithmus (nicht-funktionierenden code):
```
class Handler:

  def __init__(self):
    self.buffer = ''

  def handler(self):
    while True:
      msg = self.get_msg()
      if not msg: break
      process msg

  def get_msg(self):
    if complete message not at the beginning of buffer:
      chunk = recv(1000)
      if not chunk: return '' # socket closed
      buffer += chunk
    remove message from beginning of buffer...update buffer
    return message
```
InformationsquelleAutor Mark Tolonen
-1

*Vorausgesetzt Sie versenden Pakete mit python-socket-Modul mit TCP/IP ex:
```
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((ip_in, port_in))
```
Können Sie nicht verwenden, senden Sie eine leere Nachricht:
```
sock.sendall(bytes("", 'ascii'))
```
Strings gesendet, die über TCP/IP null sind beendet und so Aussehen:
```
IP packing | TCP packing | string | null ascii character (0x00 in hex)
```
So senden", " Ergebnis:
```
IP packing | TCP packing | 0x00
```
welche einen TCP-server interpretiert wird als ein trennen und die Prozedur dient nicht der Anfrage.

Senden Sie eine "leere Nachricht", dass die server umgehen, verwenden Sie so etwas wie:
```
sock.sendall(bytes("\00", 'ascii'))
```
sendet ein Paket, das aussieht wie:
```
IP packing | TCP packing | 0x00 | 0x00
```
und die Abwicklung würde folgendermaßen Aussehen:
```
data = str(self.request.recv(1024), 'ascii')
# data = ""
```
Obwohl alle tcp-Pakete verwenden, 32-bit von Daten, unabhängig davon, ob es benutzt wird oder nicht, so senden einer einzelnen null-Zeichen ist nicht wirklich viel Leistung Segen.
- Gesendete Zeichenfolgen mit TCP/IP sind nicht null-terminiert. Das geschieht, wenn überhaupt, durch den Absender. Senden "" wird nicht dazu führen, dass überhaupt nichts, geschweige denn etwas, das interpretiert werden, als eine Trennung. Alle TCP-Pakete, nicht "32-bit-Daten'. Antwort ist kompletter Unsinn.
InformationsquelleAutor David
-1

Als beantwortet zuvor recv() 0 zurückgeben bedeutet "trennen", so dass Sie nicht haben, eine 0-Länge Nachricht.

Jedoch, können Sie eine TCP-Nachricht, die scheint leer, wenn Sie nur betrachten es als einen string, wenn was eingegangen ist ein Paket, beginnend mit einem '\0' - Zeichen.

Können Sie behandeln diese Ecke Fall wie:
```
received = self.request.recv( PACKET_SIZE )
if received[0]=='\x00':
    <handle empty packet>
```
- Ein Ergebnis null von recv() an trennen. Ein disconnect segment in TCP ist eine, die enthält ein FIN-bit. Es ist nicht unbedingt mit der Länge null.
InformationsquelleAutor Kristóf Szalay

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.