/[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 42 by werner, Fri Oct 28 08:25:30 2005 UTC revision 256 by twoaday, Sat Aug 5 10:31:06 2006 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-2006 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.
# Line 18  Line 18 
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   */   */
 /* TODO:  
  *    check_armor_type: we should check the whole file and not only the first line!  
  */  
21    
22  #ifdef HAVE_CONFIG_H  #ifdef HAVE_CONFIG_H
23  #include <config.h>  #include <config.h>
24  #endif  #endif
25    
26  #include <sys/types.h>  #include <sys/types.h>
 #include <sys/types.h>  
27  #include <windows.h>  #include <windows.h>
28  #include <commdlg.h>  #include <commdlg.h>
29  #include <io.h>  #include <io.h>
30  #include <stdio.h>  #include <stdio.h>
31    
32  #include "../resource.h"  #include "resource.h"
33  #include "wptTypes.h"  #include "wptTypes.h"
34  #include "wptGPG.h"  #include "wptGPG.h"
35  #include "wptAgent.h"  #include "wptAgent.h"
# Line 50  Line 46 
46  #include "wptUTF8.h"  #include "wptUTF8.h"
47  #include "wptRegistry.h"  #include "wptRegistry.h"
48  #include "wptImport.h"  #include "wptImport.h"
49    #include "wptCrypto.h"
50    #include "wptKeyManager.h"
51  #include "openpgp.h"  #include "openpgp.h"
52    
 #define op_begin()  SetCursor (LoadCursor (NULL, IDC_WAIT))  
 #define op_end()    SetCursor (LoadCursor (NULL, IDC_ARROW))  
53    
54  void progress_cleanup (progress_filter_s *pfx);  void progress_cleanup (progress_filter_s *pfx);
55  BOOL CALLBACK file_secdel_confirm_dlg_proc (HWND dlg, UINT msg,  BOOL CALLBACK file_secdel_confirm_dlg_proc (HWND dlg, UINT msg,
# Line 62  BOOL CALLBACK file_secdel_confirm_dlg_pr Line 57  BOOL CALLBACK file_secdel_confirm_dlg_pr
57  char* gpg_keylist_to_pattern (gpgme_key_t *rset, int n);  char* gpg_keylist_to_pattern (gpgme_key_t *rset, int n);
58  gpgme_error_t sym_passphrase_cb (void *hook, const char *hint, const char *pass_inf,  gpgme_error_t sym_passphrase_cb (void *hook, const char *hint, const char *pass_inf,
59                                   int prev_was_bad, int fd);                                   int prev_was_bad, int fd);
60    void verify_show_signature_state (gpgme_signature_t sig);
61    
 /*-- wptFileVerifyDlg.cpp --*/  
 void file_verify_add_state (file_sig_ctx_t c);  
 void file_verify_use_event (void);  
 void file_verify_wait (void);  
62    
63  static const char * mm_files[] = {".mov", ".avi", ".mpg", ".mpeg",  static const char *mm_files[] = {".mov", ".avi", ".mpg", ".mpeg",
64                                    ".mp3", ".wav", ".mid", ".wma",                                    ".mp3", ".wav", ".mid", ".wma",
65                                    ".gif", ".jpg", ".png", ".jpeg", ".dib", 0};                                    ".gif", ".jpg", ".png", ".jpeg", ".dib", 0};
66    
67    
68    /* Add a new file to the model @fm. */
69    static void
70    fm_model_add_file (fm_model_t *fm, fm_model_t file)
71    {
72        fm_model_t m;
73    
74        if (!*fm) {
75            *fm = file;
76            return;
77        }
78        for (m = *fm; m->next; m = m->next)
79            ;
80        m->next = file;
81    }
82    
83    
84    /* Search for a file model based on the name @name. */
85    static fm_model_t
86    fm_model_find_file (fm_model_t fm, const char *name)
87    {
88        fm_model_t m;
89    
90        for (m=fm; m; m=m->next) {
91            if (!stricmp (m->name, name))
92                return m;
93        }
94        return NULL;
95    }
96    
97    
98  /* Check if the drive given by @fname is a floppy disc.  /* Check if the drive given by @fname is a floppy disc.
99     Return value: -1 for success. */     Return value: -1 for success. */
100  static int  static int
# Line 114  overwrite_file (const char *fname) Line 136  overwrite_file (const char *fname)
136    
137  /* Removes 'critical' attributes from the file @fname.  /* Removes 'critical' attributes from the file @fname.
138     If @force is 1, the user is not asked for permission. */     If @force is 1, the user is not asked for permission. */
139  static void  void
140  remove_crit_file_attrs (const char *fname, int force)  remove_crit_file_attrs (const char *fname, int force)
141  {  {
142      u32 fattr;      DWORD fattr;
143      int id = 0;      int id = 0;
144    
145      if (file_exist_check (fname))      if (file_exist_check (fname))
# Line 146  is_directory (const char *fname) Line 168  is_directory (const char *fname)
168  }  }
169    
170    
171  /* Return -1 if the given name @name is a valid PGP extension. */  /* Return -1 if the given name @name is a valid GPG extension. */
172  static int  int
173  is_openpgp_ext (const char *name)  is_openpgp_ext (const char *name)
174  {  {
175      if (stristr (name, ".gpg") || stristr (name, ".asc")      if (stristr (name, ".gpg") ||
176          || stristr (name, ".sig") || stristr (name, ".pgp"))          stristr (name, ".asc") ||
177            stristr (name, ".sig") ||
178            stristr (name, ".pgp"))
179          return -1;          return -1;
180      return 0;      return 0;
181  }  }
# Line 169  is_multi_media (const char * name) Line 193  is_multi_media (const char * name)
193      if (i == -1)      if (i == -1)
194      {      {
195          ans = msg_box (NULL, _("Multi-Media files are already compressed, GPG would compress\n"          ans = msg_box (NULL, _("Multi-Media files are already compressed, GPG would compress\n"
196                                 "them anyway and this costs a lot of time.\n"                                 "them anyway and this takes a lot of time.\n"
197                                 "It is possible to disable compression for these files.\n"                                 "It is possible to disable compression for these files.\n"
198                                 "Do you want to disable it?"),                                 "Do you want to disable it?"),
199                                 _("File Manager"), MB_YESNO|MB_INFO);                                 _("File Manager"), MB_YESNO|MB_INFO);
# Line 202  file_get_extension (gpgme_ctx_t ctx, gpg Line 226  file_get_extension (gpgme_ctx_t ctx, gpg
226          return ".asc";          return ".asc";
227      if (!use_armor && sigmode == GPGME_SIG_MODE_DETACH)      if (!use_armor && sigmode == GPGME_SIG_MODE_DETACH)
228          return ".sig";          return ".sig";
229      return ".gpg";      return reg_prefs.default_ext == 1? ".pgp" : ".gpg";
230  }  }
231    
232    
# Line 227  fm_quote_file (const char * name) Line 251  fm_quote_file (const char * name)
251    
252  /* Check the armor type of the file @fname and return  /* Check the armor type of the file @fname and return
253     a string representation of it. */     a string representation of it. */
254  static const char *  static const char*
255  fm_check_armor_type (const char *fname, int *r_type)  fm_check_armor_type (const char *fname, int *r_type)
256  {  {
257      FILE * fp;      FILE *fp;
258      char header[768], * p;      char header[768], *p;
259            
260      if (r_type)      if (r_type)
261          *r_type = PGP_NONE;          *r_type = PGP_NONE;
# Line 274  leave: Line 298  leave:
298    
299  /* Extract file type from @fname. If @r_type is valid,  /* Extract file type from @fname. If @r_type is valid,
300     it contains the PGP type on success. */     it contains the PGP type on success. */
301  static const char *  static const char*
302  fm_get_file_type (const char *fname, int *r_type)  fm_get_file_type (const char *fname, int *r_type)
303  {          {        
304      gpg_iobuf_t inp;      gpg_iobuf_t inp;
305      armor_filter_context_t afx;      armor_filter_context_t afx;
306      PACKET *pkt;      PACKET *pkt;
307      const char *s = NULL;      const char *s = NULL;
308      int i = 0, rc = 0;      size_t count = 0, compr = 0;
309        int rc = 0;
310    
311      if (r_type)      if (r_type)
312          *r_type = PGP_NONE;          *r_type = PGP_NONE;
# Line 295  fm_get_file_type (const char *fname, int Line 320  fm_get_file_type (const char *fname, int
320    
321      inp = gpg_iobuf_open (fname);      inp = gpg_iobuf_open (fname);
322      if (!inp) {      if (!inp) {
323          const char *s = winpt_strerror (WPTERR_FILE_OPEN);          const char *err = winpt_strerror (WPTERR_FILE_OPEN);
324          log_box (_("File Manager"), MB_ERR, "\"%s\": %s", fname, s);          log_box (_("File Manager"), MB_ERR, "\"%s\": %s", fname, err);
325          return NULL;          return NULL;
326      }      }
327      gpg_iobuf_ioctl (inp, 3, 1, NULL); /* disable cache */      gpg_iobuf_ioctl (inp, 3, 1, NULL); /* disable cache */
# Line 338  fm_get_file_type (const char *fname, int Line 363  fm_get_file_type (const char *fname, int
363              s = "SECKEY";   rc = -2;              s = "SECKEY";   rc = -2;
364              if (r_type) *r_type = PGP_SECKEY;              if (r_type) *r_type = PGP_SECKEY;
365              break;              break;
366    
367            case PKT_COMPRESSED:
368                /* If we only find 1 packet and it is compressed,
369                   we assume a compress one-pass signature. */
370                if (count != 0)
371                    break;
372                s = "SIGNED";   rc = -2;
373                compr = 1;
374                break;
375    
376            default:
377                break;
378          }          }
379            count++;
380          gpg_free_packet (pkt);          gpg_free_packet (pkt);
381          gpg_init_packet (pkt);          gpg_init_packet (pkt);
382          if (rc == -2)          if (rc == -2)
# Line 350  fm_get_file_type (const char *fname, int Line 388  fm_get_file_type (const char *fname, int
388          s = fm_check_armor_type (fname, r_type);          s = fm_check_armor_type (fname, r_type);
389      if (!s)      if (!s)
390          s = "UNKNOWN";          s = "UNKNOWN";
391      if (!strcmp (s, "SIGNED")      if (!strcmp (s, "SIGNED") && !compr
392          && strcmp (fm_check_armor_type (fname, r_type), "SIGNED-CLEAR ")) {          && strcmp (fm_check_armor_type (fname, r_type), "SIGNED-CLEAR ")) {
393          if (r_type) *r_type = PGP_SIG;          if (r_type) *r_type = PGP_SIG;
394          s = "SIGNED-DETACH";          s = "SIGNED-DETACH";
# Line 359  fm_get_file_type (const char *fname, int Line 397  fm_get_file_type (const char *fname, int
397  }  }
398    
399    
400  int  /* Build the File Manager dialog context. */
401  fm_build (listview_ctrl_t *lv, HWND ctrl)  void
402    fm_build (fm_info_t *r_fm, HWND ctrl)
403  {  {
404      int i, rc = 0;      int i;
405      listview_ctrl_t c;      fm_info_t fm;
406      struct listview_column_s col[] =      struct listview_column_s col[] = {
     {  
407          {0,  80, (char *)_("Status") },          {0,  80, (char *)_("Status") },
408          {1, 256, (char *)_("Name") },          {1, 256, (char *)_("Name") },
409          {2, 128, (char *)_("Operation") },          {2, 128, (char *)_("Operation") },
410          {0,   0, NULL }          {0,   0, NULL}  
411      };      };
           
     rc = listview_new( &c );  
     if( rc )  
         BUG( NULL );  
     c->ctrl = ctrl;  
     for ( i = 0; col[i].width; i++ )  
         listview_add_column( c, &col[i] );  
     listview_set_ext_style( c );  
     if( lv )  
         *lv = c;  
     return 0;  
 } /* fm_build */  
412    
413        fm = new fm_info_s;
414        memset (fm, 0, sizeof *fm);
415        listview_new (&fm->lv, ctrl);
416        for (i = 0; col[i].width; i++)
417            listview_add_column (fm->lv, &col[i]);
418        listview_set_ext_style (fm->lv);
419        fm->model = NULL; /*init*/
420        *r_fm = fm;
421    }
422    
423  void  
424  fm_delete( listview_ctrl_t lv )  /* Release the file model. */
425    static void
426    fm_model_release (fm_model_t mod)
427  {  {
428      if( lv ) {      fm_model_t m;
429          listview_release( lv );  
430        while (mod) {
431            m = mod->next;
432            free_if_alloc (mod->name);
433            free_if_alloc (mod->op);
434            free_if_alloc (mod->status);
435            free_if_alloc (mod);
436            mod = m;
437      }      }
438  } /* fm_delete */  }
439    
440    
441    /* Reset the File Manager info context. */
442    void
443    fm_reset (fm_info_t fm)
444    {
445        listview_del_all_items (fm->lv);
446        fm_model_release (fm->model);
447        fm->model = NULL;
448    }
449    
450    
451    /* Release the File Manager dialog context. */
452    void
453    fm_delete (fm_info_t fm)
454    {
455        if (!fm)
456            return;
457        if (fm->menu)
458            DestroyMenu (fm->menu);
459        listview_release (fm->lv);
460        fm_model_release (fm->model);
461        free_if_alloc (fm);  
462    }
463    
464    
465  int  int
466  fm_state_new (fm_state_t * ctx)  fm_state_new (fm_state_t * ctx)
467  {  {
468      gpgme_error_t rc;      fm_state_s *c;
     fm_state_s * c;  
469    
470      c = new fm_state_s;      c = new fm_state_s;
471      if (!c)      if (!c)
472          BUG (0);          BUG (0);
473      memset (c, 0, sizeof *c);      memset (c, 0, sizeof *c);
474      rc = gpgme_new (&c->ctx);      if (gpgme_new (&c->ctx))
     if (rc)  
475          BUG (0);          BUG (0);
     /* XXX rc = gpgme_recipients_new (&c->recp);*/  
     /* XXX gpgme_set_comment (c->ctx, "Generated by WinPT "PGM_VERSION); */  
476      *ctx = c;      *ctx = c;
477      return 0;      return 0;
478  } /* fm_state_new */  }
479    
480    
481  /* Release the FM state handle @c. */  /* Release the FM state handle @c. */
# Line 420  fm_state_release (fm_state_t c) Line 484  fm_state_release (fm_state_t c)
484  {  {
485      if (!c)      if (!c)
486          return;          return;
     if (c->recp)  
         free (c->recp);  
487      if (c->ctx) {      if (c->ctx) {
488          gpgme_release (c->ctx);          gpgme_release (c->ctx);
489          c->ctx = NULL;            c->ctx = NULL;  
490      }      }
491        safe_free (c->recp);
492      free_if_alloc (c->opaque);      free_if_alloc (c->opaque);
493      free_if_alloc (c->output);      free_if_alloc (c->output);
494      delete c; c = NULL;          delete c;
495  }  }
496    
497    
498    /* Check if file @file is already in the list (view). */
499  static int  static int
500  fm_check_for_entry( listview_ctrl_t lv, const char *file )  fm_check_for_entry (listview_ctrl_t lv, const char *file)
501  {  {
502      char name[512];      char name[MAX_PATH+128];
503      int i;      int i;
504    
505      memset (name, 0, sizeof (name));      memset (name, 0, sizeof (name));
506      for (i = 0; i < listview_count_items( lv, 0 ); i++) {      for (i = 0; i < listview_count_items (lv, 0); i++) {
507          listview_get_item_text( lv, i, 1, name, sizeof (name) - 1 );          listview_get_item_text (lv, i, FM_COL_NAME, name, sizeof (name) - 1);
508          if( !strcmp( name, file ) )          if (!strcmp (name, file))
509              return 1; /* found */                    return 1; /* found */      
510      }      }
511    
512      return 0;      return 0;
513  } /* fm_check_for_entry */  }
514    
515    
516  static int  static int
517  fm_set_ftype (listview_ctrl_t lv, const char *name)  fm_set_ftype (listview_ctrl_t lv, fm_model_t *fm, const char *name)
518  {  {
519        fm_model_t m;
520      const char *type;      const char *type;
521      int rc;      int rc;
522    
523      rc = fm_check_for_entry (lv, name);      rc = fm_check_for_entry (lv, name);
524      if (rc)      if (rc)
525          return 0;          return 0;
526        m = new fm_model_s;
527        memset (m, 0, sizeof *m);
528      type = fm_get_file_type (name, NULL);      type = fm_get_file_type (name, NULL);
529      if (!type || !strcmp (type, "UNKNOWN"))      if (!type || !strcmp (type, "UNKNOWN"))
530          type = gnupg_check_file_ext (name, NULL);          type = gnupg_check_file_ext (name, NULL);
531      rc = listview_add_item (lv, " ");      listview_add_item2 (lv, " ", (void*)m);
532      if (rc)      listview_add_sub_item (lv, 0, FM_COL_STAT, type);
533          return -1;      listview_add_sub_item (lv, 0, FM_COL_NAME, name);
534      listview_add_sub_item (lv, 0, 0, type);      m->name = m_strdup (name);
535      listview_add_sub_item (lv, 0, 1, name);      m->status = m_strdup (type);
536        m->op = NULL;
537        fm_model_add_file (fm, m);
538      return 0;      return 0;
539  }  }
540    
541    
542    /* Add all files from the directory @path to the list view @lv. */
543  static int  static int
544  fm_add_dir_files (listview_ctrl_t lv, char *path)  fm_add_dir_files (listview_ctrl_t lv, fm_model_t *fm, char *path)
545  {  {
546      struct _finddata_t fd;      struct _finddata_t fd;
547      char * p;      char *p;
548      long hd;      long hd;
549    
550      strcat (path, "\\*");      strcat (path, "\\*");
551      hd = _findfirst (path, &fd);      hd = _findfirst (path, &fd);
552      do {      do {
553          p = new char [(strlen (path) + strlen (fd.name))+1];          p = new char [strlen (path) + strlen (fd.name)+1];
554          if (!p)          if (!p)
555              BUG (0);              BUG (0);
556          memcpy (p, path, strlen (path)-1);          memcpy (p, path, strlen (path)-1);
557          p[strlen (path)-1] = 0;          p[strlen (path)-1] = 0;
558          strcat (p, fd.name);          strcat (p, fd.name);
559          if (!is_directory (p))          if (!is_directory (p))
560              fm_set_ftype (lv, p);              fm_set_ftype (lv, fm, p);
561          free_if_alloc (p);          free_if_alloc (p);
562      } while (_findnext (hd, &fd) == 0);      } while (_findnext (hd, &fd) == 0);
563      _findclose (hd);      _findclose (hd);
# Line 497  fm_add_dir_files (listview_ctrl_t lv, ch Line 568  fm_add_dir_files (listview_ctrl_t lv, ch
568  /* Add the drag & drop files from @dd_files to the  /* Add the drag & drop files from @dd_files to the
569     list view control @lv. */     list view control @lv. */
570  int  int
571  fm_add_dropped_files (listview_ctrl_t lv, HDROP dd_files)  fm_add_dropped_files (fm_info_t fm, HDROP dd_files)
572  {  {
573      char name[384+4];      char name[384+4];
574      int nfiles, rc, i;      int nfiles;
575        int rc = 0;
576        int i;
577            
578      memset (name, 0, sizeof (name));      memset (name, 0, sizeof (name));
579      nfiles = DragQueryFile (dd_files, 0xFFFFFFFF, NULL, 0);      nfiles = DragQueryFile (dd_files, 0xFFFFFFFF, NULL, 0);
580      for (i = 0;  i < nfiles; i++) {      for (i = 0;  i < nfiles; i++) {
581          DragQueryFile (dd_files, i, name, sizeof (name) -1);          DragQueryFile (dd_files, i, name, sizeof (name) -1);
582          if (is_directory (name))          if (is_directory (name))
583              rc = fm_add_dir_files (lv, name);              rc = fm_add_dir_files (fm->lv, &fm->model, name);
584          else          else
585              rc = fm_set_ftype (lv, name);              rc = fm_set_ftype (fm->lv, &fm->model, name);
586          if (rc == -1)          if (rc == -1)
587              break; /* XXX: fixme? */              break; /* XXX: fixme? */
588      }      }
589        DragFinish (dd_files);
590      return rc;      return rc;
591  }  }
592    
# Line 521  fm_add_dropped_files (listview_ctrl_t lv Line 595  fm_add_dropped_files (listview_ctrl_t lv
595     figure out the type of it.     figure out the type of it.
596     Return value: 0 on success. */     Return value: 0 on success. */
597  static int  static int
598  add_single_file (listview_ctrl_t lv, const char *name)  add_single_file (listview_ctrl_t lv, fm_model_t *fm, const char *name)
599  {  {
600        fm_model_t m;
601      const char *type;      const char *type;
602      int rc = 0;      int rc = 0;
603        
604      type = fm_get_file_type (name, NULL);      type = fm_get_file_type (name, NULL);
605      if (!type)      if (!type)
606          return WPTERR_FILE_OPEN;          return WPTERR_FILE_OPEN;
607        m = new fm_model_s;
608        memset (m, 0, sizeof *m);
609      if (!strcmp (type, "UNKNOWN"))            if (!strcmp (type, "UNKNOWN"))      
610          type = gnupg_check_file_ext (name, NULL);                    type = gnupg_check_file_ext (name, NULL);
611      rc = listview_add_item (lv, "");              rc = listview_add_item2 (lv, "", (void*)m);
612      if (!rc) {        if (!rc) {
613          listview_add_sub_item (lv, 0, 0, type);          listview_add_sub_item (lv, 0, FM_COL_STAT, type);
614          listview_add_sub_item (lv, 0, 1, name);          listview_add_sub_item (lv, 0, FM_COL_NAME, name);
615      }      }
616        m->status = m_strdup (type);
617        m->name = m_strdup (name);
618        m->op = NULL;
619        fm_model_add_file (fm, m);
620      return rc;      return rc;
621  }  }
622    
# Line 543  add_single_file (listview_ctrl_t lv, con Line 624  add_single_file (listview_ctrl_t lv, con
624  /* Use the common Open-File-Dialog to allow the user to  /* Use the common Open-File-Dialog to allow the user to
625     add one ore more selected files to the listview @lv. */     add one ore more selected files to the listview @lv. */
626  int  int
627  fm_add_opened_files (listview_ctrl_t lv, HWND dlg)  fm_add_opened_files (fm_info_t fm, HWND dlg)
628  {  {
629      OPENFILENAME open;      OPENFILENAME open;
630      char file[512], name[MAX_PATH+1];      char file[512], name[MAX_PATH+1];
# Line 556  fm_add_opened_files (listview_ctrl_t lv, Line 637  fm_add_opened_files (listview_ctrl_t lv,
637      open.lStructSize = sizeof (OPENFILENAME);      open.lStructSize = sizeof (OPENFILENAME);
638      open.hInstance = glob_hinst;      open.hInstance = glob_hinst;
639      open.lpstrTitle = _("File Open");      open.lpstrTitle = _("File Open");
640      open.lpstrFilter = _("All Files (*.*)\0*.*\0\0");      open.lpstrFilter = "All Files (*.*)\0*.*\0\0";
641      open.hwndOwner = dlg;      open.hwndOwner = dlg;
642      open.lpstrFile = file;      open.lpstrFile = file;
643      open.nMaxFile = sizeof (file) - 1;      open.nMaxFile = sizeof (file) - 1;
# Line 566  fm_add_opened_files (listview_ctrl_t lv, Line 647  fm_add_opened_files (listview_ctrl_t lv,
647      if (!GetOpenFileName (&open))      if (!GetOpenFileName (&open))
648          return 0;          return 0;
649    
650        /* It is possible that multiple files are returned
651           and then they are separated by \0 chars. */
652      s = file;      s = file;
653      len = sizeof (file)-1;      len = sizeof (file)-1;
654      for (;;) {      for (;;) {
# Line 580  fm_add_opened_files (listview_ctrl_t lv, Line 663  fm_add_opened_files (listview_ctrl_t lv,
663              name[i] = *s++;              name[i] = *s++;
664          }          }
665          if (n == 0)          if (n == 0)
666              path = strdup (name);              path = m_strdup (name);
667          else {          else {
668              char *p = make_filename (path, name, NULL);              char *p = make_filename (path, name, NULL);
669              rc = add_single_file (lv, p);              rc = add_single_file (fm->lv, &fm->model, p);
670              free (p);              free_if_alloc (p);
671          }          }
672          n++;          n++;
673      }      }
674      if (n == 1) /* single file selected. */      if (n == 1) /* single file selected. */
675          rc = add_single_file (lv, path);          rc = add_single_file (fm->lv, &fm->model, path);
676      if (path)      free_if_alloc (path);
         free (path);  
677      return rc;      return rc;
678  }  }
679    
680    
681  int  int
682  fm_assume_onepass_sig (const char * fname)  fm_assume_onepass_sig (const char *fname)
683  {  {    
     gpgme_data_t dat;  
684      armor_filter_context_t afx;      armor_filter_context_t afx;
685      gpg_iobuf_t fp;      gpg_iobuf_t fp;
686      PACKET * pkt = (PACKET *)calloc (1, sizeof *pkt);      gpgme_data_t dat;
687        PACKET *pkt;
688        char tmpfile[MAX_PATH+1];
689      int check = 0;      int check = 0;
690    
691        pkt = (PACKET *)calloc (1, sizeof *pkt);
692      if (!fname) {      if (!fname) {
693            get_temp_name (tmpfile, sizeof (tmpfile)-1, "gpgme.tmp");
694          gpg_data_new_from_clipboard (&dat, 0);          gpg_data_new_from_clipboard (&dat, 0);
695          gpg_data_release_and_set_file (dat, "gpgme.tmp");          gpg_data_release_and_set_file (dat, tmpfile);
696    
697          fp = gpg_iobuf_open ("gpgme.tmp");          fp = gpg_iobuf_open (tmpfile);
698          if (!fp)          if (!fp)
699              return 0;              return 0;
700          gpg_iobuf_ioctl (fp, 3, 1, NULL);          gpg_iobuf_ioctl (fp, 3, 1, NULL);
# Line 622  fm_assume_onepass_sig (const char * fnam Line 707  fm_assume_onepass_sig (const char * fnam
707              && pkt->pkttype == PKT_COMPRESSED)              && pkt->pkttype == PKT_COMPRESSED)
708              check = 1;                check = 1;  
709          gpg_free_packet (pkt);          gpg_free_packet (pkt);
         safe_free (pkt);  
710          gpg_iobuf_close (fp);          gpg_iobuf_close (fp);
711          unlink ("gpgme.tmp");          DeleteFile (tmpfile);
712      }      }
713      /* XXX: implement it for real files */      /* XXX: implement it for real files */
714        safe_free (pkt);
715      return check;      return check;
716  }  }
717    
# Line 639  fm_get_current_pos (listview_ctrl_t lv) Line 724  fm_get_current_pos (listview_ctrl_t lv)
724      items = listview_count_items (lv, 0);      items = listview_count_items (lv, 0);
725      if (!items)      if (!items)
726          return -1;          return -1;
727      else if (items == 1)      else if (items == 1) {
     {  
728          listview_select_one (lv, 0);          listview_select_one (lv, 0);
729          return 0;          return 0;
730      }      }
731      else if (items > 1)      else if (items > 1) {
     {  
732          i = listview_get_curr_pos (lv);          i = listview_get_curr_pos (lv);
733          if (i == -1)          if (i == -1) {
734          {              msg_box (lv->ctrl, _("Please select a file."),
735              msg_box (lv->ctrl, _("Please select a file."), _("File Manager"), MB_ERR);                       _("File Manager"), MB_ERR);
736              return -1;              return -1;
737          }          }
738          return i;          return i;
739      }      }
740    
741      return -1;      return -1;
742  } /* fm_get_current_pos */  }
743    
744    
745  static int  static int
746  fm_check_detached_sig( listview_ctrl_t lv, int pos )  fm_check_detached_sig (listview_ctrl_t lv, int pos)
747  {  {
748      char type[128];      char type[128];
749    
750      listview_get_item_text( lv, pos, 0, type, 127 );      listview_get_item_text (lv, pos, 0, type, sizeof (type)-1);
751      return !strcmp( type, "SIGNED-DETACH" )? 1 : 0;      return !strcmp (type, "SIGNED-DETACH")? 1 : 0;
752  } /* fm_check_detached_sig */  }
753    
754    
755  int  int
# Line 687  fm_check_file_type (listview_ctrl_t lv, Line 770  fm_check_file_type (listview_ctrl_t lv,
770          break;          break;
771                    
772      case FM_DECRYPT:      case FM_DECRYPT:
773          if (!strcmp (status, "DATA")          if (!strcmp (status, "DATA") ||
774              || !strcmp (status, "ENCRYPTED")              !strcmp (status, "ENCRYPTED") ||
775              || !strcmp (status, "SYMKEYENC")              !strcmp (status, "SYMKEYENC") ||
776              || !strcmp (status, "ARMORED"))              !strcmp (status, "ARMORED"))
777              rc = 1;              rc = 1;
778          break;          break;
779                    
# Line 723  fm_check_file_type (listview_ctrl_t lv, Line 806  fm_check_file_type (listview_ctrl_t lv,
806      }      }
807            
808      return rc;      return rc;
809  } /* fm_check_file_type */  }
810    
811    
812    /* Set the file status of the given command @fm_cmd.
813       @success is 0 on success. */
814  static void  static void
815  fm_set_status (listview_ctrl_t lv, int pos, int fm_cmd, int success,  fm_set_status (listview_ctrl_t lv, int pos, int fm_cmd,
816                 const char * output)                 gpgme_sig_mode_t sigmode, int success, const char *output)
817  {  {
818      char status[128], operat[128];      char status[128], operat[128];
819      int update = 1;      int update = 1;
820      const char *s;      const char *s;
821    
822      if ( fm_cmd == FM_LIST )      if (fm_cmd == FM_LIST)
823          return;          return;
824      success ? s = "SUCCESS" : s = "FAILED";      success ? s = "SUCCESS" : s = "FAILED";
825      strcpy( operat, s );      strcpy (operat, s);
826    
827      switch (fm_cmd) {      switch (fm_cmd) {
828      case FM_ENCRYPT:      case FM_ENCRYPT:
829      case FM_ENCRYPT_DIR:      case FM_ENCRYPT_DIR:
830      case FM_SIGNENCRYPT: strcpy( status, "ENCRYPTED" ); break;      case FM_SIGNENCRYPT: strcpy (status, "ENCRYPTED"); break;
831      case FM_DECRYPT:     strcpy( status, "UNKNOWN" );   break;      case FM_DECRYPT:     strcpy (status, "UNKNOWN");   break;
832      case FM_SIGN:        strcpy( status, "SIGNED" );    break;      case FM_SIGN:
833            if (sigmode == GPGME_SIG_MODE_DETACH)
834                strcpy (status, "SIGNED-DETACH");
835            else if (sigmode == GPGME_SIG_MODE_CLEAR)
836                strcpy (status, "SIGNED-CLEAR");
837            else
838                strcpy (status, "SIGNED");
839            break;
840      case FM_VERIFY:      update = 0;                    break;      case FM_VERIFY:      update = 0;                    break;
841      case FM_SYMENC:      strcpy( status, "SYMKEYENC" ); break;      case FM_SYMENC:      strcpy (status, "SYMKEYENC"); break;
842      case FM_IMPORT:      update = 0;                    break;      case FM_IMPORT:      update = 0;                    break;
843      case FM_WIPE:        strcpy( status, "WIPED" );     break;      case FM_WIPE:        strcpy (status, "WIPED");     break;
844      default:             strcpy( status, "UNKNOWN");    break;      default:             strcpy (status, "UNKNOWN");    break;
845      }      }
846    
847      if (success) {      if (success && update) {
848          if (update) {          listview_add_sub_item (lv, pos, 0, status);
849              listview_add_sub_item (lv, pos, 0, status);          listview_add_sub_item (lv, pos, 1, output);
             listview_add_sub_item (lv, pos, 1, output);  
         }  
850      }      }
851      listview_add_sub_item( lv, pos, 2, operat );      listview_add_sub_item( lv, pos, 2, operat );
852  } /* fm_set_status */  }
853    
854    
855  int  int
856  fm_clearsign_8bit (listview_ctrl_t lv, fm_state_s *ctx)  fm_clearsign_8bit (listview_ctrl_t lv, fm_state_s *ctx)
857  {  {
858      FILE *f;      FILE *f;
859      byte buf[32];      BYTE buf[32];
860      char name[256];      char name[256];
861      int i, n, cnt=0;      int i, n, cnt=0;
862    
863      if (ctx->sigmode != GPGME_SIG_MODE_CLEAR)      if (ctx->sigmode != GPGME_SIG_MODE_CLEAR)
864          return 0;          return 0;
865      listview_get_item_text (lv, -1, 1, name, sizeof (name)-1);      listview_get_item_text (lv, -1, FM_COL_NAME, name, sizeof (name)-1);
866      if (stristr (name, ".TXT"))      if (stristr (name, ".TXT"))
867          return 0;          return 0;
868      f = fopen (name, "rb");      f = fopen (name, "rb");
869      if (!f)      if (!f)
870          return -1; /* should never happen */          return -1; /* should never happen */
871      n = fread (buf, 1, 32, f);      n = fread (buf, 1, 32, f);
872        fclose (f);
873      for (i = 0; i < n; i++) {      for (i = 0; i < n; i++) {
874          if (buf[i] == 0x00 || buf[i] > 170)          if (buf[i] == 0x00 || buf[i] > 170)
875              cnt++;              cnt++;
876      }      }
     fclose (f);  
877      if (!cnt)      if (!cnt)
878          return 0;          return 0;
879      n = -1;      n = -1;
880      i = log_box (_("File Manager"), MB_WARN|MB_YESNO,      i = log_box (_("File Manager"), MB_WARN|MB_YESNO,
881                   _("\"%s\" does not seems to be a text file.\n"                   _("\"%s\" does not seems to be a text file.\n"
882                     "Do you really want to clearsign it?"), name);                     "Do you really want to clearsign it?"), name);
883      if (i == IDYES)      if (i == IDYES)
# Line 795  fm_clearsign_8bit (listview_ctrl_t lv, f Line 885  fm_clearsign_8bit (listview_ctrl_t lv, f
885      return n;      return n;
886  }  }
887    
888    
889  int  int
890  fm_parse_files (listview_ctrl_t lv, HWND dlg, int cmd)  fm_parse_files (listview_ctrl_t lv, HWND dlg, int cmd)
891  {  {
# Line 807  fm_parse_files (listview_ctrl_t lv, HWND Line 898  fm_parse_files (listview_ctrl_t lv, HWND
898            
899      switch (cmd) {      switch (cmd) {
900      case ID_FILEMISC_ENCRYPT: fm_cmd = FM_ENCRYPT; break;      case ID_FILEMISC_ENCRYPT: fm_cmd = FM_ENCRYPT; break;
901        case ID_FILEMISC_ENCRYPT_ZIP:fm_cmd = FM_ENCRYPT_ZIP; break;
902      case ID_FILEMISC_DECRYPT: fm_cmd = FM_DECRYPT; break;      case ID_FILEMISC_DECRYPT: fm_cmd = FM_DECRYPT; break;
903      case ID_FILEMISC_SYMENC:  fm_cmd = FM_SYMENC;  break;      case ID_FILEMISC_SYMENC:  fm_cmd = FM_SYMENC;  break;
904      case ID_FILEMISC_SIGN:    fm_cmd = FM_SIGN;    break;          case ID_FILEMISC_SIGN:    fm_cmd = FM_SIGN;    break;    
# Line 819  fm_parse_files (listview_ctrl_t lv, HWND Line 911  fm_parse_files (listview_ctrl_t lv, HWND
911      }      }
912            
913      if (fm_get_current_pos (lv) == -1)      if (fm_get_current_pos (lv) == -1)
914          return WPTERR_GENERAL;              return WPTERR_GENERAL;
915      rc = fm_state_new (&ctx);      rc = fm_state_new (&ctx);
916      if (rc)      if (rc)
917          BUG (0);          BUG (0);
# Line 840  fm_parse_files (listview_ctrl_t lv, HWND Line 932  fm_parse_files (listview_ctrl_t lv, HWND
932            
933      /* Commands we need before we can perform the main command */      /* Commands we need before we can perform the main command */
934      switch (fm_cmd) {      switch (fm_cmd) {
935        case FM_ENCRYPT_ZIP:
936      case FM_ENCRYPT:      case FM_ENCRYPT:
937      case FM_SIGNENCRYPT:      case FM_SIGNENCRYPT:
938          if (fm_cmd == FM_SIGNENCRYPT)          if (fm_cmd == FM_SIGNENCRYPT)
939              ctx->req_signer = 1;              ctx->req_signer = 1;
940          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_FILE_ENCRYPT, ctx->dlg,          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_FILE_ENCRYPT,
941                          file_encrypt_dlg_proc, (LPARAM)ctx);                          ctx->dlg, file_encrypt_dlg_proc, (LPARAM)ctx);
942          if (ctx->cancel == 1) {          if (ctx->cancel == 1) {
943              rc = WPTERR_GENERAL;              rc = WPTERR_GENERAL;
944              goto leave;              goto leave;
945          }          }
946          break;          break;
# Line 886  fm_parse_files (listview_ctrl_t lv, HWND Line 979  fm_parse_files (listview_ctrl_t lv, HWND
979          memset (&confirm, 0, sizeof confirm);          memset (&confirm, 0, sizeof confirm);
980          confirm.lv_files = lv;          confirm.lv_files = lv;
981          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_FILES_SECDEL, ctx->dlg,          DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_FILES_SECDEL, ctx->dlg,
982                              file_secdel_confirm_dlg_proc, (LPARAM)&confirm);                          file_secdel_confirm_dlg_proc, (LPARAM)&confirm);
983          if (!confirm.yes)          if (!confirm.yes)
984              goto leave;              goto leave;
985      }      }
986        
987      for( i = 0; i < listview_count_items( lv, 0 ); i++ ) {      if (fm_cmd == FM_ENCRYPT_ZIP)
988          if( !listview_get_item_state( lv, i ) )          fm_encrypt_into_zip (ctx, lv);
989    
990        for (i = 0; i < listview_count_items (lv, 0); i++) {
991            if (!listview_get_item_state (lv, i))
992              continue;              continue;
993          listview_get_item_text( lv, i, 1, fname, sizeof (fname) - 1 );          listview_get_item_text (lv, i, 1, fname, sizeof (fname) - 1);
994          if( file_exist_check( fname ) && !is_directory( fname ) ) {          if( file_exist_check (fname) && !is_directory (fname)) {
995              log_box( _("File Manager"), MB_ERR, _("\"%s\" does not exist"), fname );              log_box (_("File Manager"), MB_ERR,
996                         _("\"%s\" does not exist"), fname);
997              continue;              continue;
998          }          }
999          if( is_directory( fname ) )          if (is_directory (fname))
1000              fm_cmd = FM_ENCRYPT_DIR;                      fm_cmd = FM_ENCRYPT_DIR;        
1001          if( !fm_check_file_type( lv, i, fm_cmd ) )          if (!fm_check_file_type (lv, i, fm_cmd))
1002              continue;              continue;
1003          sig_detached = fm_check_detached_sig( lv, i );          sig_detached = fm_check_detached_sig (lv, i);
1004          switch( fm_cmd ) {          switch (fm_cmd) {
1005          case FM_LIST:        rc = fm_list( fname, dlg );       break;          case FM_LIST:        rc = fm_list( fname, dlg );       break;
1006          case FM_WIPE:        rc = fm_wipe( fname );            break;          case FM_WIPE:        rc = fm_wipe( fname );            break;
1007          case FM_ENCRYPT:     rc = fm_encrypt( ctx, fname, 0 ); break;          case FM_ENCRYPT:     rc = fm_encrypt( ctx, fname, 0 ); break;
# Line 912  fm_parse_files (listview_ctrl_t lv, HWND Line 1009  fm_parse_files (listview_ctrl_t lv, HWND
1009          case FM_SIGNENCRYPT: rc = fm_encrypt( ctx, fname, 1 ); break;          case FM_SIGNENCRYPT: rc = fm_encrypt( ctx, fname, 1 ); break;
1010          case FM_DECRYPT:     rc = fm_decrypt( ctx, fname );    break;          case FM_DECRYPT:     rc = fm_decrypt( ctx, fname );    break;
1011          case FM_SIGN:        rc = fm_sign( ctx, fname );       break;          case FM_SIGN:        rc = fm_sign( ctx, fname );       break;
1012          case FM_SYMENC:      rc = fm_sym_encrypt( ctx, fname );break;          case FM_SYMENC:      rc = fm_sym_encrypt (ctx, fname); break;
1013          case FM_VERIFY:      rc = fm_verify (ctx, sig_detached, fname);break;          case FM_VERIFY:      rc = fm_verify (ctx, sig_detached, fname);break;
1014          case FM_IMPORT:          case FM_IMPORT:
1015              free_if_alloc (ctx->opaque);              free_if_alloc (ctx->opaque);
1016              ctx->opaque = m_strdup (fname);              ctx->opaque = m_strdup (fname);
1017              if (!ctx->opaque)              DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_IMPORT, dlg,
1018                  BUG (0);                              file_import_dlg_proc, (LPARAM)ctx);
             DialogBoxParam( glob_hinst, (LPCSTR)IDD_WINPT_IMPORT, dlg,  
                            file_import_dlg_proc, (LPARAM)ctx );  
1019              if (ctx->cancel == 1)              if (ctx->cancel == 1)
1020                  continue;                  continue;
1021              rc = fm_import (ctx, fname);              rc = fm_import (ctx, fname);
1022              break;              break;
1023          }          }
1024          fm_set_status (lv, i, fm_cmd, !rc, ctx->output);          if (ctx->cancel == 1) {
1025                ctx->cancel = 0;
1026                continue;
1027            }
1028            fm_set_status (lv, i, fm_cmd, ctx->sigmode, !rc, ctx->output);
1029          free_if_alloc (ctx->output);          free_if_alloc (ctx->output);
1030          progress_cleanup (&pfx);          progress_cleanup (&pfx);
1031      }      }
1032    
1033      if (fm_cmd == FM_WIPE) {      if (fm_cmd == FM_WIPE) {
1034          secure_unlink_set_cb (NULL, NULL);          secure_unlink_set_cb (NULL, NULL);
1035          progress_cleanup (&pfx2);          progress_cleanup (&pfx2);
# Line 942  fm_parse_files (listview_ctrl_t lv, HWND Line 1042  fm_parse_files (listview_ctrl_t lv, HWND
1042      /* remove wipe files from the list */      /* remove wipe files from the list */
1043      n = listview_count_items (lv, 0);      n = listview_count_items (lv, 0);
1044      while (n--) {      while (n--) {
         char status[128];  
1045          listview_get_item_text (lv, n, 0, status, sizeof (status) - 1);          listview_get_item_text (lv, n, 0, status, sizeof (status) - 1);
1046          if( !strcmp (status, "WIPED"))          if (!strcmp (status, "WIPED"))
1047              listview_del_item (lv, n);              listview_del_item (lv, n);
1048      }      }
1049            
# Line 986  fm_list (const char *name, HWND dlg) Line 1085  fm_list (const char *name, HWND dlg)
1085  static int  static int
1086  ask_filename (fm_state_t c, const char *msg, char **dst)  ask_filename (fm_state_t c, const char *msg, char **dst)
1087  {  {
1088      const char * s;      const char *s;
1089    
1090      s = get_filename_dlg (c->dlg, FILE_SAVE, msg, NULL, NULL);      s = get_filesave_dlg (c->dlg, msg, NULL, NULL);
1091      if (!s)      if (!s)
1092          return WPTERR_GENERAL;          return WPTERR_GENERAL;
1093    
# Line 996  ask_filename (fm_state_t c, const char * Line 1095  ask_filename (fm_state_t c, const char *
1095          free_if_alloc (*dst);          free_if_alloc (*dst);
1096      free_if_alloc (c->output);      free_if_alloc (c->output);
1097      c->output = m_strdup (s);      c->output = m_strdup (s);
     if (!c->output)  
         BUG (0);  
1098      if (dst)      if (dst)
1099          *dst = fm_quote_file (s);          *dst = fm_quote_file (s);
1100      return 0;      return 0;
# Line 1012  fm_encrypt (fm_state_t c, const char *na Line 1109  fm_encrypt (fm_state_t c, const char *na
1109      gpgme_ctx_t ctx = c->ctx;      gpgme_ctx_t ctx = c->ctx;
1110      file_data_t in=NULL, out=NULL;      file_data_t in=NULL, out=NULL;
1111      char *keyid = NULL, ext[5];      char *keyid = NULL, ext[5];
1112      int no_compr = 0;      /*int no_compr = 0;*/
1113      int rc = 0;      int rc = 0;
1114    
1115      c->output = new char[strlen (name) + 5 + 1];      c->output = new char[strlen (name) + 5 + 1];
# Line 1020  fm_encrypt (fm_state_t c, const char *na Line 1117  fm_encrypt (fm_state_t c, const char *na
1117          BUG (0);          BUG (0);
1118      strcpy (ext, file_get_extension (ctx, c->sigmode));      strcpy (ext, file_get_extension (ctx, c->sigmode));
1119      strcpy (c->output, name);      strcpy (c->output, name);
1120      strcat (c->output, ext);              strcat (c->output, ext);
1121            
1122      if (!overwrite_file (c->output)) {      if (!overwrite_file (c->output)) {
1123          rc = ask_filename (c, _("Enter filename for encrypted file"), NULL);          rc = ask_filename (c, _("Enter Filename for Encrypted File"), NULL);
1124          if (rc)          if (rc)
1125              goto leave;              goto leave;
1126      }      }
1127    
1128      err = gpg_file_data_new (name, 1, &in);      err = gpg_file_data_new (name, F_DATA_READ, &in);
1129      if (err)      if (err)
1130          goto leave;          goto leave;
1131      err = gpg_file_data_new (c->output, 0, &out);      remove_crit_file_attrs (c->output, 0);
1132        err = gpg_file_data_new (c->output, F_DATA_WRITE, &out);
1133      if (err)      if (err)
1134          goto leave;          goto leave;
1135    
# Line 1042  fm_encrypt (fm_state_t c, const char *na Line 1140  fm_encrypt (fm_state_t c, const char *na
1140      }      }
1141      */      */
1142            
1143      /* XXX      /* XXX: disable compression for multi-media files.
1144      no_compr = is_multi_media (name);      no_compr = is_multi_media (name);
1145      gpgme_control (ctx, GPGME_CTRL_NO_COMPR, no_compr);      gpgme_control (ctx, GPGME_CTRL_NO_COMPR, no_compr);
1146      */      */
# Line 1061  fm_encrypt (fm_state_t c, const char *na Line 1159  fm_encrypt (fm_state_t c, const char *na
1159              gpgme_signers_add (ctx, key);              gpgme_signers_add (ctx, key);
1160          }          }
1161          else {          else {
1162              gpgme_key_t key = gpgme_signers_enum (ctx, 0);              gpgme_key_t sigkey = gpgme_signers_enum (ctx, 0);
1163              if (key && key->subkeys) {              if (sigkey && sigkey->subkeys) {
1164                  keyid = m_strdup (key->subkeys->keyid);                  keyid = m_strdup (sigkey->subkeys->keyid);
                 if (!keyid)  
                     BUG (NULL);  
1165              }              }
1166          }          }
1167          if (!c->init_cb || !c->cache_cb) {          if (!c->init_cb || !c->cache_cb) {
# Line 1102  fm_encrypt (fm_state_t c, const char *na Line 1198  fm_encrypt (fm_state_t c, const char *na
1198              goto leave;              goto leave;
1199          }          }
1200      }      }
     if (c->wipe)  
         secure_unlink (name, WIPE_MODE_SIMPLE);  
