diff --git a/NEWS b/NEWS index a8b60f4..3a8e367 100644 --- a/NEWS +++ b/NEWS @@ -1,1272 +1,1289 @@ Noteworthy changes in version 1.48 (unreleased) [C34/A34/R_] ----------------------------------------------- * New configure option --with-libtool-modification. [T6619] * New option parser flag to detect commands given without a double - dash. There is also the new meta command [command-mode] to set + dash. There is also the new meta command "command-mode" to set this flag via a config file. [T6978] + * Added an es_fopen mode flag "sequential" with support on Windows. + [rE7a42ff0ec9] + + * Added an es_fopen mode flag "wipe" to cleanup internal buffers at + close time. [T6954] + + * New function gpgrt_wipememory. [T6964] + + * Improvements to setenv on Windows. [rE89e53ad90f] + + * Fixed call to estream-printf string filters. [T6737] + + * Many improvements to the yat2m tool. + + * Updates to the build system. + * Interface changes relative to the 1.47 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ARGPARSE_FLAG_COMMAND NEW. + gpgrt_wipememory NEW. Release-info: https://dev.gnupg.org/T6441 Noteworthy changes in version 1.47 (2023-04-06) [C34/A34/R0] ----------------------------------------------- * New error codes for PUKs and reset codes. [T6421] * Avoid segv in logging with improper use of the "socket://". [rE68333be630] * Fixed translation of argparse's internal option --help. [rE885a287a57] * Interface changes relative to the 1.46 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPG_ERR_SOURCE_TKD NEW. GPG_ERR_BAD_PUK NEW. GPG_ERR_NO_RESET_CODE NEW. GPG_ERR_BAD_RESET_CODE NEW. GPGRT_SPAWN_KEEP_STDIN NEW. GPGRT_SPAWN_KEEP_STDOUT NEW. GPGRT_SPAWN_KEEP_STDERR NEW. GPGRT_SPAWN_INHERIT_FILE NEW. Release-info: https://dev.gnupg.org/T6231 Noteworthy changes in version 1.46 (2022-10-07) [C33/A33/R1] ----------------------------------------------- * Support for bidirectional pipes under Windows. [T6112] * REG_DWORD types are now support in the Windows Registry. [rE745d333cf7] * Added ES_SYSHD_SOCK support for gpgrt_sysopen under Windows. [rE018ea46a30] * Fixed gpgrt_log_get_fd for the file case. [T5922] * Avoids header problem with C11 and "noreturn". [T4002] * The gpg-error-config command is not installed by default, because it is now replaced by use of pkg-config/gpgrt-config with gpg-error.pc. Supply --enable-install-gpg-error-config configure option, if it's really needed. * Fixed support of posix-lock for FreeBSD. [rE6e17e70bb7] * Build fixes for some Mingw tool chain versions. [T5890, T4656] * Removed remaining support for WindowsCE. [T5912] * Updated config.guess, config.sub, and config.rpath. [T6078] * gpg-error-config is now only installed when enabled. [T5683] * System paths are now stripped from --cflags --and --libs. [T6136] Release-info: https://dev.gnupg.org/T5923 Noteworthy changes in version 1.45 (2022-04-07) [C33/A33/R0] ----------------------------------------------- * Support the "sysopen" mode parameter for gpgrt_fopen so that file names longer than MAX_PATH can be supported under Windows. * gpgrt_access and gpgrt_mkdir now support file names longer than MAX_PATH. * gpgrt_fopen now maps "/dev/null" to "nul" on Windows. * Published some internal helper functions for Windows. * Interface changes relative to the 1.42 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ gpgrt_free_wchar NEW. gpgrt_fname_to_wchar NEW. gpgrt_utf8_to_wchar NEW. gpgrt_wchar_to_utf8 NEW. Release-info: https://dev.gnupg.org/T5802 Noteworthy changes in version 1.44 (2022-01-27) [C32/A32/R2] ----------------------------------------------- * Fix dependency to gpg-error-config-test.sh. [T5696] * Run the posix locking test only on supported platforms. [T5699] * Detect Linux systems using musl. [T5762] * Fix gpg-error-config-test for PKG_CONFIG_LIBDIR. [T5740] * Fix returning of option attributes for options with args. [T5799] * Add Turkish translations. Release-info: https://dev.gnupg.org/T5676 Noteworthy changes in version 1.43 (2021-11-03) [C32/A32/R1] ----------------------------------------------- * Fix for building against GNU libc 2.34. [T5547] * Fix build problems on macOS. [T5440,T5610] * Fix gpgrt-config problems. [T5381,T5595] * Fix gpgrt_free for legacy platforms. [448bf7b01cad] * Fix truncation of error message in the middle of a character. [T5048] * Fix the --disable-threads configure options. [T5495] * Improve lock-obj generation for cross-builds [99ae862a96a5] * Improve cross-builds. [T5365] * Improve gpgrt_wait_processes. [T5381] * Allow config files to read values from the Windows Registry and from envvars. [b1790f4cc71f] * Update the Russian and Czech translations. Release-info: https://dev.gnupg.org/T5352 Noteworthy changes in version 1.42 (2021-03-22) [C32/A32/R0] ----------------------------------------------- * Allow Unicode file names under Windows for the gettext domain. * Improve cross-compiling support. [#5289] * Improve $libdir determination by gpgrt-config. [#5293] * Support --disable-thread by gen-lock-obj.sh. [#5296] * Interface changes relative to the 1.40 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPG_ERR_SOURCE_TPM2D NEW. Release-info: https://dev.gnupg.org/T5194 Noteworthy changes in version 1.41 (2020-12-21) [C31/A31/R1] ----------------------------------------------- * Fixes another glitch in the "ignore" meta command. * Fixes two typos in the German translation. Release-info: https://dev.gnupg.org/T5192 Noteworthy changes in version 1.40 (2020-12-21) [C31/A31/R0] ----------------------------------------------- * New function gpgrt_access. * Make "ignore" meta command work correctly in the option parser. * On Windows gpgrt_getcwd and the internal getusername now handle Unicode values. [#5098] * Update the build system. * Interface changes relative to the 1.39 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ gpgrt_access NEW. Release-info: https://dev.gnupg.org/T5191 Noteworthy changes in version 1.39 (2020-08-24) [C30/A30/R0] ----------------------------------------------- * On Windows gpgrt_fopen, gpgrt_chdir, and gpgrt_mkdir now handle UTF-8 names. [#4083] * Make timeout of gpgrt_poll work correctly on Windows if no file descriptors are active. * New function gpgrt_fcancel as alternative to gpgrt_close. This function avoid flushing out buffered data and also tries to delete a newly created file. * Changes to ease cross-building. [#4973] * "gpg-error --lib-version" works again. * Interface changes relative to the 1.38 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ gpgrt_fcancel NEW. Release-info: https://dev.gnupg.org/T5031 Noteworthy changes in version 1.38 (2020-05-29) [C29/A29/R0] ----------------------------------------------- * New option parser with features to implement system wide configuration files. * New functions to build file names. * New function to help reallocating arrays. * Protect gpgrt_inc_errorcount against counter overflow. * Improve cross-building for new platforms. [#4774] * Support 64-bit big-endian MIPS architecture. [#4952] * Support static link for Windows with -lws2_32. [#4623] * Interface changes relative to the 1.37 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ gpgrt_fnameconcat NEW. gpgrt_absfnameconcat NEW. gpgrt_reallocarray NEW. gpgrt_set_confdir NEW. gpgrt_argparser NEW. ARGPARSE_FLAG_SYS NEW. ARGPARSE_FLAG_USER NEW. ARGPARSE_FLAG_VERBOSE NEW. ARGPARSE_FLAG_USERVERS NEW. ARGPARSE_FLAG_WITHATTR NEW. ARGPARSE_NO_CONFFILE NEW. ARGPARSE_CONFFILE NEW. ARGPARSE_OPT_CONFFILE NEW. ARGPARSE_ATTR_FORCE NEW. ARGPARSE_ATTR_IGNORE NEW. ARGPARSE_TYPE_MASK NEW. ARGPARSE_PERMISSION_ERROR NEW. ARGPARSE_INVALID_META NEW. ARGPARSE_UNKNOWN_META NEW. ARGPARSE_UNEXPECTED_META NEW. ARGPARSE_conffile NEW. ARGPARSE_noconffile NEW. ARGPARSE_verbatim NEW. ARGPARSE_header NEW. GPGRT_CONFDIR_USER NEW. GPGRT_CONFDIR_SYS NEW. Release-info: https://dev.gnupg.org/T4859 Noteworthy changes in version 1.37 (2020-02-07) [C28/A28/R0] ----------------------------------------------- * Fixes a build problems when using Gawk 5.0 [#4459] * Fixes Bourne shell incompatibilities on Solaris. [#4574] * Improves cross-comiling support. [#4643] * On Windows strerror_s is now used to emulate strerror_r. [#4539] * New error codes to map SQLite primary error codes. * Now uses poll(2) instead of select(2) in gpgrt_poll if possible. * Fixes a bug in gpgrt_close. [#4698] * Fixes build problem under Cygwin. [#4474] * Fixes a few minor portability bugs. * Interface changes relative to the 1.36 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPG_ERR_NO_KEYBOXD NEW. GPG_ERR_KEYBOXD NEW. GPG_ERR_NO_SERVICE NEW. GPG_ERR_SERVICE. NEW. GPG_ERR_SQL_OK NEW. GPG_ERR_SQL_ERROR NEW. GPG_ERR_SQL_INTERNAL NEW. GPG_ERR_SQL_PERM NEW. GPG_ERR_SQL_ABORT NEW. GPG_ERR_SQL_BUSY NEW. GPG_ERR_SQL_LOCKED NEW. GPG_ERR_SQL_NOMEM NEW. GPG_ERR_SQL_READONLY NEW. GPG_ERR_SQL_INTERRUPT NEW. GPG_ERR_SQL_IOERR NEW. GPG_ERR_SQL_CORRUPT NEW. GPG_ERR_SQL_NOTFOUND NEW. GPG_ERR_SQL_FULL NEW. GPG_ERR_SQL_CANTOPEN NEW. GPG_ERR_SQL_PROTOCOL NEW. GPG_ERR_SQL_EMPTY NEW. GPG_ERR_SQL_SCHEMA NEW. GPG_ERR_SQL_TOOBIG NEW. GPG_ERR_SQL_CONSTRAINT NEW. GPG_ERR_SQL_MISMATCH NEW. GPG_ERR_SQL_MISUSE NEW. GPG_ERR_SQL_NOLFS NEW. GPG_ERR_SQL_AUTH NEW. GPG_ERR_SQL_FORMAT NEW. GPG_ERR_SQL_RANGE NEW. GPG_ERR_SQL_NOTADB NEW. GPG_ERR_SQL_NOTICE NEW. GPG_ERR_SQL_WARNING NEW. GPG_ERR_SQL_ROW NEW. GPG_ERR_SQL_DONE NEW. gpg_err_code_from_sqlite NEW. Release-info: https://dev.gnupg.org/T4772 Noteworthy changes in version 1.36 (2019-03-19) [C27/A27/R0] ----------------------------------------------- * Two new error codes to better support PIV cards. * Support armv7a-unknown-linux-gnueabihf. * Increased estream buffer sizes for Windows. * Interface changes relative to the 1.34 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPG_ERR_NO_AUTH NEW. GPG_ERR_BAD_AUTH NEW. Release-info: https://dev.gnupg.org/T4413 Noteworthy changes in version 1.35 (2019-01-28) [C26/A26/R1] ----------------------------------------------- * Distribute the correct gpgrt-config. Noteworthy changes in version 1.34 (2019-01-16) [C26/A26/R0] ----------------------------------------------- * Support for riscv32. * New API to allow emergency cleanup after internal fatal errors. * Minor bug and portability fixes. [#4286,#4298 * Interface changes relative to the 1.33 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ gpgrt_abort NEW. gpgrt_add_emergency_cleanup NEW. Release-info: https://dev.gnupg.org/T4296 Noteworthy changes in version 1.33 (2018-12-07) [C25/A25/R0] ----------------------------------------------- * New unified config script gpgrt-config which can now be used by all GnuPG related packages. * Support for ARC and arm64ilp32. * The log functions now sanitize strings printed with the "%s" format specifier. All control characters are C-escaped in the output. Users of that function may want to remove their own escaping to avoid doubling of backslashes. * New fprintf style function to apply a custom filter for string arguments. * New function to compare version strings. * Interface changes relative to the 1.28 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ gpgrt_cmp_version New. gpgrt_string_filter_t New. gpgrt_fprintf_sf New. gpgrt_fprintf_sf_unlocked New. gpgrt_ftruncate New but limited functionality. gpgrt_w32_override_locale New. Release-info: https://dev.gnupg.org/T4205 Noteworthy changes in version 1.32 (2018-07-12) [C24/A24/R3] ----------------------------------------------- * Fixes a problem with gpgrt_fflush and gpgrt_fopencookie. [#4069] * Fixes a problem with the C11 header stdnoreturn.h. [#4002] * The yat2m tool can now also be build on Windows. * Updates translations for Spanish, Russian and Ukrainian. Noteworthy changes in version 1.31 (2018-05-02) [C24/A24/R2] ----------------------------------------------- * Fixes another problem with gpgrt_poll under Windows. [#3937] * New translation for Spanish. Noteworthy changes in version 1.30 (2018-04-30) [C24/A24/R1] ----------------------------------------------- * Fixes a hang on Windows when using gpgrt_poll under nPth. * Build fix for Solaris. [#3869] Noteworthy changes in version 1.29 (2018-04-11) [C24/A24/R0] ----------------------------------------------- * The yat2m tool is during cross-compile now also installed on the host platform. * New option parser and associated functions similar to the one used by GnuPG. * New Base-64 encoder. * Fixes regression in 1.28 for arm64 and w64 builds. * Interface changes relative to the 1.28 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ gpgrt_argparse New. gpgrt_usage New. gpgrt_strusage New. gpgrt_set_strusage New. gpgrt_set_usage_outfnc New. gpgrt_set_fixed_string_mapper New. GPGRT_ENABLE_ARGPARSE_MACROS New macro. gpgrt_b64enc_start New. gpgrt_b64enc_write New. gpgrt_b64enc_finish New. Noteworthy changes in version 1.28 (2018-03-13) [C23/A23/R0] ----------------------------------------------- * The formerly internal yat2m tool is now installed for a native build. * The new files gpgrt.m4 and gpgrt-config are now installed. They can be used instead of gpg-error.m4 and gpg-error-config. * New logging functions similar to those used by GnuPG. * New helper functions for platform abstraction. * Interface changes relative to the 1.27 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ gpgrt_get_errorcount New API. gpgrt_inc_errorcount New API. gpgrt_log_set_sink New API. gpgrt_log_set_socket_dir_cb New API. gpgrt_log_set_pid_suffix_cb New API. gpgrt_log_set_prefix New API. gpgrt_log_get_prefix New API. gpgrt_log_test_fd New API. gpgrt_log_get_fd New API. gpgrt_log_get_stream New API. gpgrt_log New API. gpgrt_logv New API. gpgrt_logv_prefix New API. gpgrt_log_string New API. gpgrt_log_info New API. gpgrt_log_error New API. gpgrt_log_fatal New API. gpgrt_log_bug New API. gpgrt_log_debug New API. gpgrt_log_debug_string New API. gpgrt_log_printf New API. gpgrt_log_flush New API. gpgrt_log_printhex New API. gpgrt_log_clock New API. gpgrt_assert New macro. _gpgrt_log_assert New internal API. GPGRT_LOGLVL_BEGIN New const. GPGRT_LOGLVL_CONT New const. GPGRT_LOGLVL_INFO New const. GPGRT_LOGLVL_WARN New const. GPGRT_LOGLVL_ERROR New const. GPGRT_LOGLVL_FATAL New const. GPGRT_LOGLVL_BUG New const. GPGRT_LOGLVL_DEBUG New const. gpgrt_realloc New API. gpgrt_malloc New API. gpgrt_calloc New API. gpgrt_strdup New API. gpgrt_strconcat New API. gpgrt_w32_reg_query_string New API. gpgrt_getenv New API. gpgrt_setenv New API. gpgrt_mkdir New API. gpgrt_chdir New API. gpgrt_getcwd New API. Noteworthy changes in version 1.27 (2017-02-28) [C22/A22/R0] ----------------------------------------------- * Added a Base64 decoder. * Added support for the sh3 architecture. * Added header gpgrt.h as an alias for gpg-error.h. * Fixed macro GPGRT_GCC_VERSION. * Fixed a race in non-blocking I/O on Windows. * Interface changes relative to the 1.26 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ gpgrt_b64state_t NEW type. gpgrt_b64dec_start NEW. gpgrt_b64dec_proc NEW. gpgrt_b64dec_finish NEW. GPG_ERR_WRONG_NAME NEW. gpgrt.h NEW header. Noteworthy changes in version 1.26 (2016-12-21) [C21/A21/R0] ----------------------------------------------- * New option --desc for gpg-error. * Interface changes relative to the 1.25 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPG_ERR_UNKNOWN_FLAG NEW. GPG_ERR_INV_ORDER NEW. GPG_ERR_ALREADY_FETCHED NEW. GPG_ERR_TRY_LATER NEW. GPG_ERR_SYSTEM_BUG NEW. GPG_ERR_DNS_UNKNOWN NEW. GPG_ERR_DNS_SECTION NEW. GPG_ERR_DNS_ADDRESS NEW. GPG_ERR_DNS_NO_QUERY NEW. GPG_ERR_DNS_NO_ANSWER NEW. GPG_ERR_DNS_CLOSED NEW. GPG_ERR_DNS_VERIFY NEW. GPG_ERR_DNS_TIMEOUT NEW. Noteworthy changes in version 1.25 (2016-11-14) [C20/A20/R0] ----------------------------------------------- * New interface gpgrt_get_syscall_clamp to allow libaries to make use of Libgpg-error's system call wrapper functions. * gpgrt_poll does now work under Windows. * Fixed bug in the locking code when used with the nPth threading library. * Added support for {i686,x86_64}-apple-darwin. * Added new error codes. * Interface changes relative to the 1.23 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ gpgrt_get_syscall_clamp NEW. GPG_ERR_ENGINE_TOO_OLD NEW. GPG_ERR_WINDOW_TOO_SMALL NEW. GPG_ERR_WINDOW_TOO_LARGE NEW. GPG_ERR_MISSING_ENVVAR NEW. GPG_ERR_USER_ID_EXISTS NEW. GPG_ERR_NAME_EXISTS NEW. GPG_ERR_DUP_NAME NEW. GPG_ERR_TOO_OLD NEW. GPG_ERR_TOO_YOUNG NEW. Noteworthy changes in version 1.24 (2016-07-14) [C19/A19/R1] ----------------------------------------------- * Fixes a bug in es_fclose_snatch when used used after es_fseek. * Fixes building without thread support. * New configure option --disable-tests. Noteworthy changes in version 1.23 (2016-06-15) [C19/A19/R0] ----------------------------------------------- * Fixes an assertion failure due to es_flush on read/write streams. * Fixes a bug with a too short memory limit is es_fopenmen. * Cross-build support for powerpc-unknown-linux-gnuspe and tilegx-unknown-linux-gnu architectures. * Interface changes relative to the 1.22 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPG_ERR_SUBKEYS_EXP_OR_REV NEW. Noteworthy changes in version 1.22 (2016-04-25) [C18/A18/R0] ----------------------------------------------- * New functions and macros to to provide iconv(3) on Windows. * Support for LeakSanitizer with the gpgrt_annotate_leaked_object inline function. * Interface changes relative to the 1.21 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPG_ERR_DB_CORRUPTED NEW. gpgrt_annotate_leaked_object NEW inline func. GPGRT_ENABLE_W32_ICONV_MACROS NEW. gpgrt_w32_iconv_open NEW. gpgrt_w32_iconv_close NEW. gpgrt_w32_iconv NEW. Noteworthy changes in version 1.21 (2015-12-12) [C17/A17/R0] ----------------------------------------------- * New functions gpgrt_poll and gpgrt_set_nonblock. For now only pipes and sockets on Unix are supported. * Fixes gettext output encoding problems on Windows. * Interface changes relative to the 1.20 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ gpgrt_set_nonblock NEW. gpgrt_get_nonblock NEW. gpgrt_poll NEW. gpgrt_poll_t NEW type. es_poll_t NEW type. es_set_nonblock NEW macro. es_get_nonblock NEW macro. es_poll NEW macro. GPG_ERR_TRUE NEW. GPG_ERR_FALSE NEW. GPG_ERR_NO_NAME NEW. GPG_ERR_NO_KEY NEW. GPG_ERR_SERVER_FAILED NEW. Noteworthy changes in version 1.20 (2015-08-26) [C16/A16/R0] ----------------------------------------------- * New macros for GCC attributes. * Make es_set_binary actually work for Windows. * Allow building without thread support. * Build without a build timestamp by default. * Interface changes relative to the 1.19 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPGRT_VERSION NEW macro. GPGRT_VERSION_NUMBER NEW macro. GPGRT_INLINE NEW macro. GPGRT_GCC_VERSION NEW macro. GPGRT_ATTR_NORETURN NEW macro. GPGRT_ATTR_PRINTF NEW macro. GPGRT_ATTR_NR_PRINTF NEW macro. GPGRT_ATTR_FORMAT_ARG NEW macro. GPGRT_ATTR_SENTINEL NEW macro. GPGRT_ATTR_USED NEW macro. GPGRT_ATTR_UNUSED NEW macro. GPGRT_ATTR_DEPRECATED NEW macro. GPGRT_ATTR_PURE NEW macro. GPGRT_ATTR_MALLOC NEW macro. GPGRT_HAVE_MACRO_FUNCTION NEW macro. GPGRT_HAVE_PRAGMA_GCC_PUSH NEW macro. Noteworthy changes in version 1.19 (2015-04-10) [C15/A15/R0] ----------------------------------------------- * New set of error codes for use with LDAP. * New options --help and --defines for gpg-error. * Allow building with gcc 5. * Interface changes relative to the 1.18 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPG_ERR_LDAP_* NEW. Noteworthy changes in version 1.18 (2015-01-26) [C14/A14/R0] ----------------------------------------------- * New translations for Hungarian, Portuguese, Russian, and traditional Chinese. Updated other translations. * New error codes. * Interface changes relative to the 1.17 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPG_ERR_FORBIDDEN NEW. GPG_ERR_OBJ_TERM_STATE NEW. GPG_ERR_REQUEST_TOO_SHORT NEW. GPG_ERR_REQUEST_TOO_LONG NEW. GPG_ERR_LEGACY_KEY NEW. Noteworthy changes in version 1.17 (2014-10-15) [C13/A13/R0] ----------------------------------------------- * New error codes for TLS protocol libraries. * New configure option --enable-build-timestamp. * New man page for gpg-error-config. * Interface changes relative to the 1.16 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPG_ERR_SOURCE_TLS NEW. GPG_ERR_NO_CERT_CHAIN NEW. GPG_ERR_CERT_TOO_LARGE NEW. GPG_ERR_INV_RECORD NEW. GPG_ERR_BAD_MAC NEW. GPG_ERR_UNEXPECTED_MSG NEW. GPG_ERR_COMPR_FAILED NEW. GPG_ERR_WOULD_WRAP NEW. GPG_ERR_FATAL_ALERT NEW. GPG_ERR_NO_CIPHER NEW. GPG_ERR_MISSING_CLIENT_CERT NEW. GPG_ERR_CLOSE_NOTIFY NEW. GPG_ERR_TICKET_EXPIRED NEW. GPG_ERR_BAD_TICKET NEW. GPG_ERR_UNKNOWN_IDENTITY NEW. GPG_ERR_BAD_HS_CERT NEW. GPG_ERR_BAD_HS_CERT_REQ NEW. GPG_ERR_BAD_HS_CERT_VER NEW. GPG_ERR_BAD_HS_CHANGE_CIPHER NEW. GPG_ERR_BAD_HS_CLIENT_HELLO NEW. GPG_ERR_BAD_HS_SERVER_HELLO NEW. GPG_ERR_BAD_HS_SERVER_HELLO_DONE NEW. GPG_ERR_BAD_HS_FINISHED NEW. GPG_ERR_BAD_HS_SERVER_KEX NEW. GPG_ERR_BAD_HS_CLIENT_KEX NEW. GPG_ERR_BOGUS_STRING NEW. gpgrt_pending NEW. gpgrt_pending_unlocked NEW. Noteworthy changes in version 1.16 (2014-09-18) [C12/A12/R2] ----------------------------------------------- * Support building for iOS. * Fixed a prototype mismatch. * Fix es_fclose for streams opened with "samethread". Noteworthy changes in version 1.15 (2014-09-11) [C12/A12/R1] ----------------------------------------------- * This releases fixes problems with the use of off_t and ssize_t by the estream functions introduced with 1.14. Although this is technically an ABI break on some platforms, we take this as a simple bug fix for 1.14. The new functions are very unlikely in use by any code and thus no breakage should happen. The 1.14 tarball will be removed from the archive. * Add type gpgrt_off_t which is guaranteed to be 64 bit. * Add type gpgrt_ssize_t to make use on Windows easier. On Unix platforms this is an alias for ssize_t. Noteworthy changes in version 1.14 (2014-09-08) [C12/A12/R0] ----------------------------------------------- * Added gpgrt_lock_trylock. * Added the estream library under the name gpgrt and a set of macros to use them with their "es_" names. * Interface changes relative to the 1.13 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPG_ERR_KEY_DISABLED NEW. gpgrt_init NEW macro. gpgrt_check_version NEW. gpgrt_lock_trylock NEW. gpgrt_set_syscall_clamp NEW. gpgrt_set_alloc_func NEW. gpgrt_stream_t NEW. gpgrt_cookie_io_functions_t NEW. gpgrt_syshd_t NEW. GPGRT_SYSHD_NONE NEW. GPGRT_SYSHD_FD NEW. GPGRT_SYSHD_SOCK NEW. GPGRT_SYSHD_RVID NEW. GPGRT_SYSHD_HANDLE NEW. gpgrt_stdin NEW macro. gpgrt_stdout NEW macro. gpgrt_stderr NEW macro. gpgrt_fopen NEW. gpgrt_mopen NEW. gpgrt_fopenmem NEW. gpgrt_fopenmem_init NEW. gpgrt_fdopen NEW. gpgrt_fdopen_nc NEW. gpgrt_sysopen NEW. gpgrt_sysopen_nc NEW. gpgrt_fpopen NEW. gpgrt_fpopen_nc NEW. gpgrt_freopen NEW. gpgrt_fopencookie NEW. gpgrt_fclose NEW. gpgrt_fclose_snatch NEW. gpgrt_onclose NEW. gpgrt_fileno NEW. gpgrt_fileno_unlocked NEW. gpgrt_syshd NEW. gpgrt_syshd_unlocked NEW. gpgrt_flockfile NEW. gpgrt_ftrylockfile NEW. gpgrt_funlockfile NEW. gpgrt_feof NEW. gpgrt_feof_unlocked NEW. gpgrt_ferror NEW. gpgrt_ferror_unlocked NEW. gpgrt_clearerr NEW. gpgrt_clearerr_unlocked NEW. gpgrt_fflush NEW. gpgrt_fseek NEW. gpgrt_fseeko NEW. gpgrt_ftell NEW. gpgrt_ftello NEW. gpgrt_rewind NEW. gpgrt_getc NEW macro. gpgrt_getc_unlocked NEW macro. gpgrt_fgetc NEW. gpgrt_fputc NEW. gpgrt_ungetc NEW. gpgrt_read NEW. gpgrt_write NEW. gpgrt_write_sanitized NEW. gpgrt_write_hexstring NEW. gpgrt_fread NEW. gpgrt_fwrite NEW. gpgrt_fgets NEW. gpgrt_putc NEW macro. gpgrt_putc_unlocked NEW macro. gpgrt_fputs NEW. gpgrt_fputs_unlocked NEW. gpgrt_getline NEW. gpgrt_read_line NEW. gpgrt_free NEW. gpgrt_fprintf NEW. gpgrt_fprintf_unlocked NEW. gpgrt_printf NEW. gpgrt_printf_unlocked NEW. gpgrt_vfprintf NEW. gpgrt_vfprintf_unlocked NEW. gpgrt_setvbuf NEW. gpgrt_setbuf NEW. gpgrt_set_binary NEW. gpgrt_tmpfile NEW. gpgrt_opaque_set NEW. gpgrt_opaque_get NEW. gpgrt_fname_set NEW. gpgrt_fname_get NEW. gpgrt_asprintf NEW. gpgrt_vasprintf NEW. gpgrt_bsprintf NEW. gpgrt_vbsprintf NEW. gpgrt_snprintf NEW. gpgrt_vsnprintf NEW. Noteworthy changes in version 1.13 (2014-04-15) [C11/A11/R0] ----------------------------------------------- * Added a portable mutex API. * The AM_PATH_GPG_ERROR macro now defines GPG_ERROR_MT_CFLAGS and GPG_ERROR_MT_LIBS autoconf output variables for use by programs which need gpgrt based thread support. gpg-error-config has a new option --mt. * Interface changes relative to the 1.12 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPG_ERR_KEY_ON_CARD NEW. GPG_ERR_MAC_ALGO NEW. GPG_ERR_INV_LOCK_OBJ NEW. gpgrt_lock_t NEW. GPGRT_LOCK_INITIALIZER NEW. GPGRT_LOCK_DEFINE NEW. gpgrt_lock_init NEW. gpgrt_lock_lock NEW. gpgrt_lock_unlock NEW. gpgrt_lock_destroy NEW. gpgrt_yield NEW. Noteworthy changes in version 1.12 (2013-06-24) ----------------------------------------------- * Add support for 64 bit Windows (use ./autogen.sh --build-w64). * Fixed parsing and installing of the Windows .def file. * Interface changes relative to the 1.11 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPG_ERR_NO_CRYPT_CTX NEW. GPG_ERR_WRONG_CRYPT_CTX NEW. GPG_ERR_BAD_CRYPT_CTX NEW. GPG_ERR_CRYPT_CTX_CONFLICT NEW. GPG_ERR_BROKEN_PUBKEY NEW. GPG_ERR_BROKEN_SECKEY NEW. Noteworthy changes in version 1.11 (2013-02-25) ----------------------------------------------- * New error source GPG_ERR_SOURCE_ASSUAN for Libassuan related errors. * New macros GPG_ERROR_VERSION and GPG_ERROR_VERSION_NUMBER. New function gpg_error_check_version. * Interface changes relative to the 1.10 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPG_ERR_NO_KEYSERVER NEW. GPG_ERR_INV_CURVE NEW. GPG_ERR_UNKNOWN_CURVE NEW. GPG_ERR_DUP_KEY NEW. GPG_ERR_AMBIGUOUS NEW. GPG_ERR_SOURCE_ASSUAN NEW. gpg_error_check_version NEW. GPG_ERROR_VERSION NEW. GPG_ERROR_VERSION_NUMBER NEW. Noteworthy changes in version 1.10 (2010-10-26) ----------------------------------------------- * Using a static library on W32 does now work. * Interface changes relative to the 1.9 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPG_ERR_NOT_INITIALIZED NEW. GPG_ERR_MISSING_ISSUER_CERT NEW. GPG_ERR_FULLY_CANCELED NEW. Noteworthy changes in version 1.9 (2010-07-21) ---------------------------------------------- * New function gpg_err_deinit. * Fix building of static lib under W32. * Interface changes relative to the 1.8 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPG_ERR_MISSING_KEY NEW. GPG_ERR_TOO_MANY NEW. GPG_ERR_LIMIT_REACHED NEW. gpg_err_deinit NEW. Noteworthy changes in version 1.8 (2010-05-06) ---------------------------------------------- * Support for WindowsCE. * New option --list for gpg-error. * Interface changes relative to the 1.7 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPG_ERR_NOT_ENABLED NEW. GPG_ERR_SOURCE_G13 NEW. GPG_ERR_NO_ENGINE NEW. gpg_err_set_errno NEW. Noteworthy changes in version 1.7 (2008-11-26) ---------------------------------------------- * Minor fixes and a few new error codes. * Interface changes relative to the 1.6 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPG_ERR_NOT_OPERATIONAL NEW GPG_ERR_NO_PASSPHRASE NEW GPG_ERR_NO_PIN NEW Noteworthy changes in version 1.6 (2007-10-29) ---------------------------------------------- * Fixed a build problem under Windows. * Interface changes relative to the 1.4 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPG_ERR_UNFINISHED NEW GPG_ERR_SOURCE_GPA NEW GPG_ERR_SOURCE_KLEO NEW Noteworthy changes in version 1.5 (2006-11-30) ---------------------------------------------- * Minor build system fixes. * Updated gettext. Removed included gettext copy. * gpg-error has a new option --version. Noteworthy changes in version 1.4 (2006-09-14) ---------------------------------------------- * Support for Common Lisp is included. * New error codes for the Assuan IPC library. * New error code GPG_ERR_MISSING_ERRNO to be used in cases when a system accidentally does not set errno but a system error definitely occurred. * New error source GPG_ERR_SOURCE_ANY to allow proper use of libgpg-error even if a specific source is not available. * New convenience functions gpg_err_code_from_syserror and gpg_error_from_syserror which make sure never to return 0. * Interface changes relative to the 1.2 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ gpg_err_code_from_syserror NEW gpg_error_from_syserror NEW GPG_ERR_SOURCE_ANY NEW GPG_ERR_MISSING_ERRNO NEW GPG_ERR_UNKNOWN_OPTION NEW GPG_ERR_UNKNOWN_COMMAND NEW GPG_ERR_ASS_GENERAL NEW GPG_ERR_ASS_ACCEPT_FAILED NEW GPG_ERR_ASS_CONNECT_FAILED NEW GPG_ERR_ASS_INV_RESPONSE NEW GPG_ERR_ASS_INV_VALUE NEW GPG_ERR_ASS_INCOMPLETE_LINE NEW GPG_ERR_ASS_LINE_TOO_LONG NEW GPG_ERR_ASS_NESTED_COMMANDS NEW GPG_ERR_ASS_NO_DATA_CB NEW GPG_ERR_ASS_NO_INQUIRE_CB NEW GPG_ERR_ASS_NOT_A_SERVER NEW GPG_ERR_ASS_NOT_A_CLIENT NEW GPG_ERR_ASS_SERVER_START NEW GPG_ERR_ASS_READ_ERROR NEW GPG_ERR_ASS_WRITE_ERROR NEW GPG_ERR_ASS_TOO_MUCH_DATA NEW GPG_ERR_ASS_UNEXPECTED_CMD NEW GPG_ERR_ASS_UNKNOWN_CMD NEW GPG_ERR_ASS_SYNTAX NEW GPG_ERR_ASS_CANCELED NEW GPG_ERR_ASS_NO_INPUT NEW GPG_ERR_ASS_NO_OUTPUT NEW GPG_ERR_ASS_PARAMETER NEW GPG_ERR_ASS_UNKNOWN_INQUIRE NEW ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Noteworthy changes in version 1.3 (2006-03-14) ---------------------------------------------- * GNU gettext is included for systems that do not provide it. Noteworthy changes in version 1.2 (2006-03-03) ---------------------------------------------- * New function gpg_err_init, which binds the locale directory to the text domain. This function is a constructor on GCC targets, so it does not need to be called explicitely. The header file defines GPG_ERR_INITIALIZED in this case. This is experimental for now. * "./autogen.sh --build-w32" does now also build a DLL for W32. Translations are not yet provided for this platform. * New error codes GPG_ERR_UNKNOWN_EXTN and GPG_ERR_UNKNOWN_CRIT_EXTN. * New error code GPG_ERR_LOCKED. * New translations included for France, Romania, and Vietnamese. * Interface changes relative to the 1.1 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPG_ERR_UNKNOWN_EXTN NEW GPG_ERR_UNKNOWN_CRIT_EXTN NEW GPG_ERR_LOCKED NEW gpg_err_init NEW GPG_ERR_INITIALIZED NEW ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Noteworthy changes in version 1.1 (2005-06-20) ---------------------------------------------- * Bug fixes. Noteworthy changes in version 1.0 (2004-07-30) ---------------------------------------------- * Ported to Solaris 2.8. * Added a new error source GPG_ERR_SOURCE_GSTI, and new error codes GPG_ERR_PROTOCOL_VIOLATION and GPG_ERR_INV_MAC for this source. * Interface changes relative to the 0.7 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPG_ERR_SOURCE_GSTI NEW GPG_ERR_PROTOCOL_VIOLATION NEW GPG_ERR_INV_MAC NEW GPG_ERR_INV_REQUEST NEW ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Noteworthy changes in version 0.7 (2004-03-07) ---------------------------------------------- * libgpg-error can be built on systems where the errno macros do not evaluate to plain numbers, but expressions. If you want to cross-compile, you might have to set CC_FOR_BUILD, though. * A new tool gpg-error to convert error numbers into symbols into strings is provided. * Interface changes relative to the 0.6 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPG_ERR_LOCALE_PROBLEM NEW GPG_ERR_NOT_LOCKED NEW ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Noteworthy changes in version 0.6 (2003-11-14) ---------------------------------------------- * German translation included. * It is now possible to use the inline functions even for non C99 compliant compilers by given e.g. -DGPG_ERR_INLINE=inline when compiling an application using this library. Note, that gcc will use inline anyway. * Interface changes relative to the 0.5 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ GPG_ERR_SOURCE_KSBA NEW GPG_ERR_SOURCE_DIRMNGR NEW GPG_ERR_TRUNCATED NEW GPG_ERR_NO_ENCODING_METHOD NEW GPG_ERR_NO_ENCRYPTION_SCHEME NEW GPG_ERR_NO_SIGNATURE_SCHEME NEW GPG_ERR_INV_ATTR NEW GPG_ERR_NO_VALUE NEW GPG_ERR_NOT_FOUND NEW GPG_ERR_VALUE_NOT_FOUND NEW GPG_ERR_SYNTAX NEW GPG_ERR_INV_CRL NEW GPG_ERR_BAD_BER NEW GPG_ERR_INV_BER NEW GPG_ERR_ELEMENT_NOT_FOUND NEW GPG_ERR_IDENTIFIER_NOT_FOUND NEW GPG_ERR_INV_TAG NEW GPG_ERR_INV_LENGTH NEW GPG_ERR_INV_KEYINFO NEW GPG_ERR_UNEXPECTED_TAG NEW GPG_ERR_NOT_DER_ENCODED, NEW GPG_ERR_NO_CMS_OBJ NEW GPG_ERR_INV_CMS_OBJ NEW GPG_ERR_UNKNOWN_CMS_OBJ, NEW GPG_ERR_UNSUPPORTED_CMS_OBJ NEW GPG_ERR_UNSUPPORTED_ENCODING, NEW GPG_ERR_UNSUPPORTED_CMS_VERSION NEW GPG_ERR_UNKNOWN_ALGORITHM NEW GPG_ERR_ENCODING_PROBLEM NEW GPG_ERR_INV_STATE NEW GPG_ERR_DUP_VALUE, NEW GPG_ERR_MISSING_ACTION NEW GPG_ERR_MODULE_NOT_FOUND NEW GPG_ERR_INV_OID_STRING NEW GPG_ERR_INV_TIME NEW GPG_ERR_INV_CRL_OBJ NEW GPG_ERR_UNSUPPORTED_CRL_VERSION NEW GPG_ERR_INV_CERT_OBJ NEW GPG_ERR_UNKNOWN_NAME NEW GPG_ERR_BUFFER_TOO_SHORT. NEW ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Noteworthy changes in version 0.5 (2003-10-06) ---------------------------------------------- * New thread safe interface gpg_strerror_r. * New error code GPG_ERR_PIN_NOT_SYNCED has been added. * Interface changes relative to the 0.4 release: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ gpg_strerror_r NEW GPG_ERR_PIN_NOT_SYNCED NEW ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Noteworthy changes in version 0.4 (2003-09-03) ---------------------------------------------- * Fixed another bug that prevented that system errors were created correctly in the first place. * Use inline in public header file only on C99 compilers. Noteworthy changes in version 0.3 (2003-07-31) ---------------------------------------------- * Fixed bug that prevented that system errors were mapped to error strings correctly. Noteworthy changes in version 0.2 (2003-07-30) ---------------------------------------------- * Value of the error code GPG_ERR_CANCELED was fixed. * New error codes GPG_ERR_WRONG_CARD, GPG_ERR_HARDWARE, GPG_ERR_PIN_BLOCKED and GPG_ERR_USE_CONDITIONS have been added. * The header file has been made C++ clean. * AM_PATH_GPG_ERR has been fixed to work without explicit version number. * The header file now uses inline instead __inline__ for non-GNU compilers. Noteworthy changes in version 0.1 (2003-06-06) ---------------------------------------------- * Initial release. Copyright 2003, 2004, 2005, 2010 g10 Code GmbH This file is free software; as a special exception the author gives unlimited permission to copy and/or distribute it, with or without modifications, as long as this notice is preserved. This file is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY, to the extent permitted by law; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. diff --git a/src/estream.c b/src/estream.c index d83b746..66ebc4b 100644 --- a/src/estream.c +++ b/src/estream.c @@ -1,5794 +1,5828 @@ /* estream.c - Extended Stream I/O Library * Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010, 2011, * 2014, 2015, 2016, 2017 g10 Code GmbH * * This file is part of Libestream. * * Libestream is free software; you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as * published by the Free Software Foundation; either version 2.1 of * the License, or (at your option) any later version. * * Libestream is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with Libestream; if not, see . * * ALTERNATIVELY, Libestream may be distributed under the terms of the * following license, in which case the provisions of this license are * required INSTEAD OF the GNU General Public License. If you wish to * allow use of your version of this file only under the terms of the * GNU General Public License, and not to allow others to use your * version of this file under the terms of the following license, * indicate your decision by deleting this paragraph and the license * below. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, and the entire permission notice in its entirety, * including the disclaimer of warranties. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. The name of the author may not be used to endorse or promote * products derived from this software without specific prior * written permission. * * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * OF THE POSSIBILITY OF SUCH DAMAGE. */ #ifdef USE_ESTREAM_SUPPORT_H # include #endif #ifdef HAVE_CONFIG_H # include #endif #if defined(_WIN32) && !defined(HAVE_W32_SYSTEM) # define HAVE_W32_SYSTEM 1 #endif #ifdef HAVE_SYS_TIME_H # include #endif #include #include #include #include #include #include #include #include #include #include #include #ifdef HAVE_W32_SYSTEM # ifdef HAVE_WINSOCK2_H # include # endif # include #else # ifdef HAVE_POLL_H # include # else # ifdef HAVE_SYS_SELECT_H # include # endif # endif #endif /* Enable tracing. The value is the module name to be printed. */ /*#define ENABLE_TRACING "estream"*/ #include "gpgrt-int.h" #include "estream-printf.h" #include "thread.h" #include "lock.h" #ifndef O_BINARY # define O_BINARY 0 #endif #ifndef HAVE_DOSISH_SYSTEM # ifdef HAVE_W32_SYSTEM # define HAVE_DOSISH_SYSTEM 1 # endif #endif #ifdef HAVE_W32_SYSTEM # ifndef S_IRGRP # define S_IRGRP S_IRUSR # endif # ifndef S_IROTH # define S_IROTH S_IRUSR # endif # ifndef S_IWGRP # define S_IWGRP S_IWUSR # endif # ifndef S_IWOTH # define S_IWOTH S_IWUSR # endif # ifndef S_IXGRP # define S_IXGRP S_IXUSR # endif # ifndef S_IXOTH # define S_IXOTH S_IXUSR # endif #endif #if !defined (EWOULDBLOCK) && defined (HAVE_W32_SYSTEM) /* Compatibility with errno.h from mingw-2.0 */ # define EWOULDBLOCK 140 #endif #ifndef EAGAIN # define EAGAIN EWOULDBLOCK #endif #define _set_errno(a) do { errno = (a); } while (0) #define IS_INVALID_FD(a) ((a) == -1) /* Calculate array dimension. */ #ifndef DIM #define DIM(array) (sizeof (array) / sizeof (*array)) #endif /* A helper macro used to convert to a hex string. */ #define tohex(n) ((n) < 10 ? ((n) + '0') : (((n) - 10) + 'A')) /* Generally used types. */ typedef void *(*func_realloc_t) (void *mem, size_t size); typedef void (*func_free_t) (void *mem); /* * A linked list to hold active stream objects. * Protected by ESTREAM_LIST_LOCK. */ struct estream_list_s { struct estream_list_s *next; estream_t stream; /* Entry is not used if NULL. */ }; typedef struct estream_list_s *estream_list_t; static estream_list_t estream_list; /* * File descriptors registered for use as the standard file handles. * Protected by ESTREAM_LIST_LOCK. */ static int custom_std_fds[3]; static unsigned char custom_std_fds_valid[3]; /* * A lock object to protect ESTREAM LIST, CUSTOM_STD_FDS and * CUSTOM_STD_FDS_VALID. Used by lock_list() and unlock_list(). */ GPGRT_LOCK_DEFINE (estream_list_lock); /* * Error code replacements. */ #ifndef EOPNOTSUPP # define EOPNOTSUPP ENOSYS #endif /* Local prototypes. */ static void fname_set_internal (estream_t stream, const char *fname, int quote); /* * Memory allocation wrappers used in this file. */ static void * mem_alloc (size_t n) { return _gpgrt_malloc (n); } static void * mem_realloc (void *p, size_t n) { return _gpgrt_realloc (p, n); } static void mem_free (void *p) { if (p) _gpgrt_free (p); } +static void +mem_free2 (void *p, size_t n, int with_wipe) +{ + if (p) + { + if (with_wipe) + _gpgrt_wipememory (p, n); + _gpgrt_free (p); + } +} + + /* * A Windows helper function to map a W32 API error code to a standard * system error code. That actually belong into sysutils but to allow * standalone use of estream we keep it here. */ #ifdef HAVE_W32_SYSTEM static int map_w32_to_errno (DWORD w32_err) { switch (w32_err) { case 0: return 0; case ERROR_FILE_NOT_FOUND: return ENOENT; case ERROR_PATH_NOT_FOUND: return ENOENT; case ERROR_ACCESS_DENIED: return EPERM; /* ReactOS uses EACCES ("Permission denied") and * is likely right because they used an * undocumented function to associate the error * codes. However we have always used EPERM * ("Operation not permitted", e.g. function is * required to be called by root) and we better * stick to that to avoid surprising bugs. */ case ERROR_INVALID_HANDLE: return EBADF; case ERROR_INVALID_BLOCK: return ENOMEM; case ERROR_NOT_ENOUGH_MEMORY: return ENOMEM; case ERROR_NO_DATA: return EPIPE; case ERROR_ALREADY_EXISTS: return EEXIST; case ERROR_FILE_INVALID: return EIO; /* This mapping has been taken from reactOS. */ case ERROR_TOO_MANY_OPEN_FILES: return EMFILE; case ERROR_ARENA_TRASHED: return ENOMEM; case ERROR_BAD_ENVIRONMENT: return E2BIG; case ERROR_BAD_FORMAT: return ENOEXEC; case ERROR_INVALID_DRIVE: return ENOENT; case ERROR_CURRENT_DIRECTORY: return EACCES; case ERROR_NOT_SAME_DEVICE: return EXDEV; case ERROR_NO_MORE_FILES: return ENOENT; case ERROR_WRITE_PROTECT: return EACCES; case ERROR_BAD_UNIT: return EACCES; case ERROR_NOT_READY: return EACCES; case ERROR_BAD_COMMAND: return EACCES; case ERROR_CRC: return EACCES; case ERROR_BAD_LENGTH: return EACCES; case ERROR_SEEK: return EACCES; case ERROR_NOT_DOS_DISK: return EACCES; case ERROR_SECTOR_NOT_FOUND: return EACCES; case ERROR_OUT_OF_PAPER: return EACCES; case ERROR_WRITE_FAULT: return EACCES; case ERROR_READ_FAULT: return EACCES; case ERROR_GEN_FAILURE: return EACCES; case ERROR_SHARING_VIOLATION: return EACCES; case ERROR_LOCK_VIOLATION: return EACCES; case ERROR_WRONG_DISK: return EACCES; case ERROR_SHARING_BUFFER_EXCEEDED: return EACCES; case ERROR_BAD_NETPATH: return ENOENT; case ERROR_NETWORK_ACCESS_DENIED: return EACCES; case ERROR_BAD_NET_NAME: return ENOENT; case ERROR_FILE_EXISTS: return EEXIST; case ERROR_CANNOT_MAKE: return EACCES; case ERROR_FAIL_I24: return EACCES; case ERROR_NO_PROC_SLOTS: return EAGAIN; case ERROR_DRIVE_LOCKED: return EACCES; case ERROR_BROKEN_PIPE: return EPIPE; case ERROR_DISK_FULL: return ENOSPC; case ERROR_INVALID_TARGET_HANDLE: return EBADF; case ERROR_WAIT_NO_CHILDREN: return ECHILD; case ERROR_CHILD_NOT_COMPLETE: return ECHILD; case ERROR_DIRECT_ACCESS_HANDLE: return EBADF; case ERROR_SEEK_ON_DEVICE: return EACCES; case ERROR_DIR_NOT_EMPTY: return ENOTEMPTY; case ERROR_NOT_LOCKED: return EACCES; case ERROR_BAD_PATHNAME: return ENOENT; case ERROR_MAX_THRDS_REACHED: return EAGAIN; case ERROR_LOCK_FAILED: return EACCES; case ERROR_INVALID_STARTING_CODESEG: return ENOEXEC; case ERROR_INVALID_STACKSEG: return ENOEXEC; case ERROR_INVALID_MODULETYPE: return ENOEXEC; case ERROR_INVALID_EXE_SIGNATURE: return ENOEXEC; case ERROR_EXE_MARKED_INVALID: return ENOEXEC; case ERROR_BAD_EXE_FORMAT: return ENOEXEC; case ERROR_ITERATED_DATA_EXCEEDS_64k: return ENOEXEC; case ERROR_INVALID_MINALLOCSIZE: return ENOEXEC; case ERROR_DYNLINK_FROM_INVALID_RING: return ENOEXEC; case ERROR_IOPL_NOT_ENABLED: return ENOEXEC; case ERROR_INVALID_SEGDPL: return ENOEXEC; case ERROR_AUTODATASEG_EXCEEDS_64k: return ENOEXEC; case ERROR_RING2SEG_MUST_BE_MOVABLE: return ENOEXEC; case ERROR_RELOC_CHAIN_XEEDS_SEGLIM: return ENOEXEC; case ERROR_INFLOOP_IN_RELOC_CHAIN: return ENOEXEC; case ERROR_FILENAME_EXCED_RANGE: return ENOENT; case ERROR_NESTING_NOT_ALLOWED: return EAGAIN; case ERROR_NOT_ENOUGH_QUOTA: return ENOMEM; default: return EIO; } } /* Wrapper to be used by other modules to set ERRNO from the Windows * error. EC may be -1 to get the last error. */ void _gpgrt_w32_set_errno (int ec) { if (ec == -1) ec = GetLastError (); _set_errno (map_w32_to_errno (ec)); } gpg_err_code_t _gpgrt_w32_get_last_err_code (void) { int ec = GetLastError (); errno = map_w32_to_errno (ec); return _gpg_err_code_from_errno (errno); } #endif /*HAVE_W32_SYSTEM*/ /* * Replacement for a missing memrchr. */ #ifndef HAVE_MEMRCHR static void * memrchr (const void *buffer, int c, size_t n) { const unsigned char *p = buffer; for (p += n; n ; n--) if (*--p == c) return (void *)p; return NULL; } #endif /*HAVE_MEMRCHR*/ /* * Wrappers to lock a stream or the list of streams. */ #if 0 # define dbg_lock_0(f) fprintf (stderr, "estream: " f); # define dbg_lock_1(f, a) fprintf (stderr, "estream: " f, (a)); # define dbg_lock_2(f, a, b) fprintf (stderr, "estream: " f, (a), (b)); #else # define dbg_lock_0(f) # define dbg_lock_1(f, a) # define dbg_lock_2(f, a, b) #endif static int init_stream_lock (estream_t _GPGRT__RESTRICT stream) { int rc; if (!stream->intern->samethread) { dbg_lock_1 ("enter init_stream_lock for %p\n", stream); memset (&stream->intern->lock, 0 , sizeof stream->intern->lock); rc = _gpgrt_lock_init (&stream->intern->lock); dbg_lock_2 ("leave init_stream_lock for %p: rc=%d\n", stream, rc); } else rc = 0; return rc; } static void destroy_stream_lock (estream_t _GPGRT__RESTRICT stream) { if (!stream->intern->samethread) { dbg_lock_1 ("enter destroy_stream_lock for %p\n", stream); _gpgrt_lock_destroy (&stream->intern->lock); dbg_lock_1 ("leave destroy_stream_lock for %p\n", stream); } } static void lock_stream (estream_t _GPGRT__RESTRICT stream) { if (!stream->intern->samethread) { dbg_lock_1 ("enter lock_stream for %p\n", stream); _gpgrt_lock_lock (&stream->intern->lock); dbg_lock_1 ("leave lock_stream for %p\n", stream); } } static int trylock_stream (estream_t _GPGRT__RESTRICT stream) { int rc; if (!stream->intern->samethread) { dbg_lock_1 ("enter trylock_stream for %p\n", stream); rc = _gpgrt_lock_trylock (&stream->intern->lock)? 0 : -1; dbg_lock_2 ("leave trylock_stream for %p: rc=%d\n", stream, rc); } else rc = 0; return rc; } static void unlock_stream (estream_t _GPGRT__RESTRICT stream) { if (!stream->intern->samethread) { dbg_lock_1 ("enter unlock_stream for %p\n", stream); _gpgrt_lock_unlock (&stream->intern->lock); dbg_lock_1 ("leave unlock_stream for %p\n", stream); } } static void lock_list (void) { dbg_lock_0 ("enter lock_list\n"); _gpgrt_lock_lock (&estream_list_lock); dbg_lock_0 ("leave lock_list\n"); } static void unlock_list (void) { dbg_lock_0 ("enter unlock_list\n"); _gpgrt_lock_unlock (&estream_list_lock); dbg_lock_0 ("leave unlock_list\n"); } #undef dbg_lock_0 #undef dbg_lock_1 #undef dbg_lock_2 /* * Manipulation of the list of stream. */ /* * Add STREAM to the list of registered stream objects. If * WITH_LOCKED_LIST is true it is assumed that the list of streams is * already locked. The implementation is straightforward: We first * look for an unused entry in the list and use that; if none is * available we put a new item at the head. We drawback of the * strategy never to shorten the list is that a one time allocation of * many streams will lead to scanning unused entries later. If that * turns out to be a problem, we may either free some items from the * list or append new entries at the end; or use a table. Returns 0 * on success; on error or non-zero is returned and ERRNO set. */ static int do_list_add (estream_t stream, int with_locked_list) { estream_list_t item; if (!with_locked_list) lock_list (); for (item = estream_list; item && item->stream; item = item->next) ; if (!item) { item = mem_alloc (sizeof *item); if (item) { item->next = estream_list; estream_list = item; } } if (item) item->stream = stream; if (!with_locked_list) unlock_list (); return item? 0 : -1; } /* * Remove STREAM from the list of registered stream objects. */ static void do_list_remove (estream_t stream, int with_locked_list) { estream_list_t item, item_prev = NULL; if (!with_locked_list) lock_list (); for (item = estream_list; item; item = item->next) if (item->stream == stream) break; else item_prev = item; if (item) { if (item_prev) item_prev->next = item->next; else estream_list = item->next; mem_free (item); } if (!with_locked_list) unlock_list (); } /* * The atexit handler for the entire gpgrt. */ static void do_deinit (void) { /* Flush all streams. */ _gpgrt_fflush (NULL); /* We should release the estream_list. However there is one problem: That list is also used to search for the standard estream file descriptors. If we would remove the entire list, any use of es_foo in another atexit function may re-create the list and the streams with possible undesirable effects. Given that we don't close the stream either, it should not matter that we keep the list and let the OS clean it up at process end. */ /* Reset the syscall clamp. */ _gpgrt_set_syscall_clamp (NULL, NULL); } /* * Initialization of the estream module. */ int _gpgrt_estream_init (void) { static int initialized; if (!initialized) { initialized = 1; atexit (do_deinit); } return 0; } /* * Implementation of memory based I/O. */ /* Cookie for memory objects. */ typedef struct estream_cookie_mem { unsigned int modeflags; /* Open flags. */ unsigned char *memory; /* Allocated data buffer. */ size_t memory_size; /* Allocated size of MEMORY. */ size_t memory_limit; /* Caller supplied maximum allowed allocation size or 0 for no limit. */ size_t offset; /* Current offset in MEMORY. */ size_t data_len; /* Used length of data in MEMORY. */ size_t block_size; /* Block size. */ struct { unsigned int grow: 1; /* MEMORY is allowed to grow. */ + unsigned int wipe: 1; /* MEMORY shall be wiped. */ } flags; func_realloc_t func_realloc; func_free_t func_free; } *estream_cookie_mem_t; /* * Create function for memory objects. DATA is either NULL or a user - * supplied buffer with the initial conetnt of the memory buffer. If + * supplied buffer with the initial content of the memory buffer. If * DATA is NULL, DATA_N and DATA_LEN need to be 0 as well. If DATA is * not NULL, DATA_N gives the allocated size of DATA and DATA_LEN the * used length in DATA. If this function succeeds DATA is now owned * by this function. If GROW is false FUNC_REALLOC is not * required. */ static int func_mem_create (void *_GPGRT__RESTRICT *_GPGRT__RESTRICT cookie, unsigned char *_GPGRT__RESTRICT data, size_t data_n, size_t data_len, - size_t block_size, unsigned int grow, + size_t block_size, unsigned int grow, unsigned int wipe, func_realloc_t func_realloc, func_free_t func_free, unsigned int modeflags, size_t memory_limit) { estream_cookie_mem_t mem_cookie; int err; if (!data && (data_n || data_len)) { _set_errno (EINVAL); return -1; } if (grow && func_free && !func_realloc) { _set_errno (EINVAL); return -1; } /* Round a memory limit up to the next block length. */ if (memory_limit && block_size) { memory_limit += block_size - 1; memory_limit /= block_size; memory_limit *= block_size; } mem_cookie = mem_alloc (sizeof (*mem_cookie)); if (!mem_cookie) err = -1; else { mem_cookie->modeflags = modeflags; mem_cookie->memory = data; mem_cookie->memory_size = data_n; mem_cookie->memory_limit = memory_limit; mem_cookie->offset = 0; mem_cookie->data_len = data_len; mem_cookie->block_size = block_size; mem_cookie->flags.grow = !!grow; + mem_cookie->flags.wipe = !!wipe; mem_cookie->func_realloc = grow? (func_realloc ? func_realloc : mem_realloc) : NULL; mem_cookie->func_free = func_free ? func_free : mem_free; *cookie = mem_cookie; err = 0; } return err; } /* * Read function for memory objects. */ static gpgrt_ssize_t func_mem_read (void *cookie, void *buffer, size_t size) { estream_cookie_mem_t mem_cookie = cookie; gpgrt_ssize_t ret; if (!size) /* Just the pending data check. */ return (mem_cookie->data_len - mem_cookie->offset)? 0 : -1; if (size > mem_cookie->data_len - mem_cookie->offset) size = mem_cookie->data_len - mem_cookie->offset; if (size) { memcpy (buffer, mem_cookie->memory + mem_cookie->offset, size); mem_cookie->offset += size; } ret = size; return ret; } /* * Write function for memory objects. */ static gpgrt_ssize_t func_mem_write (void *cookie, const void *buffer, size_t size) { estream_cookie_mem_t mem_cookie = cookie; gpgrt_ssize_t ret; size_t nleft; if (!size) return 0; /* A flush is a NOP for memory objects. */ if (mem_cookie->modeflags & O_APPEND) { /* Append to data. */ mem_cookie->offset = mem_cookie->data_len; } gpgrt_assert (mem_cookie->memory_size >= mem_cookie->offset); nleft = mem_cookie->memory_size - mem_cookie->offset; /* If we are not allowed to grow the buffer, limit the size to the left space. */ if (!mem_cookie->flags.grow && size > nleft) size = nleft; /* Enlarge the memory buffer if needed. */ if (size > nleft) { unsigned char *newbuf; size_t newsize; if (!mem_cookie->memory_size) newsize = size; /* Not yet allocated. */ else newsize = mem_cookie->memory_size + (size - nleft); if (newsize < mem_cookie->offset) { _set_errno (EINVAL); return -1; } /* Round up to the next block length. BLOCK_SIZE should always be set; we check anyway. */ if (mem_cookie->block_size) { newsize += mem_cookie->block_size - 1; if (newsize < mem_cookie->offset) { _set_errno (EINVAL); return -1; } newsize /= mem_cookie->block_size; newsize *= mem_cookie->block_size; } /* Check for a total limit. */ if (mem_cookie->memory_limit && newsize > mem_cookie->memory_limit) { _set_errno (ENOSPC); return -1; } gpgrt_assert (mem_cookie->func_realloc); newbuf = mem_cookie->func_realloc (mem_cookie->memory, newsize); if (!newbuf) return -1; mem_cookie->memory = newbuf; mem_cookie->memory_size = newsize; gpgrt_assert (mem_cookie->memory_size >= mem_cookie->offset); nleft = mem_cookie->memory_size - mem_cookie->offset; gpgrt_assert (size <= nleft); } memcpy (mem_cookie->memory + mem_cookie->offset, buffer, size); if (mem_cookie->offset + size > mem_cookie->data_len) mem_cookie->data_len = mem_cookie->offset + size; mem_cookie->offset += size; ret = size; return ret; } /* * Seek function for memory objects. */ static int func_mem_seek (void *cookie, gpgrt_off_t *offset, int whence) { estream_cookie_mem_t mem_cookie = cookie; gpgrt_off_t pos_new; switch (whence) { case SEEK_SET: pos_new = *offset; break; case SEEK_CUR: pos_new = mem_cookie->offset += *offset; break; case SEEK_END: pos_new = mem_cookie->data_len += *offset; break; default: _set_errno (EINVAL); return -1; } if (pos_new > mem_cookie->memory_size) { size_t newsize; void *newbuf; if (!mem_cookie->flags.grow) { _set_errno (ENOSPC); return -1; } newsize = pos_new + mem_cookie->block_size - 1; if (newsize < pos_new) { _set_errno (EINVAL); return -1; } newsize /= mem_cookie->block_size; newsize *= mem_cookie->block_size; if (mem_cookie->memory_limit && newsize > mem_cookie->memory_limit) { _set_errno (ENOSPC); return -1; } gpgrt_assert (mem_cookie->func_realloc); newbuf = mem_cookie->func_realloc (mem_cookie->memory, newsize); if (!newbuf) return -1; mem_cookie->memory = newbuf; mem_cookie->memory_size = newsize; } if (pos_new > mem_cookie->data_len) { /* Fill spare space with zeroes. */ memset (mem_cookie->memory + mem_cookie->data_len, 0, pos_new - mem_cookie->data_len); mem_cookie->data_len = pos_new; } mem_cookie->offset = pos_new; *offset = pos_new; return 0; } /* * The IOCTL function for memory objects. */ static int func_mem_ioctl (void *cookie, int cmd, void *ptr, size_t *len) { estream_cookie_mem_t mem_cookie = cookie; int ret; if (cmd == COOKIE_IOCTL_SNATCH_BUFFER) { /* Return the internal buffer of the stream to the caller and invalidate it for the stream. */ *(void**)ptr = mem_cookie->memory; *len = mem_cookie->data_len; mem_cookie->memory = NULL; mem_cookie->memory_size = 0; mem_cookie->offset = 0; ret = 0; } else if (cmd == COOKIE_IOCTL_TRUNCATE) { gpgrt_off_t length = *(gpgrt_off_t *)ptr; ret = func_mem_seek (cookie, &length, SEEK_SET); if (ret != -1) mem_cookie->data_len = mem_cookie->offset; } else { _set_errno (EINVAL); ret = -1; } return ret; } /* * The destroy function for memory objects. */ static int func_mem_destroy (void *cookie) { estream_cookie_mem_t mem_cookie = cookie; if (cookie) { + if (mem_cookie->flags.wipe) + _gpgrt_wipememory (mem_cookie->memory, mem_cookie->memory_size); mem_cookie->func_free (mem_cookie->memory); mem_free (mem_cookie); } return 0; } /* * Access object for the memory functions. */ static struct cookie_io_functions_s estream_functions_mem = { { func_mem_read, func_mem_write, func_mem_seek, func_mem_destroy, }, func_mem_ioctl, }; /* * Implementation of file descriptor based I/O. */ /* Cookie for fd objects. */ typedef struct estream_cookie_fd { int fd; /* The file descriptor we are using for actual output. */ int no_close; /* If set we won't close the file descriptor. */ int nonblock; /* Non-blocking mode is enabled. */ } *estream_cookie_fd_t; /* * Create function for objects indentified by a libc file descriptor. */ static int func_fd_create (void **cookie, int fd, unsigned int modeflags, int no_close) { estream_cookie_fd_t fd_cookie; int err; trace (("enter: fd=%d mf=%x nc=%d", fd, modeflags, no_close)); fd_cookie = mem_alloc (sizeof (*fd_cookie)); if (! fd_cookie) err = -1; else { #ifdef HAVE_DOSISH_SYSTEM /* Make sure it is in binary mode if requested. */ if ( (modeflags & O_BINARY) ) setmode (fd, O_BINARY); #endif fd_cookie->fd = fd; fd_cookie->no_close = no_close; fd_cookie->nonblock = !!(modeflags & O_NONBLOCK); *cookie = fd_cookie; err = 0; } trace_errno (err, ("leave: cookie=%p err=%d", *cookie, err)); return err; } /* * Read function for fd objects. */ static gpgrt_ssize_t func_fd_read (void *cookie, void *buffer, size_t size) { estream_cookie_fd_t file_cookie = cookie; gpgrt_ssize_t bytes_read; trace (("enter: cookie=%p buffer=%p size=%d", cookie, buffer, (int)size)); if (!size) bytes_read = -1; /* We don't know whether anything is pending. */ else if (IS_INVALID_FD (file_cookie->fd)) { _gpgrt_yield (); bytes_read = 0; } else { _gpgrt_pre_syscall (); do { bytes_read = read (file_cookie->fd, buffer, size); } while (bytes_read == -1 && errno == EINTR); _gpgrt_post_syscall (); } trace_errno (bytes_read == -1, ("leave: bytes_read=%d", (int)bytes_read)); return bytes_read; } /* * Write function for fd objects. */ static gpgrt_ssize_t func_fd_write (void *cookie, const void *buffer, size_t size) { estream_cookie_fd_t file_cookie = cookie; gpgrt_ssize_t bytes_written; trace (("enter: cookie=%p buffer=%p size=%d", cookie, buffer, (int)size)); if (IS_INVALID_FD (file_cookie->fd)) { _gpgrt_yield (); bytes_written = size; /* Yeah: Success writing to the bit bucket. */ } else if (buffer) { _gpgrt_pre_syscall (); do { bytes_written = write (file_cookie->fd, buffer, size); } while (bytes_written == -1 && errno == EINTR); _gpgrt_post_syscall (); } else bytes_written = size; /* Note that for a flush SIZE should be 0. */ trace_errno (bytes_written == -1, ("leave: bytes_written=%d", (int)bytes_written)); return bytes_written; } /* * Seek function for fd objects. */ static int func_fd_seek (void *cookie, gpgrt_off_t *offset, int whence) { estream_cookie_fd_t file_cookie = cookie; gpgrt_off_t offset_new; int err; if (IS_INVALID_FD (file_cookie->fd)) { _set_errno (ESPIPE); err = -1; } else { _gpgrt_pre_syscall (); offset_new = lseek (file_cookie->fd, *offset, whence); _gpgrt_post_syscall (); if (offset_new == -1) err = -1; else { *offset = offset_new; err = 0; } } return err; } /* * The IOCTL function for fd objects. */ static int func_fd_ioctl (void *cookie, int cmd, void *ptr, size_t *len) { estream_cookie_fd_t fd_cookie = cookie; int ret; if (cmd == COOKIE_IOCTL_NONBLOCK && !len) { fd_cookie->nonblock = !!ptr; if (IS_INVALID_FD (fd_cookie->fd)) { _set_errno (EINVAL); ret = -1; } else { #ifdef _WIN32 _set_errno (EOPNOTSUPP); /* FIXME: Implement for Windows. */ ret = -1; #else _set_errno (0); ret = fcntl (fd_cookie->fd, F_GETFL, 0); if (ret == -1 && errno) ; else if (fd_cookie->nonblock) ret = fcntl (fd_cookie->fd, F_SETFL, (ret | O_NONBLOCK)); else ret = fcntl (fd_cookie->fd, F_SETFL, (ret & ~O_NONBLOCK)); #endif } } else { _set_errno (EINVAL); ret = -1; } return ret; } /* * The destroy function for fd objects. */ static int func_fd_destroy (void *cookie) { estream_cookie_fd_t fd_cookie = cookie; int err; trace (("enter: cookie=%p", cookie)); if (fd_cookie) { if (IS_INVALID_FD (fd_cookie->fd)) err = 0; else err = fd_cookie->no_close? 0 : close (fd_cookie->fd); mem_free (fd_cookie); } else err = 0; trace_errno (err,("leave: err=%d", err)); return err; } /* * Access object for the fd functions. */ static struct cookie_io_functions_s estream_functions_fd = { { func_fd_read, func_fd_write, func_fd_seek, func_fd_destroy, }, func_fd_ioctl, }; #ifdef HAVE_W32_SYSTEM /* * Implementation of SOCKET based I/O. */ /* Cookie for SOCKET objects. */ typedef struct estream_cookie_sock { SOCKET sock; /* The SOCKET we are using for actual output. */ int no_close; /* If set we won't close the file descriptor. */ int nonblock; /* Non-blocking mode is enabled. */ } *estream_cookie_sock_t; /* * Create function for objects indentified by a libc file descriptor. */ static int func_sock_create (void **cookie, SOCKET sock, unsigned int modeflags, int no_close) { estream_cookie_sock_t sock_cookie; int err; trace (("enter: sock=%d mf=%x nc=%d", (int)sock, modeflags, no_close)); sock_cookie = mem_alloc (sizeof (*sock_cookie)); if (! sock_cookie) err = -1; else { sock_cookie->sock = sock; sock_cookie->no_close = no_close; sock_cookie->nonblock = !!(modeflags & O_NONBLOCK); *cookie = sock_cookie; err = 0; } trace_errno (err, ("leave: cookie=%p err=%d", *cookie, err)); return err; } /* * Read function for SOCKET objects. */ static gpgrt_ssize_t func_sock_read (void *cookie, void *buffer, size_t size) { estream_cookie_sock_t file_cookie = cookie; gpgrt_ssize_t bytes_read; trace (("enter: cookie=%p buffer=%p size=%d", cookie, buffer, (int)size)); if (!size) bytes_read = -1; /* We don't know whether anything is pending. */ else if (IS_INVALID_FD (file_cookie->sock)) { _gpgrt_yield (); bytes_read = 0; } else { _gpgrt_pre_syscall (); do { bytes_read = recv (file_cookie->sock, buffer, size, 0); } while (bytes_read == -1 && errno == EINTR); _gpgrt_post_syscall (); } trace_errno (bytes_read == -1, ("leave: bytes_read=%d", (int)bytes_read)); return bytes_read; } /* * Write function for SOCKET objects. */ static gpgrt_ssize_t func_sock_write (void *cookie, const void *buffer, size_t size) { estream_cookie_sock_t file_cookie = cookie; gpgrt_ssize_t bytes_written; trace (("enter: cookie=%p buffer=%p size=%d", cookie, buffer, (int)size)); if (IS_INVALID_FD (file_cookie->sock)) { _gpgrt_yield (); bytes_written = size; /* Yeah: Success writing to the bit bucket. */ } else if (buffer) { _gpgrt_pre_syscall (); do { bytes_written = send (file_cookie->sock, buffer, size, 0); } while (bytes_written == -1 && errno == EINTR); _gpgrt_post_syscall (); } else bytes_written = size; /* Note that for a flush SIZE should be 0. */ trace_errno (bytes_written == -1, ("leave: bytes_written=%d", (int)bytes_written)); return bytes_written; } /* * Seek function for SOCKET objects. */ static int func_sock_seek (void *cookie, gpgrt_off_t *offset, int whence) { (void)cookie; (void)offset; (void)whence; _set_errno (ESPIPE); return -1; } /* * The IOCTL function for SOCKET objects. */ static int func_sock_ioctl (void *cookie, int cmd, void *ptr, size_t *len) { estream_cookie_sock_t sock_cookie = cookie; int ret; if (cmd == COOKIE_IOCTL_NONBLOCK && !len) { sock_cookie->nonblock = !!ptr; if (IS_INVALID_FD (sock_cookie->sock)) { _set_errno (EINVAL); ret = -1; } else { u_long mode = 0; if (sock_cookie->nonblock) mode = 1; ret = ioctlsocket (sock_cookie->sock, FIONBIO, &mode); } } else { _set_errno (EINVAL); ret = -1; } return ret; } /* * The destroy function for SOCKET objects. */ static int func_sock_destroy (void *cookie) { estream_cookie_sock_t sock_cookie = cookie; int err; trace (("enter: cookie=%p", cookie)); if (sock_cookie) { if (IS_INVALID_FD (sock_cookie->sock)) err = 0; else err = sock_cookie->no_close? 0 : closesocket (sock_cookie->sock); mem_free (sock_cookie); } else err = 0; trace_errno (err,("leave: err=%d", err)); return err; } /* * Access object for the fd functions. */ static struct cookie_io_functions_s estream_functions_sock = { { func_sock_read, func_sock_write, func_sock_seek, func_sock_destroy, }, func_sock_ioctl, }; /* * Implementation of W32 handle based I/O. */ /* Cookie for fd objects. */ typedef struct estream_cookie_w32 { HANDLE hd; /* The handle we are using for actual output. */ int no_close; /* If set we won't close the handle. */ int no_syscall_clamp; /* Do not use the syscall clamp. */ } *estream_cookie_w32_t; /* * Create function for w32 handle objects. */ static int func_w32_create (void **cookie, HANDLE hd, unsigned int modeflags, int no_close, int no_syscall_clamp) { estream_cookie_w32_t w32_cookie; int err; trace (("enter: hd=%p mf=%x nc=%d nsc=%d", hd, modeflags, no_close, no_syscall_clamp)); w32_cookie = mem_alloc (sizeof (*w32_cookie)); if (!w32_cookie) err = -1; else { /* CR/LF translations are not supported when using the bare W32 API. If that is really required we need to implemented that in the upper layer. */ (void)modeflags; w32_cookie->hd = hd; w32_cookie->no_close = no_close; w32_cookie->no_syscall_clamp = no_syscall_clamp; *cookie = w32_cookie; err = 0; } trace_errno (err, ("leave: cookie=%p err=%d", *cookie, err)); return err; } /* * Read function for W32 handle objects. * * Note that this function may also be used by the reader thread of * w32-stream. In that case the NO_SYSCALL_CLAMP is set. */ static gpgrt_ssize_t func_w32_read (void *cookie, void *buffer, size_t size) { estream_cookie_w32_t w32_cookie = cookie; gpgrt_ssize_t bytes_read; trace (("enter: cookie=%p buffer=%p size=%d", cookie, buffer, (int)size)); if (!size) bytes_read = -1; /* We don't know whether anything is pending. */ else if (w32_cookie->hd == INVALID_HANDLE_VALUE) { _gpgrt_yield (); bytes_read = 0; } else { if (!w32_cookie->no_syscall_clamp) _gpgrt_pre_syscall (); do { DWORD nread, ec; trace (("cookie=%p calling ReadFile", cookie)); if (!ReadFile (w32_cookie->hd, buffer, size, &nread, NULL)) { ec = GetLastError (); trace (("cookie=%p ReadFile failed: ec=%ld", cookie,ec)); if (ec == ERROR_BROKEN_PIPE) bytes_read = 0; /* Like our pth_read we handle this as EOF. */ else { _set_errno (map_w32_to_errno (ec)); bytes_read = -1; } } else bytes_read = (int)nread; } while (bytes_read == -1 && errno == EINTR); if (!w32_cookie->no_syscall_clamp) _gpgrt_post_syscall (); } trace_errno (bytes_read==-1,("leave: bytes_read=%d", (int)bytes_read)); return bytes_read; } /* * Write function for W32 handle objects. * * Note that this function may also be used by the writer thread of * w32-stream. In that case the NO_SYSCALL_CLAMP is set. */ static gpgrt_ssize_t func_w32_write (void *cookie, const void *buffer, size_t size) { estream_cookie_w32_t w32_cookie = cookie; gpgrt_ssize_t bytes_written; trace (("enter: cookie=%p buffer=%p size=%d", cookie, buffer, (int)size)); if (w32_cookie->hd == INVALID_HANDLE_VALUE) { _gpgrt_yield (); bytes_written = size; /* Yeah: Success writing to the bit bucket. */ } else if (buffer) { if (!w32_cookie->no_syscall_clamp) _gpgrt_pre_syscall (); do { DWORD nwritten; trace (("cookie=%p calling WriteFile", cookie)); if (!WriteFile (w32_cookie->hd, buffer, size, &nwritten, NULL)) { DWORD ec = GetLastError (); trace (("cookie=%p WriteFile failed: ec=%ld", cookie, ec)); _set_errno (map_w32_to_errno (ec)); bytes_written = -1; } else bytes_written = (int)nwritten; } while (bytes_written == -1 && errno == EINTR); if (!w32_cookie->no_syscall_clamp) _gpgrt_post_syscall (); } else bytes_written = size; /* Note that for a flush SIZE should be 0. */ trace_errno (bytes_written==-1, ("leave: bytes_written=%d", (int)bytes_written)); return bytes_written; } /* * Seek function for W32 handle objects. */ static int func_w32_seek (void *cookie, gpgrt_off_t *offset, int whence) { estream_cookie_w32_t w32_cookie = cookie; DWORD method; LARGE_INTEGER distance, newoff; if (w32_cookie->hd == INVALID_HANDLE_VALUE) { _set_errno (ESPIPE); return -1; } if (GetFileType (w32_cookie->hd) == FILE_TYPE_PIPE) { _set_errno (ESPIPE); return -1; } if (whence == SEEK_SET) { method = FILE_BEGIN; distance.QuadPart = (unsigned long long)(*offset); } else if (whence == SEEK_CUR) { method = FILE_CURRENT; distance.QuadPart = (long long)(*offset); } else if (whence == SEEK_END) { method = FILE_END; distance.QuadPart = (long long)(*offset); } else { _set_errno (EINVAL); return -1; } if (!w32_cookie->no_syscall_clamp) _gpgrt_pre_syscall (); if (!SetFilePointerEx (w32_cookie->hd, distance, &newoff, method)) { _set_errno (map_w32_to_errno (GetLastError ())); _gpgrt_post_syscall (); return -1; } if (!w32_cookie->no_syscall_clamp) _gpgrt_post_syscall (); /* Note that gpgrt_off_t is always 64 bit. */ *offset = (gpgrt_off_t)newoff.QuadPart; return 0; } /* * Destroy function for W32 handle objects. */ static int func_w32_destroy (void *cookie) { estream_cookie_w32_t w32_cookie = cookie; int err; trace (("enter: cookie=%p", cookie)); if (w32_cookie) { if (w32_cookie->hd == INVALID_HANDLE_VALUE) err = 0; else if (w32_cookie->no_close) err = 0; else { trace (("cookie=%p closing handle %p", cookie, w32_cookie->hd)); if (!CloseHandle (w32_cookie->hd)) { DWORD ec = GetLastError (); trace (("cookie=%p CloseHandle failed: ec=%ld", cookie,ec)); _set_errno (map_w32_to_errno (ec)); err = -1; } else err = 0; } mem_free (w32_cookie); } else err = 0; trace_errno (err, ("leave: err=%d", err)); return err; } /* * Access object for the W32 handle based objects. */ static struct cookie_io_functions_s estream_functions_w32 = { { func_w32_read, func_w32_write, func_w32_seek, func_w32_destroy, }, NULL, }; #endif /*HAVE_W32_SYSTEM*/ /* * Implementation of stdio based I/O. */ /* Cookie for fp objects. */ typedef struct estream_cookie_fp { FILE *fp; /* The file pointer we are using for actual output. */ int no_close; /* If set we won't close the file pointer. */ } *estream_cookie_fp_t; /* * Create function for stdio based objects. */ static int func_fp_create (void **cookie, FILE *fp, unsigned int modeflags, int no_close) { estream_cookie_fp_t fp_cookie; int err; fp_cookie = mem_alloc (sizeof *fp_cookie); if (!fp_cookie) err = -1; else { #ifdef HAVE_DOSISH_SYSTEM /* Make sure it is in binary mode if requested. */ if ( (modeflags & O_BINARY) ) setmode (fileno (fp), O_BINARY); #else (void)modeflags; #endif fp_cookie->fp = fp; fp_cookie->no_close = no_close; *cookie = fp_cookie; err = 0; } return err; } /* * Read function for stdio based objects. */ static gpgrt_ssize_t func_fp_read (void *cookie, void *buffer, size_t size) { estream_cookie_fp_t file_cookie = cookie; gpgrt_ssize_t bytes_read; if (!size) return -1; /* We don't know whether anything is pending. */ if (file_cookie->fp) { _gpgrt_pre_syscall (); bytes_read = fread (buffer, 1, size, file_cookie->fp); _gpgrt_post_syscall (); } else bytes_read = 0; if (!bytes_read && ferror (file_cookie->fp)) return -1; return bytes_read; } /* * Write function for stdio bases objects. */ static gpgrt_ssize_t func_fp_write (void *cookie, const void *buffer, size_t size) { estream_cookie_fp_t file_cookie = cookie; size_t bytes_written; if (file_cookie->fp) { _gpgrt_pre_syscall (); if (buffer) { #ifdef HAVE_W32_SYSTEM /* Using an fwrite to stdout connected to the console fails with the error "Not enough space" for an fwrite size of >= 52KB (tested on Windows XP SP2). To solve this we always chunk the writes up into smaller blocks. */ bytes_written = 0; while (bytes_written < size) { size_t cnt = size - bytes_written; if (cnt > 32*1024) cnt = 32*1024; if (fwrite ((const char*)buffer + bytes_written, cnt, 1, file_cookie->fp) != 1) break; /* Write error. */ bytes_written += cnt; } #else bytes_written = fwrite (buffer, 1, size, file_cookie->fp); #endif } else /* Only flush requested. */ bytes_written = size; fflush (file_cookie->fp); _gpgrt_post_syscall (); } else bytes_written = size; /* Successfully written to the bit bucket. */ if (bytes_written != size) return -1; return bytes_written; } /* * Seek function for stdio based objects. */ static int func_fp_seek (void *cookie, gpgrt_off_t *offset, int whence) { estream_cookie_fp_t file_cookie = cookie; long int offset_new; if (!file_cookie->fp) { _set_errno (ESPIPE); return -1; } _gpgrt_pre_syscall (); if ( fseek (file_cookie->fp, (long int)*offset, whence) ) { /* fprintf (stderr, "\nfseek failed: errno=%d (%s)\n", */ /* errno,strerror (errno)); */ _gpgrt_post_syscall (); return -1; } offset_new = ftell (file_cookie->fp); _gpgrt_post_syscall (); if (offset_new == -1) { /* fprintf (stderr, "\nftell failed: errno=%d (%s)\n", */ /* errno,strerror (errno)); */ return -1; } *offset = offset_new; return 0; } /* * Destroy function for stdio based objects. */ static int func_fp_destroy (void *cookie) { estream_cookie_fp_t fp_cookie = cookie; int err; if (fp_cookie) { if (fp_cookie->fp) { _gpgrt_pre_syscall (); fflush (fp_cookie->fp); _gpgrt_post_syscall (); err = fp_cookie->no_close? 0 : fclose (fp_cookie->fp); } else err = 0; mem_free (fp_cookie); } else err = 0; return err; } /* * Access object for stdio based objects. */ static struct cookie_io_functions_s estream_functions_fp = { { func_fp_read, func_fp_write, func_fp_seek, func_fp_destroy, }, NULL, }; /* * Implementation of file name based I/O. * * Note that only a create function is required because the other * operations ares handled by file descriptor based I/O. */ #ifdef HAVE_W32_SYSTEM static int any8bitchar (const char *string) { if (string) for ( ; *string; string++) if ((*string & 0x80)) return 1; return 0; } #endif /*HAVE_W32_SYSTEM*/ /* Create function for objects identified by a file name. */ static int func_file_create (void **cookie, int *filedes, const char *path, unsigned int modeflags, unsigned int cmode) { estream_cookie_fd_t file_cookie; int err; int fd; err = 0; file_cookie = mem_alloc (sizeof (*file_cookie)); if (! file_cookie) { err = -1; goto out; } #ifdef HAVE_W32_SYSTEM if (any8bitchar (path)) { wchar_t *wpath; wpath = _gpgrt_utf8_to_wchar (path); if (!wpath) fd = -1; else { fd = _wopen (wpath, modeflags, cmode); _gpgrt_free_wchar (wpath); } } else /* Avoid unnecessary conversion. */ fd = open (path, modeflags, cmode); #else fd = open (path, modeflags, cmode); #endif if (fd == -1) { err = -1; goto out; } #ifdef HAVE_DOSISH_SYSTEM /* Make sure it is in binary mode if requested. */ if ( (modeflags & O_BINARY) ) setmode (fd, O_BINARY); #endif file_cookie->fd = fd; file_cookie->no_close = 0; *cookie = file_cookie; *filedes = fd; out: if (err) mem_free (file_cookie); return err; } /* Create function for objects identified by a file name. Windows * version to use CreateFile. */ #ifdef HAVE_W32_SYSTEM static int func_file_create_w32 (void **cookie, HANDLE *rethd, const char *path, unsigned int modeflags, unsigned int cmode, unsigned int flags_and_attrs) { estream_cookie_w32_t hd_cookie; wchar_t *wpath = NULL; int err = 0; HANDLE hd; DWORD desired_access; DWORD share_mode; DWORD creation_distribution; (void)cmode; hd_cookie = mem_alloc (sizeof *hd_cookie); if (!hd_cookie) { err = -1; goto leave; } wpath = _gpgrt_fname_to_wchar (path); if (!wpath) { err = -1; goto leave; } if ((modeflags & O_WRONLY)) { desired_access = GENERIC_WRITE; share_mode = FILE_SHARE_WRITE; } else if ((modeflags & O_RDWR)) { desired_access = GENERIC_READ | GENERIC_WRITE; share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE; } else { desired_access = GENERIC_READ; share_mode = FILE_SHARE_READ; } creation_distribution = 0; if ((modeflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL)) creation_distribution |= CREATE_NEW; else if ((modeflags & O_TRUNC) == O_TRUNC) { if ((modeflags & O_CREAT) == O_CREAT) creation_distribution |= CREATE_ALWAYS; else if ((modeflags & O_RDONLY) != O_RDONLY) creation_distribution |= TRUNCATE_EXISTING; } else if ((modeflags & O_APPEND) == O_APPEND) creation_distribution |= OPEN_EXISTING; else if ((modeflags & O_CREAT) == O_CREAT) creation_distribution |= OPEN_ALWAYS; else creation_distribution |= OPEN_EXISTING; hd = CreateFileW (wpath, desired_access, share_mode, NULL, /* security attributes */ creation_distribution, flags_and_attrs, NULL); /* template file */ if (hd == INVALID_HANDLE_VALUE) { _set_errno (map_w32_to_errno (GetLastError ())); err = -1; goto leave; } hd_cookie->hd = hd; hd_cookie->no_close = 0; hd_cookie->no_syscall_clamp = 0; *cookie = hd_cookie; *rethd = hd; leave: _gpgrt_free_wchar (wpath); if (err) mem_free (hd_cookie); return err; } #endif /*HAVE_W32_SYSTEM*/ /* Flags used by parse_mode and friends. */ #define X_SAMETHREAD (1 << 0) #define X_SYSOPEN (1 << 1) #define X_POLLABLE (1 << 2) #define X_SEQUENTIAL (1 << 3) +#define X_WIPE (1 << 4) /* Parse the mode flags of fopen et al. In addition to the POSIX * defined mode flags keyword parameters are supported. These are * key/value pairs delimited by comma and optional white spaces. * Keywords and values may not contain a comma or white space; unknown * keywords are skipped. Supported keywords are: * * mode= * * Creates a file and gives the new file read and write permissions * for the user and read permission for the group. The format of * the string is the same as shown by the -l option of the ls(1) * command. However the first letter must be a dash and it is * allowed to leave out trailing dashes. If this keyword parameter * is not given the default mode for creating files is "-rw-rw-r--" * (664). Note that the system still applies the current umask to * the mode when creating a file. Example: * * "wb,mode=-rw-r--" * * samethread * * Assumes that the object is only used by the creating thread and * disables any internal locking. This keyword is also found on * IBM systems. * * nonblock * * The object is opened in non-blocking mode. This is the same as * calling gpgrt_set_nonblock on the file. * * sysopen * * The object is opened in GPGRT_SYSHD_HANDLE mode. On POSIX this * is a NOP but under Windows the direct W32 API functions (HANDLE) * are used instead of their libc counterparts (fd). This flag * also allows to use file names longer than MAXPATH. Note that * gpgrt_fileno does not not work for such a stream under Windows. * * pollable * * The object is opened in a way suitable for use with es_poll. On * POSIX this is a NOP but under Windows we create up to two * threads, one for reading and one for writing, do any I/O there, * and synchronize with them in order to support es_poll. * * sequential * * Indicate that the file will in general be access in sequential * way. On Windows FILE_FLAG_SEQUENTIAL_SCAN will thus be used. * + * wipe + * + * Overwrites internal buffers at fclose time. + * * Note: R_CMODE is optional because is only required by functions * which are able to creat a file. */ static int parse_mode (const char *modestr, unsigned int *modeflags, unsigned int *r_xmode, unsigned int *r_cmode) { unsigned int omode, oflags, cmode; int got_cmode = 0; *r_xmode = 0; switch (*modestr) { case 'r': omode = O_RDONLY; oflags = 0; break; case 'w': omode = O_WRONLY; oflags = O_TRUNC | O_CREAT; break; case 'a': omode = O_WRONLY; oflags = O_APPEND | O_CREAT; break; default: _set_errno (EINVAL); return -1; } for (modestr++; *modestr; modestr++) { switch (*modestr) { case '+': omode = O_RDWR; break; case 'b': oflags |= O_BINARY; break; case 'x': oflags |= O_EXCL; break; case ',': goto keyvalue; default: /* Ignore unknown flags. */ break; } } keyvalue: /* Parse key/value pairs (similar to fopen on mainframes). */ for (cmode=0; *modestr == ','; modestr += strcspn (modestr, ",")) { modestr++; modestr += strspn (modestr, " \t"); if (!strncmp (modestr, "mode=", 5)) { static struct { char letter; unsigned int value; } table[] = { { '-', 0 }, { 'r', S_IRUSR }, { 'w', S_IWUSR }, { 'x', S_IXUSR }, { 'r', S_IRGRP }, { 'w', S_IWGRP }, { 'x', S_IXGRP }, { 'r', S_IROTH }, { 'w', S_IWOTH }, { 'x', S_IXOTH }}; int idx; got_cmode = 1; modestr += 5; /* For now we only support a string as used by ls(1) and no octal numbers. The first character must be a dash. */ for (idx=0; idx < 10 && *modestr; idx++, modestr++) { if (*modestr == table[idx].letter) cmode |= table[idx].value; else if (*modestr != '-') break; } if (*modestr && !strchr (" \t,", *modestr)) { _set_errno (EINVAL); return -1; } } else if (!strncmp (modestr, "samethread", 10)) { modestr += 10; if (*modestr && !strchr (" \t,", *modestr)) { _set_errno (EINVAL); return -1; } *r_xmode |= X_SAMETHREAD; } else if (!strncmp (modestr, "nonblock", 8)) { modestr += 8; if (*modestr && !strchr (" \t,", *modestr)) { _set_errno (EINVAL); return -1; } oflags |= O_NONBLOCK; #if HAVE_W32_SYSTEM /* Currently, nonblock implies pollable on Windows. */ *r_xmode |= X_POLLABLE; #endif } else if (!strncmp (modestr, "sysopen", 7)) { modestr += 7; if (*modestr && !strchr (" \t,", *modestr)) { _set_errno (EINVAL); return -1; } *r_xmode |= X_SYSOPEN; } else if (!strncmp (modestr, "pollable", 8)) { modestr += 8; if (*modestr && !strchr (" \t,", *modestr)) { _set_errno (EINVAL); return -1; } *r_xmode |= X_POLLABLE; } else if (!strncmp (modestr, "sequential", 10)) { modestr += 10; if (*modestr && !strchr (" \t,", *modestr)) { _set_errno (EINVAL); return -1; } *r_xmode |= X_SEQUENTIAL; } + else if (!strncmp (modestr, "wipe", 4)) + { + modestr += 10; + if (*modestr && !strchr (" \t,", *modestr)) + { + _set_errno (EINVAL); + return -1; + } + *r_xmode |= X_WIPE; + } } if (!got_cmode) cmode = (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH); *modeflags = (omode | oflags); if (r_cmode) *r_cmode = cmode; return 0; } /* * Low level stream functionality. */ static int fill_stream (estream_t stream) { size_t bytes_read = 0; int err; if (!stream->intern->func_read) { _set_errno (EOPNOTSUPP); err = -1; } else if (!stream->buffer_size) err = 0; else { gpgrt_cookie_read_function_t func_read = stream->intern->func_read; gpgrt_ssize_t ret; ret = (*func_read) (stream->intern->cookie, stream->buffer, stream->buffer_size); if (ret == -1) { bytes_read = 0; err = -1; #if EWOULDBLOCK != EAGAIN if (errno == EWOULDBLOCK) _set_errno (EAGAIN); #endif } else { bytes_read = ret; err = 0; } } if (err) { if (errno != EAGAIN) { if (errno == EPIPE) stream->intern->indicators.hup = 1; stream->intern->indicators.err = 1; } } else if (!bytes_read) stream->intern->indicators.eof = 1; stream->intern->offset += stream->data_len; stream->data_len = bytes_read; stream->data_offset = 0; return err; } static int flush_stream (estream_t stream) { gpgrt_cookie_write_function_t func_write = stream->intern->func_write; int err; gpgrt_assert (stream->flags.writing); if (stream->data_offset) { size_t bytes_written; size_t data_flushed; gpgrt_ssize_t ret; if (! func_write) { _set_errno (EOPNOTSUPP); err = -1; goto out; } /* Note: to prevent an endless loop caused by user-provided write-functions that pretend to have written more bytes than they were asked to write, we have to check for "(stream->data_offset - data_flushed) > 0" instead of "stream->data_offset - data_flushed". */ data_flushed = 0; err = 0; while ((((gpgrt_ssize_t) (stream->data_offset - data_flushed)) > 0) && !err) { ret = (*func_write) (stream->intern->cookie, stream->buffer + data_flushed, stream->data_offset - data_flushed); if (ret == -1) { bytes_written = 0; err = -1; #if EWOULDBLOCK != EAGAIN if (errno == EWOULDBLOCK) _set_errno (EAGAIN); #endif } else bytes_written = ret; data_flushed += bytes_written; if (err) break; } stream->data_flushed += data_flushed; if (stream->data_offset == data_flushed) { stream->intern->offset += stream->data_offset; stream->data_offset = 0; stream->data_flushed = 0; } } else err = 0; /* Always propagate flush event in case gpgrt_fflush was called * explictly to do flush buffers in caller's cookie functions. */ (*func_write) (stream->intern->cookie, NULL, 0); out: if (err && errno != EAGAIN) { if (errno == EPIPE) stream->intern->indicators.hup = 1; stream->intern->indicators.err = 1; } return err; } /* * Discard buffered data for STREAM. */ static void es_empty (estream_t stream) { gpgrt_assert (!stream->flags.writing); stream->data_len = 0; stream->data_offset = 0; stream->unread_data_len = 0; } /* * Initialize STREAM. */ static void init_stream_obj (estream_t stream, void *cookie, es_syshd_t *syshd, gpgrt_stream_backend_kind_t kind, struct cookie_io_functions_s functions, unsigned int modeflags, unsigned int xmode) { stream->intern->kind = kind; stream->intern->cookie = cookie; stream->intern->opaque = NULL; stream->intern->offset = 0; stream->intern->func_read = functions.public.func_read; stream->intern->func_write = functions.public.func_write; stream->intern->func_seek = functions.public.func_seek; stream->intern->func_ioctl = functions.func_ioctl; stream->intern->func_close = functions.public.func_close; stream->intern->strategy = _IOFBF; stream->intern->syshd = *syshd; stream->intern->print_ntotal = 0; stream->intern->indicators.err = 0; stream->intern->indicators.eof = 0; stream->intern->indicators.hup = 0; stream->intern->is_stdstream = 0; stream->intern->stdstream_fd = 0; stream->intern->deallocate_buffer = 0; stream->intern->printable_fname = NULL; stream->intern->printable_fname_inuse = 0; stream->intern->samethread = !! (xmode & X_SAMETHREAD); + stream->intern->wipe = !! (xmode & X_WIPE); stream->intern->onclose = NULL; stream->data_len = 0; stream->data_offset = 0; stream->data_flushed = 0; stream->unread_data_len = 0; /* Depending on the modeflags we set whether we start in writing or reading mode. This is required in case we are working on a stream which is not seeekable (like stdout). Without this pre-initialization we would do a seek at the first write call and as this will fail no output will be delivered. */ if ((modeflags & O_WRONLY) || (modeflags & O_RDWR) ) stream->flags.writing = 1; else stream->flags.writing = 0; } /* * Deinitialize the STREAM object. This does _not_ free the memory, * destroys the lock, or closes the underlying descriptor. */ static int deinit_stream_obj (estream_t stream) { gpgrt_cookie_close_function_t func_close; int err, tmp_err; trace (("enter: stream %p", stream)); func_close = stream->intern->func_close; err = 0; if (stream->flags.writing) { tmp_err = flush_stream (stream); if (!err) err = tmp_err; } if (func_close) { trace (("stream %p calling func_close", stream)); tmp_err = func_close (stream->intern->cookie); if (!err) err = tmp_err; } mem_free (stream->intern->printable_fname); stream->intern->printable_fname = NULL; stream->intern->printable_fname_inuse = 0; while (stream->intern->onclose) { notify_list_t tmp = stream->intern->onclose->next; mem_free (stream->intern->onclose); stream->intern->onclose = tmp; } trace_errno (err, ("leave: stream %p err=%d", stream, err)); return err; } /* * Create a new stream and initialize it. On success the new stream * handle is stored at R_STREAM. On failure NULL is stored at * R_STREAM. */ static int create_stream (estream_t *r_stream, void *cookie, es_syshd_t *syshd, gpgrt_stream_backend_kind_t kind, struct cookie_io_functions_s functions, unsigned int modeflags, unsigned int xmode, int with_locked_list) { estream_internal_t stream_internal_new; estream_t stream_new; int err; #if HAVE_W32_SYSTEM void *old_cookie = NULL; #endif stream_new = NULL; stream_internal_new = NULL; #if HAVE_W32_SYSTEM if ((xmode & X_POLLABLE) && kind != BACKEND_W32) { /* We require the W32 backend, because only that allows us to * write directly using the native W32 API and to disable the * system clamp. Note that func_w32_create has already been * called with the flag to disable the system call clamp. */ _set_errno (EINVAL); err = -1; goto out; } #endif /*HAVE_W32_SYSTEM*/ stream_new = mem_alloc (sizeof (*stream_new)); if (! stream_new) { err = -1; goto out; } stream_internal_new = mem_alloc (sizeof (*stream_internal_new)); if (! stream_internal_new) { err = -1; goto out; } stream_new->buffer = stream_internal_new->buffer; stream_new->buffer_size = sizeof (stream_internal_new->buffer); stream_new->unread_buffer = stream_internal_new->unread_buffer; stream_new->unread_buffer_size = sizeof (stream_internal_new->unread_buffer); stream_new->intern = stream_internal_new; #if HAVE_W32_SYSTEM if ((xmode & X_POLLABLE)) { void *new_cookie; err = _gpgrt_w32_pollable_create (&new_cookie, modeflags, functions, cookie); if (err) goto out; modeflags &= ~O_NONBLOCK; old_cookie = cookie; cookie = new_cookie; kind = BACKEND_W32_POLLABLE; functions = _gpgrt_functions_w32_pollable; } #endif /*HAVE_W32_SYSTEM*/ init_stream_obj (stream_new, cookie, syshd, kind, functions, modeflags, xmode); init_stream_lock (stream_new); err = do_list_add (stream_new, with_locked_list); if (err) goto out; *r_stream = stream_new; out: if (err) { trace_errno (err, ("leave: err=%d", err)); if (stream_new) { deinit_stream_obj (stream_new); destroy_stream_lock (stream_new); mem_free (stream_new->intern); mem_free (stream_new); } } #if HAVE_W32_SYSTEM else if (old_cookie) trace (("leave: success stream=%p cookie=%p,%p", *r_stream, old_cookie, cookie)); #endif else trace (("leave: success stream=%p cookie=%p", *r_stream, cookie)); return err; } /* * Deinitialize a stream object and destroy it. With CANCEL_MODE set * try to cancel as much as possible (see _gpgrt_fcancel). */ static int do_close (estream_t stream, int cancel_mode, int with_locked_list) { int err; trace (("stream %p %s", stream, with_locked_list? "(with locked list)":"")); if (stream) { do_list_remove (stream, with_locked_list); if (cancel_mode) { stream->flags.writing = 0; es_empty (stream); } while (stream->intern->onclose) { notify_list_t tmp = stream->intern->onclose->next; if (stream->intern->onclose->fnc) stream->intern->onclose->fnc (stream, stream->intern->onclose->fnc_value); mem_free (stream->intern->onclose); stream->intern->onclose = tmp; } err = deinit_stream_obj (stream); destroy_stream_lock (stream); if (stream->intern->deallocate_buffer) - mem_free (stream->buffer); - mem_free (stream->intern); + mem_free2 (stream->buffer, stream->buffer_size, stream->intern->wipe); + + mem_free2 (stream->intern, sizeof (struct _gpgrt_stream_internal), + stream->intern->wipe); mem_free (stream); } else err = 0; trace_errno (err, ("stream %p err=%d", stream, err)); return err; } /* * The onclose worker function which is called with a locked * stream. */ static int do_onclose (estream_t stream, int mode, void (*fnc) (estream_t, void*), void *fnc_value) { notify_list_t item; if (!mode) { for (item = stream->intern->onclose; item; item = item->next) if (item->fnc && item->fnc == fnc && item->fnc_value == fnc_value) item->fnc = NULL; /* Disable this notification. */ } else { item = mem_alloc (sizeof *item); if (!item) return -1; item->fnc = fnc; item->fnc_value = fnc_value; item->next = stream->intern->onclose; stream->intern->onclose = item; } return 0; } /* * Try to read BYTES_TO_READ bytes from STREAM into BUFFER in * unbuffered-mode, storing the amount of bytes read at BYTES_READ. */ static int do_read_nbf (estream_t _GPGRT__RESTRICT stream, unsigned char *_GPGRT__RESTRICT buffer, size_t bytes_to_read, size_t *_GPGRT__RESTRICT bytes_read) { gpgrt_cookie_read_function_t func_read = stream->intern->func_read; size_t data_read; gpgrt_ssize_t ret; int err; data_read = 0; err = 0; while (bytes_to_read - data_read) { ret = (*func_read) (stream->intern->cookie, buffer + data_read, bytes_to_read - data_read); if (ret == -1) { err = -1; #if EWOULDBLOCK != EAGAIN if (errno == EWOULDBLOCK) _set_errno (EAGAIN); #endif break; } else if (ret) data_read += ret; else break; } stream->intern->offset += data_read; *bytes_read = data_read; return err; } /* * Helper for check_pending. */ static int check_pending_nbf (estream_t _GPGRT__RESTRICT stream) { gpgrt_cookie_read_function_t func_read = stream->intern->func_read; char buffer[1]; if (!(*func_read) (stream->intern->cookie, buffer, 0)) return 1; /* Pending bytes. */ return 0; /* No pending bytes or error. */ } /* * Try to read BYTES_TO_READ bytes from STREAM into BUFFER in * fully-buffered-mode, storing the amount of bytes read at * BYTES_READ. */ static int do_read_fbf (estream_t _GPGRT__RESTRICT stream, unsigned char *_GPGRT__RESTRICT buffer, size_t bytes_to_read, size_t *_GPGRT__RESTRICT bytes_read) { size_t data_available; size_t data_to_read; size_t data_read; int err; data_read = 0; err = 0; while ((bytes_to_read - data_read) && (! err)) { if (stream->data_offset == stream->data_len) { /* Nothing more to read in current container, try to fill container with new data. */ err = fill_stream (stream); if (! err) if (! stream->data_len) /* Filling did not result in any data read. */ break; } if (! err) { /* Filling resulted in some new data. */ data_to_read = bytes_to_read - data_read; data_available = stream->data_len - stream->data_offset; if (data_to_read > data_available) data_to_read = data_available; memcpy (buffer + data_read, stream->buffer + stream->data_offset, data_to_read); stream->data_offset += data_to_read; data_read += data_to_read; } } *bytes_read = data_read; return err; } /* * Helper for check_pending. */ static int check_pending_fbf (estream_t _GPGRT__RESTRICT stream) { gpgrt_cookie_read_function_t func_read = stream->intern->func_read; char buffer[1]; if (stream->data_offset == stream->data_len) { /* Nothing more to read in current container, check whether it would be possible to fill the container with new data. */ if (!(*func_read) (stream->intern->cookie, buffer, 0)) return 1; /* Pending bytes. */ } else return 1; return 0; } /* * Try to read BYTES_TO_READ bytes from STREAM into BUFFER in * line-buffered-mode, storing the amount of bytes read at BYTES_READ. */ static int do_read_lbf (estream_t _GPGRT__RESTRICT stream, unsigned char *_GPGRT__RESTRICT buffer, size_t bytes_to_read, size_t *_GPGRT__RESTRICT bytes_read) { int err; err = do_read_fbf (stream, buffer, bytes_to_read, bytes_read); return err; } /* * Try to read BYTES_TO_READ bytes from STREAM into BUFFER, storing * the amount of bytes read at BYTES_READ. */ static int es_readn (estream_t _GPGRT__RESTRICT stream, void *_GPGRT__RESTRICT buffer_arg, size_t bytes_to_read, size_t *_GPGRT__RESTRICT bytes_read) { unsigned char *buffer = (unsigned char *)buffer_arg; size_t data_read_unread, data_read; int err; data_read_unread = 0; data_read = 0; err = 0; if (stream->flags.writing) { /* Switching to reading mode -> flush output. */ err = flush_stream (stream); if (err) goto out; stream->flags.writing = 0; } /* Read unread data first. */ while ((bytes_to_read - data_read_unread) && stream->unread_data_len) { buffer[data_read_unread] = stream->unread_buffer[stream->unread_data_len - 1]; stream->unread_data_len--; data_read_unread++; } switch (stream->intern->strategy) { case _IONBF: err = do_read_nbf (stream, buffer + data_read_unread, bytes_to_read - data_read_unread, &data_read); break; case _IOLBF: err = do_read_lbf (stream, buffer + data_read_unread, bytes_to_read - data_read_unread, &data_read); break; case _IOFBF: err = do_read_fbf (stream, buffer + data_read_unread, bytes_to_read - data_read_unread, &data_read); break; } out: if (bytes_read) *bytes_read = data_read_unread + data_read; return err; } /* * Return true if at least one byte is pending for read. This is a * best effort check and it it possible that bytes are still pending * even if false is returned. If the stream is in writing mode it is * switched to read mode. */ static int check_pending (estream_t _GPGRT__RESTRICT stream) { if (stream->flags.writing) { /* Switching to reading mode -> flush output. */ if (flush_stream (stream)) return 0; /* Better return 0 on error. */ stream->flags.writing = 0; } /* Check unread data first. */ if (stream->unread_data_len) return 1; switch (stream->intern->strategy) { case _IONBF: return check_pending_nbf (stream); case _IOLBF: case _IOFBF: return check_pending_fbf (stream); } return 0; } /* * Try to unread DATA_N bytes from DATA into STREAM, storing the * amount of bytes successfully unread at BYTES_UNREAD. */ static void es_unreadn (estream_t _GPGRT__RESTRICT stream, const unsigned char *_GPGRT__RESTRICT data, size_t data_n, size_t *_GPGRT__RESTRICT bytes_unread) { size_t space_left; space_left = stream->unread_buffer_size - stream->unread_data_len; if (data_n > space_left) data_n = space_left; if (! data_n) goto out; memcpy (stream->unread_buffer + stream->unread_data_len, data, data_n); stream->unread_data_len += data_n; stream->intern->indicators.eof = 0; out: if (bytes_unread) *bytes_unread = data_n; } /* * Seek in STREAM. */ static int es_seek (estream_t _GPGRT__RESTRICT stream, gpgrt_off_t offset, int whence, gpgrt_off_t *_GPGRT__RESTRICT offset_new) { gpgrt_cookie_seek_function_t func_seek = stream->intern->func_seek; int err, ret; gpgrt_off_t off; if (! func_seek) { _set_errno (EOPNOTSUPP); err = -1; goto out; } if (stream->flags.writing) { /* Flush data first in order to prevent flushing it to the wrong offset. */ err = flush_stream (stream); if (err) goto out; stream->flags.writing = 0; } off = offset; if (whence == SEEK_CUR) { off = off - stream->data_len + stream->data_offset; off -= stream->unread_data_len; } ret = (*func_seek) (stream->intern->cookie, &off, whence); if (ret == -1) { err = -1; #if EWOULDBLOCK != EAGAIN if (errno == EWOULDBLOCK) _set_errno (EAGAIN); #endif goto out; } err = 0; es_empty (stream); if (offset_new) *offset_new = off; stream->intern->indicators.eof = 0; stream->intern->offset = off; out: if (err) { if (errno == EPIPE) stream->intern->indicators.hup = 1; stream->intern->indicators.err = 1; } return err; } /* * Write BYTES_TO_WRITE bytes from BUFFER into STREAM in * unbuffered-mode, storing the amount of bytes written at * BYTES_WRITTEN. */ static int es_write_nbf (estream_t _GPGRT__RESTRICT stream, const unsigned char *_GPGRT__RESTRICT buffer, size_t bytes_to_write, size_t *_GPGRT__RESTRICT bytes_written) { gpgrt_cookie_write_function_t func_write = stream->intern->func_write; size_t data_written; gpgrt_ssize_t ret; int err; if (bytes_to_write && (! func_write)) { _set_errno (EOPNOTSUPP); err = -1; goto out; } data_written = 0; err = 0; while (bytes_to_write - data_written) { ret = (*func_write) (stream->intern->cookie, buffer + data_written, bytes_to_write - data_written); if (ret == -1) { err = -1; #if EWOULDBLOCK != EAGAIN if (errno == EWOULDBLOCK) _set_errno (EAGAIN); #endif break; } else data_written += ret; } stream->intern->offset += data_written; *bytes_written = data_written; out: return err; } /* * Write BYTES_TO_WRITE bytes from BUFFER into STREAM in * fully-buffered-mode, storing the amount of bytes written at * BYTES_WRITTEN. */ static int es_write_fbf (estream_t _GPGRT__RESTRICT stream, const unsigned char *_GPGRT__RESTRICT buffer, size_t bytes_to_write, size_t *_GPGRT__RESTRICT bytes_written) { size_t space_available; size_t data_to_write; size_t data_written; int err; data_written = 0; err = 0; while ((bytes_to_write - data_written) && (! err)) { if (stream->data_offset == stream->buffer_size) /* Container full, flush buffer. */ err = flush_stream (stream); if (! err) { /* Flushing resulted in empty container. */ data_to_write = bytes_to_write - data_written; space_available = stream->buffer_size - stream->data_offset; if (data_to_write > space_available) data_to_write = space_available; memcpy (stream->buffer + stream->data_offset, buffer + data_written, data_to_write); stream->data_offset += data_to_write; data_written += data_to_write; } } *bytes_written = data_written; return err; } /* Write BYTES_TO_WRITE bytes from BUFFER into STREAM in line-buffered-mode, storing the amount of bytes written in *BYTES_WRITTEN. */ static int es_write_lbf (estream_t _GPGRT__RESTRICT stream, const unsigned char *_GPGRT__RESTRICT buffer, size_t bytes_to_write, size_t *_GPGRT__RESTRICT bytes_written) { size_t data_flushed = 0; size_t data_buffered = 0; unsigned char *nlp; int err = 0; nlp = memrchr (buffer, '\n', bytes_to_write); if (nlp) { /* Found a newline, directly write up to (including) this character. */ err = flush_stream (stream); if (!err) err = es_write_nbf (stream, buffer, nlp - buffer + 1, &data_flushed); } if (!err) { /* Write remaining data fully buffered. */ err = es_write_fbf (stream, buffer + data_flushed, bytes_to_write - data_flushed, &data_buffered); } *bytes_written = data_flushed + data_buffered; return err; } /* Write BYTES_TO_WRITE bytes from BUFFER into STREAM in, storing the amount of bytes written in BYTES_WRITTEN. */ static int es_writen (estream_t _GPGRT__RESTRICT stream, const void *_GPGRT__RESTRICT buffer, size_t bytes_to_write, size_t *_GPGRT__RESTRICT bytes_written) { size_t data_written; int err; data_written = 0; err = 0; if (!stream->flags.writing) { /* Switching to writing mode -> discard input data and seek to position at which reading has stopped. We can do this only if a seek function has been registered. */ if (stream->intern->func_seek) { err = es_seek (stream, 0, SEEK_CUR, NULL); if (err) { if (errno == ESPIPE) err = 0; else goto out; } stream->flags.writing = 1; } } switch (stream->intern->strategy) { case _IONBF: err = es_write_nbf (stream, buffer, bytes_to_write, &data_written); break; case _IOLBF: err = es_write_lbf (stream, buffer, bytes_to_write, &data_written); break; case _IOFBF: err = es_write_fbf (stream, buffer, bytes_to_write, &data_written); break; } out: if (bytes_written) *bytes_written = data_written; return err; } static int peek_stream (estream_t _GPGRT__RESTRICT stream, unsigned char **_GPGRT__RESTRICT data, size_t *_GPGRT__RESTRICT data_len) { int err; if (stream->flags.writing) { /* Switching to reading mode -> flush output. */ err = flush_stream (stream); if (err) goto out; stream->flags.writing = 0; } if (stream->data_offset == stream->data_len) { /* Refill container. */ err = fill_stream (stream); if (err) goto out; } if (data) *data = stream->buffer + stream->data_offset; if (data_len) *data_len = stream->data_len - stream->data_offset; err = 0; out: return err; } /* Skip SIZE bytes of input data contained in buffer. */ static int skip_stream (estream_t stream, size_t size) { int err; if (stream->data_offset + size > stream->data_len) { _set_errno (EINVAL); err = -1; } else { stream->data_offset += size; err = 0; } return err; } static int doreadline (estream_t _GPGRT__RESTRICT stream, size_t max_length, char *_GPGRT__RESTRICT *_GPGRT__RESTRICT line, size_t *_GPGRT__RESTRICT line_length) { size_t line_size; estream_t line_stream; char *line_new; void *line_stream_cookie; char *newline; unsigned char *data; size_t data_len; int err; es_syshd_t syshd; line_new = NULL; line_stream = NULL; line_stream_cookie = NULL; err = func_mem_create (&line_stream_cookie, NULL, 0, 0, - BUFFER_BLOCK_SIZE, 1, + BUFFER_BLOCK_SIZE, 1, stream->intern->wipe, mem_realloc, mem_free, O_RDWR, 0); if (err) goto out; memset (&syshd, 0, sizeof syshd); err = create_stream (&line_stream, line_stream_cookie, &syshd, BACKEND_MEM, estream_functions_mem, O_RDWR, 1, 0); if (err) goto out; { size_t space_left = max_length; line_size = 0; for (;;) { if (max_length && (space_left == 1)) break; err = peek_stream (stream, &data, &data_len); if (err || (! data_len)) break; if (data_len > (space_left - 1)) data_len = space_left - 1; newline = memchr (data, '\n', data_len); if (newline) { data_len = (newline - (char *) data) + 1; err = _gpgrt_write (line_stream, data, data_len, NULL); if (! err) { /* Not needed: space_left -= data_len */ line_size += data_len; skip_stream (stream, data_len); break; /* endless loop */ } } else { err = _gpgrt_write (line_stream, data, data_len, NULL); if (! err) { space_left -= data_len; line_size += data_len; skip_stream (stream, data_len); } } if (err) break; } } if (err) goto out; /* Complete line has been written to line_stream. */ if ((max_length > 1) && (! line_size)) { stream->intern->indicators.eof = 1; goto out; } err = es_seek (line_stream, 0, SEEK_SET, NULL); if (err) goto out; if (! *line) { line_new = mem_alloc (line_size + 1); if (! line_new) { err = -1; goto out; } } else line_new = *line; err = _gpgrt_read (line_stream, line_new, line_size, NULL); if (err) goto out; line_new[line_size] = '\0'; if (! *line) *line = line_new; if (line_length) *line_length = line_size; out: if (line_stream) do_close (line_stream, 0, 0); else if (line_stream_cookie) func_mem_destroy (line_stream_cookie); if (err) { if (! *line) mem_free (line_new); stream->intern->indicators.err = 1; } return err; } /* Output function used by estream_format. */ static int print_writer (void *outfncarg, const char *buf, size_t buflen) { estream_t stream = outfncarg; size_t nwritten; int rc; nwritten = 0; rc = es_writen (stream, buf, buflen, &nwritten); stream->intern->print_ntotal += nwritten; return rc; } /* The core of our printf function. This is called in locked state. */ static int do_print_stream (estream_t _GPGRT__RESTRICT stream, gpgrt_string_filter_t sf, void *sfvalue, const char *_GPGRT__RESTRICT format, va_list ap) { int rc; stream->intern->print_ntotal = 0; rc = _gpgrt_estream_format (print_writer, stream, sf, sfvalue, format, ap); if (rc) return -1; return (int)stream->intern->print_ntotal; } static int es_set_buffering (estream_t _GPGRT__RESTRICT stream, char *_GPGRT__RESTRICT buffer, int mode, size_t size) { int err; /* Flush or empty buffer depending on mode. */ if (stream->flags.writing) { err = flush_stream (stream); if (err) goto out; } else es_empty (stream); stream->intern->indicators.eof = 0; /* Free old buffer in case that was allocated by this function. */ if (stream->intern->deallocate_buffer) { stream->intern->deallocate_buffer = 0; - mem_free (stream->buffer); + mem_free2 (stream->buffer, stream->buffer_size, stream->intern->wipe); stream->buffer = NULL; } if (mode == _IONBF) stream->buffer_size = 0; else { void *buffer_new; if (buffer) buffer_new = buffer; else { if (!size) size = BUFSIZ; buffer_new = mem_alloc (size); if (! buffer_new) { err = -1; goto out; } } stream->buffer = buffer_new; stream->buffer_size = size; if (! buffer) stream->intern->deallocate_buffer = 1; } stream->intern->strategy = mode; err = 0; out: return err; } static gpgrt_off_t es_offset_calculate (estream_t stream) { gpgrt_off_t offset; offset = stream->intern->offset + stream->data_offset; if (offset < stream->unread_data_len) /* Offset undefined. */ offset = 0; else offset -= stream->unread_data_len; return offset; } static void es_opaque_ctrl (estream_t _GPGRT__RESTRICT stream, void *_GPGRT__RESTRICT opaque_new, void **_GPGRT__RESTRICT opaque_old) { if (opaque_old) *opaque_old = stream->intern->opaque; if (opaque_new) stream->intern->opaque = opaque_new; } /* API. */ estream_t _gpgrt_fopen (const char *_GPGRT__RESTRICT path, const char *_GPGRT__RESTRICT mode) { unsigned int modeflags, cmode, xmode; int create_called = 0; estream_t stream = NULL; void *cookie = NULL; int err; struct cookie_io_functions_s *functions; es_syshd_t syshd; int kind; err = parse_mode (mode, &modeflags, &xmode, &cmode); if (err) goto leave; /* Convenience hack so that we can use /dev/null on Windows. */ #ifdef HAVE_W32_SYSTEM if (path && !strcmp (path, "/dev/null")) path = "nul"; #endif #ifdef HAVE_W32_SYSTEM if ((xmode & X_SYSOPEN)) { unsigned int flagsattrs = 0; kind = BACKEND_W32; functions = &estream_functions_w32; syshd.type = ES_SYSHD_HANDLE; if ((xmode & X_SEQUENTIAL)) flagsattrs |= FILE_FLAG_SEQUENTIAL_SCAN; err = func_file_create_w32 (&cookie, &syshd.u.handle, path, modeflags, cmode, flagsattrs); } else #endif /* W32 */ { kind = BACKEND_FD; functions = &estream_functions_fd; syshd.type = ES_SYSHD_FD; err = func_file_create (&cookie, &syshd.u.fd, path, modeflags, cmode); } if (err) goto leave; create_called = 1; err = create_stream (&stream, cookie, &syshd, kind, *functions, modeflags, xmode, 0); if (err) goto leave; if (stream && path) fname_set_internal (stream, path, 1); leave: if (err && create_called) functions->public.func_close (cookie); return stream; } /* Create a new estream object in memory. If DATA is not NULL this buffer will be used as the memory buffer; thus after this functions - returns with the success the the memory at DATA belongs to the new + returns with the success the memory at DATA belongs to the new estream. The allocated length of DATA is given by DATA_LEN and its used length by DATA_N. Usually this is malloced buffer; if a static buffer is provided, the caller must pass false for GROW and provide a dummy function for FUNC_FREE. FUNC_FREE and FUNC_REALLOC allow the caller to provide custom functions for realloc and free to be used by the new estream object. Note that the realloc function is also used for initial allocation. If DATA is NULL a buffer is internally allocated; either using internal function or those provide by the caller. It is an error to provide a realloc function but no free function. Providing only a free function is allowed as long as GROW is false. */ estream_t _gpgrt_mopen (void *_GPGRT__RESTRICT data, size_t data_n, size_t data_len, unsigned int grow, func_realloc_t func_realloc, func_free_t func_free, const char *_GPGRT__RESTRICT mode) { int create_called = 0; estream_t stream = NULL; void *cookie = NULL; unsigned int modeflags, xmode; int err; es_syshd_t syshd; err = parse_mode (mode, &modeflags, &xmode, NULL); if (err) goto out; err = func_mem_create (&cookie, data, data_n, data_len, - BUFFER_BLOCK_SIZE, grow, + BUFFER_BLOCK_SIZE, grow, (xmode & X_WIPE), func_realloc, func_free, modeflags, 0); if (err) goto out; memset (&syshd, 0, sizeof syshd); create_called = 1; err = create_stream (&stream, cookie, &syshd, BACKEND_MEM, estream_functions_mem, modeflags, xmode, 0); out: if (err && create_called) (*estream_functions_mem.public.func_close) (cookie); return stream; } estream_t _gpgrt_fopenmem (size_t memlimit, const char *_GPGRT__RESTRICT mode) { unsigned int modeflags, xmode; estream_t stream = NULL; void *cookie = NULL; es_syshd_t syshd; /* Memory streams are always read/write. We use MODE only to get the append flag. */ if (parse_mode (mode, &modeflags, &xmode, NULL)) return NULL; modeflags |= O_RDWR; if (func_mem_create (&cookie, NULL, 0, 0, - BUFFER_BLOCK_SIZE, 1, + BUFFER_BLOCK_SIZE, 1, (xmode & X_WIPE), mem_realloc, mem_free, modeflags, memlimit)) return NULL; memset (&syshd, 0, sizeof syshd); if (create_stream (&stream, cookie, &syshd, BACKEND_MEM, estream_functions_mem, modeflags, xmode, 0)) (*estream_functions_mem.public.func_close) (cookie); return stream; } /* This is the same as es_fopenmem but intializes the memory with a copy of (DATA,DATALEN). The stream is initially set to the beginning. If MEMLIMIT is not 0 but shorter than DATALEN it DATALEN will be used as the value for MEMLIMIT. */ estream_t _gpgrt_fopenmem_init (size_t memlimit, const char *_GPGRT__RESTRICT mode, const void *data, size_t datalen) { estream_t stream; if (memlimit && memlimit < datalen) memlimit = datalen; stream = _gpgrt_fopenmem (memlimit, mode); if (stream && data && datalen) { if (es_writen (stream, data, datalen, NULL)) { int saveerrno = errno; _gpgrt_fclose (stream); stream = NULL; _set_errno (saveerrno); } else { es_seek (stream, 0L, SEEK_SET, NULL); stream->intern->indicators.eof = 0; stream->intern->indicators.err = 0; } } return stream; } estream_t _gpgrt_fopencookie (void *_GPGRT__RESTRICT cookie, const char *_GPGRT__RESTRICT mode, gpgrt_cookie_io_functions_t functions) { unsigned int modeflags, xmode; estream_t stream; int err; es_syshd_t syshd; struct cookie_io_functions_s io_functions = { functions, NULL }; stream = NULL; modeflags = 0; err = parse_mode (mode, &modeflags, &xmode, NULL); if (err) goto out; memset (&syshd, 0, sizeof syshd); err = create_stream (&stream, cookie, &syshd, BACKEND_USER, io_functions, modeflags, xmode, 0); if (err) goto out; out: return stream; } static estream_t do_fdopen (int filedes, const char *mode, int no_close, int with_locked_list) { int create_called = 0; estream_t stream = NULL; void *cookie = NULL; unsigned int modeflags, xmode; int err; es_syshd_t syshd; err = parse_mode (mode, &modeflags, &xmode, NULL); if (err) goto out; if ((xmode & X_SYSOPEN)) { /* Not allowed for fdopen. */ _set_errno (EINVAL); err = -1; goto out; } err = func_fd_create (&cookie, filedes, modeflags, no_close); if (err) goto out; syshd.type = ES_SYSHD_FD; syshd.u.fd = filedes; create_called = 1; err = create_stream (&stream, cookie, &syshd, BACKEND_FD, estream_functions_fd, modeflags, xmode, with_locked_list); if (!err && stream) { if ((modeflags & O_NONBLOCK)) err = stream->intern->func_ioctl (cookie, COOKIE_IOCTL_NONBLOCK, "", NULL); } out: if (err && create_called) (*estream_functions_fd.public.func_close) (cookie); return stream; } estream_t _gpgrt_fdopen (int filedes, const char *mode) { return do_fdopen (filedes, mode, 0, 0); } /* A variant of es_fdopen which does not close FILEDES at the end. */ estream_t _gpgrt_fdopen_nc (int filedes, const char *mode) { return do_fdopen (filedes, mode, 1, 0); } static estream_t do_fpopen (FILE *fp, const char *mode, int no_close, int with_locked_list) { unsigned int modeflags, cmode, xmode; int create_called = 0; estream_t stream = NULL; void *cookie = NULL; int err; es_syshd_t syshd; err = parse_mode (mode, &modeflags, &xmode, &cmode); if (err) goto out; if ((xmode & X_SYSOPEN)) { /* Not allowed for fpopen. */ _set_errno (EINVAL); err = -1; goto out; } if (fp) fflush (fp); err = func_fp_create (&cookie, fp, modeflags, no_close); if (err) goto out; syshd.type = ES_SYSHD_FD; syshd.u.fd = fp? fileno (fp): -1; create_called = 1; err = create_stream (&stream, cookie, &syshd, BACKEND_FP, estream_functions_fp, modeflags, xmode, with_locked_list); out: if (err && create_called) (*estream_functions_fp.public.func_close) (cookie); return stream; } /* Create an estream from the stdio stream FP. This mechanism is useful in case the stdio streams have special properties and may not be mixed with fd based functions. This is for example the case under Windows where the 3 standard streams are associated with the console whereas a duped and fd-opened stream of one of this stream won't be associated with the console. As this messes things up it is easier to keep on using the standard I/O stream as a backend for estream. */ estream_t _gpgrt_fpopen (FILE *fp, const char *mode) { return do_fpopen (fp, mode, 0, 0); } /* Same as es_fpopen but does not close FP at the end. */ estream_t _gpgrt_fpopen_nc (FILE *fp, const char *mode) { return do_fpopen (fp, mode, 1, 0); } #ifdef HAVE_W32_SYSTEM static estream_t do_sockopen (SOCKET sock, const char *mode, int no_close, int with_locked_list) { int create_called = 0; estream_t stream = NULL; void *cookie = NULL; unsigned int modeflags, xmode; int err; es_syshd_t syshd; err = parse_mode (mode, &modeflags, &xmode, NULL); if (err) goto out; if ((xmode & X_SYSOPEN)) { /* Not allowed for sockopen. */ _set_errno (EINVAL); err = -1; goto out; } err = func_sock_create (&cookie, sock, modeflags, no_close); if (err) goto out; syshd.type = ES_SYSHD_SOCK; syshd.u.sock = sock; create_called = 1; err = create_stream (&stream, cookie, &syshd, BACKEND_SOCK, estream_functions_sock, modeflags, xmode, with_locked_list); if (!err && stream) { if ((modeflags & O_NONBLOCK)) err = stream->intern->func_ioctl (cookie, COOKIE_IOCTL_NONBLOCK, "", NULL); } out: if (err && create_called) (*estream_functions_sock.public.func_close) (cookie); return stream; } estream_t do_w32open (HANDLE hd, const char *mode, int no_close, int with_locked_list) { unsigned int modeflags, cmode, xmode; int create_called = 0; estream_t stream = NULL; void *cookie = NULL; int err; es_syshd_t syshd; /* For obvious reasons we ignore sysmode here. */ err = parse_mode (mode, &modeflags, &xmode, &cmode); if (err) goto leave; /* If we are pollable we create the function cookie with syscall * clamp disabled. This is because functions are called from * separate reader and writer threads in w32-stream. */ err = func_w32_create (&cookie, hd, modeflags, no_close, !!(xmode & X_POLLABLE)); if (err) goto leave; syshd.type = ES_SYSHD_HANDLE; syshd.u.handle = hd; create_called = 1; err = create_stream (&stream, cookie, &syshd, BACKEND_W32, estream_functions_w32, modeflags, xmode, with_locked_list); leave: if (err && create_called) (*estream_functions_w32.public.func_close) (cookie); return stream; } #endif /*HAVE_W32_SYSTEM*/ static estream_t do_sysopen (es_syshd_t *syshd, const char *mode, int no_close) { estream_t stream; switch (syshd->type) { case ES_SYSHD_FD: #ifndef HAVE_W32_SYSTEM case ES_SYSHD_SOCK: #endif stream = do_fdopen (syshd->u.fd, mode, no_close, 0); break; #ifdef HAVE_W32_SYSTEM case ES_SYSHD_SOCK: stream = do_sockopen (syshd->u.sock, mode, no_close, 0); break; case ES_SYSHD_HANDLE: stream = do_w32open (syshd->u.handle, mode, no_close, 0); break; #endif /* FIXME: Support RVIDs under Wince? */ default: _set_errno (EINVAL); stream = NULL; } return stream; } /* On POSIX systems this function is an alias for es_fdopen. Under Windows it uses the bare W32 API and thus a HANDLE instead of a file descriptor. */ estream_t _gpgrt_sysopen (es_syshd_t *syshd, const char *mode) { return do_sysopen (syshd, mode, 0); } /* Same as es_sysopen but the handle/fd will not be closed by es_fclose. */ estream_t _gpgrt_sysopen_nc (es_syshd_t *syshd, const char *mode) { return do_sysopen (syshd, mode, 1); } /* Set custom standard descriptors to be used for stdin, stdout and stderr. This function needs to be called before any of the standard streams are accessed. This internal version uses a double dash inside its name. */ void _gpgrt__set_std_fd (int no, int fd) { /* fprintf (stderr, "es_set_std_fd(%d, %d)\n", no, fd); */ lock_list (); if (no >= 0 && no < 3 && !custom_std_fds_valid[no]) { custom_std_fds[no] = fd; custom_std_fds_valid[no] = 1; } unlock_list (); } /* Return the stream used for stdin, stdout or stderr. This internal version uses a double dash inside its name. */ estream_t _gpgrt__get_std_stream (int fd) { estream_list_t list_obj; estream_t stream = NULL; fd %= 3; /* We only allow 0, 1 or 2 but we don't want to return an error. */ lock_list (); for (list_obj = estream_list; list_obj; list_obj = list_obj->next) if (list_obj->stream && list_obj->stream->intern->is_stdstream && list_obj->stream->intern->stdstream_fd == fd) { stream = list_obj->stream; break; } if (!stream) { /* Standard stream not yet created. We first try to create them from registered file descriptors. */ if (!fd && custom_std_fds_valid[0]) stream = do_fdopen (custom_std_fds[0], "r", 1, 1); else if (fd == 1 && custom_std_fds_valid[1]) stream = do_fdopen (custom_std_fds[1], "a", 1, 1); else if (custom_std_fds_valid[2]) stream = do_fdopen (custom_std_fds[2], "a", 1, 1); if (!stream) { /* Second try is to use the standard C streams. */ if (!fd) stream = do_fpopen (stdin, "r", 1, 1); else if (fd == 1) stream = do_fpopen (stdout, "a", 1, 1); else stream = do_fpopen (stderr, "a", 1, 1); } if (!stream) { /* Last try: Create a bit bucket. */ stream = do_fpopen (NULL, fd? "a":"r", 0, 1); if (!stream) { fprintf (stderr, "fatal: error creating a dummy estream" " for %d: %s\n", fd, strerror (errno)); _gpgrt_abort(); } } stream->intern->is_stdstream = 1; stream->intern->stdstream_fd = fd; if (fd == 2) es_set_buffering (stream, NULL, _IOLBF, 0); fname_set_internal (stream, fd == 0? "[stdin]" : fd == 1? "[stdout]" : "[stderr]", 0); } unlock_list (); return stream; } /* Note: A "samethread" keyword given in "mode" is ignored and the * value used by STREAM is used instead. Note that this function is * the reasons why some of the init and deinit code is split up into * several functions. */ estream_t _gpgrt_freopen (const char *_GPGRT__RESTRICT path, const char *_GPGRT__RESTRICT mode, estream_t _GPGRT__RESTRICT stream) { int err; if (path) { unsigned int modeflags, cmode, xmode, dummy; int create_called; void *cookie; int fd; es_syshd_t syshd; cookie = NULL; create_called = 0; /* Convenience hack so that we can use /dev/null on Windows. */ #ifdef HAVE_W32_SYSTEM if (!strcmp (path, "/dev/null")) path = "nul"; #endif xmode = stream->intern->samethread ? X_SAMETHREAD : 0; lock_stream (stream); deinit_stream_obj (stream); err = parse_mode (mode, &modeflags, &dummy, &cmode); if (err) goto leave; (void)dummy; err = func_file_create (&cookie, &fd, path, modeflags, cmode); if (err) goto leave; syshd.type = ES_SYSHD_FD; syshd.u.fd = fd; create_called = 1; init_stream_obj (stream, cookie, &syshd, BACKEND_FD, estream_functions_fd, modeflags, xmode); leave: if (err) { if (create_called) func_fd_destroy (cookie); do_close (stream, 0, 0); stream = NULL; } else { if (path) fname_set_internal (stream, path, 1); unlock_stream (stream); } } else { /* FIXME? We don't support re-opening at the moment. */ _set_errno (EINVAL); deinit_stream_obj (stream); do_close (stream, 0, 0); stream = NULL; } return stream; } int _gpgrt_fclose (estream_t stream) { int err; err = do_close (stream, 0, 0); return err; } /* gpgrt_fcancel does the same as gpgrt_fclose but tries to avoid * flushing out any data still held in internal buffers. It may or * may not remove a new file created for that stream by the open * function. */ int _gpgrt_fcancel (estream_t stream) { int err; err = do_close (stream, 1, 0); return err; } /* This is a special version of es_fclose which can be used with es_fopenmem to return the memory buffer. This is feature is useful to write to a memory buffer using estream. Note that the function does not close the stream if the stream does not support snatching the buffer. On error NULL is stored at R_BUFFER. Note that if no write operation has happened, NULL may also be stored at BUFFER on success. The caller needs to release the returned memory using gpgrt_free. */ int _gpgrt_fclose_snatch (estream_t stream, void **r_buffer, size_t *r_buflen) { int err; /* Note: There is no need to lock the stream in a close call. The object will be destroyed after the close and thus any other contender for the lock would work on a closed stream. */ if (r_buffer) { cookie_ioctl_function_t func_ioctl = stream->intern->func_ioctl; size_t buflen; *r_buffer = NULL; if (!func_ioctl) { _set_errno (EOPNOTSUPP); err = -1; goto leave; } if (stream->flags.writing) { err = flush_stream (stream); if (err) goto leave; stream->flags.writing = 0; } err = func_ioctl (stream->intern->cookie, COOKIE_IOCTL_SNATCH_BUFFER, r_buffer, &buflen); if (err) goto leave; if (r_buflen) *r_buflen = buflen; } err = do_close (stream, 0, 0); leave: if (err && r_buffer) { mem_free (*r_buffer); *r_buffer = NULL; } return err; } /* Register or unregister a close notification function for STREAM. FNC is the function to call and FNC_VALUE the value passed as second argument. To register the notification the value for MODE must be 1. If mode is 0 the function tries to remove or disable an already registered notification; for this to work the value of FNC and FNC_VALUE must be the same as with the registration and FNC_VALUE must be a unique value. No error will be returned if MODE is 0. FIXME: I think the next comment is not anymore correct: Unregister should only be used in the error case because it may not be able to remove memory internally allocated for the onclose handler. FIXME: Unregister is not thread safe. The notification will be called right before the stream is closed. If gpgrt_fcancel is used, the cancellation of internal buffers is done before the notifications. The notification handler may not call any estream function for STREAM, neither direct nor indirectly. */ int _gpgrt_onclose (estream_t stream, int mode, void (*fnc) (estream_t, void*), void *fnc_value) { int err; lock_stream (stream); err = do_onclose (stream, mode, fnc, fnc_value); unlock_stream (stream); return err; } int _gpgrt_fileno_unlocked (estream_t stream) { es_syshd_t syshd; if (_gpgrt_syshd_unlocked (stream, &syshd)) return -1; switch (syshd.type) { case ES_SYSHD_FD: return syshd.u.fd; case ES_SYSHD_SOCK: return syshd.u.sock; default: _set_errno (EINVAL); return -1; } } /* Return the handle of a stream which has been opened by es_sysopen. The caller needs to pass a structure which will be filled with the sys handle. Return 0 on success or true on error and sets errno. This is the unlocked version. */ int _gpgrt_syshd_unlocked (estream_t stream, es_syshd_t *syshd) { if (!stream || !syshd || stream->intern->syshd.type == ES_SYSHD_NONE) { if (syshd) syshd->type = ES_SYSHD_NONE; _set_errno (EINVAL); return -1; } *syshd = stream->intern->syshd; return 0; } void _gpgrt_flockfile (estream_t stream) { lock_stream (stream); } int _gpgrt_ftrylockfile (estream_t stream) { return trylock_stream (stream); } void _gpgrt_funlockfile (estream_t stream) { unlock_stream (stream); } int _gpgrt_fileno (estream_t stream) { int ret; lock_stream (stream); ret = _gpgrt_fileno_unlocked (stream); unlock_stream (stream); return ret; } /* Return the handle of a stream which has been opened by es_sysopen. The caller needs to pass a structure which will be filled with the sys handle. Return 0 on success or true on error and sets errno. This is the unlocked version. */ int _gpgrt_syshd (estream_t stream, es_syshd_t *syshd) { int ret; lock_stream (stream); ret = _gpgrt_syshd_unlocked (stream, syshd); unlock_stream (stream); return ret; } int _gpgrt__pending_unlocked (estream_t stream) { return check_pending (stream); } /* Return true if there is at least one byte pending for read on STREAM. This does only work if the backend supports checking for pending bytes and is thus mostly useful with cookie based backends. Note that if this function is used with cookie based functions, the read cookie may be called with 0 for the SIZE argument. If bytes are pending the function is expected to return -1 in this case and thus deviates from the standard behavior of read(2). */ int _gpgrt__pending (estream_t stream) { int ret; lock_stream (stream); ret = _gpgrt__pending_unlocked (stream); unlock_stream (stream); return ret; } int _gpgrt_feof_unlocked (estream_t stream) { return stream->intern->indicators.eof; } int _gpgrt_feof (estream_t stream) { int ret; lock_stream (stream); ret = _gpgrt_feof_unlocked (stream); unlock_stream (stream); return ret; } int _gpgrt_ferror_unlocked (estream_t stream) { return stream->intern->indicators.err; } int _gpgrt_ferror (estream_t stream) { int ret; lock_stream (stream); ret = _gpgrt_ferror_unlocked (stream); unlock_stream (stream); return ret; } void _gpgrt_clearerr_unlocked (estream_t stream) { stream->intern->indicators.eof = 0; stream->intern->indicators.err = 0; /* We do not reset the HUP indicator because there is no way to get out of this state. */ } void _gpgrt_clearerr (estream_t stream) { lock_stream (stream); _gpgrt_clearerr_unlocked (stream); unlock_stream (stream); } static int do_fflush (estream_t stream) { int err; if (stream->flags.writing) err = flush_stream (stream); else { es_empty (stream); err = 0; } return err; } int _gpgrt_fflush (estream_t stream) { int err; if (stream) { lock_stream (stream); err = do_fflush (stream); unlock_stream (stream); } else { estream_list_t item; err = 0; lock_list (); for (item = estream_list; item; item = item->next) if (item->stream) { lock_stream (item->stream); err |= do_fflush (item->stream); unlock_stream (item->stream); } unlock_list (); } return err ? EOF : 0; } int _gpgrt_fseek (estream_t stream, long int offset, int whence) { int err; lock_stream (stream); err = es_seek (stream, offset, whence, NULL); unlock_stream (stream); return err; } int _gpgrt_fseeko (estream_t stream, gpgrt_off_t offset, int whence) { int err; lock_stream (stream); err = es_seek (stream, offset, whence, NULL); unlock_stream (stream); return err; } long int _gpgrt_ftell (estream_t stream) { long int ret; lock_stream (stream); ret = es_offset_calculate (stream); unlock_stream (stream); return ret; } gpgrt_off_t _gpgrt_ftello (estream_t stream) { gpgrt_off_t ret = -1; lock_stream (stream); ret = es_offset_calculate (stream); unlock_stream (stream); return ret; } void _gpgrt_rewind (estream_t stream) { lock_stream (stream); es_seek (stream, 0L, SEEK_SET, NULL); /* Note that es_seek already cleared the EOF flag. */ stream->intern->indicators.err = 0; unlock_stream (stream); } int _gpgrt_ftruncate (estream_t stream, gpgrt_off_t length) { cookie_ioctl_function_t func_ioctl; int ret; lock_stream (stream); func_ioctl = stream->intern->func_ioctl; if (!func_ioctl) { _set_errno (EOPNOTSUPP); ret = -1; } else { ret = func_ioctl (stream->intern->cookie, COOKIE_IOCTL_TRUNCATE, &length, NULL); } unlock_stream (stream); return ret; } int _gpgrt__getc_underflow (estream_t stream) { int err; unsigned char c; size_t bytes_read; err = es_readn (stream, &c, 1, &bytes_read); return (err || (! bytes_read)) ? EOF : c; } int _gpgrt__putc_overflow (int c, estream_t stream) { unsigned char d = c; int err; err = es_writen (stream, &d, 1, NULL); return err ? EOF : c; } int _gpgrt_fgetc (estream_t stream) { int ret; lock_stream (stream); ret = _gpgrt_getc_unlocked (stream); unlock_stream (stream); return ret; } int _gpgrt_fputc (int c, estream_t stream) { int ret; lock_stream (stream); ret = _gpgrt_putc_unlocked (c, stream); unlock_stream (stream); return ret; } int _gpgrt_ungetc (int c, estream_t stream) { unsigned char data = (unsigned char) c; size_t data_unread; lock_stream (stream); es_unreadn (stream, &data, 1, &data_unread); unlock_stream (stream); return data_unread ? c : EOF; } int _gpgrt_read (estream_t _GPGRT__RESTRICT stream, void *_GPGRT__RESTRICT buffer, size_t bytes_to_read, size_t *_GPGRT__RESTRICT bytes_read) { int err; if (bytes_to_read) { lock_stream (stream); err = es_readn (stream, buffer, bytes_to_read, bytes_read); unlock_stream (stream); } else err = 0; return err; } int _gpgrt_write (estream_t _GPGRT__RESTRICT stream, const void *_GPGRT__RESTRICT buffer, size_t bytes_to_write, size_t *_GPGRT__RESTRICT bytes_written) { int err; if (bytes_to_write) { lock_stream (stream); err = es_writen (stream, buffer, bytes_to_write, bytes_written); unlock_stream (stream); } else err = 0; return err; } size_t _gpgrt_fread (void *_GPGRT__RESTRICT ptr, size_t size, size_t nitems, estream_t _GPGRT__RESTRICT stream) { size_t ret, bytes; if (size && nitems) { lock_stream (stream); es_readn (stream, ptr, size * nitems, &bytes); unlock_stream (stream); ret = bytes / size; } else ret = 0; return ret; } size_t _gpgrt_fwrite (const void *_GPGRT__RESTRICT ptr, size_t size, size_t nitems, estream_t _GPGRT__RESTRICT stream) { size_t ret, bytes; if (size && nitems) { lock_stream (stream); es_writen (stream, ptr, size * nitems, &bytes); unlock_stream (stream); ret = bytes / size; } else ret = 0; return ret; } char * _gpgrt_fgets (char *_GPGRT__RESTRICT buffer, int length, estream_t _GPGRT__RESTRICT stream) { unsigned char *s = (unsigned char*)buffer; int c; if (!length) return NULL; c = EOF; lock_stream (stream); while (length > 1 && (c = _gpgrt_getc_unlocked (stream)) != EOF && c != '\n') { *s++ = c; length--; } unlock_stream (stream); if (c == EOF && s == (unsigned char*)buffer) return NULL; /* Nothing read. */ if (c != EOF && length > 1) *s++ = c; *s = 0; return buffer; } int _gpgrt_fputs_unlocked (const char *_GPGRT__RESTRICT s, estream_t _GPGRT__RESTRICT stream) { size_t length; int err; length = strlen (s); err = es_writen (stream, s, length, NULL); return err ? EOF : 0; } int _gpgrt_fputs (const char *_GPGRT__RESTRICT s, estream_t _GPGRT__RESTRICT stream) { size_t length; int err; length = strlen (s); lock_stream (stream); err = es_writen (stream, s, length, NULL); unlock_stream (stream); return err ? EOF : 0; } gpgrt_ssize_t _gpgrt_getline (char *_GPGRT__RESTRICT *_GPGRT__RESTRICT lineptr, size_t *_GPGRT__RESTRICT n, estream_t _GPGRT__RESTRICT stream) { char *line = NULL; size_t line_n = 0; int err; lock_stream (stream); err = doreadline (stream, 0, &line, &line_n); unlock_stream (stream); if (err) goto out; if (*n) { /* Caller wants us to use his buffer. */ if (*n < (line_n + 1)) { /* Provided buffer is too small -> resize. */ void *p; p = mem_realloc (*lineptr, line_n + 1); if (! p) err = -1; else { if (*lineptr != p) *lineptr = p; } } if (! err) { memcpy (*lineptr, line, line_n + 1); if (*n != line_n) *n = line_n; } mem_free (line); } else { /* Caller wants new buffers. */ *lineptr = line; *n = line_n; } out: return err ? err : (gpgrt_ssize_t)line_n; } /* Same as fgets() but if the provided buffer is too short a larger one will be allocated. This is similar to getline. A line is considered a byte stream ending in a LF. If MAX_LENGTH is not NULL, it shall point to a value with the maximum allowed allocation. Returns the length of the line. EOF is indicated by a line of length zero. A truncated line is indicated my setting the value at MAX_LENGTH to 0. If the returned value is less then 0 not enough memory was available or another error occurred; ERRNO is then set accordingly. If a line has been truncated, the file pointer is moved forward to the end of the line so that the next read starts with the next line. Note that MAX_LENGTH must be re-initialized in this case. The caller initially needs to provide the address of a variable, initialized to NULL, at ADDR_OF_BUFFER and don't change this value anymore with the following invocations. LENGTH_OF_BUFFER should be the address of a variable, initialized to 0, which is also maintained by this function. Thus, both paramaters should be considered the state of this function. Note: The returned buffer is allocated with enough extra space to allow the caller to append a CR,LF,Nul. The buffer should be released using gpgrt_free. */ gpgrt_ssize_t _gpgrt_read_line (estream_t stream, char **addr_of_buffer, size_t *length_of_buffer, size_t *max_length) { int c; char *buffer = *addr_of_buffer; size_t length = *length_of_buffer; size_t nbytes = 0; size_t maxlen = max_length? *max_length : 0; char *p; if (!buffer) { /* No buffer given - allocate a new one. */ length = 256; buffer = mem_alloc (length); *addr_of_buffer = buffer; if (!buffer) { *length_of_buffer = 0; if (max_length) *max_length = 0; return -1; } *length_of_buffer = length; } if (length < 4) { /* This should never happen. If it does, the function has been called with wrong arguments. */ _set_errno (EINVAL); return -1; } length -= 3; /* Reserve 3 bytes for CR,LF,EOL. */ lock_stream (stream); p = buffer; while ((c = _gpgrt_getc_unlocked (stream)) != EOF) { if (nbytes == length) { /* Enlarge the buffer. */ if (maxlen && length > maxlen) { /* We are beyond our limit: Skip the rest of the line. */ while (c != '\n' && (c=_gpgrt_getc_unlocked (stream)) != EOF) ; *p++ = '\n'; /* Always append a LF (we reserved some space). */ nbytes++; if (max_length) *max_length = 0; /* Indicate truncation. */ break; /* the while loop. */ } length += 3; /* Adjust for the reserved bytes. */ length += length < 1024? 256 : 1024; *addr_of_buffer = mem_realloc (buffer, length); if (!*addr_of_buffer) { int save_errno = errno; mem_free (buffer); *length_of_buffer = 0; if (max_length) *max_length = 0; unlock_stream (stream); _set_errno (save_errno); return -1; } buffer = *addr_of_buffer; *length_of_buffer = length; length -= 3; p = buffer + nbytes; } *p++ = c; nbytes++; if (c == '\n') break; } *p = 0; /* Make sure the line is a string. */ unlock_stream (stream); return nbytes; } /* Wrapper around free() to match the memory allocation system used by estream. Should be used for all buffers returned to the caller by libestream. If a custom allocation handler has been set with gpgrt_set_alloc_func that register function may be used instead. This function has been moved to init.c. */ /* void */ /* _gpgrt_free (void *a) */ /* { */ /* mem_free (a); */ /* } */ int _gpgrt_vfprintf_unlocked (estream_t _GPGRT__RESTRICT stream, gpgrt_string_filter_t sf, void *sfvalue, const char *_GPGRT__RESTRICT format, va_list ap) { return do_print_stream (stream, sf, sfvalue, format, ap); } int _gpgrt_vfprintf (estream_t _GPGRT__RESTRICT stream, gpgrt_string_filter_t sf, void *sfvalue, const char *_GPGRT__RESTRICT format, va_list ap) { int ret; lock_stream (stream); ret = do_print_stream (stream, sf, sfvalue, format, ap); unlock_stream (stream); return ret; } int _gpgrt_fprintf_unlocked (estream_t _GPGRT__RESTRICT stream, const char *_GPGRT__RESTRICT format, ...) { int ret; va_list ap; va_start (ap, format); ret = do_print_stream (stream, NULL, NULL, format, ap); va_end (ap); return ret; } int _gpgrt_fprintf (estream_t _GPGRT__RESTRICT stream, const char *_GPGRT__RESTRICT format, ...) { int ret; va_list ap; va_start (ap, format); lock_stream (stream); ret = do_print_stream (stream, NULL, NULL, format, ap); unlock_stream (stream); va_end (ap); return ret; } static int tmpfd (void) { #ifdef HAVE_W32_SYSTEM int attempts, n; char buffer[MAX_PATH+9+12+1]; # define mystrlen(a) strlen (a) char *name, *p; HANDLE file; int pid = GetCurrentProcessId (); unsigned int value; int i; n = GetTempPath (MAX_PATH+1, buffer); if (!n || n > MAX_PATH || mystrlen (buffer) > MAX_PATH) { _set_errno (ENOENT); return -1; } p = buffer + mystrlen (buffer); strcpy (p, "_estream"); p += 8; /* We try to create the directory but don't care about an error as it may already exist and the CreateFile would throw an error anyway. */ CreateDirectory (buffer, NULL); *p++ = '\\'; name = p; for (attempts=0; attempts < 10; attempts++) { p = name; value = (GetTickCount () ^ ((pid<<16) & 0xffff0000)); for (i=0; i < 8; i++) { *p++ = tohex (((value >> 28) & 0x0f)); value <<= 4; } strcpy (p, ".tmp"); file = CreateFile (buffer, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_NEW, FILE_ATTRIBUTE_TEMPORARY | FILE_FLAG_DELETE_ON_CLOSE, NULL); if (file != INVALID_HANDLE_VALUE) { int fd = _open_osfhandle ((intptr_t)file, 0); if (fd == -1) { CloseHandle (file); return -1; } return fd; } Sleep (1); /* One ms as this is the granularity of GetTickCount. */ } _set_errno (ENOENT); return -1; #else /*!HAVE_W32_SYSTEM*/ FILE *fp; int fp_fd; int fd; fp = NULL; fd = -1; fp = tmpfile (); if (! fp) goto out; fp_fd = fileno (fp); fd = dup (fp_fd); out: if (fp) fclose (fp); return fd; #endif /*!HAVE_W32_SYSTEM*/ } estream_t _gpgrt_tmpfile (void) { unsigned int modeflags; int create_called = 0; estream_t stream = NULL; void *cookie = NULL; int err; int fd; es_syshd_t syshd; modeflags = O_RDWR | O_TRUNC | O_CREAT; fd = tmpfd (); if (fd == -1) { err = -1; goto out; } err = func_fd_create (&cookie, fd, modeflags, 0); if (err) goto out; syshd.type = ES_SYSHD_FD; syshd.u.fd = fd; create_called = 1; err = create_stream (&stream, cookie, &syshd, BACKEND_FD, estream_functions_fd, modeflags, 0, 0); out: if (err) { if (create_called) func_fd_destroy (cookie); else if (fd != -1) close (fd); stream = NULL; } return stream; } int _gpgrt_setvbuf (estream_t _GPGRT__RESTRICT stream, char *_GPGRT__RESTRICT buf, int type, size_t size) { int err; if ((type == _IOFBF || type == _IOLBF || type == _IONBF) && (!buf || size || type == _IONBF)) { lock_stream (stream); err = es_set_buffering (stream, buf, type, size); unlock_stream (stream); } else { _set_errno (EINVAL); err = -1; } return err; } /* Put a stream into binary mode. This is only needed for the standard streams if they are to be used in a binary way. On Unix systems it is never needed but MSDOS based systems require such a call. It needs to be called before any I/O is done on STREAM. */ void _gpgrt_set_binary (estream_t stream) { lock_stream (stream); if (!(stream->intern->modeflags & O_BINARY)) { stream->intern->modeflags |= O_BINARY; #ifdef HAVE_DOSISH_SYSTEM if (stream->intern->func_read == func_fd_read) { estream_cookie_fd_t fd_cookie = stream->intern->cookie; if (!IS_INVALID_FD (fd_cookie->fd)) setmode (fd_cookie->fd, O_BINARY); } else if (stream->intern->func_read == func_fp_read) { estream_cookie_fp_t fp_cookie = stream->intern->cookie; if (fp_cookie->fp) setmode (fileno (fp_cookie->fp), O_BINARY); } #endif } unlock_stream (stream); } /* Set non-blocking mode for STREAM. Use true for ONOFF to enable and false to disable non-blocking mode. Returns 0 on success or -1 on error and sets ERRNO. Note that not all backends support non-blocking mode. In non-blocking mode a system call will not block but return an error and set errno to EAGAIN. The estream API always uses EAGAIN and not EWOULDBLOCK. If a buffered function like es_fgetc() or es_fgets() returns an error and both, feof() and ferror() return false the caller may assume that the error condition was EAGAIN. Switching back from non-blocking to blocking may raise problems with buffering, thus care should be taken. Although read+write sockets are supported in theory, switching from write to read may result into problems because estream may first flush the write buffers and there is no way to handle that non-blocking (EAGAIN) case. Explicit flushing should thus be done before before switching to read. */ int _gpgrt_set_nonblock (estream_t stream, int onoff) { cookie_ioctl_function_t func_ioctl; int ret; lock_stream (stream); func_ioctl = stream->intern->func_ioctl; if (!func_ioctl) { _set_errno (EOPNOTSUPP); ret = -1; } else { unsigned int save_flags = stream->intern->modeflags; if (onoff) stream->intern->modeflags |= O_NONBLOCK; else stream->intern->modeflags &= ~O_NONBLOCK; ret = func_ioctl (stream->intern->cookie, COOKIE_IOCTL_NONBLOCK, onoff?"":NULL, NULL); if (ret) stream->intern->modeflags = save_flags; } unlock_stream (stream); return ret; } /* Return true if STREAM is in non-blocking mode. */ int _gpgrt_get_nonblock (estream_t stream) { int ret; lock_stream (stream); ret = !!(stream->intern->modeflags & O_NONBLOCK); unlock_stream (stream); return ret; } /* A version of poll(2) working on estream handles. Note that not all estream types work with this function. In contrast to the standard poll function the gpgrt_poll_t object uses a set of bit flags instead of the EVENTS and REVENTS members. An item with the IGNORE flag set is entirely ignored. The TIMEOUT values is given in milliseconds, a value of -1 waits indefinitely, and a value of 0 returns immediately. A positive return value gives the number of fds with new information. A return value of 0 indicates a timeout and -1 indicates an error in which case ERRNO is set. */ int _gpgrt_poll (gpgrt_poll_t *fds, unsigned int nfds, int timeout) { gpgrt_poll_t *item; int count = 0; int idx; #ifndef HAVE_W32_SYSTEM # ifdef HAVE_POLL_H struct pollfd *poll_fds = NULL; nfds_t poll_nfds; # else fd_set readfds, writefds, exceptfds; int any_readfd, any_writefd, any_exceptfd; int max_fd; #endif int fd, ret, any; #endif /*HAVE_W32_SYSTEM*/ trace (("enter: nfds=%u timeout=%d", nfds, timeout)); if (!fds) { _set_errno (EINVAL); count = -1; goto leave; } /* Clear all response fields (even for ignored items). */ for (item = fds, idx = 0; idx < nfds; item++, idx++) { item->got_read = 0; item->got_write = 0; item->got_oob = 0; item->got_rdhup = 0; item->got_err = 0; item->got_hup = 0; item->got_nval = 0; } /* Check for pending reads. */ for (item = fds, idx = 0; idx < nfds; item++, idx++) { if (item->ignore) continue; if (!item->want_read) continue; if (_gpgrt__pending (item->stream)) { item->got_read = 1; count++; } } /* Check for space in the write buffers. */ for (item = fds, idx = 0; idx < nfds; item++, idx++) { if (item->ignore) continue; if (!item->want_write) continue; /* FIXME */ } if (count) goto leave; /* Now do the real select. */ #ifdef HAVE_W32_SYSTEM _gpgrt_pre_syscall (); count = _gpgrt_w32_poll (fds, nfds, timeout); _gpgrt_post_syscall (); #else /*!HAVE_W32_SYSTEM*/ # ifdef HAVE_POLL_H poll_fds = xtrymalloc (sizeof (*poll_fds)*nfds); if (!poll_fds) { count = -1; goto leave; } poll_nfds = 0; for (item = fds, idx = 0; idx < nfds; item++, idx++) { if (item->ignore) continue; fd = _gpgrt_fileno (item->stream); if (fd == -1) continue; /* Stream does not support polling. */ if (item->want_read || item->want_write || item->want_oob) { poll_fds[poll_nfds].fd = fd; poll_fds[poll_nfds].events = ((item->want_read ? POLLIN : 0) |(item->want_write ? POLLOUT : 0) |(item->want_oob ? POLLPRI : 0)); poll_fds[poll_nfds].revents = 0; poll_nfds++; } } _gpgrt_pre_syscall (); do ret = poll (poll_fds, poll_nfds, timeout); while (ret == -1 && (errno == EINTR || errno == EAGAIN)); _gpgrt_post_syscall (); # else /* !HAVE_POLL_H */ any_readfd = any_writefd = any_exceptfd = 0; max_fd = 0; for (item = fds, idx = 0; idx < nfds; item++, idx++) { if (item->ignore) continue; fd = _gpgrt_fileno (item->stream); if (fd == -1) continue; /* Stream does not support polling. */ if (item->want_read) { if (!any_readfd) { FD_ZERO (&readfds); any_readfd = 1; } FD_SET (fd, &readfds); if (fd > max_fd) max_fd = fd; } if (item->want_write) { if (!any_writefd) { FD_ZERO (&writefds); any_writefd = 1; } FD_SET (fd, &writefds); if (fd > max_fd) max_fd = fd; } if (item->want_oob) { if (!any_exceptfd) { FD_ZERO (&exceptfds); any_exceptfd = 1; } FD_SET (fd, &exceptfds); if (fd > max_fd) max_fd = fd; } } _gpgrt_pre_syscall (); do { struct timeval timeout_val; timeout_val.tv_sec = timeout / 1000; timeout_val.tv_usec = (timeout % 1000) * 1000; ret = select (max_fd+1, any_readfd? &readfds : NULL, any_writefd? &writefds : NULL, any_exceptfd? &exceptfds : NULL, timeout == -1 ? NULL : &timeout_val); } while (ret == -1 && errno == EINTR); _gpgrt_post_syscall (); # endif if (ret == -1) { # ifdef HAVE_POLL_H trace_errno (1, ("poll failed: ")); # else trace_errno (1, ("select failed: ")); # endif count = -1; goto leave; } if (!ret) { /* Timeout. Note that in this case we can't return got_err for * an invalid stream. */ count = 0; goto leave; } # ifdef HAVE_POLL_H poll_nfds = 0; for (item = fds, idx = 0; idx < nfds; item++, idx++) { if (item->ignore) continue; fd = _gpgrt_fileno (item->stream); if (fd == -1) { item->got_err = 1; /* Stream does not support polling. */ count++; continue; } any = 0; if (item->stream->intern->indicators.hup) { item->got_hup = 1; any = 1; } if (item->want_read && (poll_fds[poll_nfds].revents & (POLLIN|POLLHUP))) { item->got_read = 1; any = 1; } if (item->want_write && (poll_fds[poll_nfds].revents & POLLOUT)) { item->got_write = 1; any = 1; } if (item->want_oob && (poll_fds[poll_nfds].revents & ~(POLLIN|POLLOUT))) { item->got_oob = 1; any = 1; } if (item->want_read || item->want_write || item->want_oob) poll_nfds++; if (any) count++; } # else for (item = fds, idx = 0; idx < nfds; item++, idx++) { if (item->ignore) continue; fd = _gpgrt_fileno (item->stream); if (fd == -1) { item->got_err = 1; /* Stream does not support polling. */ count++; continue; } any = 0; if (item->stream->intern->indicators.hup) { item->got_hup = 1; any = 1; } if (item->want_read && FD_ISSET (fd, &readfds)) { item->got_read = 1; any = 1; } if (item->want_write && FD_ISSET (fd, &writefds)) { item->got_write = 1; any = 1; } if (item->want_oob && FD_ISSET (fd, &exceptfds)) { item->got_oob = 1; any = 1; } if (any) count++; } # endif #endif /*!HAVE_W32_SYSTEM*/ leave: #ifndef HAVE_W32_SYSTEM # ifdef HAVE_POLL_H xfree (poll_fds); # endif #endif #ifdef ENABLE_TRACING trace (("leave: count=%d", count)); if (count > 0) { for (item = fds, idx = 0; idx < nfds; item++, idx++) { trace ((" %3d %c%c%c%c%c %c%c%c%c%c%c%c", idx, fds[idx].want_read? 'r':'-', fds[idx].want_write? 'w':'-', fds[idx].want_oob? 'o':'-', fds[idx].want_rdhup? 'h':'-', fds[idx].ignore? 'i':'-', fds[idx].got_read? 'r':'-', fds[idx].got_write? 'w':'-', fds[idx].got_oob? 'o':'-', fds[idx].got_rdhup? 'h':'-', fds[idx].got_hup? 'H':'-', fds[idx].got_err? 'e':'-', fds[idx].got_nval? 'n':'-' )); } } #endif /*ENABLE_TRACING*/ return count; } void _gpgrt_opaque_set (estream_t stream, void *opaque) { lock_stream (stream); es_opaque_ctrl (stream, opaque, NULL); unlock_stream (stream); } void * _gpgrt_opaque_get (estream_t stream) { void *opaque; lock_stream (stream); es_opaque_ctrl (stream, NULL, &opaque); unlock_stream (stream); return opaque; } static void fname_set_internal (estream_t stream, const char *fname, int quote) { if (stream->intern->printable_fname && !stream->intern->printable_fname_inuse) { mem_free (stream->intern->printable_fname); stream->intern->printable_fname = NULL; } if (stream->intern->printable_fname) return; /* Can't change because it is in use. */ if (*fname != '[') quote = 0; else quote = !!quote; stream->intern->printable_fname = mem_alloc (strlen (fname) + quote + 1); if (quote) stream->intern->printable_fname[0] = '\\'; strcpy (stream->intern->printable_fname+quote, fname); } /* Set the filename attribute of STREAM. There is no error return. as long as STREAM is valid. This function is called internally by functions which open a filename. */ void _gpgrt_fname_set (estream_t stream, const char *fname) { if (fname) { lock_stream (stream); fname_set_internal (stream, fname, 1); unlock_stream (stream); } } /* Return the filename attribute of STREAM. In case no filename has been set, "[?]" will be returned. The returned file name is valid as long as STREAM is valid. */ const char * _gpgrt_fname_get (estream_t stream) { const char *fname; lock_stream (stream); fname = stream->intern->printable_fname; if (fname) stream->intern->printable_fname_inuse = 1; unlock_stream (stream); if (!fname) fname = "[?]"; return fname; } /* Print a BUFFER to STREAM while replacing all control characters and the characters in DELIMITERS by standard C escape sequences. Returns 0 on success or -1 on error. If BYTES_WRITTEN is not NULL the number of bytes actually written are stored at this address. */ int _gpgrt_write_sanitized (estream_t _GPGRT__RESTRICT stream, const void * _GPGRT__RESTRICT buffer, size_t length, const char * delimiters, size_t * _GPGRT__RESTRICT bytes_written) { const unsigned char *p = buffer; size_t count = 0; int ret; lock_stream (stream); for (; length; length--, p++, count++) { if (*p < 0x20 || *p == 0x7f || (delimiters && (strchr (delimiters, *p) || *p == '\\'))) { _gpgrt_putc_unlocked ('\\', stream); count++; if (*p == '\n') { _gpgrt_putc_unlocked ('n', stream); count++; } else if (*p == '\r') { _gpgrt_putc_unlocked ('r', stream); count++; } else if (*p == '\f') { _gpgrt_putc_unlocked ('f', stream); count++; } else if (*p == '\v') { _gpgrt_putc_unlocked ('v', stream); count++; } else if (*p == '\b') { _gpgrt_putc_unlocked ('b', stream); count++; } else if (!*p) { _gpgrt_putc_unlocked('0', stream); count++; } else { _gpgrt_fprintf_unlocked (stream, "x%02x", *p); count += 3; } } else { _gpgrt_putc_unlocked (*p, stream); count++; } } if (bytes_written) *bytes_written = count; ret = _gpgrt_ferror_unlocked (stream)? -1 : 0; unlock_stream (stream); return ret; } /* Write LENGTH bytes of BUFFER to STREAM as a hex encoded string. RESERVED must be 0. Returns 0 on success or -1 on error. If BYTES_WRITTEN is not NULL the number of bytes actually written are stored at this address. */ int _gpgrt_write_hexstring (estream_t _GPGRT__RESTRICT stream, const void *_GPGRT__RESTRICT buffer, size_t length, int reserved, size_t *_GPGRT__RESTRICT bytes_written ) { int ret; const unsigned char *s; size_t count = 0; (void)reserved; #define tohex(n) ((n) < 10 ? ((n) + '0') : (((n) - 10) + 'A')) if (!length) return 0; lock_stream (stream); for (s = buffer; length; s++, length--) { _gpgrt_putc_unlocked ( tohex ((*s>>4)&15), stream); _gpgrt_putc_unlocked ( tohex (*s&15), stream); count += 2; } if (bytes_written) *bytes_written = count; ret = _gpgrt_ferror_unlocked (stream)? -1 : 0; unlock_stream (stream); return ret; #undef tohex } diff --git a/src/gpgrt-int.h b/src/gpgrt-int.h index 410c483..4ed64be 100644 --- a/src/gpgrt-int.h +++ b/src/gpgrt-int.h @@ -1,868 +1,869 @@ /* gpgrt-int.h - Internal definitions * Copyright (C) 2014, 2017 g10 Code GmbH * * This file is part of libgpg-error. * * libgpg-error is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License * as published by the Free Software Foundation; either version 2.1 of * the License, or (at your option) any later version. * * libgpg-error is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this program; if not, see . * SPDX-License-Identifier: LGPL-2.1+ */ #ifndef _GPGRT_GPGRT_INT_H #define _GPGRT_GPGRT_INT_H #include "gpg-error.h" #include "visibility.h" #include "protos.h" /* * Internal i18n macros. */ #ifdef ENABLE_NLS # ifdef HAVE_W32_SYSTEM # include "gettext.h" # else # include # endif # define _(a) gettext (a) # ifdef gettext_noop # define N_(a) gettext_noop (a) # else # define N_(a) (a) # endif #else /*!ENABLE_NLS*/ # define _(a) (a) # define N_(a) (a) #endif /*!ENABLE_NLS */ /* * Hacks mainly required for Slowaris. */ #ifdef _GPGRT_NEED_AFLOCAL # ifndef HAVE_W32_SYSTEM # include # include # else # ifdef HAVE_WINSOCK2_H # include # endif # include # endif # ifndef PF_LOCAL # ifdef PF_UNIX # define PF_LOCAL PF_UNIX # else # define PF_LOCAL AF_UNIX # endif # endif /*PF_LOCAL*/ # ifndef AF_LOCAL # define AF_LOCAL AF_UNIX # endif /*AF_UNIX*/ /* We used to avoid this macro in GnuPG and inlined the AF_LOCAL name * length computation directly with the little twist of adding 1 extra * byte. It seems that this was needed once on an old HP/UX box and * there are also rumours that 4.3 Reno and DEC systems need it. This * one-off buglet did not harm any current system until it came to Mac * OS X where the kernel (as of May 2009) exhibited a strange bug: The * systems basically froze in the connect call if the passed name * contained an invalid directory part. Ignore the old Unices. */ # ifndef SUN_LEN # define SUN_LEN(ptr) ((size_t) (((struct sockaddr_un *) 0)->sun_path) \ + strlen ((ptr)->sun_path)) # endif /*SUN_LEN*/ #endif /*_GPGRT_NEED_AFLOCAL*/ /* * Common helper macros. */ #ifndef DIM # define DIM(array) (sizeof (array) / sizeof (*array)) #endif /* * Local error function prototypes. */ const char *_gpg_strerror (gpg_error_t err); int _gpg_strerror_r (gpg_error_t err, char *buf, size_t buflen); const char *_gpg_strsource (gpg_error_t err); gpg_err_code_t _gpg_err_code_from_errno (int err); int _gpg_err_code_to_errno (gpg_err_code_t code); gpg_err_code_t _gpg_err_code_from_syserror (void); void _gpg_err_set_errno (int err); gpg_error_t _gpg_err_init (void); void _gpg_err_deinit (int mode); void _gpgrt_add_emergency_cleanup (void (*f)(void)); void _gpgrt_abort (void) GPGRT_ATTR_NORETURN; void _gpgrt_set_alloc_func (void *(*f)(void *a, size_t n)); void *_gpgrt_realloc (void *a, size_t n); void *_gpgrt_reallocarray (void *a, size_t oldnmemb, size_t nmemb, size_t size); void *_gpgrt_malloc (size_t n); void *_gpgrt_calloc (size_t n, size_t m); char *_gpgrt_strdup (const char *string); char *_gpgrt_strconcat (const char *s1, ...) GPGRT_ATTR_SENTINEL(0); void _gpgrt_free (void *a); void _gpgrt_wipememory (void *ptr, size_t len); /* The next is only to be used by visibility.c. */ char *_gpgrt_strconcat_core (const char *s1, va_list arg_ptr); #define xfree(a) _gpgrt_free ((a)) #define xtrymalloc(a) _gpgrt_malloc ((a)) #define xtrycalloc(a,b) _gpgrt_calloc ((a),(b)) #define xtryrealloc(a,b) _gpgrt_realloc ((a),(b)) #define xtryreallocarray(a,b,c,d) _gpgrt_reallocarray ((a),(b),(c),(d)) #define xtrystrdup(a) _gpgrt_strdup ((a)) void _gpgrt_pre_syscall (void); void _gpgrt_post_syscall (void); const char *_gpg_error_check_version (const char *req_version); gpg_err_code_t _gpgrt_lock_init (gpgrt_lock_t *lockhd); gpg_err_code_t _gpgrt_lock_lock (gpgrt_lock_t *lockhd); gpg_err_code_t _gpgrt_lock_trylock (gpgrt_lock_t *lockhd); gpg_err_code_t _gpgrt_lock_unlock (gpgrt_lock_t *lockhd); gpg_err_code_t _gpgrt_lock_destroy (gpgrt_lock_t *lockhd); gpg_err_code_t _gpgrt_yield (void); /* * Tracing */ /* The trace macro is used this way: * trace (("enter - foo=%d bar=%s", foo, bar)); * Note the double parenthesis, they are important. * To append the current errno to the output, use * trace_errno (EXTPR,("leave - baz=%d", faz)); * If EXPR evaluates to true the output of strerror (errno) * is appended to the output. Note that the trace function does * not modify ERRNO. To enable tracing you need to have this * #define ENABLE_TRACING "modulename" * before you include gpgrt-int.h. */ #ifdef ENABLE_TRACING # define trace(X) do { \ _gpgrt_internal_trace_begin \ (ENABLE_TRACING, __func__, __LINE__, 0); \ _gpgrt_internal_trace X; \ _gpgrt_internal_trace_end (); \ } while (0) # define trace_errno(C,X) do { \ _gpgrt_internal_trace_begin \ (ENABLE_TRACING, __func__, __LINE__, (C)); \ _gpgrt_internal_trace X; \ _gpgrt_internal_trace_end (); \ } while (0) # define trace_start(X) do { \ _gpgrt_internal_trace_begin \ (ENABLE_TRACING, __func__, __LINE__, 0); \ _gpgrt_internal_trace_printf X; \ } while (0) # define trace_append(X) do { \ _gpgrt_internal_trace_printf X; \ } while (0) # define trace_finish(X) do { \ _gpgrt_internal_trace_printf X; \ _gpgrt_internal_trace_end (); \ } while (0) #else # define trace(X) do { } while (0) # define trace_errno(C,X) do { } while (0) # define trace_start(X) do { } while (0) # define trace_append(X) do { } while (0) # define trace_finish(X) do { } while (0) #endif /*!ENABLE_TRACING*/ void _gpgrt_internal_trace_begin (const char *mod, const char *file, int line, int with_errno); void _gpgrt_internal_trace (const char *format, ...) GPGRT_ATTR_PRINTF(1,2); void _gpgrt_internal_trace_printf (const char *format, ...) GPGRT_ATTR_PRINTF(1,2); void _gpgrt_internal_trace_end (void); /* * Local definitions for estream. */ #if HAVE_W32_SYSTEM # ifndef O_NONBLOCK # define O_NONBLOCK 0x40000000 /* FIXME: Is that safe? */ # endif #endif /* * A private cookie function to implement an internal IOCTL service. */ typedef int (*cookie_ioctl_function_t) (void *cookie, int cmd, void *ptr, size_t *len); #define COOKIE_IOCTL_SNATCH_BUFFER 1 #define COOKIE_IOCTL_NONBLOCK 2 #define COOKIE_IOCTL_TRUNCATE 3 /* An internal variant of gpgrt_cookie_close_function_t with a slot * for the ioctl function. */ struct cookie_io_functions_s { struct _gpgrt_cookie_io_functions public; cookie_ioctl_function_t func_ioctl; }; typedef enum { BACKEND_MEM, BACKEND_FD, BACKEND_SOCK, BACKEND_W32, BACKEND_FP, BACKEND_USER, BACKEND_W32_POLLABLE } gpgrt_stream_backend_kind_t; /* * A type to hold notification functions. */ struct notify_list_s { struct notify_list_s *next; void (*fnc) (estream_t, void*); /* The notification function. */ void *fnc_value; /* The value to be passed to FNC. */ }; typedef struct notify_list_s *notify_list_t; /* * Buffer management layer. */ /* BUFSIZ on Windows is 512 but on current Linux it is 8k. We better * use the 8k for Windows as well. */ #ifdef HAVE_W32_SYSTEM # define BUFFER_BLOCK_SIZE 8192 #else # define BUFFER_BLOCK_SIZE BUFSIZ #endif #define BUFFER_UNREAD_SIZE 16 /* * The private object describing a stream. */ struct _gpgrt_stream_internal { unsigned char buffer[BUFFER_BLOCK_SIZE]; unsigned char unread_buffer[BUFFER_UNREAD_SIZE]; gpgrt_lock_t lock; /* Lock. Used by *_stream_lock(). */ gpgrt_stream_backend_kind_t kind; void *cookie; /* Cookie. */ void *opaque; /* Opaque data. */ unsigned int modeflags; /* Flags for the backend. */ char *printable_fname; /* Malloced filename for es_fname_get. */ gpgrt_off_t offset; gpgrt_cookie_read_function_t func_read; gpgrt_cookie_write_function_t func_write; gpgrt_cookie_seek_function_t func_seek; gpgrt_cookie_close_function_t func_close; cookie_ioctl_function_t func_ioctl; int strategy; es_syshd_t syshd; /* A copy of the system handle. */ struct { unsigned int err: 1; unsigned int eof: 1; unsigned int hup: 1; } indicators; unsigned int deallocate_buffer: 1; unsigned int is_stdstream:1; /* This is a standard stream. */ unsigned int stdstream_fd:2; /* 0, 1 or 2 for a standard stream. */ unsigned int printable_fname_inuse: 1; /* es_fname_get has been used. */ unsigned int samethread: 1; /* The "samethread" mode keyword. */ + unsigned int wipe: 1; /* The "wipe" mode keyword. */ size_t print_ntotal; /* Bytes written from in print_writer. */ notify_list_t onclose; /* On close notify function list. */ }; typedef struct _gpgrt_stream_internal *estream_internal_t; /* * Local prototypes for estream. */ int _gpgrt_estream_init (void); void _gpgrt_set_syscall_clamp (void (*pre)(void), void (*post)(void)); void _gpgrt_get_syscall_clamp (void (**r_pre)(void), void (**r_post)(void)); gpgrt_stream_t _gpgrt_fopen (const char *_GPGRT__RESTRICT path, const char *_GPGRT__RESTRICT mode); gpgrt_stream_t _gpgrt_mopen (void *_GPGRT__RESTRICT data, size_t data_n, size_t data_len, unsigned int grow, void *(*func_realloc) (void *mem, size_t size), void (*func_free) (void *mem), const char *_GPGRT__RESTRICT mode); gpgrt_stream_t _gpgrt_fopenmem (size_t memlimit, const char *_GPGRT__RESTRICT mode); gpgrt_stream_t _gpgrt_fopenmem_init (size_t memlimit, const char *_GPGRT__RESTRICT mode, const void *data, size_t datalen); gpgrt_stream_t _gpgrt_fdopen (int filedes, const char *mode); gpgrt_stream_t _gpgrt_fdopen_nc (int filedes, const char *mode); gpgrt_stream_t _gpgrt_sysopen (gpgrt_syshd_t *syshd, const char *mode); gpgrt_stream_t _gpgrt_sysopen_nc (gpgrt_syshd_t *syshd, const char *mode); gpgrt_stream_t _gpgrt_fpopen (FILE *fp, const char *mode); gpgrt_stream_t _gpgrt_fpopen_nc (FILE *fp, const char *mode); gpgrt_stream_t _gpgrt_freopen (const char *_GPGRT__RESTRICT path, const char *_GPGRT__RESTRICT mode, gpgrt_stream_t _GPGRT__RESTRICT stream); gpgrt_stream_t _gpgrt_fopencookie (void *_GPGRT__RESTRICT cookie, const char *_GPGRT__RESTRICT mode, gpgrt_cookie_io_functions_t functions); int _gpgrt_fclose (gpgrt_stream_t stream); int _gpgrt_fcancel (gpgrt_stream_t stream); int _gpgrt_fclose_snatch (gpgrt_stream_t stream, void **r_buffer, size_t *r_buflen); int _gpgrt_onclose (gpgrt_stream_t stream, int mode, void (*fnc) (gpgrt_stream_t, void*), void *fnc_value); int _gpgrt_fileno (gpgrt_stream_t stream); int _gpgrt_fileno_unlocked (gpgrt_stream_t stream); int _gpgrt_syshd (gpgrt_stream_t stream, gpgrt_syshd_t *syshd); int _gpgrt_syshd_unlocked (gpgrt_stream_t stream, gpgrt_syshd_t *syshd); void _gpgrt__set_std_fd (int no, int fd); gpgrt_stream_t _gpgrt__get_std_stream (int fd); /* The es_stderr et al macros are pretty common so that we want to use * them too. This requires that we redefine them. */ #undef es_stdin #define es_stdin _gpgrt__get_std_stream (0) #undef es_stdout #define es_stdout _gpgrt__get_std_stream (1) #undef es_stderr #define es_stderr _gpgrt__get_std_stream (2) void _gpgrt_flockfile (gpgrt_stream_t stream); int _gpgrt_ftrylockfile (gpgrt_stream_t stream); void _gpgrt_funlockfile (gpgrt_stream_t stream); int _gpgrt_feof (gpgrt_stream_t stream); int _gpgrt_feof_unlocked (gpgrt_stream_t stream); int _gpgrt_ferror (gpgrt_stream_t stream); int _gpgrt_ferror_unlocked (gpgrt_stream_t stream); void _gpgrt_clearerr (gpgrt_stream_t stream); void _gpgrt_clearerr_unlocked (gpgrt_stream_t stream); int _gpgrt__pending (gpgrt_stream_t stream); int _gpgrt__pending_unlocked (gpgrt_stream_t stream); int _gpgrt_fflush (gpgrt_stream_t stream); int _gpgrt_fseek (gpgrt_stream_t stream, long int offset, int whence); int _gpgrt_fseeko (gpgrt_stream_t stream, gpgrt_off_t offset, int whence); long int _gpgrt_ftell (gpgrt_stream_t stream); gpgrt_off_t _gpgrt_ftello (gpgrt_stream_t stream); void _gpgrt_rewind (gpgrt_stream_t stream); int _gpgrt_ftruncate (estream_t stream, gpgrt_off_t length); int _gpgrt_fgetc (gpgrt_stream_t stream); int _gpgrt_fputc (int c, gpgrt_stream_t stream); int _gpgrt__getc_underflow (gpgrt_stream_t stream); int _gpgrt__putc_overflow (int c, gpgrt_stream_t stream); /* Note: Keeps the next two macros in sync with their counterparts in gpg-error.h. */ #define _gpgrt_getc_unlocked(stream) \ (((!(stream)->flags.writing) \ && ((stream)->data_offset < (stream)->data_len) \ && (! (stream)->unread_data_len)) \ ? ((int) (stream)->buffer[((stream)->data_offset)++]) \ : _gpgrt__getc_underflow ((stream))) #define _gpgrt_putc_unlocked(c, stream) \ (((stream)->flags.writing \ && ((stream)->data_offset < (stream)->buffer_size) \ && (c != '\n')) \ ? ((int) ((stream)->buffer[((stream)->data_offset)++] = (c))) \ : _gpgrt__putc_overflow ((c), (stream))) int _gpgrt_ungetc (int c, gpgrt_stream_t stream); int _gpgrt_read (gpgrt_stream_t _GPGRT__RESTRICT stream, void *_GPGRT__RESTRICT buffer, size_t bytes_to_read, size_t *_GPGRT__RESTRICT bytes_read); int _gpgrt_write (gpgrt_stream_t _GPGRT__RESTRICT stream, const void *_GPGRT__RESTRICT buffer, size_t bytes_to_write, size_t *_GPGRT__RESTRICT bytes_written); int _gpgrt_write_sanitized (gpgrt_stream_t _GPGRT__RESTRICT stream, const void *_GPGRT__RESTRICT buffer, size_t length, const char *delimiters, size_t *_GPGRT__RESTRICT bytes_written); int _gpgrt_write_hexstring (gpgrt_stream_t _GPGRT__RESTRICT stream, const void *_GPGRT__RESTRICT buffer, size_t length, int reserved, size_t *_GPGRT__RESTRICT bytes_written); size_t _gpgrt_fread (void *_GPGRT__RESTRICT ptr, size_t size, size_t nitems, gpgrt_stream_t _GPGRT__RESTRICT stream); size_t _gpgrt_fwrite (const void *_GPGRT__RESTRICT ptr, size_t size, size_t memb, gpgrt_stream_t _GPGRT__RESTRICT stream); char *_gpgrt_fgets (char *_GPGRT__RESTRICT s, int n, gpgrt_stream_t _GPGRT__RESTRICT stream); int _gpgrt_fputs (const char *_GPGRT__RESTRICT s, gpgrt_stream_t _GPGRT__RESTRICT stream); int _gpgrt_fputs_unlocked (const char *_GPGRT__RESTRICT s, gpgrt_stream_t _GPGRT__RESTRICT stream); gpgrt_ssize_t _gpgrt_getline (char *_GPGRT__RESTRICT *_GPGRT__RESTRICT lineptr, size_t *_GPGRT__RESTRICT n, gpgrt_stream_t stream); gpgrt_ssize_t _gpgrt_read_line (gpgrt_stream_t stream, char **addr_of_buffer, size_t *length_of_buffer, size_t *max_length); int _gpgrt_fprintf (gpgrt_stream_t _GPGRT__RESTRICT stream, const char *_GPGRT__RESTRICT format, ...) GPGRT_ATTR_PRINTF(2,3); int _gpgrt_fprintf_unlocked (gpgrt_stream_t _GPGRT__RESTRICT stream, const char *_GPGRT__RESTRICT format, ...) GPGRT_ATTR_PRINTF(2,3); int _gpgrt_vfprintf (gpgrt_stream_t _GPGRT__RESTRICT stream, gpgrt_string_filter_t sf, void *sfvalue, const char *_GPGRT__RESTRICT format, va_list ap) GPGRT_ATTR_PRINTF(4,0); int _gpgrt_vfprintf_unlocked (gpgrt_stream_t _GPGRT__RESTRICT stream, gpgrt_string_filter_t sf, void *sfvalue, const char *_GPGRT__RESTRICT format, va_list ap) GPGRT_ATTR_PRINTF(4,0); int _gpgrt_setvbuf (gpgrt_stream_t _GPGRT__RESTRICT stream, char *_GPGRT__RESTRICT buf, int mode, size_t size); void _gpgrt_set_binary (gpgrt_stream_t stream); int _gpgrt_set_nonblock (gpgrt_stream_t stream, int onoff); int _gpgrt_get_nonblock (gpgrt_stream_t stream); int _gpgrt_poll (gpgrt_poll_t *fds, unsigned int nfds, int timeout); gpgrt_stream_t _gpgrt_tmpfile (void); void _gpgrt_opaque_set (gpgrt_stream_t _GPGRT__RESTRICT stream, void *_GPGRT__RESTRICT opaque); void *_gpgrt_opaque_get (gpgrt_stream_t stream); void _gpgrt_fname_set (gpgrt_stream_t stream, const char *fname); const char *_gpgrt_fname_get (gpgrt_stream_t stream); #include "estream-printf.h" /* Make sure we always use our snprintf */ #undef snprintf #define snprintf _gpgrt_estream_snprintf #if HAVE_W32_SYSTEM /* Prototypes for w32-estream.c. */ extern struct cookie_io_functions_s _gpgrt_functions_w32_pollable; int _gpgrt_w32_pollable_create (void *_GPGRT__RESTRICT *_GPGRT__RESTRICT cookie, unsigned int modeflags, struct cookie_io_functions_s next_functions, void *next_cookie); int _gpgrt_w32_poll (gpgrt_poll_t *fds, size_t nfds, int timeout); #endif /*HAVE_W32_SYSTEM*/ /* * Local prototypes for the encoders. */ struct _gpgrt_b64state { int idx; int quad_count; estream_t stream; char *title; unsigned char radbuf[4]; unsigned int crc; gpg_err_code_t lasterr; unsigned int flags; unsigned int stop_seen:1; unsigned int invalid_encoding:1; unsigned int using_decoder:1; }; gpgrt_b64state_t _gpgrt_b64enc_start (estream_t stream, const char *title); gpg_err_code_t _gpgrt_b64enc_write (gpgrt_b64state_t state, const void *buffer, size_t nbytes); gpg_err_code_t _gpgrt_b64enc_finish (gpgrt_b64state_t state); gpgrt_b64state_t _gpgrt_b64dec_start (const char *title); gpg_err_code_t _gpgrt_b64dec_proc (gpgrt_b64state_t state, void *buffer, size_t length, size_t *r_nbytes); gpg_err_code_t _gpgrt_b64dec_finish (gpgrt_b64state_t state); /* * Local prototypes for logging */ int _gpgrt_get_errorcount (int clear); void _gpgrt_inc_errorcount (void); void _gpgrt_log_set_sink (const char *name, estream_t stream, int fd); void _gpgrt_log_set_socket_dir_cb (const char *(*fnc)(void)); void _gpgrt_log_set_pid_suffix_cb (int (*cb)(unsigned long *r_value)); void _gpgrt_log_set_prefix (const char *text, unsigned int flags); const char *_gpgrt_log_get_prefix (unsigned int *flags); int _gpgrt_log_test_fd (int fd); int _gpgrt_log_get_fd (void); estream_t _gpgrt_log_get_stream (void); void _gpgrt_log (int level, const char *fmt, ...) GPGRT_ATTR_PRINTF(2,3); void _gpgrt_logv (int level, const char *fmt, va_list arg_ptr); void _gpgrt_logv_prefix (int level, const char *prefix, const char *fmt, va_list arg_ptr); void _gpgrt_log_string (int level, const char *string); void _gpgrt_log_bug (const char *fmt, ...) GPGRT_ATTR_NR_PRINTF(1,2); void _gpgrt_log_fatal (const char *fmt, ...) GPGRT_ATTR_NR_PRINTF(1,2); void _gpgrt_log_error (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2); void _gpgrt_log_info (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2); void _gpgrt_log_debug (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2); void _gpgrt_log_debug_string (const char *string, const char *fmt, ...) GPGRT_ATTR_PRINTF(2,3); void _gpgrt_log_printf (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2); void _gpgrt_log_flush (void); void _gpgrt_logv_printhex (const void *buffer, size_t length, const char *fmt, va_list arg_ptr); void _gpgrt_log_printhex (const void *buffer, size_t length, const char *fmt, ...) GPGRT_ATTR_PRINTF(3,4); void _gpgrt_logv_clock (const char *fmt, va_list arg_ptr); void _gpgrt_log_clock (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2); void _gpgrt__log_assert (const char *expr, const char *file, int line, const char *func) GPGRT_ATTR_NORETURN; /* Redefine the assert macro to use our internal function. */ #undef gpgrt_assert #ifdef GPGRT_HAVE_MACRO_FUNCTION #define gpgrt_assert(expr) \ ((expr) \ ? (void) 0 \ : _gpgrt__log_assert (#expr, __FILE__, __LINE__, __FUNCTION__)) #else /*!GPGRT_HAVE_MACRO_FUNCTION*/ /* # define BUG() bug_at( __FILE__ , __LINE__ ) */ #define gpgrt_assert(expr) \ ((expr) \ ? (void) 0 \ : _gpgrt__log_assert (#expr, __FILE__, __LINE__, NULL)) #endif /*!GPGRT_HAVE_MACRO_FUNCTION*/ /* Note: The next function is only to be used by visibility.c. */ int _gpgrt_logv_internal (int level, int ignore_arg_ptr, const char *extrastring, const char *prefmt, const char *fmt, va_list arg_ptr); /* * Local prototypes for the spawn functions. * * We put the docs here because we have separate implementations in * the files spawn-posix.c and spawn-w32.c */ /* Return the maximum number of currently allowed file descriptors. * Only useful on POSIX systems. */ /* int get_max_fds (void); */ /* Close all file descriptors starting with descriptor FIRST. If * EXCEPT is not NULL, it is expected to be a list of file descriptors * which are not to close. This list shall be sorted in ascending * order with its end marked by -1. */ /* void close_all_fds (int first, int *except); */ /* Returns an array with all currently open file descriptors. The end * of the array is marked by -1. The caller needs to release this * array using the *standard free* and not with xfree. This allow the * use of this function right at startup even before libgcrypt has * been initialized. Returns NULL on error and sets ERRNO accordingly. */ /* int *get_all_open_fds (void); */ /* Create a pipe. The DIRECTION parameter gives the type of the created pipe: * DIRECTION < 0 := Inbound pipe: On Windows the write end is inheritable. * DIRECTION > 0 := Outbound pipe: On Windows the read end is inheritable. * If R_FP is NULL a standard pipe and no stream is created, DIRECTION * should then be 0. */ gpg_err_code_t _gpgrt_make_pipe (int filedes[2], estream_t *r_fp, int direction, int nonblock); /* Convenience macros to create a pipe. */ #define _gpgrt_create_pipe(a) _gpgrt_make_pipe ((a),NULL, 0, 0) #define _gpgrt_create_inbound_pipe(a,b,c) _gpgrt_make_pipe ((a), (b), -1, (c)) #define _gpgrt_create_outbound_pipe(a,b,c) _gpgrt_make_pipe ((a), (b), 1, (c)) /* Fork and exec the program PGMNAME. * * If R_INFP is NULL connect stdin of the new process to /dev/null; if * it is not NULL store the address of a pointer to a new estream * there. If R_OUTFP is NULL connect stdout of the new process to * /dev/null; if it is not NULL store the address of a pointer to a * new estream there. If R_ERRFP is NULL connect stderr of the new * process to /dev/null; if it is not NULL store the address of a * pointer to a new estream there. On success the process id of the * new process is stored at R_PID. On error -1 is stored at R_PID and * if R_OUTFP or R_ERRFP are not NULL, NULL is stored there. * * The arguments for the process are expected in the NULL terminated * array ARGV. The program name itself should not be included there. * * IF EXCEPT is not NULL, it is expected to be an ordered list of file * descriptors, terminated by an entry with the value (-1). These * file descriptors won't be closed before spawning a new program. * * Returns 0 on success or an error code. Calling gpgrt_wait_process * and gpgrt_release_process is required if the function succeeded. * * FLAGS is a bit vector: * * GPGRT_SPAWN_NONBLOCK * If set the two output streams are created in non-blocking * mode and the input stream is switched to non-blocking mode. * This is merely a convenience feature because the caller * could do the same with gpgrt_set_nonblock. Does not yet * work for Windows. * * GPGRT_SPAWN_DETACHED * If set the process will be started as a background process. * This flag is only useful under W32 systems, so that no new * console is created and pops up a console window when starting * the server. * * GPGRT_SPAWN_RUN_ASFW * On W32 run AllowSetForegroundWindow for the child. Note that * due to unknown problems this actually allows * SetForegroundWindow for all children of this process. * * GNUPG_SPAWN_KEEP_STDIN * GNUPG_SPAWN_KEEP_STDOUT * GNUPG_SPAWN_KEEP_STDERR * Do not assign /dev/null to a non-required standard file * descriptor. * */ gpg_err_code_t _gpgrt_spawn_process (const char *pgmname, const char *argv[], int *execpt, unsigned int flags, estream_t *r_infp, estream_t *r_outfp, estream_t *r_errfp, gpgrt_process_t *r_process_id); /* Variant of gpgrt_spawn_process. This function forks and then execs * PGMNAME, while connecting INFD to stdin, OUTFD to stdout and ERRFD * to stderr (any of them may be -1 to connect them to /dev/null). * The arguments for the process are expected in the NULL terminated * array ARGV. The program name itself should not be included there. * Calling gpgrt_wait_process and gpgrt_release_process is required. * Returns 0 on success or an error code. If SPAWN_CB is not NULL, * the given function will be called with SPAWN_CB_ARG to determine if * file descriptors/handles should be inherited or not. The callback * function should return 1 to ask keeping file descriptors/handles. * If SPAWN_CB is NULL, or it returns 0, all file descriptors (except * INFD, OUTFD, and ERRFD) will be closed on POSIX machine. On POSIX * machine, it is called right after the fork, by child process. */ gpg_err_code_t _gpgrt_spawn_process_fd (const char *pgmname, const char *argv[], int infd, int outfd, int errfd, int (*spawn_cb) (void *), void *spawn_cb_arg, gpgrt_process_t *r_process_id); /* Spawn a new process and immediately detach from it. The name of * the program to exec is PGMNAME and its arguments are in ARGV (the * programname is automatically passed as first argument). * Environment strings in ENVP are set. An error is returned if * pgmname is not executable; to make this work it is necessary to * provide an absolute file name. */ gpg_err_code_t _gpgrt_spawn_process_detached (const char *pgmname, const char *argv[], const char *envp[]); /* If HANG is true, waits for the process identified by PROCESS_ID to * exit; if HANG is false, checks whether the process has terminated. * PGMNAME should be the same as supplied to the spawn function and is * only used for diagnostics. Return values: * * 0 * The process exited successful. 0 is stored at R_EXITCODE. * * GPG_ERR_GENERAL * The process exited without success. The exit code of process * is then stored at R_EXITCODE. An exit code of -1 indicates * that the process terminated abnormally (e.g. due to a signal). * * GPG_ERR_TIMEOUT * The process is still running (returned only if HANG is false). * * GPG_ERR_INV_VALUE * An invalid PID has been specified. * * Other error codes may be returned as well. Unless otherwise noted, * -1 will be stored at R_EXITCODE. R_EXITCODE may be passed as NULL * if the exit code is not required (in that case an error message will * be printed). Note that under Windows PID is not the process id but * the handle of the process. */ gpg_err_code_t _gpgrt_wait_process (const char *pgmname, gpgrt_process_t process_id, int hang, int *r_exitcode); /* Like _gpgrt_wait_process, but for COUNT processes. */ gpg_err_code_t _gpgrt_wait_processes (const char **pgmnames, gpgrt_process_t *process_ids, size_t count, int hang, int *r_exitcodes); /* Kill a process; that is send an appropriate signal to the process. * gpgrt_wait_process must be called to actually remove the process * from the system. An invalid PROCESS_ID is ignored. */ void _gpgrt_kill_process (gpgrt_process_t process_id); /* Release the process identified by PROCESS_ID. This function is * actually only required for Windows but it does not harm to always * call it. It is a nop if PROCESS_ID is invalid. */ void _gpgrt_release_process (gpgrt_process_t process_id); /* Close all file resources (descriptors), except KEEP_FDS. */ void _gpgrt_close_all_fds (int from, int *keep_fds); /* * Local prototypes for argparse. */ int _gpgrt_argparse (estream_t fp, gpgrt_argparse_t *arg, gpgrt_opt_t *opts); int _gpgrt_argparser (gpgrt_argparse_t *arg, gpgrt_opt_t *opts, const char *confname); void _gpgrt_usage (int level); const char *_gpgrt_strusage (int level); void _gpgrt_set_strusage (const char *(*f)(int)); void _gpgrt_set_usage_outfnc (int (*fnc)(int, const char *)); void _gpgrt_set_fixed_string_mapper (const char *(*f)(const char*)); void _gpgrt_set_confdir (int what, const char *name); /* * Various helper functions */ int _gpgrt_cmp_version (const char *a, const char *b, int level); /* * Internal platform abstraction functions (sysutils.c) */ /* Return true if FD is valid. */ int _gpgrt_fd_valid_p (int fd); /* A getenv variant which returns a malloced copy. */ char *_gpgrt_getenv (const char *name); /* A setenv variant which can be used for unsetenv by setting VALUE to * NULL and OVERRIDE to true. */ gpg_err_code_t _gpgrt_setenv (const char *name, const char *value, int overwrite); /* A wrapper around mkdir using a string for the mode (permissions). */ gpg_err_code_t _gpgrt_mkdir (const char *name, const char *modestr); /* A simple wrapper around chdir. */ gpg_err_code_t _gpgrt_chdir (const char *name); /* Return the current WD as a malloced string. */ char *_gpgrt_getcwd (void); /* Wrapper for Windows to allow utf8 file names. */ gpg_err_code_t _gpgrt_access (const char *fname, int mode); /* Return the home directory of user NAME. */ char *_gpgrt_getpwdir (const char *name); /* Return the account name of the current user. */ char *_gpgrt_getusername (void); /* Expand and concat file name parts. */ char *_gpgrt_vfnameconcat (int want_abs, const char *first_part, va_list arg_ptr); char *_gpgrt_fnameconcat (const char *first_part, ... ) GPGRT_ATTR_SENTINEL(0); char *_gpgrt_absfnameconcat (const char *first_part, ... ) GPGRT_ATTR_SENTINEL(0); /* * Platform specific functions (Windows) */ #ifdef HAVE_W32_SYSTEM char *_gpgrt_w32_reg_query_string (const char *root, const char *dir, const char *name); char *_gpgrt_w32_reg_get_string (const char *key); wchar_t *_gpgrt_fname_to_wchar (const char *fname); #endif /*HAVE_W32_SYSTEM*/ /* * Missing functions implemented inline. */ #ifndef HAVE_STPCPY static GPG_ERR_INLINE char * _gpgrt_stpcpy (char *a, const char *b) { while (*b) *a++ = *b++; *a = 0; return a; } #define stpcpy(a,b) _gpgrt_stpcpy ((a), (b)) #endif /*!HAVE_STPCPY*/ #endif /*_GPGRT_GPGRT_INT_H*/