gpgme/gpgme/engine-gpgsm.c

/* engine-gpgsm.c -  GpgSM engine
 *	Copyright (C) 2000 Werner Koch (dd9jn)
 *      Copyright (C) 2001, 2002 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 General Public License as published by
 * the Free Software Foundation; either version 2 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 General Public License for more details.
 *
 * You should have received a copy of the GNU 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
 */

#if HAVE_CONFIG_H
#include <config.h>
#endif

/* FIXME: Correct check?  */
#ifdef GPGSM_PATH
#define ENABLE_GPGSM 1
#endif

#ifdef ENABLE_GPGSM

#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <assert.h>
#include <unistd.h>
#include <locale.h>
#include <fcntl.h> /* FIXME */

#include "rungpg.h"
#include "status-table.h"

#include "gpgme.h"
#include "util.h"
#include "types.h"
#include "ops.h"
#include "wait.h"
#include "io.h"
#include "key.h"
#include "sema.h"

#include "engine-gpgsm.h"

#include "assuan.h"

#define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
                     *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
#define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))



typedef struct
{
  int fd;	/* FD we talk about.  */
  int dir;	/* Inbound/Outbound, maybe given implicit?  */
  void *data;	/* Handler-specific data.  */
  void *tag;	/* ID from the user for gpgme_remove_io_callback.  */
} iocb_data_t;

struct gpgsm_object_s
{
  ASSUAN_CONTEXT assuan_ctx;

  iocb_data_t status_cb;

  /* Input, output etc are from the servers perspective.  */
  iocb_data_t input_cb;
  int input_fd_server;

  iocb_data_t output_cb;
  int output_fd_server;

  iocb_data_t message_cb;
  int message_fd_server;

  char *command;

  struct
  {
    GpgStatusHandler fnc;
    void *fnc_value;
  } status;

  struct
  {
    GpgColonLineHandler fnc;
    void *fnc_value;
    struct
    {
      unsigned char *line;
      int linesize;
      int linelen;
    } attic;
  } colon; 

  struct GpgmeIOCbs io_cbs;
};


const char *
_gpgme_gpgsm_get_version (void)
{
  static const char *gpgsm_version;
  DEFINE_STATIC_LOCK (gpgsm_version_lock);

  LOCK (gpgsm_version_lock);
  if (!gpgsm_version)
    gpgsm_version = _gpgme_get_program_version (_gpgme_get_gpgsm_path ());
  UNLOCK (gpgsm_version_lock);

  return gpgsm_version;
}


GpgmeError
_gpgme_gpgsm_check_version (void)
{
    return _gpgme_compare_versions (_gpgme_gpgsm_get_version (),
				  NEED_GPGSM_VERSION)
    ? 0 : mk_error (Invalid_Engine);
}


static void
close_notify_handler (int fd, void *opaque)
{
  GpgsmObject gpgsm = opaque;
  int possibly_done = 0;

  assert (fd != -1);
  if (gpgsm->status_cb.fd == fd)
    {
      if (gpgsm->status_cb.tag)
	{
	  (*gpgsm->io_cbs.remove) (gpgsm->status_cb.tag);
	  possibly_done = 1;
	}
      gpgsm->status_cb.fd = -1;
    }
  else if (gpgsm->input_cb.fd == fd)
    {
      if (gpgsm->input_cb.tag)
	{
	  (*gpgsm->io_cbs.remove) (gpgsm->input_cb.tag);
	  possibly_done = 1;
	}
      gpgsm->input_cb.fd = -1;
    }
  else if (gpgsm->output_cb.fd == fd)
    {
      if (gpgsm->output_cb.tag)
	{      
	  (*gpgsm->io_cbs.remove) (gpgsm->output_cb.tag);
	  possibly_done = 1;
	}
      gpgsm->output_cb.fd = -1;
    }
  else if (gpgsm->message_cb.fd == fd)
    {
      if (gpgsm->message_cb.tag)
	{
	  (*gpgsm->io_cbs.remove) (gpgsm->message_cb.tag);
	  possibly_done = 1;
	}
      gpgsm->message_cb.fd = -1;
    }
  if (possibly_done && gpgsm->io_cbs.event
      && gpgsm->status_cb.fd == -1 && gpgsm->input_cb.fd == -1
      && gpgsm->output_cb.fd == -1 && gpgsm->message_cb.fd == -1)
    (*gpgsm->io_cbs.event) (gpgsm->io_cbs.event_priv, GPGME_EVENT_DONE, NULL);
}


