Update XZ Utils to 5.0.5

src/xz/file_io.c

 ///////////////////////////////////////////////////////////////////////////////
 //
 /// \file       file_io.c
 /// \brief      File opening, unlinking, and closing
 //
 //  Author:     Lasse Collin
 //
 //  This file has been put into the public domain.
 //  You can do whatever you want with this file.
 //
@@ skipping 23 matching lines @@
 
 #ifndef O_NOCTTY
 #       define O_NOCTTY 0
 #endif
 
 
 /// If true, try to create sparse files when decompressing.
 static bool try_sparse = true;
 
 #ifndef TUKLIB_DOSLIKE
-/// File status flags of standard output. This is used by io_open_dest()
-/// and io_close_dest().
-static int stdout_flags = 0;
+/// Original file status flags of standard output. This is used by
+/// io_open_dest() and io_close_dest() to save and restore the flags.
+static int stdout_flags;
+static bool restore_stdout_flags = false;
 #endif
 
 
 static bool io_write_buf(file_pair *pair, const uint8_t *buf, size_t size);
 
 
 extern void
 io_init(void)
 {
         // Make sure that stdin, stdout, and stderr are connected to
@@ skipping 333 matching lines @@
 
 #       if defined(__FreeBSD__) || defined(__DragonFly__)
                 if (errno == EMLINK)
                         was_symlink = true;
 
 #       elif defined(__digital__) && defined(__unix__)
                 if (errno == ENOTSUP)
                         was_symlink = true;
 
 #       elif defined(__NetBSD__)
-                // As of 2010-09-05, NetBSD doesn't document what errno is
-                // used with O_NOFOLLOW. It is EFTYPE though, and I
-                // understood that is very unlikely to change even though
-                // it is undocumented.
                 if (errno == EFTYPE)
                         was_symlink = true;
 
 #       else
                 if (errno == ELOOP && !follow_symlinks) {
                         const int saved_errno = errno;
                         struct stat st;
                         if (lstat(pair->src_name, &st) == 0
                                         && S_ISLNK(st.st_mode))
                                 was_symlink = true;
@@ skipping 20 matching lines @@
         // Drop O_NONBLOCK, which is used only when we are accepting only
         // regular files. After the open() call, we want things to block
         // instead of giving EAGAIN.
         if (reg_files_only) {
                 flags = fcntl(pair->src_fd, F_GETFL);
                 if (flags == -1)
                         goto error_msg;
 
                 flags &= ~O_NONBLOCK;
 
-                if (fcntl(pair->src_fd, F_SETFL, flags))
+                if (fcntl(pair->src_fd, F_SETFL, flags) == -1)
                         goto error_msg;
         }
 #endif
 
         // Stat the source file. We need the result also when we copy
         // the permissions, and when unlinking.
         if (fstat(pair->src_fd, &pair->src_st))
                 goto error_msg;
 
         if (S_ISDIR(pair->src_st.st_mode)) {
@@ skipping 172 matching lines @@
                 //  - O_APPEND may be active.
                 //
                 // TODO: I'm keeping this disabled for DOS-like systems
                 // for now. FAT doesn't support sparse files, but NTFS
                 // does, so maybe this should be enabled on Windows after
                 // some testing.
                 if (pair->dest_fd == STDOUT_FILENO) {
                         if (!S_ISREG(pair->dest_st.st_mode))
                                 return false;
 
-                        const int flags = fcntl(STDOUT_FILENO, F_GETFL);
-                        if (flags == -1)
+                        stdout_flags = fcntl(STDOUT_FILENO, F_GETFL);
+                        if (stdout_flags == -1)
                                 return false;
 
-                        if (flags & O_APPEND) {
+                        if (stdout_flags & O_APPEND) {
                                 // Creating a sparse file is not possible
                                 // when O_APPEND is active (it's used by
                                 // shell's >> redirection). As I understand
                                 // it, it is safe to temporarily disable
                                 // O_APPEND in xz, because if someone
                                 // happened to write to the same file at the
                                 // same time, results would be bad anyway
                                 // (users shouldn't assume that xz uses any
                                 // specific block size when writing data).
                                 //
                                 // The write position may be something else
                                 // than the end of the file, so we must fix
                                 // it to start writing at the end of the file
                                 // to imitate O_APPEND.
                                 if (lseek(STDOUT_FILENO, 0, SEEK_END) == -1)
                                         return false;
 
                                 if (fcntl(STDOUT_FILENO, F_SETFL,
-                                                stdout_flags & ~O_APPEND))
+                                                stdout_flags & ~O_APPEND)
+                                                == -1)
                                         return false;
 
-                                // Remember the flags so that io_close_dest()
-                                // can restore them.
-                                stdout_flags = flags;
+                                // Disabling O_APPEND succeeded. Mark
+                                // that the flags should be restored
+                                // in io_close_dest().
+                                restore_stdout_flags = true;
 
                         } else if (lseek(STDOUT_FILENO, 0, SEEK_CUR)
                                         != pair->dest_st.st_size) {
                                 // Writing won't start exactly at the end
                                 // of the file. We cannot use sparse output,
                                 // because it would probably corrupt the file.
                                 return false;
                         }
                 }
 
@@ skipping 20 matching lines @@
 /// \param      pair    File whose dest_fd should be closed
 /// \param      success If false, the file will be removed from the disk.
 ///
 /// \return     Zero if closing succeeds. On error, -1 is returned and
 ///             error message printed.
 static bool
 io_close_dest(file_pair *pair, bool success)
 {
 #ifndef TUKLIB_DOSLIKE
         // If io_open_dest() has disabled O_APPEND, restore it here.
-        if (stdout_flags != 0) {
+        if (restore_stdout_flags) {
                 assert(pair->dest_fd == STDOUT_FILENO);
 
-                const int fail = fcntl(STDOUT_FILENO, F_SETFL, stdout_flags);
-                stdout_flags = 0;
+                restore_stdout_flags = false;
 
-                if (fail) {
+                if (fcntl(STDOUT_FILENO, F_SETFL, stdout_flags) == -1) {
                         message_error(_("Error restoring the O_APPEND flag "
                                         "to standard output: %s"),
                                         strerror(errno));
                         return true;
                 }
         }
 #endif
 
         if (pair->dest_fd == -1 || pair->dest_fd == STDOUT_FILENO)
                 return false;
@@ skipping 152 matching lines @@
 static bool
 io_write_buf(file_pair *pair, const uint8_t *buf, size_t size)
 {
         assert(size < SSIZE_MAX);
 
         while (size > 0) {
                 const ssize_t amount = write(pair->dest_fd, buf, size);
                 if (amount == -1) {
                         if (errno == EINTR) {
                                 if (user_abort)
-                                        return -1;
+                                        return true;
 
                                 continue;
                         }
 
                         // Handle broken pipe specially. gzip and bzip2
                         // don't print anything on SIGPIPE. In addition,
                         // gzip --quiet uses exit status 2 (warning) on
                         // broken pipe instead of whatever raise(SIGPIPE)
                         // would make it return. It is there to hide "Broken
                         // pipe" message on some old shells (probably old
@@ skipping 52 matching lines @@
                                                 strerror(errno));
                                 return true;
                         }
 
                         pair->dest_pending_sparse = 0;
                 }
         }
 
         return io_write_buf(pair, buf->u8, size);
 }