projects / reactos.git / blob
? search:


cbbff9847e9400f46ffd8aa24398b12a441598fc
[reactos.git] / reactos / dll / win32 / mapi32 / sendmail.c
1 /*
2 * MAPISendMail implementation
3 *
4 * Copyright 2005 Hans Leidekker
5 * Copyright 2009 Owen Rudge for CodeWeavers
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <stdio.h>
26 #include <stdarg.h>
27
28 #define COBJMACROS
29
30 #include "windef.h"
31 #include "winbase.h"
32 #include "winerror.h"
33 #include "objbase.h"
34 #include "objidl.h"
35 #include "mapi.h"
36 #include "mapix.h"
37 #include "mapiutil.h"
38 #include "mapidefs.h"
39 #include "winreg.h"
40 #include "shellapi.h"
41 #include "shlwapi.h"
42 #include "wine/debug.h"
43 #include "util.h"
44
45 WINE_DEFAULT_DEBUG_CHANNEL(mapi);
46
47 #define READ_BUF_SIZE 4096
48
49 /*
50 Internal function to send a message via Extended MAPI. Wrapper around the Simple
51 MAPI function MAPISendMail.
52 */
53 static ULONG sendmail_extended_mapi(LHANDLE mapi_session, ULONG_PTR uiparam, lpMapiMessage message,
54 FLAGS flags, ULONG reserved)
55 {
56 ULONG tags[] = {1, PR_IPM_DRAFTS_ENTRYID};
57 ULONG retval = MAPI_E_FAILURE;
58 IMAPISession *session = NULL;
59 IMAPITable* msg_table;
60 LPSRowSet rows = NULL;
61 IMsgStore* msg_store;
62 IMAPIFolder* folder = NULL, *draft_folder = NULL;
63 LPENTRYID entry_id;
64 LPSPropValue props;
65 ULONG entry_len;
66 DWORD obj_type;
67 IMessage* msg;
68 ULONG values;
69 HRESULT ret;
70
71 TRACE("Using Extended MAPI wrapper for MAPISendMail\n");
72
73 /* Attempt to log on via Extended MAPI */
74
75 ret = MAPILogonEx(0, NULL, NULL, MAPI_EXTENDED | MAPI_USE_DEFAULT | MAPI_NEW_SESSION, &session);
76 TRACE("MAPILogonEx: %x\n", ret);
77
78 if (ret != S_OK)
79 {
80 retval = MAPI_E_LOGIN_FAILURE;
81 goto cleanup;
82 }
83
84 /* Open the default message store */
85
86 if (IMAPISession_GetMsgStoresTable(session, 0, &msg_table) == S_OK)
87 {
88 /* We want the default store */
89 SizedSPropTagArray(2, columns) = {2, {PR_ENTRYID, PR_DEFAULT_STORE}};
90
91 /* Set the columns we want */
92 if (IMAPITable_SetColumns(msg_table, (LPSPropTagArray) &columns, 0) == S_OK)
93 {
94 while (1)
95 {
96 if (IMAPITable_QueryRows(msg_table, 1, 0, &rows) != S_OK)
97 {
98 MAPIFreeBuffer(rows);
99 rows = NULL;
100 }
101 else if (rows->cRows != 1)
102 {
103 FreeProws(rows);
104 rows = NULL;
105 }
106 else
107 {
108 /* If it's not the default store, try the next row */
109 if (!rows->aRow[0].lpProps[1].Value.b)
110 {
111 FreeProws(rows);
112 continue;
113 }
114 }
115
116 break;
117 }
118 }
119
120 IMAPITable_Release(msg_table);
121 }
122
123 /* Did we manage to get the right store? */
124 if (!rows)
125 goto logoff;
126
127 /* Open the message store */
128 IMAPISession_OpenMsgStore(session, 0, rows->aRow[0].lpProps[0].Value.bin.cb,
129 (ENTRYID *) rows->aRow[0].lpProps[0].Value.bin.lpb, NULL,
130 MDB_NO_DIALOG | MAPI_BEST_ACCESS, &msg_store);
131
132 /* We don't need this any more */
133 FreeProws(rows);
134
135 /* First open the inbox, from which the drafts folder can be opened */
136 if (IMsgStore_GetReceiveFolder(msg_store, NULL, 0, &entry_len, &entry_id, NULL) == S_OK)
137 {
138 IMsgStore_OpenEntry(msg_store, entry_len, entry_id, NULL, 0, &obj_type, (LPUNKNOWN*) &folder);
139 MAPIFreeBuffer(entry_id);
140 }
141
142 /* Open the drafts folder, or failing that, try asking the message store for the outbox */
143 if ((folder == NULL) || ((ret = IMAPIFolder_GetProps(folder, (LPSPropTagArray) tags, 0, &values, &props)) != S_OK))
144 {
145 TRACE("Unable to open Drafts folder; opening Outbox instead\n");
146 tags[1] = PR_IPM_OUTBOX_ENTRYID;
147 ret = IMsgStore_GetProps(msg_store, (LPSPropTagArray) tags, 0, &values, &props);
148 }
149
150 if (ret != S_OK)
151 goto logoff;
152
153 IMsgStore_OpenEntry(msg_store, props[0].Value.bin.cb, (LPENTRYID) props[0].Value.bin.lpb,
154 NULL, MAPI_MODIFY, &obj_type, (LPUNKNOWN *) &draft_folder);
155
156 /* Create a new message */
157 if (IMAPIFolder_CreateMessage(draft_folder, NULL, 0, &msg) == S_OK)
158 {
159 ULONG token;
160 SPropValue p;
161
162 /* Define message properties */
163 p.ulPropTag = PR_MESSAGE_FLAGS;
164 p.Value.l = MSGFLAG_FROMME | MSGFLAG_UNSENT;
165
166 IMessage_SetProps(msg, 1, &p, NULL);
167
168 p.ulPropTag = PR_SENTMAIL_ENTRYID;
169 p.Value.bin.cb = props[0].Value.bin.cb;
170 p.Value.bin.lpb = props[0].Value.bin.lpb;
171 IMessage_SetProps(msg, 1,&p, NULL);
172
173 /* Set message subject */
174 if (message->lpszSubject)
175 {
176 p.ulPropTag = PR_SUBJECT_A;
177 p.Value.lpszA = message->lpszSubject;
178 IMessage_SetProps(msg, 1, &p, NULL);
179 }
180
181 /* Set message body */
182 if (message->lpszNoteText)
183 {
184 LPSTREAM stream = NULL;
185
186 if (IMessage_OpenProperty(msg, PR_BODY_A, &IID_IStream, 0,
187 MAPI_MODIFY | MAPI_CREATE, (LPUNKNOWN*) &stream) == S_OK)
188 {
189 IStream_Write(stream, message->lpszNoteText, strlen(message->lpszNoteText)+1, NULL);
190 IStream_Release(stream);
191 }
192 }
193
194 /* Add message attachments */
195 if (message->nFileCount > 0)
196 {
197 ULONG num_attach = 0;
198 int i, j;
199
200 for (i = 0; i < message->nFileCount; i++)
201 {
202 IAttach* attachment = NULL;
203 SPropValue prop[4];
204 LPCSTR filename;
205 HANDLE file;
206
207 if (!message->lpFiles[i].lpszPathName)
208 continue;
209
210 /* Open the attachment for reading */
211 file = CreateFileA(message->lpFiles[i].lpszPathName, GENERIC_READ, FILE_SHARE_READ,
212 NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
213
214 if (file == INVALID_HANDLE_VALUE)
215 continue;
216
217 /* Check if a display filename has been given; if not, get one ourselves from path name */
218 filename = message->lpFiles[i].lpszFileName;
219
220 if (!filename)
221 {
222 filename = message->lpFiles[i].lpszPathName;
223
224 for (j = strlen(message->lpFiles[i].lpszPathName)-1; j >= 0; j--)
225 {
226 if (message->lpFiles[i].lpszPathName[i] == '\\' ||
227 message->lpFiles[i].lpszPathName[i] == '/')
228 {
229 filename = &message->lpFiles[i].lpszPathName[i+1];
230 break;
231 }
232 }
233 }
234
235 TRACE("Attachment %d path: '%s'; filename: '%s'\n", i, debugstr_a(message->lpFiles[i].lpszPathName),
236 debugstr_a(filename));
237
238 /* Create the attachment */
239 if (IMessage_CreateAttach(msg, NULL, 0, &num_attach, &attachment) != S_OK)
240 {
241 TRACE("Unable to create attachment\n");
242 CloseHandle(file);
243 continue;
244 }
245
246 /* Set the attachment properties */
247 ZeroMemory(prop, sizeof(prop));
248
249 prop[0].ulPropTag = PR_ATTACH_METHOD;
250 prop[0].Value.ul = ATTACH_BY_VALUE;
251 prop[1].ulPropTag = PR_ATTACH_LONG_FILENAME_A;
252 prop[1].Value.lpszA = (LPSTR) filename;
253 prop[2].ulPropTag = PR_ATTACH_FILENAME_A;
254 prop[2].Value.lpszA = (LPSTR) filename;
255 prop[3].ulPropTag = PR_RENDERING_POSITION;
256 prop[3].Value.l = -1;
257
258 if (IAttach_SetProps(attachment, 4, prop, NULL) == S_OK)
259 {
260 LPSTREAM stream = NULL;
261
262 if (IAttach_OpenProperty(attachment, PR_ATTACH_DATA_BIN, &IID_IStream, 0,
263 MAPI_MODIFY | MAPI_CREATE, (LPUNKNOWN*) &stream) == S_OK)
264 {
265 BYTE data[READ_BUF_SIZE];
266 DWORD size = 0, read, written;
267
268 while (ReadFile(file, data, READ_BUF_SIZE, &read, NULL) && (read != 0))
269 {
270 IStream_Write(stream, data, read, &written);
271 size += read;
272 }
273
274 TRACE("%d bytes read, %d bytes written of attachment\n", read, written);
275
276 IStream_Commit(stream, STGC_DEFAULT);
277 IStream_Release(stream);
278
279 prop[0].ulPropTag = PR_ATTACH_SIZE;
280 prop[0].Value.ul = size;
281 IAttach_SetProps(attachment, 1, prop, NULL);
282
283 IAttach_SaveChanges(attachment, KEEP_OPEN_READONLY);
284 num_attach++;
285 }
286 }
287
288 CloseHandle(file);
289 IAttach_Release(attachment);
290 }
291 }
292
293 IMessage_SaveChanges(msg, KEEP_OPEN_READWRITE);
294
295 /* Prepare the message form */
296
297 if (IMAPISession_PrepareForm(session, NULL, msg, &token) == S_OK)
298 {
299 ULONG access = 0, status = 0, flags = 0, pc = 0;
300 ULONG pT[2] = {1, PR_MSG_STATUS};
301
302 /* Retrieve message status, flags, access rights and class */
303
304 if (IMessage_GetProps(msg, (LPSPropTagArray) pT, 0, &pc, &props) == S_OK)
305 {
306 status = props->Value.ul;
307 MAPIFreeBuffer(props);
308 }
309
310 pT[1] = PR_MESSAGE_FLAGS;
311
312 if (IMessage_GetProps(msg, (LPSPropTagArray) pT, 0, &pc, &props) == S_OK)
313 {
314 flags = props->Value.ul;
315 MAPIFreeBuffer(props);
316 }
317
318 pT[1] = PR_ACCESS;
319
320 if (IMessage_GetProps(msg, (LPSPropTagArray) pT, 0, &pc, &props) == S_OK)
321 {
322 access = props->Value.ul;
323 MAPIFreeBuffer(props);
324 }
325
326 pT[1] = PR_MESSAGE_CLASS_A;
327
328 if (IMessage_GetProps(msg, (LPSPropTagArray) pT, 0, &pc, &props) == S_OK)
329 {
330 /* Show the message form (edit window) */
331
332 ret = IMAPISession_ShowForm(session, 0, msg_store, draft_folder, NULL,
333 token, NULL, 0, status, flags, access,
334 props->Value.lpszA);
335
336 switch (ret)
337 {
338 case S_OK:
339 retval = SUCCESS_SUCCESS;
340 break;
341
342 case MAPI_E_USER_CANCEL:
343 retval = MAPI_E_USER_ABORT;
344 break;
345
346 default:
347 TRACE("ShowForm failure: %x\n", ret);
348 break;
349 }
350 }
351 }
352
353 IMessage_Release(msg);
354 }
355
356 /* Free up the resources we've used */
357 IMAPIFolder_Release(draft_folder);
358 if (folder) IMAPIFolder_Release(folder);
359 IMsgStore_Release(msg_store);
360
361 logoff: ;
362 IMAPISession_Logoff(session, 0, 0, 0);
363 IMAPISession_Release(session);
364
365 cleanup: ;
366 MAPIUninitialize();
367 return retval;
368 }
369
370 /**************************************************************************
371 * MAPISendMail (MAPI32.211)
372 *
373 * Send a mail.
374 *
375 * PARAMS
376 * session [I] Handle to a MAPI session.
377 * uiparam [I] Parent window handle.
378 * message [I] Pointer to a MAPIMessage structure.
379 * flags [I] Flags.
380 * reserved [I] Reserved, pass 0.
381 *
382 * RETURNS
383 * Success: SUCCESS_SUCCESS
384 * Failure: MAPI_E_FAILURE
385 *
386 * NOTES
387 * The fallback procedure is a temporary hack.
388 */
389 ULONG WINAPI MAPISendMail( LHANDLE session, ULONG_PTR uiparam,
390 lpMapiMessage message, FLAGS flags, ULONG reserved )
391 {
392 ULONG ret = MAPI_E_FAILURE;
393 unsigned int i, to_count = 0, cc_count = 0, bcc_count = 0;
394 unsigned int to_size = 0, cc_size = 0, bcc_size = 0, subj_size, body_size;
395
396 char *to = NULL, *cc = NULL, *bcc = NULL;
397 const char *address, *subject, *body;
398 static const char format[] =
399 "mailto:\"%s\"?subject=\"%s\"&cc=\"%s\"&bcc=\"%s\"&body=\"%s\"";
400 char *mailto = NULL, *escape = NULL;
401 char empty_string[] = "";
402 HRESULT res;
403 DWORD size;
404
405 TRACE( "(0x%08x 0x%08lx %p 0x%08x 0x%08x)\n", session, uiparam,
406 message, flags, reserved );
407
408 /* Check to see if we have a Simple MAPI provider loaded */
409 if (mapiFunctions.MAPISendMail)
410 return mapiFunctions.MAPISendMail(session, uiparam, message, flags, reserved);
411
412 /* Check if we have an Extended MAPI provider - if so, use our wrapper */
413 if (MAPIInitialize(NULL) == S_OK)
414 return sendmail_extended_mapi(session, uiparam, message, flags, reserved);
415
416 /* Fall back on our own implementation */
417 if (!message) return MAPI_E_FAILURE;
418
419 for (i = 0; i < message->nRecipCount; i++)
420 {
421 if (!message->lpRecips)
422 {
423 WARN("No recipients found\n");
424 return MAPI_E_FAILURE;
425 }
426
427 address = message->lpRecips[i].lpszAddress;
428 if (address)
429 {
430 switch (message->lpRecips[i].ulRecipClass)
431 {
432 case MAPI_ORIG:
433 TRACE( "From: %s\n", debugstr_a(address) );
434 break;
435 case MAPI_TO:
436 TRACE( "To: %s\n", debugstr_a(address) );
437 to_size += lstrlenA( address ) + 1;
438 break;
439 case MAPI_CC:
440 TRACE( "Cc: %s\n", debugstr_a(address) );
441 cc_size += lstrlenA( address ) + 1;
442 break;
443 case MAPI_BCC:
444 TRACE( "Bcc: %s\n", debugstr_a(address) );
445 bcc_size += lstrlenA( address ) + 1;
446 break;
447 default:
448 TRACE( "Unknown recipient class: %d\n",
449 message->lpRecips[i].ulRecipClass );
450 }
451 }
452 else
453 FIXME("Name resolution and entry identifiers not supported\n");
454 }
455 if (message->nFileCount) FIXME("Ignoring attachments\n");
456
457 subject = message->lpszSubject ? message->lpszSubject : "";
458 body = message->lpszNoteText ? message->lpszNoteText : "";
459
460 TRACE( "Subject: %s\n", debugstr_a(subject) );
461 TRACE( "Body: %s\n", debugstr_a(body) );
462
463 subj_size = lstrlenA( subject );
464 body_size = lstrlenA( body );
465
466 ret = MAPI_E_INSUFFICIENT_MEMORY;
467 if (to_size)
468 {
469 to = HeapAlloc( GetProcessHeap(), 0, to_size );
470 if (!to) goto exit;
471 to[0] = 0;
472 }
473 if (cc_size)
474 {
475 cc = HeapAlloc( GetProcessHeap(), 0, cc_size );
476 if (!cc) goto exit;
477 cc[0] = 0;
478 }
479 if (bcc_size)
480 {
481 bcc = HeapAlloc( GetProcessHeap(), 0, bcc_size );
482 if (!bcc) goto exit;
483 bcc[0] = 0;
484 }
485
486 if (message->lpOriginator)
487 TRACE( "From: %s\n", debugstr_a(message->lpOriginator->lpszAddress) );
488
489 for (i = 0; i < message->nRecipCount; i++)
490 {
491 address = message->lpRecips[i].lpszAddress;
492 if (address)
493 {
494 switch (message->lpRecips[i].ulRecipClass)
495 {
496 case MAPI_TO:
497 if (to_count) lstrcatA( to, "," );
498 lstrcatA( to, address );
499 to_count++;
500 break;
501 case MAPI_CC:
502 if (cc_count) lstrcatA( cc, "," );
503 lstrcatA( cc, address );
504 cc_count++;
505 break;
506 case MAPI_BCC:
507 if (bcc_count) lstrcatA( bcc, "," );
508 lstrcatA( bcc, address );
509 bcc_count++;
510 break;
511 }
512 }
513 }
514 ret = MAPI_E_FAILURE;
515 size = sizeof(format) + to_size + cc_size + bcc_size + subj_size + body_size;
516
517 mailto = HeapAlloc( GetProcessHeap(), 0, size );
518 if (!mailto) goto exit;
519
520 sprintf( mailto, format, to ? to : "", subject, cc ? cc : "", bcc ? bcc : "", body );
521
522 size = 1;
523 res = UrlEscapeA( mailto, empty_string, &size, URL_ESCAPE_SPACES_ONLY );
524 if (res != E_POINTER) goto exit;
525
526 escape = HeapAlloc( GetProcessHeap(), 0, size );
527 if (!escape) goto exit;
528
529 res = UrlEscapeA( mailto, escape, &size, URL_ESCAPE_SPACES_ONLY );
530 if (res != S_OK) goto exit;
531
532 if ((UINT_PTR)ShellExecuteA( NULL, "open", escape, NULL, NULL, 0 ) > 32)
533 ret = SUCCESS_SUCCESS;
534
535 exit:
536 HeapFree( GetProcessHeap(), 0, to );
537 HeapFree( GetProcessHeap(), 0, cc );
538 HeapFree( GetProcessHeap(), 0, bcc );
539 HeapFree( GetProcessHeap(), 0, mailto );
540 HeapFree( GetProcessHeap(), 0, escape );
541
542 return ret;
543 }
544
545 ULONG WINAPI MAPISendDocuments(ULONG_PTR uiparam, LPSTR delim, LPSTR paths,
546 LPSTR filenames, ULONG reserved)
547 {
548 if (mapiFunctions.MAPISendDocuments)
549 return mapiFunctions.MAPISendDocuments(uiparam, delim, paths, filenames, reserved);
550
551 return MAPI_E_NOT_SUPPORTED;
552 }
A free Windows-compatible Operating System