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 18550 : gpgrt_lock_lock (gpgrt_lock_t *lockhd)
120 : {
121 18550 : 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 19011 : gpgrt_lock_unlock (gpgrt_lock_t *lockhd)
132 : {
133 19011 : 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 2423 : gpgrt_yield (void)
144 : {
145 2423 : 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 2 : gpgrt_fgets (char *_GPGRT__RESTRICT buffer, int length,
471 : estream_t _GPGRT__RESTRICT stream)
472 : {
473 2 : 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 : }
|
