/[winpt]/trunk/Src/wptKeyPropsDlg.cpp
ViewVC logotype

Diff of /trunk/Src/wptKeyPropsDlg.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 28 by twoaday, Thu Oct 20 12:35:59 2005 UTC revision 310 by twoaday, Sat Apr 7 11:07:20 2007 UTC
# Line 1  Line 1 
1  /* wptKeyPropsDlg.cpp - WinPT key properties dialog  /* wptKeyPropsDlg.cpp - WinPT key property dialog
2   *      Copyright (C) 2000, 2001, 2002, 2003, 2005 Timo Schulz   *      Copyright (C) 2000, 2001, 2002, 2003, 2005, 2006 Timo Schulz
3   *   *
4   * This file is part of WinPT.   * This file is part of WinPT.
5   *   *
6   * WinPT is free software; you can redistribute it and/or modify   * WinPT is free software; you can redistribute it and/or modify
7   * it under the terms of the GNU General Public License as published by   * it under the terms of the GNU General Public License as published by
8   * the Free Software Foundation; either version 2 of the License, or   * the Free Software Foundation; either version 2 of the License, or
9   * (at your option) any later version.   * (at your option) any later version.
10   *   *
11   * WinPT is distributed in the hope that it will be useful,   * WinPT is distributed in the hope that it will be useful,
12   * but WITHOUT ANY WARRANTY; without even the implied warranty of   * but WITHOUT ANY WARRANTY; without even the implied warranty of
13   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   * GNU General Public License for more details.   * GNU General Public License for more details.
15   *   *
16   * You should have received a copy of the GNU General Public License   * You should have received a copy of the GNU General Public License
17   * along with WinPT; if not, write to the Free Software Foundation,   * along with WinPT; if not, write to the Free Software Foundation,
18   * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA   * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19   */   */
20    #ifdef HAVE_CONFIG_H
21  #include <windows.h>  #include <config.h>
22    #endif
23  #include "../resource.h"  
24  #include "wptErrors.h"  #include <windows.h>
25  #include "wptGPG.h"  #include <assert.h>
26  #include "wptCommonCtl.h"  
27  #include "wptContext.h" /* for passphrase_s */  #include "resource.h"
28  #include "wptNLS.h"  #include "wptErrors.h"
29  #include "wptDlgs.h"  #include "wptGPG.h"
30  #include "wptTypes.h"  #include "wptCommonCtl.h"
31  #include "wptKeylist.h"  #include "wptContext.h" /* for passphrase_s */
32  #include "wptW32API.h"  #include "wptNLS.h"
33  #include "wptVersion.h"  #include "wptDlgs.h"
34  #include "wptKeyEdit.h"  #include "wptTypes.h"
35    #include "wptKeylist.h"
36    #include "wptW32API.h"
37  static void  #include "wptVersion.h"
38  do_change_ownertrust (winpt_key_t k, const char *s)  #include "wptKeyEdit.h"
39  {  
40      char ot[64];  
41        /* Check that the key is not expired or revoked. */
42      if( strstr( s, "ultimate" ) ) {  static int
43          listview_get_item_text (k->callback.ctl, k->callback.idx, 5, ot, DIM (ot)-1);  do_check_key (gpgme_key_t key)
44          strcpy (ot, "Ultimate");  {
45          listview_add_sub_item (k->callback.ctl, k->callback.idx, 5, ot);      int invalid;
46          /* fixme: If we switch back from Ultimate to a lower level */  
47      }      invalid = key->expired;
48  } /* do_change_ownertrust */      if (!invalid)
49            invalid = key->revoked;
50        return invalid;
51  static int  }
52  do_check_key (gpgme_key_t key)  
53  {  
54      int okay = 0;  /* Convert a trust integer into a string representation. */
55      okay = key->expired;  static const char*
56      if (!okay)  ownertrust_to_string (int val, bool is_keypair)
57          okay = key->revoked;  {
58      return okay;      const char *inf;
59  } /* do_check_key */      int id = val;
60    
61        switch (id) {
62  static const char*      case 1: inf = _("Don't know");         break;
63  ownertrust_to_string (int val)      case 2: inf = _("I do NOT trust");     break;
64  {      case 3: inf = _("I trust marginally"); break;
65      const char * inf;      case 4: inf = _("I trust fully");      break;
66      int id = val;      case 5:
67      switch (id) {      case 6:
68      case 1: inf = _("Don't know");         break;          if (is_keypair)
69      case 2: inf = _("I do NOT trust");     break;              inf = _("I trust ultimately (implicit)");
70      case 3: inf = _("I trust marginally"); break;          else
71      case 4: inf = _("I trust fully");      break;              inf = _("I trust ultimately"); break;
72      case 5:      default:inf = _("Unknown");            break;
73      case 6: inf = _("I trust ultimately"); break;      }
74      default:inf = _("Unknown");            break;      
75      }      return inf;
76        }
77      return inf;  
78  } /* ownertrust_to_string */  
79    /* Generate a unique temp name for the photo which
80       depends on the dialog handle and return it. */
81  #define PHOTO_TMPNAME "winpt_temp_photo.jpg"  const char*
82    get_photo_tmpname (HWND dlg)
83  static int  {
84  keyprops_show_photo (HWND dlg, gpgme_key_t key)      static char buf[MAX_PATH+128+1];
85  {      char name[64];
86      RECT r;      
87      POINT p;      _snprintf (name, DIM (name)-1, "winpt_photo_%08lX.tmp", (DWORD)dlg);
88      HWND h;      get_temp_name (buf, DIM (buf)-1, name);
89      const BYTE *img;      return buf;
90      DWORD imglen = 0;  }
91      int pos=0;  
92      winpt_key_s k;  
93    static void
94      winpt_get_pubkey (key->subkeys->keyid, &k);  draw_nophoto_img (HWND dlg)
95      img = k.ext->attrib.d;  {
96      imglen = k.ext->attrib.len;      /*..
97        n = DrawText (hdc, "No Photo-ID", -1, &r, DT_LEFT);
98      if (!img || !imglen)      ..*/
99          return -1;  }
100      FILE *f = fopen (PHOTO_TMPNAME, "wb");  
101      if (f) {  
102          for (pos = 0; img[pos] != 0x10; pos++)  
103                  ;  /* Delete temporary photo file. */
104          pos += 16;  void
105          fwrite (img + pos, 1, imglen - pos, f);  key_unload_photo (HWND dlg)
106          fwrite (img, 1, imglen, f);  {
107          fclose (f);      DeleteFile (get_photo_tmpname (dlg));
108      }  }
109    
110      h = GetDlgItem (dlg, IDC_KEYPROPS_IMG);  
111      GetWindowRect (h, &r);  /* Load the photo from the key @key */
112      p.x = r.left + 5;  int
113      p.y = r.top - 2;  key_load_photo (HWND dlg, gpgme_key_t key, gpgme_validity_t *r_valid)
114      memset (&p, 0, sizeof (p));  {
115      PTD_jpg_show (h, &p, PHOTO_TMPNAME);      winpt_key_s k;
116      unlink (PHOTO_TMPNAME);      FILE *fp;
117        const BYTE *img;
118      return 0;      DWORD imglen;
119  }  
120        if (winpt_get_pubkey (key->subkeys->keyid, &k))
121            BUG (0);
122  /* Return string representation of the key validity. @key. */      img = k.ext->attrib.d;
123  static const char*      imglen = k.ext->attrib.len;
124  get_validity (gpgme_key_t key)      if (img && !k.ext->attrib.validity)
125  {          get_uat_validity (key->subkeys->keyid, &k.ext->attrib.validity);
126      int val;      if (r_valid)
127      val = key->expired;          *r_valid = k.ext->attrib.validity;
128      if (val)  
129          return "Expired";            if (!img || !imglen) {
130      val = key->revoked;          draw_nophoto_img (dlg);
131      if (val)          return -1;
132          return "Revoked";      }
133      return get_key_trust2 (NULL, key->uids->validity, 0, 0);  
134  }      fp = fopen (get_photo_tmpname (dlg), "wb");
135        if (fp) {
136            const int pos = 16;
137  /* Return the preferred sym. algorithm from @key as a string. */          fwrite (img + pos, 1, imglen - pos, fp);
138  static const char*          fclose (fp);
139  get_pref_cipher (winpt_key_t k)      }
140  {      return 0;
141      const char *sym_prefs=NULL;      }
142    
143      if (k->is_v3)  
144          return "IDEA";  /* Return string representation of the key validity. @key. */
145      if (!k->ext->sym_prefs)  static const char*
146          return "3DES";  get_validity (gpgme_key_t key)
147      switch (*k->ext->sym_prefs) {  {
148      case 1: return "IDEA";      if (key->expired)
149      case 2: return "3DES";          return _("Expired");    
150      case 3: return "CAST5";      if (key->revoked)
151      case 4: return "Blowfish";          return _("Revoked");
152      case 7:      if (key->disabled)
153      case 8:          return _("Disabled");
154      case 9: return "AES";      if (key->invalid)
155      case 10:return "Twofish";          return _("Invalid");
156      }      return get_key_trust2 (NULL, key->uids->validity, 0, 0);
157      return "Unknown";  }
158  }  
159    
160    /* Return the preferred sym. algorithm from @key as a string. */
161  /* Return true if the key has designated revokers. */  static const char*
162  static bool  get_pref_cipher (winpt_key_t k)
163  check_for_desig_rev (gpgme_key_t key)  {
164  {      if (k->is_v3)
165      winpt_key_s k;          return "IDEA";
166      memset (&k, 0, sizeof (k));      if (!k->ext || !k->ext->sym_prefs)
167      if (!winpt_get_pubkey (key->subkeys->keyid, &k))          return "3DES";
168          return k.ext->gloflags.has_desig_rev? true : false;      switch (*k->ext->sym_prefs) {
169      return false;      case 1: return "IDEA";
170  }      case 2: return "3DES";
171        case 3: return "CAST5";
172        case 4: return "Blowfish";
173  /* Print information (name) of the smart card. */      case 7: return "AES128";
174  static const char*      case 8: return "AES192";
175  get_card_type (winpt_key_t k)      case 9: return "AES256";
176  {      case 10:return "Twofish";
177      static char buf[64];      default:break;
178        }
179      if (!k->ext->card_type)      return "Unknown";
180          return "";  }
181      _snprintf (buf, sizeof (buf)-1, "Card-Type: %s\r\n", k->ext->card_type);  
182      return buf;  
183  }  /* Return true if the key has designated revokers. */
184    static bool
185    check_for_desig_rev (gpgme_key_t key)
186  /* Dialog box procedure to show the key properties. */  {
187  BOOL CALLBACK      winpt_key_s k;
188  keyprops_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)  
189  {      memset (&k, 0, sizeof (k));
190      static winpt_key_t k;      if (!winpt_get_pubkey (key->subkeys->keyid, &k))
191      static gpgme_key_t key, sk;          return k.ext->gloflags.has_desig_rev? true : false;
192      static int photo_done = 0;      return false;
193      struct winpt_key_s k2;  }
194      refresh_cache_s rcs = {0};  
195      const char *inf;  
196      char info[512];  /* Print information (name) of the smart card. */
197      u32 created, expires;  static const char*
198      int ot, cancel = 0;  get_card_type (winpt_key_t k)
199      int rc;  {    
200            static char buf[64];
201      switch (msg) {  
202      case WM_INITDIALOG:      if (!k->ext || !k->ext->card_type)
203          if (!lparam)          return "";
204              dlg_fatal_error (dlg, "Could not get dialog param!");      _snprintf (buf, DIM (buf)-1, _("Card-Type: %s\r\n"), k->ext->card_type);
205          k = (winpt_key_t)lparam;      return buf;
206          #ifndef LANG_DE  }
207          SetWindowText( dlg, _("Key Properties") );  
208          SetDlgItemText (dlg, IDC_KEYPROPS_OT_CHANGE, _("&Change"));  
209          SetDlgItemText (dlg, IDC_KEYPROPS_REVOKERS, _("&Revokers"));  /* Return 1 if at least one user-ID is valid. */
210          SetDlgItemText (dlg, IDC_KEYPROPS_CHANGE_PWD, _("Change &Passwd"));  static int
211          #endif    key_is_valid (gpgme_key_t key)
212    {
213          photo_done = 0;      gpgme_user_id_t u;
214          memset (&k2, 0, sizeof (k2));  
215          if (k->key_pair)      for (u=key->uids; u; u=u->next) {
216              winpt_get_seckey (k->keyid, &k2);          if (u->validity >= GPGME_VALIDITY_MARGINAL)
217          else              return 1;
218              winpt_get_pubkey (k->keyid, &k2);      }
219          sk = k2.ctx;      return 0;
220          if (sk)  }
221              k->is_protected = k2.is_protected;  
222          if (get_pubkey (k->keyid, &key))  
223              BUG (0);  /* Return extended algorithm information. */
224          created = key->subkeys->timestamp;  const char*
225          expires = key->subkeys->expires;  props_get_key_algo (gpgme_key_t key, int idx)
226          _snprintf (info, DIM (info)-1,  {
227                    "Type: %s\r\n"      /* PGP calls the old RSAv3 keys 'RSA Legacy' and because this
228                    "Key ID: %s\r\n"         is a good method to differ between OpenPGP v4 cert-only keys
229                    "Algorithm: %s\r\n"         and v3 RSA keys, we use the same notation. */
230                    "Size: %s\r\n"      if (key->subkeys != NULL && strlen (key->subkeys->fpr) == 32)
231                    "Created: %s\r\n"          return "RSA Legacy";
232                    "Expires: %s\r\n"      return get_key_algo (key, idx);
233                    "Validity: %s\r\n"  }
234                    "Cipher: %s\r\n"  
235                    "%s\r\n",  
236                    get_key_type (key),  /* Display the key information for key @k.
237                    k->keyid,     Return value: gpgme key on success. */
238                    get_key_algo (key, 0),  static void
239                    get_key_size (key, 0),  display_key_info (HWND dlg, winpt_key_t k)
240                    get_key_created (created),  {
241                    get_key_expire_date (expires),      gpgme_key_t key;
242                    get_validity (key),      struct winpt_key_s sk;
243                    get_pref_cipher (&k2),      char info[512];
244                    get_card_type (&k2));      const char *inf;
245          SetDlgItemText (dlg, IDC_KEYPROPS_INFO, info);      DWORD created, expires;
246          SetDlgItemText (dlg, IDC_KEYPROPS_FPR, get_key_fpr (key));  
247          ot = gpgme_key_get_ulong_attr( key, GPGME_ATTR_OTRUST, NULL, 0 );                    gpg_keycache_update_attr (k->ext, KC_ATTR_PREFSYM, 0);
248          inf = ownertrust_to_string (ot);      memset (&sk, 0, sizeof (sk));
249          SetDlgItemText( dlg, IDC_KEYPROPS_OT, inf );      if (k->key_pair && !winpt_get_seckey (k->keyid, &sk))
250          if (k->key_pair)          k->is_protected = sk.is_protected;
251              EnableWindow( GetDlgItem( dlg, IDC_KEYPROPS_CHANGE_PWD ), TRUE );      key = k->ext->key;
252          if (check_for_desig_rev (key))      created = key->subkeys->timestamp;
253              EnableWindow( GetDlgItem( dlg, IDC_KEYPROPS_REVOKERS ), TRUE );      expires = key->subkeys->expires;
254          center_window (dlg, NULL);      _snprintf (info, DIM (info)-1,
255          SetForegroundWindow (dlg);                       _("Type: %s\r\n"
256          return TRUE;                 "Key ID: 0x%s\r\n"
257                         "Algorithm: %s\r\n"
258      case WM_PAINT:                       "Size: %s bits\r\n"
259          if (photo_done == 0) {                 "Created: %s\r\n"
260              photo_done = 1;                 "Expires: %s\r\n"
261              keyprops_show_photo (dlg, key);                 "Validity: %s\r\n"
262          }                 "Cipher: %s\r\n"
263          break;                 "%s\r\n"),
264                   get_key_type (key),
265      case WM_SYSCOMMAND:                 k->keyid,
266          if( LOWORD( wparam ) == SC_CLOSE )                 props_get_key_algo (key, 0),
267              EndDialog( dlg, TRUE );                 get_key_size (key, 0),
268          return FALSE;                 get_key_created (created),
269                           get_key_expire_date (expires),
270      case WM_COMMAND:                 get_validity (key),
271          switch( LOWORD( wparam ) ) {                 get_pref_cipher (k),
272          case IDOK:                 get_card_type (&sk));
273              EndDialog( dlg, TRUE );  
274              return TRUE;      SetDlgItemText (dlg, IDC_KEYPROPS_INFO, info);
275                    SetDlgItemText (dlg, IDC_KEYPROPS_FPR, get_key_fpr (key));  
276          case IDC_KEYPROPS_OT_CHANGE:      inf = ownertrust_to_string (key->owner_trust, k->key_pair);
277              if( do_check_key( key ) ) {      SetDlgItemText (dlg, IDC_KEYPROPS_OT, inf);
278                  msg_box( dlg, _("The status of this key is 'revoked' or 'expired'.\n"  }
279                                  "You cannot change the ownertrust of such keys."),  
280                                  _("WinPT Warning"), MB_ERR );  
281                  return FALSE;  /* Context to store associated data of the dialog. */
282              }  struct prop_info_s {
283              if( !k->key_pair && key->uids->validity < 3 ) {      winpt_key_t key;
284                  rc = msg_box( dlg, _("This is a non-valid key.\n"  };
285                                       "Modifying the ownertrust has no effect on such keys.\n\n"  
286                                       "Do you really want to continue?"),  
287                                       _("WinPT Warning"), MB_ICONWARNING|MB_YESNO );  static void
288                  if (rc == IDNO)  on_init_dialog (HWND dlg, WPARAM wparam, LPARAM lparam)
289                      return FALSE;  {
290              }      gpgme_validity_t valid;
291              GetDlgItemText( dlg, IDC_KEYPROPS_OT, info, sizeof info -1 );  
292        winpt_key_t k = (winpt_key_t)lparam;
293                    assert (k != NULL);
294              dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_KEYEDIT_OWNERTRUST,      SetWindowText (dlg, _("Key Properties"));
295                                dlg, (DLGPROC)keyedit_ownertrust_dlg_proc,      SetDlgItemText (dlg, IDC_KEYPROPS_OT_CHANGE, _("&Change"));
296                                (LPARAM)k, _("Change Ownertrust"),      SetDlgItemText (dlg, IDC_KEYPROPS_REVOKERS, _("&Revokers"));
297                                IDS_WINPT_KEYEDIT_OWNERTRUST);      SetDlgItemText (dlg, IDC_KEYPROPS_CHANGE_PWD, _("Change &Password"));
298              if (k->callback.new_val == -1) { /* Cancel */      SetDlgItemText (dlg, IDC_KEYPROPS_OTINF, _("Ownertrust"));  
299                  EndDialog (dlg, FALSE);      
300                  break;      display_key_info (dlg, k);
301              }      if (!key_load_photo (dlg, k->ctx, &valid)) {
302            k->has_photo = 1;
303              inf = ownertrust_to_string (k->callback.new_val);          if (valid < GPGME_VALIDITY_MARGINAL)
304              do_change_ownertrust (k, inf);              SetDlgItemText (dlg, IDC_KEYPROPS_IMGINF, _("Photo-ID not validated."));
305              SetDlgItemText (dlg, IDC_KEYPROPS_OT, inf);      }
306              msg_box (dlg, _("Ownertrust successfully changed."), _("GnuPG Status"), MB_OK);      if (k->key_pair)
307                        EnableWindow (GetDlgItem (dlg, IDC_KEYPROPS_CHANGE_PWD), TRUE);
308              /* reload only the keylist */      if (check_for_desig_rev (k->ctx))
309              rcs.kr_reload = 1; rcs.kr_update = 1;          EnableWindow (GetDlgItem (dlg, IDC_KEYPROPS_REVOKERS), TRUE);
310              rcs.tr_update = 0;      if (do_check_key (k->ctx))
311              DialogBoxParam( glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, dlg,          EnableWindow (GetDlgItem (dlg, IDC_KEYPROPS_OT_CHANGE), FALSE);
312                              keycache_dlg_proc, (LPARAM)&rcs );      center_window (dlg, NULL);  
313              /* XXX: old code!?      SetForegroundWindow (dlg);
314              get_seckey (k->keyid, &sk);  }
315              if (get_pubkey (k->keyid, &key))  
316                  BUG (0);  
317              */  /* Dialog box procedure to show the key properties. */
318              return TRUE;  BOOL CALLBACK
319                keyprops_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
320          case IDC_KEYPROPS_CHANGE_PWD:  {
321              keyedit_change_passwd (k, dlg);              struct prop_info_s *prop = NULL;
322              return TRUE;      const char *inf;
323        int rc;
324          case IDC_KEYPROPS_REVOKERS:              
325              dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYREVOKERS, dlg,      if (msg != WM_INITDIALOG &&
326                                key_revokers_dlg_proc, (LPARAM)key, _("Key Revokers"),          (prop = (prop_info_s*)GetWindowLong (dlg, GWL_USERDATA)) == NULL)
327                                IDS_WINPT_KEY_REVOKERS);          return FALSE;
328              break;  
329          }      switch (msg) {
330      }      case WM_INITDIALOG:
331                assert (lparam != 0);
332      return FALSE;          prop = new struct prop_info_s;
333  }          prop->key = (winpt_key_t)lparam;
334            SetWindowLong (dlg, GWL_USERDATA, (LONG)prop);
335            on_init_dialog (dlg, wparam, lparam);
336            return TRUE;
337    
338        case WM_DESTROY:
339            key_unload_photo (dlg);
340            delete prop;prop = NULL;
341            SetWindowLong (dlg, GWL_USERDATA, 0);
342            break;
343          
344        case WM_PAINT:
345            /* Display the photo in the frame of the dialog @dlg.
346               The coordinates are fixed to (0,0). */
347            if (prop->key->has_photo) {
348                POINT p;
349                p.x = p.y = 0;
350                PTD_jpg_show (GetDlgItem (dlg, IDC_KEYPROPS_IMG),
351                              &p, get_photo_tmpname (dlg));
352            }
353            break;
354    
355        case WM_COMMAND:
356            switch (LOWORD (wparam)) {
357            case IDOK:
358                EndDialog (dlg, TRUE);
359                return TRUE;
360    
361            case IDCANCEL:
362                EndDialog (dlg, FALSE);
363                return TRUE;
364                
365            case IDC_KEYPROPS_OT_CHANGE:
366                if (!prop->key->key_pair && !key_is_valid (prop->key->ctx)) {
367                    rc = msg_box (dlg, _("This is a non-valid key.\n"
368                                         "Modifying the ownertrust has no effect on such keys.\n\n"
369                                         "Do you really want to continue?"),
370                                         _("WinPT Warning"), MB_ICONWARNING|MB_YESNO);
371                    if (rc == IDNO)
372                        return TRUE;
373                }
374                rc = dialog_box_param (glob_hinst,
375                                       (LPCSTR)IDD_WINPT_KEYEDIT_OWNERTRUST,
376                                        dlg, keyedit_ownertrust_dlg_proc,
377                                       (LPARAM)prop->key, _("Change Ownertrust"),
378                                        IDS_WINPT_KEYEDIT_OWNERTRUST);
379                if (rc == FALSE) /* Cancel */
380                    return TRUE;
381    
382                inf = ownertrust_to_string (prop->key->callback.new_val,
383                                            prop->key->key_pair);
384                SetDlgItemText (dlg, IDC_KEYPROPS_OT, inf);
385                msg_box (dlg, _("Ownertrust successfully changed."),
386                         _("GnuPG Status"), MB_OK);
387                prop->key->update = 1;
388                return TRUE;
389                
390            case IDC_KEYPROPS_CHANGE_PWD:
391                keyedit_change_passwd (prop->key, dlg);        
392                return TRUE;
393    
394            case IDC_KEYPROPS_REVOKERS:
395                prop->key->update = dialog_box_param (glob_hinst,
396                                              (LPCTSTR)IDD_WINPT_KEYREVOKERS, dlg,
397                                              key_revokers_dlg_proc, (LPARAM)prop->key,
398                                              _("Key Revokers"),
399                                              IDS_WINPT_KEY_REVOKERS);
400                UpdateWindow (dlg);
401                break;
402            }
403        }
404        
405        return FALSE;
406    }
Legend:
Removed from v.28  
changed lines
  Added in v.310
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26