/* engine-gpgsm.c - GpgSM engine.

 * Copyright (C) 2000 Werner Koch (dd9jn)

 * Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2009,

 *               2010 g10 Code GmbH

 *

 * This file is part of GPGME.

 *

 * GPGME is free software; you can redistribute it and/or modify it

 * under the terms of the GNU Lesser General Public License as

 * published by the Free Software Foundation; either version 2.1 of

 * the License, or (at your option) any later version.

 *

 * GPGME is distributed in the hope that it will be useful, but

 * WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this program; if not, see <https://gnu.org/licenses/>.

 * SPDX-License-Identifier: LGPL-2.1-or-later

 */

#if HAVE_CONFIG_H

#include <config.h>

#endif

#include <stdlib.h>

#include <string.h>

#ifdef HAVE_SYS_TYPES_H

# include <sys/types.h>

#endif

#include <assert.h>

#ifdef HAVE_UNISTD_H

# include <unistd.h>

#endif

#ifdef HAVE_LOCALE_H

#include <locale.h>

#endif

#include <fcntl.h> /* FIXME */

#include "gpgme.h"

#include "util.h"

#include "ops.h"

#include "wait.h"

#include "priv-io.h"

#include "sema.h"

#include "data.h"

#include "assuan.h"

#include "debug.h"

#include "engine-backend.h"

typedef struct

{

  int fd;	/* FD we talk about.  */

  int server_fd;/* Server FD for this connection.  */

  int dir;	/* Inbound/Outbound, maybe given implicit?  */

  void *data;	/* Handler-specific data.  */

  void *tag;	/* ID from the user for gpgme_remove_io_callback.  */

  char server_fd_str[15]; /* Same as SERVER_FD but as a string.  We

                             need this because _gpgme_io_fd2str can't

                             be used on a closed descriptor.  */

} iocb_data_t;

struct engine_gpgsm

{

  assuan_context_t assuan_ctx;

  int lc_ctype_set;

  int lc_messages_set;

  iocb_data_t status_cb;

  /* Input, output etc are from the servers perspective.  */

  iocb_data_t input_cb;

  gpgme_data_t input_helper_data;  /* Input helper data object.  */

  void *input_helper_memory;       /* Input helper memory block.  */

  iocb_data_t output_cb;

  iocb_data_t message_cb;

  iocb_data_t diag_cb;

  struct

  {

    engine_status_handler_t fnc;

    void *fnc_value;

    gpgme_status_cb_t mon_cb;

    void *mon_cb_value;

  } status;

  struct

  {

    engine_colon_line_handler_t fnc;

    void *fnc_value;

    struct

    {

      char *line;

      int linesize;

      int linelen;

    } attic;

    int any; /* any data line seen */

  } colon;

  gpgme_data_t inline_data;  /* Used to collect D lines.  */

  char request_origin[10];

  struct gpgme_io_cbs io_cbs;

  /* Memory data containing diagnostics (--logger-fd) of gpgsm */

  gpgme_data_t diagnostics;

};

typedef struct engine_gpgsm *engine_gpgsm_t;

static void gpgsm_io_event (void *engine,

                            gpgme_event_io_t type, void *type_data);

static char *

gpgsm_get_version (const char *file_name)

{

  return _gpgme_get_program_version (file_name ? file_name

				     : _gpgme_get_default_gpgsm_name ());

}

static const char *

gpgsm_get_req_version (void)

{

  return "2.0.4";

}

static void

close_notify_handler (int fd, void *opaque)

