Chnages to supporta pinnetry notification
[gpgme.git] / assuan / assuan.h
index 05f0212..6df0166 100644 (file)
@@ -1,5 +1,5 @@
-/* assuan.c - Definitions for the Assuan protocol
- *     Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc.
+/* assuan.h - Definitions for the Assuan IPC library
+ * Copyright (C) 2001, 2002, 2003, 2005, 2007 Free Software Foundation, Inc.
  *
  * This file is part of Assuan.
  *
@@ -15,7 +15,8 @@
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA 
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+ * USA. 
  */
 
 #ifndef ASSUAN_H
 #include <sys/types.h>
 #include <unistd.h>
 
-#include <sys/socket.h>
 
-#define _ASSUAN_IN_GPGME
-#ifdef _ASSUAN_IN_GPGME
+/* To use this file with libraries the following macros are useful:
+
+     #define _ASSUAN_EXT_SYM_PREFIX _foo_
+   
+     This prefixes all external symbols with "_foo_".
+
+     #define _ASSUAN_ONLY_GPG_ERRORS
+
+     If this is defined all old-style Assuan error codes are made
+     inactive as well as other dereacted stuff.
+
+   The follwing macros are used internally in the implementation of
+   libassuan:
+
+     #define _ASSUAN_NO_PTH 
+
+       This avoids inclusion of special GNU Pth hacks.
+
+     #define _ASSUAN_NO_FIXED_SIGNALS 
+
+       This disables changing of certain signal handler; i.e. SIGPIPE.
+
+     #define _ASSUAN_USE_DOUBLE_FORK
+
+       Use a double fork approach when connecting to a server through
+       a pipe.
+ */
+/**** Begin GPGME specific modifications. ******/
 #define _ASSUAN_EXT_SYM_PREFIX _gpgme_
+#define _ASSUAN_NO_PTH 
+#define _ASSUAN_NO_FIXED_SIGNALS 
+#define _ASSUAN_USE_DOUBLE_FORK
 
 #ifdef _ASSUAN_IN_GPGME_BUILD_ASSUAN
+#include <ath.h>
+
+int _gpgme_io_close (int fd);
 int _gpgme_io_read (int fd, void *buffer, size_t count);
 int _gpgme_io_write (int fd, const void *buffer, size_t count);
-ssize_t _gpgme_ath_select (int nfd, fd_set *rset, fd_set *wset, fd_set *eset,
-                          struct timeval *timeout);
-ssize_t _gpgme_ath_waitpid (pid_t pid, int *status, int options);
-int _gpgme_ath_accept (int s, struct sockaddr *addr, socklen_t *length_ptr);
-int _gpgme_ath_connect (int s, struct sockaddr *addr, socklen_t length);
-int _gpgme_ath_sendmsg (int s, const struct msghdr *msg, int flags);
-int _gpgme_ath_recvmsg (int s, struct msghdr *msg, int flags);
+int _gpgme_io_sendmsg (int sock, const struct msghdr *msg, int flags);
+int _gpgme_io_recvmsg (int sock, struct msghdr *msg, int flags);
 
+#define close         _gpgme_io_close
 #define read          _gpgme_io_read
 #define write         _gpgme_io_write
 #define waitpid              _gpgme_ath_waitpid
 #define select       _gpgme_ath_select
 #define accept        _gpgme_ath_accept
 #define connect       _gpgme_ath_connect
-#define sendmsg              _gpgme_ath_sendmsg
-#define recvmsg       _gpgme_ath_recvmsg
-#endif
-#endif
+#define sendmsg              _gpgme_io_sendmsg
+#define recvmsg       _gpgme_io_recvmsg
+#endif /*_ASSUAN_IN_GPGME_BUILD_ASSUAN*/
+/**** End GPGME specific modifications. ******/
+
 
 #ifdef _ASSUAN_EXT_SYM_PREFIX
 #define _ASSUAN_PREFIX1(x,y) x ## y
@@ -59,6 +88,8 @@ int _gpgme_ath_recvmsg (int s, struct msghdr *msg, int flags);
 #define _ASSUAN_PREFIX(x) _ASSUAN_PREFIX2(_ASSUAN_EXT_SYM_PREFIX,x)
 #define assuan_ _ASSUAN_PREFIX(assuan_)
 #define assuan_register_command _ASSUAN_PREFIX(assuan_register_command)
+#define assuan_register_post_cmd_notify \
+  _ASSUAN_PREFIX(assuan_register_post_cmd_notify)
 #define assuan_register_bye_notify _ASSUAN_PREFIX(assuan_register_bye_notify)
 #define assuan_register_reset_notify \
   _ASSUAN_PREFIX(assuan_register_reset_notify)
