trunk/w32gpgme/w32-clip.c

/* w32-clip.c - W32 API clipboard functions
 *      Copyright (C) 2001, 2002, 2003, 2005 Timo Schulz
 *
 * This file is part of MyGPGME.
 *
 * MyGPGME 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.
 *
 * MyGPGME 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 this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */

#include <windows.h>
#include "w32gpgme.h"

int gpg_data_wrap_lines (gpgme_data_t *r_dh, size_t wraplen);

//FIXME #include "wptVersion.h"
#define PGM_VERSION "0.10.2-gpgme"

/* 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 = GlobalLock (cb);
    if (!private_clip)
        goto leave;
    size = strlen (private_clip);
    clip = 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 = 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) {
        line[n] = '\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");
        }
         
        line[strlen (line)-2] = 0; /* XXX: make sure we really have \r\n */
        gpgme_data_write (mdh, line, strlen (line));
        gpgme_data_write (mdh, "\r\n", 2);
    }

    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	twoaday	23	/* w32-clip.c - W32 API clipboard functions
2			* Copyright (C) 2001, 2002, 2003, 2005 Timo Schulz
3			*
4			* This file is part of MyGPGME.
5			*
6			* MyGPGME is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* MyGPGME is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18			* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19			*/
20
21			#include <windows.h>
22			#include "w32gpgme.h"
23
24			int gpg_data_wrap_lines (gpgme_data_t *r_dh, size_t wraplen);
25
26			//FIXME #include "wptVersion.h"
27			#define PGM_VERSION "0.10.2-gpgme"
28
29			/* Retrieve the thext of the clipboard.
30			Return value: the text as a string, NULL otherwise. */
31			static char*
32			get_w32_clip_text (void)
33			{
34			char *private_clip = NULL;
35			char *clip = NULL;
36			size_t size;
37			HANDLE cb;
38
39			if (!OpenClipboard (NULL))
40			return NULL;
41			cb = GetClipboardData (CF_TEXT);
42			if (!cb)
43			goto leave;
44			private_clip = GlobalLock (cb);
45			if (!private_clip)
46			goto leave;
47			size = strlen (private_clip);
48			clip = malloc (size + 1);
49			if (!clip) {
50			GlobalUnlock (cb);
51			goto leave;
52			}
53			memcpy (clip, private_clip, size);
54			clip[size] = '\0';
55			GlobalUnlock(cb);
56
57			leave:
58			CloseClipboard ();
59			return clip;
60			}
61
62
63			/* Set the new clipboard data to @data. */
64			static void
65			set_w32_clip_text (const char *data, int size)
66			{
67			HANDLE cb;
68			char *private_data;
69
70			if (!OpenClipboard(NULL))
71			return;
72			EmptyClipboard ();
73			cb = GlobalAlloc (GHND, size+1);
74			if (!cb)
75			goto leave;
76			private_data = GlobalLock (cb);
77			if (!private_data)
78			goto leave;
79			memcpy (private_data, data, size);
80			private_data[size] = '\0';
81			SetClipboardData (CF_TEXT, cb);
82			GlobalUnlock (cb);
83
84			leave:
85			CloseClipboard ();
86			GlobalFree (cb);
87			}
88
89
90			/* Retrieve the clipboard data and create a new gpgme
91			data object @r_dh and return it. If @wraplen is > 0
92			wrap lines of the buffer.
93			Return value: 0 on success. */
94			gpgme_error_t
95			gpg_data_new_from_clipboard (gpgme_data_t *r_dh, int wraplen)
96			{
97			gpgme_error_t err = 0;
98			gpgme_data_t dh;
99			char *clip_text = NULL;
100
101			if (!r_dh)
102	twoaday	25	return gpg_error (GPG_ERR_INV_ARG);
103	twoaday	23	*r_dh = NULL;
104			clip_text = get_w32_clip_text ();
105			if (!clip_text)
106	twoaday	25	return gpg_error (GPG_ERR_NO_DATA);
107	twoaday	23	err = gpgme_data_new_from_mem (&dh, clip_text, strlen (clip_text), 1);
108			if (clip_text)
109			free (clip_text);
110			if (wraplen > 0)
111			gpg_data_wrap_lines (&dh, wraplen);
112	twoaday	25
113	twoaday	23	*r_dh = dh;
114			return err;
115			}
116
117
118			/* Search for the armor header 'Version:' in @r_dh and
119			add the WinPT version. On success @r_dh is replaced
120			with the modified data.
121			Return value: 0 on success. */
122			static gpgme_error_t
123			gpg_data_change_version (gpgme_data_t *r_dh)
124			{
125			gpgme_error_t err = 0;
126			gpgme_data_t mdh;
127			char line[128+32];
128	twoaday	24	int n;
129	twoaday	23
130			if (!r_dh)
131			return gpg_error (GPG_ERR_INV_ARG);
132
133	twoaday	24	err = gpgme_data_new (&mdh);
134	twoaday	23	if (err)
135			return err;
136
137	twoaday	24	gpgme_data_rewind (*r_dh);
138			while ((n=gpg_data_readline (*r_dh, line, 128)) > 0) {
139			line[n] = '\0';
140	twoaday	23	if (strlen (line) > 14 &&
141			!strncmp (line, "Version: GnuPG", 14) &&
142			!strstr (line, "WinPT "PGM_VERSION)) {
143			line[strlen (line) - 2] = '\0';
144			strcat (line, " - " );
145			strcat (line, "WinPT "PGM_VERSION);
146			strcat (line, "\r\n");
147			}
148	twoaday	25
149			line[strlen (line)-2] = 0; /* XXX: make sure we really have \r\n */
150	twoaday	23	gpgme_data_write (mdh, line, strlen (line));
151	twoaday	25	gpgme_data_write (mdh, "\r\n", 2);
152	twoaday	23	}
153	twoaday	24
154	twoaday	23	gpgme_data_write (mdh, "", 1);
155	twoaday	24	gpgme_data_rewind (mdh);
156	twoaday	23	gpgme_data_release (*r_dh);
157			*r_dh = mdh;
158			return err;
159			}
160
161			/* Release a gpgme data object @dh and write the contents of
162			the object to the clipboard. If @chg_ver is set, modify the
163			Version: header and add WinPT information. */
164			void
165			gpg_data_release_and_set_clipboard (gpgme_data_t dh, int chg_ver)
166			{
167			gpgme_data_t in;
168			char *clip_text;
169			size_t n;
170
171			if (!dh)
172			return;
173
174			in = dh;
175			if (chg_ver)
176			gpg_data_change_version (&in);
177
178			clip_text = gpgme_data_release_and_get_mem (in, &n);
179	twoaday	24	if (clip_text && *clip_text) {
180	twoaday	25	set_w32_clip_text (clip_text, n);
181			memset (clip_text, 0xFF, n);
182	twoaday	27	gpgme_free (clip_text);
183	twoaday	23	}
184			}