how to receive a socket message with an empty data?

Question

i have a socket client and a socket server.

(the server is in python, and is synchroneous.)

sometimes the clients send an empty string. i'm required to identify this situation, and return a response.

with this code, the server just keeps on waiting, and the client's don't get anything in return, unless it sends something mroe "fat" ;)

how can i capture the empty message? is it at all possible?

that's my 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... )

Answer 1

• In TCP, there is no such thing as an empty message, so zero means a peer disconnect.
• In UDP, there is no such thing as a peer disconnect, so zero means an empty datagram.

As you describe a multi-threaded socket server, it would seem to be TCP, in which case your requirement doesn't make sense. You can't send an empty message over TCP. You would have to use a superimposed protocol for everything.

Answer 2

Assuming TCP, you have to design a protocol that indicates when you've received a complete message. send() is not guaranteed to send every byte (check the return value) and recv() is not guaranteed to read the number of bytes requested. In the TCP recv() case, receiving zero bytes indicates the socket was closed, so there is no way to send an empty message without metadata (data describing the data).

So design a protocol that includes a way to determine a complete message has been received. Common ways are to send the size of the message first, or use a special sequence at the end indicating the message is complete. Also note socket's sendall() method will send all the bytes of the message.

Examples:

sendall('\x05Hello')  # length first
sendall('Hello\x00')  # nul-termination
sendall('\x00')       # length first, empty message
sendall('\x00')       # empty string, nul-termination.

For receiving, buffer recv() calls until a complete message is present.

Receive Algorithm (non-working 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

Answer 3

If the empty string means 0 bytes, the socket library on the client side might ignore it because a packet with 0 data bytes is a disconnect packet.

Answer 4

As answered previously, recv() returning 0 means "disconnect", so you cannot have a 0-length message.

However, you can get a TCP message that seems empty if you only look at it as a string, if what's actually received is a packet starting with a '\0' character.

You can handle this corner case like:

received = self.request.recv( PACKET_SIZE )
if received[0]=='\x00':
    <handle empty packet>

Answer 5

*Assuming you're sending packets with python's socket module with TCP/IP ex:

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((ip_in, port_in))

You cannot use to send an empty message:

sock.sendall(bytes("", 'ascii'))

Strings sent with TCP/IP are null terminating and look something like:

IP packing | TCP packing | string | null ascii character (0x00 in hex)

So sending "" will result in:

IP packing | TCP packing | 0x00

which a TCP server will interpret as a disconnect and the handler will not serve the request.

To send an "empty message" that the server will handle, use something like:

sock.sendall(bytes("\00", 'ascii'))

which sends a packet that looks like:

IP packing | TCP packing | 0x00 | 0x00

and the handling would look something like:

data = str(self.request.recv(1024), 'ascii')
# data = ""

Although all tcp packets use 32bits of data regardless of whether it is used or not, so sending a single null character is not really going to be much of a performance boon.