1201            
1202  leave:  leave:
1203      if (in)      if (in)
# Line 1111  leave: Line 1205  leave:
1205      if (out)      if (out)
1206          gpg_file_data_release (out);          gpg_file_data_release (out);
1207      free_if_alloc (keyid);      free_if_alloc (keyid);
1208        if (!rc && c->wipe)
1209            secure_unlink (name, WIPE_MODE_SIMPLE);
1210      return rc;      return rc;
1211  }  }
1212    
# Line 1122  fm_sym_encrypt (fm_state_t c, const char Line 1218  fm_sym_encrypt (fm_state_t c, const char
1218      gpgme_error_t err;          gpgme_error_t err;    
1219      file_data_t in=NULL, out=NULL;      file_data_t in=NULL, out=NULL;
1220      int rc = 0, cancel = 0;      int rc = 0, cancel = 0;
1221      char * src = NULL, * dst = NULL;      char ext[5], *pass;    
     char ext[5], * pass;      
1222            
1223      pass = request_passphrase2 (_("Symmetric"), 0, &cancel);      pass = request_passphrase2 (_("Symmetric Encryption"), 0, &cancel);
1224      if (cancel)      if (cancel) {
1225            c->cancel = 1;
1226          return 0;          return 0;
1227        }
1228            
1229      /* XXX gpgme_control (ctx, GPGME_CTRL_CIPHER, -1);*/      /* XXX: a convenient feature could be to select the preferred
1230                symmetric algorithm. */
1231      c->output = new char[strlen (name) + 5 + 1];      c->output = new char[strlen (name) + 5 + 1];
1232      if (!c->output)      if (!c->output)
1233          BUG (0);          BUG (0);
# Line 1142  fm_sym_encrypt (fm_state_t c, const char Line 1240  fm_sym_encrypt (fm_state_t c, const char
1240          goto leave;              goto leave;    
1241      }      }
1242    
1243      gpgme_set_passphrase_cb (ctx, sym_passphrase_cb, pass);          gpgme_set_passphrase_cb (ctx, sym_passphrase_cb, pass);
   
