Why recv() returns '0' bytes at all for-loop iterations except the first one?

I'm writing a small networking program in C++. Among other things it has to download twitter profile pictures. I have a list (stl::vector) of URLs. And I think that my next step is to create for-loop and send GET messages through the socket and save the pictures to different png-files. The problem is when I send the very first message, receive the answer segments and save png-data all things seems to be fine. But right at the next iteration the same message, sent through the same socket, produces 0 received bytes by recv() function. I solved the problem by adding a socket creation code to the cycle body, but I'm a bit confused with the socket concepts. It looks like when I send the message, the socket should be closed and recreated again to send next message to the same server (in order to get next image). Is this a right way of socket's networking programming or it is possible to receive several HTTP response messages through the same socket?

Thanks in advance.

UPD: Here is the code with the loop where I create a socket.

    // Get links from xml.
    ...
    // Load images in cycle.
    int i=0;
    for (i=0; i<imageLinks.size(); i++)
    {
        // New socket is returned from serverConnect. Why do we need to create new at each iteration?
        string srvAddr = "207.123.60.126";
        int socketImg = serverConnect(srvAddr)开发者_如何学C;
        // Create a message.
        ...
        string message = "GET " + relativePart;
                message += " HTTP/1.1\r\n";
        message += "Host: " + hostPart + "\r\n";
        message += "\r\n";
        // Send a message.
        BufferArray tempImgBuffer = sendMessage(sockImg, message, false);
        fstream pFile;
        string name;
        // Form the name.
        ...
        pFile.open(name.c_str(), ios::app | ios::out | ios::in | ios::binary);
        // Write the file contents.
        ...
        pFile.close();
        // Close the socket.
        close(sockImg);
    }

The other side is closing the connection. That's how HTTP/1.0 works. You can:

• Make a different connection for each HTTP GET
• Use HTTP/1.0 with the unofficial Connection: Keep-Alive
• Use HTTP/1.1. In HTTP 1.1 all connections are considered persistent unless declared otherwise.

Obligatory xkcd link Server Attention Span

Wiki HTTP

The original version of HTTP (HTTP/1.0) was revised in HTTP/1.1. HTTP/1.0 uses a separate connection to the same server for every request-response transaction, while HTTP/1.1 can reuse a connection multiple times

HTTP in its original form (HTTP 1.0) is indeed a "one request per connection" protocol. Once you get the response back, the other side has probably closed the connection. There were unofficial mechanisms added to some implementations to support multiple requests per connection, but they were not standardized.

HTTP 1.1 turns this around. All connections are by default "persistent".

To use this, you need to add "HTTP/1.1" to the end of your request line. Instead of GET http://someurl/, do GET http://someurl/ HTTP/1.1. You'll also need to make sure you provide the "Host:" header when you do this.

Note well, however, that even some otherwise-compliant HTTP servers may not support persistent connections. Note also that the connection may in fact be dropped after very little delay, a certain number of requests, or just randomly. You must be prepared for this, and ready to re-connect and resume issuing your requests where you left off.

See also the HTTP 1.1 RFC.