2009-11-03 Marcus Brinkmann <marcus@g10code.de>
[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 vfs_start (gpgme_ctx_t ctx, int synchronous,
60            const char *command,
61            gpgme_assuan_data_cb_t data_cb,
62            void *data_cb_value,
63            gpgme_assuan_inquire_cb_t inq_cb,
64            void *inq_cb_value,
65            gpgme_assuan_status_cb_t status_cb,
66            void *status_cb_value)
67 {
68   gpgme_error_t err;
69   void *hook;
70   op_data_t opd;
71
72   if (!command || !*command)
73     return gpg_error (GPG_ERR_INV_VALUE);
74
75   /* The flag value 256 is used to suppress an engine reset.  This is
76      required to keep the connection running.  */
77   err = _gpgme_op_reset (ctx, ((synchronous & 255) | 256));
78   if (err)
79     return err;
80
81   err = _gpgme_op_data_lookup (ctx, OPDATA_VFS_MOUNT, &hook, sizeof (*opd),
82                                NULL);
83   opd = hook;
84   if (err)
85     return err;
86
87   return _gpgme_engine_op_assuan_transact (ctx->engine, command,
88                                            data_cb, data_cb_value,
89                                            inq_cb, inq_cb_value,
90                                            status_cb, status_cb_value);
91 }
92
93
94
95 /* XXXX.  This is the asynchronous variant. */
96 static gpgme_error_t
97 gpgme_op_vfs_transact_start (gpgme_ctx_t ctx, 
98                              const char *command,
99                              gpgme_assuan_data_cb_t data_cb,
100                              void *data_cb_value,
101                              gpgme_assuan_inquire_cb_t inq_cb,
102                              void *inq_cb_value,
103                              gpgme_assuan_status_cb_t status_cb,
104                              void *status_cb_value)
105 {
106   return vfs_start (ctx, 0, command, data_cb, data_cb_value,
107                     inq_cb, inq_cb_value, status_cb, status_cb_value);
108 }
109
110
111 /* XXXX.  This is the synchronous variant. */
112 static gpgme_error_t
113 gpgme_op_vfs_transact (gpgme_ctx_t ctx,
114                        const char *command,
115                        gpgme_assuan_data_cb_t data_cb,
116                        void *data_cb_value,
117                        gpgme_assuan_inquire_cb_t inq_cb,
118                        void *inq_cb_value,
119                        gpgme_assuan_status_cb_t status_cb,
120                        void *status_cb_value,
121                        gpgme_error_t *op_err)
122 {
123   gpgme_error_t err;
124   
125   err = vfs_start (ctx, 1, command, data_cb, data_cb_value,
126                    inq_cb, inq_cb_value, status_cb, status_cb_value);
127   if (!err)
128     err = _gpgme_wait_one_ext (ctx, op_err);
129   return err;
130 }
131
132 \f
133 /* The actual exported interface follows.  */
134
135 /* The container is automatically unmounted when the context is reset
136    or destroyed.  This is a synchronous convenience interface, which
137    automatically returns an operation error if there is no
138    transmission error.  */
139 static gpgme_error_t
140 _gpgme_op_vfs_mount (gpgme_ctx_t ctx, const char *container_file,
141                      const char *mount_dir, int flags, gpgme_error_t *op_err)
142 {
143   gpg_error_t err;
144   char *cmd;
145   char *container_file_esc = NULL;
146
147   /* We want to encourage people to check error values, so not getting
148      them is discouraged here.  Also makes our code easier.  */
149   if (! op_err)
150     return gpg_error (GPG_ERR_INV_VALUE);
151
152   err = _gpgme_encode_percent_string (container_file, &container_file_esc, 0);
153   if (err)
154     return err;
155
156   if (asprintf (&cmd, "OPEN -- %s", container_file_esc) < 0)
157     {
158       err = gpg_error_from_syserror ();
159       free (container_file_esc);
160       return err;
161     }
162   free (container_file_esc);
163
164   err = gpgme_op_vfs_transact (ctx, cmd, NULL, NULL, NULL, NULL,
165                                NULL, NULL, op_err);
166   free (cmd);
167   if (err || *op_err)
168     return err;
169
170   if (mount_dir)
171     {
172       char *mount_dir_esc = NULL;
173
174       err = _gpgme_encode_percent_string (mount_dir, &mount_dir_esc, 0);
175       if (err)
176         return err;
177
178       if (asprintf (&cmd, "MOUNT -- %s", mount_dir_esc) < 0)
179         {
180           err = gpg_error_from_syserror ();
181           free (mount_dir_esc);
182           return err;
183         }
184       free (mount_dir_esc);
185     }
186   else
187     {
188       if (asprintf (&cmd, "MOUNT") < 0)
189         return gpg_error_from_syserror ();
190     }
191     
192   err = gpgme_op_vfs_transact (ctx, cmd, NULL, NULL, NULL, NULL,
193                                NULL, NULL, op_err);
194   free (cmd);
195
196   return err;
197 }
198
199 gpgme_error_t
200 gpgme_op_vfs_mount (gpgme_ctx_t ctx, const char *container_file,
201                     const char *mount_dir, unsigned int flags,
202                     gpgme_error_t *op_err)
203 {
204   TRACE_BEG4 (DEBUG_CTX, "gpgme_op_vfs_mount", ctx,
205               "container=%s, mount_dir=%s, flags=0x%x, op_err=%p",
206               container_file, mount_dir, flags, op_err);
207   return TRACE_ERR (_gpgme_op_vfs_mount (ctx, container_file, mount_dir,
208                                          flags, op_err));
209 }
210