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