contrib/ntpd/imsg.c

   1 /*      $OpenBSD: src/usr.sbin/ntpd/imsg.c,v 1.7 2004/09/16 01:13:42 henning 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 MIND, USE, DATA OR PROFITS, WHETHER
  15  * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  16  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 #include <sys/types.h>
  20
  21 #include <errno.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25
  26 #include "ntpd.h"
  27
  28 void
  29 imsg_init(struct imsgbuf *ibuf, int fd)
  30 {
  31         msgbuf_init(&ibuf->w);
  32         bzero(&ibuf->r, sizeof(ibuf->r));
  33         ibuf->fd = fd;
  34         ibuf->w.fd = fd;
  35         ibuf->pid = getpid();
  36 }
  37
  38 int
  39 imsg_read(struct imsgbuf *ibuf)
  40 {
  41         ssize_t                  n;
  42
  43         if ((n = read(ibuf->fd, ibuf->r.buf + ibuf->r.wpos,
  44             sizeof(ibuf->r.buf) - ibuf->r.wpos)) == -1) {
  45                 if (errno != EINTR && errno != EAGAIN) {
  46                         log_warn("imsg_read: pipe read error");
  47                         return (-1);
  48                 }
  49                 return (0);
  50         }
  51
  52         ibuf->r.wpos += n;
  53
  54         return (n);
  55 }
  56
  57 int
  58 imsg_get(struct imsgbuf *ibuf, struct imsg *imsg)
  59 {
  60         ssize_t                  datalen = 0;
  61         size_t                   av, left;
  62
  63         av = ibuf->r.wpos;
  64
  65         if (IMSG_HEADER_SIZE > av)
  66                 return (0);
  67
  68         memcpy(&imsg->hdr, ibuf->r.buf, sizeof(imsg->hdr));
  69         if (imsg->hdr.len < IMSG_HEADER_SIZE ||
  70             imsg->hdr.len > MAX_IMSGSIZE) {
  71                 log_warnx("imsg_get: imsg hdr len out of bounds");
  72                 return (-1);
  73         }
  74         if (imsg->hdr.len > av)
  75                 return (0);
  76         datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
  77         ibuf->r.rptr = ibuf->r.buf + IMSG_HEADER_SIZE;
  78         if ((imsg->data = malloc(datalen)) == NULL) {
  79                 log_warn("imsg_get");
  80                 return (-1);
  81         }
  82         memcpy(imsg->data, ibuf->r.rptr, datalen);
  83
  84         if (imsg->hdr.len < av) {
  85                 left = av - imsg->hdr.len;
  86                 memcpy(&ibuf->r.buf, ibuf->r.buf + imsg->hdr.len, left);
  87                 ibuf->r.wpos = left;
  88         } else
  89                 ibuf->r.wpos = 0;
  90
  91         return (datalen + IMSG_HEADER_SIZE);
  92 }
  93
  94 int
  95 imsg_compose(struct imsgbuf *ibuf, enum imsg_type type, u_int32_t peerid,
  96     pid_t pid, void *data, u_int16_t datalen)
  97 {
  98         struct buf      *wbuf;
  99         int              n;
 100
 101         if ((wbuf = imsg_create(ibuf, type, peerid, pid, datalen)) == NULL)
 102                 return (-1);
 103
 104         if (imsg_add(wbuf, data, datalen) == -1)
 105                 return (-1);
 106
 107         if ((n = imsg_close(ibuf, wbuf)) < 0)
 108                 return (-1);
 109
 110         return (n);
 111 }
 112
 113 struct buf *
 114 imsg_create(struct imsgbuf *ibuf, enum imsg_type type, u_int32_t peerid,
 115     pid_t pid, u_int16_t datalen)
 116 {
 117         struct buf      *wbuf;
 118         struct imsg_hdr  hdr;
 119
 120         if (datalen > MAX_IMSGSIZE - IMSG_HEADER_SIZE) {
 121                 log_warnx("imsg_create: len %u > MAX_IMSGSIZE; "
 122                     "type %u peerid %lu", datalen + IMSG_HEADER_SIZE,
 123                     type, peerid);
 124                 return (NULL);
 125         }
 126
 127         hdr.len = datalen + IMSG_HEADER_SIZE;
 128         hdr.type = type;
 129         hdr.peerid = peerid;
 130         hdr.pid = pid;
 131         if ((wbuf = buf_open(hdr.len)) == NULL) {
 132                 log_warn("imsg_create: buf_open");
 133                 return (NULL);
 134         }
 135         if (imsg_add(wbuf, &hdr, sizeof(hdr)) == -1)
 136                 return (NULL);
 137
 138         return (wbuf);
 139 }
 140
 141 int
 142 imsg_add(struct buf *msg, void *data, u_int16_t datalen)
 143 {
 144         if (datalen)
 145                 if (buf_add(msg, data, datalen) == -1) {
 146                         log_warnx("imsg_add: buf_add error");
 147                         buf_free(msg);
 148                         return (-1);
 149                 }
 150         return (datalen);
 151 }
 152
 153 int
 154 imsg_close(struct imsgbuf *ibuf, struct buf *msg)
 155 {
 156         int     n;
 157
 158         if ((n = buf_close(&ibuf->w, msg)) < 0) {
 159                         log_warnx("imsg_close: buf_add error");
 160                         buf_free(msg);
 161                         return (-1);
 162         }
 163         return (n);
 164 }
 165
 166 void
 167 imsg_free(struct imsg *imsg)
 168 {
 169         free(imsg->data);
 170 }