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 (winpt_key_t key, const char *keyfile, int flags)
{
    LHANDLE hd;
    MapiMessage *msg;
    MapiRecipDesc *recip;
    MapiFileDesc *attch;
    gpgme_key_t to = key->ctx;
    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 (key, 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;
}


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

    memset (&key, 0, sizeof (key));
    if (winpt_get_pubkey (keyid, &key))
        return -1;
    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	207	mapi_send_pubkey_ext (winpt_key_t key, const char *keyfile, int flags)
157	werner	36	{
158			LHANDLE hd;
159	twoaday	150	MapiMessage *msg;
160			MapiRecipDesc *recip;
161			MapiFileDesc *attch;
162	twoaday	207	gpgme_key_t to = key->ctx;
163	twoaday	150	char p, kinf;
164			const char *s;
165	werner	36	int rc;
166
167			if (!init)
168			return 0;
169
170			rc = mapi_logon (0, NULL, NULL, MAPI_LOGON_UI, 0, &hd);
171			if (rc != SUCCESS_SUCCESS) {
172			MessageBox (NULL, "MAPI Login failed.", "MAPI", MB_ICONWARNING\|MB_OK);
173			return rc;
174			}
175
176	twoaday	150	msg = (MapiMessage )calloc (1, sizeof msg);
177	werner	36	if (!msg)
178			BUG (0);
179	twoaday	150	p = msg->lpszSubject = strdup ("OpenPGP Public Key");
180	werner	36	if (!p)
181			BUG (0);
182	twoaday	150
183			s = "Attached is this OpenPGP public key:\n%s\n\n"
184			"Import this key via the clipboard or the Key Manager to\n"
185			"exchange encrypted mails with the key holder and to be able\n"
186			"to verify its signatures.\n"
187			"\n"
188			"If you don't have WinPT, you can download it at http://www.winpt.org";
189	twoaday	207	kinf = km_key_get_info (key, 0);
190	twoaday	150	p = (char*)malloc (strlen (s) + strlen (kinf) + 2);
191			sprintf (p, s, kinf);
192			free_if_alloc (kinf);
193
194			p = msg->lpszNoteText = p;
195	werner	36	if (!p)
196	twoaday	150	BUG (0);
197	werner	36
198	twoaday	150	/* If the key was signed, we assume it shall be sent back to the owner. */
199			if (flags) {
200			recip = (MapiRecipDesc )calloc (1, sizeof recip);
201			if (!recip)
202	werner	36	BUG (0);
203	twoaday	150	recip[0].ulRecipClass = MAPI_TO;
204			p = recip[0].lpszName = strdup (to->uids->uid);
205			if (!p)
206			BUG (0);
207			msg->lpRecips = recip;
208			msg->nRecipCount = 1;
209	werner	36	}
210	twoaday	150	else {
211			msg->lpRecips = recip = NULL;
212			msg->nRecipCount = 0;
213			}
214	werner	36
215	twoaday	150	msg->nFileCount = 1;
216			attch = (MapiFileDesc )calloc (1, sizeof attch);
217			if (!attch)
218			BUG (0);
219			attch[0].lpszFileName = strdup (keyfile);
220			attch[0].lpszPathName = strdup (keyfile);
221			msg->lpFiles = attch;
222
223			rc = mapi_send_mail (hd, 0, msg, MAPI_DIALOG , 0);
224	werner	36	if (rc == MAPI_E_USER_ABORT)
225			rc = SUCCESS_SUCCESS;
226			if (rc != SUCCESS_SUCCESS)
227			MessageBox (NULL, _("Could not sent mail."), "MAPI", MB_ERR);
228
229	twoaday	150	free_recip_tab (recip, 1);
230			free_files_tab (attch, 1);
231	werner	36	free_mapi_msg (msg);
232			mapi_logoff (hd, 0, 0, 0);
233
234			return 0;
235	twoaday	150	}
236	werner	36
237
238
239	twoaday	150	int
240			mapi_send_pubkey (const char keyid, char keyfile)
241	werner	36	{
242	twoaday	207	winpt_key_s key;
243	werner	36
244	twoaday	207	memset (&key, 0, sizeof (key));
245			if (winpt_get_pubkey (keyid, &key))
246			return -1;
247			return mapi_send_pubkey_ext (&key, keyfile, 0);
248	twoaday	150	}