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

Diff of /trunk/Src/WinPT.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 34 by twoaday, Wed Oct 26 11:20:09 2005 UTC
# Line 17  Line 17 
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  #include <windows.h>  #include <windows.h>
21    
22  #include "../resource.h"  #include "../resource.h"
# Line 34  Line 33 
33  #include "wptCard.h"  #include "wptCard.h"
34  #include "wptFileManager.h"  #include "wptFileManager.h"
35  #include "wptContext.h"  #include "wptContext.h"
36    #include "wptCardEdit.h"
37    
38    
39    #define MIN_GPG_VER   "1.4.3"   /* Minimal GPG version. */
40    #define MIN_GPGME_VER "1.2.0"   /* Minimal GPGME version. */
41    #define MIN_PTD_VER   "0.8.1"   /* Minimal PTD version. */
42    
43    
44  HINSTANCE glob_hinst; /* global instance for the dialogs */  HINSTANCE glob_hinst;   /* global instance for the dialogs */
45  HWND glob_hwnd; /* global window handle for the dialogs */  HWND glob_hwnd;         /* global window handle for the dialogs */
46  HWND activ_hwnd;  HWND activ_hwnd;
47  LOCK mo_file;  LOCK mo_file;
48  int scard_support = 0;  int scard_support = 0;
49  int debug = 0;  int debug = 0;
50    int mobile = 0;
51  int gpg_read_only = 0;  int gpg_read_only = 0;
52  char gpgver[3];  char gpgver[3];
53    
54    
55    /* Load the key cache and rebuild the signature cache. */
56  static void  static void
57  update_keycache (HWND hwnd)  update_keycache (HWND hwnd)
58  {  {
# Line 54  update_keycache (HWND hwnd) Line 62  update_keycache (HWND hwnd)
62      rcs.tr_update = 1;      rcs.tr_update = 1;
63      DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,      DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, hwnd,
64                      keycache_dlg_proc, (LPARAM)&rcs);                      keycache_dlg_proc, (LPARAM)&rcs);
65  } /* update_keycache */  }
66    
67    
68    /* Set GPGME debug mode. If @val is 0, the debug mode is disabled. */
69    void
70    gpg_set_debug_mode (int val)
71    {      
72        if (val)
73            putenv ("GPGME_DEBUG=5:gpgme.dbg");
74        else
75            putenv ("GPGME_DEBUG=");
76    }
77    
78    
79  static char *  /* Return the name of the gettext language file. */
80    static char*
81  get_gettext_lang (void)  get_gettext_lang (void)
82  {      {    
83      char * fname;      char *fname;
84      fname = get_reg_entry_mo ();      fname = get_reg_entry_mo ();
85      if (!fname)      if (!fname)
86          return NULL;          return NULL;
87      return fname;      return fname;
88  } /* get_gettext_lang */  }
89    
90    
91    /* Initialize the gettext sub system. */
92  static void  static void
93  load_gettext (void)  load_gettext (int prev_inst)
94  {  {
95      char * nls = NULL;      char *nls = NULL;
96      char * file = NULL;      char *file = NULL;
97    
98      nls = get_gettext_lang ();      nls = get_gettext_lang ();
99      if (nls) {      if (nls) {
100          set_gettext_file ("winpt", nls);          set_gettext_file ("winpt", nls);
101          file = make_filename (nls, "winpt", "mo");          file = make_filename (nls, "winpt", "mo");
102          if (!file_exist_check (nls) && init_file_lock (&mo_file, file))  {          if (!file_exist_check (nls) && init_file_lock (&mo_file, file))  {
103              msg_box (NULL, _("Could not initizalize file lock.\n"              if (!prev_inst)
104                               "Native Language Support"),                  msg_box (NULL, _("Could not initizalize file lock.\n"
105                       _("WinPT Error"), MB_ERR);                                   "Native Language Support"),
106                             _("WinPT Error"), MB_ERR);
107          }          }
108          free_if_alloc (nls);          free_if_alloc (nls);
109          free_if_alloc (file);          free_if_alloc (file);
110      }      }
111  } /* load_gettext */  }
112    
113    
114  /* check if the default key from the gpg.conf file is available in the  /* check if the default key from the gpg.conf file is available in the
115     keyring. if not, bail out because encryption won't work properly then. */     keyring. if not, bail out because encryption won't work properly then. */
116  static int  static int
117  check_default_key (gpgme_keycache_t kc)  check_default_key (gpg_keycache_t kc)
118  {  {
119      gpgme_key_t key;      gpgme_key_t key;
120      gpgme_error_t err = GPGME_No_Error;      gpgme_error_t err = GPG_ERR_NO_ERROR;
121      char * defkey;      char * defkey;
122    
123      defkey = get_gnupg_default_key ();      defkey = get_gnupg_default_key ();
124      if (defkey)      if (defkey)
125          err = gpgme_keycache_find_key (kc, defkey, 0, &key);          err = gpg_keycache_find_key (kc, defkey, 0, &key);
126      free_if_alloc (defkey);      free_if_alloc (defkey);
127      return err? -1 : 0;      return err? -1 : 0;
128  } /* check_default_key */  }
129    
130    
131  /* Return the WinPT program file name (with full pathname). */  /* Return the WinPT program file name (with full pathname). */
132  static const char *  static const char *
133  get_prog_part (const char * fname, int use_cwd)  get_prog_part (const char * fname, int use_cwd)
134  {  {
135      static char program[1024];      static char program[512];
136      char currdir[256], * cmd = NULL;      char currdir[256];
137        char *cmd = NULL;
138      int j;      int j;
139                    
140      memset (currdir, 0, DIM (currdir));      memset (currdir, 0, DIM (currdir));
# Line 125  get_prog_part (const char * fname, int u Line 148  get_prog_part (const char * fname, int u
148          cmd = GetCommandLine ();          cmd = GetCommandLine ();
149          if (cmd == NULL)          if (cmd == NULL)
150              return NULL;              return NULL;
151          strncpy (currdir, cmd, 255);          strncpy (currdir, cmd, sizeof (currdir)-1);
152          j = strlen (currdir);          j = strlen (currdir);
153          while (j--)          while (j--) {
         {        
154              if (currdir[j] == '\\')              if (currdir[j] == '\\')
155                  break;                            break;
156          }          }
157          currdir[j] = 0;          currdir[j] = 0;
158          _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);          _snprintf (program, DIM (program)-1, "%s\\%s", currdir + 1, fname);
159      }      }
160      return program;      return program;
161  } /* get_prog_part */  }
162    
163    
164    /* Check that the underlying crypto engine fullfills the minimal
165       requirements so all commands work properly. */
166  static int  static int
167  check_crypto_engine (void)  check_crypto_engine (void)
168  {  {
169      int ma=1, mi=2, pa=4; /* GPG 1.2.4 */      int ma=1, mi=4, pa=3; /* GPG 1.4.3 */
170      int rc;      int rc;
171    
172      rc = check_gnupg_engine (&ma, &mi, &pa);      rc = check_gnupg_engine (&ma, &mi, &pa);
173      if (rc == -1) {      if (rc == -1) {
174          msg_box (NULL, _("Could not read GnuPG version."), _("WinPT Error"), MB_ERR);          msg_box (NULL, _("Could not read GnuPG version."),
175                     _("WinPT Error"), MB_ERR);
176          return rc;          return rc;
177      }      }
178      else if (rc) {      else if (rc) {
179          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
180                   _("Sorry, you need a newer GPG version.\n"                   _("Sorry, you need a newer GPG version.\n"
181                     "GPG version %d.%d.%d requred GPG version 1.2.4"),                     "GPG version %d.%d.%d required GPG version "MIN_GPG_VER),
182                     ma, mi, pa);                     ma, mi, pa);
183          return rc;          return rc;
184      }      }
185      /* We enable smartcard support for GPG: 1.9.x and >= 1.3.90 */      /* We enable smartcard support for GPG: 1.9 or >= 1.4 */
186      if (ma > 1 || mi >= 9 || mi > 3)      if (ma >= 1 && mi >= 4)
187          scard_support = 1;          scard_support = 1;
188    
189      gpgver[0] = ma;      gpgver[0] = ma;
190      gpgver[1] = mi;      gpgver[1] = mi;
191      gpgver[2] = pa;      gpgver[2] = pa;
192      return rc;      return rc;
193  } /* check_crypto_engine */  }
194    
195    
196    /* Try to load the keyserver config file. If @quiet is 1
197       do not show any errors. */
198  static int  static int
199  load_keyserver_conf (int quiet)  load_keyserver_conf (int quiet)
200  {  {
# Line 187  load_keyserver_conf (int quiet) Line 214  load_keyserver_conf (int quiet)
214  }  }
215    
216    
217    /* Enable the mobility mode. */
218    static void
219    enable_mobile_mode (void)
220    {
221        memset (&reg_prefs, 0, sizeof (reg_prefs));
222        reg_prefs.always_trust = 0;
223        reg_prefs.auto_backup = 0;
224        reg_prefs.cache_time = 0;
225        reg_prefs.expert = 0;
226        reg_prefs.keylist_mode = 1;
227        reg_prefs.kserv_conf = m_strdup ("keyserver.conf");
228        reg_prefs.no_zip_mmedia = 1;
229        reg_prefs.use_tmpfiles = 1;
230        reg_prefs.word_wrap = 80;
231        reg_prefs.use_viewer = 0; /* XXX */
232    }
233    
234    char* multi_gnupg_path (void);
235    
236    /* Main entry point. */
237  int WINAPI  int WINAPI
238  WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)  WinMain (HINSTANCE hinst, HINSTANCE hprev, LPSTR cmdline, int showcmd)
239  {  {
# Line 194  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 241  WinMain (HINSTANCE hinst, HINSTANCE hpre
241      HACCEL accel_tab;      HACCEL accel_tab;
242      int rc, ec, created = 0, use_cwd = 0, nfiles = 0;      int rc, ec, created = 0, use_cwd = 0, nfiles = 0;
243      int first_start = 0, start_gpgprefs = 0;      int first_start = 0, start_gpgprefs = 0;
244      const char * s;      int winpt_inst_found = 0;
245        const char *s;
246      MSG msg;      MSG msg;
247      HWND hwnd;      HWND hwnd = NULL;
248    
249      glob_hinst = hinst;      glob_hinst = hinst;
250        
     gpgme_lib_init ();  
251      #ifdef _DEBUG      #ifdef _DEBUG
252      gpgme_set_debug_mode (1);      gpg_set_debug_mode (1);
253        debug = 1;
254      #endif      #endif
     gpgme_set_pgm_string ("WinPT "PGM_VERSION);  
255    
256      s = PTD_get_version ();      s = PTD_get_version ();
257      if (strcmp (s, "0.8.0"))      if (strcmp (s, MIN_PTD_VER)) {
     {  
258          log_box (_("Privacy Tray Dynamic (PTD)"), MB_ERR,          log_box (_("Privacy Tray Dynamic (PTD)"), MB_ERR,
259                   _("Please update your PTD.dll to the newest version, "                   _("Please update your PTD.dll to the newest version, "
260                     "the version (%s) you use is too old."), s);                     "the version (%s) you use is too old."), s);
261          return 0;          return 0;
262      }      }
263    
264      if (gpg_md_selftest ())      if (gpg_md_selftest ()) {
     {  
265          msg_box (NULL, _("Cryptographic selftest failed."),          msg_box (NULL, _("Cryptographic selftest failed."),
266                   _("WinPT Error"), MB_ERR);                   _("WinPT Error"), MB_ERR);
267          return 0;          return 0;
268      }      }
269    
270        s = gpgme_check_version (MIN_GPGME_VER);
271        if (!s || !*s) {
272            msg_box (NULL, _("A newer GPGME version is needed; at least "MIN_GPGME_VER),
273                     _("WinPT Error"), MB_ERR);
274            return 0;
275        }
276    
277        CreateMutex (NULL, TRUE, PGM_NAME);
278        if (GetLastError () == ERROR_ALREADY_EXISTS)
279            winpt_inst_found = 1;
280    
281        if (cmdline && stristr (cmdline, "--mobile")) {
282            msg_box (NULL, "WARNING: mobile modus is not fully implemented yet!",
283                     "WinPT", MB_INFO);
284            mobile = 1;
285        }
286    
287      set_default_kserver ();      set_default_kserver ();
288      regist_inst_gnupg (1);  
289      regist_inst_winpt (1, &created);      if (!mobile) {
290      if (!created)          regist_inst_gnupg (1);
291      {          regist_inst_winpt (1, &created);
292        }
293        else {
294            enable_mobile_mode ();
295            /* XXX: ask for GPG path */
296            created = 1; /* Disable registry writing */
297        }
298    
299        if (!created) {
300          memset (&reg_prefs, 0, sizeof (reg_prefs));          memset (&reg_prefs, 0, sizeof (reg_prefs));
301          reg_prefs.use_tmpfiles = 1; /* default */          reg_prefs.use_tmpfiles = 1; /* default */
302            reg_prefs.fm.progress = 0; /* XXX: fix the bug and enable it again */
303          get_reg_winpt_prefs (&reg_prefs);          get_reg_winpt_prefs (&reg_prefs);
304          if (!reg_prefs.no_hotkeys)          if (!reg_prefs.no_hotkeys)
305              hotkeys_modify ();              hotkeys_modify ();
306      }      }
307    
308      rc = gnupg_check_homedir ();      rc = gnupg_check_homedir ();
309      if (rc)      if (rc) {
     {  
310          log_box (_("WinPT Error"), MB_ERR,          log_box (_("WinPT Error"), MB_ERR,
311                   _("GPG home directory is not set correctly.\n"                   _("GPG home directory is not set correctly.\n"
312                     "Please check the GPG registry settings:\n%s."),                     "Please check the GPG registry settings:\n%s."),
313                   winpt_strerror (rc));                   winpt_strerror (rc));
314          const char * s = get_filename_dlg (GetActiveWindow (), FILE_OPEN,          const char * s = get_fileopen_dlg (GetActiveWindow (),
315                                             _("Select GPG Public Keyring"),                                             _("Select GPG Public Keyring"),
316                                             _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),                                             _("GPG Keyrings (*.gpg)\0*.gpg\0\0"),
317                                             NULL);                                             NULL);
318          if (s && !file_exist_check (s))          if (s != NULL) {
         {  
319              size_t n;              size_t n;
320              char * p = strrchr (s, '\\');              char * p = strrchr (s, '\\');
321              if (!p)              if (!p)
322                  BUG (0);                  BUG (0);
323              n = p - s;              n = p - s;
324              if (n)              if (n) {
             {  
325                  char * file = new char[n+1];                  char * file = new char[n+1];
326                  if (!file)                  if (!file)
327                      BUG (NULL);                      BUG (NULL);
# Line 265  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 333  WinMain (HINSTANCE hinst, HINSTANCE hpre
333                  gnupg_check_homedir (); /* change gpgProgram if needed */                  gnupg_check_homedir (); /* change gpgProgram if needed */
334              }              }
335          }          }
336          else          else {
         {  
337              msg_box (NULL, _("GPG home directory could not be determited."),              msg_box (NULL, _("GPG home directory could not be determited."),
338                       _("WinPT Error"), MB_ERR);                       _("WinPT Error"), MB_ERR);
339              goto start;              goto start;
# Line 274  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 341  WinMain (HINSTANCE hinst, HINSTANCE hpre
341      }      }
342    
343      rc = check_gnupg_prog ();      rc = check_gnupg_prog ();
344      if (rc)      if (rc) {
     {  
345          if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"          if (msg_box (NULL, _("Could not find the GPG binary (gpg.exe).\n"
346                               "Do you want to start the GPG preferences to "                               "Do you want to start the GPG preferences to "
347                               "correct  this problem?"), _("WinPT Error"),                               "correct  this problem?"), _("WinPT Error"),
# Line 289  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 355  WinMain (HINSTANCE hinst, HINSTANCE hpre
355      }      }
356    
357      rc = gnupg_access_files ();      rc = gnupg_access_files ();
358      if (!start_gpgprefs && rc)      if (!start_gpgprefs && rc) {
359      {          if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS) {
         if (rc == WPTERR_GPG_KEYRINGS || rc == WPTERR_GPG_OPT_KEYRINGS)  
         {  
360              ec = msg_box (NULL,              ec = msg_box (NULL,
361                  _("Could not access and/or find the public and secret keyring.\n"                  _("Could not access and/or find the public and secret keyring.\n"
362                    "If this is an accident, quit the program and fix it.\n\n"                    "If this is an accident, quit the program and fix it.\n\n"
# Line 301  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 365  WinMain (HINSTANCE hinst, HINSTANCE hpre
365              if (ec == IDYES)              if (ec == IDYES)
366                  first_start = 1;                  first_start = 1;
367          }          }
368          if (!first_start)          if (!first_start) {
         {  
369              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);              msg_box (NULL, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
370              return 0;              return 0;
371          }          }
372      }      }
373    
374      if (!first_start)      if (!first_start) {
     {  
375          rc = gpg_check_permissions (1);          rc = gpg_check_permissions (1);
376          if (rc && rc == 2)          if (rc && rc == 2)
377              gpg_read_only = 1;              gpg_read_only = 1;
# Line 317  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 379  WinMain (HINSTANCE hinst, HINSTANCE hpre
379              return 0;              return 0;
380      }      }
381    
382      load_gettext ();      load_gettext (winpt_inst_found);
383      init_gnupg_table ();      init_gnupg_table ();
384    
385      nfiles = fm_parse_command_line (cmdline);      nfiles = fm_parse_command_line (cmdline);
386      if (nfiles > 0)      if (nfiles > 0) {
387            free_gnupg_table ();
388          return 0;          return 0;
389        }
390    
391      if (cmdline && stristr (cmdline, "--wipe-freespace")) {      if (cmdline && stristr (cmdline, "--wipe-freespace")) {
392          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,          dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL,
# Line 333  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 397  WinMain (HINSTANCE hinst, HINSTANCE hpre
397      }      }
398    
399      load_keyserver_conf (cmdline? 1 : 0);      load_keyserver_conf (cmdline? 1 : 0);
400    
401      if (cmdline && (stristr (cmdline, "--keymanager")      if (cmdline && (stristr (cmdline, "--keymanager")
402                  || stristr (cmdline, "--cardmanager"))) {                  || stristr (cmdline, "--cardmanager"))) {
403          update_keycache (GetDesktopWindow ());          update_keycache (GetDesktopWindow ());
404          if (stristr (cmdline, "keymanager"))          if (stristr (cmdline, "keymanager"))
405              dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,              dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYMISC,
406                              GetDesktopWindow(), keymanager_dlg_proc, NULL,                              GetDesktopWindow(), keymanager_dlg_proc, NULL,
407                              _("Key Manager"), IDS_WINPT_KEYMISC);                              _("Key Manager"), IDS_WINPT_KEYMISC);  
408          else {          else {
409              gpgme_card_t crd = smartcard_init ();              gpg_card_t crd = gpg_card_load ();
410              if (crd)              if (crd)
411                  dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_CARD_EDIT,                  dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_CARD_EDIT,
412                                    GetDesktopWindow(), card_edit_dlg_proc,                                    GetDesktopWindow(), card_edit_dlg_proc,
413                                    (LPARAM)crd, _("Card Manager"),                                    (LPARAM)crd, _("Card Manager"),
414                                    IDS_WINPT_CARD_EDIT);                                    IDS_WINPT_CARD_EDIT);
415              gpgme_card_release (crd);              gpg_card_release (crd);
416          }          }
417          keycache_release ();          keycache_release (0);
418          free_gnupg_table ();          free_gnupg_table ();
419          return 0;          return 0;
420      }      }
421    
422      CreateMutex (NULL, TRUE, PGM_NAME);      /* If we found another WinPT instance, just quit to avoid it
423      if (GetLastError () == ERROR_ALREADY_EXISTS) {         will be executed twice. */
424        if (winpt_inst_found) {
425            log_debug ("%s", "WinMain: WinPT is already running.");
426          free_gnupg_table ();          free_gnupg_table ();
427          return 0;          return 0;
428      }      }
429    
430      /*if (file_exist_check ("loadimage.exe"))      if (cmdline) {
431          PTD_create_loadimage (NULL);*/          if (stristr (cmdline, "--enable-debug") || stristr (cmdline, "--debug")) {
432                        gpg_set_debug_mode (1);
433      if (cmdline && stristr (cmdline, "--enable-debug")) {              winpt_debug_msg ();
434          gpgme_set_debug_mode (1);              debug = 1;
435          winpt_debug_msg ();          }
         debug = 1;  
436      }      }
437    
438      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));      wc.hIcon = LoadIcon (glob_hinst, MAKEINTRESOURCE (IDI_WINPT));
439      rc = RegisterClass (&wc);      rc = RegisterClass (&wc);
440      if (rc == FALSE) {      if (rc == FALSE) {
441          msg_box (NULL, _("Could not register window class"), _("WinPT Error"), MB_ERR);          msg_box (NULL, _("Could not register window class"),
442                     _("WinPT Error"), MB_ERR);
443          free_gnupg_table ();          free_gnupg_table ();
444          return 0;          return 0;
445      }      }
# Line 393  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 460  WinMain (HINSTANCE hinst, HINSTANCE hpre
460      UpdateWindow (hwnd);      UpdateWindow (hwnd);
461    
462      if (!first_start && !start_gpgprefs) {      if (!first_start && !start_gpgprefs) {
463          gnupg_backup_options (1);          gnupg_backup_options ();        
         gnupg_backup_options (0);  
           
464          rc = check_crypto_engine ();          rc = check_crypto_engine ();
465          if (rc) {          if (rc) {
466              DestroyWindow (hwnd);              DestroyWindow (hwnd);
# Line 403  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 468  WinMain (HINSTANCE hinst, HINSTANCE hpre
468              return 0;              return 0;
469          }          }
470      }      }
471        
472      if (start_gpgprefs)      if (start_gpgprefs) {
     {  
473          char *ring;          char *ring;
474          size_t size = 0;          size_t size = 0;
475          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, hwnd,
# Line 417  WinMain (HINSTANCE hinst, HINSTANCE hpre Line 481  WinMain (HINSTANCE hinst, HINSTANCE hpre
481      }      }
482    
483      if (first_start) {      if (first_start) {
484          struct key_wizard_s c, dummy;          struct first_start_s fs;
485            struct genkey_s c;
486            HWND h;
487  start:  start:
488          DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, hwnd,          h = GetDesktopWindow ();
489                          first_run_dlg_proc, (LPARAM)&dummy);          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_GPGPREFS, h,
490          switch (dummy.interactive)                              gpgprefs_dlg_proc, NULL);
491          {          DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FIRST, h,
492                            first_run_dlg_proc, (LPARAM)&fs);
493            switch (fs.choice) {
494          case SETUP_KEYGEN:          case SETUP_KEYGEN:
495              c.interactive = 1;              c.interactive = 1;
496                c.first_start = 1;
497              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,              rc = DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD,
498                                   hwnd, keygen_wizard_dlg_proc, (LPARAM)&c);                                   h, keygen_wizard_dlg_proc, (LPARAM)&c);
499              if (!rc)              if (!rc)
500                  goto start;                  goto start;
             update_keycache (hwnd);  
             check_crypto_engine ();  
