gpg: Remove all assert.h and s/assert/log_assert/.
[gnupg.git] / g10 / trust.c
1 /* trust.c - High level trust functions
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3  *               2008, 2012 Free Software Foundation, Inc.
4  * Copyright (C) 2014 Werner Koch
5  *
6  * This file is part of GnuPG.
7  *
8  * GnuPG is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * GnuPG is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26
27 #include "gpg.h"
28 #include "keydb.h"
29 #include "util.h"
30 #include "options.h"
31 #include "packet.h"
32 #include "main.h"
33 #include "i18n.h"
34 #include "trustdb.h"
35 #include "host2net.h"
36
37
38 /* Return true if key is disabled.  Note that this is usually used via
39    the pk_is_disabled macro.  */
40 int
41 cache_disabled_value (PKT_public_key *pk)
42 {
43 #ifdef NO_TRUST_MODELS
44   (void)pk;
45   return 0;
46 #else
47   return tdb_cache_disabled_value (pk);
48 #endif
49 }
50
51
52 void
53 register_trusted_keyid (u32 *keyid)
54 {
55 #ifdef NO_TRUST_MODELS
56   (void)keyid;
57 #else
58   tdb_register_trusted_keyid (keyid);
59 #endif
60 }
61
62
63 void
64 register_trusted_key (const char *string)
65 {
66 #ifdef NO_TRUST_MODELS
67   (void)string;
68 #else
69   tdb_register_trusted_key (string);
70 #endif
71 }
72
73
74 \f
75 /*
76  * This function returns a letter for a trust value.  Trust flags
77  * are ignored.
78  */
79 static int
80 trust_letter (unsigned int value)
81 {
82   switch( (value & TRUST_MASK) )
83     {
84     case TRUST_UNKNOWN:   return '-';
85     case TRUST_EXPIRED:   return 'e';
86     case TRUST_UNDEFINED: return 'q';
87     case TRUST_NEVER:     return 'n';
88     case TRUST_MARGINAL:  return 'm';
89     case TRUST_FULLY:     return 'f';
90     case TRUST_ULTIMATE:  return 'u';
91     default:              return '?';
92     }
93 }
94
95
96 /* The strings here are similar to those in
97    pkclist.c:do_edit_ownertrust() */
98 const char *
99 trust_value_to_string (unsigned int value)
100 {
101   switch ((value & TRUST_MASK))
102     {
103     case TRUST_UNKNOWN:   return _("unknown");
104     case TRUST_EXPIRED:   return _("expired");
105     case TRUST_UNDEFINED: return _("undefined");
106     case TRUST_NEVER:     return _("never");
107     case TRUST_MARGINAL:  return _("marginal");
108     case TRUST_FULLY:     return _("full");
109     case TRUST_ULTIMATE:  return _("ultimate");
110     default:              return "err";
111     }
112 }
113
114
115 int
116 string_to_trust_value (const char *str)
117 {
118   if (!ascii_strcasecmp (str, "undefined"))
119     return TRUST_UNDEFINED;
120   else if (!ascii_strcasecmp (str, "never"))
121     return TRUST_NEVER;
122   else if (!ascii_strcasecmp (str, "marginal"))
123     return TRUST_MARGINAL;
124   else if (!ascii_strcasecmp (str, "full"))
125     return TRUST_FULLY;
126   else if (!ascii_strcasecmp(str, "ultimate"))
127     return TRUST_ULTIMATE;
128   else
129     return -1;
130 }
131
132
133 const char *
134 uid_trust_string_fixed (PKT_public_key *key, PKT_user_id *uid)
135 {
136   if (!key && !uid)
137     {
138       /* TRANSLATORS: these strings are similar to those in
139          trust_value_to_string(), but are a fixed length.  This is needed to
140          make attractive information listings where columns line up
141          properly.  The value "10" should be the length of the strings you
142          choose to translate to.  This is the length in printable columns.
143          It gets passed to atoi() so everything after the number is
144          essentially a comment and need not be translated.  Either key and
145          uid are both NULL, or neither are NULL. */
146       return _("10 translator see trust.c:uid_trust_string_fixed");
147     }
148   else if(uid->is_revoked || (key && key->flags.revoked))
149     return                         _("[ revoked]");
150   else if(uid->is_expired)
151     return                         _("[ expired]");
152   else if(key)
153     {
154       switch (get_validity (key, uid, NULL, 0) & TRUST_MASK)
155         {
156         case TRUST_UNKNOWN:   return _("[ unknown]");
157         case TRUST_EXPIRED:   return _("[ expired]");
158         case TRUST_UNDEFINED: return _("[  undef ]");
159         case TRUST_MARGINAL:  return _("[marginal]");
160         case TRUST_FULLY:     return _("[  full  ]");
161         case TRUST_ULTIMATE:  return _("[ultimate]");
162         }
163     }
164
165   return "err";
166 }
167
168
169 \f
170 /*
171  * Return the assigned ownertrust value for the given public key.
172  * The key should be the primary key.
173  */
174 unsigned int
175 get_ownertrust (PKT_public_key *pk)
176 {
177 #ifdef NO_TRUST_MODELS
178   (void)pk;
179   return TRUST_UNKNOWN;
180 #else
181   return tdb_get_ownertrust (pk);
182 #endif
183 }
184
185
186 /*
187  * Same as get_ownertrust but this takes the minimum ownertrust value
188  * into into account, and will bump up the value as needed.
189  */
190 static int
191 get_ownertrust_with_min (PKT_public_key *pk)
192 {
193 #ifdef NO_TRUST_MODELS
194   (void)pk;
195   return TRUST_UNKNOWN;
196 #else
197   unsigned int otrust, otrust_min;
198
199   otrust = (tdb_get_ownertrust (pk) & TRUST_MASK);
200   otrust_min = tdb_get_min_ownertrust (pk);
201   if (otrust < otrust_min)
202     {
203       /* If the trust that the user has set is less than the trust
204          that was calculated from a trust signature chain, use the
205          higher of the two.  We do this here and not in
206          get_ownertrust since the underlying ownertrust should not
207          really be set - just the appearance of the ownertrust. */
208
209       otrust = otrust_min;
210     }
211
212   return otrust;
213 #endif
214 }
215
216
217 /*
218  * Same as get_ownertrust but return a trust letter instead of an
219  * value.  This takes the minimum ownertrust value into account.
220  */
221 int
222 get_ownertrust_info (PKT_public_key *pk)
223 {
224   return trust_letter (get_ownertrust_with_min (pk));
225 }
226
227
228 /*
229  * Same as get_ownertrust but return a trust string instead of an
230  * value.  This takes the minimum ownertrust value into account.
231  */
232 const char *
233 get_ownertrust_string (PKT_public_key *pk)
234 {
235   return trust_value_to_string (get_ownertrust_with_min (pk));
236 }
237
238
239 /*
240  * Set the trust value of the given public key to the new value.
241  * The key should be a primary one.
242  */
243 void
244 update_ownertrust (PKT_public_key *pk, unsigned int new_trust)
245 {
246 #ifdef NO_TRUST_MODELS
247   (void)pk;
248   (void)new_trust;
249 #else
250   tdb_update_ownertrust (pk, new_trust);
251 #endif
252 }
253
254
255 int
256 clear_ownertrusts (PKT_public_key *pk)
257 {
258 #ifdef NO_TRUST_MODELS
259   (void)pk;
260   return 0;
261 #else
262   return tdb_clear_ownertrusts (pk);
263 #endif
264 }
265
266
267 void
268 revalidation_mark (void)
269 {
270 #ifndef NO_TRUST_MODELS
271   tdb_revalidation_mark ();
272 #endif
273 }
274
275
276 void
277 check_trustdb_stale (void)
278 {
279 #ifndef NO_TRUST_MODELS
280   tdb_check_trustdb_stale ();
281 #endif
282 }
283
284
285 void
286 check_or_update_trustdb (void)
287 {
288 #ifndef NO_TRUST_MODELS
289   tdb_check_or_update ();
290 #endif
291 }
292
293
294 /*
295  * Return the validity information for PK.  If the namehash is not
296  * NULL, the validity of the corresponding user ID is returned,
297  * otherwise, a reasonable value for the entire key is returned.
298  */
299 unsigned int
300 get_validity (PKT_public_key *pk, PKT_user_id *uid, PKT_signature *sig,
301               int may_ask)
302 {
303   int rc;
304   unsigned int validity;
305   u32 kid[2];
306   PKT_public_key *main_pk;
307
308   if (uid)
309     namehash_from_uid (uid);
310
311   keyid_from_pk (pk, kid);
312   if (pk->main_keyid[0] != kid[0] || pk->main_keyid[1] != kid[1])
313     {
314       /* This is a subkey - get the mainkey. */
315       main_pk = xmalloc_clear (sizeof *main_pk);
316       rc = get_pubkey (main_pk, pk->main_keyid);
317       if (rc)
318         {
319           char *tempkeystr = xstrdup (keystr (pk->main_keyid));
320           log_error ("error getting main key %s of subkey %s: %s\n",
321                      tempkeystr, keystr (kid), gpg_strerror (rc));
322           xfree (tempkeystr);
323           validity = TRUST_UNKNOWN;
324           goto leave;
325         }
326     }
327   else
328     main_pk = pk;
329
330 #ifdef NO_TRUST_MODELS
331   validity = TRUST_UNKNOWN;
332 #else
333   validity = tdb_get_validity_core (pk, uid, main_pk, sig, may_ask);
334 #endif
335
336  leave:
337   /* Set some flags direct from the key */
338   if (main_pk->flags.revoked)
339     validity |= TRUST_FLAG_REVOKED;
340   if (main_pk != pk && pk->flags.revoked)
341     validity |= TRUST_FLAG_SUB_REVOKED;
342   /* Note: expiration is a trust value and not a flag - don't know why
343    * I initially designed it that way.  */
344   if (main_pk->has_expired || pk->has_expired)
345     validity = ((validity & (~TRUST_MASK | TRUST_FLAG_PENDING_CHECK))
346                 | TRUST_EXPIRED);
347
348   if (main_pk != pk)
349     free_public_key (main_pk);
350   return validity;
351 }
352
353
354 int
355 get_validity_info (PKT_public_key *pk, PKT_user_id *uid)
356 {
357   int trustlevel;
358
359   if (!pk)
360     return '?';  /* Just in case a NULL PK is passed.  */
361
362   trustlevel = get_validity (pk, uid, NULL, 0);
363   if ((trustlevel & TRUST_FLAG_REVOKED))
364     return 'r';
365   return trust_letter (trustlevel);
366 }
367
368
369 const char *
370 get_validity_string (PKT_public_key *pk, PKT_user_id *uid)
371 {
372   int trustlevel;
373
374   if (!pk)
375     return "err";  /* Just in case a NULL PK is passed.  */
376
377   trustlevel = get_validity (pk, uid, NULL, 0);
378   if ((trustlevel & TRUST_FLAG_REVOKED))
379     return _("revoked");
380   return trust_value_to_string (trustlevel);
381 }
382
383
384 \f
385 /*
386  * Mark the signature of the given UID which are used to certify it.
387  * To do this, we first revmove all signatures which are not valid and
388  * from the remain ones we look for the latest one.  If this is not a
389  * certification revocation signature we mark the signature by setting
390  * node flag bit 8.  Revocations are marked with flag 11, and sigs
391  * from unavailable keys are marked with flag 12.  Note that flag bits
392  * 9 and 10 are used for internal purposes.
393  */
394 void
395 mark_usable_uid_certs (kbnode_t keyblock, kbnode_t uidnode,
396                        u32 *main_kid, struct key_item *klist,
397                        u32 curtime, u32 *next_expire)
398 {
399   kbnode_t node;
400   PKT_signature *sig;
401
402   /* First check all signatures.  */
403   for (node=uidnode->next; node; node = node->next)
404     {
405       int rc;
406
407       node->flag &= ~(1<<8 | 1<<9 | 1<<10 | 1<<11 | 1<<12);
408       if (node->pkt->pkttype == PKT_USER_ID
409           || node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
410         break; /* ready */
411       if (node->pkt->pkttype != PKT_SIGNATURE)
412         continue;
413       sig = node->pkt->pkt.signature;
414       if (main_kid
415           && sig->keyid[0] == main_kid[0] && sig->keyid[1] == main_kid[1])
416         continue; /* ignore self-signatures if we pass in a main_kid */
417       if (!IS_UID_SIG(sig) && !IS_UID_REV(sig))
418         continue; /* we only look at these signature classes */
419       if(sig->sig_class>=0x11 && sig->sig_class<=0x13 &&
420          sig->sig_class-0x10<opt.min_cert_level)
421         continue; /* treat anything under our min_cert_level as an
422                      invalid signature */
423       if (klist && !is_in_klist (klist, sig))
424         continue;  /* no need to check it then */
425       if ((rc=check_key_signature (keyblock, node, NULL)))
426         {
427           /* we ignore anything that won't verify, but tag the
428              no_pubkey case */
429           if (gpg_err_code (rc) == GPG_ERR_NO_PUBKEY)
430             node->flag |= 1<<12;
431           continue;
432         }
433       node->flag |= 1<<9;
434     }
435   /* Reset the remaining flags. */
436   for (; node; node = node->next)
437     node->flag &= ~(1<<8 | 1<<9 | 1<<10 | 1<<11 | 1<<12);
438
439   /* kbnode flag usage: bit 9 is here set for signatures to consider,
440    * bit 10 will be set by the loop to keep track of keyIDs already
441    * processed, bit 8 will be set for the usable signatures, and bit
442    * 11 will be set for usable revocations. */
443
444   /* For each cert figure out the latest valid one.  */
445   for (node=uidnode->next; node; node = node->next)
446     {
447       KBNODE n, signode;
448       u32 kid[2];
449       u32 sigdate;
450
451       if (node->pkt->pkttype == PKT_PUBLIC_SUBKEY)
452         break;
453       if ( !(node->flag & (1<<9)) )
454         continue; /* not a node to look at */
455       if ( (node->flag & (1<<10)) )
456         continue; /* signature with a keyID already processed */
457       node->flag |= (1<<10); /* mark this node as processed */
458       sig = node->pkt->pkt.signature;
459       signode = node;
460       sigdate = sig->timestamp;
461       kid[0] = sig->keyid[0]; kid[1] = sig->keyid[1];
462
463       /* Now find the latest and greatest signature */
464       for (n=uidnode->next; n; n = n->next)
465         {
466           if (n->pkt->pkttype == PKT_PUBLIC_SUBKEY)
467             break;
468           if ( !(n->flag & (1<<9)) )
469             continue;
470           if ( (n->flag & (1<<10)) )
471             continue; /* shortcut already processed signatures */
472           sig = n->pkt->pkt.signature;
473           if (kid[0] != sig->keyid[0] || kid[1] != sig->keyid[1])
474             continue;
475           n->flag |= (1<<10); /* mark this node as processed */
476
477           /* If signode is nonrevocable and unexpired and n isn't,
478              then take signode (skip).  It doesn't matter which is
479              older: if signode was older then we don't want to take n
480              as signode is nonrevocable.  If n was older then we're
481              automatically fine. */
482
483           if(((IS_UID_SIG(signode->pkt->pkt.signature) &&
484                !signode->pkt->pkt.signature->flags.revocable &&
485                (signode->pkt->pkt.signature->expiredate==0 ||
486                 signode->pkt->pkt.signature->expiredate>curtime))) &&
487              (!(IS_UID_SIG(n->pkt->pkt.signature) &&
488                 !n->pkt->pkt.signature->flags.revocable &&
489                 (n->pkt->pkt.signature->expiredate==0 ||
490                  n->pkt->pkt.signature->expiredate>curtime))))
491             continue;
492
493           /* If n is nonrevocable and unexpired and signode isn't,
494              then take n.  Again, it doesn't matter which is older: if
495              n was older then we don't want to take signode as n is
496              nonrevocable.  If signode was older then we're
497              automatically fine. */
498
499           if((!(IS_UID_SIG(signode->pkt->pkt.signature) &&
500                 !signode->pkt->pkt.signature->flags.revocable &&
501                 (signode->pkt->pkt.signature->expiredate==0 ||
502                  signode->pkt->pkt.signature->expiredate>curtime))) &&
503              ((IS_UID_SIG(n->pkt->pkt.signature) &&
504                !n->pkt->pkt.signature->flags.revocable &&
505                (n->pkt->pkt.signature->expiredate==0 ||
506                 n->pkt->pkt.signature->expiredate>curtime))))
507             {
508               signode = n;
509               sigdate = sig->timestamp;
510               continue;
511             }
512
513           /* At this point, if it's newer, it goes in as the only
514              remaining possibilities are signode and n are both either
515              revocable or expired or both nonrevocable and unexpired.
516              If the timestamps are equal take the later ordered
517              packet, presuming that the key packets are hopefully in
518              their original order. */
519
520           if (sig->timestamp >= sigdate)
521             {
522               signode = n;
523               sigdate = sig->timestamp;
524             }
525         }
526
527       sig = signode->pkt->pkt.signature;
528       if (IS_UID_SIG (sig))
529         { /* this seems to be a usable one which is not revoked.
530            * Just need to check whether there is an expiration time,
531            * We do the expired certification after finding a suitable
532            * certification, the assumption is that a signator does not
533            * want that after the expiration of his certificate the
534            * system falls back to an older certification which has a
535            * different expiration time */
536           const byte *p;
537           u32 expire;
538
539           p = parse_sig_subpkt (sig->hashed, SIGSUBPKT_SIG_EXPIRE, NULL );
540           expire = p? sig->timestamp + buf32_to_u32(p) : 0;
541
542           if (expire==0 || expire > curtime )
543             {
544               signode->flag |= (1<<8); /* yeah, found a good cert */
545               if (next_expire && expire && expire < *next_expire)
546                 *next_expire = expire;
547             }
548         }
549       else
550         signode->flag |= (1<<11);
551     }
552 }
553
554
555 static int
556 clean_sigs_from_uid (kbnode_t keyblock, kbnode_t uidnode,
557                      int noisy, int self_only)
558 {
559   int deleted = 0;
560   kbnode_t node;
561   u32 keyid[2];
562
563   log_assert (keyblock->pkt->pkttype==PKT_PUBLIC_KEY);
564
565   keyid_from_pk (keyblock->pkt->pkt.public_key, keyid);
566
567   /* Passing in a 0 for current time here means that we'll never weed
568      out an expired sig.  This is correct behavior since we want to
569      keep the most recent expired sig in a series. */
570   mark_usable_uid_certs (keyblock, uidnode, NULL, NULL, 0, NULL);
571
572   /* What we want to do here is remove signatures that are not
573      considered as part of the trust calculations.  Thus, all invalid
574      signatures are out, as are any signatures that aren't the last of
575      a series of uid sigs or revocations It breaks down like this:
576      coming out of mark_usable_uid_certs, if a sig is unflagged, it is
577      not even a candidate.  If a sig has flag 9 or 10, that means it
578      was selected as a candidate and vetted.  If a sig has flag 8 it
579      is a usable signature.  If a sig has flag 11 it is a usable
580      revocation.  If a sig has flag 12 it was issued by an unavailable
581      key.  "Usable" here means the most recent valid
582      signature/revocation in a series from a particular signer.
583
584      Delete everything that isn't a usable uid sig (which might be
585      expired), a usable revocation, or a sig from an unavailable
586      key. */
587
588   for (node=uidnode->next;
589        node && node->pkt->pkttype==PKT_SIGNATURE;
590        node=node->next)
591     {
592       int keep;
593
594       keep = self_only? (node->pkt->pkt.signature->keyid[0] == keyid[0]
595                          && node->pkt->pkt.signature->keyid[1] == keyid[1]) : 1;
596
597       /* Keep usable uid sigs ... */
598       if ((node->flag & (1<<8)) && keep)
599         continue;
600
601       /* ... and usable revocations... */
602       if ((node->flag & (1<<11)) && keep)
603         continue;
604
605       /* ... and sigs from unavailable keys. */
606       /* disabled for now since more people seem to want sigs from
607          unavailable keys removed altogether.  */
608       /*
609         if(node->flag & (1<<12))
610         continue;
611       */
612
613       /* Everything else we delete */
614
615       /* At this point, if 12 is set, the signing key was unavailable.
616          If 9 or 10 is set, it's superseded.  Otherwise, it's
617          invalid. */
618
619       if (noisy)
620         log_info ("removing signature from key %s on user ID \"%s\": %s\n",
621                   keystr (node->pkt->pkt.signature->keyid),
622                   uidnode->pkt->pkt.user_id->name,
623                   node->flag&(1<<12)? "key unavailable":
624                   node->flag&(1<<9)?  "signature superseded"
625                   /* */               :"invalid signature"  );
626
627       delete_kbnode (node);
628       deleted++;
629     }
630
631   return deleted;
632 }
633
634
635 /* This is substantially easier than clean_sigs_from_uid since we just
636    have to establish if the uid has a valid self-sig, is not revoked,
637    and is not expired.  Note that this does not take into account
638    whether the uid has a trust path to it - just whether the keyholder
639    themselves has certified the uid.  Returns true if the uid was
640    compacted.  To "compact" a user ID, we simply remove ALL signatures
641    except the self-sig that caused the user ID to be remove-worthy.
642    We don't actually remove the user ID packet itself since it might
643    be resurrected in a later merge.  Note that this function requires
644    that the caller has already done a merge_keys_and_selfsig().
645
646    TODO: change the import code to allow importing a uid with only a
647    revocation if the uid already exists on the keyring. */
648
649 static int
650 clean_uid_from_key (kbnode_t keyblock, kbnode_t uidnode, int noisy)
651 {
652   kbnode_t node;
653   PKT_user_id *uid = uidnode->pkt->pkt.user_id;
654   int deleted = 0;
655
656   log_assert (keyblock->pkt->pkttype==PKT_PUBLIC_KEY);
657   log_assert (uidnode->pkt->pkttype==PKT_USER_ID);
658
659   /* Skip valid user IDs, compacted user IDs, and non-self-signed user
660      IDs if --allow-non-selfsigned-uid is set. */
661   if (uid->created
662       || uid->flags.compacted
663       || (!uid->is_expired && !uid->is_revoked && opt.allow_non_selfsigned_uid))
664     return 0;
665
666   for (node=uidnode->next;
667        node && node->pkt->pkttype == PKT_SIGNATURE;
668       node=node->next)
669     {
670       if (!node->pkt->pkt.signature->flags.chosen_selfsig)
671         {
672           delete_kbnode (node);
673           deleted = 1;
674           uidnode->pkt->pkt.user_id->flags.compacted = 1;
675         }
676     }
677
678   if (noisy)
679     {
680       const char *reason;
681       char *user = utf8_to_native (uid->name, uid->len, 0);
682
683       if (uid->is_revoked)
684         reason = _("revoked");
685       else if (uid->is_expired)
686         reason = _("expired");
687       else
688         reason = _("invalid");
689
690       log_info ("compacting user ID \"%s\" on key %s: %s\n",
691                 user, keystr_from_pk (keyblock->pkt->pkt.public_key),
692                 reason);
693
694       xfree (user);
695     }
696
697   return deleted;
698 }
699
700
701 /* Needs to be called after a merge_keys_and_selfsig() */
702 void
703 clean_one_uid (kbnode_t keyblock, kbnode_t uidnode, int noisy, int self_only,
704                int *uids_cleaned, int *sigs_cleaned)
705 {
706   int dummy = 0;
707
708   log_assert (keyblock->pkt->pkttype==PKT_PUBLIC_KEY);
709   log_assert (uidnode->pkt->pkttype==PKT_USER_ID);
710
711   if (!uids_cleaned)
712     uids_cleaned = &dummy;
713
714   if (!sigs_cleaned)
715     sigs_cleaned = &dummy;
716
717   /* Do clean_uid_from_key first since if it fires off, we don't have
718      to bother with the other.  */
719   *uids_cleaned += clean_uid_from_key (keyblock, uidnode, noisy);
720   if (!uidnode->pkt->pkt.user_id->flags.compacted)
721     *sigs_cleaned += clean_sigs_from_uid (keyblock, uidnode, noisy, self_only);
722 }
723
724
725 void
726 clean_key (kbnode_t keyblock, int noisy, int self_only,
727            int *uids_cleaned, int *sigs_cleaned)
728 {
729   kbnode_t uidnode;
730
731   merge_keys_and_selfsig (keyblock);
732
733   for (uidnode = keyblock->next;
734        uidnode && uidnode->pkt->pkttype != PKT_PUBLIC_SUBKEY;
735        uidnode = uidnode->next)
736     {
737       if (uidnode->pkt->pkttype == PKT_USER_ID)
738         clean_one_uid (keyblock, uidnode,noisy, self_only,
739                        uids_cleaned, sigs_cleaned);
740     }
741 }