/[winpt]/trunk/Src/wptKeylist.cpp

Diff of /trunk/Src/wptKeylist.cpp

Parent Directory | Revision Log | View Patch Patch

-revision 25 by twoaday,
Wed Oct 12 10:04:26 2005 UTC
+revision 428 by twoaday,
Sat Apr  7 11:55:16 2012 UTC
 Line 1
  /* wptKeylist.cpp - Keylist element
-  *      Copyright (C) 2001-2005 Timo Schulz
+  *      Copyright (C) 2001-2006, 2009 Timo Schulz
   *      Copyright (C) 2004 Andreas Jobs
   *
   * This file is part of WinPT.
   *
   * WinPT 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.
   *
   * WinPT 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
+ #ifdef HAVE_CONFIG_H
-  * along with WinPT; if not, write to the Free Software Foundation,
+ #include <config.h>
-  * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ #endif
-  */
  #include <windows.h>
  #include <commctrl.h>
  #include <time.h>
  #include "wptCommonCtl.h"
  #include "wptTypes.h"
  #include "wptGPG.h"
  #include "wptKeylist.h"
  #include "wptKeyManager.h"
  #include "wptW32API.h"
  #include "wptNLS.h"
  #include "wptErrors.h"
  #include "wptUTF8.h"
  #include "wptRegistry.h"
  #include "wptContext.h"
