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