LCOV - code coverage report
Current view: top level - src - visibility.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 65 234 27.8 %
Date: 2016-09-12 12:50:44 Functions: 27 97 27.8 %

          Line data    Source code
       1             : /* visibility.c - Wrapper for all public functions.
       2             :  * Copyright (C) 2014  g10 Code GmbH
       3             :  *
       4             :  * This file is part of libgpg-error.
       5             :  *
       6             :  * libgpg-error is free software; you can redistribute it and/or
       7             :  * modify it under the terms of the GNU Lesser General Public License
       8             :  * as published by the Free Software Foundation; either version 2.1 of
       9             :  * the License, or (at your option) any later version.
      10             :  *
      11             :  * libgpg-error 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 this program; if not, see <https://www.gnu.org/licenses/>.
      18             :  */
      19             : 
      20             : #include <config.h>
      21             : #include <stdarg.h>
      22             : 
      23             : #define _GPGRT_INCL_BY_VISIBILITY_C 1
      24             : #include "gpgrt-int.h"
      25             : 
      26             : const char *
      27           9 : gpg_strerror (gpg_error_t err)
      28             : {
      29           9 :   return _gpg_strerror (err);
      30             : }
      31             : 
      32             : int
      33           0 : gpg_strerror_r (gpg_error_t err, char *buf, size_t buflen)
      34             : {
      35           0 :   return _gpg_strerror_r (err, buf, buflen);
      36             : }
      37             : 
      38             : const char *
      39           9 : gpg_strsource (gpg_error_t err)
      40             : {
      41           9 :   return _gpg_strsource (err);
      42             : }
      43             : 
      44             : gpg_err_code_t
      45           2 : gpg_err_code_from_errno (int err)
      46             : {
      47           2 :   return _gpg_err_code_from_errno (err);
      48             : }
      49             : 
      50             : int
      51           0 : gpg_err_code_to_errno (gpg_err_code_t code)
      52             : {
      53           0 :   return _gpg_err_code_to_errno (code);
      54             : }
      55             : 
      56             : gpg_err_code_t
      57           2 : gpg_err_code_from_syserror (void)
      58             : {
      59           2 :   return _gpg_err_code_from_syserror ();
      60             : }
      61             : 
      62             : void
      63           1 : gpg_err_set_errno (int err)
      64             : {
      65           1 :   _gpg_err_set_errno (err);
      66           1 : }
      67             : 
      68             : 
      69             : gpg_error_t
      70           6 : gpg_err_init (void)
      71             : {
      72           6 :   return _gpg_err_init ();
      73             : }
      74             : 
      75             : void
      76           0 : gpg_err_deinit (int mode)
      77             : {
      78           0 :   _gpg_err_deinit (mode);
      79           0 : }
      80             : 
      81             : const char *
      82           6 : gpg_error_check_version (const char *req_version)
      83             : {
      84           6 :   return _gpg_error_check_version (req_version);
      85             : }
      86             : 
      87             : const char *
      88           0 : gpgrt_check_version (const char *req_version)
      89             : {
      90           0 :   return _gpg_error_check_version (req_version);
      91             : }
      92             : 
      93             : void
      94           0 : gpgrt_set_syscall_clamp (void (*pre)(void), void (*post)(void))
      95             : {
      96           0 :   _gpgrt_set_syscall_clamp (pre, post);
      97           0 : }
      98             : 
      99             : void
     100           0 : gpgrt_set_alloc_func (void *(*f)(void *a, size_t n))
     101             : {
     102           0 :   _gpgrt_set_alloc_func (f);
     103           0 : }
     104             : 
     105             : 
     106             : gpg_err_code_t
     107           1 : gpgrt_lock_init (gpgrt_lock_t *lockhd)
     108             : {
     109           1 :   return _gpgrt_lock_init (lockhd);
     110             : }
     111             : 
     112             : gpg_err_code_t
     113       19314 : gpgrt_lock_lock (gpgrt_lock_t *lockhd)
     114             : {
     115       19314 :   return _gpgrt_lock_lock (lockhd);
     116             : }
     117             : 
     118             : gpg_err_code_t
     119           0 : gpgrt_lock_trylock (gpgrt_lock_t *lockhd)
     120             : {
     121           0 :   return _gpgrt_lock_trylock (lockhd);
     122             : }
     123             : 
     124             : gpg_err_code_t
     125       19777 : gpgrt_lock_unlock (gpgrt_lock_t *lockhd)
     126             : {
     127       19777 :   return _gpgrt_lock_unlock (lockhd);
     128             : }
     129             : 
     130             : gpg_err_code_t
     131           3 : gpgrt_lock_destroy (gpgrt_lock_t *lockhd)
     132             : {
     133           3 :   return _gpgrt_lock_destroy (lockhd);
     134             : }
     135             : 
     136             : gpg_err_code_t
     137        2533 : gpgrt_yield (void)
     138             : {
     139        2533 :   return _gpgrt_yield ();
     140             : }
     141             : 
     142             : 
     143             : 
     144             : estream_t
     145           0 : gpgrt_fopen (const char *_GPGRT__RESTRICT path,
     146             :              const char *_GPGRT__RESTRICT mode)
     147             : {
     148           0 :   return _gpgrt_fopen (path, mode);
     149             : }
     150             : 
     151             : estream_t
     152           0 : gpgrt_mopen (void *_GPGRT__RESTRICT data, size_t data_n, size_t data_len,
     153             :              unsigned int grow,
     154             :              void *(*func_realloc) (void *mem, size_t size),
     155             :              void (*func_free) (void *mem),
     156             :              const char *_GPGRT__RESTRICT mode)
     157             : {
     158           0 :   return _gpgrt_mopen (data, data_n, data_len, grow, func_realloc, func_free,
     159             :                        mode);
     160             : }
     161             : 
     162             : estream_t
     163           0 : gpgrt_fopenmem (size_t memlimit, const char *_GPGRT__RESTRICT mode)
     164             : {
     165           0 :   return _gpgrt_fopenmem (memlimit, mode);
     166             : }
     167             : 
     168             : estream_t
     169           0 : gpgrt_fopenmem_init (size_t memlimit, const char *_GPGRT__RESTRICT mode,
     170             :                      const void *data, size_t datalen)
     171             : {
     172           0 :   return _gpgrt_fopenmem_init (memlimit, mode, data, datalen);
     173             : }
     174             : 
     175             : estream_t
     176           6 : gpgrt_fdopen (int filedes, const char *mode)
     177             : {
     178           6 :   return _gpgrt_fdopen (filedes, mode);
     179             : }
     180             : 
     181             : estream_t
     182           0 : gpgrt_fdopen_nc (int filedes, const char *mode)
     183             : {
     184           0 :   return _gpgrt_fdopen_nc (filedes, mode);
     185             : }
     186             : 
     187             : estream_t
     188           0 : gpgrt_sysopen (es_syshd_t *syshd, const char *mode)
     189             : {
     190           0 :   return _gpgrt_sysopen (syshd, mode);
     191             : }
     192             : 
     193             : estream_t
     194           0 : gpgrt_sysopen_nc (es_syshd_t *syshd, const char *mode)
     195             : {
     196           0 :   return _gpgrt_sysopen_nc (syshd, mode);
     197             : }
     198             : 
     199             : estream_t
     200           0 : gpgrt_fpopen (FILE *fp, const char *mode)
     201             : {
     202           0 :   return _gpgrt_fpopen (fp, mode);
     203             : }
     204             : 
     205             : estream_t
     206           0 : gpgrt_fpopen_nc (FILE *fp, const char *mode)
     207             : {
     208           0 :   return _gpgrt_fpopen_nc (fp, mode);
     209             : }
     210             : 
     211             : estream_t
     212           0 : gpgrt_freopen (const char *_GPGRT__RESTRICT path,
     213             :                const char *_GPGRT__RESTRICT mode,
     214             :                estream_t _GPGRT__RESTRICT stream)
     215             : {
     216           0 :   return _gpgrt_freopen (path, mode, stream);
     217             : }
     218             : 
     219             : estream_t
     220           0 : gpgrt_fopencookie (void *_GPGRT__RESTRICT cookie,
     221             :                    const char *_GPGRT__RESTRICT mode,
     222             :                    gpgrt_cookie_io_functions_t functions)
     223             : {
     224           0 :   return _gpgrt_fopencookie (cookie, mode, functions);
     225             : }
     226             : 
     227             : int
     228           6 : gpgrt_fclose (estream_t stream)
     229             : {
     230           6 :   return _gpgrt_fclose (stream);
     231             : }
     232             : 
     233             : int
     234           0 : gpgrt_fclose_snatch (estream_t stream, void **r_buffer, size_t *r_buflen)
     235             : {
     236           0 :   return _gpgrt_fclose_snatch (stream, r_buffer, r_buflen);
     237             : }
     238             : 
     239             : int
     240           0 : gpgrt_onclose (estream_t stream, int mode,
     241             :                void (*fnc) (estream_t, void*), void *fnc_value)
     242             : {
     243           0 :   return _gpgrt_onclose (stream, mode, fnc, fnc_value);
     244             : }
     245             : 
     246             : int
     247           3 : gpgrt_fileno (estream_t stream)
     248             : {
     249           3 :   return _gpgrt_fileno (stream);
     250             : }
     251             : 
     252             : int
     253           0 : gpgrt_fileno_unlocked (estream_t stream)
     254             : {
     255           0 :   return _gpgrt_fileno_unlocked (stream);
     256             : }
     257             : 
     258             : int
     259           0 : gpgrt_syshd (estream_t stream, es_syshd_t *syshd)
     260             : {
     261           0 :   return _gpgrt_syshd (stream, syshd);
     262             : }
     263             : 
     264             : int
     265           0 : gpgrt_syshd_unlocked (estream_t stream, es_syshd_t *syshd)
     266             : {
     267           0 :   return _gpgrt_syshd_unlocked (stream, syshd);
     268             : }
     269             : 
     270             : void
     271           0 : _gpgrt_set_std_fd (int no, int fd)
     272             : {
     273           0 :   _gpgrt__set_std_fd (no, fd);  /* (double dash in name) */
     274           0 : }
     275             : 
     276             : estream_t
     277           0 : _gpgrt_get_std_stream (int fd)
     278             : {
     279           0 :   return _gpgrt__get_std_stream (fd);  /* (double dash in name) */
     280             : }
     281             : 
     282             : void
     283           0 : gpgrt_flockfile (estream_t stream)
     284             : {
     285           0 :   _gpgrt_flockfile (stream);
     286           0 : }
     287             : 
     288             : int
     289           0 : gpgrt_ftrylockfile (estream_t stream)
     290             : {
     291           0 :   return _gpgrt_ftrylockfile (stream);
     292             : }
     293             : 
     294             : void
     295           0 : gpgrt_funlockfile (estream_t stream)
     296             : {
     297           0 :   _gpgrt_funlockfile (stream);
     298           0 : }
     299             : 
     300             : int
     301           0 : _gpgrt_pending (estream_t stream)
     302             : {
     303           0 :   return _gpgrt__pending (stream);
     304             : }
     305             : 
     306             : int
     307           0 : _gpgrt_pending_unlocked (estream_t stream)
     308             : {
     309           0 :   return _gpgrt__pending_unlocked (stream);
     310             : }
     311             : 
     312             : int
     313           1 : gpgrt_feof (estream_t stream)
     314             : {
     315           1 :   return _gpgrt_feof (stream);
     316             : }
     317             : 
     318             : int
     319           0 : gpgrt_feof_unlocked (estream_t stream)
     320             : {
     321           0 :   return _gpgrt_feof_unlocked (stream);
     322             : }
     323             : 
     324             : int
     325           0 : gpgrt_ferror (estream_t stream)
     326             : {
     327           0 :   return _gpgrt_ferror (stream);
     328             : }
     329             : 
     330             : int
     331           0 : gpgrt_ferror_unlocked (estream_t stream)
     332             : {
     333           0 :   return _gpgrt_ferror_unlocked (stream);
     334             : }
     335             : 
     336             : void
     337           0 : gpgrt_clearerr (estream_t stream)
     338             : {
     339           0 :   _gpgrt_clearerr (stream);
     340           0 : }
     341             : 
     342             : void
     343           0 : gpgrt_clearerr_unlocked (estream_t stream)
     344             : {
     345           0 :   _gpgrt_clearerr_unlocked (stream);
     346           0 : }
     347             : 
     348             : int
     349          10 : gpgrt_fflush (estream_t stream)
     350             : {
     351          10 :   return _gpgrt_fflush (stream);
     352             : }
     353             : 
     354             : int
     355           0 : gpgrt_fseek (estream_t stream, long int offset, int whence)
     356             : {
     357           0 :   return _gpgrt_fseek (stream, offset, whence);
     358             : }
     359             : 
     360             : int
     361           0 : gpgrt_fseeko (estream_t stream, gpgrt_off_t offset, int whence)
     362             : {
     363           0 :   return _gpgrt_fseeko (stream, offset, whence);
     364             : }
     365             : 
     366             : long int
     367           0 : gpgrt_ftell (estream_t stream)
     368             : {
     369           0 :   return _gpgrt_ftell (stream);
     370             : }
     371             : 
     372             : gpgrt_off_t
     373           0 : gpgrt_ftello (estream_t stream)
     374             : {
     375           0 :   return _gpgrt_ftello (stream);
     376             : }
     377             : 
     378             : void
     379           0 : gpgrt_rewind (estream_t stream)
     380             : {
     381           0 :   _gpgrt_rewind (stream);
     382           0 : }
     383             : 
     384             : int
     385         100 : gpgrt_fgetc (estream_t stream)
     386             : {
     387         100 :   return _gpgrt_fgetc (stream);
     388             : }
     389             : 
     390             : int
     391           0 : _gpgrt_getc_underflow (estream_t stream)
     392             : {
     393           0 :   return _gpgrt__getc_underflow (stream);
     394             : }
     395             : 
     396             : int
     397           0 : gpgrt_fputc (int c, estream_t stream)
     398             : {
     399           0 :   return _gpgrt_fputc (c, stream);
     400             : }
     401             : 
     402             : int
     403           0 : _gpgrt_putc_overflow (int c, estream_t stream)
     404             : {
     405           0 :   return _gpgrt__putc_overflow (c, stream);
     406             : }
     407             : 
     408             : int
     409           0 : gpgrt_ungetc (int c, estream_t stream)
     410             : {
     411           0 :   return _gpgrt_ungetc (c, stream);
     412             : }
     413             : 
     414             : int
     415           0 : gpgrt_read (estream_t _GPGRT__RESTRICT stream,
     416             :             void *_GPGRT__RESTRICT buffer, size_t bytes_to_read,
     417             :             size_t *_GPGRT__RESTRICT bytes_read)
     418             : {
     419           0 :   return _gpgrt_read (stream, buffer, bytes_to_read, bytes_read);
     420             : }
     421             : 
     422             : int
     423           7 : gpgrt_write (estream_t _GPGRT__RESTRICT stream,
     424             :              const void *_GPGRT__RESTRICT buffer, size_t bytes_to_write,
     425             :              size_t *_GPGRT__RESTRICT bytes_written)
     426             : {
     427           7 :   return _gpgrt_write (stream, buffer, bytes_to_write, bytes_written);
     428             : }
     429             : 
     430             : int
     431           0 : gpgrt_write_sanitized (estream_t _GPGRT__RESTRICT stream,
     432             :                        const void * _GPGRT__RESTRICT buffer, size_t length,
     433             :                        const char * delimiters,
     434             :                        size_t * _GPGRT__RESTRICT bytes_written)
     435             : {
     436           0 :   return _gpgrt_write_sanitized (stream, buffer, length, delimiters,
     437             :                                  bytes_written);
     438             : }
     439             : 
     440             : int
     441           0 : gpgrt_write_hexstring (estream_t _GPGRT__RESTRICT stream,
     442             :                        const void *_GPGRT__RESTRICT buffer, size_t length,
     443             :                        int reserved, size_t *_GPGRT__RESTRICT bytes_written )
     444             : {
     445           0 :   return _gpgrt_write_hexstring (stream, buffer, length, reserved,
     446             :                                  bytes_written);
     447             : }
     448             : 
     449             : size_t
     450           0 : gpgrt_fread (void *_GPGRT__RESTRICT ptr, size_t size, size_t nitems,
     451             :              estream_t _GPGRT__RESTRICT stream)
     452             : {
     453           0 :   return _gpgrt_fread (ptr, size, nitems, stream);
     454             : }
     455             : 
     456             : size_t
     457           0 : gpgrt_fwrite (const void *_GPGRT__RESTRICT ptr, size_t size, size_t nitems,
     458             :               estream_t _GPGRT__RESTRICT stream)
     459             : {
     460           0 :   return _gpgrt_fwrite (ptr, size, nitems, stream);
     461             : }
     462             : 
     463             : char *
     464          10 : gpgrt_fgets (char *_GPGRT__RESTRICT buffer, int length,
     465             :              estream_t _GPGRT__RESTRICT stream)
     466             : {
     467          10 :   return _gpgrt_fgets (buffer, length, stream);
     468             : }
     469             : 
     470             : int
     471           0 : gpgrt_fputs (const char *_GPGRT__RESTRICT s, estream_t _GPGRT__RESTRICT stream)
     472             : {
     473           0 :   return _gpgrt_fputs (s, stream);
     474             : }
     475             : 
     476             : int
     477           0 : gpgrt_fputs_unlocked (const char *_GPGRT__RESTRICT s,
     478             :                       estream_t _GPGRT__RESTRICT stream)
     479             : {
     480           0 :   return _gpgrt_fputs_unlocked (s, stream);
     481             : }
     482             : 
     483             : gpgrt_ssize_t
     484           0 : gpgrt_getline (char *_GPGRT__RESTRICT *_GPGRT__RESTRICT lineptr,
     485             :                size_t *_GPGRT__RESTRICT n, estream_t _GPGRT__RESTRICT stream)
     486             : {
     487           0 :   return _gpgrt_getline (lineptr, n, stream);
     488             : }
     489             : 
     490             : gpgrt_ssize_t
     491           0 : gpgrt_read_line (estream_t stream,
     492             :                  char **addr_of_buffer, size_t *length_of_buffer,
     493             :                  size_t *max_length)
     494             : {
     495           0 :   return _gpgrt_read_line (stream, addr_of_buffer, length_of_buffer,
     496             :                            max_length);
     497             : }
     498             : 
     499             : void
     500         153 : gpgrt_free (void *a)
     501             : {
     502         153 :   if (a)
     503         153 :     _gpgrt_free (a);
     504         153 : }
     505             : 
     506             : int
     507           0 : gpgrt_vfprintf (estream_t _GPGRT__RESTRICT stream,
     508             :                 const char *_GPGRT__RESTRICT format,
     509             :                 va_list ap)
     510             : {
     511           0 :   return _gpgrt_vfprintf (stream, format, ap);
     512             : }
     513             : 
     514             : int
     515           0 : gpgrt_vfprintf_unlocked (estream_t _GPGRT__RESTRICT stream,
     516             :                           const char *_GPGRT__RESTRICT format,
     517             :                           va_list ap)
     518             : {
     519           0 :   return _gpgrt_vfprintf_unlocked (stream, format, ap);
     520             : }
     521             : 
     522             : int
     523           0 : gpgrt_printf (const char *_GPGRT__RESTRICT format, ...)
     524             : {
     525             :   va_list ap;
     526             :   int rc;
     527             : 
     528           0 :   va_start (ap, format);
     529           0 :   rc = _gpgrt_vfprintf (es_stdout, format, ap);
     530           0 :   va_end (ap);
     531             : 
     532           0 :   return rc;
     533             : }
     534             : 
     535             : int
     536           0 : gpgrt_printf_unlocked (const char *_GPGRT__RESTRICT format, ...)
     537             : {
     538             :   va_list ap;
     539             :   int rc;
     540             : 
     541           0 :   va_start (ap, format);
     542           0 :   rc = _gpgrt_vfprintf_unlocked (es_stdout, format, ap);
     543           0 :   va_end (ap);
     544             : 
     545           0 :   return rc;
     546             : }
     547             : 
     548             : int
     549           3 : gpgrt_fprintf (estream_t _GPGRT__RESTRICT stream,
     550             :                const char *_GPGRT__RESTRICT format, ...)
     551             : {
     552             :   va_list ap;
     553             :   int rc;
     554             : 
     555           3 :   va_start (ap, format);
     556           3 :   rc = _gpgrt_vfprintf (stream, format, ap);
     557           3 :   va_end (ap);
     558             : 
     559           3 :   return rc;
     560             : }
     561             : 
     562             : int
     563           0 : gpgrt_fprintf_unlocked (estream_t _GPGRT__RESTRICT stream,
     564             :                         const char *_GPGRT__RESTRICT format, ...)
     565             : {
     566             :   va_list ap;
     567             :   int rc;
     568             : 
     569           0 :   va_start (ap, format);
     570           0 :   rc = _gpgrt_vfprintf_unlocked (stream, format, ap);
     571           0 :   va_end (ap);
     572             : 
     573           0 :   return rc;
     574             : }
     575             : 
     576             : int
     577           0 : gpgrt_setvbuf (estream_t _GPGRT__RESTRICT stream,
     578             :                 char *_GPGRT__RESTRICT buf, int type, size_t size)
     579             : {
     580           0 :   return _gpgrt_setvbuf (stream, buf, type, size);
     581             : }
     582             : 
     583             : void
     584           0 : gpgrt_setbuf (estream_t _GPGRT__RESTRICT stream, char *_GPGRT__RESTRICT buf)
     585             : {
     586           0 :   _gpgrt_setvbuf (stream, buf, buf? _IOFBF : _IONBF, BUFSIZ);
     587           0 : }
     588             : 
     589             : void
     590           0 : gpgrt_set_binary (estream_t stream)
     591             : {
     592           0 :   _gpgrt_set_binary (stream);
     593           0 : }
     594             : 
     595             : int
     596           3 : gpgrt_set_nonblock (estream_t stream, int onoff)
     597             : {
     598           3 :   return _gpgrt_set_nonblock (stream, onoff);
     599             : }
     600             : 
     601             : int
     602           0 : gpgrt_get_nonblock (estream_t stream)
     603             : {
     604           0 :   return _gpgrt_get_nonblock (stream);
     605             : }
     606             : 
     607             : int
     608          13 : gpgrt_poll (gpgrt_poll_t *fds, unsigned int nfds, int timeout)
     609             : {
     610          13 :   return _gpgrt_poll (fds, nfds, timeout);
     611             : }
     612             : 
     613             : estream_t
     614           0 : gpgrt_tmpfile (void)
     615             : {
     616           0 :   return _gpgrt_tmpfile ();
     617             : }
     618             : 
     619             : void
     620           0 : gpgrt_opaque_set (estream_t stream, void *opaque)
     621             : {
     622           0 :   _gpgrt_opaque_set (stream, opaque);
     623           0 : }
     624             : 
     625             : void *
     626           0 : gpgrt_opaque_get (estream_t stream)
     627             : {
     628           0 :   return _gpgrt_opaque_get (stream);
     629             : }
     630             : 
     631             : void
     632           0 : gpgrt_fname_set (estream_t stream, const char *fname)
     633             : {
     634           0 :   _gpgrt_fname_set (stream, fname);
     635           0 : }
     636             : 
     637             : const char *
     638           0 : gpgrt_fname_get (estream_t stream)
     639             : {
     640           0 :   return _gpgrt_fname_get (stream);
     641             : }
     642             : 
     643             : int
     644           0 : gpgrt_asprintf (char **r_buf, const char *_GPGRT__RESTRICT format, ...)
     645             : {
     646             :   va_list ap;
     647             :   int rc;
     648             : 
     649           0 :   va_start (ap, format);
     650           0 :   rc = _gpgrt_estream_vasprintf (r_buf, format, ap);
     651           0 :   va_end (ap);
     652             : 
     653           0 :   return rc;
     654             : }
     655             : 
     656             : int
     657         153 : gpgrt_vasprintf (char **r_buf, const char *_GPGRT__RESTRICT format, va_list ap)
     658             : {
     659         153 :   return _gpgrt_estream_vasprintf (r_buf, format, ap);
     660             : }
     661             : 
     662             : char *
     663           0 : gpgrt_bsprintf (const char *_GPGRT__RESTRICT format, ...)
     664             : {
     665             :   int rc;
     666             :   va_list ap;
     667             :   char *buf;
     668             : 
     669           0 :   va_start (ap, format);
     670           0 :   rc = _gpgrt_estream_vasprintf (&buf, format, ap);
     671           0 :   va_end (ap);
     672           0 :   if (rc < 0)
     673             :     return NULL;
     674           0 :   return buf;
     675             : }
     676             : 
     677             : char *
     678         153 : gpgrt_vbsprintf (const char *_GPGRT__RESTRICT format, va_list ap)
     679             : {
     680             :   int rc;
     681             :   char *buf;
     682             : 
     683         153 :   rc = _gpgrt_estream_vasprintf (&buf, format, ap);
     684         153 :   if (rc < 0)
     685             :     return NULL;
     686         153 :   return buf;
     687             : }
     688             : 
     689             : int
     690          26 : gpgrt_snprintf (char *buf, size_t bufsize, const char *format, ...)
     691             : {
     692             :   int rc;
     693             :   va_list arg_ptr;
     694             : 
     695          26 :   va_start (arg_ptr, format);
     696          26 :   rc = _gpgrt_estream_vsnprintf (buf, bufsize, format, arg_ptr);
     697          26 :   va_end (arg_ptr);
     698             : 
     699          26 :   return rc;
     700             : }
     701             : 
     702             : int
     703           0 : gpgrt_vsnprintf (char *buf, size_t bufsize,
     704             :                  const char *format, va_list arg_ptr)
     705             : {
     706           0 :   return _gpgrt_estream_vsnprintf (buf, bufsize, format, arg_ptr);
     707             : }

Generated by: LCOV version 1.11