/* engine-gpg.c - Gpg Engine.

 * Copyright (C) 2000 Werner Koch (dd9jn)

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

 *               2009, 2010, 2012, 2013 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 <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <assert.h>

#ifdef HAVE_UNISTD_H

# include <unistd.h>

#endif

#ifdef HAVE_LOCALE_H

#include <locale.h>

#endif

#include "gpgme.h"

#include "util.h"

#include "ops.h"

#include "wait.h"

#include "context.h"  /*temp hack until we have GpmeData methods to do I/O */

#include "priv-io.h"

#include "sema.h"

#include "debug.h"

#include "data.h"

#include "mbox-util.h"

#include "engine-backend.h"

/* This type is used to build a list of gpg arguments and data

   sources/sinks.  */

struct arg_and_data_s

{

  struct arg_and_data_s *next;

  gpgme_data_t data;  /* If this is not NULL, use arg below.  */

  int inbound;     /* True if this is used for reading from gpg.  */

  int dup_to;

  int print_fd;    /* Print the fd number and not the special form of it.  */

  int *arg_locp;   /* Write back the argv idx of this argument when

		      building command line to this location.  */

  char arg[1];     /* Used if data above is not used.  */

};

struct fd_data_map_s

{

  gpgme_data_t data;

  int inbound;  /* true if this is used for reading from gpg */

  int dup_to;

  int fd;       /* the fd to use */

  int peer_fd;  /* the other side of the pipe */

  int arg_loc;  /* The index into the argv for translation purposes.  */

  void *tag;

};

/* NB.: R_LINE is allocated an gpgrt function and thus gpgrt_free

 * shall be used to release it.  This takes care of custom memory

 * allocators and avoids problems on Windows with different runtimes

 * used for libgpg-error/gpgrt and gpgme.  */

typedef gpgme_error_t (*colon_preprocessor_t) (char *line, char **rline);

struct engine_gpg

{

  char *file_name;

  char *version;

  char *lc_messages;

  char *lc_ctype;

  struct arg_and_data_s *arglist;

  struct arg_and_data_s **argtail;

  struct

  {

    int fd[2];

    int arg_loc;

    size_t bufsize;

    char *buffer;

    size_t readpos;

    int eof;

    engine_status_handler_t fnc;

    void *fnc_value;

    gpgme_status_cb_t mon_cb;

    void *mon_cb_value;

    void *tag;

  } status;

  /* This is a kludge - see the comment at colon_line_handler.  */

  struct

  {

    int fd[2];

    int arg_loc;

    size_t bufsize;

    char *buffer;

    size_t readpos;

    int eof;

    engine_colon_line_handler_t fnc;  /* this indicate use of this structrue */

    void *fnc_value;

    void *tag;

    colon_preprocessor_t preprocess_fnc;

  } colon;

  char **argv;

  struct fd_data_map_s *fd_data_map;

  /* stuff needed for interactive (command) mode */

  struct

  {

    int used;

    int fd;

    void *cb_data;

    int idx;		/* Index in fd_data_map */

    gpgme_status_code_t code;  /* last code */

    char *keyword;       /* what has been requested (malloced) */

    engine_command_handler_t fnc;

    void *fnc_value;

  } cmd;

  struct gpgme_io_cbs io_cbs;

  gpgme_pinentry_mode_t pinentry_mode;

  char request_origin[10];

  char *auto_key_locate;

  char *trust_model;

  struct {

    unsigned int no_symkey_cache : 1;

    unsigned int offline : 1;

    unsigned int ignore_mdc_error : 1;

  } flags;

  /* NULL or the data object fed to --override_session_key-fd.  */

  gpgme_data_t override_session_key;

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

  gpgme_data_t diagnostics;

};

typedef struct engine_gpg *engine_gpg_t;

static void

gpg_io_event (void *engine, gpgme_event_io_t type, void *type_data)