{

  engine_gpgsm_t gpgsm = opaque;

  assert (fd != -1);

  if (gpgsm->status_cb.fd == fd)

    {

      if (gpgsm->status_cb.tag)

	(*gpgsm->io_cbs.remove) (gpgsm->status_cb.tag);

      gpgsm->status_cb.fd = -1;

      gpgsm->status_cb.tag = NULL;

      /* Because the server keeps on running as long as the

       * gpgme_ctx_t is valid the diag fd will not receive a close and

       * thus the operation gets stuck trying to read the diag fd.

       * The status fd however is closed right after it received the

       * "OK" from the command.  So we use this event to also close

       * the diag fd.  */

      _gpgme_io_close (gpgsm->diag_cb.fd);

    }

  else if (gpgsm->input_cb.fd == fd)

    {

      if (gpgsm->input_cb.tag)

	(*gpgsm->io_cbs.remove) (gpgsm->input_cb.tag);

      gpgsm->input_cb.fd = -1;

      gpgsm->input_cb.tag = NULL;

      if (gpgsm->input_helper_data)

        {

          gpgme_data_release (gpgsm->input_helper_data);

          gpgsm->input_helper_data = NULL;

        }

      if (gpgsm->input_helper_memory)

        {

          free (gpgsm->input_helper_memory);

          gpgsm->input_helper_memory = NULL;

        }

    }

  else if (gpgsm->output_cb.fd == fd)

    {

      if (gpgsm->output_cb.tag)

	(*gpgsm->io_cbs.remove) (gpgsm->output_cb.tag);

      gpgsm->output_cb.fd = -1;

      gpgsm->output_cb.tag = NULL;

    }

  else if (gpgsm->message_cb.fd == fd)

    {

      if (gpgsm->message_cb.tag)

	(*gpgsm->io_cbs.remove) (gpgsm->message_cb.tag);

      gpgsm->message_cb.fd = -1;

      gpgsm->message_cb.tag = NULL;

    }

  else if (gpgsm->diag_cb.fd == fd)

    {

      if (gpgsm->diag_cb.tag)

	(*gpgsm->io_cbs.remove) (gpgsm->diag_cb.tag);

      gpgsm->diag_cb.fd = -1;

      gpgsm->diag_cb.tag = NULL;

    }

}

/* This is the default inquiry callback.  We use it to handle the

   Pinentry notifications.  */

static gpgme_error_t

default_inq_cb (engine_gpgsm_t gpgsm, const char *line)

{

  (void)gpgsm;

  if (!strncmp (line, "PINENTRY_LAUNCHED", 17) && (line[17]==' '||!line[17]))

    {

      _gpgme_allow_set_foreground_window ((pid_t)strtoul (line+17, NULL, 10));

    }

  return 0;

}

static gpgme_error_t

gpgsm_cancel (void *engine)

{

  engine_gpgsm_t gpgsm = engine;

  if (!gpgsm)

    return gpg_error (GPG_ERR_INV_VALUE);

  if (gpgsm->status_cb.fd != -1)

    _gpgme_io_close (gpgsm->status_cb.fd);

  if (gpgsm->input_cb.fd != -1)

    _gpgme_io_close (gpgsm->input_cb.fd);

  if (gpgsm->output_cb.fd != -1)

    _gpgme_io_close (gpgsm->output_cb.fd);

  if (gpgsm->message_cb.fd != -1)

    _gpgme_io_close (gpgsm->message_cb.fd);

  if (gpgsm->diag_cb.fd != -1)

    _gpgme_io_close (gpgsm->diag_cb.fd);

  if (gpgsm->assuan_ctx)

    {

      assuan_release (gpgsm->assuan_ctx);

      gpgsm->assuan_ctx = NULL;

    }

  return 0;

}

static void

gpgsm_release (void *engine)

{

  engine_gpgsm_t gpgsm = engine;

  if (!gpgsm)

    return;

  gpgsm_cancel (engine);

  gpgme_data_release (gpgsm->diagnostics);

  free (gpgsm->colon.attic.line);

  free (gpgsm);

}

static gpgme_error_t

gpgsm_new (void **engine, const char *file_name, const char *home_dir,

           const char *version)