@@ -88,12 +119,15 @@ int _gpgme_ath_recvmsg (int s, struct msghdr *msg, int flags);
 #define assuan_init_socket_server _ASSUAN_PREFIX(assuan_init_socket_server)
 #define assuan_init_connected_socket_server \
   _ASSUAN_PREFIX(assuan_init_connected_socket_server)
+#define assuan_init_socket_server_ext \
+  _ASSUAN_PREFIX(assuan_init_socket_server_ext)
 #define assuan_pipe_connect _ASSUAN_PREFIX(assuan_pipe_connect)
+#define assuan_pipe_connect_ext _ASSUAN_PREFIX(assuan_pipe_connect_ext)
 #define assuan_socket_connect _ASSUAN_PREFIX(assuan_socket_connect)
-#define assuan_domain_connect _ASSUAN_PREFIX(assuan_domain_connect)
-#define assuan_init_domain_server _ASSUAN_PREFIX(assuan_init_domain_server)
+#define assuan_socket_connect_ext _ASSUAN_PREFIX(assuan_socket_connect_ext)
 #define assuan_disconnect _ASSUAN_PREFIX(assuan_disconnect)
 #define assuan_get_pid _ASSUAN_PREFIX(assuan_get_pid)
+#define assuan_get_peercred _ASSUAN_PREFIX(assuan_get_peercred)
 #define assuan_transact _ASSUAN_PREFIX(assuan_transact)
 #define assuan_inquire _ASSUAN_PREFIX(assuan_inquire)
 #define assuan_read_line _ASSUAN_PREFIX(assuan_read_line)
@@ -103,19 +137,28 @@ int _gpgme_ath_recvmsg (int s, struct msghdr *msg, int flags);
 #define assuan_sendfd _ASSUAN_PREFIX(assuan_sendfd)
 #define assuan_receivefd _ASSUAN_PREFIX(assuan_receivefd)
 #define assuan_set_malloc_hooks _ASSUAN_PREFIX(assuan_set_malloc_hooks)
+#define assuan_set_assuan_log_level _ASSUAN_PREFIX(assuan_set_assuan_log_level)
 #define assuan_set_log_stream _ASSUAN_PREFIX(assuan_set_log_stream)
 #define assuan_set_error _ASSUAN_PREFIX(assuan_set_error)
 #define assuan_set_pointer _ASSUAN_PREFIX(assuan_set_pointer)
 #define assuan_get_pointer _ASSUAN_PREFIX(assuan_get_pointer)
+#define assuan_set_io_monitor _ASSUAN_PREFIX(assuan_set_io_monitor)
 #define assuan_begin_confidential _ASSUAN_PREFIX(assuan_begin_confidential)
 #define assuan_end_confidential _ASSUAN_PREFIX(assuan_end_confidential)
 #define assuan_strerror _ASSUAN_PREFIX(assuan_strerror)
+#define assuan_set_assuan_err_source \
+  _ASSUAN_PREFIX(assuan_set_assuan_err_source)
 #define assuan_set_assuan_log_stream \
   _ASSUAN_PREFIX(assuan_set_assuan_log_stream)
 #define assuan_get_assuan_log_stream \
   _ASSUAN_PREFIX(assuan_get_assuan_log_stream)
 #define assuan_get_assuan_log_prefix \
   _ASSUAN_PREFIX(assuan_get_assuan_log_prefix)
+#define assuan_set_flag _ASSUAN_PREFIX(assuan_set_flag)
+#define assuan_get_flag _ASSUAN_PREFIX(assuan_get_flag)
+#define assuan_pipe_connect2 _ASSUAN_PREFIX(assuan_pipe_connect2)
+#define assuan_set_assuan_log_prefix \
+  _ASSUAN_PREFIX(assuan_set_assuan_log_prefix)
 
 /* And now the internal functions, argh...  */
 #define _assuan_read_line _ASSUAN_PREFIX(_assuan_read_line)
@@ -138,89 +181,156 @@ int _gpgme_ath_recvmsg (int s, struct msghdr *msg, int flags);
 #define _assuan_log_print_buffer _ASSUAN_PREFIX(_assuan_log_print_buffer)
 #define _assuan_log_sanitized_string \
   _ASSUAN_PREFIX(_assuan_log_sanitized_string)