{

  engine_gpg_t gpg = engine;

  TRACE (DEBUG_ENGINE, "gpgme:gpg_io_event", gpg,

          "event %p, type %d, type_data %p",

          gpg->io_cbs.event, type, type_data);

  if (gpg->io_cbs.event)

    (*gpg->io_cbs.event) (gpg->io_cbs.event_priv, type, type_data);

}

static void

close_notify_handler (int fd, void *opaque)

{

  engine_gpg_t gpg = opaque;

  assert (fd != -1);

  if (gpg->status.fd[0] == fd)

    {

      if (gpg->status.tag)

	(*gpg->io_cbs.remove) (gpg->status.tag);

      gpg->status.fd[0] = -1;

    }

  else if (gpg->status.fd[1] == fd)

    gpg->status.fd[1] = -1;

  else if (gpg->colon.fd[0] == fd)

    {

      if (gpg->colon.tag)

	(*gpg->io_cbs.remove) (gpg->colon.tag);

      gpg->colon.fd[0] = -1;

    }

  else if (gpg->colon.fd[1] == fd)

    gpg->colon.fd[1] = -1;

  else if (gpg->cmd.fd == fd)

    gpg->cmd.fd = -1;

  else if (gpg->fd_data_map)

    {

      int i;

      for (i = 0; gpg->fd_data_map[i].data; i++)

	{

	  if (gpg->fd_data_map[i].fd == fd)

	    {

	      if (gpg->fd_data_map[i].tag)

		(*gpg->io_cbs.remove) (gpg->fd_data_map[i].tag);

	      gpg->fd_data_map[i].fd = -1;

	      break;

            }

	  if (gpg->fd_data_map[i].peer_fd == fd)

	    {

	      gpg->fd_data_map[i].peer_fd = -1;

	      break;

            }

        }

    }

}

/* If FRONT is true, push at the front of the list.  Use this for

   options added late in the process.  */

static gpgme_error_t

_add_arg (engine_gpg_t gpg, const char *prefix, const char *arg, size_t arglen,

          int front, int *arg_locp)

{

  struct arg_and_data_s *a;

  size_t prefixlen = prefix? strlen (prefix) : 0;

  assert (gpg);

  assert (arg);

  a = malloc (sizeof *a + prefixlen + arglen);

  if (!a)

    return gpg_error_from_syserror ();

  a->data = NULL;

  a->dup_to = -1;

  a->arg_locp = arg_locp;

  if (prefixlen)

    memcpy (a->arg, prefix, prefixlen);

  memcpy (a->arg + prefixlen, arg, arglen);

  a->arg[prefixlen + arglen] = 0;

  if (front)

    {

      a->next = gpg->arglist;

      if (!gpg->arglist)

	{

	  /* If this is the first argument, we need to update the tail

	     pointer.  */

	  gpg->argtail = &a->next;

	}

      gpg->arglist = a;

    }

  else

    {

      a->next = NULL;

      *gpg->argtail = a;

      gpg->argtail = &a->next;

    }

  return 0;

}

static gpgme_error_t

add_arg_ext (engine_gpg_t gpg, const char *arg, int front)

{

  return _add_arg (gpg, NULL, arg, strlen (arg), front, NULL);

}

static gpgme_error_t

add_arg_with_locp (engine_gpg_t gpg, const char *arg, int *locp)

{

  return _add_arg (gpg, NULL, arg, strlen (arg), 0, locp);

}

static gpgme_error_t

add_arg (engine_gpg_t gpg, const char *arg)

{

  return _add_arg (gpg, NULL, arg, strlen (arg), 0, NULL);

}

static gpgme_error_t

add_arg_pfx (engine_gpg_t gpg, const char *prefix, const char *arg)

{

  return _add_arg (gpg, prefix, arg, strlen (arg), 0, NULL);

}

static gpgme_error_t

add_arg_len (engine_gpg_t gpg, const char *prefix,

             const char *arg, size_t arglen)

{

  return _add_arg (gpg, prefix, arg, arglen, 0, NULL);

}

