lib/bufio.c

   1 /*
   2  * bufio.c was written by Omar Polo <op@omarpolo.com>
   3  *
   4  * This is free and unencumbered software released into the public domain.
   5  *
   6  * Anyone is free to copy, modify, publish, use, compile, sell, or
   7  * distribute this software, either in source code form or as a compiled
   8  * binary, for any purpose, commercial or non-commercial, and by any
   9  * means.
  10  *
  11  * In jurisdictions that recognize copyright laws, the author or authors
  12  * of this software dedicate any and all copyright interest in the
  13  * software to the public domain. We make this dedication for the benefit
  14  * of the public at large and to the detriment of our heirs and
  15  * successors. We intend this dedication to be an overt act of
  16  * relinquishment in perpetuity of all present and future rights to this
  17  * software under copyright law.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  20  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  21  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  22  * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  23  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  24  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  25  * OTHER DEALINGS IN THE SOFTWARE.
  26  */
  27
  28 #include "got_compat.h"
  29
  30 #include <assert.h>
  31 #include <errno.h>
  32 #include <stdarg.h>
  33 #include <stdint.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <tls.h>
  37 #include <string.h>
  38 #include <unistd.h>
  39
  40 #include "bufio.h"
  41
  42 int
  43 buf_init(struct buf *buf)
  44 {
  45         const size_t     cap = BIO_CHUNK;
  46
  47         memset(buf, 0, sizeof(*buf));
  48         if ((buf->buf = malloc(cap)) == NULL)
  49                 return (-1);
  50         buf->cap = cap;
  51         return (0);
  52 }
  53
  54 static int
  55 buf_grow(struct buf *buf)
  56 {
  57         size_t           newcap;
  58         void            *t;
  59
  60         newcap = buf->cap + BIO_CHUNK;
  61         t = realloc(buf->buf, newcap);
  62         if (t == NULL)
  63                 return (-1);
  64         buf->buf = t;
  65         buf->cap = newcap;
  66         return (0);
  67 }
  68
  69 int
  70 buf_has_line(struct buf *buf, const char *nl)
  71 {
  72         return (memmem(buf->buf, buf->len, nl, strlen(nl)) != NULL);
  73 }
  74
  75 char *
  76 buf_getdelim(struct buf *buf, const char *nl, size_t *len)
  77 {
  78         uint8_t *endl;
  79         size_t   nlen;
  80
  81         *len = 0;
  82
  83         nlen = strlen(nl);
  84         if ((endl = memmem(buf->buf, buf->len, nl, nlen)) == NULL)
  85                 return (NULL);
  86         *len = endl + nlen - buf->buf;
  87         *endl = '\0';
  88         return (buf->buf);
  89 }
  90
  91 void
  92 buf_drain(struct buf *buf, size_t l)
  93 {
  94         buf->cur = 0;
  95
  96         if (l >= buf->len) {
  97                 buf->len = 0;
  98                 return;
  99         }
 100
 101         memmove(buf->buf, buf->buf + l, buf->len - l);
 102         buf->len -= l;
 103 }
 104
 105 void
 106 buf_drain_line(struct buf *buf, const char *nl)
 107 {
 108         uint8_t         *endln;
 109         size_t           nlen;
 110
 111         nlen = strlen(nl);
 112         if ((endln = memmem(buf->buf, buf->len, nl, nlen)) == NULL)
 113                 return;
 114         buf_drain(buf, endln + nlen - buf->buf);
 115 }
 116
 117 void
 118 buf_free(struct buf *buf)
 119 {
 120         free(buf->buf);
 121         memset(buf, 0, sizeof(*buf));
 122 }
 123
 124 int
 125 bufio_init(struct bufio *bio)
 126 {
 127         memset(bio, 0, sizeof(*bio));
 128         bio->fd = -1;
 129
 130         if (buf_init(&bio->wbuf) == -1)
 131                 return (-1);
 132         if (buf_init(&bio->rbuf) == -1) {
 133                 buf_free(&bio->wbuf);
 134                 return (-1);
 135         }
 136         return (0);
 137 }
 138
 139 void
 140 bufio_free(struct bufio *bio)
 141 {
 142         if (bio->ctx)
 143                 tls_free(bio->ctx);
 144         bio->ctx = NULL;
 145
 146         if (bio->fd != -1)
 147                 close(bio->fd);
 148         bio->fd = -1;
 149
 150         buf_free(&bio->rbuf);
 151         buf_free(&bio->wbuf);
 152 }
 153
 154 int
 155 bufio_close(struct bufio *bio)
 156 {
 157         if (bio->ctx == NULL)
 158                 return (0);
 159
 160         switch (tls_close(bio->ctx)) {
 161         case 0:
 162                 return 0;
 163         case TLS_WANT_POLLIN:
 164                 errno = EAGAIN;
 165                 bio->wantev = BUFIO_WANT_READ;
 166                 return (-1);
 167         case TLS_WANT_POLLOUT:
 168                 errno = EAGAIN;
 169                 bio->wantev = BUFIO_WANT_WRITE;
 170                 return (-1);
 171         default:
 172                 return (-1);
 173         }
 174 }
 175
 176 int
 177 bufio_reset(struct bufio *bio)
 178 {
 179         bufio_free(bio);
 180         return (bufio_init(bio));
 181 }
 182
 183 void
 184 bufio_set_fd(struct bufio *bio, int fd)
 185 {
 186         bio->fd = fd;
 187 }
 188
 189 int
 190 bufio_starttls(struct bufio *bio, const char *host, int insecure,
 191     const uint8_t *cert, size_t certlen, const uint8_t *key, size_t keylen)
 192 {
 193         struct tls_config       *conf;
 194
 195         if ((conf = tls_config_new()) == NULL)
 196                 return (-1);
 197
 198         if (insecure) {
 199                 tls_config_insecure_noverifycert(conf);
 200                 tls_config_insecure_noverifyname(conf);
 201                 tls_config_insecure_noverifytime(conf);
 202         }
 203
 204         if (cert && tls_config_set_keypair_mem(conf, cert, certlen,
 205             key, keylen) == -1) {
 206                 tls_config_free(conf);
 207                 return (-1);
 208         }
 209
 210         if ((bio->ctx = tls_client()) == NULL) {
 211                 tls_config_free(conf);
 212                 return (-1);
 213         }
 214
 215         if (tls_configure(bio->ctx, conf) == -1) {
 216                 tls_config_free(conf);
 217                 return (-1);
 218         }
 219
 220         tls_config_free(conf);
 221
 222         if (tls_connect_socket(bio->ctx, bio->fd, host) == -1)
 223                 return (-1);
 224
 225         return (0);
 226 }
 227
 228 int
 229 bufio_ev(struct bufio *bio)
 230 {
 231         short            ev;
 232
 233         if (bio->wantev)
 234                 return (bio->wantev);
 235
 236         ev = BUFIO_WANT_READ;
 237         if (bio->wbuf.len != 0)
 238                 ev |= BUFIO_WANT_WRITE;
 239
 240         return (ev);
 241 }
 242
 243 int
 244 bufio_handshake(struct bufio *bio)
 245 {
 246         if (bio->ctx == NULL) {
 247                 errno = EINVAL;
 248                 return (-1);
 249         }
 250
 251         switch (tls_handshake(bio->ctx)) {
 252         case 0:
 253                 return (0);
 254         case TLS_WANT_POLLIN:
 255                 errno = EAGAIN;
 256                 bio->wantev = BUFIO_WANT_READ;
 257                 return (-1);
 258         case TLS_WANT_POLLOUT:
 259                 errno = EAGAIN;
 260                 bio->wantev = BUFIO_WANT_WRITE;
 261                 return (-1);
 262         default:
 263                 return (-1);
 264         }
 265 }
 266
 267 ssize_t
 268 bufio_read(struct bufio *bio)
 269 {
 270         struct buf      *rbuf = &bio->rbuf;
 271         ssize_t          r;
 272
 273         assert(rbuf->cap >= rbuf->len);
 274         if (rbuf->cap - rbuf->len < BIO_CHUNK) {
 275                 if (buf_grow(rbuf) == -1)
 276                         return (-1);
 277         }
 278
 279         if (bio->ctx) {
 280                 r = tls_read(bio->ctx, rbuf->buf + rbuf->len,
 281                     rbuf->cap - rbuf->len);
 282                 switch (r) {
 283                 case TLS_WANT_POLLIN:
 284                         errno = EAGAIN;
 285                         bio->wantev = BUFIO_WANT_READ;
 286                         return (-1);
 287                 case TLS_WANT_POLLOUT:
 288                         errno = EAGAIN;
 289                         bio->wantev = BUFIO_WANT_WRITE;
 290                         return (-1);
 291                 case -1:
 292                         bio->wantev = 0;
 293                         errno = 0;
 294                         return (-1);
 295                 default:
 296                         bio->wantev = 0;
 297                         rbuf->len += r;
 298                         return (r);
 299                 }
 300         }
 301
 302         r = read(bio->fd, rbuf->buf + rbuf->len, rbuf->cap - rbuf->len);
 303         if (r == -1)
 304                 return (-1);
 305         rbuf->len += r;
 306         return (r);
 307 }
 308
 309 size_t
 310 bufio_drain(struct bufio *bio, void *d, size_t len)
 311 {
 312         struct buf      *rbuf = &bio->rbuf;
 313
 314         if (len > rbuf->len)
 315                 len = rbuf->len;
 316         memcpy(d, rbuf->buf, len);
 317         buf_drain(rbuf, len);
 318         return (len);
 319 }
 320
 321 ssize_t
 322 bufio_write(struct bufio *bio)
 323 {
 324         struct buf      *wbuf = &bio->wbuf;
 325         ssize_t          w;
 326
 327         if (bio->ctx) {
 328                 switch (w = tls_write(bio->ctx, wbuf->buf, wbuf->len)) {
 329                 case TLS_WANT_POLLIN:
 330                         errno = EAGAIN;
 331                         bio->wantev = BUFIO_WANT_READ;
 332                         return (-1);
 333                 case TLS_WANT_POLLOUT:
 334                         errno = EAGAIN;
 335                         bio->wantev = BUFIO_WANT_WRITE;
 336                         return (-1);
 337                 case -1:
 338                         return (-1);
 339                 default:
 340                         bio->wantev = 0;
 341                         buf_drain(wbuf, w);
 342                         return (w);
 343                 }
 344         }
 345
 346         w = write(bio->fd, wbuf->buf, wbuf->len);
 347         if (w == -1)
 348                 return (-1);
 349         buf_drain(wbuf, w);
 350         return (w);
 351 }
 352
 353 const char *
 354 bufio_io_err(struct bufio *bio)
 355 {
 356         if (bio->ctx)
 357                 return tls_error(bio->ctx);
 358
 359         return strerror(errno);
 360 }
 361
 362 int
 363 bufio_compose(struct bufio *bio, const void *d, size_t len)
 364 {
 365         struct buf      *wbuf = &bio->wbuf;
 366
 367         while (wbuf->cap - wbuf->len < len) {
 368                 if (buf_grow(wbuf) == -1)
 369                         return (-1);
 370         }
 371
 372         memcpy(wbuf->buf + wbuf->len, d, len);
 373         wbuf->len += len;
 374         return (0);
 375 }
 376
 377 int
 378 bufio_compose_str(struct bufio *bio, const char *str)
 379 {
 380         return (bufio_compose(bio, str, strlen(str)));
 381 }
 382
 383 int
 384 bufio_compose_fmt(struct bufio *bio, const char *fmt, ...)
 385 {
 386         va_list          ap;
 387         char            *str;
 388         int              r;
 389
 390         va_start(ap, fmt);
 391         r = vasprintf(&str, fmt, ap);
 392         va_end(ap);
 393
 394         if (r == -1)
 395                 return (-1);
 396         r = bufio_compose(bio, str, r);
 397         free(str);
 398         return (r);
 399 }
 400
 401 void
 402 bufio_rewind_cursor(struct bufio *bio)
 403 {
 404         bio->rbuf.cur = 0;
 405 }
 406
 407 int
 408 bufio_get_cb(void *d)
 409 {
 410         struct bufio    *bio = d;
 411         struct buf      *rbuf = &bio->rbuf;
 412
 413         if (rbuf->cur >= rbuf->len)
 414                 return (EOF);
 415         return (rbuf->buf[rbuf->cur++]);
 416 }
 417
 418 int
 419 bufio_peek_cb(void *d)
 420 {
 421         struct bufio    *bio = d;
 422         struct buf      *rbuf = &bio->rbuf;
 423
 424         if (rbuf->cur >= rbuf->len)
 425                 return (EOF);
 426         return (rbuf->buf[rbuf->cur]);
 427 }