static GpgmeError
map_assuan_error (AssuanError err)
{
  switch (err)
    {
    case ASSUAN_No_Error:
      return mk_error (No_Error);
    case ASSUAN_General_Error:
      return mk_error (General_Error);
    case ASSUAN_Out_Of_Core:
      return mk_error (Out_Of_Core);
    case ASSUAN_Invalid_Value:
      return mk_error (Invalid_Value);
    case ASSUAN_Read_Error:
      return mk_error (Read_Error);
    case ASSUAN_Write_Error:
      return mk_error (Write_Error);

    case ASSUAN_Timeout:
    case ASSUAN_Problem_Starting_Server:
    case ASSUAN_Not_A_Server:
    case ASSUAN_Not_A_Client:
    case ASSUAN_Nested_Commands:
    case ASSUAN_Invalid_Response:
    case ASSUAN_No_Data_Callback:
    case ASSUAN_No_Inquire_Callback:
    case ASSUAN_Connect_Failed:
    case ASSUAN_Accept_Failed:
      return mk_error (General_Error);

      /* The following error codes are meant as status codes.  */
    case ASSUAN_Not_Implemented:
      return mk_error (Not_Implemented);
    case ASSUAN_Canceled:
      return mk_error (Canceled);
    case ASSUAN_Unsupported_Algorithm:
      return mk_error (Not_Implemented);  /* XXX Argh.  */
      
    case ASSUAN_No_Data_Available:
      return mk_error (EOF);
      
      /* These are errors internal to GPGME.  */
    case ASSUAN_No_Input:
    case ASSUAN_No_Output:
    case ASSUAN_Invalid_Command:
    case ASSUAN_Unknown_Command:
    case ASSUAN_Syntax_Error:
    case ASSUAN_Parameter_Error:
    case ASSUAN_Parameter_Conflict:
    case ASSUAN_Line_Too_Long:
    case ASSUAN_Line_Not_Terminated:
    case ASSUAN_Invalid_Data:
    case ASSUAN_Unexpected_Command:
    case ASSUAN_Too_Much_Data:
    case ASSUAN_Inquire_Unknown:
    case ASSUAN_Inquire_Error:
    case ASSUAN_Invalid_Option:
    case ASSUAN_Invalid_Index:
    case ASSUAN_Unexpected_Status:
    case ASSUAN_Unexpected_Data:
    case ASSUAN_Invalid_Status:
    case ASSUAN_Not_Confirmed:
      return mk_error (General_Error);

      /* These are errors in the server.  */
    case ASSUAN_Server_Fault:
    case ASSUAN_Server_Resource_Problem:
    case ASSUAN_Server_IO_Error:
    case ASSUAN_Server_Bug:
    case ASSUAN_No_Agent:
    case ASSUAN_Agent_Error:
      return mk_error (Invalid_Engine);  /* XXX:  Need something more useful.  */

    case ASSUAN_Bad_Certificate:
    case ASSUAN_Bad_Certificate_Path:
    case ASSUAN_Missing_Certificate:
    case ASSUAN_No_Public_Key:
    case ASSUAN_No_Secret_Key:
    case ASSUAN_Invalid_Name:
    case ASSUAN_Card_Error:	/* XXX: Oh well.  */
    case ASSUAN_Invalid_Card:	/* XXX: Oh well.  */
    case ASSUAN_No_PKCS15_App:	/* XXX: Oh well.  */
    case ASSUAN_Card_Not_Present:	/* XXX: Oh well.  */
    case ASSUAN_Invalid_Id:	/* XXX: Oh well.  */
      return mk_error (Invalid_Key);

    case ASSUAN_Bad_Signature:
      return mk_error (Invalid_Key);  /* XXX: This is wrong.  */

    case ASSUAN_Cert_Revoked:
    case ASSUAN_No_CRL_For_Cert:
    case ASSUAN_CRL_Too_Old:
    case ASSUAN_Not_Trusted:
      return mk_error (Invalid_Key);  /* XXX Some more details would be good.  */

    default:
      return mk_error (General_Error);
    }
}


