trunk/Src/wptClipEncryptDlg.cpp

/* wptClipEncryptDlg.cpp - Clipboard encrypt dialog
 *      Copyright (C) 2000-2006 Timo Schulz
 *      Copyright (C) 2005 g10 Code GmbH
 *
 * This file is part of WinPT.
 *
 * WinPT is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * WinPT is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with WinPT; if not, write to the Free Software Foundation, 
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <windows.h>
#include <commctrl.h>

#include "resource.h"
#include "wptTypes.h"
#include "wptW32API.h"
#include "wptVersion.h"
#include "wptErrors.h"
#include "wptCommonCtl.h"
#include "wptGPG.h"
#include "wptKeylist.h"
#include "wptNLS.h"
#include "wptContext.h" /* for passphrase_s */
#include "wptRegistry.h"
#include "wptDlgs.h"
#include "wptUTF8.h"
#include "StringBuffer.h"


/* Encrypt the contents of the clipboard with the keys in @rset.
   If @always_trust is set, GPG is forced to trust any recipients.
   The context is returned in @r_ctx.
   Return value: 0 on success. */
gpgme_error_t
gpg_clip_encrypt (gpgme_key_t rset[], int always_trust, gpgme_ctx_t *r_ctx)
{
    gpgme_error_t err;
    gpgme_encrypt_flags_t flags;
    gpgme_ctx_t ctx = NULL;
    gpgme_data_t plain = NULL;
    gpgme_data_t ciph = NULL;
    
    err = gpgme_new (&ctx);
    if (err)
        return err;

    /* Recently a lot of users got in trouble because they enabled
       the textmode even for non-text (binary) data. This leads to
       serious trouble. But because our clipboard functions only support
       the text format, the returned data is pure text or at least a 
       conversion of it so we can safely use the textmode here. */
    gpgme_set_textmode (ctx, 1);
    gpgme_set_armor (ctx, 1);
    
    err = gpg_data_new_from_clipboard (&plain, 0);
    if (err)
        goto leave;
    err = gpgme_data_new (&ciph);
    if (err)
        goto leave;
    flags = always_trust? GPGME_ENCRYPT_ALWAYS_TRUST : (gpgme_encrypt_flags_t)0;
    err = gpgme_op_encrypt (ctx, rset, flags, plain, ciph);
    *r_ctx = ctx;
    if (err)
        goto leave;
    
    gpg_data_release_and_set_clipboard (ciph, 1);
    ciph = NULL;

leave:
    if (ciph)
        gpgme_data_release (ciph);
    gpgme_data_release (plain);
    return err;
}


/* Show all invalid recipients if possible. @dlg is the 
   handle to the calling dialog and @ctx is the context
   used for encryption.
   Return value: 0 if invalid recipients exist -1 otherwise. */
static int
show_invalid_recipients (HWND dlg, gpgme_ctx_t ctx)
{
    gpgme_encrypt_result_t res;
    gpgme_invalid_key_t k;
    gpgme_key_t key;
    StringBuffer p;
    size_t len=0;
    const char *keyid;
    const char *warn = _("key not found");
    char *uid;

    if (!ctx)
        return -1;
    res = gpgme_op_encrypt_result (ctx);
    if (!res || !res->invalid_recipients)
        return -1;

    for (k=res->invalid_recipients; k; k = k->next) {
        if (!get_pubkey (k->fpr, &key))
            len += (32 + strlen (k->fpr)+8 + strlen (key->uids->name) + 2) + 4;
        else
            len += strlen (warn) + strlen (k->fpr)+8 + 2 + 4;
    }

    p = _("Recipients unsuable for encryption:\n");
    for (k = res->invalid_recipients; k; k = k->next) {
        if (!get_pubkey (k->fpr, &key)) {
            uid = utf8_to_native (key->uids->name);
            keyid = key->subkeys->keyid+8;
        }
        else {
            uid = strdup (warn);
            keyid = k->fpr;
        }
        p = p + keyid + " : " + uid + "\n";
        safe_free (uid);
    }
    msg_box (dlg, p.getBuffer (), _("Encryption"), MB_ERR);
    return 0;
}