+#define _assuan_log_printf _ASSUAN_PREFIX(_assuan_log_printf)
+#define _assuan_set_default_log_stream \
+  _ASSUAN_PREFIX(_assuan_set_default_log_stream)
+#define _assuan_w32_strerror _ASSUAN_PREFIX(_assuan_w32_strerror)
+#define _assuan_gpg_strerror_r _ASSUAN_PREFIX(_assuan_gpg_strerror_r)
+#define _assuan_gpg_strsource  _ASSUAN_PREFIX(_assuan_gpg_strsource)
+#define _assuan_write_line _ASSUAN_PREFIX(_assuan_write_line)
+#define _assuan_close _ASSUAN_PREFIX(_assuan_close)   
+#define _assuan_sock_new _ASSUAN_PREFIX(_assuan_sock_new)  
+#define _assuan_sock_bind _ASSUAN_PREFIX(_assuan_sock_bind)
+#define _assuan_sock_connect _ASSUAN_PREFIX(_assuan_sock_connect)
+#define _assuan_error _ASSUAN_PREFIX(_assuan_error)
+#define _assuan_init_uds_io _ASSUAN_PREFIX(_assuan_init_uds_io)
+#define _assuan_uds_close_fds _ASSUAN_PREFIX(_assuan_uds_close_fds)
+#define _assuan_uds_deinit _ASSUAN_PREFIX(_assuan_uds_deinit)
+#define _assuan_simple_recvmsg _ASSUAN_PREFIX(_assuan_simple_recvmsg)
+#define _assuan_simple_sendmsg _ASSUAN_PREFIX(_assuan_simple_sendmsg)
+#define _assuan_waitpid _ASSUAN_PREFIX(_assuan_waitpid)
+
+#define _assuan_funopen _gpgme_funopen
+#endif /*_ASSUAN_EXT_SYM_PREFIX*/
 
-#endif
 
 #ifdef __cplusplus
 extern "C"
 {
+#if 0
+}
+#endif
 #endif
-  
 