GpgmeError
_gpgme_gpgsm_new (GpgsmObject *r_gpgsm)
{
  GpgmeError err = 0;
  GpgsmObject gpgsm;
  char *argv[3];
  int fds[2];
  int child_fds[4];
  char *dft_display = NULL;
  char *dft_ttyname = NULL;
  char *dft_ttytype = NULL;
  char *old_lc = NULL;
  char *dft_lc = NULL;
  char *optstr;
  int fdlist[5];
  int nfds;

  *r_gpgsm = NULL;
  gpgsm = xtrycalloc (1, sizeof *gpgsm);
  if (!gpgsm)
    {
      err = mk_error (Out_Of_Core);
      return err;
    }

  gpgsm->status_cb.fd = -1;
  gpgsm->status_cb.tag = 0;

  gpgsm->input_cb.fd = -1;
  gpgsm->input_cb.tag = 0;
  gpgsm->input_fd_server = -1;
  gpgsm->output_cb.fd = -1;
  gpgsm->output_cb.tag = 0;
  gpgsm->output_fd_server = -1;
  gpgsm->message_cb.fd = -1;
  gpgsm->message_cb.tag = 0;
  gpgsm->message_fd_server = -1;

  gpgsm->status.fnc = 0;
  gpgsm->colon.fnc = 0;
  gpgsm->colon.attic.line = 0;
  gpgsm->colon.attic.linesize = 0;
  gpgsm->colon.attic.linelen = 0;

  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, 0) < 0)
    {
      err = mk_error (Pipe_Error);
      goto leave;
    }
  gpgsm->input_cb.fd = fds[1];
  gpgsm->input_cb.dir = 0;
  gpgsm->input_fd_server = fds[0];

  if (_gpgme_io_pipe (fds, 1) < 0)
    {
      err = mk_error (Pipe_Error);
      goto leave;
    }
  gpgsm->output_cb.fd = fds[0];
  gpgsm->output_cb.dir = 1;
  gpgsm->output_fd_server = fds[1];

  if (_gpgme_io_pipe (fds, 0) < 0)
    {
      err = mk_error (Pipe_Error);
      goto leave;
    }
  gpgsm->message_cb.fd = fds[1];
  gpgsm->message_cb.dir = 0;
  gpgsm->message_fd_server = fds[0];

  child_fds[0] = gpgsm->input_fd_server;
  child_fds[1] = gpgsm->output_fd_server;
  child_fds[2] = gpgsm->message_fd_server;
  child_fds[3] = -1;

  argv[0] = "gpgsm";
  argv[1] = "--server";
  argv[2] = NULL;

  err = assuan_pipe_connect2 (&gpgsm->assuan_ctx,
                              _gpgme_get_gpgsm_path (), argv, child_fds,
                              1 /* dup stderr to /dev/null */);

  /* We need to know the fd used by assuan for reads.  We do this by
     using the assumption that the first returned fd from
     assuan_get_active_fds() is always this one.  */
  nfds = assuan_get_active_fds (gpgsm->assuan_ctx, 0 /* read fds */,
                                fdlist, DIM (fdlist));
  if (nfds < 1)
    {
      err = mk_error (General_Error);  /* FIXME */
      goto leave;
    }
  /* We duplicate the file descriptor, so we can close it without
     disturbing assuan.  Alternatively, we could special case
     status_fd and register/unregister it manually as needed, but this
     increases code duplication and is more complicated as we can not
     use the close notifications etc.  */
  gpgsm->status_cb.fd = dup (fdlist[0]);
  if (gpgsm->status_cb.fd < 0)
    {
      err = mk_error (General_Error);	/* FIXME */
      goto leave;
    }
  gpgsm->status_cb.dir = 1;
  gpgsm->status_cb.data = gpgsm;

  dft_display = getenv ("DISPLAY");
  if (dft_display)
    {
      if (asprintf (&optstr, "OPTION display=%s", dft_display) < 0)
        {
	  err = mk_error (Out_Of_Core);
	  goto leave;
	}
      err = assuan_transact (gpgsm->assuan_ctx, optstr, NULL, NULL, NULL,
			     NULL, NULL, NULL);
      free (optstr);
      if (err)
	{
	  err = map_assuan_error (err);
	  goto leave;
	}
    }
  dft_ttyname = ttyname (1);
  if (dft_ttyname)
    {
      if (asprintf (&optstr, "OPTION ttyname=%s", dft_ttyname) < 0)
        {
	  err = mk_error (Out_Of_Core);
	  goto leave;
	}
      err = assuan_transact (gpgsm->assuan_ctx, optstr, NULL, NULL, NULL, NULL, NULL,
			     NULL);
      free (optstr);
      if (err)
	{
	  err = map_assuan_error (err);
	  goto leave;
	}

      dft_ttytype = getenv ("TERM");
      if (dft_ttytype)
	{
	  if (asprintf (&optstr, "OPTION ttytype=%s", dft_ttytype) < 0)
	    {
	      err = mk_error (Out_Of_Core);
	      goto leave;
	    }
	  err = assuan_transact (gpgsm->assuan_ctx, optstr, NULL, NULL, NULL, NULL, NULL,
				 NULL);
	  free (optstr);
	  if (err)
	    {
	      err = map_assuan_error (err);
	      goto leave;
	    }
	}
      old_lc = setlocale (LC_CTYPE, NULL);
      dft_lc = setlocale (LC_CTYPE, "");
      if (dft_lc)
	{
	  if (asprintf (&optstr, "OPTION lc-ctype=%s", dft_lc) < 0)
	    err = mk_error (Out_Of_Core);
	  else
	    {
	      err = assuan_transact (gpgsm->assuan_ctx, optstr, NULL, NULL, NULL, NULL, NULL,
				     NULL);
	      free (optstr);
	      if (err)
		err = map_assuan_error (err);
	    }
	}
      if (old_lc)
	setlocale (LC_CTYPE, old_lc);
      if (err)
	goto leave;

      old_lc = setlocale (LC_MESSAGES, NULL);
      dft_lc = setlocale (LC_MESSAGES, "");
      if (dft_lc)
	{
	  if (asprintf (&optstr, "OPTION lc-messages=%s", dft_lc) < 0)
	    err = mk_error (Out_Of_Core);
	  else
	    {
	      err = assuan_transact (gpgsm->assuan_ctx, optstr, NULL, NULL, NULL, NULL, NULL,
				     NULL);
	      free (optstr);
	      if (err)
		err = map_assuan_error (err);
	    }
	}
      if (old_lc)
	setlocale (LC_MESSAGES, old_lc);
      if (err)
	goto leave;
    }

  if (!err &&
      (_gpgme_io_set_close_notify (gpgsm->status_cb.fd,
				   close_notify_handler, gpgsm)
       || _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 = mk_error (General_Error);
      goto leave;
    }
      
 leave:
  /* Close the server ends of the pipes.  Our ends are closed in
     _gpgme_gpgsm_release.  */
  if (gpgsm->input_fd_server != -1)
    _gpgme_io_close (gpgsm->input_fd_server);
  if (gpgsm->output_fd_server != -1)
    _gpgme_io_close (gpgsm->output_fd_server);
  if (gpgsm->message_fd_server != -1)
    _gpgme_io_close (gpgsm->message_fd_server);

  if (err)
    _gpgme_gpgsm_release (gpgsm);
  else
    *r_gpgsm = gpgsm;

  return err;
}


void
_gpgme_gpgsm_release (GpgsmObject gpgsm)
{
  if (!gpgsm)
    return;

  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);

  assuan_disconnect (gpgsm->assuan_ctx);

  xfree (gpgsm->colon.attic.line);
  xfree (gpgsm->command);
  xfree (gpgsm);
}

/* Forward declaration.  */
static GpgStatusCode parse_status (const char *name);

