src/basic/io-util.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <errno.h>
   4 #include <limits.h>
   5 #include <stdio.h>
   6 #include <unistd.h>
   7
   8 #include "io-util.h"
   9 #include "string-util.h"
  10 #include "time-util.h"
  11
  12 int flush_fd(int fd) {
  13         int count = 0;
  14
  15         /* Read from the specified file descriptor, until POLLIN is not set anymore, throwing away everything
  16          * read. Note that some file descriptors (notable IP sockets) will trigger POLLIN even when no data can be read
  17          * (due to IP packet checksum mismatches), hence this function is only safe to be non-blocking if the fd used
  18          * was set to non-blocking too. */
  19
  20         for (;;) {
  21                 char buf[LINE_MAX];
  22                 ssize_t l;
  23                 int r;
  24
  25                 r = fd_wait_for_event(fd, POLLIN, 0);
  26                 if (r < 0) {
  27                         if (r == -EINTR)
  28                                 continue;
  29
  30                         return r;
  31                 }
  32                 if (r == 0)
  33                         return count;
  34
  35                 l = read(fd, buf, sizeof(buf));
  36                 if (l < 0) {
  37                         if (errno == EINTR)
  38                                 continue;
  39
  40                         if (errno == EAGAIN)
  41                                 return count;
  42
  43                         return -errno;
  44                 } else if (l == 0)
  45                         return count;
  46
  47                 count += (int) l;
  48         }
  49 }
  50
  51 ssize_t loop_read(int fd, void *buf, size_t nbytes, bool do_poll) {
  52         uint8_t *p = ASSERT_PTR(buf);
  53         ssize_t n = 0;
  54
  55         assert(fd >= 0);
  56
  57         /* If called with nbytes == 0, let's call read() at least
  58          * once, to validate the operation */
  59
  60         if (nbytes > (size_t) SSIZE_MAX)
  61                 return -EINVAL;
  62
  63         do {
  64                 ssize_t k;
  65
  66                 k = read(fd, p, nbytes);
  67                 if (k < 0) {
  68                         if (errno == EINTR)
  69                                 continue;
  70
  71                         if (errno == EAGAIN && do_poll) {
  72
  73                                 /* We knowingly ignore any return value here,
  74                                  * and expect that any error/EOF is reported
  75                                  * via read() */
  76
  77                                 (void) fd_wait_for_event(fd, POLLIN, USEC_INFINITY);
  78                                 continue;
  79                         }
  80
  81                         return n > 0 ? n : -errno;
  82                 }
  83
  84                 if (k == 0)
  85                         return n;
  86
  87                 assert((size_t) k <= nbytes);
  88
  89                 p += k;
  90                 nbytes -= k;
  91                 n += k;
  92         } while (nbytes > 0);
  93
  94         return n;
  95 }
  96
  97 int loop_read_exact(int fd, void *buf, size_t nbytes, bool do_poll) {
  98         ssize_t n;
  99
 100         n = loop_read(fd, buf, nbytes, do_poll);
 101         if (n < 0)
 102                 return (int) n;
 103         if ((size_t) n != nbytes)
 104                 return -EIO;
 105
 106         return 0;
 107 }
 108
 109 int loop_write(int fd, const void *buf, size_t nbytes, bool do_poll) {
 110         const uint8_t *p = ASSERT_PTR(buf);
 111
 112         assert(fd >= 0);
 113
 114         if (_unlikely_(nbytes > (size_t) SSIZE_MAX))
 115                 return -EINVAL;
 116
 117         do {
 118                 ssize_t k;
 119
 120                 k = write(fd, p, nbytes);
 121                 if (k < 0) {
 122                         if (errno == EINTR)
 123                                 continue;
 124
 125                         if (errno == EAGAIN && do_poll) {
 126                                 /* We knowingly ignore any return value here,
 127                                  * and expect that any error/EOF is reported
 128                                  * via write() */
 129
 130                                 (void) fd_wait_for_event(fd, POLLOUT, USEC_INFINITY);
 131                                 continue;
 132                         }
 133
 134                         return -errno;
 135                 }
 136
 137                 if (_unlikely_(nbytes > 0 && k == 0)) /* Can't really happen */
 138                         return -EIO;
 139
 140                 assert((size_t) k <= nbytes);
 141
 142                 p += k;
 143                 nbytes -= k;
 144         } while (nbytes > 0);
 145
 146         return 0;
 147 }
 148
 149 int pipe_eof(int fd) {
 150         int r;
 151
 152         r = fd_wait_for_event(fd, POLLIN, 0);
 153         if (r <= 0)
 154                 return r;
 155
 156         return !!(r & POLLHUP);
 157 }
 158
 159 int ppoll_usec(struct pollfd *fds, size_t nfds, usec_t timeout) {
 160         int r;
 161
 162         assert(fds || nfds == 0);
 163
 164         if (nfds == 0)
 165                 return 0;
 166
 167         r = ppoll(fds, nfds, timeout == USEC_INFINITY ? NULL : TIMESPEC_STORE(timeout), NULL);
 168         if (r < 0)
 169                 return -errno;
 170         if (r == 0)
 171                 return 0;
 172
 173         for (size_t i = 0, n = r; i < nfds && n > 0; i++) {
 174                 if (fds[i].revents == 0)
 175                         continue;
 176                 if (fds[i].revents & POLLNVAL)
 177                         return -EBADF;
 178                 n--;
 179         }
 180
 181         return r;
 182 }
 183
 184 int fd_wait_for_event(int fd, int event, usec_t timeout) {
 185         struct pollfd pollfd = {
 186                 .fd = fd,
 187                 .events = event,
 188         };
 189         int r;
 190
 191         r = ppoll_usec(&pollfd, 1, timeout);
 192         if (r <= 0)
 193                 return r;
 194
 195         return pollfd.revents;
 196 }
 197
 198 static size_t nul_length(const uint8_t *p, size_t sz) {
 199         size_t n = 0;
 200
 201         while (sz > 0) {
 202                 if (*p != 0)
 203                         break;
 204
 205                 n++;
 206                 p++;
 207                 sz--;
 208         }
 209
 210         return n;
 211 }
 212
 213 ssize_t sparse_write(int fd, const void *p, size_t sz, size_t run_length) {
 214         const uint8_t *q, *w, *e;
 215         ssize_t l;
 216
 217         q = w = p;
 218         e = q + sz;
 219         while (q < e) {
 220                 size_t n;
 221
 222                 n = nul_length(q, e - q);
 223
 224                 /* If there are more than the specified run length of
 225                  * NUL bytes, or if this is the beginning or the end
 226                  * of the buffer, then seek instead of write */
 227                 if ((n > run_length) ||
 228                     (n > 0 && q == p) ||
 229                     (n > 0 && q + n >= e)) {
 230                         if (q > w) {
 231                                 l = write(fd, w, q - w);
 232                                 if (l < 0)
 233                                         return -errno;
 234                                 if (l != q -w)
 235                                         return -EIO;
 236                         }
 237
 238                         if (lseek(fd, n, SEEK_CUR) == (off_t) -1)
 239                                 return -errno;
 240
 241                         q += n;
 242                         w = q;
 243                 } else if (n > 0)
 244                         q += n;
 245                 else
 246                         q++;
 247         }
 248
 249         if (q > w) {
 250                 l = write(fd, w, q - w);
 251                 if (l < 0)
 252                         return -errno;
 253                 if (l != q - w)
 254                         return -EIO;
 255         }
 256
 257         return q - (const uint8_t*) p;
 258 }
 259
 260 char* set_iovec_string_field(struct iovec *iovec, size_t *n_iovec, const char *field, const char *value) {
 261         char *x;
 262
 263         x = strjoin(field, value);
 264         if (x)
 265                 iovec[(*n_iovec)++] = IOVEC_MAKE_STRING(x);
 266         return x;
 267 }
 268
 269 char* set_iovec_string_field_free(struct iovec *iovec, size_t *n_iovec, const char *field, char *value) {
 270         char *x;
 271
 272         x = set_iovec_string_field(iovec, n_iovec, field, value);
 273         free(value);
 274         return x;
 275 }
 276
 277 struct iovec_wrapper *iovw_new(void) {
 278         return malloc0(sizeof(struct iovec_wrapper));
 279 }
 280
 281 void iovw_free_contents(struct iovec_wrapper *iovw, bool free_vectors) {
 282         if (free_vectors)
 283                 for (size_t i = 0; i < iovw->count; i++)
 284                         free(iovw->iovec[i].iov_base);
 285
 286         iovw->iovec = mfree(iovw->iovec);
 287         iovw->count = 0;
 288 }
 289
 290 struct iovec_wrapper *iovw_free_free(struct iovec_wrapper *iovw) {
 291         iovw_free_contents(iovw, true);
 292
 293         return mfree(iovw);
 294 }
 295
 296 struct iovec_wrapper *iovw_free(struct iovec_wrapper *iovw) {
 297         iovw_free_contents(iovw, false);
 298
 299         return mfree(iovw);
 300 }
 301
 302 int iovw_put(struct iovec_wrapper *iovw, void *data, size_t len) {
 303         if (iovw->count >= IOV_MAX)
 304                 return -E2BIG;
 305
 306         if (!GREEDY_REALLOC(iovw->iovec, iovw->count + 1))
 307                 return -ENOMEM;
 308
 309         iovw->iovec[iovw->count++] = IOVEC_MAKE(data, len);
 310         return 0;
 311 }
 312
 313 int iovw_put_string_field(struct iovec_wrapper *iovw, const char *field, const char *value) {
 314         _cleanup_free_ char *x = NULL;
 315         int r;
 316
 317         x = strjoin(field, value);
 318         if (!x)
 319                 return -ENOMEM;
 320
 321         r = iovw_put(iovw, x, strlen(x));
 322         if (r >= 0)
 323                 TAKE_PTR(x);
 324
 325         return r;
 326 }
 327
 328 int iovw_put_string_field_free(struct iovec_wrapper *iovw, const char *field, char *value) {
 329         _cleanup_free_ _unused_ char *free_ptr = value;
 330
 331         return iovw_put_string_field(iovw, field, value);
 332 }
 333
 334 void iovw_rebase(struct iovec_wrapper *iovw, char *old, char *new) {
 335         for (size_t i = 0; i < iovw->count; i++)
 336                 iovw->iovec[i].iov_base = (char *)iovw->iovec[i].iov_base - old + new;
 337 }
 338
 339 size_t iovw_size(struct iovec_wrapper *iovw) {
 340         size_t n = 0;
 341
 342         for (size_t i = 0; i < iovw->count; i++)
 343                 n += iovw->iovec[i].iov_len;
 344
 345         return n;
 346 }