Python套接字接收多个TCP标头

Question

I am a beginner with Python, so please consider I will not be able to give complete information in one go.

My requirements are:

I am implementing a Python based socket receiver. Implementation is complete but I have to handle a message/data stream with following:

1) Data stream will have 4 different types of message in it. Each having a message header (1-4) which I am getting using

type_msg=struct.unpack('B',data[0])[0]

2) Second part is that next 4 bits will have the actual length of the data of each type according to the header. So,

actual_len = struct.unpack('i', data[1:5])[0]

3) Next part is to handle the data received and play with it. Length of received data can be taken by ** rcv_len = len(data)**

I am facing problem in situation where I receive less/more data then than actual length. I have the delta-length which I have got using actual_len-rcv_len

I am unable to handle code after this. What is the best way to receive delta message and then appending it to received data till now. I also want to write the data into a file.

I have read about data.append but not very sure about how to implement it. Should I again receive data using conn.recv(del_len) or do something else.

Any guidance will be very helpful.

Adding Code below:

BUFFER_SIZE=40960
import socket
import struct

class mySocket:

def __init__(self, sock=None):
    if sock is None:
        self.sock = socket.socket(
                        socket.AF_INET, socket.SOCK_STREAM)
        self.sock.bind(('', 9988)) 
        self.sock.listen(1)
    else:
        self.sock = sock

def receive_data(self):
    # Wait for a connection
    print >>sys.stderr, 'waiting for a connection'
    conn, client_address= self.sock.accept()
    print "Connected to client with IP---->", client_address
    while True:
        data = conn.recv(BUFFER_SIZE) 
        if not data:
            print "Connection is Broken.."
            break
        else: 
            if data<5:
                print "MSG HEADER STILL NOT COMPLETELY RECEIVED"
            else:
                type_msg=struct.unpack('B',data[0])
                msg_type = type_msg[0]
                rcv_len = len(data)
                actual_len = struct.unpack('i', data[1:5])[0]
                print "Received Length: ",rcv_len
                print "Actual Length : ",actual_len
                if msg_type == 1:
                    f_cfg = open("test.xml", "wb")
                    if rcv_len < actual_len:
                        del_len = actual_len-rcv_len
                        print "Delta length :",del_len
                        while (del_len):
                            print "Receiving Falcon Config File..."
                            print "Actual Length : ",actual_len,"and total length now is",rcv_len+del_len
                            f_cfg.write(data[5:rcv_len]+data[del_len]) //Feel something wrong in this.
                    else:
                        print "Writing Falcon config"
                        f_cfg.write(data[5:])
                    f_cfg.close()
                else:
                    print "INVALID MESSAGE TYPE. DATA CORRUPTED !!"
                    break

    conn.send("Data Received")
    conn.close()

Answer 1

You are pretty close. The tricks are to never read in more data than you need at any step so you don't have to worry about over shooting. And just keep track of the data remaining by subtracting the amount you receive each time so you don't have to juggle multiple variables.

Here is a helper that will read in a fixed size buffer. Use it to read in the header.

def recv_exactly(sock, count):
    """receive exactly count bytes from socket. If socket is closed,
    empty string is returned even if some data received.
    """
    buf = []
    while count:
        data = sock.recv(count)
        if not data:
            return ''
        count -= len(data)
        buf.append(data)
    return ''.join(buf)

You could use the same function to read in the data, but its better to write the file as you go. Notice when receiving data, the min function is used to decide on a recv size.

def receive_data(self):
    # Wait for a connection
    print >>sys.stderr, 'waiting for a connection'
    conn, client_address= self.sock.accept()
    print "Connected to client with IP---->", client_address
    while True:
        # read fix length header
        data = recv_exactly(conn, 5) 
        if not data:
            print "Connection is Broken.."
            break
        msg_type, data_len = struct.unpack('Bi', data)

        if msg_type == 1:
            # read stream into file
            with open('test.xml', 'wb') as fp:
                while data_len:
                    # read next chunk. on the last chunk, limit recv to the
                    # known amount of outstanding data
                    data = conn.recv(min(data_len, BUFFER_SIZE))
                    if not data:
                        print "ERROR: TOO FEW BYTES RECEIVED"
                        break
                    fp.write(data)
                    data_len -= len(data)

    conn.send("Data Received")
    conn.close()