static GpgmeError
gpgsm_assuan_simple_command (ASSUAN_CONTEXT ctx, char *cmd, GpgStatusHandler status_fnc,
			     void *status_fnc_value)
{
  AssuanError err;
  char *line;
  size_t linelen;

  err = assuan_write_line (ctx, cmd);
  if (err)
    return map_assuan_error (err);

  do
    {
      err = assuan_read_line (ctx, &line, &linelen);
      if (err)
	return map_assuan_error (err);

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

      if (linelen >= 2
	  && line[0] == 'O' && line[1] == 'K'
	  && (line[2] == '\0' || line[2] == ' '))
	return 0;
      else if (linelen >= 4
	  && line[0] == 'E' && line[1] == 'R' && line[2] == 'R'
	  && line[3] == ' ')
	err = map_assuan_error (atoi (&line[4]));
      else if (linelen >= 2
	       && line[0] == 'S' && line[1] == ' ')
	{
	  char *rest;
	  GpgStatusCode r;

	  rest = strchr (line + 2, ' ');
	  if (!rest)
	    rest = line + linelen; /* set to an empty string */
	  else
	    *(rest++) = 0;

	  r = parse_status (line + 2);

	  if (r >= 0 && status_fnc)
	    status_fnc (status_fnc_value, r, rest);
	  else
	    err = mk_error (General_Error);
	}
      else
	err = mk_error (General_Error);
    }
  while (!err);

  return err;
}


#define COMMANDLINELEN 40
static GpgmeError
gpgsm_set_fd (ASSUAN_CONTEXT ctx, const char *which, int fd, const char *opt)
{
  char line[COMMANDLINELEN];

  if (opt)
    snprintf (line, COMMANDLINELEN, "%s FD=%i %s", which, fd, opt);
  else
    snprintf (line, COMMANDLINELEN, "%s FD=%i", which, fd);

  return gpgsm_assuan_simple_command (ctx, line, NULL, NULL);
}


static const char *
map_input_enc (GpgmeData 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:
      break;
    }
  return NULL;
}


GpgmeError
_gpgme_gpgsm_op_decrypt (GpgsmObject gpgsm, GpgmeData ciph, GpgmeData plain)
{
  GpgmeError err;

  if (!gpgsm)
    return mk_error (Invalid_Value);

  gpgsm->command = xtrystrdup ("DECRYPT");
  if (!gpgsm->command)
    return mk_error (Out_Of_Core);

  gpgsm->input_cb.data = ciph;
  err = gpgsm_set_fd (gpgsm->assuan_ctx, "INPUT", gpgsm->input_fd_server, 
                      map_input_enc (gpgsm->input_cb.data));
  if (err)
    return mk_error (General_Error);	/* FIXME */
  gpgsm->output_cb.data = plain;
  err = gpgsm_set_fd (gpgsm->assuan_ctx, "OUTPUT", gpgsm->output_fd_server, 0);
  if (err)
    return mk_error (General_Error);	/* FIXME */
  _gpgme_io_close (gpgsm->message_cb.fd);

  return 0;
}


GpgmeError
_gpgme_gpgsm_op_delete (GpgsmObject gpgsm, GpgmeKey key, int allow_secret)
{
  char *fpr = (char *) gpgme_key_get_string_attr (key, GPGME_ATTR_FPR, NULL, 0);
  char *linep = fpr;
  char *line;
  int length = 8;	/* "DELKEYS " */

  if (!fpr)
    return mk_error (Invalid_Key);

  while (*linep)
    {
      length++;
      if (*linep == '%' || *linep == ' ' || *linep == '+')
	length += 2;
      linep++;
    }
  length++;

  line = xtrymalloc (length);
  if (!line)
    return mk_error (Out_Of_Core);

  strcpy (line, "DELKEYS ");
  linep = &line[8];

  while (*fpr)
    {
      switch (*fpr)
	{
	case '%':
	  *(linep++) = '%';
	  *(linep++) = '2';
	  *(linep++) = '5';
	  break;
	case ' ':
	  *(linep++) = '%';
	  *(linep++) = '2';
	  *(linep++) = '0';
	  break;
	case '+':
	  *(linep++) = '%';
	  *(linep++) = '2';
	  *(linep++) = 'B';
	  break;
	default:
	  *(linep++) = *fpr;
	  break;
	}
      fpr++;
    }
  *linep = '\0';

  gpgsm->command = line;
  _gpgme_io_close (gpgsm->output_cb.fd);
  _gpgme_io_close (gpgsm->input_cb.fd);
  _gpgme_io_close (gpgsm->message_cb.fd);

  return 0;
}


static GpgmeError
gpgsm_set_recipients (GpgsmObject gpgsm, GpgmeRecipients recp)
{
  GpgmeError err;
  ASSUAN_CONTEXT ctx = gpgsm->assuan_ctx;
  char *line;
  int linelen;
  struct user_id_s *r;
  int valid_recipients = 0;

  linelen = 10 + 40 + 1;	/* "RECIPIENT " + guess + '\0'.  */
  line = xtrymalloc (10 + 40 + 1);
  if (!line)
    return mk_error (Out_Of_Core);
  strcpy (line, "RECIPIENT ");
  for (r = recp->list; r; r = r->next)
    {
      int newlen = 11 + strlen (r->name);
      if (linelen < newlen)
	{
	  char *newline = xtryrealloc (line, newlen);
	  if (! newline)
	    {
	      xfree (line);
	      return mk_error (Out_Of_Core);
	    }
	  line = newline;
	  linelen = newlen;
	}
      strcpy (&line[10], r->name);
      
      err = gpgsm_assuan_simple_command (ctx, line, gpgsm->status.fnc,
					 gpgsm->status.fnc_value);
      if (!err)
	valid_recipients = 1;
      else if (err != GPGME_Invalid_Key)
	{
	  xfree (line);
	  return err;
	}
    }
  xfree (line);
  if (!valid_recipients && gpgsm->status.fnc)
    gpgsm->status.fnc (gpgsm->status.fnc_value, STATUS_NO_RECP, "");
  return 0;
}


