lib/imsg.c

   1 // SPDX-License-Identifier: ISC
   2 /*      $OpenBSD$       */
   3
   4 /*
   5  * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
   6  */
   7
   8 #include <zebra.h>
   9
  10 #include "memory.h"
  11 #include "queue.h"
  12 #include "imsg.h"
  13
  14 static int imsg_fd_overhead = 0;
  15
  16 static int imsg_get_fd(struct imsgbuf *);
  17
  18 #ifndef __OpenBSD__
  19 /*
  20  * The original code calls getdtablecount() which is OpenBSD specific. Use
  21  * available_fds() from OpenSMTPD instead.
  22  */
  23 static int available_fds(unsigned int n)
  24 {
  25         unsigned int i;
  26         int ret, fds[256];
  27
  28         if (n > (unsigned int)array_size(fds))
  29                 return 1;
  30
  31         ret = 0;
  32         for (i = 0; i < n; i++) {
  33                 fds[i] = -1;
  34                 if ((fds[i] = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
  35                         if (errno == EAFNOSUPPORT || errno == EPROTONOSUPPORT)
  36                                 fds[i] = socket(AF_INET6, SOCK_DGRAM, 0);
  37                         if (fds[i] < 0) {
  38                                 ret = 1;
  39                                 break;
  40                         }
  41                 }
  42         }
  43
  44         for (i = 0; i < n && fds[i] >= 0; i++)
  45                 close(fds[i]);
  46
  47         return (ret);
  48 }
  49 #endif
  50
  51 void imsg_init(struct imsgbuf *ibuf, int fd)
  52 {
  53         msgbuf_init(&ibuf->w);
  54         memset(&ibuf->r, 0, sizeof(ibuf->r));
  55         ibuf->fd = fd;
  56         ibuf->w.fd = fd;
  57         ibuf->pid = getpid();
  58         TAILQ_INIT(&ibuf->fds);
  59 }
  60
  61 ssize_t imsg_read(struct imsgbuf *ibuf)
  62 {
  63         struct msghdr msg;
  64         struct cmsghdr *cmsg;
  65         union {
  66                 struct cmsghdr hdr;
  67                 char buf[CMSG_SPACE(sizeof(int) * 1)];
  68         } cmsgbuf;
  69         struct iovec iov;
  70         ssize_t n;
  71         int fd;
  72         struct imsg_fd *ifd;
  73
  74         memset(&msg, 0, sizeof(msg));
  75         memset(&cmsgbuf, 0, sizeof(cmsgbuf));
  76
  77         iov.iov_base = ibuf->r.buf + ibuf->r.wpos;
  78         iov.iov_len = sizeof(ibuf->r.buf) - ibuf->r.wpos;
  79         msg.msg_iov = &iov;
  80         msg.msg_iovlen = 1;
  81         msg.msg_control = &cmsgbuf.buf;
  82         msg.msg_controllen = sizeof(cmsgbuf.buf);
  83
  84         if ((ifd = calloc(1, sizeof(struct imsg_fd))) == NULL)
  85                 return -1;
  86
  87 again:
  88 #ifdef __OpenBSD__
  89         if (getdtablecount() + imsg_fd_overhead
  90                     + (int)((CMSG_SPACE(sizeof(int)) - CMSG_SPACE(0))
  91                             / sizeof(int))
  92             >= getdtablesize()) {
  93 #else
  94         if (available_fds(imsg_fd_overhead
  95                           + (CMSG_SPACE(sizeof(int)) - CMSG_SPACE(0))
  96                                     / sizeof(int))) {
  97 #endif
  98                 errno = EAGAIN;
  99                 free(ifd);
 100                 return -1;
 101         }
 102
 103         n = recvmsg(ibuf->fd, &msg, 0);
 104         if (n == -1) {
 105                 if (errno == EINTR)
 106                         goto again;
 107                 goto fail;
 108         }
 109
 110         ibuf->r.wpos += n;
 111
 112         for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL;
 113              cmsg = CMSG_NXTHDR(&msg, cmsg)) {
 114                 if (cmsg->cmsg_level == SOL_SOCKET
 115                     && cmsg->cmsg_type == SCM_RIGHTS) {
 116                         int i;
 117                         int j;
 118
 119                         /*
 120                          * We only accept one file descriptor.  Due to C
 121                          * padding rules, our control buffer might contain
 122                          * more than one fd, and we must close them.
 123                          */
 124                         j = ((char *)cmsg + cmsg->cmsg_len
 125                              - (char *)CMSG_DATA(cmsg))
 126                             / sizeof(int);
 127                         for (i = 0; i < j; i++) {
 128                                 fd = ((int *)CMSG_DATA(cmsg))[i];
 129                                 if (ifd != NULL) {
 130                                         ifd->fd = fd;
 131                                         TAILQ_INSERT_TAIL(&ibuf->fds, ifd,
 132                                                           entry);
 133                                         ifd = NULL;
 134                                 } else
 135                                         close(fd);
 136                         }
 137                 }
 138                 /* we do not handle other ctl data level */
 139         }
 140
 141 fail:
 142         free(ifd);
 143         return (n);
 144 }
 145
 146 ssize_t imsg_get(struct imsgbuf *ibuf, struct imsg *imsg)
 147 {
 148         size_t av, left, datalen;
 149
 150         av = ibuf->r.wpos;
 151
 152         if (IMSG_HEADER_SIZE > av)
 153                 return 0;
 154
 155         memcpy(&imsg->hdr, ibuf->r.buf, sizeof(imsg->hdr));
 156         if (imsg->hdr.len < IMSG_HEADER_SIZE || imsg->hdr.len > MAX_IMSGSIZE) {
 157                 errno = ERANGE;
 158                 return -1;
 159         }
 160         if (imsg->hdr.len > av)
 161                 return 0;
 162         datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
 163         ibuf->r.rptr = ibuf->r.buf + IMSG_HEADER_SIZE;
 164         if (datalen == 0)
 165                 imsg->data = NULL;
 166         else if ((imsg->data = malloc(datalen)) == NULL)
 167                 return -1;
 168
 169         if (imsg->hdr.flags & IMSGF_HASFD)
 170                 imsg->fd = imsg_get_fd(ibuf);
 171         else
 172                 imsg->fd = -1;
 173
 174         if (imsg->data)
 175                 memcpy(imsg->data, ibuf->r.rptr, datalen);
 176
 177         if (imsg->hdr.len < av) {
 178                 left = av - imsg->hdr.len;
 179                 memmove(&ibuf->r.buf, ibuf->r.buf + imsg->hdr.len, left);
 180                 ibuf->r.wpos = left;
 181         } else
 182                 ibuf->r.wpos = 0;
 183
 184         return (datalen + IMSG_HEADER_SIZE);
 185 }
 186
 187 int imsg_compose(struct imsgbuf *ibuf, uint32_t type, uint32_t peerid,
 188                  pid_t pid, int fd, const void *data, uint16_t datalen)
 189 {
 190         struct ibuf *wbuf;
 191
 192         if ((wbuf = imsg_create(ibuf, type, peerid, pid, datalen)) == NULL)
 193                 return -1;
 194
 195         if (imsg_add(wbuf, data, datalen) == -1)
 196                 return -1;
 197
 198         wbuf->fd = fd;
 199
 200         imsg_close(ibuf, wbuf);
 201
 202         return 1;
 203 }
 204
 205 int imsg_composev(struct imsgbuf *ibuf, uint32_t type, uint32_t peerid,
 206                   pid_t pid, int fd, const struct iovec *iov, int iovcnt)
 207 {
 208         struct ibuf *wbuf;
 209         int i, datalen = 0;
 210
 211         for (i = 0; i < iovcnt; i++)
 212                 datalen += iov[i].iov_len;
 213
 214         if ((wbuf = imsg_create(ibuf, type, peerid, pid, datalen)) == NULL)
 215                 return -1;
 216
 217         for (i = 0; i < iovcnt; i++)
 218                 if (imsg_add(wbuf, iov[i].iov_base, iov[i].iov_len) == -1)
 219                         return -1;
 220
 221         wbuf->fd = fd;
 222
 223         imsg_close(ibuf, wbuf);
 224
 225         return 1;
 226 }
 227
 228 /* ARGSUSED */
 229 struct ibuf *imsg_create(struct imsgbuf *ibuf, uint32_t type, uint32_t peerid,
 230                          pid_t pid, uint16_t datalen)
 231 {
 232         struct ibuf *wbuf;
 233         struct imsg_hdr hdr;
 234
 235         memset(&hdr, 0x00, IMSG_HEADER_SIZE);
 236
 237         datalen += IMSG_HEADER_SIZE;
 238         if (datalen > MAX_IMSGSIZE) {
 239                 errno = ERANGE;
 240                 return NULL;
 241         }
 242
 243         hdr.type = type;
 244         hdr.flags = 0;
 245         hdr.peerid = peerid;
 246         if ((hdr.pid = pid) == 0)
 247                 hdr.pid = ibuf->pid;
 248         if ((wbuf = ibuf_dynamic(datalen, MAX_IMSGSIZE)) == NULL) {
 249                 return NULL;
 250         }
 251         if (imsg_add(wbuf, &hdr, sizeof(hdr)) == -1)
 252                 return NULL;
 253
 254         return (wbuf);
 255 }
 256
 257 int imsg_add(struct ibuf *msg, const void *data, uint16_t datalen)
 258 {
 259         if (datalen)
 260                 if (ibuf_add(msg, data, datalen) == -1) {
 261                         ibuf_free(msg);
 262                         return -1;
 263                 }
 264         return (datalen);
 265 }
 266
 267 void imsg_close(struct imsgbuf *ibuf, struct ibuf *msg)
 268 {
 269         struct imsg_hdr *hdr;
 270
 271         hdr = (struct imsg_hdr *)msg->buf;
 272
 273         hdr->flags &= ~IMSGF_HASFD;
 274         if (msg->fd != -1)
 275                 hdr->flags |= IMSGF_HASFD;
 276
 277         hdr->len = (uint16_t)msg->wpos;
 278
 279         ibuf_close(&ibuf->w, msg);
 280 }
 281
 282 void imsg_free(struct imsg *imsg)
 283 {
 284         free(imsg->data);
 285 }
 286
 287 int imsg_get_fd(struct imsgbuf *ibuf)
 288 {
 289         int fd;
 290         struct imsg_fd *ifd;
 291
 292         if ((ifd = TAILQ_POP_FIRST(&ibuf->fds, entry)) == NULL)
 293                 return -1;
 294
 295         fd = ifd->fd;
 296         free(ifd);
 297
 298         return (fd);
 299 }
 300
 301 int imsg_flush(struct imsgbuf *ibuf)
 302 {
 303         while (ibuf->w.queued)
 304                 if (msgbuf_write(&ibuf->w) <= 0)
 305                         return -1;
 306         return 0;
 307 }
 308
 309 void imsg_clear(struct imsgbuf *ibuf)
 310 {
 311         int fd;
 312
 313         msgbuf_clear(&ibuf->w);
 314         while ((fd = imsg_get_fd(ibuf)) != -1)
 315                 close(fd);
 316 }