LCOV - code coverage report
Current view: top level - src - vfs-mount.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 0 72 0.0 %
Date: 2016-09-12 13:07:23 Functions: 0 6 0.0 %

          Line data    Source code
       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             : 
      40             : gpgme_vfs_mount_result_t
      41           0 : 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           0 :   err = _gpgme_op_data_lookup (ctx, OPDATA_VFS_MOUNT, &hook, -1, NULL);
      48           0 :   opd = hook;
      49             :   /* Check in case this function is used without having run a command
      50             :      before.  */
      51           0 :   if (err || !opd)
      52           0 :     return NULL;
      53             : 
      54           0 :   return &opd->result;
      55             : }
      56             : 
      57             : 
      58             : static gpgme_error_t
      59           0 : _gpgme_vfs_mount_status_handler (void *priv, const char *code, const char *args)
      60             : {
      61           0 :   gpgme_ctx_t ctx = (gpgme_ctx_t) priv;
      62             :   gpgme_error_t err;
      63             :   void *hook;
      64             :   op_data_t opd;
      65             : 
      66           0 :   err = _gpgme_op_data_lookup (ctx, OPDATA_VFS_MOUNT, &hook, -1, NULL);
      67           0 :   opd = hook;
      68           0 :   if (err)
      69           0 :     return err;
      70             : 
      71           0 :   if (! strcasecmp ("MOUNTPOINT", code))
      72             :     {
      73           0 :       if (opd->result.mount_dir)
      74           0 :         free (opd->result.mount_dir);
      75           0 :       opd->result.mount_dir = strdup (args);
      76             :     }
      77             : 
      78           0 :   return 0;
      79             : }
      80             : 
      81             : 
      82             : static gpgme_error_t
      83           0 : 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           0 :   if (!command || !*command)
      97           0 :     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           0 :   err = _gpgme_op_reset (ctx, ((synchronous & 255) | 256));
     102           0 :   if (err)
     103           0 :     return err;
     104             : 
     105           0 :   err = _gpgme_op_data_lookup (ctx, OPDATA_VFS_MOUNT, &hook, sizeof (*opd),
     106             :                                NULL);
     107           0 :   opd = hook;
     108           0 :   if (err)
     109           0 :     return err;
     110             : 
     111           0 :   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           0 : 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           0 :   if (!ctx)
     152           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     153             : 
     154           0 :   err = vfs_start (ctx, 1, command, data_cb, data_cb_value,
     155             :                    inq_cb, inq_cb_value, status_cb, status_cb_value);
     156           0 :   if (!err)
     157           0 :     err = _gpgme_wait_one_ext (ctx, op_err);
     158           0 :   return err;
     159             : }
     160             : 
     161             : 
     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           0 : _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           0 :   char *container_file_esc = NULL;
     175             : 
     176             :   /* We want to encourage people to check error values, so not getting
     177             :      them is discouraged here.  Also makes our code easier.  */
     178           0 :   if (! op_err)
     179           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     180             : 
     181           0 :   err = _gpgme_encode_percent_string (container_file, &container_file_esc, 0);
     182           0 :   if (err)
     183           0 :     return err;
     184             : 
     185           0 :   if (asprintf (&cmd, "OPEN -- %s", container_file_esc) < 0)
     186             :     {
     187           0 :       err = gpg_error_from_syserror ();
     188           0 :       free (container_file_esc);
     189           0 :       return err;
     190             :     }
     191           0 :   free (container_file_esc);
     192             : 
     193           0 :   err = gpgme_op_vfs_transact (ctx, cmd, NULL, NULL, NULL, NULL,
     194             :                                NULL, NULL, op_err);
     195           0 :   free (cmd);
     196           0 :   if (err || *op_err)
     197           0 :     return err;
     198             : 
     199           0 :   if (mount_dir)
     200             :     {
     201           0 :       char *mount_dir_esc = NULL;
     202             : 
     203           0 :       err = _gpgme_encode_percent_string (mount_dir, &mount_dir_esc, 0);
     204           0 :       if (err)
     205           0 :         return err;
     206             : 
     207           0 :       if (asprintf (&cmd, "MOUNT -- %s", mount_dir_esc) < 0)
     208             :         {
     209           0 :           err = gpg_error_from_syserror ();
     210           0 :           free (mount_dir_esc);
     211           0 :           return err;
     212             :         }
     213           0 :       free (mount_dir_esc);
     214             :     }
     215             :   else
     216             :     {
     217           0 :       if (asprintf (&cmd, "MOUNT") < 0)
     218           0 :         return gpg_error_from_syserror ();
     219             :     }
     220             : 
     221           0 :   err = gpgme_op_vfs_transact (ctx, cmd, NULL, NULL, NULL, NULL,
     222             :                                _gpgme_vfs_mount_status_handler, ctx, op_err);
     223           0 :   free (cmd);
     224             : 
     225           0 :   return err;
     226             : }
     227             : 
     228             : gpgme_error_t
     229           0 : gpgme_op_vfs_mount (gpgme_ctx_t ctx, const char *container_file,
     230             :                     const char *mount_dir, unsigned int flags,
     231             :                     gpgme_error_t *op_err)
     232             : {
     233             :   gpg_error_t err;
     234             : 
     235           0 :   TRACE_BEG4 (DEBUG_CTX, "gpgme_op_vfs_mount", ctx,
     236             :               "container=%s, mount_dir=%s, flags=0x%x, op_err=%p",
     237             :               container_file, mount_dir, flags, op_err);
     238             : 
     239           0 :   if (!ctx)
     240           0 :     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
     241             : 
     242           0 :   err = _gpgme_op_vfs_mount (ctx, container_file, mount_dir, flags, op_err);
     243           0 :   return TRACE_ERR (err);
     244             : }
     245             : 

Generated by: LCOV version 1.11