src/engine-g13.c

   1 /* engine-g13.c - G13 engine.
   2    Copyright (C) 2000 Werner Koch (dd9jn)
   3    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2009 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 #if HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <sys/types.h>
  29 #include <assert.h>
  30 #ifdef HAVE_UNISTD_H
  31 # include <unistd.h>
  32 #endif
  33 #ifdef HAVE_LOCALE_H
  34 #include <locale.h>
  35 #endif
  36 #include <fcntl.h> /* FIXME */
  37 #include <errno.h>
  38
  39 #include "gpgme.h"
  40 #include "util.h"
  41 #include "ops.h"
  42 #include "wait.h"
  43 #include "priv-io.h"
  44 #include "sema.h"
  45
  46 #include "assuan.h"
  47 #include "debug.h"
  48
  49 #include "engine-backend.h"
  50
  51 \f
  52 typedef struct
  53 {
  54   int fd;       /* FD we talk about.  */
  55   int server_fd;/* Server FD for this connection.  */
  56   int dir;      /* Inbound/Outbound, maybe given implicit?  */
  57   void *data;   /* Handler-specific data.  */
  58   void *tag;    /* ID from the user for gpgme_remove_io_callback.  */
  59   char server_fd_str[15]; /* Same as SERVER_FD but as a string.  We
  60                              need this because _gpgme_io_fd2str can't
  61                              be used on a closed descriptor.  */
  62 } iocb_data_t;
  63
  64
  65 struct engine_g13
  66 {
  67   assuan_context_t assuan_ctx;
  68
  69   int lc_ctype_set;
  70   int lc_messages_set;
  71
  72   iocb_data_t status_cb;
  73
  74   struct gpgme_io_cbs io_cbs;
  75
  76   /* User provided callbacks.  */
  77   struct {
  78     gpgme_assuan_data_cb_t data_cb;
  79     void *data_cb_value;
  80
  81     gpgme_assuan_inquire_cb_t inq_cb;
  82     void *inq_cb_value;
  83
  84     gpgme_assuan_status_cb_t status_cb;
  85     void *status_cb_value;
  86   } user;
  87 };
  88
  89 typedef struct engine_g13 *engine_g13_t;
  90
  91
  92 static void g13_io_event (void *engine,
  93                             gpgme_event_io_t type, void *type_data);
  94
  95
  96 \f
  97 static char *
  98 g13_get_version (const char *file_name)
  99 {
 100   return _gpgme_get_program_version (file_name ? file_name
 101                                      : _gpgme_get_g13_path ());
 102 }
 103
 104
 105 static const char *
 106 g13_get_req_version (void)
 107 {
 108   return NEED_G13_VERSION;
 109 }
 110
 111 \f
 112 static void
 113 close_notify_handler (int fd, void *opaque)
 114 {
 115   engine_g13_t g13 = opaque;
 116
 117   assert (fd != -1);
 118   if (g13->status_cb.fd == fd)
 119     {
 120       if (g13->status_cb.tag)
 121         (*g13->io_cbs.remove) (g13->status_cb.tag);
 122       g13->status_cb.fd = -1;
 123       g13->status_cb.tag = NULL;
 124     }
 125 }
 126
 127
 128 /* This is the default inquiry callback.  We use it to handle the
 129    Pinentry notifications.  */
 130 static gpgme_error_t
 131 default_inq_cb (engine_g13_t g13, const char *keyword, const char *args)
 132 {
 133   gpg_error_t err;
 134
 135   if (!strcmp (keyword, "PINENTRY_LAUNCHED"))
 136     {
 137       _gpgme_allow_set_foreground_window ((pid_t)strtoul (args, NULL, 10));
 138     }
 139
 140   if (g13->user.inq_cb)
 141     {
 142       gpgme_data_t data = NULL;
 143
 144       err = g13->user.inq_cb (g13->user.inq_cb_value,
 145                                 keyword, args, &data);
 146       if (!err && data)
 147         {
 148           /* FIXME: Returning data is not yet implemented.  However we
 149              need to allow the caller to cleanup his data object.
 150              Thus we run the callback in finish mode immediately.  */
 151           err = g13->user.inq_cb (g13->user.inq_cb_value,
 152                                   NULL, NULL, &data);
 153         }
 154     }
 155   else
 156     err = 0;
 157
 158   return err;
 159 }
 160
 161
 162 static gpgme_error_t
 163 g13_cancel (void *engine)
 164 {
 165   engine_g13_t g13 = engine;
 166
 167   if (!g13)
 168     return gpg_error (GPG_ERR_INV_VALUE);
 169
 170   if (g13->status_cb.fd != -1)
 171     _gpgme_io_close (g13->status_cb.fd);
 172
 173   if (g13->assuan_ctx)
 174     {
 175       assuan_release (g13->assuan_ctx);
 176       g13->assuan_ctx = NULL;
 177     }
 178
 179   return 0;
 180 }
 181
 182
 183 static gpgme_error_t
 184 g13_cancel_op (void *engine)
 185 {
 186   engine_g13_t g13 = engine;
 187
 188   if (!g13)
 189     return gpg_error (GPG_ERR_INV_VALUE);
 190
 191   if (g13->status_cb.fd != -1)
 192     _gpgme_io_close (g13->status_cb.fd);
 193
 194   return 0;
 195 }
 196
 197
 198 static void
 199 g13_release (void *engine)
 200 {
 201   engine_g13_t g13 = engine;
 202
 203   if (!g13)
 204     return;
 205
 206   g13_cancel (engine);
 207
 208   free (g13);
 209 }
 210
 211
 212 static gpgme_error_t
 213 g13_new (void **engine, const char *file_name, const char *home_dir)
 214 {
 215   gpgme_error_t err = 0;
 216   engine_g13_t g13;
 217   int argc;
 218   const char *argv[5];
 219   char *dft_display = NULL;
 220   char dft_ttyname[64];
 221   char *dft_ttytype = NULL;
 222   char *optstr;
 223
 224   g13 = calloc (1, sizeof *g13);
 225   if (!g13)
 226     return gpg_error_from_errno (errno);
 227
 228   g13->status_cb.fd = -1;
 229   g13->status_cb.dir = 1;
 230   g13->status_cb.tag = 0;
 231   g13->status_cb.data = g13;
 232
 233   argc = 0;
 234   argv[argc++] = "g13";
 235   if (home_dir)
 236     {
 237       argv[argc++] = "--homedir";
 238       argv[argc++] = home_dir;
 239     }
 240   argv[argc++] = "--server";
 241   argv[argc++] = NULL;
 242
 243   err = assuan_new_ext (&g13->assuan_ctx, GPG_ERR_SOURCE_GPGME,
 244                         &_gpgme_assuan_malloc_hooks, _gpgme_assuan_log_cb,
 245                         NULL);
 246   if (err)
 247     goto leave;
 248   assuan_ctx_set_system_hooks (g13->assuan_ctx, &_gpgme_assuan_system_hooks);
 249
 250 #if USE_DESCRIPTOR_PASSING
 251   err = assuan_pipe_connect
 252     (g13->assuan_ctx, file_name ? file_name : _gpgme_get_g13_path (),
 253      argv, NULL, NULL, NULL, ASSUAN_PIPE_CONNECT_FDPASSING);
 254 #else
 255   err = assuan_pipe_connect
 256     (g13->assuan_ctx, file_name ? file_name : _gpgme_get_g13_path (),
 257      argv, NULL, NULL, NULL, 0);
 258 #endif
 259   if (err)
 260     goto leave;
 261
 262   err = _gpgme_getenv ("DISPLAY", &dft_display);
 263   if (err)
 264     goto leave;
 265   if (dft_display)
 266     {
 267       if (asprintf (&optstr, "OPTION display=%s", dft_display) < 0)
 268         {
 269           free (dft_display);
 270           err = gpg_error_from_errno (errno);
 271           goto leave;
 272         }
 273       free (dft_display);
 274
 275       err = assuan_transact (g13->assuan_ctx, optstr, NULL, NULL, NULL,
 276                              NULL, NULL, NULL);
 277       free (optstr);
 278       if (err)
 279         goto leave;
 280     }
 281
 282   if (isatty (1))
 283     {
 284       int rc;
 285
 286       rc = ttyname_r (1, dft_ttyname, sizeof (dft_ttyname));
 287       if (rc)
 288         {
 289           err = gpg_error_from_errno (rc);
 290           goto leave;
 291         }
 292       else
 293         {
 294           if (asprintf (&optstr, "OPTION ttyname=%s", dft_ttyname) < 0)
 295             {
 296               err = gpg_error_from_errno (errno);
 297               goto leave;
 298             }
 299           err = assuan_transact (g13->assuan_ctx, optstr, NULL, NULL, NULL,
 300                                  NULL, NULL, NULL);
 301           free (optstr);
 302           if (err)
 303             goto leave;
 304
 305           err = _gpgme_getenv ("TERM", &dft_ttytype);
 306           if (err)
 307             goto leave;
 308           if (dft_ttytype)
 309             {
 310               if (asprintf (&optstr, "OPTION ttytype=%s", dft_ttytype) < 0)
 311                 {
 312                   free (dft_ttytype);
 313                   err = gpg_error_from_errno (errno);
 314                   goto leave;
 315                 }
 316               free (dft_ttytype);
 317
 318               err = assuan_transact (g13->assuan_ctx, optstr, NULL, NULL,
 319                                      NULL, NULL, NULL, NULL);
 320               free (optstr);
 321               if (err)
 322                 goto leave;
 323             }
 324         }
 325     }
 326
 327 #ifdef HAVE_W32_SYSTEM
 328   /* Under Windows we need to use AllowSetForegroundWindow.  Tell
 329      g13 to tell us when it needs it.  */
 330   if (!err)
 331     {
 332       err = assuan_transact (g13->assuan_ctx, "OPTION allow-pinentry-notify",
 333                              NULL, NULL, NULL, NULL, NULL, NULL);
 334       if (gpg_err_code (err) == GPG_ERR_UNKNOWN_OPTION)
 335         err = 0; /* This is a new feature of g13.  */
 336     }
 337 #endif /*HAVE_W32_SYSTEM*/
 338
 339  leave:
 340
 341   if (err)
 342     g13_release (g13);
 343   else
 344     *engine = g13;
 345
 346   return err;
 347 }
 348
 349
 350 static gpgme_error_t
 351 g13_set_locale (void *engine, int category, const char *value)
 352 {
 353   engine_g13_t g13 = engine;
 354   gpgme_error_t err;
 355   char *optstr;
 356   char *catstr;
 357
 358   /* FIXME: If value is NULL, we need to reset the option to default.
 359      But we can't do this.  So we error out here.  G13 needs support
 360      for this.  */
 361   if (0)
 362     ;
 363 #ifdef LC_CTYPE
 364   else if (category == LC_CTYPE)
 365     {
 366       catstr = "lc-ctype";
 367       if (!value && g13->lc_ctype_set)
 368         return gpg_error (GPG_ERR_INV_VALUE);
 369       if (value)
 370         g13->lc_ctype_set = 1;
 371     }
 372 #endif
 373 #ifdef LC_MESSAGES
 374   else if (category == LC_MESSAGES)
 375     {
 376       catstr = "lc-messages";
 377       if (!value && g13->lc_messages_set)
 378         return gpg_error (GPG_ERR_INV_VALUE);
 379       if (value)
 380         g13->lc_messages_set = 1;
 381     }
 382 #endif /* LC_MESSAGES */
 383   else
 384     return gpg_error (GPG_ERR_INV_VALUE);
 385
 386   /* FIXME: Reset value to default.  */
 387   if (!value)
 388     return 0;
 389
 390   if (asprintf (&optstr, "OPTION %s=%s", catstr, value) < 0)
 391     err = gpg_error_from_errno (errno);
 392   else
 393     {
 394       err = assuan_transact (g13->assuan_ctx, optstr, NULL, NULL,
 395                              NULL, NULL, NULL, NULL);
 396       free (optstr);
 397     }
 398
 399   return err;
 400 }
 401
 402
 403 #if USE_DESCRIPTOR_PASSING
 404 static gpgme_error_t
 405 g13_assuan_simple_command (assuan_context_t ctx, char *cmd,
 406                            engine_status_handler_t status_fnc,
 407                            void *status_fnc_value)
 408 {
 409   gpg_error_t err;
 410   char *line;
 411   size_t linelen;
 412
 413   err = assuan_write_line (ctx, cmd);
 414   if (err)
 415     return err;
 416
 417   do
 418     {
 419       err = assuan_read_line (ctx, &line, &linelen);
 420       if (err)
 421         return err;
 422
 423       if (*line == '#' || !linelen)
 424         continue;
 425
 426       if (linelen >= 2
 427           && line[0] == 'O' && line[1] == 'K'
 428           && (line[2] == '\0' || line[2] == ' '))
 429         return 0;
 430       else if (linelen >= 4
 431           && line[0] == 'E' && line[1] == 'R' && line[2] == 'R'
 432           && line[3] == ' ')
 433         err = atoi (&line[4]);
 434       else if (linelen >= 2
 435                && line[0] == 'S' && line[1] == ' ')
 436         {
 437           char *rest;
 438
 439           rest = strchr (line + 2, ' ');
 440           if (!rest)
 441             rest = line + linelen; /* set to an empty string */
 442           else
 443             *(rest++) = 0;
 444
 445           /* Nothing to do with status lines.  */
 446         }
 447       else
 448         err = gpg_error (GPG_ERR_GENERAL);
 449     }
 450   while (!err);
 451
 452   return err;
 453 }
 454 #endif
 455
 456
 457 static gpgme_error_t
 458 status_handler (void *opaque, int fd)
 459 {
 460   struct io_cb_data *data = (struct io_cb_data *) opaque;
 461   engine_g13_t g13 = (engine_g13_t) data->handler_value;
 462   gpgme_error_t err = 0;
 463   char *line;
 464   size_t linelen;
 465
 466   do
 467     {
 468       err = assuan_read_line (g13->assuan_ctx, &line, &linelen);
 469       if (err)
 470         {
 471           /* Try our best to terminate the connection friendly.  */
 472           /*      assuan_write_line (g13->assuan_ctx, "BYE"); */
 473           TRACE2 (DEBUG_CTX, "gpgme:status_handler", g13,
 474                   "fd 0x%x: error reading assuan line: %s",
 475                   fd, gpg_strerror (err));
 476         }
 477       else if (linelen >= 3
 478                && line[0] == 'E' && line[1] == 'R' && line[2] == 'R'
 479                && (line[3] == '\0' || line[3] == ' '))
 480         {
 481           if (line[3] == ' ')
 482             err = atoi (&line[4]);
 483           if (! err)
 484             err = gpg_error (GPG_ERR_GENERAL);
 485           TRACE2 (DEBUG_CTX, "gpgme:status_handler", g13,
 486                   "fd 0x%x: ERR line: %s",
 487                   fd, err ? gpg_strerror (err) : "ok");
 488
 489           /* Command execution errors are not fatal, as we use
 490              a session based protocol.  */
 491           data->op_err = err;
 492
 493           /* The caller will do the rest (namely, call cancel_op,
 494              which closes status_fd).  */
 495           return 0;
 496         }
 497       else if (linelen >= 2
 498                && line[0] == 'O' && line[1] == 'K'
 499                && (line[2] == '\0' || line[2] == ' '))
 500         {
 501           TRACE1 (DEBUG_CTX, "gpgme:status_handler", g13,
 502                   "fd 0x%x: OK line", fd);
 503
 504           _gpgme_io_close (g13->status_cb.fd);
 505           return 0;
 506         }
 507       else if (linelen > 2
 508                && line[0] == 'D' && line[1] == ' ')
 509         {
 510           /* We are using the colon handler even for plain inline data
 511              - strange name for that function but for historic reasons
 512              we keep it.  */
 513           /* FIXME We can't use this for binary data because we
 514              assume this is a string.  For the current usage of colon
 515              output it is correct.  */
 516           char *src = line + 2;
 517           char *end = line + linelen;
 518           char *dst = src;
 519
 520           linelen = 0;
 521           while (src < end)
 522             {
 523               if (*src == '%' && src + 2 < end)
 524                 {
 525                   /* Handle escaped characters.  */
 526                   ++src;
 527                   *dst++ = _gpgme_hextobyte (src);
 528                   src += 2;
 529                 }
 530               else
 531                 *dst++ = *src++;
 532
 533               linelen++;
 534             }
 535
 536           src = line + 2;
 537           if (linelen && g13->user.data_cb)
 538             err = g13->user.data_cb (g13->user.data_cb_value,
 539                                        src, linelen);
 540           else
 541             err = 0;
 542
 543           TRACE2 (DEBUG_CTX, "gpgme:g13_status_handler", g13,
 544                   "fd 0x%x: D inlinedata; status from cb: %s",
 545                   fd, (g13->user.data_cb ?
 546                        (err? gpg_strerror (err):"ok"):"no callback"));
 547
 548         }
 549       else if (linelen > 2
 550                && line[0] == 'S' && line[1] == ' ')
 551         {
 552           char *src;
 553           char *args;
 554
 555           src = line + 2;
 556           while (*src == ' ')
 557             src++;
 558
 559           args = strchr (line + 2, ' ');
 560           if (!args)
 561             args = line + linelen; /* set to an empty string */
 562           else
 563             *(args++) = 0;
 564
 565           while (*args == ' ')
 566             args++;
 567
 568           if (g13->user.status_cb)
 569             err = g13->user.status_cb (g13->user.status_cb_value,
 570                                        src, args);
 571           else
 572             err = 0;
 573
 574           TRACE3 (DEBUG_CTX, "gpgme:g13_status_handler", g13,
 575                   "fd 0x%x: S line (%s) - status from cb: %s",
 576                   fd, line+2, (g13->user.status_cb ?
 577                                (err? gpg_strerror (err):"ok"):"no callback"));
 578         }
 579       else if (linelen >= 7
 580                && line[0] == 'I' && line[1] == 'N' && line[2] == 'Q'
 581                && line[3] == 'U' && line[4] == 'I' && line[5] == 'R'
 582                && line[6] == 'E'
 583                && (line[7] == '\0' || line[7] == ' '))
 584         {
 585           char *src;
 586           char *args;
 587
 588           for (src=line+7; *src == ' '; src++)
 589             ;
 590
 591           args = strchr (src, ' ');
 592           if (!args)
 593             args = line + linelen; /* Let it point to an empty string.  */
 594           else
 595             *(args++) = 0;
 596
 597           while (*args == ' ')
 598             args++;
 599
 600           err = default_inq_cb (g13, src, args);
 601           if (!err)
 602             {
 603               /* Flush and send END.  */
 604               err = assuan_send_data (g13->assuan_ctx, NULL, 0);
 605             }
 606           else if (gpg_err_code (err) == GPG_ERR_ASS_CANCELED)
 607             {
 608               /* Flush and send CANcel.  */
 609               err = assuan_send_data (g13->assuan_ctx, NULL, 1);
 610             }
 611           assuan_write_line (g13->assuan_ctx, "END");
 612         }
 613     }
 614   while (!err && assuan_pending_line (g13->assuan_ctx));
 615
 616   return err;
 617 }
 618
 619
 620 static gpgme_error_t
 621 add_io_cb (engine_g13_t g13, iocb_data_t *iocbd, gpgme_io_cb_t handler)
 622 {
 623   gpgme_error_t err;
 624
 625   TRACE_BEG2 (DEBUG_ENGINE, "engine-g13:add_io_cb", g13,
 626               "fd %d, dir %d", iocbd->fd, iocbd->dir);
 627   err = (*g13->io_cbs.add) (g13->io_cbs.add_priv,
 628                               iocbd->fd, iocbd->dir,
 629                               handler, iocbd->data, &iocbd->tag);
 630   if (err)
 631     return TRACE_ERR (err);
 632   if (!iocbd->dir)
 633     /* FIXME Kludge around poll() problem.  */
 634     err = _gpgme_io_set_nonblocking (iocbd->fd);
 635   return TRACE_ERR (err);
 636 }
 637
 638
 639 static gpgme_error_t
 640 start (engine_g13_t g13, const char *command)
 641 {
 642   gpgme_error_t err;
 643   assuan_fd_t afdlist[5];
 644   int fdlist[5];
 645   int nfds;
 646   int i;
 647
 648   /* We need to know the fd used by assuan for reads.  We do this by
 649      using the assumption that the first returned fd from
 650      assuan_get_active_fds() is always this one.  */
 651   nfds = assuan_get_active_fds (g13->assuan_ctx, 0 /* read fds */,
 652                                 afdlist, DIM (afdlist));
 653   if (nfds < 1)
 654     return gpg_error (GPG_ERR_GENERAL); /* FIXME */
 655   /* For now... */
 656   for (i = 0; i < nfds; i++)
 657     fdlist[i] = (int) afdlist[i];
 658
 659   /* We "duplicate" the file descriptor, so we can close it here (we
 660      can't close fdlist[0], as that is closed by libassuan, and
 661      closing it here might cause libassuan to close some unrelated FD
 662      later).  Alternatively, we could special case status_fd and
 663      register/unregister it manually as needed, but this increases
 664      code duplication and is more complicated as we can not use the
 665      close notifications etc.  A third alternative would be to let
 666      Assuan know that we closed the FD, but that complicates the
 667      Assuan interface.  */
 668
 669   g13->status_cb.fd = _gpgme_io_dup (fdlist[0]);
 670   if (g13->status_cb.fd < 0)
 671     return gpg_error_from_syserror ();
 672
 673   if (_gpgme_io_set_close_notify (g13->status_cb.fd,
 674                                   close_notify_handler, g13))
 675     {
 676       _gpgme_io_close (g13->status_cb.fd);
 677       g13->status_cb.fd = -1;
 678       return gpg_error (GPG_ERR_GENERAL);
 679     }
 680
 681   err = add_io_cb (g13, &g13->status_cb, status_handler);
 682   if (!err)
 683     err = assuan_write_line (g13->assuan_ctx, command);
 684
 685   if (!err)
 686     g13_io_event (g13, GPGME_EVENT_START, NULL);
 687
 688   return err;
 689 }
 690
 691
 692 #if USE_DESCRIPTOR_PASSING
 693 static gpgme_error_t
 694 g13_reset (void *engine)
 695 {
 696   engine_g13_t g13 = engine;
 697
 698   /* We must send a reset because we need to reset the list of
 699      signers.  Note that RESET does not reset OPTION commands. */
 700   return g13_assuan_simple_command (g13->assuan_ctx, "RESET", NULL, NULL);
 701 }
 702 #endif
 703
 704
 705 static gpgme_error_t
 706 g13_transact (void *engine,
 707                 const char *command,
 708                 gpgme_assuan_data_cb_t data_cb,
 709                 void *data_cb_value,
 710                 gpgme_assuan_inquire_cb_t inq_cb,
 711                 void *inq_cb_value,
 712                 gpgme_assuan_status_cb_t status_cb,
 713                 void *status_cb_value)
 714 {
 715   engine_g13_t g13 = engine;
 716   gpgme_error_t err;
 717
 718   if (!g13 || !command || !*command)
 719     return gpg_error (GPG_ERR_INV_VALUE);
 720
 721   g13->user.data_cb = data_cb;
 722   g13->user.data_cb_value = data_cb_value;
 723   g13->user.inq_cb = inq_cb;
 724   g13->user.inq_cb_value = inq_cb_value;
 725   g13->user.status_cb = status_cb;
 726   g13->user.status_cb_value = status_cb_value;
 727
 728   err = start (g13, command);
 729   return err;
 730 }
 731
 732
 733
 734 static void
 735 g13_set_io_cbs (void *engine, gpgme_io_cbs_t io_cbs)
 736 {
 737   engine_g13_t g13 = engine;
 738   g13->io_cbs = *io_cbs;
 739 }
 740
 741
 742 static void
 743 g13_io_event (void *engine, gpgme_event_io_t type, void *type_data)
 744 {
 745   engine_g13_t g13 = engine;
 746
 747   TRACE3 (DEBUG_ENGINE, "gpgme:g13_io_event", g13,
 748           "event %p, type %d, type_data %p",
 749           g13->io_cbs.event, type, type_data);
 750   if (g13->io_cbs.event)
 751     (*g13->io_cbs.event) (g13->io_cbs.event_priv, type, type_data);
 752 }
 753
 754
 755 struct engine_ops _gpgme_engine_ops_g13 =
 756   {
 757     /* Static functions.  */
 758     _gpgme_get_g13_path,
 759     NULL,
 760     g13_get_version,
 761     g13_get_req_version,
 762     g13_new,
 763
 764     /* Member functions.  */
 765     g13_release,
 766 #if USE_DESCRIPTOR_PASSING
 767     g13_reset,
 768 #else
 769     NULL,                       /* reset */
 770 #endif
 771     NULL,               /* set_status_handler */
 772     NULL,               /* set_command_handler */
 773     NULL,               /* set_colon_line_handler */
 774     g13_set_locale,
 775     NULL,               /* set_protocol */
 776     NULL,               /* decrypt */
 777     NULL,               /* decrypt_verify */
 778     NULL,               /* delete */
 779     NULL,               /* edit */
 780     NULL,               /* encrypt */
 781     NULL,               /* encrypt_sign */
 782     NULL,               /* export */
 783     NULL,               /* export_ext */
 784     NULL,               /* genkey */
 785     NULL,               /* import */
 786     NULL,               /* keylist */
 787     NULL,               /* keylist_ext */
 788     NULL,               /* sign */
 789     NULL,               /* trustlist */
 790     NULL,               /* verify */
 791     NULL,               /* getauditlog */
 792     g13_transact,
 793     NULL,               /* conf_load */
 794     NULL,               /* conf_save */
 795     g13_set_io_cbs,
 796     g13_io_event,
 797     g13_cancel,
 798     g13_cancel_op,
 799   };