1 files changed, 7 insertions, 4 deletions

diff --git a/cache.c b/cache.c
index aa97ae1..9f02cf5 100644
--- a/cache.c
+++ b/cache.c
@@ -36,106 +36,109 @@ struct cache_slot {
 };
 
 /* Open an existing cache slot and fill the cache buffer with
  * (part of) the content of the cache file. Return 0 on success
  * and errno otherwise.
  */
 static int open_slot(struct cache_slot *slot)
 {
         char *bufz;
         int bufkeylen = -1;
 
         slot->cache_fd = open(slot->cache_name, O_RDONLY);
         if (slot->cache_fd == -1)
                 return errno;
 
         if (fstat(slot->cache_fd, &slot->cache_st))
                 return errno;
 
         slot->bufsize = xread(slot->cache_fd, slot->buf, sizeof(slot->buf));
         if (slot->bufsize < 0)
                 return errno;
 
         bufz = memchr(slot->buf, 0, slot->bufsize);
         if (bufz)
                 bufkeylen = bufz - slot->buf;
 
         slot->match = bufkeylen == slot->keylen &&
             !memcmp(slot->key, slot->buf, bufkeylen + 1);
 
         return 0;
 }
 
 /* Close the active cache slot */
 static int close_slot(struct cache_slot *slot)
 {
         int err = 0;
         if (slot->cache_fd > 0) {
                 if (close(slot->cache_fd))
                         err = errno;
                 else
                         slot->cache_fd = -1;
         }
         return err;
 }
 
 /* Print the content of the active cache slot (but skip the key). */
 static int print_slot(struct cache_slot *slot)
 {
-        ssize_t i;
+        ssize_t i, j;
 
         i = lseek(slot->cache_fd, slot->keylen + 1, SEEK_SET);
         if (i != slot->keylen + 1)
                 return errno;
 
-        while((i = xread(slot->cache_fd, slot->buf, sizeof(slot->buf))) > 0)
-                i = xwrite(STDOUT_FILENO, slot->buf, i);
+        do {
+                i = j = xread(slot->cache_fd, slot->buf, sizeof(slot->buf));
+                if (i > 0)
+                        j = xwrite(STDOUT_FILENO, slot->buf, i);
+        } while (i > 0 && j == i);
 
-        if (i < 0)
+        if (i < 0 || j != i)
                 return errno;
         else
                 return 0;
 }
 
 /* Check if the slot has expired */
 static int is_expired(struct cache_slot *slot)
 {
         if (slot->ttl < 0)
                 return 0;
         else
                 return slot->cache_st.st_mtime + slot->ttl*60 < time(NULL);
 }
 
 /* Check if the slot has been modified since we opened it.
  * NB: If stat() fails, we pretend the file is modified.
  */
 static int is_modified(struct cache_slot *slot)
 {
         struct stat st;
 
         if (stat(slot->cache_name, &st))
                 return 1;
         return (st.st_ino != slot->cache_st.st_ino ||
                 st.st_mtime != slot->cache_st.st_mtime ||
                 st.st_size != slot->cache_st.st_size);
 }
 
 /* Close an open lockfile */
 static int close_lock(struct cache_slot *slot)
 {
         int err = 0;
         if (slot->lock_fd > 0) {
                 if (close(slot->lock_fd))
                         err = errno;
                 else
                         slot->lock_fd = -1;
         }
         return err;
 }
 
 /* Create a lockfile used to store the generated content for a cache
  * slot, and write the slot key + \0 into it.
  * Returns 0 on success and errno otherwise.
  */
 static int lock_slot(struct cache_slot *slot)
 {
         slot->lock_fd = open(slot->lock_name, O_RDWR|O_CREAT|O_EXCL,