GpgFrontend/gpgme
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

doc/

Browse Source 
2003-05-29  Marcus Brinkmann  <marcus@g10code.de>

	* gpgme.texi (Exporting Keys): Change and document prototypes.
	Add new gpgme_op_export_ext and gpgme_op_export_ext_start
	variants.
	(Selecting Recipients): Section removed.
	(Encrypting a Plaintext): Change prototypes and document the
	changes.

gpgme/
2003-05-29  Marcus Brinkmann  <marcus@g10code.de>

	* gpgme.h (gpgme_op_export_start): Change second arg to const char *.
	(gpgme_op_export): Likewise.
	(gpgme_op_export_ext_start): New prototype.
	(gpgme_op_export_ext): Likewise.
	* engine.h: Likewise for _gpgme_engine_op_export and
	_gpgme_engine_op_export_ext.
	* engine-backend.h (struct engine_ops): Change second argument of
	prototype of export to const char *, and add reserverd int as
	third argument.  Add prototype for export_ext.
	* engine.c (_gpgme_engine_op_export_ext): New function.
	(_gpgme_engine_op_export): Change second argument of prototype of
	export to const char *, and add reserverd int as third argument.
	* rungpg.c (gpg_export): Change second argument of prototype of
	export to const char *, and add reserverd int as third argument.
	(gpg_export_ext): New function.
	(gpg_keylist_ext): Break loop at error.
	(_gpgme_engine_ops_gpg): Add gpg_export_ext.
	* engine-gpgsm.c (gpgsm_export): Change second argument of
	prototype of export to const char *, and add reserverd int as
	third argument.
	(gpgsm_export_ext): New function.
	(_gpgme_engine_ops_gpgsm): Add gpgsm_export_ext.
	* export.c (export_start): Change second argument of prototype of
	export to const char *, and add reserverd int as third argument.
	(gpgme_op_export_start): Likewise.
	(export_ext_start): New function.
	(gpgme_op_export_ext_start): Likewise.
	(gpgme_op_export_ext): Likewise.

	* gpgme.h (gpgme_keylist_mode_t): New type for anonymous enum.
	(gpgme_sigsum_t): New type for anonymous enum.

	* encrypt-sign.c (encrypt_sign_start): Check for errors earlier,
	and return an error if RECP is not set.

	* Makefile.am (libgpgme_la_SOURCES): Remove user-id.c.
	* user-id.c: Remove file.
	* ops.h: Remove prototype for _gpgme_user_ids_all_valid.
	* gpgme.h (gpgme_encrypt_flags_t): New type.
	(gpgme_op_encrypt_start): Change second parameter to type
	gpgme_key_t[], and add third parameter.
	(gpgme_op_encrypt): Likewise.
	(gpgme_op_encrypt_sign_start): Likewise.
	(gpgme_op_encrypt_sign): Likewise.
	* encrypt.c (encrypt_start): Likewise.
	(gpgme_op_encrypt_start): Likewise.
	(gpgme_op_encrypt): Likewise.  Pass flags to engine.
	* encrypt-sign.c (encrypt_sign_start): Likewise.
	(gpgme_op_encrypt_sign_start): Likewise.
	(gpgme_op_encrypt_sign): Likewise.
	* engine-backend.h (struct engine_ops): Likewise for prototypes of
	encrypt and encrypt_sign.
	* engine.h: Likewise for prototypes of _gpgme_engine_op_encrypt
	and _gpgme_engine_op_encrypt_sign.
	* engine.c (_gpgme_engine_op_encrypt): Likewise.
	(_gpgme_engine_op_encrypt_sign): Likewise.
	* rungpg.c (gpg_encrypt): Likewise.
	(gpg_encrypt_sign): Likewise.
	* rungpg.c (gpg_encrypt): Check flags for always trust option.
	* engine-gpgsm.c (gpgsm_encrypt): Likewise.
	(set_recipients): Rewritten to use keys instead user IDs.
	* rungpg.c (append_args_from_recipients): Rewritten to use keys
	instead user IDs.
	* encrypt.c (_gpgme_encrypt_status_handler): Change errors
	returned to GPGME_Invalid_Key and GPGME_General_Error.

tests/
2003-05-29  Marcus Brinkmann  <marcus@g10code.de>

	* gpg/t-encrypt-sym.c (main): Adapt to new syntax.
	* gpg/t-encrypt.c (main): Likewise.
	* gpg/t-eventloop.c (main): Likewise.
	* gpg/t-encrypt-sign.c (main): Likewise.
	* gpgsm/t-export.c (main): Likewise.
	* gpgsm/t-encrypt.c (main): Likewise.
This commit is contained in:
Marcus Brinkmann 2003-05-29 03:21:02 +00:00
parent 8585e1cc53
commit 8f8c78d534
26 changed files with 752 additions and 736 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
NEWS
View File

@ -95,36 +95,21 @@ Noteworthy changes in version 0.4.1 (unreleased)
The user is expected to write the response to the file descriptor,
followed by a newline.
* The recipients interface has been removed and replaced by a more
generic and light gpgme_user_ids_* interface, which only provides
two functions: gpgme_user_ids_append adds a new user ID at the end
of the linked list, and gpgme_user_ids_release releases all user
IDs in the linked list. The resulting user ID object is free for
the user to change (note however that gpgme_user_ids_release only
releases resources allocated by GPGME).
* The recipients interface has been removed. Instead, you use
NULL-terminated lists of keys for specifying the recipients of an
encryption operation. Use the new encryption flag
GPGME_ENCRYPT_ALWAYS_TRUST if you want to override the validity of
the keys (but note that in general this is not a good idea).
This change propagates to the prototypes of gpgme_op_encrypt,
This change has been made to the prototypes of gpgme_op_encrypt,
gpgme_op_encrypt_start, gpgme_op_encrypt_sign and
gpgme_op_encrypt_sign_start. Also the prototypes of
gpgme_op_export_start and gpgme_op_export finally make sense.
gpgme_op_encrypt_sign_start.
Here is an example how to use the new interface:
gpgme_user_id_t rset = NULL;
gpgme_user_id_t *rset_lastp = &rset;
err = gpgme_user_ids_append (rset_lastp, "Alpha");
fail_if_err (err);
(*rset_lastp)->validity = GPGME_VALIDITY_FULL;
rset_lastp = &(*rset_lastp)->next;
err = gpgme_user_ids_append (rset_lastp, "Bob");
fail_if_err (err);
(*rset_lastp)->validity = GPGME_VALIDITY_FULL;
[...]
gpgme_user_ids_release (rset);
The export interface has been changed to use pattern strings like
the keylist interface. Thus, new functions gpgme_op_export_ext and
gpgme_op_export_ext_start have been added as well. Now the
prototypes of gpgme_op_export_start and gpgme_op_export finally
make sense.
* gpgme_op_verify and gpgme_op_decrypt_verify don't return a status
summary anymore. Use gpgme_get_sig_status to retrieve the individual
@ -308,23 +293,27 @@ gpgme_op_decrypt_verify CHANGED: Drop R_STAT argument.
gpgme_wait CHANGED: Can return NULL even if hang is true.
GpgmeIdleFunc REMOVED
gpgme_register_idle REMOVED
GpgmeRecipients REMOVED: Use gpgme_user_id_t.
gpgme_recipients_new REMOVED: Initialize gpgme_user_id_t with NULL.
gpgme_recipients_release REMOVED: Use gpgme_user_ids_release.
gpgme_recipients_add_name REMOVED: Use gpgme_user_ids_append
gpgme_recipients_add_name_with_validity REMOVED: Set validity directly.
gpgme_recipients_count REMOVED: You can count them yourself.
gpgme_recipients_enum_open REMOVED: gpgme_user_id_t is a linked list.
gpgme_recipients_enum_read REMOVED: See gpgme_recipients_enum_open.
gpgme_recipients_enum_close REMOVED: See gpgme_recipients_enum_read.
gpgme_user_ids_append NEW
gpgme_user_ids_release NEW
gpgme_op_encrypt CHANGED: Recipients passed as gpgme_user_id_t.
gpgme_op_encrypt_start CHANGED: Recipients passed as gpgme_user_id_t.
gpgme_op_encrypt_sign CHANGED: Recipients passed as gpgme_user_id_t.
gpgme_op_encrypt_sign_start CHANGED: Recipients passed as gpgme_user_id_t.
gpgme_op_export_start CHANGED: User IDs passed as gpgme_user_id_t.
gpgme_op_export CHANGED: User IDs passed as gpgme_user_id_t.
GpgmeRecipients REMOVED
gpgme_recipients_new REMOVED
gpgme_recipients_release REMOVED
gpgme_recipients_add_name REMOVED
gpgme_recipients_add_name_with_validity REMOVED
gpgme_recipients_count REMOVED
gpgme_recipients_enum_open REMOVED
gpgme_recipients_enum_read REMOVED
gpgme_recipients_enum_close REMOVED
gpgme_encrypt_flags_t NEW
GPGME_ENCRYPT_ALWAYS_TRUST NEW
gpgme_op_encrypt CHANGED: Recipients passed as gpgme_key_t[].
gpgme_op_encrypt_start CHANGED: Recipients passed as gpgme_key_t[].
gpgme_op_encrypt_sign CHANGED: Recipients passed as gpgme_key_t[].
gpgme_op_encrypt_sign_start CHANGED: Recipients passed as gpgme_key_t[].
gpgme_op_export_start CHANGED: User IDs passed as patterns.
gpgme_op_export CHANGED: User IDs passed as patterns.
gpgme_op_export_ext_start NEW
gpgme_op_export_ext NEW
gpgme_keylist_mode_t NEW
gpgme_sigsum_t NEW
gpgme_engine_info_t NEW
gpgme_get_engine_info CHANGED: Return info structure instead XML.
gpgme_get_protocol_name NEW

9
doc/ChangeLog
View File

@ -1,3 +1,12 @@
2003-05-29 Marcus Brinkmann <marcus@g10code.de>
* gpgme.texi (Exporting Keys): Change and document prototypes.
Add new gpgme_op_export_ext and gpgme_op_export_ext_start
variants.
(Selecting Recipients): Section removed.
(Encrypting a Plaintext): Change prototypes and document the
changes.
2003-05-28 Marcus Brinkmann <marcus@g10code.de>
* gpgme.texi (Exporting Keys): Change argument type from

177
doc/gpgme.texi
View File

