C ++ TCP套接字通信-连接按预期工作，几秒钟后失败，未接收到新数据并且read（）和recv（）块

Question

I am using 64-bit Ubuntu 16.04 LTS. Like I said, I am attempting to make a TCP socket connection to another device. The program starts by reading data from the socket to initialize the last_recorded_data variable (as seen below, towards the bottom of myStartProcedure() ), and I know that this is working exactly as expected. Then, the rest of the program starts which is driven by callbacks. When I make UPDATE_BUFFER_MS something smaller like 8, it fails after a couple of seconds. A frequency of this value is the desired value, but if I make it larger for testing purposes (something like 500), then it works for a little bit longer, but also eventually fails the same way.

The failure is as follows: The device I'm attempting to read from consistently sends data every 8 milliseconds, and within this packet of data, the first few bytes are reserved for telling the client how large the packet is, in bytes. During normal operation, the received number of bytes and the size as described by these first few bytes are equal. However, the packet received directly before the read() call starts to block is always 24 bytes less than the expected size, but the packet says the data packet sent should still be the expected size. When the next attempt to get the data is made, the read() call blocks and upon timeout sets errno to be EAGAIN (Resource temporarily unavailable) .

I tried communicating with this same device with a Python application and it is not experiencing the same issue. Furthermore, I tried this C++ application on another one of these devices and I'm seeing the same behavior, so I think it's a problem on my end. My code (simplified) is below. Please let me know if you see any obvious errors, thank you!!

#include <string>
#include <unistd.h>
#include <iostream>

#include <stdio.h>
#include <errno.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#define COMM_DOMAIN AF_INET
#define PORT        8008

#define TIMEOUT_SECS  3
#define TIMEOUT_USECS 0

#define UPDATE_BUFFER_MS 8

#define PACKET_SIZE_BYTES_MAX 1200

//
// Global variables
//

// Socket file descriptor
int socket_conn;

// Tracks the timestamp of the last time data was recorded
// The data packet from the TCP connection is sent every UPDATE_BUFFER_MS milliseconds
unsigned long last_process_cycle_timestamp;

// The most recently heard data, cast to a double
double last_recorded_data;

// The number of bytes expected from a full packet
int full_packet_size;

// The minimum number of bytes needed from the packet, as I don't need all of the data
int min_required_packet_size;

// Helper to cast the packet data to a double
union PacketAsFloat
{
    unsigned char byte_values[8];
    double decimal_value;
};

// Simple struct to package the data read from the socket
struct SimpleDataStruct
{
    // Whether or not the struct was properly populated
    bool valid;

    // Some data that we're interested in right now
    double important_data;

    //
    // Other, irrelevant members removed for simplicity
    //
};

// Procedure to read the next data packet
SimpleDataStruct readCurrentData()
{
    SimpleDataStruct data;
    data.valid = false;

    unsigned char socket_data_buffer[PACKET_SIZE_BYTES_MAX] = {0};

    int read_status = read(socket_conn, socket_data_buffer, PACKET_SIZE_BYTES_MAX);
    if (read_status < min_required_packet_size)
    {
        return data;
    }

    //for (int i = 0; i < read_status - 1; i++)
    //{
    //  std::cout << static_cast<int>(socket_data_buffer[i]) << ", ";
    //}
    //std::cout << static_cast<int>(socket_data_buffer[read_status - 1]) << std::endl;

    PacketAsFloat packet_union;
    for (int j = 0; j < 8; j++)
    {
        packet_union.byte_values[7 - j] = socket_data_buffer[j + 252];
    }

    data.important_data = packet_union.decimal_value;
    data.valid          = true;

    return data;
}

// This acts as the main entry point
void myStartProcedure(std::string host)
{
    //
    // Code to determine the value for full_packet_size and min_required_packet_size (because it can vary) was removed
    // Simplified version is below
    //

    full_packet_size         = some_known_value;
    min_required_packet_size = some_other_known_value;

    //
    // Create socket connection
    //

    if ((socket_conn = socket(COMM_DOMAIN, SOCK_STREAM, 0)) < 0)
    {
        std::cout << "socket_conn heard a bad value..." << std::endl;
        return;
    }

    struct sockaddr_in socket_server_address;
    memset(&socket_server_address, '0', sizeof(socket_server_address));

    socket_server_address.sin_family = COMM_DOMAIN;
    socket_server_address.sin_port   = htons(PORT);

    // Create and set timeout
    struct timeval timeout_chars;
    timeout_chars.tv_sec  = TIMEOUT_SECS;
    timeout_chars.tv_usec = TIMEOUT_USECS;

    setsockopt(socket_conn, SOL_SOCKET, SO_RCVTIMEO, (const char*)&timeout_chars, sizeof(timeout_chars));

    if (inet_pton(COMM_DOMAIN, host.c_str(), &socket_server_address.sin_addr) <= 0)
    {
        std::cout << "Invalid address heard..." << std::endl;
        return;
    }

    if (connect(socket_conn, (struct sockaddr *)&socket_server_address, sizeof(socket_server_address)) < 0)
    {
        std::cout << "Failed to make connection to " << host << ":" << PORT << std::endl;
        return;
    }
    else
    {
        std::cout << "Successfully brought up socket connection..." << std::endl;
    }

    // Sleep for half a second to let the networking setup properly
    sleepMilli(500); // A sleep function I defined elsewhere

    SimpleDataStruct initial = readCurrentData();
    if (initial.valid)
    {
        last_recorded_data = initial.important_data;
    }
    else
    {
        // Error handling
        return -1;
    }

    //
    // Start the rest of the program, which is driven by callbacks
    //
}

