Q:

TCP C send data when not receiving data

I'm trying to send data to the connected client, even when the client did not send me a message first.
This is my current code:
while (true) {
    // open a new socket to transmit data per connection
    int sock;
    if ((sock = accept(listen_sock, (sockaddr *) &client_address, &client_address_len)) < 0) {
        logger.log(TYPE::ERROR, "server::could not open a socket to accept data");
        exit(0);
    }

    int n = 0, total_received_bytes = 0, max_len = 4096;
    std::vector<char> buffer(max_len);

    logger.log(TYPE::SUCCESS,
               "server::client connected with ip address: " + std::string(inet_ntoa(client_address.sin_addr)));

    // keep running as long as the client keeps the connection open
    while (true) {
        n = recv(sock, &buffer[0], buffer.size(), 0);
        if (n > 0) {
            total_received_bytes += n;

            std::string str(buffer.begin(), buffer.end());

            KV key_value = kv_from(vector_from(str));

            messaging.set_command(key_value);
        }

        std::string message = "hmc::" + messaging.get_value("hmc") + "---" + "sonar::" + messaging.get_value("sonar") + "\n";
        send(sock, message.c_str(), message.length(), 0);
    }

    logger.log(TYPE::INFO, "server::connection closed");
    close(sock);
}

I thought by moving the n = recv(sock, &buffer[0], buffer.size(), 0); outside the while condition that it would send the data indefinitely, but that is not what happened.
Thanks in advance.
Solution
Adding MSG_DONTWAIT to the recv function enabled non-blocking operations which I was looking for.

A:

First I will explain, why it does not work, then I will make a proposal for solutions. Basically you will find the answer in the  man7.org > Linux > man-pages and for recv specifially here.
When the function "recv" is called, then it will not return, until data is available and can be read. This behavior of functions is called "blocking". Means, the current execution thread is blocked until data has been read.
So, calling the function
n = recv(sock, &buffer[0], buffer.size(), 0);

as you did, causes the trouble. You need also to check the return code. 0 means, connection closed, -1 means error and you must check errno for further information.
You can modify the socket to work in non-blocking mode with the function fnctl and the O_NONBLOCK flag, for the lifetime of the socket. You can also use the the flag MSG_DONTWAIT as 4th parameter (flags), to unblock the function on a per-function-call base. 
In both cases, if no data is available, the functions returns a -1 and you need to check errno for EAGAIN or EWOULDBLOCK.
return value 0 indicates that the connection has been closed.
But from the architecture point of view, I would not recommend to use this approach. You could use multiple threads for receiving and sending data, or, using Linux, one of select, poll or similar functions. There is even a common design pattern for this. It is called "reactor", There are also related patterns like "Acceptor/Connector" and "Proactor"/"ACT" available. If you plan to write a more robust application, then you may consider those.
You will find an implementation of Acceptor, Connector, Reactor, Proactor, ACT here
Hope this helps

