2db9f6cf312a163c24781c869f03a662c1cc1bfd
[gpgme.git] / src / opassuan.c
1 /* opassuan.c - Low-level Assuan operations.
2    Copyright (C) 2009 g10 Code GmbH
3
4    This file is part of GPGME.
5  
6    GPGME is free software; you can redistribute it and/or modify it
7    under the terms of the GNU Lesser General Public License as
8    published by the Free Software Foundation; either version 2.1 of
9    the License, or (at your option) any later version.
10    
11    GPGME is distributed in the hope that it will be useful, but
12    WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14    Lesser General Public License for more details.
15    
16    You should have received a copy of the GNU Lesser General Public
17    License along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #if HAVE_CONFIG_H
21 #include <config.h>
22 #endif
23
24 #include "gpgme.h"
25 #include "context.h"
26 #include "ops.h"
27 #include "util.h"
28
29 static gpgme_error_t
30 opassuan_start (gpgme_ctx_t ctx, int synchronous,
31                 const char *command,
32                 gpgme_assuan_data_cb_t data_cb,
33                 void *data_cb_value,
34                 gpgme_assuan_inquire_cb_t inq_cb,
35                 void *inq_cb_value,
36                 gpgme_assuan_status_cb_t status_cb,
37                 void *status_cb_value)
38 {
39   gpgme_error_t err;
40
41   if (!command || !*command)
42     return gpg_error (GPG_ERR_INV_VALUE);
43
44   /* The flag value 256 is used to suppress an engine reset.  This is
45      required to keep the connection running.  */
46   err = _gpgme_op_reset (ctx, ((synchronous&255) | 256));
47   if (err)
48     return err;
49
50   return _gpgme_engine_op_assuan_transact (ctx->engine, command,
51                                            data_cb, data_cb_value,
52                                            inq_cb, inq_cb_value,
53                                            status_cb, status_cb_value);
54 }
55
56
57
58 /* XXXX.  This is the asynchronous variant. */
59 gpgme_error_t
60 gpgme_op_assuan_transact_start (gpgme_ctx_t ctx, 
61                                 const char *command,
62                                 gpgme_assuan_data_cb_t data_cb,
63                                 void *data_cb_value,
64                                 gpgme_assuan_inquire_cb_t inq_cb,
65                                 void *inq_cb_value,
66                                 gpgme_assuan_status_cb_t status_cb,
67                                 void *status_cb_value)
68 {
69   return opassuan_start (ctx, 0, command, 
70                          data_cb, data_cb_value,
71                          inq_cb, inq_cb_value,
72                          status_cb, status_cb_value);
73 }
74
75
76 /* XXXX.  This is the synchronous variant. */
77 gpgme_error_t
78 gpgme_op_assuan_transact_ext (gpgme_ctx_t ctx,
79                               const char *command,
80                               gpgme_assuan_data_cb_t data_cb,
81                               void *data_cb_value,
82                               gpgme_assuan_inquire_cb_t inq_cb,
83                               void *inq_cb_value,
84                               gpgme_assuan_status_cb_t status_cb,
85                               void *status_cb_value,
86                               gpgme_error_t *op_err)
87 {
88   gpgme_error_t err;
89
90   err = opassuan_start (ctx, 1, command, 
91                         data_cb, data_cb_value,
92                         inq_cb, inq_cb_value,
93                         status_cb, status_cb_value);
94   if (!err)
95     err = _gpgme_wait_one_ext (ctx, op_err);
96   return err;
97 }
98
99
100
101 \f
102 /* Compatibility code for old interface.  */
103
104 /* Evil hack breaking abstractions for the purpose of localizing our
105    other hack.  This is copied from engine.c.  */
106 struct engine
107 {
108   struct engine_ops *ops;
109   void *engine;
110 };
111
112 typedef struct
113 {
114   struct _gpgme_op_assuan_result result;
115 } *op_data_t;
116
117 gpg_error_t _gpgme_engine_assuan_last_op_err (void *engine);
118
119 gpgme_assuan_result_t
120 gpgme_op_assuan_result (gpgme_ctx_t ctx)
121 {
122   gpgme_error_t err;
123   void *hook;
124   op_data_t opd;
125
126   err = _gpgme_op_data_lookup (ctx, OPDATA_ASSUAN, &hook, -1, NULL);
127   opd = hook;
128   /* Check in case this function is used without having run a command
129      before.  */
130   if (err || !opd)
131     return NULL;
132
133   /* All of this is a hack for the old style interface.  The new style
134      interface returns op errors directly.  */
135   opd->result.err = _gpgme_engine_assuan_last_op_err (ctx->engine->engine);
136
137   return &opd->result;
138 }
139
140
141 gpgme_error_t
142 gpgme_op_assuan_transact (gpgme_ctx_t ctx,
143                           const char *command,
144                           gpgme_assuan_data_cb_t data_cb,
145                           void *data_cb_value,
146                           gpgme_assuan_inquire_cb_t inq_cb,
147                           void *inq_cb_value,
148                           gpgme_assuan_status_cb_t status_cb,
149                           void *status_cb_value)
150 {
151   gpgme_error_t op_err;
152   gpgme_error_t err;
153
154   /* Users of the old-style session based interfaces need to look at
155      the result structure.  */
156   gpgme_op_assuan_transact_ext (ctx, command, data_cb, data_cb_value,
157                                 inq_cb, inq_cb_value,
158                                 status_cb, status_cb_value, &op_err);
159
160   return err;
161 }