git.sesse.net Git - ffmpeg/blob - libavutil/bprint.c

   1 /*
   2  * Copyright (c) 2012 Nicolas George
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include <stdarg.h>
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <time.h>
  25 #include "avassert.h"
  26 #include "avstring.h"
  27 #include "bprint.h"
  28 #include "common.h"
  29 #include "compat/va_copy.h"
  30 #include "error.h"
  31 #include "mem.h"
  32
  33 #if HAVE_UNISTD_H
  34 #include <unistd.h>
  35 #endif
  36
  37
  38 #define av_bprint_room(buf) ((buf)->size - FFMIN((buf)->len, (buf)->size))
  39 #define av_bprint_is_allocated(buf) ((buf)->str != (buf)->reserved_internal_buffer)
  40
  41 static int av_bprint_alloc(AVBPrint *buf, unsigned room)
  42 {
  43     char *old_str, *new_str;
  44     unsigned min_size, new_size;
  45
  46     if (buf->size == buf->size_max)
  47         return AVERROR(EIO);
  48     if (!av_bprint_is_complete(buf))
  49         return AVERROR_INVALIDDATA; /* it is already truncated anyway */
  50     min_size = buf->len + 1 + FFMIN(UINT_MAX - buf->len - 1, room);
  51     new_size = buf->size > buf->size_max / 2 ? buf->size_max : buf->size * 2;
  52     if (new_size < min_size)
  53         new_size = FFMIN(buf->size_max, min_size);
  54     old_str = av_bprint_is_allocated(buf) ? buf->str : NULL;
  55     new_str = av_realloc(old_str, new_size);
  56     if (!new_str)
  57         return AVERROR(ENOMEM);
  58     if (!old_str)
  59         memcpy(new_str, buf->str, buf->len + 1);
  60     buf->str  = new_str;
  61     buf->size = new_size;
  62     return 0;
  63 }
  64
  65 static void av_bprint_grow(AVBPrint *buf, unsigned extra_len)
  66 {
  67     /* arbitrary margin to avoid small overflows */
  68     extra_len = FFMIN(extra_len, UINT_MAX - 5 - buf->len);
  69     buf->len += extra_len;
  70     if (buf->size)
  71         buf->str[FFMIN(buf->len, buf->size - 1)] = 0;
  72 }
  73
  74 void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
  75 {
  76     unsigned size_auto = (char *)buf + sizeof(*buf) -
  77                          buf->reserved_internal_buffer;
  78
  79     if (size_max == 1)
  80         size_max = size_auto;
  81     buf->str      = buf->reserved_internal_buffer;
  82     buf->len      = 0;
  83     buf->size     = FFMIN(size_auto, size_max);
  84     buf->size_max = size_max;
  85     *buf->str = 0;
  86     if (size_init > buf->size)
  87         av_bprint_alloc(buf, size_init - 1);
  88 }
  89
  90 void av_bprint_init_for_buffer(AVBPrint *buf, char *buffer, unsigned size)
  91 {
  92     buf->str      = buffer;
  93     buf->len      = 0;
  94     buf->size     = size;
  95     buf->size_max = size;
  96     *buf->str = 0;
  97 }
  98
  99 void av_bprintf(AVBPrint *buf, const char *fmt, ...)
 100 {
 101     unsigned room;
 102     char *dst;
 103     va_list vl;
 104     int extra_len;
 105
 106     while (1) {
 107         room = av_bprint_room(buf);
 108         dst = room ? buf->str + buf->len : NULL;
 109         va_start(vl, fmt);
 110         extra_len = vsnprintf(dst, room, fmt, vl);
 111         va_end(vl);
 112         if (extra_len <= 0)
 113             return;
 114         if (extra_len < room)
 115             break;
 116         if (av_bprint_alloc(buf, extra_len))
 117             break;
 118     }
 119     av_bprint_grow(buf, extra_len);
 120 }
 121
 122 void av_vbprintf(AVBPrint *buf, const char *fmt, va_list vl_arg)
 123 {
 124     unsigned room;
 125     char *dst;
 126     int extra_len;
 127     va_list vl;
 128
 129     while (1) {
 130         room = av_bprint_room(buf);
 131         dst = room ? buf->str + buf->len : NULL;
 132         va_copy(vl, vl_arg);
 133         extra_len = vsnprintf(dst, room, fmt, vl);
 134         va_end(vl);
 135         if (extra_len <= 0)
 136             return;
 137         if (extra_len < room)
 138             break;
 139         if (av_bprint_alloc(buf, extra_len))
 140             break;
 141     }
 142     av_bprint_grow(buf, extra_len);
 143 }
 144
 145 void av_bprint_chars(AVBPrint *buf, char c, unsigned n)
 146 {
 147     unsigned room, real_n;
 148
 149     while (1) {
 150         room = av_bprint_room(buf);
 151         if (n < room)
 152             break;
 153         if (av_bprint_alloc(buf, n))
 154             break;
 155     }
 156     if (room) {
 157         real_n = FFMIN(n, room - 1);
 158         memset(buf->str + buf->len, c, real_n);
 159     }
 160     av_bprint_grow(buf, n);
 161 }
 162
 163 void av_bprint_append_data(AVBPrint *buf, const char *data, unsigned size)
 164 {
 165     unsigned room, real_n;
 166
 167     while (1) {
 168         room = av_bprint_room(buf);
 169         if (size < room)
 170             break;
 171         if (av_bprint_alloc(buf, size))
 172             break;
 173     }
 174     if (room) {
 175         real_n = FFMIN(size, room - 1);
 176         memcpy(buf->str + buf->len, data, real_n);
 177     }
 178     av_bprint_grow(buf, size);
 179 }
 180
 181 void av_bprint_strftime(AVBPrint *buf, const char *fmt, const struct tm *tm)
 182 {
 183     unsigned room;
 184     size_t l;
 185
 186     if (!*fmt)
 187         return;
 188     while (1) {
 189         room = av_bprint_room(buf);
 190         if (room && (l = strftime(buf->str + buf->len, room, fmt, tm)))
 191             break;
 192         /* strftime does not tell us how much room it would need: let us
 193            retry with twice as much until the buffer is large enough */
 194         room = !room ? strlen(fmt) + 1 :
 195                room <= INT_MAX / 2 ? room * 2 : INT_MAX;
 196         if (av_bprint_alloc(buf, room)) {
 197             /* impossible to grow, try to manage something useful anyway */
 198             room = av_bprint_room(buf);
 199             if (room < 1024) {
 200                 /* if strftime fails because the buffer has (almost) reached
 201                    its maximum size, let us try in a local buffer; 1k should
 202                    be enough to format any real date+time string */
 203                 char buf2[1024];
 204                 if ((l = strftime(buf2, sizeof(buf2), fmt, tm))) {
 205                     av_bprintf(buf, "%s", buf2);
 206                     return;
 207                 }
 208             }
 209             if (room) {
 210                 /* if anything else failed and the buffer is not already
 211                    truncated, let us add a stock string and force truncation */
 212                 static const char txt[] = "[truncated strftime output]";
 213                 memset(buf->str + buf->len, '!', room);
 214                 memcpy(buf->str + buf->len, txt, FFMIN(sizeof(txt) - 1, room));
 215                 av_bprint_grow(buf, room); /* force truncation */
 216             }
 217             return;
 218         }
 219     }
 220     av_bprint_grow(buf, l);
 221 }
 222
 223 void av_bprint_get_buffer(AVBPrint *buf, unsigned size,
 224                           unsigned char **mem, unsigned *actual_size)
 225 {
 226     if (size > av_bprint_room(buf))
 227         av_bprint_alloc(buf, size);
 228     *actual_size = av_bprint_room(buf);
 229     *mem = *actual_size ? buf->str + buf->len : NULL;
 230 }
 231
 232 void av_bprint_clear(AVBPrint *buf)
 233 {
 234     if (buf->len) {
 235         *buf->str = 0;
 236         buf->len  = 0;
 237     }
 238 }
 239
 240 int av_bprint_finalize(AVBPrint *buf, char **ret_str)
 241 {
 242     unsigned real_size = FFMIN(buf->len + 1, buf->size);
 243     char *str;
 244     int ret = 0;
 245
 246     if (ret_str) {
 247         if (av_bprint_is_allocated(buf)) {
 248             str = av_realloc(buf->str, real_size);
 249             if (!str)
 250                 str = buf->str;
 251             buf->str = NULL;
 252         } else {
 253             str = av_malloc(real_size);
 254             if (str)
 255                 memcpy(str, buf->str, real_size);
 256             else
 257                 ret = AVERROR(ENOMEM);
 258         }
 259         *ret_str = str;
 260     } else {
 261         if (av_bprint_is_allocated(buf))
 262             av_freep(&buf->str);
 263     }
 264     buf->size = real_size;
 265     return ret;
 266 }
 267
 268 #define WHITESPACES " \n\t"
 269
 270 void av_bprint_escape(AVBPrint *dstbuf, const char *src, const char *special_chars,
 271                       enum AVEscapeMode mode, int flags)
 272 {
 273     const char *src0 = src;
 274
 275     if (mode == AV_ESCAPE_MODE_AUTO)
 276         mode = AV_ESCAPE_MODE_BACKSLASH; /* TODO: implement a heuristic */
 277
 278     switch (mode) {
 279     case AV_ESCAPE_MODE_QUOTE:
 280         /* enclose the string between '' */
 281         av_bprint_chars(dstbuf, '\'', 1);
 282         for (; *src; src++) {
 283             if (*src == '\'')
 284                 av_bprintf(dstbuf, "'\\''");
 285             else
 286                 av_bprint_chars(dstbuf, *src, 1);
 287         }
 288         av_bprint_chars(dstbuf, '\'', 1);
 289         break;
 290
 291     /* case AV_ESCAPE_MODE_BACKSLASH or unknown mode */
 292     default:
 293         /* \-escape characters */
 294         for (; *src; src++) {
 295             int is_first_last       = src == src0 || !*(src+1);
 296             int is_ws               = !!strchr(WHITESPACES, *src);
 297             int is_strictly_special = special_chars && strchr(special_chars, *src);
 298             int is_special          =
 299                 is_strictly_special || strchr("'\\", *src) ||
 300                 (is_ws && (flags & AV_ESCAPE_FLAG_WHITESPACE));
 301
 302             if (is_strictly_special ||
 303                 (!(flags & AV_ESCAPE_FLAG_STRICT) &&
 304                  (is_special || (is_ws && is_first_last))))
 305                 av_bprint_chars(dstbuf, '\\', 1);
 306             av_bprint_chars(dstbuf, *src, 1);
 307         }
 308         break;
 309     }
 310 }
 311
 312 int av_bprint_fd_contents(AVBPrint *pb, int fd)
 313 {
 314     int ret;
 315     char buf[1024];
 316     while (1) {
 317         ret = read(fd, buf, sizeof(buf));
 318         if (!ret)
 319             return 0;
 320         else if (ret < 0)
 321             return AVERROR(errno);
 322         av_bprint_append_data(pb, buf, ret);
 323         if (!av_bprint_is_complete(pb))
 324             return AVERROR(ENOMEM);
 325     }
 326 }
 327
 328 #ifdef TEST
 329
 330 #undef printf
 331
 332 static void bprint_pascal(AVBPrint *b, unsigned size)
 333 {
 334     unsigned i, j;
 335     unsigned p[42];
 336
 337     av_assert0(size < FF_ARRAY_ELEMS(p));
 338
 339     p[0] = 1;
 340     av_bprintf(b, "%8d\n", 1);
 341     for (i = 1; i <= size; i++) {
 342         p[i] = 1;
 343         for (j = i - 1; j > 0; j--)
 344             p[j] = p[j] + p[j - 1];
 345         for (j = 0; j <= i; j++)
 346             av_bprintf(b, "%8d", p[j]);
 347         av_bprintf(b, "\n");
 348     }
 349 }
 350
 351 int main(void)
 352 {
 353     AVBPrint b;
 354     char buf[256];
 355     struct tm testtime = { .tm_year = 100, .tm_mon = 11, .tm_mday = 20 };
 356
 357     av_bprint_init(&b, 0, -1);
 358     bprint_pascal(&b, 5);
 359     printf("Short text in unlimited buffer: %u/%u\n", (unsigned)strlen(b.str), b.len);
 360     printf("%s\n", b.str);
 361     av_bprint_finalize(&b, NULL);
 362
 363     av_bprint_init(&b, 0, -1);
 364     bprint_pascal(&b, 25);
 365     printf("Long text in unlimited buffer: %u/%u\n", (unsigned)strlen(b.str), b.len);
 366     av_bprint_finalize(&b, NULL);
 367
 368     av_bprint_init(&b, 0, 2048);
 369     bprint_pascal(&b, 25);
 370     printf("Long text in limited buffer: %u/%u\n", (unsigned)strlen(b.str), b.len);
 371     av_bprint_finalize(&b, NULL);
 372
 373     av_bprint_init(&b, 0, 1);
 374     bprint_pascal(&b, 5);
 375     printf("Short text in automatic buffer: %u/%u\n", (unsigned)strlen(b.str), b.len);
 376
 377     av_bprint_init(&b, 0, 1);
 378     bprint_pascal(&b, 25);
 379     printf("Long text in automatic buffer: %u/%u\n", (unsigned)strlen(b.str)/8*8, b.len);
 380     /* Note that the size of the automatic buffer is arch-dependent. */
 381
 382     av_bprint_init(&b, 0, 0);
 383     bprint_pascal(&b, 25);
 384     printf("Long text count only buffer: %u/%u\n", (unsigned)strlen(b.str), b.len);
 385
 386     av_bprint_init_for_buffer(&b, buf, sizeof(buf));
 387     bprint_pascal(&b, 25);
 388     printf("Long text count only buffer: %u/%u\n", (unsigned)strlen(buf), b.len);
 389
 390     av_bprint_init(&b, 0, -1);
 391     av_bprint_strftime(&b, "%Y-%m-%d", &testtime);
 392     printf("strftime full: %u/%u \"%s\"\n", (unsigned)strlen(buf), b.len, b.str);
 393     av_bprint_finalize(&b, NULL);
 394
 395     av_bprint_init(&b, 0, 8);
 396     av_bprint_strftime(&b, "%Y-%m-%d", &testtime);
 397     printf("strftime truncated: %u/%u \"%s\"\n", (unsigned)strlen(buf), b.len, b.str);
 398
 399     return 0;
 400 }
 401
 402 #endif