(process_request): Kludge to print better error

messages for gpg-error enabled programs.

4 files changed, 109 insertions, 59 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 08bb2bd..44a642a 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,14 @@
+2003-11-12  Werner Koch  <[email protected]>
+
+	* assuan-handler.c (process_request): Kludge to print better error
+	messages for gpg-error enabled programs.
+
+2003-11-06  Werner Koch  <[email protected]>
+
+	* assuan.h (assuan_context_t): New.  Should be used in favor of
+	ASSUAN_CONTEXT.
+	(assuan_error_t): New. To be used instead of AssuanError.
+
 2003-11-11  Moritz Schulte  <[email protected]>
 
 	* assuan-socket-connect.c (assuan_socket_connect): Fix computation
diff --git a/src/assuan-handler.c b/src/assuan-handler.c
index f8b85db..bb9a565 100644
--- a/src/assuan-handler.c
+++ b/src/assuan-handler.c
@@ -390,7 +390,7 @@ my_strcasecmp (const char *a, const char *b)
 }
 
 /* Parse the line, break out the command, find it in the command
-   table, remove leading and white spaces from the arguments, all the
+   table, remove leading and white spaces from the arguments, call the
    handler with the argument line and return the error */
 static int 
 dispatch_command (ASSUAN_CONTEXT ctx, char *line, int linelen)
@@ -483,7 +483,7 @@ process_request (ASSUAN_CONTEXT ctx)
     }
   else 
     {
-      char errline[256];
+      char errline[300];
 
       if (rc < 100)
         sprintf (errline, "ERR %d server fault (%.50s)",
@@ -492,8 +492,40 @@ process_request (ASSUAN_CONTEXT ctx)
         {
           const char *text = ctx->err_no == rc? ctx->err_str:NULL;
 
-          sprintf (errline, "ERR %d %.50s%s%.100s",
-                   rc, assuan_strerror (rc), text? " - ":"", text?text:"");
+#if defined(__GNUC__) && defined(__ELF__)
+          /* If we have weak symbol support we try to use the rror
+             strings from libgpg-error without creating a dependency.
+             They are used for debugging purposes only, so there is no
+             problem if they are not available.  We need to make sure
+             that we are using elf because only this guarantees that
+             weak symbol support is available in case GNU ld is not
+             used. */
+          unsigned int source, code;
+
+          int gpg_strerror_r (unsigned int err, char *buf, size_t buflen)
+            __attribute__ ((weak));
+
+          const char *gpg_strsource (unsigned int err)
+            __attribute__ ((weak));
+
+          source = ((rc >> 24) & 0xff);
+          code = (rc & 0x00ffffff);
+          if (source && gpg_strsource && gpg_strerror_r)
+            {
+              /* Assume this is an libgpg-error. */
+              char ebuf[50];
+
+              gpg_strerror_r (rc, ebuf, sizeof ebuf );
+              sprintf (errline, "ERR %d %.50s <%.30s>%s%.100s",
+                       rc,
+                       ebuf,
+                       gpg_strsource (rc),
+                       text? " - ":"", text?text:"");
+            }
+          else
+#endif /* __GNUC__  && __ELF__ */
+            sprintf (errline, "ERR %d %.50s%s%.100s",
+                     rc, assuan_strerror (rc), text? " - ":"", text?text:"");
         }
       rc = assuan_write_line (ctx, errline);
     }
diff --git a/src/assuan-inquire.c b/src/assuan-inquire.c
index ec9d8e6..3c7d013 100644
--- a/src/assuan-inquire.c
+++ b/src/assuan-inquire.c
@@ -136,7 +136,7 @@ free_membuf (struct membuf *mb)
  **/
 AssuanError
 assuan_inquire (ASSUAN_CONTEXT ctx, const char *keyword,
-                char **r_buffer, size_t *r_length, size_t maxlen)
+                unsigned char **r_buffer, size_t *r_length, size_t maxlen)
 {
   AssuanError rc;
   struct membuf mb;
diff --git a/src/assuan.h b/src/assuan.h
index f898c26..07f56b3 100644
--- a/src/assuan.h
+++ b/src/assuan.h
@@ -28,6 +28,9 @@
 #ifdef __cplusplus
 extern "C"
 {
+#if 0
+}
+#endif
 #endif
 
 typedef enum
@@ -101,7 +104,9 @@ typedef enum
   ASSUAN_Card_Not_Present = 404,
   ASSUAN_Invalid_Id = 405
 
-} AssuanError;
+} assuan_error_t;
+
+typedef assuan_error_t AssuanError; /* Deprecated. */
 
 /* This is a list of pre-registered ASSUAN commands */
 typedef enum
@@ -123,68 +128,69 @@ typedef enum
 #define ASSUAN_LINELENGTH 1002 /* 1000 + [CR,]LF */
 
 struct assuan_context_s;
+typedef struct assuan_context_s *assuan_context_t;
 typedef struct assuan_context_s *ASSUAN_CONTEXT;
 
 /*-- 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_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,
+FILE *assuan_get_data_fp (assuan_context_t ctx);
+AssuanError assuan_set_okay_line (assuan_context_t ctx, const char *line);
+void 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,
+AssuanError 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);
+AssuanError assuan_set_hello_line (assuan_context_t ctx, const char *line);
+AssuanError assuan_accept (assuan_context_t ctx);
+int assuan_get_input_fd (assuan_context_t ctx);
+int assuan_get_output_fd (assuan_context_t ctx);
+AssuanError assuan_close_input_fd (assuan_context_t ctx);
+AssuanError 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-pipe-connect.c --*/
-AssuanError assuan_pipe_connect (ASSUAN_CONTEXT *ctx, const char *name,
+AssuanError assuan_pipe_connect (assuan_context_t *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,
+AssuanError assuan_socket_connect (assuan_context_t *ctx, const char *name,
                                    pid_t server_pid);
 
 /*-- assuan-domain-connect.c --*/
@@ -193,7 +199,7 @@ AssuanError assuan_socket_connect (ASSUAN_CONTEXT *ctx, const char *name,
    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,
+AssuanError assuan_domain_connect (assuan_context_t *r_ctx,
 				   int rendezvousfd,
 				   pid_t server);
 
@@ -202,18 +208,18 @@ AssuanError assuan_domain_connect (ASSUAN_CONTEXT *r_ctx,
 /* 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,
+AssuanError assuan_init_domain_server (assuan_context_t *r_ctx,
 				       int rendezvousfd,
 				       pid_t client);
 
 
 /*-- 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);
 
 /*-- assuan-client.c --*/
 AssuanError 
-assuan_transact (ASSUAN_CONTEXT ctx,
+assuan_transact (assuan_context_t ctx,
                  const char *command,
                  AssuanError (*data_cb)(void *, const void *, size_t),
                  void *data_cb_arg,
@@ -224,35 +230,36 @@ assuan_transact (ASSUAN_CONTEXT ctx,
 
 
 /*-- assuan-inquire.c --*/
-AssuanError assuan_inquire (ASSUAN_CONTEXT ctx, const char *keyword,
-                            char **r_buffer, size_t *r_length, size_t maxlen);
+AssuanError 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,
+AssuanError 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);
+AssuanError assuan_write_line (assuan_context_t ctx, const char *line );
+AssuanError 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);
+AssuanError assuan_sendfd (assuan_context_t ctx, int fd);
+AssuanError 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);