gotd/imsg.c

   1 /*
   2  * Copyright (c) 2022 Stefan Sperling <stsp@openbsd.org>
   3  *
   4  * Permission to use, copy, modify, and distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include "got_compat.h"
  18
  19 #include <sys/queue.h>
  20 #include <sys/types.h>
  21 #include <sys/uio.h>
  22
  23 #include <errno.h>
  24 #include <event.h>
  25 #include <imsg.h>
  26 #include <limits.h>
  27 #include <poll.h>
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include <unistd.h>
  31
  32 #include "got_error.h"
  33 #include "got_object.h"
  34 #include "got_path.h"
  35
  36 #include "got_lib_poll.h"
  37
  38 #include "gotd.h"
  39
  40 const struct got_error *
  41 gotd_imsg_recv_error(uint32_t *client_id, struct imsg *imsg)
  42 {
  43         struct gotd_imsg_error ierr;
  44         size_t datalen;
  45
  46         datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
  47         if (datalen != sizeof(ierr))
  48                 return got_error(GOT_ERR_PRIVSEP_LEN);
  49         memcpy(&ierr, imsg->data, sizeof(ierr));
  50
  51         if (client_id)
  52                 *client_id = ierr.client_id;
  53
  54         if (ierr.code == GOT_ERR_ERRNO)
  55                 errno = ierr.errno_code;
  56
  57         return got_error_msg(ierr.code, ierr.msg);
  58 }
  59
  60 const struct got_error *
  61 gotd_imsg_flush(struct imsgbuf *ibuf)
  62 {
  63         const struct got_error *err = NULL;
  64
  65         while (imsgbuf_queuelen(ibuf) > 0) {
  66                 err = got_poll_fd(ibuf->fd, POLLOUT, INFTIM);
  67                 if (err)
  68                         break;
  69
  70                 if (imsgbuf_write(ibuf) == -1) {
  71                         err = got_error_from_errno("imsgbuf_write");
  72                         break;
  73                 }
  74         }
  75
  76         return err;
  77 }
  78
  79 static const struct got_error *
  80 gotd_imsg_recv(struct imsg *imsg, struct imsgbuf *ibuf, size_t min_datalen)
  81 {
  82         ssize_t n;
  83
  84         n = imsg_get(ibuf, imsg);
  85         if (n == -1)
  86                 return got_error_from_errno("imsg_get");
  87
  88         if (n == 0) {
  89                 n = imsgbuf_read(ibuf);
  90                 if (n == -1)
  91                         return got_error_from_errno("imsg_read");
  92                 if (n == 0)
  93                         return got_error(GOT_ERR_EOF);
  94                 n = imsg_get(ibuf, imsg);
  95                 if (n == -1)
  96                         return got_error_from_errno("imsg_get");
  97                 if (n == 0)
  98                         return got_error(GOT_ERR_PRIVSEP_READ);
  99         }
 100
 101         if (imsg->hdr.len < IMSG_HEADER_SIZE + min_datalen)
 102                 return got_error(GOT_ERR_PRIVSEP_LEN);
 103
 104         return NULL;
 105 }
 106
 107 const struct got_error *
 108 gotd_imsg_poll_recv(struct imsg *imsg, struct imsgbuf *ibuf, size_t min_datalen)
 109 {
 110         const struct got_error *err = NULL;
 111
 112         for (;;) {
 113                 err = gotd_imsg_recv(imsg, ibuf, min_datalen);
 114                 if (err == NULL || err->code != GOT_ERR_PRIVSEP_READ)
 115                         return err;
 116
 117                 err = got_poll_fd(ibuf->fd, POLLIN, INFTIM);
 118                 if (err)
 119                         break;
 120         }
 121
 122         return err;
 123 }
 124
 125 int
 126 gotd_imsg_send_error(struct imsgbuf *ibuf, uint32_t peerid,
 127     uint32_t client_id, const struct got_error *err)
 128 {
 129         const struct got_error *flush_err;
 130         struct gotd_imsg_error ierr;
 131         int ret;
 132
 133         ierr.code = err->code;
 134         if (err->code == GOT_ERR_ERRNO)
 135                 ierr.errno_code = errno;
 136         else
 137                 ierr.errno_code = 0;
 138         ierr.client_id = client_id;
 139         strlcpy(ierr.msg, err->msg, sizeof(ierr.msg));
 140
 141         ret = imsg_compose(ibuf, GOTD_IMSG_ERROR, peerid, getpid(), -1,
 142             &ierr, sizeof(ierr));
 143         if (ret == -1)
 144                 return -1;
 145
 146         flush_err = gotd_imsg_flush(ibuf);
 147         if (flush_err)
 148                 return -1;
 149
 150         return 0;
 151 }
 152
 153 int
 154 gotd_imsg_send_error_event(struct gotd_imsgev *iev, uint32_t peerid,
 155     uint32_t client_id, const struct got_error *err)
 156 {
 157         struct gotd_imsg_error ierr;
 158         int ret;
 159
 160         ierr.code = err->code;
 161         if (err->code == GOT_ERR_ERRNO)
 162                 ierr.errno_code = errno;
 163         else
 164                 ierr.errno_code = 0;
 165         ierr.client_id = client_id;
 166         strlcpy(ierr.msg, err->msg, sizeof(ierr.msg));
 167
 168         ret = gotd_imsg_compose_event(iev, GOTD_IMSG_ERROR, peerid, -1,
 169             &ierr, sizeof(ierr));
 170         if (ret == -1)
 171                 return -1;
 172
 173         return 0;
 174 }
 175
 176 void
 177 gotd_imsg_event_add(struct gotd_imsgev *iev)
 178 {
 179         iev->events = EV_READ;
 180         if (imsgbuf_queuelen(&iev->ibuf))
 181                 iev->events |= EV_WRITE;
 182
 183         event_del(&iev->ev);
 184         event_set(&iev->ev, iev->ibuf.fd, iev->events, iev->handler, iev);
 185         event_add(&iev->ev, NULL);
 186 }
 187
 188 int
 189 gotd_imsg_compose_event(struct gotd_imsgev *iev, uint16_t type, uint32_t peerid,
 190     int fd, void *data, uint16_t datalen)
 191 {
 192         int ret;
 193
 194         ret = imsg_compose(&iev->ibuf, type, peerid, getpid(), fd,
 195             data, datalen);
 196         if (ret != -1)
 197                 gotd_imsg_event_add(iev);
 198
 199         return ret;
 200 }
 201
 202 int
 203 gotd_imsg_forward(struct gotd_imsgev *iev, struct imsg *imsg, int fd)
 204 {
 205         return gotd_imsg_compose_event(iev, imsg->hdr.type, imsg->hdr.peerid,
 206             fd, imsg->data, imsg->hdr.len - IMSG_HEADER_SIZE);
 207 }