使用Winsock接收分块HTTP数据

您需要更改您的读取代码。你不能像你试图做的那样使用固定长度的缓冲区读取chunked数据。数据以可变长度的块发送，其中每个块都有一个以字节为单位指定块实际长度的头，数据的最终块的长度为0。为了正确地处理数据块，您需要读取分块的标题。请阅读RFC 2616章节3.6.1。你的逻辑需要更像下面的伪代码:

send request;
status = recv() a line of text until CRLF;
parse status as needed;
response-code = extract response-code from status;
response-version = extract response-version from status;
do
{
    line = recv() a line of text until CRLF;
    if (line is blank)
        break;
    store line in headers list;
}
while (true);
parse headers list as needed;
if ((response-code is not in [1xx, 204, 304]) and (request was not "HEAD"))
{
    if (Transfer-Encoding header is present and not "identity")
    {
        do
        {
            line = recv a line of text until CRLF;
            length = extract length from line;
            extensions = extract extensions from line;
            process extensions as needed; // optional
            if (length == 0)
                break;
            recv() length number of bytes into destination buffer;
            recv() and discard bytes until CRLF;
        }
        while (true);
        do
        {
            line = recv a line of text until CRLF;
            if (line is blank)
                break;
            store line in headers list as needed;
        }
        while (true);
        re-parse headers list as needed;
    }
    else if (Content-Length header is present)
    {
        recv() Content-Length number of bytes into destination buffer;
    }
    else if (Content-Type header starts with "multipart/")
    {
        boundary = extract boundary from Content-Type's "boundary" attribute;
        recv() data into destination buffer until MIME termination boundary is reached;
    }
    else
    {
        recv() data into destination buffer until disconnected;
    }
}
if (not disconnected)
{
    if (response-version is "HTTP/1.1")
    {
        if (Connection header is "close")
            close connection;
    }
    else
    {
        if (Connection header is not "keep-alive")
            close connection;
    }
}
check response-code for errors;
process destination buffer, per info in headers list;

确实没有收到分块，但是内容被分块了。你必须自己画一幅图，你收到的缓冲可能是什么样子的。你不可能一次只收到一大块。有时，您有前一个块的一些数据，这条线表示新块的大小，后面跟着一些块数据。还有一些时候，你只接收到一小块数据。另一次是一小块数据和一行的一部分，表示新的块，等等。想象一下最坏的情况，这并不容易。阅读:http://www.jmarshall.com/easy/http/

在您可以使用下面的代码之前接收所有的头，直到空行。缓冲区中开始的内容是nContentStart。代码使用一些内部类，我不能分享，但你应该得到的想法;)据我测试，它像预期的工作，不泄漏内存。虽然这并不容易，但我不能完全确定!

    if (bChunked)
    {
        int nOffset = nContentStart;
        int nChunkLen = 0;
        int nCopyLen;
        while (true)
        {
            if (nOffset >= nDataLen)
                {pData->SetSize(0); Close(); ASSERTRETURN(false);}
            // copy data of previous chunk to caller's buffer
            if (nChunkLen > 0)
            {
                nCopyLen = min(nChunkLen, nDataLen - nOffset);
                n = pData->GetSize();
                pData->SetSize(n + nCopyLen);
                memcpy(pData->GetPtr() + n, buf.GetPtr() + nOffset, nCopyLen);
                nChunkLen -= nCopyLen;
                ASSERT(nChunkLen >= 0);
                nOffset += nCopyLen;
                if (nChunkLen == 0)
                    nOffset += strlen(lpszLineBreak);
                ASSERT(nOffset <= nDataLen);
            }
            // when previous chunk is copied completely, process new chunk
            if (nChunkLen == 0 && nOffset < nDataLen)
            {
                // chunk length is specified on first line
                p1 = buf.GetPtr() + nOffset;
                p2 = strstr(p1, lpszLineBreak);
                while (!p2) // if we can't find the line break receive more data until we do
                {
                    buf.SetSize(nDataLen + RECEIVE_BUFFER_SIZE + 1);
                    nReceived = m_socket.Receive((BYTE*)buf.GetPtr() + nDataLen, RECEIVE_BUFFER_SIZE);
                    if (nReceived == -1)
                        {pData->SetSize(0); Close(); ASSERTRETURN(false);} // connection error
                    if (nReceived == 0)
                        {pData->SetSize(0); Close(); ASSERTRETURN(false);} // all data already received but did not find line break
                    nDataLen += nReceived;
                    buf[nDataLen] = 0;
                    p1 = buf.GetPtr() + nOffset; // address of buffer likely changed
                    p2 = strstr(p1, lpszLineBreak);
                }
                *p2 = 0;
                p2 += strlen(lpszLineBreak);
                p3 = strchr(p1, ';');
                if (p3)
                    *p3 = 0;
                if (sscanf(p1, "%X", &nChunkLen) != 1)
                    {pData->SetSize(0); Close(); ASSERTRETURN(false);}
                if (nChunkLen < 0)
                    {pData->SetSize(0); Close(); ASSERTRETURN(false);}
                if (nChunkLen == 0)
                    break; // last chunk received
                // copy the following chunk data to caller's buffer
                nCopyLen = min(nChunkLen, buf.GetPtr() + nDataLen - p2);
                n = pData->GetSize();
                pData->SetSize(n + nCopyLen);
                memcpy(pData->GetPtr() + n, p2, nCopyLen);
                nChunkLen -= nCopyLen;
                ASSERT(nChunkLen >= 0);
                nOffset = (p2 - buf.GetPtr()) + nCopyLen;
                if (nChunkLen == 0)
                    nOffset += strlen(lpszLineBreak);
                if (nChunkLen == 0 && nOffset < nDataLen)
                    continue; // a new chunk starts in this buffer at nOffset, no need to receive more data
            }
            // receive more data
            buf.SetSize(RECEIVE_BUFFER_SIZE + 1);
            nDataLen = m_socket.Receive((BYTE*)buf.GetPtr(), RECEIVE_BUFFER_SIZE);
            if (nDataLen == -1)
                {pData->SetSize(0); Close(); ASSERTRETURN(false);}
            if (nDataLen == 0)
                {pData->SetSize(0); Close(); ASSERTRETURN(false);}
            buf[nDataLen] = 0;
            nOffset = 0;
        }
        // TODO: receive optional footers and add them to m_headers
    }