@ -189,7 +189,6 @@ Sign
Encrypt
* Selecting Recipients:: How to choose the recipients.
* Encrypting a Plaintext:: How to encrypt a plaintext.
Run Control
@ -1630,7 +1629,7 @@ certificates to include into an S/MIME signed message.
@cindex key listing mode
@cindex key listing, mode of
@deftypefun void gpgme_set_keylist_mode (@w{gpgme_ctx_t @var{ctx}}, @w{int @var{mode}})
@deftypefun void gpgme_set_keylist_mode (@w{gpgme_ctx_t @var{ctx}}, @w{gpgme_keylist_mode_t @var{mode}})
The function @code{gpgme_set_keylist_mode} changes the default
behaviour of the key listing functions. The value in @var{mode} is a
bitwise-or combination of one or multiple of the following bit values:
@ -1668,7 +1667,7 @@ pointer or @var{mode} is not a valid mode.
@end deftypefun
@deftypefun int gpgme_get_keylist_mode (@w{gpgme_ctx_t @var{ctx}})
@deftypefun gpgme_keylist_mode_t gpgme_get_keylist_mode (@w{gpgme_ctx_t @var{ctx}})
The function @code{gpgme_get_keylist_mode} returns the current key
listing mode of the context @var{ctx}. This value can then be
modified and used in a subsequent @code{gpgme_set_keylist_mode}
@ -2649,28 +2648,61 @@ operation is started on the context.
@cindex key, export
@cindex key ring, export from
@deftypefun gpgme_error_t gpgme_op_export (@w{gpgme_ctx_t @var{ctx}}, @w{gpgme_user_id_t @var{uids}}, @w{gpgme_data_t @var{keydata}})
The function @code{gpgme_op_export} extracts the public keys of the
user IDs in @var{uids} and returns them in the data buffer
@var{keydata}. The type of the public keys returned is determined by
the @acronym{ASCII} armor attribute set for the context @var{ctx}.
@deftypefun gpgme_error_t gpgme_op_export (@w{gpgme_ctx_t @var{ctx}}, @w{const char *@var{pattern}}, @w{unsigned int @var{reserved}}, @w{gpgme_data_t @var{keydata}})
The function @code{gpgme_op_export} extracts public keys and returns
them in the data buffer @var{keydata}. The output format of the key
data returned is determined by the @acronym{ASCII} armor attribute set
for the context @var{ctx}.
If @var{pattern} is @code{NULL}, all available keys are returned.
Otherwise, @var{pattern} contains an engine specific expression that
is used to limit the list to all keys matching the pattern.
@var{reserved} is reserved for future use and must be @code{0}.
The function returns @code{GPGME_No_Error} if the operation completed
successfully, @code{GPGME_Invalid_Value} if @var{uids} is
@code{NULL} or @var{keydata} is not a valid empty data buffer, and
passes through any errors that are reported by the crypto engine
support routines.
successfully, @code{GPGME_Invalid_Value} if @var{keydata} is not a
valid empty data buffer, and passes through any errors that are
reported by the crypto engine support routines.
@end deftypefun
@deftypefun gpgme_error_t gpgme_op_export_start (@w{gpgme_ctx_t @var{ctx}}, @w{gpgme_user_id_t @var{uids}}, @w{gpgme_data_t @var{keydata}})
@deftypefun gpgme_error_t gpgme_op_export_start (@w{gpgme_ctx_t @var{ctx}}, @w{const char *@var{pattern}}, @w{unsigned int @var{reserved}}, @w{gpgme_data_t @var{keydata}})
The function @code{gpgme_op_export_start} initiates a
@code{gpgme_op_export} operation. It can be completed by calling
@code{gpgme_wait} on the context. @xref{Waiting For Completion}.
The function returns @code{GPGME_No_Error} if the operation could be
started successfully, and @code{GPGME_Invalid_Value} if
@var{uids} is @code{NULL} or @var{keydata} is not a valid empty
data buffer.
started successfully, and @code{GPGME_Invalid_Value} if @var{keydata}
is not a valid empty data buffer.
@end deftypefun
@deftypefun gpgme_error_t gpgme_op_export_ext (@w{gpgme_ctx_t @var{ctx}}, @w{const char *@var{pattern}[]}, @w{unsigned int @var{reserved}}, @w{gpgme_data_t @var{keydata}})
The function @code{gpgme_op_export} extracts public keys and returns
them in the data buffer @var{keydata}. The output format of the key
data returned is determined by the @acronym{ASCII} armor attribute set
for the context @var{ctx}.
If @var{pattern} or @var{*pattern} is @code{NULL}, all available keys
are returned. Otherwise, @var{pattern} is a @code{NULL} terminated
array of strings that are used to limit the list to all keys matching
at least one of the patterns verbatim.
@var{reserved} is reserved for future use and must be @code{0}.
The function returns @code{GPGME_No_Error} if the operation completed
successfully, @code{GPGME_Invalid_Value} if @var{keydata} is not a
valid empty data buffer, and passes through any errors that are
reported by the crypto engine support routines.
@end deftypefun
@deftypefun gpgme_error_t gpgme_op_export_ext_start (@w{gpgme_ctx_t @var{ctx}}, @w{const char *@var{pattern}[]}, @w{unsigned int @var{reserved}}, @w{gpgme_data_t @var{keydata}})
The function @code{gpgme_op_export_ext_start} initiates a
@code{gpgme_op_export_ext} operation. It can be completed by calling
@code{gpgme_wait} on the context. @xref{Waiting For Completion}.
The function returns @code{GPGME_No_Error} if the operation could be
started successfully, and @code{GPGME_Invalid_Value} if @var{keydata}
is not a valid empty data buffer.
@end deftypefun
@ -3178,7 +3210,7 @@ following members:
This is a pointer to the next new signature structure in the linked
list, or @code{NULL} if this is the last element.
@item unsigned int summary;
@item gpgme_sigsum_t summary;
This is a bit vector giving a summary of the signature status. It
provides an easy interface to a defined semantic of the signature
status. Checking just one bit is sufficient to see whether a
@ -3746,79 +3778,41 @@ time. The list of recipients is created independently of any context,
and then passed to the encryption operation.
@menu
* Selecting Recipients:: How to choose the recipients.
* Encrypting a Plaintext:: How to encrypt a plaintext.
@end menu
@node Selecting Recipients
@subsubsection Selecting Recipients
@cindex encryption, selecting recipients
@cindex recipients
@deftypefun gpgme_error_t gpgme_user_ids_append (@w{gpgme_user_id_t *@var{rset_p}}, @w{const char *@var{name}})
The function @code{gpgme_user_ids_append} creates a new
@code{gpgme_user_id_t} object, initializes its @code{uid} member with
a copy of the string pointed to by @var{name}, initializes its
@code{name}, @code{email}, @code{comment} members to the empty string,
its @code{validity} member to @code{GPGME_VALIDITY_UNKNOWN} and leaves
all other fields to 0.
It then appends the user ID at the end of the linked list of user IDs
that starts at *@var{rset_p}, or it returns it in *@var{rset_p} if
that is @code{NULL}. You can then update for example the validity
information in the user ID directly.
We recommend that you keep a pointer to the last element in your
linked list. This is faster and allows you to easily update the
fields of the last user ID. Here is an example how to create a linked
list of user IDs in @var{rset} with full validity from a
@code{NULL}-terminated array of names:
@example
const char *names[] = @{ "Alpha", "Bob", NULL @};
gpgme_error_t err;
gpgme_user_id_t rset = NULL;
gpgme_user_id_t *rset_lastp = &rset;
do
@{
err = gpgme_user_ids_append (rset_lastp, *(names++));
if (!err)
@{
(*rset_lastp)->validity = GPGME_VALIDITY_FULL;
rset_lastp = &(*rset_lastp)->next;
@}
@}
while (!err && *names);
@end example
The function returns @code{GPGME_No_Error} if the recipient set could
be created successfully, and @code{GPGME_Out_Of_Core} if not enough
memory was available.
@end deftypefun
@deftypefun void gpgme_user_ids_release (@w{gpgme_user_id_t @var{uids}})
The function @code{gpgme_user_ids_release} destroys the linked list of
user IDs @var{uids} and releases all associated resources allocated by
@acronym{GPGME}..
@end deftypefun
@node Encrypting a Plaintext
@subsubsection Encrypting a Plaintext
@deftypefun gpgme_error_t gpgme_op_encrypt (@w{gpgme_ctx_t @var{ctx}}, @w{gpgme_user_id_t @var{rset}}, @w{gpgme_data_t @var{plain}}, @w{gpgme_data_t @var{cipher}})
@deftypefun gpgme_error_t gpgme_op_encrypt (@w{gpgme_ctx_t @var{ctx}}, @w{gpgme_key_t @var{recp}[]}, @w{gpgme_encrypt_flags_t @var{flags}}, @w{gpgme_data_t @var{plain}}, @w{gpgme_data_t @var{cipher}})
The function @code{gpgme_op_encrypt} encrypts the plaintext in the data
object @var{plain} for the recipients @var{rset} and stores the
object @var{plain} for the recipients @var{recp} and stores the
ciphertext in the data object @var{cipher}. The type of the
ciphertext created is determined by the @acronym{ASCII} armor and text
mode attributes set for the context @var{ctx}.
If @code{GPGME_Invalid_UserID} is returned, some recipients in
@var{rset} are invalid, but not all. In this case the plaintext is
encrypted for all valid recipients and returned in @var{cipher}. More
information about the invalid recipients is available with
@var{key} must be a @code{NULL}-terminated array of keys. The user
must keep references for all keys during the whole duration of the
call (but see @code{gpgme_op_encrypt_start} for the requirements with
the asynchronous variant).
The value in @var{flags} is a bitwise-or combination of one or
multiple of the following bit values:
@table @code
@item GPGME_ENCRYPT_ALWAYS_TRUST
The @code{GPGME_ENCRYPT_ALWAYS_TRUST} symbol specifies that all the
recipients in @var{recp} should be trusted, even if the keys do not
have a high enough validity in the keyring. This flag should be used
with care; in general it is not a good idea to use any untrusted keys.
@end table
If @code{GPGME_Invalid_Key} is returned, some recipients in @var{recp}
are invalid, but not all. In this case the plaintext might be
encrypted for all valid recipients and returned in @var{cipher} (if
this happens depends on the crypto engine). More information about
the invalid recipients is available with
@code{gpgme_op_encrypt_result}.
If @var{recp} is @code{NULL}, symmetric rather than public key
@ -3830,19 +3824,22 @@ crypto backend.
The function returns @code{GPGME_No_Error} if the ciphertext could be
created successfully, @code{GPGME_Invalid_Value} if @var{ctx},
@var{rset}, @var{plain} or @var{cipher} is not a valid pointer,
@code{GPGME_No_UserID} if @var{rset} does not contain any valid
recipients, @code{GPGME_Invalid_UserID} if @var{rset} contains some
invalid recipients, @code{GPGME_Bad_Passphrase} if the passphrase for
the secret key could not be retrieved, and passes through any errors
that are reported by the crypto engine support routines.
@var{recp}, @var{plain} or @var{cipher} is not a valid pointer,
@code{GPGME_Invalid_Key} if @var{recp} contains some invalid
recipients, @code{GPGME_Bad_Passphrase} if the passphrase for the
secret key could not be retrieved, and passes through any errors that
are reported by the crypto engine support routines.
@end deftypefun
@deftypefun gpgme_error_t gpgme_op_encrypt_start (@w{gpgme_ctx_t @var{ctx}}, @w{gpgme_user_id_t @var{rset}}, @w{gpgme_data_t @var{plain}}, @w{gpgme_data_t @var{cipher}})
@deftypefun gpgme_error_t gpgme_op_encrypt_start (@w{gpgme_ctx_t @var{ctx}}, @w{gpgme_key_t @var{recp}[]}, @w{gpgme_encrypt_flags_t @var{flags}}, @w{gpgme_data_t @var{plain}}, @w{gpgme_data_t @var{cipher}})
The function @code{gpgme_op_encrypt_start} initiates a
@code{gpgme_op_encrypt} operation. It can be completed by calling
@code{gpgme_wait} on the context. @xref{Waiting For Completion}.
References to the keys only need to be held for the duration of this
call. The user can release its references to the keys after this
function returns, even if the operation is not yet finished.
The function returns @code{GPGME_No_Error} if the operation could be
started successfully, @code{GPGME_Invalid_Value} if @var{ctx},
@var{rset}, @var{plain} or @var{cipher} is not a valid pointer, and
@ -3875,7 +3872,7 @@ next operation is started on the context.
@end deftypefun
@deftypefun gpgme_error_t gpgme_op_encrypt_sign (@w{gpgme_ctx_t @var{ctx}}, @w{gpgme_user_id_t @var{rset}}, @w{gpgme_data_t @var{plain}}, @w{gpgme_data_t @var{cipher}})
@deftypefun gpgme_error_t gpgme_op_encrypt_sign (@w{gpgme_ctx_t @var{ctx}}, @w{gpgme_key_t @var{recp}[]}, @w{gpgme_encrypt_flags_t @var{flags}}, @w{gpgme_data_t @var{plain}}, @w{gpgme_data_t @var{cipher}})
The function @code{gpgme_op_encrypt_sign} does a combined encrypt and
sign operation. It is used like @code{gpgme_op_encrypt}, but the
ciphertext also contains signatures for the signers listed in
@ -3885,17 +3882,15 @@ The combined encrypt and sign operation is currently only available
for the OpenPGP crypto engine.
@end deftypefun
@deftypefun gpgme_error_t gpgme_op_encrypt_sign_start (@w{gpgme_ctx_t @var{ctx}}, @w{gpgme_user_id_t @var{rset}}, @w{gpgme_data_t @var{plain}}, @w{gpgme_data_t @var{cipher}})
@deftypefun gpgme_error_t gpgme_op_encrypt_sign_start (@w{gpgme_ctx_t @var{ctx}}, @w{gpgme_key_t @var{recp}}, @w{gpgme_encrypt_flags_t @var{flags}}, @w{gpgme_data_t @var{plain}}, @w{gpgme_data_t @var{cipher}})
The function @code{gpgme_op_encrypt_sign_start} initiates a
@code{gpgme_op_encrypt_sign} operation. It can be completed by
calling @code{gpgme_wait} on the context. @xref{Waiting For
Completion}.
The function returns @code{GPGME_No_Error} if the operation could be
started successfully, @code{GPGME_Invalid_Value} if @var{ctx},
@var{rset}, @var{plain} or @var{cipher} is not a valid pointer, and
@code{GPGME_No_UserID} if @var{rset} does not contain any valid
recipients.
started successfully, and @code{GPGME_Invalid_Value} if @var{ctx},
@var{rset}, @var{plain} or @var{cipher} is not a valid pointer.
@end deftypefun