{

  gpgme_error_t err = 0;

  engine_gpgsm_t gpgsm;

  const char *pgmname;

  const char *argv[7];

  char *diag_fd_str = NULL;

  int argc;

  int fds[2];

  int child_fds[5];

  int nchild_fds;

  char *dft_display = NULL;

  char dft_ttyname[64];

  char *env_tty = NULL;

  char *dft_ttytype = NULL;

  char *optstr;

  unsigned int connect_flags;

  (void)version; /* Not yet used.  */

  gpgsm = calloc (1, sizeof *gpgsm);

  if (!gpgsm)

    return gpg_error_from_syserror ();

  gpgsm->status_cb.fd = -1;

  gpgsm->status_cb.dir = 1;

  gpgsm->status_cb.tag = 0;

  gpgsm->status_cb.data = gpgsm;

  gpgsm->input_cb.fd = -1;

  gpgsm->input_cb.dir = 0;

  gpgsm->input_cb.tag = 0;

  gpgsm->input_cb.server_fd = -1;

  *gpgsm->input_cb.server_fd_str = 0;

  gpgsm->output_cb.fd = -1;

  gpgsm->output_cb.dir = 1;

  gpgsm->output_cb.tag = 0;

  gpgsm->output_cb.server_fd = -1;

  *gpgsm->output_cb.server_fd_str = 0;

  gpgsm->message_cb.fd = -1;

  gpgsm->message_cb.dir = 0;

  gpgsm->message_cb.tag = 0;

  gpgsm->message_cb.server_fd = -1;

  *gpgsm->message_cb.server_fd_str = 0;

  gpgsm->diag_cb.fd = -1;

  gpgsm->diag_cb.dir = 1;

  gpgsm->diag_cb.tag = 0;

  gpgsm->diag_cb.server_fd = -1;

  *gpgsm->diag_cb.server_fd_str = 0;

  gpgsm->status.fnc = 0;

  gpgsm->colon.fnc = 0;

  gpgsm->colon.attic.line = 0;

  gpgsm->colon.attic.linesize = 0;

  gpgsm->colon.attic.linelen = 0;

  gpgsm->colon.any = 0;

  gpgsm->inline_data = NULL;

  gpgsm->io_cbs.add = NULL;

  gpgsm->io_cbs.add_priv = NULL;

  gpgsm->io_cbs.remove = NULL;

  gpgsm->io_cbs.event = NULL;

  gpgsm->io_cbs.event_priv = NULL;

  if (_gpgme_io_pipe (fds, 1) < 0)

    {

      err = gpg_error_from_syserror ();

      goto leave;

    }

  gpgsm->diag_cb.fd = fds[0];

  gpgsm->diag_cb.server_fd = fds[1];

#if USE_DESCRIPTOR_PASSING

  child_fds[0] = gpgsm->diag_cb.server_fd;

  child_fds[1] = -1;

  nchild_fds = 2;

  connect_flags = ASSUAN_PIPE_CONNECT_FDPASSING;

#else /*!USE_DESCRIPTOR_PASSING*/

  if (_gpgme_io_pipe (fds, 0) < 0)

    {

      err = gpg_error_from_syserror ();

      goto leave;

    }

  gpgsm->input_cb.fd = fds[1];

  gpgsm->input_cb.server_fd = fds[0];

  if (_gpgme_io_pipe (fds, 1) < 0)

    {

      err = gpg_error_from_syserror ();

      goto leave;

    }

  gpgsm->output_cb.fd = fds[0];

  gpgsm->output_cb.server_fd = fds[1];

  if (_gpgme_io_pipe (fds, 0) < 0)

    {

      err = gpg_error_from_syserror ();

      goto leave;

    }

  gpgsm->message_cb.fd = fds[1];

  gpgsm->message_cb.server_fd = fds[0];

  child_fds[0] = gpgsm->input_cb.server_fd;

  child_fds[1] = gpgsm->output_cb.server_fd;

  child_fds[2] = gpgsm->message_cb.server_fd;

  child_fds[3] = gpgsm->diag_cb.server_fd;

  child_fds[4] = -1;

  nchild_fds = 5;

  connect_flags = 0;

#endif  /*!USE_DESCRIPTOR_PASSING*/

  pgmname = file_name ? file_name : _gpgme_get_default_gpgsm_name ();

  argc = 0;

  argv[argc++] = _gpgme_get_basename (pgmname);

  if (home_dir)

    {

      argv[argc++] = "--homedir";

      argv[argc++] = home_dir;

    }

  /* Set up diagnostics */

  err = gpgme_data_new (&gpgsm->diagnostics);

  if (err)

    goto leave;

  gpgsm->diag_cb.data = gpgsm->diagnostics;

  argv[argc++] = "--logger-fd";

  if (gpgrt_asprintf (&diag_fd_str, "%i", gpgsm->diag_cb.server_fd) == -1)

    {

      err = gpg_error_from_syserror ();

      goto leave;

    }

  argv[argc++] = diag_fd_str;

  argv[argc++] = "--server";

  argv[argc++] = NULL;

  err = assuan_new_ext (&gpgsm->assuan_ctx, GPG_ERR_SOURCE_GPGME,

			&_gpgme_assuan_malloc_hooks, _gpgme_assuan_log_cb,

			NULL);

  if (err)

    goto leave;

  assuan_ctx_set_system_hooks (gpgsm->assuan_ctx, &_gpgme_assuan_system_hooks);

  {

    assuan_fd_t achild_fds[5];

    int i;

    /* For now... */

    for (i = 0; i < nchild_fds; i++)

      achild_fds[i] = (assuan_fd_t) child_fds[i];

    err = assuan_pipe_connect (gpgsm->assuan_ctx, pgmname, argv,

                               achild_fds, NULL, NULL, connect_flags);

    /* FIXME: Check whether our Windows code still updates the list.*/

    for (i = 0; i < nchild_fds; i++)

      child_fds[i] = (int) achild_fds[i];

  }

#if !USE_DESCRIPTOR_PASSING

  /* On Windows, handles are inserted in the spawned process with

     DuplicateHandle, and child_fds contains the server-local names

     for the inserted handles when assuan_pipe_connect returns.  */

  if (!err)

    {

      /* Note: We don't use _gpgme_io_fd2str here.  On W32 the

	 returned handles are real W32 system handles, not whatever

	 GPGME uses internally (which may be a system handle, a C

	 library handle or a GLib/Qt channel.  Confusing, yes, but

	 remember these are server-local names, so they are not part

	 of GPGME at all.  */

      snprintf (gpgsm->input_cb.server_fd_str,

		sizeof gpgsm->input_cb.server_fd_str, "%d", child_fds[0]);

      snprintf (gpgsm->output_cb.server_fd_str,

		sizeof gpgsm->output_cb.server_fd_str, "%d", child_fds[1]);

      snprintf (gpgsm->message_cb.server_fd_str,

		sizeof gpgsm->message_cb.server_fd_str, "%d", child_fds[2]);

      snprintf (gpgsm->diag_cb.server_fd_str,

		sizeof gpgsm->diag_cb.server_fd_str, "%d", child_fds[3]);

    }

#endif

  if (err)

    goto leave;

  err = _gpgme_getenv ("DISPLAY", &dft_display);

  if (err)

    goto leave;

  if (dft_display)

    {

      if (gpgrt_asprintf (&optstr, "OPTION display=%s", dft_display) < 0)

        {

	  free (dft_display);

	  err = gpg_error_from_syserror ();

	  goto leave;

	}

      free (dft_display);

      err = assuan_transact (gpgsm->assuan_ctx, optstr, NULL, NULL, NULL,

			     NULL, NULL, NULL);

      gpgrt_free (optstr);

      if (err)

	goto leave;

    }

  err = _gpgme_getenv ("GPG_TTY", &env_tty);

  if (isatty (1) || env_tty || err)

    {

      int rc = 0;

      if (err)

        goto leave;

      else if (env_tty)

        {

          snprintf (dft_ttyname, sizeof (dft_ttyname), "%s", env_tty);

          free (env_tty);

        }

      else

        rc = ttyname_r (1, dft_ttyname, sizeof (dft_ttyname));

      /* Even though isatty() returns 1, ttyname_r() may fail in many

	 ways, e.g., when /dev/pts is not accessible under chroot.  */

      if (!rc)

	{

	  if (gpgrt_asprintf (&optstr, "OPTION ttyname=%s", dft_ttyname) < 0)

	    {

	      err = gpg_error_from_syserror ();

	      goto leave;

	    }

	  err = assuan_transact (gpgsm->assuan_ctx, optstr, NULL, NULL, NULL,

				 NULL, NULL, NULL);

	  gpgrt_free (optstr);

	  if (err)

	    goto leave;

	  err = _gpgme_getenv ("TERM", &dft_ttytype);

	  if (err)

	    goto leave;

	  if (dft_ttytype)

	    {

	      if (gpgrt_asprintf (&optstr, "OPTION ttytype=%s", dft_ttytype)< 0)

		{

		  free (dft_ttytype);

		  err = gpg_error_from_syserror ();

		  goto leave;

		}

	      free (dft_ttytype);

	      err = assuan_transact (gpgsm->assuan_ctx, optstr, NULL, NULL,

				     NULL, NULL, NULL, NULL);

	      gpgrt_free (optstr);

	      if (err)

		goto leave;

	    }

	}

    }

  /* Ask gpgsm to enable the audit log support.  */

  if (!err)

    {

      err = assuan_transact (gpgsm->assuan_ctx, "OPTION enable-audit-log=1",

                             NULL, NULL, NULL, NULL, NULL, NULL);

      if (gpg_err_code (err) == GPG_ERR_UNKNOWN_OPTION)

        err = 0; /* This is an optional feature of gpgsm.  */

    }

#ifdef HAVE_W32_SYSTEM

  /* Under Windows we need to use AllowSetForegroundWindow.  Tell

     gpgsm to tell us when it needs it.  */

  if (!err)

    {

      err = assuan_transact (gpgsm->assuan_ctx, "OPTION allow-pinentry-notify",

                             NULL, NULL, NULL, NULL, NULL, NULL);

      if (gpg_err_code (err) == GPG_ERR_UNKNOWN_OPTION)

        err = 0; /* This is a new feature of gpgsm.  */

    }

#endif /*HAVE_W32_SYSTEM*/

#if !USE_DESCRIPTOR_PASSING

  if (!err

      && (_gpgme_io_set_close_notify (gpgsm->input_cb.fd,

				      close_notify_handler, gpgsm)

	  || _gpgme_io_set_close_notify (gpgsm->output_cb.fd,

					 close_notify_handler, gpgsm)

	  || _gpgme_io_set_close_notify (gpgsm->message_cb.fd,

					 close_notify_handler, gpgsm)))

    {

      err = gpg_error (GPG_ERR_GENERAL);

      goto leave;

    }

#endif

  if (!err && _gpgme_io_set_close_notify (gpgsm->diag_cb.fd,

                                          close_notify_handler, gpgsm))

    {

      err = gpg_error (GPG_ERR_GENERAL);

      goto leave;

    }

 leave:

  /* Close the server ends of the pipes (because of this, we must use

     the stored server_fd_str in the function start).  Our ends are

     closed in gpgsm_release().  */

#if !USE_DESCRIPTOR_PASSING

  if (gpgsm->input_cb.server_fd != -1)

    _gpgme_io_close (gpgsm->input_cb.server_fd);

  if (gpgsm->output_cb.server_fd != -1)

    _gpgme_io_close (gpgsm->output_cb.server_fd);

  if (gpgsm->message_cb.server_fd != -1)

    _gpgme_io_close (gpgsm->message_cb.server_fd);

  if (gpgsm->diag_cb.server_fd != -1)

    _gpgme_io_close (gpgsm->diag_cb.server_fd);

#endif

  if (err)

    gpgsm_release (gpgsm);

  else

    *engine = gpgsm;

  free (diag_fd_str);

  return err;

}

