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	twoaday	150	/* wptMAPI.cpp - MAPI interface for sending keys.
2			* Copyright (C) 2003, 2004, 2005, 2006 Timo Schulz
3	werner	36	*
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	werner	47	#include "resource.h"
29	werner	36	#include "wptTypes.h"
30			#include "wptErrors.h"
31			#include "wptW32API.h"
32			#include "wptGPG.h"
33	twoaday	121	#include "wptVersion.h"
34	twoaday	150	#include "wptCommonCtl.h"
35			#include "wptKeyManager.h"
36	werner	36
37	twoaday	150
38	werner	36	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	twoaday	77	/* Load MAPI library and set function pointers.
49			Return value: 0 on success. */
50	werner	36	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	twoaday	77	}
70	werner	36
71
72	twoaday	77	/* Free library and cleanup. */
73	werner	36	void
74			mapi_deinit (void)
75			{
76			if (hlib) {
77			FreeLibrary (hlib);
78			hlib = NULL;
79			init = 0;
80			}
81	twoaday	77	}
82	werner	36
83	twoaday	77
84			/* Send the file given in @ascfile via the MAPI mechanism. */
85	werner	36	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	twoaday	150	free_mapi_msg (MapiMessage *msg)
113	werner	36	{
114			if (!msg)
115			return;
116			safe_free (msg->lpszSubject);
117			safe_free (msg->lpszNoteText);
118			safe_free (msg);
119	twoaday	150	}
120	werner	36
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	twoaday	150	}
135	werner	36
136
137			static void
138	twoaday	150	free_files_tab (MapiFileDesc *files, size_t n)
139	werner	36	{
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	twoaday	150	}
152	werner	36
153
154	twoaday	150	/* Same as mapi_send_pubkey but there is an additional note. */
155	werner	36	int
156	twoaday	150	mapi_send_pubkey_ext (gpgme_key_t to, const char *keyfile, int flags)
157	werner	36	{
158			LHANDLE hd;
159	twoaday	150	MapiMessage *msg;
160			MapiRecipDesc *recip;
161			MapiFileDesc *attch;
162			char p, kinf;
163			const char *s;
164	werner	36	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	twoaday	150	msg = (MapiMessage )calloc (1, sizeof msg);
176	werner	36	if (!msg)
177			BUG (0);
178	twoaday	150	p = msg->lpszSubject = strdup ("OpenPGP Public Key");
179	werner	36	if (!p)
180			BUG (0);
181	twoaday	150
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	werner	36	if (!p)
195	twoaday	150	BUG (0);
196	werner	36
197	twoaday	150	/* 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	werner	36	BUG (0);
202	twoaday	150	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	werner	36	}
209	twoaday	150	else {
210			msg->lpRecips = recip = NULL;
211			msg->nRecipCount = 0;
212			}
213	werner	36
214	twoaday	150	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	werner	36	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	twoaday	150	free_recip_tab (recip, 1);
229			free_files_tab (attch, 1);
230	werner	36	free_mapi_msg (msg);
231			mapi_logoff (hd, 0, 0, 0);
232
233			return 0;
234	twoaday	150	}
235	werner	36
236
237	twoaday	150	#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	werner	36	{
244	twoaday	150	LHANDLE hd;
245			const char * fmt;
246			char * keyinf = NULL;
247			int rc;
248	werner	36
249	twoaday	150	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	werner	36	}
262	twoaday	150	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	werner	36
268	twoaday	150	fail:
269			mapi_logoff (hd, 0, 0, 0);
270			free_if_alloc (keyinf);
271			return rc;
272			}
273			#endif
274	werner	36
275
276	twoaday	150	int
277			mapi_send_pubkey (const char keyid, char keyfile)
278	werner	36	{
279	twoaday	150	gpgme_key_t key;
280	werner	36
281	twoaday	150	get_pubkey (keyid, &key);
282			return mapi_send_pubkey_ext (key, keyfile, 0);
283			}