GpgmeError
_gpgme_gpgsm_op_encrypt (GpgsmObject gpgsm, GpgmeRecipients recp,
			 GpgmeData plain, GpgmeData ciph, int use_armor)
{
  GpgmeError err;

  if (!gpgsm)
    return mk_error (Invalid_Value);
  if (!recp)
    return mk_error (Not_Implemented);

  gpgsm->command = xtrystrdup ("ENCRYPT");
  if (!gpgsm->command)
    return mk_error (Out_Of_Core);

  gpgsm->input_cb.data = plain;
  err = gpgsm_set_fd (gpgsm->assuan_ctx, "INPUT", gpgsm->input_fd_server,
                      map_input_enc (gpgsm->input_cb.data));
  if (err)
    return err;
  gpgsm->output_cb.data = ciph;
  err = gpgsm_set_fd (gpgsm->assuan_ctx, "OUTPUT", gpgsm->output_fd_server,
		      use_armor ? "--armor" : 0);
  if (err)
    return err;
  _gpgme_io_close (gpgsm->message_cb.fd);

  err = gpgsm_set_recipients (gpgsm, recp);
  if (err)
    return err;

  return 0;
}


GpgmeError
_gpgme_gpgsm_op_export (GpgsmObject gpgsm, GpgmeRecipients recp,
			GpgmeData keydata, int use_armor)
{
  GpgmeError err = 0;
  char *cmd = NULL;
  int cmdi;
  int cmdlen = 32;

  if (!gpgsm)
    return mk_error (Invalid_Value);

  cmd = malloc (cmdlen);
  if (!cmd)
    return mk_error (Out_Of_Core);
  strcpy (cmd, "EXPORT");
  cmdi = 6;

  if (recp)
    {
      void *ec;
      const char *s;

      err = gpgme_recipients_enum_open (recp, &ec);
      while (!err && (s = gpgme_recipients_enum_read (recp, &ec)))
	{
	  int slen = strlen (s);
	  /* New string is old string + ' ' + s + '\0'.  */
	  if (cmdlen < cmdi + 1 + slen + 1)
	    {
	      char *newcmd = xtryrealloc (cmd, cmdlen * 2);
	      if (!newcmd)
		{
		  xfree (cmd);
		  return mk_error (Out_Of_Core);
		}
	      cmd = newcmd;
	      cmdlen *= 2;
	    }
	  cmd[cmdi++] = ' ';
	  strcpy (cmd + cmdi, s);
	  cmdi += slen;
	}
      if (!err)
	err = gpgme_recipients_enum_close (recp, &ec);
      if (err)
	return err;
    }

  gpgsm->command = cmd;

  gpgsm->output_cb.data = keydata;
  err = gpgsm_set_fd (gpgsm->assuan_ctx, "OUTPUT", gpgsm->output_fd_server,
		      use_armor ? "--armor" : 0);
  if (err)
    return err;
  _gpgme_io_close (gpgsm->input_cb.fd);
  _gpgme_io_close (gpgsm->message_cb.fd);

  return 0;
}


GpgmeError
_gpgme_gpgsm_op_genkey (GpgsmObject gpgsm, GpgmeData help_data, int use_armor,
			GpgmeData pubkey, GpgmeData seckey)
{
  GpgmeError err;

  if (!gpgsm || !pubkey || seckey)
    return mk_error (Invalid_Value);

  gpgsm->command = xtrystrdup ("GENKEY");
  if (!gpgsm->command)
    return mk_error (Out_Of_Core);

  gpgsm->input_cb.data = help_data;
  err = gpgsm_set_fd (gpgsm->assuan_ctx, "INPUT", gpgsm->input_fd_server,
                      map_input_enc (gpgsm->input_cb.data));
  if (err)
    return err;
  gpgsm->output_cb.data = pubkey;
  err = gpgsm_set_fd (gpgsm->assuan_ctx, "OUTPUT", gpgsm->output_fd_server,
		      use_armor ? "--armor" : 0);
  if (err)
    return err;
  _gpgme_io_close (gpgsm->message_cb.fd);

  return 0;
}


GpgmeError
_gpgme_gpgsm_op_import (GpgsmObject gpgsm, GpgmeData keydata)
{
  GpgmeError err;

  if (!gpgsm)
    return mk_error (Invalid_Value);

  gpgsm->command = xtrystrdup ("IMPORT");
  if (!gpgsm->command)
    return mk_error (Out_Of_Core);

  gpgsm->input_cb.data = keydata;
  err = gpgsm_set_fd (gpgsm->assuan_ctx, "INPUT", gpgsm->input_fd_server,
                      map_input_enc (gpgsm->input_cb.data));
  if (err)
    return err;
  _gpgme_io_close (gpgsm->output_cb.fd);
  _gpgme_io_close (gpgsm->message_cb.fd);

  return 0;
}


GpgmeError
_gpgme_gpgsm_op_keylist (GpgsmObject gpgsm, const char *pattern,
			 int secret_only, int keylist_mode)
{
  char *line;
  GpgmeError err;

  if (!pattern)
    pattern = "";

  if (asprintf (&line, "OPTION list-mode=%d", (keylist_mode & 3)) < 0)
    return mk_error (Out_Of_Core);
  err = gpgsm_assuan_simple_command (gpgsm->assuan_ctx, line, NULL, NULL);
  free (line);
  if (err)
    return err;

  /* Length is "LISTSECRETKEYS " + p + '\0'.  */
  line = xtrymalloc (15 + strlen (pattern) + 1);
  if (!line)
    return mk_error (Out_Of_Core);
  if (secret_only)
    {
      strcpy (line, "LISTSECRETKEYS ");
      strcpy (&line[15], pattern);
    }
  else
    {
      strcpy (line, "LISTKEYS ");
      strcpy (&line[9], pattern);
    }

  _gpgme_io_close (gpgsm->input_cb.fd);
  _gpgme_io_close (gpgsm->output_cb.fd);
  _gpgme_io_close (gpgsm->message_cb.fd);

  gpgsm->command = line;
  return 0;
}