static gpgme_error_t

add_data (engine_gpg_t gpg, gpgme_data_t data, int dup_to, int inbound)

{

  struct arg_and_data_s *a;

  assert (gpg);

  assert (data);

  a = malloc (sizeof *a - 1);

  if (!a)

    return gpg_error_from_syserror ();

  a->next = NULL;

  a->data = data;

  a->inbound = inbound;

  a->arg_locp = NULL;

  if (dup_to == -2)

    {

      a->print_fd = 1;

      a->dup_to = -1;

    }

  else

    {

      a->print_fd = 0;

      a->dup_to = dup_to;

    }

  *gpg->argtail = a;

  gpg->argtail = &a->next;

  return 0;

}

/* Return true if the engine's version is at least VERSION.  */

static int

have_gpg_version (engine_gpg_t gpg, const char *version)

{

  return _gpgme_compare_versions (gpg->version, version);

}

static char *

gpg_get_version (const char *file_name)

{

  return _gpgme_get_program_version (file_name ? file_name

				     : _gpgme_get_default_gpg_name ());

}

static const char *

gpg_get_req_version (void)

{

  return "1.4.0";

}

static void

free_argv (char **argv)

{

  int i;

  for (i = 0; argv[i]; i++)

    free (argv[i]);

  free (argv);

}

static void

free_fd_data_map (struct fd_data_map_s *fd_data_map)

{

  int i;

  if (!fd_data_map)

    return;

  for (i = 0; fd_data_map[i].data; i++)

    {

      if (fd_data_map[i].fd != -1)

	_gpgme_io_close (fd_data_map[i].fd);

      if (fd_data_map[i].peer_fd != -1)

	_gpgme_io_close (fd_data_map[i].peer_fd);

      /* Don't release data because this is only a reference.  */

    }

  free (fd_data_map);

}

static gpgme_error_t

gpg_cancel (void *engine)

{

  engine_gpg_t gpg = engine;

  if (!gpg)

    return gpg_error (GPG_ERR_INV_VALUE);

  /* If gpg may be waiting for a cmd, close the cmd fd first.  On

     Windows, close operations block on the reader/writer thread.  */

  if (gpg->cmd.used)

    {

      if (gpg->cmd.fd != -1)

	_gpgme_io_close (gpg->cmd.fd);

      else if (gpg->fd_data_map

	       && gpg->fd_data_map[gpg->cmd.idx].fd != -1)

	_gpgme_io_close (gpg->fd_data_map[gpg->cmd.idx].fd);

    }

  if (gpg->status.fd[0] != -1)

    _gpgme_io_close (gpg->status.fd[0]);

  if (gpg->status.fd[1] != -1)

    _gpgme_io_close (gpg->status.fd[1]);

  if (gpg->colon.fd[0] != -1)

    _gpgme_io_close (gpg->colon.fd[0]);

  if (gpg->colon.fd[1] != -1)

    _gpgme_io_close (gpg->colon.fd[1]);

  if (gpg->fd_data_map)

    {

      free_fd_data_map (gpg->fd_data_map);

      gpg->fd_data_map = NULL;

    }

  return 0;

}

static void

gpg_release (void *engine)

{

  engine_gpg_t gpg = engine;

  if (!gpg)

    return;

  gpg_cancel (engine);

  if (gpg->file_name)

    free (gpg->file_name);

  if (gpg->version)

    free (gpg->version);

  if (gpg->lc_messages)

    free (gpg->lc_messages);

  if (gpg->lc_ctype)

    free (gpg->lc_ctype);

  while (gpg->arglist)

    {

      struct arg_and_data_s *next = gpg->arglist->next;

      free (gpg->arglist);

      gpg->arglist = next;

    }

  if (gpg->status.buffer)

    free (gpg->status.buffer);

  if (gpg->colon.buffer)

    free (gpg->colon.buffer);

  if (gpg->argv)

    free_argv (gpg->argv);

  if (gpg->cmd.keyword)

    free (gpg->cmd.keyword);

  free (gpg->auto_key_locate);

  free (gpg->trust_model);

  gpgme_data_release (gpg->override_session_key);

  gpgme_data_release (gpg->diagnostics);

  free (gpg);

}

