From f66f856c89b7c02e368afe2343de7cce50e6109e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ingo=20Kl=C3=B6cker?= Date: Fri, 14 Aug 2020 11:11:23 +0200 Subject: [PATCH] core: Add error handling to setexpire * src/genkey.c (setexpire, gpgme_op_setexpire_start, gpgme_op_setexpire): Move to ... * src/setexpire.c: New. * src/Makefile.am (main_sources): Add that file. * src/context.h (ctx_op_data_id_t): Add OPDATA_SETEXPIRE. * lang/qt/tests/t-various.cpp (testSetExpire): Test error handling. -- Errors (and failures) emitted via status-fd need to be handled explicitly, i.e. we need to provide an appropriate status handler with corresponding op_data_t. Additionally, we need to set a passphrase command handler if a passphrase callback is set in the context, e.g. during tests. GnuPG-bug-id: 4395 --- lang/qt/tests/t-various.cpp | 9 ++ src/Makefile.am | 1 + src/context.h | 2 +- src/genkey.c | 52 ---------- src/setexpire.c | 193 ++++++++++++++++++++++++++++++++++++ 5 files changed, 204 insertions(+), 53 deletions(-) create mode 100644 src/setexpire.c diff --git a/lang/qt/tests/t-various.cpp b/lang/qt/tests/t-various.cpp index dc5a2d1c..1e6bba41 100644 --- a/lang/qt/tests/t-various.cpp +++ b/lang/qt/tests/t-various.cpp @@ -222,6 +222,15 @@ private Q_SLOTS: QVERIFY (key.subkey(0).expirationTime() == keyExpiration); QVERIFY (key.subkey(1).expirationTime() != subkeyExpiration); + + // test error handling: calling setExpire() with the primary key as + // subkey should fail with "subkey not found" + ctx = Context::createForProtocol(key.protocol()); + std::vector primaryKey; + primaryKey.push_back(key.subkey(0)); + const auto err = ctx->setExpire(key, 3000, primaryKey); + QCOMPARE(err.code(), GPG_ERR_NOT_FOUND); + delete ctx; } void testVersion() diff --git a/src/Makefile.am b/src/Makefile.am index 1bbb5388..1061995c 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -80,6 +80,7 @@ main_sources = \ sign.c passphrase.c progress.c \ key.c keylist.c keysign.c trust-item.c trustlist.c tofupolicy.c \ import.c export.c genkey.c delete.c edit.c getauditlog.c \ + setexpire.c \ opassuan.c passwd.c spawn.c assuan-support.c \ engine.h engine-backend.h engine.c engine-gpg.c status-table.c \ engine-gpgsm.c engine-assuan.c engine-gpgconf.c \ diff --git a/src/context.h b/src/context.h index 25dfc792..7f745a52 100644 --- a/src/context.h +++ b/src/context.h @@ -39,7 +39,7 @@ typedef enum OPDATA_IMPORT, OPDATA_GENKEY, OPDATA_KEYLIST, OPDATA_EDIT, OPDATA_VERIFY, OPDATA_TRUSTLIST, OPDATA_ASSUAN, OPDATA_VFS_MOUNT, OPDATA_PASSWD, OPDATA_EXPORT, OPDATA_KEYSIGN, OPDATA_TOFU_POLICY, - OPDATA_QUERY_SWDB + OPDATA_QUERY_SWDB, OPDATA_SETEXPIRE } ctx_op_data_id_t; diff --git a/src/genkey.c b/src/genkey.c index 981a0093..77576b18 100644 --- a/src/genkey.c +++ b/src/genkey.c @@ -663,55 +663,3 @@ gpgme_op_set_uid_flag (gpgme_ctx_t ctx, { return set_uid_flag (ctx, 1, key, userid, name, value); } - -/* Set the expiration time of a key or its subkeys. See - --quick-set-expire in the gnupg documentation. */ -static gpg_error_t -setexpire (gpgme_ctx_t ctx, int synchronous, - gpgme_key_t key, - unsigned long expires, - const char *subfprs, - unsigned int reserved) -{ - gpgme_error_t err = 0; - - TRACE_BEG (DEBUG_CTX, "gpgme_op_setexpire", ctx, - "%d key=%p expiry: %lu subkeys: '%s' reserved=0x%x", - synchronous, key, expires, subfprs, reserved); - - if (!ctx || !key) - return TRACE_ERR (gpg_error (GPG_ERR_INV_ARG)); - - err = _gpgme_op_reset (ctx, synchronous); - if (err) - return err; - - err = _gpgme_engine_op_setexpire (ctx->engine, key, expires, subfprs, reserved); - - if (synchronous && !err) - err = _gpgme_wait_one (ctx); - return TRACE_ERR (err); -} - -/* See setexpire. */ -gpgme_error_t -gpgme_op_setexpire_start (gpgme_ctx_t ctx, - gpgme_key_t key, - unsigned long expires, - const char *subfprs, - unsigned int reserved) -{ - return setexpire (ctx, 0, key, expires, subfprs, reserved); -} - - -/* See setexpire. This is the synchronous variant. */ -gpgme_error_t -gpgme_op_setexpire (gpgme_ctx_t ctx, - gpgme_key_t key, - unsigned long expires, - const char *subfprs, - unsigned int reserved) -{ - return setexpire (ctx, 1, key, expires, subfprs, reserved); -} diff --git a/src/setexpire.c b/src/setexpire.c new file mode 100644 index 00000000..5161499a --- /dev/null +++ b/src/setexpire.c @@ -0,0 +1,193 @@ +/* setexpire.c - Set expire helpers. + * Copyright (C) 2020 g10 Code GmbH + * + * This file is part of GPGME. + * + * GPGME is free software; you can redistribute it and/or modify it + * under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * GPGME is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this program; if not, see . + * SPDX-License-Identifier: LGPL-2.1-or-later + */ + +#if HAVE_CONFIG_H +#include +#endif +#include + +#include "gpgme.h" +#include "debug.h" +#include "context.h" +#include "ops.h" + + +typedef struct +{ + /* The error code from a FAILURE status line or 0. */ + gpg_error_t failure_code; + + /* The error code from an ERROR status line or 0. */ + gpg_error_t error_code; + +} *op_data_t; + + +/* Parse an error status line. Return the error location and the + error code. The function may modify ARGS. */ +static char * +parse_error (char *args, gpg_error_t *r_err) +{ + char *where = strchr (args, ' '); + char *which; + + if (where) + { + *where = '\0'; + which = where + 1; + + where = strchr (which, ' '); + if (where) + *where = '\0'; + + where = args; + } + else + { + *r_err = trace_gpg_error (GPG_ERR_INV_ENGINE); + return NULL; + } + + *r_err = atoi (which); + + return where; +} + + +static gpgme_error_t +setexpire_status_handler (void *priv, gpgme_status_code_t code, char *args) +{ + gpgme_ctx_t ctx = (gpgme_ctx_t) priv; + gpgme_error_t err; + void *hook; + op_data_t opd; + char *loc; + + err = _gpgme_op_data_lookup (ctx, OPDATA_SETEXPIRE, &hook, -1, NULL); + opd = hook; + if (err) + return err; + + switch (code) + { + case GPGME_STATUS_ERROR: + loc = parse_error (args, &err); + if (!loc) + return err; + if (!opd->error_code) + opd->error_code = err; + break; + + case GPGME_STATUS_FAILURE: + opd->failure_code = _gpgme_parse_failure (args); + break; + + case GPGME_STATUS_EOF: + if (opd->error_code) + err = opd->error_code; + else if (opd->failure_code) + err = opd->failure_code; + break; + + default: + break; + } + + return err; +} + + +/* Set the expiration time of a key or its subkeys. See + --quick-set-expire in the gnupg documentation. */ +static gpg_error_t +setexpire (gpgme_ctx_t ctx, int synchronous, + gpgme_key_t key, + unsigned long expires, + const char *subfprs, + unsigned int reserved) +{ + gpgme_error_t err; + void *hook; + op_data_t opd; + + TRACE_BEG (DEBUG_CTX, "gpgme_op_setexpire", ctx, + "%d key=%p expiry: %lu subkeys: '%s' reserved=0x%x", + synchronous, key, expires, subfprs, reserved); + + if (!ctx) + return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE)); + + if (ctx->protocol != GPGME_PROTOCOL_OPENPGP) + return TRACE_ERR (gpgme_error (GPG_ERR_UNSUPPORTED_PROTOCOL)); + + if (!key) + return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE)); + + err = _gpgme_op_reset (ctx, synchronous); + if (err) + return err; + + err = _gpgme_op_data_lookup (ctx, OPDATA_SETEXPIRE, &hook, sizeof (*opd), + NULL); + opd = hook; + if (err) + return err; + + _gpgme_engine_set_status_handler (ctx->engine, setexpire_status_handler, + ctx); + + if (ctx->passphrase_cb) + { + err = _gpgme_engine_set_command_handler + (ctx->engine, _gpgme_passphrase_command_handler, ctx); + if (err) + return err; + } + + err = _gpgme_engine_op_setexpire (ctx->engine, key, expires, subfprs, reserved); + + if (synchronous && !err) + err = _gpgme_wait_one (ctx); + return TRACE_ERR (err); +} + + +/* See setexpire. */ +gpgme_error_t +gpgme_op_setexpire_start (gpgme_ctx_t ctx, + gpgme_key_t key, + unsigned long expires, + const char *subfprs, + unsigned int reserved) +{ + return setexpire (ctx, 0, key, expires, subfprs, reserved); +} + + +/* See setexpire. This is the synchronous variant. */ +gpgme_error_t +gpgme_op_setexpire (gpgme_ctx_t ctx, + gpgme_key_t key, + unsigned long expires, + const char *subfprs, + unsigned int reserved) +{ + return setexpire (ctx, 1, key, expires, subfprs, reserved); +}