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

Diff of /trunk/Src/wptKeyserverDlg.cpp

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

revision 22 by twoaday, Wed Aug 10 11:33:35 2005 UTC revision 118 by twoaday, Thu Dec 8 13:21:52 2005 UTC
# Line 1  Line 1 
1  /* wptKeyserverDlg.cpp - Keyserver dialog  /* wptKeyserverDlg.cpp - Keyserver dialog
2   *      Copyright (C) 2000-2005 Timo Schulz   *      Copyright (C) 2000-2005 Timo Schulz
3   *   *      Copyright (C) 2005 g10 Code GmbH
4   * This file is part of WinPT.   *
5   *   * This file is part of WinPT.
6   * 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   * WinPT is free software; you can redistribute it and/or modify
8   * the Free Software Foundation; either version 2 of the License, or   * it under the terms of the GNU General Public License as published by
9   * (at your option) any later version.   * the Free Software Foundation; either version 2 of the License, or
10   *   * (at your option) any later version.
11   * WinPT is distributed in the hope that it will be useful,   *
12   * but WITHOUT ANY WARRANTY; without even the implied warranty of   * WinPT is distributed in the hope that it will be useful,
13   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the   * but WITHOUT ANY WARRANTY; without even the implied warranty of
14   * GNU General Public License for more details.   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   *   * GNU General Public License for more details.
16   * You should have received a copy of the GNU General Public License   *
17   * along with WinPT; if not, write to the Free Software Foundation,   * You should have received a copy of the GNU General Public License
18   * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA   * along with WinPT; if not, write to the Free Software Foundation,
19   */   * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20     */
21  #include <windows.h>  #ifdef HAVE_CONFIG_H
22  #include <commctrl.h>  #include <config.h>
23  #include <malloc.h>  #endif
24    
25  #include "../resource.h"  #include <windows.h>
26  #include "wptKeyserver.h"  #include <commctrl.h>
27  #include "wptErrors.h"  #include <malloc.h>
28  #include "wptTypes.h"  
29  #include "wptCommonCtl.h"  #include "resource.h"
30  #include "wptNLS.h"  #include "wptKeyserver.h"
31  #include "wptW32API.h"  #include "wptErrors.h"
32  #include "wptVersion.h"  #include "wptTypes.h"
33  #include "wptGPG.h"  #include "wptCommonCtl.h"
34  #include "wptKeyManager.h"  #include "wptNLS.h"
35  #include "wptContext.h" /* for passphrase_s */  #include "wptW32API.h"
36  #include "wptDlgs.h"  #include "wptVersion.h"
37    #include "wptGPG.h"
38    #include "wptKeyManager.h"
39  #define MAX_KEYSIZE 70000  #include "wptContext.h" /* for passphrase_s */
40    #include "wptDlgs.h"
41  char * get_reg_entry_keyserver (const char *);  
42  int set_reg_entry_keyserver (const char *, const char *);  
43    #define MAX_KEYSIZE 70000
44    
45  static void  char* get_reg_entry_keyserver (const char *);
46  hkp_err_box (HWND dlg, const char * host, u16 port, int rc)  int set_reg_entry_keyserver (const char *, const char *);
47  {  
48      const char *err = kserver_strerror();  
49    /* Print out keyserver error and a possible Winsock error. */
50      log_box( _("Keyserver"), MB_ERR, "%s:%d: %s", host, port, winpt_strerror (rc));  static void
51      if (err)  hkp_err_box (HWND dlg, const char *host, WORD port, int rc)
52          msg_box (dlg, err, wsock_strerror (), MB_ERR);  {
53  } /* hkp_err_box */      const char *err = kserver_strerror ();
54    
55        log_box (_("Keyserver"), MB_ERR, "%s:%d: %s",
56  int               host, port, winpt_strerror (rc));
57  hkp_send_key (HWND dlg, const char *kserver, u16 port, const char *pattern)      if (err)
58  {          msg_box (dlg, err, wsock_strerror (), MB_ERR);
59      gpgme_ctx_t c;        }
60      gpgme_recipients_t rset;  
61      gpgme_data_t keydata;  
62      gpgme_error_t ec;  /* Send the extracted key with keyid @pattern to the
63      char *rawkey = NULL, msg[1024];     keyserver @kserver (port @port).
64      int rc;     Return value: 0 on success. */
65        int
66      ec = gpgme_recipients_new( &rset );  hkp_send_key (HWND dlg, const char *kserver, WORD port, const char *pattern)
67      if( ec )  {
68          BUG( NULL );      gpgme_ctx_t ctx;
69      gpgme_recipients_add_name( rset, pattern );      gpgme_data_t keydata;
70      ec = gpgme_new( &c );      gpgme_error_t ec;
71      if( ec )      char *rawkey = NULL;
72          BUG( NULL );      char msg[384];
73      gpgme_control( c, GPGME_CTRL_ARMOR, 1 );      size_t n;
74      ec = gpgme_data_new( &keydata );      
75      if( ec )      ec = gpgme_new (&ctx);
76          BUG( NULL );      if (ec)
77      rc = (int) gpgme_op_export( c, rset, keydata );          BUG (NULL);
78      if( rc ) {      gpgme_set_armor (ctx, 1);
79          msg_box( dlg, gpgme_strerror( (gpgme_error_t)rc ), _("Export"), MB_ERR );      ec = gpgme_data_new (&keydata);
80          goto leave;      if (ec)
81      }          BUG (NULL);
82      rawkey = gpgme_data_release_and_return_string (keydata);      ec = gpgme_op_export (ctx, pattern, 0, keydata);
83      rc = kserver_sendkey (kserver, port, rawkey, strlen (rawkey));      if (ec) {
84      if (rc) {          msg_box (dlg, gpgme_strerror (ec), _("Export"), MB_ERR);
85          hkp_err_box (dlg, kserver, port, rc);          goto leave;
86          goto leave;      }
87      }      rawkey = gpgme_data_release_and_get_mem (keydata, &n);
88            ec = kserver_sendkey (kserver, port, rawkey, n);
89      _snprintf (msg, sizeof (msg) -1, _("Key '%s' successfully sent"), pattern);      if (ec) {
90      status_box (dlg, msg, _("GnuPG status"));          hkp_err_box (dlg, kserver, port, ec);
91                goto leave;
92  leave:      }
93      gpgme_release (c);      
94      gpgme_recipients_release (rset);      _snprintf (msg, sizeof (msg) -1, _("Key '%s' successfully sent"), pattern);
95      safe_free (rawkey);      status_box (dlg, msg, _("GnuPG status"));
96      return rc;      
97  } /* hkp_send_key */  leave:
98        gpgme_release (ctx);
99        if (rawkey)
100  int          gpgme_free (rawkey);
101  hkp_recv_key (HWND dlg, const char *kserver, u16 port,      return ec? -1 : 0;
102                const char *pattern, int proto, int flags)  }
103  {  
104      gpgme_ctx_t ctx;  
105      gpgme_data_t keydata;  
106      gpgme_error_t ec;  /* Show all received keys from the keyserver. */
107      int rc, import_res[14];  static void
108      char *rawkey = NULL, msg[384];  show_imported_keys (gpgme_import_result_t res)
109        {
110      rawkey = new char[MAX_KEYSIZE];      gpgme_import_status_t t;
111      if (!rawkey)      gpgme_key_t key;
112          BUG (0);      gpgme_data_t msg;
113      memset (rawkey, 0, MAX_KEYSIZE);      gpgme_ctx_t ctx;
114      if( proto == KSPROTO_LDAP ) {      gpgme_error_t err;
115          rc = ldap_recvkey( kserver, pattern, rawkey, MAX_KEYSIZE-1 );      const char *s;
116          if( rc ) {      char *p;
117              msg_box( dlg, _("LDAP key import failed.\n"      size_t n=0;
118                              "Please make sure you have an online connection"  
119                              " and gpgkeys_ldap.exe is installed"),      if (!res)
120                              _("Keyserver"), MB_ERR );          return;
121              free_if_alloc( rawkey );  
122              return rc;      err = gpgme_data_new (&msg);
123          }      if (err)
124      }          BUG (NULL);
125      else if (proto == KSPROTO_FINGER) {      err = gpgme_new (&ctx);
126          rc = finger_recvkey (kserver, pattern, rawkey, MAX_KEYSIZE-1);      if (err)
127          if (rc) {          BUG (NULL);
128              log_box (_("Keyserver"), MB_ERR, _("Finger key import failed: %s\n"),      if (res->considered > 1) {
129                       winpt_strerror (rc));          s = _("WARNING: multiple keys matched request.\n\n");
130              free_if_alloc (rawkey);          gpgme_data_write (msg, s, strlen (s));
131              return rc;      }
132          }  
133      }      if (res->unchanged == res->considered)
134      else if( ( rc = kserver_recvkey( kserver, port, kserver_check_keyid( pattern ),          s = _("Key(s) successfully received but nothing was changed.");
135                                       rawkey, MAX_KEYSIZE-1 ) ) ) {      else
136          hkp_err_box (dlg, kserver, port, rc);          s = _("Key(s) sucessfully received and imported.");
137          free_if_alloc (rawkey);      gpgme_data_write (msg, s, strlen (s));
138          return rc;      gpgme_data_write (msg, "\n\n", 2);
139      }  
140      else {      for (t=res->imports; t; t = t->next) {
141          if( !strstr( rawkey, "BEGIN PGP PUBLIC KEY BLOCK" ) ) {          if (!gpgme_get_key (ctx, t->fpr, &key, 0)) {
142              msg_box( dlg, _("This is not a valid OpenPGP key."), _("Keyserver"), MB_ERR );              s = key->uids->uid;
143              goto leave;              gpgme_data_write (msg, s, strlen (s));
144          }              gpgme_data_write (msg, "\n", 1);
145          ec = gpgme_new( &ctx );              gpgme_key_release (key);
146          if( ec )          }
147              BUG( NULL );      }
148          gpgme_data_new_from_mem( &keydata, rawkey, strlen( rawkey ), 1 );      gpgme_data_write (msg, "\0", 1);
149          rc = gpgme_op_import( ctx, NULL, keydata );      p = gpgme_data_release_and_get_mem (msg, &n);
150          if( rc ) {      if (p != NULL) {
151              msg_box( dlg, gpgme_strerror( (gpgme_error_t)rc ), _("Import"), MB_ERR );          msg_box (NULL, p, _("Imported Keys"), MB_INFO);
152              goto leave;          gpgme_free (p);
153          }      }
154          gpgme_get_import_status (ctx, import_res, NULL);      gpgme_release (ctx);
155      }  }
156        
157      /* if we use the refresh mode, a lot of keys will be fetched and thus only  
158         a summarize at the end is presented and not for each key. */  /* Receive a key from the keyserver @kserver (port @port)
159      if (!(flags & KM_KS_REFRESH)) {     with the pattern @pattern.
160          if (import_res[GPGME_IMPSTAT_NPKEYS] == 0) {     Return value: 0 on success. */
161              _snprintf (msg, DIM (msg)-1,  int
162                         _("Key '%s' successfully received but nothing was changed."), pattern );  hkp_recv_key2 (HWND dlg, const char *kserver, WORD port,
163              status_box (dlg, msg, _("GnuPG Status"));                 const char *pattern, int proto, int flags,
164              rc = WPTERR_GENERAL;                 char **r_fpr)
165              goto leave;  {
166          }      gpgme_ctx_t ctx;
167          _snprintf (msg, DIM (msg)-1, _("Key '%s' sucessfully received and imported."), pattern);      gpgme_data_t keydata;
168          status_box (dlg, msg, _("GnuPG Status"));      gpgme_error_t ec;
169      }      gpgme_import_result_t import_res = NULL;    
170            char *rawkey = NULL;
171  leave:      int rc;
172      free_if_alloc (rawkey);      
173      gpgme_release (ctx);      /* XXX: implement dynamic buffers. */
174      gpgme_data_release (keydata);      rawkey = new char[MAX_KEYSIZE];
175        if (!rawkey)
176      return rc;          BUG (0);
177  } /* hkp_recv_key */      memset (rawkey, 0, MAX_KEYSIZE);
178        if (proto == KSPROTO_LDAP) {
179            rc = ldap_recvkey (kserver, pattern, rawkey, MAX_KEYSIZE-1);
180  #define my_iskeychar(a) ( ( (a) >='0' && (a) <= '9' ) || ( (a) >= 'A' && (a) <= 'F' ) )          if (rc) {
181                msg_box (dlg, _("LDAP key import failed.\n"
182  static int                              "Please make sure you have an online connection"
183  check_pattern( const char *pattern )                              " and gpgkeys_ldap.exe is installed"),
184  {                              _("Keyserver"), MB_ERR);
185      int rc = 1;              free_if_alloc (rawkey);
186                    return rc;
187      /* Whitespace are not allowed! */          }
188      if( strchr( pattern, ' ') ) {      }
189          rc = WPTERR_GENERAL;      else if (proto == KSPROTO_FINGER) {
190          goto leave;          rc = finger_recvkey (kserver, pattern, rawkey, MAX_KEYSIZE-1);
191      }          if (rc) {
192                    log_box (_("Keyserver"), MB_ERR,
193      if( (( strstr( pattern, "0x" ) ) && ( strlen( pattern ) == 10 ) )                       _("Finger key import failed: %s\n"), winpt_strerror (rc));
194           || (strstr(pattern, "0x")) && ( strlen( pattern )  == 18 ) ) {              free_if_alloc (rawkey);
195          rc = 0;              return rc;
196          goto leave;          }
197      }      }
198            else if ((rc = kserver_recvkey (kserver, port,
199      if( (( my_iskeychar( pattern[0] )) && ( strlen( pattern )  == 8 ) )                                      kserver_check_keyid (pattern),
200           || (my_iskeychar(pattern[0])) && ( strlen( pattern ) == 16) ) {                                      rawkey, MAX_KEYSIZE-1))) {
201          rc = 0;          hkp_err_box (dlg, kserver, port, rc);
202          goto leave;          free_if_alloc (rawkey);
203      }          return rc;
204            }
205      if( ( strchr( pattern, '@' ) ) && ( strlen( pattern ) >= 3 ) ) {      else {
206          rc = 0;          if (!strstr (rawkey, "BEGIN PGP PUBLIC KEY BLOCK")) {
207          goto leave;              msg_box (dlg, _("This is not a valid OpenPGP key."),
208      }                       _("Keyserver"), MB_ERR);
209                    goto leave;
210  leave:          }
211      return rc;          ec = gpgme_new (&ctx);
212  } /* check_pattern */          if (ec)
213                BUG (NULL);
214            gpgme_data_new_from_mem (&keydata, rawkey, strlen (rawkey), 1);
215  static void          rc = gpgme_op_import (ctx, keydata);
216  set_proxy (HWND dlg)          if (rc) {
217  {              msg_box (dlg, gpgme_strerror ((gpgme_error_t)rc), _("Import"), MB_ERR);
218      char proxy[384];              goto leave;
219      int port = 0;          }
220                import_res = gpgme_op_import_result (ctx);
221      strcpy (proxy, "HTTP proxy: ");          if (import_res && r_fpr)
222      if (kserver_get_proxy (&port)) {              *r_fpr = m_strdup (import_res->imports->fpr);
223          char t[256];      }
224          const char *http = kserver_get_proxy (&port);      
225          _snprintf (t, sizeof (t) - 1, "\"%s:%d\"", http, port);      /* if we use the refresh mode, a lot of keys will be fetched and thus only
226          strcat (proxy, t);         a summarize at the end is presented and not for each key. */
227      }      if (!(flags & KM_KS_REFRESH)) {
228      else          show_imported_keys (import_res);
229          strcat( proxy, "none" );          if (import_res && import_res->unchanged == import_res->considered) {
230      SetDlgItemText( dlg, IDC_KEYSERVER_PROXY, proxy );              rc = WPTERR_GENERAL; /* no keys updated. */
231  } /* set_proxy */              goto leave;
232            }
233        }
234  static int inline  
235  kserver_get_pos (listview_ctrl_t lv)  leave:
236  {      free_if_alloc (rawkey);
237      if (listview_count_items (lv, 0) == 1)      gpgme_release (ctx);
238          return 0;      gpgme_data_release (keydata);
239      return listview_get_curr_pos (lv);  
240  }      return rc;
241    }
242    
243  static u16 inline  
244  kserver_get_port (listview_ctrl_t lv)  /* Alias for hkp_recv_key2 but without the ability to return
245  {     the fingerprint of the key. */
246      char buf[16];  int
247    hkp_recv_key (HWND dlg, const char *kserver, WORD port,
248      listview_get_item_text (lv, kserver_get_pos (lv), 3, buf, 15);                const char *pattern, int proto, int flags)
249      return (u16)strtoul (buf, NULL, 10);  {
250  }      return hkp_recv_key2 (dlg, kserver, port, pattern, proto, flags, NULL);
251    }
252  static void  
253  load_default_ks (listview_ctrl_t lv)  
254  {  #define my_iskeychar(a) (((a) >='0' && (a) <= '9' ) || ((a) >= 'A' && (a) <= 'F'))
255      char * p, buf[192];  
256      int i;  static int
257    check_pattern (const char *pattern)
258      p = get_reg_entry_keyserver ("Default");  {
259      if (!p)      int rc = 1;
260          return;      
261      for( i = 0; i < listview_count_items( lv, 0 ); i++ ) {      /* Whitespace are not allowed! */
262          listview_get_item_text( lv, i, 0, buf, sizeof (buf)-1 );      if (strchr( pattern, ' ')) {
263          if( !strncmp( p, buf, strlen( p ) ) ) {          rc = WPTERR_GENERAL;
264              listview_add_sub_item( lv, i, 2, "x" );          goto leave;
265              break;      }
266          }      
267      }      if (((strstr (pattern, "0x")) && (strlen (pattern) == 10)) ||
268      free_if_alloc (p);           (strstr(pattern, "0x")) && (strlen (pattern)  == 18)) {
269  } /* load_default_ks */          rc = 0; /* Either long or short keyid */
270            goto leave;
271        }
272  static int      
273  save_default_ks (listview_ctrl_t lv)      if( (( my_iskeychar( pattern[0] )) && ( strlen( pattern )  == 8 ) )
274  {           || (my_iskeychar(pattern[0])) && ( strlen( pattern ) == 16) ) {
275      char buf[192], port[32];          rc = 0;
276      int idx, i;            goto leave;
277        }
278      idx = listview_get_curr_pos( lv );      
279      if( idx == -1 ) {      if( ( strchr( pattern, '@' ) ) && ( strlen( pattern ) >= 3 ) ) {
280          msg_box( NULL, _("Please select one of the servers."), _("Keyserver"), MB_ERR );          rc = 0;
281          return -1;          goto leave;
282      }      }
283      listview_get_item_text( lv, idx, 1, buf, sizeof (buf)-1 );      
284      if( *buf != 'H' ) {  leave:
285          msg_box( NULL, _("Only HTTP keyserver can be used."), _("Keyserver"), MB_ERR );      return rc;
286          return -1;  } /* check_pattern */
287      }  
288      for (i = 0; i < listview_count_items( lv, 0 ); i++)  
289          listview_add_sub_item (lv, i, 2, "");  static void
290      listview_add_sub_item (lv, idx, 2, "x");  set_proxy (HWND dlg)
291      listview_get_item_text (lv, idx, 0, buf, sizeof (buf)-1);  {
292      set_reg_entry_keyserver ("Default", buf);      char proxy[256];
293      i = kserver_get_port (lv);      int port = 0;
294      sprintf (port, "%d", i);      
295      set_reg_entry_keyserver ("Default_Port", port);      strcpy (proxy, "HTTP proxy: ");
296      keyserver_set_default (buf, (u16)i);      if (kserver_get_proxy (&port)) {
297      return 0;          char t[128];
298  } /* save_default_ks */          const char *http = kserver_get_proxy (&port);
299            _snprintf (t, sizeof (t) - 1, "\"%s:%d\"", http, port);
300            strcat (proxy, t);
301  int      }
302  keyserver_list_build (listview_ctrl_t *r_lv, HWND hwnd)      else
303  {          strcat (proxy, "none");
304      struct listview_column_s keyserver[] = {      SetDlgItemText (dlg, IDC_KEYSERVER_PROXY, proxy);
305          {0, 160, (char *)_("DNS Name")},          } /* set_proxy */
306          {1,  52, (char *)_("Protocol")},  
307          {2,  46, (char *)_("Default")},  
308          {3,  46, (char *)_("Port")},  static int inline
309          {0,   0, NULL}  kserver_get_pos (listview_ctrl_t lv)
310      };  {
311      listview_ctrl_t lv;      if (listview_count_items (lv, 0) == 1)
312      char buf[32];          return 0;
313      int j;      return listview_get_curr_pos (lv);
314    }
315      listview_new (&lv);      
316      lv->ctrl = hwnd;        
317      for (j=0; keyserver[j].fieldname; j++)  static u16 inline
318          listview_add_column (lv, &keyserver[j]);          kserver_get_port (listview_ctrl_t lv)
319      for (j = 0; j<MAX_KEYSERVERS; j++) {  {
320          if (!server[j].used)      char buf[16];
321              continue;  
322          listview_add_item (lv, " ");      listview_get_item_text (lv, kserver_get_pos (lv), 3, buf, 15);
323          listview_add_sub_item (lv, 0, 0, server[j].name);      return (u16)strtoul (buf, NULL, 10);
324          switch (server[j].proto) {  }
325          case KSPROTO_HTTP:  
326              listview_add_sub_item( lv, 0, 1, "H" ); break;  static void
327          case KSPROTO_LDAP:  load_default_ks (listview_ctrl_t lv)
328              listview_add_sub_item( lv, 0, 1, "L" ); break;  {
329          case KSPROTO_FINGER:      char * p, buf[192];
330              listview_add_sub_item( lv, 0, 1, "F" ); break;      int i;
331          }  
332          sprintf (buf, "%d", server[j].port);      p = get_reg_entry_keyserver ("Default");
333          listview_add_sub_item (lv, 0, 3, buf);      if (!p)
334      }          return;
335      load_default_ks (lv);      for( i = 0; i < listview_count_items( lv, 0 ); i++ ) {
336      if (listview_count_items (lv, 0) == 0) {          listview_get_item_text( lv, i, 0, buf, sizeof (buf)-1 );
337          listview_add_item (lv, "");          if( !strncmp( p, buf, strlen( p ) ) ) {
338          listview_add_sub_item (lv, 0, 0, DEF_HKP_KEYSERVER);              listview_add_sub_item( lv, i, 2, "x" );
339          listview_add_sub_item (lv, 0, 1, "H");              break;
340      }          }
341      listview_set_ext_style (lv);      }
342      *r_lv = lv;      free_if_alloc (p);
343      return 0;  } /* load_default_ks */
344  }  
345    
346    static int
347  BOOL CALLBACK  save_default_ks (listview_ctrl_t lv)
348  keyserver_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)  {
349  {      char buf[192], port[32];
350      static listview_ctrl_t lv = NULL;      int idx, i;  
351      static int lv_idx = 0;  
352      int rc, proto_nr = 0;      idx = listview_get_curr_pos( lv );
353      char kserver[128], pattern[128];      if( idx == -1 ) {
354      char proto[16];              msg_box( NULL, _("Please select one of the servers."), _("Keyserver"), MB_ERR );
355      keyserver_ctx ksc;          return -1;
356            }
357      switch ( msg ) {      listview_get_item_text( lv, idx, 1, buf, sizeof (buf)-1 );
358      case WM_INITDIALOG:      if( *buf != 'H' ) {
359  #ifndef LANG_DE          msg_box( NULL, _("Only HTTP keyserver can be used."), _("Keyserver"), MB_ERR );
360          SetWindowText( dlg, _("Keyserver Access") );          return -1;
361          SetDlgItemText( dlg, IDC_KEYSERVER_SEND,      }
362                          _("Send key (default is receiving)") );      for (i = 0; i < listview_count_items( lv, 0 ); i++)
363          SetDlgItemText( dlg, IDC_KEYSERVER_INFO,          listview_add_sub_item (lv, i, 2, "");
364                          _("Please enter the key ID or email address you search for"));      listview_add_sub_item (lv, idx, 2, "x");
365          SetDlgItemText( dlg, IDC_KEYSERVER_INDEX, _("&Search") );      listview_get_item_text (lv, idx, 0, buf, sizeof (buf)-1);
366  #endif      set_reg_entry_keyserver ("Default", buf);
367          set_proxy (dlg);      i = kserver_get_port (lv);
368          keyserver_list_build (&lv, GetDlgItem (dlg, IDC_KEYSERVER_LIST));      sprintf (port, "%d", i);
369          center_window (dlg);      set_reg_entry_keyserver ("Default_Port", port);
370          SetForegroundWindow (dlg);      keyserver_set_default (buf, (u16)i);
371          return TRUE;      return 0;
372            } /* save_default_ks */
373      case WM_NOTIFY:  
374          NMHDR *notify;  
375          notify = (NMHDR *)lparam;  int
376          if( notify && notify->code == NM_CLICK  keyserver_list_build (listview_ctrl_t *r_lv, HWND hwnd)
377              && notify->idFrom == IDC_KEYSERVER_LIST )  {
378              lv_idx = listview_get_curr_pos( lv );      struct listview_column_s keyserver[] = {
379          return TRUE;          {0, 160, (char *)_("DNS Name")},        
380                    {1,  52, (char *)_("Protocol")},
381      case WM_DESTROY:          {2,  46, (char *)_("Default")},
382          if( lv ) {          {3,  46, (char *)_("Port")},
383              listview_release( lv );          {0,   0, NULL}
384              lv = NULL;      };
385          }      listview_ctrl_t lv;
386          lv_idx = 0;      char buf[32];
387          return FALSE;      int j;
388            
389      case WM_SYSCOMMAND:      listview_new (&lv);    
390          if( LOWORD( wparam ) == SC_CLOSE )      lv->ctrl = hwnd;      
391              EndDialog( dlg, TRUE );      for (j=0; keyserver[j].fieldname; j++)
392          return FALSE;          listview_add_column (lv, &keyserver[j]);        
393                for (j = 0; j<MAX_KEYSERVERS; j++) {
394      case WM_COMMAND:          if (!server[j].used)
395          switch( LOWORD( wparam ) ) {              continue;
396          case IDC_KEYSERVER_PROXSETT:          listview_add_item (lv, " ");
397              dialog_box_param( glob_hinst, (LPCTSTR)IDD_WINPT_KEYSERVER_PROXY, glob_hwnd,          listview_add_sub_item (lv, 0, 0, server[j].name);
398                                keyserver_proxy_dlg_proc, NULL,          switch (server[j].proto) {
399                                _("Proxy Settings"), IDS_WINPT_KEYSERVER_PROXY );          case KSPROTO_HTTP:
400              set_proxy( dlg );              listview_add_sub_item( lv, 0, 1, "H" ); break;
401              return TRUE;          case KSPROTO_LDAP:
402                            listview_add_sub_item( lv, 0, 1, "L" ); break;
403          case IDC_KEYSERVER_INDEX:          case KSPROTO_FINGER:
404              if (!lv_idx) {              listview_add_sub_item( lv, 0, 1, "F" ); break;
405                  lv_idx = kserver_get_pos (lv);          }
406                  if (lv_idx == -1) {          sprintf (buf, "%d", server[j].port);
407                      msg_box (dlg, _("Please select one of the keyservers."), _("Keyserver"), MB_INFO);          listview_add_sub_item (lv, 0, 3, buf);
408                      return FALSE;      }
409                  }      load_default_ks (lv);
410              }      if (listview_count_items (lv, 0) == 0) {
411              listview_get_item_text (lv, lv_idx, 1, proto, sizeof (proto)-1);          listview_add_item (lv, "");
412              if (*proto == 'L') {          listview_add_sub_item (lv, 0, 0, DEF_HKP_KEYSERVER);
413                  msg_box( dlg, _("This is not implemented yet!"), _("Keyserver"), MB_ERR );          listview_add_sub_item (lv, 0, 1, "H");
414                  return FALSE;      }
415              }      listview_set_ext_style (lv);
416              listview_get_item_text (lv, lv_idx, 0, kserver, sizeof (kserver)-1);      *r_lv = lv;
417              if (!GetDlgItemText (dlg, IDC_KEYSERVER_SEARCH, pattern, sizeof (pattern)-1)) {      return 0;
418                  msg_box (dlg, _("Please enter the search pattern."), _("Keyserver"), MB_INFO);  }
419                  return FALSE;  
420              }  
421              ksc.name = kserver;  /* Dialog box procedure to access keyservers. */
422              ksc.pattern = pattern;  BOOL CALLBACK
423              ksc.port = kserver_get_port (lv);  keyserver_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
424              DialogBoxParam( glob_hinst, (LPCSTR)IDD_WINPT_HKPSEARCH, dlg,  {
425                              hkpsearch_dlg_proc, (LPARAM) &ksc );      static listview_ctrl_t lv = NULL;
426              return TRUE;      static int lv_idx = 0;
427                    static struct genkey_s *key;
428          case IDC_KEYSERVER_RECV:      keyserver_ctx ksc;
429              memset (&kserver, 0, sizeof (kserver));      char kserver[128], pattern[128];
430              if (!lv_idx) {      char proto[16];
431                  lv_idx = kserver_get_pos (lv);      int rc, proto_nr = 0;
432                  if (lv_idx == -1) {      
433                      msg_box( dlg, _("Please select one of the keyservers."), _("Keyserver"), MB_INFO );      switch (msg) {
434                      return FALSE;      case WM_INITDIALOG:
435                  }          if (lparam != 0)
436              }              key = (struct genkey_s*)lparam;
437              listview_get_item_text( lv, lv_idx, 1, proto, sizeof (proto)-1 );          SetWindowText (dlg, _("Keyserver Access"));
438              proto_nr = KSPROTO_HTTP;          SetDlgItemText (dlg, IDC_KEYSERVER_RECV, _("&Receive"));
439              if( *proto == 'L' )          SetDlgItemText (dlg, IDC_KEYSERVER_SEND,
440                  proto_nr = KSPROTO_LDAP;                          _("Send key (default is receiving)"));
441              else if( *proto == 'F' )          SetDlgItemText (dlg, IDC_KEYSERVER_INFO,
442                  proto_nr = KSPROTO_FINGER;                          _("Please enter the key ID or email address you search for"));
443              listview_get_item_text( lv, lv_idx, 0, kserver, sizeof (kserver)-1 );          SetDlgItemText (dlg, IDC_KEYSERVER_INDEX, _("&Search"));
444              if( !GetDlgItemText( dlg, IDC_KEYSERVER_SEARCH, pattern, sizeof (pattern)-1 ) ) {          SetDlgItemText (dlg, IDC_KEYSERVER_PROXSETT, _("C&hange"));
445                  msg_box( dlg, _("Please enter the search pattern."), _("Keyserver"), MB_INFO );          SetDlgItemText (dlg, IDC_KEYSERVER_DEFAULT, _("Set &default"));
446                  return FALSE;          SetDlgItemText (dlg, IDCANCEL, _("&Close"));
447              }  
448              if( proto_nr == KSPROTO_LDAP && strchr( pattern, '@' ) ) {          set_proxy (dlg);
449                  msg_box( dlg, _("Only keyids are allowed."), _("LDAP Keyserver"), MB_INFO );          keyserver_list_build (&lv, GetDlgItem (dlg, IDC_KEYSERVER_LIST));
450                  return FALSE;          center_window (dlg, NULL);
451              }          SetForegroundWindow (dlg);
452              else if (proto_nr == KSPROTO_FINGER) {          return TRUE;
453                  if (strchr (pattern, '@') || strchr (pattern, ' ')) {          
454                      msg_box (dlg, _("Only enter the name of the user."), _("FINGER Keyserver"), MB_INFO);      case WM_NOTIFY:
455                      return FALSE;          NMHDR *notify;
456                  }          notify = (NMHDR *)lparam;
457              }          if (notify && notify->code == NM_CLICK
458              else if( check_pattern( pattern ) ) {              && notify->idFrom == IDC_KEYSERVER_LIST)
459                  msg_box( dlg, _("Only email addresses or keyids are allowed."), _("HKP Keyserver"), MB_INFO );              lv_idx = listview_get_curr_pos (lv);
460                  return FALSE;          return TRUE;
461              }          
462              rc = hkp_recv_key (dlg, kserver, kserver_get_port (lv), pattern, proto_nr, 0);      case WM_DESTROY:
463              if (!rc)          if (lv) {
464                  keycache_set_reload (1);              listview_release (lv);
465              return TRUE;              lv = NULL;
466            }
467          case IDC_KEYSERVER_DEFAULT:          lv_idx = 0;
468              save_default_ks( lv );          return FALSE;
469              break;          
470                    case WM_SYSCOMMAND:
471          case IDCANCEL:          if (LOWORD (wparam) == SC_CLOSE)
472              EndDialog( dlg, FALSE );              EndDialog (dlg, TRUE);
473              return FALSE;          return FALSE;
474          }          
475          break;      case WM_COMMAND:
476      }          switch (LOWORD (wparam)) {
477                case IDC_KEYSERVER_PROXSETT:
478      return FALSE;              dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYSERVER_PROXY,
479  } /* keyserver_dlg_proc */                                dlg, keyserver_proxy_dlg_proc, NULL,
480                                  _("Proxy Settings"), IDS_WINPT_KEYSERVER_PROXY);
481                set_proxy (dlg);
482                return TRUE;
483                
484            case IDC_KEYSERVER_INDEX:
485                if (!lv_idx) {
486                    lv_idx = kserver_get_pos (lv);
487                    if (lv_idx == -1) {
488                        msg_box (dlg, _("Please select one of the keyservers."),
489                                 _("Keyserver"), MB_INFO);
490                        return FALSE;
491                    }
492                }
493                listview_get_item_text (lv, lv_idx, 1, proto, sizeof (proto)-1);
494                if (*proto == 'L') {
495                    msg_box (dlg, _("This is not implemented yet!"),
496                             _("Keyserver"), MB_ERR);
497                    return FALSE;
498                }
499                listview_get_item_text (lv, lv_idx, 0, kserver, sizeof (kserver)-1);
500                if (!GetDlgItemText (dlg, IDC_KEYSERVER_SEARCH, pattern, sizeof (pattern)-1)) {
501                    msg_box (dlg, _("Please enter the search pattern."),
502                             _("Keyserver"), MB_INFO);
503                    return FALSE;
504                }
505                ksc.name = kserver;
506                ksc.pattern = pattern;
507                ksc.port = kserver_get_port (lv);
508                DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_HKPSEARCH, dlg,
509                                hkpsearch_dlg_proc, (LPARAM) &ksc);
510                return TRUE;
511                
512            case IDC_KEYSERVER_RECV:
513                memset (&kserver, 0, sizeof (kserver));
514                if (!lv_idx) {
515                    lv_idx = kserver_get_pos (lv);
516                    if (lv_idx == -1) {
517                        msg_box (dlg, _("Please select one of the keyservers."),
518                                _("Keyserver"), MB_INFO);
519                        return FALSE;
520                    }
521                }
522                listview_get_item_text( lv, lv_idx, 1, proto, sizeof (proto)-1 );
523                proto_nr = KSPROTO_HTTP;
524                if (*proto == 'L')
525                    proto_nr = KSPROTO_LDAP;
526                else if (*proto == 'F')
527                    proto_nr = KSPROTO_FINGER;
528                listview_get_item_text (lv, lv_idx, 0, kserver, sizeof (kserver)-1);
529                if( !GetDlgItemText( dlg, IDC_KEYSERVER_SEARCH, pattern, sizeof (pattern)-1)) {
530                    msg_box (dlg, _("Please enter the search pattern."),
531                             _("Keyserver"), MB_INFO);
532                    return FALSE;
533                }
534                if (proto_nr == KSPROTO_LDAP && strchr (pattern, '@')) {
535                    msg_box (dlg, _("Only keyids are allowed."), _("LDAP Keyserver"), MB_INFO);
536                    return FALSE;
537                }
538                else if (proto_nr == KSPROTO_FINGER) {
539                    if (strchr (pattern, '@') || strchr (pattern, ' ')) {
540                        msg_box (dlg, _("Only enter the name of the user."),
541                                 _("FINGER Keyserver"), MB_INFO);
542                        return FALSE;
543                    }
544                }
545                else if (check_pattern (pattern)) {
546                    msg_box (dlg, _("Only email addresses or keyids are allowed."),
547                            _("HKP Keyserver"), MB_INFO);
548                    return FALSE;
549                }
550                rc = hkp_recv_key2 (dlg, kserver, kserver_get_port (lv),
551                                    pattern, proto_nr, 0, key? &key->fpr : NULL);
552                if (!rc && key->fpr != NULL) {
553                    keycache_update (0, key->fpr);
554                    get_pubkey (key->fpr, &key->newkey);
555                    /* we do not need the fingerprint any longer. */
556                    free_if_alloc (key->fpr);
557                }
558                return TRUE;
559    
560            case IDC_KEYSERVER_DEFAULT:
561                save_default_ks (lv);
562                break;
563                
564            case IDCANCEL:
565                EndDialog (dlg, FALSE);
566                return FALSE;
567            }
568            break;
569        }
570        
571        return FALSE;
572    }
Legend:
Removed from v.22  
changed lines
  Added in v.118
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26