trunk/Src/wptMAPI.cpp

/* wptMAPI.cpp - MAPI interface for sending keys.
 *      Copyright (C) 2003, 2004, 2005, 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 <mapi.h>

#include "resource.h"
#include "wptTypes.h"
#include "wptErrors.h"
#include "wptW32API.h"
#include "wptGPG.h"
#include "wptVersion.h"
#include "wptCommonCtl.h"
#include "wptKeyManager.h"


static LPMAPILOGON          mapi_logon = NULL; 
static LPMAPILOGOFF         mapi_logoff = NULL;     
static LPMAPISENDDOCUMENTS  mapi_send_documents = NULL; 
static LPMAPISENDMAIL       mapi_send_mail = NULL;
static HINSTANCE            hlib = NULL;
static int                  init = 0;

#define load_one_fnc(cast, hlib, name) (cast)GetProcAddress ((hlib), name)


/* Load MAPI library and set function pointers.
   Return value: 0 on success. */
int
mapi_init (void)
{
    if (init)
        return 0;

    hlib = LoadLibrary ("MAPI32.DLL");
    if (!hlib)
        return -1;

    mapi_logon = load_one_fnc (LPMAPILOGON, hlib, "MAPILogon");
    mapi_logoff = load_one_fnc (LPMAPILOGOFF, hlib, "MAPILogoff");
    mapi_send_documents = load_one_fnc (LPMAPISENDDOCUMENTS, hlib, "MAPISendDocuments");
    mapi_send_mail = load_one_fnc (LPMAPISENDMAIL, hlib, "MAPISendMail");
    if (!mapi_logon || !mapi_logoff || !mapi_send_documents || !mapi_send_mail)
        return -1;
    init = 1;

    return 0;
}


/* Free library and cleanup. */
void
mapi_deinit (void)
{
    if (hlib) {
        FreeLibrary (hlib);
        hlib = NULL;
        init = 0;
    }
}


/* Send the file given in @ascfile via the MAPI mechanism. */
int
mapi_send_ascfile (char *ascfile)
{
    LHANDLE hd;
    int rc;

    if (!init)
        return 0;

    rc = mapi_logon (0, NULL, NULL, MAPI_LOGON_UI, 0, &hd);
    if (rc != SUCCESS_SUCCESS) {
        MessageBox (NULL, _("MAPI Login failed."), "MAPI", MB_ICONWARNING|MB_OK);
        goto fail;
    }
    rc = mapi_send_documents (0, ";", ascfile, NULL, 0);
    if (rc == MAPI_E_USER_ABORT)
        rc = SUCCESS_SUCCESS;
    if (rc != SUCCESS_SUCCESS)
        MessageBox (NULL, _("Could not sent mail."), "MAPI", MB_ICONERROR|MB_OK);

fail:
    mapi_logoff (hd, 0, 0, 0);
    return rc;
}


static void
free_mapi_msg (MapiMessage *msg)
{
    if (!msg)
        return;
    safe_free (msg->lpszSubject);
    safe_free (msg->lpszNoteText);
    safe_free (msg);
}


static void
free_recip_tab (MapiRecipDesc *recip, size_t n)
{
    size_t i;

    if (!recip)
        return;
    if (!n)
        return;
    for (i=0; i < n; i++)
        safe_free (recip[i].lpszName);
    safe_free (recip);
}


static void
free_files_tab (MapiFileDesc *files, size_t n)
{
    size_t i;

    if (!files)
        return;
    if (!n)
        return;
    for (i=0; i < n; i++) {
        safe_free (files[i].lpszFileName);
        safe_free (files[i].lpszPathName);
    }
    safe_free (files);
}


