spelling: fix misspellings
[gpgme.git] / src / vfs-mount.c
1 /* vfs-mount.c - vfs mount support in GPGME
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, write to the Free Software
18    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
19    02111-1307, USA.  */
20
21 #if HAVE_CONFIG_H
22 #include <config.h>
23 #endif
24
25 #include <stdlib.h>
26
27 #include "gpgme.h"
28 #include "debug.h"
29 #include "context.h"
30 #include "ops.h"
31 #include "util.h"
32
33 typedef struct
34 {
35   struct _gpgme_op_vfs_mount_result result;
36 } *op_data_t;
37
38
39 \f
40 gpgme_vfs_mount_result_t
41 gpgme_op_vfs_mount_result (gpgme_ctx_t ctx)
42 {
43   gpgme_error_t err;
44   void *hook;
45   op_data_t opd;
46
47   err = _gpgme_op_data_lookup (ctx, OPDATA_VFS_MOUNT, &hook, -1, NULL);
48   opd = hook;
49   /* Check in case this function is used without having run a command
50      before.  */
51   if (err || !opd)
52     return NULL;
53
54   return &opd->result;
55 }
56
57
58 static gpgme_error_t
59 _gpgme_vfs_mount_status_handler (void *priv, const char *code, const char *args)
60 {
61   gpgme_ctx_t ctx = (gpgme_ctx_t) priv;
62   gpgme_error_t err;
63   void *hook;
64   op_data_t opd;
65
66   err = _gpgme_op_data_lookup (ctx, OPDATA_VFS_MOUNT, &hook, -1, NULL);
67   opd = hook;
68   if (err)
69     return err;
70
71   if (! strcasecmp ("MOUNTPOINT", code))
72     {
73       if (opd->result.mount_dir)
74         free (opd->result.mount_dir);
75       opd->result.mount_dir = strdup (args);
76     }
77
78   return 0;
79 }
80
81
82 static gpgme_error_t
83 vfs_start (gpgme_ctx_t ctx, int synchronous,
84            const char *command,
85            gpgme_assuan_data_cb_t data_cb,
86            void *data_cb_value,
87            gpgme_assuan_inquire_cb_t inq_cb,
88            void *inq_cb_value,
89            gpgme_assuan_status_cb_t status_cb,
90            void *status_cb_value)
91 {
92   gpgme_error_t err;
93   void *hook;
94   op_data_t opd;
95
96   if (!command || !*command)
97     return gpg_error (GPG_ERR_INV_VALUE);
98
99   /* The flag value 256 is used to suppress an engine reset.  This is
100      required to keep the connection running.  */
101   err = _gpgme_op_reset (ctx, ((synchronous & 255) | 256));
102   if (err)
103     return err;
104
105   err = _gpgme_op_data_lookup (ctx, OPDATA_VFS_MOUNT, &hook, sizeof (*opd),
106                                NULL);
107   opd = hook;
108   if (err)
109     return err;
110
111   return _gpgme_engine_op_assuan_transact (ctx->engine, command,
112                                            data_cb, data_cb_value,
113                                            inq_cb, inq_cb_value,
114                                            status_cb, status_cb_value);
115 }
116
117
118
119 #if 0
120 /* XXXX.  This is the asynchronous variant. */
121 static gpgme_error_t
122 gpgme_op_vfs_transact_start (gpgme_ctx_t ctx,
123                              const char *command,
124                              gpgme_assuan_data_cb_t data_cb,
125                              void *data_cb_value,
126                              gpgme_assuan_inquire_cb_t inq_cb,
127                              void *inq_cb_value,
128                              gpgme_assuan_status_cb_t status_cb,
129                              void *status_cb_value)
130 {
131   return vfs_start (ctx, 0, command, data_cb, data_cb_value,
132                     inq_cb, inq_cb_value, status_cb, status_cb_value);
133 }
134 #endif
135
136
137 /* XXXX.  This is the synchronous variant. */
138 static gpgme_error_t
139 gpgme_op_vfs_transact (gpgme_ctx_t ctx,
140                        const char *command,
141                        gpgme_assuan_data_cb_t data_cb,
142                        void *data_cb_value,
143                        gpgme_assuan_inquire_cb_t inq_cb,
144                        void *inq_cb_value,
145                        gpgme_assuan_status_cb_t status_cb,
146                        void *status_cb_value,
147                        gpgme_error_t *op_err)
148 {
149   gpgme_error_t err;
150
151   if (!ctx)
152     return gpg_error (GPG_ERR_INV_VALUE);
153
154   err = vfs_start (ctx, 1, command, data_cb, data_cb_value,
155                    inq_cb, inq_cb_value, status_cb, status_cb_value);
156   if (!err)
157     err = _gpgme_wait_one_ext (ctx, op_err);
158   return err;
159 }
160
161 \f
162 /* The actual exported interface follows.  */
163
164 /* The container is automatically unmounted when the context is reset
165    or destroyed.  This is a synchronous convenience interface, which
166    automatically returns an operation error if there is no
167    transmission error.  */
168 static gpgme_error_t
169 _gpgme_op_vfs_mount (gpgme_ctx_t ctx, const char *container_file,
170                      const char *mount_dir, int flags, gpgme_error_t *op_err)
171 {
172   gpg_error_t err;
173   char *cmd;
174   char *container_file_esc = NULL;
175
176   (void)flags;
177
178   /* We want to encourage people to check error values, so not getting
179      them is discouraged here.  Also makes our code easier.  */
180   if (! op_err)
181     return gpg_error (GPG_ERR_INV_VALUE);
182
183   err = _gpgme_encode_percent_string (container_file, &container_file_esc, 0);
184   if (err)
185     return err;
186
187   if (gpgrt_asprintf (&cmd, "OPEN -- %s", container_file_esc) < 0)
188     {
189       err = gpg_error_from_syserror ();
190       free (container_file_esc);
191       return err;
192     }
193   free (container_file_esc);
194
195   err = gpgme_op_vfs_transact (ctx, cmd, NULL, NULL, NULL, NULL,
196                                NULL, NULL, op_err);
197   gpgrt_free (cmd);
198   if (err || *op_err)
199     return err;
200
201   if (mount_dir)
202     {
203       char *mount_dir_esc = NULL;
204
205       err = _gpgme_encode_percent_string (mount_dir, &mount_dir_esc, 0);
206       if (err)
207         return err;
208
209       if (gpgrt_asprintf (&cmd, "MOUNT -- %s", mount_dir_esc) < 0)
210         {
211           err = gpg_error_from_syserror ();
212           free (mount_dir_esc);
213           return err;
214         }
215       free (mount_dir_esc);
216     }
217   else
218     {
219       if (gpgrt_asprintf (&cmd, "MOUNT") < 0)
220         return gpg_error_from_syserror ();
221     }
222
223   err = gpgme_op_vfs_transact (ctx, cmd, NULL, NULL, NULL, NULL,
224                                _gpgme_vfs_mount_status_handler, ctx, op_err);
225   gpgrt_free (cmd);
226
227   return err;
228 }
229
230 gpgme_error_t
231 gpgme_op_vfs_mount (gpgme_ctx_t ctx, const char *container_file,
232                     const char *mount_dir, unsigned int flags,
233                     gpgme_error_t *op_err)
234 {
235   gpg_error_t err;
236
237   TRACE_BEG4 (DEBUG_CTX, "gpgme_op_vfs_mount", ctx,
238               "container=%s, mount_dir=%s, flags=0x%x, op_err=%p",
239               container_file, mount_dir, flags, op_err);
240
241   if (!ctx)
242     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
243
244   err = _gpgme_op_vfs_mount (ctx, container_file, mount_dir, flags, op_err);
245   return TRACE_ERR (err);
246 }
247