static gpgme_error_t

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

         const char *version)

{

  engine_gpg_t gpg;

  gpgme_error_t rc = 0;

  char *dft_display = NULL;

  char dft_ttyname[64];

  char *dft_ttytype = NULL;

  char *env_tty = NULL;

  gpg = calloc (1, sizeof *gpg);

  if (!gpg)

    return gpg_error_from_syserror ();

  if (file_name)

    {

      gpg->file_name = strdup (file_name);

      if (!gpg->file_name)

	{

	  rc = gpg_error_from_syserror ();

	  goto leave;

	}

    }

  if (version)

    {

      gpg->version = strdup (version);

      if (!gpg->version)

	{

	  rc = gpg_error_from_syserror ();

	  goto leave;

	}

    }

  gpg->argtail = &gpg->arglist;

  gpg->status.fd[0] = -1;

  gpg->status.fd[1] = -1;

  gpg->colon.fd[0] = -1;

  gpg->colon.fd[1] = -1;

  gpg->cmd.fd = -1;

  gpg->cmd.idx = -1;

  /* Allocate the read buffer for the status pipe.  */

  gpg->status.bufsize = 1024;

  gpg->status.readpos = 0;

  gpg->status.buffer = malloc (gpg->status.bufsize);

  if (!gpg->status.buffer)

    {

      rc = gpg_error_from_syserror ();

      goto leave;

    }

  /* In any case we need a status pipe - create it right here and

     don't handle it with our generic gpgme_data_t mechanism.  */

  if (_gpgme_io_pipe (gpg->status.fd, 1) == -1)

    {

      rc = gpg_error_from_syserror ();

      goto leave;

    }

  if (_gpgme_io_set_close_notify (gpg->status.fd[0],

				  close_notify_handler, gpg)

      || _gpgme_io_set_close_notify (gpg->status.fd[1],

				     close_notify_handler, gpg))

    {

      rc = gpg_error (GPG_ERR_GENERAL);

      goto leave;

    }

  gpg->status.eof = 0;

  if (home_dir)

    {

      rc = add_arg (gpg, "--homedir");

      if (!rc)

	rc = add_arg (gpg, home_dir);

      if (rc)

	goto leave;

    }

  rc = add_arg (gpg, "--status-fd");

  if (rc)

    goto leave;

  {

    char buf[25];

    _gpgme_io_fd2str (buf, sizeof (buf), gpg->status.fd[1]);

    rc = add_arg_with_locp (gpg, buf, &gpg->status.arg_loc);

    if (rc)

      goto leave;

  }

  rc = add_arg (gpg, "--no-tty");

  if (!rc)

    rc = add_arg (gpg, "--charset");

  if (!rc)

    rc = add_arg (gpg, "utf8");

  if (!rc)

    rc = add_arg (gpg, "--enable-progress-filter");

  if (!rc && have_gpg_version (gpg, "2.1.11"))

    rc = add_arg (gpg, "--exit-on-status-write-error");

  if (rc)

    goto leave;

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

  if (rc)

    goto leave;

  if (dft_display)

    {

      rc = add_arg (gpg, "--display");

      if (!rc)

	rc = add_arg (gpg, dft_display);

      free (dft_display);

      if (rc)

	goto leave;

    }

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

  if (isatty (1) || env_tty || rc)

    {

      int err = 0;

      if (rc)

        goto leave;

      else if (env_tty)

        {

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

          free (env_tty);

        }

      else

        err = 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 (!err)

	{

          if (*dft_ttyname)

            {

              rc = add_arg (gpg, "--ttyname");

              if (!rc)

                rc = add_arg (gpg, dft_ttyname);

            }

          else

            rc = 0;

          if (!rc)

	    {

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

	      if (rc)

		goto leave;

              if (dft_ttytype)

                {

                  rc = add_arg (gpg, "--ttytype");

                  if (!rc)

                    rc = add_arg (gpg, dft_ttytype);

                }

	      free (dft_ttytype);

	    }

	  if (rc)

	    goto leave;

	}

    }

  rc = gpgme_data_new (&gpg->diagnostics);

  if (rc)

    goto leave;

  rc = add_arg (gpg, "--logger-fd");

  if (rc)

    goto leave;

  rc = add_data (gpg, gpg->diagnostics, -2, 1);

 leave:

  if (rc)

    gpg_release (gpg);

  else

    *engine = gpg;

  return rc;

}

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