68
gpgme/ChangeLog
View File

@ -1,3 +1,71 @@
2003-05-29 Marcus Brinkmann <marcus@g10code.de>
* gpgme.h (gpgme_op_export_start): Change second arg to const char *.
(gpgme_op_export): Likewise.
(gpgme_op_export_ext_start): New prototype.
(gpgme_op_export_ext): Likewise.
* engine.h: Likewise for _gpgme_engine_op_export and
_gpgme_engine_op_export_ext.
* engine-backend.h (struct engine_ops): Change second argument of
prototype of export to const char *, and add reserverd int as
third argument. Add prototype for export_ext.
* engine.c (_gpgme_engine_op_export_ext): New function.
(_gpgme_engine_op_export): Change second argument of prototype of
export to const char *, and add reserverd int as third argument.
* rungpg.c (gpg_export): Change second argument of prototype of
export to const char *, and add reserverd int as third argument.
(gpg_export_ext): New function.
(gpg_keylist_ext): Break loop at error.
(_gpgme_engine_ops_gpg): Add gpg_export_ext.
* engine-gpgsm.c (gpgsm_export): Change second argument of
prototype of export to const char *, and add reserverd int as
third argument.
(gpgsm_export_ext): New function.
(_gpgme_engine_ops_gpgsm): Add gpgsm_export_ext.
* export.c (export_start): Change second argument of prototype of
export to const char *, and add reserverd int as third argument.
(gpgme_op_export_start): Likewise.
(export_ext_start): New function.
(gpgme_op_export_ext_start): Likewise.
(gpgme_op_export_ext): Likewise.
* gpgme.h (gpgme_keylist_mode_t): New type for anonymous enum.
(gpgme_sigsum_t): New type for anonymous enum.
* encrypt-sign.c (encrypt_sign_start): Check for errors earlier,
and return an error if RECP is not set.
* Makefile.am (libgpgme_la_SOURCES): Remove user-id.c.
* user-id.c: Remove file.
* ops.h: Remove prototype for _gpgme_user_ids_all_valid.
* gpgme.h (gpgme_encrypt_flags_t): New type.
(gpgme_op_encrypt_start): Change second parameter to type
gpgme_key_t[], and add third parameter.
(gpgme_op_encrypt): Likewise.
(gpgme_op_encrypt_sign_start): Likewise.
(gpgme_op_encrypt_sign): Likewise.
* encrypt.c (encrypt_start): Likewise.
(gpgme_op_encrypt_start): Likewise.
(gpgme_op_encrypt): Likewise. Pass flags to engine.
* encrypt-sign.c (encrypt_sign_start): Likewise.
(gpgme_op_encrypt_sign_start): Likewise.
(gpgme_op_encrypt_sign): Likewise.
* engine-backend.h (struct engine_ops): Likewise for prototypes of
encrypt and encrypt_sign.
* engine.h: Likewise for prototypes of _gpgme_engine_op_encrypt
and _gpgme_engine_op_encrypt_sign.
* engine.c (_gpgme_engine_op_encrypt): Likewise.
(_gpgme_engine_op_encrypt_sign): Likewise.
* rungpg.c (gpg_encrypt): Likewise.
(gpg_encrypt_sign): Likewise.
* rungpg.c (gpg_encrypt): Check flags for always trust option.
* engine-gpgsm.c (gpgsm_encrypt): Likewise.
(set_recipients): Rewritten to use keys instead user IDs.
* rungpg.c (append_args_from_recipients): Rewritten to use keys
instead user IDs.
* encrypt.c (_gpgme_encrypt_status_handler): Change errors
returned to GPGME_Invalid_Key and GPGME_General_Error.
2003-05-28 Marcus Brinkmann <marcus@g10code.de>
* engine-gpgsm.c: Rename GpgsmObject to engine_gpgsm_t.

2
gpgme/Makefile.am
View File

@ -72,7 +72,7 @@ libgpgme_la_SOURCES = \
gpgme.h util.h conversion.c context.h ops.h \
data.h data.c data-fd.c data-stream.c data-mem.c data-user.c \
data-compat.c \
user-id.c signers.c \
signers.c \
wait.c wait-global.c wait-private.c wait-user.c wait.h \
op-support.c \
encrypt.c encrypt-sign.c decrypt.c decrypt-verify.c verify.c \

2
gpgme/context.h
View File

@ -75,7 +75,7 @@ struct gpgme_context
unsigned int use_textmode : 1;
/* Flags for keylist mode. */
unsigned int keylist_mode;
gpgme_keylist_mode_t keylist_mode;
/* Number of certs to be included. */
unsigned int include_certs;

35
gpgme/encrypt-sign.c
View File