GpgmeError
_gpgme_gpgsm_op_keylist_ext (GpgsmObject gpgsm, const char *pattern[],
			     int secret_only, int reserved, int keylist_mode)
{
  char *line;
  GpgmeError err;
  /* Length is "LISTSECRETKEYS " + p + '\0'.  */
  int length = 15 + 1;
  char *linep;
  
  if (reserved)
    return mk_error (Invalid_Value);

  if (asprintf (&line, "OPTION list-mode=%d", (keylist_mode & 3)) < 0)
    return mk_error (Out_Of_Core);
  err = gpgsm_assuan_simple_command (gpgsm->assuan_ctx, line, NULL, NULL);
  free (line);
  if (err)
    return err;

  if (pattern && *pattern)
    {
      const char **pat = pattern;

      while (*pat)
	{
	  const char *patlet = *pat;

	  while (*patlet)
	    {
	      length++;
	      if (*patlet == '%' || *patlet == ' ' || *patlet == '+')
		length += 2;
	      patlet++;
	    }
	  pat++;
	  /* This will allocate one byte more than necessary.  */
	  length++;
	}
    }
  line = xtrymalloc (length);
  if (!line)
    return mk_error (Out_Of_Core);
  if (secret_only)
    {
      strcpy (line, "LISTSECRETKEYS ");
      linep = &line[15];
    }
  else
    {
      strcpy (line, "LISTKEYS ");
      linep = &line[9];
    }

  if (pattern && *pattern)
    {
      while (*pattern)
	{
	  const char *patlet = *pattern;

	  while (*patlet)
	    {
	      switch (*patlet)
		{
		case '%':
		  *(linep++) = '%';
		  *(linep++) = '2';
		  *(linep++) = '5';
		  break;
		case ' ':
		  *(linep++) = '%';
		  *(linep++) = '2';
		  *(linep++) = '0';
		  break;
		case '+':
		  *(linep++) = '%';
		  *(linep++) = '2';
		  *(linep++) = 'B';
		  break;
		default:
		  *(linep++) = *patlet;
		  break;
		}
	      patlet++;
	    }
	  pattern++;
	}
    }
  *linep = '\0';

  _gpgme_io_close (gpgsm->input_cb.fd);
  _gpgme_io_close (gpgsm->output_cb.fd);
  _gpgme_io_close (gpgsm->message_cb.fd);

  gpgsm->command = line;
  return 0;
}


GpgmeError
_gpgme_gpgsm_op_sign (GpgsmObject gpgsm, GpgmeData in, GpgmeData out,
		      GpgmeSigMode mode, int use_armor,
		      int use_textmode, int include_certs,
		      GpgmeCtx ctx /* FIXME */)
{
  GpgmeError err;
  char *assuan_cmd;

  if (!gpgsm)
    return mk_error (Invalid_Value);

  gpgsm->command = xtrystrdup (mode == GPGME_SIG_MODE_DETACH
			       ? "SIGN --detached" : "SIGN");
  if (!gpgsm->command)
    return mk_error (Out_Of_Core);

  if (asprintf (&assuan_cmd, "OPTION include-certs %i", include_certs) < 0)
    return mk_error (Out_Of_Core);
  err = gpgsm_assuan_simple_command (gpgsm->assuan_ctx, assuan_cmd, NULL, NULL);
  free (assuan_cmd);
  if (err)
    return err;

  gpgsm->input_cb.data = in;
  err = gpgsm_set_fd (gpgsm->assuan_ctx, "INPUT", gpgsm->input_fd_server,
                      map_input_enc (gpgsm->input_cb.data));
  if (err)
    return err;
  gpgsm->output_cb.data = out;
  err = gpgsm_set_fd (gpgsm->assuan_ctx, "OUTPUT", gpgsm->output_fd_server,
		      use_armor ? "--armor" : 0);
  if (err)
    return err;
  _gpgme_io_close (gpgsm->message_cb.fd);

  return 0;
}


GpgmeError
_gpgme_gpgsm_op_trustlist (GpgsmObject gpgsm, const char *pattern)
{
  /* FIXME */
  return mk_error (Not_Implemented);
}


GpgmeError
_gpgme_gpgsm_op_verify (GpgsmObject gpgsm, GpgmeData sig, GpgmeData text)
{
  GpgmeError err;

  if (!gpgsm)
    return mk_error (Invalid_Value);

  gpgsm->command = xtrystrdup ("VERIFY");
  if (!gpgsm->command)
    return mk_error (Out_Of_Core);

  gpgsm->input_cb.data = sig;
  err = gpgsm_set_fd (gpgsm->assuan_ctx, "INPUT", gpgsm->input_fd_server,
                      map_input_enc (gpgsm->input_cb.data));
  if (err)
    return err;
  if (_gpgme_data_get_mode (text) == GPGME_DATA_MODE_IN)
    {
      /* Normal or cleartext signature.  */
      gpgsm->output_cb.data = text;
      err = gpgsm_set_fd (gpgsm->assuan_ctx, "OUTPUT", gpgsm->output_fd_server,
			  0);
      _gpgme_io_close (gpgsm->message_cb.fd);
    }
  else
    {
      /* Detached signature.  */
      gpgsm->message_cb.data = text;
      err = gpgsm_set_fd (gpgsm->assuan_ctx, "MESSAGE",
			  gpgsm->message_fd_server, 0);
      _gpgme_io_close (gpgsm->output_cb.fd);
    }
  if (err)
    return err;

  return 0;
}


