i18n: simplify numeric error reporting

diff --git a/wrapper.c b/wrapper.c
index 7c126b87c50d4d46a986b0de42b4038e92face69..e7f197996868a614c84537ad96fc672ea901148d 100644 (file)
--- a/wrapper.c
+++ b/wrapper.c
@@ -227,6 +227,24 @@ int xopen(const char *path, int oflag, ...)
        }
 }
 
+static int handle_nonblock(int fd, short poll_events, int err)
+{
+       struct pollfd pfd;
+
+       if (err != EAGAIN && err != EWOULDBLOCK)
+               return 0;
+
+       pfd.fd = fd;
+       pfd.events = poll_events;
+
+       /*
+        * no need to check for errors, here;
+        * a subsequent read/write will detect unrecoverable errors
+        */
+       poll(&pfd, 1, -1);
+       return 1;
+}
+
 /*
  * xread() is the same a read(), but it automatically restarts read()
  * operations with a recoverable error (EAGAIN and EINTR). xread()
@@ -242,20 +260,8 @@ ssize_t xread(int fd, void *buf, size_t len)
                if (nr < 0) {
                        if (errno == EINTR)
                                continue;
-                       if (errno == EAGAIN || errno == EWOULDBLOCK) {
-                               struct pollfd pfd;
-                               pfd.events = POLLIN;
-                               pfd.fd = fd;
-                               /*
-                                * it is OK if this poll() failed; we
-                                * want to leave this infinite loop
-                                * only when read() returns with
-                                * success, or an expected failure,
-                                * which would be checked by the next
-                                * call to read(2).
-                                */
-                               poll(&pfd, 1, -1);
-                       }
+                       if (handle_nonblock(fd, POLLIN, errno))
+                               continue;
                }
                return nr;
        }
@@ -273,8 +279,13 @@ ssize_t xwrite(int fd, const void *buf, size_t len)
            len = MAX_IO_SIZE;
        while (1) {
                nr = write(fd, buf, len);
-               if ((nr < 0) && (errno == EAGAIN || errno == EINTR))
-                       continue;
+               if (nr < 0) {
+                       if (errno == EINTR)
+                               continue;
+                       if (handle_nonblock(fd, POLLOUT, errno))
+                               continue;
+               }
+
                return nr;
        }
 }
@@ -640,22 +651,28 @@ int xsnprintf(char *dst, size_t max, const char *fmt, ...)
        return len;
 }
 
+void write_file_buf(const char *path, const char *buf, size_t len)
+{
+       int fd = xopen(path, O_WRONLY | O_CREAT | O_TRUNC, 0666);
+       if (write_in_full(fd, buf, len) != len)
+               die_errno(_("could not write to %s"), path);
+       if (close(fd))
+               die_errno(_("could not close %s"), path);
+}
+
 void write_file(const char *path, const char *fmt, ...)
 {
        va_list params;
        struct strbuf sb = STRBUF_INIT;
-       int fd = xopen(path, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 
        va_start(params, fmt);
        strbuf_vaddf(&sb, fmt, params);
        va_end(params);
 
        strbuf_complete_line(&sb);
-       if (write_in_full(fd, sb.buf, sb.len) != sb.len)
-               die_errno(_("could not write to %s"), path);
+
+       write_file_buf(path, sb.buf, sb.len);
        strbuf_release(&sb);
-       if (close(fd))
-               die_errno(_("could not close %s"), path);
 }
 
 void sleep_millisec(int millisec)