Line data Source code
1 : /* estream-printf.c - Versatile mostly C-99 compliant printf formatting
2 : * Copyright (C) 2007, 2008, 2009, 2010, 2012, 2014 g10 Code GmbH
3 : *
4 : * This file is part of Libestream.
5 : *
6 : * Libestream is free software; you can redistribute it and/or modify
7 : * it under the terms of the GNU Lesser General Public License as
8 : * published by the Free Software Foundation; either version 2.1 of
9 : * the License, or (at your option) any later version.
10 : *
11 : * Libestream is distributed in the hope that it will be useful, but
12 : * 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 Libestream; if not, see <http://www.gnu.org/licenses/>.
18 : *
19 : * ALTERNATIVELY, Libestream may be distributed under the terms of the
20 : * following license, in which case the provisions of this license are
21 : * required INSTEAD OF the GNU General Public License. If you wish to
22 : * allow use of your version of this file only under the terms of the
23 : * GNU General Public License, and not to allow others to use your
24 : * version of this file under the terms of the following license,
25 : * indicate your decision by deleting this paragraph and the license
26 : * below.
27 : *
28 : * Redistribution and use in source and binary forms, with or without
29 : * modification, are permitted provided that the following conditions
30 : * are met:
31 : * 1. Redistributions of source code must retain the above copyright
32 : * notice, and the entire permission notice in its entirety,
33 : * including the disclaimer of warranties.
34 : * 2. Redistributions in binary form must reproduce the above copyright
35 : * notice, this list of conditions and the following disclaimer in the
36 : * documentation and/or other materials provided with the distribution.
37 : * 3. The name of the author may not be used to endorse or promote
38 : * products derived from this software without specific prior
39 : * written permission.
40 : *
41 : * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
42 : * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
43 : * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
44 : * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
45 : * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
46 : * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
47 : * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 : * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
49 : * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
50 : * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
51 : * OF THE POSSIBILITY OF SUCH DAMAGE.
52 : */
53 :
54 : /* Required autoconf tests:
55 :
56 : AC_TYPE_LONG_LONG_INT defines HAVE_LONG_LONG_INT
57 : AC_TYPE_LONG_DOUBLE defines HAVE_LONG_DOUBLE
58 : AC_TYPE_INTMAX_T defines HAVE_INTMAX_T
59 : AC_TYPE_UINTMAX_T defines HAVE_UINTMAX_T
60 : AC_CHECK_TYPES([ptrdiff_t]) defines HAVE_PTRDIFF_T
61 : AC_CHECK_SIZEOF([unsigned long]) defines SIZEOF_UNSIGNED_LONG
62 : AC_CHECK_SIZEOF([void *]) defines SIZEOF_VOID_P
63 : HAVE_LANGINFO_THOUSANDS_SEP
64 :
65 : Note that the file estream.m4 provides the autoconf macro
66 : ESTREAM_PRINTF_INIT which runs all required checks.
67 : See estream-printf.h for ways to tune this code.
68 :
69 : Missing stuff: wchar and wint_t
70 : thousands_sep in pr_float.
71 :
72 : */
73 :
74 : #ifdef HAVE_CONFIG_H
75 : # include <config.h>
76 : #endif
77 :
78 : #if defined(_WIN32) && !defined(HAVE_W32_SYSTEM)
79 : # define HAVE_W32_SYSTEM 1
80 : # if defined(__MINGW32CE__) && !defined (HAVE_W32CE_SYSTEM)
81 : # define HAVE_W32CE_SYSTEM
82 : # endif
83 : #endif
84 :
85 : #include <stdio.h>
86 : #include <stdlib.h>
87 : #include <string.h>
88 : #include <unistd.h>
89 : #include <stdarg.h>
90 : #include <errno.h>
91 : #include <stddef.h>
92 : #include <assert.h>
93 : #if defined(HAVE_INTMAX_T) || defined(HAVE_UINTMAX_T)
94 : # ifdef HAVE_STDINT_H
95 : # include <stdint.h>
96 : # endif
97 : #endif
98 : #ifdef HAVE_LANGINFO_THOUSANDS_SEP
99 : #include <langinfo.h>
100 : #endif
101 : #ifdef HAVE_W32CE_SYSTEM
102 : #include <gpg-error.h> /* ERRNO replacement. */
103 : #endif
104 : #ifdef _ESTREAM_PRINTF_EXTRA_INCLUDE
105 : # include _ESTREAM_PRINTF_EXTRA_INCLUDE
106 : #endif
107 : #include "estream-printf.h"
108 :
109 : /* #define DEBUG 1 */
110 :
111 :
112 : /* Allow redefinition of asprintf used realloc function. */
113 : #if defined(_ESTREAM_PRINTF_REALLOC)
114 : #define my_printf_realloc(a,b) _ESTREAM_PRINTF_REALLOC((a),(b))
115 : #else
116 : #define my_printf_realloc(a,b) fixed_realloc((a),(b))
117 : #endif
118 :
119 : /* A wrapper to set ERRNO. */
120 : #ifdef HAVE_W32CE_SYSTEM
121 : # define _set_errno(a) gpg_err_set_errno ((a))
122 : #else
123 : # define _set_errno(a) do { errno = (a); } while (0)
124 : #endif
125 :
126 :
127 : /* Calculate array dimension. */
128 : #ifndef DIM
129 : #define DIM(array) (sizeof (array) / sizeof (*array))
130 : #endif
131 :
132 :
133 : /* We allow for that many args without requiring malloced memory. */
134 : #define DEFAULT_MAX_ARGSPECS 5
135 :
136 : /* We allow for that many values without requiring malloced memory. */
137 : #define DEFAULT_MAX_VALUES 8
138 :
139 : /* We allocate this many new array argspec elements each time. */
140 : #define ARGSPECS_BUMP_VALUE 10
141 :
142 : /* Special values for the field width and the precision. */
143 : #define NO_FIELD_VALUE (-1)
144 : #define STAR_FIELD_VALUE (-2)
145 :
146 : /* Bit valuues used for the conversion flags. */
147 : #define FLAG_GROUPING 1
148 : #define FLAG_LEFT_JUST 2
149 : #define FLAG_PLUS_SIGN 4
150 : #define FLAG_SPACE_PLUS 8
151 : #define FLAG_ALT_CONV 16
152 : #define FLAG_ZERO_PAD 32
153 :
154 : /* Constants used the length modifiers. */
155 : typedef enum
156 : {
157 : LENMOD_NONE = 0,
158 : LENMOD_CHAR, /* "hh" */
159 : LENMOD_SHORT, /* "h" */
160 : LENMOD_LONG, /* "l" */
161 : LENMOD_LONGLONG, /* "ll" */
162 : LENMOD_INTMAX, /* "j" */
163 : LENMOD_SIZET, /* "z" */
164 : LENMOD_PTRDIFF, /* "t" */
165 : LENMOD_LONGDBL /* "L" */
166 : } lenmod_t;
167 :
168 : /* All the conversion specifiers. */
169 : typedef enum
170 : {
171 : CONSPEC_UNKNOWN = 0,
172 : CONSPEC_DECIMAL,
173 : CONSPEC_OCTAL,
174 : CONSPEC_UNSIGNED,
175 : CONSPEC_HEX,
176 : CONSPEC_HEX_UP,
177 : CONSPEC_FLOAT,
178 : CONSPEC_FLOAT_UP,
179 : CONSPEC_EXP,
180 : CONSPEC_EXP_UP,
181 : CONSPEC_F_OR_G,
182 : CONSPEC_F_OR_G_UP,
183 : CONSPEC_HEX_EXP,
184 : CONSPEC_HEX_EXP_UP,
185 : CONSPEC_CHAR,
186 : CONSPEC_STRING,
187 : CONSPEC_POINTER,
188 : CONSPEC_STRERROR,
189 : CONSPEC_BYTES_SO_FAR
190 : } conspec_t;
191 :
192 :
193 : /* Constants describing all the suppoorted types. Note that we list
194 : all the types we know about even if certain types are not available
195 : on this system. */
196 : typedef enum
197 : {
198 : VALTYPE_UNSUPPORTED = 0, /* Artificial type for error detection. */
199 : VALTYPE_CHAR,
200 : VALTYPE_SCHAR,
201 : VALTYPE_UCHAR,
202 : VALTYPE_SHORT,
203 : VALTYPE_USHORT,
204 : VALTYPE_INT,
205 : VALTYPE_UINT,
206 : VALTYPE_LONG,
207 : VALTYPE_ULONG,
208 : VALTYPE_LONGLONG,
209 : VALTYPE_ULONGLONG,
210 : VALTYPE_DOUBLE,
211 : VALTYPE_LONGDOUBLE,
212 : VALTYPE_STRING,
213 : VALTYPE_INTMAX,
214 : VALTYPE_UINTMAX,
215 : VALTYPE_SIZE,
216 : VALTYPE_PTRDIFF,
217 : VALTYPE_POINTER,
218 : VALTYPE_CHAR_PTR,
219 : VALTYPE_SCHAR_PTR,
220 : VALTYPE_SHORT_PTR,
221 : VALTYPE_INT_PTR,
222 : VALTYPE_LONG_PTR,
223 : VALTYPE_LONGLONG_PTR,
224 : VALTYPE_INTMAX_PTR,
225 : VALTYPE_SIZE_PTR,
226 : VALTYPE_PTRDIFF_PTR
227 : } valtype_t;
228 :
229 :
230 : /* A union used to store the actual values. */
231 : typedef union
232 : {
233 : char a_char;
234 : signed char a_schar;
235 : unsigned char a_uchar;
236 : short a_short;
237 : unsigned short a_ushort;
238 : int a_int;
239 : unsigned int a_uint;
240 : long int a_long;
241 : unsigned long int a_ulong;
242 : #ifdef HAVE_LONG_LONG_INT
243 : long long int a_longlong;
244 : unsigned long long int a_ulonglong;
245 : #endif
246 : double a_double;
247 : #ifdef HAVE_LONG_DOUBLE
248 : long double a_longdouble;
249 : #endif
250 : const char *a_string;
251 : #ifdef HAVE_INTMAX_T
252 : intmax_t a_intmax;
253 : #endif
254 : #ifdef HAVE_UINTMAX_T
255 : intmax_t a_uintmax;
256 : #endif
257 : size_t a_size;
258 : #ifdef HAVE_PTRDIFF_T
259 : ptrdiff_t a_ptrdiff;
260 : #endif
261 : void *a_void_ptr;
262 : char *a_char_ptr;
263 : signed char *a_schar_ptr;
264 : short *a_short_ptr;
265 : int *a_int_ptr;
266 : long *a_long_ptr;
267 : #ifdef HAVE_LONG_LONG_INT
268 : long long int *a_longlong_ptr;
269 : #endif
270 : #ifdef HAVE_INTMAX_T
271 : intmax_t *a_intmax_ptr;
272 : #endif
273 : size_t *a_size_ptr;
274 : #ifdef HAVE_PTRDIFF_T
275 : ptrdiff_t *a_ptrdiff_ptr;
276 : #endif
277 : } value_t;
278 :
279 : /* An object used to keep track of a format option and arguments. */
280 : struct argspec_s
281 : {
282 : size_t length; /* The length of these args including the percent. */
283 : unsigned int flags; /* The conversion flags (bits defined by FLAG_foo). */
284 : int width; /* The field width. */
285 : int precision; /* The precision. */
286 : lenmod_t lenmod; /* The length modifier. */
287 : conspec_t conspec; /* The conversion specifier. */
288 : int arg_pos; /* The position of the argument. This one may
289 : be -1 to indicate that no value is expected
290 : (e.g. for "%m"). */
291 : int width_pos; /* The position of the argument for a field
292 : width star's value. 0 for not used. */
293 : int precision_pos; /* The position of the argument for the a
294 : precision star's value. 0 for not used. */
295 : valtype_t vt; /* The type of the corresponding argument. */
296 : };
297 : typedef struct argspec_s *argspec_t;
298 :
299 : /* An object to build up a table of values and their types. */
300 : struct valueitem_s
301 : {
302 : valtype_t vt; /* The type of the value. */
303 : value_t value; /* The value. */
304 : };
305 : typedef struct valueitem_s *valueitem_t;
306 :
307 :
308 : /* Not all systems have a C-90 compliant realloc. To cope with this
309 : we use this simple wrapper. */
310 : #ifndef _ESTREAM_PRINTF_REALLOC
311 : static void *
312 : fixed_realloc (void *a, size_t n)
313 : {
314 : if (!a)
315 : return malloc (n);
316 :
317 : if (!n)
318 : {
319 : free (a);
320 : return NULL;
321 : }
322 :
323 : return realloc (a, n);
324 : }
325 : #endif /*!_ESTREAM_PRINTF_REALLOC*/
326 :
327 :
328 : #ifdef DEBUG
329 : static void
330 : dump_argspecs (argspec_t arg, size_t argcount)
331 : {
332 : int idx;
333 :
334 : for (idx=0; argcount; argcount--, arg++, idx++)
335 : fprintf (stderr,
336 : "%2d: len=%u flags=%u width=%d prec=%d mod=%d "
337 : "con=%d vt=%d pos=%d-%d-%d\n",
338 : idx,
339 : (unsigned int)arg->length,
340 : arg->flags,
341 : arg->width,
342 : arg->precision,
343 : arg->lenmod,
344 : arg->conspec,
345 : arg->vt,
346 : arg->arg_pos,
347 : arg->width_pos,
348 : arg->precision_pos);
349 : }
350 : #endif /*DEBUG*/
351 :
352 :
353 : /* Set the vt field for ARG. */
354 : static void
355 453 : compute_type (argspec_t arg)
356 : {
357 453 : switch (arg->conspec)
358 : {
359 : case CONSPEC_UNKNOWN:
360 0 : arg->vt = VALTYPE_UNSUPPORTED;
361 0 : break;
362 :
363 : case CONSPEC_DECIMAL:
364 233 : switch (arg->lenmod)
365 : {
366 0 : case LENMOD_CHAR: arg->vt = VALTYPE_SCHAR; break;
367 0 : case LENMOD_SHORT: arg->vt = VALTYPE_SHORT; break;
368 0 : case LENMOD_LONG: arg->vt = VALTYPE_LONG; break;
369 0 : case LENMOD_LONGLONG: arg->vt = VALTYPE_LONGLONG; break;
370 0 : case LENMOD_INTMAX: arg->vt = VALTYPE_INTMAX; break;
371 0 : case LENMOD_SIZET: arg->vt = VALTYPE_SIZE; break;
372 0 : case LENMOD_PTRDIFF: arg->vt = VALTYPE_PTRDIFF; break;
373 233 : default: arg->vt = VALTYPE_INT; break;
374 : }
375 : break;
376 :
377 : case CONSPEC_OCTAL:
378 : case CONSPEC_UNSIGNED:
379 : case CONSPEC_HEX:
380 : case CONSPEC_HEX_UP:
381 96 : switch (arg->lenmod)
382 : {
383 0 : case LENMOD_CHAR: arg->vt = VALTYPE_UCHAR; break;
384 0 : case LENMOD_SHORT: arg->vt = VALTYPE_USHORT; break;
385 0 : case LENMOD_LONG: arg->vt = VALTYPE_ULONG; break;
386 0 : case LENMOD_LONGLONG: arg->vt = VALTYPE_ULONGLONG; break;
387 0 : case LENMOD_INTMAX: arg->vt = VALTYPE_UINTMAX; break;
388 0 : case LENMOD_SIZET: arg->vt = VALTYPE_SIZE; break;
389 0 : case LENMOD_PTRDIFF: arg->vt = VALTYPE_PTRDIFF; break;
390 96 : default: arg->vt = VALTYPE_UINT; break;
391 : }
392 : break;
393 :
394 : case CONSPEC_FLOAT:
395 : case CONSPEC_FLOAT_UP:
396 : case CONSPEC_EXP:
397 : case CONSPEC_EXP_UP:
398 : case CONSPEC_F_OR_G:
399 : case CONSPEC_F_OR_G_UP:
400 : case CONSPEC_HEX_EXP:
401 : case CONSPEC_HEX_EXP_UP:
402 84 : switch (arg->lenmod)
403 : {
404 6 : case LENMOD_LONGDBL: arg->vt = VALTYPE_LONGDOUBLE; break;
405 0 : case LENMOD_LONG: arg->vt = VALTYPE_DOUBLE; break;
406 78 : default: arg->vt = VALTYPE_DOUBLE; break;
407 : }
408 : break;
409 :
410 : case CONSPEC_CHAR:
411 0 : arg->vt = VALTYPE_INT;
412 0 : break;
413 :
414 : case CONSPEC_STRING:
415 34 : arg->vt = VALTYPE_STRING;
416 0 : break;
417 :
418 : case CONSPEC_POINTER:
419 0 : arg->vt = VALTYPE_POINTER;
420 0 : break;
421 :
422 : case CONSPEC_STRERROR:
423 6 : arg->vt = VALTYPE_STRING;
424 0 : break;
425 :
426 : case CONSPEC_BYTES_SO_FAR:
427 0 : switch (arg->lenmod)
428 : {
429 0 : case LENMOD_CHAR: arg->vt = VALTYPE_SCHAR_PTR; break;
430 0 : case LENMOD_SHORT: arg->vt = VALTYPE_SHORT_PTR; break;
431 0 : case LENMOD_LONG: arg->vt = VALTYPE_LONG_PTR; break;
432 0 : case LENMOD_LONGLONG: arg->vt = VALTYPE_LONGLONG_PTR; break;
433 0 : case LENMOD_INTMAX: arg->vt = VALTYPE_INTMAX_PTR; break;
434 0 : case LENMOD_SIZET: arg->vt = VALTYPE_SIZE_PTR; break;
435 0 : case LENMOD_PTRDIFF: arg->vt = VALTYPE_PTRDIFF_PTR; break;
436 0 : default: arg->vt = VALTYPE_INT_PTR; break;
437 : }
438 : break;
439 :
440 : }
441 453 : }
442 :
443 :
444 :
445 : /* Parse the FORMAT string and populate the specification array stored
446 : at the address ARGSPECS_ADDR. The caller has provided enough space
447 : to store up to MAX_ARGSPECS in that buffer. The function may
448 : however ignore the provided buffer and malloc a larger one. On
449 : success the address of that larger buffer will be stored at
450 : ARGSPECS_ADDR. The actual number of specifications will be
451 : returned at R_ARGSPECS_COUNT. */
452 : static int
453 335 : parse_format (const char *format,
454 : argspec_t *argspecs_addr, size_t max_argspecs,
455 : size_t *r_argspecs_count)
456 : {
457 : const char *s;
458 335 : argspec_t argspecs = *argspecs_addr;
459 : argspec_t arg;
460 : size_t argcount = 0;
461 :
462 335 : if (!format)
463 : goto leave_einval;
464 :
465 550 : for (; *format; format++)
466 : {
467 : unsigned int flags;
468 : int width, precision;
469 : lenmod_t lenmod;
470 : conspec_t conspec;
471 : int arg_pos, width_pos, precision_pos;
472 :
473 550 : if (*format != '%')
474 93 : continue;
475 457 : s = ++format;
476 457 : if (!*s)
477 : goto leave_einval;
478 457 : if (*s == '%')
479 4 : continue; /* Just a quoted percent. */
480 :
481 : /* First check whether there is a positional argument. */
482 : arg_pos = 0; /* No positional argument given. */
483 453 : if (*s >= '1' && *s <= '9')
484 : {
485 : const char *save_s = s;
486 :
487 50 : arg_pos = (*s++ - '0');
488 82 : for (; *s >= '0' && *s <= '9'; s++)
489 32 : arg_pos = 10*arg_pos + (*s - '0');
490 50 : if (arg_pos < 0)
491 : goto leave_einval; /* Overflow during conversion. */
492 50 : if (*s == '$')
493 4 : s++;
494 : else
495 : {
496 : arg_pos = 0;
497 : s = save_s;
498 : }
499 : }
500 :
501 : /* Parse the flags. */
502 : flags = 0;
503 717 : for ( ; *s; s++)
504 : {
505 717 : switch (*s)
506 : {
507 0 : case '\'': flags |= FLAG_GROUPING; break;
508 50 : case '-': flags |= FLAG_LEFT_JUST; break;
509 12 : case '+': flags |= FLAG_PLUS_SIGN; break;
510 12 : case ' ': flags |= FLAG_SPACE_PLUS; break;
511 58 : case '#': flags |= FLAG_ALT_CONV; break;
512 132 : case '0': flags |= FLAG_ZERO_PAD; break;
513 : default:
514 : goto flags_parsed;
515 : }
516 : }
517 : flags_parsed:
518 :
519 : /* Parse the field width. */
520 : width_pos = 0;
521 453 : if (*s == '*')
522 : {
523 : width = STAR_FIELD_VALUE;
524 89 : s++;
525 : /* If we have a positional argument, another one might also
526 : be used to give the position of the star's value. */
527 89 : if (arg_pos && *s >= '1' && *s <= '9')
528 : {
529 0 : width_pos = (*s++ - '0');
530 0 : for (; *s >= '0' && *s <= '9'; s++)
531 0 : width_pos = 10*width_pos + (*s - '0');
532 0 : if (width_pos < 1)
533 : goto leave_einval; /* Overflow during conversion. */
534 0 : if (*s != '$')
535 : goto leave_einval; /* Not followed by $. */
536 0 : s++;
537 : }
538 : }
539 364 : else if ( *s >= '0' && *s <= '9')
540 : {
541 238 : width = (*s++ - '0');
542 310 : for (; *s >= '0' && *s <= '9'; s++)
543 : {
544 72 : if (!width && *s == '0')
545 : goto leave_einval; /* Leading zeroes are not allowed.
546 : Fixme: check what other
547 : implementations do. */
548 72 : width = 10*width + (*s - '0');
549 : }
550 238 : if (width < 0)
551 : goto leave_einval; /* Overflow during conversion. */
552 : }
553 : else
554 : width = NO_FIELD_VALUE;
555 :
556 : /* Parse the precision. */
557 : precision_pos = 0;
558 : precision = NO_FIELD_VALUE;
559 453 : if (*s == '.')
560 : {
561 186 : int ignore_value = (s[1] == '-');
562 :
563 186 : s++;
564 186 : if (*s == '*')
565 : {
566 : precision = STAR_FIELD_VALUE;
567 84 : s++;
568 : /* If we have a positional argument, another one might also
569 : be used to give the position of the star's value. */
570 84 : if (arg_pos && *s >= '1' && *s <= '9')
571 : {
572 0 : precision_pos = (*s++ - '0');
573 0 : for (; *s >= '0' && *s <= '9'; s++)
574 0 : precision_pos = 10*precision_pos + (*s - '0');
575 0 : if (precision_pos < 1)
576 : goto leave_einval; /* Overflow during conversion. */
577 0 : if (*s != '$')
578 : goto leave_einval; /* Not followed by $. */
579 0 : s++;
580 : }
581 : }
582 102 : else if ( *s >= '0' && *s <= '9')
583 : {
584 100 : precision = (*s++ - '0');
585 130 : for (; *s >= '0' && *s <= '9'; s++)
586 : {
587 30 : if (!precision && *s == '0')
588 : goto leave_einval; /* Leading zeroes are not allowed.
589 : Fixme: check what other
590 : implementations do. */
591 30 : precision = 10*precision + (*s - '0');
592 : }
593 100 : if (precision < 0)
594 : goto leave_einval; /* Overflow during conversion. */
595 : }
596 : else
597 : precision = 0;
598 186 : if (ignore_value)
599 : precision = NO_FIELD_VALUE;
600 : }
601 :
602 : /* Parse the length modifiers. */
603 453 : switch (*s)
604 : {
605 : case 'h':
606 0 : if (s[1] == 'h')
607 : {
608 : lenmod = LENMOD_CHAR;
609 0 : s++;
610 : }
611 : else
612 : lenmod = LENMOD_SHORT;
613 0 : s++;
614 0 : break;
615 : case 'l':
616 0 : if (s[1] == 'l')
617 : {
618 : lenmod = LENMOD_LONGLONG;
619 0 : s++;
620 : }
621 : else
622 : lenmod = LENMOD_LONG;
623 0 : s++;
624 0 : break;
625 0 : case 'j': lenmod = LENMOD_INTMAX; s++; break;
626 0 : case 'z': lenmod = LENMOD_SIZET; s++; break;
627 0 : case 't': lenmod = LENMOD_PTRDIFF; s++; break;
628 6 : case 'L': lenmod = LENMOD_LONGDBL; s++; break;
629 : default: lenmod = LENMOD_NONE; break;
630 : }
631 :
632 : /* Parse the conversion specifier. */
633 453 : switch (*s)
634 : {
635 : case 'd':
636 : case 'i': conspec = CONSPEC_DECIMAL; break;
637 32 : case 'o': conspec = CONSPEC_OCTAL; break;
638 0 : case 'u': conspec = CONSPEC_UNSIGNED; break;
639 32 : case 'x': conspec = CONSPEC_HEX; break;
640 32 : case 'X': conspec = CONSPEC_HEX_UP; break;
641 68 : case 'f': conspec = CONSPEC_FLOAT; break;
642 0 : case 'F': conspec = CONSPEC_FLOAT_UP; break;
643 2 : case 'e': conspec = CONSPEC_EXP; break;
644 0 : case 'E': conspec = CONSPEC_EXP_UP; break;
645 2 : case 'g': conspec = CONSPEC_F_OR_G; break;
646 0 : case 'G': conspec = CONSPEC_F_OR_G_UP; break;
647 12 : case 'a': conspec = CONSPEC_HEX_EXP; break;
648 0 : case 'A': conspec = CONSPEC_HEX_EXP_UP; break;
649 0 : case 'c': conspec = CONSPEC_CHAR; break;
650 34 : case 's': conspec = CONSPEC_STRING; break;
651 0 : case 'p': conspec = CONSPEC_POINTER; break;
652 0 : case 'n': conspec = CONSPEC_BYTES_SO_FAR; break;
653 0 : case 'C': conspec = CONSPEC_CHAR; lenmod = LENMOD_LONG; break;
654 0 : case 'S': conspec = CONSPEC_STRING; lenmod = LENMOD_LONG; break;
655 6 : case 'm': conspec = CONSPEC_STRERROR; arg_pos = -1; break;
656 : default: conspec = CONSPEC_UNKNOWN;
657 : }
658 :
659 : /* Save the args. */
660 453 : if (argcount >= max_argspecs)
661 : {
662 : /* We either need to allocate a new array instead of the
663 : caller provided one or realloc the array. Instead of
664 : using realloc we allocate a new one and release the
665 : original one then. */
666 : size_t n, newmax;
667 : argspec_t newarg;
668 :
669 21 : newmax = max_argspecs + ARGSPECS_BUMP_VALUE;
670 21 : if (newmax <= max_argspecs)
671 : goto leave_einval; /* Too many arguments. */
672 21 : newarg = calloc (newmax, sizeof *newarg);
673 21 : if (!newarg)
674 : goto leave;
675 105 : for (n=0; n < argcount; n++)
676 105 : newarg[n] = argspecs[n];
677 21 : if (argspecs != *argspecs_addr)
678 0 : free (argspecs);
679 : argspecs = newarg;
680 : max_argspecs = newmax;
681 : }
682 :
683 453 : arg = argspecs + argcount;
684 453 : arg->length = s - format + 2;
685 453 : arg->flags = flags;
686 453 : arg->width = width;
687 453 : arg->precision = precision;
688 453 : arg->lenmod = lenmod;
689 453 : arg->conspec = conspec;
690 453 : arg->arg_pos = arg_pos;
691 453 : arg->width_pos = width_pos;
692 453 : arg->precision_pos = precision_pos;
693 453 : compute_type (arg);
694 453 : argcount++;
695 : format = s;
696 : }
697 :
698 335 : *argspecs_addr = argspecs;
699 335 : *r_argspecs_count = argcount;
700 335 : return 0; /* Success. */
701 :
702 : leave_einval:
703 0 : _set_errno (EINVAL);
704 : leave:
705 0 : if (argspecs != *argspecs_addr)
706 0 : free (argspecs);
707 0 : *argspecs_addr = NULL;
708 0 : return -1;
709 : }
710 :
711 :
712 : /* This function reads all the values as specified by VALUETABLE into
713 : VALUETABLE. The values are expected in VAARGS. The function
714 : returns -1 if a specified type is not supported. */
715 : static int
716 335 : read_values (valueitem_t valuetable, size_t valuetable_len, va_list vaargs)
717 : {
718 : int validx;
719 :
720 955 : for (validx=0; validx < valuetable_len; validx++)
721 : {
722 620 : value_t *value = &valuetable[validx].value;
723 620 : valtype_t vt = valuetable[validx].vt;
724 :
725 620 : switch (vt)
726 : {
727 0 : case VALTYPE_CHAR: value->a_char = va_arg (vaargs, int); break;
728 : case VALTYPE_CHAR_PTR:
729 0 : value->a_char_ptr = va_arg (vaargs, char *);
730 0 : break;
731 0 : case VALTYPE_SCHAR: value->a_schar = va_arg (vaargs, int); break;
732 : case VALTYPE_SCHAR_PTR:
733 0 : value->a_schar_ptr = va_arg (vaargs, signed char *);
734 0 : break;
735 0 : case VALTYPE_UCHAR: value->a_uchar = va_arg (vaargs, int); break;
736 0 : case VALTYPE_SHORT: value->a_short = va_arg (vaargs, int); break;
737 0 : case VALTYPE_USHORT: value->a_ushort = va_arg (vaargs, int); break;
738 : case VALTYPE_SHORT_PTR:
739 0 : value->a_short_ptr = va_arg (vaargs, short *);
740 0 : break;
741 : case VALTYPE_INT:
742 406 : value->a_int = va_arg (vaargs, int);
743 406 : break;
744 : case VALTYPE_INT_PTR:
745 0 : value->a_int_ptr = va_arg (vaargs, int *);
746 0 : break;
747 : case VALTYPE_UINT:
748 96 : value->a_uint = va_arg (vaargs, unsigned int);
749 96 : break;
750 : case VALTYPE_LONG:
751 0 : value->a_long = va_arg (vaargs, long);
752 0 : break;
753 : case VALTYPE_ULONG:
754 0 : value->a_ulong = va_arg (vaargs, unsigned long);
755 0 : break;
756 : case VALTYPE_LONG_PTR:
757 0 : value->a_long_ptr = va_arg (vaargs, long *);
758 0 : break;
759 : #ifdef HAVE_LONG_LONG_INT
760 : case VALTYPE_LONGLONG:
761 0 : value->a_longlong = va_arg (vaargs, long long int);
762 0 : break;
763 : case VALTYPE_ULONGLONG:
764 0 : value->a_ulonglong = va_arg (vaargs, unsigned long long int);
765 0 : break;
766 : case VALTYPE_LONGLONG_PTR:
767 0 : value->a_longlong_ptr = va_arg (vaargs, long long *);
768 0 : break;
769 : #endif
770 : case VALTYPE_DOUBLE:
771 78 : value->a_double = va_arg (vaargs, double);
772 78 : break;
773 : #ifdef HAVE_LONG_DOUBLE
774 : case VALTYPE_LONGDOUBLE:
775 6 : value->a_longdouble = va_arg (vaargs, long double);
776 6 : break;
777 : #endif
778 : case VALTYPE_STRING:
779 34 : value->a_string = va_arg (vaargs, const char *);
780 34 : break;
781 : case VALTYPE_POINTER:
782 0 : value->a_void_ptr = va_arg (vaargs, void *);
783 0 : break;
784 : #ifdef HAVE_INTMAX_T
785 : case VALTYPE_INTMAX:
786 0 : value->a_intmax = va_arg (vaargs, intmax_t);
787 0 : break;
788 : case VALTYPE_INTMAX_PTR:
789 0 : value->a_intmax_ptr = va_arg (vaargs, intmax_t *);
790 0 : break;
791 : #endif
792 : #ifdef HAVE_UINTMAX_T
793 : case VALTYPE_UINTMAX:
794 0 : value->a_uintmax = va_arg (vaargs, uintmax_t);
795 0 : break;
796 : #endif
797 : case VALTYPE_SIZE:
798 0 : value->a_size = va_arg (vaargs, size_t);
799 0 : break;
800 : case VALTYPE_SIZE_PTR:
801 0 : value->a_size_ptr = va_arg (vaargs, size_t *);
802 0 : break;
803 : #ifdef HAVE_PTRDIFF_T
804 : case VALTYPE_PTRDIFF:
805 0 : value->a_ptrdiff = va_arg (vaargs, ptrdiff_t);
806 0 : break;
807 : case VALTYPE_PTRDIFF_PTR:
808 0 : value->a_ptrdiff_ptr = va_arg (vaargs, ptrdiff_t *);
809 0 : break;
810 : #endif
811 : default: /* Unsupported type. */
812 : return -1;
813 : }
814 : }
815 : return 0;
816 : }
817 :
818 :
819 :
820 : /* Output COUNT padding characters PADCHAR and update NBYTES by the
821 : number of bytes actually written. */
822 : static int
823 373 : pad_out (estream_printf_out_t outfnc, void *outfncarg,
824 : int padchar, int count, size_t *nbytes)
825 : {
826 : char buf[32];
827 : size_t n;
828 : int rc;
829 :
830 1066 : while (count > 0)
831 : {
832 320 : n = (count <= sizeof buf)? count : sizeof buf;
833 320 : memset (buf, padchar, n);
834 320 : rc = outfnc (outfncarg, buf, n);
835 320 : if (rc)
836 0 : return rc;
837 320 : *nbytes += n;
838 320 : count -= n;
839 : }
840 :
841 : return 0;
842 : }
843 :
844 :
845 : /* "d,i,o,u,x,X" formatting. OUTFNC and OUTFNCARG describes the
846 : output routine, ARG gives the argument description and VALUE the
847 : actual value (its type is available through arg->vt). */
848 : static int
849 329 : pr_integer (estream_printf_out_t outfnc, void *outfncarg,
850 : argspec_t arg, value_t value, size_t *nbytes)
851 : {
852 : int rc;
853 : #ifdef HAVE_LONG_LONG_INT
854 : unsigned long long aulong;
855 : #else
856 : unsigned long aulong;
857 : #endif
858 : char numbuf[100];
859 : char *p, *pend;
860 : size_t n;
861 329 : char signchar = 0;
862 : int n_prec; /* Number of extra precision digits required. */
863 : int n_extra; /* Extra number of prefix or sign characters. */
864 :
865 329 : if (arg->conspec == CONSPEC_DECIMAL)
866 : {
867 : #ifdef HAVE_LONG_LONG_INT
868 : long long along;
869 : #else
870 : long along;
871 : #endif
872 :
873 233 : switch (arg->vt)
874 : {
875 0 : case VALTYPE_SHORT: along = value.a_short; break;
876 233 : case VALTYPE_INT: along = value.a_int; break;
877 0 : case VALTYPE_LONG: along = value.a_long; break;
878 : #ifdef HAVE_LONG_LONG_INT
879 0 : case VALTYPE_LONGLONG: along = value.a_longlong; break;
880 0 : case VALTYPE_SIZE: along = value.a_size; break;
881 : # ifdef HAVE_INTMAX_T
882 0 : case VALTYPE_INTMAX: along = value.a_intmax; break;
883 : # endif
884 : # ifdef HAVE_PTRDIFF_T
885 0 : case VALTYPE_PTRDIFF: along = value.a_ptrdiff; break;
886 : # endif
887 : #endif /*HAVE_LONG_LONG_INT*/
888 : default:
889 : return -1;
890 : }
891 233 : if (along < 0)
892 : {
893 34 : aulong = -along;
894 34 : signchar = '-';
895 : }
896 : else
897 199 : aulong = along;
898 : }
899 : else
900 : {
901 96 : switch (arg->vt)
902 : {
903 0 : case VALTYPE_USHORT: aulong = value.a_ushort; break;
904 96 : case VALTYPE_UINT: aulong = value.a_uint; break;
905 0 : case VALTYPE_ULONG: aulong = value.a_ulong; break;
906 : #ifdef HAVE_LONG_LONG_INT
907 0 : case VALTYPE_ULONGLONG: aulong = value.a_ulonglong; break;
908 0 : case VALTYPE_SIZE: aulong = value.a_size; break;
909 : # ifdef HAVE_UINTMAX_T
910 0 : case VALTYPE_UINTMAX: aulong = value.a_uintmax; break;
911 : # endif
912 : # ifdef HAVE_PTRDIFF_T
913 0 : case VALTYPE_PTRDIFF: aulong = value.a_ptrdiff; break;
914 : # endif
915 : #endif /*HAVE_LONG_LONG_INT*/
916 : default:
917 : return -1;
918 : }
919 : }
920 :
921 329 : if (signchar == '-')
922 : ;
923 295 : else if ((arg->flags & FLAG_PLUS_SIGN))
924 6 : signchar = '+';
925 289 : else if ((arg->flags & FLAG_SPACE_PLUS))
926 6 : signchar = ' ';
927 :
928 329 : n_extra = !!signchar;
929 :
930 : /* We build the string up backwards. */
931 : p = pend = numbuf + DIM(numbuf);
932 329 : if ((!aulong && !arg->precision))
933 : ;
934 321 : else if (arg->conspec == CONSPEC_DECIMAL
935 321 : || arg->conspec == CONSPEC_UNSIGNED)
936 : {
937 : int grouping = -1;
938 225 : const char * grouping_string =
939 : #ifdef HAVE_LANGINFO_THOUSANDS_SEP
940 : nl_langinfo(THOUSANDS_SEP);
941 : #else
942 : "'";
943 : #endif
944 :
945 : do
946 : {
947 454 : if ((arg->flags & FLAG_GROUPING)
948 0 : && (++grouping == 3) && *grouping_string)
949 : {
950 0 : *--p = *grouping_string;
951 : grouping = 0;
952 : }
953 454 : *--p = '0' + (aulong % 10);
954 454 : aulong /= 10;
955 : }
956 454 : while (aulong);
957 : }
958 96 : else if (arg->conspec == CONSPEC_OCTAL)
959 : {
960 : do
961 : {
962 64 : *--p = '0' + (aulong % 8);
963 64 : aulong /= 8;
964 : }
965 64 : while (aulong);
966 32 : if ((arg->flags & FLAG_ALT_CONV) && *p != '0')
967 16 : *--p = '0';
968 : }
969 : else /* HEX or HEXUP */
970 : {
971 64 : const char *digits = ((arg->conspec == CONSPEC_HEX)
972 : ? "0123456789abcdef" : "0123456789ABCDEF");
973 : do
974 : {
975 128 : *--p = digits[(aulong % 16)];
976 128 : aulong /= 16;
977 : }
978 128 : while (aulong);
979 64 : if ((arg->flags & FLAG_ALT_CONV))
980 32 : n_extra += 2;
981 : }
982 :
983 329 : n = pend - p;
984 :
985 329 : if ((arg->flags & FLAG_ZERO_PAD)
986 132 : && arg->precision == NO_FIELD_VALUE && !(arg->flags & FLAG_LEFT_JUST)
987 130 : && n && arg->width - n_extra > n )
988 67 : n_prec = arg->width - n_extra - n;
989 262 : else if (arg->precision > 0 && arg->precision > n)
990 60 : n_prec = arg->precision - n;
991 : else
992 : n_prec = 0;
993 :
994 329 : if (!(arg->flags & FLAG_LEFT_JUST)
995 267 : && arg->width >= 0 && arg->width - n_extra > n
996 139 : && arg->width - n_extra - n >= n_prec )
997 : {
998 133 : rc = pad_out (outfnc, outfncarg, ' ',
999 : arg->width - n_extra - n - n_prec, nbytes);
1000 133 : if (rc)
1001 : return rc;
1002 : }
1003 :
1004 329 : if (signchar)
1005 : {
1006 46 : rc = outfnc (outfncarg, &signchar, 1);
1007 46 : if (rc)
1008 : return rc;
1009 46 : *nbytes += 1;
1010 : }
1011 :
1012 329 : if ((arg->flags & FLAG_ALT_CONV)
1013 48 : && (arg->conspec == CONSPEC_HEX || arg->conspec == CONSPEC_HEX_UP))
1014 : {
1015 32 : rc = outfnc (outfncarg, arg->conspec == CONSPEC_HEX? "0x": "0X", 2);
1016 32 : if (rc)
1017 : return rc;
1018 32 : *nbytes += 2;
1019 : }
1020 :
1021 329 : if (n_prec)
1022 : {
1023 127 : rc = pad_out (outfnc, outfncarg, '0', n_prec, nbytes);
1024 127 : if (rc)
1025 : return rc;
1026 : }
1027 :
1028 329 : rc = outfnc (outfncarg, p, pend - p);
1029 329 : if (rc)
1030 : return rc;
1031 329 : *nbytes += pend - p;
1032 :
1033 329 : if ((arg->flags & FLAG_LEFT_JUST)
1034 62 : && arg->width >= 0 && arg->width - n_extra - n_prec > n)
1035 : {
1036 58 : rc = pad_out (outfnc, outfncarg, ' ',
1037 : arg->width - n_extra - n_prec - n, nbytes);
1038 58 : if (rc)
1039 0 : return rc;
1040 : }
1041 :
1042 : return 0;
1043 : }
1044 :
1045 :
1046 : /* "e,E,f,F,g,G,a,A" formatting. OUTFNC and OUTFNCARG describes the
1047 : output routine, ARG gives the argument description and VALUE the
1048 : actual value (its type is available through arg->vt). For
1049 : portability reasons sprintf is used for the actual formatting.
1050 : This is useful because sprint is the only standard function to
1051 : convert a floating number into its ascii representation. To avoid
1052 : using malloc we just pass the precision to sprintf and do the final
1053 : formatting with our own code. */
1054 : static int
1055 84 : pr_float (estream_printf_out_t outfnc, void *outfncarg,
1056 : argspec_t arg, value_t value, size_t *nbytes)
1057 : {
1058 : int rc;
1059 : #ifdef HAVE_LONG_DOUBLE
1060 : long double adblfloat = 0; /* Just to please gcc. */
1061 : int use_dbl = 0;
1062 : #endif
1063 : double afloat;
1064 : char numbuf[350];
1065 : char formatstr[20];
1066 : char *p, *pend;
1067 : size_t n;
1068 84 : char signchar = 0;
1069 : int n_extra; /* Extra number of prefix or sign characters. */
1070 :
1071 84 : switch (arg->vt)
1072 : {
1073 78 : case VALTYPE_DOUBLE: afloat = value.a_double; break;
1074 : #ifdef HAVE_LONG_DOUBLE
1075 : case VALTYPE_LONGDOUBLE:
1076 : afloat = 0; /* Just to please gcc. */
1077 6 : adblfloat = value.a_longdouble;
1078 6 : use_dbl=1; break;
1079 : #endif
1080 : default:
1081 : return -1;
1082 : }
1083 :
1084 : /* We build the string using sprint. */
1085 : p = formatstr + sizeof formatstr;
1086 84 : *--p = 0;
1087 84 : switch (arg->conspec)
1088 : {
1089 68 : case CONSPEC_FLOAT: *--p = 'f'; break;
1090 0 : case CONSPEC_FLOAT_UP: *--p = 'F'; break;
1091 2 : case CONSPEC_EXP: *--p = 'e'; break;
1092 0 : case CONSPEC_EXP_UP: *--p = 'E'; break;
1093 2 : case CONSPEC_F_OR_G: *--p = 'g'; break;
1094 0 : case CONSPEC_F_OR_G_UP: *--p = 'G'; break;
1095 12 : case CONSPEC_HEX_EXP: *--p = 'a'; break;
1096 0 : case CONSPEC_HEX_EXP_UP: *--p = 'A'; break;
1097 : default:
1098 : return -1; /* Actually a bug. */
1099 : }
1100 : #ifdef HAVE_LONG_DOUBLE
1101 84 : if (use_dbl)
1102 6 : *--p = 'L';
1103 : #endif
1104 84 : if (arg->precision != NO_FIELD_VALUE)
1105 : {
1106 : /* Limit it to a meaningful value so that even a stupid sprintf
1107 : won't overflow our buffer. */
1108 60 : n = arg->precision <= 100? arg->precision : 100;
1109 : do
1110 : {
1111 80 : *--p = '0' + (n % 10);
1112 80 : n /= 10;
1113 : }
1114 80 : while (n);
1115 60 : *--p = '.';
1116 : }
1117 84 : if ((arg->flags & FLAG_ALT_CONV))
1118 10 : *--p = '#';
1119 84 : *--p = '%';
1120 : #ifdef HAVE_LONG_DOUBLE
1121 84 : if (use_dbl)
1122 6 : sprintf (numbuf, p, adblfloat);
1123 : else
1124 : #endif /*HAVE_LONG_DOUBLE*/
1125 78 : sprintf (numbuf, p, afloat);
1126 : p = numbuf;
1127 84 : n = strlen (numbuf);
1128 84 : pend = p + n;
1129 :
1130 84 : if (*p =='-')
1131 : {
1132 32 : signchar = '-';
1133 : p++;
1134 32 : n--;
1135 : }
1136 52 : else if ((arg->flags & FLAG_PLUS_SIGN))
1137 0 : signchar = '+';
1138 52 : else if ((arg->flags & FLAG_SPACE_PLUS))
1139 0 : signchar = ' ';
1140 :
1141 84 : n_extra = !!signchar;
1142 :
1143 84 : if (!(arg->flags & FLAG_LEFT_JUST)
1144 56 : && arg->width >= 0 && arg->width - n_extra > n)
1145 : {
1146 20 : rc = pad_out (outfnc, outfncarg, ' ', arg->width - n_extra - n, nbytes);
1147 20 : if (rc)
1148 : return rc;
1149 : }
1150 :
1151 84 : if (signchar)
1152 : {
1153 32 : rc = outfnc (outfncarg, &signchar, 1);
1154 32 : if (rc)
1155 : return rc;
1156 32 : *nbytes += 1;
1157 : }
1158 :
1159 84 : rc = outfnc (outfncarg, p, pend - p);
1160 84 : if (rc)
1161 : return rc;
1162 84 : *nbytes += pend - p;
1163 :
1164 84 : if ((arg->flags & FLAG_LEFT_JUST)
1165 28 : && arg->width >= 0 && arg->width - n_extra > n)
1166 : {
1167 24 : rc = pad_out (outfnc, outfncarg, ' ', arg->width - n_extra - n, nbytes);
1168 24 : if (rc)
1169 0 : return rc;
1170 : }
1171 :
1172 : return 0;
1173 : }
1174 :
1175 :
1176 : /* "c" formatting. */
1177 : static int
1178 0 : pr_char (estream_printf_out_t outfnc, void *outfncarg,
1179 : argspec_t arg, value_t value, size_t *nbytes)
1180 : {
1181 : int rc;
1182 : char buf[1];
1183 :
1184 0 : if (arg->vt != VALTYPE_INT)
1185 : return -1;
1186 0 : buf[0] = (unsigned int)value.a_int;
1187 0 : rc = outfnc (outfncarg, buf, 1);
1188 0 : if(rc)
1189 : return rc;
1190 0 : *nbytes += 1;
1191 :
1192 0 : return 0;
1193 : }
1194 :
1195 :
1196 : /* "s" formatting. */
1197 : static int
1198 40 : pr_string (estream_printf_out_t outfnc, void *outfncarg,
1199 : argspec_t arg, value_t value, size_t *nbytes)
1200 : {
1201 : int rc;
1202 : size_t n;
1203 : const char *string, *s;
1204 :
1205 40 : if (arg->vt != VALTYPE_STRING)
1206 : return -1;
1207 40 : string = value.a_string;
1208 40 : if (!string)
1209 : string = "(null)";
1210 40 : if (arg->precision >= 0)
1211 : {
1212 : /* Test for nul after N so that we can pass a non-nul terminated
1213 : string. */
1214 410 : for (n=0,s=string; n < arg->precision && *s; s++)
1215 410 : n++;
1216 : }
1217 : else
1218 28 : n = strlen (string);
1219 :
1220 40 : if (!(arg->flags & FLAG_LEFT_JUST)
1221 38 : && arg->width >= 0 && arg->width > n )
1222 : {
1223 9 : rc = pad_out (outfnc, outfncarg, ' ', arg->width - n, nbytes);
1224 9 : if (rc)
1225 : return rc;
1226 : }
1227 :
1228 40 : rc = outfnc (outfncarg, string, n);
1229 40 : if (rc)
1230 : return rc;
1231 40 : *nbytes += n;
1232 :
1233 40 : if ((arg->flags & FLAG_LEFT_JUST)
1234 2 : && arg->width >= 0 && arg->width > n)
1235 : {
1236 2 : rc = pad_out (outfnc, outfncarg, ' ', arg->width - n, nbytes);
1237 2 : if (rc)
1238 0 : return rc;
1239 : }
1240 :
1241 : return 0;
1242 : }
1243 :
1244 :
1245 : /* "p" formatting. */
1246 : static int
1247 0 : pr_pointer (estream_printf_out_t outfnc, void *outfncarg,
1248 : argspec_t arg, value_t value, size_t *nbytes)
1249 : {
1250 : int rc;
1251 : #if defined(HAVE_LONG_LONG_INT) && (SIZEOF_UNSIGNED_LONG < SIZEOF_VOID_P)
1252 : unsigned long long aulong;
1253 : #else
1254 : unsigned long aulong;
1255 : #endif
1256 : char numbuf[100];
1257 : char *p, *pend;
1258 :
1259 0 : if (arg->vt != VALTYPE_POINTER)
1260 : return -1;
1261 : /* We assume that a pointer can be converted to an unsigned long.
1262 : That is not correct for a 64 bit Windows, but then we assume that
1263 : long long is supported and usable for storing a pointer. */
1264 : #if defined(HAVE_LONG_LONG_INT) && (SIZEOF_UNSIGNED_LONG < SIZEOF_VOID_P)
1265 : aulong = (unsigned long long)value.a_void_ptr;
1266 : #else
1267 0 : aulong = (unsigned long)value.a_void_ptr;
1268 : #endif
1269 :
1270 : p = pend = numbuf + DIM(numbuf);
1271 : do
1272 : {
1273 0 : *--p = "0123456789abcdefx"[(aulong % 16)];
1274 0 : aulong /= 16;
1275 : }
1276 0 : while (aulong);
1277 0 : while ((pend-p) < 2*sizeof (aulong))
1278 0 : *--p = '0';
1279 0 : *--p = 'x';
1280 0 : *--p = '0';
1281 :
1282 0 : rc = outfnc (outfncarg, p, pend - p);
1283 0 : if (rc)
1284 : return rc;
1285 0 : *nbytes += pend - p;
1286 :
1287 0 : return 0;
1288 : }
1289 :
1290 : /* "n" pesudo format operation. */
1291 : static int
1292 0 : pr_bytes_so_far (estream_printf_out_t outfnc, void *outfncarg,
1293 : argspec_t arg, value_t value, size_t *nbytes)
1294 : {
1295 : (void)outfnc;
1296 : (void)outfncarg;
1297 :
1298 0 : switch (arg->vt)
1299 : {
1300 : case VALTYPE_SCHAR_PTR:
1301 0 : *value.a_schar_ptr = (signed char)(unsigned int)(*nbytes);
1302 0 : break;
1303 : case VALTYPE_SHORT_PTR:
1304 0 : *value.a_short_ptr = (short)(unsigned int)(*nbytes);
1305 0 : break;
1306 : case VALTYPE_LONG_PTR:
1307 0 : *value.a_long_ptr = (long)(*nbytes);
1308 0 : break;
1309 : #ifdef HAVE_LONG_LONG_INT
1310 : case VALTYPE_LONGLONG_PTR:
1311 0 : *value.a_longlong_ptr = (long long)(*nbytes);
1312 0 : break;
1313 : #endif
1314 : #ifdef HAVE_INTMAX_T
1315 : case VALTYPE_INTMAX_PTR:
1316 0 : *value.a_intmax_ptr = (intmax_t)(*nbytes);
1317 0 : break;
1318 : #endif
1319 : case VALTYPE_SIZE_PTR:
1320 0 : *value.a_size_ptr = (*nbytes);
1321 0 : break;
1322 : #ifdef HAVE_PTRDIFF_T
1323 : case VALTYPE_PTRDIFF_PTR:
1324 0 : *value.a_ptrdiff_ptr = (ptrdiff_t)(*nbytes);
1325 0 : break;
1326 : #endif
1327 : case VALTYPE_INT_PTR:
1328 0 : *value.a_int_ptr = (int)(*nbytes);
1329 0 : break;
1330 : default:
1331 : return -1; /* An unsupported type has been used. */
1332 : }
1333 :
1334 : return 0;
1335 : }
1336 :
1337 :
1338 :
1339 : /* Run the actual formatting. OUTFNC and OUTFNCARG are the output
1340 : functions. FORMAT is format string ARGSPECS is the parsed format
1341 : string, ARGSPECS_LEN the number of items in ARGSPECS. VALUETABLE
1342 : holds the values and may be directly addressed using the position
1343 : arguments given by ARGSPECS. MYERRNO is used for the "%m"
1344 : conversion. NBYTES well be updated to reflect the number of bytes
1345 : send to the output function. */
1346 : static int
1347 335 : do_format (estream_printf_out_t outfnc, void *outfncarg,
1348 : const char *format, argspec_t argspecs, size_t argspecs_len,
1349 : valueitem_t valuetable, int myerrno, size_t *nbytes)
1350 : {
1351 : int rc = 0;
1352 : const char *s;
1353 : argspec_t arg = argspecs;
1354 : int argidx = 0; /* Only used for assertion. */
1355 : size_t n;
1356 : value_t value;
1357 :
1358 : s = format;
1359 1220 : while ( *s )
1360 : {
1361 550 : if (*s != '%')
1362 : {
1363 93 : s++;
1364 93 : continue;
1365 : }
1366 457 : if (s != format)
1367 : {
1368 43 : rc = outfnc (outfncarg, format, (n=s-format));
1369 43 : if (rc)
1370 0 : return rc;
1371 43 : *nbytes += n;
1372 : }
1373 457 : if (s[1] == '%')
1374 : {
1375 : /* Note that this code ignores one trailing percent escape -
1376 : this is however okay as the args parser must have
1377 : detected this already. */
1378 4 : rc = outfnc (outfncarg, s, 1);
1379 4 : if (rc)
1380 0 : return rc;
1381 4 : *nbytes += 1;
1382 4 : s += 2;
1383 : format = s;
1384 4 : continue;
1385 : }
1386 :
1387 : /* Save the next start. */
1388 453 : s += arg->length;
1389 : format = s;
1390 :
1391 453 : assert (argidx < argspecs_len);
1392 453 : argidx++;
1393 :
1394 : /* Apply indirect field width and precision values. */
1395 453 : if (arg->width == STAR_FIELD_VALUE)
1396 : {
1397 89 : assert (valuetable[arg->width_pos-1].vt == VALTYPE_INT);
1398 89 : arg->width = valuetable[arg->width_pos-1].value.a_int;
1399 89 : if (arg->width < 0)
1400 : {
1401 42 : arg->width = -arg->width;
1402 42 : arg->flags |= FLAG_LEFT_JUST;
1403 : }
1404 : }
1405 453 : if (arg->precision == STAR_FIELD_VALUE)
1406 : {
1407 84 : assert (valuetable[arg->precision_pos-1].vt == VALTYPE_INT);
1408 84 : arg->precision = valuetable[arg->precision_pos-1].value.a_int;
1409 84 : if (arg->precision < 0)
1410 42 : arg->precision = NO_FIELD_VALUE;
1411 : }
1412 :
1413 453 : if (arg->arg_pos == -1 && arg->conspec == CONSPEC_STRERROR)
1414 6 : value.a_string = strerror (myerrno);
1415 : else
1416 : {
1417 447 : assert (arg->vt == valuetable[arg->arg_pos-1].vt);
1418 447 : value = valuetable[arg->arg_pos-1].value;
1419 : }
1420 :
1421 453 : switch (arg->conspec)
1422 : {
1423 0 : case CONSPEC_UNKNOWN: assert (!"bug"); break;
1424 :
1425 : case CONSPEC_DECIMAL:
1426 : case CONSPEC_UNSIGNED:
1427 : case CONSPEC_OCTAL:
1428 : case CONSPEC_HEX:
1429 : case CONSPEC_HEX_UP:
1430 329 : rc = pr_integer (outfnc, outfncarg, arg, value, nbytes);
1431 329 : break;
1432 : case CONSPEC_FLOAT:
1433 : case CONSPEC_FLOAT_UP:
1434 : case CONSPEC_EXP:
1435 : case CONSPEC_EXP_UP:
1436 : case CONSPEC_F_OR_G:
1437 : case CONSPEC_F_OR_G_UP:
1438 : case CONSPEC_HEX_EXP:
1439 : case CONSPEC_HEX_EXP_UP:
1440 84 : rc = pr_float (outfnc, outfncarg, arg, value, nbytes);
1441 84 : break;
1442 : case CONSPEC_CHAR:
1443 : rc = pr_char (outfnc, outfncarg, arg, value, nbytes);
1444 0 : break;
1445 : case CONSPEC_STRING:
1446 : case CONSPEC_STRERROR:
1447 40 : rc = pr_string (outfnc, outfncarg, arg, value, nbytes);
1448 40 : break;
1449 : case CONSPEC_POINTER:
1450 0 : rc = pr_pointer (outfnc, outfncarg, arg, value, nbytes);
1451 0 : break;
1452 : case CONSPEC_BYTES_SO_FAR:
1453 0 : rc = pr_bytes_so_far (outfnc, outfncarg, arg, value, nbytes);
1454 0 : break;
1455 : }
1456 453 : if (rc)
1457 0 : return rc;
1458 453 : arg++;
1459 : }
1460 :
1461 : /* Print out any trailing stuff. */
1462 335 : n = s - format;
1463 335 : rc = n? outfnc (outfncarg, format, n) : 0;
1464 335 : if (!rc)
1465 335 : *nbytes += n;
1466 :
1467 335 : return rc;
1468 : }
1469 :
1470 :
1471 :
1472 :
1473 : /* The versatile printf formatting routine. It expects a callback
1474 : function OUTFNC and an opaque argument OUTFNCARG used for actual
1475 : output of the formatted stuff. FORMAT is the format specification
1476 : and VAARGS a variable argumemt list matching the arguments of
1477 : FORMAT. */
1478 : int
1479 335 : _gpgrt_estream_format (estream_printf_out_t outfnc,
1480 : void *outfncarg,
1481 : const char *format, va_list vaargs)
1482 : {
1483 : /* Buffer to hold the argspecs and a pointer to it.*/
1484 : struct argspec_s argspecs_buffer[DEFAULT_MAX_ARGSPECS];
1485 335 : argspec_t argspecs = argspecs_buffer;
1486 : size_t argspecs_len; /* Number of specifications in ARGSPECS. */
1487 :
1488 : /* Buffer to hold the description for the values. */
1489 : struct valueitem_s valuetable_buffer[DEFAULT_MAX_VALUES];
1490 : valueitem_t valuetable = valuetable_buffer;
1491 :
1492 : int rc; /* Return code. */
1493 : size_t argidx; /* Used to index the argspecs array. */
1494 : size_t validx; /* Used to index the valuetable. */
1495 : int max_pos;/* Highest argument position. */
1496 :
1497 335 : size_t nbytes = 0; /* Keep track of the number of bytes passed to
1498 : the output function. */
1499 :
1500 335 : int myerrno = errno; /* Save the errno for use with "%m". */
1501 :
1502 :
1503 : /* Parse the arguments to come up with descriptive list. We can't
1504 : do this on the fly because we need to support positional
1505 : arguments. */
1506 335 : rc = parse_format (format, &argspecs, DIM(argspecs_buffer), &argspecs_len);
1507 335 : if (rc)
1508 : goto leave;
1509 :
1510 : /* Check that all ARG_POS fields are set. */
1511 453 : for (argidx=0,max_pos=0; argidx < argspecs_len; argidx++)
1512 : {
1513 453 : if (argspecs[argidx].arg_pos != -1
1514 447 : && argspecs[argidx].arg_pos > max_pos)
1515 : max_pos = argspecs[argidx].arg_pos;
1516 453 : if (argspecs[argidx].width_pos > max_pos)
1517 : max_pos = argspecs[argidx].width_pos;
1518 453 : if (argspecs[argidx].precision_pos > max_pos)
1519 : max_pos = argspecs[argidx].precision_pos;
1520 : }
1521 335 : if (!max_pos)
1522 : {
1523 : /* Fill in all the positions. */
1524 447 : for (argidx=0; argidx < argspecs_len; argidx++)
1525 : {
1526 447 : if (argspecs[argidx].width == STAR_FIELD_VALUE)
1527 89 : argspecs[argidx].width_pos = ++max_pos;
1528 447 : if (argspecs[argidx].precision == STAR_FIELD_VALUE)
1529 84 : argspecs[argidx].precision_pos = ++max_pos;
1530 447 : if (argspecs[argidx].arg_pos != -1 )
1531 443 : argspecs[argidx].arg_pos = ++max_pos;
1532 : }
1533 : }
1534 : else
1535 : {
1536 : /* Check that they are all filled. More test are done later. */
1537 6 : for (argidx=0; argidx < argspecs_len; argidx++)
1538 : {
1539 6 : if (!argspecs[argidx].arg_pos
1540 6 : || (argspecs[argidx].width == STAR_FIELD_VALUE
1541 0 : && !argspecs[argidx].width_pos)
1542 6 : || (argspecs[argidx].precision == STAR_FIELD_VALUE
1543 0 : && !argspecs[argidx].precision_pos))
1544 : goto leave_einval;
1545 : }
1546 : }
1547 : /* Check that there is no overflow in max_pos and that it has a
1548 : reasonable length. There may never be more elements than the
1549 : number of characters in FORMAT. */
1550 335 : if (max_pos < 0 || max_pos >= strlen (format))
1551 : goto leave_einval;
1552 :
1553 : #ifdef DEBUG
1554 : dump_argspecs (argspecs, argspecs_len);
1555 : #endif
1556 :
1557 : /* Allocate a table to hold the values. If it is small enough we
1558 : use a stack allocated buffer. */
1559 335 : if (max_pos > DIM(valuetable_buffer))
1560 : {
1561 0 : valuetable = calloc (max_pos, sizeof *valuetable);
1562 0 : if (!valuetable)
1563 : goto leave_error;
1564 : }
1565 : else
1566 : {
1567 2680 : for (validx=0; validx < DIM(valuetable_buffer); validx++)
1568 2680 : valuetable[validx].vt = VALTYPE_UNSUPPORTED;
1569 : }
1570 788 : for (argidx=0; argidx < argspecs_len; argidx++)
1571 : {
1572 453 : if (argspecs[argidx].arg_pos != - 1)
1573 : {
1574 447 : validx = argspecs[argidx].arg_pos - 1;
1575 447 : if (valuetable[validx].vt)
1576 : goto leave_einval; /* Already defined. */
1577 447 : valuetable[validx].vt = argspecs[argidx].vt;
1578 : }
1579 453 : if (argspecs[argidx].width == STAR_FIELD_VALUE)
1580 : {
1581 89 : validx = argspecs[argidx].width_pos - 1;
1582 89 : if (valuetable[validx].vt)
1583 : goto leave_einval; /* Already defined. */
1584 89 : valuetable[validx].vt = VALTYPE_INT;
1585 : }
1586 453 : if (argspecs[argidx].precision == STAR_FIELD_VALUE)
1587 : {
1588 84 : validx = argspecs[argidx].precision_pos - 1;
1589 84 : if (valuetable[validx].vt)
1590 : goto leave_einval; /* Already defined. */
1591 84 : valuetable[validx].vt = VALTYPE_INT;
1592 : }
1593 : }
1594 :
1595 : /* Read all the arguments. This will error out for unsupported
1596 : types and for not given positional arguments. */
1597 335 : rc = read_values (valuetable, max_pos, vaargs);
1598 335 : if (rc)
1599 : goto leave_einval;
1600 :
1601 : /* for (validx=0; validx < max_pos; validx++) */
1602 : /* fprintf (stderr, "%2d: vt=%d\n", validx, valuetable[validx].vt); */
1603 :
1604 : /* Everything has been collected, go ahead with the formatting. */
1605 335 : rc = do_format (outfnc, outfncarg, format,
1606 : argspecs, argspecs_len, valuetable, myerrno, &nbytes);
1607 :
1608 335 : goto leave;
1609 :
1610 : leave_einval:
1611 0 : _set_errno (EINVAL);
1612 : leave_error:
1613 : rc = -1;
1614 : leave:
1615 335 : if (valuetable != valuetable_buffer)
1616 0 : free (valuetable);
1617 335 : if (argspecs != argspecs_buffer)
1618 21 : free (argspecs);
1619 335 : return rc;
1620 : }
1621 :
1622 :
1623 :
1624 :
1625 : /* A simple output handler utilizing stdio. */
1626 : static int
1627 0 : plain_stdio_out (void *outfncarg, const char *buf, size_t buflen)
1628 : {
1629 : FILE *fp = (FILE*)outfncarg;
1630 :
1631 0 : if ( fwrite (buf, buflen, 1, fp) != 1 )
1632 : return -1;
1633 0 : return 0;
1634 : }
1635 :
1636 :
1637 : /* A replacement for printf. */
1638 : int
1639 0 : _gpgrt_estream_printf (const char *format, ...)
1640 : {
1641 : int rc;
1642 : va_list arg_ptr;
1643 :
1644 0 : va_start (arg_ptr, format);
1645 0 : rc = _gpgrt_estream_format (plain_stdio_out, stderr, format, arg_ptr);
1646 0 : va_end (arg_ptr);
1647 :
1648 0 : return rc;
1649 : }
1650 :
1651 : /* A replacement for fprintf. */
1652 : int
1653 0 : _gpgrt_estream_fprintf (FILE *fp, const char *format, ...)
1654 : {
1655 : int rc;
1656 : va_list arg_ptr;
1657 :
1658 0 : va_start (arg_ptr, format);
1659 0 : rc = _gpgrt_estream_format (plain_stdio_out, fp, format, arg_ptr);
1660 0 : va_end (arg_ptr);
1661 :
1662 0 : return rc;
1663 : }
1664 :
1665 : /* A replacement for vfprintf. */
1666 : int
1667 0 : _gpgrt_estream_vfprintf (FILE *fp, const char *format, va_list arg_ptr)
1668 : {
1669 0 : return _gpgrt_estream_format (plain_stdio_out, fp, format, arg_ptr);
1670 : }
1671 :
1672 :
1673 :
1674 : /* Communication object used between estream_snprintf and
1675 : fixed_buffer_out. */
1676 : struct fixed_buffer_parm_s
1677 : {
1678 : size_t size; /* Size of the buffer. */
1679 : size_t count; /* Number of bytes requested for output. */
1680 : size_t used; /* Used size of the buffer. */
1681 : char *buffer; /* Provided buffer. */
1682 : };
1683 :
1684 : /* A simple malloced buffer output handler. */
1685 : static int
1686 246 : fixed_buffer_out (void *outfncarg, const char *buf, size_t buflen)
1687 : {
1688 : struct fixed_buffer_parm_s *parm = outfncarg;
1689 :
1690 246 : parm->count += buflen;
1691 :
1692 246 : if (!parm->buffer)
1693 : ;
1694 232 : else if (parm->used + buflen < parm->size)
1695 : {
1696 : /* Handle the common case that everything fits into the buffer
1697 : separately. */
1698 117 : memcpy (parm->buffer + parm->used, buf, buflen);
1699 117 : parm->used += buflen;
1700 : }
1701 : else
1702 : {
1703 : /* The slow version of above. */
1704 65 : for ( ;buflen && parm->used < parm->size; buflen--)
1705 65 : parm->buffer[parm->used++] = *buf++;
1706 : }
1707 :
1708 246 : return 0;
1709 : }
1710 :
1711 :
1712 : /* A replacement for vsnprintf. */
1713 : int
1714 26 : _gpgrt_estream_vsnprintf (char *buf, size_t bufsize,
1715 : const char *format, va_list arg_ptr)
1716 : {
1717 : struct fixed_buffer_parm_s parm;
1718 : int rc;
1719 :
1720 26 : parm.size = bufsize;
1721 26 : parm.count = 0;
1722 26 : parm.used = 0;
1723 26 : parm.buffer = bufsize?buf:NULL;
1724 26 : rc = _gpgrt_estream_format (fixed_buffer_out, &parm, format, arg_ptr);
1725 26 : if (!rc)
1726 26 : rc = fixed_buffer_out (&parm, "", 1); /* Print terminating Nul. */
1727 26 : if (rc == -1)
1728 : return -1;
1729 26 : if (bufsize && buf && parm.size && parm.count >= parm.size)
1730 19 : buf[parm.size-1] = 0;
1731 :
1732 26 : parm.count--; /* Do not count the trailing nul. */
1733 26 : return (int)parm.count; /* Return number of bytes which would have
1734 : been written. */
1735 : }
1736 :
1737 : /* A replacement for snprintf. */
1738 : int
1739 0 : _gpgrt_estream_snprintf (char *buf, size_t bufsize, const char *format, ...)
1740 : {
1741 : int rc;
1742 : va_list arg_ptr;
1743 :
1744 0 : va_start (arg_ptr, format);
1745 0 : rc = _gpgrt_estream_vsnprintf (buf, bufsize, format, arg_ptr);
1746 0 : va_end (arg_ptr);
1747 :
1748 0 : return rc;
1749 : }
1750 :
1751 :
1752 :
1753 : /* Communication object used between estream_asprintf and
1754 : dynamic_buffer_out. */
1755 : struct dynamic_buffer_parm_s
1756 : {
1757 : int error_flag; /* Internal helper. */
1758 : size_t alloced; /* Allocated size of the buffer. */
1759 : size_t used; /* Used size of the buffer. */
1760 : char *buffer; /* Malloced buffer. */
1761 : };
1762 :
1763 : /* A simple malloced buffer output handler. */
1764 : static int
1765 1006 : dynamic_buffer_out (void *outfncarg, const char *buf, size_t buflen)
1766 : {
1767 : struct dynamic_buffer_parm_s *parm = outfncarg;
1768 :
1769 1006 : if (parm->error_flag)
1770 : {
1771 : /* Just in case some formatting routine did not checked for an
1772 : error. */
1773 0 : _set_errno (parm->error_flag);
1774 0 : return -1;
1775 : }
1776 :
1777 1006 : if (parm->used + buflen >= parm->alloced)
1778 : {
1779 : char *p;
1780 :
1781 0 : parm->alloced += buflen + 512;
1782 0 : p = my_printf_realloc (parm->buffer, parm->alloced);
1783 0 : if (!p)
1784 : {
1785 0 : parm->error_flag = errno ? errno : ENOMEM;
1786 : /* Wipe out what we already accumulated. This is useful in
1787 : case sensitive data is formated. */
1788 0 : memset (parm->buffer, 0, parm->used);
1789 0 : return -1;
1790 : }
1791 0 : parm->buffer = p;
1792 : }
1793 1006 : memcpy (parm->buffer + parm->used, buf, buflen);
1794 1006 : parm->used += buflen;
1795 :
1796 1006 : return 0;
1797 : }
1798 :
1799 :
1800 : /* A replacement for vasprintf. As with the BSD version of vasprintf
1801 : -1 will be returned on error and NULL stored at BUFP. On success
1802 : the number of bytes printed will be returned. */
1803 : int
1804 306 : _gpgrt_estream_vasprintf (char **bufp, const char *format, va_list arg_ptr)
1805 : {
1806 : struct dynamic_buffer_parm_s parm;
1807 : int rc;
1808 :
1809 306 : parm.error_flag = 0;
1810 306 : parm.alloced = 512;
1811 306 : parm.used = 0;
1812 306 : parm.buffer = my_printf_realloc (NULL, parm.alloced);
1813 306 : if (!parm.buffer)
1814 : {
1815 0 : *bufp = NULL;
1816 0 : return -1;
1817 : }
1818 :
1819 306 : rc = _gpgrt_estream_format (dynamic_buffer_out, &parm, format, arg_ptr);
1820 306 : if (!rc)
1821 306 : rc = dynamic_buffer_out (&parm, "", 1); /* Print terminating Nul. */
1822 : /* Fixme: Should we shrink the resulting buffer? */
1823 306 : if (rc != -1 && parm.error_flag)
1824 : {
1825 : rc = -1;
1826 0 : _set_errno (parm.error_flag);
1827 : }
1828 306 : if (rc == -1)
1829 : {
1830 0 : memset (parm.buffer, 0, parm.used);
1831 0 : if (parm.buffer)
1832 0 : my_printf_realloc (parm.buffer, 0);
1833 0 : *bufp = NULL;
1834 0 : return -1;
1835 : }
1836 306 : assert (parm.used); /* We have at least the terminating Nul. */
1837 306 : *bufp = parm.buffer;
1838 306 : return parm.used - 1; /* Do not include that Nul. */
1839 : }
1840 :
1841 : /* A replacement for asprintf. As with the BSD of asprintf version -1
1842 : will be returned on error and NULL stored at BUFP. On success the
1843 : number of bytes printed will be returned. */
1844 : int
1845 0 : _gpgrt_estream_asprintf (char **bufp, const char *format, ...)
1846 : {
1847 : int rc;
1848 : va_list arg_ptr;
1849 :
1850 0 : va_start (arg_ptr, format);
1851 0 : rc = _gpgrt_estream_vasprintf (bufp, format, arg_ptr);
1852 0 : va_end (arg_ptr);
1853 :
1854 0 : return rc;
1855 : }
1856 :
1857 : /* A variant of asprintf. The function returns the allocated buffer
1858 : or NULL on error; ERRNO is set in the error case. The caller
1859 : should use es_free to release the buffer. This function actually
1860 : belongs into estream-printf but we put it here as a convenience
1861 : and because es_free is required anyway. */
1862 : char *
1863 0 : _gpgrt_estream_bsprintf (const char *format, ...)
1864 : {
1865 : int rc;
1866 : va_list ap;
1867 : char *buf;
1868 :
1869 0 : va_start (ap, format);
1870 0 : rc = _gpgrt_estream_vasprintf (&buf, format, ap);
1871 0 : va_end (ap);
1872 0 : if (rc < 0)
1873 : return NULL;
1874 0 : return buf;
1875 : }
|
