dlls/winemapi/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 "mapi.h"
  34 #include "winreg.h"
  35 #include "shellapi.h"
  36 #include "shlwapi.h"
  37 #include "winternl.h"
  38 #include "wine/debug.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(winemapi);
  41
  42 /* Escapes a string for use in mailto: URL */
  43 static char *escape_string(char *in, char *empty_string)
  44 {
  45     HRESULT res;
  46     DWORD size;
  47     char *escaped = NULL;
  48
  49     if (!in)
  50         return empty_string;
  51
  52     size = 1;
  53     res = UrlEscapeA(in, empty_string, &size, URL_ESCAPE_PERCENT | URL_ESCAPE_SEGMENT_ONLY);
  54
  55     if (res == E_POINTER)
  56     {
  57         escaped = HeapAlloc(GetProcessHeap(), 0, size);
  58
  59         if (!escaped)
  60             return in;
  61
  62         /* If for some reason UrlEscape fails, just send the original text */
  63         if (UrlEscapeA(in, escaped, &size, URL_ESCAPE_PERCENT | URL_ESCAPE_SEGMENT_ONLY) != S_OK)
  64         {
  65             HeapFree(GetProcessHeap(), 0, escaped);
  66             escaped = in;
  67         }
  68     }
  69
  70     return escaped ? escaped : empty_string;
  71 }
  72
  73 /**************************************************************************
  74  *  MAPISendMail
  75  *
  76  * Send a message using a native mail client.
  77  *
  78  * PARAMS
  79  *  session  [I] Handle to a MAPI session.
  80  *  uiparam  [I] Parent window handle.
  81  *  message  [I] Pointer to a MAPIMessage structure.
  82  *  flags    [I] Flags.
  83  *  reserved [I] Reserved, pass 0.
  84  *
  85  * RETURNS
  86  *  Success: SUCCESS_SUCCESS
  87  *  Failure: MAPI_E_FAILURE
  88  *
  89  */
  90 ULONG WINAPI MAPISendMail(LHANDLE session, ULONG_PTR uiparam,
  91     lpMapiMessage message, FLAGS flags, ULONG reserved)
  92 {
  93     ULONG ret = MAPI_E_FAILURE;
  94     unsigned int i, to_count = 0, cc_count = 0, bcc_count = 0;
  95     unsigned int to_size = 0, cc_size = 0, bcc_size = 0, subj_size, body_size;
  96
  97     char *to = NULL, *cc = NULL, *bcc = NULL, *subject = NULL, *body = NULL;
  98     const char *address;
  99     static const char format[] =
 100         "mailto:\"%s\"?subject=\"%s\"&cc=\"%s\"&bcc=\"%s\"&body=\"%s\"";
 101     static const char smtp[] = "smtp:";
 102     char *mailto = NULL, *escape = NULL;
 103     char empty_string[] = "";
 104     HRESULT res;
 105     DWORD size;
 106
 107     TRACE("(0x%08lx 0x%08lx %p 0x%08x 0x%08x)\n", session, uiparam,
 108            message, flags, reserved);
 109
 110     if (!message)
 111         return MAPI_E_FAILURE;
 112
 113     for (i = 0; i < message->nRecipCount; i++)
 114     {
 115         if (!message->lpRecips)
 116         {
 117             WARN("No recipients found\n");
 118             return MAPI_E_FAILURE;
 119         }
 120
 121         address = message->lpRecips[i].lpszAddress;
 122
 123         if (address)
 124         {
 125             if (!_strnicmp(address, smtp, sizeof(smtp) - 1))
 126                 address += sizeof(smtp) - 1;
 127
 128             switch (message->lpRecips[i].ulRecipClass)
 129             {
 130                 case MAPI_ORIG:
 131                     TRACE("From: %s\n", debugstr_a(address));
 132                     break;
 133
 134                 case MAPI_TO:
 135                     TRACE("To: %s\n", debugstr_a(address));
 136                     to_size += lstrlenA(address) + 1;
 137                     break;
 138
 139                 case MAPI_CC:
 140                     TRACE("Cc: %s\n", debugstr_a(address));
 141                     cc_size += lstrlenA(address) + 1;
 142                     break;
 143
 144                 case MAPI_BCC:
 145                     TRACE("Bcc: %s\n", debugstr_a(address));
 146                     bcc_size += lstrlenA(address) + 1;
 147                     break;
 148
 149                 default:
 150                     TRACE("Unknown recipient class: %d\n",
 151                            message->lpRecips[i].ulRecipClass);
 152             }
 153         }
 154         else
 155             FIXME("Name resolution and entry identifiers not supported\n");
 156     }
 157
 158     if (message->nFileCount)
 159     {
 160         FIXME("Ignoring %u attachments:\n", message->nFileCount);
 161         for (i = 0; i < message->nFileCount; i++)
 162             FIXME("\t%s (%s)\n", debugstr_a(message->lpFiles[i].lpszPathName),
 163                   debugstr_a(message->lpFiles[i].lpszFileName));
 164     }
 165
 166     /* Escape subject and body */
 167     subject = escape_string(message->lpszSubject, empty_string);
 168     body = escape_string(message->lpszNoteText, empty_string);
 169
 170     TRACE("Subject: %s\n", debugstr_a(subject));
 171     TRACE("Body: %s\n", debugstr_a(body));
 172
 173     subj_size = lstrlenA(subject);
 174     body_size = lstrlenA(body);
 175
 176     ret = MAPI_E_INSUFFICIENT_MEMORY;
 177
 178     if (to_size)
 179     {
 180         to = HeapAlloc(GetProcessHeap(), 0, to_size);
 181
 182         if (!to)
 183             goto exit;
 184
 185         to[0] = 0;
 186     }
 187
 188     if (cc_size)
 189     {
 190         cc = HeapAlloc(GetProcessHeap(), 0, cc_size);
 191
 192         if (!cc)
 193             goto exit;
 194
 195         cc[0] = 0;
 196     }
 197
 198     if (bcc_size)
 199     {
 200         bcc = HeapAlloc(GetProcessHeap(), 0, bcc_size);
 201
 202         if (!bcc)
 203             goto exit;
 204
 205         bcc[0] = 0;
 206     }
 207
 208     if (message->lpOriginator)
 209         TRACE("From: %s\n", debugstr_a(message->lpOriginator->lpszAddress));
 210
 211     for (i = 0; i < message->nRecipCount; i++)
 212     {
 213         address = message->lpRecips[i].lpszAddress;
 214
 215         if (address)
 216         {
 217             if (!_strnicmp(address, smtp, sizeof(smtp) - 1))
 218                 address += sizeof(smtp) - 1;
 219
 220             switch (message->lpRecips[i].ulRecipClass)
 221             {
 222                 case MAPI_TO:
 223                     if (to_count)
 224                         lstrcatA(to, ",");
 225
 226                     lstrcatA(to, address);
 227                     to_count++;
 228                     break;
 229
 230                 case MAPI_CC:
 231                     if (cc_count)
 232                         lstrcatA(cc, ",");
 233
 234                     lstrcatA(cc, address);
 235                     cc_count++;
 236                     break;
 237
 238                 case MAPI_BCC:
 239                     if (bcc_count)
 240                         lstrcatA(bcc, ",");
 241
 242                     lstrcatA(bcc, address);
 243                     bcc_count++;
 244                     break;
 245             }
 246         }
 247     }
 248     ret = MAPI_E_FAILURE;
 249     size = sizeof(format) + to_size + cc_size + bcc_size + subj_size + body_size;
 250
 251     mailto = HeapAlloc(GetProcessHeap(), 0, size);
 252
 253     if (!mailto)
 254         goto exit;
 255
 256     sprintf(mailto, format, to ? to : "", subject, cc ? cc : "", bcc ? bcc : "", body);
 257
 258     size = 1;
 259     res = UrlEscapeA(mailto, empty_string, &size, URL_ESCAPE_SPACES_ONLY);
 260
 261     if (res != E_POINTER)
 262         goto exit;
 263
 264     escape = HeapAlloc(GetProcessHeap(), 0, size);
 265
 266     if (!escape)
 267         goto exit;
 268
 269     res = UrlEscapeA(mailto, escape, &size, URL_ESCAPE_SPACES_ONLY);
 270
 271     if (res != S_OK)
 272         goto exit;
 273
 274     TRACE("Executing winebrowser.exe with parameters '%s'\n", debugstr_a(escape));
 275
 276     if ((UINT_PTR) ShellExecuteA(NULL, "open", "winebrowser.exe", escape, NULL, 0) > 32)
 277         ret = SUCCESS_SUCCESS;
 278
 279 exit:
 280     HeapFree(GetProcessHeap(), 0, to);
 281     HeapFree(GetProcessHeap(), 0, cc);
 282     HeapFree(GetProcessHeap(), 0, bcc);
 283     HeapFree(GetProcessHeap(), 0, mailto);
 284     HeapFree(GetProcessHeap(), 0, escape);
 285
 286     if (subject != empty_string)
 287         HeapFree(GetProcessHeap(), 0, subject);
 288
 289     if (body != empty_string)
 290         HeapFree(GetProcessHeap(), 0, body);
 291
 292     return ret;
 293 }
 294
 295 ULONG WINAPI MAPISendDocuments(ULONG_PTR uiparam, LPSTR delim, LPSTR paths,
 296     LPSTR filenames, ULONG reserved)
 297 {
 298     return MAPI_E_NOT_SUPPORTED;
 299 }