501              break;              break;
502    
503          case SETUP_IMPORT:          case SETUP_IMPORT:
# Line 439  start: Line 506  start:
506                  msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);                  msg_box (hwnd, winpt_strerror (rc), _("WinPT Error"), MB_ERR);
507                  goto start;                  goto start;
508              }              }
             update_keycache (hwnd);  
             check_crypto_engine ();  
509              break;              break;
510    
         case SETUP_EXISTING:  
             break; /* todo */  
   
511          case -1:          case -1:
512              DestroyWindow (hwnd);              DestroyWindow (hwnd);
513              free_gnupg_table ();              free_gnupg_table ();
514              return 0;              return 0;
515          }          }
516            update_keycache (hwnd);
517            check_crypto_engine ();
518      }      }
519      else {      else {
520          gpgme_keycache_t c;          gpg_keycache_t c;
521          update_keycache (hwnd);          update_keycache (hwnd);
522          c = keycache_get_ctx (1);          c = keycache_get_ctx (1);
523          if (!c || !gpgme_keycache_count (c)) {          if (!c || !gpg_keycache_get_size (c)) {
524              gnupg_display_error ();              gnupg_display_error ();
525              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"              msg_box (hwnd, _("The keycache was not initialized or is empty.\n"
526                               "Please check your GPG config (keyrings, pathes...)"),                               "Please check your GPG config (keyrings, pathes...)"),
# Line 501  start: Line 565  start:
565      }      }
566                    
567      return 0;      return 0;
568  } /* WinMain */  }
Legend:
Removed from v.2  
changed lines
  Added in v.34
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26