-typedef enum
-{
-  ASSUAN_No_Error = 0,
-  ASSUAN_General_Error = 1,
-  ASSUAN_Out_Of_Core = 2,
-  ASSUAN_Invalid_Value = 3,
-  ASSUAN_Timeout = 4,
-  ASSUAN_Read_Error = 5,
-  ASSUAN_Write_Error = 6,
-  ASSUAN_Problem_Starting_Server = 7,
-  ASSUAN_Not_A_Server = 8,
-  ASSUAN_Not_A_Client = 9,
-  ASSUAN_Nested_Commands = 10,
-  ASSUAN_Invalid_Response = 11,
-  ASSUAN_No_Data_Callback = 12,
-  ASSUAN_No_Inquire_Callback = 13,
-  ASSUAN_Connect_Failed = 14,
-  ASSUAN_Accept_Failed = 15,
-
-  /* error codes above 99 are meant as status codes */
-  ASSUAN_Not_Implemented = 100,
-  ASSUAN_Server_Fault    = 101,
-  ASSUAN_Invalid_Command = 102,
-  ASSUAN_Unknown_Command = 103,
-  ASSUAN_Syntax_Error    = 104,
-  ASSUAN_Parameter_Error = 105,
-  ASSUAN_Parameter_Conflict = 106,
-  ASSUAN_Line_Too_Long = 107,
-  ASSUAN_Line_Not_Terminated = 108,
-  ASSUAN_No_Input = 109,
-  ASSUAN_No_Output = 110,
-  ASSUAN_Canceled = 111,
-  ASSUAN_Unsupported_Algorithm = 112,
-  ASSUAN_Server_Resource_Problem = 113,
-  ASSUAN_Server_IO_Error = 114,
-  ASSUAN_Server_Bug = 115,
-  ASSUAN_No_Data_Available = 116,
-  ASSUAN_Invalid_Data = 117,
-  ASSUAN_Unexpected_Command = 118,
-  ASSUAN_Too_Much_Data = 119,
-  ASSUAN_Inquire_Unknown = 120,
-  ASSUAN_Inquire_Error = 121,
-  ASSUAN_Invalid_Option = 122,
-  ASSUAN_Invalid_Index = 123,
-  ASSUAN_Unexpected_Status = 124,
-  ASSUAN_Unexpected_Data = 125,
-  ASSUAN_Invalid_Status = 126,
-
-  ASSUAN_Not_Confirmed = 128,
-
-  ASSUAN_Bad_Certificate = 201,
-  ASSUAN_Bad_Certificate_Chain = 202,
-  ASSUAN_Missing_Certificate = 203,
-  ASSUAN_Bad_Signature = 204,
-  ASSUAN_No_Agent = 205,
-  ASSUAN_Agent_Error = 206,
-  ASSUAN_No_Public_Key = 207,
-  ASSUAN_No_Secret_Key = 208,
-  ASSUAN_Invalid_Name = 209,
-
-  ASSUAN_Cert_Revoked = 301,
-  ASSUAN_No_CRL_For_Cert = 302,
-  ASSUAN_CRL_Too_Old = 303,
-  ASSUAN_Not_Trusted = 304,
-
-  ASSUAN_Card_Error = 401,
-  ASSUAN_Invalid_Card = 402,
-  ASSUAN_No_PKCS15_App = 403,
-  ASSUAN_Card_Not_Present = 404,
-  ASSUAN_Invalid_Id = 405
-
-} AssuanError;
+
+/* Check for compiler features.  */
+#if __GNUC__
+#define _ASSUAN_GCC_VERSION (__GNUC__ * 10000 \
+                            + __GNUC_MINOR__ * 100 \
+                            + __GNUC_PATCHLEVEL__)
+
+#if _ASSUAN_GCC_VERSION > 30100
+#define _ASSUAN_DEPRECATED  __attribute__ ((__deprecated__))
+#endif
+#endif
+#ifndef _ASSUAN_DEPRECATED
+#define _ASSUAN_DEPRECATED
+#endif
+
+
+/* Assuan error codes.  These are only used by old applications or
+   those applications which won't make use of libgpg-error. */
+#ifndef _ASSUAN_ONLY_GPG_ERRORS
+#ifndef _ASSUAN_IN_LIBASSUAN
+#define  ASSUAN_No_Error 0
+#endif
+#define  ASSUAN_General_Error 1
+#define  ASSUAN_Out_Of_Core 2
+#define  ASSUAN_Invalid_Value 3
+#ifndef _ASSUAN_IN_LIBASSUAN
+#define  ASSUAN_Timeout 4
+#endif
+#define  ASSUAN_Read_Error 5
+#define  ASSUAN_Write_Error 6
+#define  ASSUAN_Problem_Starting_Server 7
+#define  ASSUAN_Not_A_Server 8
+#ifndef _ASSUAN_IN_LIBASSUAN
+#define  ASSUAN_Not_A_Client 9
+#endif
+#define  ASSUAN_Nested_Commands 10
+#define  ASSUAN_Invalid_Response 11
+#define  ASSUAN_No_Data_Callback 12
+#define  ASSUAN_No_Inquire_Callback 13
+#define  ASSUAN_Connect_Failed 14
+#define  ASSUAN_Accept_Failed 15
+
+  /* Error codes above 99 are meant as status codes */
+#define  ASSUAN_Not_Implemented 100
+#define  ASSUAN_Server_Fault    101
+#ifndef _ASSUAN_IN_LIBASSUAN
+#define  ASSUAN_Invalid_Command 102
+#endif
+#define  ASSUAN_Unknown_Command 103
+#define  ASSUAN_Syntax_Error    104
+#ifndef _ASSUAN_IN_LIBASSUAN
+#define  ASSUAN_Parameter_Error 105
+#endif
+#define  ASSUAN_Parameter_Conflict 106
+#define  ASSUAN_Line_Too_Long 107
+#define  ASSUAN_Line_Not_Terminated 108
+#ifndef _ASSUAN_IN_LIBASSUAN
+#define  ASSUAN_No_Input 109
+#define  ASSUAN_No_Output 110
+#endif
+#define  ASSUAN_Canceled 111
+#ifndef _ASSUAN_IN_LIBASSUAN
+#define  ASSUAN_Unsupported_Algorithm 112
+#define  ASSUAN_Server_Resource_Problem 113
+#define  ASSUAN_Server_IO_Error 114
+#define  ASSUAN_Server_Bug 115
+#define  ASSUAN_No_Data_Available 116
+#define  ASSUAN_Invalid_Data 117
+#endif
+#define  ASSUAN_Unexpected_Command 118
+#define  ASSUAN_Too_Much_Data 119
+#ifndef _ASSUAN_IN_LIBASSUAN
+#define  ASSUAN_Inquire_Unknown 120
+#define  ASSUAN_Inquire_Error 121
+#define  ASSUAN_Invalid_Option 122
+#define  ASSUAN_Invalid_Index 123
+#define  ASSUAN_Unexpected_Status 124
+#define  ASSUAN_Unexpected_Data 125
+#define  ASSUAN_Invalid_Status 126
+#define  ASSUAN_Locale_Problem 127
+#endif
+#define  ASSUAN_Not_Confirmed 128
+
+  /* Warning: Don't use the Error codes, below they are deprecated. */
+#ifndef _ASSUAN_IN_LIBASSUAN
+#define  ASSUAN_Bad_Certificate 201
+#define  ASSUAN_Bad_Certificate_Chain 202
+#define  ASSUAN_Missing_Certificate 203
+#define  ASSUAN_Bad_Signature 204
+#define  ASSUAN_No_Agent 205
+#define  ASSUAN_Agent_Error 206
+#define  ASSUAN_No_Public_Key 207
+#define  ASSUAN_No_Secret_Key 208
+#define  ASSUAN_Invalid_Name 209
+
+#define  ASSUAN_Cert_Revoked 301
+#define  ASSUAN_No_CRL_For_Cert 302
+#define  ASSUAN_CRL_Too_Old 303
+#define  ASSUAN_Not_Trusted 304
+
+#define  ASSUAN_Card_Error 401
+#define  ASSUAN_Invalid_Card 402
+#define  ASSUAN_No_PKCS15_App 403
+#define  ASSUAN_Card_Not_Present 404
+#define  ASSUAN_Invalid_Id 405
+
+  /* Error codes in the range 1000 to 9999 may be used by applications
+     at their own discretion. */
+#define  ASSUAN_USER_ERROR_FIRST 1000
+#define  ASSUAN_USER_ERROR_LAST 9999
+#endif
+
+typedef int assuan_error_t;
+
+typedef assuan_error_t AssuanError _ASSUAN_DEPRECATED; 
 
 /* This is a list of pre-registered ASSUAN commands */
