trunk/Src/wptClipboard.cpp

/* wptClipboard.cpp
 *      Copyright (C) 2001, 2002, 2003, 2005 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 <gpgme.h>

#include "wptW32API.h"
#include "wptCrypto.h"
#include "wptVersion.h"
#include "wptGPG.h"

gpgme_error_t gpg_data_wrap_lines (gpgme_data_t *r_dh, size_t wraplen);

/* XXX: define clipboard errors. */

/* Check if the clipboard contains text. @r_val contains
   one text data is available.
   Return value: 0 on success. */
gpgme_error_t
gpg_clip_istext_avail (int *r_val)
{    
    HANDLE clipmem;
    char *clipdata;
    
    if (!r_val)
        return gpg_error (GPG_ERR_INV_ARG);
    if (OpenClipboard (NULL) == FALSE)
        return gpg_error (GPG_ERR_NO_DATA);
    
    *r_val = 0;
    clipmem = GetClipboardData (CF_TEXT);
    if (!clipmem)
        goto leave;

    clipdata = (char *) GlobalLock (clipmem);
    if (!clipdata)
        goto leave;
    if (strlen (clipdata) > 0)
        *r_val = 1;
    GlobalUnlock (clipmem);

leave:
    CloseClipboard ();
    return 0;
}


/* Figure out what kind of PGP data is stored in @data.
   @r_type contains the ORed types on success.
   Return value: 0 on success. */
gpgme_error_t
gpg_clip_parse_pgpid (const char *data, int *r_type)
{
    int type;

    if (!data)
        return gpg_error (GPG_ERR_INV_ARG);
    if (strlen (data) < 19) {
        *r_type = 0;
        return 0;
    }
    type = 0;
    if (strstr( data, "BEGIN PGP MESSAGE") )
        type |= PGP_MESSAGE;
    if (strstr (data, "BEGIN PGP SIGNED MESSAGE"))
        type |= PGP_CLEARSIG;
    if (strstr (data, "BEGIN PGP SIGNATURE"))
        type |= PGP_SIG;
    if (strstr (data, "BEGIN PGP PUBLIC KEY BLOCK"))
        type |= PGP_PUBKEY;
    if (strstr (data, "BEGIN PGP PRIVATE KEY BLOCK") 
        || strstr (data, "BEGIN PGP SECRET KEY BLOCK"))
        type |= PGP_SECKEY;
    if (strstr (data, "- -----BEGIN"))
        type |= PGP_DASH_ESCAPED;
    *r_type = type;
    return 0;
}


/* Check if the clipboard is already OpenPGP protected.
   @r_type optional returns the type and @r_val contains
   1 for yes.
   Return value: 0 on success. */
gpgme_error_t
gpg_clip_is_secured (int *r_type, int *r_val)
{
    int rc = 0;
    HANDLE clipmem;
    char *clipdata;
    
    if (!r_val)
        return gpg_error (GPG_ERR_INV_ARG);
    if( OpenClipboard (NULL) == FALSE )
        return gpg_error (GPG_ERR_INTERNAL);
    clipmem = GetClipboardData( CF_TEXT );
    if( !clipmem ) {
        *r_val = 0;
        goto leave;
    }
    clipdata = (char *) GlobalLock( clipmem );
    if (!clipdata) {
        *r_val = 0;     
        goto leave;     
    }
    if (strstr (clipdata, "-----BEGIN PGP") 
        && strstr (clipdata, "-----END PGP"))
        *r_val = 1;
    GlobalUnlock (clipmem);
    gpg_clip_parse_pgpid (clipdata, r_type);

leave:
    CloseClipboard ();
    return rc;
}


gpgme_error_t
gpg_clip_get_pgptype (int *r_type)
{
    gpgme_error_t rc = 0;
    HANDLE clipmem;
    char *clipdata;
    
    if (OpenClipboard (NULL) == FALSE)
        return gpg_error (GPG_ERR_INTERNAL);
    clipmem = GetClipboardData (CF_TEXT);
    if (!clipmem) {
        rc = gpg_error (GPG_ERR_NO_DATA);
        goto leave;
    }
    clipdata = (char *)GlobalLock( clipmem );
    if (!clipdata) {
        rc = gpg_error (GPG_ERR_NO_DATA);
        goto leave;
    }    
    gpg_clip_parse_pgpid (clipdata, r_type);
    GlobalUnlock (clipmem);
    
leave:
    CloseClipboard ();
    return rc;
}


/* Retrieve the thext of the clipboard.
   Return value: the text as a string, NULL otherwise. */
