From: Marcus Brinkmann Date: Tue, 7 Dec 2004 18:25:54 +0000 (+0000) Subject: 2004-12-07 Marcus Brinkmann X-Git-Tag: gpgme-1-1-0~70 X-Git-Url: http://git.tremily.us/?a=commitdiff_plain;h=0ebb858f1ea4ad3181e6dc71a98338e4e060db13;p=gpgme.git 2004-12-07 Marcus Brinkmann * libgpgme.vers (GPGME_1.1): New version. * engine-backend.h (struct engine_ops): Add argument FILE_NAME to member get_version(). Add arguments FILE_NAME and HOME_DIR to member new(). Change return type of get_file_name and get_version to char *. * engine-gpgsm.c (gpgsm_get_version): Change return type to char pointer. Do not cache result. (gpgsm_new): Add file_name and home_dir argument, and use them instead of the defaults, if set. * rungpg.c (struct engine_gpg): New member file_name. (gpg_get_version): Change return type to char pointer, and do not cache result. (gpg_release): Free gpg->file_name. (gpg_new): Take new arguments file_name and home_dir. Set the --homedir argument if HOME_DIR is not NULL. Set gpg->file_name. (start): Use gpg->file_name instead _gpgme_get_gpg_path, if set. * engine.h (_gpgme_engine_info_copy, _gpgme_engine_info_release): New prototypes. (_gpgme_engine_new): Change first argument to gpgme_engine_info_t info. * engine.c: Include . (gpgme_get_engine_info): Set *INFO within the lock. Move ENGINE_INFO and ENGINE_INFO_LOCK to .... (engine_info, engine_info_lock): ... here. New static variables. (engine_get_version): Add file_name argument to get_version invocation. Change return type to char pointer. (gpgme_engine_check_version): Rewritten to free() the return value of engine_get_version after using it. (_gpgme_engine_info_release): New function. (gpgme_get_engine_info): Rewritten. (_gpgme_engine_info_copy): New function. (_gpgme_set_engine_info): New function. (gpgme_set_engine_info): New function. (_gpgme_engine_new): Change first argument to gpgme_engine_info_t info, and use that. * gpgme.h (struct _gpgme_engine_info): Change type of file_name and version to char * (remove the const). New member home_dir. (gpgme_set_engine_info, gpgme_ctx_get_engine_info, gpgme_ctx_set_engine_info): New prototypes. * context.h (struct gpgme_context): New member engine_info. * gpgme.c (gpgme_new): Allocate CTX->engine_info. (gpgme_release): Deallocate CTX->engine_info. (gpgme_ctx_get_engine_info, gpgme_ctx_set_engine_info): New functions. * op-support.c (_gpgme_op_reset): Look for correct engine info and pass it to _gpgme_engine_new. * version.c (gpgme_check_version): Adjust to _gpgme_compare_versions returning an int. (_gpgme_compare_versions): Return an int value, not a const char pointer. * ops.h (_gpgme_compare_versions): Same for prototype. --- diff --git a/NEWS b/NEWS index cc545d3..6199788 100644 --- a/NEWS +++ b/NEWS @@ -1,3 +1,16 @@ +Noteworthy changes in version 1.1.0 (unreleased) +------------------------------------------------ + + * You can now configure the backend engine file name and home + directory to be used, as default and per context. + +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +gpgme_set_engine_info NEW +gpgme_ctx_get_engine_info NEW +gpgme_ctx_set_engine_info NEW +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + + Noteworthy changes in version 1.0.1 (2004-10-22) ------------------------------------------------ diff --git a/gpgme/ChangeLog b/gpgme/ChangeLog index 6b2539d..647fa19 100644 --- a/gpgme/ChangeLog +++ b/gpgme/ChangeLog @@ -1,3 +1,57 @@ +2004-12-07 Marcus Brinkmann + + * libgpgme.vers (GPGME_1.1): New version. + * engine-backend.h (struct engine_ops): Add argument FILE_NAME to + member get_version(). Add arguments FILE_NAME and HOME_DIR to + member new(). Change return type of get_file_name and get_version + to char *. + * engine-gpgsm.c (gpgsm_get_version): Change return type to char + pointer. Do not cache result. + (gpgsm_new): Add file_name and home_dir argument, and use them + instead of the defaults, if set. + * rungpg.c (struct engine_gpg): New member file_name. + (gpg_get_version): Change return type to char pointer, and do not + cache result. + (gpg_release): Free gpg->file_name. + (gpg_new): Take new arguments file_name and home_dir. Set the + --homedir argument if HOME_DIR is not NULL. Set gpg->file_name. + (start): Use gpg->file_name instead _gpgme_get_gpg_path, if set. + * engine.h (_gpgme_engine_info_copy, _gpgme_engine_info_release): + New prototypes. + (_gpgme_engine_new): Change first argument to gpgme_engine_info_t + info. + * engine.c: Include . + (gpgme_get_engine_info): Set *INFO within the lock. Move + ENGINE_INFO and ENGINE_INFO_LOCK to .... + (engine_info, engine_info_lock): ... here. New static variables. + (engine_get_version): Add file_name argument to + get_version invocation. Change return type to char pointer. + (gpgme_engine_check_version): Rewritten to free() the return value + of engine_get_version after using it. + (_gpgme_engine_info_release): New function. + (gpgme_get_engine_info): Rewritten. + (_gpgme_engine_info_copy): New function. + (_gpgme_set_engine_info): New function. + (gpgme_set_engine_info): New function. + (_gpgme_engine_new): Change first argument to gpgme_engine_info_t + info, and use that. + * gpgme.h (struct _gpgme_engine_info): Change type of file_name + and version to char * (remove the const). New member home_dir. + (gpgme_set_engine_info, gpgme_ctx_get_engine_info, + gpgme_ctx_set_engine_info): New prototypes. + * context.h (struct gpgme_context): New member engine_info. + * gpgme.c (gpgme_new): Allocate CTX->engine_info. + (gpgme_release): Deallocate CTX->engine_info. + (gpgme_ctx_get_engine_info, gpgme_ctx_set_engine_info): New + functions. + * op-support.c (_gpgme_op_reset): Look for correct engine info and + pass it to _gpgme_engine_new. + * version.c (gpgme_check_version): Adjust to + _gpgme_compare_versions returning an int. + (_gpgme_compare_versions): Return an int value, not a const char + pointer. + * ops.h (_gpgme_compare_versions): Same for prototype. + 2004-10-03 Marcus Brinkmann * verify.c (parse_trust): If no reason is provided, set diff --git a/gpgme/context.h b/gpgme/context.h index 64c5276..83ee6aa 100644 --- a/gpgme/context.h +++ b/gpgme/context.h @@ -62,6 +62,9 @@ typedef struct ctx_op_data *ctx_op_data_t; be performed (sequentially). */ struct gpgme_context { + /* The engine info for this context. */ + gpgme_engine_info_t engine_info; + /* The protocol used by this context. */ gpgme_protocol_t protocol; diff --git a/gpgme/engine-backend.h b/gpgme/engine-backend.h index 32fd242..bf481cf 100644 --- a/gpgme/engine-backend.h +++ b/gpgme/engine-backend.h @@ -30,10 +30,21 @@ struct engine_ops { /* Static functions. */ - const char *(*get_file_name) (void); - const char *(*get_version) (void); + + /* Return the default file name for the binary of this engine. */ + char *(*get_file_name) (void); + + /* Returns a malloced string containing the version of the engine + with the given binary file name (or the default if FILE_NAME is + NULL. */ + char *(*get_version) (const char *file_name); + + /* Returns a statically allocated string containing the required + version. */ const char *(*get_req_version) (void); + gpgme_error_t (*new) (void **r_engine, + const char *file_name, const char *home_dir, const char *lc_ctype, const char *lc_messages); /* Member functions. */ diff --git a/gpgme/engine-gpgsm.c b/gpgme/engine-gpgsm.c index 0138fdf..10952be 100644 --- a/gpgme/engine-gpgsm.c +++ b/gpgme/engine-gpgsm.c @@ -95,18 +95,11 @@ struct engine_gpgsm typedef struct engine_gpgsm *engine_gpgsm_t; -static const char * -gpgsm_get_version (void) +static char * +gpgsm_get_version (const char *file_name) { - static const char *gpgsm_version; - DEFINE_STATIC_LOCK (gpgsm_version_lock); - - LOCK (gpgsm_version_lock); - if (!gpgsm_version) - gpgsm_version = _gpgme_get_program_version (_gpgme_get_gpgsm_path ()); - UNLOCK (gpgsm_version_lock); - - return gpgsm_version; + return _gpgme_get_program_version (file_name ? file_name + : _gpgme_get_gpgsm_path ()); } @@ -319,11 +312,13 @@ gpgsm_release (void *engine) static gpgme_error_t -gpgsm_new (void **engine, const char *lc_ctype, const char *lc_messages) +gpgsm_new (void **engine, const char *file_name, const char *home_dir, + const char *lc_ctype, const char *lc_messages) { gpgme_error_t err = 0; engine_gpgsm_t gpgsm; - char *argv[3]; + char *argv[5]; + int argc; int fds[2]; int child_fds[4]; char *dft_display = NULL; @@ -395,12 +390,19 @@ gpgsm_new (void **engine, const char *lc_ctype, const char *lc_messages) child_fds[2] = gpgsm->message_fd_server; child_fds[3] = -1; - argv[0] = "gpgsm"; - argv[1] = "--server"; - argv[2] = NULL; + argc = 0; + argv[argc++] = "gpgsm"; + if (home_dir) + { + argv[argc++] = "--homedir"; + argv[argc++] = home_dir; + } + argv[argc++] = "--server"; + argv[argc++] = NULL; err = assuan_pipe_connect (&gpgsm->assuan_ctx, - _gpgme_get_gpgsm_path (), argv, child_fds); + file_name ? file_name : _gpgme_get_gpgsm_path (), + argv, child_fds); /* FIXME: Check error. */ /* We need to know the fd used by assuan for reads. We do this by diff --git a/gpgme/engine.c b/gpgme/engine.c index 6128c2f..f2edc7d 100644 --- a/gpgme/engine.c +++ b/gpgme/engine.c @@ -24,6 +24,7 @@ #include #include #include +#include #include "gpgme.h" #include "util.h" @@ -51,9 +52,14 @@ static struct engine_ops *engine_ops[] = #endif }; + +/* The engine info. */ +static gpgme_engine_info_t engine_info; +DEFINE_STATIC_LOCK (engine_info_lock); + /* Get the file name of the engine for PROTOCOL. */ -static const char * +static char * engine_get_file_name (gpgme_protocol_t proto) { if (proto > DIM (engine_ops)) @@ -66,15 +72,16 @@ engine_get_file_name (gpgme_protocol_t proto) } -/* Get the version number of the engine for PROTOCOL. */ -static const char * -engine_get_version (gpgme_protocol_t proto) +/* Get a malloced string containing the version number of the engine + for PROTOCOL. */ +static char * +engine_get_version (gpgme_protocol_t proto, const char *file_name) { if (proto > DIM (engine_ops)) return NULL; if (engine_ops[proto] && engine_ops[proto]->get_version) - return (*engine_ops[proto]->get_version) (); + return (*engine_ops[proto]->get_version) (file_name); else return NULL; } @@ -98,21 +105,45 @@ engine_get_req_version (gpgme_protocol_t proto) gpgme_error_t gpgme_engine_check_version (gpgme_protocol_t proto) { - return _gpgme_compare_versions (engine_get_version (proto), - engine_get_req_version (proto)) - ? 0 : gpg_error (GPG_ERR_INV_ENGINE); + int result; + char *engine_version = engine_get_version (proto, NULL); + + result = _gpgme_compare_versions (engine_version, + engine_get_req_version (proto)); + if (engine_version) + free (engine_version); + + return result ? 0 : gpg_error (GPG_ERR_INV_ENGINE); +} + + +/* Release the engine info INFO. */ +void +_gpgme_engine_info_release (gpgme_engine_info_t info) +{ + while (info) + { + gpgme_engine_info_t next_info = info->next; + + assert (info->file_name); + free (info->file_name); + if (info->home_dir) + free (info->home_dir); + if (info->version) + free (info->version); + free (info); + info = next_info; + } } /* Get the information about the configured and installed engines. A pointer to the first engine in the statically allocated linked list - is returned in *INFO. If an error occurs, it is returned. */ + is returned in *INFO. If an error occurs, it is returned. The + returned data is valid until the next gpgme_set_engine_info. */ gpgme_error_t gpgme_get_engine_info (gpgme_engine_info_t *info) { - static gpgme_engine_info_t engine_info; - DEFINE_STATIC_LOCK (engine_info_lock); - LOCK (engine_info_lock); if (!engine_info) { @@ -123,70 +154,238 @@ gpgme_get_engine_info (gpgme_engine_info_t *info) for (proto = 0; proto < DIM (proto_list); proto++) { - const char *file_name = engine_get_file_name (proto_list[proto]); + char *file_name = engine_get_file_name (proto_list[proto]); if (!file_name) continue; + file_name = strdup (file_name); + *lastp = malloc (sizeof (*engine_info)); - if (!*lastp) + if (!*lastp || !file_name) { int saved_errno = errno; - while (engine_info) - { - gpgme_engine_info_t next_info = engine_info->next; - free (engine_info); - engine_info = next_info; - } + _gpgme_engine_info_release (engine_info); + engine_info = NULL; + + if (file_name) + free (file_name); + UNLOCK (engine_info_lock); return gpg_error_from_errno (saved_errno); } (*lastp)->protocol = proto_list[proto]; (*lastp)->file_name = file_name; - (*lastp)->version = engine_get_version (proto_list[proto]); + (*lastp)->home_dir = NULL; + (*lastp)->version = engine_get_version (proto_list[proto], NULL); (*lastp)->req_version = engine_get_req_version (proto_list[proto]); (*lastp)->next = NULL; lastp = &(*lastp)->next; } } - UNLOCK (engine_info_lock); + *info = engine_info; + UNLOCK (engine_info_lock); return 0; } - + +/* Get a deep copy of the engine info and return it in INFO. */ gpgme_error_t -_gpgme_engine_new (gpgme_protocol_t proto, engine_t *r_engine, - const char *lc_ctype, const char *lc_messages) +_gpgme_engine_info_copy (gpgme_engine_info_t *r_info) { - engine_t engine; + gpgme_error_t err = 0; + gpgme_engine_info_t info; + gpgme_engine_info_t new_info; + gpgme_engine_info_t *lastp; + + LOCK (engine_info_lock); + info = engine_info; + if (!info) + { + /* Make sure it is initialized. */ + UNLOCK (engine_info_lock); + err = gpgme_get_engine_info (&info); + if (err) + return err; + + LOCK (engine_info_lock); + } + + new_info = NULL; + lastp = &new_info; + + while (info) + { + char *file_name; + char *home_dir; + char *version; + + assert (info->file_name); + file_name = strdup (info->file_name); + + if (info->home_dir) + { + home_dir = strdup (info->home_dir); + if (!home_dir) + err = gpg_error_from_errno (errno); + } + else + home_dir = NULL; + + if (info->version) + { + version = strdup (info->version); + if (!version) + err = gpg_error_from_errno (errno); + } + else + version = NULL; + + *lastp = malloc (sizeof (*engine_info)); + if (!*lastp || !file_name || err) + { + int saved_errno = errno; + + _gpgme_engine_info_release (new_info); + + if (file_name) + free (file_name); + if (home_dir) + free (home_dir); + if (version) + free (version); + + UNLOCK (engine_info_lock); + return gpg_error_from_errno (saved_errno); + } - const char *file_name; - const char *version; + (*lastp)->protocol = info->protocol; + (*lastp)->file_name = file_name; + (*lastp)->home_dir = home_dir; + (*lastp)->version = version; + (*lastp)->req_version = info->req_version; + (*lastp)->next = NULL; + lastp = &(*lastp)->next; + info = info->next; + } + + *r_info = new_info; + UNLOCK (engine_info_lock); + return 0; +} + + +/* Set the engine info for the info list INFO, protocol PROTO, to the + file name FILE_NAME and the home directory HOME_DIR. */ +gpgme_error_t +_gpgme_set_engine_info (gpgme_engine_info_t info, gpgme_protocol_t proto, + const char *file_name, const char *home_dir) +{ + char *new_file_name; + char *new_home_dir; + + /* FIXME: Use some PROTO_MAX definition. */ if (proto > DIM (engine_ops)) return gpg_error (GPG_ERR_INV_VALUE); - if (!engine_ops[proto]) + while (info && info->protocol != proto) + info = info->next; + + if (!info) return gpg_error (GPG_ERR_INV_ENGINE); - file_name = engine_get_file_name (proto); - version = engine_get_version (proto); - if (!file_name || !version) + /* Prepare new members. */ + if (file_name) + new_file_name = strdup (file_name); + else + { + new_file_name = engine_get_file_name (proto); + assert (file_name); + new_file_name = strdup (new_file_name); + } + if (!new_file_name) + return gpg_error_from_errno (errno); + + if (home_dir) + { + new_home_dir = strdup (home_dir); + if (!new_home_dir) + { + free (new_file_name); + return gpg_error_from_errno (errno); + } + } + else + new_home_dir = NULL; + + /* Remove the old members. */ + assert (info->file_name); + free (info->file_name); + if (info->home_dir) + free (info->home_dir); + if (info->version) + free (info->version); + + /* Install the new members. */ + info->file_name = new_file_name; + info->home_dir = new_home_dir; + info->version = engine_get_version (proto, file_name); + + return 0; +} + + +/* Set the default engine info for the protocol PROTO to the file name + FILE_NAME and the home directory HOME_DIR. */ +gpgme_error_t +gpgme_set_engine_info (gpgme_protocol_t proto, + const char *file_name, const char *home_dir) +{ + gpgme_error_t err; + gpgme_engine_info_t info; + + LOCK (engine_info_lock); + info = engine_info; + if (!info) + { + /* Make sure it is initialized. */ + UNLOCK (engine_info_lock); + err = gpgme_get_engine_info (&info); + if (err) + return err; + + LOCK (engine_info_lock); + } + + err = _gpgme_set_engine_info (info, proto, file_name, home_dir); + UNLOCK (engine_info_lock); + return err; +} + + +gpgme_error_t +_gpgme_engine_new (gpgme_engine_info_t info, engine_t *r_engine, + const char *lc_ctype, const char *lc_messages) +{ + engine_t engine; + + if (!info->file_name || !info->version) return gpg_error (GPG_ERR_INV_ENGINE); engine = calloc (1, sizeof *engine); if (!engine) return gpg_error_from_errno (errno); - engine->ops = engine_ops[proto]; - if (engine_ops[proto]->new) + engine->ops = engine_ops[info->protocol]; + if (engine->ops->new) { - gpgme_error_t err = (*engine_ops[proto]->new) (&engine->engine, - lc_ctype, - lc_messages); + gpgme_error_t err = (*engine->ops->new) (&engine->engine, + info->file_name, info->home_dir, + lc_ctype, lc_messages); if (err) { free (engine); diff --git a/gpgme/engine.h b/gpgme/engine.h index 42cec55..72659cd 100644 --- a/gpgme/engine.h +++ b/gpgme/engine.h @@ -35,7 +35,14 @@ typedef gpgme_error_t (*engine_command_handler_t) (void *priv, const char *keyword, int fd); -gpgme_error_t _gpgme_engine_new (gpgme_protocol_t proto, +/* Get a deep copy of the engine info and return it in INFO. */ +gpgme_error_t _gpgme_engine_info_copy (gpgme_engine_info_t *r_info); + +/* Release the engine info INFO. */ +void _gpgme_engine_info_release (gpgme_engine_info_t info); + + +gpgme_error_t _gpgme_engine_new (gpgme_engine_info_t info, engine_t *r_engine, const char *lc_ctype, const char *lc_messages); diff --git a/gpgme/gpgme.c b/gpgme/gpgme.c index de70767..d89a8db 100644 --- a/gpgme/gpgme.c +++ b/gpgme/gpgme.c @@ -50,6 +50,14 @@ gpgme_new (gpgme_ctx_t *r_ctx) ctx = calloc (1, sizeof *ctx); if (!ctx) return gpg_error_from_errno (errno); + + _gpgme_engine_info_copy (&ctx->engine_info); + if (!ctx->engine_info) + { + free (ctx); + return gpg_error_from_errno (errno); + } + ctx->keylist_mode = GPGME_KEYLIST_MODE_LOCAL; ctx->include_certs = 1; ctx->protocol = GPGME_PROTOCOL_OpenPGP; @@ -62,6 +70,7 @@ gpgme_new (gpgme_ctx_t *r_ctx) if (!ctx->lc_ctype) { UNLOCK (def_lc_lock); + _gpgme_engine_info_release (ctx->engine_info); free (ctx); return gpg_error_from_errno (errno); } @@ -77,6 +86,7 @@ gpgme_new (gpgme_ctx_t *r_ctx) UNLOCK (def_lc_lock); if (ctx->lc_ctype) free (ctx->lc_ctype); + _gpgme_engine_info_release (ctx->engine_info); free (ctx); return gpg_error_from_errno (errno); } @@ -120,6 +130,7 @@ gpgme_release (gpgme_ctx_t ctx) free (ctx->lc_ctype); if (ctx->lc_messages) free (ctx->lc_messages); + _gpgme_engine_info_release (ctx->engine_info); free (ctx); } @@ -389,6 +400,29 @@ gpgme_set_locale (gpgme_ctx_t ctx, int category, const char *value) return 0; } + +/* Get the information about the configured engines. A pointer to the + first engine in the statically allocated linked list is returned. + The returned data is valid until the next gpgme_ctx_set_engine_info. */ +gpgme_engine_info_t +gpgme_ctx_get_engine_info (gpgme_ctx_t ctx) +{ + return ctx->engine_info; +} + + +/* Set the engine info for the context CTX, protocol PROTO, to the + file name FILE_NAME and the home directory HOME_DIR. */ +gpgme_error_t +gpgme_ctx_set_engine_info (gpgme_ctx_t ctx, gpgme_protocol_t proto, + const char *file_name, const char *home_dir) +{ + /* FIXME: Make sure to reset the context if we are running in daemon + mode. */ + return _gpgme_set_engine_info (ctx->engine_info, proto, + file_name, home_dir); +} + const char * gpgme_pubkey_algo_name (gpgme_pubkey_algo_t algo) diff --git a/gpgme/gpgme.h b/gpgme/gpgme.h index ffcfe0e..3048472 100644 --- a/gpgme/gpgme.h +++ b/gpgme/gpgme.h @@ -412,13 +412,16 @@ struct _gpgme_engine_info gpgme_protocol_t protocol; /* The file name of the engine binary. */ - const char *file_name; - + char *file_name; + /* The version string of the installed engine. */ - const char *version; + char *version; /* The minimum version required for GPGME. */ const char *req_version; + + /* The home directory used, or NULL if default. */ + char *home_dir; }; typedef struct _gpgme_engine_info *gpgme_engine_info_t; @@ -741,6 +744,19 @@ void gpgme_get_progress_cb (gpgme_ctx_t ctx, gpgme_progress_cb_t *cb, locale if CTX is a null pointer. */ gpgme_error_t gpgme_set_locale (gpgme_ctx_t ctx, int category, const char *value); + +/* Get the information about the configured engines. A pointer to the + first engine in the statically allocated linked list is returned. + The returned data is valid until the next gpgme_ctx_set_engine_info. */ +gpgme_engine_info_t gpgme_ctx_get_engine_info (gpgme_ctx_t ctx); + +/* Set the engine info for the context CTX, protocol PROTO, to the + file name FILE_NAME and the home directory HOME_DIR. */ +gpgme_error_t gpgme_ctx_set_engine_info (gpgme_ctx_t ctx, + gpgme_protocol_t proto, + const char *file_name, + const char *home_dir); + /* Return a statically allocated string with the name of the public key algorithm ALGO, or NULL if that name is not known. */ @@ -1501,9 +1517,18 @@ int gpgme_trust_item_get_int_attr (gpgme_trust_item_t item, _gpgme_attr_t what, /* Check that the library fulfills the version requirement. */ const char *gpgme_check_version (const char *req_version); -/* Retrieve information about the backend engines. */ +/* Get the information about the configured and installed engines. A + pointer to the first engine in the statically allocated linked list + is returned in *INFO. If an error occurs, it is returned. The + returned data is valid until the next gpgme_set_engine_info. */ gpgme_error_t gpgme_get_engine_info (gpgme_engine_info_t *engine_info); +/* Set the default engine info for the protocol PROTO to the file name + FILE_NAME and the home directory HOME_DIR. */ +gpgme_error_t gpgme_set_engine_info (gpgme_protocol_t proto, + const char *file_name, + const char *home_dir); + /* Engine support functions. */ diff --git a/gpgme/libgpgme.vers b/gpgme/libgpgme.vers index 9bef503..a16d37f 100644 --- a/gpgme/libgpgme.vers +++ b/gpgme/libgpgme.vers @@ -18,6 +18,15 @@ # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA +GPGME_1.1 { + global: + gpgme_set_engine_info; + + gpgme_ctx_get_engine_info; + gpgme_ctx_set_engine_info; +}; + + GPGME_1.0 { global: gpgme_check_version; diff --git a/gpgme/op-support.c b/gpgme/op-support.c index be42e75..7321af4 100644 --- a/gpgme/op-support.c +++ b/gpgme/op-support.c @@ -66,17 +66,26 @@ gpgme_error_t _gpgme_op_reset (gpgme_ctx_t ctx, int type) { gpgme_error_t err = 0; + gpgme_engine_info_t info; struct gpgme_io_cbs io_cbs; + info = ctx->engine_info; + while (info && info->protocol != ctx->protocol) + info = info->next; + + if (!info) + return gpg_error (GPG_ERR_UNSUPPORTED_PROTOCOL); + _gpgme_release_result (ctx); - /* Create an engine object. */ - if (ctx->engine) + if (ctx->engine) { _gpgme_engine_release (ctx->engine); ctx->engine = NULL; } - err = _gpgme_engine_new (ctx->protocol, &ctx->engine, + + /* Create an engine object. */ + err = _gpgme_engine_new (info, &ctx->engine, ctx->lc_ctype, ctx->lc_messages); if (err) return err; diff --git a/gpgme/ops.h b/gpgme/ops.h index f01cc9a..79ac7d4 100644 --- a/gpgme/ops.h +++ b/gpgme/ops.h @@ -136,8 +136,10 @@ void _gpgme_op_trustlist_event_cb (void *data, gpgme_event_io_t type, /*-- version.c --*/ -const char *_gpgme_compare_versions (const char *my_version, - const char *req_version); +/* Return true if MY_VERSION is at least REQ_VERSION, and false + otherwise. */ +int _gpgme_compare_versions (const char *my_version, + const char *req_version); char *_gpgme_get_program_version (const char *const path); #endif /* OPS_H */ diff --git a/gpgme/rungpg.c b/gpgme/rungpg.c index ce938c6..3d7d4c8 100644 --- a/gpgme/rungpg.c +++ b/gpgme/rungpg.c @@ -66,6 +66,8 @@ struct fd_data_map_s struct engine_gpg { + char *file_name; + struct arg_and_data_s *arglist; struct arg_and_data_s **argtail; @@ -224,17 +226,11 @@ add_data (engine_gpg_t gpg, gpgme_data_t data, int dup_to, int inbound) } -static const char * -gpg_get_version (void) +static char * +gpg_get_version (const char *file_name) { - static const char *gpg_version; - DEFINE_STATIC_LOCK (gpg_version_lock); - - LOCK (gpg_version_lock); - if (!gpg_version) - gpg_version = _gpgme_get_program_version (_gpgme_get_gpg_path ()); - UNLOCK (gpg_version_lock); - return gpg_version; + return _gpgme_get_program_version (file_name ? file_name + : _gpgme_get_gpg_path ()); } @@ -313,6 +309,9 @@ gpg_release (void *engine) gpg_cancel (engine); + if (gpg->file_name) + free (gpg->file_name); + while (gpg->arglist) { struct arg_and_data_s *next = gpg->arglist->next; @@ -336,7 +335,8 @@ gpg_release (void *engine) static gpgme_error_t -gpg_new (void **engine, const char *lc_ctype, const char *lc_messages) +gpg_new (void **engine, const char *file_name, const char *home_dir, + const char *lc_ctype, const char *lc_messages) { engine_gpg_t gpg; gpgme_error_t rc = 0; @@ -345,6 +345,16 @@ gpg_new (void **engine, const char *lc_ctype, const char *lc_messages) if (!gpg) return gpg_error_from_errno (errno); + if (file_name) + { + gpg->file_name = strdup (file_name); + if (!gpg->file_name) + { + rc = gpg_error_from_errno (errno); + goto leave; + } + } + gpg->argtail = &gpg->arglist; gpg->status.fd[0] = -1; gpg->status.fd[1] = -1; @@ -380,6 +390,16 @@ gpg_new (void **engine, const char *lc_ctype, const char *lc_messages) goto leave; } gpg->status.eof = 0; + + if (home_dir) + { + rc = add_arg (gpg, "--homedir"); + if (!rc) + rc = add_arg (gpg, home_dir); + if (rc) + goto leave; + } + rc = add_arg (gpg, "--status-fd"); if (rc) goto leave; @@ -1043,7 +1063,7 @@ start (engine_gpg_t gpg) if (!gpg) return gpg_error (GPG_ERR_INV_VALUE); - if (! _gpgme_get_gpg_path ()) + if (!gpg->file_name && !_gpgme_get_gpg_path ()) return gpg_error (GPG_ERR_INV_ENGINE); rc = build_argv (gpg); @@ -1101,7 +1121,8 @@ start (engine_gpg_t gpg) fd_parent_list[n].fd = -1; fd_parent_list[n].dup_to = -1; - status = _gpgme_io_spawn (_gpgme_get_gpg_path (), + status = _gpgme_io_spawn (gpg->file_name ? gpg->file_name : + _gpgme_get_gpg_path (), gpg->argv, fd_child_list, fd_parent_list); saved_errno = errno; free (fd_child_list); diff --git a/gpgme/version.c b/gpgme/version.c index e2c4ef8..d4d7864 100644 --- a/gpgme/version.c +++ b/gpgme/version.c @@ -103,7 +103,9 @@ parse_version_string (const char *str, int *major, int *minor, int *micro) } -const char * +/* Return true if MY_VERSION is at least REQ_VERSION, and false + otherwise. */ +int _gpgme_compare_versions (const char *my_version, const char *rq_version) { @@ -112,17 +114,17 @@ _gpgme_compare_versions (const char *my_version, const char *my_plvl, *rq_plvl; if (!rq_version) - return my_version; + return 1; if (!my_version) - return NULL; + return 0; my_plvl = parse_version_string (my_version, &my_major, &my_minor, &my_micro); if (!my_plvl) - return NULL; + return 0; rq_plvl = parse_version_string (rq_version, &rq_major, &rq_minor, &rq_micro); if (!rq_plvl) - return NULL; + return 0; if (my_major > rq_major || (my_major == rq_major && my_minor > rq_minor) @@ -130,9 +132,9 @@ _gpgme_compare_versions (const char *my_version, && my_micro > rq_micro) || (my_major == rq_major && my_minor == rq_minor && my_micro == rq_micro && strcmp (my_plvl, rq_plvl) >= 0)) - return my_version; + return 1; - return NULL; + return 0; } @@ -149,7 +151,7 @@ const char * gpgme_check_version (const char *req_version) { do_subsystem_inits (); - return _gpgme_compare_versions (VERSION, req_version); + return _gpgme_compare_versions (VERSION, req_version) ? VERSION : NULL; }