security-and-privacy/gnupg
security-and-privacy
/
gnupg
mirror of git://git.gnupg.org/gnupg.git
1
0
Fork 0
Code Releases Activity

Update error handling to match gpg-error in CVS.

This commit is contained in:
Marcus Brinkmann 2003-06-04 21:37:56 +00:00
parent 39e6e163d4
commit a58ce94d8e
16 changed files with 119 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
agent/divert-scd.c
View File

@ -48,11 +48,11 @@ ask_for_card (CTRL ctrl, const unsigned char *shadow_info, char **r_kid)
*r_kid = NULL; *r_kid = NULL;
s = shadow_info; s = shadow_info;
if (*s != '(') if (*s != '(')
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
s++; s++;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
want_sn = xtrymalloc (n*2+1); want_sn = xtrymalloc (n*2+1);
if (!want_sn) if (!want_sn)
return out_of_core (); return out_of_core ();
@ -68,7 +68,7 @@ ask_for_card (CTRL ctrl, const unsigned char *shadow_info, char **r_kid)
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
want_kid = xtrymalloc (n+1); want_kid = xtrymalloc (n+1);
if (!want_kid) if (!want_kid)
{ {
@ -261,11 +261,11 @@ divert_pkdecrypt (CTRL ctrl,
s = cipher; s = cipher;
if (*s != '(') if (*s != '(')
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
s++; s++;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
if (!smatch (&s, n, "enc-val")) if (!smatch (&s, n, "enc-val"))
return gpg_error (GPG_ERR_UNKNOWN_SEXP); return gpg_error (GPG_ERR_UNKNOWN_SEXP);
if (*s != '(') if (*s != '(')
@ -273,7 +273,7 @@ divert_pkdecrypt (CTRL ctrl,
s++; s++;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
if (!smatch (&s, n, "rsa")) if (!smatch (&s, n, "rsa"))
return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM); return gpg_error (GPG_ERR_UNSUPPORTED_ALGORITHM);
if (*s != '(') if (*s != '(')
@ -281,7 +281,7 @@ divert_pkdecrypt (CTRL ctrl,
s++; s++;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
if (!smatch (&s, n, "a")) if (!smatch (&s, n, "a"))
return gpg_error (GPG_ERR_UNKNOWN_SEXP); return gpg_error (GPG_ERR_UNKNOWN_SEXP);
n = snext (&s); n = snext (&s);

6
agent/genkey.c
View File

@ -101,7 +101,7 @@ agent_genkey (CTRL ctrl, const char *keyparam, size_t keyparamlen,
if (rc) if (rc)
{ {
log_error ("failed to convert keyparam: %s\n", gcry_strerror (rc)); log_error ("failed to convert keyparam: %s\n", gcry_strerror (rc));
return gpg_error (GPG_ERR_INVALID_DATA); return gpg_error (GPG_ERR_INV_DATA);
} }
/* Get the passphrase now, cause key generation may take a while. */ /* Get the passphrase now, cause key generation may take a while. */
@ -147,7 +147,7 @@ agent_genkey (CTRL ctrl, const char *keyparam, size_t keyparamlen,
log_error ("key generation failed: invalid return value\n"); log_error ("key generation failed: invalid return value\n");
gcry_sexp_release (s_key); gcry_sexp_release (s_key);
xfree (pi); xfree (pi);
return gpg_error (GPG_ERR_INVALID_DATA); return gpg_error (GPG_ERR_INV_DATA);
} }
s_public = gcry_sexp_find_token (s_key, "public-key", 0); s_public = gcry_sexp_find_token (s_key, "public-key", 0);
if (!s_public) if (!s_public)
@ -156,7 +156,7 @@ agent_genkey (CTRL ctrl, const char *keyparam, size_t keyparamlen,
gcry_sexp_release (s_private); gcry_sexp_release (s_private);
gcry_sexp_release (s_key); gcry_sexp_release (s_key);
xfree (pi); xfree (pi);
return gpg_error (GPG_ERR_INVALID_DATA); return gpg_error (GPG_ERR_INV_DATA);
} }
gcry_sexp_release (s_key); s_key = NULL; gcry_sexp_release (s_key); s_key = NULL;

6
agent/learncard.c
View File

@ -110,7 +110,7 @@ kpinfo_cb (void *opaque, const char *line)
} }
else if ((p - item->hexgrip) != 40 || !spacep (p)) else if ((p - item->hexgrip) != 40 || !spacep (p))
{ /* not a 20 byte hex keygrip or not followed by a space */ { /* not a 20 byte hex keygrip or not followed by a space */
parm->error = gpg_error (GPG_ERR_INVALID_RESPONSE); parm->error = gpg_error (GPG_ERR_INV_RESPONSE);
xfree (item); xfree (item);
return; return;
} }
@ -122,7 +122,7 @@ kpinfo_cb (void *opaque, const char *line)
p++; p++;
if (p == item->id) if (p == item->id)
{ /* invalid ID string */ { /* invalid ID string */
parm->error = gpg_error (GPG_ERR_INVALID_RESPONSE); parm->error = gpg_error (GPG_ERR_INV_RESPONSE);
xfree (item); xfree (item);
return; return;
} }
@ -154,7 +154,7 @@ certinfo_cb (void *opaque, const char *line)
; ;
if (p == pend || !*p) if (p == pend || !*p)
{ {
parm->error = gpg_error (GPG_ERR_INVALID_RESPONSE); parm->error = gpg_error (GPG_ERR_INV_RESPONSE);
return; return;
} }
*pend = 0; /* ignore trailing stuff */ *pend = 0; /* ignore trailing stuff */

2
agent/pkdecrypt.c
View File

@ -77,7 +77,7 @@ agent_pkdecrypt (CTRL ctrl, const char *ciphertext, size_t ciphertextlen,
if (!gcry_sexp_canon_len (ciphertext, ciphertextlen, NULL, NULL)) if (!gcry_sexp_canon_len (ciphertext, ciphertextlen, NULL, NULL))
{ {
rc = gpg_error (GPG_ERR_INVALID_SEXP); rc = gpg_error (GPG_ERR_INV_SEXP);
goto leave; goto leave;
} }

90
agent/protect.c
View File

@ -68,11 +68,11 @@ calculate_mic (const unsigned char *plainkey, unsigned char *sha1hash)
s = plainkey; s = plainkey;
if (*s != '(') if (*s != '(')
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
s++; s++;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
if (!smatch (&s, n, "private-key")) if (!smatch (&s, n, "private-key"))
return gpg_error (GPG_ERR_UNKNOWN_SEXP); return gpg_error (GPG_ERR_UNKNOWN_SEXP);
if (*s != '(') if (*s != '(')
@ -81,7 +81,7 @@ calculate_mic (const unsigned char *plainkey, unsigned char *sha1hash)
s++; s++;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
s += n; /* skip over the algorithm name */ s += n; /* skip over the algorithm name */
while (*s == '(') while (*s == '(')
@ -89,18 +89,18 @@ calculate_mic (const unsigned char *plainkey, unsigned char *sha1hash)
s++; s++;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
s += n; s += n;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
s += n; s += n;
if ( *s != ')' ) if ( *s != ')' )
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
s++; s++;
} }
if (*s != ')') if (*s != ')')
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
s++; s++;
hash_end = s; hash_end = s;
@ -278,12 +278,12 @@ agent_protect (const unsigned char *plainkey, const char *passphrase,
s = plainkey; s = plainkey;
if (*s != '(') if (*s != '(')
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
depth++; depth++;
s++; s++;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
if (!smatch (&s, n, "private-key")) if (!smatch (&s, n, "private-key"))
return gpg_error (GPG_ERR_UNKNOWN_SEXP); return gpg_error (GPG_ERR_UNKNOWN_SEXP);
if (*s != '(') if (*s != '(')
@ -293,7 +293,7 @@ agent_protect (const unsigned char *plainkey, const char *passphrase,
s++; s++;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
for (infidx=0; protect_info[infidx].algo for (infidx=0; protect_info[infidx].algo
&& !smatch (&s, n, protect_info[infidx].algo); infidx++) && !smatch (&s, n, protect_info[infidx].algo); infidx++)
@ -307,28 +307,28 @@ agent_protect (const unsigned char *plainkey, const char *passphrase,
if (i == protect_info[infidx].prot_from) if (i == protect_info[infidx].prot_from)
prot_begin = s; prot_begin = s;
if (*s != '(') if (*s != '(')
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
depth++; depth++;
s++; s++;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
if (n != 1 || c != *s) if (n != 1 || c != *s)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
s += n; s += n;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
s +=n; /* skip value */ s +=n; /* skip value */
if (*s != ')') if (*s != ')')
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
depth--; depth--;
if (i == protect_info[infidx].prot_to) if (i == protect_info[infidx].prot_to)
prot_end = s; prot_end = s;
s++; s++;
} }
if (*s != ')' || !prot_begin || !prot_end ) if (*s != ')' || !prot_begin || !prot_end )
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
depth--; depth--;
hash_end = s; hash_end = s;
s++; s++;
@ -566,7 +566,7 @@ merge_lists (const unsigned char *protectedkey,
invalid_sexp: invalid_sexp:
xfree (newlist); xfree (newlist);
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
} }
@ -591,11 +591,11 @@ agent_unprotect (const unsigned char *protectedkey, const char *passphrase,
s = protectedkey; s = protectedkey;
if (*s != '(') if (*s != '(')
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
s++; s++;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
if (!smatch (&s, n, "protected-private-key")) if (!smatch (&s, n, "protected-private-key"))
return gpg_error (GPG_ERR_UNKNOWN_SEXP); return gpg_error (GPG_ERR_UNKNOWN_SEXP);
if (*s != '(') if (*s != '(')
@ -603,7 +603,7 @@ agent_unprotect (const unsigned char *protectedkey, const char *passphrase,
s++; s++;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
for (infidx=0; protect_info[infidx].algo for (infidx=0; protect_info[infidx].algo
&& !smatch (&s, n, protect_info[infidx].algo); infidx++) && !smatch (&s, n, protect_info[infidx].algo); infidx++)
@ -620,12 +620,12 @@ agent_unprotect (const unsigned char *protectedkey, const char *passphrase,
for (;;) for (;;)
{ {
if (*s != '(') if (*s != '(')
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
prot_begin = s; prot_begin = s;
s++; s++;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
if (smatch (&s, n, "protected")) if (smatch (&s, n, "protected"))
break; break;
s += n; s += n;
@ -637,15 +637,15 @@ agent_unprotect (const unsigned char *protectedkey, const char *passphrase,
/* found */ /* found */
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
if (!smatch (&s, n, "openpgp-s2k3-sha1-" PROT_CIPHER_STRING "-cbc")) if (!smatch (&s, n, "openpgp-s2k3-sha1-" PROT_CIPHER_STRING "-cbc"))
return gpg_error (GPG_ERR_UNSUPPORTED_PROTECTION); return gpg_error (GPG_ERR_UNSUPPORTED_PROTECTION);
if (*s != '(' || s[1] != '(') if (*s != '(' || s[1] != '(')
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
s += 2; s += 2;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
if (!smatch (&s, n, "sha1")) if (!smatch (&s, n, "sha1"))
return gpg_error (GPG_ERR_UNSUPPORTED_PROTECTION); return gpg_error (GPG_ERR_UNSUPPORTED_PROTECTION);
n = snext (&s); n = snext (&s);
@ -660,7 +660,7 @@ agent_unprotect (const unsigned char *protectedkey, const char *passphrase,
here. We might want to check that we only have digits - but this here. We might want to check that we only have digits - but this
is nothing we should worry about */ is nothing we should worry about */
if (s[n] != ')' ) if (s[n] != ')' )
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
s2kcount = strtoul (s, NULL, 10); s2kcount = strtoul (s, NULL, 10);
if (!s2kcount) if (!s2kcount)
return gpg_error (GPG_ERR_CORRUPTED_PROTECTION); return gpg_error (GPG_ERR_CORRUPTED_PROTECTION);
@ -673,11 +673,11 @@ agent_unprotect (const unsigned char *protectedkey, const char *passphrase,
iv = s; iv = s;
s += n; s += n;
if (*s != ')' ) if (*s != ')' )
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
s++; s++;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
rc = do_decryption (s, n, rc = do_decryption (s, n,
passphrase, s2ksalt, s2kcount, passphrase, s2ksalt, s2kcount,
@ -836,15 +836,15 @@ agent_shadow_key (const unsigned char *pubkey,
size_t shadow_info_len = gcry_sexp_canon_len (shadow_info, 0, NULL,NULL); size_t shadow_info_len = gcry_sexp_canon_len (shadow_info, 0, NULL,NULL);
if (!pubkey_len || !shadow_info_len) if (!pubkey_len || !shadow_info_len)
return gpg_error (GPG_ERR_INVALID_VALUE); return gpg_error (GPG_ERR_INV_VALUE);
s = pubkey; s = pubkey;
if (*s != '(') if (*s != '(')
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
depth++; depth++;
s++; s++;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
if (!smatch (&s, n, "public-key")) if (!smatch (&s, n, "public-key"))
return gpg_error (GPG_ERR_UNKNOWN_SEXP); return gpg_error (GPG_ERR_UNKNOWN_SEXP);
if (*s != '(') if (*s != '(')
@ -853,25 +853,25 @@ agent_shadow_key (const unsigned char *pubkey,
s++; s++;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
s += n; /* skip over the algorithm name */ s += n; /* skip over the algorithm name */
while (*s != ')') while (*s != ')')
{ {
if (*s != '(') if (*s != '(')
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
depth++; depth++;
s++; s++;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
s += n; s += n;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
s +=n; /* skip value */ s +=n; /* skip value */
if (*s != ')') if (*s != ')')
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
depth--; depth--;
s++; s++;
} }
@ -912,12 +912,12 @@ agent_get_shadow_info (const unsigned char *shadowkey,
s = shadowkey; s = shadowkey;
if (*s != '(') if (*s != '(')
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
depth++; depth++;
s++; s++;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
if (!smatch (&s, n, "shadowed-private-key")) if (!smatch (&s, n, "shadowed-private-key"))
return gpg_error (GPG_ERR_UNKNOWN_SEXP); return gpg_error (GPG_ERR_UNKNOWN_SEXP);
if (*s != '(') if (*s != '(')
@ -926,7 +926,7 @@ agent_get_shadow_info (const unsigned char *shadowkey,
s++; s++;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
s += n; /* skip over the algorithm name */ s += n; /* skip over the algorithm name */
for (;;) for (;;)
@ -934,32 +934,32 @@ agent_get_shadow_info (const unsigned char *shadowkey,
if (*s == ')') if (*s == ')')
return gpg_error (GPG_ERR_UNKNOWN_SEXP); return gpg_error (GPG_ERR_UNKNOWN_SEXP);
if (*s != '(') if (*s != '(')
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
depth++; depth++;
s++; s++;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
if (smatch (&s, n, "shadowed")) if (smatch (&s, n, "shadowed"))
break; break;
s += n; s += n;
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
s +=n; /* skip value */ s +=n; /* skip value */
if (*s != ')') if (*s != ')')
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
depth--; depth--;
s++; s++;
} }
/* found the shadowed list, s points to the protocol */ /* found the shadowed list, s points to the protocol */
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
if (smatch (&s, n, "t1-v1")) if (smatch (&s, n, "t1-v1"))
{ {
if (*s != '(') if (*s != '(')
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
*shadow_info = s; *shadow_info = s;
} }
else else

4
agent/sexp-parse.h
View File

@ -68,10 +68,10 @@ sskip (unsigned char const **buf, int *depth)
else else
{ {
if (!d) if (!d)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
n = snext (&s); n = snext (&s);
if (!n) if (!n)
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
s += n; s += n;
} }
} }

6
common/errors.h
View File

@ -23,11 +23,7 @@
#include "util.h" #include "util.h"
#ifdef GPG_ERR_SOURCE_DEFAULT #ifndef GPG_ERR_SOURCE_DEFAULT
# define GPG_ERR_INVALID_VALUE GPG_ERR_INV_VALUE
# define GPG_ERR_INVALID_DATA GPG_ERR_INV_DATA
# define GPG_ERR_INVALID_SEXP GPG_ERR_INV_SEXP
#else /*GPG_ERR_SOURCE_DEFAUL*/
/* Error numbers. Note, that they are onkly used for old code not yet /* Error numbers. Note, that they are onkly used for old code not yet
converted to libgpg-error. */ converted to libgpg-error. */
enum { enum {

12
scd/card-dinsig.c
View File

@ -128,13 +128,13 @@ dinsig_enum_keypairs (CARD card, int idx,
log_error ("failed to parse the certificate at idx %d: %s\n", log_error ("failed to parse the certificate at idx %d: %s\n",
idx, ksba_strerror (krc)); idx, ksba_strerror (krc));
ksba_cert_release (cert); ksba_cert_release (cert);
return gpg_error (GPG_ERR_CARD_ERROR); return gpg_error (GPG_ERR_CARD);
} }
if (card_help_get_keygrip (cert, keygrip)) if (card_help_get_keygrip (cert, keygrip))
{ {
log_error ("failed to calculate the keygrip at index %d\n", idx); log_error ("failed to calculate the keygrip at index %d\n", idx);
ksba_cert_release (cert); ksba_cert_release (cert);
return gpg_error (GPG_ERR_CARD_ERROR); return gpg_error (GPG_ERR_CARD);
} }
ksba_cert_release (cert); ksba_cert_release (cert);
@ -171,7 +171,7 @@ dinsig_read_cert (CARD card, const char *certidstr,
else if (!strcmp (certidstr, "DINSIG-DF01.C200")) else if (!strcmp (certidstr, "DINSIG-DF01.C200"))
sc_format_path ("3F00DF01C200", &path); sc_format_path ("3F00DF01C200", &path);
else else
return gpg_error (GPG_ERR_INVALID_ID); return gpg_error (GPG_ERR_INV_ID);
rc = sc_select_file (card->scard, &path, &file); rc = sc_select_file (card->scard, &path, &file);
if (rc) if (rc)
@ -184,13 +184,13 @@ dinsig_read_cert (CARD card, const char *certidstr,
{ {
log_error ("wrong type or structure of certificate EF\n"); log_error ("wrong type or structure of certificate EF\n");
sc_file_free (file); sc_file_free (file);
return gpg_error (GPG_ERR_CARD_ERROR); return gpg_error (GPG_ERR_CARD);
} }
if (file->size < 20) /* check against a somewhat arbitrary length */ if (file->size < 20) /* check against a somewhat arbitrary length */
{ {
log_error ("certificate EF too short\n"); log_error ("certificate EF too short\n");
sc_file_free (file); sc_file_free (file);
return gpg_error (GPG_ERR_CARD_ERROR); return gpg_error (GPG_ERR_CARD);
} }
buf = xtrymalloc (file->size); buf = xtrymalloc (file->size);
if (!buf) if (!buf)
@ -206,7 +206,7 @@ dinsig_read_cert (CARD card, const char *certidstr,
log_error ("short read on certificate EF\n"); log_error ("short read on certificate EF\n");
sc_file_free (file); sc_file_free (file);
xfree (buf); xfree (buf);
return gpg_error (GPG_ERR_CARD_ERROR); return gpg_error (GPG_ERR_CARD);
} }
sc_file_free (file); sc_file_free (file);
if (rc < 0) if (rc < 0)

24
scd/card-p15.c
View File

@ -70,7 +70,7 @@ init_private_data (CARD card)
{ {
log_error ("private keys enumeration failed: %s\n", sc_strerror (rc)); log_error ("private keys enumeration failed: %s\n", sc_strerror (rc));
xfree (priv); xfree (priv);
return gpg_error (GPG_ERR_CARD_ERROR); return gpg_error (GPG_ERR_CARD);
} }
priv->n_prkey_rsa_objs = rc; priv->n_prkey_rsa_objs = rc;
@ -82,7 +82,7 @@ init_private_data (CARD card)
{ {
log_error ("private keys enumeration failed: %s\n", sc_strerror (rc)); log_error ("private keys enumeration failed: %s\n", sc_strerror (rc));
xfree (priv); xfree (priv);
return gpg_error (GPG_ERR_CARD_ERROR); return gpg_error (GPG_ERR_CARD);
} }
priv->n_cert_objs = rc; priv->n_cert_objs = rc;
@ -145,7 +145,7 @@ p15_enum_keypairs (CARD card, int idx,
{ {
log_info ("failed to read certificate for private key %d: %s\n", log_info ("failed to read certificate for private key %d: %s\n",
idx, sc_strerror (rc)); idx, sc_strerror (rc));
return gpg_error (GPG_ERR_CARD_ERROR); return gpg_error (GPG_ERR_CARD);
} }
cert = ksba_cert_new (); cert = ksba_cert_new ();
@ -162,13 +162,13 @@ p15_enum_keypairs (CARD card, int idx,
log_error ("failed to parse the certificate for private key %d: %s\n", log_error ("failed to parse the certificate for private key %d: %s\n",
idx, ksba_strerror (krc)); idx, ksba_strerror (krc));
ksba_cert_release (cert); ksba_cert_release (cert);
return gpg_error (GPG_ERR_CARD_ERROR); return gpg_error (GPG_ERR_CARD);
} }
if (card_help_get_keygrip (cert, keygrip)) if (card_help_get_keygrip (cert, keygrip))
{ {
log_error ("failed to calculate the keygrip of private key %d\n", idx); log_error ("failed to calculate the keygrip of private key %d\n", idx);
ksba_cert_release (cert); ksba_cert_release (cert);
return gpg_error (GPG_ERR_CARD_ERROR); return gpg_error (GPG_ERR_CARD);
} }
ksba_cert_release (cert); ksba_cert_release (cert);
@ -252,14 +252,14 @@ idstr_to_id (const char *idstr, struct sc_pkcs15_id *id)
/* For now we only support the standard DF */ /* For now we only support the standard DF */
if (strncmp (idstr, "P15-5015.", 9) ) if (strncmp (idstr, "P15-5015.", 9) )
return gpg_error (GPG_ERR_INVALID_ID); return gpg_error (GPG_ERR_INV_ID);
for (s=idstr+9, n=0; hexdigitp (s); s++, n++) for (s=idstr+9, n=0; hexdigitp (s); s++, n++)
; ;
if (*s || (n&1)) if (*s || (n&1))
return gpg_error (GPG_ERR_INVALID_ID); /*invalid or odd number of digits*/ return gpg_error (GPG_ERR_INV_ID); /*invalid or odd number of digits*/
n /= 2; n /= 2;
if (!n || n > SC_PKCS15_MAX_ID_SIZE) if (!n || n > SC_PKCS15_MAX_ID_SIZE)
return gpg_error (GPG_ERR_INVALID_ID); /* empty or too large */ return gpg_error (GPG_ERR_INV_ID); /* empty or too large */
for (s=idstr+9, n=0; *s; s += 2, n++) for (s=idstr+9, n=0; *s; s += 2, n++)
id->value[n] = xtoi_2 (s); id->value[n] = xtoi_2 (s);
id->len = n; id->len = n;
@ -279,7 +279,7 @@ p15_read_cert (CARD card, const char *certidstr,
int rc; int rc;
if (!card || !certidstr || !cert || !ncert) if (!card || !certidstr || !cert || !ncert)
return gpg_error (GPG_ERR_INVALID_VALUE); return gpg_error (GPG_ERR_INV_VALUE);
if (!card->p15card) if (!card->p15card)
return gpg_error (GPG_ERR_NO_PKCS15_APP); return gpg_error (GPG_ERR_NO_PKCS15_APP);
@ -300,7 +300,7 @@ p15_read_cert (CARD card, const char *certidstr,
{ {
log_info ("failed to read certificate '%s': %s\n", log_info ("failed to read certificate '%s': %s\n",
certidstr, sc_strerror (rc)); certidstr, sc_strerror (rc));
return gpg_error (GPG_ERR_CARD_ERROR); return gpg_error (GPG_ERR_CARD);
} }
*cert = xtrymalloc (certder->data_len); *cert = xtrymalloc (certder->data_len);
@ -411,7 +411,7 @@ p15_sign (CARD card, const char *keyidstr, int hashalgo,
if (rc < 0) if (rc < 0)
{ {
log_error ("failed to create signature: %s\n", sc_strerror (rc)); log_error ("failed to create signature: %s\n", sc_strerror (rc));
rc = gpg_error (GPG_ERR_CARD_ERROR); rc = gpg_error (GPG_ERR_CARD);
} }
else else
{ {
@ -473,7 +473,7 @@ p15_decipher (CARD card, const char *keyidstr,
if (rc < 0) if (rc < 0)
{ {
log_error ("failed to decipher the data: %s\n", sc_strerror (rc)); log_error ("failed to decipher the data: %s\n", sc_strerror (rc));
rc = gpg_error (GPG_ERR_CARD_ERROR); rc = gpg_error (GPG_ERR_CARD);
} }
else else
{ {

31
scd/card.c
View File

@ -48,9 +48,9 @@ map_sc_err (int rc)
case SC_ERROR_OUT_OF_MEMORY: e = GPG_ERR_ENOMEM; break; case SC_ERROR_OUT_OF_MEMORY: e = GPG_ERR_ENOMEM; break;
case SC_ERROR_CARD_NOT_PRESENT: e = GPG_ERR_CARD_NOT_PRESENT; break; case SC_ERROR_CARD_NOT_PRESENT: e = GPG_ERR_CARD_NOT_PRESENT; break;
case SC_ERROR_CARD_REMOVED: e = GPG_ERR_CARD_REMOVED; break; case SC_ERROR_CARD_REMOVED: e = GPG_ERR_CARD_REMOVED; break;
case SC_ERROR_INVALID_CARD: e = GPG_ERR_INVALID_CARD; break; case SC_ERROR_INVALID_CARD: e = GPG_ERR_INV_CARD; break;
#endif #endif
default: e = GPG_ERR_CARD_ERROR; break; default: e = GPG_ERR_CARD; break;
} }
return gpg_make_error (GPG_ERR_SOURCE_UNKNOWN, e); return gpg_make_error (GPG_ERR_SOURCE_UNKNOWN, e);
} }
@ -114,7 +114,7 @@ card_open (CARD *rcard)
if (card->reader >= card->ctx->reader_count) if (card->reader >= card->ctx->reader_count)
{ {
log_error ("no card reader available\n"); log_error ("no card reader available\n");
rc = gpg_error (GPG_ERR_CARD_ERROR); rc = gpg_error (GPG_ERR_CARD);
goto leave; goto leave;
} }
card->ctx->error_file = log_get_stream (); card->ctx->error_file = log_get_stream ();
@ -242,7 +242,7 @@ find_iccsn (const unsigned char *buffer, size_t length, char **serial)
s = find_simple_tlv (buffer, length, 0x5A, &n); s = find_simple_tlv (buffer, length, 0x5A, &n);
if (!s) if (!s)
return gpg_error (GPG_ERR_CARD_ERROR); return gpg_error (GPG_ERR_CARD);
length -= s - buffer; length -= s - buffer;
if (n > length) if (n > length)
{ {
@ -257,12 +257,11 @@ find_iccsn (const unsigned char *buffer, size_t length, char **serial)
n--; n--;
} }
else else
return gpg_error (GPG_ERR_CARD_ERROR); /* Bad encoding; does return gpg_error (GPG_ERR_CARD); /* Bad encoding; does
not fit into not fit into buffer. */
buffer. */
} }
if (!n) if (!n)
return gpg_error (GPG_ERR_CARD_ERROR); /* Well, that is too short. */ return gpg_error (GPG_ERR_CARD); /* Well, that is too short. */
*serial = p = xtrymalloc (2*n+1); *serial = p = xtrymalloc (2*n+1);
if (!*serial) if (!*serial)
@ -332,21 +331,21 @@ card_get_serial_and_stamp (CARD card, char **serial, time_t *stamp)
if (rc) if (rc)
{ {
log_error ("sc_select_file failed: %s\n", sc_strerror (rc)); log_error ("sc_select_file failed: %s\n", sc_strerror (rc));
return gpg_error (GPG_ERR_CARD_ERROR); return gpg_error (GPG_ERR_CARD);
} }
if (file->type != SC_FILE_TYPE_WORKING_EF if (file->type != SC_FILE_TYPE_WORKING_EF
|| file->ef_structure != SC_FILE_EF_TRANSPARENT) || file->ef_structure != SC_FILE_EF_TRANSPARENT)
{ {
log_error ("wrong type or structure of GDO file\n"); log_error ("wrong type or structure of GDO file\n");
sc_file_free (file); sc_file_free (file);
return gpg_error (GPG_ERR_CARD_ERROR); return gpg_error (GPG_ERR_CARD);
} }
if (!file->size || file->size >= DIM(buf) ) if (!file->size || file->size >= DIM(buf) )
{ /* FIXME: Use a real parser */ { /* FIXME: Use a real parser */
log_error ("unsupported size of GDO file (%d)\n", file->size); log_error ("unsupported size of GDO file (%d)\n", file->size);
sc_file_free (file); sc_file_free (file);
return gpg_error (GPG_ERR_CARD_ERROR); return gpg_error (GPG_ERR_CARD);
} }
buflen = file->size; buflen = file->size;
@ -355,16 +354,16 @@ card_get_serial_and_stamp (CARD card, char **serial, time_t *stamp)
if (rc < 0) if (rc < 0)
{ {
log_error ("error reading GDO file: %s\n", sc_strerror (rc)); log_error ("error reading GDO file: %s\n", sc_strerror (rc));
return gpg_error (GPG_ERR_CARD_ERROR); return gpg_error (GPG_ERR_CARD);
} }
if (rc != buflen) if (rc != buflen)
{ {
log_error ("short read on GDO file\n"); log_error ("short read on GDO file\n");
return gpg_error (GPG_ERR_CARD_ERROR); return gpg_error (GPG_ERR_CARD);
} }
rc = find_iccsn (buf, buflen, serial); rc = find_iccsn (buf, buflen, serial);
if (gpg_err_code (rc) == GPG_ERR_CARD_ERROR) if (gpg_err_code (rc) == GPG_ERR_CARD)
log_error ("invalid structure of GDO file\n"); log_error ("invalid structure of GDO file\n");
if (!rc && card->p15card && !strcmp (*serial, "D27600000000000000000000")) if (!rc && card->p15card && !strcmp (*serial, "D27600000000000000000000"))
{ /* This is a German card with a silly serial number. Try to get { /* This is a German card with a silly serial number. Try to get
@ -436,7 +435,7 @@ card_enum_keypairs (CARD card, int idx,
if (!card || !keygrip) if (!card || !keygrip)
return gpg_error (GPG_ERR_INV_VALUE); return gpg_error (GPG_ERR_INV_VALUE);
if (idx < 0) if (idx < 0)
return gpg_error (GPG_ERR_INVALID_INDEX); return gpg_error (GPG_ERR_INV_INDEX);
if (!card->fnc.initialized) if (!card->fnc.initialized)
return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED); return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
if (!card->fnc.enum_keypairs) if (!card->fnc.enum_keypairs)
@ -468,7 +467,7 @@ card_enum_certs (CARD card, int idx, char **certid, int *certtype)
if (!card) if (!card)
return gpg_error (GPG_ERR_INV_VALUE); return gpg_error (GPG_ERR_INV_VALUE);
if (idx < 0) if (idx < 0)
return gpg_error (GPG_ERR_INVALID_INDEX); return gpg_error (GPG_ERR_INV_INDEX);
if (!card->fnc.initialized) if (!card->fnc.initialized)
return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED); return gpg_error (GPG_ERR_CARD_NOT_INITIALIZED);
if (!card->fnc.enum_certs) if (!card->fnc.enum_certs)

2
scd/command.c
View File

@ -452,7 +452,7 @@ pin_cb (void *opaque, const char *info, char **retstr)
{ {
/* We require that the returned value is an UTF-8 string */ /* We require that the returned value is an UTF-8 string */
xfree (value); xfree (value);
return gpg_error (GPG_ERR_INVALID_RESPONSE); return gpg_error (GPG_ERR_INV_RESPONSE);
} }
*retstr = value; *retstr = value;
return 0; return 0;

2
sm/base64.c
View File

@ -607,7 +607,7 @@ gpgsm_finish_writer (Base64Context ctx)
struct writer_cb_parm_s *parm; struct writer_cb_parm_s *parm;
if (!ctx) if (!ctx)
return gpg_error (GPG_ERR_INVALID_VALUE); return gpg_error (GPG_ERR_INV_VALUE);
parm = &ctx->u.wparm; parm = &ctx->u.wparm;
if (parm->did_finish) if (parm->did_finish)
return 0; /* already done */ return 0; /* already done */

20
sm/call-agent.c
View File

@ -415,7 +415,7 @@ gpgsm_agent_pksign (const char *keygrip,
if (!gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL)) if (!gcry_sexp_canon_len (*r_buf, *r_buflen, NULL, NULL))
{ {
xfree (*r_buf); *r_buf = NULL; xfree (*r_buf); *r_buf = NULL;
return gpg_error (GPG_ERR_INVALID_VALUE); return gpg_error (GPG_ERR_INV_VALUE);
} }
return *r_buf? 0 : OUT_OF_CORE (errno); return *r_buf? 0 : OUT_OF_CORE (errno);
@ -455,12 +455,12 @@ gpgsm_agent_pkdecrypt (const char *keygrip,
size_t ciphertextlen; size_t ciphertextlen;
if (!keygrip || strlen(keygrip) != 40 || !ciphertext || !r_buf || !r_buflen) if (!keygrip || strlen(keygrip) != 40 || !ciphertext || !r_buf || !r_buflen)
return gpg_error (GPG_ERR_INVALID_VALUE); return gpg_error (GPG_ERR_INV_VALUE);
*r_buf = NULL; *r_buf = NULL;
ciphertextlen = gcry_sexp_canon_len (ciphertext, 0, NULL, NULL); ciphertextlen = gcry_sexp_canon_len (ciphertext, 0, NULL, NULL);
if (!ciphertextlen) if (!ciphertextlen)
return gpg_error (GPG_ERR_INVALID_VALUE); return gpg_error (GPG_ERR_INV_VALUE);
rc = start_agent (); rc = start_agent ();
if (rc) if (rc)
@ -499,11 +499,11 @@ gpgsm_agent_pkdecrypt (const char *keygrip,
len--; /* remove the terminating 0 */ len--; /* remove the terminating 0 */
n = strtoul (buf, &endp, 10); n = strtoul (buf, &endp, 10);
if (!n || *endp != ':') if (!n || *endp != ':')
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
endp++; endp++;
if (endp-buf+n > len) if (endp-buf+n > len)
return gpg_error (GPG_ERR_INVALID_SEXP); /* oops len does not return gpg_error (GPG_ERR_INV_SEXP); /* oops len does not
match internal len*/ match internal len*/
memmove (buf, endp, n); memmove (buf, endp, n);
*r_buflen = n; *r_buflen = n;
*r_buf = buf; *r_buf = buf;
@ -552,7 +552,7 @@ gpgsm_agent_genkey (KsbaConstSexp keyparms, KsbaSexp *r_pubkey)
gk_parm.sexp = keyparms; gk_parm.sexp = keyparms;
gk_parm.sexplen = gcry_sexp_canon_len (keyparms, 0, NULL, NULL); gk_parm.sexplen = gcry_sexp_canon_len (keyparms, 0, NULL, NULL);
if (!gk_parm.sexplen) if (!gk_parm.sexplen)
return gpg_error (GPG_ERR_INVALID_VALUE); return gpg_error (GPG_ERR_INV_VALUE);
rc = assuan_transact (agent_ctx, "GENKEY", rc = assuan_transact (agent_ctx, "GENKEY",
membuf_data_cb, &data, membuf_data_cb, &data,
inq_genkey_parms, &gk_parm, NULL, NULL); inq_genkey_parms, &gk_parm, NULL, NULL);
@ -567,7 +567,7 @@ gpgsm_agent_genkey (KsbaConstSexp keyparms, KsbaSexp *r_pubkey)
if (!gcry_sexp_canon_len (buf, len, NULL, NULL)) if (!gcry_sexp_canon_len (buf, len, NULL, NULL))
{ {
xfree (buf); xfree (buf);
return gpg_error (GPG_ERR_INVALID_SEXP); return gpg_error (GPG_ERR_INV_SEXP);
} }
*r_pubkey = buf; *r_pubkey = buf;
return 0; return 0;
@ -651,7 +651,7 @@ gpgsm_agent_havekey (const char *hexkeygrip)
return rc; return rc;
if (!hexkeygrip || strlen (hexkeygrip) != 40) if (!hexkeygrip || strlen (hexkeygrip) != 40)
return gpg_error (GPG_ERR_INVALID_VALUE); return gpg_error (GPG_ERR_INV_VALUE);
snprintf (line, DIM(line)-1, "HAVEKEY %s", hexkeygrip); snprintf (line, DIM(line)-1, "HAVEKEY %s", hexkeygrip);
line[DIM(line)-1] = 0; line[DIM(line)-1] = 0;
@ -768,7 +768,7 @@ gpgsm_agent_passwd (const char *hexkeygrip)
return rc; return rc;
if (!hexkeygrip || strlen (hexkeygrip) != 40) if (!hexkeygrip || strlen (hexkeygrip) != 40)
return gpg_error (GPG_ERR_INVALID_VALUE); return gpg_error (GPG_ERR_INV_VALUE);
snprintf (line, DIM(line)-1, "PASSWD %s", hexkeygrip); snprintf (line, DIM(line)-1, "PASSWD %s", hexkeygrip);
line[DIM(line)-1] = 0; line[DIM(line)-1] = 0;

2
sm/certchain.c
View File

@ -186,7 +186,7 @@ check_cert_policy (KsbaCert cert)
{ {
fclose (fp); fclose (fp);
xfree (policies); xfree (policies);
return gpg_error (GPG_ERR_CONFIGURATION_ERROR); return gpg_error (GPG_ERR_CONFIGURATION);
} }
*p = 0; /* strip the rest of the line */ *p = 0; /* strip the rest of the line */
/* See whether we find ALLOWED (which is an OID) in POLICIES */ /* See whether we find ALLOWED (which is an OID) in POLICIES */

4
sm/decrypt.c
View File

@ -450,7 +450,7 @@ gpgsm_decrypt (CTRL ctrl, int in_fd, FILE *out_fp)
if (!npadding || npadding > dfparm.blklen) if (!npadding || npadding > dfparm.blklen)
{ {
log_error ("invalid padding with value %d\n", npadding); log_error ("invalid padding with value %d\n", npadding);
rc = gpg_error (GPG_ERR_INVALID_DATA); rc = gpg_error (GPG_ERR_INV_DATA);
goto leave; goto leave;
} }
rc = ksba_writer_write (writer, rc = ksba_writer_write (writer,
@ -466,7 +466,7 @@ gpgsm_decrypt (CTRL ctrl, int in_fd, FILE *out_fp)
if (dfparm.lastblock[i] != npadding) if (dfparm.lastblock[i] != npadding)
{ {
log_error ("inconsistent padding\n"); log_error ("inconsistent padding\n");
rc = gpg_error (GPG_ERR_INVALID_DATA); rc = gpg_error (GPG_ERR_INV_DATA);
goto leave; goto leave;
} }
} }

18
sm/keydb.c
View File

@ -562,7 +562,7 @@ keydb_get_cert (KEYDB_HANDLE hd, KsbaCert *r_cert)
int rc = 0; int rc = 0;
if (!hd) if (!hd)
return gpg_error (GPG_ERR_INVALID_VALUE); return gpg_error (GPG_ERR_INV_VALUE);
if ( hd->found < 0 || hd->found >= hd->used) if ( hd->found < 0 || hd->found >= hd->used)
return -1; /* nothing found */ return -1; /* nothing found */
@ -591,7 +591,7 @@ keydb_insert_cert (KEYDB_HANDLE hd, KsbaCert cert)
char digest[20]; char digest[20];
if (!hd) if (!hd)
return gpg_error (GPG_ERR_INVALID_VALUE); return gpg_error (GPG_ERR_INV_VALUE);
if (opt.dry_run) if (opt.dry_run)
return 0; return 0;
@ -633,7 +633,7 @@ keydb_update_cert (KEYDB_HANDLE hd, KsbaCert cert)
char digest[20]; char digest[20];
if (!hd) if (!hd)
return gpg_error (GPG_ERR_INVALID_VALUE); return gpg_error (GPG_ERR_INV_VALUE);
if ( hd->found < 0 || hd->found >= hd->used) if ( hd->found < 0 || hd->found >= hd->used)
return -1; /* nothing found */ return -1; /* nothing found */
@ -671,7 +671,7 @@ keydb_delete (KEYDB_HANDLE hd)
int rc = -1; int rc = -1;
if (!hd) if (!hd)
return gpg_error (GPG_ERR_INVALID_VALUE); return gpg_error (GPG_ERR_INV_VALUE);
if ( hd->found < 0 || hd->found >= hd->used) if ( hd->found < 0 || hd->found >= hd->used)
return -1; /* nothing found */ return -1; /* nothing found */
@ -710,7 +710,7 @@ keydb_locate_writable (KEYDB_HANDLE hd, const char *reserved)
int rc; int rc;
if (!hd) if (!hd)
return gpg_error (GPG_ERR_INVALID_VALUE); return gpg_error (GPG_ERR_INV_VALUE);
rc = keydb_search_reset (hd); /* this does reset hd->current */ rc = keydb_search_reset (hd); /* this does reset hd->current */
if (rc) if (rc)
@ -770,7 +770,7 @@ keydb_search_reset (KEYDB_HANDLE hd)
int i, rc = 0; int i, rc = 0;
if (!hd) if (!hd)
return gpg_error (GPG_ERR_INVALID_VALUE); return gpg_error (GPG_ERR_INV_VALUE);
hd->current = 0; hd->current = 0;
hd->found = -1; hd->found = -1;
@ -800,7 +800,7 @@ keydb_search (KEYDB_HANDLE hd, KEYDB_SEARCH_DESC *desc, size_t ndesc)
int rc = -1; int rc = -1;
if (!hd) if (!hd)
return gpg_error (GPG_ERR_INVALID_VALUE); return gpg_error (GPG_ERR_INV_VALUE);
while (rc == -1 && hd->current >= 0 && hd->current < hd->used) while (rc == -1 && hd->current >= 0 && hd->current < hd->used)
{ {
@ -891,12 +891,12 @@ keydb_search_issuer_sn (KEYDB_HANDLE hd,
desc.mode = KEYDB_SEARCH_MODE_ISSUER_SN; desc.mode = KEYDB_SEARCH_MODE_ISSUER_SN;
s = serial; s = serial;
if (*s !='(') if (*s !='(')
return gpg_error (GPG_ERR_INVALID_VALUE); return gpg_error (GPG_ERR_INV_VALUE);
s++; s++;
for (desc.snlen = 0; digitp (s); s++) for (desc.snlen = 0; digitp (s); s++)
desc.snlen = 10*desc.snlen + atoi_1 (s); desc.snlen = 10*desc.snlen + atoi_1 (s);
if (*s !=':') if (*s !=':')
return gpg_error (GPG_ERR_INVALID_VALUE); return gpg_error (GPG_ERR_INV_VALUE);
desc.sn = s+1; desc.sn = s+1;
desc.u.name = issuer; desc.u.name = issuer;
rc = keydb_search (hd, &desc, 1); rc = keydb_search (hd, &desc, 1);