/* Dialog procedure for the clipboard encryption. */
BOOL CALLBACK 
clip_encrypt_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    static listview_ctrl_t lv = NULL;
    static int keys_sortby = 0;
    gpg_keycache_t kc;
    gpgme_key_t *rset;
    gpgme_ctx_t ctx=NULL;
    gpgme_error_t err;
    char tmpbuf[64];
    size_t n;
    int force_trust = 0;    
    
    switch (msg) {
    case WM_INITDIALOG:
        SetWindowText (dlg, _("Encryption"));
        SetDlgItemText (dlg, IDC_ENCRYPT_FNDCMD, _("&Find"));
        SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));
        kc = keycache_get_ctx (KEYCACHE_PUB);
        lv = keylist_load (GetDlgItem (dlg, IDC_ENCRYPT_KEYLIST), kc, NULL,
                           KEYLIST_ENCRYPT_MIN, KEY_SORT_USERID);
        center_window (dlg, NULL);
        SetForegroundWindow (dlg);
        return TRUE;
        
    case WM_DESTROY:
        if (lv) {
            keylist_delete (lv);
            lv = NULL;
        }
        return FALSE;
        
    case WM_NOTIFY:
        NMHDR *notify;
        
        notify = (NMHDR *)lparam;
        if (notify && notify->code == NM_DBLCLK && 
            notify->idFrom == IDC_ENCRYPT_KEYLIST)
            PostMessage( dlg, WM_COMMAND, MAKEWPARAM (IDOK, 0), 0);
        if (notify && notify->code == LVN_COLUMNCLICK && 
            notify->idFrom == IDC_ENCRYPT_KEYLIST) {
            NMLISTVIEW *p = (LPNMLISTVIEW) lparam;
            int sortby = 0;

            switch (p->iSubItem) {
            case  0: sortby = KEY_SORT_USERID; break;
            case  1: sortby = KEY_SORT_KEYID; break;
            case  2: sortby = KEY_SORT_LEN; break;
            case  4: sortby = KEY_SORT_VALIDITY; break;
            default: sortby = KEY_SORT_USERID; break;
            }
            if ((keys_sortby & ~KEYLIST_SORT_DESC) == sortby)
                keys_sortby ^= KEYLIST_SORT_DESC;
            else
                keys_sortby = sortby;
            keylist_sort (lv, keys_sortby);
        }
        return TRUE;
        
    case WM_COMMAND:
        switch (LOWORD (wparam)) {
        case IDOK:
            rset = keylist_get_recipients (lv, &force_trust, &n);
            if (!n) {
                msg_box (dlg, _("You must select at least one key."), 
                         _("Encryption"), MB_ERR);
                safe_free (rset);
                return FALSE;
            }
            err = gpg_clip_encrypt (rset, force_trust, &ctx);
            if (err) {
                if (show_invalid_recipients (dlg, ctx))
                    msg_box (dlg, gpgme_strerror (err), _("Encryption"), MB_ERR);
            }
            else
                show_msg (dlg, 1500, _("GnuPG Status: Finished"));
            safe_free (rset);
            if (ctx)
                gpgme_release (ctx);
            if (!err)
                EndDialog (dlg, TRUE);
            return TRUE;
            
        case IDCANCEL:
            EndDialog (dlg, FALSE);
            return FALSE;

        case IDC_ENCRYPT_FNDCMD:
            n = GetDlgItemText (dlg, IDC_ENCRYPT_FIND, tmpbuf, DIM (tmpbuf)-1);
            if (!n)
                break;
            n = listview_find (lv, tmpbuf, 0);
            if (n != -1) {
                int oldpos = listview_get_curr_pos (lv);
                listview_select_one (lv, n);
                listview_scroll (lv, oldpos, n);
            }
            else
                log_box (_("Encryption"), MB_ERR, 
                         _("No recipient found with '%s'"), tmpbuf);
            break;
        }
        break;
    }
    
    return FALSE;
}