/* Copy flags from CTX into the engine object.  */

static void

gpgsm_set_engine_flags (void *engine, const gpgme_ctx_t ctx)

{

  engine_gpgsm_t gpgsm = engine;

  if (ctx->request_origin)

    {

      if (strlen (ctx->request_origin) + 1 > sizeof gpgsm->request_origin)

        strcpy (gpgsm->request_origin, "xxx"); /* Too long  - force error */

      else

        strcpy (gpgsm->request_origin, ctx->request_origin);

    }

  else

    *gpgsm->request_origin = 0;

}

static gpgme_error_t

gpgsm_set_locale (void *engine, int category, const char *value)

{

  engine_gpgsm_t gpgsm = engine;

  gpgme_error_t err;

  char *optstr;

  const char *catstr;

  /* FIXME: If value is NULL, we need to reset the option to default.

     But we can't do this.  So we error out here.  GPGSM needs support

     for this.  */

  if (0)

    ;

#ifdef LC_CTYPE

  else if (category == LC_CTYPE)

    {

      catstr = "lc-ctype";

      if (!value && gpgsm->lc_ctype_set)

	return gpg_error (GPG_ERR_INV_VALUE);

      if (value)

	gpgsm->lc_ctype_set = 1;

    }

#endif

#ifdef LC_MESSAGES

  else if (category == LC_MESSAGES)

    {

      catstr = "lc-messages";

      if (!value && gpgsm->lc_messages_set)

	return gpg_error (GPG_ERR_INV_VALUE);

      if (value)

	gpgsm->lc_messages_set = 1;

    }

#endif /* LC_MESSAGES */

  else

    return gpg_error (GPG_ERR_INV_VALUE);

  /* FIXME: Reset value to default.  */

  if (!value)

    return 0;

  if (gpgrt_asprintf (&optstr, "OPTION %s=%s", catstr, value) < 0)

    err = gpg_error_from_syserror ();

  else

    {

      err = assuan_transact (gpgsm->assuan_ctx, optstr, NULL, NULL,

			     NULL, NULL, NULL, NULL);

      gpgrt_free (optstr);

    }

  return err;

}