static void

gpg_set_engine_flags (void *engine, const gpgme_ctx_t ctx)

{

  engine_gpg_t gpg = engine;

  if (ctx->request_origin && have_gpg_version (gpg, "2.2.6"))

    {

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

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

      else

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

    }

  else

    *gpg->request_origin = 0;

  if (ctx->auto_key_locate && have_gpg_version (gpg, "2.1.18"))

    {

      if (gpg->auto_key_locate)

        free (gpg->auto_key_locate);

      gpg->auto_key_locate = _gpgme_strconcat ("--auto-key-locate=",

                                               ctx->auto_key_locate, NULL);

    }

  if (ctx->trust_model && strlen (ctx->trust_model))

    {

      if (gpg->trust_model)

        free (gpg->trust_model);

      gpg->trust_model = _gpgme_strconcat ("--trust-model=",

                                           ctx->trust_model, NULL);

    }

  gpg->flags.no_symkey_cache = (ctx->no_symkey_cache

                                && have_gpg_version (gpg, "2.2.7"));

  gpg->flags.offline = (ctx->offline && have_gpg_version (gpg, "2.1.23"));

  gpg->flags.ignore_mdc_error = !!ctx->ignore_mdc_error;

}

static gpgme_error_t

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

{

  engine_gpg_t gpg = engine;

  if (0)

    ;

#ifdef LC_CTYPE

  else if (category == LC_CTYPE)

    {

      if (gpg->lc_ctype)

        {

          free (gpg->lc_ctype);

          gpg->lc_ctype = NULL;

        }

      if (value)

	{

	  gpg->lc_ctype = strdup (value);

	  if (!gpg->lc_ctype)

	    return gpg_error_from_syserror ();

	}

    }

#endif

#ifdef LC_MESSAGES

  else if (category == LC_MESSAGES)

    {

      if (gpg->lc_messages)

        {

          free (gpg->lc_messages);

          gpg->lc_messages = NULL;

        }

      if (value)

	{

	  gpg->lc_messages = strdup (value);

	  if (!gpg->lc_messages)

	    return gpg_error_from_syserror ();

	}

    }

#endif /* LC_MESSAGES */

  else

    return gpg_error (GPG_ERR_INV_VALUE);

  return 0;

}

/* This sets a status callback for monitoring status lines before they

 * are passed to a caller set handler.  */

static void

gpg_set_status_cb (void *engine, gpgme_status_cb_t cb, void *cb_value)

{

  engine_gpg_t gpg = engine;

  gpg->status.mon_cb = cb;

  gpg->status.mon_cb_value = cb_value;

}

/* Note, that the status_handler is allowed to modify the args

   value.  */

static void

gpg_set_status_handler (void *engine, engine_status_handler_t fnc,

			void *fnc_value)

{

  engine_gpg_t gpg = engine;

  gpg->status.fnc = fnc;

  gpg->status.fnc_value = fnc_value;

}

/* Kludge to process --with-colon output.  */

static gpgme_error_t

gpg_set_colon_line_handler (void *engine, engine_colon_line_handler_t fnc,

			    void *fnc_value)

