/* encrypt-sign.c -  encrypt and verify functions

   Copyright (C) 2000 Werner Koch (dd9jn)

   Copyright (C) 2001, 2002, 2003, 2004 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, 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

#include <stdlib.h>

#include <string.h>

#include <errno.h>

#include "gpgme.h"

#include "debug.h"

#include "context.h"

#include "ops.h"

static gpgme_error_t

encrypt_sign_status_handler (void *priv, gpgme_status_code_t code, char *args)

{

  gpgme_error_t err;

  err = _gpgme_progress_status_handler (priv, code, args);

  if (!err)

    err = _gpgme_encrypt_status_handler (priv, code, args);

  if (!err)

    err = _gpgme_sign_status_handler (priv, code, args);

  return err;

}

static gpgme_error_t

encrypt_sym_status_handler (void *priv, gpgme_status_code_t code, char *args)

{

  gpgme_error_t err;

  err = _gpgme_progress_status_handler (priv, code, args);

  if (!err)

    err = _gpgme_sign_status_handler (priv, code, args);

  if (!err)

    err = _gpgme_passphrase_status_handler (priv, code, args);

  return err;

}

static gpgme_error_t

encrypt_sign_start (gpgme_ctx_t ctx, int synchronous, gpgme_key_t recp[],

		    gpgme_encrypt_flags_t flags,

		    gpgme_data_t plain, gpgme_data_t cipher)

{

  gpgme_error_t err;

  int symmetric;

  err = _gpgme_op_reset (ctx, synchronous);

  if (err)

    return err;

  symmetric = !recp || (flags & GPGME_ENCRYPT_SYMMETRIC);

  if (!plain)

    return gpg_error (GPG_ERR_NO_DATA);

  if (!cipher)

    return gpg_error (GPG_ERR_INV_VALUE);

  if (recp && !*recp)

    return gpg_error (GPG_ERR_INV_VALUE);

  err = _gpgme_op_encrypt_init_result (ctx);

  if (err)

    return err;

  err = _gpgme_op_sign_init_result (ctx);

  if (err)

    return err;

  if (ctx->passphrase_cb)

    {

      err = _gpgme_engine_set_command_handler

	(ctx->engine, _gpgme_passphrase_command_handler, ctx, NULL);

      if (err)

	return err;

    }

  _gpgme_engine_set_status_handler (ctx->engine,

                                    symmetric

                                    ? encrypt_sym_status_handler

                                    : encrypt_sign_status_handler,

				    ctx);

  return _gpgme_engine_op_encrypt_sign (ctx->engine, recp, flags, plain,

					cipher, ctx->use_armor,

					ctx /* FIXME */);

}

/* Encrypt plaintext PLAIN within CTX for the recipients RECP and

   store the resulting ciphertext in CIPHER.  Also sign the ciphertext

   with the signers in CTX.  */

gpgme_error_t

gpgme_op_encrypt_sign_start (gpgme_ctx_t ctx, gpgme_key_t recp[],

			     gpgme_encrypt_flags_t flags,

			     gpgme_data_t plain, gpgme_data_t cipher)

{

  gpgme_error_t err;

  TRACE_BEG3 (DEBUG_CTX, "gpgme_op_encrypt_sign_start", ctx,

	      "flags=0x%x, plain=%p, cipher=%p", flags, plain, cipher);

  if (!ctx)

    return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));

  if (_gpgme_debug_trace () && recp)

    {

      int i = 0;

      while (recp[i])

	{

	  TRACE_LOG3 ("recipient[%i] = %p (%s)", i, recp[i],

		      (recp[i]->subkeys && recp[i]->subkeys->fpr) ?

		      recp[i]->subkeys->fpr : "invalid");

	  i++;

	}

    }

  err = encrypt_sign_start (ctx, 0, recp, flags, plain, cipher);

  return err;

}

/* Encrypt plaintext PLAIN within CTX for the recipients RECP and

   store the resulting ciphertext in CIPHER.  Also sign the ciphertext

   with the signers in CTX.  */

gpgme_error_t

gpgme_op_encrypt_sign (gpgme_ctx_t ctx, gpgme_key_t recp[],

		       gpgme_encrypt_flags_t flags,

		       gpgme_data_t plain, gpgme_data_t cipher)

{

  gpgme_error_t err;

  TRACE_BEG3 (DEBUG_CTX, "gpgme_op_encrypt_sign", ctx,

	      "flags=0x%x, plain=%p, cipher=%p", flags, plain, cipher);

  if (!ctx)

    return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));

  if (_gpgme_debug_trace () && recp)

    {

      int i = 0;

      while (recp[i])

	{

	  TRACE_LOG3 ("recipient[%i] = %p (%s)", i, recp[i],

		      (recp[i]->subkeys && recp[i]->subkeys->fpr) ?

		      recp[i]->subkeys->fpr : "invalid");

	  i++;

	}

    }

  err = encrypt_sign_start (ctx, 1, recp, flags, plain, cipher);

  if (!err)

    err = _gpgme_wait_one (ctx);

  return TRACE_ERR (err);

}