LCOV - code coverage report
Current view: top level - src - edit.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 42 74 56.8 %
Date: 2015-11-05 17:14:26 Functions: 4 7 57.1 %

          Line data    Source code
       1             : /* edit.c - Key edit function.
       2             :    Copyright (C) 2002, 2003, 2004 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             : #include <stdlib.h>
      25             : 
      26             : #include "gpgme.h"
      27             : #include "debug.h"
      28             : #include "context.h"
      29             : #include "ops.h"
      30             : 
      31             : 
      32             : typedef struct
      33             : {
      34             :   /* The user callback function and its hook value.  */
      35             :   gpgme_edit_cb_t fnc;
      36             :   void *fnc_value;
      37             : } *op_data_t;
      38             : 
      39             : 
      40             : static gpgme_error_t
      41           8 : edit_status_handler (void *priv, gpgme_status_code_t status, char *args)
      42             : {
      43           8 :   gpgme_ctx_t ctx = (gpgme_ctx_t) priv;
      44             :   gpgme_error_t err;
      45             :   void *hook;
      46             :   op_data_t opd;
      47             : 
      48           8 :   err = _gpgme_passphrase_status_handler (priv, status, args);
      49           8 :   if (err)
      50           0 :     return err;
      51             : 
      52           8 :   err = _gpgme_progress_status_handler (priv, status, args);
      53           8 :   if (err)
      54           0 :     return err;
      55             : 
      56           8 :   err = _gpgme_op_data_lookup (ctx, OPDATA_EDIT, &hook, -1, NULL);
      57           8 :   opd = hook;
      58           8 :   if (err)
      59           0 :     return err;
      60             : 
      61           8 :   return (*opd->fnc) (opd->fnc_value, status, args, -1);
      62             : }
      63             : 
      64             : 
      65             : static gpgme_error_t
      66           7 : command_handler (void *priv, gpgme_status_code_t status, const char *args,
      67             :                  int fd, int *processed_r)
      68             : {
      69           7 :   gpgme_ctx_t ctx = (gpgme_ctx_t) priv;
      70             :   gpgme_error_t err;
      71           7 :   int processed = 0;
      72             : 
      73           7 :   if (ctx->passphrase_cb)
      74             :     {
      75           7 :       err = _gpgme_passphrase_command_handler (ctx, status, args,
      76             :                                                fd, &processed);
      77           7 :       if (err)
      78           0 :         return err;
      79             :     }
      80             : 
      81           7 :   if (!processed)
      82             :     {
      83             :       void *hook;
      84             :       op_data_t opd;
      85             : 
      86           7 :       err = _gpgme_op_data_lookup (ctx, OPDATA_EDIT, &hook, -1, NULL);
      87           7 :       opd = hook;
      88           7 :       if (err)
      89           0 :         return err;
      90             : 
      91             :       /* FIXME: We expect the user to handle _all_ status codes.
      92             :          Later, we may fix the callback interface to allow the user
      93             :          indicate if it processed the status code or not.  */
      94           7 :       *processed_r = 1;
      95             : 
      96           7 :       return (*opd->fnc) (opd->fnc_value, status, args, fd);
      97             :     }
      98             : 
      99           0 :   *processed_r = processed;
     100           0 :   return 0;
     101             : }
     102             : 
     103             : 
     104             : static gpgme_error_t
     105           1 : edit_start (gpgme_ctx_t ctx, int synchronous, int type, gpgme_key_t key,
     106             :             gpgme_edit_cb_t fnc, void *fnc_value, gpgme_data_t out)
     107             : {
     108             :   gpgme_error_t err;
     109             :   void *hook;
     110             :   op_data_t opd;
     111             : 
     112           1 :   err = _gpgme_op_reset (ctx, synchronous);
     113           1 :   if (err)
     114           0 :     return err;
     115             : 
     116           1 :   if (!fnc || !out)
     117           0 :     return gpg_error (GPG_ERR_INV_VALUE);
     118             : 
     119           1 :   err = _gpgme_op_data_lookup (ctx, OPDATA_EDIT, &hook, sizeof (*opd), NULL);
     120           1 :   opd = hook;
     121           1 :   if (err)
     122           0 :     return err;
     123             : 
     124           1 :   opd->fnc = fnc;
     125           1 :   opd->fnc_value = fnc_value;
     126             : 
     127           1 :   err = _gpgme_engine_set_command_handler (ctx->engine, command_handler,
     128             :                                            ctx, out);
     129           1 :   if (err)
     130           0 :     return err;
     131             : 
     132           1 :   _gpgme_engine_set_status_handler (ctx->engine, edit_status_handler, ctx);
     133             : 
     134           1 :   return _gpgme_engine_op_edit (ctx->engine, type, key, out, ctx);
     135             : }
     136             : 
     137             : 
     138             : gpgme_error_t
     139           0 : gpgme_op_edit_start (gpgme_ctx_t ctx, gpgme_key_t key,
     140             :                      gpgme_edit_cb_t fnc, void *fnc_value, gpgme_data_t out)
     141             : {
     142             :   gpgme_error_t err;
     143             : 
     144           0 :   TRACE_BEG5 (DEBUG_CTX, "gpgme_op_edit_start", ctx,
     145             :               "key=%p (%s), fnc=%p fnc_value=%p, out=%p", key,
     146             :               (key && key->subkeys && key->subkeys->fpr) ?
     147             :               key->subkeys->fpr : "invalid", fnc, fnc_value, out);
     148             : 
     149           0 :   if (!ctx)
     150           0 :     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
     151             : 
     152           0 :   err = edit_start (ctx, 0, 0, key, fnc, fnc_value, out);
     153           0 :   return err;
     154             : }
     155             : 
     156             : 
     157             : /* Edit the key KEY.  Send status and command requests to FNC and
     158             :    output of edit commands to OUT.  */
     159             : gpgme_error_t
     160           1 : gpgme_op_edit (gpgme_ctx_t ctx, gpgme_key_t key,
     161             :                gpgme_edit_cb_t fnc, void *fnc_value, gpgme_data_t out)
     162             : {
     163             :   gpgme_error_t err;
     164             : 
     165           1 :   TRACE_BEG5 (DEBUG_CTX, "gpgme_op_edit", ctx,
     166             :               "key=%p (%s), fnc=%p fnc_value=%p, out=%p", key,
     167             :               (key && key->subkeys && key->subkeys->fpr) ?
     168             :               key->subkeys->fpr : "invalid", fnc, fnc_value, out);
     169             : 
     170           1 :   if (!ctx)
     171           0 :     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
     172             : 
     173           1 :   err = edit_start (ctx, 1, 0, key, fnc, fnc_value, out);
     174             : 
     175           1 :   if (!err)
     176           1 :     err = _gpgme_wait_one (ctx);
     177           1 :   return TRACE_ERR (err);
     178             : }
     179             : 
     180             : 
     181             : gpgme_error_t
     182           0 : gpgme_op_card_edit_start (gpgme_ctx_t ctx, gpgme_key_t key,
     183             :                           gpgme_edit_cb_t fnc, void *fnc_value,
     184             :                           gpgme_data_t out)
     185             : {
     186             :   gpgme_error_t err;
     187             : 
     188           0 :   TRACE_BEG5 (DEBUG_CTX, "gpgme_op_card_edit_start", ctx,
     189             :               "key=%p (%s), fnc=%p fnc_value=%p, out=%p", key,
     190             :               (key && key->subkeys && key->subkeys->fpr) ?
     191             :               key->subkeys->fpr : "invalid", fnc, fnc_value, out);
     192             : 
     193           0 :   if (!ctx)
     194           0 :     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
     195             : 
     196           0 :   err = edit_start (ctx, 0, 1, key, fnc, fnc_value, out);
     197           0 :   return err;
     198             : }
     199             : 
     200             : 
     201             : /* Edit the card for the key KEY.  Send status and command requests to
     202             :    FNC and output of edit commands to OUT.  */
     203             : gpgme_error_t
     204           0 : gpgme_op_card_edit (gpgme_ctx_t ctx, gpgme_key_t key,
     205             :                     gpgme_edit_cb_t fnc, void *fnc_value, gpgme_data_t out)
     206             : {
     207             :   gpgme_error_t err;
     208             : 
     209           0 :   TRACE_BEG5 (DEBUG_CTX, "gpgme_op_card_edit", ctx,
     210             :               "key=%p (%s), fnc=%p fnc_value=%p, out=%p", key,
     211             :               (key && key->subkeys && key->subkeys->fpr) ?
     212             :               key->subkeys->fpr : "invalid", fnc, fnc_value, out);
     213             : 
     214           0 :   if (!ctx)
     215           0 :     return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE));
     216             : 
     217           0 :   err = edit_start (ctx, 1, 1, key, fnc, fnc_value, out);
     218           0 :   if (!err)
     219           0 :     err = _gpgme_wait_one (ctx);
     220           0 :   return TRACE_ERR (err);
     221             : }

Generated by: LCOV version 1.11