static char*
get_w32_clip_text (void)
{
    char *private_clip = NULL;
    char *clip = NULL;
    size_t size;
    HANDLE cb;
    
    if (!OpenClipboard (NULL))
        return NULL;
    cb = GetClipboardData (CF_TEXT);
    if (!cb)
        goto leave;
    private_clip = (char *)GlobalLock (cb);
    if (!private_clip)
        goto leave;
    size = strlen (private_clip);
    clip = (char*)malloc (size + 1);
    if (!clip) {
        GlobalUnlock (cb);
        goto leave;
    }
    memcpy (clip, private_clip, size);
    clip[size] = '\0';
    GlobalUnlock(cb);
    
leave:
    CloseClipboard ();
    return clip;
}


/* Set the new clipboard data to @data. */
static void
set_w32_clip_text (const char *data, int size)
{
    HANDLE cb;
    char *private_data;
    
    if (!OpenClipboard(NULL))
        return;
    EmptyClipboard ();
    cb = GlobalAlloc (GHND, size+1);
    if (!cb)
        goto leave;
    private_data = (char*)GlobalLock (cb);
    if (!private_data)
        goto leave;
    memcpy (private_data, data, size);
    private_data[size] = '\0';
    SetClipboardData (CF_TEXT, cb);
    GlobalUnlock (cb);
    
leave:    
    CloseClipboard ();
    GlobalFree (cb);
}


/* Retrieve the clipboard data and create a new gpgme
   data object @r_dh and return it. If @wraplen is > 0
   wrap lines of the buffer.
   Return value: 0 on success. */
gpgme_error_t
gpg_data_new_from_clipboard (gpgme_data_t *r_dh, int wraplen)
{
    gpgme_error_t err = 0;
    gpgme_data_t dh;
    char *clip_text = NULL;

    if (!r_dh)
        return gpg_error (GPG_ERR_INV_ARG);
    *r_dh = NULL;
    clip_text = get_w32_clip_text ();
    if (!clip_text)
        return gpg_error (GPG_ERR_NO_DATA);
    err = gpgme_data_new_from_mem (&dh, clip_text, strlen (clip_text), 1);
    if (clip_text)
        free (clip_text);
    if (wraplen > 0)
        gpg_data_wrap_lines (&dh, wraplen);
    
    *r_dh = dh;
    return err;
}


/* Search for the armor header 'Version:' in @r_dh and
   add the WinPT version. On success @r_dh is replaced
   with the modified data.
   Return value: 0 on success. */
static gpgme_error_t
gpg_data_change_version (gpgme_data_t *r_dh)
{
    gpgme_error_t err = 0;
    gpgme_data_t mdh;
    char line[128+32];
    int n;

    if (!r_dh)
        return gpg_error (GPG_ERR_INV_ARG);
    
    err = gpgme_data_new (&mdh);
    if (err)
        return err;

    gpgme_data_rewind (*r_dh);
    while ((n=gpg_data_readline (*r_dh, line, 128)) > 0) {
        if (strlen (line) > 14 &&
            !strncmp (line, "Version: GnuPG", 14)  &&
            !strstr (line, "WinPT "PGM_VERSION)) {
            line[strlen (line) - 2] = '\0';
            strcat (line, " - " );
            strcat (line, "WinPT "PGM_VERSION);
            strcat (line, "\r\n");
        }
        gpgme_data_write (mdh, line, strlen (line));
    }

    gpgme_data_write (mdh, "", 1);
    gpgme_data_rewind (mdh);
    gpgme_data_release (*r_dh);
    *r_dh = mdh;
    return err;
}

/* Release a gpgme data object @dh and write the contents of
   the object to the clipboard. If @chg_ver is set, modify the
   Version: header and add WinPT information. */