static gpgme_error_t

gpgsm_assuan_simple_command (engine_gpgsm_t gpgsm, const char *cmd,

			     engine_status_handler_t status_fnc,

			     void *status_fnc_value)

{

  assuan_context_t ctx = gpgsm->assuan_ctx;

  gpg_error_t err, cb_err;

  char *line;

  size_t linelen;

  err = assuan_write_line (ctx, cmd);

  if (err)

    return err;

  cb_err = 0;

  do

    {

      err = assuan_read_line (ctx, &line, &linelen);

      if (err)

	break;

      if (*line == '#' || !linelen)

	continue;

      if (linelen >= 2

	  && line[0] == 'O' && line[1] == 'K'

	  && (line[2] == '\0' || line[2] == ' '))

	break;

      else if (linelen >= 4

	  && line[0] == 'E' && line[1] == 'R' && line[2] == 'R'

	  && line[3] == ' ')

        {

          /* We prefer a callback generated error because that one is

             more related to gpgme and thus probably more important

             than the error returned by the engine.  */

          err = cb_err? cb_err : atoi (&line[4]);

          cb_err = 0;

        }

      else if (linelen >= 2

	       && line[0] == 'S' && line[1] == ' ')

	{

          /* After an error from a status callback we skip all further

             status lines.  */

          if (!cb_err)

            {

              char *rest;

              gpgme_status_code_t r;

              rest = strchr (line + 2, ' ');

              if (!rest)

                rest = line + linelen; /* set to an empty string */

              else

                *(rest++) = 0;

              r = _gpgme_parse_status (line + 2);

              if (gpgsm->status.mon_cb && r != GPGME_STATUS_PROGRESS)

                {

                  /* Note that we call the monitor even if we do

                   * not know the status code (r < 0).  */

                  cb_err = gpgsm->status.mon_cb (gpgsm->status.mon_cb_value,

                                                 line + 2, rest);

                }

              if (r >= 0 && status_fnc && !cb_err)

                cb_err = status_fnc (status_fnc_value, r, rest);

            }

	}

      else

        {

          /* Invalid line or INQUIRY.  We can't do anything else than

             to stop.  As with ERR we prefer a status callback

             generated error code, though.  */

          err = cb_err ? cb_err : gpg_error (GPG_ERR_GENERAL);

          cb_err = 0;

        }

    }

  while (!err);

  /* We only want the first error from the status handler, thus we

   * take the one saved in CB_ERR. */

  if (!err && cb_err)

    err = cb_err;

  return err;

}

