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 : }
|