{

  engine_gpg_t gpg = engine;

  gpg->colon.bufsize = 1024;

  gpg->colon.readpos = 0;

  gpg->colon.buffer = malloc (gpg->colon.bufsize);

  if (!gpg->colon.buffer)

    return gpg_error_from_syserror ();

  if (_gpgme_io_pipe (gpg->colon.fd, 1) == -1)

    {

      int saved_err = gpg_error_from_syserror ();

      free (gpg->colon.buffer);

      gpg->colon.buffer = NULL;

      return saved_err;

    }

  if (_gpgme_io_set_close_notify (gpg->colon.fd[0], close_notify_handler, gpg)

      || _gpgme_io_set_close_notify (gpg->colon.fd[1],

				     close_notify_handler, gpg))

    return gpg_error (GPG_ERR_GENERAL);

  gpg->colon.eof = 0;

  gpg->colon.fnc = fnc;

  gpg->colon.fnc_value = fnc_value;

  return 0;

}

static gpgme_error_t

command_handler (void *opaque, int fd)

{

  struct io_cb_data *data = (struct io_cb_data *) opaque;

  engine_gpg_t gpg = (engine_gpg_t) data->handler_value;

  gpgme_error_t err;

  int processed = 0;

  assert (gpg->cmd.used);

  assert (gpg->cmd.code);

  assert (gpg->cmd.fnc);

  err = gpg->cmd.fnc (gpg->cmd.fnc_value, gpg->cmd.code, gpg->cmd.keyword, fd,

		      &processed);

  gpg->cmd.code = 0;

  /* And sleep again until read_status will wake us up again.  */

  /* XXX We must check if there are any more fds active after removing

     this one.  */

  (*gpg->io_cbs.remove) (gpg->fd_data_map[gpg->cmd.idx].tag);

  gpg->cmd.fd = gpg->fd_data_map[gpg->cmd.idx].fd;

  gpg->fd_data_map[gpg->cmd.idx].fd = -1;

  if (err)

    return err;

  /* We always need to send at least a newline character.  */

  if (!processed)

    _gpgme_io_write (fd, "\n", 1);

  return 0;

}

/* The FNC will be called to get a value for one of the commands with

 * a key KEY.  If the code passed to FNC is 0, the function may

 * release resources associated with the returned value from another

 * call.  To match such a second call to a first call, the returned

 * value from the first call is passed as keyword.  */

static gpgme_error_t

gpg_set_command_handler (void *engine, engine_command_handler_t fnc,

			 void *fnc_value)

{

  engine_gpg_t gpg = engine;

  gpgme_error_t rc;

  rc = add_arg (gpg, "--command-fd");

  if (rc)

    return rc;

  /* This is a hack.  We don't have a real data object.  The only

     thing that matters is that we use something unique, so we use the

     address of the cmd structure in the gpg object.  */

  rc = add_data (gpg, (void *) &gpg->cmd, -2, 0);

  if (rc)

    return rc;

  gpg->cmd.fnc = fnc;

  gpg->cmd.cb_data = (void *) &gpg->cmd;

  gpg->cmd.fnc_value = fnc_value;

  gpg->cmd.used = 1;

  return 0;

}

static gpgme_error_t

build_argv (engine_gpg_t gpg, const char *pgmname)

{

  gpgme_error_t err;

  struct arg_and_data_s *a;

  struct fd_data_map_s *fd_data_map;

  size_t datac=0, argc=0;

  char **argv;

  int need_special = 0;

  int use_agent = 0;

  char *p;

  if (_gpgme_in_gpg_one_mode ())

    {

      /* In GnuPG-1 mode we don't want to use the agent with a

         malformed environment variable.  This is only a very basic

         test but sufficient to make our life in the regression tests

         easier.  With GnuPG-2 the agent is anyway required and on

         modern installations GPG_AGENT_INFO is optional.  */

      err = _gpgme_getenv ("GPG_AGENT_INFO", &p);

      if (err)

        return err;

      use_agent = (p && strchr (p, ':'));

      if (p)