lib/buf.c

   1 /*      $OpenBSD: buf.c,v 1.27 2016/10/16 13:35:51 okan Exp $   */
   2 /*
   3  * Copyright (c) 2003 Jean-Francois Brousseau <jfb@openbsd.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. The name of the author may not be used to endorse or promote products
  13  *    derived from this software without specific prior written permission.
  14  *
  15  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  16  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  17  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
  18  * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  19  * EXEMPLARY, OR CONSEQUENTIAL  DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  21  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  22  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  23  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  24  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 #include <sys/stat.h>
  28
  29 #include <errno.h>
  30 #include <fcntl.h>
  31 #include <stdint.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <unistd.h>
  36
  37 #include "buf.h"
  38
  39 #include "got_error.h"
  40
  41 #define BUF_INCR        128
  42
  43 #define SIZE_LEFT(b)    ((b)->cb_size - (b)->cb_len)
  44
  45 static const struct got_error *buf_grow(BUF *, size_t);
  46
  47 /*
  48  * Create a new buffer structure and return a pointer to it.  This structure
  49  * uses dynamically-allocated memory and must be freed with buf_free(), once
  50  * the buffer is no longer needed.
  51  */
  52 const struct got_error *
  53 buf_alloc(BUF **b, size_t len)
  54 {
  55         const struct got_error *err = NULL;
  56
  57         *b = malloc(sizeof(**b));
  58         if (*b == NULL)
  59                 return NULL;
  60         /* Postpone creation of zero-sized buffers */
  61         if (len > 0) {
  62                 (*b)->cb_buf = calloc(1, len);
  63                 if ((*b)->cb_buf == NULL) {
  64                         err = got_error_from_errno("calloc");
  65                         free(*b);
  66                         *b = NULL;
  67                         return err;
  68                 }
  69         } else
  70                 (*b)->cb_buf = NULL;
  71
  72         (*b)->cb_size = len;
  73         (*b)->cb_len = 0;
  74
  75         return NULL;
  76 }
  77
  78 /*
  79  * Open the file specified by <path> and load all of its contents into a
  80  * buffer.
  81  * Returns the loaded buffer on success or NULL on failure.
  82  * Sets errno on error.
  83  */
  84 const struct got_error *
  85 buf_load(BUF **buf, FILE *f)
  86 {
  87         const struct got_error *err = NULL;
  88         size_t ret;
  89         size_t len;
  90         u_char *bp;
  91         struct stat st;
  92
  93         *buf = NULL;
  94
  95         if (fstat(fileno(f), &st) == -1) {
  96                 err = got_error_from_errno("fstat");
  97                 goto out;
  98         }
  99
 100         if ((uintmax_t)st.st_size > SIZE_MAX) {
 101                 err = got_error_set_errno(EFBIG,
 102                     "cannot fit file into memory buffer");
 103                 goto out;
 104         }
 105         err = buf_alloc(buf, st.st_size);
 106         if (err)
 107                 goto out;
 108         for (bp = (*buf)->cb_buf; ; bp += ret) {
 109                 len = SIZE_LEFT(*buf);
 110                 ret = fread(bp, 1, len, f);
 111                 if (ret == 0 && ferror(f)) {
 112                         err = got_ferror(f, GOT_ERR_IO);
 113                         goto out;
 114                 } else if (ret == 0)
 115                         break;
 116
 117                 (*buf)->cb_len += (size_t)ret;
 118         }
 119
 120 out:
 121         if (err) {
 122                 buf_free(*buf);
 123                 *buf = NULL;
 124         }
 125         return err;
 126 }
 127
 128 void
 129 buf_free(BUF *b)
 130 {
 131         if (b == NULL)
 132                 return;
 133         free(b->cb_buf);
 134         free(b);
 135 }
 136
 137 /*
 138  * Free the buffer <b>'s structural information but do not free the contents
 139  * of the buffer.  Instead, they are returned and should be freed later using
 140  * free().
 141  */
 142 void *
 143 buf_release(BUF *b)
 144 {
 145         void *tmp;
 146
 147         tmp = b->cb_buf;
 148         free(b);
 149         return (tmp);
 150 }
 151
 152 u_char *
 153 buf_get(BUF *b)
 154 {
 155         return (b->cb_buf);
 156 }
 157
 158 /*
 159  * Empty the contents of the buffer <b> and reset pointers.
 160  */
 161 void
 162 buf_empty(BUF *b)
 163 {
 164         memset(b->cb_buf, 0, b->cb_size);
 165         b->cb_len = 0;
 166 }
 167
 168 /*
 169  * Append a single character <c> to the end of the buffer <b>.
 170  */
 171 const struct got_error *
 172 buf_putc(BUF *b, int c)
 173 {
 174         const struct got_error *err = NULL;
 175         u_char *bp;
 176
 177         if (SIZE_LEFT(b) == 0) {
 178                 err = buf_grow(b, BUF_INCR);
 179                 if (err)
 180                         return err;
 181         }
 182         bp = b->cb_buf + b->cb_len;
 183         *bp = (u_char)c;
 184         b->cb_len++;
 185         return NULL;
 186 }
 187
 188 /*
 189  * Append a string <s> to the end of buffer <b>.
 190  */
 191 const struct got_error *
 192 buf_puts(size_t *newlen, BUF *b, const char *str)
 193 {
 194         return buf_append(newlen, b, str, strlen(str));
 195 }
 196
 197 /*
 198  * Return u_char at buffer position <pos>.
 199  */
 200 u_char
 201 buf_getc(BUF *b, size_t pos)
 202 {
 203         return (b->cb_buf[pos]);
 204 }
 205
 206 /*
 207  * Append <len> bytes of data pointed to by <data> to the buffer <b>.  If the
 208  * buffer is too small to accept all data, it will get resized to an
 209  * appropriate size to accept all data.
 210  * Returns the number of bytes successfully appended to the buffer.
 211  */
 212 const struct got_error *
 213 buf_append(size_t *newlen, BUF *b, const void *data, size_t len)
 214 {
 215         const struct got_error *err = NULL;
 216         size_t left, rlen;
 217         u_char *bp;
 218
 219         left = SIZE_LEFT(b);
 220         rlen = len;
 221
 222         if (left < len) {
 223                 err = buf_grow(b, len - left);
 224                 if (err)
 225                         return err;
 226         }
 227         bp = b->cb_buf + b->cb_len;
 228         memcpy(bp, data, rlen);
 229         b->cb_len += rlen;
 230
 231         *newlen = rlen;
 232         return NULL;
 233 }
 234
 235 /*
 236  * Returns the size of the buffer that is being used.
 237  */
 238 size_t
 239 buf_len(BUF *b)
 240 {
 241         return (b->cb_len);
 242 }
 243
 244 /*
 245  * Write the contents of the buffer <b> to the specified <fd>
 246  */
 247 int
 248 buf_write_fd(BUF *b, int fd)
 249 {
 250         u_char *bp;
 251         size_t len;
 252         ssize_t ret;
 253
 254         len = b->cb_len;
 255         bp = b->cb_buf;
 256
 257         do {
 258                 ret = write(fd, bp, len);
 259                 if (ret == -1) {
 260                         if (errno == EINTR || errno == EAGAIN)
 261                                 continue;
 262                         return (-1);
 263                 }
 264
 265                 len -= (size_t)ret;
 266                 bp += (size_t)ret;
 267         } while (len > 0);
 268
 269         return (0);
 270 }
 271
 272 /*
 273  * Write the contents of the buffer <b> to the file whose path is given in
 274  * <path>.  If the file does not exist, it is created with mode <mode>.
 275  */
 276 const struct got_error *
 277 buf_write(BUF *b, const char *path, mode_t mode)
 278 {
 279         const struct got_error *err = NULL;
 280         int fd;
 281  open:
 282         if ((fd = open(path, O_WRONLY|O_CREAT|O_TRUNC|O_CLOEXEC, mode)) == -1) {
 283                 err = got_error_from_errno2("open", path);
 284                 if (errno == EACCES && unlink(path) != -1)
 285                         goto open;
 286                 else
 287                         return err;
 288         }
 289
 290         if (buf_write_fd(b, fd) == -1) {
 291                 err = got_error_from_errno("buf_write_fd");
 292                 (void)unlink(path);
 293                 return err;
 294         }
 295
 296         if (fchmod(fd, mode) < 0)
 297                 err = got_error_from_errno2("fchmod", path);
 298
 299         if (close(fd) == -1 && err == NULL)
 300                 err = got_error_from_errno2("close", path);
 301
 302         return err;
 303 }
 304
 305 /*
 306  * Write the contents of the buffer <b> to a temporary file whose path is
 307  * specified using <template> (see mkstemp.3).
 308  * NB. This function will modify <template>, as per mkstemp
 309  */
 310 const struct got_error *
 311 buf_write_stmp(BUF *b, char *template)
 312 {
 313         const struct got_error *err = NULL;
 314         int fd;
 315
 316         if ((fd = mkstemp(template)) == -1)
 317                 return got_error_from_errno("mkstemp");
 318
 319         if (buf_write_fd(b, fd) == -1) {
 320                 err = got_error_from_errno("buf_write_fd");
 321                 (void)unlink(template);
 322         }
 323
 324         if (close(fd) == -1 && err == NULL)
 325                 err = got_error_from_errno("close");
 326
 327         return err;
 328 }
 329
 330 /*
 331  * Grow the buffer <b> by <len> bytes.  The contents are unchanged by this
 332  * operation regardless of the result.
 333  */
 334 static const struct got_error *
 335 buf_grow(BUF *b, size_t len)
 336 {
 337         u_char *buf;
 338         buf = reallocarray(b->cb_buf, 1, b->cb_size + len);
 339         if (buf == NULL)
 340                 return got_error_from_errno("reallocarray");
 341         b->cb_buf = buf;
 342         b->cb_size += len;
 343         return NULL;
 344 }