使用 sha256 验证的 python 套接字文件传输不起作用，但只是有时？

Question

客户端:

def send_file_to_hashed(data, tcpsock):
time.sleep(1)
f = data
flag = 0
i=0
tcpsock.send(hashlib.sha256(f.read()).hexdigest())
f.seek(0)
time.sleep(1)
l = f.read(BUFFER_SIZE-64)
while True:
    while (l):
        tcpsock.send(hashlib.sha256(l).hexdigest() + l)
        time.sleep(1)
        hashok = tcpsock.recv(6) 
        if  hashok == "HASHOK":
            l = f.read(BUFFER_SIZE-64)
            flag = 1
        if hashok == "BROKEN":
            flag = 0
    if not l:
        time.sleep(1)
        tcpsock.send("DONE")
        break
return (tcpsock,flag)

def upload(filename):
flag = 0
while(flag == 0):
    with open(os.getcwd()+'\\data\\'+ filename +'.csv', 'rU') as UL:
        tuplol = send_file_to_hashed(UL ,send_to_sock(filename +".csv",send_to("upload",TCP_IP,TCP_PORT)))
        (sock,flagn) = tuplol
        flag = flagn
        time.sleep(2)
        sock.close()

服务器端:

   elif(message == "upload"):
        message = rec_OK(self.sock)
        fis = os.getcwd()+'/data/'+ time.strftime("%H:%M_%d_%m_%Y") + "_" + message
        f = open(fis , 'w')
        latest = open(os.getcwd()+'/data/' + message , 'w')
        time.sleep(1)
        filehash = rec_OK(self.sock)
        print("filehash:" + filehash)
        while True:
            time.sleep(1)
            rawdata = self.sock.recv(BUFFER_SIZE)
            log.write("rawdata :" + rawdata + "\n")
            data = rawdata[64:]
            dhash = rawdata[:64]
            log.write("chash: " + dhash + "\n")
            log.write("shash: " + hashlib.sha256(data).hexdigest() + "\n")
            if dhash == hashlib.sha256(data).hexdigest():
                f.write(data)
                latest.write(data)
                self.sock.send("HASHOK")
                log.write("HASHOK\n" )
                print"HASHOK"
            else:
                self.sock.send("HASHNO")
                print "HASHNO"
                log.write("HASHNO\n")
            if rawdata == "DONE":
                f.close()
                f = open(fis , 'r')

                if (hashlib.sha256(f.read()).hexdigest() == filehash): 
                    print "ULDONE"
                    log.write("ULDONE")
                    f.close()
                    latest.close()
                    break
                else:
                    self.sock.send("BROKEN")
                    print hashlib.sha256(f.read()).hexdigest()
                    log.write("BROKEN")
                    print filehash
                    print "BROKEN UL"
        f.close()

因此，在我从计算机运行的所有测试中，数据上传工作正常，甚至在通过移动连接上传数据时工作正常，但有时人们仍然说这需要很长时间，几分钟后他们就会终止它。数据存在于他们的计算机上，但不在服务器上。我不知道发生了什么，请帮忙!

Answer 1

首先:这与煞无关。

网络上的流媒体传输是不可预测的。这一行

rawdata = self.sock.recv(BUFFER_SIZE)

不保证您会读取 BUFFER_SIZE 字节。在最坏的情况下，您可能只读取了 1 个字节。因此，由于原始数据包含整个消息的假设，您的服务器端完全崩溃了。情况更糟。如果客户端快速发送命令和哈希，您可能会得到例如rawdata == 'DONEa2daf78c44(...) 这是混合输出。

“悬挂”部分就是由此而来的。跟踪您的代码并查看当服务器收到部分/损坏的消息时会发生什么(我已经在想象中做到了:P)。

<小时/>

通过网络进行流式传输几乎从来没有像在一侧调用 sock.send 和在另一侧调用 sock.recv 那样简单。您需要一些缓冲/成帧协议(protocol)。例如，您可以实现这个简单的协议(protocol):始终将前两个字节解释为传入消息的大小，如下所示:

客户端(伪代码)

# convert len of msg into two-byte array
# I am assuming the max size of msg is 65536
buf = bytearray([len(msg) & 255, len(msg) >> 8])
sock.sendall(buf)
sock.sendall(msg)

服务器(伪代码)

size = to_int(sock.recv(1))
size += to_int(sock.recv(1)) << 8
# You need two calls to recv since recv(2) can return 1 byte.
# (well, you can try recv(2) with `if` here to avoid additional
#     syscall, not sure if worth it)
buffer = bytearray()
while size > 0:
    tmp = sock.recv(size)
    buffer += tmp
    size -= len(tmp)

现在您已经正确读取了可以使用的 buffer 变量中的数据。

警告:服务器的伪代码已简化。例如，您需要在各处(包括计算大小的位置)检查是否有空的 recv() 结果。这是客户端断开连接时的情况。

很遗憾，您面前有很多工作要做。您必须重写整个发送和接收代码。