1244      err = gpg_file_data_new (name, 1, &in);      err = gpg_file_data_new (name, 1, &in);
1245      if (err)      if (err)
1246          goto leave;          goto leave;
# Line 1172  leave: Line 1269  leave:
1269          gpg_file_data_release (out);          gpg_file_data_release (out);
1270      sfree_if_alloc (pass);      sfree_if_alloc (pass);
1271      return rc;      return rc;
 } /* fm_sym_encrypt */  
   
   
 /* Show the human readable verify result from @sigres. */  
 static void  
 show_verify_result (gpgme_verify_result_t sigres)  
 {  
     gpgme_key_t key=NULL;  
     gpgme_signature_t sig=sigres->signatures;  
     const char *s, *keyid;  
     int sigok = 0;  
     int type;  
     char buf[384];  
   
     sig = sigres->signatures;  
     sigok = sig->summary & GPGME_SIGSUM_GREEN;  
     s = sigok? _("Good signature") : _("BAD signature");  
     type = sigok? MB_OK: MB_ICONWARNING|MB_OK;  
     keyid = sig->fpr;    
     if (!keyid)  
         return;  
   
     keyid = strlen (sig->fpr) == 40? sig->fpr+32 : sig->fpr + 24;  
     get_pubkey (sig->fpr, &key);  
     _snprintf (buf, sizeof (buf)-1, "Signature made %s using %s key ID %s\n"  
                                     "%s from \"%s\"",  
                 strtimestamp (sig->timestamp), get_key_pubalgo (sig->pubkey_algo),  
                 keyid, s, key? key->uids->uid : _("user ID not found"));  
     msg_box (NULL, buf, _("Decrypt Verify"), type);  
1272  }  }
1273    
1274    
1275  /* Check the recipients if we have at least one secret key. */  /* Check the recipients if we have at least one secret key. */
1276  bool  bool
1277  secret_key_available (gpgme_recipient_t rset)  is_seckey_available (gpgme_recipient_t rset)
1278  {  {
1279      gpgme_recipient_t r;      gpgme_recipient_t r;
1280      gpgme_key_t key;      winpt_key_s key;
1281    
1282      for (r=rset; r; r = r->next) {            for (r=rset; r; r = r->next) {
1283          if (gpgme_err_code (r->status) == GPG_ERR_NO_SECKEY)          if (gpgme_err_code (r->status) == GPG_ERR_NO_SECKEY)
1284              continue;              continue;
1285          else {          else {
1286                memset (&key, 0, sizeof (key));
1287              /* extra check to make sure the key is available right now. */              /* extra check to make sure the key is available right now. */
1288              if (!get_seckey (r->keyid, &key))              if (!winpt_get_seckey (r->keyid, &key)) {
1289                    winpt_release_pubkey (&key);
1290                  return true;                  return true;
1291                }
1292                winpt_release_pubkey (&key);
1293          }          }
1294      }      }
1295      return false;      return false;
1296  }  }
1297    
1298    
1299    /* If the decrypt result contains the original file name,
1300       we use it instead of the artificial "output - .gpg" string. */
1301    static int
1302    restore_original_name (const char *output, const char *file_name)
1303    {
1304        char *dir;
1305        char *orig;
1306        int rc = 0;
1307    
1308        dir = strrchr (output, '\\');
1309        if (!dir)
1310            orig = strdup (file_name);
1311        else {
1312            orig = (char*)calloc (1, strlen (file_name)+ 1 +
1313                                     strlen (output)+1);
1314            if (!orig)
1315                BUG (0);
1316            memcpy (orig, output, (dir-output)+1);
1317            strcat (orig, file_name);
1318        }
1319        /* XXX: we need to find out if the string needs to be utf8 decoded. */
1320        if (overwrite_file (orig)) {
1321            DeleteFile (orig);
1322            if (!MoveFile (output, orig))
1323                rc = -1;
1324        }
1325        safe_free (orig);
1326        return rc;
1327    }
1328    
1329    
1330  /* Decrypt the file @name. */  /* Decrypt the file @name. */
1331  int  int
1332  fm_decrypt (fm_state_t c, const char *name)  fm_decrypt (fm_state_t c, const char *name)
# Line 1232  fm_decrypt (fm_state_t c, const char *na Line 1335  fm_decrypt (fm_state_t c, const char *na
1335      gpgme_ctx_t ctx = c->ctx;          gpgme_ctx_t ctx = c->ctx;    
1336      gpgme_decrypt_result_t res;      gpgme_decrypt_result_t res;
1337      gpgme_verify_result_t sigres;      gpgme_verify_result_t sigres;
1338      file_data_t in =NULL, out=NULL;      file_data_t in = NULL, out = NULL;
     int is_signed = 0;  