void
gpg_data_release_and_set_clipboard (gpgme_data_t dh, int chg_ver)
{
    gpgme_data_t in;
    char *clip_text;
    size_t n;
    
    if (!dh)
        return;

    in = dh;
    if (chg_ver)
        gpg_data_change_version (&in);

    clip_text = gpgme_data_release_and_get_mem (in, &n);
    if (clip_text && *clip_text) {
        set_w32_clip_text (clip_text, n);
        memset (clip_text, 0xFF, n);
        gpgme_free (clip_text);
    }
}
1	/* wptClipboard.cpp
2	* Copyright (C) 2001, 2002, 2003, 2005 Timo Schulz
3	* 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
22	#ifdef HAVE_CONFIG_H
23	#include <config.h>
24	#endif
25
26	#include <windows.h>
27	#include <gpgme.h>
28
29	#include "wptW32API.h"
30	#include "wptCrypto.h"
31	#include "wptVersion.h"
32	#include "wptGPG.h"
33
34	gpgme_error_t gpg_data_wrap_lines (gpgme_data_t *r_dh, size_t wraplen);
35
36	/* XXX: define clipboard errors. */
37
38	/* Check if the clipboard contains text. @r_val contains
39	one text data is available.
40	Return value: 0 on success. */
41	gpgme_error_t
42	gpg_clip_istext_avail (int *r_val)
43	{
44	HANDLE clipmem;
45	char *clipdata;
46
47	if (!r_val)
48	return gpg_error (GPG_ERR_INV_ARG);
49	if (OpenClipboard (NULL) == FALSE)
50	return gpg_error (GPG_ERR_NO_DATA);
51
52	*r_val = 0;
53	clipmem = GetClipboardData (CF_TEXT);
54	if (!clipmem)
55	goto leave;
56
57	clipdata = (char *) GlobalLock (clipmem);
58	if (!clipdata)
59	goto leave;
60	if (strlen (clipdata) > 0)
61	*r_val = 1;
62	GlobalUnlock (clipmem);
63
64	leave:
65	CloseClipboard ();
66	return 0;
67	}
68
69
70	/* Figure out what kind of PGP data is stored in @data.
71	@r_type contains the ORed types on success.
72	Return value: 0 on success. */
73	gpgme_error_t
74	gpg_clip_parse_pgpid (const char data, int r_type)
75	{
76	int type;
77
78	if (!data)
79	return gpg_error (GPG_ERR_INV_ARG);
80	if (strlen (data) < 19) {
81	*r_type = 0;
82	return 0;
83	}
84	type = 0;
85	if (strstr( data, "BEGIN PGP MESSAGE") )
86	type \|= PGP_MESSAGE;
87	if (strstr (data, "BEGIN PGP SIGNED MESSAGE"))
88	type \|= PGP_CLEARSIG;
89	if (strstr (data, "BEGIN PGP SIGNATURE"))
90	type \|= PGP_SIG;
91	if (strstr (data, "BEGIN PGP PUBLIC KEY BLOCK"))
92	type \|= PGP_PUBKEY;
93	if (strstr (data, "BEGIN PGP PRIVATE KEY BLOCK")
94	\|\| strstr (data, "BEGIN PGP SECRET KEY BLOCK"))
95	type \|= PGP_SECKEY;
96	if (strstr (data, "- -----BEGIN"))
97	type \|= PGP_DASH_ESCAPED;
98	*r_type = type;
99	return 0;
100	}
101
102
103	/* Check if the clipboard is already OpenPGP protected.
104	@r_type optional returns the type and @r_val contains
105	1 for yes.
106	Return value: 0 on success. */
107	gpgme_error_t
108	gpg_clip_is_secured (int r_type, int r_val)
109	{
110	int rc = 0;
111	HANDLE clipmem;
112	char *clipdata;
113
114	if (!r_val)
115	return gpg_error (GPG_ERR_INV_ARG);
116	if( OpenClipboard (NULL) == FALSE )
117	return gpg_error (GPG_ERR_INTERNAL);
118	clipmem = GetClipboardData( CF_TEXT );
119	if( !clipmem ) {
120	*r_val = 0;
121	goto leave;
122	}
123	clipdata = (char *) GlobalLock( clipmem );
124	if (!clipdata) {
125	*r_val = 0;
126	goto leave;
127	}
128	if (strstr (clipdata, "-----BEGIN PGP")
129	&& strstr (clipdata, "-----END PGP"))
130	*r_val = 1;
131	GlobalUnlock (clipmem);
132	gpg_clip_parse_pgpid (clipdata, r_type);
133
134	leave:
135	CloseClipboard ();
136	return rc;
137	}
138
139
140	gpgme_error_t
141	gpg_clip_get_pgptype (int *r_type)
142	{
143	gpgme_error_t rc = 0;
144	HANDLE clipmem;
145	char *clipdata;
146
147	if (OpenClipboard (NULL) == FALSE)
148	return gpg_error (GPG_ERR_INTERNAL);
149	clipmem = GetClipboardData (CF_TEXT);
150	if (!clipmem) {
151	rc = gpg_error (GPG_ERR_NO_DATA);
152	goto leave;
153	}
154	clipdata = (char *)GlobalLock( clipmem );
155	if (!clipdata) {
156	rc = gpg_error (GPG_ERR_NO_DATA);
157	goto leave;
158	}
159	gpg_clip_parse_pgpid (clipdata, r_type);
160	GlobalUnlock (clipmem);
161
162	leave:
163	CloseClipboard ();
164	return rc;
165	}
166
167
168	/* Retrieve the thext of the clipboard.
169	Return value: the text as a string, NULL otherwise. */
170	static char*
171	get_w32_clip_text (void)
172	{
173	char *private_clip = NULL;
174	char *clip = NULL;
175	size_t size;
176	HANDLE cb;
177
178	if (!OpenClipboard (NULL))
179	return NULL;
180	cb = GetClipboardData (CF_TEXT);
181	if (!cb)
182	goto leave;
183	private_clip = (char *)GlobalLock (cb);
184	if (!private_clip)
185	goto leave;
186	size = strlen (private_clip);
187	clip = (char*)malloc (size + 1);
188	if (!clip) {
189	GlobalUnlock (cb);
190	goto leave;
191	}
192	memcpy (clip, private_clip, size);
193	clip[size] = '\0';
194	GlobalUnlock(cb);
195
196	leave:
197	CloseClipboard ();
198	return clip;
199	}
200
201
202	/* Set the new clipboard data to @data. */
203	static void
204	set_w32_clip_text (const char *data, int size)
205	{
206	HANDLE cb;
207	char *private_data;
208
209	if (!OpenClipboard(NULL))
210	return;
211	EmptyClipboard ();
212	cb = GlobalAlloc (GHND, size+1);
213	if (!cb)
214	goto leave;
215	private_data = (char*)GlobalLock (cb);
216	if (!private_data)
217	goto leave;
218	memcpy (private_data, data, size);
219	private_data[size] = '\0';
220	SetClipboardData (CF_TEXT, cb);
221	GlobalUnlock (cb);
222
223	leave:
224	CloseClipboard ();
225	GlobalFree (cb);
226	}
227
228
229	/* Retrieve the clipboard data and create a new gpgme
230	data object @r_dh and return it. If @wraplen is > 0
231	wrap lines of the buffer.
232	Return value: 0 on success. */
233	gpgme_error_t
234	gpg_data_new_from_clipboard (gpgme_data_t *r_dh, int wraplen)
235	{
236	gpgme_error_t err = 0;
237	gpgme_data_t dh;
238	char *clip_text = NULL;
239
240	if (!r_dh)
241	return gpg_error (GPG_ERR_INV_ARG);
242	*r_dh = NULL;
243	clip_text = get_w32_clip_text ();
244	if (!clip_text)
245	return gpg_error (GPG_ERR_NO_DATA);
246	err = gpgme_data_new_from_mem (&dh, clip_text, strlen (clip_text), 1);
247	if (clip_text)
248	free (clip_text);
249	if (wraplen > 0)
250	gpg_data_wrap_lines (&dh, wraplen);
251
252	*r_dh = dh;
253	return err;
254	}
255
256
257	/* Search for the armor header 'Version:' in @r_dh and
258	add the WinPT version. On success @r_dh is replaced
259	with the modified data.
260	Return value: 0 on success. */
261	static gpgme_error_t
262	gpg_data_change_version (gpgme_data_t *r_dh)
263	{
264	gpgme_error_t err = 0;
265	gpgme_data_t mdh;
266	char line[128+32];
267	int n;
268
269	if (!r_dh)
270	return gpg_error (GPG_ERR_INV_ARG);
271
272	err = gpgme_data_new (&mdh);
273	if (err)
274	return err;
275
276	gpgme_data_rewind (*r_dh);
277	while ((n=gpg_data_readline (*r_dh, line, 128)) > 0) {
278	if (strlen (line) > 14 &&
279	!strncmp (line, "Version: GnuPG", 14) &&
280	!strstr (line, "WinPT "PGM_VERSION)) {
281	line[strlen (line) - 2] = '\0';
282	strcat (line, " - " );
283	strcat (line, "WinPT "PGM_VERSION);
284	strcat (line, "\r\n");
285	}
286	gpgme_data_write (mdh, line, strlen (line));
287	}
288
289	gpgme_data_write (mdh, "", 1);
290	gpgme_data_rewind (mdh);
291	gpgme_data_release (*r_dh);
292	*r_dh = mdh;
293	return err;
294	}
295
296	/* Release a gpgme data object @dh and write the contents of
297	the object to the clipboard. If @chg_ver is set, modify the
298	Version: header and add WinPT information. */
299	void
300	gpg_data_release_and_set_clipboard (gpgme_data_t dh, int chg_ver)
301	{
302	gpgme_data_t in;
303	char *clip_text;
304	size_t n;
305
306	if (!dh)
307	return;
308
309	in = dh;
310	if (chg_ver)
311	gpg_data_change_version (&in);
312
313	clip_text = gpgme_data_release_and_get_mem (in, &n);
314	if (clip_text && *clip_text) {
315	set_w32_clip_text (clip_text, n);
316	memset (clip_text, 0xFF, n);
317	gpgme_free (clip_text);
318	}
319	}