/[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 25 by twoaday, Wed Oct 12 10:04:26 2005 UTC revision 36 by werner, Thu Oct 27 15:25:13 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   *   *
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    
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 <windows.h>
27  #include "wptErrors.h"  #include <commctrl.h>
28  #include "wptTypes.h"  #include <malloc.h>
29  #include "wptCommonCtl.h"  
30  #include "wptNLS.h"  #include "../resource.h"
31  #include "wptW32API.h"  #include "wptKeyserver.h"
32  #include "wptVersion.h"  #include "wptErrors.h"
33  #include "wptGPG.h"  #include "wptTypes.h"
34  #include "wptKeyManager.h"  #include "wptCommonCtl.h"
35  #include "wptContext.h" /* for passphrase_s */  #include "wptNLS.h"
36  #include "wptDlgs.h"  #include "wptW32API.h"
37    #include "wptVersion.h"
38    #include "wptGPG.h"
39  #define MAX_KEYSIZE 70000  #include "wptKeyManager.h"
40    #include "wptContext.h" /* for passphrase_s */
41  char * get_reg_entry_keyserver (const char *);  #include "wptDlgs.h"
42  int set_reg_entry_keyserver (const char *, const char *);  
43    
44    #define MAX_KEYSIZE 70000
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    
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, u16 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", host, port, winpt_strerror (rc));
56  int      if (err)
57  hkp_send_key (HWND dlg, const char *kserver, u16 port, const char *pattern)          msg_box (dlg, err, wsock_strerror (), MB_ERR);
58  {  } /* hkp_err_box */
59      gpgme_ctx_t c;  
60      gpgme_data_t keydata;  
61      gpgme_error_t ec;  int
62      char *rawkey = NULL, msg[1024];  hkp_send_key (HWND dlg, const char *kserver, u16 port, const char *pattern)
63      size_t n;  {
64      int rc;      gpgme_ctx_t c;
65            gpgme_data_t keydata;
66      ec = gpgme_new( &c );      gpgme_error_t ec;
67      if( ec )      char *rawkey = NULL, msg[1024];
68          BUG( NULL );      size_t n;
69      gpgme_set_armor (c, 1);      int rc;
70      ec = gpgme_data_new( &keydata );      
71      if( ec )      ec = gpgme_new( &c );
72          BUG( NULL );      if( ec )
73      rc = (int) gpgme_op_export( c, pattern, 0, keydata );          BUG( NULL );
74      if( rc ) {      gpgme_set_armor (c, 1);
75          msg_box( dlg, gpgme_strerror( (gpgme_error_t)rc ), _("Export"), MB_ERR );      ec = gpgme_data_new( &keydata );
76          goto leave;      if( ec )
77      }          BUG( NULL );
78      rawkey = gpgme_data_release_and_get_mem (keydata, &n);      rc = (int) gpgme_op_export( c, pattern, 0, keydata );
79      rc = kserver_sendkey (kserver, port, rawkey, n);      if( rc ) {
80      if (rc) {          msg_box( dlg, gpgme_strerror( (gpgme_error_t)rc ), _("Export"), MB_ERR );
81          hkp_err_box (dlg, kserver, port, rc);          goto leave;
82          goto leave;      }
83      }      rawkey = gpgme_data_release_and_get_mem (keydata, &n);
84            rc = kserver_sendkey (kserver, port, rawkey, n);
85      _snprintf (msg, sizeof (msg) -1, _("Key '%s' successfully sent"), pattern);      if (rc) {
86      status_box (dlg, msg, _("GnuPG status"));          hkp_err_box (dlg, kserver, port, rc);
87                goto leave;
88  leave:      }
89      gpgme_release (c);      
90      safe_free (rawkey);      _snprintf (msg, sizeof (msg) -1, _("Key '%s' successfully sent"), pattern);
91      return rc;      status_box (dlg, msg, _("GnuPG status"));
92  } /* hkp_send_key */      
93    leave:
94        gpgme_release (c);
95  int      if (rawkey)
96  hkp_recv_key (HWND dlg, const char *kserver, u16 port,          gpgme_free (rawkey);
97                const char *pattern, int proto, int flags)      return rc;
98  {  } /* hkp_send_key */
99      gpgme_ctx_t ctx;  
100      gpgme_data_t keydata;  
101      gpgme_error_t ec;  int
102      gpgme_import_result_t import_res;  hkp_recv_key (HWND dlg, const char *kserver, u16 port,
103      int rc;                const char *pattern, int proto, int flags)
104      char *rawkey = NULL, msg[384];  {
105            gpgme_ctx_t ctx;
106      rawkey = new char[MAX_KEYSIZE];      gpgme_data_t keydata;
107      if (!rawkey)      gpgme_error_t ec;
108          BUG (0);      gpgme_import_result_t import_res;
109      memset (rawkey, 0, MAX_KEYSIZE);      int rc;
110      if( proto == KSPROTO_LDAP ) {      char *rawkey = NULL, msg[384];
111          rc = ldap_recvkey( kserver, pattern, rawkey, MAX_KEYSIZE-1 );      
112          if( rc ) {      rawkey = new char[MAX_KEYSIZE];
113              msg_box( dlg, _("LDAP key import failed.\n"      if (!rawkey)
114                              "Please make sure you have an online connection"          BUG (0);
115                              " and gpgkeys_ldap.exe is installed"),      memset (rawkey, 0, MAX_KEYSIZE);
116                              _("Keyserver"), MB_ERR );      if( proto == KSPROTO_LDAP ) {
117              free_if_alloc( rawkey );          rc = ldap_recvkey( kserver, pattern, rawkey, MAX_KEYSIZE-1 );
118              return rc;          if( rc ) {
119          }              msg_box( dlg, _("LDAP key import failed.\n"
120      }                              "Please make sure you have an online connection"
121      else if (proto == KSPROTO_FINGER) {                              " and gpgkeys_ldap.exe is installed"),
122          rc = finger_recvkey (kserver, pattern, rawkey, MAX_KEYSIZE-1);                              _("Keyserver"), MB_ERR );
123          if (rc) {              free_if_alloc( rawkey );
124              log_box (_("Keyserver"), MB_ERR, _("Finger key import failed: %s\n"),              return rc;
125                       winpt_strerror (rc));          }
126              free_if_alloc (rawkey);      }
127              return rc;      else if (proto == KSPROTO_FINGER) {
128          }          rc = finger_recvkey (kserver, pattern, rawkey, MAX_KEYSIZE-1);
129      }          if (rc) {
130      else if( ( rc = kserver_recvkey( kserver, port, kserver_check_keyid( pattern ),              log_box (_("Keyserver"), MB_ERR, _("Finger key import failed: %s\n"),
131                                       rawkey, MAX_KEYSIZE-1 ) ) ) {                       winpt_strerror (rc));
132          hkp_err_box (dlg, kserver, port, rc);              free_if_alloc (rawkey);
133          free_if_alloc (rawkey);              return rc;
134          return rc;          }
135      }      }
136      else {      else if( ( rc = kserver_recvkey( kserver, port, kserver_check_keyid( pattern ),
137          if( !strstr( rawkey, "BEGIN PGP PUBLIC KEY BLOCK" ) ) {                                       rawkey, MAX_KEYSIZE-1 ) ) ) {
138              msg_box( dlg, _("This is not a valid OpenPGP key."), _("Keyserver"), MB_ERR );          hkp_err_box (dlg, kserver, port, rc);
139              goto leave;          free_if_alloc (rawkey);
140          }          return rc;
141          ec = gpgme_new( &ctx );      }
142          if( ec )      else {
143              BUG( NULL );          if( !strstr( rawkey, "BEGIN PGP PUBLIC KEY BLOCK" ) ) {
144          gpgme_data_new_from_mem( &keydata, rawkey, strlen( rawkey ), 1 );              msg_box( dlg, _("This is not a valid OpenPGP key."), _("Keyserver"), MB_ERR );
145          rc = gpgme_op_import( ctx, keydata );              goto leave;
146          if( rc ) {          }
147              msg_box( dlg, gpgme_strerror( (gpgme_error_t)rc ), _("Import"), MB_ERR );          ec = gpgme_new( &ctx );
148              goto leave;          if( ec )
149          }              BUG( NULL );
150          import_res = gpgme_op_import_result (ctx);          gpgme_data_new_from_mem( &keydata, rawkey, strlen( rawkey ), 1 );
151      }          rc = gpgme_op_import( ctx, keydata );
152                if( rc ) {
153      /* if we use the refresh mode, a lot of keys will be fetched and thus only              msg_box( dlg, gpgme_strerror( (gpgme_error_t)rc ), _("Import"), MB_ERR );
154         a summarize at the end is presented and not for each key. */              goto leave;
155      if (!(flags & KM_KS_REFRESH)) {          }
156          if (import_res->new_user_ids == 0) {          import_res = gpgme_op_import_result (ctx);
157              _snprintf (msg, DIM (msg)-1,      }
158                         _("Key '%s' successfully received but nothing was changed."), pattern );      
159              status_box (dlg, msg, _("GnuPG Status"));      /* if we use the refresh mode, a lot of keys will be fetched and thus only
160              rc = WPTERR_GENERAL;         a summarize at the end is presented and not for each key. */
161              goto leave;      if (!(flags & KM_KS_REFRESH)) {
162          }          if (import_res->new_user_ids == 0) {
163          _snprintf (msg, DIM (msg)-1, _("Key '%s' sucessfully received and imported."), pattern);              _snprintf (msg, DIM (msg)-1,
164          status_box (dlg, msg, _("GnuPG Status"));                         _("Key '%s' successfully received but nothing was changed."), pattern );
165      }              status_box (dlg, msg, _("GnuPG Status"));
166                    rc = WPTERR_GENERAL;
167  leave:              goto leave;
168      free_if_alloc (rawkey);          }
169      gpgme_release (ctx);          _snprintf (msg, DIM (msg)-1, _("Key '%s' sucessfully received and imported."), pattern);
170      gpgme_data_release (keydata);          status_box (dlg, msg, _("GnuPG Status"));
171        }
172      return rc;      
173  } /* hkp_recv_key */  leave:
174        free_if_alloc (rawkey);
175        gpgme_release (ctx);
176  #define my_iskeychar(a) ( ( (a) >='0' && (a) <= '9' ) || ( (a) >= 'A' && (a) <= 'F' ) )      gpgme_data_release (keydata);
177    
178  static int      return rc;
179  check_pattern( const char *pattern )  } /* hkp_recv_key */
180  {  
181      int rc = 1;  
182        #define my_iskeychar(a) ( ( (a) >='0' && (a) <= '9' ) || ( (a) >= 'A' && (a) <= 'F' ) )
183      /* Whitespace are not allowed! */  
184      if( strchr( pattern, ' ') ) {  static int
185          rc = WPTERR_GENERAL;  check_pattern( const char *pattern )
186          goto leave;  {
187      }      int rc = 1;
188            
189      if( (( strstr( pattern, "0x" ) ) && ( strlen( pattern ) == 10 ) )      /* Whitespace are not allowed! */
190           || (strstr(pattern, "0x")) && ( strlen( pattern )  == 18 ) ) {      if( strchr( pattern, ' ') ) {
191          rc = 0;          rc = WPTERR_GENERAL;
192          goto leave;          goto leave;
193      }      }
194            
195      if( (( my_iskeychar( pattern[0] )) && ( strlen( pattern )  == 8 ) )      if( (( strstr( pattern, "0x" ) ) && ( strlen( pattern ) == 10 ) )
196           || (my_iskeychar(pattern[0])) && ( strlen( pattern ) == 16) ) {           || (strstr(pattern, "0x")) && ( strlen( pattern )  == 18 ) ) {
197          rc = 0;          rc = 0;
198          goto leave;          goto leave;
199      }      }
200            
201      if( ( strchr( pattern, '@' ) ) && ( strlen( pattern ) >= 3 ) ) {      if( (( my_iskeychar( pattern[0] )) && ( strlen( pattern )  == 8 ) )
202          rc = 0;           || (my_iskeychar(pattern[0])) && ( strlen( pattern ) == 16) ) {
203          goto leave;          rc = 0;
204      }          goto leave;
205            }
206  leave:      
207      return rc;      if( ( strchr( pattern, '@' ) ) && ( strlen( pattern ) >= 3 ) ) {
208  } /* check_pattern */          rc = 0;
209            goto leave;
210        }
211  static void      
212  set_proxy (HWND dlg)  leave:
213  {      return rc;
214      char proxy[384];  } /* check_pattern */
215      int port = 0;  
216        
217      strcpy (proxy, "HTTP proxy: ");  static void
218      if (kserver_get_proxy (&port)) {  set_proxy (HWND dlg)
219          char t[256];  {
220          const char *http = kserver_get_proxy (&port);      char proxy[384];
221          _snprintf (t, sizeof (t) - 1, "\"%s:%d\"", http, port);      int port = 0;
222          strcat (proxy, t);      
223      }      strcpy (proxy, "HTTP proxy: ");
224      else      if (kserver_get_proxy (&port)) {
225          strcat( proxy, "none" );          char t[256];
226      SetDlgItemText( dlg, IDC_KEYSERVER_PROXY, proxy );          const char *http = kserver_get_proxy (&port);
227  } /* set_proxy */          _snprintf (t, sizeof (t) - 1, "\"%s:%d\"", http, port);
228            strcat (proxy, t);
229        }
230  static int inline      else
231  kserver_get_pos (listview_ctrl_t lv)          strcat( proxy, "none" );
232  {      SetDlgItemText( dlg, IDC_KEYSERVER_PROXY, proxy );
233      if (listview_count_items (lv, 0) == 1)  } /* set_proxy */
234          return 0;  
235      return listview_get_curr_pos (lv);  
236  }  static int inline
237    kserver_get_pos (listview_ctrl_t lv)
238    {
239  static u16 inline      if (listview_count_items (lv, 0) == 1)
240  kserver_get_port (listview_ctrl_t lv)          return 0;
241  {      return listview_get_curr_pos (lv);
242      char buf[16];  }
243    
244      listview_get_item_text (lv, kserver_get_pos (lv), 3, buf, 15);  
245      return (u16)strtoul (buf, NULL, 10);  static u16 inline
246  }  kserver_get_port (listview_ctrl_t lv)
247    {
248  static void      char buf[16];
249  load_default_ks (listview_ctrl_t lv)  
250  {      listview_get_item_text (lv, kserver_get_pos (lv), 3, buf, 15);
251      char * p, buf[192];      return (u16)strtoul (buf, NULL, 10);
252      int i;  }
253    
254      p = get_reg_entry_keyserver ("Default");  static void
255      if (!p)  load_default_ks (listview_ctrl_t lv)
256          return;  {
257      for( i = 0; i < listview_count_items( lv, 0 ); i++ ) {      char * p, buf[192];
258          listview_get_item_text( lv, i, 0, buf, sizeof (buf)-1 );      int i;
259          if( !strncmp( p, buf, strlen( p ) ) ) {  
260              listview_add_sub_item( lv, i, 2, "x" );      p = get_reg_entry_keyserver ("Default");
261              break;      if (!p)
262          }          return;
263      }      for( i = 0; i < listview_count_items( lv, 0 ); i++ ) {
264      free_if_alloc (p);          listview_get_item_text( lv, i, 0, buf, sizeof (buf)-1 );
265  } /* load_default_ks */          if( !strncmp( p, buf, strlen( p ) ) ) {
266                listview_add_sub_item( lv, i, 2, "x" );
267                break;
268  static int          }
269  save_default_ks (listview_ctrl_t lv)      }
270  {      free_if_alloc (p);
271      char buf[192], port[32];  } /* load_default_ks */
272      int idx, i;    
273    
274      idx = listview_get_curr_pos( lv );  static int
275      if( idx == -1 ) {  save_default_ks (listview_ctrl_t lv)
276          msg_box( NULL, _("Please select one of the servers."), _("Keyserver"), MB_ERR );  {
277          return -1;      char buf[192], port[32];
278      }      int idx, i;  
279      listview_get_item_text( lv, idx, 1, buf, sizeof (buf)-1 );  
280      if( *buf != 'H' ) {      idx = listview_get_curr_pos( lv );
281          msg_box( NULL, _("Only HTTP keyserver can be used."), _("Keyserver"), MB_ERR );      if( idx == -1 ) {
282          return -1;          msg_box( NULL, _("Please select one of the servers."), _("Keyserver"), MB_ERR );
283      }          return -1;
284      for (i = 0; i < listview_count_items( lv, 0 ); i++)      }
285          listview_add_sub_item (lv, i, 2, "");      listview_get_item_text( lv, idx, 1, buf, sizeof (buf)-1 );
286      listview_add_sub_item (lv, idx, 2, "x");      if( *buf != 'H' ) {
287      listview_get_item_text (lv, idx, 0, buf, sizeof (buf)-1);          msg_box( NULL, _("Only HTTP keyserver can be used."), _("Keyserver"), MB_ERR );
288      set_reg_entry_keyserver ("Default", buf);          return -1;
289      i = kserver_get_port (lv);      }
290      sprintf (port, "%d", i);      for (i = 0; i < listview_count_items( lv, 0 ); i++)
291      set_reg_entry_keyserver ("Default_Port", port);          listview_add_sub_item (lv, i, 2, "");
292      keyserver_set_default (buf, (u16)i);      listview_add_sub_item (lv, idx, 2, "x");
293      return 0;      listview_get_item_text (lv, idx, 0, buf, sizeof (buf)-1);
294  } /* save_default_ks */      set_reg_entry_keyserver ("Default", buf);
295        i = kserver_get_port (lv);
296        sprintf (port, "%d", i);
297  int      set_reg_entry_keyserver ("Default_Port", port);
298  keyserver_list_build (listview_ctrl_t *r_lv, HWND hwnd)      keyserver_set_default (buf, (u16)i);
299  {      return 0;
300      struct listview_column_s keyserver[] = {  } /* save_default_ks */
301          {0, 160, (char *)_("DNS Name")},          
302          {1,  52, (char *)_("Protocol")},  
303          {2,  46, (char *)_("Default")},  int
304          {3,  46, (char *)_("Port")},  keyserver_list_build (listview_ctrl_t *r_lv, HWND hwnd)
305          {0,   0, NULL}  {
306      };      struct listview_column_s keyserver[] = {
307      listview_ctrl_t lv;          {0, 160, (char *)_("DNS Name")},        
308      char buf[32];          {1,  52, (char *)_("Protocol")},
309      int j;          {2,  46, (char *)_("Default")},
310            {3,  46, (char *)_("Port")},
311      listview_new (&lv);              {0,   0, NULL}
312      lv->ctrl = hwnd;            };
313      for (j=0; keyserver[j].fieldname; j++)      listview_ctrl_t lv;
314          listview_add_column (lv, &keyserver[j]);              char buf[32];
315      for (j = 0; j<MAX_KEYSERVERS; j++) {      int j;
316          if (!server[j].used)  
317              continue;      listview_new (&lv);    
318          listview_add_item (lv, " ");      lv->ctrl = hwnd;      
319          listview_add_sub_item (lv, 0, 0, server[j].name);      for (j=0; keyserver[j].fieldname; j++)
320          switch (server[j].proto) {          listview_add_column (lv, &keyserver[j]);        
321          case KSPROTO_HTTP:      for (j = 0; j<MAX_KEYSERVERS; j++) {
322              listview_add_sub_item( lv, 0, 1, "H" ); break;          if (!server[j].used)
323          case KSPROTO_LDAP:              continue;
324              listview_add_sub_item( lv, 0, 1, "L" ); break;          listview_add_item (lv, " ");
325          case KSPROTO_FINGER:          listview_add_sub_item (lv, 0, 0, server[j].name);
326              listview_add_sub_item( lv, 0, 1, "F" ); break;          switch (server[j].proto) {
327          }          case KSPROTO_HTTP:
328          sprintf (buf, "%d", server[j].port);              listview_add_sub_item( lv, 0, 1, "H" ); break;
329          listview_add_sub_item (lv, 0, 3, buf);          case KSPROTO_LDAP:
330      }              listview_add_sub_item( lv, 0, 1, "L" ); break;
331      load_default_ks (lv);          case KSPROTO_FINGER:
332      if (listview_count_items (lv, 0) == 0) {              listview_add_sub_item( lv, 0, 1, "F" ); break;
333          listview_add_item (lv, "");          }
334          listview_add_sub_item (lv, 0, 0, DEF_HKP_KEYSERVER);          sprintf (buf, "%d", server[j].port);
335          listview_add_sub_item (lv, 0, 1, "H");          listview_add_sub_item (lv, 0, 3, buf);
336      }      }
337      listview_set_ext_style (lv);      load_default_ks (lv);
338      *r_lv = lv;      if (listview_count_items (lv, 0) == 0) {
339      return 0;          listview_add_item (lv, "");
340  }          listview_add_sub_item (lv, 0, 0, DEF_HKP_KEYSERVER);
341            listview_add_sub_item (lv, 0, 1, "H");
342        }
343  BOOL CALLBACK      listview_set_ext_style (lv);
344  keyserver_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)      *r_lv = lv;
345  {      return 0;
346      static listview_ctrl_t lv = NULL;  }
347      static int lv_idx = 0;  
348      int rc, proto_nr = 0;  
349      char kserver[128], pattern[128];  BOOL CALLBACK
350      char proto[16];      keyserver_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
351      keyserver_ctx ksc;  {
352            static listview_ctrl_t lv = NULL;
353      switch ( msg ) {      static int lv_idx = 0;
354      case WM_INITDIALOG:      int rc, proto_nr = 0;
355  #ifndef LANG_DE      char kserver[128], pattern[128];
356          SetWindowText( dlg, _("Keyserver Access") );      char proto[16];    
357          SetDlgItemText( dlg, IDC_KEYSERVER_SEND,      keyserver_ctx ksc;
358                          _("Send key (default is receiving)") );      
359          SetDlgItemText( dlg, IDC_KEYSERVER_INFO,      switch ( msg ) {
360                          _("Please enter the key ID or email address you search for"));      case WM_INITDIALOG:
361          SetDlgItemText( dlg, IDC_KEYSERVER_INDEX, _("&Search") );      #ifndef LANG_DE
362  #endif          SetWindowText (dlg, _("Keyserver Access"));
363          set_proxy (dlg);          SetDlgItemText (dlg, IDC_KEYSERVER_RECV, _("&Receive"));
364          keyserver_list_build (&lv, GetDlgItem (dlg, IDC_KEYSERVER_LIST));          SetDlgItemText (dlg, IDC_KEYSERVER_SEND,
365          center_window (dlg, NULL);                          _("Send key (default is receiving)"));
366          SetForegroundWindow (dlg);          SetDlgItemText (dlg, IDC_KEYSERVER_INFO,
367          return TRUE;                          _("Please enter the key ID or email address you search for"));
368                    SetDlgItemText (dlg, IDC_KEYSERVER_INDEX, _("&Search"));
369      case WM_NOTIFY:          SetDlgItemText (dlg, IDC_KEYSERVER_PROXSETT, _("C&hange"));
370          NMHDR *notify;          SetDlgItemText (dlg, IDC_KEYSERVER_DEFAULT, _("Set &default"));
371          notify = (NMHDR *)lparam;      #endif
372          if( notify && notify->code == NM_CLICK          set_proxy (dlg);
373              && notify->idFrom == IDC_KEYSERVER_LIST )          keyserver_list_build (&lv, GetDlgItem (dlg, IDC_KEYSERVER_LIST));
374              lv_idx = listview_get_curr_pos( lv );          center_window (dlg, NULL);
375          return TRUE;          SetForegroundWindow (dlg);
376                    return TRUE;
377      case WM_DESTROY:          
378          if( lv ) {      case WM_NOTIFY:
379              listview_release( lv );          NMHDR *notify;
380              lv = NULL;          notify = (NMHDR *)lparam;
381          }          if( notify && notify->code == NM_CLICK
382          lv_idx = 0;              && notify->idFrom == IDC_KEYSERVER_LIST )
383          return FALSE;              lv_idx = listview_get_curr_pos( lv );
384                    return TRUE;
385      case WM_SYSCOMMAND:          
386          if( LOWORD( wparam ) == SC_CLOSE )      case WM_DESTROY:
387              EndDialog( dlg, TRUE );          if( lv ) {
388          return FALSE;              listview_release( lv );
389                        lv = NULL;
390      case WM_COMMAND:          }
391          switch( LOWORD( wparam ) ) {          lv_idx = 0;
392          case IDC_KEYSERVER_PROXSETT:          return FALSE;
393              dialog_box_param( glob_hinst, (LPCTSTR)IDD_WINPT_KEYSERVER_PROXY, glob_hwnd,          
394                                keyserver_proxy_dlg_proc, NULL,      case WM_SYSCOMMAND:
395                                _("Proxy Settings"), IDS_WINPT_KEYSERVER_PROXY );          if( LOWORD( wparam ) == SC_CLOSE )
396              set_proxy( dlg );              EndDialog( dlg, TRUE );
397              return TRUE;          return FALSE;
398                        
399          case IDC_KEYSERVER_INDEX:      case WM_COMMAND:
400              if (!lv_idx) {          switch( LOWORD( wparam ) ) {
401                  lv_idx = kserver_get_pos (lv);          case IDC_KEYSERVER_PROXSETT:
402                  if (lv_idx == -1) {              dialog_box_param( glob_hinst, (LPCTSTR)IDD_WINPT_KEYSERVER_PROXY, glob_hwnd,
403                      msg_box (dlg, _("Please select one of the keyservers."), _("Keyserver"), MB_INFO);                                keyserver_proxy_dlg_proc, NULL,
404                      return FALSE;                                _("Proxy Settings"), IDS_WINPT_KEYSERVER_PROXY );
405                  }              set_proxy( dlg );
406              }              return TRUE;
407              listview_get_item_text (lv, lv_idx, 1, proto, sizeof (proto)-1);              
408              if (*proto == 'L') {          case IDC_KEYSERVER_INDEX:
409                  msg_box( dlg, _("This is not implemented yet!"), _("Keyserver"), MB_ERR );              if (!lv_idx) {
410                  return FALSE;                  lv_idx = kserver_get_pos (lv);
411              }                  if (lv_idx == -1) {
412              listview_get_item_text (lv, lv_idx, 0, kserver, sizeof (kserver)-1);                      msg_box (dlg, _("Please select one of the keyservers."), _("Keyserver"), MB_INFO);
413              if (!GetDlgItemText (dlg, IDC_KEYSERVER_SEARCH, pattern, sizeof (pattern)-1)) {                      return FALSE;
414                  msg_box (dlg, _("Please enter the search pattern."), _("Keyserver"), MB_INFO);                  }
415                  return FALSE;              }
416              }              listview_get_item_text (lv, lv_idx, 1, proto, sizeof (proto)-1);
417              ksc.name = kserver;              if (*proto == 'L') {
418              ksc.pattern = pattern;                  msg_box( dlg, _("This is not implemented yet!"), _("Keyserver"), MB_ERR );
419              ksc.port = kserver_get_port (lv);                  return FALSE;
420              DialogBoxParam( glob_hinst, (LPCSTR)IDD_WINPT_HKPSEARCH, dlg,              }
421                              hkpsearch_dlg_proc, (LPARAM) &ksc );              listview_get_item_text (lv, lv_idx, 0, kserver, sizeof (kserver)-1);
422              return TRUE;              if (!GetDlgItemText (dlg, IDC_KEYSERVER_SEARCH, pattern, sizeof (pattern)-1)) {
423                                msg_box (dlg, _("Please enter the search pattern."), _("Keyserver"), MB_INFO);
424          case IDC_KEYSERVER_RECV:                  return FALSE;
425              memset (&kserver, 0, sizeof (kserver));              }
426              if (!lv_idx) {              ksc.name = kserver;
427                  lv_idx = kserver_get_pos (lv);              ksc.pattern = pattern;
428                  if (lv_idx == -1) {              ksc.port = kserver_get_port (lv);
429                      msg_box( dlg, _("Please select one of the keyservers."), _("Keyserver"), MB_INFO );              DialogBoxParam( glob_hinst, (LPCSTR)IDD_WINPT_HKPSEARCH, dlg,
430                      return FALSE;                              hkpsearch_dlg_proc, (LPARAM) &ksc );
431                  }              return TRUE;
432              }              
433              listview_get_item_text( lv, lv_idx, 1, proto, sizeof (proto)-1 );          case IDC_KEYSERVER_RECV:
434              proto_nr = KSPROTO_HTTP;              memset (&kserver, 0, sizeof (kserver));
435              if( *proto == 'L' )              if (!lv_idx) {
436                  proto_nr = KSPROTO_LDAP;                  lv_idx = kserver_get_pos (lv);
437              else if( *proto == 'F' )                  if (lv_idx == -1) {
438                  proto_nr = KSPROTO_FINGER;                      msg_box( dlg, _("Please select one of the keyservers."), _("Keyserver"), MB_INFO );
439              listview_get_item_text( lv, lv_idx, 0, kserver, sizeof (kserver)-1 );                      return FALSE;
440              if( !GetDlgItemText( dlg, IDC_KEYSERVER_SEARCH, pattern, sizeof (pattern)-1 ) ) {                  }
441                  msg_box( dlg, _("Please enter the search pattern."), _("Keyserver"), MB_INFO );              }
442                  return FALSE;              listview_get_item_text( lv, lv_idx, 1, proto, sizeof (proto)-1 );
443              }              proto_nr = KSPROTO_HTTP;
444              if( proto_nr == KSPROTO_LDAP && strchr( pattern, '@' ) ) {              if( *proto == 'L' )
445                  msg_box( dlg, _("Only keyids are allowed."), _("LDAP Keyserver"), MB_INFO );                  proto_nr = KSPROTO_LDAP;
446                  return FALSE;              else if( *proto == 'F' )
447              }                  proto_nr = KSPROTO_FINGER;
448              else if (proto_nr == KSPROTO_FINGER) {              listview_get_item_text( lv, lv_idx, 0, kserver, sizeof (kserver)-1 );
449                  if (strchr (pattern, '@') || strchr (pattern, ' ')) {              if( !GetDlgItemText( dlg, IDC_KEYSERVER_SEARCH, pattern, sizeof (pattern)-1 ) ) {
450                      msg_box (dlg, _("Only enter the name of the user."), _("FINGER Keyserver"), MB_INFO);                  msg_box( dlg, _("Please enter the search pattern."), _("Keyserver"), MB_INFO );
451                      return FALSE;                  return FALSE;
452                  }              }
453              }              if( proto_nr == KSPROTO_LDAP && strchr( pattern, '@' ) ) {
454              else if( check_pattern( pattern ) ) {                  msg_box( dlg, _("Only keyids are allowed."), _("LDAP Keyserver"), MB_INFO );
455                  msg_box( dlg, _("Only email addresses or keyids are allowed."), _("HKP Keyserver"), MB_INFO );                  return FALSE;
456                  return FALSE;              }
457              }              else if (proto_nr == KSPROTO_FINGER) {
458              rc = hkp_recv_key (dlg, kserver, kserver_get_port (lv), pattern, proto_nr, 0);                  if (strchr (pattern, '@') || strchr (pattern, ' ')) {
459              if (!rc)                      msg_box (dlg, _("Only enter the name of the user."), _("FINGER Keyserver"), MB_INFO);
460                  keycache_set_reload (1);                      return FALSE;
461              return TRUE;                  }
462                }
463          case IDC_KEYSERVER_DEFAULT:              else if( check_pattern( pattern ) ) {
464              save_default_ks( lv );                  msg_box( dlg, _("Only email addresses or keyids are allowed."), _("HKP Keyserver"), MB_INFO );
465              break;                  return FALSE;
466                            }
467          case IDCANCEL:              rc = hkp_recv_key (dlg, kserver, kserver_get_port (lv), pattern, proto_nr, 0);
468              EndDialog( dlg, FALSE );              if (!rc)
469              return FALSE;                  keycache_set_reload (1);
470          }              return TRUE;
471          break;  
472      }          case IDC_KEYSERVER_DEFAULT:
473                    save_default_ks( lv );
474      return FALSE;              break;
475  } /* keyserver_dlg_proc */              
476            case IDCANCEL:
477                EndDialog( dlg, FALSE );
478                return FALSE;
479            }
480            break;
481        }
482        
483        return FALSE;
484    } /* keyserver_dlg_proc */
Legend:
Removed from v.25  
changed lines
  Added in v.36
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26