TCP Socket garbage

Question

i have a TCP protocol server-client program.

Unlike a lot of people, i am not getting errors because my send function isnt sending as much bytes as it should. My problem is because the recv() function catches a los of weird characters. I hexdumped them and they tend to be either negative numbers(i guess larger than 4 bits long) or not alphanumeric ones.(one that appears all the time is \8 = ◘).

The functions i use are these:

bool Socket::Send(char* msg){
    if ((send(sockfd, msg, strlen(msg), 0)) == SOCKET_ERROR){
        Close();
        return false;
    }
    return true;
}

int Socket::Receive(char* msg, int maxlen){
    int recvResult;
    if ((recvResult = recv(sockfd, msg, maxlen, 0)) == SOCKET_ERROR){
        Close();
    }
    return recvResult;
}

I checked and everything being send is ok. i mean, i wrote it to a file and checked it and it was ok.

Is there anything else i should consider? What am i doing wrong?

Answer 1

Unlike a lot of people, i am not getting errors because my send function isnt sending as much bytes as it should.

Nobody gets that error, because it never happens, although, as you aren't checking for it, you're in no position to assert that it isn't happening.

My problem is because the recv() function catches a los of weird characters.

No. What happens is that the recv() function returns fewer bytes than requested, and that happens because it isn't specified to transfer more than one byte, or zero bytes in non-blocking mode. You have to loop until you've read all the data you're expecting.

And you have to take care not to use bytes in the receive buffer that weren't transferred in the most recent recv() call, as indicated by its return value.

You are almost certainly printing the entire buffer and so you're seeing garbage. It was neither sent nor received.

NB if recv() returns zero you should close the socket.

Answer 2

You said you have a TCP protocol, what you have is not a protocol that’s just a TCP connection.

In order to implement a protocol you need to send some more information, the recv() part should (must) know what is going to receive.

You need to send either, ahead the length of the buffer or a terminating char, at the end of the buffer, which should not be part of the rest of the sent message. Characters like Line-Feed (10), Carriage-Return (13) and Form-Feed (12) are good candidates.

If you decide to use a terminating character, then, you should read (recv) one char at a time, verifying if that is the terminating indicator. Terminating characters are only useful when sending strings which represent literal words, is not indicated to be used for sending files or images or binary strings.

I've modified your routines implementing the length of the buffer indicator method:

bool Socket::Sender(char* msg){
    // Send a string with the length (int) of it ahead
    int len = strlen(msg);
    int hLen = htonl(len); // put it in network byte order
    if (send(sockfd, (char *) &hLen, sizeof(int), 0) == sizeof(int) &&
        send(sockfd, msg, len, 0) == len) 
    {
        return true;
    }
    Close();
    return false;
}

int Socket::Receive(char* msg, int maxlen){
    int recvResult;
    int len;
    int offset;

    // receive a string with the length (int) of it first
    if (recv(sockfd, (char *) &len, sizeof(int), 0) == sizeof(int))
    {
        len=ntohl(len); // put in host byte order
        // Check there is enough space
        if (len > maxlen)
        {
            // the receive chars is bigger than maxlen, 
            // either receive as many as maxlen or return error
            len=maxlen;
            // Close();
            // return -1;
        }
        offset=0;
        // loop until len chars are received, no more no less
        while (offset < len) 
        {
            recvResult = recv(sockfd, (char *) &msg[offset], len-offset, 0);
            if (recvResult <= 0)
            {
                Close();
                return -1;
            }
            offset +=recvResult;
        }
        // Succeeded, return len
        return len;
    }
    Close();
    return -1;
}