从Linux的管道/套接字中读取所有内容还是全部内容？

Question

I've got a subprocess that I've popened that outputs fixed-sized structs containing some status information. My plan is to have a separate thread that reads from the stdout of that process to pull in the data as it comes.

I've got to check a flag periodically to make sure the program is still running so I can shut down cleanly, so I have to set the pipe to non-blocking and just have to run a loop piecing together the status message.

Is there a canonical way I can tell Linux "either read this entire amount or nothing before a timeout", that way I'll be able to check my flag, but I don't have to handle the boilerplate of reading the structure piece meal?

Alternatively, is there a way to push data back into a pipe? I could try to read the whole thing, and if it times out before it's all ready, push what I have back in and try again in a bit.

I've also written my popen (so I can grab stdin and stdout, so I'm totally OK using a socket rather than a pipe if that helps).

Answer 1

Here's what I ended up doing for anyone that's curious. I just wrote a class that wraps up the file descriptor and message size and gives me the "all-or-none" behavior I want.

struct aonreader { 
    aonreader(int fd, ssize_t size) { 
        fd_      = fd;
        size_    = size_;
        nread_   = 0;
        nremain_ = size_;
    }

    ssize_t read(void *dst) { 
         ssize_t ngot = read(fd, (char*)dst + nread_, nremain_);
         if (ngot < 0) { 
             if (errno != EAGAIN && errno != EWOULDBLOCK) {
                  return -1; // error
             }
         } else {
             nread_   += ngot;
             nremain_ -= ngot;

             // if we read a whole struct
             if (nremain_ == 0) {
                 nread_   = 0;
                 nremain_ = size_;
                 return size_;
             }
         }
         return 0;             

    private:
         int     fd_;
         ssize_t size_;
         ssize_t nread_;
         ssize_t nremain_;
    };

Which can then be used something like this:

    thing_you_want thing;
    aonreader buffer(fd, sizeof(thing_you_want));
    while (running) { 
        size_t ngot = buffer.read(&thing);
        if (ngot == sizeof(thing_you_want)) { 
            <handle thing>
        } else if (ngot < 0) { 
            <error, handle errno>
        }
        <otherwise loop and check running flag>
    }