1339      int rc = 0;      int rc = 0;
1340            
1341      if (!c->init_cb || !c->cache_cb) {      if (!c->init_cb || !c->cache_cb) {
1342          set_gpg_passphrase_cb (&c->pass_cb, c->ctx, GPG_CMD_DECRYPT,          set_gpg_passphrase_cb (&c->pass_cb, c->ctx, GPG_CMD_DECRYPT,
1343                                 c->dlg, _("Decryption"));                                 c->dlg, _("Decryption"));
1344          c->init_cb = 1;          c->init_cb = 1;
1345      }          }
1346            
1347      c->output = m_strdup (name);      c->output = m_strdup (name);
     if (!c->output)  
         BUG (0);  
1348      if (is_openpgp_ext (c->output))      if (is_openpgp_ext (c->output))
1349          c->output[strlen (c->output)-4] = '\0';          c->output[strlen (c->output)-4] = '\0';
1350      else {      else {
# Line 1254  fm_decrypt (fm_state_t c, const char *na Line 1354  fm_decrypt (fm_state_t c, const char *na
1354          if (s) {          if (s) {
1355              free_if_alloc (c->output);              free_if_alloc (c->output);
1356              c->output = m_strdup (s);              c->output = m_strdup (s);
             if (!c->output)  
                 BUG (NULL);  
1357          }          }
1358      }      }
1359    
1360      if (overwrite_file (c->output) == 0) {      if (overwrite_file (c->output) == 0) {
1361          rc = ask_filename (c, _("Please enter filename for plaintext file"), NULL);          rc = ask_filename (c, _("Enter Filename for Plaintext File"), NULL);
1362          if (rc)          if (rc)
1363              goto leave;              goto leave;
1364      }          }
1365    
1366      remove_crit_file_attrs (c->output, 0);      /* we fetch all recipients here to make sure they list is complete. */
1367        release_gpg_recipients (&c->pass_cb.recipients);
1368        gpg_get_recipients (name, &c->pass_cb.recipients);
1369    
1370      err = gpg_file_data_new (name, 1, &in);      err = gpg_file_data_new (name, F_DATA_READ, &in);
1371      if (err)      if (err)
1372          goto leave;          goto leave;
1373      err = gpg_file_data_new (c->output, 0, &out);      remove_crit_file_attrs (c->output, 0);
1374        err = gpg_file_data_new (c->output, F_DATA_WRITE, &out);
1375      if (err)      if (err)
1376          goto leave;          goto leave;
1377        
1378      op_begin ();      op_begin ();
1379      err = gpgme_op_decrypt_verify (ctx, in->dat, out->dat);      err = gpgme_op_decrypt_verify (ctx, in->dat, out->dat);
1380      op_end ();      op_end ();
# Line 1285  fm_decrypt (fm_state_t c, const char *na Line 1386  fm_decrypt (fm_state_t c, const char *na
1386      }      }
1387    
1388      res = gpgme_op_decrypt_result (ctx);      res = gpgme_op_decrypt_result (ctx);
1389      if (res && res->recipients && !secret_key_available (res->recipients)) {      if (res && res->recipients && !is_seckey_available (res->recipients)) {
1390          const char *keyid = res->recipients->keyid;          const char *keyid = get_keyid_from_fpr (res->recipients->keyid);
1391          char *p = get_key_userid (keyid+8);          char *p = get_key_userid (keyid);
1392          gpgme_pubkey_algo_t pkalgo = res->recipients->pubkey_algo;          gpgme_pubkey_algo_t pkalgo = res->recipients->pubkey_algo;
1393                    
1394          log_box( _("Decryption"), MB_ERR,          log_box (_("Decryption"), MB_ERR,
1395                   _("Encrypted with %s key, ID %s.%s\n"                   _("Encrypted with %s key, ID 0x%s.%s\n"
1396                     "Decryption failed: secret key not available."),                     "Decryption failed: secret key not available."),
1397                     get_key_pubalgo (pkalgo), keyid+8, p);                     get_key_pubalgo (pkalgo), keyid, p);
1398          rc = WPTERR_GENERAL;          rc = WPTERR_GENERAL;
1399          free_if_alloc (p);          free_if_alloc (p);
1400          goto leave;          goto leave;
# Line 1304  fm_decrypt (fm_state_t c, const char *na Line 1405  fm_decrypt (fm_state_t c, const char *na
1405          goto leave;          goto leave;
1406      }      }
1407      if (file_exist_check (c->output)) {      if (file_exist_check (c->output)) {
1408          log_box ("Decrypt", MB_ERR, _("Decryption failed.\n%s: does not exist."), c->output);          log_box ("Decrypt", MB_ERR,
1409                     _("Decryption failed.\n%s: does not exist."), c->output);
1410          rc = WPTERR_GENERAL;          rc = WPTERR_GENERAL;
1411            goto leave;
1412        }
1413        else if (res && res->file_name) {
1414            char *file;
1415            int id = IDNO;
1416    
1417            file = strrchr (c->output, '\\');
1418            if (!file)
1419                file = c->output;
1420            else
1421                file++;
1422            if (strcmp (res->file_name, file))
1423                id = log_box (_("Decrypt"), MB_QUEST_ASK,
1424                              _("The original file name is '%s'.\n\n"
1425                                "Do you want to use this instead of '%s'?"),
1426                          res->file_name, file);
1427            if (id == IDYES) {
1428                /* before we can move the file, it needs to be closed first. */
1429                gpg_file_data_release (out);
1430                out = NULL;
1431                restore_original_name (c->output, res->file_name);
1432            }
1433      }      }
       
