src/wait.h

   1 /* wait.h - Definitions for the wait queue interface.
   2    Copyright (C) 2000 Werner Koch (dd9jn)
   3    Copyright (C) 2001, 2002, 2003, 2004 g10 Code GmbH
   4
   5    This file is part of GPGME.
   6
   7    GPGME 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    GPGME 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, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  20    02111-1307, USA.  */
  21
  22 #ifndef WAIT_H
  23 #define WAIT_H
  24
  25 #include "gpgme.h"
  26 #include "sema.h"
  27
  28 struct fd_table
  29 {
  30   struct io_select_fd_s *fds;
  31   size_t size;
  32 };
  33 typedef struct fd_table *fd_table_t;
  34
  35 /* Wait items are hooked into the io_select_fd_s to connect an fd with
  36    a callback handler.  */
  37 struct wait_item_s
  38 {
  39   gpgme_ctx_t ctx;
  40   gpgme_io_cb_t handler;
  41   void *handler_value;
  42   int dir;
  43 };
  44
  45 /* A registered fd handler is removed later using the tag that
  46    identifies it.  */
  47 struct tag
  48 {
  49   /* The context for which the fd was registered.  */
  50   gpgme_ctx_t ctx;
  51
  52   /* The index into the fd table for this context.  */
  53   int idx;
  54
  55   /* This is used by the wrappers for the user event loop.  */
  56   void *user_tag;
  57 };
  58
  59
  60 void _gpgme_fd_table_init (fd_table_t fdt);
  61 void _gpgme_fd_table_deinit (fd_table_t fdt);
  62
  63 gpgme_error_t _gpgme_add_io_cb (void *data, int fd, int dir,
  64                              gpgme_io_cb_t fnc, void *fnc_data, void **r_tag);
  65 void _gpgme_remove_io_cb (void *tag);
  66 void _gpgme_wait_private_event_cb (void *data, gpgme_event_io_t type,
  67                                    void *type_data);
  68 void _gpgme_wait_global_event_cb (void *data, gpgme_event_io_t type,
  69                                   void *type_data);
  70
  71 gpgme_error_t _gpgme_wait_user_add_io_cb (void *data, int fd, int dir,
  72                                           gpgme_io_cb_t fnc, void *fnc_data,
  73                                           void **r_tag);
  74 void _gpgme_wait_user_remove_io_cb (void *tag);
  75 void _gpgme_wait_user_event_cb (void *data, gpgme_event_io_t type,
  76                                 void *type_data);
  77
  78 gpgme_error_t _gpgme_run_io_cb (struct io_select_fd_s *an_fds, int checked,
  79                                 gpgme_error_t *err);
  80
  81 \f
  82 /* Session based interfaces require to make a distinction between IPC
  83    errors and operational errors.  To glue this into the old
  84    interface, I/O handlers (esp. the status handler) are called with a
  85    struct as the opaque value that contains the handlers opaque value
  86    but also a field for the operational error to be returned.  */
  87 struct io_cb_data
  88 {
  89   /* If this is the first field, the old internal code will still work.  */
  90   void *handler_value;
  91
  92   /* The I/O callback can pass an operational error here.  */
  93   gpgme_error_t op_err;
  94 };
  95
  96 #endif  /* WAIT_H */