gpgme_error_t gpgme_op_trustlist_start (gpgme_ctx_t ctx, const char *pattern, int max_level) { gpgme_error_t err = 0; void *hook; op_data_t opd; TRACE_BEG2 (DEBUG_CTX, "gpgme_op_trustlist_start", ctx, "pattern=%s, max_level=%i", pattern, max_level); if (!pattern || !*pattern) return TRACE_ERR (gpg_error (GPG_ERR_INV_VALUE)); err = _gpgme_op_reset (ctx, 2); if (err) return TRACE_ERR (err); err = _gpgme_op_data_lookup (ctx, OPDATA_TRUSTLIST, &hook, sizeof (*opd), NULL); opd = hook; if (err) return TRACE_ERR (err); _gpgme_engine_set_status_handler (ctx->engine, trustlist_status_handler, ctx); err = _gpgme_engine_set_colon_line_handler (ctx->engine, trustlist_colon_handler, ctx); if (err) return TRACE_ERR (err); err = _gpgme_engine_op_trustlist (ctx->engine, pattern); return TRACE_ERR (err); }
static gpgme_error_t vfs_start (gpgme_ctx_t ctx, int synchronous, const char *command, gpgme_assuan_data_cb_t data_cb, void *data_cb_value, gpgme_assuan_inquire_cb_t inq_cb, void *inq_cb_value, gpgme_assuan_status_cb_t status_cb, void *status_cb_value) { gpgme_error_t err; if (!command || !*command) return gpg_error (GPG_ERR_INV_VALUE); /* The flag value 256 is used to suppress an engine reset. This is required to keep the connection running. */ err = _gpgme_op_reset (ctx, ((synchronous & 255) | 256)); if (err) return err; return _gpgme_engine_op_assuan_transact (ctx->engine, command, data_cb, data_cb_value, inq_cb, inq_cb_value, status_cb, status_cb_value); }
static gpgme_error_t export_start (gpgme_ctx_t ctx, int synchronous, const char *pattern, gpgme_export_mode_t mode, gpgme_data_t keydata) { gpgme_error_t err; if ((mode & ~(GPGME_EXPORT_MODE_EXTERN))) return gpg_error (GPG_ERR_INV_VALUE); /* Invalid flags in MODE. */ if ((mode & GPGME_EXPORT_MODE_EXTERN)) { if (keydata) return gpg_error (GPG_ERR_INV_VALUE); } else { if (!keydata) return gpg_error (GPG_ERR_INV_VALUE); } err = _gpgme_op_reset (ctx, synchronous); if (err) return err; _gpgme_engine_set_status_handler (ctx->engine, export_status_handler, ctx); return _gpgme_engine_op_export (ctx->engine, pattern, mode, keydata, ctx->use_armor); }
static gpgme_error_t decrypt_start (gpgme_ctx_t ctx, int synchronous, gpgme_data_t cipher, gpgme_data_t plain) { gpgme_error_t err; err = _gpgme_op_reset (ctx, synchronous); if (err) return err; err = _gpgme_op_decrypt_init_result (ctx); if (err) return err; if (!cipher) return gpg_error (GPG_ERR_NO_DATA); if (!plain) return gpg_error (GPG_ERR_INV_VALUE); if (err) return err; if (ctx->passphrase_cb) { err = _gpgme_engine_set_command_handler (ctx->engine, _gpgme_passphrase_command_handler, ctx, NULL); if (err) return err; } _gpgme_engine_set_status_handler (ctx->engine, decrypt_status_handler, ctx); return _gpgme_engine_op_decrypt (ctx->engine, cipher, plain); }
static gpgme_error_t _gpgme_op_import_start (gpgme_ctx_t ctx, int synchronous, gpgme_data_t keydata) { gpgme_error_t err; void *hook; op_data_t opd; err = _gpgme_op_reset (ctx, synchronous); if (err) return err; err = _gpgme_op_data_lookup (ctx, OPDATA_IMPORT, &hook, sizeof (*opd), release_op_data); opd = hook; if (err) return err; opd->lastp = &opd->result.imports; if (!keydata) return gpg_error (GPG_ERR_NO_DATA); _gpgme_engine_set_status_handler (ctx->engine, import_status_handler, ctx); return _gpgme_engine_op_import (ctx->engine, keydata, NULL); }
static gpgme_error_t spawn_start (gpgme_ctx_t ctx, int synchronous, const char *file, const char *argv[], gpgme_data_t datain, gpgme_data_t dataout, gpgme_data_t dataerr, unsigned int flags) { gpgme_error_t err; const char *tmp_argv[2]; if (ctx->protocol != GPGME_PROTOCOL_SPAWN) return gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL); err = _gpgme_op_reset (ctx, synchronous); if (err) return err; if (!argv) { tmp_argv[0] = _gpgme_get_basename (file); tmp_argv[1] = NULL; argv = tmp_argv; } return _gpgme_engine_op_spawn (ctx->engine, file, argv, datain, dataout, dataerr, flags); }
gpgme_error_t gpgme_op_trustlist_start (gpgme_ctx_t ctx, const char *pattern, int max_level) { gpgme_error_t err = 0; void *hook; op_data_t opd; if (!pattern || !*pattern) return gpg_error (GPG_ERR_INV_VALUE); err = _gpgme_op_reset (ctx, 2); if (err) return err; err = _gpgme_op_data_lookup (ctx, OPDATA_TRUSTLIST, &hook, sizeof (*opd), NULL); opd = hook; if (err) return err; _gpgme_engine_set_status_handler (ctx->engine, trustlist_status_handler, ctx); err = _gpgme_engine_set_colon_line_handler (ctx->engine, trustlist_colon_handler, ctx); if (err) return err; return _gpgme_engine_op_trustlist (ctx->engine, pattern); }
static gpgme_error_t genkey_start(gpgme_ctx_t ctx, int synchronous, const char *parms, gpgme_data_t pubkey, gpgme_data_t seckey) { gpgme_error_t err; void *hook; op_data_t opd; err = _gpgme_op_reset(ctx, synchronous); if(err) return err; err = _gpgme_op_data_lookup(ctx, OPDATA_GENKEY, &hook, sizeof(*opd), release_op_data); opd = hook; if(err) return err; err = get_key_parameter(parms, &opd->key_parameter); if(err) return err; _gpgme_engine_set_status_handler(ctx->engine, genkey_status_handler, ctx); return _gpgme_engine_op_genkey(ctx->engine, opd->key_parameter, ctx->use_armor, pubkey, seckey); }
static gpgme_error_t delete_start (gpgme_ctx_t ctx, int synchronous, const gpgme_key_t key, int allow_secret) { gpgme_error_t err; err = _gpgme_op_reset (ctx, synchronous); if (err) return err; _gpgme_engine_set_status_handler (ctx->engine, delete_status_handler, ctx); return _gpgme_engine_op_delete (ctx->engine, key, allow_secret); }
static gpgme_error_t _gpgme_op_import_keys_start (gpgme_ctx_t ctx, int synchronous, gpgme_key_t *keys) { gpgme_error_t err; void *hook; op_data_t opd; int idx, firstidx, nkeys; err = _gpgme_op_reset (ctx, synchronous); if (err) return err; err = _gpgme_op_data_lookup (ctx, OPDATA_IMPORT, &hook, sizeof (*opd), release_op_data); opd = hook; if (err) return err; opd->lastp = &opd->result.imports; if (!keys) return gpg_error (GPG_ERR_NO_DATA); for (idx=nkeys=0, firstidx=-1; keys[idx]; idx++) { /* We only consider keys of the current protocol. */ if (keys[idx]->protocol != ctx->protocol) continue; if (firstidx == -1) firstidx = idx; /* If a key has been found using a different key listing mode, we bail out. This makes the processing easier. Fixme: To allow a mix of keys we would need to sort them by key listing mode and start two import operations one after the other. */ if (keys[idx]->keylist_mode != keys[firstidx]->keylist_mode) return gpg_error (GPG_ERR_CONFLICT); nkeys++; } if (!nkeys) return gpg_error (GPG_ERR_NO_DATA); _gpgme_engine_set_status_handler (ctx->engine, import_status_handler, ctx); return _gpgme_engine_op_import (ctx->engine, NULL, keys); }
static gpgme_error_t verify_start (gpgme_ctx_t ctx, int synchronous, gpgme_data_t sig, gpgme_data_t signed_text, gpgme_data_t plaintext) { gpgme_error_t err; err = _gpgme_op_reset (ctx, synchronous); if (err) return err; err = _gpgme_op_verify_init_result (ctx); if (err) return err; _gpgme_engine_set_status_handler (ctx->engine, verify_status_handler, ctx); if (!sig) return gpg_error (GPG_ERR_NO_DATA); return _gpgme_engine_op_verify (ctx->engine, sig, signed_text, plaintext); }
static gpgme_error_t encrypt_sign_start (gpgme_ctx_t ctx, int synchronous, gpgme_key_t recp[], gpgme_encrypt_flags_t flags, gpgme_data_t plain, gpgme_data_t cipher) { gpgme_error_t err; err = _gpgme_op_reset (ctx, synchronous); if (err) return err; if (!plain) return gpg_error (GPG_ERR_NO_DATA); if (!cipher || !recp) return gpg_error (GPG_ERR_INV_VALUE); err = _gpgme_op_encrypt_init_result (ctx); if (err) return err; err = _gpgme_op_sign_init_result (ctx); if (err) return err; if (ctx->passphrase_cb) { err = _gpgme_engine_set_command_handler (ctx->engine, _gpgme_passphrase_command_handler, ctx, NULL); if (err) return err; } _gpgme_engine_set_status_handler (ctx->engine, encrypt_sign_status_handler, ctx); return _gpgme_engine_op_encrypt_sign (ctx->engine, recp, flags, plain, cipher, ctx->use_armor, ctx /* FIXME */); }
/* Public function to release load a configuration list. No asynchronous interface for now. */ gpgme_error_t gpgme_op_conf_load (gpgme_ctx_t ctx, gpgme_conf_comp_t *conf_p) { #ifdef ENABLE_GPGCONF gpgme_error_t err; gpgme_protocol_t proto; if (!ctx) return gpg_error (GPG_ERR_INV_VALUE); proto = ctx->protocol; ctx->protocol = GPGME_PROTOCOL_GPGCONF; err = _gpgme_op_reset (ctx, 1); if (err) return err; err = _gpgme_engine_op_conf_load (ctx->engine, conf_p); ctx->protocol = proto; return err; #else return gpg_error (GPG_ERR_NOT_IMPLEMENTED); #endif }
static gpgme_error_t opassuan_start (gpgme_ctx_t ctx, int synchronous, const char *command, gpgme_assuan_data_cb_t data_cb, void *data_cb_value, gpgme_assuan_inquire_cb_t inq_cb, void *inq_cb_value, gpgme_assuan_status_cb_t status_cb, void *status_cb_value) { gpgme_error_t err; if (!command || !*command) return gpg_error (GPG_ERR_INV_VALUE); /* The flag value 256 is used to suppress an engine reset. This is required to keep the connection running. */ err = _gpgme_op_reset (ctx, ((synchronous&255) | 256)); if (err) return err; { /* LEGACY: Remove this when removing the deprecated result structure. */ void *hook; op_data_t opd; err = _gpgme_op_data_lookup (ctx, OPDATA_ASSUAN, &hook, sizeof (*opd), NULL); if (err) return err; } return _gpgme_engine_op_assuan_transact (ctx->engine, command, data_cb, data_cb_value, inq_cb, inq_cb_value, status_cb, status_cb_value); }