static int
status_cmp (const void *ap, const void *bp)
{
  const struct status_table_s *a = ap;
  const struct status_table_s *b = bp;

  return strcmp (a->name, b->name);
}


static GpgStatusCode
parse_status (const char *name)
{
  struct status_table_s t, *r;
  t.name = name;
  r = bsearch (&t, status_table, DIM(status_table) - 1,
	       sizeof t, status_cmp);
  return r ? r->code : -1;
}


static void
gpgsm_status_handler (void *opaque, int fd)
{
  AssuanError err;
  GpgsmObject gpgsm = opaque;
  char *line;
  size_t linelen;

  do
    {
      err = assuan_read_line (gpgsm->assuan_ctx, &line, &linelen);

      if (err
          || (linelen >= 2
              && line[0] == 'O' && line[1] == 'K'
              && (line[2] == '\0' || line[2] == ' '))
	  || (linelen >= 3
	      && line[0] == 'E' && line[1] == 'R' && line[2] == 'R'
	      && (line[3] == '\0' || line[3] == ' ')))
	{
	  /* XXX: If an error occured, find out what happened, then
	     save the error value before running the status handler
	     (so it takes precedence).  */
	  if (!err && line[0] == 'E' && line[3] == ' ')
	    {
	      err = map_assuan_error (atoi (&line[4]));
	      if (!err)
		err = mk_error (General_Error);
	    }
	  if (err)
	    {
	      /* XXX Kludge ahead.  We really, really, really must not
		 make use of status.fnc_value.  */
	      GpgmeCtx ctx = (GpgmeCtx) gpgsm->status.fnc_value;
	      if (!ctx->error)
		ctx->error = err;
	    }

	  if (gpgsm->status.fnc)
	    gpgsm->status.fnc (gpgsm->status.fnc_value, STATUS_EOF, "");

	  /* XXX: Try our best to terminate the connection.  */
	  if (err)
	    assuan_write_line (gpgsm->assuan_ctx, "BYE");

	  _gpgme_io_close (gpgsm->status_cb.fd);
	  return;
	}

      if (linelen > 2
	  && line[0] == 'D' && line[1] == ' '
          && gpgsm->colon.fnc)
        {
	  /* We are using the colon handler even for plain inline data
             - strange name for that function but for historic reasons
             we keep it.  */
          /* FIXME We can't use this for binary data because we
             assume this is a string.  For the current usage of colon
             output it is correct.  */
          unsigned char *src = line + 2;
	  unsigned char *end = line + linelen;
	  unsigned char *dst;
          unsigned char **aline = &gpgsm->colon.attic.line;
	  int *alinelen = &gpgsm->colon.attic.linelen;

	  if (gpgsm->colon.attic.linesize
	      < *alinelen + linelen + 1)
	    {
	      unsigned char *newline = xtryrealloc (*aline,
						    *alinelen + linelen + 1);
	      if (!newline)
		{
		  _gpgme_io_close (gpgsm->status_cb.fd);
		  return;
		}
	      *aline = newline;
	      gpgsm->colon.attic.linesize += linelen + 1;
	    }

	  dst = *aline + *alinelen;

          while (src < end)
            {
              if (*src == '%' && src + 2 < end)
                {
		  /* Handle escaped characters.  */
		  ++src;
                  *dst = xtoi_2 (src);
		  (*alinelen)++;
                  src += 2;
                }
              else
		{
		  *dst = *src++;
		  (*alinelen)++;
		}

	      if (*dst == '\n')
		{
		  /* Terminate the pending line, pass it to the colon
		     handler and reset it.  */

		  if (*alinelen > 1 && *(dst - 1) == '\r')
		    dst--;
		  *dst = '\0';

		  /* FIXME How should we handle the return code? */
		  gpgsm->colon.fnc (gpgsm->colon.fnc_value, *aline);
		  dst = *aline;
		  *alinelen = 0;
		}
	      else
		dst++;
            }
        }
      else if (linelen > 2
	  && line[0] == 'S' && line[1] == ' ')
	{
	  char *rest;
	  GpgStatusCode r;

	  rest = strchr (line + 2, ' ');
	  if (!rest)
	    rest = line + linelen; /* set to an empty string */
	  else
	    *(rest++) = 0;

	  r = parse_status (line + 2);

	  if (r >= 0)
	    {
	      if (gpgsm->status.fnc)
		gpgsm->status.fnc (gpgsm->status.fnc_value, r, rest);
	    }
	  else
	    fprintf (stderr, "[UNKNOWN STATUS]%s %s", line + 2, rest);
	}
    }
  while (assuan_pending_line (gpgsm->assuan_ctx));
}


void
_gpgme_gpgsm_set_status_handler (GpgsmObject gpgsm,
				 GpgStatusHandler fnc, void *fnc_value) 
{
  assert (gpgsm);

  gpgsm->status.fnc = fnc;
  gpgsm->status.fnc_value = fnc_value;
}


void
_gpgme_gpgsm_set_colon_line_handler (GpgsmObject gpgsm,
                                     GpgColonLineHandler fnc, void *fnc_value) 
{
  assert (gpgsm);

  gpgsm->colon.fnc = fnc;
  gpgsm->colon.fnc_value = fnc_value;
}


static GpgmeError
_gpgme_gpgsm_add_io_cb (GpgsmObject gpgsm, iocb_data_t *iocbd,
			GpgmeIOCb handler)
{
  GpgmeError err;

  err = (*gpgsm->io_cbs.add) (gpgsm->io_cbs.add_priv,
			      iocbd->fd, iocbd->dir,
			      handler, iocbd->data, &iocbd->tag);
  if (err)
    return err;
  if (!iocbd->dir)
    /* FIXME Kludge around poll() problem.  */
    err = _gpgme_io_set_nonblocking (iocbd->fd);
  return err;
}