/* Same as mapi_send_pubkey but there is an additional note. */
int
mapi_send_pubkey_ext (gpgme_key_t to, const char *keyfile, int flags)
{
    LHANDLE hd;
    MapiMessage *msg;
    MapiRecipDesc *recip;
    MapiFileDesc *attch;
    char *p, *kinf;
    const char *s;
    int rc;

    if (!init)
        return 0;

    rc = mapi_logon (0, NULL, NULL, MAPI_LOGON_UI, 0, &hd);
    if (rc != SUCCESS_SUCCESS) {
        MessageBox (NULL, "MAPI Login failed.", "MAPI", MB_ICONWARNING|MB_OK);
        return rc;
    }

    msg = (MapiMessage *)calloc (1, sizeof *msg);
    if (!msg)
        BUG (0);
    p = msg->lpszSubject = strdup ("OpenPGP Public Key");
    if (!p)
        BUG (0);

    s = "Attached is this OpenPGP public key:\n%s\n\n"
        "Import this key via the clipboard or the Key Manager to\n"
        "exchange encrypted mails with the key holder and to be able\n"
        "to verify its signatures.\n"
        "\n"
        "If you don't have WinPT, you can download it at http://www.winpt.org";
    kinf = km_key_get_info (to, 0);
    p = (char*)malloc (strlen (s) + strlen (kinf) + 2);
    sprintf (p, s, kinf);
    free_if_alloc (kinf);

    p = msg->lpszNoteText = p;
    if (!p)
        BUG (0); 

    /* If the key was signed, we assume it shall be sent back to the owner. */
    if (flags) {
        recip = (MapiRecipDesc *)calloc (1, sizeof *recip);
        if (!recip)
            BUG (0);
        recip[0].ulRecipClass = MAPI_TO;
        p = recip[0].lpszName = strdup (to->uids->uid); 
        if (!p)    
            BUG (0);
        msg->lpRecips = recip;
        msg->nRecipCount = 1;
    }
    else {
        msg->lpRecips = recip = NULL;
        msg->nRecipCount = 0;
    }

    msg->nFileCount = 1;
    attch = (MapiFileDesc *)calloc (1, sizeof *attch);
    if (!attch)
        BUG (0);
    attch[0].lpszFileName = strdup (keyfile);
    attch[0].lpszPathName = strdup (keyfile);
    msg->lpFiles = attch;

    rc = mapi_send_mail (hd, 0, msg, MAPI_DIALOG , 0);
    if (rc == MAPI_E_USER_ABORT)
        rc = SUCCESS_SUCCESS;
    if (rc != SUCCESS_SUCCESS)
        MessageBox (NULL, _("Could not sent mail."), "MAPI", MB_ERR);

    free_recip_tab (recip, 1);
    free_files_tab (attch, 1);
    free_mapi_msg (msg);
    mapi_logoff (hd, 0, 0, 0);

    return 0;
}


#if 0
/* Send a public key stored in @keyfile with the keyid @keyid
   via the MAPI mechanism to a mail recipient. 
   Return value: SUCCESS_SUCCESS on succes. */
int
mapi_send_pubkey2 (const char *keyid, char *keyfile)
{
    LHANDLE hd;
    const char * fmt;
    char * keyinf = NULL;
    int rc;

    if (!init)
        return 0;

    fmt = _("GPG Public Key of %s");
    keyinf = new char[strlen (fmt) + strlen (keyid) + 2];
    if (!keyinf)
        BUG (0);
    sprintf (keyinf, fmt, keyid);
    rc = mapi_logon (0, NULL, NULL, MAPI_LOGON_UI, 0, &hd);
    if (rc != SUCCESS_SUCCESS) {
        MessageBox (NULL, _("MAPI Login failed."), "MAPI", MB_ICONWARNING|MB_OK);
        goto fail;
    }
    rc = mapi_send_documents (0, ";", keyfile, keyinf, 0);
    if (rc == MAPI_E_USER_ABORT)
        rc = SUCCESS_SUCCESS;
    if (rc != SUCCESS_SUCCESS)
        MessageBox (NULL, _("Could not sent mail."), "MAPI", MB_ICONERROR|MB_OK);

fail:
    mapi_logoff (hd, 0, 0, 0);
    free_if_alloc (keyinf);
    return rc;
}
#endif


