dlls/inetcomm/mimeole.c

   1 /*
   2  * MIME OLE Interfaces
   3  *
   4  * Copyright 2006 Robert Shearman for CodeWeavers
   5  * Copyright 2007 Huw Davies 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 #define COBJMACROS
  23
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winuser.h"
  30 #include "objbase.h"
  31 #include "ole2.h"
  32 #include "mimeole.h"
  33
  34 #include "wine/list.h"
  35 #include "wine/debug.h"
  36
  37 #include "inetcomm_private.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(inetcomm);
  40
  41 typedef struct
  42 {
  43     LPCSTR     name;
  44     DWORD      id;
  45     DWORD      flags; /* MIMEPROPFLAGS */
  46     VARTYPE    default_vt;
  47 } property_t;
  48
  49 typedef struct
  50 {
  51     struct list entry;
  52     property_t prop;
  53 } property_list_entry_t;
  54
  55 static const property_t default_props[] =
  56 {
  57     {"References",                   PID_HDR_REFS,       0,                               VT_LPSTR},
  58     {"Subject",                      PID_HDR_SUBJECT,    0,                               VT_LPSTR},
  59     {"From",                         PID_HDR_FROM,       MPF_ADDRESS,                     VT_LPSTR},
  60     {"Message-ID",                   PID_HDR_MESSAGEID,  0,                               VT_LPSTR},
  61     {"Return-Path",                  PID_HDR_RETURNPATH, MPF_ADDRESS,                     VT_LPSTR},
  62     {"Date",                         PID_HDR_DATE,       0,                               VT_LPSTR},
  63     {"Received",                     PID_HDR_RECEIVED,   0,                               VT_LPSTR},
  64     {"Reply-To",                     PID_HDR_REPLYTO,    MPF_ADDRESS,                     VT_LPSTR},
  65     {"X-Mailer",                     PID_HDR_XMAILER,    0,                               VT_LPSTR},
  66     {"Bcc",                          PID_HDR_BCC,        MPF_ADDRESS,                     VT_LPSTR},
  67     {"MIME-Version",                 PID_HDR_MIMEVER,    MPF_MIME,                        VT_LPSTR},
  68     {"Content-Type",                 PID_HDR_CNTTYPE,    MPF_MIME | MPF_HASPARAMS,        VT_LPSTR},
  69     {"Content-Transfer-Encoding",    PID_HDR_CNTXFER,    MPF_MIME,                        VT_LPSTR},
  70     {"Content-ID",                   PID_HDR_CNTID,      MPF_MIME,                        VT_LPSTR},
  71     {"Content-Disposition",          PID_HDR_CNTDISP,    MPF_MIME,                        VT_LPSTR},
  72     {"To",                           PID_HDR_TO,         MPF_ADDRESS,                     VT_LPSTR},
  73     {"Cc",                           PID_HDR_CC,         MPF_ADDRESS,                     VT_LPSTR},
  74     {"Sender",                       PID_HDR_SENDER,     MPF_ADDRESS,                     VT_LPSTR},
  75     {"In-Reply-To",                  PID_HDR_INREPLYTO,  0,                               VT_LPSTR},
  76     {NULL,                           0,                  0,                               0}
  77 };
  78
  79 typedef struct
  80 {
  81     struct list entry;
  82     const property_t *prop;
  83     PROPVARIANT value;
  84 } header_t;
  85
  86 typedef struct MimeBody
  87 {
  88     const IMimeBodyVtbl *lpVtbl;
  89     LONG refs;
  90
  91     HBODY handle;
  92
  93     struct list headers;
  94     struct list new_props; /* FIXME: This should be in a PropertySchema */
  95     DWORD next_prop_id;
  96 } MimeBody;
  97
  98 static inline MimeBody *impl_from_IMimeBody( IMimeBody *iface )
  99 {
 100     return (MimeBody *)((char*)iface - FIELD_OFFSET(MimeBody, lpVtbl));
 101 }
 102
 103 static LPSTR strdupA(LPCSTR str)
 104 {
 105     char *ret;
 106     int len = strlen(str);
 107     ret = HeapAlloc(GetProcessHeap(), 0, len + 1);
 108     memcpy(ret, str, len + 1);
 109     return ret;
 110 }
 111
 112 #define PARSER_BUF_SIZE 1024
 113
 114 /*****************************************************
 115  *        copy_headers_to_buf [internal]
 116  *
 117  * Copies the headers into a '\0' terminated memory block and leave
 118  * the stream's current position set to after the blank line.
 119  */
 120 static HRESULT copy_headers_to_buf(IStream *stm, char **ptr)
 121 {
 122     char *buf = NULL;
 123     DWORD size = PARSER_BUF_SIZE, offset = 0, last_end = 0;
 124     HRESULT hr;
 125     int done = 0;
 126
 127     *ptr = NULL;
 128
 129     do
 130     {
 131         char *end;
 132         DWORD read;
 133
 134         if(!buf)
 135             buf = HeapAlloc(GetProcessHeap(), 0, size + 1);
 136         else
 137         {
 138             size *= 2;
 139             buf = HeapReAlloc(GetProcessHeap(), 0, buf, size + 1);
 140         }
 141         if(!buf)
 142         {
 143             hr = E_OUTOFMEMORY;
 144             goto fail;
 145         }
 146
 147         hr = IStream_Read(stm, buf + offset, size - offset, &read);
 148         if(FAILED(hr)) goto fail;
 149
 150         offset += read;
 151         buf[offset] = '\0';
 152
 153         if(read == 0) done = 1;
 154
 155         while(!done && (end = strstr(buf + last_end, "\r\n")))
 156         {
 157             DWORD new_end = end - buf + 2;
 158             if(new_end - last_end == 2)
 159             {
 160                 LARGE_INTEGER off;
 161                 off.QuadPart = new_end;
 162                 IStream_Seek(stm, off, STREAM_SEEK_SET, NULL);
 163                 buf[new_end] = '\0';
 164                 done = 1;
 165             }
 166             else
 167                 last_end = new_end;
 168         }
 169     } while(!done);
 170
 171     *ptr = buf;
 172     return S_OK;
 173
 174 fail:
 175     HeapFree(GetProcessHeap(), 0, buf);
 176     return hr;
 177 }
 178
 179 static header_t *read_prop(MimeBody *body, char **ptr)
 180 {
 181     char *colon = strchr(*ptr, ':');
 182     const property_t *prop;
 183     header_t *ret;
 184
 185     if(!colon) return NULL;
 186
 187     *colon = '\0';
 188
 189     for(prop = default_props; prop->name; prop++)
 190     {
 191         if(!strcasecmp(*ptr, prop->name))
 192         {
 193             TRACE("%s: found match with default property id %d\n", *ptr, prop->id);
 194             break;
 195         }
 196     }
 197
 198     if(!prop->name)
 199     {
 200         property_list_entry_t *prop_entry;
 201         LIST_FOR_EACH_ENTRY(prop_entry, &body->new_props, property_list_entry_t, entry)
 202         {
 203             if(!strcasecmp(*ptr, prop_entry->prop.name))
 204             {
 205                 TRACE("%s: found match with already added new property id %d\n", *ptr, prop_entry->prop.id);
 206                 prop = &prop_entry->prop;
 207                 break;
 208             }
 209         }
 210         if(!prop->name)
 211         {
 212             prop_entry = HeapAlloc(GetProcessHeap(), 0, sizeof(*prop_entry));
 213             prop_entry->prop.name = strdupA(*ptr);
 214             prop_entry->prop.id = body->next_prop_id++;
 215             prop_entry->prop.flags = 0;
 216             prop_entry->prop.default_vt = VT_LPSTR;
 217             list_add_tail(&body->new_props, &prop_entry->entry);
 218             prop = &prop_entry->prop;
 219             TRACE("%s: allocating new prop id %d\n", *ptr, prop_entry->prop.id);
 220         }
 221     }
 222
 223     ret = HeapAlloc(GetProcessHeap(), 0, sizeof(*ret));
 224     ret->prop = prop;
 225     PropVariantInit(&ret->value);
 226     *ptr = colon + 1;
 227
 228     return ret;
 229 }
 230
 231 static void read_value(header_t *header, char **cur)
 232 {
 233     char *end = *cur, *value;
 234     DWORD len;
 235
 236     do {
 237         end = strstr(end, "\r\n");
 238         end += 2;
 239     } while(*end == ' ' || *end == '\t');
 240
 241     len = end - *cur;
 242     value = HeapAlloc(GetProcessHeap(), 0, len + 1);
 243     memcpy(value, *cur, len);
 244     value[len] = '\0';
 245
 246     header->value.vt = VT_LPSTR;
 247     header->value.pszVal = value;
 248
 249     *cur = end;
 250 }
 251
 252 static HRESULT parse_headers(MimeBody *body, IStream *stm)
 253 {
 254     char *header_buf, *cur_header_ptr;
 255     HRESULT hr;
 256     header_t *header;
 257
 258     hr = copy_headers_to_buf(stm, &header_buf);
 259     if(FAILED(hr)) return hr;
 260
 261     cur_header_ptr = header_buf;
 262     while((header = read_prop(body, &cur_header_ptr)))
 263     {
 264         read_value(header, &cur_header_ptr);
 265         list_add_tail(&body->headers, &header->entry);
 266     }
 267
 268     HeapFree(GetProcessHeap(), 0, header_buf);
 269     return hr;
 270 }
 271
 272 static void empty_header_list(struct list *list)
 273 {
 274     header_t *header, *cursor2;
 275
 276     LIST_FOR_EACH_ENTRY_SAFE(header, cursor2, list, header_t, entry)
 277     {
 278         list_remove(&header->entry);
 279         PropVariantClear(&header->value);
 280         HeapFree(GetProcessHeap(), 0, header);
 281     }
 282 }
 283
 284 static void empty_new_prop_list(struct list *list)
 285 {
 286     property_list_entry_t *prop, *cursor2;
 287
 288     LIST_FOR_EACH_ENTRY_SAFE(prop, cursor2, list, property_list_entry_t, entry)
 289     {
 290         list_remove(&prop->entry);
 291         HeapFree(GetProcessHeap(), 0, (char *)prop->prop.name);
 292         HeapFree(GetProcessHeap(), 0, prop);
 293     }
 294 }
 295
 296 static HRESULT WINAPI MimeBody_QueryInterface(IMimeBody* iface,
 297                                      REFIID riid,
 298                                      void** ppvObject)
 299 {
 300     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppvObject);
 301
 302     *ppvObject = NULL;
 303
 304     if (IsEqualIID(riid, &IID_IUnknown) ||
 305         IsEqualIID(riid, &IID_IPersist) ||
 306         IsEqualIID(riid, &IID_IPersistStreamInit) ||
 307         IsEqualIID(riid, &IID_IMimePropertySet) ||
 308         IsEqualIID(riid, &IID_IMimeBody))
 309     {
 310         *ppvObject = iface;
 311     }
 312
 313     if(*ppvObject)
 314     {
 315         IUnknown_AddRef((IUnknown*)*ppvObject);
 316         return S_OK;
 317     }
 318
 319     FIXME("no interface for %s\n", debugstr_guid(riid));
 320     return E_NOINTERFACE;
 321 }
 322
 323 static ULONG WINAPI MimeBody_AddRef(IMimeBody* iface)
 324 {
 325     MimeBody *This = impl_from_IMimeBody(iface);
 326     TRACE("(%p)->()\n", iface);
 327     return InterlockedIncrement(&This->refs);
 328 }
 329
 330 static ULONG WINAPI MimeBody_Release(IMimeBody* iface)
 331 {
 332     MimeBody *This = impl_from_IMimeBody(iface);
 333     ULONG refs;
 334
 335     TRACE("(%p)->()\n", iface);
 336
 337     refs = InterlockedDecrement(&This->refs);
 338     if (!refs)
 339     {
 340         empty_header_list(&This->headers);
 341         empty_new_prop_list(&This->new_props);
 342
 343         HeapFree(GetProcessHeap(), 0, This);
 344     }
 345
 346     return refs;
 347 }
 348
 349 static HRESULT WINAPI MimeBody_GetClassID(
 350                                  IMimeBody* iface,
 351                                  CLSID* pClassID)
 352 {
 353     FIXME("stub\n");
 354     return E_NOTIMPL;
 355 }
 356
 357
 358 static HRESULT WINAPI MimeBody_IsDirty(
 359                               IMimeBody* iface)
 360 {
 361     FIXME("stub\n");
 362     return E_NOTIMPL;
 363 }
 364
 365 static HRESULT WINAPI MimeBody_Load(
 366                            IMimeBody* iface,
 367                            LPSTREAM pStm)
 368 {
 369     MimeBody *This = impl_from_IMimeBody(iface);
 370     TRACE("(%p)->(%p)\n", iface, pStm);
 371     return parse_headers(This, pStm);
 372 }
 373
 374 static HRESULT WINAPI MimeBody_Save(
 375                            IMimeBody* iface,
 376                            LPSTREAM pStm,
 377                            BOOL fClearDirty)
 378 {
 379     FIXME("stub\n");
 380     return E_NOTIMPL;
 381 }
 382
 383 static HRESULT WINAPI MimeBody_GetSizeMax(
 384                                  IMimeBody* iface,
 385                                  ULARGE_INTEGER* pcbSize)
 386 {
 387     FIXME("stub\n");
 388     return E_NOTIMPL;
 389 }
 390
 391 static HRESULT WINAPI MimeBody_InitNew(
 392                               IMimeBody* iface)
 393 {
 394     TRACE("%p->()\n", iface);
 395     return S_OK;
 396 }
 397
 398 static HRESULT WINAPI MimeBody_GetPropInfo(
 399                                   IMimeBody* iface,
 400                                   LPCSTR pszName,
 401                                   LPMIMEPROPINFO pInfo)
 402 {
 403     FIXME("stub\n");
 404     return E_NOTIMPL;
 405 }
 406
 407 static HRESULT WINAPI MimeBody_SetPropInfo(
 408                                   IMimeBody* iface,
 409                                   LPCSTR pszName,
 410                                   LPCMIMEPROPINFO pInfo)
 411 {
 412     FIXME("stub\n");
 413     return E_NOTIMPL;
 414 }
 415
 416 static HRESULT WINAPI MimeBody_GetProp(
 417                               IMimeBody* iface,
 418                               LPCSTR pszName,
 419                               DWORD dwFlags,
 420                               LPPROPVARIANT pValue)
 421 {
 422     FIXME("stub\n");
 423     return E_NOTIMPL;
 424 }
 425
 426 static HRESULT WINAPI MimeBody_SetProp(
 427                               IMimeBody* iface,
 428                               LPCSTR pszName,
 429                               DWORD dwFlags,
 430                               LPCPROPVARIANT pValue)
 431 {
 432     FIXME("stub\n");
 433     return E_NOTIMPL;
 434 }
 435
 436 static HRESULT WINAPI MimeBody_AppendProp(
 437                                  IMimeBody* iface,
 438                                  LPCSTR pszName,
 439                                  DWORD dwFlags,
 440                                  LPPROPVARIANT pValue)
 441 {
 442     FIXME("stub\n");
 443     return E_NOTIMPL;
 444 }
 445
 446 static HRESULT WINAPI MimeBody_DeleteProp(
 447                                  IMimeBody* iface,
 448                                  LPCSTR pszName)
 449 {
 450     FIXME("stub\n");
 451     return E_NOTIMPL;
 452 }
 453
 454 static HRESULT WINAPI MimeBody_CopyProps(
 455                                 IMimeBody* iface,
 456                                 ULONG cNames,
 457                                 LPCSTR* prgszName,
 458                                 IMimePropertySet* pPropertySet)
 459 {
 460     FIXME("stub\n");
 461     return E_NOTIMPL;
 462 }
 463
 464 static HRESULT WINAPI MimeBody_MoveProps(
 465                                 IMimeBody* iface,
 466                                 ULONG cNames,
 467                                 LPCSTR* prgszName,
 468                                 IMimePropertySet* pPropertySet)
 469 {
 470     FIXME("stub\n");
 471     return E_NOTIMPL;
 472 }
 473
 474 static HRESULT WINAPI MimeBody_DeleteExcept(
 475                                    IMimeBody* iface,
 476                                    ULONG cNames,
 477                                    LPCSTR* prgszName)
 478 {
 479     FIXME("stub\n");
 480     return E_NOTIMPL;
 481 }
 482
 483 static HRESULT WINAPI MimeBody_QueryProp(
 484                                 IMimeBody* iface,
 485                                 LPCSTR pszName,
 486                                 LPCSTR pszCriteria,
 487                                 boolean fSubString,
 488                                 boolean fCaseSensitive)
 489 {
 490     FIXME("stub\n");
 491     return E_NOTIMPL;
 492 }
 493
 494 static HRESULT WINAPI MimeBody_GetCharset(
 495                                  IMimeBody* iface,
 496                                  LPHCHARSET phCharset)
 497 {
 498     FIXME("stub\n");
 499     return E_NOTIMPL;
 500 }
 501
 502 static HRESULT WINAPI MimeBody_SetCharset(
 503                                  IMimeBody* iface,
 504                                  HCHARSET hCharset,
 505                                  CSETAPPLYTYPE applytype)
 506 {
 507     FIXME("stub\n");
 508     return E_NOTIMPL;
 509 }
 510
 511 static HRESULT WINAPI MimeBody_GetParameters(
 512                                     IMimeBody* iface,
 513                                     LPCSTR pszName,
 514                                     ULONG* pcParams,
 515                                     LPMIMEPARAMINFO* pprgParam)
 516 {
 517     FIXME("stub\n");
 518     return E_NOTIMPL;
 519 }
 520
 521 static HRESULT WINAPI MimeBody_IsContentType(
 522                                     IMimeBody* iface,
 523                                     LPCSTR pszPriType,
 524                                     LPCSTR pszSubType)
 525 {
 526     FIXME("stub\n");
 527     return E_NOTIMPL;
 528 }
 529
 530 static HRESULT WINAPI MimeBody_BindToObject(
 531                                    IMimeBody* iface,
 532                                    REFIID riid,
 533                                    void** ppvObject)
 534 {
 535     FIXME("stub\n");
 536     return E_NOTIMPL;
 537 }
 538
 539 static HRESULT WINAPI MimeBody_Clone(
 540                             IMimeBody* iface,
 541                             IMimePropertySet** ppPropertySet)
 542 {
 543     FIXME("stub\n");
 544     return E_NOTIMPL;
 545 }
 546
 547 static HRESULT WINAPI MimeBody_SetOption(
 548                                 IMimeBody* iface,
 549                                 const TYPEDID oid,
 550                                 LPCPROPVARIANT pValue)
 551 {
 552     FIXME("stub\n");
 553     return E_NOTIMPL;
 554 }
 555
 556 static HRESULT WINAPI MimeBody_GetOption(
 557                                 IMimeBody* iface,
 558                                 const TYPEDID oid,
 559                                 LPPROPVARIANT pValue)
 560 {
 561     FIXME("stub\n");
 562     return E_NOTIMPL;
 563 }
 564
 565 static HRESULT WINAPI MimeBody_EnumProps(
 566                                 IMimeBody* iface,
 567                                 DWORD dwFlags,
 568                                 IMimeEnumProperties** ppEnum)
 569 {
 570     FIXME("stub\n");
 571     return E_NOTIMPL;
 572 }
 573
 574 static HRESULT WINAPI MimeBody_IsType(
 575                              IMimeBody* iface,
 576                              IMSGBODYTYPE bodytype)
 577 {
 578     FIXME("stub\n");
 579     return E_NOTIMPL;
 580 }
 581
 582 static HRESULT WINAPI MimeBody_SetDisplayName(
 583                                      IMimeBody* iface,
 584                                      LPCSTR pszDisplay)
 585 {
 586     FIXME("stub\n");
 587     return E_NOTIMPL;
 588 }
 589
 590 static HRESULT WINAPI MimeBody_GetDisplayName(
 591                                      IMimeBody* iface,
 592                                      LPSTR* ppszDisplay)
 593 {
 594     FIXME("stub\n");
 595     return E_NOTIMPL;
 596 }
 597
 598 static HRESULT WINAPI MimeBody_GetOffsets(
 599                                  IMimeBody* iface,
 600                                  LPBODYOFFSETS pOffsets)
 601 {
 602     FIXME("stub\n");
 603     return E_NOTIMPL;
 604 }
 605
 606 static HRESULT WINAPI MimeBody_GetCurrentEncoding(
 607                                          IMimeBody* iface,
 608                                          ENCODINGTYPE* pietEncoding)
 609 {
 610     FIXME("stub\n");
 611     return E_NOTIMPL;
 612 }
 613
 614 static HRESULT WINAPI MimeBody_SetCurrentEncoding(
 615                                          IMimeBody* iface,
 616                                          ENCODINGTYPE ietEncoding)
 617 {
 618     FIXME("stub\n");
 619     return E_NOTIMPL;
 620 }
 621
 622 static HRESULT WINAPI MimeBody_GetEstimatedSize(
 623                                        IMimeBody* iface,
 624                                        ENCODINGTYPE ietEncoding,
 625                                        ULONG* pcbSize)
 626 {
 627     FIXME("stub\n");
 628     return E_NOTIMPL;
 629 }
 630
 631 static HRESULT WINAPI MimeBody_GetDataHere(
 632                                   IMimeBody* iface,
 633                                   ENCODINGTYPE ietEncoding,
 634                                   IStream* pStream)
 635 {
 636     FIXME("stub\n");
 637     return E_NOTIMPL;
 638 }
 639
 640 static HRESULT WINAPI MimeBody_GetData(
 641                               IMimeBody* iface,
 642                               ENCODINGTYPE ietEncoding,
 643                               IStream** ppStream)
 644 {
 645     FIXME("stub\n");
 646     return E_NOTIMPL;
 647 }
 648
 649 static HRESULT WINAPI MimeBody_SetData(
 650                               IMimeBody* iface,
 651                               ENCODINGTYPE ietEncoding,
 652                               LPCSTR pszPriType,
 653                               LPCSTR pszSubType,
 654                               REFIID riid,
 655                               LPVOID pvObject)
 656 {
 657     FIXME("stub\n");
 658     return E_NOTIMPL;
 659 }
 660
 661 static HRESULT WINAPI MimeBody_EmptyData(
 662                                 IMimeBody* iface)
 663 {
 664     FIXME("stub\n");
 665     return E_NOTIMPL;
 666 }
 667
 668 static HRESULT WINAPI MimeBody_CopyTo(
 669                              IMimeBody* iface,
 670                              IMimeBody* pBody)
 671 {
 672     FIXME("stub\n");
 673     return E_NOTIMPL;
 674 }
 675
 676 static HRESULT WINAPI MimeBody_GetTransmitInfo(
 677                                       IMimeBody* iface,
 678                                       LPTRANSMITINFO pTransmitInfo)
 679 {
 680     FIXME("stub\n");
 681     return E_NOTIMPL;
 682 }
 683
 684 static HRESULT WINAPI MimeBody_SaveToFile(
 685                                  IMimeBody* iface,
 686                                  ENCODINGTYPE ietEncoding,
 687                                  LPCSTR pszFilePath)
 688 {
 689     FIXME("stub\n");
 690     return E_NOTIMPL;
 691 }
 692
 693 static HRESULT WINAPI MimeBody_GetHandle(
 694                                 IMimeBody* iface,
 695                                 LPHBODY phBody)
 696 {
 697     MimeBody *This = impl_from_IMimeBody(iface);
 698     TRACE("(%p)->(%p)\n", iface, phBody);
 699
 700     *phBody = This->handle;
 701     return This->handle ? S_OK : MIME_E_NO_DATA;
 702 }
 703
 704 static IMimeBodyVtbl body_vtbl =
 705 {
 706     MimeBody_QueryInterface,
 707     MimeBody_AddRef,
 708     MimeBody_Release,
 709     MimeBody_GetClassID,
 710     MimeBody_IsDirty,
 711     MimeBody_Load,
 712     MimeBody_Save,
 713     MimeBody_GetSizeMax,
 714     MimeBody_InitNew,
 715     MimeBody_GetPropInfo,
 716     MimeBody_SetPropInfo,
 717     MimeBody_GetProp,
 718     MimeBody_SetProp,
 719     MimeBody_AppendProp,
 720     MimeBody_DeleteProp,
 721     MimeBody_CopyProps,
 722     MimeBody_MoveProps,
 723     MimeBody_DeleteExcept,
 724     MimeBody_QueryProp,
 725     MimeBody_GetCharset,
 726     MimeBody_SetCharset,
 727     MimeBody_GetParameters,
 728     MimeBody_IsContentType,
 729     MimeBody_BindToObject,
 730     MimeBody_Clone,
 731     MimeBody_SetOption,
 732     MimeBody_GetOption,
 733     MimeBody_EnumProps,
 734     MimeBody_IsType,
 735     MimeBody_SetDisplayName,
 736     MimeBody_GetDisplayName,
 737     MimeBody_GetOffsets,
 738     MimeBody_GetCurrentEncoding,
 739     MimeBody_SetCurrentEncoding,
 740     MimeBody_GetEstimatedSize,
 741     MimeBody_GetDataHere,
 742     MimeBody_GetData,
 743     MimeBody_SetData,
 744     MimeBody_EmptyData,
 745     MimeBody_CopyTo,
 746     MimeBody_GetTransmitInfo,
 747     MimeBody_SaveToFile,
 748     MimeBody_GetHandle
 749 };
 750
 751 #define FIRST_CUSTOM_PROP_ID 0x100
 752
 753 HRESULT MimeBody_create(IUnknown *outer, void **obj)
 754 {
 755     MimeBody *This;
 756
 757     *obj = NULL;
 758
 759     if(outer) return CLASS_E_NOAGGREGATION;
 760
 761     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 762     if (!This) return E_OUTOFMEMORY;
 763
 764     This->lpVtbl = &body_vtbl;
 765     This->refs = 1;
 766     This->handle = NULL;
 767     list_init(&This->headers);
 768     list_init(&This->new_props);
 769     This->next_prop_id = FIRST_CUSTOM_PROP_ID;
 770
 771     *obj = (IMimeBody *)&This->lpVtbl;
 772     return S_OK;
 773 }
 774
 775 typedef struct MimeMessage
 776 {
 777     const IMimeMessageVtbl *lpVtbl;
 778
 779     LONG refs;
 780 } MimeMessage;
 781
 782 static HRESULT WINAPI MimeMessage_QueryInterface(IMimeMessage *iface, REFIID riid, void **ppv)
 783 {
 784     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 785
 786     if (IsEqualIID(riid, &IID_IUnknown) ||
 787         IsEqualIID(riid, &IID_IPersist) ||
 788         IsEqualIID(riid, &IID_IPersistStreamInit) ||
 789         IsEqualIID(riid, &IID_IMimeMessageTree) ||
 790         IsEqualIID(riid, &IID_IMimeMessage))
 791     {
 792         *ppv = iface;
 793         IUnknown_AddRef(iface);
 794         return S_OK;
 795     }
 796
 797     FIXME("no interface for %s\n", debugstr_guid(riid));
 798     *ppv = NULL;
 799     return E_NOINTERFACE;
 800 }
 801
 802 static ULONG WINAPI MimeMessage_AddRef(IMimeMessage *iface)
 803 {
 804     MimeMessage *This = (MimeMessage *)iface;
 805     TRACE("(%p)->()\n", iface);
 806     return InterlockedIncrement(&This->refs);
 807 }
 808
 809 static ULONG WINAPI MimeMessage_Release(IMimeMessage *iface)
 810 {
 811     MimeMessage *This = (MimeMessage *)iface;
 812     ULONG refs;
 813
 814     TRACE("(%p)->()\n", iface);
 815
 816     refs = InterlockedDecrement(&This->refs);
 817     if (!refs)
 818     {
 819         HeapFree(GetProcessHeap(), 0, This);
 820     }
 821
 822     return refs;
 823 }
 824
 825 /*** IPersist methods ***/
 826 static HRESULT WINAPI MimeMessage_GetClassID(
 827     IMimeMessage *iface,
 828     CLSID *pClassID)
 829 {
 830     FIXME("(%p)->(%p)\n", iface, pClassID);
 831     return E_NOTIMPL;
 832 }
 833
 834 /*** IPersistStreamInit methods ***/
 835 static HRESULT WINAPI MimeMessage_IsDirty(
 836     IMimeMessage *iface)
 837 {
 838     FIXME("(%p)->()\n", iface);
 839     return E_NOTIMPL;
 840 }
 841
 842 static HRESULT WINAPI MimeMessage_Load(
 843     IMimeMessage *iface,
 844     LPSTREAM pStm){
 845     FIXME("(%p)->(%p)\n", iface, pStm);
 846     return E_NOTIMPL;
 847 }
 848
 849 static HRESULT WINAPI MimeMessage_Save(
 850     IMimeMessage *iface,
 851     LPSTREAM pStm,
 852     BOOL fClearDirty)
 853 {
 854     FIXME("(%p)->(%p, %s)\n", iface, pStm, fClearDirty ? "TRUE" : "FALSE");
 855     return E_NOTIMPL;
 856 }
 857
 858 static HRESULT WINAPI MimeMessage_GetSizeMax(
 859     IMimeMessage *iface,
 860     ULARGE_INTEGER *pcbSize)
 861 {
 862     FIXME("(%p)->(%p)\n", iface, pcbSize);
 863     return E_NOTIMPL;
 864 }
 865
 866 static HRESULT WINAPI MimeMessage_InitNew(
 867     IMimeMessage *iface)
 868 {
 869     FIXME("(%p)->()\n", iface);
 870     return E_NOTIMPL;
 871 }
 872
 873 /*** IMimeMessageTree methods ***/
 874 static HRESULT WINAPI MimeMessage_GetMessageSource(
 875     IMimeMessage *iface,
 876     IStream **ppStream,
 877     DWORD dwFlags)
 878 {
 879     FIXME("(%p)->(%p, 0x%x)\n", iface, ppStream, dwFlags);
 880     return E_NOTIMPL;
 881 }
 882
 883 static HRESULT WINAPI MimeMessage_GetMessageSize(
 884     IMimeMessage *iface,
 885     ULONG *pcbSize,
 886     DWORD dwFlags)
 887 {
 888     FIXME("(%p)->(%p, 0x%x)\n", iface, pcbSize, dwFlags);
 889     return E_NOTIMPL;
 890 }
 891
 892 static HRESULT WINAPI MimeMessage_LoadOffsetTable(
 893     IMimeMessage *iface,
 894     IStream *pStream)
 895 {
 896     FIXME("(%p)->(%p)\n", iface, pStream);
 897     return E_NOTIMPL;
 898 }
 899
 900 static HRESULT WINAPI MimeMessage_SaveOffsetTable(
 901     IMimeMessage *iface,
 902     IStream *pStream,
 903     DWORD dwFlags)
 904 {
 905     FIXME("(%p)->(%p, 0x%x)\n", iface, pStream, dwFlags);
 906     return E_NOTIMPL;
 907 }
 908
 909
 910 static HRESULT WINAPI MimeMessage_GetFlags(
 911     IMimeMessage *iface,
 912     DWORD *pdwFlags)
 913 {
 914     FIXME("(%p)->(%p)\n", iface, pdwFlags);
 915     return E_NOTIMPL;
 916 }
 917
 918 static HRESULT WINAPI MimeMessage_Commit(
 919     IMimeMessage *iface,
 920     DWORD dwFlags)
 921 {
 922     FIXME("(%p)->(0x%x)\n", iface, dwFlags);
 923     return E_NOTIMPL;
 924 }
 925
 926
 927 static HRESULT WINAPI MimeMessage_HandsOffStorage(
 928     IMimeMessage *iface)
 929 {
 930     FIXME("(%p)->()\n", iface);
 931     return E_NOTIMPL;
 932 }
 933
 934 static HRESULT WINAPI MimeMessage_BindToObject(
 935     IMimeMessage *iface,
 936     const HBODY hBody,
 937     REFIID riid,
 938     void **ppvObject)
 939 {
 940     FIXME("(%p)->(%p, %s, %p)\n", iface, hBody, debugstr_guid(riid), ppvObject);
 941     return E_NOTIMPL;
 942 }
 943
 944 static HRESULT WINAPI MimeMessage_SaveBody(
 945     IMimeMessage *iface,
 946     HBODY hBody,
 947     DWORD dwFlags,
 948     IStream *pStream)
 949 {
 950     FIXME("(%p)->(%p, 0x%x, %p)\n", iface, hBody, dwFlags, pStream);
 951     return E_NOTIMPL;
 952 }
 953
 954 static HRESULT WINAPI MimeMessage_InsertBody(
 955     IMimeMessage *iface,
 956     BODYLOCATION location,
 957     HBODY hPivot,
 958     LPHBODY phBody)
 959 {
 960     FIXME("(%p)->(%d, %p, %p)\n", iface, location, hPivot, phBody);
 961     return E_NOTIMPL;
 962 }
 963
 964 static HRESULT WINAPI MimeMessage_GetBody(
 965     IMimeMessage *iface,
 966     BODYLOCATION location,
 967     HBODY hPivot,
 968     LPHBODY phBody)
 969 {
 970     FIXME("(%p)->(%d, %p, %p)\n", iface, location, hPivot, phBody);
 971     return E_NOTIMPL;
 972 }
 973
 974 static HRESULT WINAPI MimeMessage_DeleteBody(
 975     IMimeMessage *iface,
 976     HBODY hBody,
 977     DWORD dwFlags)
 978 {
 979     FIXME("(%p)->(%p, %08x)\n", iface, hBody, dwFlags);
 980     return E_NOTIMPL;
 981 }
 982
 983 static HRESULT WINAPI MimeMessage_MoveBody(
 984     IMimeMessage *iface,
 985     HBODY hBody,
 986     BODYLOCATION location)
 987 {
 988     FIXME("(%p)->(%d)\n", iface, location);
 989     return E_NOTIMPL;
 990 }
 991
 992 static HRESULT WINAPI MimeMessage_CountBodies(
 993     IMimeMessage *iface,
 994     HBODY hParent,
 995     boolean fRecurse,
 996     ULONG *pcBodies)
 997 {
 998     FIXME("(%p)->(%p, %s, %p)\n", iface, hParent, fRecurse ? "TRUE" : "FALSE", pcBodies);
 999     return E_NOTIMPL;
1000 }
1001
1002 static HRESULT WINAPI MimeMessage_FindFirst(
1003     IMimeMessage *iface,
1004     LPFINDBODY pFindBody,
1005     LPHBODY phBody)
1006 {
1007     FIXME("(%p)->(%p, %p)\n", iface, pFindBody, phBody);
1008     return E_NOTIMPL;
1009 }
1010
1011 static HRESULT WINAPI MimeMessage_FindNext(
1012     IMimeMessage *iface,
1013     LPFINDBODY pFindBody,
1014     LPHBODY phBody)
1015 {
1016     FIXME("(%p)->(%p, %p)\n", iface, pFindBody, phBody);
1017     return E_NOTIMPL;
1018 }
1019
1020 static HRESULT WINAPI MimeMessage_ResolveURL(
1021     IMimeMessage *iface,
1022     HBODY hRelated,
1023     LPCSTR pszBase,
1024     LPCSTR pszURL,
1025     DWORD dwFlags,
1026     LPHBODY phBody)
1027 {
1028     FIXME("(%p)->(%p, %s, %s, 0x%x, %p)\n", iface, hRelated, pszBase, pszURL, dwFlags, phBody);
1029     return E_NOTIMPL;
1030 }
1031
1032 static HRESULT WINAPI MimeMessage_ToMultipart(
1033     IMimeMessage *iface,
1034     HBODY hBody,
1035     LPCSTR pszSubType,
1036     LPHBODY phMultipart)
1037 {
1038     FIXME("(%p)->(%p, %s, %p)\n", iface, hBody, pszSubType, phMultipart);
1039     return E_NOTIMPL;
1040 }
1041
1042 static HRESULT WINAPI MimeMessage_GetBodyOffsets(
1043     IMimeMessage *iface,
1044     HBODY hBody,
1045     LPBODYOFFSETS pOffsets)
1046 {
1047     FIXME("(%p)->(%p, %p)\n", iface, hBody, pOffsets);
1048     return E_NOTIMPL;
1049 }
1050
1051 static HRESULT WINAPI MimeMessage_GetCharset(
1052     IMimeMessage *iface,
1053     LPHCHARSET phCharset)
1054 {
1055     FIXME("(%p)->(%p)\n", iface, phCharset);
1056     return E_NOTIMPL;
1057 }
1058
1059 static HRESULT WINAPI MimeMessage_SetCharset(
1060     IMimeMessage *iface,
1061     HCHARSET hCharset,
1062     CSETAPPLYTYPE applytype)
1063 {
1064     FIXME("(%p)->(%p, %d)\n", iface, hCharset, applytype);
1065     return E_NOTIMPL;
1066 }
1067
1068 static HRESULT WINAPI MimeMessage_IsBodyType(
1069     IMimeMessage *iface,
1070     HBODY hBody,
1071     IMSGBODYTYPE bodytype)
1072 {
1073     FIXME("(%p)->(%p, %d)\n", iface, hBody, bodytype);
1074     return E_NOTIMPL;
1075 }
1076
1077 static HRESULT WINAPI MimeMessage_IsContentType(
1078     IMimeMessage *iface,
1079     HBODY hBody,
1080     LPCSTR pszPriType,
1081     LPCSTR pszSubType)
1082 {
1083     FIXME("(%p)->(%p, %s, %s)\n", iface, hBody, pszPriType, pszSubType);
1084     return E_NOTIMPL;
1085 }
1086
1087 static HRESULT WINAPI MimeMessage_QueryBodyProp(
1088     IMimeMessage *iface,
1089     HBODY hBody,
1090     LPCSTR pszName,
1091     LPCSTR pszCriteria,
1092     boolean fSubString,
1093     boolean fCaseSensitive)
1094 {
1095     FIXME("(%p)->(%p, %s, %s, %s, %s)\n", iface, hBody, pszName, pszCriteria, fSubString ? "TRUE" : "FALSE", fCaseSensitive ? "TRUE" : "FALSE");
1096     return E_NOTIMPL;
1097 }
1098
1099 static HRESULT WINAPI MimeMessage_GetBodyProp(
1100     IMimeMessage *iface,
1101     HBODY hBody,
1102     LPCSTR pszName,
1103     DWORD dwFlags,
1104     LPPROPVARIANT pValue)
1105 {
1106     FIXME("(%p)->(%p, %s, 0x%x, %p)\n", iface, hBody, pszName, dwFlags, pValue);
1107     return E_NOTIMPL;
1108 }
1109
1110 static HRESULT WINAPI MimeMessage_SetBodyProp(
1111     IMimeMessage *iface,
1112     HBODY hBody,
1113     LPCSTR pszName,
1114     DWORD dwFlags,
1115     LPCPROPVARIANT pValue)
1116 {
1117     FIXME("(%p)->(%p, %s, 0x%x, %p)\n", iface, hBody, pszName, dwFlags, pValue);
1118     return E_NOTIMPL;
1119 }
1120
1121 static HRESULT WINAPI MimeMessage_DeleteBodyProp(
1122     IMimeMessage *iface,
1123     HBODY hBody,
1124     LPCSTR pszName)
1125 {
1126     FIXME("(%p)->(%p, %s)\n", iface, hBody, pszName);
1127     return E_NOTIMPL;
1128 }
1129
1130 static HRESULT WINAPI MimeMessage_SetOption(
1131     IMimeMessage *iface,
1132     const TYPEDID oid,
1133     LPCPROPVARIANT pValue)
1134 {
1135     FIXME("(%p)->(%d, %p)\n", iface, oid, pValue);
1136     return E_NOTIMPL;
1137 }
1138
1139 static HRESULT WINAPI MimeMessage_GetOption(
1140     IMimeMessage *iface,
1141     const TYPEDID oid,
1142     LPPROPVARIANT pValue)
1143 {
1144     FIXME("(%p)->(%d, %p)\n", iface, oid, pValue);
1145     return E_NOTIMPL;
1146 }
1147
1148 /*** IMimeMessage methods ***/
1149 static HRESULT WINAPI MimeMessage_CreateWebPage(
1150     IMimeMessage *iface,
1151     IStream *pRootStm,
1152     LPWEBPAGEOPTIONS pOptions,
1153     IMimeMessageCallback *pCallback,
1154     IMoniker **ppMoniker)
1155 {
1156     FIXME("(%p)->(%p, %p, %p, %p)\n", iface, pRootStm, pOptions, pCallback, ppMoniker);
1157     *ppMoniker = NULL;
1158     return E_NOTIMPL;
1159 }
1160
1161 static HRESULT WINAPI MimeMessage_GetProp(
1162     IMimeMessage *iface,
1163     LPCSTR pszName,
1164     DWORD dwFlags,
1165     LPPROPVARIANT pValue)
1166 {
1167     FIXME("(%p)->(%s, 0x%x, %p)\n", iface, pszName, dwFlags, pValue);
1168     return E_NOTIMPL;
1169 }
1170
1171 static HRESULT WINAPI MimeMessage_SetProp(
1172     IMimeMessage *iface,
1173     LPCSTR pszName,
1174     DWORD dwFlags,
1175     LPCPROPVARIANT pValue)
1176 {
1177     FIXME("(%p)->(%s, 0x%x, %p)\n", iface, pszName, dwFlags, pValue);
1178     return E_NOTIMPL;
1179 }
1180
1181 static HRESULT WINAPI MimeMessage_DeleteProp(
1182     IMimeMessage *iface,
1183     LPCSTR pszName)
1184 {
1185     FIXME("(%p)->(%s)\n", iface, pszName);
1186     return E_NOTIMPL;
1187 }
1188
1189 static HRESULT WINAPI MimeMessage_QueryProp(
1190     IMimeMessage *iface,
1191     LPCSTR pszName,
1192     LPCSTR pszCriteria,
1193     boolean fSubString,
1194     boolean fCaseSensitive)
1195 {
1196     FIXME("(%p)->(%s, %s, %s, %s)\n", iface, pszName, pszCriteria, fSubString ? "TRUE" : "FALSE", fCaseSensitive ? "TRUE" : "FALSE");
1197     return E_NOTIMPL;
1198 }
1199
1200 static HRESULT WINAPI MimeMessage_GetTextBody(
1201     IMimeMessage *iface,
1202     DWORD dwTxtType,
1203     ENCODINGTYPE ietEncoding,
1204     IStream **pStream,
1205     LPHBODY phBody)
1206 {
1207     FIXME("(%p)->(%d, %d, %p, %p)\n", iface, dwTxtType, ietEncoding, pStream, phBody);
1208     return E_NOTIMPL;
1209 }
1210
1211 static HRESULT WINAPI MimeMessage_SetTextBody(
1212     IMimeMessage *iface,
1213     DWORD dwTxtType,
1214     ENCODINGTYPE ietEncoding,
1215     HBODY hAlternative,
1216     IStream *pStream,
1217     LPHBODY phBody)
1218 {
1219     FIXME("(%p)->(%d, %d, %p, %p, %p)\n", iface, dwTxtType, ietEncoding, hAlternative, pStream, phBody);
1220     return E_NOTIMPL;
1221 }
1222
1223 static HRESULT WINAPI MimeMessage_AttachObject(
1224     IMimeMessage *iface,
1225     REFIID riid,
1226     void *pvObject,
1227     LPHBODY phBody)
1228 {
1229     FIXME("(%p)->(%s, %p, %p)\n", iface, debugstr_guid(riid), pvObject, phBody);
1230     return E_NOTIMPL;
1231 }
1232
1233 static HRESULT WINAPI MimeMessage_AttachFile(
1234     IMimeMessage *iface,
1235     LPCSTR pszFilePath,
1236     IStream *pstmFile,
1237     LPHBODY phBody)
1238 {
1239     FIXME("(%p)->(%s, %p, %p)\n", iface, pszFilePath, pstmFile, phBody);
1240     return E_NOTIMPL;
1241 }
1242
1243 static HRESULT WINAPI MimeMessage_AttachURL(
1244     IMimeMessage *iface,
1245     LPCSTR pszBase,
1246     LPCSTR pszURL,
1247     DWORD dwFlags,
1248     IStream *pstmURL,
1249     LPSTR *ppszCIDURL,
1250     LPHBODY phBody)
1251 {
1252     FIXME("(%p)->(%s, %s, 0x%x, %p, %p, %p)\n", iface, pszBase, pszURL, dwFlags, pstmURL, ppszCIDURL, phBody);
1253     return E_NOTIMPL;
1254 }
1255
1256 static HRESULT WINAPI MimeMessage_GetAttachments(
1257     IMimeMessage *iface,
1258     ULONG *pcAttach,
1259     LPHBODY *pprghAttach)
1260 {
1261     FIXME("(%p)->(%p, %p)\n", iface, pcAttach, pprghAttach);
1262     return E_NOTIMPL;
1263 }
1264
1265 static HRESULT WINAPI MimeMessage_GetAddressTable(
1266     IMimeMessage *iface,
1267     IMimeAddressTable **ppTable)
1268 {
1269     FIXME("(%p)->(%p)\n", iface, ppTable);
1270     return E_NOTIMPL;
1271 }
1272
1273 static HRESULT WINAPI MimeMessage_GetSender(
1274     IMimeMessage *iface,
1275     LPADDRESSPROPS pAddress)
1276 {
1277     FIXME("(%p)->(%p)\n", iface, pAddress);
1278     return E_NOTIMPL;
1279 }
1280
1281 static HRESULT WINAPI MimeMessage_GetAddressTypes(
1282     IMimeMessage *iface,
1283     DWORD dwAdrTypes,
1284     DWORD dwProps,
1285     LPADDRESSLIST pList)
1286 {
1287     FIXME("(%p)->(%d, %d, %p)\n", iface, dwAdrTypes, dwProps, pList);
1288     return E_NOTIMPL;
1289 }
1290
1291 static HRESULT WINAPI MimeMessage_GetAddressFormat(
1292     IMimeMessage *iface,
1293     DWORD dwAdrTypes,
1294     ADDRESSFORMAT format,
1295     LPSTR *ppszFormat)
1296 {
1297     FIXME("(%p)->(%d, %d, %p)\n", iface, dwAdrTypes, format, ppszFormat);
1298     return E_NOTIMPL;
1299 }
1300
1301 static HRESULT WINAPI MimeMessage_EnumAddressTypes(
1302     IMimeMessage *iface,
1303     DWORD dwAdrTypes,
1304     DWORD dwProps,
1305     IMimeEnumAddressTypes **ppEnum)
1306 {
1307     FIXME("(%p)->(%d, %d, %p)\n", iface, dwAdrTypes, dwProps, ppEnum);
1308     return E_NOTIMPL;
1309 }
1310
1311 static HRESULT WINAPI MimeMessage_SplitMessage(
1312     IMimeMessage *iface,
1313     ULONG cbMaxPart,
1314     IMimeMessageParts **ppParts)
1315 {
1316     FIXME("(%p)->(%d, %p)\n", iface, cbMaxPart, ppParts);
1317     return E_NOTIMPL;
1318 }
1319
1320 static HRESULT WINAPI MimeMessage_GetRootMoniker(
1321     IMimeMessage *iface,
1322     IMoniker **ppMoniker)
1323 {
1324     FIXME("(%p)->(%p)\n", iface, ppMoniker);
1325     return E_NOTIMPL;
1326 }
1327
1328 static const IMimeMessageVtbl MimeMessageVtbl =
1329 {
1330     MimeMessage_QueryInterface,
1331     MimeMessage_AddRef,
1332     MimeMessage_Release,
1333     MimeMessage_GetClassID,
1334     MimeMessage_IsDirty,
1335     MimeMessage_Load,
1336     MimeMessage_Save,
1337     MimeMessage_GetSizeMax,
1338     MimeMessage_InitNew,
1339     MimeMessage_GetMessageSource,
1340     MimeMessage_GetMessageSize,
1341     MimeMessage_LoadOffsetTable,
1342     MimeMessage_SaveOffsetTable,
1343     MimeMessage_GetFlags,
1344     MimeMessage_Commit,
1345     MimeMessage_HandsOffStorage,
1346     MimeMessage_BindToObject,
1347     MimeMessage_SaveBody,
1348     MimeMessage_InsertBody,
1349     MimeMessage_GetBody,
1350     MimeMessage_DeleteBody,
1351     MimeMessage_MoveBody,
1352     MimeMessage_CountBodies,
1353     MimeMessage_FindFirst,
1354     MimeMessage_FindNext,
1355     MimeMessage_ResolveURL,
1356     MimeMessage_ToMultipart,
1357     MimeMessage_GetBodyOffsets,
1358     MimeMessage_GetCharset,
1359     MimeMessage_SetCharset,
1360     MimeMessage_IsBodyType,
1361     MimeMessage_IsContentType,
1362     MimeMessage_QueryBodyProp,
1363     MimeMessage_GetBodyProp,
1364     MimeMessage_SetBodyProp,
1365     MimeMessage_DeleteBodyProp,
1366     MimeMessage_SetOption,
1367     MimeMessage_GetOption,
1368     MimeMessage_CreateWebPage,
1369     MimeMessage_GetProp,
1370     MimeMessage_SetProp,
1371     MimeMessage_DeleteProp,
1372     MimeMessage_QueryProp,
1373     MimeMessage_GetTextBody,
1374     MimeMessage_SetTextBody,
1375     MimeMessage_AttachObject,
1376     MimeMessage_AttachFile,
1377     MimeMessage_AttachURL,
1378     MimeMessage_GetAttachments,
1379     MimeMessage_GetAddressTable,
1380     MimeMessage_GetSender,
1381     MimeMessage_GetAddressTypes,
1382     MimeMessage_GetAddressFormat,
1383     MimeMessage_EnumAddressTypes,
1384     MimeMessage_SplitMessage,
1385     MimeMessage_GetRootMoniker,
1386 };
1387
1388 /***********************************************************************
1389  *              MimeOleCreateMessage (INETCOMM.@)
1390  */
1391 HRESULT WINAPI MimeOleCreateMessage(IUnknown *pUnkOuter, IMimeMessage **ppMessage)
1392 {
1393     MimeMessage *This;
1394
1395     TRACE("(%p, %p)\n", pUnkOuter, ppMessage);
1396
1397     if (pUnkOuter)
1398     {
1399         FIXME("outer unknown not supported yet\n");
1400         return E_NOTIMPL;
1401     }
1402
1403     *ppMessage = NULL;
1404
1405     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1406     if (!This) return E_OUTOFMEMORY;
1407
1408     This->lpVtbl = &MimeMessageVtbl;
1409     This->refs = 1;
1410
1411     *ppMessage = (IMimeMessage *)&This->lpVtbl;
1412     return S_OK;
1413 }
1414
1415 /***********************************************************************
1416  *              MimeOleSetCompatMode (INETCOMM.@)
1417  */
1418 HRESULT WINAPI MimeOleSetCompatMode(DWORD dwMode)
1419 {
1420     FIXME("(0x%x)\n", dwMode);
1421     return S_OK;
1422 }
1423
1424 /***********************************************************************
1425  *              MimeOleCreateVirtualStream (INETCOMM.@)
1426  */
1427 HRESULT WINAPI MimeOleCreateVirtualStream(IStream **ppStream)
1428 {
1429     HRESULT hr;
1430     FIXME("(%p)\n", ppStream);
1431
1432     hr = CreateStreamOnHGlobal(NULL, TRUE, ppStream);
1433     return hr;
1434 }
1435
1436 typedef struct MimeSecurity
1437 {
1438     const IMimeSecurityVtbl *lpVtbl;
1439
1440     LONG refs;
1441 } MimeSecurity;
1442
1443 static HRESULT WINAPI MimeSecurity_QueryInterface(
1444         IMimeSecurity* iface,
1445         REFIID riid,
1446         void** obj)
1447 {
1448     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), obj);
1449
1450     if (IsEqualIID(riid, &IID_IUnknown) ||
1451         IsEqualIID(riid, &IID_IMimeSecurity))
1452     {
1453         *obj = iface;
1454         IUnknown_AddRef(iface);
1455         return S_OK;
1456     }
1457
1458     FIXME("no interface for %s\n", debugstr_guid(riid));
1459     *obj = NULL;
1460     return E_NOINTERFACE;
1461 }
1462
1463 static ULONG WINAPI MimeSecurity_AddRef(
1464         IMimeSecurity* iface)
1465 {
1466     MimeSecurity *This = (MimeSecurity *)iface;
1467     TRACE("(%p)->()\n", iface);
1468     return InterlockedIncrement(&This->refs);
1469 }
1470
1471 static ULONG WINAPI MimeSecurity_Release(
1472         IMimeSecurity* iface)
1473 {
1474     MimeSecurity *This = (MimeSecurity *)iface;
1475     ULONG refs;
1476
1477     TRACE("(%p)->()\n", iface);
1478
1479     refs = InterlockedDecrement(&This->refs);
1480     if (!refs)
1481     {
1482         HeapFree(GetProcessHeap(), 0, This);
1483     }
1484
1485     return refs;
1486 }
1487
1488 static HRESULT WINAPI MimeSecurity_InitNew(
1489         IMimeSecurity* iface)
1490 {
1491     FIXME("(%p)->(): stub\n", iface);
1492     return S_OK;
1493 }
1494
1495 static HRESULT WINAPI MimeSecurity_CheckInit(
1496         IMimeSecurity* iface)
1497 {
1498     FIXME("(%p)->(): stub\n", iface);
1499     return E_NOTIMPL;
1500 }
1501
1502 static HRESULT WINAPI MimeSecurity_EncodeMessage(
1503         IMimeSecurity* iface,
1504         IMimeMessageTree* pTree,
1505         DWORD dwFlags)
1506 {
1507     FIXME("(%p)->(%p, %08x): stub\n", iface, pTree, dwFlags);
1508     return E_NOTIMPL;
1509 }
1510
1511 static HRESULT WINAPI MimeSecurity_EncodeBody(
1512         IMimeSecurity* iface,
1513         IMimeMessageTree* pTree,
1514         HBODY hEncodeRoot,
1515         DWORD dwFlags)
1516 {
1517     FIXME("(%p)->(%p, %p, %08x): stub\n", iface, pTree, hEncodeRoot, dwFlags);
1518     return E_NOTIMPL;
1519 }
1520
1521 static HRESULT WINAPI MimeSecurity_DecodeMessage(
1522         IMimeSecurity* iface,
1523         IMimeMessageTree* pTree,
1524         DWORD dwFlags)
1525 {
1526     FIXME("(%p)->(%p, %08x): stub\n", iface, pTree, dwFlags);
1527     return E_NOTIMPL;
1528 }
1529
1530 static HRESULT WINAPI MimeSecurity_DecodeBody(
1531         IMimeSecurity* iface,
1532         IMimeMessageTree* pTree,
1533         HBODY hDecodeRoot,
1534         DWORD dwFlags)
1535 {
1536     FIXME("(%p)->(%p, %p, %08x): stub\n", iface, pTree, hDecodeRoot, dwFlags);
1537     return E_NOTIMPL;
1538 }
1539
1540 static HRESULT WINAPI MimeSecurity_EnumCertificates(
1541         IMimeSecurity* iface,
1542         HCAPICERTSTORE hc,
1543         DWORD dwUsage,
1544         PCX509CERT pPrev,
1545         PCX509CERT* ppCert)
1546 {
1547     FIXME("(%p)->(%p, %08x, %p, %p): stub\n", iface, hc, dwUsage, pPrev, ppCert);
1548     return E_NOTIMPL;
1549 }
1550
1551 static HRESULT WINAPI MimeSecurity_GetCertificateName(
1552         IMimeSecurity* iface,
1553         const PCX509CERT pX509Cert,
1554         const CERTNAMETYPE cn,
1555         LPSTR* ppszName)
1556 {
1557     FIXME("(%p)->(%p, %08x, %p): stub\n", iface, pX509Cert, cn, ppszName);
1558     return E_NOTIMPL;
1559 }
1560
1561 static HRESULT WINAPI MimeSecurity_GetMessageType(
1562         IMimeSecurity* iface,
1563         const HWND hwndParent,
1564         IMimeBody* pBody,
1565         DWORD* pdwSecType)
1566 {
1567     FIXME("(%p)->(%p, %p, %p): stub\n", iface, hwndParent, pBody, pdwSecType);
1568     return E_NOTIMPL;
1569 }
1570
1571 static HRESULT WINAPI MimeSecurity_GetCertData(
1572         IMimeSecurity* iface,
1573         const PCX509CERT pX509Cert,
1574         const CERTDATAID dataid,
1575         LPPROPVARIANT pValue)
1576 {
1577     FIXME("(%p)->(%p, %x, %p): stub\n", iface, pX509Cert, dataid, pValue);
1578     return E_NOTIMPL;
1579 }
1580
1581
1582 static const IMimeSecurityVtbl MimeSecurityVtbl =
1583 {
1584     MimeSecurity_QueryInterface,
1585     MimeSecurity_AddRef,
1586     MimeSecurity_Release,
1587     MimeSecurity_InitNew,
1588     MimeSecurity_CheckInit,
1589     MimeSecurity_EncodeMessage,
1590     MimeSecurity_EncodeBody,
1591     MimeSecurity_DecodeMessage,
1592     MimeSecurity_DecodeBody,
1593     MimeSecurity_EnumCertificates,
1594     MimeSecurity_GetCertificateName,
1595     MimeSecurity_GetMessageType,
1596     MimeSecurity_GetCertData
1597 };
1598
1599 /***********************************************************************
1600  *              MimeOleCreateSecurity (INETCOMM.@)
1601  */
1602 HRESULT WINAPI MimeOleCreateSecurity(IMimeSecurity **ppSecurity)
1603 {
1604     MimeSecurity *This;
1605
1606     TRACE("(%p)\n", ppSecurity);
1607
1608     *ppSecurity = NULL;
1609
1610     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1611     if (!This) return E_OUTOFMEMORY;
1612
1613     This->lpVtbl = &MimeSecurityVtbl;
1614     This->refs = 1;
1615
1616     *ppSecurity = (IMimeSecurity *)&This->lpVtbl;
1617     return S_OK;
1618 }