1434      sigres = gpgme_op_verify_result (ctx);      sigres = gpgme_op_verify_result (ctx);
1435      if (sigres && sigres->signatures)      if (sigres && sigres->signatures)
1436          show_verify_result (sigres);          verify_show_signature_state (sigres->signatures);
1437            
1438  leave:  leave:
1439      if (in)      if (in)
1440          gpg_file_data_release (in);          gpg_file_data_release (in);
1441      if (out)      if (out)
1442          gpg_file_data_release (out);          gpg_file_data_release (out);
1443    
1444      return rc;      return rc;
1445  }  }
1446    
1447    
1448  int  int
1449  fm_sign (fm_state_t c, const char * name)  fm_sign (fm_state_t c, const char * name)
1450  {        {
     int rc = 0;  
1451      gpgme_ctx_t ctx = c->ctx;      gpgme_ctx_t ctx = c->ctx;
1452      gpgme_error_t err;      gpgme_error_t err;
1453      file_data_t in=NULL, out=NULL;      file_data_t in=NULL, out=NULL;
1454      char ext[5];      char ext[5];
1455        int rc = 0;
1456    
1457      if (!c->init_cb || !c->cache_cb) {      if (!c->init_cb || !c->cache_cb) {
1458          set_gpg_passphrase_cb (&c->pass_cb, c->ctx, GPG_CMD_SIGN, c->dlg, _("Signing") );          set_gpg_passphrase_cb (&c->pass_cb, c->ctx,
1459                                   GPG_CMD_SIGN, c->dlg, _("Signing"));
1460          c->init_cb = 1;          c->init_cb = 1;
1461      }      }
1462            
1463      free_if_alloc (c->output);      free_if_alloc (c->output);
1464      c->output = new char[strlen (name) + 5 + 1];      c->output = new char[strlen (name) + 5 + 1];
1465      if( !c->output)      if (!c->output)
1466          BUG( NULL );          BUG (NULL);
1467      strcpy (ext, file_get_extension (ctx, c->sigmode));      strcpy (ext, file_get_extension (ctx, c->sigmode));
1468      strcpy (c->output, name);      strcpy (c->output, name);
1469      strcat (c->output, ext);      strcat (c->output, ext);
1470            
1471      if (!overwrite_file (c->output)) {      if (!overwrite_file (c->output)) {
1472          rc = ask_filename (c, _("Enter filename for signed file"), NULL);          rc = ask_filename (c, _("Enter Filename for Signed File"), NULL);
1473          if (rc)          if (rc)
1474              goto leave;              goto leave;
1475      }      }
1476      remove_crit_file_attrs (c->output, 0);      
1477        err = gpg_file_data_new (name, F_DATA_READ, &in);
     err = gpg_file_data_new (name, 1, &in);  
1478      if (err)      if (err)
1479          goto leave;          goto leave;
1480      err = gpg_file_data_new (c->output, 0, &out);      remove_crit_file_attrs (c->output, 0);
1481        err = gpg_file_data_new (c->output, F_DATA_WRITE, &out);
1482      if (err)      if (err)
1483          goto leave;          goto leave;
1484    
1485      op_begin ();      op_begin ();
1486      err = gpgme_op_sign (ctx, in->dat, out->dat, c->sigmode);      err = gpgme_op_sign (ctx, in->dat, out->dat, c->sigmode);
1487      op_end ();      op_end ();
1488      if( !c->cache_cb )      if (!c->cache_cb)
1489          release_gpg_passphrase_cb (&c->pass_cb);          release_gpg_passphrase_cb (&c->pass_cb);
1490      if( c->pass_cb.cancel ) {      if (c->pass_cb.cancel) {
1491          rc = WPTERR_GENERAL;          rc = WPTERR_GENERAL;
1492          goto leave;          goto leave;
1493      }      }
1494      if( err ) {      if (err) {
1495          msg_box( c->dlg, gpgme_strerror( err ), _("Sign"), MB_ERR );          msg_box (c->dlg, gpgme_strerror (err), _("Sign"), MB_ERR);
1496          rc = WPTERR_GENERAL;          rc = WPTERR_GENERAL;
1497          goto leave;              goto leave;    
1498      }      }
# Line 1381  leave: Line 1506  leave:
1506  }  }
1507    
1508    
1509  static int  static void
1510  fm_add_sig_stat (file_sig_ctx_t log)  fm_add_sig_stat (file_sig_ctx_t log)
1511  {  {
1512      gpgme_key_t key;          struct winpt_key_s key;
1513      const char *kid;      const char *kid;
     int not_found = 0;  
1514    
1515      kid = log->sig->fpr;      memset (&key, 0, sizeof (key));
1516      if (!kid)      kid = get_keyid_from_fpr (log->sig->fpr);
1517          BUG (NULL);      log->use_uid = 0;
1518      if (strlen (kid) == 40)      if (!winpt_get_pubkey (kid, &key)) {
1519          kid += 32;                log->user_id = key.ext->uids->uid;
     else if (strlen (kid) == 32)  
         kid += 24;  
     if (get_pubkey (kid, &key))  
         log->use_uid = 0;  
     else {  
         log->user_id = key->uids->uid;  
1520          log->use_uid = 1;          log->use_uid = 1;
1521      }      }
1522      file_verify_add_state (log);      file_verify_add_state (log);
1523      return 0;      winpt_release_pubkey (&key);    
1524  }  }
1525    
1526    
1527    /* Verify a detached signature from the clipboard. */  
1528  static int  static int
1529  verify_pasted (listview_ctrl_t lv, fm_state_t ctx, const char * dat,  verify_pasted (listview_ctrl_t lv, fm_state_t ctx,
1530                 int i, HWND dlg)                 const char *dat, int pos, HWND dlg)
1531  {  {
1532      FILE * fp;      FILE *fp;
1533      char stat[32];      char stat[32];
1534      char file[256], * fname = NULL;      char file[256], *fname = NULL;
1535      int del_end=0;      int del_end = 0;
1536    
1537      listview_get_item_text (lv, i, 0, stat, sizeof (stat)-1);      listview_get_item_text (lv, pos, FM_COL_STAT, stat, sizeof (stat)-1);
1538      listview_get_item_text (lv, i, 1, file, sizeof (file)-1);      listview_get_item_text (lv, pos, FM_COL_NAME, file, sizeof (file)-1);
1539      if (strcmp (stat, "UNKNOWN"))      if (strcmp (stat, "UNKNOWN"))
1540          return 0;          return 0;
1541      fname = make_filename (NULL, file, "asc");      fname = make_filename (NULL, file, "asc");
1542      if (file_exist_check (fname) != 0) {      if (file_exist_check (fname) != 0) {
1543          fp = fopen (fname, "wb");          fp = fopen (fname, "wb");
1544          if (fp == NULL) {          if (fp == NULL) {
1545              log_box (_("File Manager"), MB_ERR, "could not create '%s'", fname);              log_box (_("File Manager"), MB_ERR, "Could not create '%s'", fname);
1546              free_if_alloc (fname);              free_if_alloc (fname);
1547              return WPTERR_GENERAL;                    return WPTERR_GENERAL;
1548          }                }
1549          fwrite (dat, 1, strlen (dat), fp);          fwrite (dat, 1, strlen (dat), fp);
1550          fclose (fp);          fclose (fp);
1551          del_end = 1;          del_end = 1;
1552      }      }
1553      fm_verify (ctx, 1, fname);      fm_verify (ctx, 1, fname);
1554      if (del_end)      if (del_end)
1555          unlink (fname);          DeleteFile (fname);
1556      free_if_alloc (fname);      free_if_alloc (fname);
1557      return 0;      return 0;
1558  }  }
1559    
1560    
1561    /* Figure out if the clipboard contains a detached signature. */
1562  int  int
1563  fm_verify_pasted_detsig (listview_ctrl_t lv, HWND dlg)  fm_verify_pasted_detsig (listview_ctrl_t lv, HWND dlg)
1564  {  {
# Line 1456  fm_verify_pasted_detsig (listview_ctrl_t Line 1576  fm_verify_pasted_detsig (listview_ctrl_t
1576      /* XXX find a way to filter out bad signatures or just ignore all in      /* XXX find a way to filter out bad signatures or just ignore all in
1577             this case */             this case */
1578      fm_state_new (&ctx);      fm_state_new (&ctx);
1579      if ((i=listview_get_curr_pos (lv)) != -1) {      i = listview_get_curr_pos (lv);
1580        if (i= -1) {
1581          verify_pasted (lv, ctx, dat, i, dlg);          verify_pasted (lv, ctx, dat, i, dlg);
1582          fnd = 1;          fnd = 1;
1583      }      }
# Line 1488  get_output_file (fm_state_t c, const cha Line 1609  get_output_file (fm_state_t c, const cha
1609      else      else
1610          title = _("Selected Output File");          title = _("Selected Output File");
1611    
1612      if (strstr (name, ".sig") || strstr (name, ".asc") || strstr (name, ".gpg")) {      if (is_openpgp_ext (name)) {
1613          _snprintf (fname, sizeof (fname) - 1, "%s", name);          _snprintf (fname, sizeof (fname) - 1, "%s", name);
1614          fname[strlen (fname) - 4] = '\0';          fname[strlen (fname) - 4] = '\0';
1615          if (file_exist_check (fname) == 0 && detached)            if (file_exist_check (fname) == 0 && detached)  
# Line 1510  get_output_file (fm_state_t c, const cha Line 1631  get_output_file (fm_state_t c, const cha
1631      if (file) {          if (file) {    
1632          free_if_alloc (c->output);              free_if_alloc (c->output);    
1633          c->output = m_strdup (file);          c->output = m_strdup (file);
         if (!c->output)  
             BUG (NULL);  
1634      }      }
1635      else {      else {
1636          msg_box (c->dlg, _("Invalid file name. Exit"), _("Verify"), MB_ERR);          msg_box (c->dlg, _("Invalid file name. Exit"), _("Verify"), MB_ERR);
# Line 1520  get_output_file (fm_state_t c, const cha Line 1639  get_output_file (fm_state_t c, const cha
1639      if (detached)      if (detached)
1640          c->sigmode = GPGME_SIG_MODE_DETACH;          c->sigmode = GPGME_SIG_MODE_DETACH;
1641      else {      else {
1642          if (strstr (name, ".asc"))          if (stristr (name, ".asc"))
1643              c->sigmode = GPGME_SIG_MODE_CLEAR;              c->sigmode = GPGME_SIG_MODE_CLEAR;
1644          else          else
1645              c->sigmode = GPGME_SIG_MODE_NORMAL;              c->sigmode = GPGME_SIG_MODE_NORMAL;
# Line 1542  fm_verify (fm_state_t c, int detached, c Line 1661  fm_verify (fm_state_t c, int detached, c
1661      file_data_t in=NULL, out=NULL;      file_data_t in=NULL, out=NULL;
1662      int rc = 0;      int rc = 0;
1663    
1664      if (strstr (name, ".sig"))      if (stristr (name, ".sig"))
1665          detached = 1;          detached = 1;
1666    
1667      if (get_output_file (c, name, detached))      if (get_output_file (c, name, detached))
# Line 1550  fm_verify (fm_state_t c, int detached, c Line 1669  fm_verify (fm_state_t c, int detached, c
1669    
1670      memset (&log, 0, sizeof (log));      memset (&log, 0, sizeof (log));
1671      log.file = m_strdup (name);      log.file = m_strdup (name);
     if (!log.file)  
         BUG (NULL);  
1672      file_verify_create_dlg ();      file_verify_create_dlg ();
1673    
1674      err = gpg_file_data_new (name, 1, &in);      err = gpg_file_data_new (name, F_DATA_READ, &in);
1675      if (err)      if (err)
1676          goto leave;          goto leave;
1677      err = gpg_file_data_new (c->output, detached? 1 : 0, &out);      err = gpg_file_data_new (c->output,
1678                                 detached? F_DATA_READ : F_DATA_WRITE, &out);
1679      if (err)      if (err)
1680          goto leave;          goto leave;
1681    
# Line 1586  leave: Line 1704  leave:
1704          gpg_file_data_release (in);          gpg_file_data_release (in);
1705      if (out)      if (out)
1706          gpg_file_data_release (out);          gpg_file_data_release (out);
1707      if (log.file)      free_if_alloc (log.file);
         delete []log.file;  
1708      return rc;      return rc;
1709  }  }
1710    
1711    
1712    /* Import the keys from the file @name.
1713       Return value: 0 on success. */
1714  int  int
1715  fm_import (fm_state_t c, const char *name)  fm_import (fm_state_t c, const char *name)
1716  {  {
# Line 1603  fm_import (fm_state_t c, const char *nam Line 1722  fm_import (fm_state_t c, const char *nam
1722    
1723      free_if_alloc (c->output);      free_if_alloc (c->output);
1724      c->output = m_strdup (name);      c->output = m_strdup (name);
     if (!c->output)  
         BUG (NULL);  
1725    
1726      err = gpg_file_data_new (name, 1, &keydata);      err = gpg_file_data_new (name, F_DATA_READ, &keydata);
1727      if (err)      if (err)
1728          goto leave;          goto leave;
1729    
# Line 1622  fm_import (fm_state_t c, const char *nam Line 1739  fm_import (fm_state_t c, const char *nam
1739      res = gpgme_op_import_result (ctx);      res = gpgme_op_import_result (ctx);
1740      print_import_status (res);      print_import_status (res);
1741      if (res->no_user_id > 0) {      if (res->no_user_id > 0) {
1742          msg_box (c->dlg, _("Key without a self signature was dectected!\n"                msg_box (c->dlg, _("Key without a self signature was dectected!\n"
1743                             "(This key is NOT usable for encryption, etc)\n"                             "(This key is NOT usable for encryption, etc)\n"
1744                             "\n"                             "\n"
1745                             "Cannot import these key(s)!"), _("Import"), MB_INFO);                             "Cannot import these key(s)!"), _("Import"), MB_INFO);
# Line 1632  leave: Line 1749  leave:
1749      if (keydata)      if (keydata)
1750          gpg_file_data_release (keydata);          gpg_file_data_release (keydata);
1751      return rc;      return rc;
1752  } /* fm_import */  }
1753    
1754    
1755  /* Export the selected keys from the File Manager to a file. */  /* Export the selected keys from the File Manager to a file. */
1756  int  int
1757  fm_export (fm_state_t c)  fm_export (fm_state_t c)
1758  {  {    
     int rc = 0, id = 0;  
1759      gpgme_ctx_t ctx = c->ctx;      gpgme_ctx_t ctx = c->ctx;
1760      gpgme_error_t err;      gpgme_error_t err;
1761      gpgme_key_t *rset = c->recp;      gpgme_key_t *rset = c->recp;
1762      file_data_t keydata = NULL;      file_data_t keydata = NULL;
1763      const char *name, *s = NULL;      const char *name;
1764      char *p = NULL, *patt = NULL;      char *p = NULL, *patt = NULL;
1765        int rc = 0;
1766    
1767      if (!rset || !rset[0]) {      if (!rset || !rset[0]) {
1768          msg_box (c->dlg, _("No key was selected for export."), _("Export"), MB_ERR);          msg_box (c->dlg, _("No key was selected for export."),
1769                     _("Export"), MB_ERR);
1770          rc = WPTERR_GENERAL;          rc = WPTERR_GENERAL;
1771          goto leave;          goto leave;
1772      }      }
1773    
1774      if (rset[1] == NULL) { /* count == 1*/      if (rset[1] == NULL) /* count == 1*/
1775          gpgme_key_t k = rset[0];          p = km_gen_export_filename (rset[0]->subkeys->keyid+8, 0);
         const char *s = k->uids->name;  
         p = new char[strlen (s)+1+8];  
         if (!p)  
             BUG (NULL);  
         strcpy (p, s );  
         strcat (p, ".asc");  
     }  
1776    
1777      name = get_filename_dlg (c->dlg, FILE_SAVE, _("Choose Name for Key File"),      name = get_filesave_dlg (c->dlg, _("Choose Name for Key File"),
1778                               NULL, p? p : NULL);                               NULL, p? p : NULL);
                               
1779      if (!name)      if (!name)
1780          name = "keys.gpg";          name = reg_prefs.default_ext? "keys.pgp" : "keys.gpg";
1781    
1782      patt = gpg_keylist_to_pattern (rset, c->n_recp);      patt = gpg_keylist_to_pattern (rset, c->n_recp);
1783    
1784      err = gpg_file_data_new (name, 0, &keydata);      err = gpg_file_data_new (name, F_DATA_WRITE, &keydata);
1785      if (err)      if (err)
1786          goto leave;          goto leave;
1787    
# Line 1688  fm_export (fm_state_t c) Line 1798  fm_export (fm_state_t c)
1798  leave:  leave:
1799      if (keydata)      if (keydata)
1800          gpg_file_data_release (keydata);          gpg_file_data_release (keydata);
1801      if (patt)      safe_free (patt);
         free (patt);  
1802      free_if_alloc (p);      free_if_alloc (p);
           
1803      return rc;      return rc;
1804  }  }
1805    
# Line 1747  fm_parse_command_line (char *cmdl) Line 1855  fm_parse_command_line (char *cmdl)
1855    
1856          case PGP_SIG:          case PGP_SIG:
1857          case PGP_CLEARSIG:          case PGP_CLEARSIG:
             file_verify_use_event ();  
1858              if (type == PGP_SIG)                  if (type == PGP_SIG)    
1859                  detached = 1;                  detached = 1;
1860              fm_verify (ctx, detached, fn);              fm_verify (ctx, detached, fn);
1861              file_verify_wait ();              file_verify_wait ();
1862              break;              break;
1863    
1864            default:
1865                break;
1866          }          }
1867      }      }
1868    
# Line 1763  fm_parse_command_line (char *cmdl) Line 1873  fm_parse_command_line (char *cmdl)
1873  }  }
1874    
1875    
1876    /* Extract the last folder name from @name. */
1877  const char*  const char*
1878  default_dirname (const char *name)  default_dirname (const char *name)
1879  {  {
1880      char * p = strrchr( name, '\\' );      char *p = strrchr (name, '\\');
1881      if( !p )      if (!p)
1882          return NULL;          return NULL;
1883      return p+1;      return p+1;
1884  } /* default_dirname */  }
1885    
1886    
1887    /* Store all selected files from @lv in a zip archive
1888       and encrypt the zip archive then.
1889       Return value: 0 on success. */
1890  int  int
1891  fm_encrypt_directory( fm_state_t c, const char * name )  fm_encrypt_into_zip (fm_state_t ctx, listview_ctrl_t lv)
1892  {  {
1893      PK_FILE_LIST list = NULL;      PK_FILE_LIST list=NULL;
1894        const char *outfile, *ext;
1895        char *out_enc;
1896        int nitems;
1897        int i, idx = -1;
1898        int rc;
1899    
1900        nitems = listview_count_items (lv, 0);
1901        if (!nitems) {
1902            msg_box (NULL, _("Encrypting into a ZIP archive makes sense with multiple files"),
1903                     _("File Manager"), MB_ERR);
1904            return WPTERR_GENERAL;
1905        }
1906    
1907        outfile = get_filesave_dlg (ctx->dlg, _("Choose File Name for Output"),
1908                                    NULL, "Encrypted_Files.zip");
1909        if (!outfile)
1910            return WPTERR_GENERAL;
1911    
1912        for (i=0; i < nitems; i++) {
1913            char name[MAX_PATH+32];
1914    
1915            if (!listview_get_item_state (lv, i))
1916                continue;
1917            if (idx == -1)
1918                idx = i;
1919            listview_get_item_text (lv, i, 1, name, sizeof (name)-1);
1920            pk_list_add (&list, name);
1921        }    
1922    
1923        pk_archiv_create (list, outfile);
1924        pk_list_free (list);
1925    
1926        rc = fm_encrypt (ctx, outfile, 0);
1927        DeleteFile (outfile);
1928        if (rc)
1929            return rc;
1930    
1931        ext = file_get_extension (ctx->ctx, ctx->sigmode)+1;
1932        out_enc = make_filename (NULL, outfile, ext);
1933        fm_set_status (lv, idx, FM_ENCRYPT, (gpgme_sig_mode_t)0, 1, out_enc);
1934        free_if_alloc (out_enc);
1935    
1936        for (i=nitems; i > -1; i--) {
1937            if (i != idx && listview_get_item_state (lv, i))
1938                listview_del_item (lv, i);
1939        }
1940        return 0;
1941    }
1942    
1943    
1944    int
1945    fm_encrypt_directory (fm_state_t c, const char *name)
1946    {    
1947      WIN32_FIND_DATA findbuf;      WIN32_FIND_DATA findbuf;
1948      HANDLE hd;      HANDLE hd;
1949      const char * s;      PK_FILE_LIST list = NULL;
1950      char * patt = NULL, * p;      const char *s;
1951        char *patt = NULL, *p;
1952      int rc = 0;      int rc = 0;
1953            
1954      if( !is_directory( name ) )          if (!is_directory (name))
1955          return -1;          return -1;
1956      patt = new char[strlen( name ) + 4];      patt = new char[strlen (name) + 4];
1957      if( !patt )      if (!patt)
1958          BUG( NULL );          BUG (NULL);
1959      strcpy( patt, name );      strcpy (patt, name);
1960      strcat( patt, "\\*" );      strcat (patt, "\\*");
1961      hd = FindFirstFile( patt, &findbuf );          hd = FindFirstFile (patt, &findbuf);
1962      if( !hd ) {      if (!hd) {
1963          free_if_alloc( patt );            free_if_alloc (patt);
1964          return -1;                return WPTERR_GENERAL;
1965      }      }
1966      if( strcmp( findbuf.cFileName, "." ) && strcmp( findbuf.cFileName, ".." ) ) {      if (strcmp (findbuf.cFileName, ".") && strcmp (findbuf.cFileName, "..")) {
1967          p = make_filename( name, findbuf.cFileName, NULL );          p = make_filename (name, findbuf.cFileName, NULL);
1968          pk_list_add( &list, p );          pk_list_add (&list, p);
1969          free_if_alloc( p );          free_if_alloc (p);
1970      }      }
1971      while( FindNextFile( hd, &findbuf ) ) {      while (FindNextFile (hd, &findbuf)) {
1972          if( strcmp( findbuf.cFileName, "." ) && strcmp( findbuf.cFileName, ".." ) ) {          if (strcmp (findbuf.cFileName, ".") && strcmp (findbuf.cFileName, "..")) {
1973              p = make_filename( name, findbuf.cFileName, NULL );              p = make_filename (name, findbuf.cFileName, NULL);
1974              pk_list_add( &list, p );              pk_list_add (&list, p);
1975              free_if_alloc( p );              free_if_alloc (p);
1976          }          }
1977      }      }
1978      s = get_filename_dlg( c->dlg, FILE_SAVE, _("Choose a Name for the Archive"),      s = get_filesave_dlg (c->dlg, _("Choose a Name for the Archive"),
1979                            NULL, default_dirname( name ) );                            NULL, default_dirname (name));
1980      if( !s ) {      if (!s) {
1981          msg_box( c->dlg, _("Invalid archive name. Exit."), _("Encrypt Directory"), MB_ERR );          msg_box (c->dlg, _("Invalid archive name. Exit."),
1982                     _("Encrypt Directory"), MB_ERR);
1983          rc = -1;          rc = -1;
1984          goto leave;          goto leave;
1985      }      }
1986    
1987      rc = pk_archiv_create( list, s );      rc = pk_archiv_create (list, s);
1988      if( rc )      if (rc)
1989          msg_box( c->dlg, _("Could not create zip archive."), _("Encrypt Directory"), MB_ERR );          msg_box (c->dlg, _("Could not create zip archive."),
1990                     _("Encrypt Directory"), MB_ERR);
1991      else {      else {
1992          fm_encrypt( c, s, 0 );          fm_encrypt (c, s, 0);
1993          unlink( s );          DeleteFile (s);
1994      }      }
1995  leave:  leave:
1996      FindClose (hd);      FindClose (hd);
1997      pk_list_free( list );      pk_list_free (list);
1998      free_if_alloc( patt );      free_if_alloc (patt);
1999      return rc;      return rc;
2000  } /* fm_encrypt_directory */  }
2001    
2002    
2003  static int CALLBACK  static int CALLBACK
2004  fm_cmp_cb( LPARAM first, LPARAM second, LPARAM sortby )  fm_cmp_cb (LPARAM first, LPARAM second, LPARAM sortby)
2005  {  {
2006      const char * a = 0, * b = 0;      fm_model_t a, b;
2007        int cmpres = 0;
2008    
2009      switch( (int)sortby ) {      a = (fm_model_t)first;
2010      case FM_SORT_STAT:      b = (fm_model_t)second;
2011        if (!a || !b)
2012            return 0;
2013    
2014        switch ((int)sortby) {
2015        case FM_COL_STAT:
2016            cmpres = stricmp (a->status, b->status);
2017          break;          break;
2018      case FM_SORT_NAME:  
2019        case FM_COL_NAME:
2020            cmpres = stricmp (a->name, b->name);
2021          break;          break;
2022      case FM_SORT_OP:  
2023        case FM_COL_OP:
2024            if (a->op && b->op)
2025                cmpres = stricmp (a->op, b->op);
2026          break;          break;
2027      }      }
2028      return stricmp( a, b );      return cmpres;
2029  } /* fm_cmp_cb */  }
2030            
2031    
2032    /* Sort the list items from @lv with the mode given by @sortby. */
2033  int  int
2034  fm_sort( listview_ctrl_t lv, int sortby )  fm_sort (listview_ctrl_t lv, int sortby)
2035  {  {
2036      return listview_sort_items( lv, sortby, fm_cmp_cb );      return ListView_SortItems (lv->ctrl, fm_cmp_cb, (LPARAM)sortby);
2037  } /* fm_sort */  }
2038    
2039    
2040    /* Start the 'print md' dialog. Pass over the listview control
2041       @lv and the digest algo @mdalgo. */
2042  void  void
2043  fm_print_md( listview_ctrl_t lv, HWND dlg, int mdalgo )  fm_print_md (listview_ctrl_t lv, HWND dlg, int mdalgo)
2044  {  {
2045      struct md_file_s mdctx;      struct md_file_s mdctx;
2046    
2047      if( listview_count_items( lv, 0 ) == 0 )      if (listview_count_items (lv, 0) == 0)
2048          return;          return;
2049      memset (&mdctx, 0, sizeof (mdctx));      memset (&mdctx, 0, sizeof (mdctx));
2050      mdctx.lv = lv;      mdctx.lv = lv;
2051      mdctx.mdalgo = mdalgo;      mdctx.mdalgo = mdalgo;
2052      DialogBoxParam( glob_hinst, (LPCTSTR)IDD_WINPT_FILE_MDSUM, dlg,      DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_FILE_MDSUM, dlg,
2053                      mdsum_dlg_proc, (LPARAM)&mdctx );                      mdsum_dlg_proc, (LPARAM)&mdctx);
2054  } /* fm_print_md */  }
2055    
2056    
2057    /* Send the selected file in @lv via MAPI to a mail recipient. */
2058  int  int
2059  fm_send_file (listview_ctrl_t lv)  fm_send_file (listview_ctrl_t lv)
2060  {  {
2061      char buf[128];      char name[128];
2062      int rc;      int rc;
2063    
2064      rc = listview_get_item_text (lv, -1, 1, buf, sizeof (buf)-1);      rc = listview_get_item_text (lv, -1, FM_COL_NAME, name, sizeof (name)-1);
2065      if (rc == -1)      if (rc != -1)
2066          return 0;          mapi_send_ascfile (name);
     /*mapi_send_ascfile (buf); XXX */  
2067      return 0;      return 0;
2068  }  }
Legend:
Removed from v.42  
changed lines
  Added in v.256
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26