compat/imsg-buffer.c

   1 /*      $OpenBSD: imsg-buffer.c,v 1.17 2023/10/24 14:05:23 claudio Exp $        */
   2
   3 /*
   4  * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 #include <sys/types.h>
  20 #include <sys/socket.h>
  21 #include <sys/uio.h>
  22
  23 #include <limits.h>
  24 #include <errno.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <unistd.h>
  28
  29 #include "got_compat.h"
  30 #include "imsg.h"
  31
  32 static int      ibuf_realloc(struct ibuf *, size_t);
  33 static void     ibuf_enqueue(struct msgbuf *, struct ibuf *);
  34 static void     ibuf_dequeue(struct msgbuf *, struct ibuf *);
  35 static void     msgbuf_drain(struct msgbuf *, size_t);
  36
  37 struct ibuf *
  38 ibuf_open(size_t len)
  39 {
  40         struct ibuf     *buf;
  41
  42         if (len == 0) {
  43                 errno = EINVAL;
  44                 return (NULL);
  45         }
  46         if ((buf = calloc(1, sizeof(struct ibuf))) == NULL)
  47                 return (NULL);
  48         if ((buf->buf = calloc(len, 1)) == NULL) {
  49                 free(buf);
  50                 return (NULL);
  51         }
  52         buf->size = buf->max = len;
  53         buf->fd = -1;
  54
  55         return (buf);
  56 }
  57
  58 struct ibuf *
  59 ibuf_dynamic(size_t len, size_t max)
  60 {
  61         struct ibuf     *buf;
  62
  63         if (max < len) {
  64                 errno = EINVAL;
  65                 return (NULL);
  66         }
  67
  68         if ((buf = calloc(1, sizeof(struct ibuf))) == NULL)
  69                 return (NULL);
  70         if (len > 0) {
  71                 if ((buf->buf = calloc(len, 1)) == NULL) {
  72                         free(buf);
  73                         return (NULL);
  74                 }
  75         }
  76         buf->size = len;
  77         buf->max = max;
  78         buf->fd = -1;
  79
  80         return (buf);
  81 }
  82
  83 static int
  84 ibuf_realloc(struct ibuf *buf, size_t len)
  85 {
  86         unsigned char   *b;
  87
  88         /* on static buffers max is eq size and so the following fails */
  89         if (len > SIZE_MAX - buf->wpos || buf->wpos + len > buf->max) {
  90                 errno = ERANGE;
  91                 return (-1);
  92         }
  93
  94         b = recallocarray(buf->buf, buf->size, buf->wpos + len, 1);
  95         if (b == NULL)
  96                 return (-1);
  97         buf->buf = b;
  98         buf->size = buf->wpos + len;
  99
 100         return (0);
 101 }
 102
 103 void *
 104 ibuf_reserve(struct ibuf *buf, size_t len)
 105 {
 106         void    *b;
 107
 108         if (len > SIZE_MAX - buf->wpos) {
 109                 errno = ERANGE;
 110                 return (NULL);
 111         }
 112
 113         if (buf->wpos + len > buf->size)
 114                 if (ibuf_realloc(buf, len) == -1)
 115                         return (NULL);
 116
 117         b = buf->buf + buf->wpos;
 118         buf->wpos += len;
 119         memset(b, 0, len);
 120         return (b);
 121 }
 122
 123 int
 124 ibuf_add(struct ibuf *buf, const void *data, size_t len)
 125 {
 126         void *b;
 127
 128         if ((b = ibuf_reserve(buf, len)) == NULL)
 129                 return (-1);
 130
 131         memcpy(b, data, len);
 132         return (0);
 133 }
 134
 135 int
 136 ibuf_add_buf(struct ibuf *buf, const struct ibuf *from)
 137 {
 138         return ibuf_add(buf, from->buf, from->wpos);
 139 }
 140
 141 int
 142 ibuf_add_n8(struct ibuf *buf, uint64_t value)
 143 {
 144         uint8_t v;
 145
 146         if (value > UINT8_MAX) {
 147                 errno = EINVAL;
 148                 return (-1);
 149         }
 150         v = value;
 151         return ibuf_add(buf, &v, sizeof(v));
 152 }
 153
 154 int
 155 ibuf_add_n16(struct ibuf *buf, uint64_t value)
 156 {
 157         uint16_t v;
 158
 159         if (value > UINT16_MAX) {
 160                 errno = EINVAL;
 161                 return (-1);
 162         }
 163         v = htobe16(value);
 164         return ibuf_add(buf, &v, sizeof(v));
 165 }
 166
 167 int
 168 ibuf_add_n32(struct ibuf *buf, uint64_t value)
 169 {
 170         uint32_t v;
 171
 172         if (value > UINT32_MAX) {
 173                 errno = EINVAL;
 174                 return (-1);
 175         }
 176         v = htobe32(value);
 177         return ibuf_add(buf, &v, sizeof(v));
 178 }
 179
 180 int
 181 ibuf_add_n64(struct ibuf *buf, uint64_t value)
 182 {
 183         value = htobe64(value);
 184         return ibuf_add(buf, &value, sizeof(value));
 185 }
 186
 187 int
 188 ibuf_add_zero(struct ibuf *buf, size_t len)
 189 {
 190         void *b;
 191
 192         if ((b = ibuf_reserve(buf, len)) == NULL)
 193                 return (-1);
 194         return (0);
 195 }
 196
 197 void *
 198 ibuf_seek(struct ibuf *buf, size_t pos, size_t len)
 199 {
 200         /* only allowed to seek in already written parts */
 201         if (len > SIZE_MAX - pos || pos + len > buf->wpos) {
 202                 errno = ERANGE;
 203                 return (NULL);
 204         }
 205
 206         return (buf->buf + pos);
 207 }
 208
 209 int
 210 ibuf_set(struct ibuf *buf, size_t pos, const void *data, size_t len)
 211 {
 212         void *b;
 213
 214         if ((b = ibuf_seek(buf, pos, len)) == NULL)
 215                 return (-1);
 216
 217         memcpy(b, data, len);
 218         return (0);
 219 }
 220
 221 int
 222 ibuf_set_n8(struct ibuf *buf, size_t pos, uint64_t value)
 223 {
 224         uint8_t v;
 225
 226         if (value > UINT8_MAX) {
 227                 errno = EINVAL;
 228                 return (-1);
 229         }
 230         v = value;
 231         return (ibuf_set(buf, pos, &v, sizeof(v)));
 232 }
 233
 234 int
 235 ibuf_set_n16(struct ibuf *buf, size_t pos, uint64_t value)
 236 {
 237         uint16_t v;
 238
 239         if (value > UINT16_MAX) {
 240                 errno = EINVAL;
 241                 return (-1);
 242         }
 243         v = htobe16(value);
 244         return (ibuf_set(buf, pos, &v, sizeof(v)));
 245 }
 246
 247 int
 248 ibuf_set_n32(struct ibuf *buf, size_t pos, uint64_t value)
 249 {
 250         uint32_t v;
 251
 252         if (value > UINT32_MAX) {
 253                 errno = EINVAL;
 254                 return (-1);
 255         }
 256         v = htobe32(value);
 257         return (ibuf_set(buf, pos, &v, sizeof(v)));
 258 }
 259
 260 int
 261 ibuf_set_n64(struct ibuf *buf, size_t pos, uint64_t value)
 262 {
 263         value = htobe64(value);
 264         return (ibuf_set(buf, pos, &value, sizeof(value)));
 265 }
 266
 267 void *
 268 ibuf_data(struct ibuf *buf)
 269 {
 270         return (buf->buf);
 271 }
 272
 273 size_t
 274 ibuf_size(struct ibuf *buf)
 275 {
 276         return (buf->wpos);
 277 }
 278
 279 size_t
 280 ibuf_left(struct ibuf *buf)
 281 {
 282         return (buf->max - buf->wpos);
 283 }
 284
 285 void
 286 ibuf_close(struct msgbuf *msgbuf, struct ibuf *buf)
 287 {
 288         ibuf_enqueue(msgbuf, buf);
 289 }
 290
 291 void
 292 ibuf_free(struct ibuf *buf)
 293 {
 294         if (buf == NULL)
 295                 return;
 296         if (buf->fd != -1)
 297                 close(buf->fd);
 298         freezero(buf->buf, buf->size);
 299         free(buf);
 300 }
 301
 302 int
 303 ibuf_fd_avail(struct ibuf *buf)
 304 {
 305         return (buf->fd != -1);
 306 }
 307
 308 int
 309 ibuf_fd_get(struct ibuf *buf)
 310 {
 311         int fd;
 312
 313         fd = buf->fd;
 314         buf->fd = -1;
 315         return (fd);
 316 }
 317
 318 void
 319 ibuf_fd_set(struct ibuf *buf, int fd)
 320 {
 321         if (buf->fd != -1)
 322                 close(buf->fd);
 323         buf->fd = fd;
 324 }
 325
 326 int
 327 ibuf_write(struct msgbuf *msgbuf)
 328 {
 329         struct iovec     iov[IOV_MAX];
 330         struct ibuf     *buf;
 331         unsigned int     i = 0;
 332         ssize_t n;
 333
 334         memset(&iov, 0, sizeof(iov));
 335         TAILQ_FOREACH(buf, &msgbuf->bufs, entry) {
 336                 if (i >= IOV_MAX)
 337                         break;
 338                 iov[i].iov_base = buf->buf + buf->rpos;
 339                 iov[i].iov_len = buf->wpos - buf->rpos;
 340                 i++;
 341         }
 342
 343 again:
 344         if ((n = writev(msgbuf->fd, iov, i)) == -1) {
 345                 if (errno == EINTR)
 346                         goto again;
 347                 if (errno == ENOBUFS)
 348                         errno = EAGAIN;
 349                 return (-1);
 350         }
 351
 352         if (n == 0) {                   /* connection closed */
 353                 errno = 0;
 354                 return (0);
 355         }
 356
 357         msgbuf_drain(msgbuf, n);
 358
 359         return (1);
 360 }
 361
 362 void
 363 msgbuf_init(struct msgbuf *msgbuf)
 364 {
 365         msgbuf->queued = 0;
 366         msgbuf->fd = -1;
 367         TAILQ_INIT(&msgbuf->bufs);
 368 }
 369
 370 static void
 371 msgbuf_drain(struct msgbuf *msgbuf, size_t n)
 372 {
 373         struct ibuf     *buf, *next;
 374
 375         for (buf = TAILQ_FIRST(&msgbuf->bufs); buf != NULL && n > 0;
 376             buf = next) {
 377                 next = TAILQ_NEXT(buf, entry);
 378                 if (n >= buf->wpos - buf->rpos) {
 379                         n -= buf->wpos - buf->rpos;
 380                         ibuf_dequeue(msgbuf, buf);
 381                 } else {
 382                         buf->rpos += n;
 383                         n = 0;
 384                 }
 385         }
 386 }
 387
 388 void
 389 msgbuf_clear(struct msgbuf *msgbuf)
 390 {
 391         struct ibuf     *buf;
 392
 393         while ((buf = TAILQ_FIRST(&msgbuf->bufs)) != NULL)
 394                 ibuf_dequeue(msgbuf, buf);
 395 }
 396
 397 int
 398 msgbuf_write(struct msgbuf *msgbuf)
 399 {
 400         struct iovec     iov[IOV_MAX];
 401         struct ibuf     *buf, *buf0 = NULL;
 402         unsigned int     i = 0;
 403         ssize_t          n;
 404         struct msghdr    msg;
 405         struct cmsghdr  *cmsg;
 406         union {
 407                 struct cmsghdr  hdr;
 408                 char            buf[CMSG_SPACE(sizeof(int))];
 409         } cmsgbuf;
 410
 411         memset(&iov, 0, sizeof(iov));
 412         memset(&msg, 0, sizeof(msg));
 413         memset(&cmsgbuf, 0, sizeof(cmsgbuf));
 414         TAILQ_FOREACH(buf, &msgbuf->bufs, entry) {
 415                 if (i >= IOV_MAX)
 416                         break;
 417                 if (i > 0 && buf->fd != -1)
 418                         break;
 419                 iov[i].iov_base = buf->buf + buf->rpos;
 420                 iov[i].iov_len = buf->wpos - buf->rpos;
 421                 i++;
 422                 if (buf->fd != -1)
 423                         buf0 = buf;
 424         }
 425
 426         msg.msg_iov = iov;
 427         msg.msg_iovlen = i;
 428
 429         if (buf0 != NULL) {
 430                 msg.msg_control = (caddr_t)&cmsgbuf.buf;
 431                 msg.msg_controllen = sizeof(cmsgbuf.buf);
 432                 cmsg = CMSG_FIRSTHDR(&msg);
 433                 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
 434                 cmsg->cmsg_level = SOL_SOCKET;
 435                 cmsg->cmsg_type = SCM_RIGHTS;
 436                 *(int *)CMSG_DATA(cmsg) = buf0->fd;
 437         }
 438
 439 again:
 440         if ((n = sendmsg(msgbuf->fd, &msg, 0)) == -1) {
 441                 if (errno == EINTR)
 442                         goto again;
 443                 if (errno == ENOBUFS)
 444                         errno = EAGAIN;
 445                 return (-1);
 446         }
 447
 448         if (n == 0) {                   /* connection closed */
 449                 errno = 0;
 450                 return (0);
 451         }
 452
 453         /*
 454          * assumption: fd got sent if sendmsg sent anything
 455          * this works because fds are passed one at a time
 456          */
 457         if (buf0 != NULL) {
 458                 close(buf0->fd);
 459                 buf0->fd = -1;
 460         }
 461
 462         msgbuf_drain(msgbuf, n);
 463
 464         return (1);
 465 }
 466
 467 static void
 468 ibuf_enqueue(struct msgbuf *msgbuf, struct ibuf *buf)
 469 {
 470         TAILQ_INSERT_TAIL(&msgbuf->bufs, buf, entry);
 471         msgbuf->queued++;
 472 }
 473
 474 static void
 475 ibuf_dequeue(struct msgbuf *msgbuf, struct ibuf *buf)
 476 {
 477         TAILQ_REMOVE(&msgbuf->bufs, buf, entry);
 478
 479         msgbuf->queued--;
 480         ibuf_free(buf);
 481 }