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