g10: Add new delete operations that allow more flags.
[gpgme.git] / src / decrypt-verify.c
1 /* decrypt-verify.c - Decrypt and verify function.
2    Copyright (C) 2000 Werner Koch (dd9jn)
3    Copyright (C) 2001, 2002, 2003, 2004 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 <assert.h>
27
28 #include "debug.h"
29 #include "gpgme.h"
30 #include "ops.h"
31
32 \f
33 static gpgme_error_t
34 decrypt_verify_status_handler (void *priv, gpgme_status_code_t code,
35                                char *args)
36 {
37   gpgme_error_t err;
38
39   err = _gpgme_progress_status_handler (priv, code, args);
40   if (!err)
41     err = _gpgme_decrypt_status_handler (priv, code, args);
42   if (!err)
43       err = _gpgme_verify_status_handler (priv, code, args);
44   return err;
45 }
46
47
48 static gpgme_error_t
49 decrypt_verify_start (gpgme_ctx_t ctx, int synchronous,
50                       gpgme_decrypt_flags_t flags,
51                       gpgme_data_t cipher, gpgme_data_t plain)
52 {
53   gpgme_error_t err;
54
55   assert ((flags & GPGME_DECRYPT_VERIFY));
56
57   err = _gpgme_op_reset (ctx, synchronous);
58   if (err)
59     return err;
60
61   err = _gpgme_op_decrypt_init_result (ctx);
62   if (err)
63     return err;
64
65   err = _gpgme_op_verify_init_result (ctx);
66   if (err)
67     return err;
68
69   if (!cipher)
70     return gpg_error (GPG_ERR_NO_DATA);
71   if (!plain)
72     return gpg_error (GPG_ERR_INV_VALUE);
73
74   if (ctx->passphrase_cb)
75     {
76       err = _gpgme_engine_set_command_handler
77         (ctx->engine, _gpgme_passphrase_command_handler, ctx, NULL);
78       if (err)
79         return err;
80     }
81
82   _gpgme_engine_set_status_handler (ctx->engine,
83                                     decrypt_verify_status_handler, ctx);
84
85   return _gpgme_engine_op_decrypt (ctx->engine,
86                                    flags,
87                                    cipher, plain,
88                                    ctx->export_session_keys,
89                                    ctx->override_session_key);
90 }
91
92
93 /* Decrypt ciphertext CIPHER and make a signature verification within
94    CTX and store the resulting plaintext in PLAIN.  */
95 gpgme_error_t
96 gpgme_op_decrypt_verify_start (gpgme_ctx_t ctx, gpgme_data_t cipher,
97                                gpgme_data_t plain)
98 {
99   gpgme_error_t err;
100
101   TRACE_BEG2 (DEBUG_CTX, "gpgme_op_decrypt_verify_start", ctx,
102               "cipher=%p, plain=%p", cipher, plain);
103
104   if (!ctx)
105     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
106
107   err = decrypt_verify_start (ctx, 0, GPGME_DECRYPT_VERIFY, cipher, plain);
108   return TRACE_ERR (err);
109 }
110
111
112 /* Decrypt ciphertext CIPHER and make a signature verification within
113    CTX and store the resulting plaintext in PLAIN.  */
114 gpgme_error_t
115 gpgme_op_decrypt_verify (gpgme_ctx_t ctx, gpgme_data_t cipher,
116                          gpgme_data_t plain)
117 {
118   gpgme_error_t err;
119
120   TRACE_BEG2 (DEBUG_CTX, "gpgme_op_decrypt_verify", ctx,
121               "cipher=%p, plain=%p", cipher, plain);
122
123   if (!ctx)
124     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
125
126   err = decrypt_verify_start (ctx, 1, GPGME_DECRYPT_VERIFY, cipher, plain);
127   if (!err)
128     err = _gpgme_wait_one (ctx);
129   return TRACE_ERR (err);
130 }
131
132
133 /* Decrypt ciphertext CIPHER within CTX and store the resulting
134    plaintext in PLAIN.  */
135 gpgme_error_t
136 gpgme_op_decrypt_ext_start (gpgme_ctx_t ctx,
137                             gpgme_decrypt_flags_t flags,
138                             gpgme_data_t cipher,
139                             gpgme_data_t plain)
140 {
141   gpgme_error_t err;
142
143   TRACE_BEG2 (DEBUG_CTX, "gpgme_op_decrypt_ext_start", ctx,
144               "cipher=%p, plain=%p", cipher, plain);
145
146   if (!ctx)
147     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
148
149   if ((flags & GPGME_DECRYPT_VERIFY))
150     err = decrypt_verify_start (ctx, 0, flags, cipher, plain);
151   else
152     err = _gpgme_decrypt_start (ctx, 0, flags, cipher, plain);
153   return TRACE_ERR (err);
154 }
155
156
157 /* Decrypt ciphertext CIPHER within CTX and store the resulting
158    plaintext in PLAIN.  */
159 gpgme_error_t
160 gpgme_op_decrypt_ext (gpgme_ctx_t ctx,
161                       gpgme_decrypt_flags_t flags,
162                       gpgme_data_t cipher,
163                       gpgme_data_t plain)
164 {
165   gpgme_error_t err;
166
167   TRACE_BEG2 (DEBUG_CTX, "gpgme_op_decrypt_ext", ctx,
168               "cipher=%p, plain=%p", cipher, plain);
169
170   if (!ctx)
171     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
172
173   if ((flags & GPGME_DECRYPT_VERIFY))
174     err = decrypt_verify_start (ctx, 1, flags, cipher, plain);
175   else
176     err = _gpgme_decrypt_start (ctx, 1, flags, cipher, plain);
177   if (!err)
178     err = _gpgme_wait_one (ctx);
179   return TRACE_ERR (err);
180 }