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

Diff of /trunk/Src/wptFileManager.cpp

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

revision 28 by twoaday, Thu Oct 20 12:35:59 2005 UTC revision 69 by twoaday, Sat Nov 5 12:28:12 2005 UTC
# Line 1  Line 1 
1  /* wptFileManager.cpp - File Manager routines  /* wptFileManager.cpp - File Manager routines
2   *      Copyright (C) 2001-2005 Timo Schulz   *      Copyright (C) 2001-2005 Timo Schulz
3   *      Copyright (C) 2005 g10 Code GmbH   *      Copyright (C) 2005 g10 Code GmbH
4   *   *
5   * This file is part of WinPT.   * This file is part of WinPT.
6   *   *
7   * WinPT is free software; you can redistribute it and/or   * WinPT is free software; you can redistribute it and/or
8   * modify it under the terms of the GNU General Public License   * modify it under the terms of the GNU General Public License
9   * as published by the Free Software Foundation; either version 2   * as published by the Free Software Foundation; either version 2
10   * of the License, or (at your option) any later version.   * of the License, or (at your option) any later version.
11   *     *  
12   * WinPT is distributed in the hope that it will be useful,   * WinPT is distributed in the hope that it will be useful,
13   * but WITHOUT ANY WARRANTY; without even the implied warranty of   * but WITHOUT ANY WARRANTY; without even the implied warranty of
14   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15   * General Public License for more details.   * General Public License for more details.
16   *   *
17   * You should have received a copy of the GNU General Public License   * You should have received a copy of the GNU General Public License
18   * along with WinPT; if not, write to the Free Software Foundation,   * along with WinPT; if not, write to the Free Software Foundation,
19   * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA   * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20   */   */
21  /* TODO:  /* TODO:
22   *    check_armor_type: we should check the whole file and not only the first line!   *    check_armor_type: we should check the whole file and not only the first line!
23   */   */
24    
25  #include <sys/types.h>  #ifdef HAVE_CONFIG_H
26  #include <windows.h>  #include <config.h>
27  #include <commdlg.h>  #endif
28  #include <io.h>  
29    #include <sys/types.h>
30  #include "../resource.h"  #include <sys/types.h>
31  #include "wptTypes.h"  #include <windows.h>
32  #include "wptGPG.h"  #include <commdlg.h>
33  #include "wptAgent.h"  #include <io.h>
34  #include "wptCommonCtl.h"  #include <stdio.h>
35  #include "wptContext.h"  
36  #include "wptErrors.h"  #include "resource.h"
37  #include "wptKeylist.h"  #include "wptTypes.h"
38  #include "wptFileManager.h"  #include "wptGPG.h"
39  #include "wptNLS.h"  #include "wptAgent.h"
40  #include "wptW32API.h"  #include "wptCommonCtl.h"
41  #include "wptVersion.h"  #include "wptContext.h"
42  #include "wptDlgs.h"  #include "wptErrors.h"
43  #include "wptGPGZIP.h"  #include "wptKeylist.h"
44  #include "wptUTF8.h"  #include "wptFileManager.h"
45  #include "wptRegistry.h"  #include "wptNLS.h"
46  #include "wptImport.h"  #include "wptW32API.h"
47    #include "wptVersion.h"
48  #include "openpgp.h"  #include "wptDlgs.h"
49    #include "wptZIP.h"
50  void progress_cleanup (progress_filter_s *pfx);  #include "wptUTF8.h"
51    #include "wptRegistry.h"
52  char* gpg_keylist_to_pattern (gpgme_key_t *rset, int n);  #include "wptImport.h"
53  gpgme_error_t sym_passphrase_cb (void *hook, const char *hint, const char *pass_inf,  #include "wptCrypto.h"
54                                   int prev_was_bad, int fd);  
55    #include "openpgp.h"
56  /*-- wptFileVerifyDlg.cpp --*/  
57  int  file_verify_add_state (file_sig_ctx_t c);  #define op_begin()  SetCursor (LoadCursor (NULL, IDC_WAIT))
58  void file_verify_use_event (void);  #define op_end()    SetCursor (LoadCursor (NULL, IDC_ARROW))
59  void file_verify_wait (void);  
60    void progress_cleanup (progress_filter_s *pfx);
61  static const char * mm_files[] = {".mov", ".avi", ".mpg", ".mpeg",  BOOL CALLBACK file_secdel_confirm_dlg_proc (HWND dlg, UINT msg,
62                                    ".mp3", ".wav", ".mid", ".wma",                                              WPARAM wparam, LPARAM lparam);
63                                    ".gif", ".jpg", ".png", ".jpeg", ".dib", 0};  char* gpg_keylist_to_pattern (gpgme_key_t *rset, int n);
64    gpgme_error_t sym_passphrase_cb (void *hook, const char *hint, const char *pass_inf,
65                                     int prev_was_bad, int fd);
66  char *  
67  fm_quote_file (const char * name)  /*-- wptFileVerifyDlg.cpp --*/
68  {  void file_verify_add_state (file_sig_ctx_t c);
69      char * p;  void file_verify_use_event (void);
70      size_t len = strlen (name) + 8;  void file_verify_wait (void);
71    
72      if (*name == '"')  static const char * mm_files[] = {".mov", ".avi", ".mpg", ".mpeg",
73          return m_strdup (name); /* avoid double quotes */                                    ".mp3", ".wav", ".mid", ".wma",
74      p = new char[len + 1];                                    ".gif", ".jpg", ".png", ".jpeg", ".dib", 0};
75      if (!p)  
76          BUG (0);  
77      _snprintf (p, len, "\"%s\"", name);  /* Check if the drive given by @fname is a floppy disc.
78       Return value: -1 for success. */
79      return p;  static int
80  } /* fm_quote_file */  is_floppy_disc (const char *fname)
81    {
82        char drv[32] = {0};    
83  int      int max = sizeof (drv)-1;
84  overwrite_file (const char * fname)      int i=0;
85  {  
86      int id;      if (!strstr (fname, ":\\"))
87            return 0;
88      if (file_exist_check (fname))  
89          return -1;      while (fname && *fname && *fname != '\\' && i < max)
90      id = log_box (_("File Manager"), MB_YESNO,          drv[i++] = *fname++;
91                    _("\"%s\" already exists.\n"      drv[i++] = '\\';
92                      "Replace existing file?"), fname);      drv[i++] = '\0';
93      return id == IDNO ? 0 : -1;      i = GetDriveType (drv);
94  } /* overwrite_file */      if (i == DRIVE_REMOVABLE)
95            return -1;
96        return 0;
97  static void  }
98  remove_crit_file_attrs (const char * fname, int force)  
99  {  
100      u32 f_attr;  /* Ask the user to overwrite file @fname.
101      int id;     Return value: 0 for cancel. */
102    static int
103      if (file_exist_check (fname))  overwrite_file (const char *fname)
104          return; /* Does not exist */  {
105                int id;
106      f_attr = GetFileAttributes (fname);  
107      if ((f_attr & FILE_ATTRIBUTE_READONLY) && force)      if (file_exist_check (fname))
108          SetFileAttributes (fname, FILE_ATTRIBUTE_NORMAL);          return -1;
109      else if (f_attr & FILE_ATTRIBUTE_READONLY) {      id = log_box (_("File Manager"), MB_YESNO,
110          id = log_box (_("File Manager"), MB_YESNO,                              _("\"%s\" already exists.\n"
111                        _("\"%s\" has read-only attribute.\n"                      "Replace existing file?"), fname);
112                          "Set attribute to normal?"), fname);      return id == IDNO ? 0 : -1;
113          if (id == IDYES)  }
114              SetFileAttributes (fname, FILE_ATTRIBUTE_NORMAL);  
115      }  
116  } /* remove_crit_file_attrs */  /* Removes 'critical' attributes from the file @fname.
117       If @force is 1, the user is not asked for permission. */
118    static void
119  static int inline  remove_crit_file_attrs (const char *fname, int force)
120  is_directory (const char * fname)  {
121  {          u32 fattr;
122      return GetFileAttributes (fname) & FILE_ATTRIBUTE_DIRECTORY? 1 : 0;      int id = 0;
123  } /* is_directory */  
124        if (file_exist_check (fname))
125            return; /* Does not exist */
126  static int inline          
127  is_openpgp_ext (const char * name)      fattr = GetFileAttributes (fname);
128  {      if ((fattr & FILE_ATTRIBUTE_READONLY) && force)
129      if (strstr (name, ".gpg") || strstr (name, ".asc")          id = IDYES;
130          || strstr (name, ".sig") || strstr (name, ".pgp"))      else if (fattr & FILE_ATTRIBUTE_READONLY)
131          return -1;          id = log_box (_("File Manager"), MB_YESNO,          
132      return 0;                        _("\"%s\" has read-only attribute.\n"
133  }                          "Set attribute to normal?"), fname);
134        if (id == IDYES) {
135            if (!SetFileAttributes (fname, FILE_ATTRIBUTE_NORMAL))
136  static int              msg_box (NULL, _("Could not reset file attribute to normal."),
137  is_multi_media (const char * name)                       _("File Manager"), MB_ERR);
138  {          }
139      const char * val;  }
140      char * p;  
141      int i;  
142      int ans=0;  /* Return 1 if the given path @fname is a directory, 0 otherwise. */
143    static int
144      i = get_reg_winpt_single (CFG_NOZIP_MMEDIA);  is_directory (const char *fname)
145      if (i == -1)  {
146      {      return GetFileAttributes (fname) & FILE_ATTRIBUTE_DIRECTORY? 1 : 0;
147          ans = msg_box (NULL, _("Multi-Media files are already compressed, GPG would compress\n"  }
148                                 "them anyway and this costs a lot of time.\n"  
149                                 "It is possible to disable compression for these files.\n"  
150                                 "Do you want to disable it?"),  /* Return -1 if the given name @name is a valid PGP extension. */
151                                 _("File Manager"), MB_YESNO|MB_INFO);  static int
152          set_reg_winpt_single (CFG_NOZIP_MMEDIA, ans == IDYES? 1 : 0);  is_openpgp_ext (const char *name)
153          if (ans == IDNO)  {
154              return 0;      if (stristr (name, ".gpg") || stristr (name, ".asc")
155      }          || stristr (name, ".sig") || stristr (name, ".pgp"))
156      else if (i == 0)          return -1;
157          return 0;      return 0;
158    }
159      p = strrchr (name, '.');  
160      if (!p)  
161          return 0;  static int
162      for (i=0; (val = mm_files[i]); i++)  is_multi_media (const char * name)
163      {  {    
164          if (!stricmp (p, val))      const char * val;
165              return -1;      char * p;
166      }      int i;
167      return 0;      int ans=0;
168  }  
169        i = get_reg_winpt_single (CFG_NOZIP_MMEDIA);
170        if (i == -1)
171  const char*      {
172  file_get_extension (gpgme_ctx_t ctx, gpgme_sig_mode_t sigmode)          ans = msg_box (NULL, _("Multi-Media files are already compressed, GPG would compress\n"
173  {                                 "them anyway and this costs a lot of time.\n"
174      int use_armor = gpgme_get_armor (ctx);                                 "It is possible to disable compression for these files.\n"
175                                   "Do you want to disable it?"),
176      if (use_armor || sigmode == GPGME_SIG_MODE_CLEAR)                                 _("File Manager"), MB_YESNO|MB_INFO);
177          return ".asc";          set_reg_winpt_single (CFG_NOZIP_MMEDIA, ans == IDYES? 1 : 0);
178      if (!use_armor && sigmode == GPGME_SIG_MODE_DETACH)          if (ans == IDNO)
179          return ".sig";              return 0;
180      return ".gpg";      }
181  } /* file_get_extension */      else if (i == 0)
182            return 0;
183    
184  int      p = strrchr (name, '.');
185  fm_build( listview_ctrl_t *lv, HWND ctrl )      if (!p)
186  {          return 0;
187      int i, rc = 0;      for (i=0; (val = mm_files[i]); i++) {
188      listview_ctrl_t c;          if (!stricmp (p, val))
189      struct listview_column_s col[] =              return -1;
190      {      }
191          {0,  80, (char *)_("Status") },      return 0;
192          {1, 256, (char *)_("Name") },  }
193          {2, 128, (char *)_("Operation") },  
194          {0,   0, NULL }  
195      };  /* Return a GPG file extension which depends on the operation
196               mode in @ctx and the sig mode @sigmode. */
197      rc = listview_new( &c );  const char*
198      if( rc )  file_get_extension (gpgme_ctx_t ctx, gpgme_sig_mode_t sigmode)
199          BUG( NULL );  {
200      c->ctrl = ctrl;      int use_armor = gpgme_get_armor (ctx);
201      for ( i = 0; col[i].width; i++ )  
202          listview_add_column( c, &col[i] );      if (use_armor || sigmode == GPGME_SIG_MODE_CLEAR)
203      listview_set_ext_style( c );          return ".asc";
204      if( lv )      if (!use_armor && sigmode == GPGME_SIG_MODE_DETACH)
205          *lv = c;          return ".sig";
206      return 0;      return ".gpg";
207  } /* fm_build */  }
208    
209    
210  void  /* Quote a file to avoid shell problems with spaces in the files. */
211  fm_delete( listview_ctrl_t lv )  char*
212  {  fm_quote_file (const char * name)
213      if( lv ) {  {
214          listview_release( lv );      char * p;
215      }      size_t len = strlen (name) + 8;
216  } /* fm_delete */  
217        if (*name == '"')
218            return m_strdup (name); /* avoid double quotes */
219  int      p = new char[len + 1];
220  fm_state_new (fm_state_t * ctx)      if (!p)
221  {          BUG (0);
222      gpgme_error_t rc;      _snprintf (p, len, "\"%s\"", name);
223      fm_state_s * c;  
224        return p;
225      c = new fm_state_s;  }
226      if (!c)  
227          BUG (0);  
228      memset (c, 0, sizeof * c);  
229      rc = gpgme_new (&c->ctx);  /* Check the armor type of the file @fname and return
230      if (rc)     a string representation of it. */
231          BUG (0);  static const char *
232      /* XXX rc = gpgme_recipients_new (&c->recp);*/  fm_check_armor_type (const char *fname, int *r_type)
233      /* XXX gpgme_set_comment (c->ctx, "Generated by WinPT "PGM_VERSION); */  {
234      *ctx = c;      FILE * fp;
235      return 0;      char header[768], * p;
236  } /* fm_state_new */      
237        if (r_type)
238            *r_type = PGP_NONE;
239  /* Release the FM state handle @c. */      fp = fopen (fname, "rb");
240  void      if (!fp)
241  fm_state_release (fm_state_t c)          return "UNKNOWN";
242  {      p = fgets (header, sizeof (header) - 1, fp);
243      if (!c)      fclose (fp);
244          return;      if (!p)
245      if (c->recp)          return "UNKNOWN";
246          free (c->recp);  
247      if (c->ctx) {      if (strncmp (header, "-----", 5))
248          gpgme_release (c->ctx);          goto leave;
249          c->ctx = NULL;        if (strstr( header, "BEGIN PGP PUBLIC KEY" )) {
250      }          if (r_type) *r_type = PGP_PUBKEY;
251      free_if_alloc (c->opaque);          return "PUBKEY";
252      free_if_alloc (c->output);      }
253      delete c; c = NULL;          else if (strstr (header, "BEGIN PGP PRIVATE KEY") ||
254  }               strstr (header, "BEGIN PGP SECRET KEY")) {
255            if (r_type) *r_type = PGP_SECKEY;
256  static int          return "SECKEY";
257  fm_check_for_entry( listview_ctrl_t lv, const char *file )      }
258  {      else if (strstr (header, "BEGIN PGP MESSAGE")) {
259      char name[512];          if (r_type) *r_type = PGP_MESSAGE;
260      int i;          return "ENCRYPTED";
261        }
262      memset (name, 0, sizeof (name));      else if (strstr( header, "BEGIN PGP SIGNED MESSAGE")) {
263      for( i = 0; i < listview_count_items( lv, 0 ); i++ )          if (r_type) *r_type = PGP_CLEARSIG;
264      {          return "SIGNED-CLEAR";
265          listview_get_item_text( lv, i, 1, name, sizeof (name) - 1 );      }
266          if( !strcmp( name, file ) )      else if (strstr(header, "BEGIN PGP SIGNATURE")) {
267              return 1; /* found */                if (r_type) *r_type = PGP_SIG;
268      }          return "SIGNED-DETACH";
269        }
270      return 0;  
271  } /* fm_check_for_entry */  leave:
272        return "UNKNOWN";
273    }
274  static int  
275  fm_set_ftype (listview_ctrl_t lv, const char * name)  
276  {  /* Extract file type from @fname. If @r_type is valid,
277      const char *type;     it contains the PGP type on success. */
278      int rc;  static const char *
279    fm_get_file_type (const char *fname, int *r_type)
280      rc = fm_check_for_entry (lv, name);  {        
281      if (rc)      gpg_iobuf_t inp;
282          return 0;      armor_filter_context_t afx;
283      type = fm_get_file_type (name);      PACKET *pkt;
284      if (!type || !strcmp (type, "UNKNOWN"))      const char *s = NULL;
285          type = gnupg_check_file_ext (name);          int rc=0;
286      rc = listview_add_item (lv, " ");  
287      if (rc)      if (r_type)
288          return -1;          *r_type = PGP_NONE;
289      listview_add_sub_item (lv, 0, 0, type);      if (!fname) {
290      listview_add_sub_item (lv, 0, 1, name);          log_debug ("fm_get_file_type: !fname\r\n");
291      return 0;          return NULL;
292  }      }
293    
294        if (is_floppy_disc (fname))
295  static int          return fm_check_armor_type (fname, r_type);
296  fm_add_dir_files (listview_ctrl_t lv, char *path)  
297  {      inp = gpg_iobuf_open (fname);
298      struct _finddata_t fd;      if (!inp) {
299      char * p;          const char *s = winpt_strerror (WPTERR_FILE_OPEN);
300      long hd;          log_box (_("File Manager"), MB_ERR, "\"%s\": %s", fname, s);
301            return NULL;
302      strcat (path, "\\*");      }
303      hd = _findfirst (path, &fd);      gpg_iobuf_ioctl (inp, 3, 1, NULL); /* disable cache */
304      do {      if (gpg_iobuf_get_filelength (inp) > 32000000 /* 32MB */
305          p = new char [(strlen (path) + strlen (fd.name))+1];          && !is_openpgp_ext (fname)) {
306          if (!p)          gpg_iobuf_close (inp);
307              BUG (0);          return "UNKNOWN";
308          memcpy (p, path, strlen (path)-1);      }
309          p[strlen (path)-1] = 0;  
310          strcat (p, fd.name);      if (gpg_use_armor_filter(inp)) {
311          if (!is_directory (p))          memset (&afx, 0, sizeof (afx));
312              fm_set_ftype (lv, p);          gpg_iobuf_push_filter (inp, gpg_armor_filter, &afx);
313          free_if_alloc (p);      }
314                pkt = (PACKET *)calloc (1, sizeof *pkt);
315      } while (_findnext (hd, &fd) == 0);      if (!pkt)
316      _findclose (hd);          BUG (NULL);
317      return 0;      gpg_init_packet (pkt);
318  }      while (!(rc = gpg_parse_packet (inp, pkt))) {
319            switch (pkt->pkttype) {
320            case PKT_PUBKEY_ENC:
321  /* Add the drag & drop files from @dd_files to the              s = "ENCRYPTED";rc = -2;
322     list view control @lv. */              if (r_type) *r_type = PGP_MESSAGE;
323  int              break;
324  fm_add_dropped_files (listview_ctrl_t lv, HDROP dd_files)          case PKT_SYMKEY_ENC:
325  {          case PKT_ENCRYPTED:
326      char name[384+4];              s = "SYMKEYENC";rc = -2;
327      int nfiles, rc, i;              if (r_type) *r_type = PGP_MESSAGE;
328                    break;
329      memset (name, 0, sizeof (name));          case PKT_SIGNATURE:
330      nfiles = DragQueryFile (dd_files, 0xFFFFFFFF, NULL, 0);          case PKT_ONEPASS_SIG:
331      for (i = 0;  i < nfiles; i++) {              s = "SIGNED";   rc = -2;
332          DragQueryFile (dd_files, i, name, sizeof (name) -1);              if (r_type) *r_type = PGP_SIG;
333          if (is_directory (name))              break;
334              rc = fm_add_dir_files (lv, name);          case PKT_PUBLIC_KEY:
335          else              s = "PUBKEY";   rc = -2;
336              rc = fm_set_ftype (lv, name);              if (r_type) *r_type = PGP_PUBKEY;
337          if (rc == -1)              break;
338              break;          case PKT_SECRET_KEY:
339      }              s = "SECKEY";   rc = -2;
340      return rc;              if (r_type) *r_type = PGP_SECKEY;
341  }              break;
342                
343            default:
344  int              break;
345  fm_add_opened_files (listview_ctrl_t lv, HWND dlg)          }
346  {          gpg_free_packet (pkt);
347      OPENFILENAME open;          gpg_init_packet (pkt);
348      const char *type;            if (rc == -2)
349      char file[1024] = "";              break; /* found */
350      int rc;      }
351            safe_free (pkt);
352      memset( &open, 0, sizeof (open) );      gpg_iobuf_close (inp);
353      open.lStructSize = sizeof (OPENFILENAME);      if (!s)
354      open.hInstance = glob_hinst;          s = fm_check_armor_type (fname, r_type);
355      open.lpstrTitle = _("File Open");      if (!s)
356      open.lpstrFilter = _("All Files (*.*)\0*.*\0\0");          s = "UNKNOWN";
357      open.hwndOwner = dlg;      if (!strcmp (s, "SIGNED")
358      open.lpstrFile = file;          && strcmp (fm_check_armor_type (fname, r_type), "SIGNED-CLEAR ")) {
359      open.nMaxFile = sizeof (file) - 1;          if (r_type) *r_type = PGP_SIG;
360      open.Flags = 0;          s = "SIGNED-DETACH";
361            }
362      if (GetOpenFileName (&open)) {      return s;
363          type = fm_get_file_type (open.lpstrFile);  }
364          if (!type)  
365              return WPTERR_FILE_OPEN;  
366          if (!strcmp (type, "UNKNOWN"))  int
367              type = gnupg_check_file_ext (open.lpstrFile);  fm_build (listview_ctrl_t *lv, HWND ctrl)
368          rc = listview_add_item (lv, "");  {
369          if( !rc ) {      int i, rc = 0;
370              listview_add_sub_item (lv, 0, 0, type);      listview_ctrl_t c;
371              listview_add_sub_item (lv, 0, 1, open.lpstrFile);      struct listview_column_s col[] =
372          }      {
373      }          {0,  80, (char *)_("Status") },
374                {1, 256, (char *)_("Name") },
375      return rc;          {2, 128, (char *)_("Operation") },
376  }          {0,   0, NULL }
377        };
378            
379  /* Check the armor type of the file @fname and return      rc = listview_new( &c );
380     a string representation of it. */      if( rc )
381  static const char *          BUG( NULL );
382  fm_check_armor_type (const char *fname)      c->ctrl = ctrl;
383  {      for ( i = 0; col[i].width; i++ )
384      FILE * fp;          listview_add_column( c, &col[i] );
385      char header[768], * p;      listview_set_ext_style( c );
386            if( lv )
387      fp = fopen (fname, "rb");          *lv = c;
388      if (!fp)      return 0;
389          return "UNKNOWN";  } /* fm_build */
390      p = fgets (header, sizeof (header) - 1, fp);  
391      fclose (fp);  
392      if (!p)  void
393          return "UNKNOWN";  fm_delete( listview_ctrl_t lv )
394    {
395      if( strncmp( header, "-----", 5 ) )      if( lv ) {
396          goto leave;          listview_release( lv );
397      if( strstr( header, "BEGIN PGP PUBLIC KEY" ) )      }
398          return "PUBKEY";  } /* fm_delete */
399      else if( strstr( header, "BEGIN PGP PRIVATE KEY" ) )  
400          return "SECKEY";  
401      else if( strstr( header, "BEGIN PGP SECRET KEY" ) )  int
402          return "SECKEY";  fm_state_new (fm_state_t * ctx)
403      else if( strstr( header, "BEGIN PGP MESSAGE" ) )  {
404          return "ENCRYPTED";      gpgme_error_t rc;
405      else if( strstr( header, "BEGIN PGP SIGNED MESSAGE" ) )      fm_state_s * c;
406          return "SIGNED-CLEAR";  
407      else if( strstr(header, "BEGIN PGP SIGNATURE" ) )      c = new fm_state_s;
408          return "SIGNED-DETACH";      if (!c)
409            BUG (0);
410  leave:      memset (c, 0, sizeof *c);
411      return "UNKNOWN";      rc = gpgme_new (&c->ctx);
412  }      if (rc)
413            BUG (0);
414        /* XXX rc = gpgme_recipients_new (&c->recp);*/
415  int      /* XXX gpgme_set_comment (c->ctx, "Generated by WinPT "PGM_VERSION); */
416  fm_assume_onepass_sig (const char * fname)      *ctx = c;
417  {      return 0;
418      gpgme_data_t dat;  } /* fm_state_new */
419      armor_filter_context_t afx;  
420      gpg_iobuf_t fp;  
421      PACKET * pkt = (PACKET *)calloc (1, sizeof *pkt);  /* Release the FM state handle @c. */
422      int check = 0;  void
423    fm_state_release (fm_state_t c)
424      if (!fname)  {
425      {      if (!c)
426          gpg_data_new_from_clipboard (&dat, 0);          return;
427          gpg_data_release_and_set_file (dat, "gpgme.tmp");      if (c->recp)
428            free (c->recp);
429          fp = gpg_iobuf_open ("gpgme.tmp");      if (c->ctx) {
430          if (!fp)          gpgme_release (c->ctx);
431              return 0;          c->ctx = NULL;  
432          gpg_iobuf_ioctl (fp, 3, 1, NULL);      }
433          if (gpg_use_armor_filter(fp))      free_if_alloc (c->opaque);
434          {      free_if_alloc (c->output);
435              memset (&afx, 0, sizeof (afx));      delete c; c = NULL;    
436              gpg_iobuf_push_filter (fp, gpg_armor_filter, &afx);  }
437          }  
438          gpg_init_packet (pkt);  static int
439          if (!gpg_parse_packet (fp, pkt)  fm_check_for_entry( listview_ctrl_t lv, const char *file )
440              && pkt->pkttype == PKT_COMPRESSED)  {
441              check = 1;        char name[512];
442          gpg_free_packet (pkt);      int i;
443          safe_free (pkt);  
444          gpg_iobuf_close (fp);      memset (name, 0, sizeof (name));
445          unlink ("gpgme.tmp");      for (i = 0; i < listview_count_items( lv, 0 ); i++) {
446      }          listview_get_item_text( lv, i, 1, name, sizeof (name) - 1 );
447      /* XXX: implement it for real files */          if( !strcmp( name, file ) )
448      return check;              return 1; /* found */      
449  }      }
450    
451        return 0;
452  static int  } /* fm_check_for_entry */
453  is_floppy_disc (const char * fname)  
454  {  
455      char drv[32] = {0};  static int
456      int i=0;  fm_set_ftype (listview_ctrl_t lv, const char *name)
457    {
458      if (!strstr (fname, ":\\"))      const char *type;
459          return 0;      int rc;
460    
461      while (fname && *fname && *fname != '\\')      rc = fm_check_for_entry (lv, name);
462          drv[i++] = *fname++;      if (rc)
463      drv[i++] = '\\';          return 0;
464      drv[i++] = '\0';      type = fm_get_file_type (name, NULL);
465      i = GetDriveType (drv);      if (!type || !strcmp (type, "UNKNOWN"))
466      if (i == DRIVE_REMOVABLE)          type = gnupg_check_file_ext (name, NULL);
467          return -1;      rc = listview_add_item (lv, " ");
468      return 0;      if (rc)
469  }          return -1;
470        listview_add_sub_item (lv, 0, 0, type);
471        listview_add_sub_item (lv, 0, 1, name);
472  const char *      return 0;
473  fm_get_file_type (const char * fname)  }
474  {          
475      gpg_iobuf_t inp;  
476      armor_filter_context_t afx;  static int
477      PACKET * pkt = (PACKET *)calloc (1, sizeof *pkt);  fm_add_dir_files (listview_ctrl_t lv, char *path)
478      int i = 0, rc = 0;  {
479      const char * s = NULL;      struct _finddata_t fd;
480        char * p;
481      if (!fname) {      long hd;
482          safe_free (pkt);  
483          return NULL;      strcat (path, "\\*");
484      }      hd = _findfirst (path, &fd);
485        do {
486      if (is_floppy_disc (fname))          p = new char [(strlen (path) + strlen (fd.name))+1];
487          return fm_check_armor_type (fname);          if (!p)
488                BUG (0);
489      inp = gpg_iobuf_open (fname);          memcpy (p, path, strlen (path)-1);
490      if (!inp) {          p[strlen (path)-1] = 0;
491          const char *s = winpt_strerror (WPTERR_FILE_OPEN);          strcat (p, fd.name);
492          log_box( _("File Manager"), MB_ERR, "\"%s\": %s", fname, s );          if (!is_directory (p))
493          safe_free( pkt );              fm_set_ftype (lv, p);
494          return NULL;          free_if_alloc (p);
495      }      } while (_findnext (hd, &fd) == 0);
496      gpg_iobuf_ioctl (inp, 3, 1, NULL); /* disable cache */      _findclose (hd);
497      if (gpg_iobuf_get_filelength (inp) > 32000000 /* 32MB */      return 0;
498          && !is_openpgp_ext (fname)) {  }
499          gpg_iobuf_close (inp);  
500          return "UNKNOWN";  
501      }  /* Add the drag & drop files from @dd_files to the
502       list view control @lv. */
503      if (gpg_use_armor_filter(inp)) {  int
504          memset (&afx, 0, sizeof (afx));  fm_add_dropped_files (listview_ctrl_t lv, HDROP dd_files)
505          gpg_iobuf_push_filter (inp, gpg_armor_filter, &afx);  {
506      }      char name[384+4];
507            int nfiles, i;
508      gpg_init_packet (pkt);      int rc=0;
509      while (!(rc = gpg_parse_packet (inp, pkt))) {      
510          switch (pkt->pkttype) {      memset (name, 0, sizeof (name));
511          case PKT_PUBKEY_ENC:  s = "ENCRYPTED";rc = -2; break;      nfiles = DragQueryFile (dd_files, 0xFFFFFFFF, NULL, 0);
512          case PKT_SYMKEY_ENC:      for (i = 0;  i < nfiles; i++) {
513          case PKT_ENCRYPTED:   s = "SYMKEYENC";rc = -2; break;          DragQueryFile (dd_files, i, name, sizeof (name) -1);
514          case PKT_SIGNATURE:          if (is_directory (name))
515          case PKT_ONEPASS_SIG: s = "SIGNED";   rc = -2; break;              rc = fm_add_dir_files (lv, name);
516          case PKT_PUBLIC_KEY:  s = "PUBKEY";   rc = -2; break;          else
517          case PKT_SECRET_KEY:  s = "SECKEY";   rc = -2; break;              rc = fm_set_ftype (lv, name);
518          }          if (rc == -1)
519          gpg_free_packet (pkt);              break; /* XXX: fixme? */
520          gpg_init_packet (pkt);      }
521          if (rc == -2)      return rc;
522              break; /* found */  }
523      }  
524      safe_free (pkt);  
525      gpg_iobuf_close (inp);  /* Add a single file @name to the list view and before
526      if (!s)     figure out the type of it.
527          s = fm_check_armor_type (fname);     Return value: 0 on success. */
528      if (!s)  static int
529          s = "UNKNOWN";  add_single_file (listview_ctrl_t lv, const char *name)
530      if (!strcmp( s, "SIGNED")  {
531          && strcmp (fm_check_armor_type (fname), "SIGNED-CLEAR "))      const char *type;
532          s = "SIGNED-DETACH";      int rc = 0;
533      return s;  
534  } /* fm_get_file_type */      type = fm_get_file_type (name, NULL);
535        if (!type)
536            return WPTERR_FILE_OPEN;
537  int      if (!strcmp (type, "UNKNOWN"))      
538  fm_get_current_pos (listview_ctrl_t lv)          type = gnupg_check_file_ext (name, NULL);          
539  {      rc = listview_add_item (lv, "");        
540      int i = 0, items;      if (!rc) {  
541            listview_add_sub_item (lv, 0, 0, type);
542      items = listview_count_items (lv, 0);          listview_add_sub_item (lv, 0, 1, name);
543      if (!items)      }
544          return -1;      return rc;
545      else if (items == 1)  }
546      {  
547          listview_select_one (lv, 0);  
548          return 0;  /* Use the common Open-File-Dialog to allow the user to
549      }     add one ore more selected files to the listview @lv. */
550      else if (items > 1)  int
551      {  fm_add_opened_files (listview_ctrl_t lv, HWND dlg)
552          i = listview_get_curr_pos (lv);  {
553          if (i == -1)      OPENFILENAME open;
554          {      char file[512], name[MAX_PATH+1];
555              msg_box (lv->ctrl, _("Please select a file."), _("File Manager"), MB_ERR);      char *path = NULL;
556              return -1;      const char *s;
557          }      int i, len=0, n=0;
558          return i;      int rc=0;
559      }  
560        memset (&open, 0, sizeof (open));
561      return -1;      open.lStructSize = sizeof (OPENFILENAME);
562  } /* fm_get_current_pos */      open.hInstance = glob_hinst;
563        open.lpstrTitle = _("File Open");
564        open.lpstrFilter = _("All Files (*.*)\0*.*\0\0");
565  static int      open.hwndOwner = dlg;
566  fm_check_detached_sig( listview_ctrl_t lv, int pos )      open.lpstrFile = file;
567  {      open.nMaxFile = sizeof (file) - 1;
568      char type[128];      open.Flags = OFN_ALLOWMULTISELECT|OFN_EXPLORER ;
569        
570      listview_get_item_text( lv, pos, 0, type, 127 );      memset (file, 0, sizeof file);
571      return !strcmp( type, "SIGNED-DETACH" )? 1 : 0;      if (!GetOpenFileName (&open))
572  } /* fm_check_detached_sig */          return 0;
573    
574        s = file;
575  int      len = sizeof (file)-1;
576  fm_check_file_type (listview_ctrl_t lv, int pos, int fm_cmd)      for (;;) {
577  {          if (len < 2 || (*s == '\0' && *(s+1) == '\0'))
578      char status[128];              break;
579      int rc = 0;          memset (name, 0, sizeof (name));
580                for (i=0; len > 0; len--, i++) {
581      listview_get_item_text (lv, pos, 0, status, sizeof (status) - 1);              if (*s == '\0') {
582                        name[i] = *s++;
583      switch (fm_cmd) {                  break;
584      case FM_ENCRYPT:              }
585      case FM_ENCRYPT_DIR:              name[i] = *s++;
586      case FM_SIGNENCRYPT:            }
587          if (strcmp (status, "ENCRYPTED")          if (n == 0)
588              && strcmp (status, "SYMKEYENC"))              path = strdup (name);
589              rc = 1;          else {
590          break;              char *p = make_filename (path, name, NULL);
591                        rc = add_single_file (lv, p);
592      case FM_DECRYPT:              free (p);
593          if (!strcmp (status, "DATA")          }
594              || !strcmp (status, "ENCRYPTED")          n++;
595              || !strcmp (status, "SYMKEYENC")      }
596              || !strcmp (status, "ARMORED"))      if (n == 1) /* single file selected. */
597              rc = 1;          rc = add_single_file (lv, path);
598          break;      if (path)
599                    free (path);
600      case FM_SIGN:      return rc;
601          if( strncmp( status, "SIGNED", 6 ) )  }
602              rc = 1;  
603          break;  
604            int
605      case FM_VERIFY:  fm_assume_onepass_sig (const char * fname)
606          if( !strncmp( status, "SIGNED", 6 )  {
607               || !strcmp( status, "COMPRESSED" ) )      gpgme_data_t dat;
608              rc = 1;      armor_filter_context_t afx;
609          break;      gpg_iobuf_t fp;
610                PACKET * pkt = (PACKET *)calloc (1, sizeof *pkt);
611      case FM_SYMENC:      int check = 0;
612          if( strcmp( status, "SYMKEYENC" ) )  
613              rc = 1;      if (!fname) {
614          break;          gpg_data_new_from_clipboard (&dat, 0);
615                    gpg_data_release_and_set_file (dat, "gpgme.tmp");
616      case FM_IMPORT:  
617          if( !strcmp( status, "PUBKEY" )          fp = gpg_iobuf_open ("gpgme.tmp");
618              || !strcmp( status, "SECKEY" ) )          if (!fp)
619              rc = 1;              return 0;
620          break;          gpg_iobuf_ioctl (fp, 3, 1, NULL);
621                    if (gpg_use_armor_filter(fp)) {
622      case FM_WIPE:              memset (&afx, 0, sizeof (afx));
623      case FM_LIST:              gpg_iobuf_push_filter (fp, gpg_armor_filter, &afx);
624          rc = 1;          }
625          break;            gpg_init_packet (pkt);
626      }          if (!gpg_parse_packet (fp, pkt)
627                    && pkt->pkttype == PKT_COMPRESSED)
628      return rc;              check = 1;  
629  } /* fm_check_file_type */          gpg_free_packet (pkt);
630            safe_free (pkt);
631            gpg_iobuf_close (fp);
632  static void          unlink ("gpgme.tmp");
633  fm_set_status (listview_ctrl_t lv, int pos, int fm_cmd, int success,      }
634                 const char * output)      /* XXX: implement it for real files */
635  {      return check;
636      char status[128], operat[128];  }
637      int update = 1;  
638      const char *s;  
639    int
640      if ( fm_cmd == FM_LIST )  fm_get_current_pos (listview_ctrl_t lv)
641          return;  {
642      success ? s = "SUCCESS" : s = "FAILED";      int i = 0, items;
643      strcpy( operat, s );  
644        items = listview_count_items (lv, 0);
645      switch (fm_cmd) {      if (!items)
646      case FM_ENCRYPT:          return -1;
647      case FM_ENCRYPT_DIR:      else if (items == 1)
648      case FM_SIGNENCRYPT: strcpy( status, "ENCRYPTED" ); break;      {
649      case FM_DECRYPT:     strcpy( status, "UNKNOWN" );   break;          listview_select_one (lv, 0);
650      case FM_SIGN:        strcpy( status, "SIGNED" );    break;          return 0;
651      case FM_VERIFY:      update = 0;                    break;      }
652      case FM_SYMENC:      strcpy( status, "SYMKEYENC" ); break;      else if (items > 1)
653      case FM_IMPORT:      update = 0;                    break;      {
654      case FM_WIPE:        strcpy( status, "WIPED" );     break;          i = listview_get_curr_pos (lv);
655      default:             strcpy( status, "UNKNOWN");    break;          if (i == -1)
656      }          {
657                msg_box (lv->ctrl, _("Please select a file."), _("File Manager"), MB_ERR);
658      if (success) {              return -1;
659          if (update) {          }
660              listview_add_sub_item (lv, pos, 0, status);          return i;
661              listview_add_sub_item (lv, pos, 1, output);      }
662          }  
663      }      return -1;
664      listview_add_sub_item( lv, pos, 2, operat );  } /* fm_get_current_pos */
665  } /* fm_set_status */  
666    
667    static int
668  int  fm_check_detached_sig( listview_ctrl_t lv, int pos )
669  fm_clearsign_8bit (listview_ctrl_t lv, fm_state_s *ctx)  {
670  {      char type[128];
671      FILE *f;  
672      byte buf[32];      listview_get_item_text( lv, pos, 0, type, 127 );
673      char name[256];      return !strcmp( type, "SIGNED-DETACH" )? 1 : 0;
674      int i, n, cnt=0;  } /* fm_check_detached_sig */
675    
676      if (ctx->sigmode != GPGME_SIG_MODE_CLEAR)  
677          return 0;  int
678      listview_get_item_text (lv, -1, 1, name, sizeof (name)-1);  fm_check_file_type (listview_ctrl_t lv, int pos, int fm_cmd)
679      if (stristr (name, ".TXT"))  {
680          return 0;      char status[128];
681      f = fopen (name, "rb");      int rc = 0;
682      if (!f)      
683          return -1; /* should never happen */      listview_get_item_text (lv, pos, 0, status, sizeof (status) - 1);
684      n = fread (buf, 1, 32, f);      
685      for (i = 0; i < n; i++) {      switch (fm_cmd) {
686          if (buf[i] == 0x00 || buf[i] > 170)      case FM_ENCRYPT:
687              cnt++;      case FM_ENCRYPT_DIR:
688      }      case FM_SIGNENCRYPT:  
689      fclose (f);          if (strcmp (status, "ENCRYPTED")
690      if (!cnt)              && strcmp (status, "SYMKEYENC"))
691          return 0;              rc = 1;
692      n = -1;          break;
693      i = log_box (_("File Manager"), MB_WARN|MB_YESNO,          
694                   _("\"%s\" does not seems to be a text file.\n"      case FM_DECRYPT:
695                     "Do you really want to clearsign it?"), name);          if (!strcmp (status, "DATA")
696      if (i == IDYES)              || !strcmp (status, "ENCRYPTED")
697          n = 0;              || !strcmp (status, "SYMKEYENC")
698      return n;              || !strcmp (status, "ARMORED"))
699  }              rc = 1;
700            break;
701  int          
702  fm_parse_files (listview_ctrl_t lv, HWND dlg, int cmd)      case FM_SIGN:
703  {          if( strncmp( status, "SIGNED", 6 ) )
704      struct secdel_confirm_s confirm = {0};              rc = 1;
705      struct progress_filter_s pfx, pfx2;          break;
706      fm_state_s * ctx;          
707      int fm_cmd, sig_detached = 0;      case FM_VERIFY:
708      int rc = 0, i, n, ndel = 0;          if( !strncmp( status, "SIGNED", 6 )
709      char fname[512], status[128];               || !strcmp( status, "COMPRESSED" ) )
710                    rc = 1;
711      switch (cmd) {          break;
712      case ID_FILEMISC_ENCRYPT: fm_cmd = FM_ENCRYPT; break;          
713      case ID_FILEMISC_DECRYPT: fm_cmd = FM_DECRYPT; break;      case FM_SYMENC:
714      case ID_FILEMISC_SYMENC:  fm_cmd = FM_SYMENC;  break;          if( strcmp( status, "SYMKEYENC" ) )
715      case ID_FILEMISC_SIGN:    fm_cmd = FM_SIGN;    break;                  rc = 1;
716      case ID_FILEMISC_VERIFY:  fm_cmd = FM_VERIFY;  break;          break;
717      case ID_FILEMISC_IMPORT:  fm_cmd = FM_IMPORT;  break;          
718      case ID_FILEMISC_WIPE:    fm_cmd = FM_WIPE;    break;      case FM_IMPORT:
719      case ID_FILEMISC_LIST:    fm_cmd = FM_LIST;    break;          if( !strcmp( status, "PUBKEY" )
720      case ID_FILEMISC_SIGNENC: fm_cmd = FM_SIGNENCRYPT; break;              || !strcmp( status, "SECKEY" ) )
721      default: return 1; /* unknown command */              rc = 1;
722      }          break;
723                
724      if (fm_get_current_pos (lv) == -1)      case FM_WIPE:
725          return WPTERR_GENERAL;          case FM_LIST:
726      rc = fm_state_new (&ctx);          rc = 1;
727      if (rc)          break;  
728          BUG (0);      }
729      ctx->dlg = dlg;      
730        return rc;
731      // XXX: for file operations the progress dialog will be  } /* fm_check_file_type */
732      //       reloaded somewhere and thus a 'dummy' dialog remains  
733    
734      /* we use it here to make sure that pfx_cleanup will not use  static void
735         any weird values. */  fm_set_status (listview_ctrl_t lv, int pos, int fm_cmd, int success,
736      memset (&pfx, 0, sizeof (pfx));                 const char * output)
737      ctx->prog_cb = NULL;  {
738      if (cmd != FM_VERIFY && cmd != FM_SIGN /*&& reg_prefs.fm.progress > 0*/) {      char status[128], operat[128];
739          pfx.hwnd = dlg;      int update = 1;
740          /*gpgme_set_progress_cb (ctx->ctx, progress_callback, &pfx);*/      const char *s;
741          /*ctx->prog_cb = &pfx;*/  
742      }      if ( fm_cmd == FM_LIST )
743                return;
744      /* Commands we need before we can perform the main command */      success ? s = "SUCCESS" : s = "FAILED";
745      switch (fm_cmd) {      strcpy( operat, s );
746      case FM_ENCRYPT:  
747      case FM_SIGNENCRYPT:      switch (fm_cmd) {
748          if (fm_cmd == FM_SIGNENCRYPT)      case FM_ENCRYPT:
749              ctx->req_signer = 1;      case FM_ENCRYPT_DIR:
750          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_FILE_ENCRYPT, ctx->dlg,      case FM_SIGNENCRYPT: strcpy( status, "ENCRYPTED" ); break;
751                          file_encrypt_dlg_proc, (LPARAM)ctx);      case FM_DECRYPT:     strcpy( status, "UNKNOWN" );   break;
752          if (ctx->cancel == 1) {      case FM_SIGN:        strcpy( status, "SIGNED" );    break;
753              rc = WPTERR_GENERAL;      case FM_VERIFY:      update = 0;                    break;
754              goto leave;      case FM_SYMENC:      strcpy( status, "SYMKEYENC" ); break;
755          }      case FM_IMPORT:      update = 0;                    break;
756          break;      case FM_WIPE:        strcpy( status, "WIPED" );     break;
757                default:             strcpy( status, "UNKNOWN");    break;
758      case FM_SIGN:      }
759          DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FILE_SIGN, dlg,  
760                          file_sign_dlg_proc, (LPARAM) ctx);      if (success) {
761          if (ctx->cancel == 1 || fm_clearsign_8bit (lv, ctx)) {          if (update) {
762              rc = WPTERR_GENERAL;              listview_add_sub_item (lv, pos, 0, status);
763              goto leave;              listview_add_sub_item (lv, pos, 1, output);
764          }          }
765          break;      }
766        listview_add_sub_item( lv, pos, 2, operat );
767      case FM_WIPE:  } /* fm_set_status */
768          memset (&pfx2, 0, sizeof (pfx2));  
769          secure_unlink_set_cb (progress_callback, &pfx2);  
770          break;  int
771      }  fm_clearsign_8bit (listview_ctrl_t lv, fm_state_s *ctx)
772        {
773      for( i = 0, n = 0;  i < listview_count_items( lv, 0 ); i++ ) {      FILE *f;
774          if( !listview_get_item_state( lv, i ) )      byte buf[32];
775              continue;      char name[256];
776          listview_get_item_text( lv, i, 0, status, sizeof (status) -1 );      int i, n, cnt=0;
777          if (!strcmp( status, "ENCRYPTED" ) && fm_cmd == FM_DECRYPT)  
778              n++;      if (ctx->sigmode != GPGME_SIG_MODE_CLEAR)
779          if (!strcmp( status, "UNKNOWN" ) && fm_cmd == FM_SIGN)          return 0;
780              n++;      listview_get_item_text (lv, -1, 1, name, sizeof (name)-1);
781          if (fm_cmd == FM_WIPE)      if (stristr (name, ".TXT"))
782              ndel++;          return 0;
783      }      f = fopen (name, "rb");
784            if (!f)
785      if (n > 1 && fm_cmd != FM_SYMENC)          return -1; /* should never happen */
786          ctx->cache_cb = 1;      n = fread (buf, 1, 32, f);
787        for (i = 0; i < n; i++) {
788      if (fm_cmd == FM_WIPE && ndel > 0) {          if (buf[i] == 0x00 || buf[i] > 170)
789          memset (&confirm, 0, sizeof confirm);              cnt++;
790          confirm.lv_files = lv;      }
791          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_FILES_SECDEL, ctx->dlg,      fclose (f);
792                              file_secdel_confirm_dlg_proc, (LPARAM)&confirm);      if (!cnt)
793          if (!confirm.yes)          return 0;
794              goto leave;      n = -1;
795      }      i = log_box (_("File Manager"), MB_WARN|MB_YESNO,
796                         _("\"%s\" does not seems to be a text file.\n"
797      for( i = 0; i < listview_count_items( lv, 0 ); i++ ) {                     "Do you really want to clearsign it?"), name);
798          if( !listview_get_item_state( lv, i ) )      if (i == IDYES)
799              continue;          n = 0;
800          listview_get_item_text( lv, i, 1, fname, sizeof (fname) - 1 );      return n;
801          if( file_exist_check( fname ) && !is_directory( fname ) ) {  }
802              log_box( _("File Manager"), MB_ERR, _("\"%s\" does not exist"), fname );  
803              continue;  int
804          }  fm_parse_files (listview_ctrl_t lv, HWND dlg, int cmd)
805          if( is_directory( fname ) )  {
806              fm_cmd = FM_ENCRYPT_DIR;              struct secdel_confirm_s confirm = {0};
807          if( !fm_check_file_type( lv, i, fm_cmd ) )      struct progress_filter_s pfx, pfx2;
808              continue;      fm_state_s * ctx;
809          sig_detached = fm_check_detached_sig( lv, i );      int fm_cmd, sig_detached = 0;
810          switch( fm_cmd ) {      int rc = 0, i, n, ndel = 0;
811          case FM_LIST:        rc = fm_list( fname, dlg );       break;      char fname[512], status[128];
812          case FM_WIPE:        rc = fm_wipe( fname );            break;      
813          case FM_ENCRYPT:     rc = fm_encrypt( ctx, fname, 0 ); break;      switch (cmd) {
814          case FM_ENCRYPT_DIR: rc = fm_encrypt_directory( ctx, fname ); break;      case ID_FILEMISC_ENCRYPT: fm_cmd = FM_ENCRYPT; break;
815          case FM_SIGNENCRYPT: rc = fm_encrypt( ctx, fname, 1 ); break;      case ID_FILEMISC_DECRYPT: fm_cmd = FM_DECRYPT; break;
816          case FM_DECRYPT:     rc = fm_decrypt( ctx, fname );    break;      case ID_FILEMISC_SYMENC:  fm_cmd = FM_SYMENC;  break;
817          case FM_SIGN:        rc = fm_sign( ctx, fname );       break;      case ID_FILEMISC_SIGN:    fm_cmd = FM_SIGN;    break;    
818          case FM_SYMENC:      rc = fm_sym_encrypt( ctx, fname );break;      case ID_FILEMISC_VERIFY:  fm_cmd = FM_VERIFY;  break;
819          case FM_VERIFY:      rc = fm_verify (ctx, sig_detached, fname);break;      case ID_FILEMISC_IMPORT:  fm_cmd = FM_IMPORT;  break;
820          case FM_IMPORT:      case ID_FILEMISC_WIPE:    fm_cmd = FM_WIPE;    break;
821              free_if_alloc (ctx->opaque);      case ID_FILEMISC_LIST:    fm_cmd = FM_LIST;    break;
822              ctx->opaque = m_strdup (fname);      case ID_FILEMISC_SIGNENC: fm_cmd = FM_SIGNENCRYPT; break;
823              if (!ctx->opaque)      default: return 1; /* unknown command */
824                  BUG (0);      }
825              DialogBoxParam( glob_hinst, (LPCSTR)IDD_WINPT_IMPORT, dlg,      
826                             file_import_dlg_proc, (LPARAM)ctx );      if (fm_get_current_pos (lv) == -1)
827              if (ctx->cancel == 1)          return WPTERR_GENERAL;    
828                  continue;      rc = fm_state_new (&ctx);
829              rc = fm_import (ctx, fname);      if (rc)
830              break;          BUG (0);
831          }      ctx->dlg = dlg;
832          fm_set_status (lv, i, fm_cmd, !rc, ctx->output);  
833          free_if_alloc (ctx->output);      // XXX: for file operations the progress dialog will be
834          progress_cleanup (&pfx);      //       reloaded somewhere and thus a 'dummy' dialog remains
835      }  
836      if (fm_cmd == FM_WIPE) {      /* we use it here to make sure that pfx_cleanup will not use
837          secure_unlink_set_cb (NULL, NULL);         any weird values. */
838          progress_cleanup (&pfx2);      memset (&pfx, 0, sizeof (pfx));
839      }      ctx->prog_cb = NULL;
840      if (ctx->cache_cb) {      if (cmd != FM_VERIFY && cmd != FM_SIGN /*&& reg_prefs.fm.progress > 0*/) {
841          release_gpg_passphrase_cb (&ctx->pass_cb);          pfx.hwnd = dlg;
842          ctx->cache_cb = 0; /* make sure it's only used for this session! */          /*gpgme_set_progress_cb (ctx->ctx, progress_callback, &pfx);*/
843      }          /*ctx->prog_cb = &pfx;*/
844            }
845      /* remove wipe files from the list */      
846      n = listview_count_items (lv, 0);      /* Commands we need before we can perform the main command */
847      while (n--) {      switch (fm_cmd) {
848          char status[128];      case FM_ENCRYPT:
849          listview_get_item_text (lv, n, 0, status, sizeof (status) - 1);      case FM_SIGNENCRYPT:
850          if( !strcmp (status, "WIPED"))          if (fm_cmd == FM_SIGNENCRYPT)
851              listview_del_item (lv, n);              ctx->req_signer = 1;
852      }          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_FILE_ENCRYPT, ctx->dlg,
853                                file_encrypt_dlg_proc, (LPARAM)ctx);
854  leave:          if (ctx->cancel == 1) {
855      if (!rc)              rc = WPTERR_GENERAL;
856          fm_state_release (ctx);              goto leave;
857      progress_cleanup (&pfx);          }
858      return rc;          break;
859  } /* fm_parse_files */          
860        case FM_SIGN:
861            DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_FILE_SIGN, dlg,
862  /* Wipe the given file @name with the delete mode                          file_sign_dlg_proc, (LPARAM) ctx);
863     from the configuration.          if (ctx->cancel == 1 || fm_clearsign_8bit (lv, ctx)) {
864     Return value: 0 on success. */              rc = WPTERR_GENERAL;
865  int              goto leave;
866  fm_wipe (const char *name)          }
867  {          break;
868      int rc;  
869        case FM_WIPE:
870      SetCursor (LoadCursor (NULL, IDC_WAIT));          memset (&pfx2, 0, sizeof (pfx2));
871      remove_crit_file_attrs (name, 1);          secure_unlink_set_cb (progress_callback, &pfx2);
872      rc = secure_unlink (name, reg_prefs.wipe_mode);          break;
873      SetCursor (LoadCursor (NULL, IDC_ARROW));      }
874      return rc;      
875  }      for( i = 0, n = 0;  i < listview_count_items( lv, 0 ); i++ ) {
876            if( !listview_get_item_state( lv, i ) )
877                continue;
878  /* Dump out the given PGP packets from file @name in a dialog. */          listview_get_item_text( lv, i, 0, status, sizeof (status) -1 );
879  int          if (!strcmp( status, "ENCRYPTED" ) && fm_cmd == FM_DECRYPT)
880  fm_list (const char *name, HWND dlg)              n++;
881  {          if (!strcmp( status, "UNKNOWN" ) && fm_cmd == FM_SIGN)
882      dialog_box_param( glob_hinst, (LPCTSTR)IDD_WINPT_FILE_STAT, dlg,              n++;
883                        file_stat_dlg_proc, (LPARAM)name, _("File Status"),          if (fm_cmd == FM_WIPE)
884                        IDS_WINPT_FILE_STAT );              ndel++;
885      return 0;      }
886  }      
887        if (n > 1 && fm_cmd != FM_SYMENC)
888            ctx->cache_cb = 1;
889  static int  
890  ask_filename (fm_state_t c, const char *msg, char **dst)      if (fm_cmd == FM_WIPE && ndel > 0) {
891  {          memset (&confirm, 0, sizeof confirm);
892      const char * s;          confirm.lv_files = lv;
893            DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_FILES_SECDEL, ctx->dlg,
894      s = get_filename_dlg (c->dlg, FILE_SAVE, msg, NULL, NULL);                              file_secdel_confirm_dlg_proc, (LPARAM)&confirm);
895      if (!s)          if (!confirm.yes)
896          return WPTERR_GENERAL;              goto leave;
897        }
898      if (dst != NULL)      
899          free_if_alloc (*dst);      for( i = 0; i < listview_count_items( lv, 0 ); i++ ) {
900      free_if_alloc (c->output);          if( !listview_get_item_state( lv, i ) )
901      c->output = m_strdup (s);              continue;
902      if (!c->output)          listview_get_item_text( lv, i, 1, fname, sizeof (fname) - 1 );
903          BUG (0);          if( file_exist_check( fname ) && !is_directory( fname ) ) {
904      if (dst)              log_box( _("File Manager"), MB_ERR, _("\"%s\" does not exist"), fname );
905          *dst = fm_quote_file (s);              continue;
906      return 0;          }
907  }          if( is_directory( fname ) )
908                fm_cmd = FM_ENCRYPT_DIR;        
909            if( !fm_check_file_type( lv, i, fm_cmd ) )
910  int              continue;
911  fm_encrypt (fm_state_t c, const char *name, int sign)          sig_detached = fm_check_detached_sig( lv, i );
912  {          switch( fm_cmd ) {
913      gpgme_error_t err;          case FM_LIST:        rc = fm_list( fname, dlg );       break;
914      gpgme_key_t key = NULL;          case FM_WIPE:        rc = fm_wipe( fname );            break;
915      gpgme_ctx_t ctx = c->ctx;          case FM_ENCRYPT:     rc = fm_encrypt( ctx, fname, 0 ); break;
916      file_data_t in=NULL, out=NULL;          case FM_ENCRYPT_DIR: rc = fm_encrypt_directory( ctx, fname ); break;
917      char *keyid = NULL, ext[5];          case FM_SIGNENCRYPT: rc = fm_encrypt( ctx, fname, 1 ); break;
918      int no_compr = 0;          case FM_DECRYPT:     rc = fm_decrypt( ctx, fname );    break;
919      int rc = 0;          case FM_SIGN:        rc = fm_sign( ctx, fname );       break;
920            case FM_SYMENC:      rc = fm_sym_encrypt( ctx, fname );break;
921      c->output = new char[strlen (name) + 5 + 1];          case FM_VERIFY:      rc = fm_verify (ctx, sig_detached, fname);break;
922      if (!c->output)          case FM_IMPORT:
923          BUG (0);              free_if_alloc (ctx->opaque);
924      strcpy (ext, file_get_extension (ctx, c->sigmode));              ctx->opaque = m_strdup (fname);
925      strcpy (c->output, name);              if (!ctx->opaque)
926      strcat (c->output, ext);                          BUG (0);
927                    DialogBoxParam( glob_hinst, (LPCSTR)IDD_WINPT_IMPORT, dlg,
928      if (!overwrite_file (c->output)) {                             file_import_dlg_proc, (LPARAM)ctx );
929          rc = ask_filename (c, _("Enter filename for encrypted file"), NULL);              if (ctx->cancel == 1)
930          if (rc)                  continue;
931              goto leave;              rc = fm_import (ctx, fname);
932      }              break;
933            }
934      err = gpg_file_data_new (name, 1, &in);          fm_set_status (lv, i, fm_cmd, !rc, ctx->output);
935      if (err)          free_if_alloc (ctx->output);
936          goto leave;          progress_cleanup (&pfx);
937      err = gpg_file_data_new (c->output, 0, &out);      }
938      if (err)      if (fm_cmd == FM_WIPE) {
939          goto leave;          secure_unlink_set_cb (NULL, NULL);
940            progress_cleanup (&pfx2);
941      /*      }
942      if (c->prog_cb) {      if (ctx->cache_cb) {
943          c->prog_cb->what = name;          release_gpg_passphrase_cb (&ctx->pass_cb);
944          gpg_file_data_set_cb (in, c->prog_cb);          ctx->cache_cb = 0; /* make sure it's only used for this session! */
945      }      }
946      */      
947            /* remove wipe files from the list */
948      /* XXX      n = listview_count_items (lv, 0);
949      no_compr = is_multi_media (name);      while (n--) {
950      gpgme_control (ctx, GPGME_CTRL_NO_COMPR, no_compr);          char status[128];
951      */          listview_get_item_text (lv, n, 0, status, sizeof (status) - 1);
952            if( !strcmp (status, "WIPED"))
953      if (sign) {              listview_del_item (lv, n);
954          if (gpgme_signers_enum (ctx, 0) == NULL) {      }
955              keyid = get_gnupg_default_key ();      
956              if (!keyid) {  leave:
957                  msg_box (c->dlg, _("Could not get default secret key."),      if (!rc)
958                           _("Signing"), MB_ERR);          fm_state_release (ctx);
959                  rc = WPTERR_GENERAL;      progress_cleanup (&pfx);
960                  goto leave;      return rc;
961              }  } /* fm_parse_files */
962              if (get_seckey (keyid, &key))  
963                  BUG (0);  
964              gpgme_signers_add (ctx, key);  /* Wipe the given file @name with the delete mode
965          }     from the configuration.
966          else {     Return value: 0 on success. */
967              gpgme_key_t key = gpgme_signers_enum (ctx, 0);  int
968              if (key && key->subkeys) {  fm_wipe (const char *name)
969                  keyid = m_strdup (key->subkeys->keyid);  {
970                  if (!keyid)      int rc;
971                      BUG (NULL);  
972              }      SetCursor (LoadCursor (NULL, IDC_WAIT));
973          }      remove_crit_file_attrs (name, 1);
974          if (!c->init_cb || !c->cache_cb) {      rc = secure_unlink (name, reg_prefs.wipe_mode);
975              set_gpg_passphrase_cb (&c->pass_cb, c->ctx, GPG_CMD_SIGN,      SetCursor (LoadCursor (NULL, IDC_ARROW));
976                                     c->dlg, _("Signing"));      return rc;
977              c->init_cb = 1;  }
978          }  
979          err = gpgme_op_encrypt_sign (ctx, c->recp, GPGME_ENCRYPT_ALWAYS_TRUST,  
980                                       in->dat, out->dat);  /* Dump out the given PGP packets from file @name in a dialog. */
981          if (!c->cache_cb)  int
982              release_gpg_passphrase_cb (&c->pass_cb);  fm_list (const char *name, HWND dlg)
983          if (c->pass_cb.cancel) {  {
984              rc = WPTERR_GENERAL;      dialog_box_param( glob_hinst, (LPCTSTR)IDD_WINPT_FILE_STAT, dlg,
985              goto leave;                        file_stat_dlg_proc, (LPARAM)name, _("File Status"),
986          }                        IDS_WINPT_FILE_STAT );
987          if (err) {      return 0;
988              msg_box (c->dlg, gpgme_strerror (err), _("Sign"), MB_ERR);  }
989              if (gpgme_err_code (err) == GPG_ERR_BAD_PASSPHRASE)  
990                  agent_del_cache (keyid);  
991              rc = WPTERR_GENERAL;  static int
992              goto leave;  ask_filename (fm_state_t c, const char *msg, char **dst)
993          }  {
994      }      const char * s;
995      else {  
996          err = gpgme_op_encrypt (ctx, c->recp, GPGME_ENCRYPT_ALWAYS_TRUST,      s = get_filename_dlg (c->dlg, FILE_SAVE, msg, NULL, NULL);
997                                  in->dat, out->dat);      if (!s)
998          if (err) {          return WPTERR_GENERAL;
999              msg_box (c->dlg, gpgme_strerror (err), _("Encrypt"), MB_ERR);  
1000              rc = WPTERR_GENERAL;      if (dst != NULL)
1001              goto leave;          free_if_alloc (*dst);
1002          }      free_if_alloc (c->output);
1003      }      c->output = m_strdup (s);
1004      if (c->wipe)      if (!c->output)
1005          secure_unlink (name, WIPE_MODE_SIMPLE);          BUG (0);
1006            if (dst)
1007  leave:          *dst = fm_quote_file (s);
1008      if (in)      return 0;
1009          gpg_file_data_release (in);  }
1010      if (out)  
1011          gpg_file_data_release (out);  
1012      free_if_alloc (keyid);  int
1013      return rc;  fm_encrypt (fm_state_t c, const char *name, int sign)
1014  }  {
1015        gpgme_error_t err;
1016        gpgme_key_t key = NULL;
1017  int      gpgme_ctx_t ctx = c->ctx;
1018  fm_sym_encrypt (fm_state_t c, const char * name)      file_data_t in=NULL, out=NULL;
1019  {      char *keyid = NULL, ext[5];
1020      gpgme_ctx_t ctx = c->ctx;      /*int no_compr = 0;*/
1021      gpgme_error_t err;          int rc = 0;
1022      file_data_t in=NULL, out=NULL;  
1023      int rc = 0, cancel = 0;      c->output = new char[strlen (name) + 5 + 1];
1024      char * src = NULL, * dst = NULL;      if (!c->output)
1025      char ext[5], * pass;              BUG (0);
1026            strcpy (ext, file_get_extension (ctx, c->sigmode));
1027      pass = request_passphrase2 (_("Symmetric"), 0, &cancel);      strcpy (c->output, name);
1028      if (cancel)      strcat (c->output, ext);        
1029          return 0;      
1030            if (!overwrite_file (c->output)) {
1031      /* XXX gpgme_control (ctx, GPGME_CTRL_CIPHER, -1);*/          rc = ask_filename (c, _("Enter filename for encrypted file"), NULL);
1032      c->output = new char[strlen (name) + 5 + 1];          if (rc)
1033      if (!c->output)              goto leave;
1034          BUG (0);      }
1035      strcpy (ext, file_get_extension (ctx, c->sigmode));  
1036      strcpy (c->output, name);      err = gpg_file_data_new (name, 1, &in);
1037      strcat (c->output, ext);      if (err)
1038            goto leave;
1039      if (overwrite_file (c->output) == 0) {      err = gpg_file_data_new (c->output, 0, &out);
1040          rc = WPTERR_GENERAL;      if (err)
1041          goto leave;              goto leave;
1042      }  
1043        /*
1044      gpgme_set_passphrase_cb (ctx, sym_passphrase_cb, pass);          if (c->prog_cb) {
1045            c->prog_cb->what = name;
1046      err = gpg_file_data_new (name, 1, &in);          gpg_file_data_set_cb (in, c->prog_cb);
1047      if (err)      }
1048          goto leave;      */
1049      err = gpg_file_data_new (c->output, 0, &out);      
1050      if (err)      /* XXX
1051          goto leave;      no_compr = is_multi_media (name);
1052        gpgme_control (ctx, GPGME_CTRL_NO_COMPR, no_compr);
1053      err = gpgme_op_encrypt (ctx, NULL, GPGME_ENCRYPT_ALWAYS_TRUST, in->dat, out->dat);      */
1054      if (err) {  
1055          msg_box (c->dlg, gpgme_strerror (err), _("Symmetric"), MB_ERR);      if (sign) {
1056          rc = WPTERR_GENERAL;          if (gpgme_signers_enum (ctx, 0) == NULL) {
1057          goto leave;              keyid = get_gnupg_default_key ();
1058      }              if (!keyid) {
1059      if (file_exist_check (c->output)) {                  msg_box (c->dlg, _("Could not get default secret key."),
1060          msg_box (c->dlg, _("Encryption failed."), _("Symmetric"), MB_ERR);                           _("Signing"), MB_ERR);
1061          rc = WPTERR_GENERAL;                  rc = WPTERR_GENERAL;
1062      }                  goto leave;
1063                    }
1064  leave:              if (get_seckey (keyid, &key))
1065      if (in)                  BUG (0);
1066          gpg_file_data_release (in);              gpgme_signers_add (ctx, key);
1067      if (out)          }
1068          gpg_file_data_release (out);          else {
1069      sfree_if_alloc (pass);              gpgme_key_t key = gpgme_signers_enum (ctx, 0);
1070      return rc;              if (key && key->subkeys) {
1071  } /* fm_sym_encrypt */                  keyid = m_strdup (key->subkeys->keyid);
1072                    if (!keyid)
1073                        BUG (NULL);
1074  /* Show the human readable verify result from @sigres. */              }
1075  static void          }
1076  show_verify_result (gpgme_verify_result_t sigres)          if (!c->init_cb || !c->cache_cb) {
1077  {              set_gpg_passphrase_cb (&c->pass_cb, c->ctx, GPG_CMD_SIGN,
1078      gpgme_key_t key=NULL;                                     c->dlg, _("Signing"));
1079      gpgme_signature_t sig=sigres->signatures;              c->init_cb = 1;
1080      const char *s, *keyid;          }
1081      int sigok = 0;          op_begin ();
1082      int type;          err = gpgme_op_encrypt_sign (ctx, c->recp, GPGME_ENCRYPT_ALWAYS_TRUST,
1083      char buf[384];                                       in->dat, out->dat);
1084            op_end ();
1085      sig = sigres->signatures;          if (!c->cache_cb)
1086      sigok = sig->summary & GPGME_SIGSUM_GREEN;              release_gpg_passphrase_cb (&c->pass_cb);
1087      s = sigok? _("Good signature") : _("BAD signature");          if (c->pass_cb.cancel) {
1088      type = sigok? MB_OK: MB_ICONWARNING|MB_OK;              rc = WPTERR_GENERAL;
1089      keyid = sig->fpr;                goto leave;
1090      if (!keyid)          }
1091          return;          if (err) {
1092                msg_box (c->dlg, gpgme_strerror (err), _("Sign"), MB_ERR);
1093      keyid = strlen (sig->fpr) == 40? sig->fpr+32 : sig->fpr + 24;              if (gpgme_err_code (err) == GPG_ERR_BAD_PASSPHRASE)
1094      get_pubkey (sig->fpr, &key);                  agent_del_cache (keyid);
1095      _snprintf (buf, sizeof (buf)-1, "Signature made %s using %s key ID %s\n"              rc = WPTERR_GENERAL;
1096                                      "%s from \"%s\"",              goto leave;
1097                  strtimestamp (sig->timestamp), get_key_pubalgo (sig->pubkey_algo),          }
1098                  keyid, s, key? key->uids->uid : _("user ID not found"));      }
1099      msg_box (NULL, buf, _("Decrypt Verify"), type);      else {
1100  }          op_begin ();
1101            err = gpgme_op_encrypt (ctx, c->recp, GPGME_ENCRYPT_ALWAYS_TRUST,
1102                                    in->dat, out->dat);
1103  /* Check the recipients if we have at least one secret key. */          op_end ();
1104  bool          if (err) {
1105  secret_key_available (gpgme_recipient_t rset)              msg_box (c->dlg, gpgme_strerror (err), _("Encrypt"), MB_ERR);
1106  {              rc = WPTERR_GENERAL;
1107      gpgme_recipient_t r;              goto leave;
1108      gpgme_key_t key;          }
1109        }
1110      for (r=rset; r; r = r->next) {            if (c->wipe)
1111          if (gpgme_err_code (r->status) == GPG_ERR_NO_SECKEY)          secure_unlink (name, WIPE_MODE_SIMPLE);
1112              continue;      
1113          else {  leave:
1114              /* extra check to make sure the key is available right now. */      if (in)
1115              if (!get_seckey (r->keyid, &key))          gpg_file_data_release (in);
1116                  return true;      if (out)
1117          }          gpg_file_data_release (out);
1118      }      free_if_alloc (keyid);
1119      return false;      return rc;
1120  }  }
1121    
1122    
1123  /* Decrypt the file @name. */  int
1124  int  fm_sym_encrypt (fm_state_t c, const char * name)
1125  fm_decrypt (fm_state_t c, const char *name)  {
1126  {      gpgme_ctx_t ctx = c->ctx;
1127      gpgme_error_t err;      gpgme_error_t err;    
1128      gpgme_ctx_t ctx = c->ctx;          file_data_t in=NULL, out=NULL;
1129      gpgme_decrypt_result_t res;      int rc = 0, cancel = 0;
1130      gpgme_verify_result_t sigres;      char ext[5], * pass;    
1131      file_data_t in =NULL, out=NULL;      
1132      int is_signed = 0;      pass = request_passphrase2 (_("Symmetric"), 0, &cancel);
1133      int rc = 0;      if (cancel)
1134                return 0;
1135      if (!c->init_cb || !c->cache_cb) {      
1136          set_gpg_passphrase_cb (&c->pass_cb, c->ctx, GPG_CMD_DECRYPT,      /* XXX gpgme_control (ctx, GPGME_CTRL_CIPHER, -1);*/
1137                                 c->dlg, _("Decryption"));      c->output = new char[strlen (name) + 5 + 1];
1138          c->init_cb = 1;      if (!c->output)
1139      }              BUG (0);
1140            strcpy (ext, file_get_extension (ctx, c->sigmode));
1141      c->output = m_strdup (name);      strcpy (c->output, name);
1142      if (!c->output)      strcat (c->output, ext);
1143          BUG (0);  
1144      if (is_openpgp_ext (c->output))      if (overwrite_file (c->output) == 0) {
1145          c->output[strlen (c->output)-4] = '\0';          rc = WPTERR_GENERAL;
1146      else {          goto leave;    
1147          const char *s = get_filesave_dlg (c->dlg, _("Choose Filename for Output"),      }
1148                                            NULL, NULL);  
1149          if (s) {      gpgme_set_passphrase_cb (ctx, sym_passphrase_cb, pass);    
1150              free_if_alloc (c->output);  
1151              c->output = m_strdup (s);      err = gpg_file_data_new (name, 1, &in);
1152              if (!c->output)      if (err)
1153                  BUG (NULL);          goto leave;
1154          }      err = gpg_file_data_new (c->output, 0, &out);
1155      }      if (err)
1156            goto leave;
1157      if (overwrite_file (c->output) == 0) {  
1158          rc = ask_filename (c, _("Please enter filename for plaintext file"), NULL);      op_begin ();
1159          if (rc)      err = gpgme_op_encrypt (ctx, NULL, GPGME_ENCRYPT_ALWAYS_TRUST,
1160              goto leave;                              in->dat, out->dat);
1161      }          op_end ();
1162        if (err) {
1163      remove_crit_file_attrs (c->output, 0);          msg_box (c->dlg, gpgme_strerror (err), _("Symmetric"), MB_ERR);
1164            rc = WPTERR_GENERAL;
1165      err = gpg_file_data_new (name, 1, &in);          goto leave;
1166      if (err)      }
1167          goto leave;      if (file_exist_check (c->output)) {
1168      err = gpg_file_data_new (c->output, 0, &out);          msg_box (c->dlg, _("Encryption failed."), _("Symmetric"), MB_ERR);
1169      if (err)          rc = WPTERR_GENERAL;
1170          goto leave;      }
1171        
1172      err = gpgme_op_decrypt_verify (ctx, in->dat, out->dat);  leave:
1173      if (!c->cache_cb)      if (in)
1174          release_gpg_passphrase_cb (&c->pass_cb);          gpg_file_data_release (in);
1175      if (c->pass_cb.cancel) {      if (out)
1176          rc = WPTERR_GENERAL;          gpg_file_data_release (out);
1177          goto leave;      sfree_if_alloc (pass);
1178      }      return rc;
1179    } /* fm_sym_encrypt */
1180      res = gpgme_op_decrypt_result (ctx);  
1181      if (res && res->recipients && !secret_key_available (res->recipients)) {  
1182          const char *keyid = res->recipients->keyid;  /* Show the human readable verify result from @sigres. */
1183          char *p = get_key_userid (keyid+8);  static void
1184          gpgme_pubkey_algo_t pkalgo = res->recipients->pubkey_algo;  show_verify_result (gpgme_verify_result_t sigres)
1185            {
1186          log_box( _("Decryption"), MB_ERR,      gpgme_key_t key=NULL;
1187                   _("Encrypted with %s key, ID %s.%s\n"      gpgme_signature_t sig=sigres->signatures;
1188                     "Decryption failed: secret key not available."),      const char *s, *keyid;
1189                     get_key_pubalgo (pkalgo), keyid+8, p);      int sigok = 0;
1190          rc = WPTERR_GENERAL;      int type;
1191          free_if_alloc (p);      char buf[384];
1192          goto leave;  
1193      }      sig = sigres->signatures;
1194      else if (err) {      sigok = sig->summary & GPGME_SIGSUM_GREEN;
1195          msg_box (c->dlg, gpgme_strerror (err), _("Decrypt"), MB_ERR);      s = sigok? _("Good signature") : _("BAD signature");
1196          rc = WPTERR_GENERAL;      type = sigok? MB_OK: MB_ICONWARNING|MB_OK;
1197          goto leave;      keyid = sig->fpr;  
1198      }      if (!keyid)
1199      if (file_exist_check (c->output)) {          return;
1200          log_box ("Decrypt", MB_ERR, _("Decryption failed.\n%s: does not exist."), c->output);  
1201          rc = WPTERR_GENERAL;      keyid = strlen (sig->fpr) == 40? sig->fpr+32 : sig->fpr + 24;
1202      }      get_pubkey (sig->fpr, &key);
1203            _snprintf (buf, sizeof (buf)-1, "Signature made %s using %s key ID %s\n"
1204      sigres = gpgme_op_verify_result (ctx);                                      "%s from \"%s\"",
1205      if (sigres && sigres->signatures)                  strtimestamp (sig->timestamp), get_key_pubalgo (sig->pubkey_algo),
1206          show_verify_result (sigres);                  keyid, s, key? key->uids->uid : _("user ID not found"));
1207        msg_box (NULL, buf, _("Decrypt Verify"), type);
1208        }
1209  leave:  
1210      if (in)  
1211          gpg_file_data_release (in);  /* Check the recipients if we have at least one secret key. */
1212      if (out)  bool
1213          gpg_file_data_release (out);  secret_key_available (gpgme_recipient_t rset)
1214      return rc;  {
1215  }      gpgme_recipient_t r;
1216        gpgme_key_t key;
1217    
1218  int      for (r=rset; r; r = r->next) {      
1219  fm_sign (fm_state_t c, const char * name)          if (gpgme_err_code (r->status) == GPG_ERR_NO_SECKEY)
1220  {                    continue;
1221      int rc = 0;          else {
1222      gpgme_ctx_t ctx = c->ctx;              /* extra check to make sure the key is available right now. */
1223      gpgme_error_t err;              if (!get_seckey (r->keyid, &key))
1224      file_data_t in=NULL, out=NULL;                  return true;
1225      char ext[5];          }
1226        }
1227      if (!c->init_cb || !c->cache_cb) {      return false;
1228          set_gpg_passphrase_cb (&c->pass_cb, c->ctx, GPG_CMD_SIGN, c->dlg, _("Signing") );  }
1229          c->init_cb = 1;  
1230      }  
1231        /* Decrypt the file @name. */
1232      free_if_alloc (c->output);  int
1233      c->output = new char[strlen (name) + 5 + 1];  fm_decrypt (fm_state_t c, const char *name)
1234      if( !c->output)  {
1235          BUG( NULL );      gpgme_error_t err;
1236      strcpy (ext, file_get_extension (ctx, c->sigmode));      gpgme_ctx_t ctx = c->ctx;    
1237      strcpy (c->output, name);      gpgme_decrypt_result_t res;
1238      strcat (c->output, ext);      gpgme_verify_result_t sigres;
1239            file_data_t in =NULL, out=NULL;
1240      if (!overwrite_file (c->output)) {      int rc = 0;
1241          rc = ask_filename (c, _("Enter filename for signed file"), NULL);      
1242          if (rc)      if (!c->init_cb || !c->cache_cb) {
1243              goto leave;          set_gpg_passphrase_cb (&c->pass_cb, c->ctx, GPG_CMD_DECRYPT,
1244      }                                 c->dlg, _("Decryption"));
1245      remove_crit_file_attrs (c->output, 0);          c->init_cb = 1;
1246        }    
1247      err = gpg_file_data_new (name, 1, &in);      
1248      if (err)      c->output = m_strdup (name);
1249          goto leave;      if (!c->output)
1250      err = gpg_file_data_new (c->output, 0, &out);          BUG (0);
1251      if (err)      if (is_openpgp_ext (c->output))
1252          goto leave;          c->output[strlen (c->output)-4] = '\0';
1253        else {
1254      err = gpgme_op_sign (ctx, in->dat, out->dat, c->sigmode);          const char *s;
1255      if( !c->cache_cb )          s = get_filesave_dlg (c->dlg, _("Choose Filename for Output"),
1256          release_gpg_passphrase_cb (&c->pass_cb);                                NULL, NULL);
1257      if( c->pass_cb.cancel ) {          if (s) {
1258          rc = WPTERR_GENERAL;              free_if_alloc (c->output);
1259          goto leave;              c->output = m_strdup (s);
1260      }              if (!c->output)
1261      if( err ) {                  BUG (NULL);
1262          msg_box( c->dlg, gpgme_strerror( err ), _("Sign"), MB_ERR );          }
1263          rc = WPTERR_GENERAL;      }
1264          goto leave;      
1265      }      if (overwrite_file (c->output) == 0) {
1266            rc = ask_filename (c, _("Please enter filename for plaintext file"), NULL);
1267  leave:          if (rc)
1268      if (in)              goto leave;
1269          gpg_file_data_release (in);      }    
1270      if (out)  
1271          gpg_file_data_release (out);      remove_crit_file_attrs (c->output, 0);
1272      return rc;  
1273  }      err = gpg_file_data_new (name, 1, &in);
1274        if (err)
1275            goto leave;
1276  static int      err = gpg_file_data_new (c->output, 0, &out);
1277  fm_add_sig_stat (file_sig_ctx_t log)      if (err)
1278  {          goto leave;
1279      gpgme_key_t key;      
1280      const char *kid;      op_begin ();
1281      int not_found = 0;      err = gpgme_op_decrypt_verify (ctx, in->dat, out->dat);
1282        op_end ();
1283      kid = log->sig->fpr;      if (!c->cache_cb)
1284      if (!kid)          release_gpg_passphrase_cb (&c->pass_cb);
1285          BUG (NULL);      if (c->pass_cb.cancel) {
1286      if (strlen (kid) == 40)          rc = WPTERR_GENERAL;
1287          kid += 32;                goto leave;
1288      else if (strlen (kid) == 32)      }
1289          kid += 24;  
1290      if (get_pubkey (kid, &key))      res = gpgme_op_decrypt_result (ctx);
1291          log->use_uid = 0;      if (res && res->recipients && !secret_key_available (res->recipients)) {
1292      else {          const char *keyid = res->recipients->keyid;
1293          log->user_id = key->uids->uid;          char *p = get_key_userid (keyid+8);
1294          log->use_uid = 1;          gpgme_pubkey_algo_t pkalgo = res->recipients->pubkey_algo;
1295      }          
1296      file_verify_add_state (log);          log_box( _("Decryption"), MB_ERR,
1297      return 0;                   _("Encrypted with %s key, ID %s.%s\n"
1298  }                     "Decryption failed: secret key not available."),
1299                       get_key_pubalgo (pkalgo), keyid+8, p);
1300            rc = WPTERR_GENERAL;
1301  static int          free_if_alloc (p);
1302  verify_pasted (listview_ctrl_t lv, fm_state_t ctx, const char * dat,          goto leave;
1303                 int i, HWND dlg)      }
1304  {      else if (err) {
1305      FILE * fp;          msg_box (c->dlg, gpgme_strerror (err), _("Decrypt"), MB_ERR);
1306      char stat[32];          rc = WPTERR_GENERAL;
1307      char file[256], * fname = NULL;          goto leave;
1308      int del_end=0;      }
1309        if (file_exist_check (c->output)) {
1310      listview_get_item_text (lv, i, 0, stat, sizeof (stat)-1);          log_box ("Decrypt", MB_ERR, _("Decryption failed.\n%s: does not exist."), c->output);
1311      listview_get_item_text (lv, i, 1, file, sizeof (file)-1);          rc = WPTERR_GENERAL;
1312      if (strcmp (stat, "UNKNOWN"))      }
1313          return 0;      
1314      fname = make_filename (NULL, file, "asc");      sigres = gpgme_op_verify_result (ctx);
1315      if (file_exist_check (fname) != 0) {      if (sigres && sigres->signatures)
1316          fp = fopen (fname, "wb");          show_verify_result (sigres);
1317          if (fp == NULL) {      
1318              log_box (_("File Manager"), MB_ERR, "could not create '%s'", fname);  leave:
1319              free_if_alloc (fname);      if (in)
1320              return WPTERR_GENERAL;                gpg_file_data_release (in);
1321          }            if (out)
1322          fwrite (dat, 1, strlen (dat), fp);          gpg_file_data_release (out);
1323          fclose (fp);      return rc;
1324          del_end = 1;  }
1325      }  
1326      fm_verify (ctx, 1, fname);  
1327      if (del_end)  int
1328          unlink (fname);  fm_sign (fm_state_t c, const char * name)
1329      free_if_alloc (fname);  {      
1330      return 0;      int rc = 0;
1331  }      gpgme_ctx_t ctx = c->ctx;
1332        gpgme_error_t err;
1333        file_data_t in=NULL, out=NULL;
1334  int      char ext[5];
1335  fm_verify_pasted_detsig (listview_ctrl_t lv, HWND dlg)  
1336  {      if (!c->init_cb || !c->cache_cb) {
1337      fm_state_t ctx = NULL;          set_gpg_passphrase_cb (&c->pass_cb, c->ctx, GPG_CMD_SIGN, c->dlg, _("Signing") );
1338      char * dat=NULL;          c->init_cb = 1;
1339      int i, fnd = 0;      }
1340        
1341      dat = get_clip_text (NULL);      free_if_alloc (c->output);
1342      if (!dat || !strstr (dat, "BEGIN PGP SIGNATURE")) {      c->output = new char[strlen (name) + 5 + 1];
1343          msg_box (dlg, _("Could not find detached signature in the clipboard."),      if( !c->output)
1344                   _("File Manager"), MB_ERR);          BUG( NULL );
1345          free_if_alloc (dat);      strcpy (ext, file_get_extension (ctx, c->sigmode));
1346          return WPTERR_GENERAL;      strcpy (c->output, name);
1347      }      strcat (c->output, ext);
1348      /* XXX find a way to filter out bad signatures or just ignore all in      
1349             this case */      if (!overwrite_file (c->output)) {
1350      fm_state_new (&ctx);          rc = ask_filename (c, _("Enter filename for signed file"), NULL);
1351      if ((i=listview_get_curr_pos (lv)) != -1) {          if (rc)
1352          verify_pasted (lv, ctx, dat, i, dlg);              goto leave;
1353          fnd = 1;      }
1354      }      remove_crit_file_attrs (c->output, 0);
1355      else {  
1356          for (i=0; i < listview_count_items (lv, 0); i++) {      err = gpg_file_data_new (name, 1, &in);
1357              verify_pasted (lv, ctx, dat, i, dlg);      if (err)
1358              fnd = 1;          goto leave;
1359          }      err = gpg_file_data_new (c->output, 0, &out);
1360      }      if (err)
1361      if (!fnd)          goto leave;
1362          msg_box (dlg, _("No files to check."), _("File Manager"), MB_INFO);  
1363      free_if_alloc (dat);      op_begin ();
1364      fm_state_release (ctx);      err = gpgme_op_sign (ctx, in->dat, out->dat, c->sigmode);
1365      return 0;      op_end ();
1366  }      if( !c->cache_cb )
1367            release_gpg_passphrase_cb (&c->pass_cb);
1368        if( c->pass_cb.cancel ) {
1369  /* Extract automatically the output file name from @name.          rc = WPTERR_GENERAL;
1370     If @detached is 1, a detached sig is assumed. */          goto leave;
1371  static int      }
1372  get_output_file (fm_state_t c, const char *name, int detached)      if( err ) {
1373  {          msg_box( c->dlg, gpgme_strerror( err ), _("Sign"), MB_ERR );
1374      const char *file = NULL;          rc = WPTERR_GENERAL;
1375      const char *title;          goto leave;    
1376      char fname[384];      }
1377        
1378      if (detached)  leave:
1379          title = _("Select Data File");      if (in)
1380      else          gpg_file_data_release (in);
1381          title = _("Selected Output File");      if (out)
1382            gpg_file_data_release (out);
1383      if (strstr (name, ".sig") || strstr (name, ".asc") || strstr (name, ".gpg")) {      return rc;
1384          _snprintf (fname, sizeof (fname) - 1, "%s", name);  }
1385          fname[strlen (fname) - 4] = '\0';  
1386          if (file_exist_check (fname) == 0 && detached)    
1387              file = fname;  static int
1388          else if (!detached) {  fm_add_sig_stat (file_sig_ctx_t log)
1389              /* If the signature is clear or normal, make sure we do not  {
1390                 overwrite the original file if it exists. */      gpgme_key_t key;    
1391              if (file_exist_check (fname) == 0 && !overwrite_file (fname)) {      const char *kid;
1392                  file = get_filesave_dlg (c->dlg, title, NULL, NULL);  
1393                  if (!file)      kid = log->sig->fpr;
1394                      return WPTERR_GENERAL;      if (!kid)
1395              }          BUG (NULL);
1396              else      if (strlen (kid) == 40)
1397                  file = fname;          kid += 32;      
1398          }      else if (strlen (kid) == 32)
1399      }          kid += 24;
1400      if (!file)      if (get_pubkey (kid, &key))
1401          file = get_fileopen_dlg (c->dlg, title, NULL, NULL);          log->use_uid = 0;
1402      if (file) {          else {
1403          free_if_alloc (c->output);              log->user_id = key->uids->uid;
1404          c->output = m_strdup (file);          log->use_uid = 1;
1405          if (!c->output)      }
1406              BUG (NULL);      file_verify_add_state (log);
1407      }      return 0;
1408      else {  }
1409          msg_box (c->dlg, _("Invalid file name. Exit"), _("Verify"), MB_ERR);  
1410          return WPTERR_GENERAL;    
1411      }  static int
1412      if (detached)  verify_pasted (listview_ctrl_t lv, fm_state_t ctx, const char * dat,
1413          c->sigmode = GPGME_SIG_MODE_DETACH;                 int i, HWND dlg)
1414      else {  {
1415          if (strstr (name, ".asc"))      FILE * fp;
1416              c->sigmode = GPGME_SIG_MODE_CLEAR;      char stat[32];
1417          else      char file[256], * fname = NULL;
1418              c->sigmode = GPGME_SIG_MODE_NORMAL;      int del_end=0;
1419      }  
1420      return 0;      listview_get_item_text (lv, i, 0, stat, sizeof (stat)-1);
1421  }      listview_get_item_text (lv, i, 1, file, sizeof (file)-1);
1422        if (strcmp (stat, "UNKNOWN"))
1423            return 0;
1424  /* Verify the signature from the file @name. If @detached 1,      fname = make_filename (NULL, file, "asc");
1425     it is assumed that a detached signature should be checked. */      if (file_exist_check (fname) != 0) {
1426  int          fp = fopen (fname, "wb");
1427  fm_verify (fm_state_t c, int detached, const char *name)          if (fp == NULL) {
1428  {              log_box (_("File Manager"), MB_ERR, "could not create '%s'", fname);
1429      gpgme_ctx_t ctx = c->ctx;              free_if_alloc (fname);
1430      gpgme_error_t err;              return WPTERR_GENERAL;      
1431      gpgme_signature_t s;          }      
1432      gpgme_verify_result_t res;          fwrite (dat, 1, strlen (dat), fp);
1433      struct file_sig_ctx_s log;          fclose (fp);
1434      file_data_t in=NULL, out=NULL;          del_end = 1;
1435      int rc = 0;      }
1436        fm_verify (ctx, 1, fname);
1437      if (strstr (name, ".sig"))      if (del_end)
1438          detached = 1;          unlink (fname);
1439        free_if_alloc (fname);
1440      if (get_output_file (c, name, detached))      return 0;
1441          return WPTERR_GENERAL;  }
1442    
1443      memset (&log, 0, sizeof (log));  
1444      log.file = m_strdup (name);  int
1445      if (!log.file)  fm_verify_pasted_detsig (listview_ctrl_t lv, HWND dlg)
1446          BUG (NULL);  {
1447      file_verify_create_dlg ();      fm_state_t ctx = NULL;
1448        char * dat=NULL;
1449      err = gpg_file_data_new (name, 1, &in);      int i, fnd = 0;
1450      if (err)  
1451          goto leave;      dat = get_clip_text (NULL);
1452      err = gpg_file_data_new (c->output, detached? 1 : 0, &out);      if (!dat || !strstr (dat, "BEGIN PGP SIGNATURE")) {
1453      if (err)          msg_box (dlg, _("Could not find detached signature in the clipboard."),
1454          goto leave;                   _("File Manager"), MB_ERR);
1455            free_if_alloc (dat);
1456      if (c->sigmode == GPGME_SIG_MODE_DETACH)          return WPTERR_GENERAL;
1457          err = gpgme_op_verify (ctx, in->dat, out->dat, NULL);      }
1458      else      /* XXX find a way to filter out bad signatures or just ignore all in
1459          err = gpgme_op_verify (ctx, in->dat, in->dat, out->dat);             this case */
1460      if (err) {      fm_state_new (&ctx);
1461          msg_box (c->dlg, gpgme_strerror (err), _("Verify"), MB_ERR);      if ((i=listview_get_curr_pos (lv)) != -1) {
1462          rc = WPTERR_GENERAL;          verify_pasted (lv, ctx, dat, i, dlg);
1463          goto leave;          fnd = 1;
1464      }          }
1465        else {
1466      res = gpgme_op_verify_result (ctx);          for (i=0; i < listview_count_items (lv, 0); i++) {
1467      for (s=res->signatures; s; s=s->next) {              verify_pasted (lv, ctx, dat, i, dlg);
1468          log.sig = s;              fnd = 1;
1469          fm_add_sig_stat (&log);          }
1470      }      }
1471      if (!c->output)      if (!fnd)
1472          c->output = m_strdup (name); /* for later use */          msg_box (dlg, _("No files to check."), _("File Manager"), MB_INFO);
1473        free_if_alloc (dat);
1474  leave:      fm_state_release (ctx);
1475      if (in)      return 0;
1476          gpg_file_data_release (in);  }
1477      if (out)  
1478          gpg_file_data_release (out);  
1479      if (log.file)  /* Extract automatically the output file name from @name.
1480          delete []log.file;     If @detached is 1, a detached sig is assumed. */
1481      return rc;  static int
1482  }  get_output_file (fm_state_t c, const char *name, int detached)
1483    {
1484        const char *file = NULL;
1485  int      const char *title;
1486  fm_import (fm_state_t c, const char *name)      char fname[384];
1487  {      
1488      gpgme_ctx_t ctx = c->ctx;      if (detached)
1489      gpgme_error_t err;          title = _("Select Data File");
1490      gpgme_import_result_t res;      else
1491      file_data_t keydata = NULL;          title = _("Selected Output File");
1492      int rc = 0;  
1493        if (strstr (name, ".sig") || strstr (name, ".asc") || strstr (name, ".gpg")) {
1494      free_if_alloc (c->output);          _snprintf (fname, sizeof (fname) - 1, "%s", name);
1495      c->output = m_strdup (name);          fname[strlen (fname) - 4] = '\0';
1496      if (!c->output)          if (file_exist_check (fname) == 0 && detached)  
1497          BUG (NULL);              file = fname;
1498            else if (!detached) {
1499      err = gpg_file_data_new (name, 1, &keydata);              /* If the signature is clear or normal, make sure we do not
1500      if (err)                 overwrite the original file if it exists. */
1501          goto leave;              if (file_exist_check (fname) == 0 && !overwrite_file (fname)) {
1502                    file = get_filesave_dlg (c->dlg, title, NULL, NULL);
1503      err = gpgme_op_import (ctx, keydata->dat);                  if (!file)
1504      if (err) {                      return WPTERR_GENERAL;
1505          msg_box (c->dlg, gpgme_strerror (err), _("Import"), MB_ERR);              }
1506          rc = WPTERR_GENERAL;              else
1507          goto leave;                  file = fname;
1508      }          }
1509        }
1510      res = gpgme_op_import_result (ctx);      if (!file)
1511      print_import_status (res);          file = get_fileopen_dlg (c->dlg, title, NULL, NULL);
1512      if (res->no_user_id > 0) {      if (file) {    
1513          msg_box (c->dlg, _("Key without a self signature was dectected!\n"                free_if_alloc (c->output);    
1514                             "(This key is NOT usable for encryption, etc)\n"          c->output = m_strdup (file);
1515                             "\n"          if (!c->output)
1516                             "Cannot import these key(s)!"), _("Import"), MB_INFO);              BUG (NULL);
1517      }      }
1518        else {
1519  leave:          msg_box (c->dlg, _("Invalid file name. Exit"), _("Verify"), MB_ERR);
1520      if (keydata)          return WPTERR_GENERAL;  
1521          gpg_file_data_release (keydata);      }
1522      return rc;      if (detached)
1523  } /* fm_import */          c->sigmode = GPGME_SIG_MODE_DETACH;
1524        else {
1525            if (strstr (name, ".asc"))
1526  /* Export the selected keys from the File Manager to a file. */              c->sigmode = GPGME_SIG_MODE_CLEAR;
1527  int          else
1528  fm_export (fm_state_t c)              c->sigmode = GPGME_SIG_MODE_NORMAL;
1529  {      }
1530      int rc = 0, id = 0;      return 0;
1531      gpgme_ctx_t ctx = c->ctx;  }
1532      gpgme_error_t err;  
1533      gpgme_key_t *rset = c->recp;  
1534      file_data_t keydata = NULL;  /* Verify the signature from the file @name. If @detached 1,
1535      const char *name, *s = NULL;     it is assumed that a detached signature should be checked. */
1536      char *p = NULL, *patt = NULL;  int
1537    fm_verify (fm_state_t c, int detached, const char *name)
1538      if (!rset || !rset[0]) {  {
1539          msg_box (c->dlg, _("No key was selected for export."), _("Export"), MB_ERR);      gpgme_ctx_t ctx = c->ctx;
1540          rc = WPTERR_GENERAL;      gpgme_error_t err;
1541          goto leave;      gpgme_signature_t s;
1542      }      gpgme_verify_result_t res;
1543        struct file_sig_ctx_s log;
1544      if (rset[1] == NULL) { /* count == 1*/      file_data_t in=NULL, out=NULL;
1545          gpgme_key_t k = rset[0];      int rc = 0;
1546          const char *s = k->uids->name;  
1547          p = new char[strlen (s)+1+8];      if (strstr (name, ".sig"))
1548          if (!p)          detached = 1;
1549              BUG (NULL);  
1550          strcpy (p, s );      if (get_output_file (c, name, detached))
1551          strcat (p, ".asc");          return WPTERR_GENERAL;
1552      }  
1553        memset (&log, 0, sizeof (log));
1554      name = get_filename_dlg (c->dlg, FILE_SAVE, _("Choose Name for Key File"),      log.file = m_strdup (name);
1555                               NULL, p? p : NULL);      if (!log.file)
1556                                        BUG (NULL);
1557      if (!name)      file_verify_create_dlg ();
1558          name = "keys.gpg";  
1559        err = gpg_file_data_new (name, 1, &in);
1560      patt = gpg_keylist_to_pattern (rset, c->n_recp);      if (err)
1561            goto leave;
1562      err = gpg_file_data_new (name, 0, &keydata);      err = gpg_file_data_new (c->output, detached? 1 : 0, &out);
1563      if (err)      if (err)
1564          goto leave;          goto leave;
1565    
1566      err = gpgme_op_export (ctx, patt, 0, keydata->dat);      op_begin ();
1567      if (err) {      if (c->sigmode == GPGME_SIG_MODE_DETACH)
1568          msg_box (c->dlg, gpgme_strerror (err), _("Export"), MB_ERR);          err = gpgme_op_verify (ctx, in->dat, out->dat, NULL);
1569          rc = WPTERR_GENERAL;      else
1570          goto leave;              err = gpgme_op_verify (ctx, in->dat, in->dat, out->dat);
1571      }      op_end ();
1572      log_box (_("GnuPG status"), MB_OK, _("Finished (Output: %s)"),  name);      if (err) {
1573            msg_box (c->dlg, gpgme_strerror (err), _("Verify"), MB_ERR);
1574  leave:          rc = WPTERR_GENERAL;
1575      if (keydata)          goto leave;
1576          gpg_file_data_release (keydata);      }    
1577      if (patt)  
1578          free (patt);      res = gpgme_op_verify_result (ctx);
1579      free_if_alloc (p);      for (s=res->signatures; s; s=s->next) {
1580                    log.sig = s;
1581      return rc;          fm_add_sig_stat (&log);
1582  }      }
1583        if (!c->output)
1584            c->output = m_strdup (name); /* for later use */
1585  int  
1586  fm_parse_command_line (char *cmdl)  leave:
1587  {      if (in)
1588      fm_state_t ctx;          gpg_file_data_release (in);
1589      const char *s;      if (out)
1590      char *p, *fn = NULL;          gpg_file_data_release (out);
1591      int count = 0, detached = 0;      if (log.file)
1592                delete []log.file;
1593      if( !cmdl || !*cmdl )      return rc;
1594          return 0;  }
1595    
1596      fm_state_new( &ctx );      
1597      ctx->dlg = GetActiveWindow( );  int
1598      ctx->cache_cb = 1;          fm_import (fm_state_t c, const char *name)
1599        {
1600      p = cmdl;      gpgme_ctx_t ctx = c->ctx;
1601      if( p && *p > 32 && !stristr( p, "winpt.exe" )      gpgme_error_t err;
1602                       && !strstr( p, "--" ) ) {      gpgme_import_result_t res;
1603          count++;      file_data_t keydata = NULL;
1604          if (*p == '"') { /* need to remove quotes */      int rc = 0;
1605              fn = new char[strlen( p )];  
1606              if (!fn)      free_if_alloc (c->output);
1607                  BUG( NULL );      c->output = m_strdup (name);
1608              memcpy( fn, p+1, strlen( p ) - 2 );      if (!c->output)
1609              fn[strlen( p ) -2] = '\0';          BUG (NULL);
1610          }  
1611          else      err = gpg_file_data_new (name, 1, &keydata);
1612              fn = m_strdup (p);      if (err)
1613          s = fm_get_file_type (fn);          goto leave;
1614          if (!s || !strcmp (s, "UNKNOWN"))  
1615              s = gnupg_check_file_ext (fn);      op_begin ();
1616          if (*s == 'U') {      err = gpgme_op_import (ctx, keydata->dat);
1617              log_box( _("File Manager"), MB_ERR, _("%s: no valid OpenPGP data found."), p );      op_end ();
1618              return count;      if (err) {
1619          }          msg_box (c->dlg, gpgme_strerror (err), _("Import"), MB_ERR);
1620                    rc = WPTERR_GENERAL;
1621          switch( *s ) {          goto leave;
1622          case 'E': fm_decrypt (ctx, fn); break;      }
1623          case 'P': fm_import (ctx, fn); break;  
1624          case 'S':      res = gpgme_op_import_result (ctx);
1625              if (s[1] == 'Y') {      print_import_status (res);
1626                  fm_decrypt (ctx, fn);      if (res->no_user_id > 0) {
1627                  break;          msg_box (c->dlg, _("Key without a self signature was dectected!\n"      
1628              }                             "(This key is NOT usable for encryption, etc)\n"
1629              file_verify_use_event ();                             "\n"
1630              if (s[1] == 'I') {                             "Cannot import these key(s)!"), _("Import"), MB_INFO);
1631                  if (strlen (s) == 13 && s[7] == 'D')      }
1632                      detached = 1;  
1633                  fm_verify( ctx, detached, fn );  leave:
1634              }      if (keydata)
1635              file_verify_wait( );          gpg_file_data_release (keydata);
1636              break;      return rc;
1637          }  } /* fm_import */
1638      }  
1639    
1640      memset( &ctx->pass_cb, 0, sizeof (ctx->pass_cb) );  /* Export the selected keys from the File Manager to a file. */
1641      safe_free( fn );  int
1642      fm_state_release( ctx );  fm_export (fm_state_t c)
1643      return count;  {
1644  } /* fm_parse_command_line */      int rc = 0;
1645        gpgme_ctx_t ctx = c->ctx;
1646        gpgme_error_t err;
1647  const char *      gpgme_key_t *rset = c->recp;
1648  default_dirname( const char * name )      file_data_t keydata = NULL;
1649  {      const char *name;
1650      char * p = strrchr( name, '\\' );      char *p = NULL, *patt = NULL;
1651      if( !p )  
1652          return NULL;      if (!rset || !rset[0]) {
1653      return p+1;          msg_box (c->dlg, _("No key was selected for export."), _("Export"), MB_ERR);
1654  } /* default_dirname */          rc = WPTERR_GENERAL;
1655            goto leave;
1656        }
1657  int  
1658  fm_encrypt_directory( fm_state_t c, const char * name )      if (rset[1] == NULL) { /* count == 1*/
1659  {          gpgme_key_t k = rset[0];
1660      PK_FILE_LIST list = NULL;          const char *s = k->uids->name;
1661      WIN32_FIND_DATA findbuf;          p = new char[strlen (s)+1+8];
1662      HANDLE hd;          if (!p)
1663      const char * s;              BUG (NULL);
1664      char * patt = NULL, * p;          strcpy (p, s );
1665      int rc = 0;          strcat (p, ".asc");
1666            }
1667      if( !is_directory( name ) )      
1668          return -1;      name = get_filename_dlg (c->dlg, FILE_SAVE, _("Choose Name for Key File"),
1669      patt = new char[strlen( name ) + 4];                               NULL, p? p : NULL);
1670      if( !patt )                              
1671          BUG( NULL );      if (!name)
1672      strcpy( patt, name );          name = "keys.gpg";
1673      strcat( patt, "\\*" );  
1674      hd = FindFirstFile( patt, &findbuf );          patt = gpg_keylist_to_pattern (rset, c->n_recp);
1675      if( !hd ) {  
1676          free_if_alloc( patt );        err = gpg_file_data_new (name, 0, &keydata);
1677          return -1;            if (err)
1678      }          goto leave;
1679      if( strcmp( findbuf.cFileName, "." ) && strcmp( findbuf.cFileName, ".." ) ) {  
1680          p = make_filename( name, findbuf.cFileName, NULL );      op_begin ();
1681          pk_list_add( &list, p );      err = gpgme_op_export (ctx, patt, 0, keydata->dat);
1682          free_if_alloc( p );      op_end ();
1683      }      if (err) {
1684      while( FindNextFile( hd, &findbuf ) ) {          msg_box (c->dlg, gpgme_strerror (err), _("Export"), MB_ERR);
1685          if( strcmp( findbuf.cFileName, "." ) && strcmp( findbuf.cFileName, ".." ) ) {          rc = WPTERR_GENERAL;
1686              p = make_filename( name, findbuf.cFileName, NULL );          goto leave;    
1687              pk_list_add( &list, p );      }
1688              free_if_alloc( p );      log_box (_("GnuPG status"), MB_OK, _("Finished (Output: %s)"),  name);
1689          }  
1690      }  leave:
1691      s = get_filename_dlg( c->dlg, FILE_SAVE, _("Choose a Name for the Archive"),      if (keydata)
1692                            NULL, default_dirname( name ) );          gpg_file_data_release (keydata);
1693      if( !s ) {      if (patt)
1694          msg_box( c->dlg, _("Invalid archive name. Exit."), _("Encrypt Directory"), MB_ERR );          free (patt);
1695          rc = -1;      free_if_alloc (p);
1696          goto leave;          
1697      }      return rc;
1698    }
1699      rc = pk_archiv_create( list, s );  
1700      if( rc )  
1701          msg_box( c->dlg, _("Could not create zip archive."), _("Encrypt Directory"), MB_ERR );  /* Parse the command line and process the given file. */  
1702      else {  int
1703          fm_encrypt( c, s, 0 );  fm_parse_command_line (char *cmdl)
1704          unlink( s );  {
1705      }      fm_state_t ctx;
1706  leave:      const char *s;
1707      pk_list_free( list );      char *p, *fn = NULL;
1708      free_if_alloc( patt );      int count = 0, detached = 0;
1709      return rc;      int type;
1710  } /* fm_encrypt_directory */      
1711        if (!cmdl || !*cmdl)
1712            return 0;
1713  static int CALLBACK  
1714  fm_cmp_cb( LPARAM first, LPARAM second, LPARAM sortby )      fm_state_new (&ctx);    
1715  {      ctx->dlg = GetActiveWindow ();
1716      const char * a = 0, * b = 0;      ctx->cache_cb = 1;
1717        
1718      switch( (int)sortby ) {      p = cmdl;
1719      case FM_SORT_STAT:      if (p && *p > 32 && !stristr (p, "winpt.exe")
1720          break;                       && !strstr (p, "--" )) {
1721      case FM_SORT_NAME:          count++;
1722          break;          if (*p == '"') { /* need to remove quotes */
1723      case FM_SORT_OP:              fn = new char[strlen (p)];
1724          break;              if (!fn)
1725      }                  BUG (NULL);
1726      return stricmp( a, b );              memcpy (fn, p+1, strlen (p) - 2);
1727  } /* fm_cmp_cb */              fn[strlen (p) -2] = '\0';
1728                    }
1729            else
1730  int              fn = m_strdup (p);
1731  fm_sort( listview_ctrl_t lv, int sortby )          s = fm_get_file_type (fn, &type);
1732  {          if (!s || !strcmp (s, "UNKNOWN"))
1733      return listview_sort_items( lv, sortby, fm_cmp_cb );              s = gnupg_check_file_ext (fn, &type);
1734  } /* fm_sort */          if (type == PGP_NONE) {
1735                log_box (_("File Manager"), MB_ERR,
1736                         _("%s: no valid OpenPGP data found."), p);
1737  void              free_if_alloc (fn);
1738  fm_print_md( listview_ctrl_t lv, HWND dlg, int mdalgo )              return count;
1739  {          }
1740      struct md_file_s mdctx;          switch (type) {
1741            case PGP_MESSAGE:
1742      if( listview_count_items( lv, 0 ) == 0 )              fm_decrypt (ctx, fn);
1743          return;              break;
1744      memset( &mdctx, 0, sizeof (mdctx) );  
1745      mdctx.lv = lv;          case PGP_PUBKEY:
1746      mdctx.mdalgo = mdalgo;          case PGP_SECKEY:
1747      DialogBoxParam( glob_hinst, (LPCTSTR)IDD_WINPT_FILE_MDSUM, dlg,              fm_import (ctx, fn);
1748                      mdsum_dlg_proc, (LPARAM)&mdctx );              break;
1749  } /* fm_print_md */  
1750            case PGP_SIG:
1751            case PGP_CLEARSIG:
1752  int              file_verify_use_event ();
1753  fm_send_file (listview_ctrl_t lv)              if (type == PGP_SIG)    
1754  {                  detached = 1;
1755      char buf[128];              fm_verify (ctx, detached, fn);
1756      int rc;              file_verify_wait ();
1757                break;
1758      rc = listview_get_item_text (lv, -1, 1, buf, sizeof (buf)-1);          }
1759      if (rc == -1)      }
1760          return 0;  
1761      /*mapi_send_ascfile (buf); XXX */      wipememory (&ctx->pass_cb, sizeof (ctx->pass_cb));
1762      return 0;      free_if_alloc (fn);
1763  }      fm_state_release (ctx);
1764        return count;
1765    }
1766    
1767    
1768    const char*
1769    default_dirname (const char *name)
1770    {
1771        char * p = strrchr( name, '\\' );
1772        if( !p )
1773            return NULL;
1774        return p+1;
1775    } /* default_dirname */
1776    
1777    
1778    int
1779    fm_encrypt_directory( fm_state_t c, const char * name )
1780    {
1781        PK_FILE_LIST list = NULL;
1782        WIN32_FIND_DATA findbuf;
1783        HANDLE hd;
1784        const char * s;
1785        char * patt = NULL, * p;
1786        int rc = 0;
1787        
1788        if( !is_directory( name ) )    
1789            return -1;
1790        patt = new char[strlen( name ) + 4];
1791        if( !patt )
1792            BUG( NULL );
1793        strcpy( patt, name );
1794        strcat( patt, "\\*" );
1795        hd = FindFirstFile( patt, &findbuf );    
1796        if( !hd ) {
1797            free_if_alloc( patt );  
1798            return -1;      
1799        }
1800        if( strcmp( findbuf.cFileName, "." ) && strcmp( findbuf.cFileName, ".." ) ) {
1801            p = make_filename( name, findbuf.cFileName, NULL );
1802            pk_list_add( &list, p );
1803            free_if_alloc( p );
1804        }
1805        while( FindNextFile( hd, &findbuf ) ) {
1806            if( strcmp( findbuf.cFileName, "." ) && strcmp( findbuf.cFileName, ".." ) ) {
1807                p = make_filename( name, findbuf.cFileName, NULL );
1808                pk_list_add( &list, p );
1809                free_if_alloc( p );
1810            }
1811        }
1812        s = get_filename_dlg( c->dlg, FILE_SAVE, _("Choose a Name for the Archive"),
1813                              NULL, default_dirname( name ) );
1814        if( !s ) {
1815            msg_box( c->dlg, _("Invalid archive name. Exit."), _("Encrypt Directory"), MB_ERR );
1816            rc = -1;
1817            goto leave;
1818        }
1819    
1820        rc = pk_archiv_create( list, s );
1821        if( rc )
1822            msg_box( c->dlg, _("Could not create zip archive."), _("Encrypt Directory"), MB_ERR );
1823        else {
1824            fm_encrypt( c, s, 0 );
1825            unlink( s );
1826        }
1827    leave:
1828        FindClose (hd);
1829        pk_list_free( list );
1830        free_if_alloc( patt );
1831        return rc;
1832    } /* fm_encrypt_directory */
1833    
1834    
1835    static int CALLBACK
1836    fm_cmp_cb( LPARAM first, LPARAM second, LPARAM sortby )
1837    {
1838        const char * a = 0, * b = 0;
1839    
1840        switch( (int)sortby ) {
1841        case FM_SORT_STAT:
1842            break;
1843        case FM_SORT_NAME:
1844            break;
1845        case FM_SORT_OP:
1846            break;
1847        }
1848        return stricmp( a, b );
1849    } /* fm_cmp_cb */
1850            
1851    
1852    int
1853    fm_sort( listview_ctrl_t lv, int sortby )
1854    {
1855        return listview_sort_items( lv, sortby, fm_cmp_cb );
1856    } /* fm_sort */
1857    
1858    
1859    void
1860    fm_print_md( listview_ctrl_t lv, HWND dlg, int mdalgo )
1861    {
1862        struct md_file_s mdctx;
1863    
1864        if( listview_count_items( lv, 0 ) == 0 )
1865            return;
1866        memset (&mdctx, 0, sizeof (mdctx));
1867        mdctx.lv = lv;
1868        mdctx.mdalgo = mdalgo;
1869        DialogBoxParam( glob_hinst, (LPCTSTR)IDD_WINPT_FILE_MDSUM, dlg,
1870                        mdsum_dlg_proc, (LPARAM)&mdctx );
1871    } /* fm_print_md */
1872    
1873    
1874    int
1875    fm_send_file (listview_ctrl_t lv)
1876    {
1877        char buf[128];
1878        int rc;
1879    
1880        rc = listview_get_item_text (lv, -1, 1, buf, sizeof (buf)-1);
1881        if (rc == -1)
1882            return 0;
1883        /*mapi_send_ascfile (buf); XXX */
1884        return 0;
1885    }
Legend:
Removed from v.28  
changed lines
  Added in v.69
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26