+/* Note, these command IDs are now deprectated and solely exists for
+   compatibility reasons. */
 typedef enum
 {
   ASSUAN_CMD_NOP = 0,
@@ -237,156 +347,232 @@ typedef enum
   ASSUAN_CMD_USER = 256  /* Other commands should be used with this offset*/
 } AssuanCommand;
 
+
+#else  /*!_ASSUAN_ONLY_GPG_ERRORS*/
+
+typedef int assuan_error_t;
+
+#endif /*!_ASSUAN_ONLY_GPG_ERRORS*/
+
+
+/* Definitions of flags for assuan_set_flag(). */
+typedef enum
+  {
+    /* When using a pipe server, by default Assuan will wait for the
+       forked process to die in assuan_disconnect.  In certain cases
+       this is not desirable.  By setting this flag, the waitpid will
+       be skipped and the caller is responsible to cleanup a forked
+       process. */
+    ASSUAN_NO_WAITPID = 1
+  } 
+assuan_flag_t;
+
 #define ASSUAN_LINELENGTH 1002 /* 1000 + [CR,]LF */
 
 struct assuan_context_s;
-typedef struct assuan_context_s *ASSUAN_CONTEXT;
+typedef struct assuan_context_s *assuan_context_t;
+#ifndef _ASSUAN_ONLY_GPG_ERRORS
+typedef struct assuan_context_s *ASSUAN_CONTEXT _ASSUAN_DEPRECATED;
+#endif /*_ASSUAN_ONLY_GPG_ERRORS*/
 
 /*-- assuan-handler.c --*/
