如何从TCP流中正确解析原始HTTP响应，避免异常解析错误？

你之前的解析逻辑错误根源是没有完整遵循HTTP RFC规范的消息边界判定规则，仅靠分隔符判断必然会出现误判，正确的解析流程按以下分层逻辑执行：

第一步：安全读取响应头 #

HTTP协议标准明确规定响应头字段中不允许出现未经转义的\r\n序列，符合规范的服务器不可能在响应头中写入\r\n\r\n，你担心的自定义头夹带\r\n\r\n的情况本身属于非法HTTP响应，不属于正常解析流程的处理范围，仅需要做异常兜底即可。
读取逻辑如下：

• 维护动态接收缓冲区，每次从socket recv到的数据都追加到缓冲区末尾
• 循环检查缓冲区中是否存在\r\n\r\n序列，存在则将该序列之前的内容切出作为响应头，剩余内容留在缓冲区作为响应体的开头
• 兜底限制响应头最大长度（比如最大8KB），超过上限仍未读到结束分隔符则直接判定为非法响应，关闭连接避免资源占用

第二步：按协议规则判定响应体长度 #

这一步是解决响应体内含\r\n导致误判的核心，完全不需要靠分隔符判断响应体结束，按照以下优先级的协议规则判断需要读取的字节数即可：

• 首先判断状态码：如果是1xx、204、304这类规定了不能携带响应体的状态码，直接判定当前响应已结束，缓冲区剩余内容属于下一个HTTP请求的响应
• 其次检查响应头是否存在Transfer-Encoding: chunked字段：如果是分块传输响应，按照分块编码规则解析：每个块开头是16进制的块长度，后跟\r\n，然后是对应长度的块内容，再跟\r\n，直到遇到长度为0的块即代表响应体结束
• 再检查是否存在Content-Length字段：如果有该字段，直接读取对应字节数的内容作为响应体，读完即结束
• 以上规则都不匹配时，才使用「连接关闭作为响应结束标志」，也就是一直读到recv返回0字节为止

特别提示：你当前场景是CONNECT代理请求，当收到200响应之后，后续的TCP流已经是你和目标站点之间的TLS加密流量，不再属于HTTP明文协议范围，不需要再用HTTP解析规则处理后续内容，直接透传即可。

Python核心实现示例 #

def read_http_response(sock):
    buffer = b""
    # 读取响应头
    while b"\r\n\r\n" not in buffer:
        chunk = sock.recv(4096)
        if not chunk:
            raise ConnectionError("连接提前中断，未读到完整响应头")
        buffer += chunk
        # 响应头长度兜底限制
        if len(buffer) > 8192:
            raise ValueError("响应头长度超过限制，判定为非法响应")
    
    # 切割响应头和剩余缓冲区
    header_bytes, remaining = buffer.split(b"\r\n\r\n", 1)
    headers = {}
    status_line = None
    for idx, line in enumerate(header_bytes.split(b"\r\n")):
        if idx == 0:
            status_line = line.decode()
            continue
        if b":" not in line:
            continue
        k, v = line.split(b":", 1)
        headers[k.strip().lower().decode()] = v.strip().decode()
    
    # 判断是否需要读响应体
    status_code = int(status_line.split()[1])
    if status_code in (100, 101, 204, 304):
        return status_line, headers, b""
    
    # 处理分块传输
    if headers.get("transfer-encoding") == "chunked":
        body = b""
        while True:
            # 读取块长度行
            while b"\r\n" not in remaining:
                chunk = sock.recv(4096)
                if not chunk:
                    raise ConnectionError("连接中断，未读到完整分块长度")
                remaining += chunk
            len_line, remaining = remaining.split(b"\r\n", 1)
            chunk_len = int(len_line.strip(), 16)
            if chunk_len == 0:
                # 跳过尾部的\r\n
                while len(remaining) < 2:
                    remaining += sock.recv(4096)
                remaining = remaining[2:]
                break
            # 读取对应长度的块内容
            while len(remaining) < chunk_len + 2: # 额外2字节是块结尾的\r\n
                chunk = sock.recv(4096)
                if not chunk:
                    raise ConnectionError("连接中断，未读到完整分块内容")
                remaining += chunk
            body += remaining[:chunk_len]
            remaining = remaining[chunk_len + 2:]
        return status_line, headers, body
    
    # 处理Content-Length
    if "content-length" in headers:
        try:
            content_length = int(headers["content-length"])
        except ValueError:
            raise ValueError("非法的Content-Length值")
        while len(remaining) < content_length:
            chunk = sock.recv(4096)
            if not chunk:
                raise ConnectionError("连接中断，未读到完整响应体")
            remaining += chunk
        body = remaining[:content_length]
        return status_line, headers, body
    
    # 兜底：读到连接关闭
    while True:
        chunk = sock.recv(4096)
        if not chunk:
            break
        remaining += chunk
    return status_line, headers, remaining

内容的提问来源于stack exchange，提问作者winwin