int
mapi_send_pubkey (const char *keyid, char *keyfile)
{
    gpgme_key_t key;

    get_pubkey (keyid, &key);
    return mapi_send_pubkey_ext (key, keyfile, 0);
}
1	/* wptMAPI.cpp - MAPI interface for sending keys.
2	* Copyright (C) 2003, 2004, 2005, 2006 Timo Schulz
3	*
4	* This file is part of WinPT.
5	*
6	* WinPT 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	* 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
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 WinPT; if not, write to the Free Software Foundation,
18	* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19	*/
20	#ifdef HAVE_CONFIG_H
21	#include <config.h>
22	#endif
23
24	#include <windows.h>
25	#include <stdio.h>
26	#include <mapi.h>
27
28	#include "resource.h"
29	#include "wptTypes.h"
30	#include "wptErrors.h"
31	#include "wptW32API.h"
32	#include "wptGPG.h"
33	#include "wptVersion.h"
34	#include "wptCommonCtl.h"
35	#include "wptKeyManager.h"
36
37
38	static LPMAPILOGON mapi_logon = NULL;
39	static LPMAPILOGOFF mapi_logoff = NULL;
40	static LPMAPISENDDOCUMENTS mapi_send_documents = NULL;
41	static LPMAPISENDMAIL mapi_send_mail = NULL;
42	static HINSTANCE hlib = NULL;
43	static int init = 0;
44
45	#define load_one_fnc(cast, hlib, name) (cast)GetProcAddress ((hlib), name)
46
47
48	/* Load MAPI library and set function pointers.
49	Return value: 0 on success. */
50	int
51	mapi_init (void)
52	{
53	if (init)
54	return 0;
55
56	hlib = LoadLibrary ("MAPI32.DLL");
57	if (!hlib)
58	return -1;
59
60	mapi_logon = load_one_fnc (LPMAPILOGON, hlib, "MAPILogon");
61	mapi_logoff = load_one_fnc (LPMAPILOGOFF, hlib, "MAPILogoff");
62	mapi_send_documents = load_one_fnc (LPMAPISENDDOCUMENTS, hlib, "MAPISendDocuments");
63	mapi_send_mail = load_one_fnc (LPMAPISENDMAIL, hlib, "MAPISendMail");
64	if (!mapi_logon \|\| !mapi_logoff \|\| !mapi_send_documents \|\| !mapi_send_mail)
65	return -1;
66	init = 1;
67
68	return 0;
69	}
70
71
72	/* Free library and cleanup. */
73	void
74	mapi_deinit (void)
75	{
76	if (hlib) {
77	FreeLibrary (hlib);
78	hlib = NULL;
79	init = 0;
80	}
81	}
82
83
84	/* Send the file given in @ascfile via the MAPI mechanism. */
85	int
86	mapi_send_ascfile (char *ascfile)
87	{
88	LHANDLE hd;
89	int rc;
90
91	if (!init)
92	return 0;
93
94	rc = mapi_logon (0, NULL, NULL, MAPI_LOGON_UI, 0, &hd);
95	if (rc != SUCCESS_SUCCESS) {
96	MessageBox (NULL, _("MAPI Login failed."), "MAPI", MB_ICONWARNING\|MB_OK);
97	goto fail;
98	}
99	rc = mapi_send_documents (0, ";", ascfile, NULL, 0);
100	if (rc == MAPI_E_USER_ABORT)
101	rc = SUCCESS_SUCCESS;
102	if (rc != SUCCESS_SUCCESS)
103	MessageBox (NULL, _("Could not sent mail."), "MAPI", MB_ICONERROR\|MB_OK);
104
105	fail:
106	mapi_logoff (hd, 0, 0, 0);
107	return rc;
108	}
109
110
111	static void
112	free_mapi_msg (MapiMessage *msg)
113	{
114	if (!msg)
115	return;
116	safe_free (msg->lpszSubject);
117	safe_free (msg->lpszNoteText);
118	safe_free (msg);
119	}
120
121
122	static void
123	free_recip_tab (MapiRecipDesc *recip, size_t n)
124	{
125	size_t i;
126
127	if (!recip)
128	return;
129	if (!n)
130	return;
131	for (i=0; i < n; i++)
132	safe_free (recip[i].lpszName);
133	safe_free (recip);
134	}
135
136
137	static void
138	free_files_tab (MapiFileDesc *files, size_t n)
139	{
140	size_t i;
141
142	if (!files)
143	return;
144	if (!n)
145	return;
146	for (i=0; i < n; i++) {
147	safe_free (files[i].lpszFileName);
148	safe_free (files[i].lpszPathName);
149	}
150	safe_free (files);
151	}
152
153
154	/* Same as mapi_send_pubkey but there is an additional note. */
155	int
156	mapi_send_pubkey_ext (gpgme_key_t to, const char *keyfile, int flags)
157	{
158	LHANDLE hd;
159	MapiMessage *msg;
160	MapiRecipDesc *recip;
161	MapiFileDesc *attch;
162	char p, kinf;
163	const char *s;
164	int rc;
165
166	if (!init)
167	return 0;
168
169	rc = mapi_logon (0, NULL, NULL, MAPI_LOGON_UI, 0, &hd);
170	if (rc != SUCCESS_SUCCESS) {
171	MessageBox (NULL, "MAPI Login failed.", "MAPI", MB_ICONWARNING\|MB_OK);
172	return rc;
173	}
174
175	msg = (MapiMessage )calloc (1, sizeof msg);
176	if (!msg)
177	BUG (0);
178	p = msg->lpszSubject = strdup ("OpenPGP Public Key");
179	if (!p)
180	BUG (0);
181
182	s = "Attached is this OpenPGP public key:\n%s\n\n"
183	"Import this key via the clipboard or the Key Manager to\n"
184	"exchange encrypted mails with the key holder and to be able\n"
185	"to verify its signatures.\n"
186	"\n"
187	"If you don't have WinPT, you can download it at http://www.winpt.org";
188	kinf = km_key_get_info (to, 0);
189	p = (char*)malloc (strlen (s) + strlen (kinf) + 2);
190	sprintf (p, s, kinf);
191	free_if_alloc (kinf);
192
193	p = msg->lpszNoteText = p;
194	if (!p)
195	BUG (0);
196
197	/* If the key was signed, we assume it shall be sent back to the owner. */
198	if (flags) {
199	recip = (MapiRecipDesc )calloc (1, sizeof recip);
200	if (!recip)
201	BUG (0);
202	recip[0].ulRecipClass = MAPI_TO;
203	p = recip[0].lpszName = strdup (to->uids->uid);
204	if (!p)
205	BUG (0);
206	msg->lpRecips = recip;
207	msg->nRecipCount = 1;
208	}
209	else {
210	msg->lpRecips = recip = NULL;
211	msg->nRecipCount = 0;
212	}
213
214	msg->nFileCount = 1;
215	attch = (MapiFileDesc )calloc (1, sizeof attch);
216	if (!attch)
217	BUG (0);
218	attch[0].lpszFileName = strdup (keyfile);
219	attch[0].lpszPathName = strdup (keyfile);
220	msg->lpFiles = attch;
221
222	rc = mapi_send_mail (hd, 0, msg, MAPI_DIALOG , 0);
223	if (rc == MAPI_E_USER_ABORT)
224	rc = SUCCESS_SUCCESS;
225	if (rc != SUCCESS_SUCCESS)
226	MessageBox (NULL, _("Could not sent mail."), "MAPI", MB_ERR);
227
228	free_recip_tab (recip, 1);
229	free_files_tab (attch, 1);
230	free_mapi_msg (msg);
231	mapi_logoff (hd, 0, 0, 0);
232
233	return 0;
234	}
235
236
237	#if 0
238	/* Send a public key stored in @keyfile with the keyid @keyid
239	via the MAPI mechanism to a mail recipient.
240	Return value: SUCCESS_SUCCESS on succes. */
241	int
242	mapi_send_pubkey2 (const char keyid, char keyfile)
243	{
244	LHANDLE hd;
245	const char * fmt;
246	char * keyinf = NULL;
247	int rc;
248
249	if (!init)
250	return 0;
251
252	fmt = _("GPG Public Key of %s");
253	keyinf = new char[strlen (fmt) + strlen (keyid) + 2];
254	if (!keyinf)
255	BUG (0);
256	sprintf (keyinf, fmt, keyid);
257	rc = mapi_logon (0, NULL, NULL, MAPI_LOGON_UI, 0, &hd);
258	if (rc != SUCCESS_SUCCESS) {
259	MessageBox (NULL, _("MAPI Login failed."), "MAPI", MB_ICONWARNING\|MB_OK);
260	goto fail;
261	}
262	rc = mapi_send_documents (0, ";", keyfile, keyinf, 0);
263	if (rc == MAPI_E_USER_ABORT)
264	rc = SUCCESS_SUCCESS;
265	if (rc != SUCCESS_SUCCESS)
266	MessageBox (NULL, _("Could not sent mail."), "MAPI", MB_ICONERROR\|MB_OK);
267
268	fail:
269	mapi_logoff (hd, 0, 0, 0);
270	free_if_alloc (keyinf);
271	return rc;
272	}
273	#endif
274
275
276	int
277	mapi_send_pubkey (const char keyid, char keyfile)
278	{
279	gpgme_key_t key;
280
281	get_pubkey (keyid, &key);
282	return mapi_send_pubkey_ext (key, keyfile, 0);
283	}