GpgmeError
_gpgme_gpgsm_start (GpgsmObject gpgsm, void *opaque)
{
  GpgmeError err = 0;
  pid_t pid;

  if (!gpgsm)
    return mk_error (Invalid_Value);

  pid = assuan_get_pid (gpgsm->assuan_ctx);

  err = _gpgme_gpgsm_add_io_cb (gpgsm, &gpgsm->status_cb,
				gpgsm_status_handler);
  if (gpgsm->input_cb.fd != -1)
    err = _gpgme_gpgsm_add_io_cb (gpgsm, &gpgsm->input_cb,
				  _gpgme_data_outbound_handler);
  if (!err && gpgsm->output_cb.fd != -1)
    err = _gpgme_gpgsm_add_io_cb (gpgsm, &gpgsm->output_cb,
				  _gpgme_data_inbound_handler);
  if (!err && gpgsm->message_cb.fd != -1)
    err = _gpgme_gpgsm_add_io_cb (gpgsm, &gpgsm->message_cb,
				  _gpgme_data_outbound_handler);

  if (!err)
    err = assuan_write_line (gpgsm->assuan_ctx, gpgsm->command);

  return err;
}

void
_gpgme_gpgsm_set_io_cbs (GpgsmObject gpgsm, struct GpgmeIOCbs *io_cbs)
{
  gpgsm->io_cbs = *io_cbs;
}

void
_gpgme_gpgsm_io_event (GpgsmObject gpgsm, GpgmeEventIO type, void *type_data)
{
  if (gpgsm->io_cbs.event)
    (*gpgsm->io_cbs.event) (gpgsm->io_cbs.event_priv, type, type_data);
}

#else	/* ENABLE_GPGSM */


#include <stddef.h>
#include "util.h"

#include "engine-gpgsm.h"


const char *
_gpgme_gpgsm_get_version (void)
{
  return NULL;
}


GpgmeError
_gpgme_gpgsm_check_version (void)
{
  return mk_error (Invalid_Engine);
}


GpgmeError
_gpgme_gpgsm_new (GpgsmObject *r_gpgsm)
{
  return mk_error (Invalid_Engine);
}


void
_gpgme_gpgsm_release (GpgsmObject gpgsm)
{
  return;
}


void
_gpgme_gpgsm_set_status_handler (GpgsmObject gpgsm,
				 GpgStatusHandler fnc, void *fnc_value) 
{
  return;
}


GpgmeError
_gpgme_gpgsm_op_decrypt (GpgsmObject gpgsm, GpgmeData ciph, GpgmeData plain)
{
  return mk_error (Invalid_Engine);
}


GpgmeError
_gpgme_gpgsm_op_delete (GpgsmObject gpgsm, GpgmeKey key, int allow_secret)
{
  return mk_error (Invalid_Engine);
}


GpgmeError
_gpgme_gpgsm_op_encrypt (GpgsmObject gpgsm, GpgmeRecipients recp,
			 GpgmeData plain, GpgmeData ciph, int use_armor)
{
  return mk_error (Invalid_Engine);
}


GpgmeError
_gpgme_gpgsm_op_export (GpgsmObject gpgsm, GpgmeRecipients recp,
			GpgmeData keydata, int use_armor)
{
  return mk_error (Invalid_Engine);
}


GpgmeError
_gpgme_gpgsm_op_genkey (GpgsmObject gpgsm, GpgmeData help_data, int use_armor,
			GpgmeData pubkey, GpgmeData seckey)
{
  return mk_error (Invalid_Engine);
}
  

GpgmeError
_gpgme_gpgsm_op_import (GpgsmObject gpgsm, GpgmeData keydata)
{
  return mk_error (Invalid_Engine);
}


GpgmeError
_gpgme_gpgsm_op_keylist (GpgsmObject gpgsm, const char *pattern,
			 int secret_only, int keylist_mode)
{
  return mk_error (Invalid_Engine);
}


GpgmeError
_gpgme_gpgsm_op_keylist_ext (GpgsmObject gpgsm, const char *pattern[],
			     int secret_only, int reserved, int keylist_mode)
{
  return mk_error (Invalid_Engine);
}

GpgmeError
_gpgme_gpgsm_op_sign (GpgsmObject gpgsm, GpgmeData in, GpgmeData out,
		      GpgmeSigMode mode, int use_armor,
		      int use_textmode, int include_certs,
		      GpgmeCtx ctx /* FIXME */)
{
  return mk_error (Invalid_Engine);
}


GpgmeError
_gpgme_gpgsm_op_trustlist (GpgsmObject gpgsm, const char *pattern)
{
  return mk_error (Invalid_Engine);
}


GpgmeError
_gpgme_gpgsm_op_verify (GpgsmObject gpgsm, GpgmeData sig, GpgmeData text)
{
  return mk_error (Invalid_Engine);
}


void
_gpgme_gpgsm_set_colon_line_handler (GpgsmObject gpgsm,
                                     GpgColonLineHandler fnc, void *fnc_value) 
{
}


GpgmeError
_gpgme_gpgsm_start (GpgsmObject gpgsm, void *opaque)
{
  return mk_error (Invalid_Engine);
}

void
_gpgme_gpgsm_set_io_cbs (GpgsmObject gpgsm, struct GpgmeIOCbs *io_cbs)
{
}

void
_gpgme_gpgsm_io_event (GpgsmObject gpgsm, GpgmeEventIO type, void *type_data)
{
}

#endif	/* ! ENABLE_GPGSM */