typedef enum { INPUT_FD, OUTPUT_FD, MESSAGE_FD } fd_type_t;

static void

gpgsm_clear_fd (engine_gpgsm_t gpgsm, fd_type_t fd_type)

{

#if !USE_DESCRIPTOR_PASSING

  switch (fd_type)

    {

    case INPUT_FD:

      _gpgme_io_close (gpgsm->input_cb.fd);

      break;

    case OUTPUT_FD:

      _gpgme_io_close (gpgsm->output_cb.fd);

      break;

    case MESSAGE_FD:

      _gpgme_io_close (gpgsm->message_cb.fd);

      break;

    }

#else

  (void)gpgsm;

  (void)fd_type;

#endif

}

#define COMMANDLINELEN 40

static gpgme_error_t

gpgsm_set_fd (engine_gpgsm_t gpgsm, fd_type_t fd_type, const char *opt)

{

  gpg_error_t err = 0;

  char line[COMMANDLINELEN];

  const char *which;

  iocb_data_t *iocb_data;

#if USE_DESCRIPTOR_PASSING

  int dir;

#endif

  switch (fd_type)

    {

    case INPUT_FD:

      which = "INPUT";

      iocb_data = &gpgsm->input_cb;

      break;

    case OUTPUT_FD:

      which = "OUTPUT";

      iocb_data = &gpgsm->output_cb;

      break;

    case MESSAGE_FD:

      which = "MESSAGE";

      iocb_data = &gpgsm->message_cb;

      break;

    default:

      return gpg_error (GPG_ERR_INV_VALUE);

    }

#if USE_DESCRIPTOR_PASSING

  dir = iocb_data->dir;

  /* We try to short-cut the communication by giving GPGSM direct

     access to the file descriptor, rather than using a pipe.  */

  iocb_data->server_fd = _gpgme_data_get_fd (iocb_data->data);

  if (iocb_data->server_fd < 0)

    {

      int fds[2];

      if (_gpgme_io_pipe (fds, dir) < 0)

	return gpg_error_from_syserror ();

      iocb_data->fd = dir ? fds[0] : fds[1];

      iocb_data->server_fd = dir ? fds[1] : fds[0];

      if (_gpgme_io_set_close_notify (iocb_data->fd,

				      close_notify_handler, gpgsm))

	{

	  err = gpg_error (GPG_ERR_GENERAL);

	  goto leave_set_fd;

	}

    }

  err = assuan_sendfd (gpgsm->assuan_ctx, iocb_data->server_fd);

  if (err)

    goto leave_set_fd;

  _gpgme_io_close (iocb_data->server_fd);

  iocb_data->server_fd = -1;

  if (opt)

    snprintf (line, COMMANDLINELEN, "%s FD %s", which, opt);

  else

    snprintf (line, COMMANDLINELEN, "%s FD", which);

#else

  if (opt)

    snprintf (line, COMMANDLINELEN, "%s FD=%s %s",

              which, iocb_data->server_fd_str, opt);

  else

    snprintf (line, COMMANDLINELEN, "%s FD=%s",

              which, iocb_data->server_fd_str);

#endif

  err = gpgsm_assuan_simple_command (gpgsm, line, NULL, NULL);

#if USE_DESCRIPTOR_PASSING

 leave_set_fd:

  if (err)

    {

      _gpgme_io_close (iocb_data->fd);

      iocb_data->fd = -1;

      if (iocb_data->server_fd != -1)

        {

          _gpgme_io_close (iocb_data->server_fd);

          iocb_data->server_fd = -1;

        }

    }

#endif

  return err;

}

static const char *

map_data_enc (gpgme_data_t d)

{

  switch (gpgme_data_get_encoding (d))

    {

    case GPGME_DATA_ENCODING_NONE:

      break;

    case GPGME_DATA_ENCODING_BINARY:

      return "--binary";

    case GPGME_DATA_ENCODING_BASE64:

      return "--base64";

    case GPGME_DATA_ENCODING_ARMOR:

      return "--armor";

    default: