LCOV - code coverage report
Current view: top level - src - visibility.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 65 237 27.4 %
Date: 2016-11-29 14:52:46 Functions: 27 98 27.6 %

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

Generated by: LCOV version 1.11