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