在fwrite调用中循环，直到缓冲区大小写为C / C ++

Question

I'm designing a C++ callback function that writes size_t size bytes from a buffer to a file in C++. However, for sanity, I have to check if fwrite returns a errno such as EACESS . The function itself it's an interface between C and C++ . Sure enough, I have a pseudocode (almost real code) written:

static size_t write_data(void *ptr, size_t size, size_t nmemb, void *stream){
     int nwritten = size;
     while(nwritten > 0){
          int written = fwrite(ptr, size, nmemb, (FILE*)stream);
          if(written < 0 && errno == EACESS){
                  // try again
                  written = 0;
          }
          /* check some other errors which may be recoverable 
          nwritten -= written;
     }

The function itself is called from libcurl :

curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);

The point is to make sure size_t written = size bytes were written to the file. The reason I'm using a fwrite instead any other method is because the function write_data is passed as a callback to a method which does a HTTP request, makes some file transfering and writes the file content to a local file. I'm not sure this approach will work. Could you guys tell me if this approach would work, or maybe potential troubles I may have? If there is a better approach ? Thanks

Answer 1

fwrite returns the number of members written, so as you write members you need to advance ptr , something like this:

size_t done = 0;

while (done < nmemb) {
    size_t written = fwrite((char*)ptr + done * size, size, nmemb - done, (FILE*)stream);
    done += written;
    if (done < nmemb) {
        /* Not all has been written. Some kind of error may have occurred. */
        if (ferror((FILE*)stream)) {
            ...
        }
    }
}

Answer 2

I think what you are looking for is a robust i/o. This link and the robust io package might help you : http://csapp.cs.cmu.edu/public/ch10-preview.pdf