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
  23 #include <stdio.h>
  24 #include <stdarg.h>
  25
  26 #define COBJMACROS
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winerror.h"
  31 #include "winuser.h"
  32 #include "objbase.h"
  33 #include "objidl.h"
  34 #include "mapi.h"
  35 #include "mapix.h"
  36 #include "mapiutil.h"
  37 #include "mapidefs.h"
  38 #include "winreg.h"
  39 #include "shellapi.h"
  40 #include "shlwapi.h"
  41 #include "wine/debug.h"
  42 #include "util.h"
  43 #include "res.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(mapi);
  46
  47 #define READ_BUF_SIZE    4096
  48
  49 #define STORE_UNICODE_OK  0x00040000
  50
  51 static LPSTR convert_from_unicode(LPCWSTR wstr)
  52 {
  53     LPSTR str;
  54     DWORD len;
  55
  56     if (!wstr)
  57         return NULL;
  58
  59     len = WideCharToMultiByte(CP_ACP, 0, wstr, -1, NULL, 0, NULL, NULL);
  60     str = HeapAlloc(GetProcessHeap(), 0, len);
  61     WideCharToMultiByte(CP_ACP, 0, wstr, -1, str, len, NULL, NULL);
  62
  63     return str;
  64 }
  65
  66 static LPWSTR convert_to_unicode(LPSTR str)
  67 {
  68     LPWSTR wstr;
  69     DWORD len;
  70
  71     if (!str)
  72         return NULL;
  73
  74     len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
  75     wstr = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
  76     MultiByteToWideChar(CP_ACP, 0, str, -1, wstr, len);
  77
  78     return wstr;
  79 }
  80
  81 /*
  82    Internal function to send a message via Extended MAPI. Wrapper around the Simple
  83    MAPI function MAPISendMail.
  84 */
  85 static ULONG sendmail_extended_mapi(LHANDLE mapi_session, ULONG_PTR uiparam, lpMapiMessageW message,
  86     FLAGS flags)
  87 {
  88     ULONG tags[] = {1, 0};
  89     char *subjectA = NULL, *bodyA = NULL;
  90     ULONG retval = MAPI_E_FAILURE;
  91     IMAPISession *session = NULL;
  92     BOOL unicode_aware = FALSE;
  93     IMAPITable* msg_table;
  94     LPSRowSet rows = NULL;
  95     IMsgStore* msg_store;
  96     IMAPIFolder* folder = NULL, *draft_folder = NULL;
  97     LPENTRYID entry_id;
  98     LPSPropValue props;
  99     ULONG entry_len;
 100     DWORD obj_type;
 101     IMessage* msg;
 102     ULONG values;
 103     HRESULT ret;
 104
 105     TRACE("Using Extended MAPI wrapper for MAPISendMail\n");
 106
 107     /* Attempt to log on via Extended MAPI */
 108
 109     ret = MAPILogonEx(0, NULL, NULL, MAPI_EXTENDED | MAPI_USE_DEFAULT | MAPI_NEW_SESSION, &session);
 110     TRACE("MAPILogonEx: %x\n", ret);
 111
 112     if (ret != S_OK)
 113     {
 114         retval = MAPI_E_LOGIN_FAILURE;
 115         goto cleanup;
 116     }
 117
 118     /* Open the default message store */
 119
 120     if (IMAPISession_GetMsgStoresTable(session, 0, &msg_table) == S_OK)
 121     {
 122         /* We want the default store */
 123         SizedSPropTagArray(2, columns) = {2, {PR_ENTRYID, PR_DEFAULT_STORE}};
 124
 125         /* Set the columns we want */
 126         if (IMAPITable_SetColumns(msg_table, (LPSPropTagArray) &columns, 0) == S_OK)
 127         {
 128             while (1)
 129             {
 130                 if (IMAPITable_QueryRows(msg_table, 1, 0, &rows) != S_OK)
 131                 {
 132                     MAPIFreeBuffer(rows);
 133                     rows = NULL;
 134                 }
 135                 else if (rows->cRows != 1)
 136                 {
 137                     FreeProws(rows);
 138                     rows = NULL;
 139                 }
 140                 else
 141                 {
 142                     /* If it's not the default store, try the next row */
 143                     if (!rows->aRow[0].lpProps[1].Value.b)
 144                     {
 145                         FreeProws(rows);
 146                         continue;
 147                     }
 148                 }
 149
 150                 break;
 151             }
 152         }
 153
 154         IMAPITable_Release(msg_table);
 155     }
 156
 157     /* Did we manage to get the right store? */
 158     if (!rows)
 159         goto logoff;
 160
 161     /* Open the message store */
 162     IMAPISession_OpenMsgStore(session, 0, rows->aRow[0].lpProps[0].Value.bin.cb,
 163                               (ENTRYID *) rows->aRow[0].lpProps[0].Value.bin.lpb, NULL,
 164                               MDB_NO_DIALOG | MAPI_BEST_ACCESS, &msg_store);
 165
 166     /* We don't need this any more */
 167     FreeProws(rows);
 168
 169     /* Check if the message store supports Unicode */
 170     tags[1] = PR_STORE_SUPPORT_MASK;
 171     ret = IMsgStore_GetProps(msg_store, (LPSPropTagArray) tags, 0, &values, &props);
 172
 173     if ((ret == S_OK) && (props[0].Value.l & STORE_UNICODE_OK))
 174         unicode_aware = TRUE;
 175     else
 176     {
 177         /* Don't convert to ANSI */
 178         if (flags & MAPI_FORCE_UNICODE)
 179         {
 180             WARN("No Unicode-capable mail client, and MAPI_FORCE_UNICODE is specified. MAPISendMail failed.\n");
 181             retval = MAPI_E_UNICODE_NOT_SUPPORTED;
 182             IMsgStore_Release(msg_store);
 183             goto logoff;
 184         }
 185     }
 186
 187     /* First open the inbox, from which the drafts folder can be opened */
 188     if (IMsgStore_GetReceiveFolder(msg_store, NULL, 0, &entry_len, &entry_id, NULL) == S_OK)
 189     {
 190         IMsgStore_OpenEntry(msg_store, entry_len, entry_id, NULL, 0, &obj_type, (LPUNKNOWN*) &folder);
 191         MAPIFreeBuffer(entry_id);
 192     }
 193
 194     tags[1] = PR_IPM_DRAFTS_ENTRYID;
 195
 196     /* Open the drafts folder, or failing that, try asking the message store for the outbox */
 197     if ((folder == NULL) || ((ret = IMAPIFolder_GetProps(folder, (LPSPropTagArray) tags, 0, &values, &props)) != S_OK))
 198     {
 199         TRACE("Unable to open Drafts folder; opening Outbox instead\n");
 200         tags[1] = PR_IPM_OUTBOX_ENTRYID;
 201         ret = IMsgStore_GetProps(msg_store, (LPSPropTagArray) tags, 0, &values, &props);
 202     }
 203
 204     if (ret != S_OK)
 205         goto logoff;
 206
 207     IMsgStore_OpenEntry(msg_store, props[0].Value.bin.cb, (LPENTRYID) props[0].Value.bin.lpb,
 208         NULL, MAPI_MODIFY, &obj_type, (LPUNKNOWN *) &draft_folder);
 209
 210     /* Create a new message */
 211     if (IMAPIFolder_CreateMessage(draft_folder, NULL, 0, &msg) == S_OK)
 212     {
 213         ULONG token;
 214         SPropValue p;
 215
 216         /* Define message properties */
 217         p.ulPropTag = PR_MESSAGE_FLAGS;
 218         p.Value.l = MSGFLAG_FROMME | MSGFLAG_UNSENT;
 219
 220         IMessage_SetProps(msg, 1, &p, NULL);
 221
 222         p.ulPropTag = PR_SENTMAIL_ENTRYID;
 223         p.Value.bin.cb = props[0].Value.bin.cb;
 224         p.Value.bin.lpb = props[0].Value.bin.lpb;
 225         IMessage_SetProps(msg, 1,&p, NULL);
 226
 227         /* Set message subject */
 228         if (message->lpszSubject)
 229         {
 230             if (unicode_aware)
 231             {
 232                 p.ulPropTag = PR_SUBJECT_W;
 233                 p.Value.lpszW = message->lpszSubject;
 234             }
 235             else
 236             {
 237                 subjectA = convert_from_unicode(message->lpszSubject);
 238
 239                 p.ulPropTag = PR_SUBJECT_A;
 240                 p.Value.lpszA = subjectA;
 241             }
 242
 243             IMessage_SetProps(msg, 1, &p, NULL);
 244         }
 245
 246         /* Set message body */
 247         if (message->lpszNoteText)
 248         {
 249             LPSTREAM stream = NULL;
 250
 251             if (IMessage_OpenProperty(msg, unicode_aware ? PR_BODY_W : PR_BODY_A, &IID_IStream, 0,
 252                 MAPI_MODIFY | MAPI_CREATE, (LPUNKNOWN*) &stream) == S_OK)
 253             {
 254                 if (unicode_aware)
 255                     IStream_Write(stream, message->lpszNoteText, (lstrlenW(message->lpszNoteText)+1) * sizeof(WCHAR), NULL);
 256                 else
 257                 {
 258                     bodyA = convert_from_unicode(message->lpszNoteText);
 259                     IStream_Write(stream, bodyA, strlen(bodyA)+1, NULL);
 260                 }
 261
 262                 IStream_Release(stream);
 263             }
 264         }
 265
 266         /* Add message attachments */
 267         if (message->nFileCount > 0)
 268         {
 269             ULONG num_attach = 0;
 270             unsigned int i;
 271
 272             for (i = 0; i < message->nFileCount; i++)
 273             {
 274                 IAttach* attachment = NULL;
 275                 char *filenameA = NULL;
 276                 SPropValue prop[4];
 277                 LPCWSTR filename;
 278                 HANDLE file;
 279
 280                 if (!message->lpFiles[i].lpszPathName)
 281                     continue;
 282
 283                 /* Open the attachment for reading */
 284                 file = CreateFileW(message->lpFiles[i].lpszPathName, GENERIC_READ, FILE_SHARE_READ,
 285                     NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 286
 287                 if (file == INVALID_HANDLE_VALUE)
 288                     continue;
 289
 290                 /* Check if a display filename has been given; if not, get one ourselves from path name */
 291                 filename = message->lpFiles[i].lpszFileName;
 292
 293                 if (!filename)
 294                 {
 295                     int j;
 296
 297                     filename = message->lpFiles[i].lpszPathName;
 298
 299                     for (j = lstrlenW(message->lpFiles[i].lpszPathName)-1; j >= 0; j--)
 300                     {
 301                         if (message->lpFiles[i].lpszPathName[i] == '\\' ||
 302                             message->lpFiles[i].lpszPathName[i] == '/')
 303                         {
 304                             filename = &message->lpFiles[i].lpszPathName[i+1];
 305                             break;
 306                         }
 307                     }
 308                 }
 309
 310                 TRACE("Attachment %u path: '%s'; filename: '%s'\n", i, debugstr_w(message->lpFiles[i].lpszPathName),
 311                     debugstr_w(filename));
 312
 313                 /* Create the attachment */
 314                 if (IMessage_CreateAttach(msg, NULL, 0, &num_attach, &attachment) != S_OK)
 315                 {
 316                     TRACE("Unable to create attachment\n");
 317                     CloseHandle(file);
 318                     continue;
 319                 }
 320
 321                 /* Set the attachment properties */
 322                 ZeroMemory(prop, sizeof(prop));
 323
 324                 prop[0].ulPropTag = PR_ATTACH_METHOD;
 325                 prop[0].Value.ul = ATTACH_BY_VALUE;
 326
 327                 if (unicode_aware)
 328                 {
 329                     prop[1].ulPropTag = PR_ATTACH_LONG_FILENAME_W;
 330                     prop[1].Value.lpszW = (LPWSTR) filename;
 331                     prop[2].ulPropTag = PR_ATTACH_FILENAME_W;
 332                     prop[2].Value.lpszW = (LPWSTR) filename;
 333                 }
 334                 else
 335                 {
 336                     filenameA = convert_from_unicode(filename);
 337
 338                     prop[1].ulPropTag = PR_ATTACH_LONG_FILENAME_A;
 339                     prop[1].Value.lpszA = (LPSTR) filenameA;
 340                     prop[2].ulPropTag = PR_ATTACH_FILENAME_A;
 341                     prop[2].Value.lpszA = (LPSTR) filenameA;
 342
 343                 }
 344
 345                 prop[3].ulPropTag = PR_RENDERING_POSITION;
 346                 prop[3].Value.l = -1;
 347
 348                 if (IAttach_SetProps(attachment, 4, prop, NULL) == S_OK)
 349                 {
 350                     LPSTREAM stream = NULL;
 351
 352                     if (IAttach_OpenProperty(attachment, PR_ATTACH_DATA_BIN, &IID_IStream, 0,
 353                         MAPI_MODIFY | MAPI_CREATE, (LPUNKNOWN*) &stream) == S_OK)
 354                     {
 355                         BYTE data[READ_BUF_SIZE];
 356                         DWORD size = 0, read, written;
 357
 358                         while (ReadFile(file, data, READ_BUF_SIZE, &read, NULL) && (read != 0))
 359                         {
 360                             IStream_Write(stream, data, read, &written);
 361                             size += read;
 362                         }
 363
 364                         TRACE("%d bytes written of attachment\n", size);
 365
 366                         IStream_Commit(stream, STGC_DEFAULT);
 367                         IStream_Release(stream);
 368
 369                         prop[0].ulPropTag = PR_ATTACH_SIZE;
 370                         prop[0].Value.ul = size;
 371                         IAttach_SetProps(attachment, 1, prop, NULL);
 372
 373                         IAttach_SaveChanges(attachment, KEEP_OPEN_READONLY);
 374                         num_attach++;
 375                     }
 376                 }
 377
 378                 CloseHandle(file);
 379                 IAttach_Release(attachment);
 380
 381                 HeapFree(GetProcessHeap(), 0, filenameA);
 382             }
 383         }
 384
 385         IMessage_SaveChanges(msg, KEEP_OPEN_READWRITE);
 386
 387         /* Prepare the message form */
 388
 389         if (IMAPISession_PrepareForm(session, NULL, msg, &token) == S_OK)
 390         {
 391             ULONG access = 0, status = 0, message_flags = 0, pc = 0;
 392             ULONG pT[2] = {1, PR_MSG_STATUS};
 393
 394             /* Retrieve message status, flags, access rights and class */
 395
 396             if (IMessage_GetProps(msg, (LPSPropTagArray) pT, 0, &pc, &props) == S_OK)
 397             {
 398                 status = props->Value.ul;
 399                 MAPIFreeBuffer(props);
 400             }
 401
 402             pT[1] = PR_MESSAGE_FLAGS;
 403
 404             if (IMessage_GetProps(msg, (LPSPropTagArray) pT, 0, &pc, &props) == S_OK)
 405             {
 406                 message_flags = props->Value.ul;
 407                 MAPIFreeBuffer(props);
 408             }
 409
 410             pT[1] = PR_ACCESS;
 411
 412             if (IMessage_GetProps(msg, (LPSPropTagArray) pT, 0, &pc, &props) == S_OK)
 413             {
 414                 access = props->Value.ul;
 415                 MAPIFreeBuffer(props);
 416             }
 417
 418             pT[1] = PR_MESSAGE_CLASS_A;
 419
 420             if (IMessage_GetProps(msg, (LPSPropTagArray) pT, 0, &pc, &props) == S_OK)
 421             {
 422                 /* Show the message form (edit window) */
 423
 424                 ret = IMAPISession_ShowForm(session, 0, msg_store, draft_folder, NULL,
 425                                             token, NULL, 0, status, message_flags, access,
 426                                             props->Value.lpszA);
 427
 428                 switch (ret)
 429                 {
 430                     case S_OK:
 431                         retval = SUCCESS_SUCCESS;
 432                         break;
 433
 434                     case MAPI_E_USER_CANCEL:
 435                         retval = MAPI_E_USER_ABORT;
 436                         break;
 437
 438                     default:
 439                         TRACE("ShowForm failure: %x\n", ret);
 440                         break;
 441                 }
 442             }
 443         }
 444
 445         IMessage_Release(msg);
 446     }
 447
 448     /* Free up the resources we've used */
 449     IMAPIFolder_Release(draft_folder);
 450     if (folder) IMAPIFolder_Release(folder);
 451     IMsgStore_Release(msg_store);
 452
 453     HeapFree(GetProcessHeap(), 0, subjectA);
 454     HeapFree(GetProcessHeap(), 0, bodyA);
 455
 456 logoff: ;
 457     IMAPISession_Logoff(session, 0, 0, 0);
 458     IMAPISession_Release(session);
 459
 460 cleanup: ;
 461     MAPIUninitialize();
 462     return retval;
 463 }
 464
 465 /**************************************************************************
 466  *  MAPISendMail        (MAPI32.211)
 467  *
 468  * Send a mail.
 469  *
 470  * PARAMS
 471  *  session  [I] Handle to a MAPI session.
 472  *  uiparam  [I] Parent window handle.
 473  *  message  [I] Pointer to a MAPIMessage structure.
 474  *  flags    [I] Flags.
 475  *  reserved [I] Reserved, pass 0.
 476  *
 477  * RETURNS
 478  *  Success: SUCCESS_SUCCESS
 479  *  Failure: MAPI_E_FAILURE
 480  *
 481  */
 482 ULONG WINAPI MAPISendMail( LHANDLE session, ULONG_PTR uiparam,
 483     lpMapiMessage message, FLAGS flags, ULONG reserved )
 484 {
 485     WCHAR msg_title[READ_BUF_SIZE], error_msg[READ_BUF_SIZE];
 486
 487     /* Check to see if we have a Simple MAPI provider loaded */
 488     if (mapiFunctions.MAPISendMail)
 489         return mapiFunctions.MAPISendMail(session, uiparam, message, flags, reserved);
 490
 491     /* Check if we have an Extended MAPI provider - if so, use our wrapper */
 492     if (MAPIInitialize(NULL) == S_OK)
 493     {
 494         MapiMessageW messageW;
 495         ULONG ret;
 496
 497         ZeroMemory(&messageW, sizeof(MapiMessageW));
 498
 499         /* Convert the entries we need to Unicode */
 500         messageW.lpszSubject = convert_to_unicode(message->lpszSubject);
 501         messageW.lpszNoteText = convert_to_unicode(message->lpszNoteText);
 502         messageW.nFileCount = message->nFileCount;
 503
 504         if (message->nFileCount && message->lpFiles)
 505         {
 506             lpMapiFileDescW filesW;
 507             unsigned int i;
 508
 509             filesW = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MapiFileDescW) * message->nFileCount);
 510
 511             for (i = 0; i < message->nFileCount; i++)
 512             {
 513                 filesW[i].lpszPathName = convert_to_unicode(message->lpFiles[i].lpszPathName);
 514                 filesW[i].lpszFileName = convert_to_unicode(message->lpFiles[i].lpszFileName);
 515             }
 516
 517             messageW.lpFiles = filesW;
 518         }
 519
 520         ret = sendmail_extended_mapi(session, uiparam, &messageW, flags);
 521
 522         /* Now free everything we allocated */
 523         if (message->nFileCount && message->lpFiles)
 524         {
 525             unsigned int i;
 526
 527             for (i = 0; i < message->nFileCount; i++)
 528             {
 529                 HeapFree(GetProcessHeap(), 0, messageW.lpFiles[i].lpszPathName);
 530                 HeapFree(GetProcessHeap(), 0, messageW.lpFiles[i].lpszFileName);
 531             }
 532
 533             HeapFree(GetProcessHeap(), 0, messageW.lpFiles);
 534         }
 535
 536         HeapFree(GetProcessHeap(), 0, messageW.lpszSubject);
 537         HeapFree(GetProcessHeap(), 0, messageW.lpszNoteText);
 538
 539         return ret;
 540     }
 541
 542     /* Display an error message since we apparently have no mail clients */
 543     LoadStringW(hInstMAPI32, IDS_NO_MAPI_CLIENT, error_msg, ARRAY_SIZE(error_msg));
 544     LoadStringW(hInstMAPI32, IDS_SEND_MAIL, msg_title, ARRAY_SIZE(msg_title));
 545
 546     MessageBoxW((HWND) uiparam, error_msg, msg_title, MB_ICONEXCLAMATION);
 547
 548     return MAPI_E_NOT_SUPPORTED;
 549 }
 550
 551 static lpMapiRecipDesc convert_recipient_from_unicode(lpMapiRecipDescW recipW, lpMapiRecipDesc dest)
 552 {
 553     lpMapiRecipDesc ret;
 554
 555     if (!recipW)
 556         return NULL;
 557
 558     if (dest)
 559         ret = dest;
 560     else
 561         ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MapiRecipDesc));
 562
 563     ret->ulRecipClass = recipW->ulRecipClass;
 564     ret->lpszName = convert_from_unicode(recipW->lpszName);
 565     ret->lpszAddress = convert_from_unicode(recipW->lpszAddress);
 566     ret->ulEIDSize = recipW->ulEIDSize;
 567     ret->lpEntryID = recipW->lpEntryID;
 568
 569     return ret;
 570 }
 571
 572 /**************************************************************************
 573  *  MAPISendMailW       (MAPI32.256)
 574  *
 575  * Send a mail.
 576  *
 577  * PARAMS
 578  *  session  [I] Handle to a MAPI session.
 579  *  uiparam  [I] Parent window handle.
 580  *  message  [I] Pointer to a MAPIMessageW structure.
 581  *  flags    [I] Flags.
 582  *  reserved [I] Reserved, pass 0.
 583  *
 584  * RETURNS
 585  *  Success: SUCCESS_SUCCESS
 586  *  Failure: MAPI_E_FAILURE
 587  *
 588  */
 589 ULONG WINAPI MAPISendMailW(LHANDLE session, ULONG_PTR uiparam,
 590     lpMapiMessageW message, FLAGS flags, ULONG reserved)
 591 {
 592     WCHAR msg_title[READ_BUF_SIZE], error_msg[READ_BUF_SIZE];
 593
 594     /* Check to see if we have a Simple MAPI provider loaded */
 595     if (mapiFunctions.MAPISendMailW)
 596         return mapiFunctions.MAPISendMailW(session, uiparam, message, flags, reserved);
 597
 598     /* Check if we have an Extended MAPI provider - if so, use our wrapper */
 599     if (MAPIInitialize(NULL) == S_OK)
 600         return sendmail_extended_mapi(session, uiparam, message, flags);
 601
 602     if (mapiFunctions.MAPISendMail)
 603     {
 604         MapiMessage messageA;
 605         ULONG ret;
 606
 607         if (flags & MAPI_FORCE_UNICODE)
 608             return MAPI_E_UNICODE_NOT_SUPPORTED;
 609
 610         /* Convert to ANSI and send to MAPISendMail */
 611         ZeroMemory(&messageA, sizeof(MapiMessage));
 612
 613         messageA.lpszSubject = convert_from_unicode(message->lpszSubject);
 614         messageA.lpszNoteText = convert_from_unicode(message->lpszNoteText);
 615         messageA.lpszMessageType = convert_from_unicode(message->lpszMessageType);
 616         messageA.lpszDateReceived = convert_from_unicode(message->lpszDateReceived);
 617         messageA.lpszConversationID = convert_from_unicode(message->lpszConversationID);
 618         messageA.flFlags = message->flFlags;
 619         messageA.lpOriginator = convert_recipient_from_unicode(message->lpOriginator, NULL);
 620         messageA.nRecipCount = message->nRecipCount;
 621         messageA.nFileCount = message->nFileCount;
 622
 623         if (message->nRecipCount && message->lpRecips)
 624         {
 625             lpMapiRecipDesc recipsA;
 626             unsigned int i;
 627
 628             recipsA = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MapiRecipDesc) * message->nRecipCount);
 629
 630             for (i = 0; i < message->nRecipCount; i++)
 631             {
 632                 convert_recipient_from_unicode(&message->lpRecips[i], &recipsA[i]);
 633             }
 634
 635             messageA.lpRecips = recipsA;
 636         }
 637
 638         if (message->nFileCount && message->lpFiles)
 639         {
 640             lpMapiFileDesc filesA;
 641             unsigned int i;
 642
 643             filesA = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MapiFileDesc) * message->nFileCount);
 644
 645             for (i = 0; i < message->nFileCount; i++)
 646             {
 647                 filesA[i].flFlags = message->lpFiles[i].flFlags;
 648                 filesA[i].nPosition = message->lpFiles[i].nPosition;
 649                 filesA[i].lpszPathName = convert_from_unicode(message->lpFiles[i].lpszPathName);
 650                 filesA[i].lpszFileName = convert_from_unicode(message->lpFiles[i].lpszFileName);
 651                 filesA[i].lpFileType = message->lpFiles[i].lpFileType;
 652             }
 653
 654             messageA.lpFiles = filesA;
 655         }
 656
 657         ret = mapiFunctions.MAPISendMail(session, uiparam, &messageA, flags, reserved);
 658
 659         /* Now free everything we allocated */
 660         if (message->lpOriginator)
 661         {
 662             HeapFree(GetProcessHeap(), 0, messageA.lpOriginator->lpszName);
 663             HeapFree(GetProcessHeap(), 0, messageA.lpOriginator->lpszAddress);
 664             HeapFree(GetProcessHeap(), 0, messageA.lpOriginator);
 665         }
 666
 667         if (message->nRecipCount && message->lpRecips)
 668         {
 669             unsigned int i;
 670
 671             for (i = 0; i < message->nRecipCount; i++)
 672             {
 673                 HeapFree(GetProcessHeap(), 0, messageA.lpRecips[i].lpszName);
 674                 HeapFree(GetProcessHeap(), 0, messageA.lpRecips[i].lpszAddress);
 675             }
 676
 677             HeapFree(GetProcessHeap(), 0, messageA.lpRecips);
 678         }
 679
 680         if (message->nFileCount && message->lpFiles)
 681         {
 682             unsigned int i;
 683
 684             for (i = 0; i < message->nFileCount; i++)
 685             {
 686                 HeapFree(GetProcessHeap(), 0, messageA.lpFiles[i].lpszPathName);
 687                 HeapFree(GetProcessHeap(), 0, messageA.lpFiles[i].lpszFileName);
 688             }
 689
 690             HeapFree(GetProcessHeap(), 0, messageA.lpFiles);
 691         }
 692
 693         HeapFree(GetProcessHeap(), 0, messageA.lpszSubject);
 694         HeapFree(GetProcessHeap(), 0, messageA.lpszNoteText);
 695         HeapFree(GetProcessHeap(), 0, messageA.lpszDateReceived);
 696         HeapFree(GetProcessHeap(), 0, messageA.lpszConversationID);
 697
 698         return ret;
 699     }
 700
 701     /* Display an error message since we apparently have no mail clients */
 702     LoadStringW(hInstMAPI32, IDS_NO_MAPI_CLIENT, error_msg, ARRAY_SIZE(error_msg));
 703     LoadStringW(hInstMAPI32, IDS_SEND_MAIL, msg_title, ARRAY_SIZE(msg_title));
 704
 705     MessageBoxW((HWND) uiparam, error_msg, msg_title, MB_ICONEXCLAMATION);
 706
 707     return MAPI_E_NOT_SUPPORTED;
 708 }
 709
 710 ULONG WINAPI MAPISendDocuments(ULONG_PTR uiparam, LPSTR delim, LPSTR paths,
 711     LPSTR filenames, ULONG reserved)
 712 {
 713     if (mapiFunctions.MAPISendDocuments)
 714         return mapiFunctions.MAPISendDocuments(uiparam, delim, paths, filenames, reserved);
 715
 716     return MAPI_E_NOT_SUPPORTED;
 717 }