void updateRequestCallback()
{
    unsigned long now_ns = currentTime(); // A function I defined elsewhere that gets the current system time in nanoseconds

    if (now_ns - last_process_cycle_timestamp >= 1000000 * UPDATE_BUFFER_MS)
    {
        SimpleDataStruct current_data = readCurrentData();

        if (current_data.valid)
        {
            last_recorded_data = current_data.important_data;
            last_process_cycle_timestamp = now_ns;
        }
        else
        {
            // Error handling
             std::cout << "ERROR setting updated data, SimpleDataStruct was invalid." << std:endl;
             return;
        }
    }
}

EDIT #1

I should be receiving a certain number of bytes every time, and I would expect the return value of read() to be returning that value as well. However, I just tried changing the value of PACKET_SIZE_BYTES_MAX to be 2048, and the return value of read() is now 2048, when it should be the size of the packet that the device is sending back (NOT 2048). The Python application is also setting the max to be 2048 and its returning packet size is the correct/expected size...

Answer 1

Try commenting out the timeout setup. I never use that on my end and I don't experience the problem you're talking about.

// Create and set timeout
struct timeval timeout_chars;
timeout_chars.tv_sec  = TIMEOUT_SECS;
timeout_chars.tv_usec = TIMEOUT_USECS;

setsockopt(socket_conn, SOL_SOCKET, SO_RCVTIMEO, (const char*)&timeout_chars, sizeof(timeout_chars));

To avoid blocking, you can setup the socket as a non-block socket and then use a select() or poll() to get more data. Both of these functions can use the timeout as presented above. However, with a non-blocking socket you must make sure that the read works as expected. In many cases you will get a partial read and have to wait ( select() or poll() ) again for more data. So the code would be a bit more complicated.

socket_conn = socket(COMM_DOMAIN, SOCK_STREAM | SOCK_NONBLOCK, 0);

If security is a potential issue, I would also set SOCK_CLOEXEC to prevent a child process from accessing the same socket.

std::vector<struct pollfd> fds;

struct pollfd fd;
fd.fd = socket_conn;
fd.events = POLLIN | POLLPRI | POLLRDHUP; // also POLLOUT for writing
fd.revents = 0; // probably useless... (kernel should clear those)
fds.push_back(fd);

int64_t timeout_chars = TIMEOUT_SECS * 1000 + TIMEOUT_USECS / 1000;

int const r = poll(&fds[0], fds.size(), timeout_chars);
if(r < 0) { ...handle error(s)... }

Another method, assuming the header size is well defined and never changes, is to read the header, then using the header information to read the rest of the data. In that case you can keep the blocking socket without any timeout. From your structures I have no idea what that could be. So... let's first define such a structure:

struct header
{
    char sync[4];  // four bytes indicated a synchronization point
    uint32_t size; // size of packet
    ...            // some other info
};

I put a "sync" field. In TCP it is often that people will add such a field so if you lose track of your position you can seek to the next sync by reading one byte at a time. Frankly, with TCP, you should never get a transmission error like that. You may lose the connection, but never lose data from the stream (ie TCP is like a perfect FIFO over your network.) That being said, if you are working on a mission critical software, a sync and also a checksum would be very welcome.

Next we read() just the header. Now we know of the exact size of this packet, so we can use that specific size and read exactly that many bytes in our packet buffer:

struct header hdr;
read(socket_conn, &hdr, sizeof(hdr));
read(socket_conn, packet, hdr.size /* - sizeof(hdr) */);

Obviously, read() may return an error and the size in the header may be defined in big endian (so you need to swap the bytes on x86 processors). But that should get you going.

Also, if the size found in the header includes the number of bytes in the header, make sure to subtract that amount when reading the rest of the packet.

---

Also, the following is wrong:

memset(&socket_server_address, '0', sizeof(socket_server_address));

You meant to clear the structure with zeroes, not character zero. Although if it connects that means it probably doesn't matter much. Just use 0 instead of '0' .