+ #include "wptVersion.h"
+ #include "resource.h"
- #define key_is_useable(key) (!(key)->revoked && !(key)->expired && !(key)->disabled)
+ #include "StringBuffer.h"
- static struct listview_column_s klist_enc[] = {
-     {0, 242, (char *)_("User ID")},
+ struct key_array_s {
-     {1, 80, (char *)_("Key ID")},
+     char keyid[32];
-     {3, 46, (char *)_("Size")},
+     int  checked;
-     {4, 50, (char *)_("Cipher")},
+ };
-     {5, 70, (char *)_("Validity")},
-     {0, 0, NULL}
- };
+ static key_array_s*
- #define KLIST_ENC_ITEMS (DIM(klist_enc) -1)
+ key_array_new (DWORD items)
+ {
- static struct listview_column_s klist[] = {
+     key_array_s *ka;
-     {0, 242, (char *)_("User ID")},
-     {1, 78, (char *)_("Key ID")},
+     if (items == 0)
-     {2, 52, (char *)_("Type")},
+         BUG (NULL);
-     {3, 68, (char *)_("Size")},
+     ka = new key_array_s[items + 1];
-     {4, 66, (char *)_("Cipher")},
+     if (!ka)
-     {5, 70, (char *)_("Validity")},
+         BUG (NULL);
-     {6, 40, (char *)_("Trust")},
+     for (DWORD i = 0; i < items; i++)
-     {7, 72, (char *) _("Creation")},
+         ka[i].checked = 0;
-     {0, 0, NULL}
+     return ka;
- };
+ }
- #define KLIST_ITEMS (DIM(klist) - 1)
+ static void
- struct key_array_s {
+ key_array_release (key_array_s *ka)
-     char keyid[32];
+ {
-     int checked;
+     free_if_alloc (ka);
- };
+ }
- static int find_secret_key( gpgme_key_t key );
+ /* Check if the keyid @keyid is in the key array @ka.
+    Return value: 1 if it exists, 0 otherwise. */
- static key_array_s*
+ static int
- key_array_new( size_t items )
+ key_array_search (key_array_s *ka, DWORD items, const char *keyid)
  {
-     key_array_s *ka;
+     for (DWORD i = 0; i < items; i++) {
-     size_t j;
+         if (!stricmp (keyid, ka[i].keyid))
+             return 1;
-     if( items == 0 )
+     }
-         return NULL;
+     return 0;
-     ka = new key_array_s[items + 1];
+ }
-     if( ka == NULL )
-         return NULL;
-     for ( j = 0; j < items; j++ )
+ /* Return if there is a secret for @key.
-         ka[j].checked = 0;
+means success. */
-     return ka;
+ static int
- } /* key_array_new */
+ find_secret_key (gpgme_key_t key)
+ {
+     winpt_key_s skey;
- static void
- key_array_release( key_array_s *ka )
+     if (!key->subkeys->keyid)
- {
+         return 0;
-     free_if_alloc( ka );
+     memset (&skey, 0, sizeof (skey));
- } /* key_array_release */
+     if (winpt_get_seckey (key->subkeys->keyid, &skey))
+         return 0;
+     if (skey.ext && skey.ext->gloflags.divert_to_card)
- static int
+         return 2;
- key_array_search( key_array_s *ka, size_t items, const char *keyid )
+     return skey.ctx? 1 : 0;
- {
+ }
-     size_t j;
-     /* fixme: we need a faster search method */
+ /* Update the gpgme key pointer of a single entry. */
-     for( j = 0; j < items; j++ ) {
+ static void
-         if( !strcmp( keyid, ka[j].keyid ) )
+ update_key (keylist_ctrl_t kl, int pos,
-             return 1;
+             gpgme_key_t key)
-     }
+ {
+     if ((size_t)pos > kl->nkeys)
-     return 0;
+         BUG (0);
- } /* key_array_search */
+     kl->keys[pos] = key;
+ }
- gpgme_user_id_t
- get_nth_userid (gpgme_key_t key, int idx)
+ /* If @re_sorted == 0, then all keys from the key list control
- {
+    are stored as references in the array.
-     gpgme_user_id_t t;
+    Otherwise we just re-order the references in the array. */
+ static size_t
-     if (!key->uids)
+ update_keys (keylist_ctrl_t kl, int re_sorted,
-         return NULL;
+              gpgme_key_t **r_list)
-     t = key->uids;
+ {
-     while (idx-- && t->next)
+     gpgme_key_t *rset;
-         t = t->next;
+     gpgme_key_t key;
-     return t;
+     listview_ctrl_t lv = kl->lv;
- }
+     struct keycache_s *c;
+     size_t k_pos;
+     int nkeys;
- int
- count_userids (gpgme_key_t key)
+     nkeys = listview_count_items (lv, 0);
- {
+     if (!nkeys)
-     gpgme_user_id_t u;
+         BUG (0);
-     int n = 1;
+     if (!re_sorted) {
-     u = key->uids;
+         rset = (gpgme_key_t*)calloc (nkeys+1, sizeof (gpgme_key_t));
-     if (!u)
+         *r_list = rset;
-         return 0;
+     }
-     while (u->next) {
+     else
-         u = u->next;
+         rset = *r_list;
-         n++;
+     k_pos = 0;
-     }
+     for (int i = 0; i < nkeys; i++) {
-     return n;
+         key = km_get_key_ptr (kl, i, &c);
- }
+         rset[k_pos++] = key;
+     }
+     return k_pos;
- gpgme_subkey_t
+ }
- get_nth_key (gpgme_key_t key, int idx)
- {
-     gpgme_subkey_t t;
+ gpgme_user_id_t
+ get_nth_userid (gpgme_key_t key, int idx)
-     if (!key->subkeys)
+ {
-         return NULL;
+     gpgme_user_id_t t;
-     t = key->subkeys;
-     while (idx-- && t->next)
+     if (!key->uids)
-         t = t->next;
+         return NULL;
-     return t;
+     t = key->uids;
- }
+     while (idx-- && t->next)
+         t = t->next;
- int
+     return t;
- count_subkeys (gpgme_key_t key)
+ }
- {
-     gpgme_subkey_t k;
-     int n = 1;
+ int
+ count_userids (gpgme_key_t key)
-     k = key->subkeys;
+ {
-     if (!k)
+     gpgme_user_id_t u;
-         return 0;
+     int n = 1;
-     while (k->next) {
-         k = k->next;
+     u = key->uids;
-         n++;
+     if (!u)
-     }
+         return 0;
-     return n;
+     while (u->next) {
- }
+         u = u->next;
+         n++;
+     }
- gpgme_key_sig_t
+     return n;
- get_selfsig (gpgme_user_id_t uid, const char *keyid, int first)
+ }
- {
-     gpgme_key_sig_t s, self_sig=NULL;
-     long timestamp=0;
+ gpgme_subkey_t
+ get_nth_key (gpgme_key_t key, int idx)
-     for (s = uid->signatures; s; s = s->next) {
+ {
-         if (!strcmp (s->keyid+8, keyid) && s->timestamp > timestamp) {
+     gpgme_subkey_t t;
-             self_sig = s;
-             timestamp = s->timestamp;
+     if (!key->subkeys)
-             if (first)
+         return NULL;
-                 break;
+     t = key->subkeys;
-         }
+     while (idx-- && t->next)
-     }
+         t = t->next;
-     return self_sig;
+     return t;
  }
+ int
- const char*
+ count_subkeys (gpgme_key_t key)
- get_key_algo (gpgme_key_t key, int keyidx)
+ {
- {
+     gpgme_subkey_t k;
-     static char algo_id[128];
+     int n = 1;
-     gpgme_subkey_t k;
-     char alg[32];
+     k = key->subkeys;
-     const char *subalg;
+     if (!k)
-     int n=0;
+         return 0;
+     while (k->next) {
-     if (keyidx > 0) {
+         k = k->next;
-         k = get_nth_key (key, keyidx-1);
+         n++;
-         subalg =  get_key_pubalgo (k->pubkey_algo);
+     }
-         _snprintf( algo_id, DIM (algo_id)-1, "%s", subalg);
+     return n;
-         return algo_id;
+ }
-     }
-     strcpy (alg, get_key_pubalgo (key->subkeys->pubkey_algo));
-     n = count_subkeys (key);
+ /* Return the self signature of the key @keyid.
-     if (n > 1) {
+    If first is set, the first self sig will be returned. */
-         k = get_nth_key (key, n-1);
+ gpgme_key_sig_t
-         subalg = get_key_pubalgo (k->pubkey_algo);
+ get_selfsig (gpgme_key_sig_t sigs, const char *keyid, int first)
-         _snprintf (algo_id, DIM (algo_id)-1, "%s/%s", alg, subalg);
+ {
-         return algo_id;
+     gpgme_key_sig_t s, self_sig=NULL;
-     }
+     long timestamp=0;
-     return get_key_pubalgo (key->subkeys->pubkey_algo);
+     int off = 0;
- } /* get_key_algo */
+     if (strlen (keyid) == 8)
+         off = 8;
- const char*
- get_key_created( long timestamp )
+     for (s = sigs; s; s = s->next) {
- {
+         if (!strcmp (s->keyid+off, keyid) && s->timestamp > timestamp) {
-     static char timebuf[128];
+             self_sig = s;
-     struct tm *warp;
+             timestamp = s->timestamp;
+             if (first) /* do not search for later self sigs. */
-     if (timestamp == 0 || timestamp == -1)
+                 break;
-         return "????-??-??";
+         }
-     warp = localtime( &timestamp );
+     }
-     _snprintf( timebuf, sizeof timebuf - 1, "%04d-%02d-%02d",
+     return self_sig;
-                 warp->tm_year + 1900, warp->tm_mon + 1, warp->tm_mday );
+ }
-     return timebuf;
- } /* get_key_created */
+ const char*
+ get_key_algo (gpgme_key_t key, int keyidx)
- const char*
+ {
- get_key_expire_date (long timestamp)
+     static char algo_id[128];
- {
+     gpgme_subkey_t k;
-     static char timebuf[64];
+     char alg[32];
-     struct tm *warp;
+     const char *subalg;
+     int n;
-     if( !timestamp )
-         return _("Never");
+     if (keyidx > 0) {
-     warp = localtime( &timestamp );
+         k = get_nth_key (key, keyidx-1);
-     _snprintf( timebuf, sizeof timebuf -1, "%04d-%02d-%02d",
+         subalg =  get_key_pubalgo (k->pubkey_algo);
-                 warp->tm_year + 1900, warp->tm_mon + 1, warp->tm_mday );
+         _snprintf (algo_id, DIM (algo_id)-1, "%s", subalg);
-     return timebuf;
+         return algo_id;
- } /* get_key_expire_date */
+     }
+     strcpy (alg, get_key_pubalgo (key->subkeys->pubkey_algo));
+     n = count_subkeys (key);
- const char*
+     if (n > 1) {
- get_key_type (gpgme_key_t key)
+         do {
- {
+             k = get_nth_key (key, --n);
-     if (find_secret_key (key))
+             if (k->revoked || k->expired)
-         return _("Key Pair");
+                 continue;
-     return _("Public Key");
+             else
- } /* get_key_type */
+                 break;
+         } while (n > 0);
+         subalg = get_key_pubalgo (k->pubkey_algo);
- const char*
+         if (k == key->subkeys)
- get_key_size (gpgme_key_t key, int keyidx)
+             _snprintf (algo_id, DIM (algo_id)-1, "%s", subalg);
- {
+         else
-     static char size_id[64];
+             _snprintf (algo_id, DIM (algo_id)-1, "%s/%s", alg, subalg);
-     gpgme_subkey_t k;
+         return algo_id;
-     int n, size_main, size_sub;
+     }
+     return get_key_pubalgo (key->subkeys->pubkey_algo);
-     if (keyidx > 0) {
+ }
-         k = get_nth_key (key, keyidx-1);
-         size_main = k->length;
-         _snprintf (size_id, DIM (size_id)-1, "%d", size_main);
+ const char*
-         return size_id;
+ get_key_created (long timestamp)
-     }
+ {
-     size_main =  key->subkeys->length;
+     static char timebuf[128];
-     n = count_subkeys (key);
-     if (n > 1) {
+     if (timestamp < 1)
-         k = get_nth_key (key, n-1);
+         return "????" "-??" "-??";
-         size_sub = k->length;
+     if (!get_locale_date (timestamp, timebuf, DIM (timebuf)-1))
-         _snprintf( size_id, sizeof (size_id) - 1, "%d/%d", size_main, size_sub );
+         return "????" "-??" "-??";
-         return size_id;
+     return timebuf;
-     }
+ }
-     _snprintf( size_id, sizeof (size_id) - 1, "%d", size_main );
-     return size_id;
- } /* get_key_size */
+ /* Return a string presentation of the time @timestamp. */
+ const char*
+ get_key_expire_date (long timestamp)
- const char*
+ {
- get_key_pubalgo (gpgme_pubkey_algo_t alg)
+     static char timebuf[64];
- {
-     switch (alg) {
+     if (timestamp == 0)
-     case GPGME_PK_DSA: return "DSA";
+         return _("Never");
-     case GPGME_PK_ELG:
+     if (!get_locale_date (timestamp, timebuf, DIM (timebuf)-1))
-     case GPGME_PK_ELG_E: return "ELG";
+         return "????" "-??" "-??";
-     case GPGME_PK_RSA: return "RSA";
+     return timebuf;
-     }
+ }
-     return "???";
- }
+ const char*
- const char *
+ get_key_type (gpgme_key_t key)
- get_key_fpr (gpgme_key_t key)
+ {
- {
+     int type = find_secret_key (key);
-     static char fpr_md[64];
-     const char *fpr;
+     if (type == 1)
-     char t[16], tmp[40];
+         return _("Key Pair");
-     size_t i=0;
+     else if (type == 2)
+         return _("Key Pair (Card)");
-     memset (fpr_md, 0, sizeof (fpr_md));
+     return _("Public Key");
-     fpr = key->subkeys->fpr;
+ }
-     if (!fpr || !*fpr) {
-         memset (tmp, '0', 40);
-         fpr = tmp;
+ const char*
-     }
+ get_key_size (gpgme_key_t key, int keyidx)
-     if (strlen (fpr) == 32) {
+ {
-         strcat (fpr_md, "        ");
+     static char size_id[64];
-         for (i=0; i < strlen (fpr)/2; i++) {
+     gpgme_subkey_t k;
-             sprintf (t, "%c%c ", fpr[2*i], fpr[2*i+1]);
+     int n, size_main, size_sub;
-             strcat (fpr_md, t);
-         }
+     if (keyidx > 0) {
-     }
+         k = get_nth_key (key, keyidx-1);
-     else {
+         size_main = k->length;
-         strcat (fpr_md, " ");
+         _snprintf (size_id, DIM (size_id)-1, "%d", size_main);
-         for (i = 0; i < strlen (fpr) / 4; i++) {
+         return size_id;
-             sprintf (t, "%c%c%c%c ", fpr[4*i], fpr[4*i+1], fpr[4*i+2], fpr[4*i+3]);
+     }
-             strcat (fpr_md, t);
+     size_main =  key->subkeys->length;
-         }
+     n = count_subkeys (key);
-     }
+     if (n > 1) {
-     return fpr_md;
+         k = get_nth_key (key, n-1);
- } /* get_key_fpr */
+         size_sub = k->length;
+         _snprintf (size_id, DIM (size_id) - 1, "%d/%d",
+                     size_main, size_sub);
- const char *
+         return size_id;
- get_key_trust2 (gpgme_key_t key, int val, int uididx, int listmode)
+     }
- {
+     _snprintf (size_id, DIM (size_id) - 1, "%d", size_main);
-     if (key)
+     return size_id;
-         val = key->owner_trust; /* uididx?? */
+ }
-     switch (val) {
-     case GPGME_VALIDITY_UNKNOWN:
-     case GPGME_VALIDITY_UNDEFINED:
+ const char*
-         return "None";
+ get_key_pubalgo2 (gpgme_pubkey_algo_t alg)
-     case GPGME_VALIDITY_NEVER:
+ {
-         return "Never";
+     switch (alg) {
-     case GPGME_VALIDITY_MARGINAL:
+     case GPGME_PK_DSA: return "D";
-         return "Marginal";
+     case GPGME_PK_RSA: return "R";
-     case GPGME_VALIDITY_FULL:
+     case GPGME_PK_ELG: return "G";
-     case GPGME_VALIDITY_ULTIMATE:
+     default: return "?";
-         return "Full";
+     }
-     }
+     return "?";
-     return "";
+ }
- }
+ const char*
- const char *
+ get_key_pubalgo (gpgme_pubkey_algo_t alg)
- get_key_trust (gpgme_key_t key, int uididx, int listmode)
+ {
- {
+     switch (alg) {
-     return get_key_trust2 (key, 0, uididx, listmode);
+     case GPGME_PK_DSA: return "DSA";
- }
+     case GPGME_PK_ELG:
+     case GPGME_PK_ELG_E: return "ELG";
+     case 0: /* XXX: do we still need this?? */
- const char *
+     case GPGME_PK_RSA:
- get_key_trust_str (int val)
+     case GPGME_PK_RSA_S:
- {
+     case GPGME_PK_RSA_E: return "RSA";
-     return get_key_trust2 (NULL, val, 0, 0);
+     default: return "???";
- }
+     }
+     return "???";
+ }
- char*
- get_key_status (gpgme_key_t key, int uididx, int listmode)
- {
+ const char*
-     gpgme_user_id_t u;
+ get_key_fpr (gpgme_key_t key)
-     char fmt[64], * p;
+ {
-     const char * attr;
+     static char fpr_md[64];
-     int i = 0;
+     const char *fpr;
-     u32 key_attr =0;
+     char t[16], tmp[40];
+     size_t i;
-     if (uididx < 0 || count_userids (key) > uididx)
-         uididx = 0;
+     memset (fpr_md, 0, sizeof (fpr_md));
-     memset (fmt, 0, sizeof (fmt));
+     fpr = key->subkeys->fpr;
-     if (listmode) {
+     if (!fpr || !*fpr) {
-         if (key->revoked)
+         memset (tmp, '0', 40);
-             sprintf (fmt, "Revoked");
+         fpr = tmp;
-         else if (key->expired)
+     }
-             sprintf (fmt, "Expired");
+     if (strlen (fpr) == 32) {
-         else if (key->disabled)
+         strcat (fpr_md, "        ");
-             sprintf (fmt, "Disabled");
+         for (i=0; i < strlen (fpr)/2; i++) {
-         /* if the key has a special status, we don't continue to figure out
+             sprintf (t, "%c%c ", fpr[2*i], fpr[2*i+1]);
-            what any user-id validities. */
+             strcat (fpr_md, t);
-         if (strlen (fmt) > 0)
+         }
-             return m_strdup (fmt);
+     }
-     }
+     else {
-     u = get_nth_userid (key, uididx);
+         strcat (fpr_md, " ");
-     key_attr = u->validity;
+         for (i = 0; i < strlen (fpr) / 4; i++) {
-     attr = get_key_trust2 (NULL, key_attr, 0, 0);
+             sprintf (t, "%c%c%c%c ", fpr[4*i], fpr[4*i+1], fpr[4*i+2], fpr[4*i+3]);
-     p = new char[strlen( attr ) + 2];
+             strcat (fpr_md, t);
-     if (!p)
+         }
-         BUG (NULL);
+     }
-     sprintf (p, "%s", attr);
+     return fpr_md;
-     return p;
+ }
- } /* get_key_status */
+ /* Extract the key ID from the fingerprint.
- /* Integer comparsion of @a and @b.
+    A long ID will be converted into a short ID. */
-    Return values: same as in strcmp. */
+ const char*
- static inline int
+ get_keyid_from_fpr (const char *fpr)
- int_cmp (int a, int b)
+ {
- {
+     if (!fpr)
-     if (a == b) return 0;
+         return "????????";
-     else if (a > b) return 1;
+     if (strlen (fpr) == 40)
-     else return -1;
+         fpr += 32;
-     return 0;
+     else if (strlen (fpr) == 32)
- }
+         fpr += 24;
+     else if (strlen (fpr) == 16)
+         fpr += 8;
- /* List view sorting callback. */
+     else
- static int CALLBACK
+         return "????????";
- keylist_cmp_cb (LPARAM first, LPARAM second, LPARAM sortby)
+     return fpr;
- {
+ }
-     gpgme_key_t a, b;
-     int cmpresult = 0;
+ const char*
-     a = (gpgme_key_t)first;
+ get_key_trust2 (gpgme_key_t key, int val, int uididx, int listmode)
-     b = (gpgme_key_t)second;
+ {
-     if (!a || !b)
+     if (key)
-         BUG (NULL);
+         val = key->owner_trust; /* uididx?? */
+     switch (val) {
-     switch (sortby & ~KEYLIST_SORT_DESC) {
+     case GPGME_VALIDITY_UNKNOWN:
-     case KEY_SORT_USERID:
+     case GPGME_VALIDITY_UNDEFINED:
+         return _("None");
+     case GPGME_VALIDITY_NEVER:
+         return _("Never");
+     case GPGME_VALIDITY_MARGINAL:
+         return _("Marginal");
+     case GPGME_VALIDITY_FULL:
+         return _("Full");
+     case GPGME_VALIDITY_ULTIMATE:
+         return _("Ultimate");
+     }
+     return "";
+ }
+ const char*
+ get_key_trust (gpgme_key_t key, int uididx, int listmode)
+ {
+     return get_key_trust2 (key, 0, uididx, listmode);
+ }
+ const char*
+ get_key_trust_str (int val)
+ {
+     return get_key_trust2 (NULL, val, 0, 0);
+ }
+ /* Return the status of the key @key. */
+ char*
+ get_key_status (gpgme_key_t key, int uididx, int listmode)
+ {
+     gpgme_user_id_t u;
+     const char *attr;
+     u32 key_attr =0;
+     if (uididx < 0 || count_userids (key) > uididx)
+         uididx = 0;
+     if (listmode) {
+         const char *s;
+         if (key->revoked)
+             s = _("Revoked");
+         else if (key->expired)
+             s = _("Expired");
+         else if (key->disabled)
+             s = _("Disabled");
+         else
+             s = "";
+         /* if the key has a special status, we don't continue to figure out
+            the user-id validities. */
+         if (*s)
+             return m_strdup (s);
+     }
+     u = get_nth_userid (key, uididx);
+     key_attr = u->validity;
+     attr = get_key_trust2 (NULL, key_attr, 0, 0);
+     return m_strdup (attr);
+ }
+ /* Return human readable description of the key @key. */
+ char*
+ get_key_desc (gpgme_key_t key)
+ {
+     gpgme_key_t sk;
+     const char *state, *alg, *type;
+     char *desc;
+     StringBuffer p;
+     state = "";
+     if (key->disabled)
+         state = _("Disabled");
+     if (key->expired)
+         state = _("Expired");
+     if (key->revoked)
+         state = _("Revoked");
+     /* If the fingerprint has 32 octets, we assume MD5 and thus
+        an old, version 3, RSA key which is called 'Legacy' by other
+        OpenPGP programs. */
+     if (strlen (key->subkeys->fpr) == 32)
+         alg = "RSA Legacy";
+     else
+         alg = "OpenPGP";
+     type = _("public key");
+     if (!get_seckey (key->subkeys->keyid+8, &sk))
+         type = _("key pair");
+     p = state;
+     p = p + " " + alg + " " + type;
+     desc = m_strdup (p.getBuffer ());
+     return desc;
+ }
+ /* Integer comparsion of @a and @b.
+    Return values: same as in strcmp. */
+ static inline int
+ int_cmp (int a, int b)
+ {
+     if (a == b) return 0;
+     else if (a > b) return 1;
+     else return -1;
+     return 0;
+ }
+ /* To allow to sort the keys, we need to take care of
+    the expired/revoke status also. */
+ static int
+ get_ext_validity (gpgme_key_t k)
+ {
+     if (k->revoked)
+         return GPGME_VALIDITY_ULTIMATE+1;
+     else if (k->expired)
+         return GPGME_VALIDITY_ULTIMATE+2;
+     else if (k->disabled)
+         return GPGME_VALIDITY_ULTIMATE+3;
+     return k->uids->validity;
+ }
+ /* List view sorting callback. */
+ static int CALLBACK
+ keylist_cmp_cb (LPARAM first, LPARAM second, LPARAM sortby)
+ {
+     struct keycache_s *aa, *bb;
+     gpgme_key_t a, b;
+     int cmpresult = 0;
+     aa = (struct keycache_s *)first;
+     bb = (struct keycache_s *)second;
+     if (!aa || !bb)
+         BUG (NULL);
+     a = aa->key;
+     b = bb->key;
+     switch (sortby & ~KEYLIST_SORT_DESC) {
+     case KEY_SORT_USERID:
          cmpresult = strcmpi (a->uids->uid, b->uids->uid);
          break;
      case KEY_SORT_KEYID:
          cmpresult = strcmpi (a->subkeys->keyid+8,
                               b->subkeys->keyid+8);
          break;
-     case KEY_SORT_VALIDITY: /* XXX: handle expire, revoked */
+     case KEY_SORT_VALIDITY:
-         cmpresult = int_cmp (a->uids->validity, b->uids->validity);
+         cmpresult = int_cmp (get_ext_validity (a),
-         break;
+                              get_ext_validity (b));
+         break;
-     case KEY_SORT_OTRUST: /* XXX: handle expire, revoked */
-         cmpresult = int_cmp (a->owner_trust, b->owner_trust);
+     case KEY_SORT_OTRUST:
-         break;
+         cmpresult = int_cmp (a->owner_trust, b->owner_trust);
+         break;
-     case KEY_SORT_IS_SECRET:
-         get_seckey (a->subkeys->keyid, &a);
+     case KEY_SORT_IS_SECRET:
-         get_seckey (b->subkeys->keyid, &b);
+         get_seckey (a->subkeys->keyid, &a);
-         cmpresult = int_cmp (a? a->secret : 0, b? b->secret : 0);
+         get_seckey (b->subkeys->keyid, &b);
-         break;
+         cmpresult = int_cmp (a? a->secret : 0, b? b->secret : 0);
+         break;
-     case KEY_SORT_LEN:
-         cmpresult = int_cmp (a->subkeys->length,
+     case KEY_SORT_LEN:
-                              b->subkeys->length);
+         cmpresult = int_cmp (a->subkeys->length,
-         break;
+                              b->subkeys->length);
+         break;
-     case KEY_SORT_CREATED:
-         cmpresult = int_cmp (a->subkeys->timestamp,
+     case KEY_SORT_CREATED:
-                              b->subkeys->timestamp);
+         cmpresult = int_cmp (a->subkeys->timestamp,
-         break;
+                              b->subkeys->timestamp);
+         break;
-     case KEY_SORT_ALGO:
-         cmpresult = int_cmp (a->subkeys->pubkey_algo,
+     case KEY_SORT_ALGO:
-                              b->subkeys->pubkey_algo);
+         cmpresult = int_cmp (a->subkeys->pubkey_algo,
-         break;
+                              b->subkeys->pubkey_algo);
+         break;
-     default:
-         cmpresult = strcmpi (a->uids->uid, b->uids->uid);
+     default:
-         break;
+         cmpresult = strcmpi (a->uids->uid, b->uids->uid);
-     }
+         break;
-     if (sortby & KEYLIST_SORT_DESC)
+     }
-         return (~cmpresult + 1);
+     if (sortby & KEYLIST_SORT_DESC)
-     else
+         return (~cmpresult + 1);
-         return cmpresult;
+     else
- }
+         return cmpresult;
+ }
- static const char*
- calc_validity (gpg_group_t grp)
+ int
- {
+ keylist_add_groups (keylist_ctrl_t kl)
-     int level = 0, valid;
+ {
-     gpg_member_t mbr;
+     return 0;
-     gpgme_key_t key;
+ }
-     for( mbr = grp->list; mbr; mbr = mbr->next ) {
-         if( get_pubkey( mbr->name, &key ) )
+ /* Synchronize the key array with the contents
-             continue;
+    of the keylist. */
-         valid = key->uids->validity;
+ void
-         switch( valid ) {
+ keylist_sync (keylist_ctrl_t kl)
-         case GPGME_VALIDITY_MARGINAL:
+ {
-         case GPGME_VALIDITY_NEVER:
+     free (kl->keys);
-         case GPGME_VALIDITY_UNDEFINED:
+     kl->nkeys = update_keys (kl, 0, &kl->keys);
-             return get_key_trust2 (NULL, valid, 0, 0);
+ }
-         }
-     }
-     return _("Full");
+ /* Create a listview for listing keys. Use the mode given in @mode
- } /* calc_validity */
+    and the control is given in @ctrl. */
+ static void
+ keylist_build (listview_ctrl_t *r_lv, HWND ctrl, int mode)
- int
+ {
- keylist_add_groups( listview_ctrl_t lv )
+     struct listview_column_s klist_enc[] = {
- {
+     {0, 242, (char *)_("User ID")},
- #if 0
+     {1, 80, (char *)_("Key ID")},
-     gpg_optfile_t gh;
+     {3, 46, (char *)_("Size")},
-     gpg_group_t grp;
+     {4, 50, (char *)_("Cipher")},
-     const char *valid;
+     {5, 70, (char *)_("Validity")},
+     {0, 0, NULL}
-     gh = km_groupdb_open( );
+     };
-     if( !gh )
+     struct listview_column_s klist[] = {
-         return WPTERR_FILE_OPEN;
+     {0, 240, (char *)_("User ID")},
+     {1, 78, (char *)_("Key ID")},
-     for( grp = gh->grp; grp; grp = grp->next ) {
+     {2, 52, (char *)_("Type")},
-         valid = calc_validity( grp );
+     {3, 66, (char *)_("Size")},
-         listview_add_item( lv, " " );
+     {4, 60, (char *)_("Cipher")},
-         listview_add_sub_item( lv, 0, 0, grp->name );
+     {5, 66, (char *)_("Validity")},
-         listview_add_sub_item( lv, 0, 1, "gpg_group_t" );
+     {6, 58, (char *)_("Trust")},
-         listview_add_sub_item( lv, 0, 2, "" );
+     {7, 72, (char *)_("Creation")},
-         listview_add_sub_item( lv, 0, 3, "Unknown" );
+     {0, 0, NULL}
-         listview_add_sub_item( lv, 0, 4, valid?valid : "Unknown" );
+     };
-     }
+     HICON ico[6];
- #endif
+     listview_ctrl_t lv;
-     return 0;
+     listview_column_t col;
- } /* keylist_add_groups */
+     int ncols = 0, ext_chkbox = 0;
+     listview_new (&lv, ctrl);
- static int
+     if (mode & KEYLIST_ENCRYPT_MIN) {
- keylist_build( listview_ctrl_t *r_lv, HWND ctrl, int mode )
+         col = klist_enc;
- {
+         ncols = (DIM (klist_enc) - 1);
-     listview_ctrl_t lv;
+         ext_chkbox = 1;
-     listview_column_t col;
+     }
-     int j, n = 0;
+     else if (mode & KEYLIST_SIGN) {
-     int kl_nolist = 0, rc = 0;
+         col = klist_enc;
+         ncols = (DIM (klist_enc) - 1) - 1;
-     rc = listview_new( &lv );
+         ext_chkbox = 1;
-     if( rc )
+     }
-         return rc;
+     else {
+         col = klist;
-     lv->ctrl = ctrl;
+         ncols = (DIM (klist) - 1);
-     if( (mode & KEYLIST_ENCRYPT) || (mode & KEYLIST_ENCRYPT_MIN) ) {
+     }
-         col = klist_enc;
-         n = KLIST_ENC_ITEMS;
+     for (int j = 0; j < ncols; j++)
-     }
+         listview_add_column (lv, &col[j]);
-     else if( (mode & KEYLIST_SIGN) ) {
+     listview_set_ext_style (lv);
-         col = klist_enc;
+     if (ext_chkbox)
-         n = KLIST_ENC_ITEMS - 1;
+         listview_set_chkbox_style (lv);
-     }
+     ico[0] = LoadIcon (glob_hinst, (LPCTSTR)IDI_PUBKEY);
-     else {
+     ico[1] = LoadIcon (glob_hinst, (LPCTSTR)IDI_KEYPAIR);
-         col = klist;
+     ico[2] = LoadIcon (glob_hinst, (LPCTSTR)IDI_REV_KEYPAIR);
-         n = KLIST_ITEMS;
+     ico[3] = LoadIcon (glob_hinst, (LPCTSTR)IDI_REV_PUBKEY);
-     }
+     ico[4] = LoadIcon (glob_hinst, (LPCTSTR)IDI_SORT_DOWNARROW);
+     ico[5] = LoadIcon (glob_hinst, (LPCTSTR)IDI_SORT_UPARROW);
-     for( j = 0; j < n; j++ )
+     listview_set_image_list (lv, 20, 16, ico, 6);
-         listview_add_column( lv, &col[j] );
+     listview_del_all_items (lv);
-     listview_set_ext_style( lv );
+     listview_set_grid_style (lv);
      *r_lv = lv;
+ }
-     return 0;
- } /* keylist_build */
+ static void
+ keylist_load_keycache (keylist_ctrl_t kl, int mode,
- static void
+                        gpg_keycache_t pubkc, gpg_keycache_t seckc)
- keylist_load_keycache (listview_ctrl_t lv, int mode,
+ {
-                        gpg_keycache_t pubkc, gpg_keycache_t seckc)
+     gpgme_key_t key, skey;
- {
+     struct keycache_s *c;
-     gpgme_error_t err = gpg_error (GPG_ERR_NO_ERROR);
+     const char *keyid;
-     gpgme_key_t key, skey;
-     const char * keyid;
+     gpg_keycache_rewind (pubkc);
+     if (pubkc && seckc) {
-     if (pubkc && seckc) {
+         while (!gpg_keycache_next_key2 (pubkc, 0, &c, &key)) {
-         gpg_keycache_rewind (pubkc);
+             keyid = key->subkeys->keyid;
-         while (!gpg_keycache_next_key (pubkc, 0, &key)) {
+             if (keyid && !gpg_keycache_find_key (seckc, keyid, 0, &skey))
-             keyid = key->subkeys->keyid;
+                 keylist_add_key (kl, mode, c, key);
-             if (keyid && !gpg_keycache_find_key (seckc, keyid, 0, &skey))
+         }
-                 keylist_add_key (lv, mode, key);
+     }
-         }
+     else if (pubkc) {
-     }
+         while (!gpg_keycache_next_key2 (pubkc, 0, &c, &key))
-     else if (pubkc) {
+             keylist_add_key (kl, mode, c, key);
-         gpg_keycache_rewind (pubkc);
+     }
-         while (!err) {
+ }
-             err = gpg_keycache_next_key (pubkc, 0, &key);
-             if (!err)
-                 keylist_add_key (lv, mode, key);
+ /* Load the list view @ctrl with the keys from the cache.
-         }
+    Return value: list view context on success. */
-     }
+ keylist_ctrl_t
- } /* keylist_load_keycache */
+ keylist_load (HWND ctrl, gpg_keycache_t pubkc, gpg_keycache_t seckc,
+               int mode, int sortby)
+ {
- listview_ctrl_t
+     keylist_ctrl_t kl;
- keylist_load (HWND ctrl, gpg_keycache_t pubkc, gpg_keycache_t seckc,
-               int mode, int sortby)
+     kl = new keylist_ctrl_s;
- {
+     keylist_build (&kl->lv, ctrl, mode);
-     listview_ctrl_t lv;
+     keylist_load_keycache (kl, mode, pubkc, seckc);
-     int rc = 0;
+     kl->nkeys = update_keys (kl, 0, &kl->keys);
+     keylist_sort (kl, sortby);
-     rc = keylist_build (&lv, ctrl, mode);
+     return kl;
-     if (rc)
+ }
-         return NULL;
-     keylist_load_keycache (lv, mode, pubkc, seckc);
-     keylist_sort (lv, sortby);
+ /* Reload the given key list control @lv. */
-     if ((mode & KEYLIST_ENCRYPT) || (mode & KEYLIST_ENCRYPT_MIN))
+ int
-         keylist_add_groups (lv);
+ keylist_reload (keylist_ctrl_t kl, gpg_keycache_t pubkc, int mode, int sortby)
-     return lv;
+ {
- } /* keylist_load */
+     listview_del_all_items (kl->lv);
+     keylist_load_keycache (kl, mode, pubkc, NULL);
+     /* It is possible that the list shrinks or increases so we need to
- int
+        rebuild the list again. */
- keylist_reload( listview_ctrl_t lv, gpg_keycache_t pubkc, int mode, int sortby )
+     free (kl->keys); kl->keys = NULL;
- {
+     kl->nkeys = update_keys (kl, 0, &kl->keys);
-     listview_del_all( lv );
+     keylist_sort (kl, sortby);
-     keylist_load_keycache( lv, mode, pubkc, NULL );
+     return 0;
-     keylist_sort( lv, sortby );
+ }
-     return 0;
- } /* keylist_reload */
+ void
+ keylist_delete (keylist_ctrl_t kl)
- void
+ {
- keylist_delete( listview_ctrl_t lv )
+     if (!kl)
- {
+         return;
-     if( lv ) {
+     if (kl->keys != NULL) {
-         listview_release( lv );
+         free (kl->keys);
-     }
+         kl->keys = NULL;
- } /* keylist_delete */
+     }
+     if (kl->lv != NULL) {
+         listview_release (kl->lv);
- static int
+         kl->lv = NULL;
- find_secret_key( gpgme_key_t key )
+     }
- {
+ }
-     const char * keyid;
-     gpgme_key_t skey;
-     keyid = key->subkeys->keyid;
-     if (!keyid)
+ /* Enumeration for possible key icons. */
-         return 0;
+ enum key_icontype_t {
-     get_seckey (keyid, &skey);
+     IMG_KEY_PUB = 0,
-     return skey? 1 : 0;
+     IMG_KEY_PAIR = 1,
- } /* find_secret_key */
+     IMG_KEY_PAIR_REV = 2,
+     IMG_KEY_PUB_REV = 3
+ };
- static int
- do_addkey (listview_ctrl_t lv, gpgme_key_t key, int uididx, int keyidx, int list)
- {
+ static int
-     LV_ITEM lvi;
+ key_get_image_id (gpgme_key_t key)
-     gpgme_user_id_t u;
+ {
-     gpgme_subkey_t k;
+     if (find_secret_key (key))
-     char fmt[128];
+         return key->revoked ? IMG_KEY_PAIR_REV :IMG_KEY_PAIR;
-     const char *attr;
+     if (key->revoked)
-     u32 key_attr;
+         return IMG_KEY_PUB_REV;
-     int idx = 0;
+     return IMG_KEY_PUB;
+ }
-     /* we check the pubkey algorithm here to make sure that no ElGamal
-        sign+encrypt key is used in _any_ mode */
-     if (list != 1 && key->subkeys->pubkey_algo == GPGME_PK_ELG) {
+ static int
-         log_debug ("ElGamal (E+S) key found: %s (%s)\n",
+ do_addkey (listview_ctrl_t lv, struct keycache_s *ctx, gpgme_key_t key,
-                     key->uids->name, key->subkeys->keyid);
+            int uididx, int keyidx, int list)
-         return 0;
+ {
-     }
+     gpgme_user_id_t u;
+     gpgme_subkey_t k;
+     LV_ITEM lvi;
-     if (listview_add_item2 (lv, " ", (void *)key))
+     char *p;
-         return WPTERR_GENERAL;
+     const char *attr;
+     int idx = 0;
-     attr = key->uids->uid;
-     memset( &lvi, 0, sizeof lvi );
+     /* we check the pubkey algorithm here to make sure that no ElGamal
-     lvi.mask = LVIF_TEXT | LVIF_PARAM;
+        sign+encrypt key is used in _any_ mode */
-     lvi.pszText = (char *)attr;
+     if (list != 1 && key->subkeys->pubkey_algo == GPGME_PK_ELG) {
-     lvi.lParam = (LPARAM )key;
+         log_debug ("ElGamal (E+S) key found: %s (%s)\n",
-     if( ListView_SetItem( lv->ctrl, &lvi ) == FALSE )
+                    key->uids->name, key->subkeys->keyid);
-         return WPTERR_GENERAL;
+         return 0;
+     }
-     if( uididx == -1 ) { /* request the primary user-id of the key. */
-         attr = key->uids->uid;
+     if (listview_add_item2 (lv, " ", (void *)ctx))
-         uididx = 0;
+         return WPTERR_GENERAL;
-     }
-     else {
+     attr = ctx->uids->uid;
-         u = get_nth_userid (key, uididx);
+     memset (&lvi, 0, sizeof lvi);
-         if (!u || u->revoked || uididx < 0)
+     lvi.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
-             uididx = 0; /* fixme: this happen sometimes but it's illegal! (<0) */
+     lvi.pszText = (char *)attr;
-         u = get_nth_userid (key, uididx);
+     lvi.iImage = key_get_image_id (key);
-         attr = key->uids->uid;
+     lvi.lParam = (LPARAM )ctx;
-     }
+     if (ListView_SetItem (lv->ctrl, &lvi) == FALSE)
-     if( attr == NULL || strlen( attr ) < 5 ) { /* normal userids are >= 5 chars */
+         return WPTERR_GENERAL;
-         attr = _("Invalid User ID");
-         listview_add_sub_item( lv, 0, idx++, attr );
+     if (uididx == -1) { /* request the primary user-id of the key. */
-     }
+         attr = ctx->uids->uid;
-     else {
+         uididx = 0;
-         char * uid = utf8_to_wincp (attr, strlen (attr));
+     }
-         if (uid) {
+     else {
-             listview_add_sub_item( lv, 0, idx++, uid );
+         u = get_nth_userid (key, uididx);
-             free (uid);
+         if (!u || u->revoked || uididx < 0)
-         }
+             uididx = 0;
-     }
+         u = get_nth_userid (key, uididx);
-     k = get_nth_key (key, keyidx);
+         attr = u->uid;
-     if( k && k->keyid ) {
+     }
-         _snprintf( fmt, sizeof fmt -1, "0x%s", k->keyid + 8 );
+     if (attr == NULL || strlen (attr) < 5) { /* normal userids are > 5 chars */
-         listview_add_sub_item( lv, 0, idx++, fmt );
+         attr = _("Invalid User ID");
-     }
+         listview_add_sub_item (lv, 0, idx++, attr);
-     if (list > 0) {
+     }
-         attr = find_secret_key (key)? "pub/sec" : "pub";
+     else
-         if (strchr( attr, '/')) {
+         listview_add_sub_item (lv, 0, idx++, attr);
-             struct winpt_key_s k;
+     k = get_nth_key (key, keyidx);
-             winpt_get_seckey (key->subkeys->keyid, &k);
+     if (k && k->keyid != NULL) {
-             if (k.ext->gloflags.divert_to_card)
+         char keyid[16+1];
-                 attr = "pub/crd";
-         }
+         _snprintf (keyid, DIM (keyid) -1, "0x%s", k->keyid + 8);
-         listview_add_sub_item( lv, 0, idx++, attr );
+         listview_add_sub_item (lv, 0, idx++, keyid);
      }
-     if (lv->cols >= 2) {
+     if (list > 0) {
-         attr = get_key_size (key, list == -1? keyidx+1 : 0);
+         DWORD key_attr = find_secret_key (key);
-         if (attr)
+         if (!key_attr)
-             listview_add_sub_item (lv, 0, idx++, attr);
+             attr = "pub";
-     }
+         else
-     if (lv->cols >= 3) {
+             attr = key_attr == 1? "pub/sec" : "pub/crd";
-         attr = get_key_algo (key, list == -1? keyidx+1 : 0);
+         listview_add_sub_item (lv, 0, idx++, attr);
-         if (attr)
+     }
-             listview_add_sub_item( lv, 0, idx++, attr);
+     if (lv->cols >= 2) {
-     }
+         attr = get_key_size (key, list == -1? keyidx+1 : 0);
-     if( lv->cols >= 4 ) {
+         if (attr != NULL)
-         char * status = get_key_status( key, uididx, list > 0? 1 : 0 );
+             listview_add_sub_item (lv, 0, idx++, attr);
-         if (!status)
+     }
-             return WPTERR_GENERAL;
+     if (lv->cols >= 3) {
-         listview_add_sub_item( lv, 0, idx++, status );
+         attr = get_key_algo (key, list == -1? keyidx+1 : 0);
-         free_if_alloc( status );
+         if (attr != NULL)
-     }
+             listview_add_sub_item( lv, 0, idx++, attr);
-     if (lv->cols >= 5) {
+     }
-         const char * s = get_key_trust (key, uididx, list > 0? 1 : 0);
+     if (lv->cols >= 4) {
-         listview_add_sub_item (lv, 0, idx++, s);
+         p = get_key_status (key, uididx, list > 0? 1 : 0);
-     }
+         if (p != NULL)
-     if( lv->cols >= 6 ) {
+             listview_add_sub_item (lv, 0, idx++, p);
-         k = get_nth_key (key, keyidx);
+         free_if_alloc (p);
-         key_attr = k->timestamp;
+     }
-         if( key_attr ) {
+     if (lv->cols >= 5) {
-             attr = get_key_created (key_attr);
+         attr = get_key_trust (key, uididx, list > 0? 1 : 0);
-             listview_add_sub_item( lv, 0, idx++, attr );
+         listview_add_sub_item (lv, 0, idx++, attr);
-         }
+     }
-     }
+     if (lv->cols >= 6) {
+         k = get_nth_key (key, keyidx);
-     return 0;
+         if (k->timestamp > 0) {
- } /* do_addkey */
+             attr = get_key_created (k->timestamp);
+             listview_add_sub_item (lv, 0, idx++, attr);
+         }
- void
+     }
- keylist_upd_key (listview_ctrl_t lv, int pos, gpgme_key_t key)
- {
+     return 0;
-     const char *s;
+ }
-     char tmp[32];
-     listview_set_item2 (lv, pos, (void *)key);
+ /* Update a single column @col but for each element in the
-     /* the only mode we support is KYLIST_LIST in the Key Manager */
+    listview @lv. */
+ void
-     s = key->uids->uid;
+ keylist_upd_col (keylist_ctrl_t kl, int col)
-     if (s)
+ {
-         listview_add_sub_item (lv, pos, 0, s);
+     gpgme_key_t key;
+     const char *s;
-     s = key->subkeys->keyid;
+     char buf[32], *p;
-     if (s) {
-         sprintf (tmp, "0x%s", s+8);
+     for (int i=0; i < listview_count_items (kl->lv, 0); i++) {
-         listview_add_sub_item (lv, pos, 1, tmp);
+         key = km_get_key_ptr (kl, i, NULL);
-     }
+         if (!key)
+             continue;
-     s = find_secret_key (key)? "pub/sec" : "pub";
+         switch (col) {
-     listview_add_sub_item (lv, pos, 2, s);
+         case KM_COL_KEYID:
+             _snprintf (buf, DIM (buf)-1, "0x%s", key->subkeys->keyid+8);
-     s = get_key_size (key, 0);
+             listview_add_sub_item (kl->lv, i, col, buf);
-     if (s)
+             break;
-         listview_add_sub_item (lv, pos, 3, s);
+         case KM_COL_CIPHER:
-     s = get_key_algo (key, 0);
+             s = get_key_algo (key, 0);
-     if (s)
+             listview_add_sub_item (kl->lv, i, col, s);
-         listview_add_sub_item (lv, pos, 4, s);
+             break;
-     s = get_key_status (key, 0, 1);
+         case KM_COL_TYPE:
-     if (s)
+             s = find_secret_key (key)? "pub/sec" : "pub";
-         listview_add_sub_item (lv, pos, 5, s);
+             listview_add_sub_item (kl->lv, i, col, s);
+             break;
-     s = get_key_trust (key, 0, 1);
-     if (s)
+         case KM_COL_CREAT:
-         listview_add_sub_item (lv, pos, 6, s);
+             s = get_key_created (key->subkeys->timestamp);
+             listview_add_sub_item (kl->lv, i, col, s);
-     long t = key->subkeys->timestamp;
+             break;
-     s = get_key_created (t);
-     if (s)
+         case KM_COL_DESC:
-         listview_add_sub_item (lv, pos, 7, s);
+             p = get_key_desc (key);
- }
+             listview_add_sub_item (kl->lv, i, col, p);
+             free_if_alloc (p);
+             break;
- int
+         }
- keylist_add_key (listview_ctrl_t lv, int mode, gpgme_key_t key)
+     }
- {
+ }
-     int uids, rc = 0, i, n = 0;
-     gpgme_subkey_t k;
+ /* Update the listview item at position @pos with the data from
-     for (k=key->subkeys, i = 0; i < count_subkeys (key); i++, k=k->next) {
+    the key @key. */
-         if (k->invalid) {
+ void
-             log_debug ("keylist_add_key: invalid key \"%s\"\n", key->uids->name);
+ keylist_upd_key (keylist_ctrl_t kl, int pos,
-             continue; /* Don't use invalid keys */
+                  struct keycache_s *ctx, gpgme_key_t key)
-         }
+ {
+     listview_ctrl_t lv = kl->lv;
-         if (mode & KEYLIST_ALL) {
+     char *p;
-             uids = count_userids (key);
+     char tmp[32];
-             rc = do_addkey (lv, key, uids, i, 0);
-             if( rc )
+     listview_set_item2 (lv, pos, (void *)ctx);
-                 return rc;
+     update_key (kl, pos, key);
-         }
+     /* the only mode we support is KEYLIST_LIST in the Key Manager */
-         else if (mode & KEYLIST_LIST)
-             return do_addkey (lv, key, -1, i, 1);
+     const char *s = ctx->uids->uid;
-         else if (mode & KEYLIST_ENCRYPT) {
+     if (s)
-             if (k->can_encrypt && key_is_useable (k)) {
+         listview_add_sub_item (lv, pos, KM_COL_UID, s);
-                 if (mode & KEYLIST_FLAG_FILE) {
-                     rc = do_addkey (lv, key, -1, i, -1);
+     s = key->subkeys->keyid;
-                     if (rc)
+     if (s) {
-                         return rc;
+         sprintf (tmp, "0x%s", s+8);
-                 }
+         listview_add_sub_item (lv, pos, KM_COL_KEYID, tmp);
-                 else {
+     }
-                     for( uids = 0;  uids < count_userids (key); uids++ ) {
-                         rc = do_addkey( lv, key, uids, i, -1 );
+     s = find_secret_key (key)? "pub/sec" : "pub";
-                         if( rc )
+     listview_add_sub_item (lv, pos, KM_COL_TYPE, s);
-                             return rc;
-                     }
+     s = get_key_size (key, 0);
-                 }
+     if (s)
-             }
+         listview_add_sub_item (lv, pos, KM_COL_SIZE, s);
-         }
-         else if (mode & KEYLIST_ENCRYPT_MIN) {
+     s = get_key_algo (key, 0);
-             if( k->can_encrypt && key_is_useable (k))
+     if (s)
-             {
+         listview_add_sub_item (lv, pos, KM_COL_CIPHER, s);
-                 rc = do_addkey (lv, key, -1, i, -1);
-                 return rc;
+     p = get_key_status (key, 0, 1);
-             }
+     if (p) {
-         }
+         listview_add_sub_item (lv, pos, KM_COL_VALID, p);
-         else if (mode & KEYLIST_SIGN) {
+         free_if_alloc (p);
-             if ( k->can_sign
+     }
-                 && find_secret_key( key )
-                 && key_is_useable (k))
+     s = get_key_trust (key, 0, 1);
-             {
+     if (s)
-                 rc = do_addkey (lv, key, -1, i, -1);
+         listview_add_sub_item (lv, pos, KM_COL_TRUST, s);
-                 if( rc )
-                     return rc;
+     long t = key->subkeys->timestamp;
-             }
+     s = get_key_created (t);
-         }
+     if (s)
-     }
+         listview_add_sub_item (lv, pos, KM_COL_CREAT, s);
+ }
-     return rc;
- } /* keylist_add_key */
+ int
+ keylist_add_key (keylist_ctrl_t kl, int mode,
- int
+                  struct keycache_s *ctx, gpgme_key_t key)
- keylist_sort (listview_ctrl_t lv, int sortby)
+ {
- {
+     gpgme_subkey_t k;
-     return listview_sort_items (lv, sortby, keylist_cmp_cb);
+     listview_ctrl_t lv = kl->lv;
- }
+     int uids, rc, i;
+     /* if the entire key is disabled, just return. */
- /* Check that the validity @validity is at least >= marginal. */
+     if (key->disabled && !(mode & KEYLIST_LIST))
- static int
+         return 0;
- key_check_validity (const char *validity)
- {
+     for (k = key->subkeys, i = 0; i < count_subkeys (key); i++, k = k->next) {
-     if (strstr (validity, "Unknown") ||
+         if (k->invalid) {
-         strstr (validity, "Undefined") ||
+             log_debug ("keylist_add_key: invalid key \"%s\"\n",
-         strstr (validity, "Never") ||
+                        key->uids->name);
-         strstr (validity, "None"))
+             continue; /* Don't use invalid keys */
-         return 0;
+         }
-     return 1;
- }
+         if (mode & KEYLIST_ALL) {
+             uids = count_userids (key);
+             rc = do_addkey (lv, ctx, key, uids, i, 0);
- /* Extract all selected recipients from the list @lv and return them
+             if (rc)
-    as a vector. @r_force_trust is >= 1 if one of the recipients is not
+                 return rc;
-    fully trusted. @r_count returns the number of selected keys.
+         }
-    Return value: the key list on success, NULL otherwise. */
+         else if (mode & KEYLIST_LIST)
- gpgme_key_t*
+             return do_addkey (lv, ctx, key, -1, i, 1);
- keylist_get_recipients (listview_ctrl_t lv, int *r_force_trust, int *r_count)
+         else if (mode & KEYLIST_ENCRYPT) {
- {
+             if (k->can_encrypt && key_is_useable (k)) {
-     int count = 0, force_trust = 0;
+                 if (mode & KEYLIST_FLAG_FILE) {
-     int n, j, ka_pos = 0, rc = 0;
+                     rc = do_addkey (lv, ctx, key, -1, i, -1);
-     int k_pos=0;
+                     if (rc)
-     char keyid[32], valid[32], id[100];
+                         return rc;
-     key_array_s *ka = NULL;
+                 }
-     gpgme_key_t *keybuf;
+                 else {
+                     for (uids = 0;  uids < count_userids (key); uids++) {
-     n = listview_count_items( lv, 0 );
+                         rc = do_addkey (lv, ctx, key, uids, i, -1);
+                         if (rc)
-     ka = key_array_new( n );
+                             return rc;
-     if (!ka)
+                     }
-         BUG (NULL);
+                 }
+             }
-     keybuf = (gpgme_key_t*)calloc (n, sizeof (gpgme_key_t));
+         }
-     if (!keybuf)
+         else if (mode & KEYLIST_ENCRYPT_MIN) {
-         BUG (NULL);
+             if (k->can_encrypt && key_is_useable (k)) {
+                 rc = do_addkey (lv, ctx, key, -1, i, -1);
-     for( j = 0; j < n; j++ ) {
+                 return rc;
-         if( listview_get_item_state (lv, j) || n == 1) {
+             }
-             listview_get_item_text (lv, j, 0, id, sizeof id-1);
+         }
-             listview_get_item_text (lv, j, 1, keyid, sizeof keyid - 1);
+         else if (mode & KEYLIST_SIGN) {
-             listview_get_item_text (lv, j, 4, valid, sizeof valid -1);
+             if (k->can_sign
-             if( !key_check_validity (valid)
+                 && find_secret_key (key)
-                  && !key_array_search( ka, ka_pos, keyid )) {
+                 && key_is_useable (k)) {
-                 char *warn = new char[512+strlen (id) + 1];
+                 rc = do_addkey (lv, ctx, key, -1, i, -1);
-                 if (!warn)
+                 if (rc)
-                     BUG (0);
+                     return rc;
-                 sprintf (warn,
+             }
-                     _("It is NOT certain that the key belongs to the person\n"
+         }
-                       "named in the user ID.  If you *really* know what you are\n"
+     }
-                       "doing, you may answer the next question with yes\n"
-                       "\n"
+     return 0;
-                       "Use \"%s\" anyway?"), id);
+ }
-                 if (reg_prefs.always_trust)
-                     rc = IDYES;
-                 else
+ int
-                     rc = msg_box (NULL, warn, _("Recipients"), MB_ERR_ASK);
+ keylist_sort (keylist_ctrl_t kl, int sortby)
-                 if (rc == IDYES) {
+ {
-                     gpgme_key_t k;
+     int ret = listview_sort_items (kl->lv, sortby, keylist_cmp_cb);
-                     get_pubkey (keyid, &k);
+     kl->nkeys = update_keys (kl, 1, &kl->keys);
-                     keybuf[k_pos++] = k;
+     return ret;
-                     force_trust++;
+ }
-                     ka[ka_pos].checked = 1;
-                     strcpy (ka[ka_pos++].keyid, keyid);
-                     count++;
+ /* Check that the validity @validity is at least >= marginal. */
-                 }
+ static int
-                 free_if_alloc (warn);
+ key_check_validity (gpgme_key_t key)
-             }
+ {
-             else {
+     gpgme_user_id_t u;
-                 gpgme_key_t k;
-                 listview_get_item_text( lv, j, 1, keyid, sizeof keyid -1 );
+     for (u=key->uids; u; u =u->next) {
-                 get_pubkey (keyid, &k);
+         if (u->validity >= GPGME_VALIDITY_MARGINAL)
-                 keybuf[k_pos++] = k;
+             return -1;
-                 count++;
+     }
-             }
-         }
+     return 0;
-     }
+ }
-     key_array_release (ka);
-     if (r_force_trust)
-         *r_force_trust = force_trust;
+ /* Extract all selected recipients from the list @lv and return them
-     if (r_count)
+    as a vector. @r_force_trust is >= 1 if one of the recipients is not
-         *r_count = count;
+    fully trusted. @r_count returns the number of selected keys.
-     return keybuf;
+    Return value: the key list on success, NULL otherwise. */
- }
+ gpgme_key_t*
+ keylist_get_recipients (keylist_ctrl_t kl, int *r_force_trust, size_t *r_count)
- static int
+ {
- keylist_get_keyflags (const char *buf, size_t buflen)
+     gpgme_key_t *keybuf, key;
- {
+     listview_ctrl_t lv = kl->lv;
-     int c = 0, flags = 0;
+     key_array_s *ka = NULL;
+     keycache_s *c;
-     if( *buf != '[' )
+     size_t count = 0;
-         return KEYFLAG_NONE;
+     int force_trust = 0;
-     while (buf && c != ']')
+     int nkeys, ka_pos = 0, rc = 0;
-     {
+     int k_pos=0;
-         c = *buf++;
-         if (c == 'R')
+     nkeys = listview_count_items (lv, 0);
-             flags |= KEYFLAG_REVOKED;
+     ka = key_array_new (nkeys);
-         if (c == 'E')
+     keybuf = (gpgme_key_t*)calloc (nkeys+1, sizeof (gpgme_key_t));
-             flags |= KEYFLAG_EXPIRED;
+     if (!keybuf)
-         if (c == 'D')
+         BUG (NULL);
-             flags |= KEYFLAG_DISABLED;
-     }
+     for (int j = 0; j < nkeys; j++) {
+         if (listview_get_item_state (lv, j) || nkeys == 1) {
-     return flags;
+             key = km_get_key_ptr (kl, j, &c);
- } /* keylist_get_keyflags */
+             if (!key)
+                 BUG (0);
+             if (!key_check_validity (key) &&
- gpgme_key_t*
+                 !key_array_search (ka, ka_pos, key->subkeys->keyid)) {
- keylist_enum_recipients (listview_ctrl_t lv,  int listype, int *r_count)
+                 StringBuffer warn;
- {
+                 warn = warn + c->uids->uid + ":\n\n";
-     gpgme_key_t* rset;
+                 warn = warn +_("It is NOT certain that the key belongs to the person\n"
-     gpgme_key_t k;
+                          "named in the user ID.  If you *really* know what you are\n"
-     int i, n, id, k_pos=0;
+                          "doing, you may answer the next question with no\n"
-     char keyid[32], t[128], t2[128];
+                          "\nSkip this key?");
+                 rc = msg_box (NULL, warn.getBuffer(), _("Warning"), MB_WARN_ASK);
-     n = listview_count_items (lv, 0);
+                 if (reg_prefs.always_trust || rc == IDNO) {
-     if (!n)
+                     keybuf[k_pos++] = key;
-         return 0;
+                     force_trust++;
-     rset = (gpgme_key_t*)calloc (n, sizeof (gpgme_key_t));
+                     ka[ka_pos].checked = 1;
-     if (!rset)
+                     strcpy (ka[ka_pos++].keyid, key->subkeys->keyid);
-         BUG (NULL);
+                     count++;
-     for( i = 0; i < n; i++ ) {
+                 }
-         if( !listview_get_item_state( lv, i ) )
+             }
-             continue;
+             else {
-         listview_get_item_text( lv, i, 1, keyid, sizeof keyid - 1 );
+                 keybuf[k_pos++] = key;
-         switch( listype ) {
+                 count++;
-         case KEYLIST_LIST:
+             }
-             listview_get_item_text( lv, i, 5, t, sizeof t - 1 );
+         }
-             if( keylist_get_keyflags( t, strlen( t ) ) & KEYFLAG_REVOKED ) {
+     }
-                 _snprintf( t2, sizeof t2 -1,
+     key_array_release (ka);
-                             _("KeyID %s.\nDo you really want to export a revoked key?"), keyid );
+     if (r_force_trust)
-                 id = msg_box( lv->ctrl, t2, _("Recipients"), MB_INFO|MB_YESNO );
+         *r_force_trust = force_trust;
-                 if( id == IDNO )
+     if (r_count)
-                     continue;
+         *r_count = count;
-             }
+     return keybuf;
-             break;
+ }
-         }
-         get_pubkey (keyid, &k);
-         rset[k_pos++] = k;
+ static int
-     }
+ keylist_get_keyflags (gpgme_key_t key)
-     if (r_count)
+ {
-         *r_count = k_pos;
+     int flags = KEYFLAG_NONE;
-     return rset;
- } /* keylist_enum_recipients */
+     if (key->revoked)
+         flags |= KEYFLAG_REVOKED;
+     if (key->expired)
- void
+         flags |= KEYFLAG_EXPIRED;
- seclist_destroy (keylist_t * list)
+     if (key->disabled)
- {
+         flags |= KEYFLAG_DISABLED;
-     keylist_t l2;
-     while (*list) {
+     return flags;
-         l2 = (*list)->next;
+ }
-         safe_free (*list);
-         *list = l2;
-     }
-     list = NULL;
+ gpgme_key_t*
- } /* seclist_destroy */
+ keylist_enum_recipients (keylist_ctrl_t kl,  int listype, size_t *r_count)
+ {
+     gpgme_key_t *rset;
- void
+     gpgme_key_t key;
- seclist_init (HWND dlg, int ctlid, int flags, keylist_t * ret_list)
+     listview_ctrl_t lv = kl->lv;
- {
+     struct keycache_s *c;
-     gpg_keycache_t kc = NULL;
+     size_t k_pos;
-     gpgme_key_t key = NULL;
+     int nkeys, id;
-     HWND kb;
-     keylist_t list=NULL, l, l2;
+     nkeys = listview_count_items (lv, 0);
-     long pos = 0;
+     if (!nkeys)
+         return 0;
-     SendDlgItemMessage (dlg, ctlid, CB_RESETCONTENT, 0, 0);
+     rset = (gpgme_key_t*)calloc (nkeys+1, sizeof (gpgme_key_t));
-     kb = GetDlgItem (dlg, ctlid);
+     if (!rset)
-     kc = keycache_get_ctx (0);
+         BUG (NULL);
-     if (!kc)
+     k_pos = 0;
-         BUG (0);
+     for (int i = 0; i < nkeys; i++) {
-     gpg_keycache_rewind (kc);
+         if (!listview_get_item_state (lv, i))
+             continue;
-     while (!gpg_keycache_next_key (kc, 1, &key)) {
+         key = km_get_key_ptr (kl, i, &c);
-         char * inf = NULL, * uid = NULL;
+         switch (listype) {
-         const char * id;
+         case KEYLIST_LIST:
-         const char * keyid;
+             if (keylist_get_keyflags (key) & KEYFLAG_REVOKED) {
-         int algo;
+                 id = printf_box (_("Recipients"), MB_INFO|MB_YESNO,
-         size_t size = 0;
+                 _("KeyID %s.\nDo you really want to export a revoked key?"),
+                                  c->uids->uid);
-         if (flags & KEYLIST_FLAG_SHORT)
+                 if (id == IDNO)
-             id = key->uids->name;
+                     continue;
-         else
+             }
-             id = key->uids->uid;
+             break;
-         keyid = key->subkeys->keyid;
+         }
-         algo = key->subkeys->pubkey_algo;
+         rset[k_pos++] = key;
-         if (!id || !keyid)
+     }
-             continue; /* fixme: error? */
+     if (r_count)
-         if (!key_is_useable (key->subkeys))
+         *r_count = k_pos;
-             continue;
+     return rset;
+ }
-         uid = utf8_to_wincp (id, strlen (id));
-         size = strlen( uid ) + strlen( keyid ) + 32;
-         inf = new char[size+1];
+ void
-         if( !inf )
+ seclist_destroy (keylist_t *list)
-             BUG( NULL );
+ {
-         _snprintf (inf, size, _("%s (%s/0x%s)"), uid,
+     keylist_t l2;
-                    get_key_pubalgo (key->subkeys->pubkey_algo), keyid + 8);
-         combox_add_string (kb, inf);
+     while (*list) {
-         free_if_alloc (inf);
+         l2 = (*list)->next;
-         free (uid);
+         safe_free (*list);
-         l = (struct keylist_s *)calloc (1, sizeof * l);
+         *list = l2;
-         if (!l)
+     }
-             BUG (0);
+     *list = NULL;
-         l->key = key;
+ }
-         if (!list)
-             list = l;
-         else {
+ void
-             for( l2 = list; l2->next; l2 = l2->next )
+ seclist_init (HWND dlg, int ctlid, int flags, keylist_t *ret_list)
-                 ;
+ {
-             l2->next = l;
+     gpg_keycache_t kc;
-         }
+     gpgme_key_t key = NULL;
-     }
+     HWND kb;
-     for( pos = 0, l2=list; pos < SendMessage( kb, CB_GETCOUNT, 0, 0 ); pos++, l2=l2->next )
+     keylist_t list=NULL, l, l2;
-         SendMessage( kb, CB_SETITEMDATA, pos, (LPARAM)(DWORD)l2->key );
+     long pos;
-     SendMessage( kb, CB_SETCURSEL, 0, 0 );
-     *ret_list = list;
+     SendDlgItemMessage (dlg, ctlid, CB_RESETCONTENT, 0, 0);
- }
+     kb = GetDlgItem (dlg, ctlid);
+     kc = keycache_get_ctx (0);
+     if (!kc)
- /* Select a secret key from the combo box with the ID @ctlid.
+         BUG (0);
-    Return the code on success in @ret_key. */
+     gpg_keycache_rewind (kc);
- int
- seclist_select_key (HWND dlg, int ctlid, gpgme_key_t *ret_key)
+     while (!gpg_keycache_next_key (kc, 1, &key)) {
- {
+         StringBuffer inf;
-     int pos;
+         char *uid;
-     DWORD k = 0;
+         const char *id;
-     pos = SendDlgItemMessage (dlg, ctlid, CB_GETCURSEL, 0, 0);
+         if (key->disabled || !key_is_useable (key->subkeys))
-     if (pos == CB_ERR) {
+             continue;
-         msg_box (dlg, _("No key was selected."), _("Secret Key List"), MB_ERR);
-         *ret_key = NULL;
+         if (flags & KEYLIST_FLAG_SHORT)
-     }
+             id = key->uids->name;
-     else {
+         else
-         k = SendDlgItemMessage (dlg, ctlid, CB_GETITEMDATA, pos, 0);
+             id = key->uids->uid;
-         *ret_key = (gpgme_key_t)k;
+         if (!id || !key->subkeys->keyid)
-     }
+             continue;
-     return k? 0 : -1;
- }
+         uid = utf8_to_native (id);
+         inf = uid;
+         inf = inf + " (" + get_key_pubalgo (key->subkeys->pubkey_algo) + "/";
+         inf = inf + "0x" + (key->subkeys->keyid+8) + ")";
+         combox_add_string (kb, inf.getBuffer ());
+         safe_free (uid);
+         l = (struct keylist_s *)calloc (1, sizeof * l);
+         if (!l)
+             BUG (0);
+         l->key = key;
+         if (!list)
+             list = l;
+         else {
+             for( l2 = list; l2->next; l2 = l2->next )
+                 ;
+             l2->next = l;
+         }
+     }
+     for (pos = 0, l2=list; pos < SendMessage (kb, CB_GETCOUNT, 0, 0);
+          pos++, l2=l2->next)
+         SendMessage (kb, CB_SETITEMDATA, pos, (LPARAM)(DWORD)l2->key);
+     SendMessage (kb, CB_SETCURSEL, 0, 0);
+     *ret_list = list;
+ }
+ /* Select a secret key from the combo box with the ID @ctlid.
+    Return the code on success in @ret_key. */
+ int
+ seclist_select_key (HWND dlg, int ctlid, gpgme_key_t *ret_key)
+ {
+     int pos;
+     DWORD k = 0;
+     pos = SendDlgItemMessage (dlg, ctlid, CB_GETCURSEL, 0, 0);
+     if (pos == CB_ERR) {
+         msg_box (dlg, _("No key was selected."), _("Secret Key List"), MB_ERR);
+         *ret_key = NULL;
+     }
+     else {
+         k = SendDlgItemMessage (dlg, ctlid, CB_GETITEMDATA, pos, 0);
+         *ret_key = (gpgme_key_t)k;
+     }
+     return k? 0 : -1;
+ }
+ LRESULT
+ keylist_listview_notify (HWND hwnd, gpgme_key_t *keys,
+                          int ctlid, LPARAM lparam)
+ {
+     LPNMHDR lpnmh = (LPNMHDR) lparam;
+     if (!lpnmh)
+         BUG (NULL);
+     /* Make sure the message is for the control and
+        that we have a key list. */
+     if (lpnmh->idFrom != (DWORD)ctlid || keys == NULL)
+         return 0;
+     switch (lpnmh->code) {
+     case NM_CUSTOMDRAW:
+         LPNMLVCUSTOMDRAW lplvcd;
+         lplvcd = (LPNMLVCUSTOMDRAW)lparam;
+         if (lplvcd->nmcd.dwDrawStage == CDDS_PREPAINT)
+             return CDRF_NOTIFYITEMDRAW;
+         if (lplvcd->nmcd.dwDrawStage == CDDS_ITEMPREPAINT) {
+             LRESULT ret = CDRF_DODEFAULT;
+             int pos = lplvcd->nmcd.dwItemSpec;
+             HWND lv = GetDlgItem (hwnd, ctlid);
+             gpgme_key_t key = keys[pos];
+             if (key != NULL) {
+                 HFONT hfont = (HFONT)SendMessage (lv, WM_GETFONT, 0, 0);
+                 LOGFONT lf;
+                 if (!GetObject (hfont, sizeof (lf), &lf))
+                     BUG (NULL);
+                 if (key->revoked)
+                     lf.lfStrikeOut = TRUE;
+                 else if (key->expired)
+                     lf.lfItalic = TRUE;
+                 if (find_secret_key (key))
+                     lf.lfWeight = FW_SEMIBOLD;
+                 hfont = CreateFontIndirect (&lf);
+                 SelectObject (lplvcd->nmcd.hdc, hfont);
+                 if (pos & 1)
+                     lplvcd->clrTextBk = RGB (0xE5, 0xE5, 0xE5);
+                 ret = CDRF_NEWFONT | CDRF_NOTIFYPOSTPAINT;
+             }
+             return ret;
+         }
+         if (lplvcd->nmcd.dwDrawStage == CDDS_ITEMPOSTPAINT) {
+             HFONT hfont = (HFONT)GetStockObject (DEFAULT_GUI_FONT);
+             hfont = (HFONT)SelectObject (lplvcd->nmcd.hdc, hfont);
+             DeleteObject (hfont);
+             return CDRF_DODEFAULT;
+         }
+         return CDRF_DODEFAULT;
+     }
+     return 0;
+ }

 Legend:



Removed from v.25
 


changed lines


 
Added in v.428
 Legend:



Removed from v.25
 


changed lines


 
Added in v.428
-Removed from v.25
+Added in v.428

[email protected]	ViewVC Help
Powered by ViewVC 1.1.26