@ -37,7 +37,8 @@ encrypt_sign_status_handler (void *priv, gpgme_status_code_t code, char *args)
static gpgme_error_t
encrypt_sign_start (gpgme_ctx_t ctx, int synchronous, gpgme_user_id_t recp,
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;
@ -46,6 +47,11 @@ encrypt_sign_start (gpgme_ctx_t ctx, int synchronous, gpgme_user_id_t recp,
if (err)
return err;
if (!plain)
return GPGME_No_Data;
if (!cipher || !recp)
return GPGME_Invalid_Value;
err = _gpgme_op_encrypt_init_result (ctx);
if (err)
return err;
@ -54,16 +60,10 @@ encrypt_sign_start (gpgme_ctx_t ctx, int synchronous, gpgme_user_id_t recp,
if (err)
return err;
if (!plain)
return GPGME_No_Data;
if (!cipher)
return GPGME_Invalid_Value;
if (ctx->passphrase_cb)
{
err = _gpgme_engine_set_command_handler (ctx->engine,
_gpgme_passphrase_command_handler,
ctx, NULL);
err = _gpgme_engine_set_command_handler
(ctx->engine, _gpgme_passphrase_command_handler, ctx, NULL);
if (err)
return err;
}
@ -71,8 +71,9 @@ encrypt_sign_start (gpgme_ctx_t ctx, int synchronous, gpgme_user_id_t recp,
_gpgme_engine_set_status_handler (ctx->engine,
encrypt_sign_status_handler, ctx);
return _gpgme_engine_op_encrypt_sign (ctx->engine, recp, plain, cipher,
ctx->use_armor, ctx /* FIXME */);
return _gpgme_engine_op_encrypt_sign (ctx->engine, recp, flags, plain,
cipher, ctx->use_armor,
ctx /* FIXME */);
}
@ -80,10 +81,11 @@ encrypt_sign_start (gpgme_ctx_t ctx, int synchronous, gpgme_user_id_t recp,
store the resulting ciphertext in CIPHER. Also sign the ciphertext
with the signers in CTX. */
gpgme_error_t
gpgme_op_encrypt_sign_start (gpgme_ctx_t ctx, gpgme_user_id_t recp,
gpgme_data_t plain, gpgme_data_t cipher)
gpgme_op_encrypt_sign_start (gpgme_ctx_t ctx, gpgme_key_t recp[],
gpgme_encrypt_flags_t flags,
gpgme_data_t plain, gpgme_data_t cipher)
{
return encrypt_sign_start (ctx, 0, recp, plain, cipher);
return encrypt_sign_start (ctx, 0, recp, flags, plain, cipher);
}
@ -91,10 +93,11 @@ gpgme_op_encrypt_sign_start (gpgme_ctx_t ctx, gpgme_user_id_t recp,
store the resulting ciphertext in CIPHER. Also sign the ciphertext
with the signers in CTX. */
gpgme_error_t
gpgme_op_encrypt_sign (gpgme_ctx_t ctx, gpgme_user_id_t recp,
gpgme_op_encrypt_sign (gpgme_ctx_t ctx, gpgme_key_t recp[],
gpgme_encrypt_flags_t flags,
gpgme_data_t plain, gpgme_data_t cipher)
{
gpgme_error_t err = encrypt_sign_start (ctx, 1, recp, plain, cipher);
gpgme_error_t err = encrypt_sign_start (ctx, 1, recp, flags, plain, cipher);
if (!err)
err = _gpgme_wait_one (ctx);
return err;

21
gpgme/encrypt.c
View File

@ -91,7 +91,7 @@ _gpgme_encrypt_status_handler (void *priv, gpgme_status_code_t code,
{
case GPGME_STATUS_EOF:
if (opd->result.invalid_recipients)
return GPGME_Invalid_UserID;
return GPGME_Invalid_Key;
break;
case GPGME_STATUS_INV_RECP:
@ -104,7 +104,7 @@ _gpgme_encrypt_status_handler (void *priv, gpgme_status_code_t code,
case GPGME_STATUS_NO_RECP:
/* Should not happen, because we require at least one recipient. */
return GPGME_No_UserID;
return GPGME_General_Error;
default:
break;
@ -148,7 +148,8 @@ _gpgme_op_encrypt_init_result (gpgme_ctx_t ctx)
static gpgme_error_t
encrypt_start (gpgme_ctx_t ctx, int synchronous, gpgme_user_id_t recp,
encrypt_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;
@ -169,6 +170,8 @@ encrypt_start (gpgme_ctx_t ctx, int synchronous, gpgme_user_id_t recp,
return GPGME_No_Data;
if (!cipher)
return GPGME_Invalid_Value;
if (recp && ! *recp)
return GPGME_Invalid_Value;
if (symmetric && ctx->passphrase_cb)
{
@ -185,26 +188,28 @@ encrypt_start (gpgme_ctx_t ctx, int synchronous, gpgme_user_id_t recp,
: encrypt_status_handler,
ctx);
return _gpgme_engine_op_encrypt (ctx->engine, recp, plain, cipher,
return _gpgme_engine_op_encrypt (ctx->engine, recp, flags, plain, cipher,
ctx->use_armor);
}
gpgme_error_t
gpgme_op_encrypt_start (gpgme_ctx_t ctx, gpgme_user_id_t recp,
gpgme_op_encrypt_start (gpgme_ctx_t ctx, gpgme_key_t recp[],
gpgme_encrypt_flags_t flags,
gpgme_data_t plain, gpgme_data_t cipher)
{
return encrypt_start (ctx, 0, recp, plain, cipher);
return encrypt_start (ctx, 0, recp, flags, plain, cipher);
}
/* Encrypt plaintext PLAIN within CTX for the recipients RECP and
store the resulting ciphertext in CIPHER. */
gpgme_error_t
gpgme_op_encrypt (gpgme_ctx_t ctx, gpgme_user_id_t recp,
gpgme_op_encrypt (gpgme_ctx_t ctx, gpgme_key_t recp[],
gpgme_encrypt_flags_t flags,
gpgme_data_t plain, gpgme_data_t cipher)
{
gpgme_error_t err = encrypt_start (ctx, 1, recp, plain, cipher);
gpgme_error_t err = encrypt_start (ctx, 1, recp, flags, plain, cipher);
if (!err)
err = _gpgme_wait_one (ctx);
return err;

18
gpgme/engine-backend.h
View File

@ -50,22 +50,28 @@ struct engine_ops
gpgme_error_t (*delete) (void *engine, gpgme_key_t key, int allow_secret);
gpgme_error_t (*edit) (void *engine, gpgme_key_t key, gpgme_data_t out,
gpgme_ctx_t ctx /* FIXME */);
gpgme_error_t (*encrypt) (void *engine, gpgme_user_id_t recp,
gpgme_error_t (*encrypt) (void *engine, gpgme_key_t recp[],
gpgme_encrypt_flags_t flags,
gpgme_data_t plain, gpgme_data_t ciph,
int use_armor);
gpgme_error_t (*encrypt_sign) (void *engine, gpgme_user_id_t recp,
gpgme_error_t (*encrypt_sign) (void *engine, gpgme_key_t recp[],
gpgme_encrypt_flags_t flags,
gpgme_data_t plain, gpgme_data_t ciph,
int use_armor, gpgme_ctx_t ctx /* FIXME */);
gpgme_error_t (*export) (void *engine, gpgme_user_id_t uids,
gpgme_data_t keydata, int use_armor);
gpgme_error_t (*export) (void *engine, const char *pattern,
unsigned int reserved, gpgme_data_t keydata,
int use_armor);
gpgme_error_t (*export_ext) (void *engine, const char *pattern[],
unsigned int reserved, gpgme_data_t keydata,
int use_armor);
gpgme_error_t (*genkey) (void *engine, gpgme_data_t help_data, int use_armor,
gpgme_data_t pubkey, gpgme_data_t seckey);
gpgme_error_t (*import) (void *engine, gpgme_data_t keydata);
gpgme_error_t (*keylist) (void *engine, const char *pattern,
int secret_only, int keylist_mode);
int secret_only, gpgme_keylist_mode_t mode);
gpgme_error_t (*keylist_ext) (void *engine, const char *pattern[],
int secret_only, int reserved,
int keylist_mode);
gpgme_keylist_mode_t mode);
gpgme_error_t (*sign) (void *engine, gpgme_data_t in, gpgme_data_t out,
gpgme_sig_mode_t mode, int use_armor,
int use_textmode,

190
gpgme/engine-gpgsm.c
View File

@ -936,22 +936,32 @@ gpgsm_delete (void *engine, gpgme_key_t key, int allow_secret)
static gpgme_error_t
set_recipients (engine_gpgsm_t gpgsm, gpgme_user_id_t uid)
set_recipients (engine_gpgsm_t gpgsm, gpgme_key_t recp[])
{
gpgme_error_t err;
gpgme_error_t err = 0;
ASSUAN_CONTEXT ctx = gpgsm->assuan_ctx;
char *line;
int linelen;
int invalid_recipients = 0;
int i = 0;
linelen = 10 + 40 + 1; /* "RECIPIENT " + guess + '\0'. */
line = malloc (10 + 40 + 1);
if (!line)
return GPGME_Out_Of_Core;
strcpy (line, "RECIPIENT ");
while (uid)
while (!err && recp[i])
{
int newlen = 11 + strlen (uid->uid);
char *fpr;
if (!recp[i]->subkeys || !recp[i]->subkeys->fpr)
{
invalid_recipients++;
continue;
}
fpr = recp[i]->subkeys->fpr;
int newlen = 11 + strlen (fpr);
if (linelen < newlen)
{
char *newline = realloc (line, newlen);
@ -963,27 +973,27 @@ set_recipients (engine_gpgsm_t gpgsm, gpgme_user_id_t uid)
line = newline;
linelen = newlen;
}
strcpy (&line[10], uid->uid);
strcpy (&line[10], fpr);
err = gpgsm_assuan_simple_command (ctx, line, gpgsm->status.fnc,
gpgsm->status.fnc_value);
if (err == GPGME_Invalid_Key)
invalid_recipients = 1;
invalid_recipients++;
else if (err)
{
free (line);
return err;
}
uid = uid->next;
i++;
}
free (line);
return invalid_recipients ? GPGME_Invalid_UserID : 0;
return invalid_recipients ? GPGME_Invalid_Key : 0;
}
static gpgme_error_t
gpgsm_encrypt (void *engine, gpgme_user_id_t recp, gpgme_data_t plain,
gpgme_data_t ciph, int use_armor)
gpgsm_encrypt (void *engine, gpgme_key_t recp[], gpgme_encrypt_flags_t flags,
gpgme_data_t plain, gpgme_data_t ciph, int use_armor)
{
engine_gpgsm_t gpgsm = engine;
gpgme_error_t err;
@ -1015,46 +1025,24 @@ gpgsm_encrypt (void *engine, gpgme_user_id_t recp, gpgme_data_t plain,
static gpgme_error_t
gpgsm_export (void *engine, gpgme_user_id_t uid, gpgme_data_t keydata,
int use_armor)
gpgsm_export (void *engine, const char *pattern, unsigned int reserved,
gpgme_data_t keydata, int use_armor)
{
engine_gpgsm_t gpgsm = engine;
gpgme_error_t err = 0;
char *cmd = NULL;
int cmdi;
int cmdlen = 32;
char *cmd;
if (!gpgsm)
if (!gpgsm || reserved)
return GPGME_Invalid_Value;
cmd = malloc (cmdlen);
if (!pattern)
pattern = "";
cmd = malloc (7 + strlen (pattern) + 1);
if (!cmd)
return GPGME_Out_Of_Core;
strcpy (cmd, "EXPORT");
cmdi = 6;
while (!err && uid)
{
int uidlen = strlen (uid->uid);
/* New string is old string + ' ' + s + '\0'. */
if (cmdlen < cmdi + 1 + uidlen + 1)
{
char *newcmd = realloc (cmd, cmdlen * 2);
if (!newcmd)
{
free (cmd);
return GPGME_Out_Of_Core;
}
cmd = newcmd;
cmdlen *= 2;
}
cmd[cmdi++] = ' ';
strcpy (cmd + cmdi, uid->uid);
cmdi += uidlen;
uid = uid->next;
}
if (err)
return err;
strcpy (cmd, "EXPORT ");
strcpy (&cmd[7], pattern);
gpgsm->output_cb.data = keydata;
err = gpgsm_set_fd (gpgsm->assuan_ctx, "OUTPUT", gpgsm->output_fd_server,
@ -1070,6 +1058,97 @@ gpgsm_export (void *engine, gpgme_user_id_t uid, gpgme_data_t keydata,
}
static gpgme_error_t
gpgsm_export_ext (void *engine, const char *pattern[], unsigned int reserved,
gpgme_data_t keydata, int use_armor)
{
engine_gpgsm_t gpgsm = engine;
gpgme_error_t err = 0;
char *line;
/* Length is "EXPORT " + p + '\0'. */
int length = 7 + 1;
char *linep;
if (!gpgsm || reserved)
return GPGME_Invalid_Value;
if (pattern && *pattern)
{
const char **pat = pattern;
while (*pat)
{
const char *patlet = *pat;
while (*patlet)
{
length++;
if (*patlet == '%' || *patlet == ' ' || *patlet == '+')
length += 2;
patlet++;
}
pat++;
/* This will allocate one byte more than necessary. */
length++;
}
}
line = malloc (length);
if (!line)
return GPGME_Out_Of_Core;
strcpy (line, "EXPORT ");
linep = &line[7];
if (pattern && *pattern)
{
while (*pattern)
{
const char *patlet = *pattern;
while (*patlet)
{
switch (*patlet)
{
case '%':
*(linep++) = '%';
*(linep++) = '2';
*(linep++) = '5';
break;
case ' ':
*(linep++) = '%';
*(linep++) = '2';
*(linep++) = '0';
break;
case '+':
*(linep++) = '%';
*(linep++) = '2';
*(linep++) = 'B';
break;
default:
*(linep++) = *patlet;
break;
}
patlet++;
}
pattern++;
}
}
*linep = '\0';
gpgsm->output_cb.data = keydata;
err = gpgsm_set_fd (gpgsm->assuan_ctx, "OUTPUT", gpgsm->output_fd_server,
use_armor ? "--armor" : 0);
if (err)
return err;
_gpgme_io_close (gpgsm->input_cb.fd);
_gpgme_io_close (gpgsm->message_cb.fd);
err = start (gpgsm, line);
free (line);
return err;
}
static gpgme_error_t
gpgsm_genkey (void *engine, gpgme_data_t help_data, int use_armor,
gpgme_data_t pubkey, gpgme_data_t seckey)
@ -1121,16 +1200,22 @@ gpgsm_import (void *engine, gpgme_data_t keydata)
static gpgme_error_t
gpgsm_keylist (void *engine, const char *pattern, int secret_only,
int keylist_mode)
gpgme_keylist_mode_t mode)
{
engine_gpgsm_t gpgsm = engine;
char *line;
gpgme_error_t err;
int list_mode = 0;
if (mode & GPGME_KEYLIST_MODE_LOCAL)
list_mode |= 1;
if (mode & GPGME_KEYLIST_MODE_EXTERN)
list_mode |= 2;
if (!pattern)
pattern = "";
if (asprintf (&line, "OPTION list-mode=%d", (keylist_mode & 3)) < 0)
if (asprintf (&line, "OPTION list-mode=%d", (list_mode & 3)) < 0)
return GPGME_Out_Of_Core;
err = gpgsm_assuan_simple_command (gpgsm->assuan_ctx, line, NULL, NULL);
free (line);
@ -1164,7 +1249,7 @@ gpgsm_keylist (void *engine, const char *pattern, int secret_only,
static gpgme_error_t
gpgsm_keylist_ext (void *engine, const char *pattern[], int secret_only,
int reserved, int keylist_mode)
int reserved, gpgme_keylist_mode_t mode)
{
engine_gpgsm_t gpgsm = engine;
char *line;
@ -1172,11 +1257,17 @@ gpgsm_keylist_ext (void *engine, const char *pattern[], int secret_only,
/* Length is "LISTSECRETKEYS " + p + '\0'. */
int length = 15 + 1;
char *linep;
int list_mode = 0;
if (reserved)
return GPGME_Invalid_Value;
if (asprintf (&line, "OPTION list-mode=%d", (keylist_mode & 3)) < 0)
if (mode & GPGME_KEYLIST_MODE_LOCAL)
list_mode |= 1;
if (mode & GPGME_KEYLIST_MODE_EXTERN)
list_mode |= 2;
if (asprintf (&line, "OPTION list-mode=%d", (list_mode & 3)) < 0)
return GPGME_Out_Of_Core;
err = gpgsm_assuan_simple_command (gpgsm->assuan_ctx, line, NULL, NULL);
free (line);
@ -1432,8 +1523,9 @@ struct engine_ops _gpgme_engine_ops_gpgsm =
gpgsm_delete,
NULL, /* edit */
gpgsm_encrypt,
NULL,
NULL, /* encrypt_sign */
gpgsm_export,
gpgsm_export_ext,
gpgsm_genkey,
gpgsm_import,
gpgsm_keylist,

46
gpgme/engine.c
View File

@ -291,7 +291,8 @@ _gpgme_engine_op_edit (engine_t engine, gpgme_key_t key, gpgme_data_t out,
gpgme_error_t
_gpgme_engine_op_encrypt (engine_t engine, gpgme_user_id_t recp,
_gpgme_engine_op_encrypt (engine_t engine, gpgme_key_t recp[],
gpgme_encrypt_flags_t flags,
gpgme_data_t plain, gpgme_data_t ciph, int use_armor)
{
if (!engine)
@ -300,13 +301,14 @@ _gpgme_engine_op_encrypt (engine_t engine, gpgme_user_id_t recp,
if (!engine->ops->encrypt)
return GPGME_Not_Implemented;
return (*engine->ops->encrypt) (engine->engine, recp, plain, ciph,
return (*engine->ops->encrypt) (engine->engine, recp, flags, plain, ciph,
use_armor);
}
gpgme_error_t
_gpgme_engine_op_encrypt_sign (engine_t engine, gpgme_user_id_t recp,
_gpgme_engine_op_encrypt_sign (engine_t engine, gpgme_key_t recp[],
gpgme_encrypt_flags_t flags,
gpgme_data_t plain, gpgme_data_t ciph,
int use_armor, gpgme_ctx_t ctx /* FIXME */)
{
@ -316,14 +318,15 @@ _gpgme_engine_op_encrypt_sign (engine_t engine, gpgme_user_id_t recp,
if (!engine->ops->encrypt_sign)
return GPGME_Not_Implemented;
return (*engine->ops->encrypt_sign) (engine->engine, recp, plain, ciph,
use_armor, ctx);
return (*engine->ops->encrypt_sign) (engine->engine, recp, flags,
plain, ciph, use_armor, ctx);
}
gpgme_error_t
_gpgme_engine_op_export (engine_t engine, gpgme_user_id_t uids,
gpgme_data_t keydata, int use_armor)
_gpgme_engine_op_export (engine_t engine, const char *pattern,
unsigned int reserved, gpgme_data_t keydata,
int use_armor)
{
if (!engine)
return GPGME_Invalid_Value;
@ -331,7 +334,24 @@ _gpgme_engine_op_export (engine_t engine, gpgme_user_id_t uids,
if (!engine->ops->export)
return GPGME_Not_Implemented;
return (*engine->ops->export) (engine->engine, uids, keydata, use_armor);
return (*engine->ops->export) (engine->engine, pattern, reserved,
keydata, use_armor);
}
gpgme_error_t
_gpgme_engine_op_export_ext (engine_t engine, const char *pattern[],
unsigned int reserved, gpgme_data_t keydata,
int use_armor)
{
if (!engine)
return GPGME_Invalid_Value;
if (!engine->ops->export_ext)
return GPGME_Not_Implemented;
return (*engine->ops->export_ext) (engine->engine, pattern, reserved,
keydata, use_armor);
}
@ -366,7 +386,7 @@ _gpgme_engine_op_import (engine_t engine, gpgme_data_t keydata)
gpgme_error_t
_gpgme_engine_op_keylist (engine_t engine, const char *pattern,
int secret_only, int keylist_mode)
int secret_only, gpgme_keylist_mode_t mode)
{
if (!engine)
return GPGME_Invalid_Value;
@ -374,14 +394,14 @@ _gpgme_engine_op_keylist (engine_t engine, const char *pattern,
if (!engine->ops->keylist)
return GPGME_Not_Implemented;
return (*engine->ops->keylist) (engine->engine, pattern, secret_only,
keylist_mode);
return (*engine->ops->keylist) (engine->engine, pattern, secret_only, mode);
}
gpgme_error_t
_gpgme_engine_op_keylist_ext (engine_t engine, const char *pattern[],
int secret_only, int reserved, int keylist_mode)
int secret_only, int reserved,
gpgme_keylist_mode_t mode)
{
if (!engine)
return GPGME_Invalid_Value;
@ -390,7 +410,7 @@ _gpgme_engine_op_keylist_ext (engine_t engine, const char *pattern[],
return GPGME_Not_Implemented;
return (*engine->ops->keylist_ext) (engine->engine, pattern, secret_only,
reserved, keylist_mode);
reserved, mode);
}

19
gpgme/engine.h
View File

@ -58,18 +58,25 @@ gpgme_error_t _gpgme_engine_op_edit (engine_t engine, gpgme_key_t key,
gpgme_data_t out,
gpgme_ctx_t ctx /* FIXME */);
gpgme_error_t _gpgme_engine_op_encrypt (engine_t engine,
gpgme_user_id_t recp,
gpgme_key_t recp[],
gpgme_encrypt_flags_t flags,
gpgme_data_t plain, gpgme_data_t ciph,
int use_armor);
gpgme_error_t _gpgme_engine_op_encrypt_sign (engine_t engine,
gpgme_user_id_t recp,
gpgme_key_t recp[],
gpgme_encrypt_flags_t flags,
gpgme_data_t plain,
gpgme_data_t ciph,
int use_armor,
gpgme_ctx_t ctx /* FIXME */);
gpgme_error_t _gpgme_engine_op_export (engine_t engine,
gpgme_user_id_t uids,
gpgme_error_t _gpgme_engine_op_export (engine_t engine, const char *pattern,
unsigned int reserved,
gpgme_data_t keydata, int use_armor);
gpgme_error_t _gpgme_engine_op_export_ext (engine_t engine,
const char *pattern[],
unsigned int reserved,
gpgme_data_t keydata,
int use_armor);
gpgme_error_t _gpgme_engine_op_genkey (engine_t engine,
gpgme_data_t help_data,
int use_armor, gpgme_data_t pubkey,
@ -79,12 +86,12 @@ gpgme_error_t _gpgme_engine_op_import (engine_t engine,
gpgme_error_t _gpgme_engine_op_keylist (engine_t engine,
const char *pattern,
int secret_only,
int keylist_mode);
gpgme_keylist_mode_t mode);
gpgme_error_t _gpgme_engine_op_keylist_ext (engine_t engine,
const char *pattern[],
int secret_only,
int reserved,
int keylist_mode);
gpgme_keylist_mode_t mode);
gpgme_error_t _gpgme_engine_op_sign (engine_t engine, gpgme_data_t in,
gpgme_data_t out, gpgme_sig_mode_t mode,
int use_armor, int use_textmode,

61
gpgme/export.c
View File

@ -35,12 +35,12 @@ export_status_handler (void *priv, gpgme_status_code_t code, char *args)
static gpgme_error_t
export_start (gpgme_ctx_t ctx, int synchronous,
gpgme_user_id_t uids, gpgme_data_t keydata)
export_start (gpgme_ctx_t ctx, int synchronous, const char *pattern,
unsigned int reserved, gpgme_data_t keydata)
{
gpgme_error_t err;
if (!keydata || !uids)
if (!keydata)
return GPGME_Invalid_Value;
err = _gpgme_op_reset (ctx, synchronous);
@ -49,24 +49,67 @@ export_start (gpgme_ctx_t ctx, int synchronous,
_gpgme_engine_set_status_handler (ctx->engine, export_status_handler, ctx);
return _gpgme_engine_op_export (ctx->engine, uids, keydata, ctx->use_armor);
return _gpgme_engine_op_export (ctx->engine, pattern, reserved, keydata,
ctx->use_armor);
}
/* Export the keys listed in RECP into KEYDATA. */
gpgme_error_t
gpgme_op_export_start (gpgme_ctx_t ctx, gpgme_user_id_t uids,
gpgme_data_t keydata)
gpgme_op_export_start (gpgme_ctx_t ctx, const char *pattern,
unsigned int reserved, gpgme_data_t keydata)
{
return export_start (ctx, 0, uids, keydata);
return export_start (ctx, 0, pattern, reserved, keydata);
}
/* Export the keys listed in RECP into KEYDATA. */
gpgme_error_t
gpgme_op_export (gpgme_ctx_t ctx, gpgme_user_id_t uids, gpgme_data_t keydata)
gpgme_op_export (gpgme_ctx_t ctx, const char *pattern, unsigned int reserved,
gpgme_data_t keydata)
{
gpgme_error_t err = export_start (ctx, 1, uids, keydata);
gpgme_error_t err = export_start (ctx, 1, pattern, reserved, keydata);
if (!err)
err = _gpgme_wait_one (ctx);
return err;
}
static gpgme_error_t
export_ext_start (gpgme_ctx_t ctx, int synchronous, const char *pattern[],
unsigned int reserved, gpgme_data_t keydata)
{
gpgme_error_t err;
if (!keydata)
return GPGME_Invalid_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_ext (ctx->engine, pattern, reserved, keydata,
ctx->use_armor);
}
/* Export the keys listed in RECP into KEYDATA. */
gpgme_error_t
gpgme_op_export_ext_start (gpgme_ctx_t ctx, const char *pattern[],
unsigned int reserved, gpgme_data_t keydata)
{
return export_ext_start (ctx, 0, pattern, reserved, keydata);
}
/* Export the keys listed in RECP into KEYDATA. */
gpgme_error_t
gpgme_op_export_ext (gpgme_ctx_t ctx, const char *pattern[],
unsigned int reserved, gpgme_data_t keydata)
{
gpgme_error_t err = export_ext_start (ctx, 1, pattern, reserved, keydata);
if (!err)
err = _gpgme_wait_one (ctx);
return err;

270
gpgme/gpgme.c
View File

@ -38,9 +38,6 @@ gpgme_new (gpgme_ctx_t *r_ctx)
{
gpgme_ctx_t ctx;
if (!r_ctx)
return GPGME_Invalid_Value;
*r_ctx = 0;
ctx = calloc (1, sizeof *ctx);
if (!ctx)
return GPGME_Out_Of_Core;
@ -53,17 +50,10 @@ gpgme_new (gpgme_ctx_t *r_ctx)
}
/**
* gpgme_release:
* @c: Context to be released.
*
* Release all resources associated with the given context.
**/
/* Release all resources associated with the given context. */
void
gpgme_release (gpgme_ctx_t ctx)
{
if (!ctx)
return;
_gpgme_engine_release (ctx->engine);
_gpgme_fd_table_deinit (&ctx->fdt);
_gpgme_release_result (ctx);
@ -73,6 +63,7 @@ gpgme_release (gpgme_ctx_t ctx)
free (ctx);
}
void
_gpgme_release_result (gpgme_ctx_t ctx)
{
@ -124,81 +115,43 @@ gpgme_get_protocol_name (gpgme_protocol_t protocol)
}
}
/**
* gpgme_set_armor:
* @ctx: the context
* @yes: boolean value to set or clear that flag
*
* Enable or disable the use of an ascii armor for all output.
**/
/* Enable or disable the use of an ascii armor for all output. */
void
gpgme_set_armor (gpgme_ctx_t ctx, int yes)
{
if (!ctx)
return;
ctx->use_armor = yes;
}
/**
* gpgme_get_armor:
* @ctx: the context
*
* Return the state of the armor flag which can be changed using
* gpgme_set_armor().
*
* Return value: Boolean whether armor mode is to be used.
**/
/* Return the state of the armor flag. */
int
gpgme_get_armor (gpgme_ctx_t ctx)
{
return ctx && ctx->use_armor;
return ctx->use_armor;
}
/**
* gpgme_set_textmode:
* @ctx: the context
* @yes: boolean flag whether textmode should be enabled
*
* Enable or disable the use of the special textmode. Textmode is for example
* used for the RFC2015 signatures; note that the updated RFC 3156 mandates
* that the MUA does some preparations so that textmode is not needed anymore.
**/
/* Enable or disable the use of the special textmode. Textmode is for
example used for the RFC2015 signatures; note that the updated RFC
3156 mandates that the MUA does some preparations so that textmode
is not needed anymore. */
void
gpgme_set_textmode (gpgme_ctx_t ctx, int yes)
{
if (!ctx)
return;
ctx->use_textmode = yes;
}
/**
* gpgme_get_textmode:
* @ctx: the context
*
* Return the state of the textmode flag which can be changed using
* gpgme_set_textmode().
*
* Return value: Boolean whether textmode is to be used.
**/
/* Return the state of the textmode flag. */
int
gpgme_get_textmode (gpgme_ctx_t ctx)
{
return ctx && ctx->use_textmode;
return ctx->use_textmode;
}
/**
* gpgme_set_include_certs:
* @ctx: the context
*
* Set the number of certifications to include in an S/MIME message.
* The default is 1 (only the cert of the sender). -1 means all certs,
* and -2 means all certs except the root cert.
*
* Return value: Boolean whether textmode is to be used.
**/
/* Set the number of certifications to include in an S/MIME message.
The default is 1 (only the cert of the sender). -1 means all
certs, and -2 means all certs except the root cert. */
void
gpgme_set_include_certs (gpgme_ctx_t ctx, int nr_of_certs)
{
@ -209,14 +162,8 @@ gpgme_set_include_certs (gpgme_ctx_t ctx, int nr_of_certs)
}
/**
* gpgme_get_include_certs:
* @ctx: the context
*
* Get the number of certifications to include in an S/MIME message.
*
* Return value: Boolean whether textmode is to be used.
**/
/* Get the number of certifications to include in an S/MIME
message. */
int
gpgme_get_include_certs (gpgme_ctx_t ctx)
{
@ -224,24 +171,12 @@ gpgme_get_include_certs (gpgme_ctx_t ctx)
}
/**
* gpgme_set_keylist_mode:
* @ctx: the context
* @mode: listing mode
*
* This function changes the default behaviour of the keylisting
* functions. mode is a bitwise-OR of the GPGME_KEYLIST_* flags.
* The default mode is GPGME_KEYLIST_MODE_LOCAL.
*
* Return value: GPGME_Invalid_Value if ctx is not a context or mode
* not a valid mode.
**/
/* This function changes the default behaviour of the keylisting
functions. MODE is a bitwise-OR of the GPGME_KEYLIST_* flags. The
default mode is GPGME_KEYLIST_MODE_LOCAL. */
gpgme_error_t
gpgme_set_keylist_mode (gpgme_ctx_t ctx, int mode)
gpgme_set_keylist_mode (gpgme_ctx_t ctx, gpgme_keylist_mode_t mode)
{
if (!ctx)
return GPGME_Invalid_Value;
if (!((mode & GPGME_KEYLIST_MODE_LOCAL)
|| (mode & GPGME_KEYLIST_MODE_EXTERN)
|| (mode & GPGME_KEYLIST_MODE_SIGS)))
@ -251,168 +186,66 @@ gpgme_set_keylist_mode (gpgme_ctx_t ctx, int mode)
return 0;
}
/**
* gpgme_get_keylist_mode:
* @ctx: the context
*
* This function ch the default behaviour of the keylisting functions.
* Defines values for @mode are: %0 = normal, %1 = fast listing without
* information about key validity.
*
* Return value: 0 if ctx is not a valid context, or the current mode.
* Note that 0 is never a valid mode.
**/
int
/* This function returns the default behaviour of the keylisting
functions. */
gpgme_keylist_mode_t
gpgme_get_keylist_mode (gpgme_ctx_t ctx)
{
if (!ctx)
return 0;
return ctx->keylist_mode;
}
/**
* gpgme_set_passphrase_cb:
* @ctx: the context
* @cb: A callback function
* @cb_value: The value passed to the callback function
*
* This function sets a callback function to be used to pass a passphrase
* to gpg. The preferred way to handle this is by using the gpg-agent, but
* because that beast is not ready for real use, you can use this passphrase
* thing.
*
* The callback function is defined as:
* <literal>
* typedef const char *(*gpgme_passphrase_cb_t)(void*cb_value,
* const char *desc,
* void **r_hd);
* </literal>
* and called whenever gpgme needs a passphrase. DESC will have a nice
* text, to be used to prompt for the passphrase and R_HD is just a parameter
* to be used by the callback it self. Because the callback returns a const
* string, the callback might want to know when it can release resources
* assocated with that returned string; gpgme helps here by calling this
* passphrase callback with an DESC of %NULL as soon as it does not need
* the returned string anymore. The callback function might then choose
* to release resources depending on R_HD.
*
**/
/* This function sets a callback function to be used to pass a
passphrase to gpg. */
void
gpgme_set_passphrase_cb (gpgme_ctx_t ctx, gpgme_passphrase_cb_t cb,
void *cb_value)
{
if (ctx)
{
ctx->passphrase_cb = cb;
ctx->passphrase_cb_value = cb_value;
}
ctx->passphrase_cb = cb;
ctx->passphrase_cb_value = cb_value;
}
/**
* gpgme_get_passphrase_cb:
* @ctx: the context
* @r_cb: The current callback function
* @r_cb_value: The current value passed to the callback function
*
* This function returns the callback function to be used to pass a passphrase
* to the crypto engine.
**/
/* This function returns the callback function to be used to pass a
passphrase to the crypto engine. */
void
gpgme_get_passphrase_cb (gpgme_ctx_t ctx, gpgme_passphrase_cb_t *r_cb,
void **r_cb_value)
{
if (ctx)
{
if (r_cb)
*r_cb = ctx->passphrase_cb;
if (r_cb_value)
*r_cb_value = ctx->passphrase_cb_value;
}
else
{
if (r_cb)
*r_cb = NULL;
if (r_cb_value)
*r_cb_value = NULL;
}
if (r_cb)
*r_cb = ctx->passphrase_cb;
if (r_cb_value)
*r_cb_value = ctx->passphrase_cb_value;
}
/**
* gpgme_set_progress_cb:
* @ctx: the context
* @cb: A callback function
* @cb_value: The value passed to the callback function
*
* This function sets a callback function to be used as a progress indicator.
*
* The callback function is defined as:
* <literal>
* typedef void (*gpgme_progress_cb_t) (void *cb_value,
* const char *what, int type,
* int curretn, int total);
* </literal>
* For details on the progress events, see the entry for the PROGRESS
* status in the file doc/DETAILS of the GnuPG distribution.
**/
/* This function sets a callback function to be used as a progress
indicator. */
void
gpgme_set_progress_cb (gpgme_ctx_t ctx, gpgme_progress_cb_t cb, void *cb_value)
{
if (ctx)
{
ctx->progress_cb = cb;
ctx->progress_cb_value = cb_value;
}
ctx->progress_cb = cb;
ctx->progress_cb_value = cb_value;
}
/**
* gpgme_get_progress_cb:
* @ctx: the context
* @r_cb: The current callback function
* @r_cb_value: The current value passed to the callback function
*
* This function returns the callback function to be used as a
* progress indicator.
**/
/* This function returns the callback function to be used as a
progress indicator. */
void
gpgme_get_progress_cb (gpgme_ctx_t ctx, gpgme_progress_cb_t *r_cb,
void **r_cb_value)
{
if (ctx)
{
if (r_cb)
*r_cb = ctx->progress_cb;
if (r_cb_value)
*r_cb_value = ctx->progress_cb_value;
}
else
{
if (r_cb)
*r_cb = NULL;
if (r_cb_value)
*r_cb_value = NULL;
}
if (r_cb)
*r_cb = ctx->progress_cb;
if (r_cb_value)
*r_cb_value = ctx->progress_cb_value;
}
/**
* gpgme_set_io_cbs:
* @ctx: the context
* @register_io_cb: A callback function
* @register_hook_value: The value passed to the callback function
* @remove_io_cb: Another callback function
*
**/
/* Set the I/O callback functions for CTX to IO_CBS. */
void
gpgme_set_io_cbs (gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs)
{
if (!ctx)
return;
if (io_cbs)
ctx->io_cbs = *io_cbs;
else
@ -426,22 +259,11 @@ gpgme_set_io_cbs (gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs)
}
/**
* gpgme_get_io_cbs:
* @ctx: the context
* @r_register_cb: The current register callback function
* @r_register_cb_value: The current value passed to the
* register callback function
* @r_remove_cb: The current remove callback function
*
* This function returns the callback function to be used to pass a passphrase
* to the crypto engine.
**/
/* This function returns the callback function for I/O. */
void
gpgme_get_io_cbs (gpgme_ctx_t ctx, gpgme_io_cbs_t io_cbs)
{
if (ctx && io_cbs)
*io_cbs = ctx->io_cbs;
*io_cbs = ctx->io_cbs;
}

67
gpgme/gpgme.h
View File

@ -669,18 +669,20 @@ void gpgme_set_include_certs (gpgme_ctx_t ctx, int nr_of_certs);
int gpgme_get_include_certs (gpgme_ctx_t ctx);
/* The available keylist mode flags. */
enum
typedef enum
{
GPGME_KEYLIST_MODE_LOCAL = 1,
GPGME_KEYLIST_MODE_EXTERN = 2,
GPGME_KEYLIST_MODE_SIGS = 4
};
}
gpgme_keylist_mode_t;
/* Set keylist mode in CTX to MODE. */
gpgme_error_t gpgme_set_keylist_mode (gpgme_ctx_t ctx, int mode);
gpgme_error_t gpgme_set_keylist_mode (gpgme_ctx_t ctx,
gpgme_keylist_mode_t mode);
/* Get keylist mode in CTX. */
int gpgme_get_keylist_mode (gpgme_ctx_t ctx);
gpgme_keylist_mode_t gpgme_get_keylist_mode (gpgme_ctx_t ctx);
/* Set the passphrase callback function in CTX to CB. HOOK_VALUE is
passed as first argument to the passphrase callback function. */
@ -767,10 +769,14 @@ typedef gpgme_error_t (*gpgme_register_io_cb_t) (void *data, int fd, int dir,
function. */
typedef void (*gpgme_remove_io_cb_t) (void *tag);
typedef enum { GPGME_EVENT_START,
GPGME_EVENT_DONE,
GPGME_EVENT_NEXT_KEY,
GPGME_EVENT_NEXT_TRUSTITEM } gpgme_event_io_t;
typedef enum
{
GPGME_EVENT_START,
GPGME_EVENT_DONE,
GPGME_EVENT_NEXT_KEY,
GPGME_EVENT_NEXT_TRUSTITEM
}
gpgme_event_io_t;
/* The type of a function that is called when a context finished an
operation. */
@ -979,21 +985,32 @@ typedef struct _gpgme_op_encrypt_result *gpgme_encrypt_result_t;
/* Retrieve a pointer to the result of the encrypt operation. */
gpgme_encrypt_result_t gpgme_op_encrypt_result (gpgme_ctx_t ctx);
/* The valid encryption flags. */
typedef enum
{
GPGME_ENCRYPT_ALWAYS_TRUST = 1
}
gpgme_encrypt_flags_t;
/* Encrypt plaintext PLAIN within CTX for the recipients RECP and
store the resulting ciphertext in CIPHER. */
gpgme_error_t gpgme_op_encrypt_start (gpgme_ctx_t ctx, gpgme_user_id_t recp,
gpgme_error_t gpgme_op_encrypt_start (gpgme_ctx_t ctx, gpgme_key_t recp[],
gpgme_encrypt_flags_t flags,
gpgme_data_t plain, gpgme_data_t cipher);
gpgme_error_t gpgme_op_encrypt (gpgme_ctx_t ctx, gpgme_user_id_t recp,
gpgme_error_t gpgme_op_encrypt (gpgme_ctx_t ctx, gpgme_key_t recp[],
gpgme_encrypt_flags_t flags,
gpgme_data_t plain, gpgme_data_t cipher);
/* Encrypt plaintext PLAIN within CTX for the recipients RECP and
store the resulting ciphertext in CIPHER. Also sign the ciphertext
with the signers in CTX. */
gpgme_error_t gpgme_op_encrypt_sign_start (gpgme_ctx_t ctx,
gpgme_user_id_t recp,
gpgme_key_t recp[],
gpgme_encrypt_flags_t flags,
gpgme_data_t plain,
gpgme_data_t cipher);
gpgme_error_t gpgme_op_encrypt_sign (gpgme_ctx_t ctx, gpgme_user_id_t recp,
gpgme_error_t gpgme_op_encrypt_sign (gpgme_ctx_t ctx, gpgme_key_t recp[],
gpgme_encrypt_flags_t flags,
gpgme_data_t plain, gpgme_data_t cipher);
@ -1069,7 +1086,7 @@ struct _gpgme_sig_notation
typedef struct _gpgme_sig_notation *gpgme_sig_notation_t;
/* Flags used for the SUMMARY field in a gpgme_signature_t. */
enum
typedef enum
{
GPGME_SIGSUM_VALID = 0x0001, /* The signature is fully valid. */
GPGME_SIGSUM_GREEN = 0x0002, /* The signature is good. */
@ -1082,14 +1099,15 @@ enum
GPGME_SIGSUM_CRL_TOO_OLD = 0x0200, /* Available CRL is too old. */
GPGME_SIGSUM_BAD_POLICY = 0x0400, /* A policy was not met. */
GPGME_SIGSUM_SYS_ERROR = 0x0800 /* A system error occured. */
};
}
gpgme_sigsum_t;
struct _gpgme_signature
{
struct _gpgme_signature *next;
/* A summary of the signature status. */
unsigned int summary;
gpgme_sigsum_t summary;
/* The fingerprint or key ID of the signature. */
char *fpr;
@ -1231,11 +1249,20 @@ gpgme_error_t gpgme_op_import_ext (gpgme_ctx_t ctx, gpgme_data_t keydata,
int *nr) _GPGME_DEPRECATED;
/* Export the keys listed in UIDS into KEYDATA. */
gpgme_error_t gpgme_op_export_start (gpgme_ctx_t ctx, gpgme_user_id_t uids,
/* Export the keys found by PATTERN into KEYDATA. */
gpgme_error_t gpgme_op_export_start (gpgme_ctx_t ctx, const char *pattern,
unsigned int reserved,
gpgme_data_t keydata);
gpgme_error_t gpgme_op_export (gpgme_ctx_t ctx, gpgme_user_id_t uids,
gpgme_data_t keydata);
gpgme_error_t gpgme_op_export (gpgme_ctx_t ctx, const char *pattern,
unsigned int reserved, gpgme_data_t keydata);
gpgme_error_t gpgme_op_export_ext_start (gpgme_ctx_t ctx,
const char *pattern[],
unsigned int reserved,
gpgme_data_t keydata);
gpgme_error_t gpgme_op_export_ext (gpgme_ctx_t ctx, const char *pattern[],
unsigned int reserved,
gpgme_data_t keydata);
/* Key generation. */
@ -1285,7 +1312,7 @@ gpgme_error_t gpgme_op_edit (gpgme_ctx_t ctx, gpgme_key_t key,
gpgme_data_t out);
/* Key management functions */
/* Key management functions. */
struct _gpgme_op_keylist_result
{
unsigned int truncated : 1;

4
gpgme/ops.h
View File

@ -33,10 +33,6 @@ void _gpgme_release_result (gpgme_ctx_t ctx);
gpgme_error_t _gpgme_wait_one (gpgme_ctx_t ctx);
gpgme_error_t _gpgme_wait_on_condition (gpgme_ctx_t ctx, volatile int *cond);
/* From user-id.c. */
int _gpgme_user_ids_all_valid (gpgme_user_id_t uid);
/* From data.c. */
gpgme_error_t _gpgme_data_inbound_handler (void *opaque, int fd);

84
gpgme/rungpg.c
View File

@ -1236,26 +1236,30 @@ gpg_edit (void *engine, gpgme_key_t key, gpgme_data_t out,
static gpgme_error_t
append_args_from_recipients (engine_gpg_t gpg, gpgme_user_id_t uid)
append_args_from_recipients (engine_gpg_t gpg, gpgme_key_t recp[])
{
gpgme_error_t err = 0;
int i = 0;
while (uid)
while (recp[i])
{
err = add_arg (gpg, "-r");
if (!recp[i]->subkeys || !recp[i]->subkeys->fpr)
err = GPGME_Invalid_Key;
if (!err)
err = add_arg (gpg, uid->uid);
err = add_arg (gpg, "-r");
if (!err)
err = add_arg (gpg, recp[i]->subkeys->fpr);
if (err)
break;
uid = uid->next;
i++;
}
return err;
}
static gpgme_error_t
gpg_encrypt (void *engine, gpgme_user_id_t recp, gpgme_data_t plain,
gpgme_data_t ciph, int use_armor)
gpg_encrypt (void *engine, gpgme_key_t recp[], gpgme_encrypt_flags_t flags,
gpgme_data_t plain, gpgme_data_t ciph, int use_armor)
{
engine_gpg_t gpg = engine;
gpgme_error_t err;
@ -1270,7 +1274,7 @@ gpg_encrypt (void *engine, gpgme_user_id_t recp, gpgme_data_t plain,
{
/* If we know that all recipients are valid (full or ultimate trust)
we can suppress further checks. */
if (!err && !symmetric && _gpgme_user_ids_all_valid (recp))
if (!err && !symmetric && (flags & GPGME_ENCRYPT_ALWAYS_TRUST))
err = add_arg (gpg, "--always-trust");
if (!err)
@ -1297,7 +1301,8 @@ gpg_encrypt (void *engine, gpgme_user_id_t recp, gpgme_data_t plain,
static gpgme_error_t
gpg_encrypt_sign (void *engine, gpgme_user_id_t recp, gpgme_data_t plain,
gpg_encrypt_sign (void *engine, gpgme_key_t recp[],
gpgme_encrypt_flags_t flags, gpgme_data_t plain,
gpgme_data_t ciph, int use_armor,
gpgme_ctx_t ctx /* FIXME */)
{
@ -1311,8 +1316,8 @@ gpg_encrypt_sign (void *engine, gpgme_user_id_t recp, gpgme_data_t plain,
err = add_arg (gpg, "--armor");
/* If we know that all recipients are valid (full or ultimate trust)
* we can suppress further checks */
if (!err && _gpgme_user_ids_all_valid (recp))
we can suppress further checks. */
if (!err && (flags & GPGME_ENCRYPT_ALWAYS_TRUST))
err = add_arg (gpg, "--always-trust");
if (!err)
@ -1341,12 +1346,15 @@ gpg_encrypt_sign (void *engine, gpgme_user_id_t recp, gpgme_data_t plain,
static gpgme_error_t
gpg_export (void *engine, gpgme_user_id_t uids, gpgme_data_t keydata,
int use_armor)
gpg_export (void *engine, const char *pattern, unsigned int reserved,
gpgme_data_t keydata, int use_armor)
{
engine_gpg_t gpg = engine;
gpgme_error_t err;
if (reserved)
return GPGME_Invalid_Value;
err = add_arg (gpg, "--export");
if (!err && use_armor)
err = add_arg (gpg, "--armor");
@ -1355,10 +1363,38 @@ gpg_export (void *engine, gpgme_user_id_t uids, gpgme_data_t keydata,
if (!err)
err = add_arg (gpg, "--");
while (!err && uids)
if (!err && pattern && *pattern)
err = add_arg (gpg, pattern);
if (!err)
err = start (gpg);
return err;
}
static gpgme_error_t
gpg_export_ext (void *engine, const char *pattern[], unsigned int reserved,
gpgme_data_t keydata, int use_armor)
{
engine_gpg_t gpg = engine;
gpgme_error_t err;
if (reserved)
return GPGME_Invalid_Value;
err = add_arg (gpg, "--export");
if (!err && use_armor)
err = add_arg (gpg, "--armor");
if (!err)
err = add_data (gpg, keydata, 1, 1);
if (!err)
err = add_arg (gpg, "--");
if (pattern)
{
err = add_arg (gpg, uids->uid);
uids = uids->next;
while (!err && *pattern && **pattern)
err = add_arg (gpg, *(pattern++));
}
if (!err)
@ -1417,7 +1453,7 @@ gpg_import (void *engine, gpgme_data_t keydata)
static gpgme_error_t
gpg_keylist (void *engine, const char *pattern, int secret_only,
int keylist_mode)
gpgme_keylist_mode_t mode)
{
engine_gpg_t gpg = engine;
gpgme_error_t err;
@ -1431,7 +1467,7 @@ gpg_keylist (void *engine, const char *pattern, int secret_only,
err = add_arg (gpg, "--with-fingerprint");
if (!err)
err = add_arg (gpg, secret_only ? "--list-secret-keys"
: ((keylist_mode & GPGME_KEYLIST_MODE_SIGS)
: ((mode & GPGME_KEYLIST_MODE_SIGS)
? "--check-sigs" : "--list-keys"));
/* Tell the gpg object about the data. */
@ -1449,7 +1485,7 @@ gpg_keylist (void *engine, const char *pattern, int secret_only,
static gpgme_error_t
gpg_keylist_ext (void *engine, const char *pattern[], int secret_only,
int reserved, int keylist_mode)
int reserved, gpgme_keylist_mode_t mode)
{
engine_gpg_t gpg = engine;
gpgme_error_t err;
@ -1466,15 +1502,14 @@ gpg_keylist_ext (void *engine, const char *pattern[], int secret_only,
err = add_arg (gpg, "--with-fingerprint");
if (!err)
err = add_arg (gpg, secret_only ? "--list-secret-keys"
: ((keylist_mode & GPGME_KEYLIST_MODE_SIGS)
: ((mode & GPGME_KEYLIST_MODE_SIGS)
? "--check-sigs" : "--list-keys"));
/* Tell the gpg object about the data. */
if (!err)
err = add_arg (gpg, "--");
if (!err && pattern && *pattern)
if (pattern)
{
while (*pattern && **pattern)
while (!err && *pattern && **pattern)
err = add_arg (gpg, *(pattern++));
}
@ -1616,6 +1651,7 @@ struct engine_ops _gpgme_engine_ops_gpg =
gpg_encrypt,
gpg_encrypt_sign,
gpg_export,
gpg_export_ext,
gpg_genkey,
gpg_import,
gpg_keylist,

91
gpgme/user-id.c
View File

@ -1,91 +0,0 @@
/* user-id.c - Managing user IDs.
Copyright (C) 2000 Werner Koch (dd9jn)
Copyright (C) 2001, 2002, 2003 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 General Public License as published by
the Free Software Foundation; either version 2 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
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GPGME; if not, write to the Free Software Foundation,
Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#if HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdlib.h>
#include <string.h>
#include <gpgme.h>
/* Release the user IDs in the list UID. */
void
gpgme_user_ids_release (gpgme_user_id_t uid)
{
while (uid)
{
gpgme_user_id_t next_uid = uid->next;
free (uid);
uid = next_uid;
}
}
/* Add the name NAME to the user ID list *UIDS_P (with unknown
validity). */
gpgme_error_t
gpgme_user_ids_append (gpgme_user_id_t *uids_p, const char *name)
{
gpgme_user_id_t uids;
gpgme_user_id_t uid;
if (!name || !uids_p)
return GPGME_Invalid_Value;
uid = calloc (1, sizeof (*uid) + strlen (name) + 1);
if (!uid)
return GPGME_Out_Of_Core;
uid->uid = ((char *) uid) + sizeof (*uid);
strcpy (uid->uid, name);
uid->name = uid->uid + strlen (name);
uid->email = uid->name;
uid->comment = uid->name;
uid->validity = GPGME_VALIDITY_UNKNOWN;
uids = *uids_p;
if (uids)
{
while (uids->next)
uids = uids->next;
uids->next = uid;
}
else
*uids_p = uid;
return 0;
}
int
_gpgme_user_ids_all_valid (gpgme_user_id_t uid)
{
while (uid)
{
if (uid->validity != GPGME_VALIDITY_FULL
&& uid->validity != GPGME_VALIDITY_ULTIMATE)
return 0;
uid = uid->next;
}
return 1;
}

9
tests/ChangeLog
View File

@ -1,3 +1,12 @@
2003-05-29 Marcus Brinkmann <marcus@g10code.de>
* gpg/t-encrypt-sym.c (main): Adapt to new syntax.
* gpg/t-encrypt.c (main): Likewise.
* gpg/t-eventloop.c (main): Likewise.
* gpg/t-encrypt-sign.c (main): Likewise.
* gpgsm/t-export.c (main): Likewise.
* gpgsm/t-encrypt.c (main): Likewise.
2003-05-28 Marcus Brinkmann <marcus@g10code.de>
* gpg/t-eventloop.c (main): Rewrite recipient management.

18
tests/gpg/t-encrypt-sign.c
View File

@ -117,8 +117,7 @@ main (int argc, char **argv)
gpgme_ctx_t ctx;
gpgme_error_t err;
gpgme_data_t in, out;
gpgme_user_id_t rset = NULL;
gpgme_user_id_t *rset_lastp = &rset;
gpgme_key_t key[3] = { NULL, NULL, NULL };
gpgme_encrypt_result_t result;
gpgme_sign_result_t sign_result;
char *agent_info;
@ -141,16 +140,14 @@ main (int argc, char **argv)
err = gpgme_data_new (&out);
fail_if_err (err);
err = gpgme_user_ids_append (rset_lastp, "Alpha");
err = gpgme_get_key (ctx, "A0FF4590BB6122EDEF6E3C542D727CC768697734",
&key[0], 0);
fail_if_err (err);
(*rset_lastp)->validity = GPGME_VALIDITY_FULL;
rset_lastp = &(*rset_lastp)->next;
err = gpgme_user_ids_append (rset_lastp, "Bob");
err = gpgme_get_key (ctx, "D695676BDCEDCC2CDD6152BCFE180B1DA9E3B0B2",
&key[1], 0);
fail_if_err (err);
(*rset_lastp)->validity = GPGME_VALIDITY_FULL;
err = gpgme_op_encrypt_sign (ctx, rset, in, out);
err = gpgme_op_encrypt_sign (ctx, key, GPGME_ENCRYPT_ALWAYS_TRUST, in, out);
fail_if_err (err);
result = gpgme_op_encrypt_result (ctx);
if (result->invalid_recipients)
@ -163,7 +160,8 @@ main (int argc, char **argv)
check_result (sign_result, GPGME_SIG_MODE_NORMAL);
print_data (out);
gpgme_user_ids_release (rset);
gpgme_key_unref (key[0]);
gpgme_key_unref (key[1]);
gpgme_data_release (in);
gpgme_data_release (out);
gpgme_release (ctx);

142
tests/gpg/t-encrypt-sym.c
View File

@ -1,23 +1,22 @@
/* t-encrypt-sym.c - regression test
* Copyright (C) 2000 Werner Koch (dd9jn)
* Copyright (C) 2001, 2003 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 General Public License as published by
* the Free Software Foundation; either version 2 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*/
Copyright (C) 2000 Werner Koch (dd9jn)
Copyright (C) 2001, 2003 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 General Public License as published by
the Free Software Foundation; either version 2 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
General Public License for more details.
You should have received a copy of the GNU General Public License
along with GPGME; if not, write to the Free Software Foundation,
Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#include <stdio.h>
#include <stdlib.h>
@ -27,11 +26,18 @@
#include <gpgme.h>
#define fail_if_err(a) do { if(a) { \
fprintf (stderr, "%s:%d: gpgme_error_t %s\n", \
__FILE__, __LINE__, gpgme_strerror(a)); \
exit (1); } \
} while(0)
#define fail_if_err(err) \
do \
{ \
if (err) \
{ \
fprintf (stderr, "%s:%d: gpgme_error_t %s\n", \
__FILE__, __LINE__, gpgme_strerror (err)); \
exit (1); \
} \
} \
while (0)
static void
print_data (gpgme_data_t dh)
@ -72,54 +78,50 @@ main (int argc, char **argv)
err = gpgme_engine_check_version (GPGME_PROTOCOL_OpenPGP);
fail_if_err (err);
do
err = gpgme_new (&ctx);
fail_if_err (err);
gpgme_set_armor (ctx, 1);
p = getenv("GPG_AGENT_INFO");
if (!(p && strchr (p, ':')))
gpgme_set_passphrase_cb (ctx, passphrase_cb, NULL);
err = gpgme_data_new_from_mem (&plain, text, strlen (text), 0);
fail_if_err (err);
err = gpgme_data_new (&cipher);
fail_if_err (err);
err = gpgme_op_encrypt (ctx, 0, 0, plain, cipher);
fail_if_err (err);
fflush (NULL);
fputs ("Begin Result Encryption:\n", stdout);
print_data (cipher);
fputs ("End Result.\n", stdout);
gpgme_data_seek (cipher, 0, SEEK_SET);
gpgme_data_release (plain);
err = gpgme_data_new (&plain);
fail_if_err (err);
err = gpgme_op_decrypt (ctx, cipher, plain);
fail_if_err (err);
fputs ("Begin Result Decryption:\n", stdout);
print_data (plain);
fputs ("End Result.\n", stdout);
text2 = gpgme_data_release_and_get_mem (plain, &len);
if (strncmp (text, text2, len))
{
err = gpgme_new (&ctx);
fail_if_err (err);
gpgme_set_armor (ctx, 1);
p = getenv("GPG_AGENT_INFO");
if (!(p && strchr (p, ':')))
gpgme_set_passphrase_cb (ctx, passphrase_cb, NULL);
err = gpgme_data_new_from_mem (&plain, text, strlen (text), 0);
fail_if_err (err);
err = gpgme_data_new (&cipher);
fail_if_err (err);
err = gpgme_op_encrypt (ctx, 0, plain, cipher);
fail_if_err (err);
fflush (NULL);
fputs ("Begin Result Encryption:\n", stdout);
print_data (cipher);
fputs ("End Result.\n", stdout);
gpgme_data_seek (cipher, 0, SEEK_SET);
gpgme_data_release (plain);
err = gpgme_data_new (&plain);
fail_if_err (err);
err = gpgme_op_decrypt (ctx, cipher, plain);
fail_if_err (err);
fputs ("Begin Result Decryption:\n", stdout);
print_data (plain);
fputs ("End Result.\n", stdout);
text2 = gpgme_data_release_and_get_mem (plain, &len);
if (strncmp (text, text2, len))
{
fprintf (stderr, "%s:%d: Wrong plaintext\n", __FILE__, __LINE__);
exit (1);
}
gpgme_data_release (cipher);
gpgme_release (ctx);
fprintf (stderr, "%s:%d: Wrong plaintext\n", __FILE__, __LINE__);
exit (1);
}
while (argc > 1 && !strcmp (argv[1], "--loop"));
gpgme_data_release (cipher);
gpgme_release (ctx);
return 0;
}

24
tests/gpg/t-encrypt.c
View File

@ -60,10 +60,11 @@ main (int argc, char **argv)
gpgme_ctx_t ctx;
gpgme_error_t err;
gpgme_data_t in, out;
gpgme_user_id_t rset = NULL;
gpgme_user_id_t *rset_lastp = &rset;
gpgme_key_t key[3] = { NULL, NULL, NULL };
gpgme_encrypt_result_t result;
gpgme_check_version (0);
err = gpgme_engine_check_version (GPGME_PROTOCOL_OpenPGP);
fail_if_err (err);
@ -76,17 +77,15 @@ main (int argc, char **argv)
err = gpgme_data_new (&out);
fail_if_err (err);
err = gpgme_user_ids_append (rset_lastp, "Alpha");
fail_if_err (err);
(*rset_lastp)->validity = GPGME_VALIDITY_FULL;
rset_lastp = &(*rset_lastp)->next;
err = gpgme_user_ids_append (rset_lastp, "Bob");
err = gpgme_get_key (ctx, "A0FF4590BB6122EDEF6E3C542D727CC768697734",
&key[0], 0);
fail_if_err (err);
err = gpgme_get_key (ctx, "D695676BDCEDCC2CDD6152BCFE180B1DA9E3B0B2",
&key[1], 0);
fail_if_err (err);
(*rset_lastp)->validity = GPGME_VALIDITY_FULL;
err = gpgme_op_encrypt (ctx, rset, in, out);
err = gpgme_op_encrypt (ctx, key, GPGME_ENCRYPT_ALWAYS_TRUST, in, out);
fail_if_err (err);
result = gpgme_op_encrypt_result (ctx);
if (result->invalid_recipients)
@ -97,11 +96,10 @@ main (int argc, char **argv)
}
print_data (out);
gpgme_user_ids_release (rset);
gpgme_key_unref (key[0]);
gpgme_key_unref (key[1]);
gpgme_data_release (in);
gpgme_data_release (out);
gpgme_release (ctx);
return 0;
}

18
tests/gpg/t-eventloop.c
View File

@ -191,8 +191,7 @@ main (int argc, char *argv[])
gpgme_ctx_t ctx;
gpgme_error_t err;
gpgme_data_t in, out;
gpgme_user_id_t rset = NULL;
gpgme_user_id_t *rset_lastp = &rset;
gpgme_key_t key[3] = { NULL, NULL, NULL };
int i;
for (i = 0; i < FDLIST_MAX; i++)
@ -213,16 +212,14 @@ main (int argc, char *argv[])
err = gpgme_data_new (&out);
fail_if_err (err);
err = gpgme_user_ids_append (rset_lastp, "Alpha");
err = gpgme_get_key (ctx, "A0FF4590BB6122EDEF6E3C542D727CC768697734",
&key[0], 0);
fail_if_err (err);
(*rset_lastp)->validity = GPGME_VALIDITY_FULL;
rset_lastp = &(*rset_lastp)->next;
err = gpgme_user_ids_append (rset_lastp, "Bob");
err = gpgme_get_key (ctx, "D695676BDCEDCC2CDD6152BCFE180B1DA9E3B0B2",
&key[1], 0);
fail_if_err (err);
(*rset_lastp)->validity = GPGME_VALIDITY_FULL;
err = gpgme_op_encrypt_start (ctx, rset, in, out);
err = gpgme_op_encrypt_start (ctx, key, GPGME_ENCRYPT_ALWAYS_TRUST, in, out);
fail_if_err (err);
my_wait ();
@ -234,7 +231,8 @@ main (int argc, char *argv[])
print_data (out);
fputs ("End Result.\n", stdout);
gpgme_user_ids_release (rset);
gpgme_key_unref (key[0]);
gpgme_key_unref (key[1]);
gpgme_data_release (in);
gpgme_data_release (out);
gpgme_release (ctx);

15
tests/gpg/t-export.c
View File

@ -60,8 +60,7 @@ main (int argc, char **argv)
gpgme_ctx_t ctx;
gpgme_error_t err;
gpgme_data_t out;
gpgme_user_id_t uids = NULL;
gpgme_user_id_t *uids_lastp = &uids;
const char *pattern[] = { "Alpha", "Bob", NULL };
err = gpgme_new (&ctx);
fail_if_err (err);
@ -69,15 +68,8 @@ main (int argc, char **argv)
err = gpgme_data_new (&out);
fail_if_err (err);
err = gpgme_user_ids_append (uids_lastp, "Alpha");
fail_if_err (err);
uids_lastp = &(*uids_lastp)->next;
err = gpgme_user_ids_append (uids_lastp, "Bob");
fail_if_err (err);
gpgme_set_armor (ctx, 1);
err = gpgme_op_export (ctx, uids, out);
err = gpgme_op_export_ext (ctx, pattern, 0, out);
fail_if_err (err);
fflush (NULL);
@ -85,11 +77,8 @@ main (int argc, char **argv)
print_data (out);
fputs ("End Result.\n", stdout);
gpgme_user_ids_release (uids);
gpgme_data_release (out);
gpgme_release (ctx);
return 0;
}

10
tests/gpgsm/t-encrypt.c
View File

@ -60,7 +60,7 @@ main (int argc, char **argv)
gpgme_ctx_t ctx;
gpgme_error_t err;
gpgme_data_t in, out;
gpgme_user_id_t rset = NULL;
gpgme_key_t key[] = { NULL, NULL };
gpgme_encrypt_result_t result;
err = gpgme_engine_check_version (GPGME_PROTOCOL_CMS);
@ -77,11 +77,11 @@ main (int argc, char **argv)
err = gpgme_data_new (&out);
fail_if_err (err);
err = gpgme_user_ids_append (&rset, "test cert 1");
err = gpgme_get_key (ctx, "3CF405464F66ED4A7DF45BBDD1E4282E33BDB76E",
&key[0], 0);
fail_if_err (err);
rset->validity = GPGME_VALIDITY_FULL;
err = gpgme_op_encrypt (ctx, rset, in, out);
err = gpgme_op_encrypt (ctx, key, 0, in, out);
fail_if_err (err);
result = gpgme_op_encrypt_result (ctx);
if (result->invalid_recipients)
@ -92,7 +92,7 @@ main (int argc, char **argv)
}
print_data (out);
gpgme_user_ids_release (rset);
gpgme_key_unref (key[0]);
gpgme_data_release (in);
gpgme_data_release (out);
gpgme_release (ctx);

11
tests/gpgsm/t-export.c
View File

@ -59,9 +59,8 @@ main (int argc, char *argv[])
{
gpgme_ctx_t ctx;
gpgme_error_t err;
gpgme_data_t out;
gpgme_user_id_t rset = NULL;
gpgme_data_t out;
const char *pattern[] = { "DFN Top Level Certification Authority", NULL };
err = gpgme_new (&ctx);
fail_if_err (err);
gpgme_set_protocol (ctx, GPGME_PROTOCOL_CMS);
@ -69,11 +68,8 @@ main (int argc, char *argv[])
err = gpgme_data_new (&out);
fail_if_err (err);
err = gpgme_user_ids_append (&rset, "DFN Top Level Certification Authority");
fail_if_err (err);
gpgme_set_armor (ctx, 1);
err = gpgme_op_export (ctx, rset, out);
err = gpgme_op_export_ext (ctx, pattern, 0, out);
fail_if_err (err);
fflush (NULL);
@ -81,7 +77,6 @@ main (int argc, char *argv[])
print_data (out);
fputs ("End Result.\n", stdout);
gpgme_user_ids_release (rset);
gpgme_data_release (out);
gpgme_release (ctx);