/[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 2 by twoaday, Mon Jan 31 11:02:21 2005 UTC revision 262 by twoaday, Sat Sep 30 10:24:34 2006 UTC
# Line 1  Line 1 
1  /* wptKeyserverDlg.cpp - Keyserver dialog  /* wptKeyserverDlg.cpp - Keyserver dialog
2   *      Copyright (C) 2000-2005 Timo Schulz   *      Copyright (C) 2000-2006 Timo Schulz
3   *   *      Copyright (C) 2005, 2006 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 <ctype.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 "wptGPGME.h"
39  #define MAX_KEYSIZE 70000  #include "wptContext.h" /* for passphrase_s */
40    #include "wptKeyManager.h"
41  char * get_reg_entry_keyserver (const char *);  #include "wptDlgs.h"
42  int set_reg_entry_keyserver (const char *, const char *);  #include "wptUTF8.h"
43    #include "wptRegistry.h"
44    
45  static void  
46  hkp_err_box (HWND dlg, const char * host, u16 port, int rc)  char* get_reg_entry_keyserver (const char *);
47  {  int set_reg_entry_keyserver (const char *, const char *);
48      const char *err = kserver_strerror();  
49    /* Symbolic column IDs */
50      log_box( _("Keyserver"), MB_ERR, "%s:%d: %s", host, port, winpt_strerror (rc));  enum { KS_COL_NAME = 0, KS_COL_PORT };
51      if (err)  
52          msg_box (dlg, err, wsock_strerror (), MB_ERR);  /* Callback context to modify (add, edit) keyserver items. */
53  } /* hkp_err_box */  struct keyserver_rec_s {
54        char name[200];     /* hostname */
55        int  proto;         /* protocol */
56  int      int  port;          /* used port */
57  hkp_send_key (HWND dlg, const char *kserver, u16 port, const char *pattern)      bool mode;          /* true = edit */
58  {      bool cancel;
59      gpgme_ctx_t c;        };
60      gpgme_recipients_t rset;  typedef struct keyserver_rec_s *keyserver_rec_t;
61      gpgme_data_t keydata;  
62      gpgme_error_t ec;  
63      char *rawkey = NULL, msg[1024];  /* Print out keyserver error and a possible Winsock error. */
64      int rc;  static void
65        hkp_err_box (HWND dlg, const char *host, WORD port, int rc)
66      ec = gpgme_recipients_new( &rset );  {
67      if( ec )      const char *err = kserver_strerror ();
68          BUG( NULL );      const char *ws_err = wsock_strerror ();
69      gpgme_recipients_add_name( rset, pattern );      
70      ec = gpgme_new( &c );      if (ws_err && strlen (ws_err) > 0)
71      if( ec )          log_box (_("Keyserver"), MB_ERR, "%s:%d: %s", host, port, ws_err);
72          BUG( NULL );      else
73      gpgme_control( c, GPGME_CTRL_ARMOR, 1 );          log_box (_("Keyserver"), MB_ERR, "%s:%d: %s\n%s",
74      ec = gpgme_data_new( &keydata );                   host, port, winpt_strerror (rc), err? err : "");
75      if( ec )  }
76          BUG( NULL );  
77      rc = (int) gpgme_op_export( c, rset, keydata );  
78      if( rc ) {  /* Send the extracted key with keyid @pattern to the
79          msg_box( dlg, gpgme_strerror( (gpgme_error_t)rc ), _("Export"), MB_ERR );     keyserver @kserver (port @port).
80          goto leave;     Return value: 0 on success. */
81      }  int
82      rawkey = gpgme_data_release_and_return_string (keydata);  hkp_send_key (HWND dlg, const char *kserver, WORD port, const char *pattern)
83      rc = kserver_sendkey (kserver, port, rawkey, strlen (rawkey));  {
84      if (rc) {      GPGME *gpg;
85          hkp_err_box (dlg, kserver, port, rc);      gpgme_error_t ec;
86          goto leave;      char *rawkey = NULL;
87      }      char msg[256];
88            
89      _snprintf (msg, sizeof (msg) -1, _("Key '%s' successfully sent"), pattern);      gpg = new GPGME ();
90      status_box (dlg, msg, _("GnuPG status"));      gpg->setArmor (true);
91            ec = gpg->exportToBuffer (pattern, &rawkey);
92  leave:      if (ec) {
93      gpgme_release (c);          msg_box (dlg, gpgme_strerror (ec), _("Export"), MB_ERR);
94      gpgme_recipients_release (rset);          goto leave;
95      safe_free (rawkey);      }
96      return rc;      op_begin ();
97  } /* hkp_send_key */      ec = kserver_sendkey (kserver, port, rawkey, strlen (rawkey));
98        op_end ();
99        if (ec) {
100  int          hkp_err_box (dlg, kserver, port, ec);
101  hkp_recv_key (HWND dlg, const char *kserver, u16 port, const char *pattern, int proto, int flags)          goto leave;
102  {      }
103      gpgme_ctx_t ctx;      
104      gpgme_data_t keydata;      _snprintf (msg, sizeof (msg) -1, _("Key '%s' successfully sent"), pattern);
105      gpgme_error_t ec;      status_box (dlg, msg, _("GnuPG status"));
106      int rc, import_res[14];      
107      char * rawkey = NULL, msg[384];  leave:
108            delete gpg;
109      rawkey = new char[MAX_KEYSIZE];      free_if_alloc (rawkey);
110      if (!rawkey)      return ec? -1 : 0;
111          BUG (0);  }
112      memset (rawkey, 0, MAX_KEYSIZE);  
113      if( proto == KSPROTO_LDAP ) {  
114          rc = ldap_recvkey( kserver, pattern, rawkey, MAX_KEYSIZE-1 );  
115          if( rc ) {  /* Show all received keys from the keyserver. */
116              msg_box( dlg, _("LDAP key import failed.\n"  static void
117                              "Please make sure you have an online connection"  show_imported_keys (gpgme_import_result_t res)
118                              " and gpgkeys_ldap.exe is installed"),  {
119                              _("Keyserver"), MB_ERR );      gpgme_import_status_t t;
120              free_if_alloc( rawkey );      gpgme_key_t key;
121              return rc;      gpgme_data_t msg;
122          }      gpgme_ctx_t ctx;
123      }      gpgme_error_t err;
124      else if (proto == KSPROTO_FINGER) {      const char *s;
125          rc = finger_recvkey (kserver, pattern, rawkey, MAX_KEYSIZE-1);      char *p, *uid;
126          if (rc) {      size_t n=0;
127              log_box (_("Keyserver"), MB_ERR, _("Finger key import failed: %s\n"),  
128                       winpt_strerror (rc));      if (!res)
129              free_if_alloc( rawkey );          return;
130              return rc;  
131          }      err = gpgme_data_new (&msg);
132      }      if (err)
133      else if( ( rc = kserver_recvkey( kserver, port, kserver_check_keyid( pattern ),          BUG (NULL);
134                                       rawkey, MAX_KEYSIZE-1 ) ) ) {      err = gpgme_new (&ctx);
135          hkp_err_box (dlg, kserver, port, rc);      if (err)
136          free_if_alloc (rawkey);          BUG (NULL);
137          return rc;      if (res->considered > 1) {
138      }          s = _("WARNING: multiple keys matched request.\n\n");
139      else {          gpgme_data_write (msg, s, strlen (s));
140          if( !strstr( rawkey, "BEGIN PGP PUBLIC KEY BLOCK" ) ) {      }
141              msg_box( dlg, _("This is not a valid OpenPGP key."), _("Keyserver"), MB_ERR );  
142              goto leave;      if (res->unchanged == res->considered)
143          }          s = _("Key(s) successfully received but nothing was changed.");
144          ec = gpgme_new( &ctx );      else
145          if( ec )          s = _("Key(s) sucessfully received and imported.");
146              BUG( NULL );          // nice to have the amount of new signatures...
147          gpgme_data_new_from_mem( &keydata, rawkey, strlen( rawkey ), 1 );      gpgme_data_write (msg, s, strlen (s));
148          rc = gpgme_op_import( ctx, NULL, keydata );      gpgme_data_write (msg, "\n\n", 2);
149          if( rc ) {  
150              msg_box( dlg, gpgme_strerror( (gpgme_error_t)rc ), _("Import"), MB_ERR );      for (t=res->imports; t; t = t->next) {
151              goto leave;          if (!gpgme_get_key (ctx, t->fpr, &key, 0)) {
152          }              s = uid = utf8_to_native (key->uids->uid);
153          gpgme_get_import_status( ctx, import_res, NULL );              gpgme_data_write (msg, s, strlen (s));
154      }              gpgme_data_write (msg, "\n", 1);
155                    gpgme_key_release (key);
156      /* if we use the refresh mode, a lot of keys will be fetched and thus only              safe_free (uid);
157         a summarize at the end is presented and not for each key. */          }
158      if( !(flags & KM_KS_REFRESH) ) {      }
159          if( import_res[GPGME_IMPSTAT_NPKEYS] == 0 ) {          gpgme_data_write (msg, "\0", 1);
160              _snprintf( msg, sizeof (msg) - 1,      p = gpgme_data_release_and_get_mem (msg, &n);
161                         _("Key '%s' successfully received but nothing was changed."), pattern );      if (p != NULL) {
162              status_box( dlg, msg, _("GnuPG Status") );          msg_box (NULL, p, _("Imported Keys"), MB_INFO);
163              rc = WPTERR_GENERAL;          gpgme_free (p);
164              goto leave;      }
165          }      gpgme_release (ctx);
166          _snprintf( msg, sizeof (msg) - 1, _("Key '%s' sucessfully received and imported."), pattern );  }
167          status_box( dlg, msg, _("GnuPG Status") );  
168      }  
169        /* Receive a key from the keyserver @kserver (port @port)
170  leave:     with the pattern @pattern.
171      free_if_alloc (rawkey);     Return value: 0 on success. */
172      gpgme_release (ctx);  static int
173      gpgme_data_release (keydata);  keyserver_recv_key (HWND dlg, const char *kserver, WORD port,
174                        const char *pattern, int proto, int flags,
175      return rc;                      char **r_fpr)
176  } /* hkp_recv_key */  {    
177        gpgme_import_result_t import_res = NULL;
178        gpgme_error_t err;
179  #define my_iskeychar(a) ( ( (a) >='0' && (a) <= '9' ) || ( (a) >= 'A' && (a) <= 'F' ) )      GPGME *gpg = NULL;
180        char *rawkey = NULL;
181  static int      int keylen = 0;
182  check_pattern( const char *pattern )      int rc;
183  {  
184      int rc = 1;      if (proto == KSPROTO_LDAP) {
185                rc = ldap_recvkey (kserver, pattern, &rawkey, &keylen);
186      /* Whitespace are not allowed! */          if (rc) {
187      if( strchr( pattern, ' ') ) {              msg_box (dlg, _("LDAP key import failed.\n"
188          rc = WPTERR_GENERAL;                              "Please make sure you have an online connection"
189          goto leave;                              " and gpgkeys_ldap.exe is installed"),
190      }                              _("Keyserver"), MB_ERR);
191                    free_if_alloc (rawkey);
192      if( (( strstr( pattern, "0x" ) ) && ( strlen( pattern ) == 10 ) )              return rc;
193           || (strstr(pattern, "0x")) && ( strlen( pattern )  == 18 ) ) {          }
194          rc = 0;      }
195          goto leave;      else if (proto == KSPROTO_FINGER) {
196      }          rc = finger_recvkey (kserver, pattern, &rawkey, &keylen);
197                if (rc) {
198      if( (( my_iskeychar( pattern[0] )) && ( strlen( pattern )  == 8 ) )              log_box (_("Keyserver"), MB_ERR,
199           || (my_iskeychar(pattern[0])) && ( strlen( pattern ) == 16) ) {                       _("Finger key import failed: %s\n"), winpt_strerror (rc));
200          rc = 0;              free_if_alloc (rawkey);
201          goto leave;              return rc;
202      }          }
203            }
204      if( ( strchr( pattern, '@' ) ) && ( strlen( pattern ) >= 3 ) ) {      else if ((rc = kserver_recvkey (kserver, port,
205          rc = 0;                                      kserver_check_keyid (pattern),
206          goto leave;                                      &rawkey, &keylen))) {
207      }          hkp_err_box (dlg, kserver, port, rc);
208                free_if_alloc (rawkey);
209  leave:          return rc;
210      return rc;      }
211  } /* check_pattern */  
212        if (!strstr (rawkey, "BEGIN PGP PUBLIC KEY BLOCK")) {
213            msg_box (dlg, _("This is not a valid OpenPGP key."),
214  static void                   _("Keyserver"), MB_ERR);
215  set_proxy (HWND dlg)          goto leave;
216  {      }
217      char proxy[384];      gpg = new GPGME ();
218      int port = 0;      err = gpg->importFromBuffer (rawkey);
219            if (err) {
220      strcpy (proxy, "HTTP proxy: ");          msg_box (dlg, gpgme_strerror (err), _("Import"), MB_ERR);
221      if (kserver_get_proxy (&port)) {          goto leave;
222          char t[256];      }
223          const char *http = kserver_get_proxy (&port);      import_res = gpg->importGetResult ();
224          _snprintf (t, sizeof (t) - 1, "\"%s:%d\"", http, port);      if (import_res && r_fpr)
225          strcat (proxy, t);          *r_fpr = m_strdup (import_res->imports->fpr);
226      }      
227      else      /* if we use the refresh mode, a lot of keys will be fetched and thus only
228          strcat( proxy, "none" );         a summarize at the end is presented and not for each key. */
229      SetDlgItemText( dlg, IDC_KEYSERVER_PROXY, proxy );      if (import_res && !(flags & KM_KS_REFRESH)) {
230  } /* set_proxy */          show_imported_keys (import_res);
231            if (import_res->unchanged == import_res->considered) {
232                rc = WPTERR_GENERAL; /* no keys updated. */
233  static int inline              goto leave;
234  kserver_get_pos (listview_ctrl_t lv)          }
235  {      }
236      if (listview_count_items (lv, 0) == 1)  
237          return 0;  leave:
238      return listview_get_curr_pos (lv);      free_if_alloc (rawkey);
239  }      if (gpg != NULL)
240            delete gpg;
241        return rc;
242  static u16 inline  }
243  kserver_get_port (listview_ctrl_t lv)  
244  {  
245      char buf[16];  /* Alias for keyserver_recv_key but without the ability to return
246       the fingerprint of the key. */
247      listview_get_item_text (lv, kserver_get_pos (lv), 3, buf, 15);  int
248      return (u16)strtoul (buf, NULL, 10);  hkp_recv_key (HWND dlg, const char *kserver, WORD port,
249  }                const char *pattern, int proto, int flags)
250    {
251  static void      return keyserver_recv_key (dlg, kserver, port, pattern,
252  load_default_ks (listview_ctrl_t lv)                                 proto, flags, NULL);
253  {  }
254      char * p, buf[192];  
255      int i;  int
256    hkp_recv_key2 (HWND dlg, const char *kserver, WORD port,
257      p = get_reg_entry_keyserver ("Default");                 const char *pattern, int proto, char **r_fpr)
258      if (!p)  {
259          return;      return keyserver_recv_key (dlg, kserver, port, pattern,
260      for( i = 0; i < listview_count_items( lv, 0 ); i++ ) {                                 proto, 0, r_fpr);
261          listview_get_item_text( lv, i, 0, buf, sizeof (buf)-1 );  }
262          if( !strncmp( p, buf, strlen( p ) ) ) {  
263              listview_add_sub_item( lv, i, 2, "x" );  
264              break;  /* Check if the given pattern are either a valid
265          }     email address, a {long, short} keyid or a fingerprint.
266      }     Return 0 on success. */
267      free_if_alloc (p);  static int
268  } /* load_default_ks */  check_pattern (const char *pattern)
269    {    
270        size_t i;
271  static int  
272  save_default_ks (listview_ctrl_t lv)      if (strchr (pattern, ' '))
273  {          return WPTERR_GENERAL; /* do not allow white spaces. */
274      char buf[192], port[32];      
275      int idx, i;        if (strchr (pattern, '@') && strlen (pattern) >= 3 &&
276            !check_email_address (pattern))
277      idx = listview_get_curr_pos( lv );          return 0;
278      if( idx == -1 ) {  
279          msg_box( NULL, _("Please select one of the servers."), _("Keyserver"), MB_ERR );      if (strstr (pattern, "0x"))
280          return -1;          pattern += 2;
281      }      if (strlen (pattern) != 8 &&
282      listview_get_item_text( lv, idx, 1, buf, sizeof (buf)-1 );          strlen (pattern) != 16 &&
283      if( *buf != 'H' ) {          strlen (pattern) != 40)
284          msg_box( NULL, _("Only HTTP keyserver can be used."), _("Keyserver"), MB_ERR );          return WPTERR_GENERAL;
285          return -1;  
286      }      for (i=0; i < strlen (pattern); i++) {
287      for (i = 0; i < listview_count_items( lv, 0 ); i++)          if (!isxdigit (pattern[i]))
288          listview_add_sub_item (lv, i, 2, "");              return WPTERR_GENERAL;
289      listview_add_sub_item (lv, idx, 2, "x");      }
290      listview_get_item_text (lv, idx, 0, buf, sizeof (buf)-1);      return 0;
291      set_reg_entry_keyserver ("Default", buf);  }
292      i = kserver_get_port (lv);  
293      sprintf (port, "%d", i);  
294      set_reg_entry_keyserver ("Default_Port", port);  /* Return human readable name for the proxy protocol. */
295      keyserver_set_default (buf, (u16)i);  static const char*
296      return 0;  name_from_proto (int proto)
297  } /* save_default_ks */  {
298        const char *s;
299    
300  int      switch (proto) {
301  keyserver_list_build (listview_ctrl_t *r_lv, HWND hwnd)      case PROXY_PROTO_NONE:      s = ""; break;
302  {      case PROXY_PROTO_HTTP:      s = "HTTP"; break;
303      struct listview_column_s keyserver[] = {      case PROXY_PROTO_SOCKS5:    s = "SOCKS5"; break;
304          {0, 160, (char *)_("DNS Name")},              default:                    s = "HTTP"; break;
305          {1,  52, (char *)_("Protocol")},      }
306          {2,  46, (char *)_("Default")},      return s;
307          {3,  46, (char *)_("Port")},  }
308          {0,   0, NULL}  
309      };  
310      listview_ctrl_t lv;  static int inline
311      char buf[32];  kserver_get_pos (listview_ctrl_t lv)
312      int j;  {
313        if (listview_count_items (lv, 0) == 1)
314      listview_new (&lv);              return 0;
315      lv->ctrl = hwnd;            return listview_get_curr_pos (lv);
316      for (j=0; keyserver[j].fieldname; j++)  }
317          listview_add_column (lv, &keyserver[j]);          
318      for (j = 0; j<MAX_KEYSERVERS; j++) {  
319          if (!server[j].used)  static WORD inline
320              continue;  kserver_get_port (listview_ctrl_t lv)
321          listview_add_item (lv, " ");  {
322          listview_add_sub_item (lv, 0, 0, server[j].name);      char buf[16];
323          switch (server[j].proto) {  
324          case KSPROTO_HTTP:      listview_get_item_text (lv, kserver_get_pos (lv),
325              listview_add_sub_item( lv, 0, 1, "H" ); break;                              KS_COL_PORT, buf, sizeof (buf)-1);
326          case KSPROTO_LDAP:      return (WORD)strtoul (buf, NULL, 10);
327              listview_add_sub_item( lv, 0, 1, "L" ); break;  }
328          case KSPROTO_FINGER:  
329              listview_add_sub_item( lv, 0, 1, "F" ); break;  
330          }  static void
331          sprintf (buf, "%d", server[j].port);  set_default_ks (listview_ctrl_t lv)
332          listview_add_sub_item (lv, 0, 3, buf);  {
333      }      char *p, buf[128];
334      load_default_ks (lv);      int i;
335      if (listview_count_items (lv, 0) == 0) {  
336          listview_add_item (lv, "");      p = get_reg_entry_keyserver ("Default");
337          listview_add_sub_item (lv, 0, 0, DEF_HKP_KEYSERVER);      if (!p)
338          listview_add_sub_item (lv, 0, 1, "H");          return;
339      }      for (i=0; i < listview_count_items (lv, 0); i++) {
340      listview_set_ext_style (lv);          listview_get_item_text (lv, i, KS_COL_NAME, buf, sizeof (buf)-1);      
341      *r_lv = lv;          if (!stricmp (buf, p)) {
342      return 0;              listview_select_one (lv, i);
343  }              break;
344            }
345        }
346  BOOL CALLBACK      free_if_alloc (p);
347  keyserver_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)  }
348  {  
349      static listview_ctrl_t lv = NULL;  
350      static int lv_idx = 0;  /* Save the selected keyserver from @lv as the default server. */
351      int rc, proto_nr = 0;  static int
352      char kserver[128], pattern[128];  save_default_ks (listview_ctrl_t lv)
353      char proto[16];      {
354      keyserver_ctx ksc;      char buf[192], port[32];
355            int idx, i;  
356      switch ( msg ) {  
357      case WM_INITDIALOG:      idx = listview_get_curr_pos (lv);
358  #ifndef LANG_DE      if (idx == -1) {
359          SetWindowText( dlg, _("Keyserver Access") );          msg_box (NULL, _("Please select one of the servers."),
360          SetDlgItemText( dlg, IDC_KEYSERVER_SEND,                   _("Keyserver"), MB_ERR);
361                          _("Send key (default is receiving)") );          return -1;
362          SetDlgItemText( dlg, IDC_KEYSERVER_INFO,      }
363                          _("Please enter the key ID or email address that belongs to the key"));                              listview_get_item_text (lv, idx, KS_COL_NAME, buf, sizeof (buf)-1);
364          SetDlgItemText( dlg, IDC_KEYSERVER_INDEX, _("&Search") );      if (strnicmp (buf, "http", 4) && strnicmp (buf, "hkp", 3)) {
365  #endif          msg_box (NULL, _("Only HKP keyserver can be used."),
366          set_proxy (dlg);                   _("Keyserver"), MB_ERR);
367          keyserver_list_build (&lv, GetDlgItem (dlg, IDC_KEYSERVER_LIST));          return -1;
368          center_window (dlg);      }
369          SetForegroundWindow (dlg);      set_reg_entry_keyserver ("Default", buf);
370          return TRUE;      i = kserver_get_port (lv);
371                sprintf (port, "%d", i);
372      case WM_NOTIFY:      set_reg_entry_keyserver ("Default_Port", port);
373          NMHDR *notify;      keyserver_set_default (buf, (WORD)i);
374          notify = (NMHDR *)lparam;      return 0;
375          if( notify && notify->code == NM_CLICK  }
376              && notify->idFrom == IDC_KEYSERVER_LIST )  
377              lv_idx = listview_get_curr_pos( lv );  
378          return TRUE;  int
379            keyserver_list_build (listview_ctrl_t *r_lv, HWND hwnd)
380      case WM_DESTROY:  {
381          if( lv ) {      struct listview_column_s keyserver[] = {
382              listview_release( lv );          {0, 180, (char *)_("DNS Name")},
383              lv = NULL;          {1,  55, (char *)_("Port")},
384          }          {0,   0, NULL}
385          lv_idx = 0;      };
386          return FALSE;      HICON ico[1];
387                listview_ctrl_t lv;
388      case WM_SYSCOMMAND:      char buf[32];
389          if( LOWORD( wparam ) == SC_CLOSE )      int j;
390              EndDialog( dlg, TRUE );  
391          return FALSE;      ico[0] = LoadIcon (glob_hinst, (LPCTSTR)IDI_COMPUTER);
392                listview_new (&lv, hwnd);    
393      case WM_COMMAND:      for (j=0; keyserver[j].fieldname; j++)
394          switch( LOWORD( wparam ) ) {          listview_add_column (lv, &keyserver[j]);
395          case IDC_KEYSERVER_PROXSETT:      listview_set_image_list (lv, 16, 16, ico, 1);
396              dialog_box_param( glob_hinst, (LPCTSTR)IDD_WINPT_KEYSERVER_PROXY, glob_hwnd,      for (j = 0; j < MAX_KEYSERVERS; j++) {
397                                keyserver_proxy_dlg_proc, NULL,          if (!server[j].used)
398                                _("Proxy Settings"), IDS_WINPT_KEYSERVER_PROXY );              continue;
399              set_proxy( dlg );          listview_add_item_image (lv, " ", 0);
400              return TRUE;          listview_add_sub_item (lv, 0, KS_COL_NAME, server[j].name);
401                        sprintf (buf, "%d", server[j].port);
402          case IDC_KEYSERVER_INDEX:          listview_add_sub_item (lv, 0, KS_COL_PORT, buf);
403              if (!lv_idx) {      }
404                  lv_idx = kserver_get_pos (lv);      if (listview_count_items (lv, 0) == 0) {
405                  if (lv_idx == -1) {          listview_add_item (lv, "");
406                      msg_box (dlg, _("Please select one of the keyservers."), _("Keyserver"), MB_INFO);          listview_add_sub_item (lv, 0, KS_COL_NAME, DEF_HKP_KEYSERVER);
407                      return FALSE;      }
408                  }      listview_set_ext_style (lv);
409              }      *r_lv = lv;
410              listview_get_item_text (lv, lv_idx, 1, proto, sizeof (proto)-1);      return 0;
411              if (*proto == 'L') {  }
412                  msg_box( dlg, _("This is not implemented yet!"), _("Keyserver"), MB_ERR );  
413                  return FALSE;  
414              }  static void
415              listview_get_item_text (lv, lv_idx, 0, kserver, sizeof (kserver)-1);  keyserver_remove (listview_ctrl_t lv)
416              if (!GetDlgItemText (dlg, IDC_KEYSERVER_SEARCH, pattern, sizeof (pattern)-1)) {  {
417                  msg_box (dlg, _("Please enter the search pattern."), _("Keyserver"), MB_INFO);      char name[100];
418                  return FALSE;      int pos = listview_get_curr_pos (lv);
419              }      int i;
420              ksc.name = kserver;  
421              ksc.pattern = pattern;      listview_get_item_text (lv, pos, KS_COL_NAME, name, sizeof (name)-1);
422              ksc.port = kserver_get_port (lv);      for (i=0; i < MAX_KEYSERVERS; i++) {
423              DialogBoxParam( glob_hinst, (LPCSTR)IDD_WINPT_HKPSEARCH, dlg,          if (server[i].name && stricmp (server[i].name, name) == 0)
424                              hkpsearch_dlg_proc, (LPARAM) &ksc );              server[i].used = 0;
425              return TRUE;      }
426                    listview_del_item (lv, pos);
427          case IDC_KEYSERVER_RECV:  }
428              memset (&kserver, 0, sizeof (kserver));  
429              if (!lv_idx) {  
430                  lv_idx = kserver_get_pos (lv);  static void
431                  if (lv_idx == -1) {  keyserver_edit (listview_ctrl_t lv, keyserver_rec_t ctx)
432                      msg_box( dlg, _("Please select one of the keyservers."), _("Keyserver"), MB_INFO );  {
433                      return FALSE;      char buf[16];
434                  }      bool fnd = false;
435              }      int i;
436              listview_get_item_text( lv, lv_idx, 1, proto, sizeof (proto)-1 );  
437              proto_nr = KSPROTO_HTTP;      for (i=0; i < MAX_KEYSERVERS; i++) {
438              if( *proto == 'L' )          if (server[i].name && stricmp (server[i].name, ctx->name) == 0) {
439                  proto_nr = KSPROTO_LDAP;              fnd = true;
440              else if( *proto == 'F' )              break;
441                  proto_nr = KSPROTO_FINGER;          }
442              listview_get_item_text( lv, lv_idx, 0, kserver, sizeof (kserver)-1 );      }
443              if( !GetDlgItemText( dlg, IDC_KEYSERVER_SEARCH, pattern, sizeof (pattern)-1 ) ) {      if (!fnd)
444                  msg_box( dlg, _("Please enter the search pattern."), _("Keyserver"), MB_INFO );          return;
445                  return FALSE;      server[i].port = ctx->port;
446              }  
447              if( proto_nr == KSPROTO_LDAP && strchr( pattern, '@' ) ) {      i = listview_get_curr_pos (lv);
448                  msg_box( dlg, _("Only keyids are allowed."), _("LDAP Keyserver"), MB_INFO );      sprintf (buf, "%d", ctx->port);
449                  return FALSE;      listview_add_sub_item (lv, i, KS_COL_NAME, ctx->name);
450              }      listview_add_sub_item (lv, i, KS_COL_PORT, buf);
451              else if( proto_nr == KSPROTO_FINGER &&  }
452                       ( strchr( pattern, '@' ) || strchr( pattern, ' ' ) ) ) {  
453                  msg_box( dlg, _("Only enter the name of the user."), _("FINGER Keyserver"), MB_INFO );  static void
454                  return FALSE;  keyserver_add (listview_ctrl_t lv, keyserver_rec_t ctx)
455              }  {
456              else if( check_pattern( pattern ) ) {      char buf[16];
457                  msg_box( dlg, _("Only email addresses or keyids are allowed."), _("Keyserver"), MB_INFO );      bool fnd = false;
458                  return FALSE;      int i;
459              }  
460              rc = hkp_recv_key (dlg, kserver, kserver_get_port (lv), pattern, proto_nr, 0);      for (i=0; i < MAX_KEYSERVERS; i++) {
461              if (!rc)          if (server[i].used == 0) {
462                  keycache_set_reload (1);              fnd = true;
463              return TRUE;              break;
464            }
465          case IDC_KEYSERVER_DEFAULT:      }
466              save_default_ks( lv );      if (!fnd) {
467              break;          msg_box (NULL, _("No space for new keyserver entry"),
468                                 _("Keyserver"), MB_ERR);
469          case IDCANCEL:          return;
470              EndDialog( dlg, FALSE );      }
471              return FALSE;      free_if_alloc (server[i].name);
472          }      server[i].name = m_strdup (ctx->name);
473          break;      server[i].port = ctx->port;
474      }      server[i].proto = ctx->proto;
475            server[i].used = 1;
476      return FALSE;  
477  } /* keyserver_dlg_proc */      sprintf (buf, "%d", ctx->port);
478        listview_add_item (lv, " ");
479        listview_add_sub_item (lv, 0, KS_COL_NAME, ctx->name);
480        listview_add_sub_item (lv, 0, KS_COL_PORT, buf);
481    }
482    
483    
484    static void
485    fill_keyserv_types (HWND dlg)
486    {
487        HWND h = GetDlgItem (dlg, IDC_KSERVADD_TYPES);
488        combox_add_string (h, _("HKP Keyserver"));
489        combox_add_string (h, _("LDAP Keyserver"));
490        combox_add_string (h, _("Finger Keyserver"));
491        SendMessage (h, CB_SETCURSEL, 0, 0);
492    }
493    
494    
495    /* Dialog box procedure for modify keyservers. */
496    BOOL CALLBACK
497    keyserver_modify_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
498    {
499        static keyserver_rec_t ctx;
500        char tmp[128];
501    
502        switch (msg) {
503        case WM_INITDIALOG:
504            fill_keyserv_types (dlg);
505            ctx = (keyserver_rec_t)lparam;
506            if (ctx->mode) {
507                SendDlgItemMessage (dlg, IDC_KSERVADD_TYPES, CB_SETCURSEL, ctx->proto, 0);
508                SetDlgItemText (dlg, IDC_KSERVADD_HOST, ctx->name);
509                SetDlgItemInt (dlg, IDC_KSERVADD_PORT, ctx->port, FALSE);
510                EnableWindow (GetDlgItem (dlg, IDC_KSERVADD_HOST), FALSE);
511                EnableWindow (GetDlgItem (dlg, IDC_KSERVADD_TYPES), FALSE);
512            }
513            else
514                SetDlgItemInt (dlg, IDC_KSERVADD_PORT, 11371, FALSE);      
515            SetWindowText (dlg, _("Edit Keyserver"));
516            SetDlgItemText (dlg, IDOK, _("&Add"));
517            SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));
518            SetDlgItemText (dlg, IDC_KSERVADD_TYPEINF, _("Type:"));
519            SetDlgItemText (dlg, IDC_KSERVADD_PORTINF, _("Port:"));
520            SetDlgItemText (dlg, IDC_KSERVADD_HOSTINF, _("Host name:"));
521            SetForegroundWindow (dlg);
522            break;
523    
524        case WM_COMMAND:
525            switch (LOWORD (wparam)) {
526            case IDOK:
527                if (!GetDlgItemText (dlg, IDC_KSERVADD_HOST, tmp, sizeof (tmp)-1)) {
528                    msg_box (dlg, _("Please enter a host name"), _("Keyserver"), MB_ERR);
529                    return FALSE;
530                }      
531                ctx->port = GetDlgItemInt (dlg, IDC_KSERVADD_PORT, NULL, FALSE);
532                if (ctx->port > 65535) {
533                    msg_box (dlg, _("Invalid port, valid numbers are < 65535"), _("Keyserver"), MB_ERR);
534                    return FALSE;
535                }
536                ctx->proto = SendDlgItemMessage (dlg, IDC_KSERVADD_TYPES, CB_GETCURSEL, 0, 0);
537                ctx->cancel = false;
538                ctx->name[0] = '\0';
539                if (!strstr (tmp, "://")) {
540                    switch (ctx->proto) {
541                    case KSPROTO_HTTP: strcpy (ctx->name, "http://"); break;
542                    case KSPROTO_LDAP: strcpy (ctx->name, "ldap://"); break;
543                    case KSPROTO_FINGER:strcpy (ctx->name, "finger://"); break;
544                    }
545                }
546                strcat (ctx->name, tmp);
547                ctx->cancel = false;
548                EndDialog (dlg, TRUE);
549                break;
550    
551            case IDCANCEL:
552                ctx->cancel = true;
553                EndDialog (dlg, FALSE);
554                break;
555            }
556            break;
557        }
558    
559        return FALSE;
560    }
561    
562    
563    /* Add search pattern @patt to the combo box if it is
564       not already available in the list. */
565    static void
566    add_pattern_to_combox (HWND dlg, int ctlid, const char *patt)
567    {
568        int err;
569    
570        err = SendDlgItemMessage (dlg, ctlid, CB_FINDSTRINGEXACT,
571                                  0, (LPARAM)(LPCSTR)patt);
572        if (err != CB_ERR)
573            return;
574        SendDlgItemMessage (dlg, IDC_KEYSERVER_SEARCH, CB_ADDSTRING,
575                            0, (LPARAM)(LPCSTR)patt);
576    }
577    
578    static void
579    load_pattern_to_combox (HWND dlg, int ctlid, const char *rkey_name)
580    {
581    }
582    
583    static void
584    save_pattern_from_combox (HWND dlg, int ctlid, const char *rkey_name)
585    {
586        char *p, tmp[64];
587        int i;
588        int n, len=0;
589    
590        n = SendDlgItemMessage (dlg, ctlid, CB_GETCOUNT, 0, 0);
591        if (n == 0 || n == CB_ERR)
592            return;
593        /* it is very unlikely that the combox contain hundred of pattern
594           but even so we limit the value to 16 which should be sufficient. */
595        if (n > 16) n = 16;
596        for (i=0; i < n; i++)
597            len += SendDlgItemMessage (dlg, ctlid, CB_GETLBTEXTLEN,
598                                       (WPARAM)i, 0) + 1 + 1;
599        p = new char[len+1];
600        memset (p, 0, len+1);
601        for (i=0; i < n; i++) {
602            memset (tmp, 0, sizeof (tmp));
603            SendDlgItemMessage (dlg, ctlid, CB_GETLBTEXT,
604                                (WPARAM)i, (LPARAM)tmp);
605            strcat (p, tmp);
606            strcat (p, "$");
607        }
608        set_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", rkey_name, p);
609        free_if_alloc (p);
610    }
611    
612    
613    /* Dialog box procedure to access keyservers. */
614    BOOL CALLBACK
615    keyserver_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
616    {
617        static listview_ctrl_t lv = NULL;
618        static int lv_idx = 0;
619        keyserver_ctx ksc;
620        struct keyserver_rec_s edit;
621        char kserver[128], pattern[128];
622        char proto[16], *fpr = NULL;
623        int rc, proto_nr = 0;
624        
625        switch (msg) {
626        case WM_INITDIALOG:
627            SetWindowText (dlg, _("Keyserver Access"));
628            SetDlgItemText (dlg, IDC_KEYSERVER_RECV, _("&Receive"));
629            SetDlgItemText (dlg, IDC_KEYSERVER_SEND,
630                            _("Send key (default is receiving)"));
631            SetDlgItemText (dlg, IDC_KEYSERVER_INFO,
632                            _("Key ID or email address you want to search for"));
633            SetDlgItemText (dlg, IDC_KEYSERVER_INDEX, _("&Search"));
634            SetDlgItemText (dlg, IDC_KEYSERVER_PROXSETT, _("C&hange proxy"));
635            SetDlgItemText (dlg, IDC_KEYSERVER_DEFAULT, _("Set &default"));
636            SetDlgItemText (dlg, IDCANCEL, _("&Close"));
637            
638            keyserver_list_build (&lv, GetDlgItem (dlg, IDC_KEYSERVER_LIST));
639            set_default_ks (lv);
640            center_window (dlg, NULL);
641            SetForegroundWindow (dlg);
642            return TRUE;
643            
644        case WM_NOTIFY:
645            NMHDR *notify;
646            notify = (NMHDR *)lparam;
647            if (!notify)
648                break;
649            if (notify->code == NM_CLICK
650                && notify->idFrom == IDC_KEYSERVER_LIST)
651                lv_idx = listview_get_curr_pos (lv);
652            else if (notify->code == NM_RCLICK &&
653                     notify->idFrom == IDC_KEYSERVER_LIST) {
654                POINT p;
655                GetCursorPos (&p);
656                HMENU hm, pop;
657                hm = LoadMenu (glob_hinst, (LPCTSTR)IDR_WINPT_KEYSERVER_CTX);
658                pop = GetSubMenu (hm, 0);
659                set_menu_text (pop, ID_KSERVCTX_ADD, _("&Add"));
660                set_menu_text (pop, ID_KSERVCTX_DEL, _("&Remove"));
661                set_menu_text (pop, ID_KSERVCTX_EDIT, _("&Edit"));
662                TrackPopupMenu (pop, 0, p.x, p.y, 0, dlg, NULL);
663                DestroyMenu (hm);
664                DestroyMenu (pop);
665            }
666            else if (notify->code == LVN_ITEMCHANGED &&
667                     ((LPNMLISTVIEW)lparam)->uNewState) {
668                listview_get_item_text (lv, listview_get_curr_pos (lv),
669                                        KS_COL_NAME, kserver, sizeof (kserver)-1);
670                if (!strnicmp (kserver, "ldap://", 7))
671                    EnableWindow (GetDlgItem (dlg, IDC_KEYSERVER_INDEX), FALSE);
672                else
673                    EnableWindow (GetDlgItem (dlg, IDC_KEYSERVER_INDEX), TRUE);
674            }
675            return TRUE;
676            
677        case WM_DESTROY:
678            if (lv) {
679                listview_release (lv);
680                lv = NULL;
681            }
682            lv_idx = 0;
683            save_pattern_from_combox (dlg, IDC_KEYSERVER_SEARCH, "KSsearch");
684            return FALSE;
685            
686        case WM_SYSCOMMAND:
687            if (LOWORD (wparam) == SC_CLOSE)
688                EndDialog (dlg, TRUE);
689            return FALSE;  
690    
691        case WM_COMMAND:
692            switch (LOWORD (wparam)) {
693            case IDC_KEYSERVER_PROXSETT:
694                dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYSERVER_PROXY,
695                                  dlg, keyserver_proxy_dlg_proc, 0,
696                                  _("Proxy Settings"), IDS_WINPT_KEYSERVER_PROXY);
697                return TRUE;
698                
699            case IDC_KEYSERVER_INDEX:
700                if (!lv_idx)
701                    lv_idx = kserver_get_pos (lv);
702                
703                if (!GetDlgItemText (dlg, IDC_KEYSERVER_SEARCH, pattern, sizeof (pattern)-1)) {
704                    msg_box (dlg, _("Please enter the search pattern."),
705                             _("Keyserver"), MB_INFO);
706                    return TRUE;
707                }
708    
709                if (lv_idx != -1) {
710                    listview_get_item_text (lv, lv_idx, KS_COL_NAME,
711                                            kserver, sizeof (kserver)-1);
712                    ksc.name = kserver;
713                    ksc.port = kserver_get_port (lv);
714                }
715                else {
716                    ksc.name = DEF_HKP_KEYSERVER;
717                    ksc.port = HKP_PORT;
718                }
719                ksc.pattern = pattern;
720                DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_HKPSEARCH, dlg,
721                                hkpsearch_dlg_proc, (LPARAM) &ksc);
722                return TRUE;
723                
724            case IDC_KEYSERVER_RECV:            
725                memset (&kserver, 0, sizeof (kserver));
726                if (!lv_idx) {
727                    lv_idx = kserver_get_pos (lv);
728                    if (lv_idx == -1) {
729                        msg_box (dlg, _("Please select one of the keyservers."),
730                                _("Keyserver"), MB_INFO);
731                        return TRUE;
732                    }
733                }
734                listview_get_item_text (lv, lv_idx, KS_COL_NAME,
735                                        proto, sizeof (proto)-1);
736                proto_nr = KSPROTO_HTTP;
737                if (!strnicmp  (proto, "ldap", 4))
738                    proto_nr = KSPROTO_LDAP;
739                else if (!strnicmp (proto, "finger", 6))
740                    proto_nr = KSPROTO_FINGER;
741                listview_get_item_text (lv, lv_idx, KS_COL_NAME,
742                                        kserver, sizeof (kserver)-1);
743                if (!GetDlgItemText(dlg, IDC_KEYSERVER_SEARCH,
744                                    pattern, sizeof (pattern)-1)) {
745                    msg_box (dlg, _("Please enter the search pattern."),
746                             _("Keyserver"), MB_INFO);
747                    return FALSE;
748                }
749                add_pattern_to_combox (dlg, IDC_KEYSERVER_SEARCH, pattern);
750                if (proto_nr == KSPROTO_LDAP && strchr (pattern, '@')) {
751                    msg_box (dlg, _("Only keyids are allowed."),
752                             _("Keyserver"), MB_INFO);
753                    return FALSE;
754                }
755                else if (proto_nr == KSPROTO_FINGER) {
756                    if (strchr (pattern, '@') || strchr (pattern, ' ')) {
757                        msg_box (dlg, _("Only enter the name of the user."),
758                                 _("Keyserver"), MB_INFO);
759                        return TRUE;
760                    }
761                }
762                else if (check_pattern (pattern)) {
763                    msg_box (dlg, _("Only email addresses or keyids are allowed."),
764                            _("Keyserver"), MB_INFO);
765                    return TRUE;
766                }
767                rc = keyserver_recv_key (dlg, kserver, kserver_get_port (lv),
768                                         pattern, proto_nr, 0,
769                                         &fpr);
770                if (!rc && fpr != NULL) {
771                    keycache_update (0, fpr);
772                    free_if_alloc (fpr);
773                }
774                return TRUE;
775    
776            case IDC_KEYSERVER_DEFAULT:
777                save_default_ks (lv);
778                return TRUE;
779    
780            case ID_KSERVCTX_ADD:
781                memset (&edit, 0, sizeof (edit));
782                edit.mode = false;
783                dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYSERVER_ADD, dlg,
784                                    keyserver_modify_dlg_proc,
785                                    (LPARAM)&edit, _("Edit Keyserver"), 0);
786                if (!edit.cancel)
787                    keyserver_add (lv, &edit);
788                return TRUE;
789    
790            case ID_KSERVCTX_EDIT:
791                memset (&edit, 0, sizeof (edit));
792                edit.mode = true;
793                listview_get_item_text (lv, lv_idx, KS_COL_NAME,
794                                        edit.name, sizeof (edit.name)-1);
795                listview_get_item_text (lv, lv_idx, KS_COL_PORT, pattern, 32);
796                edit.port = atoi (pattern);
797                if (!strnicmp (edit.name, "hkp", 3) || !strnicmp (edit.name, "http", 4))
798                    edit.proto = KSPROTO_HTTP;
799                else if (!strnicmp (edit.name, "ldap", 4))
800                    edit.proto = KSPROTO_LDAP;
801                else
802                    edit.proto = KSPROTO_FINGER;
803                dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYSERVER_ADD, dlg,
804                                    keyserver_modify_dlg_proc,
805                                    (LPARAM)&edit, _("Edit Keyserver"), 0);
806                if (!edit.cancel)
807                    keyserver_edit (lv, &edit);
808                break;
809    
810            case ID_KSERVCTX_DEL:
811                keyserver_remove (lv);
812                return TRUE;
813                
814            case IDCANCEL:
815                EndDialog (dlg, FALSE);
816                return TRUE;
817            }
818            break;
819        }
820        
821        return FALSE;
822    }
Legend:
Removed from v.2  
changed lines
  Added in v.262
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26