1	werner	36	/* wptClipEncryptDlg.cpp - Clipboard encrypt dialog
2	twoaday	220	* Copyright (C) 2000-2006 Timo Schulz
3	werner	36	* Copyright (C) 2005 g10 Code GmbH
4			*
5			* This file is part of WinPT.
6			*
7			* WinPT is free software; you can redistribute it and/or modify
8			* it under the terms of the GNU General Public License as published by
9			* the Free Software Foundation; either version 2 of the License, or
10			* (at your option) any later version.
11			*
12			* WinPT is distributed in the hope that it will be useful,
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			* GNU General Public License for more details.
16			*
17			* You should have received a copy of the GNU General Public License
18			* along with WinPT; if not, write to the Free Software Foundation,
19			* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20			*/
21	twoaday	197
22	werner	36	#ifdef HAVE_CONFIG_H
23			#include <config.h>
24			#endif
25
26			#include <windows.h>
27			#include <commctrl.h>
28
29	werner	47	#include "resource.h"
30	werner	36	#include "wptTypes.h"
31			#include "wptW32API.h"
32			#include "wptVersion.h"
33			#include "wptErrors.h"
34			#include "wptCommonCtl.h"
35			#include "wptGPG.h"
36			#include "wptKeylist.h"
37			#include "wptNLS.h"
38			#include "wptContext.h" /* for passphrase_s */
39			#include "wptRegistry.h"
40			#include "wptDlgs.h"
41	twoaday	197	#include "wptUTF8.h"
42	twoaday	278	#include "StringBuffer.h"
43	werner	36
44
45			/* Encrypt the contents of the clipboard with the keys in @rset.
46			If @always_trust is set, GPG is forced to trust any recipients.
47			The context is returned in @r_ctx.
48			Return value: 0 on success. */
49			gpgme_error_t
50			gpg_clip_encrypt (gpgme_key_t rset[], int always_trust, gpgme_ctx_t *r_ctx)
51			{
52			gpgme_error_t err;
53	twoaday	256	gpgme_encrypt_flags_t flags;
54	werner	36	gpgme_ctx_t ctx = NULL;
55			gpgme_data_t plain = NULL;
56			gpgme_data_t ciph = NULL;
57
58			err = gpgme_new (&ctx);
59			if (err)
60			return err;
61	twoaday	273
62			/* Recently a lot of users got in trouble because they enabled
63			the textmode even for non-text (binary) data. This leads to
64			serious trouble. But because our clipboard functions only support
65			the text format, the returned data is pure text or at least a
66			conversion of it so we can safely use the textmode here. */
67			gpgme_set_textmode (ctx, 1);
68	werner	36	gpgme_set_armor (ctx, 1);
69
70			err = gpg_data_new_from_clipboard (&plain, 0);
71			if (err)
72			goto leave;
73			err = gpgme_data_new (&ciph);
74			if (err)
75	twoaday	197	goto leave;
76	twoaday	256	flags = always_trust? GPGME_ENCRYPT_ALWAYS_TRUST : (gpgme_encrypt_flags_t)0;
77			err = gpgme_op_encrypt (ctx, rset, flags, plain, ciph);
78	werner	36	*r_ctx = ctx;
79			if (err)
80			goto leave;
81
82			gpg_data_release_and_set_clipboard (ciph, 1);
83			ciph = NULL;
84
85			leave:
86			if (ciph)
87			gpgme_data_release (ciph);
88			gpgme_data_release (plain);
89			return err;
90			}
91
92
93			/* Show all invalid recipients if possible. @dlg is the
94			handle to the calling dialog and @ctx is the context
95			used for encryption.
96			Return value: 0 if invalid recipients exist -1 otherwise. */
97			static int
98			show_invalid_recipients (HWND dlg, gpgme_ctx_t ctx)
99			{
100			gpgme_encrypt_result_t res;
101			gpgme_invalid_key_t k;
102			gpgme_key_t key;
103	twoaday	278	StringBuffer p;
104	werner	36	size_t len=0;
105	twoaday	225	const char *keyid;
106			const char *warn = _("key not found");
107	twoaday	278	char *uid;
108	werner	36
109			if (!ctx)
110			return -1;
111			res = gpgme_op_encrypt_result (ctx);
112			if (!res \|\| !res->invalid_recipients)
113			return -1;
114
115			for (k=res->invalid_recipients; k; k = k->next) {
116	twoaday	225	if (!get_pubkey (k->fpr, &key))
117			len += (32 + strlen (k->fpr)+8 + strlen (key->uids->name) + 2) + 4;
118			else
119			len += strlen (warn) + strlen (k->fpr)+8 + 2 + 4;
120	werner	36	}
121
122	twoaday	278	p = _("Recipients unsuable for encryption:\n");
123	werner	36	for (k = res->invalid_recipients; k; k = k->next) {
124	twoaday	225	if (!get_pubkey (k->fpr, &key)) {
125			uid = utf8_to_native (key->uids->name);
126			keyid = key->subkeys->keyid+8;
127			}
128			else {
129			uid = strdup (warn);
130			keyid = k->fpr;
131			}
132	twoaday	278	p = p + keyid + " : " + uid + "\n";
133	twoaday	197	safe_free (uid);
134	werner	36	}
135	twoaday	278	msg_box (dlg, p.getBuffer (), _("Encryption"), MB_ERR);
136	werner	36	return 0;
137			}
138
139
140			/* Dialog procedure for the clipboard encryption. */
141			BOOL CALLBACK
142			clip_encrypt_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
143			{
144			static listview_ctrl_t lv = NULL;
145	twoaday	236	static int keys_sortby = 0;
146	werner	36	gpg_keycache_t kc;
147			gpgme_key_t *rset;
148			gpgme_ctx_t ctx=NULL;
149			gpgme_error_t err;
150	twoaday	256	char tmpbuf[64];
151	twoaday	260	size_t n;
152			int force_trust = 0;
153	werner	36
154	twoaday	197	switch (msg) {
155	werner	36	case WM_INITDIALOG:
156	twoaday	105	SetWindowText (dlg, _("Encryption"));
157			SetDlgItemText (dlg, IDC_ENCRYPT_FNDCMD, _("&Find"));
158			SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));
159	twoaday	197	kc = keycache_get_ctx (KEYCACHE_PUB);
160			lv = keylist_load (GetDlgItem (dlg, IDC_ENCRYPT_KEYLIST), kc, NULL,
161	twoaday	176	KEYLIST_ENCRYPT_MIN, KEY_SORT_USERID);
162	twoaday	197	center_window (dlg, NULL);
163			SetForegroundWindow (dlg);
164	werner	36	return TRUE;
165
166			case WM_DESTROY:
167	twoaday	220	if (lv) {
168			keylist_delete (lv);
169	werner	36	lv = NULL;
170			}
171			return FALSE;
172
173			case WM_NOTIFY:
174			NMHDR *notify;
175
176			notify = (NMHDR *)lparam;
177			if (notify && notify->code == NM_DBLCLK &&
178			notify->idFrom == IDC_ENCRYPT_KEYLIST)
179	twoaday	256	PostMessage( dlg, WM_COMMAND, MAKEWPARAM (IDOK, 0), 0);
180	werner	36	if (notify && notify->code == LVN_COLUMNCLICK &&
181	twoaday	236	notify->idFrom == IDC_ENCRYPT_KEYLIST) {
182	werner	36	NMLISTVIEW *p = (LPNMLISTVIEW) lparam;
183			int sortby = 0;
184
185	twoaday	220	switch (p->iSubItem) {
186	werner	36	case 0: sortby = KEY_SORT_USERID; break;
187			case 1: sortby = KEY_SORT_KEYID; break;
188			case 2: sortby = KEY_SORT_LEN; break;
189			case 4: sortby = KEY_SORT_VALIDITY; break;
190			default: sortby = KEY_SORT_USERID; break;
191			}
192	twoaday	236	if ((keys_sortby & ~KEYLIST_SORT_DESC) == sortby)
193			keys_sortby ^= KEYLIST_SORT_DESC;
194			else
195			keys_sortby = sortby;
196			keylist_sort (lv, keys_sortby);
197	werner	36	}
198			return TRUE;
199
200			case WM_COMMAND:
201	twoaday	236	switch (LOWORD (wparam)) {
202	werner	36	case IDOK:
203			rset = keylist_get_recipients (lv, &force_trust, &n);
204			if (!n) {
205	twoaday	197	msg_box (dlg, _("You must select at least one key."),
206			_("Encryption"), MB_ERR);
207			safe_free (rset);
208	werner	36	return FALSE;
209			}
210			err = gpg_clip_encrypt (rset, force_trust, &ctx);
211			if (err) {
212			if (show_invalid_recipients (dlg, ctx))
213			msg_box (dlg, gpgme_strerror (err), _("Encryption"), MB_ERR);
214			}
215			else
216	twoaday	220	show_msg (dlg, 1500, _("GnuPG Status: Finished"));
217			safe_free (rset);
218			if (ctx)
219			gpgme_release (ctx);
220			if (!err)
221			EndDialog (dlg, TRUE);
222	werner	36	return TRUE;
223
224			case IDCANCEL:
225	twoaday	220	EndDialog (dlg, FALSE);
226	werner	36	return FALSE;
227
228			case IDC_ENCRYPT_FNDCMD:
229			n = GetDlgItemText (dlg, IDC_ENCRYPT_FIND, tmpbuf, DIM (tmpbuf)-1);
230			if (!n)
231			break;
232	twoaday	241	n = listview_find (lv, tmpbuf, 0);
233	twoaday	256	if (n != -1) {
234	werner	36	int oldpos = listview_get_curr_pos (lv);
235			listview_select_one (lv, n);
236			listview_scroll (lv, oldpos, n);
237			}
238			else
239	twoaday	256	log_box (_("Encryption"), MB_ERR,
240			_("No recipient found with '%s'"), tmpbuf);
241	werner	36	break;
242			}
243			break;
244			}
245
246			return FALSE;
247			}
248