trunk/Src/wptGPGMEWrapper.cpp

/* wptGPGMEWrapper.cpp - Object oriented wrapper for GPGME
 *      Copyright (C) 2006 Timo Schulz
 *
 * 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 <stdio.h>
#include <string.h>

#include "gpgme.h"
#include "wptGPG.h"
#include "wptGPGME.h"
#include "wptW32API.h"


/* Constructor to build gpgme context. */
GPGME::GPGME ()
{
    gpgme_new (&ctx);
}

/* Destructor to release gpgme context. */
GPGME::~GPGME ()
{
    if (ctx != NULL)
        gpgme_release (ctx);
}

/* Enable or disable the feature to add the 
    WinPT version to armored output. */
void
GPGME::setChangeVersion (bool val)
{
    chg_ver = val;
}

/* Enable or disable armor. */
void 
GPGME::setArmor (bool val)
{
    gpgme_set_armor (ctx, val? 1 : 0);
}

bool
GPGME::getArmor (void)
{
    return gpgme_get_armor (ctx)? true: false;
}


/* Import keys from a memory buffer. 
   Return value: 0 on success. */
gpgme_error_t
GPGME::importFromBuffer (const char *indata)
{
    gpgme_data_t keydata = NULL;
    gpgme_error_t err;

    err = gpgme_data_new_from_mem (&keydata, indata, strlen (indata), 1);
    if (err)
        return err;

    op_begin ();
    err = gpgme_op_import (ctx, keydata);
    op_end ();

    gpgme_data_release (keydata);
    return err;
}


/* Import the keys from the clipboard.
   Return value: 0 on success. */
gpgme_error_t
GPGME::importFromClipboard (void)
{    
    gpgme_data_t keydata = NULL;
    gpgme_error_t err;

    err = gpg_data_new_from_clipboard (&keydata, 0);
    if (err)
        return err;

    op_begin ();
    err = gpgme_op_import (ctx, keydata);
    op_end ();

    gpgme_data_release (keydata);
    return err;
}


/* Import the keys from the file @file.
   Return value: 0 on success. */
gpgme_error_t
GPGME::importFromFile (const char *file)
{
    gpgme_data_t keydata;
    gpgme_error_t err;

    err = gpgme_data_new_from_file (&keydata, file, 1);
    if (err)
        return err;
    
    op_begin ();
    err = gpgme_op_import (ctx, keydata);
    op_end ();

    gpgme_data_release (keydata);
    return err;
}


/* Return the import result for the last GPG operation. */
gpgme_import_result_t
GPGME::importGetResult (void)
{
    return gpgme_op_import_result (ctx);
}


/* Export key pattern @patt to file @outfile.
   Return value: 0 on success. */
gpgme_error_t
GPGME::exportToFile (const char *patt, const char *outfile)
{
    gpgme_data_t dat;
    gpgme_error_t err;

    err = gpgme_data_new (&dat);
    if (err)
        return err;
    op_begin ();
    err = gpgme_op_export (ctx, patt, 0, dat);
    op_end ();
    if (err) {
        gpgme_data_release (dat);
        return err;
    }
    err = gpg_data_release_and_set_file (dat, outfile);
    if (err)
        gpgme_data_release (dat);
    return err;
}


/* Export key pattern @patt to the clipboard.
   Return value: 0 on success. */
gpgme_error_t
GPGME::exportToClipboard (const char *patt)
{
    gpgme_data_t dat;
    gpgme_error_t err;

    err = gpgme_data_new (&dat);
    if (err)
        return err;
    op_begin ();
    err = gpgme_op_export (ctx, patt, 0, dat);
    op_end ();
    if (err) {
        gpgme_data_release (dat);
        return err;
    }
    gpg_data_release_and_set_clipboard (dat, chg_ver? 1 : 0);
    return err;
}


/* Export key pattern @patt to the buffer @outdata. 
   Return value: 0 on success. */
