LCOV - code coverage report
Current view: top level - build/src - assuan.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 2 0.0 %
Date: 2016-09-12 12:52:30 Functions: 0 1 0.0 %

          Line data    Source code
       1             : /* assuan.h - Definitions for the Assuan IPC library             -*- c -*-
       2             :    Copyright (C) 2001-2013 Free Software Foundation, Inc.
       3             :    Copyright (C) 2001-2015 g10 Code GmbH
       4             : 
       5             :    This file is part of Assuan.
       6             : 
       7             :    Assuan is free software; you can redistribute it and/or modify it
       8             :    under the terms of the GNU Lesser General Public License as
       9             :    published by the Free Software Foundation; either version 2.1 of
      10             :    the License, or (at your option) any later version.
      11             : 
      12             :    Assuan is distributed in the hope that it will be useful, but
      13             :    WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :    Lesser General Public License for more details.
      16             : 
      17             :    You should have received a copy of the GNU Lesser General Public
      18             :    License along with this program; if not, see <http://www.gnu.org/licenses/>.
      19             : 
      20             :    Do not edit.  Generated from assuan.h.in by mkheader for linux-gnu.
      21             :  */
      22             : 
      23             : #ifndef ASSUAN_H
      24             : #define ASSUAN_H
      25             : 
      26             : #include <stdio.h>
      27             : #include <sys/types.h>
      28             : #include <unistd.h>
      29             : #include <stdarg.h>
      30             : 
      31             : #ifndef _ASSUAN_NO_SOCKET_WRAPPER
      32             : #include <sys/socket.h>
      33             : #endif /*!_ASSUAN_NO_SOCKET_WRAPPER*/
      34             : 
      35             : typedef struct msghdr *assuan_msghdr_t;
      36             : 
      37             : #include <gpg-error.h>
      38             : 
      39             : /* Compile time configuration:
      40             : 
      41             :    #define _ASSUAN_NO_SOCKET_WRAPPER
      42             : 
      43             :    Do not include the definitions for the socket wrapper feature.  */
      44             : 
      45             : 
      46             : #ifdef __cplusplus
      47             : extern "C"
      48             : {
      49             : #if 0
      50             : }
      51             : #endif
      52             : #endif
      53             : 
      54             : /* The version of this header should match the one of the library.  Do
      55             :    not use this symbol in your application; use assuan_check_version
      56             :    instead.  */
      57             : #define ASSUAN_VERSION "2.4.4"
      58             : 
      59             : /* The version number of this header.  It may be used to handle minor
      60             :    API incompatibilities.  */
      61             : #define ASSUAN_VERSION_NUMBER 0x020404
      62             : 
      63             : 
      64             : /* Check for compiler features.  */
      65             : #if __GNUC__
      66             : #define _ASSUAN_GCC_VERSION (__GNUC__ * 10000 \
      67             :                             + __GNUC_MINOR__ * 100 \
      68             :                             + __GNUC_PATCHLEVEL__)
      69             : 
      70             : #if _ASSUAN_GCC_VERSION > 30100
      71             : #define _ASSUAN_DEPRECATED  __attribute__ ((__deprecated__))
      72             : #endif
      73             : #endif
      74             : #ifndef _ASSUAN_DEPRECATED
      75             : #define _ASSUAN_DEPRECATED
      76             : #endif
      77             : 
      78             : 
      79             : #define ASSUAN_LINELENGTH 1002 /* 1000 + [CR,]LF */
      80             : 
      81             : struct assuan_context_s;
      82             : typedef struct assuan_context_s *assuan_context_t;
      83             : 
      84             : typedef int assuan_fd_t;
      85             : #define ASSUAN_INVALID_FD  (-1)
      86             : #define ASSUAN_INVALID_PID ((pid_t) -1)
      87             : static GPG_ERR_INLINE assuan_fd_t
      88           0 : assuan_fd_from_posix_fd (int fd)
      89             : {
      90           0 :   return fd;
      91             : }
      92             : 
      93             : 
      94             : assuan_fd_t assuan_fdopen (int fd);
      95             : 
      96             : /* Under Windows Assuan features an emulation of Unix domain sockets
      97             :    based on a local TCP connections.  To implement access permissions
      98             :    based on file permissions a nonce is used which is expected by the
      99             :    server as the first bytes received.  On POSIX systems this is a
     100             :    dummy structure. */  
     101             : struct assuan_sock_nonce_s
     102             : {
     103             :   size_t length;
     104             : };
     105             : typedef struct assuan_sock_nonce_s assuan_sock_nonce_t;
     106             : 
     107             : 
     108             : /* Global interface.  */
     109             : 
     110             : struct assuan_malloc_hooks
     111             : {
     112             :   void *(*malloc) (size_t cnt);
     113             :   void *(*realloc) (void *ptr, size_t cnt);
     114             :   void (*free) (void *ptr);
     115             : };
     116             : typedef struct assuan_malloc_hooks *assuan_malloc_hooks_t;
     117             : 
     118             : /* Categories for log messages.  */
     119             : #define ASSUAN_LOG_INIT 1
     120             : #define ASSUAN_LOG_CTX 2
     121             : #define ASSUAN_LOG_ENGINE 3
     122             : #define ASSUAN_LOG_DATA 4
     123             : #define ASSUAN_LOG_SYSIO 5
     124             : #define ASSUAN_LOG_CONTROL 8
     125             : 
     126             : /* If MSG is NULL, return true/false depending on if this category is
     127             :    logged.  This is used to probe before expensive log message
     128             :    generation (buffer dumps).  */
     129             : typedef int (*assuan_log_cb_t) (assuan_context_t ctx, void *hook,
     130             :                                 unsigned int cat, const char *msg);
     131             : 
     132             : /* Return or check the version number.  */
     133             : const char *assuan_check_version (const char *req_version);
     134             : 
     135             : /* Set the default gpg error source.  */
     136             : void assuan_set_gpg_err_source (gpg_err_source_t errsource);
     137             : 
     138             : /* Get the default gpg error source.  */
     139             : gpg_err_source_t assuan_get_gpg_err_source (void);
     140             : 
     141             : 
     142             : /* Set the default malloc hooks.  */
     143             : void assuan_set_malloc_hooks (assuan_malloc_hooks_t malloc_hooks);
     144             : 
     145             : /* Get the default malloc hooks.  */
     146             : assuan_malloc_hooks_t assuan_get_malloc_hooks (void);
     147             : 
     148             : 
     149             : /* Set the default log callback handler.  */
     150             : void assuan_set_log_cb (assuan_log_cb_t log_cb, void *log_cb_data);
     151             : 
     152             : /* Get the default log callback handler.  */
     153             : void assuan_get_log_cb (assuan_log_cb_t *log_cb, void **log_cb_data);
     154             : 
     155             : 
     156             : /* Create a new Assuan context.  The initial parameters are all needed
     157             :    in the creation of the context.  */
     158             : gpg_error_t assuan_new_ext (assuan_context_t *ctx, gpg_err_source_t errsource,
     159             :                             assuan_malloc_hooks_t malloc_hooks,
     160             :                             assuan_log_cb_t log_cb, void *log_cb_data);
     161             : 
     162             : /* Create a new context with default arguments.  */
     163             : gpg_error_t assuan_new (assuan_context_t *ctx);
     164             : 
     165             : /* Release all resources associated with the given context.  */
     166             : void assuan_release (assuan_context_t ctx);
     167             : 
     168             : /* Release the memory at PTR using the allocation handler of the
     169             :    context CTX.  This is a convenience function.  */
     170             : void assuan_free (assuan_context_t ctx, void *ptr);
     171             : 
     172             : 
     173             : /* Set user-data in a context.  */
     174             : void assuan_set_pointer (assuan_context_t ctx, void *pointer);
     175             : 
     176             : /* Get user-data in a context.  */
     177             : void *assuan_get_pointer (assuan_context_t ctx);
     178             : 
     179             : 
     180             : /* Definitions of flags for assuan_set_flag().  */
     181             : typedef unsigned int assuan_flag_t;
     182             : 
     183             : /* When using a pipe server, by default Assuan will wait for the
     184             :    forked process to die in assuan_release.  In certain cases this
     185             :    is not desirable.  By setting this flag, the waitpid will be
     186             :    skipped and the caller is responsible to cleanup a forked
     187             :    process. */
     188             : #define ASSUAN_NO_WAITPID 1
     189             : /* This flag indicates whether Assuan logging is in confidential mode.
     190             :    You can use assuan_{begin,end}_condidential to change the mode.  */
     191             : #define ASSUAN_CONFIDENTIAL 2
     192             : /* This flag suppresses fix up of signal handlers for pipes.  */
     193             : #define ASSUAN_NO_FIXSIGNALS 3
     194             : /* This flag changes assuan_transact to return comment lines via the
     195             :    status callback.  The default is to skip comment lines.  */
     196             : #define ASSUAN_CONVEY_COMMENTS 4
     197             : /* This flag disables logging for one context.  */
     198             : #define ASSUAN_NO_LOGGING 5
     199             : /* This flag forces a connection close.  */
     200             : #define ASSUAN_FORCE_CLOSE 6
     201             : 
     202             : /* For context CTX, set the flag FLAG to VALUE.  Values for flags
     203             :    are usually 1 or 0 but certain flags might allow for other values;
     204             :    see the description of the type assuan_flag_t for details.  */
     205             : void assuan_set_flag (assuan_context_t ctx, assuan_flag_t flag, int value);
     206             : 
     207             : /* Return the VALUE of FLAG in context CTX.  */
     208             : int assuan_get_flag (assuan_context_t ctx, assuan_flag_t flag);
     209             : 
     210             : 
     211             : /* Same as assuan_set_flag (ctx, ASSUAN_CONFIDENTIAL, 1).  */
     212             : void assuan_begin_confidential (assuan_context_t ctx);
     213             : 
     214             : /* Same as assuan_set_flag (ctx, ASSUAN_CONFIDENTIAL, 0).  */
     215             : void assuan_end_confidential (assuan_context_t ctx);
     216             : 
     217             : 
     218             : /* Direction values for assuan_set_io_monitor.  */
     219             : #define ASSUAN_IO_FROM_PEER 0
     220             : #define ASSUAN_IO_TO_PEER 1
     221             : 
     222             : /* Return flags of I/O monitor.  */
     223             : #define ASSUAN_IO_MONITOR_NOLOG 1
     224             : #define ASSUAN_IO_MONITOR_IGNORE 2
     225             : 
     226             : /* The IO monitor gets to see all I/O on the context, and can return
     227             :    ASSUAN_IO_MONITOR_* bits to control actions on it.  */
     228             : typedef unsigned int (*assuan_io_monitor_t) (assuan_context_t ctx, void *hook,
     229             :                                              int inout, const char *line,
     230             :                                              size_t linelen);
     231             : 
     232             : /* Set the IO monitor function.  */
     233             : void assuan_set_io_monitor (assuan_context_t ctx,
     234             :                             assuan_io_monitor_t io_monitor, void *hook_data);
     235             : 
     236             : 
     237             : #define ASSUAN_SYSTEM_HOOKS_VERSION 2
     238             : #define ASSUAN_SPAWN_DETACHED 128
     239             : struct assuan_system_hooks
     240             : {
     241             :   /* Always set to ASSUAN_SYTEM_HOOKS_VERSION.  */
     242             :   int version;
     243             : 
     244             :   /* Sleep for the given number of microseconds.  */
     245             :   void (*usleep) (assuan_context_t ctx, unsigned int usec);
     246             : 
     247             :   /* Create a pipe with an inheritable end.  */
     248             :   int (*pipe) (assuan_context_t ctx, assuan_fd_t fd[2], int inherit_idx);
     249             : 
     250             :  /* Close the given file descriptor, created with _assuan_pipe or one
     251             :    of the socket functions.  */
     252             :   int (*close) (assuan_context_t ctx, assuan_fd_t fd);
     253             : 
     254             : 
     255             :   ssize_t (*read) (assuan_context_t ctx, assuan_fd_t fd, void *buffer,
     256             :                    size_t size);
     257             :   ssize_t (*write) (assuan_context_t ctx, assuan_fd_t fd,
     258             :                     const void *buffer, size_t size);
     259             : 
     260             :   int (*recvmsg) (assuan_context_t ctx, assuan_fd_t fd, assuan_msghdr_t msg,
     261             :                   int flags);
     262             :   int (*sendmsg) (assuan_context_t ctx, assuan_fd_t fd,
     263             :                   const assuan_msghdr_t msg, int flags);
     264             : 
     265             :   /* If NAME is NULL, don't exec, just fork.  FD_CHILD_LIST is
     266             :      modified to reflect the value of the FD in the peer process (on
     267             :      Windows).  */
     268             :   int (*spawn) (assuan_context_t ctx, pid_t *r_pid, const char *name,
     269             :                 const char **argv,
     270             :                 assuan_fd_t fd_in, assuan_fd_t fd_out,
     271             :                 assuan_fd_t *fd_child_list,
     272             :                 void (*atfork) (void *opaque, int reserved),
     273             :                 void *atforkvalue, unsigned int flags);
     274             : 
     275             :   /* If action is 0, like waitpid.  If action is 1, just release the PID?  */
     276             :   pid_t (*waitpid) (assuan_context_t ctx, pid_t pid,
     277             :                     int action, int *status, int options);
     278             :   int (*socketpair) (assuan_context_t ctx, int _namespace, int style,
     279             :                      int protocol, assuan_fd_t filedes[2]);
     280             :   int (*socket) (assuan_context_t ctx, int _namespace, int style, int protocol);
     281             :   int (*connect) (assuan_context_t ctx, int sock, struct sockaddr *addr, socklen_t length);
     282             : };
     283             : typedef struct assuan_system_hooks *assuan_system_hooks_t;
     284             : 
     285             : 
     286             : /* Configuration of the default log handler.  */
     287             : 
     288             : /* Set the prefix to be used at the start of a line emitted by assuan
     289             :    on the log stream.  The default is the empty string.  Note, that
     290             :    this function is not thread-safe and should in general be used
     291             :    right at startup. */
     292             : void assuan_set_assuan_log_prefix (const char *text);
     293             : 
     294             : /* Return a prefix to be used at the start of a line emitted by assuan
     295             :    on the log stream.  The default implementation returns the empty
     296             :    string, i.e. ""  */
     297             : const char *assuan_get_assuan_log_prefix (void);
     298             : 
     299             : /* Global default log stream.  */
     300             : void assuan_set_assuan_log_stream (FILE *fp);
     301             : 
     302             : /* Set the per context log stream for the default log handler.  */
     303             : void assuan_set_log_stream (assuan_context_t ctx, FILE *fp);
     304             : 
     305             : 
     306             : typedef gpg_error_t (*assuan_handler_t) (assuan_context_t, char *);
     307             : 
     308             : /*-- assuan-handler.c --*/
     309             : gpg_error_t assuan_register_command (assuan_context_t ctx,
     310             :                                      const char *cmd_string,
     311             :                                      assuan_handler_t handler,
     312             :                                      const char *help_string);
     313             : gpg_error_t assuan_register_pre_cmd_notify (assuan_context_t ctx,
     314             :                                              gpg_error_t (*fnc)(assuan_context_t, const char *cmd));
     315             : gpg_error_t assuan_register_post_cmd_notify (assuan_context_t ctx,
     316             :                                              void (*fnc)(assuan_context_t,
     317             :                                                          gpg_error_t));
     318             : gpg_error_t assuan_register_bye_notify (assuan_context_t ctx,
     319             :                                         assuan_handler_t handler);
     320             : gpg_error_t assuan_register_reset_notify (assuan_context_t ctx,
     321             :                                           assuan_handler_t handler);
     322             : gpg_error_t assuan_register_cancel_notify (assuan_context_t ctx,
     323             :                                            assuan_handler_t handler);
     324             : gpg_error_t assuan_register_input_notify (assuan_context_t ctx,
     325             :                                           assuan_handler_t handler);
     326             : gpg_error_t assuan_register_output_notify (assuan_context_t ctx,
     327             :                                            assuan_handler_t handler);
     328             : 
     329             : gpg_error_t assuan_register_option_handler (assuan_context_t ctx,
     330             :                                             gpg_error_t (*fnc)(assuan_context_t,
     331             :                                                                const char*,
     332             :                                                                const char*));
     333             : 
     334             : gpg_error_t assuan_process (assuan_context_t ctx);
     335             : gpg_error_t assuan_process_next (assuan_context_t ctx, int *done);
     336             : gpg_error_t assuan_process_done (assuan_context_t ctx, gpg_error_t rc);
     337             : int assuan_get_active_fds (assuan_context_t ctx, int what,
     338             :                            assuan_fd_t *fdarray, int fdarraysize);
     339             : 
     340             : const char *assuan_get_command_name (assuan_context_t ctx);
     341             : 
     342             : FILE *assuan_get_data_fp (assuan_context_t ctx);
     343             : gpg_error_t assuan_set_okay_line (assuan_context_t ctx, const char *line);
     344             : gpg_error_t assuan_write_status (assuan_context_t ctx,
     345             :                                  const char *keyword, const char *text);
     346             : 
     347             : /* Negotiate a file descriptor.  If LINE contains "FD=N", returns N
     348             :    assuming a local file descriptor.  If LINE contains "FD" reads a
     349             :    file descriptor via CTX and stores it in *RDF (the CTX must be
     350             :    capable of passing file descriptors).  Under W32 the returned FD is
     351             :    a libc-type one.  */
     352             : gpg_error_t assuan_command_parse_fd (assuan_context_t ctx, char *line,
     353             :                                         assuan_fd_t *rfd);
     354             : 
     355             : 
     356             : /*-- assuan-listen.c --*/
     357             : gpg_error_t assuan_set_hello_line (assuan_context_t ctx, const char *line);
     358             : gpg_error_t assuan_accept (assuan_context_t ctx);
     359             : assuan_fd_t assuan_get_input_fd (assuan_context_t ctx);
     360             : assuan_fd_t assuan_get_output_fd (assuan_context_t ctx);
     361             : gpg_error_t assuan_close_input_fd (assuan_context_t ctx);
     362             : gpg_error_t assuan_close_output_fd (assuan_context_t ctx);
     363             : 
     364             : 
     365             : /*-- assuan-pipe-server.c --*/
     366             : gpg_error_t assuan_init_pipe_server (assuan_context_t ctx,
     367             :                                      assuan_fd_t filedes[2]);
     368             : 
     369             : /*-- assuan-socket-server.c --*/
     370             : #define ASSUAN_SOCKET_SERVER_FDPASSING 1
     371             : #define ASSUAN_SOCKET_SERVER_ACCEPTED 2
     372             : gpg_error_t assuan_init_socket_server (assuan_context_t ctx,
     373             :                                        assuan_fd_t listen_fd,
     374             :                                        unsigned int flags);
     375             : void assuan_set_sock_nonce (assuan_context_t ctx, assuan_sock_nonce_t *nonce);
     376             : 
     377             : /*-- assuan-pipe-connect.c --*/
     378             : #define ASSUAN_PIPE_CONNECT_FDPASSING 1
     379             : #define ASSUAN_PIPE_CONNECT_DETACHED 128
     380             : gpg_error_t assuan_pipe_connect (assuan_context_t ctx,
     381             :                                  const char *name,
     382             :                                  const char *argv[],
     383             :                                  assuan_fd_t *fd_child_list,
     384             :                                  void (*atfork) (void *, int),
     385             :                                  void *atforkvalue,
     386             :                                  unsigned int flags);
     387             : 
     388             : /*-- assuan-socket-connect.c --*/
     389             : #define ASSUAN_SOCKET_CONNECT_FDPASSING 1
     390             : gpg_error_t assuan_socket_connect (assuan_context_t ctx, const char *name,
     391             :                                    pid_t server_pid, unsigned int flags);
     392             : 
     393             : /*-- assuan-socket-connect.c --*/
     394             : gpg_error_t assuan_socket_connect_fd (assuan_context_t ctx, int fd,
     395             :                                    unsigned int flags);
     396             : 
     397             : /*-- context.c --*/
     398             : pid_t assuan_get_pid (assuan_context_t ctx);
     399             : struct _assuan_peercred
     400             : {
     401             : #ifdef _WIN32
     402             :   /* Empty struct not allowed on some compilers.  */
     403             :   unsigned int _dummy;
     404             : #else
     405             :   pid_t pid;
     406             :   uid_t uid;
     407             :   gid_t gid;
     408             : #endif
     409             : };
     410             : typedef struct _assuan_peercred *assuan_peercred_t;
     411             : 
     412             : gpg_error_t assuan_get_peercred (assuan_context_t ctx,
     413             :                                  assuan_peercred_t *peercred);
     414             : 
     415             : 
     416             : 
     417             : /* Client interface.  */
     418             : #define ASSUAN_RESPONSE_ERROR 0
     419             : #define ASSUAN_RESPONSE_OK 1
     420             : #define ASSUAN_RESPONSE_DATA 2
     421             : #define ASSUAN_RESPONSE_INQUIRE 3
     422             : #define ASSUAN_RESPONSE_STATUS 4
     423             : #define ASSUAN_RESPONSE_END 5
     424             : #define ASSUAN_RESPONSE_COMMENT 6
     425             : typedef int assuan_response_t;
     426             : 
     427             : /* This already de-escapes data lines.  */
     428             : gpg_error_t assuan_client_read_response (assuan_context_t ctx,
     429             :                                          char **line, int *linelen);
     430             : 
     431             : gpg_error_t assuan_client_parse_response (assuan_context_t ctx,
     432             :                                           char *line, int linelen,
     433             :                                           assuan_response_t *response,
     434             :                                           int *off);
     435             : 
     436             : /*-- assuan-client.c --*/
     437             : gpg_error_t
     438             : assuan_transact (assuan_context_t ctx,
     439             :                  const char *command,
     440             :                  gpg_error_t (*data_cb)(void *, const void *, size_t),
     441             :                  void *data_cb_arg,
     442             :                  gpg_error_t (*inquire_cb)(void*, const char *),
     443             :                  void *inquire_cb_arg,
     444             :                  gpg_error_t (*status_cb)(void*, const char *),
     445             :                  void *status_cb_arg);
     446             : 
     447             : 
     448             : /*-- assuan-inquire.c --*/
     449             : gpg_error_t assuan_inquire (assuan_context_t ctx, const char *keyword,
     450             :                                unsigned char **r_buffer, size_t *r_length,
     451             :                                size_t maxlen);
     452             : gpg_error_t assuan_inquire_ext (assuan_context_t ctx, const char *keyword,
     453             :                                 size_t maxlen,
     454             :                                 gpg_error_t (*cb) (void *cb_data,
     455             :                                                    gpg_error_t rc,
     456             :                                                    unsigned char *buf,
     457             :                                                    size_t buf_len),
     458             :                                 void *cb_data);
     459             : /*-- assuan-buffer.c --*/
     460             : gpg_error_t assuan_read_line (assuan_context_t ctx,
     461             :                               char **line, size_t *linelen);
     462             : int assuan_pending_line (assuan_context_t ctx);
     463             : gpg_error_t assuan_write_line (assuan_context_t ctx, const char *line);
     464             : gpg_error_t assuan_send_data (assuan_context_t ctx,
     465             :                               const void *buffer, size_t length);
     466             : 
     467             : /* The file descriptor must be pending before assuan_receivefd is
     468             :    called.  This means that assuan_sendfd should be called *before* the
     469             :    trigger is sent (normally via assuan_write_line ("INPUT FD")).  */
     470             : gpg_error_t assuan_sendfd (assuan_context_t ctx, assuan_fd_t fd);
     471             : gpg_error_t assuan_receivefd (assuan_context_t ctx, assuan_fd_t *fd);
     472             : 
     473             : 
     474             : /*-- assuan-util.c --*/
     475             : gpg_error_t assuan_set_error (assuan_context_t ctx, gpg_error_t err,
     476             :                               const char *text);
     477             : 
     478             : 
     479             : 
     480             : /*-- assuan-socket.c --*/
     481             : 
     482             : /* This flag is used with assuan_sock_connect_byname to
     483             :    connect via SOCKS.  */
     484             : #define ASSUAN_SOCK_SOCKS   1
     485             : /* This flag is used with assuan_sock_connect_byname to force a
     486             :    connection via Tor even if the socket subsystem has not been
     487             :    swicthed into Tor mode.  This flags overrides ASSUAN_SOCK_SOCKS. */
     488             : #define ASSUAN_SOCK_TOR     2
     489             : 
     490             : /* These are socket wrapper functions to support an emulation of Unix
     491             :    domain sockets on Windows W32.  */
     492             : gpg_error_t assuan_sock_init (void);
     493             : void assuan_sock_deinit (void);
     494             : int assuan_sock_close (assuan_fd_t fd);
     495             : assuan_fd_t assuan_sock_new (int domain, int type, int proto);
     496             : int assuan_sock_set_flag (assuan_fd_t sockfd, const char *name, int value);
     497             : int assuan_sock_get_flag (assuan_fd_t sockfd, const char *name, int *r_value);
     498             : int assuan_sock_connect (assuan_fd_t sockfd,
     499             :                          struct sockaddr *addr, int addrlen);
     500             : assuan_fd_t assuan_sock_connect_byname (const char *host, unsigned short port,
     501             :                                         int reserved,
     502             :                                         const char *credentials,
     503             :                                         unsigned int flags);
     504             : int assuan_sock_bind (assuan_fd_t sockfd, struct sockaddr *addr, int addrlen);
     505             : int assuan_sock_set_sockaddr_un (const char *fname, struct sockaddr *addr,
     506             :                                  int *r_redirected);
     507             : int assuan_sock_get_nonce (struct sockaddr *addr, int addrlen,
     508             :                            assuan_sock_nonce_t *nonce);
     509             : int assuan_sock_check_nonce (assuan_fd_t fd, assuan_sock_nonce_t *nonce);
     510             : 
     511             : 
     512             : /* Set the default or per context system callbacks.  This is
     513             :    irreversible.  */
     514             : void assuan_set_system_hooks (assuan_system_hooks_t system_hooks);
     515             : 
     516             : void assuan_ctx_set_system_hooks (assuan_context_t ctx,
     517             :                                   assuan_system_hooks_t system_hooks);
     518             : 
     519             : void __assuan_usleep (assuan_context_t ctx, unsigned int usec);
     520             : int __assuan_pipe (assuan_context_t ctx, assuan_fd_t fd[2], int inherit_idx);
     521             : int __assuan_close (assuan_context_t ctx, assuan_fd_t fd);
     522             : int __assuan_spawn (assuan_context_t ctx, pid_t *r_pid, const char *name,
     523             :                     const char **argv, assuan_fd_t fd_in, assuan_fd_t fd_out,
     524             :                     assuan_fd_t *fd_child_list,
     525             :                     void (*atfork) (void *opaque, int reserved),
     526             :                     void *atforkvalue, unsigned int flags);
     527             : int __assuan_socketpair (assuan_context_t ctx, int _namespace, int style,
     528             :                          int protocol, assuan_fd_t filedes[2]);
     529             : int __assuan_socket (assuan_context_t ctx, int _namespace, int style, int protocol);
     530             : int __assuan_connect (assuan_context_t ctx, int sock, struct sockaddr *addr, socklen_t length);
     531             : ssize_t __assuan_read (assuan_context_t ctx, assuan_fd_t fd, void *buffer, size_t size);
     532             : ssize_t __assuan_write (assuan_context_t ctx, assuan_fd_t fd, const void *buffer, size_t size);
     533             : int __assuan_recvmsg (assuan_context_t ctx, assuan_fd_t fd, assuan_msghdr_t msg, int flags);
     534             : int __assuan_sendmsg (assuan_context_t ctx, assuan_fd_t fd, const assuan_msghdr_t msg, int flags);
     535             : pid_t __assuan_waitpid (assuan_context_t ctx, pid_t pid, int nowait, int *status, int options);
     536             : 
     537             : 
     538             : #define ASSUAN_SYSTEM_PTH_IMPL                                          \
     539             :   static void _assuan_pth_usleep (assuan_context_t ctx, unsigned int usec) \
     540             :   { (void) ctx; pth_usleep (usec); }                                    \
     541             :   static ssize_t _assuan_pth_read (assuan_context_t ctx, assuan_fd_t fd, \
     542             :                                 void *buffer, size_t size)              \
     543             :   { (void) ctx; return pth_read (fd, buffer, size); }                   \
     544             :   static ssize_t _assuan_pth_write (assuan_context_t ctx, assuan_fd_t fd, \
     545             :                                  const void *buffer, size_t size)       \
     546             :   { (void) ctx; return pth_write (fd, buffer, size); }                  \
     547             :   static int _assuan_pth_recvmsg (assuan_context_t ctx, assuan_fd_t fd, \
     548             :                                   assuan_msghdr_t msg, int flags)       \
     549             :   {                                                                     \
     550             :     /* Pth does not provide a recvmsg function.  We implement it.  */   \
     551             :     int ret;                                                            \
     552             :     int fdmode;                                                         \
     553             :                                                                         \
     554             :     (void) ctx;                                                         \
     555             :     fdmode = pth_fdmode (fd, PTH_FDMODE_POLL);                          \
     556             :     if (fdmode == PTH_FDMODE_ERROR)                                     \
     557             :       {                                                                 \
     558             :         errno = EBADF;                                                  \
     559             :         return -1;                                                      \
     560             :       }                                                                 \
     561             :     if (fdmode == PTH_FDMODE_BLOCK)                                     \
     562             :       {                                                                 \
     563             :         fd_set fds;                                                     \
     564             :                                                                         \
     565             :         FD_ZERO (&fds);                                                     \
     566             :         FD_SET (fd, &fds);                                          \
     567             :         while ((ret = pth_select (fd + 1, &fds, NULL, NULL, NULL)) < 0   \
     568             :                && errno == EINTR)                                       \
     569             :           ;                                                             \
     570             :         if (ret < 0)                                                 \
     571             :           return -1;                                                    \
     572             :       }                                                                 \
     573             :                                                                         \
     574             :     while ((ret = recvmsg (fd, msg, flags)) == -1 && errno == EINTR)    \
     575             :       ;                                                                 \
     576             :     return ret;                                                         \
     577             :   }                                                                     \
     578             :   static int _assuan_pth_sendmsg (assuan_context_t ctx, assuan_fd_t fd, \
     579             :                                   const assuan_msghdr_t msg, int flags) \
     580             :   {                                                                     \
     581             :     /* Pth does not provide a sendmsg function.  We implement it.  */   \
     582             :     int ret;                                                            \
     583             :     int fdmode;                                                         \
     584             :                                                                         \
     585             :     (void) ctx;                                                         \
     586             :     fdmode = pth_fdmode (fd, PTH_FDMODE_POLL);                          \
     587             :     if (fdmode == PTH_FDMODE_ERROR)                                     \
     588             :       {                                                                 \
     589             :         errno = EBADF;                                                  \
     590             :         return -1;                                                      \
     591             :       }                                                                 \
     592             :     if (fdmode == PTH_FDMODE_BLOCK)                                     \
     593             :       {                                                                 \
     594             :         fd_set fds;                                                     \
     595             :                                                                         \
     596             :         FD_ZERO (&fds);                                                     \
     597             :         FD_SET (fd, &fds);                                          \
     598             :         while ((ret = pth_select (fd + 1, NULL, &fds, NULL, NULL)) < 0   \
     599             :                && errno == EINTR)                                       \
     600             :           ;                                                             \
     601             :         if (ret < 0)                                                 \
     602             :           return -1;                                                    \
     603             :         }                                                               \
     604             :                                                                         \
     605             :     while ((ret = sendmsg (fd, msg, flags)) == -1 && errno == EINTR)    \
     606             :       ;                                                                 \
     607             :     return ret;                                                         \
     608             :   }                                                                     \
     609             :   static pid_t _assuan_pth_waitpid (assuan_context_t ctx, pid_t pid,     \
     610             :                                    int nowait, int *status, int options) \
     611             :   { (void) ctx;                                                         \
     612             :      if (!nowait) return pth_waitpid (pid, status, options);            \
     613             :       else return 0; }                                                  \
     614             :                                                                         \
     615             :   struct assuan_system_hooks _assuan_system_pth =                       \
     616             :     { ASSUAN_SYSTEM_HOOKS_VERSION, _assuan_pth_usleep, __assuan_pipe,   \
     617             :       __assuan_close, _assuan_pth_read, _assuan_pth_write,              \
     618             :       _assuan_pth_recvmsg, _assuan_pth_sendmsg,                         \
     619             :       __assuan_spawn, _assuan_pth_waitpid, __assuan_socketpair,         \
     620             :       __assuan_socket, __assuan_connect }
     621             : 
     622             : extern struct assuan_system_hooks _assuan_system_pth;
     623             : #define ASSUAN_SYSTEM_PTH &_assuan_system_pth
     624             : 
     625             : #define ASSUAN_SYSTEM_NPTH_IMPL                                         \
     626             :   static void _assuan_npth_usleep (assuan_context_t ctx, unsigned int usec) \
     627             :   { (void) ctx; npth_usleep (usec); }                                   \
     628             :   static ssize_t _assuan_npth_read (assuan_context_t ctx, assuan_fd_t fd, \
     629             :                                     void *buffer, size_t size)          \
     630             :   { ssize_t res; (void) ctx; npth_unprotect();                          \
     631             :     res = __assuan_read (ctx, fd, buffer, size);                        \
     632             :     npth_protect(); return res; }                                       \
     633             :   static ssize_t _assuan_npth_write (assuan_context_t ctx, assuan_fd_t fd, \
     634             :                                      const void *buffer, size_t size)   \
     635             :   { ssize_t res; (void) ctx; npth_unprotect();                          \
     636             :     res = __assuan_write (ctx, fd, buffer, size);                       \
     637             :     npth_protect(); return res; }                                       \
     638             :   static int _assuan_npth_recvmsg (assuan_context_t ctx, assuan_fd_t fd, \
     639             :                                   assuan_msghdr_t msg, int flags)       \
     640             :   { int res; (void) ctx; npth_unprotect();                              \
     641             :     res = __assuan_recvmsg (ctx, fd, msg, flags);                       \
     642             :     npth_protect(); return res; }                                       \
     643             :   static int _assuan_npth_sendmsg (assuan_context_t ctx, assuan_fd_t fd, \
     644             :                                   const assuan_msghdr_t msg, int flags) \
     645             :   { int res; (void) ctx; npth_unprotect();                              \
     646             :     res = __assuan_sendmsg (ctx, fd, msg, flags);                       \
     647             :     npth_protect(); return res; }                                       \
     648             :   static pid_t _assuan_npth_waitpid (assuan_context_t ctx, pid_t pid,   \
     649             :                                      int nowait, int *status, int options) \
     650             :   { pid_t res; (void) ctx; npth_unprotect();                            \
     651             :     res = __assuan_waitpid (ctx, pid, nowait, status, options);         \
     652             :     npth_protect(); return res; }                                       \
     653             :   static int _assuan_npth_connect (assuan_context_t ctx, int sock,      \
     654             :                                    struct sockaddr *addr, socklen_t len)\
     655             :   { int res; npth_unprotect();                                          \
     656             :     res = __assuan_connect (ctx, sock, addr, len);                      \
     657             :     npth_protect(); return res; }                                       \
     658             :                                                                         \
     659             :   struct assuan_system_hooks _assuan_system_npth =                      \
     660             :     { ASSUAN_SYSTEM_HOOKS_VERSION, _assuan_npth_usleep, __assuan_pipe,  \
     661             :       __assuan_close, _assuan_npth_read, _assuan_npth_write,            \
     662             :       _assuan_npth_recvmsg, _assuan_npth_sendmsg,                       \
     663             :       __assuan_spawn, _assuan_npth_waitpid, __assuan_socketpair,        \
     664             :       __assuan_socket, _assuan_npth_connect }
     665             : 
     666             : extern struct assuan_system_hooks _assuan_system_npth;
     667             : #define ASSUAN_SYSTEM_NPTH &_assuan_system_npth
     668             : 
     669             : 
     670             : #ifdef __cplusplus
     671             : }
     672             : #endif
     673             : #endif /* ASSUAN_H */
     674             : /*
     675             : Local Variables:
     676             : buffer-read-only: t
     677             : End:
     678             : */

Generated by: LCOV version 1.11