函数setsockopt似乎不起作用

Question

I'm working with the WinSock2 and I would like to receive all my packages at once (they are XML files). Right now I'm making as below because setsockopt seems ignoring my "order" to set a size of the receiving buffer, but it always returns OK from the execution:

#define IP_BUF_SZ 2000000
//...
std::string sBuffer;
long chrs_read = 0;
int iBufSize = IP_BUF_SZ;
//...
if (setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, (char*)&iBufSize, sizeof(int)) == SOCKET_ERROR)
    MessageBox("Unable to increase"); //never reachs here

do
{
    char* buf = (char*)MALLOCZ(IP_BUF_SZ + 1000);
    chrs_read = recv(sockfd, buf, IP_BUF_SZ, 0);

    if (chrs_read > 0)
        sBuffer += std::string(buf);

    FREE(buf);
    buf = NULL;
}
while (chrs_read > 0);

but I would like to do something like that (all at once):

setsockopt(IP_STATUS[CHAN_EPIC].sockfd, SOL_SOCKET, SO_RCVBUF, (char*)&iBufSize, sizeof(int);
char* buf = (char*)MALLOCZ(IP_BUF_SZ + 1000);
chrs_read = recv(IP_STATUS[CHAN_EPIC].sockfd, buf, IP_BUF_SZ, 0); 
sBuffer += std::string(buf);

Remark : my files are less than IP_BUF_SZ sized. Thank you in advance.

Answer 1

setsockopt(SO_RCVBUF) DOES NOT guarantee that you can receive an entire message in a single recv() call. It DOES NOT even guarantee that you will get the buffer size you requested. You have to use getsockopt(SO_RCVBUF) to retrieve the actual buffer size.

SO_RCVBUF simply controls how many bytes the socket can hold in its internal buffer before the sender starting blocking waiting for you to read the bytes. But recv() DOES NOT guarantee that it will return all of the bytes you requested (unless you call it with the MSG_WAITALL flag, which I would not recommend in this situation since you don't know the message length beforehand). If you ask recv() to read X bytes, and only Y bytes are currently available, where Y < X, recv() will return Y bytes and not wait to return X bytes. The only guarantee is that recv() will return at least 1 byte and no more than X bytes. So, you still need a reading loop no matter what you set the internal buffer size to.

SO_RCVBUF is merely a suggestive option used for optimizing network I/O. Don't actually rely on it for your code's reading logic.

That said, there are other problems with the code you showed.

You are allocating and freeing your receive buffer on each iteration of your loop. Don't do that. Allocate it once, THEN loop the reading, THEN free the buffer when finished.

There is no need to over-allocate your receive buffer beyond what you actually ask from recv() . There is also no need to zero the buffer when reading. Those steps are just wasted overhead.

You are also not taking the return value of recv() into account when appending the receive buffer to your std::string . You are using the std::string constructor that expects the buffer to be null-terminated. You are relying on your buffer zeroing to provide a null-terminator, but if the data contains any embedded nul characters of its own (depending on the XML's encoding) then that will truncate what you append to the std::string . recv() returns how many bytes it read. You need to append exactly that many bytes to your std::string , no more no less.

Try something more like this:

#define IP_BUF_SZ 2000000

//...

std::string sBuffer;
long chrs_read;

//...

int iBufSize = IP_BUF_SZ;
int iBufVarSize = sizeof(iBufSize);

if (setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, (char*)&iBufSize, iBufVarSize) == SOCKET_ERROR)
    MessageBox("Unable to set buffer size");
else if (getsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, (char*)&iBufSize, &iBufVarSize) == SOCKET_ERROR)
{
    MessageBox("Unable to get buffer size");
    iBufSize = IP_BUF_SZ;
}

char* buf = (char*) malloc(iBufSize);
if (!buf)
    MessageBox("Unable to allocate buffer");
else
{
    do
    {
        chrs_read = recv(sockfd, buf, iBufSize, 0);
        if (chrs_read <= 0)
        {
            if (chrs_read == SOCKET_ERROR)
                MessageBox("Unable to read message");
            break;
        }
        sBuffer.append(buf, chrs_read);
    }
    while (true);

    free(buf);
    buf = NULL;
}

Note that this logic is reading until the socket disconnects or encounters an error while reading. That is OK if there is only ever 1 message per socket connection. But if you intend to send multiple XML messages on a single connection, that will not work anymore. You would need to put a delimiter in between the messages so you know where one message ends and the next begins. That could be a leading header specifying the message's length, or it could be a unique terminator sequence at the end of the message.

Answer 2

You can make the buffer as big as the system will let you, but nothing you can do will allow you to receive all of your data at once from TCP. You have to loop until you receive all the data you are expecting.

Your question is based on a false assumption.