-int assuan_register_command (ASSUAN_CONTEXT ctx,
+int assuan_register_command (assuan_context_t ctx,
                              const char *cmd_string,
-                             int (*handler)(ASSUAN_CONTEXT, char *));
-int assuan_register_bye_notify (ASSUAN_CONTEXT ctx,
-                                void (*fnc)(ASSUAN_CONTEXT));
-int assuan_register_reset_notify (ASSUAN_CONTEXT ctx,
-                                  void (*fnc)(ASSUAN_CONTEXT));
-int assuan_register_cancel_notify (ASSUAN_CONTEXT ctx,
-                                   void (*fnc)(ASSUAN_CONTEXT));
-int assuan_register_input_notify (ASSUAN_CONTEXT ctx,
-                                  void (*fnc)(ASSUAN_CONTEXT, const char *));
-int assuan_register_output_notify (ASSUAN_CONTEXT ctx,
-                                  void (*fnc)(ASSUAN_CONTEXT, const char *));
-
-int assuan_register_option_handler (ASSUAN_CONTEXT ctx,
-                                    int (*fnc)(ASSUAN_CONTEXT,
+                             int (*handler)(assuan_context_t, char *));
+int assuan_register_post_cmd_notify (assuan_context_t ctx,
+                                     void (*fnc)(assuan_context_t, int));
+int assuan_register_bye_notify (assuan_context_t ctx,
+                                void (*fnc)(assuan_context_t));
+int assuan_register_reset_notify (assuan_context_t ctx,
+                                  void (*fnc)(assuan_context_t));
+int assuan_register_cancel_notify (assuan_context_t ctx,
+                                   void (*fnc)(assuan_context_t));
+int assuan_register_input_notify (assuan_context_t ctx,
+                                  void (*fnc)(assuan_context_t, const char *));
+int assuan_register_output_notify (assuan_context_t ctx,
+                                  void (*fnc)(assuan_context_t, const char *));
+
+int assuan_register_option_handler (assuan_context_t ctx,
+                                    int (*fnc)(assuan_context_t,
                                                const char*, const char*));
 
-int assuan_process (ASSUAN_CONTEXT ctx);
-int assuan_process_next (ASSUAN_CONTEXT ctx);
-int assuan_get_active_fds (ASSUAN_CONTEXT ctx, int what,
+int assuan_process (assuan_context_t ctx);
+int assuan_process_next (assuan_context_t ctx);
+int assuan_get_active_fds (assuan_context_t ctx, int what,
                            int *fdarray, int fdarraysize);
 
 
-FILE *assuan_get_data_fp (ASSUAN_CONTEXT ctx);
-AssuanError assuan_set_okay_line (ASSUAN_CONTEXT ctx, const char *line);
-void assuan_write_status (ASSUAN_CONTEXT ctx,
-                          const char *keyword, const char *text);
+FILE *assuan_get_data_fp (assuan_context_t ctx);
+assuan_error_t assuan_set_okay_line (assuan_context_t ctx, const char *line);
+assuan_error_t assuan_write_status (assuan_context_t ctx,
+                                    const char *keyword, const char *text);
 
 /* Negotiate a file descriptor.  If LINE contains "FD=N", returns N
    assuming a local file descriptor.  If LINE contains "FD" reads a
    file descriptor via CTX and stores it in *RDF (the CTX must be
    capable of passing file descriptors).  */
-AssuanError assuan_command_parse_fd (ASSUAN_CONTEXT ctx, char *line,
-                                    int *rfd);
+assuan_error_t assuan_command_parse_fd (assuan_context_t ctx, char *line,
+                                        int *rfd);
 
 /*-- assuan-listen.c --*/
-AssuanError assuan_set_hello_line (ASSUAN_CONTEXT ctx, const char *line);
-AssuanError assuan_accept (ASSUAN_CONTEXT ctx);
-int assuan_get_input_fd (ASSUAN_CONTEXT ctx);
-int assuan_get_output_fd (ASSUAN_CONTEXT ctx);
-AssuanError assuan_close_input_fd (ASSUAN_CONTEXT ctx);
-AssuanError assuan_close_output_fd (ASSUAN_CONTEXT ctx);
+assuan_error_t assuan_set_hello_line (assuan_context_t ctx, const char *line);
+assuan_error_t assuan_accept (assuan_context_t ctx);
+int assuan_get_input_fd (assuan_context_t ctx);
+int assuan_get_output_fd (assuan_context_t ctx);
+assuan_error_t assuan_close_input_fd (assuan_context_t ctx);
+assuan_error_t assuan_close_output_fd (assuan_context_t ctx);
 
 
 /*-- assuan-pipe-server.c --*/
-int assuan_init_pipe_server (ASSUAN_CONTEXT *r_ctx, int filedes[2]);
-void assuan_deinit_server (ASSUAN_CONTEXT ctx);
+int assuan_init_pipe_server (assuan_context_t *r_ctx, int filedes[2]);
+void assuan_deinit_server (assuan_context_t ctx);
 
 /*-- assuan-socket-server.c --*/
-int assuan_init_socket_server (ASSUAN_CONTEXT *r_ctx, int listen_fd);
-int assuan_init_connected_socket_server (ASSUAN_CONTEXT *r_ctx, int fd);
-
+int assuan_init_socket_server (assuan_context_t *r_ctx, int listen_fd);
+int assuan_init_connected_socket_server (assuan_context_t *r_ctx, 
+                                         int fd) _ASSUAN_DEPRECATED;
+int assuan_init_socket_server_ext (assuan_context_t *r_ctx, int fd,
+                                   unsigned int flags);
 
 /*-- assuan-pipe-connect.c --*/
-AssuanError assuan_pipe_connect (ASSUAN_CONTEXT *ctx, const char *name,
-                                 char *const argv[], int *fd_child_list);
-/*-- assuan-socket-connect.c --*/
-AssuanError assuan_socket_connect (ASSUAN_CONTEXT *ctx, const char *name,
-                                   pid_t server_pid);
-
-/*-- assuan-domain-connect.c --*/
-
-/* Connect to a Unix domain socket server.  RENDEZVOUSFD is
-   bidirectional file descriptor (normally returned via socketpair)
-   which the client can use to rendezvous with the server.  SERVER s
-   the server's pid.  */
-AssuanError assuan_domain_connect (ASSUAN_CONTEXT *r_ctx,
-                                  int rendezvousfd,
-                                  pid_t server);
-
-/*-- assuan-domain-server.c --*/
-
-/* RENDEZVOUSFD is a bidirectional file descriptor (normally returned
-   via socketpair) that the domain server can use to rendezvous with
-   the client.  CLIENT is the client's pid.  */
-AssuanError assuan_init_domain_server (ASSUAN_CONTEXT *r_ctx,
-                                      int rendezvousfd,
-                                      pid_t client);
+assuan_error_t assuan_pipe_connect (assuan_context_t *ctx,
+                                    const char *name,
+                                   const char *const argv[],
+                                   int *fd_child_list);
+assuan_error_t assuan_pipe_connect2 (assuan_context_t *ctx,
+                                     const char *name,
+                                     const char *const argv[],
+                                    int *fd_child_list,
+                                     void (*atfork) (void*, int),
+                                     void *atforkvalue) _ASSUAN_DEPRECATED;
+assuan_error_t assuan_pipe_connect_ext (assuan_context_t *ctx, 
+                                        const char *name,
+                                        const char *const argv[],
+                                        int *fd_child_list,
+                                        void (*atfork) (void *, int),
+                                        void *atforkvalue,
+                                        unsigned int flags);
 
+/*-- assuan-socket-connect.c --*/
+assuan_error_t assuan_socket_connect (assuan_context_t *ctx, 
+                                      const char *name,
+                                      pid_t server_pid);
+assuan_error_t assuan_socket_connect_ext (assuan_context_t *ctx,
+                                          const char *name,
+                                          pid_t server_pid,
+                                          unsigned int flags);
 
 /*-- assuan-connect.c --*/
-void assuan_disconnect (ASSUAN_CONTEXT ctx);
-pid_t assuan_get_pid (ASSUAN_CONTEXT ctx);
+void assuan_disconnect (assuan_context_t ctx);
+pid_t assuan_get_pid (assuan_context_t ctx);
+#ifndef HAVE_W32_SYSTEM
+assuan_error_t assuan_get_peercred (assuan_context_t ctx,
+                                    pid_t *pid, uid_t *uid, gid_t *gid);
+#endif
 
 /*-- assuan-client.c --*/
-AssuanError 
-assuan_transact (ASSUAN_CONTEXT ctx,
+assuan_error_t 
+assuan_transact (assuan_context_t ctx,
                  const char *command,
-                 AssuanError (*data_cb)(void *, const void *, size_t),
+                 int (*data_cb)(void *, const void *, size_t),
                  void *data_cb_arg,
-                 AssuanError (*inquire_cb)(void*, const char *),
+                 int (*inquire_cb)(void*, const char *),
                  void *inquire_cb_arg,
-                 AssuanError (*status_cb)(void*, const char *),
+                 int (*status_cb)(void*, const char *),
                  void *status_cb_arg);
 
 
 /*-- assuan-inquire.c --*/
-AssuanError assuan_inquire (ASSUAN_CONTEXT ctx, const char *keyword,
-                            char **r_buffer, size_t *r_length, size_t maxlen);
+assuan_error_t assuan_inquire (assuan_context_t ctx, const char *keyword,
+                               unsigned char **r_buffer, size_t *r_length,
+                               size_t maxlen);
 
 /*-- assuan-buffer.c --*/
-AssuanError assuan_read_line (ASSUAN_CONTEXT ctx,
+assuan_error_t assuan_read_line (assuan_context_t ctx,
                               char **line, size_t *linelen);
-int assuan_pending_line (ASSUAN_CONTEXT ctx);
-AssuanError assuan_write_line (ASSUAN_CONTEXT ctx, const char *line );
-AssuanError assuan_send_data (ASSUAN_CONTEXT ctx,
+int assuan_pending_line (assuan_context_t ctx);
+assuan_error_t assuan_write_line (assuan_context_t ctx, const char *line );
+assuan_error_t assuan_send_data (assuan_context_t ctx,
                               const void *buffer, size_t length);
 
 /* The file descriptor must be pending before assuan_receivefd is
-   call.  This means that assuan_sendfd should be called *before* the
-   trigger is sent (normally via assuan_send_data ("I sent you a
-   descriptor")).  */
-AssuanError assuan_sendfd (ASSUAN_CONTEXT ctx, int fd);
-AssuanError assuan_receivefd (ASSUAN_CONTEXT ctx, int *fd);
+   called.  This means that assuan_sendfd should be called *before* the
+   trigger is sent (normally via assuan_write_line ("INPUT FD")).  */
+assuan_error_t assuan_sendfd (assuan_context_t ctx, int fd);
+assuan_error_t assuan_receivefd (assuan_context_t ctx, int *fd);
 
 /*-- assuan-util.c --*/
 void assuan_set_malloc_hooks ( void *(*new_alloc_func)(size_t n),
                                void *(*new_realloc_func)(void *p, size_t n),
                                void (*new_free_func)(void*) );
-void assuan_set_log_stream (ASSUAN_CONTEXT ctx, FILE *fp);
-int assuan_set_error (ASSUAN_CONTEXT ctx, int err, const char *text);
-void assuan_set_pointer (ASSUAN_CONTEXT ctx, void *pointer);
-void *assuan_get_pointer (ASSUAN_CONTEXT ctx);
+void assuan_set_log_stream (assuan_context_t ctx, FILE *fp);
+int assuan_set_error (assuan_context_t ctx, int err, const char *text);
+void assuan_set_pointer (assuan_context_t ctx, void *pointer);
+void *assuan_get_pointer (assuan_context_t ctx);
 
-void assuan_begin_confidential (ASSUAN_CONTEXT ctx);
-void assuan_end_confidential (ASSUAN_CONTEXT ctx);
+void assuan_begin_confidential (assuan_context_t ctx);
+void assuan_end_confidential (assuan_context_t ctx);
 
-/*-- assuan-errors.c (built) --*/
-const char *assuan_strerror (AssuanError err);
+void assuan_set_io_monitor (assuan_context_t ctx,
+                            unsigned int (*monitor)(assuan_context_t ctx,
+                                                    int direction,
+                                                    const char *line,
+                                                    size_t linelen));
+
+/* For context CTX, set the flag FLAG to VALUE.  Values for flags
+   are usually 1 or 0 but certain flags might allow for other values;
+   see the description of the type assuan_flag_t for details. */
+void assuan_set_flag (assuan_context_t ctx, assuan_flag_t flag, int value);
+
+/* Return the VALUE of FLAG in context CTX. */ 
+int  assuan_get_flag (assuan_context_t ctx, assuan_flag_t flag);
+
+
+/*-- assuan-errors.c --*/
+
+#ifndef _ASSUAN_ONLY_GPG_ERRORS
+/* Return a string describing the assuan error.  The use of this
+   function is deprecated; it is better to call
+   assuan_set_assuan_err_source once and then make use libgpg-error. */
+const char *assuan_strerror (assuan_error_t err);
+#endif /*_ASSUAN_ONLY_GPG_ERRORS*/
+
+/* Enable gpg-error style error codes.  ERRSOURCE is one of gpg-error
+   sources.  Note, that this function is not thread-safe and should be
+   used right at startup. Switching back to the old style mode is not
+   supported. */
+void assuan_set_assuan_err_source (int errsource);
 
 /*-- assuan-logging.c --*/
 
-/* Set the stream to which assuan should log.  By default, this is
-   stderr.  */
+/* Set the log level for general assuan commands.  0 is no logging at
+   all, 1 is the standard logging and the default. Higher leveles may
+   be defined in the future.  Passing a level of -1 will not change
+   the current log level.  Returns previous log level.  Note, that
+   this function is not thread-safe and should in general be used
+   right at startup. */
+int assuan_set_assuan_log_level (int level);
+
+/* Set the stream to which assuan should log message not associated
+   with a context.  By default, this is stderr.  The default value
+   will be changed when the first log stream is associated with a
+   context.  Note, that this function is not thread-safe and should
+   in general be used right at startup. */
 extern void assuan_set_assuan_log_stream (FILE *fp);
 
-/* Return the stream which is currently being using for logging.  */
+/* Return the stream which is currently being using for global logging.  */
 extern FILE *assuan_get_assuan_log_stream (void);
 
-/* User defined call back.  Return a prefix to be used at the start of
-   a line emitted by assuan on the log stream.  The default
-   implementation returns the empty string, i.e. ""  */
-extern const char *assuan_get_assuan_log_prefix (void);
+/* Set the prefix to be used at the start of a line emitted by assuan
+   on the log stream.  The default is the empty string.  Note, that
+   this function is not thread-safe and should in general be used
+   right at startup. */
+void assuan_set_assuan_log_prefix (const char *text);
+
+/* Return a prefix to be used at the start of a line emitted by assuan
+   on the log stream.  The default implementation returns the empty
+   string, i.e. ""  */
+const char *assuan_get_assuan_log_prefix (void);
 
 #ifdef __cplusplus
 }