* 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 <assert.h>.
(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.
+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)
------------------------------------------------
+2004-12-07 Marcus Brinkmann <marcus@g10code.de>
+
+ * 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 <assert.h>.
+ (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 <marcus@g10code.de>
* verify.c (parse_trust): If no reason is provided, set
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;
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. */
typedef struct engine_gpgsm *engine_gpgsm_t;
\f
-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 ());
}
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;
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
#include <stdlib.h>
#include <string.h>
#include <errno.h>
+#include <assert.h>
#include "gpgme.h"
#include "util.h"
#endif
};
+
+/* The engine info. */
+static gpgme_engine_info_t engine_info;
+DEFINE_STATIC_LOCK (engine_info_lock);
+
\f
/* 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))
}
-/* 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;
}
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)
{
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;
}
-\f
+
+/* 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;
+}
+
+\f
+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);
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);
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;
if (!ctx->lc_ctype)
{
UNLOCK (def_lc_lock);
+ _gpgme_engine_info_release (ctx->engine_info);
free (ctx);
return gpg_error_from_errno (errno);
}
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);
}
free (ctx->lc_ctype);
if (ctx->lc_messages)
free (ctx->lc_messages);
+ _gpgme_engine_info_release (ctx->engine_info);
free (ctx);
}
return 0;
}
+\f
+/* 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);
+}
+
\f
const char *
gpgme_pubkey_algo_name (gpgme_pubkey_algo_t algo)
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;
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);
+
\f
/* Return a statically allocated string with the name of the public
key algorithm ALGO, or NULL if that name is not known. */
/* 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);
+
\f
/* Engine support functions. */
# 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;
_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;
\f
/*-- 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 */
struct engine_gpg
{
+ char *file_name;
+
struct arg_and_data_s *arglist;
struct arg_and_data_s **argtail;
}
\f
-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 ());
}
gpg_cancel (engine);
+ if (gpg->file_name)
+ free (gpg->file_name);
+
while (gpg->arglist)
{
struct arg_and_data_s *next = gpg->arglist->next;
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;
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;
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;
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);
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);
}
-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)
{
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)
&& 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;
}
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;
}
\f
projects / gpgme.git / commitdiff