gpgme_error_t
GPGME::exportToBuffer (const char *patt, char **outdata)
{
    gpgme_error_t err;
    gpgme_data_t dat;
    size_t n;
    char *p;

    err = gpgme_data_new (&dat);
    if (err)
        return err;
    op_begin ();
    err = gpgme_op_export (ctx, patt, 0, dat);
    op_end ();
    if (err) {
        gpgme_data_release (dat);
        return err;
    }
    p = gpgme_data_release_and_get_mem (dat, &n);

    /* we use this detour because p were allocated inside
       the gpgme DLL and cannot be freed with 'free' because
       the DLL might be linked against debug libs but the application
       run ins release mode. */
    *outdata = new char[n+1];
    memcpy (*outdata, p, n);
    (*outdata)[n] = 0;
    gpgme_free (p);

    return err;
}
1	twoaday	133	/* wptGPGMEWrapper.cpp - Object oriented wrapper for GPGME
2			* Copyright (C) 2006 Timo Schulz
3			*
4			* This file is part of WinPT.
5			*
6			* WinPT is free software; you can redistribute it and/or
7			* modify it under the terms of the GNU General Public License
8			* as published by the Free Software Foundation; either version 2
9			* of the License, or (at your option) any later version.
10			*
11			* WinPT 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 GNU
14			* General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with WinPT; if not, write to the Free Software Foundation,
18			* Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19			*/
20
21			#ifdef HAVE_CONFIG_H
22			#include <config.h>
23			#endif
24
25			#include <windows.h>
26			#include <stdio.h>
27			#include <string.h>
28
29			#include "gpgme.h"
30			#include "wptGPG.h"
31			#include "wptGPGME.h"
32	twoaday	195	#include "wptW32API.h"
33	twoaday	133
34
35			/* Constructor to build gpgme context. */
36			GPGME::GPGME ()
37			{
38			gpgme_new (&ctx);
39			}
40
41			/* Destructor to release gpgme context. */
42			GPGME::~GPGME ()
43			{
44			if (ctx != NULL)
45			gpgme_release (ctx);
46			}
47
48	twoaday	167	/* Enable or disable the feature to add the
49			WinPT version to armored output. */
50	twoaday	133	void
51			GPGME::setChangeVersion (bool val)
52			{
53			chg_ver = val;
54			}
55
56			/* Enable or disable armor. */
57			void
58			GPGME::setArmor (bool val)
59			{
60			gpgme_set_armor (ctx, val? 1 : 0);
61			}
62
63			bool
64			GPGME::getArmor (void)
65			{
66			return gpgme_get_armor (ctx)? true: false;
67			}
68
69	twoaday	260
70	twoaday	262	/* Import keys from a memory buffer.
71			Return value: 0 on success. */
72			gpgme_error_t
73			GPGME::importFromBuffer (const char *indata)
74			{
75			gpgme_data_t keydata = NULL;
76			gpgme_error_t err;
77
78			err = gpgme_data_new_from_mem (&keydata, indata, strlen (indata), 1);
79			if (err)
80			return err;
81
82			op_begin ();
83			err = gpgme_op_import (ctx, keydata);
84			op_end ();
85
86			gpgme_data_release (keydata);
87			return err;
88			}
89
90
91	twoaday	260	/* Import the keys from the clipboard.
92			Return value: 0 on success. */
93			gpgme_error_t
94			GPGME::importFromClipboard (void)
95			{
96			gpgme_data_t keydata = NULL;
97			gpgme_error_t err;
98
99			err = gpg_data_new_from_clipboard (&keydata, 0);
100			if (err)
101			return err;
102
103			op_begin ();
104			err = gpgme_op_import (ctx, keydata);
105			op_end ();
106
107			gpgme_data_release (keydata);
108			return err;
109			}
110
111
112			/* Import the keys from the file @file.
113			Return value: 0 on success. */
114			gpgme_error_t
115			GPGME::importFromFile (const char *file)
116			{
117			gpgme_data_t keydata;
118			gpgme_error_t err;
119
120			err = gpgme_data_new_from_file (&keydata, file, 1);
121			if (err)
122			return err;
123
124			op_begin ();
125			err = gpgme_op_import (ctx, keydata);
126			op_end ();
127
128			gpgme_data_release (keydata);
129			return err;
130			}
131
132
133			/* Return the import result for the last GPG operation. */
134			gpgme_import_result_t
135			GPGME::importGetResult (void)
136			{
137			return gpgme_op_import_result (ctx);
138			}
139
140
141	twoaday	133	/* Export key pattern @patt to file @outfile.
142			Return value: 0 on success. */
143			gpgme_error_t
144			GPGME::exportToFile (const char patt, const char outfile)
145			{
146			gpgme_data_t dat;
147			gpgme_error_t err;
148
149			err = gpgme_data_new (&dat);
150			if (err)
151			return err;
152	twoaday	167	op_begin ();
153	twoaday	133	err = gpgme_op_export (ctx, patt, 0, dat);
154	twoaday	167	op_end ();
155	twoaday	133	if (err) {
156			gpgme_data_release (dat);
157			return err;
158			}
159			err = gpg_data_release_and_set_file (dat, outfile);
160	twoaday	247	if (err)
161			gpgme_data_release (dat);
162	twoaday	133	return err;
163			}
164
165
166			/* Export key pattern @patt to the clipboard.
167			Return value: 0 on success. */
168			gpgme_error_t
169			GPGME::exportToClipboard (const char *patt)
170			{
171			gpgme_data_t dat;
172			gpgme_error_t err;
173
174			err = gpgme_data_new (&dat);
175			if (err)
176			return err;
177	twoaday	167	op_begin ();
178	twoaday	133	err = gpgme_op_export (ctx, patt, 0, dat);
179	twoaday	167	op_end ();
180	twoaday	133	if (err) {
181			gpgme_data_release (dat);
182			return err;
183			}
184			gpg_data_release_and_set_clipboard (dat, chg_ver? 1 : 0);
185			return err;
186			}
187
188
189			/* Export key pattern @patt to the buffer @outdata.
190			Return value: 0 on success. */
191			gpgme_error_t
192			GPGME::exportToBuffer (const char patt, char *outdata)
193			{
194			gpgme_error_t err;
195			gpgme_data_t dat;
196			size_t n;
197			char *p;
198
199			err = gpgme_data_new (&dat);
200			if (err)
201			return err;
202	twoaday	167	op_begin ();
203	twoaday	133	err = gpgme_op_export (ctx, patt, 0, dat);
204	twoaday	167	op_end ();
205	twoaday	133	if (err) {
206			gpgme_data_release (dat);
207			return err;
208			}
209			p = gpgme_data_release_and_get_mem (dat, &n);
210
211	twoaday	270	/* we use this detour because p were allocated inside
212			the gpgme DLL and cannot be freed with 'free' because
213			the DLL might be linked against debug libs but the application
214			run ins release mode. */
215	twoaday	133	*outdata = new char[n+1];
216			memcpy (*outdata, p, n);
217			(*outdata)[n] = 0;
218			gpgme_free (p);
219
220			return err;
221			}