git.oblomov.eu Git - wine/blob - 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 #define NONAMELESSUNION
  24
  25 #include <stdarg.h>
  26 #include <stdio.h>
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winuser.h"
  31 #include "objbase.h"
  32 #include "ole2.h"
  33 #include "mimeole.h"
  34
  35 #include "wine/list.h"
  36 #include "wine/debug.h"
  37
  38 #include "inetcomm_private.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(inetcomm);
  41
  42 typedef struct
  43 {
  44     LPCSTR     name;
  45     DWORD      id;
  46     DWORD      flags; /* MIMEPROPFLAGS */
  47     VARTYPE    default_vt;
  48 } property_t;
  49
  50 typedef struct
  51 {
  52     struct list entry;
  53     property_t prop;
  54 } property_list_entry_t;
  55
  56 static const property_t default_props[] =
  57 {
  58     {"References",                   PID_HDR_REFS,       0,                               VT_LPSTR},
  59     {"Subject",                      PID_HDR_SUBJECT,    0,                               VT_LPSTR},
  60     {"From",                         PID_HDR_FROM,       MPF_ADDRESS,                     VT_LPSTR},
  61     {"Message-ID",                   PID_HDR_MESSAGEID,  0,                               VT_LPSTR},
  62     {"Return-Path",                  PID_HDR_RETURNPATH, MPF_ADDRESS,                     VT_LPSTR},
  63     {"Date",                         PID_HDR_DATE,       0,                               VT_LPSTR},
  64     {"Received",                     PID_HDR_RECEIVED,   0,                               VT_LPSTR},
  65     {"Reply-To",                     PID_HDR_REPLYTO,    MPF_ADDRESS,                     VT_LPSTR},
  66     {"X-Mailer",                     PID_HDR_XMAILER,    0,                               VT_LPSTR},
  67     {"Bcc",                          PID_HDR_BCC,        MPF_ADDRESS,                     VT_LPSTR},
  68     {"MIME-Version",                 PID_HDR_MIMEVER,    MPF_MIME,                        VT_LPSTR},
  69     {"Content-Type",                 PID_HDR_CNTTYPE,    MPF_MIME | MPF_HASPARAMS,        VT_LPSTR},
  70     {"Content-Transfer-Encoding",    PID_HDR_CNTXFER,    MPF_MIME,                        VT_LPSTR},
  71     {"Content-ID",                   PID_HDR_CNTID,      MPF_MIME,                        VT_LPSTR},
  72     {"Content-Disposition",          PID_HDR_CNTDISP,    MPF_MIME | MPF_HASPARAMS,        VT_LPSTR},
  73     {"To",                           PID_HDR_TO,         MPF_ADDRESS,                     VT_LPSTR},
  74     {"Cc",                           PID_HDR_CC,         MPF_ADDRESS,                     VT_LPSTR},
  75     {"Sender",                       PID_HDR_SENDER,     MPF_ADDRESS,                     VT_LPSTR},
  76     {"In-Reply-To",                  PID_HDR_INREPLYTO,  0,                               VT_LPSTR},
  77     {NULL,                           0,                  0,                               0}
  78 };
  79
  80 typedef struct
  81 {
  82     struct list entry;
  83     char *name;
  84     char *value;
  85 } param_t;
  86
  87 typedef struct
  88 {
  89     struct list entry;
  90     const property_t *prop;
  91     PROPVARIANT value;
  92     struct list params;
  93 } header_t;
  94
  95 typedef struct MimeBody
  96 {
  97     IMimeBody IMimeBody_iface;
  98     LONG ref;
  99
 100     HBODY handle;
 101
 102     struct list headers;
 103     struct list new_props; /* FIXME: This should be in a PropertySchema */
 104     DWORD next_prop_id;
 105     char *content_pri_type;
 106     char *content_sub_type;
 107     ENCODINGTYPE encoding;
 108     void *data;
 109     IID data_iid;
 110     BODYOFFSETS body_offsets;
 111 } MimeBody;
 112
 113 static inline MimeBody *impl_from_IMimeBody(IMimeBody *iface)
 114 {
 115     return CONTAINING_RECORD(iface, MimeBody, IMimeBody_iface);
 116 }
 117
 118 static LPSTR strdupA(LPCSTR str)
 119 {
 120     char *ret;
 121     int len = strlen(str);
 122     ret = HeapAlloc(GetProcessHeap(), 0, len + 1);
 123     memcpy(ret, str, len + 1);
 124     return ret;
 125 }
 126
 127 #define PARSER_BUF_SIZE 1024
 128
 129 /*****************************************************
 130  *        copy_headers_to_buf [internal]
 131  *
 132  * Copies the headers into a '\0' terminated memory block and leave
 133  * the stream's current position set to after the blank line.
 134  */
 135 static HRESULT copy_headers_to_buf(IStream *stm, char **ptr)
 136 {
 137     char *buf = NULL;
 138     DWORD size = PARSER_BUF_SIZE, offset = 0, last_end = 0;
 139     HRESULT hr;
 140     int done = 0;
 141
 142     *ptr = NULL;
 143
 144     do
 145     {
 146         char *end;
 147         DWORD read;
 148
 149         if(!buf)
 150             buf = HeapAlloc(GetProcessHeap(), 0, size + 1);
 151         else
 152         {
 153             size *= 2;
 154             buf = HeapReAlloc(GetProcessHeap(), 0, buf, size + 1);
 155         }
 156         if(!buf)
 157         {
 158             hr = E_OUTOFMEMORY;
 159             goto fail;
 160         }
 161
 162         hr = IStream_Read(stm, buf + offset, size - offset, &read);
 163         if(FAILED(hr)) goto fail;
 164
 165         offset += read;
 166         buf[offset] = '\0';
 167
 168         if(read == 0) done = 1;
 169
 170         while(!done && (end = strstr(buf + last_end, "\r\n")))
 171         {
 172             DWORD new_end = end - buf + 2;
 173             if(new_end - last_end == 2)
 174             {
 175                 LARGE_INTEGER off;
 176                 off.QuadPart = new_end;
 177                 IStream_Seek(stm, off, STREAM_SEEK_SET, NULL);
 178                 buf[new_end] = '\0';
 179                 done = 1;
 180             }
 181             else
 182                 last_end = new_end;
 183         }
 184     } while(!done);
 185
 186     *ptr = buf;
 187     return S_OK;
 188
 189 fail:
 190     HeapFree(GetProcessHeap(), 0, buf);
 191     return hr;
 192 }
 193
 194 static header_t *read_prop(MimeBody *body, char **ptr)
 195 {
 196     char *colon = strchr(*ptr, ':');
 197     const property_t *prop;
 198     header_t *ret;
 199
 200     if(!colon) return NULL;
 201
 202     *colon = '\0';
 203
 204     for(prop = default_props; prop->name; prop++)
 205     {
 206         if(!strcasecmp(*ptr, prop->name))
 207         {
 208             TRACE("%s: found match with default property id %d\n", *ptr, prop->id);
 209             break;
 210         }
 211     }
 212
 213     if(!prop->name)
 214     {
 215         property_list_entry_t *prop_entry;
 216         LIST_FOR_EACH_ENTRY(prop_entry, &body->new_props, property_list_entry_t, entry)
 217         {
 218             if(!strcasecmp(*ptr, prop_entry->prop.name))
 219             {
 220                 TRACE("%s: found match with already added new property id %d\n", *ptr, prop_entry->prop.id);
 221                 prop = &prop_entry->prop;
 222                 break;
 223             }
 224         }
 225         if(!prop->name)
 226         {
 227             prop_entry = HeapAlloc(GetProcessHeap(), 0, sizeof(*prop_entry));
 228             prop_entry->prop.name = strdupA(*ptr);
 229             prop_entry->prop.id = body->next_prop_id++;
 230             prop_entry->prop.flags = 0;
 231             prop_entry->prop.default_vt = VT_LPSTR;
 232             list_add_tail(&body->new_props, &prop_entry->entry);
 233             prop = &prop_entry->prop;
 234             TRACE("%s: allocating new prop id %d\n", *ptr, prop_entry->prop.id);
 235         }
 236     }
 237
 238     ret = HeapAlloc(GetProcessHeap(), 0, sizeof(*ret));
 239     ret->prop = prop;
 240     PropVariantInit(&ret->value);
 241     list_init(&ret->params);
 242     *ptr = colon + 1;
 243
 244     return ret;
 245 }
 246
 247 static void unfold_header(char *header, int len)
 248 {
 249     char *start = header, *cp = header;
 250
 251     do {
 252         while(*cp == ' ' || *cp == '\t')
 253         {
 254             cp++;
 255             len--;
 256         }
 257         if(cp != start)
 258             memmove(start, cp, len + 1);
 259
 260         cp = strstr(start, "\r\n");
 261         len -= (cp - start);
 262         start = cp;
 263         *start = ' ';
 264         start++;
 265         len--;
 266         cp += 2;
 267     } while(*cp == ' ' || *cp == '\t');
 268
 269     *(start - 1) = '\0';
 270 }
 271
 272 static char *unquote_string(const char *str)
 273 {
 274     int quoted = 0;
 275     char *ret, *cp;
 276
 277     while(*str == ' ' || *str == '\t') str++;
 278
 279     if(*str == '"')
 280     {
 281         quoted = 1;
 282         str++;
 283     }
 284     ret = strdupA(str);
 285     for(cp = ret; *cp; cp++)
 286     {
 287         if(*cp == '\\')
 288             memmove(cp, cp + 1, strlen(cp + 1) + 1);
 289         else if(*cp == '"')
 290         {
 291             if(!quoted)
 292             {
 293                 WARN("quote in unquoted string\n");
 294             }
 295             else
 296             {
 297                 *cp = '\0';
 298                 break;
 299             }
 300         }
 301     }
 302     return ret;
 303 }
 304
 305 static void add_param(header_t *header, const char *p)
 306 {
 307     const char *key = p, *value, *cp = p;
 308     param_t *param;
 309     char *name;
 310
 311     TRACE("got param %s\n", p);
 312
 313     while (*key == ' ' || *key == '\t' ) key++;
 314
 315     cp = strchr(key, '=');
 316     if(!cp)
 317     {
 318         WARN("malformed parameter - skipping\n");
 319         return;
 320     }
 321
 322     name = HeapAlloc(GetProcessHeap(), 0, cp - key + 1);
 323     memcpy(name, key, cp - key);
 324     name[cp - key] = '\0';
 325
 326     value = cp + 1;
 327
 328     param = HeapAlloc(GetProcessHeap(), 0, sizeof(*param));
 329     param->name = name;
 330     param->value = unquote_string(value);
 331     list_add_tail(&header->params, &param->entry);
 332 }
 333
 334 static void split_params(header_t *header, char *value)
 335 {
 336     char *cp = value, *start = value;
 337     int in_quote = 0;
 338     int done_value = 0;
 339
 340     while(*cp)
 341     {
 342         if(!in_quote && *cp == ';')
 343         {
 344             *cp = '\0';
 345             if(done_value) add_param(header, start);
 346             done_value = 1;
 347             start = cp + 1;
 348         }
 349         else if(*cp == '"')
 350             in_quote = !in_quote;
 351         cp++;
 352     }
 353     if(done_value) add_param(header, start);
 354 }
 355
 356 static void read_value(header_t *header, char **cur)
 357 {
 358     char *end = *cur, *value;
 359     DWORD len;
 360
 361     do {
 362         end = strstr(end, "\r\n");
 363         end += 2;
 364     } while(*end == ' ' || *end == '\t');
 365
 366     len = end - *cur;
 367     value = HeapAlloc(GetProcessHeap(), 0, len + 1);
 368     memcpy(value, *cur, len);
 369     value[len] = '\0';
 370
 371     unfold_header(value, len);
 372     TRACE("value %s\n", debugstr_a(value));
 373
 374     if(header->prop->flags & MPF_HASPARAMS)
 375     {
 376         split_params(header, value);
 377         TRACE("value w/o params %s\n", debugstr_a(value));
 378     }
 379
 380     header->value.vt = VT_LPSTR;
 381     header->value.u.pszVal = value;
 382
 383     *cur = end;
 384 }
 385
 386 static void init_content_type(MimeBody *body, header_t *header)
 387 {
 388     char *slash;
 389     DWORD len;
 390
 391     if(header->prop->id != PID_HDR_CNTTYPE)
 392     {
 393         ERR("called with header %s\n", header->prop->name);
 394         return;
 395     }
 396
 397     slash = strchr(header->value.u.pszVal, '/');
 398     if(!slash)
 399     {
 400         WARN("malformed context type value\n");
 401         return;
 402     }
 403     len = slash - header->value.u.pszVal;
 404     body->content_pri_type = HeapAlloc(GetProcessHeap(), 0, len + 1);
 405     memcpy(body->content_pri_type, header->value.u.pszVal, len);
 406     body->content_pri_type[len] = '\0';
 407     body->content_sub_type = strdupA(slash + 1);
 408 }
 409
 410 static HRESULT parse_headers(MimeBody *body, IStream *stm)
 411 {
 412     char *header_buf, *cur_header_ptr;
 413     HRESULT hr;
 414     header_t *header;
 415
 416     hr = copy_headers_to_buf(stm, &header_buf);
 417     if(FAILED(hr)) return hr;
 418
 419     cur_header_ptr = header_buf;
 420     while((header = read_prop(body, &cur_header_ptr)))
 421     {
 422         read_value(header, &cur_header_ptr);
 423         list_add_tail(&body->headers, &header->entry);
 424
 425         if(header->prop->id == PID_HDR_CNTTYPE)
 426             init_content_type(body, header);
 427     }
 428
 429     HeapFree(GetProcessHeap(), 0, header_buf);
 430     return hr;
 431 }
 432
 433 static void empty_param_list(struct list *list)
 434 {
 435     param_t *param, *cursor2;
 436
 437     LIST_FOR_EACH_ENTRY_SAFE(param, cursor2, list, param_t, entry)
 438     {
 439         list_remove(&param->entry);
 440         HeapFree(GetProcessHeap(), 0, param->name);
 441         HeapFree(GetProcessHeap(), 0, param->value);
 442         HeapFree(GetProcessHeap(), 0, param);
 443     }
 444 }
 445
 446 static void empty_header_list(struct list *list)
 447 {
 448     header_t *header, *cursor2;
 449
 450     LIST_FOR_EACH_ENTRY_SAFE(header, cursor2, list, header_t, entry)
 451     {
 452         list_remove(&header->entry);
 453         PropVariantClear(&header->value);
 454         empty_param_list(&header->params);
 455         HeapFree(GetProcessHeap(), 0, header);
 456     }
 457 }
 458
 459 static void empty_new_prop_list(struct list *list)
 460 {
 461     property_list_entry_t *prop, *cursor2;
 462
 463     LIST_FOR_EACH_ENTRY_SAFE(prop, cursor2, list, property_list_entry_t, entry)
 464     {
 465         list_remove(&prop->entry);
 466         HeapFree(GetProcessHeap(), 0, (char *)prop->prop.name);
 467         HeapFree(GetProcessHeap(), 0, prop);
 468     }
 469 }
 470
 471 static void release_data(REFIID riid, void *data)
 472 {
 473     if(!data) return;
 474
 475     if(IsEqualIID(riid, &IID_IStream))
 476         IStream_Release((IStream *)data);
 477     else
 478         FIXME("Unhandled data format %s\n", debugstr_guid(riid));
 479 }
 480
 481 static HRESULT find_prop(MimeBody *body, const char *name, header_t **prop)
 482 {
 483     header_t *header;
 484
 485     *prop = NULL;
 486
 487     LIST_FOR_EACH_ENTRY(header, &body->headers, header_t, entry)
 488     {
 489         if(!strcasecmp(name, header->prop->name))
 490         {
 491             *prop = header;
 492             return S_OK;
 493         }
 494     }
 495
 496     return MIME_E_NOT_FOUND;
 497 }
 498
 499 static HRESULT WINAPI MimeBody_QueryInterface(IMimeBody* iface,
 500                                      REFIID riid,
 501                                      void** ppvObject)
 502 {
 503     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppvObject);
 504
 505     *ppvObject = NULL;
 506
 507     if (IsEqualIID(riid, &IID_IUnknown) ||
 508         IsEqualIID(riid, &IID_IPersist) ||
 509         IsEqualIID(riid, &IID_IPersistStreamInit) ||
 510         IsEqualIID(riid, &IID_IMimePropertySet) ||
 511         IsEqualIID(riid, &IID_IMimeBody))
 512     {
 513         *ppvObject = iface;
 514     }
 515
 516     if(*ppvObject)
 517     {
 518         IUnknown_AddRef((IUnknown*)*ppvObject);
 519         return S_OK;
 520     }
 521
 522     FIXME("no interface for %s\n", debugstr_guid(riid));
 523     return E_NOINTERFACE;
 524 }
 525
 526 static ULONG WINAPI MimeBody_AddRef(IMimeBody *iface)
 527 {
 528     MimeBody *This = impl_from_IMimeBody(iface);
 529     LONG ref = InterlockedIncrement(&This->ref);
 530
 531     TRACE("(%p) ref=%d\n", This, ref);
 532
 533     return ref;
 534 }
 535
 536 static ULONG WINAPI MimeBody_Release(IMimeBody *iface)
 537 {
 538     MimeBody *This = impl_from_IMimeBody(iface);
 539     LONG ref = InterlockedDecrement(&This->ref);
 540
 541     TRACE("(%p) ref=%d\n", This, ref);
 542
 543     if (!ref)
 544     {
 545         empty_header_list(&This->headers);
 546         empty_new_prop_list(&This->new_props);
 547
 548         HeapFree(GetProcessHeap(), 0, This->content_pri_type);
 549         HeapFree(GetProcessHeap(), 0, This->content_sub_type);
 550
 551         release_data(&This->data_iid, This->data);
 552
 553         HeapFree(GetProcessHeap(), 0, This);
 554     }
 555
 556     return ref;
 557 }
 558
 559 static HRESULT WINAPI MimeBody_GetClassID(
 560                                  IMimeBody* iface,
 561                                  CLSID* pClassID)
 562 {
 563     FIXME("stub\n");
 564     return E_NOTIMPL;
 565 }
 566
 567
 568 static HRESULT WINAPI MimeBody_IsDirty(
 569                               IMimeBody* iface)
 570 {
 571     FIXME("stub\n");
 572     return E_NOTIMPL;
 573 }
 574
 575 static HRESULT WINAPI MimeBody_Load(IMimeBody *iface, IStream *pStm)
 576 {
 577     MimeBody *This = impl_from_IMimeBody(iface);
 578     TRACE("(%p)->(%p)\n", iface, pStm);
 579     return parse_headers(This, pStm);
 580 }
 581
 582 static HRESULT WINAPI MimeBody_Save(IMimeBody *iface, IStream *pStm, BOOL fClearDirty)
 583 {
 584     FIXME("stub\n");
 585     return E_NOTIMPL;
 586 }
 587
 588 static HRESULT WINAPI MimeBody_GetSizeMax(
 589                                  IMimeBody* iface,
 590                                  ULARGE_INTEGER* pcbSize)
 591 {
 592     FIXME("stub\n");
 593     return E_NOTIMPL;
 594 }
 595
 596 static HRESULT WINAPI MimeBody_InitNew(
 597                               IMimeBody* iface)
 598 {
 599     TRACE("%p->()\n", iface);
 600     return S_OK;
 601 }
 602
 603 static HRESULT WINAPI MimeBody_GetPropInfo(
 604                                   IMimeBody* iface,
 605                                   LPCSTR pszName,
 606                                   LPMIMEPROPINFO pInfo)
 607 {
 608     FIXME("stub\n");
 609     return E_NOTIMPL;
 610 }
 611
 612 static HRESULT WINAPI MimeBody_SetPropInfo(
 613                                   IMimeBody* iface,
 614                                   LPCSTR pszName,
 615                                   LPCMIMEPROPINFO pInfo)
 616 {
 617     FIXME("stub\n");
 618     return E_NOTIMPL;
 619 }
 620
 621 static HRESULT WINAPI MimeBody_GetProp(
 622                               IMimeBody* iface,
 623                               LPCSTR pszName,
 624                               DWORD dwFlags,
 625                               LPPROPVARIANT pValue)
 626 {
 627     MimeBody *This = impl_from_IMimeBody(iface);
 628     TRACE("(%p)->(%s, %d, %p)\n", This, pszName, dwFlags, pValue);
 629
 630     if(!strcasecmp(pszName, "att:pri-content-type"))
 631     {
 632         PropVariantClear(pValue);
 633         pValue->vt = VT_LPSTR;
 634         pValue->u.pszVal = strdupA(This->content_pri_type);
 635         return S_OK;
 636     }
 637
 638     FIXME("stub!\n");
 639     return E_FAIL;
 640 }
 641
 642 static HRESULT WINAPI MimeBody_SetProp(
 643                               IMimeBody* iface,
 644                               LPCSTR pszName,
 645                               DWORD dwFlags,
 646                               LPCPROPVARIANT pValue)
 647 {
 648     FIXME("stub\n");
 649     return E_NOTIMPL;
 650 }
 651
 652 static HRESULT WINAPI MimeBody_AppendProp(
 653                                  IMimeBody* iface,
 654                                  LPCSTR pszName,
 655                                  DWORD dwFlags,
 656                                  LPPROPVARIANT pValue)
 657 {
 658     FIXME("stub\n");
 659     return E_NOTIMPL;
 660 }
 661
 662 static HRESULT WINAPI MimeBody_DeleteProp(
 663                                  IMimeBody* iface,
 664                                  LPCSTR pszName)
 665 {
 666     FIXME("stub\n");
 667     return E_NOTIMPL;
 668 }
 669
 670 static HRESULT WINAPI MimeBody_CopyProps(
 671                                 IMimeBody* iface,
 672                                 ULONG cNames,
 673                                 LPCSTR* prgszName,
 674                                 IMimePropertySet* pPropertySet)
 675 {
 676     FIXME("stub\n");
 677     return E_NOTIMPL;
 678 }
 679
 680 static HRESULT WINAPI MimeBody_MoveProps(
 681                                 IMimeBody* iface,
 682                                 ULONG cNames,
 683                                 LPCSTR* prgszName,
 684                                 IMimePropertySet* pPropertySet)
 685 {
 686     FIXME("stub\n");
 687     return E_NOTIMPL;
 688 }
 689
 690 static HRESULT WINAPI MimeBody_DeleteExcept(
 691                                    IMimeBody* iface,
 692                                    ULONG cNames,
 693                                    LPCSTR* prgszName)
 694 {
 695     FIXME("stub\n");
 696     return E_NOTIMPL;
 697 }
 698
 699 static HRESULT WINAPI MimeBody_QueryProp(
 700                                 IMimeBody* iface,
 701                                 LPCSTR pszName,
 702                                 LPCSTR pszCriteria,
 703                                 boolean fSubString,
 704                                 boolean fCaseSensitive)
 705 {
 706     FIXME("stub\n");
 707     return E_NOTIMPL;
 708 }
 709
 710 static HRESULT WINAPI MimeBody_GetCharset(
 711                                  IMimeBody* iface,
 712                                  LPHCHARSET phCharset)
 713 {
 714     FIXME("stub\n");
 715     *phCharset = NULL;
 716     return S_OK;
 717 }
 718
 719 static HRESULT WINAPI MimeBody_SetCharset(
 720                                  IMimeBody* iface,
 721                                  HCHARSET hCharset,
 722                                  CSETAPPLYTYPE applytype)
 723 {
 724     FIXME("stub\n");
 725     return E_NOTIMPL;
 726 }
 727
 728 static HRESULT WINAPI MimeBody_GetParameters(
 729                                     IMimeBody* iface,
 730                                     LPCSTR pszName,
 731                                     ULONG* pcParams,
 732                                     LPMIMEPARAMINFO* pprgParam)
 733 {
 734     MimeBody *This = impl_from_IMimeBody(iface);
 735     HRESULT hr;
 736     header_t *header;
 737
 738     TRACE("(%p)->(%s, %p, %p)\n", iface, debugstr_a(pszName), pcParams, pprgParam);
 739
 740     *pprgParam = NULL;
 741     *pcParams = 0;
 742
 743     hr = find_prop(This, pszName, &header);
 744     if(hr != S_OK) return hr;
 745
 746     *pcParams = list_count(&header->params);
 747     if(*pcParams)
 748     {
 749         IMimeAllocator *alloc;
 750         param_t *param;
 751         MIMEPARAMINFO *info;
 752
 753         MimeOleGetAllocator(&alloc);
 754
 755         *pprgParam = info = IMimeAllocator_Alloc(alloc, *pcParams * sizeof(**pprgParam));
 756         LIST_FOR_EACH_ENTRY(param, &header->params, param_t, entry)
 757         {
 758             int len;
 759
 760             len = strlen(param->name) + 1;
 761             info->pszName = IMimeAllocator_Alloc(alloc, len);
 762             memcpy(info->pszName, param->name, len);
 763             len = strlen(param->value) + 1;
 764             info->pszData = IMimeAllocator_Alloc(alloc, len);
 765             memcpy(info->pszData, param->value, len);
 766             info++;
 767         }
 768         IMimeAllocator_Release(alloc);
 769     }
 770     return S_OK;
 771 }
 772
 773 static HRESULT WINAPI MimeBody_IsContentType(
 774                                     IMimeBody* iface,
 775                                     LPCSTR pszPriType,
 776                                     LPCSTR pszSubType)
 777 {
 778     MimeBody *This = impl_from_IMimeBody(iface);
 779
 780     TRACE("(%p)->(%s, %s)\n", This, debugstr_a(pszPriType), debugstr_a(pszSubType));
 781     if(pszPriType)
 782     {
 783         const char *pri = This->content_pri_type;
 784         if(!pri) pri = "text";
 785         if(strcasecmp(pri, pszPriType)) return S_FALSE;
 786     }
 787
 788     if(pszSubType)
 789     {
 790         const char *sub = This->content_sub_type;
 791         if(!sub) sub = "plain";
 792         if(strcasecmp(sub, pszSubType)) return S_FALSE;
 793     }
 794
 795     return S_OK;
 796 }
 797
 798 static HRESULT WINAPI MimeBody_BindToObject(
 799                                    IMimeBody* iface,
 800                                    REFIID riid,
 801                                    void** ppvObject)
 802 {
 803     FIXME("stub\n");
 804     return E_NOTIMPL;
 805 }
 806
 807 static HRESULT WINAPI MimeBody_Clone(
 808                             IMimeBody* iface,
 809                             IMimePropertySet** ppPropertySet)
 810 {
 811     FIXME("stub\n");
 812     return E_NOTIMPL;
 813 }
 814
 815 static HRESULT WINAPI MimeBody_SetOption(
 816                                 IMimeBody* iface,
 817                                 const TYPEDID oid,
 818                                 LPCPROPVARIANT pValue)
 819 {
 820     HRESULT hr = E_NOTIMPL;
 821     TRACE("(%p)->(%08x, %p)\n", iface, oid, pValue);
 822
 823     if(pValue->vt != TYPEDID_TYPE(oid))
 824     {
 825         WARN("Called with vartype %04x and oid %08x\n", pValue->vt, oid);
 826         return E_INVALIDARG;
 827     }
 828
 829     switch(oid)
 830     {
 831     case OID_SECURITY_HWND_OWNER:
 832         FIXME("OID_SECURITY_HWND_OWNER (value %08x): ignoring\n", pValue->u.ulVal);
 833         hr = S_OK;
 834         break;
 835     default:
 836         FIXME("Unhandled oid %08x\n", oid);
 837     }
 838
 839     return hr;
 840 }
 841
 842 static HRESULT WINAPI MimeBody_GetOption(
 843                                 IMimeBody* iface,
 844                                 const TYPEDID oid,
 845                                 LPPROPVARIANT pValue)
 846 {
 847     FIXME("(%p)->(%08x, %p): stub\n", iface, oid, pValue);
 848     return E_NOTIMPL;
 849 }
 850
 851 static HRESULT WINAPI MimeBody_EnumProps(
 852                                 IMimeBody* iface,
 853                                 DWORD dwFlags,
 854                                 IMimeEnumProperties** ppEnum)
 855 {
 856     FIXME("stub\n");
 857     return E_NOTIMPL;
 858 }
 859
 860 static HRESULT WINAPI MimeBody_IsType(
 861                              IMimeBody* iface,
 862                              IMSGBODYTYPE bodytype)
 863 {
 864     MimeBody *This = impl_from_IMimeBody(iface);
 865
 866     TRACE("(%p)->(%d)\n", iface, bodytype);
 867     switch(bodytype)
 868     {
 869     case IBT_EMPTY:
 870         return This->data ? S_FALSE : S_OK;
 871     default:
 872         FIXME("Unimplemented bodytype %d - returning S_OK\n", bodytype);
 873     }
 874     return S_OK;
 875 }
 876
 877 static HRESULT WINAPI MimeBody_SetDisplayName(
 878                                      IMimeBody* iface,
 879                                      LPCSTR pszDisplay)
 880 {
 881     FIXME("stub\n");
 882     return E_NOTIMPL;
 883 }
 884
 885 static HRESULT WINAPI MimeBody_GetDisplayName(
 886                                      IMimeBody* iface,
 887                                      LPSTR* ppszDisplay)
 888 {
 889     FIXME("stub\n");
 890     return E_NOTIMPL;
 891 }
 892
 893 static HRESULT WINAPI MimeBody_GetOffsets(
 894                                  IMimeBody* iface,
 895                                  LPBODYOFFSETS pOffsets)
 896 {
 897     MimeBody *This = impl_from_IMimeBody(iface);
 898     TRACE("(%p)->(%p)\n", This, pOffsets);
 899
 900     *pOffsets = This->body_offsets;
 901
 902     if(This->body_offsets.cbBodyEnd == 0) return MIME_E_NO_DATA;
 903     return S_OK;
 904 }
 905
 906 static HRESULT WINAPI MimeBody_GetCurrentEncoding(
 907                                          IMimeBody* iface,
 908                                          ENCODINGTYPE* pietEncoding)
 909 {
 910     MimeBody *This = impl_from_IMimeBody(iface);
 911
 912     TRACE("(%p)->(%p)\n", This, pietEncoding);
 913
 914     *pietEncoding = This->encoding;
 915     return S_OK;
 916 }
 917
 918 static HRESULT WINAPI MimeBody_SetCurrentEncoding(
 919                                          IMimeBody* iface,
 920                                          ENCODINGTYPE ietEncoding)
 921 {
 922     MimeBody *This = impl_from_IMimeBody(iface);
 923
 924     TRACE("(%p)->(%d)\n", This, ietEncoding);
 925
 926     This->encoding = ietEncoding;
 927     return S_OK;
 928 }
 929
 930 static HRESULT WINAPI MimeBody_GetEstimatedSize(
 931                                        IMimeBody* iface,
 932                                        ENCODINGTYPE ietEncoding,
 933                                        ULONG* pcbSize)
 934 {
 935     FIXME("stub\n");
 936     return E_NOTIMPL;
 937 }
 938
 939 static HRESULT WINAPI MimeBody_GetDataHere(
 940                                   IMimeBody* iface,
 941                                   ENCODINGTYPE ietEncoding,
 942                                   IStream* pStream)
 943 {
 944     FIXME("stub\n");
 945     return E_NOTIMPL;
 946 }
 947
 948 static HRESULT WINAPI MimeBody_GetData(
 949                               IMimeBody* iface,
 950                               ENCODINGTYPE ietEncoding,
 951                               IStream** ppStream)
 952 {
 953     MimeBody *This = impl_from_IMimeBody(iface);
 954     FIXME("(%p)->(%d, %p). Ignoring encoding type.\n", This, ietEncoding, ppStream);
 955
 956     *ppStream = This->data;
 957     IStream_AddRef(*ppStream);
 958     return S_OK;
 959 }
 960
 961 static HRESULT WINAPI MimeBody_SetData(
 962                               IMimeBody* iface,
 963                               ENCODINGTYPE ietEncoding,
 964                               LPCSTR pszPriType,
 965                               LPCSTR pszSubType,
 966                               REFIID riid,
 967                               LPVOID pvObject)
 968 {
 969     MimeBody *This = impl_from_IMimeBody(iface);
 970     TRACE("(%p)->(%d, %s, %s, %s %p)\n", This, ietEncoding, debugstr_a(pszPriType), debugstr_a(pszSubType),
 971           debugstr_guid(riid), pvObject);
 972
 973     if(IsEqualIID(riid, &IID_IStream))
 974         IStream_AddRef((IStream *)pvObject);
 975     else
 976     {
 977         FIXME("Unhandled object type %s\n", debugstr_guid(riid));
 978         return E_INVALIDARG;
 979     }
 980
 981     if(This->data)
 982         FIXME("release old data\n");
 983
 984     This->data_iid = *riid;
 985     This->data = pvObject;
 986
 987     IMimeBody_SetCurrentEncoding(iface, ietEncoding);
 988
 989     /* FIXME: Update the content type.
 990        If pszPriType == NULL use 'application'
 991        If pszSubType == NULL use 'octet-stream' */
 992
 993     return S_OK;
 994 }
 995
 996 static HRESULT WINAPI MimeBody_EmptyData(
 997                                 IMimeBody* iface)
 998 {
 999     FIXME("stub\n");
1000     return E_NOTIMPL;
1001 }
1002
1003 static HRESULT WINAPI MimeBody_CopyTo(
1004                              IMimeBody* iface,
1005                              IMimeBody* pBody)
1006 {
1007     FIXME("stub\n");
1008     return E_NOTIMPL;
1009 }
1010
1011 static HRESULT WINAPI MimeBody_GetTransmitInfo(
1012                                       IMimeBody* iface,
1013                                       LPTRANSMITINFO pTransmitInfo)
1014 {
1015     FIXME("stub\n");
1016     return E_NOTIMPL;
1017 }
1018
1019 static HRESULT WINAPI MimeBody_SaveToFile(
1020                                  IMimeBody* iface,
1021                                  ENCODINGTYPE ietEncoding,
1022                                  LPCSTR pszFilePath)
1023 {
1024     FIXME("stub\n");
1025     return E_NOTIMPL;
1026 }
1027
1028 static HRESULT WINAPI MimeBody_GetHandle(
1029                                 IMimeBody* iface,
1030                                 LPHBODY phBody)
1031 {
1032     MimeBody *This = impl_from_IMimeBody(iface);
1033     TRACE("(%p)->(%p)\n", iface, phBody);
1034
1035     *phBody = This->handle;
1036     return This->handle ? S_OK : MIME_E_NO_DATA;
1037 }
1038
1039 static IMimeBodyVtbl body_vtbl =
1040 {
1041     MimeBody_QueryInterface,
1042     MimeBody_AddRef,
1043     MimeBody_Release,
1044     MimeBody_GetClassID,
1045     MimeBody_IsDirty,
1046     MimeBody_Load,
1047     MimeBody_Save,
1048     MimeBody_GetSizeMax,
1049     MimeBody_InitNew,
1050     MimeBody_GetPropInfo,
1051     MimeBody_SetPropInfo,
1052     MimeBody_GetProp,
1053     MimeBody_SetProp,
1054     MimeBody_AppendProp,
1055     MimeBody_DeleteProp,
1056     MimeBody_CopyProps,
1057     MimeBody_MoveProps,
1058     MimeBody_DeleteExcept,
1059     MimeBody_QueryProp,
1060     MimeBody_GetCharset,
1061     MimeBody_SetCharset,
1062     MimeBody_GetParameters,
1063     MimeBody_IsContentType,
1064     MimeBody_BindToObject,
1065     MimeBody_Clone,
1066     MimeBody_SetOption,
1067     MimeBody_GetOption,
1068     MimeBody_EnumProps,
1069     MimeBody_IsType,
1070     MimeBody_SetDisplayName,
1071     MimeBody_GetDisplayName,
1072     MimeBody_GetOffsets,
1073     MimeBody_GetCurrentEncoding,
1074     MimeBody_SetCurrentEncoding,
1075     MimeBody_GetEstimatedSize,
1076     MimeBody_GetDataHere,
1077     MimeBody_GetData,
1078     MimeBody_SetData,
1079     MimeBody_EmptyData,
1080     MimeBody_CopyTo,
1081     MimeBody_GetTransmitInfo,
1082     MimeBody_SaveToFile,
1083     MimeBody_GetHandle
1084 };
1085
1086 static HRESULT MimeBody_set_offsets(MimeBody *body, const BODYOFFSETS *offsets)
1087 {
1088     TRACE("setting offsets to %d, %d, %d, %d\n", offsets->cbBoundaryStart,
1089           offsets->cbHeaderStart, offsets->cbBodyStart, offsets->cbBodyEnd);
1090
1091     body->body_offsets = *offsets;
1092     return S_OK;
1093 }
1094
1095 #define FIRST_CUSTOM_PROP_ID 0x100
1096
1097 static MimeBody *mimebody_create(void)
1098 {
1099     MimeBody *This;
1100     BODYOFFSETS body_offsets;
1101
1102     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1103     if (!This)
1104         return NULL;
1105
1106     This->IMimeBody_iface.lpVtbl = &body_vtbl;
1107     This->ref = 1;
1108     This->handle = NULL;
1109     list_init(&This->headers);
1110     list_init(&This->new_props);
1111     This->next_prop_id = FIRST_CUSTOM_PROP_ID;
1112     This->content_pri_type = NULL;
1113     This->content_sub_type = NULL;
1114     This->encoding = IET_7BIT;
1115     This->data = NULL;
1116     This->data_iid = IID_NULL;
1117
1118     body_offsets.cbBoundaryStart = body_offsets.cbHeaderStart = 0;
1119     body_offsets.cbBodyStart     = body_offsets.cbBodyEnd     = 0;
1120     MimeBody_set_offsets(This, &body_offsets);
1121
1122     return This;
1123 }
1124
1125 HRESULT MimeBody_create(IUnknown *outer, void **ppv)
1126 {
1127     MimeBody *mb;
1128
1129     if(outer)
1130         return CLASS_E_NOAGGREGATION;
1131
1132     if ((mb = mimebody_create()))
1133     {
1134         *ppv = &mb->IMimeBody_iface;
1135         return S_OK;
1136     }
1137     else
1138     {
1139         *ppv = NULL;
1140         return E_OUTOFMEMORY;
1141     }
1142 }
1143
1144
1145
1146 typedef struct
1147 {
1148     IStream IStream_iface;
1149     LONG ref;
1150     IStream *base;
1151     ULARGE_INTEGER pos, start, length;
1152 } sub_stream_t;
1153
1154 static inline sub_stream_t *impl_from_IStream(IStream *iface)
1155 {
1156     return CONTAINING_RECORD(iface, sub_stream_t, IStream_iface);
1157 }
1158
1159 static HRESULT WINAPI sub_stream_QueryInterface(IStream *iface, REFIID riid, void **ppv)
1160 {
1161     sub_stream_t *This = impl_from_IStream(iface);
1162
1163     TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
1164     *ppv = NULL;
1165
1166     if(IsEqualIID(riid, &IID_IUnknown) ||
1167        IsEqualIID(riid, &IID_ISequentialStream) ||
1168        IsEqualIID(riid, &IID_IStream))
1169     {
1170         IStream_AddRef(iface);
1171         *ppv = iface;
1172         return S_OK;
1173     }
1174     return E_NOINTERFACE;
1175 }
1176
1177 static ULONG WINAPI sub_stream_AddRef(IStream *iface)
1178 {
1179     sub_stream_t *This = impl_from_IStream(iface);
1180     LONG ref = InterlockedIncrement(&This->ref);
1181
1182     TRACE("(%p) ref=%d\n", This, ref);
1183
1184     return ref;
1185 }
1186
1187 static ULONG WINAPI sub_stream_Release(IStream *iface)
1188 {
1189     sub_stream_t *This = impl_from_IStream(iface);
1190     LONG ref = InterlockedDecrement(&This->ref);
1191
1192     TRACE("(%p) ref=%d\n", This, ref);
1193
1194     if(!ref)
1195     {
1196         IStream_Release(This->base);
1197         HeapFree(GetProcessHeap(), 0, This);
1198     }
1199     return ref;
1200 }
1201
1202 static HRESULT WINAPI sub_stream_Read(
1203         IStream* iface,
1204         void *pv,
1205         ULONG cb,
1206         ULONG *pcbRead)
1207 {
1208     sub_stream_t *This = impl_from_IStream(iface);
1209     HRESULT hr;
1210     ULARGE_INTEGER base_pos;
1211     LARGE_INTEGER tmp_pos;
1212
1213     TRACE("(%p, %d, %p)\n", pv, cb, pcbRead);
1214
1215     tmp_pos.QuadPart = 0;
1216     IStream_Seek(This->base, tmp_pos, STREAM_SEEK_CUR, &base_pos);
1217     tmp_pos.QuadPart = This->pos.QuadPart + This->start.QuadPart;
1218     IStream_Seek(This->base, tmp_pos, STREAM_SEEK_SET, NULL);
1219
1220     if(This->pos.QuadPart + cb > This->length.QuadPart)
1221         cb = This->length.QuadPart - This->pos.QuadPart;
1222
1223     hr = IStream_Read(This->base, pv, cb, pcbRead);
1224
1225     This->pos.QuadPart += *pcbRead;
1226
1227     tmp_pos.QuadPart = base_pos.QuadPart;
1228     IStream_Seek(This->base, tmp_pos, STREAM_SEEK_SET, NULL);
1229
1230     return hr;
1231 }
1232
1233 static HRESULT WINAPI sub_stream_Write(
1234         IStream* iface,
1235         const void *pv,
1236         ULONG cb,
1237         ULONG *pcbWritten)
1238 {
1239     FIXME("stub\n");
1240     return E_NOTIMPL;
1241 }
1242
1243 static HRESULT WINAPI sub_stream_Seek(
1244         IStream* iface,
1245         LARGE_INTEGER dlibMove,
1246         DWORD dwOrigin,
1247         ULARGE_INTEGER *plibNewPosition)
1248 {
1249     sub_stream_t *This = impl_from_IStream(iface);
1250     LARGE_INTEGER new_pos;
1251
1252     TRACE("(%08x.%08x, %x, %p)\n", dlibMove.u.HighPart, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
1253
1254     switch(dwOrigin)
1255     {
1256     case STREAM_SEEK_SET:
1257         new_pos = dlibMove;
1258         break;
1259     case STREAM_SEEK_CUR:
1260         new_pos.QuadPart = This->pos.QuadPart + dlibMove.QuadPart;
1261         break;
1262     case STREAM_SEEK_END:
1263         new_pos.QuadPart = This->length.QuadPart + dlibMove.QuadPart;
1264         break;
1265     default:
1266         return STG_E_INVALIDFUNCTION;
1267     }
1268
1269     if(new_pos.QuadPart < 0) new_pos.QuadPart = 0;
1270     else if(new_pos.QuadPart > This->length.QuadPart) new_pos.QuadPart = This->length.QuadPart;
1271
1272     This->pos.QuadPart = new_pos.QuadPart;
1273
1274     if(plibNewPosition) *plibNewPosition = This->pos;
1275     return S_OK;
1276 }
1277
1278 static HRESULT WINAPI sub_stream_SetSize(
1279         IStream* iface,
1280         ULARGE_INTEGER libNewSize)
1281 {
1282     FIXME("stub\n");
1283     return E_NOTIMPL;
1284 }
1285
1286 static HRESULT WINAPI sub_stream_CopyTo(
1287         IStream* iface,
1288         IStream *pstm,
1289         ULARGE_INTEGER cb,
1290         ULARGE_INTEGER *pcbRead,
1291         ULARGE_INTEGER *pcbWritten)
1292 {
1293     HRESULT        hr = S_OK;
1294     BYTE           tmpBuffer[128];
1295     ULONG          bytesRead, bytesWritten, copySize;
1296     ULARGE_INTEGER totalBytesRead;
1297     ULARGE_INTEGER totalBytesWritten;
1298
1299     TRACE("(%p)->(%p, %d, %p, %p)\n", iface, pstm, cb.u.LowPart, pcbRead, pcbWritten);
1300
1301     totalBytesRead.QuadPart = 0;
1302     totalBytesWritten.QuadPart = 0;
1303
1304     while ( cb.QuadPart > 0 )
1305     {
1306         if ( cb.QuadPart >= sizeof(tmpBuffer) )
1307             copySize = sizeof(tmpBuffer);
1308         else
1309             copySize = cb.u.LowPart;
1310
1311         hr = IStream_Read(iface, tmpBuffer, copySize, &bytesRead);
1312         if (FAILED(hr)) break;
1313
1314         totalBytesRead.QuadPart += bytesRead;
1315
1316         if (bytesRead)
1317         {
1318             hr = IStream_Write(pstm, tmpBuffer, bytesRead, &bytesWritten);
1319             if (FAILED(hr)) break;
1320             totalBytesWritten.QuadPart += bytesWritten;
1321         }
1322
1323         if (bytesRead != copySize)
1324             cb.QuadPart = 0;
1325         else
1326             cb.QuadPart -= bytesRead;
1327     }
1328
1329     if (pcbRead) pcbRead->QuadPart = totalBytesRead.QuadPart;
1330     if (pcbWritten) pcbWritten->QuadPart = totalBytesWritten.QuadPart;
1331
1332     return hr;
1333 }
1334
1335 static HRESULT WINAPI sub_stream_Commit(
1336         IStream* iface,
1337         DWORD grfCommitFlags)
1338 {
1339     FIXME("stub\n");
1340     return E_NOTIMPL;
1341 }
1342
1343 static HRESULT WINAPI sub_stream_Revert(
1344         IStream* iface)
1345 {
1346     FIXME("stub\n");
1347     return E_NOTIMPL;
1348 }
1349
1350 static HRESULT WINAPI sub_stream_LockRegion(
1351         IStream* iface,
1352         ULARGE_INTEGER libOffset,
1353         ULARGE_INTEGER cb,
1354         DWORD dwLockType)
1355 {
1356     FIXME("stub\n");
1357     return E_NOTIMPL;
1358 }
1359
1360 static HRESULT WINAPI sub_stream_UnlockRegion(
1361         IStream* iface,
1362         ULARGE_INTEGER libOffset,
1363         ULARGE_INTEGER cb,
1364         DWORD dwLockType)
1365 {
1366     FIXME("stub\n");
1367     return E_NOTIMPL;
1368 }
1369
1370 static HRESULT WINAPI sub_stream_Stat(
1371         IStream* iface,
1372         STATSTG *pstatstg,
1373         DWORD grfStatFlag)
1374 {
1375     sub_stream_t *This = impl_from_IStream(iface);
1376     FIXME("(%p)->(%p, %08x)\n", This, pstatstg, grfStatFlag);
1377     memset(pstatstg, 0, sizeof(*pstatstg));
1378     pstatstg->cbSize = This->length;
1379     return S_OK;
1380 }
1381
1382 static HRESULT WINAPI sub_stream_Clone(
1383         IStream* iface,
1384         IStream **ppstm)
1385 {
1386     FIXME("stub\n");
1387     return E_NOTIMPL;
1388 }
1389
1390 static struct IStreamVtbl sub_stream_vtbl =
1391 {
1392     sub_stream_QueryInterface,
1393     sub_stream_AddRef,
1394     sub_stream_Release,
1395     sub_stream_Read,
1396     sub_stream_Write,
1397     sub_stream_Seek,
1398     sub_stream_SetSize,
1399     sub_stream_CopyTo,
1400     sub_stream_Commit,
1401     sub_stream_Revert,
1402     sub_stream_LockRegion,
1403     sub_stream_UnlockRegion,
1404     sub_stream_Stat,
1405     sub_stream_Clone
1406 };
1407
1408 static HRESULT create_sub_stream(IStream *stream, ULARGE_INTEGER start, ULARGE_INTEGER length, IStream **out)
1409 {
1410     sub_stream_t *This;
1411
1412     *out = NULL;
1413     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1414     if(!This) return E_OUTOFMEMORY;
1415
1416     This->IStream_iface.lpVtbl = &sub_stream_vtbl;
1417     This->ref = 1;
1418     This->start = start;
1419     This->length = length;
1420     This->pos.QuadPart = 0;
1421     IStream_AddRef(stream);
1422     This->base = stream;
1423
1424     *out = &This->IStream_iface;
1425     return S_OK;
1426 }
1427
1428
1429 typedef struct body_t
1430 {
1431     struct list entry;
1432     DWORD index;
1433     MimeBody *mime_body;
1434
1435     struct body_t *parent;
1436     struct list children;
1437 } body_t;
1438
1439 typedef struct MimeMessage
1440 {
1441     IMimeMessage IMimeMessage_iface;
1442     LONG ref;
1443     IStream *stream;
1444
1445     struct list body_tree;
1446     DWORD next_index;
1447 } MimeMessage;
1448
1449 static inline MimeMessage *impl_from_IMimeMessage(IMimeMessage *iface)
1450 {
1451     return CONTAINING_RECORD(iface, MimeMessage, IMimeMessage_iface);
1452 }
1453
1454 static HRESULT WINAPI MimeMessage_QueryInterface(IMimeMessage *iface, REFIID riid, void **ppv)
1455 {
1456     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
1457
1458     if (IsEqualIID(riid, &IID_IUnknown) ||
1459         IsEqualIID(riid, &IID_IPersist) ||
1460         IsEqualIID(riid, &IID_IPersistStreamInit) ||
1461         IsEqualIID(riid, &IID_IMimeMessageTree) ||
1462         IsEqualIID(riid, &IID_IMimeMessage))
1463     {
1464         *ppv = iface;
1465         IMimeMessage_AddRef(iface);
1466         return S_OK;
1467     }
1468
1469     FIXME("no interface for %s\n", debugstr_guid(riid));
1470     *ppv = NULL;
1471     return E_NOINTERFACE;
1472 }
1473
1474 static ULONG WINAPI MimeMessage_AddRef(IMimeMessage *iface)
1475 {
1476     MimeMessage *This = impl_from_IMimeMessage(iface);
1477     ULONG ref = InterlockedIncrement(&This->ref);
1478
1479     TRACE("(%p) ref=%d\n", This, ref);
1480
1481     return ref;
1482 }
1483
1484 static void empty_body_list(struct list *list)
1485 {
1486     body_t *body, *cursor2;
1487     LIST_FOR_EACH_ENTRY_SAFE(body, cursor2, list, body_t, entry)
1488     {
1489         empty_body_list(&body->children);
1490         list_remove(&body->entry);
1491         IMimeBody_Release(&body->mime_body->IMimeBody_iface);
1492         HeapFree(GetProcessHeap(), 0, body);
1493     }
1494 }
1495
1496 static ULONG WINAPI MimeMessage_Release(IMimeMessage *iface)
1497 {
1498     MimeMessage *This = impl_from_IMimeMessage(iface);
1499     ULONG ref = InterlockedDecrement(&This->ref);
1500
1501     TRACE("(%p) ref=%d\n", This, ref);
1502
1503     if (!ref)
1504     {
1505         empty_body_list(&This->body_tree);
1506
1507         if(This->stream) IStream_Release(This->stream);
1508         HeapFree(GetProcessHeap(), 0, This);
1509     }
1510
1511     return ref;
1512 }
1513
1514 /*** IPersist methods ***/
1515 static HRESULT WINAPI MimeMessage_GetClassID(
1516     IMimeMessage *iface,
1517     CLSID *pClassID)
1518 {
1519     FIXME("(%p)->(%p)\n", iface, pClassID);
1520     return E_NOTIMPL;
1521 }
1522
1523 /*** IPersistStreamInit methods ***/
1524 static HRESULT WINAPI MimeMessage_IsDirty(
1525     IMimeMessage *iface)
1526 {
1527     FIXME("(%p)->()\n", iface);
1528     return E_NOTIMPL;
1529 }
1530
1531 static body_t *new_body_entry(MimeBody *mime_body, DWORD index, body_t *parent)
1532 {
1533     body_t *body = HeapAlloc(GetProcessHeap(), 0, sizeof(*body));
1534     if(body)
1535     {
1536         body->mime_body = mime_body;
1537         body->index = index;
1538         list_init(&body->children);
1539         body->parent = parent;
1540     }
1541     return body;
1542 }
1543
1544 typedef struct
1545 {
1546     struct list entry;
1547     BODYOFFSETS offsets;
1548 } offset_entry_t;
1549
1550 static HRESULT create_body_offset_list(IStream *stm, const char *boundary, struct list *body_offsets)
1551 {
1552     HRESULT hr;
1553     DWORD read;
1554     int boundary_len = strlen(boundary);
1555     char *buf, *nl_boundary, *ptr, *overlap;
1556     DWORD start = 0, overlap_no;
1557     offset_entry_t *cur_body = NULL;
1558     ULARGE_INTEGER cur;
1559     LARGE_INTEGER zero;
1560
1561     list_init(body_offsets);
1562     nl_boundary = HeapAlloc(GetProcessHeap(), 0, 4 + boundary_len + 1);
1563     memcpy(nl_boundary, "\r\n--", 4);
1564     memcpy(nl_boundary + 4, boundary, boundary_len + 1);
1565
1566     overlap_no = boundary_len + 5;
1567
1568     overlap = buf = HeapAlloc(GetProcessHeap(), 0, overlap_no + PARSER_BUF_SIZE + 1);
1569
1570     zero.QuadPart = 0;
1571     hr = IStream_Seek(stm, zero, STREAM_SEEK_CUR, &cur);
1572     start = cur.u.LowPart;
1573
1574     do {
1575         hr = IStream_Read(stm, overlap, PARSER_BUF_SIZE, &read);
1576         if(FAILED(hr)) goto end;
1577         if(read == 0) break;
1578         overlap[read] = '\0';
1579
1580         ptr = buf;
1581         do {
1582             ptr = strstr(ptr, nl_boundary);
1583             if(ptr)
1584             {
1585                 DWORD boundary_start = start + ptr - buf;
1586                 char *end = ptr + boundary_len + 4;
1587
1588                 if(*end == '\0' || *(end + 1) == '\0')
1589                     break;
1590
1591                 if(*end == '\r' && *(end + 1) == '\n')
1592                 {
1593                     if(cur_body)
1594                     {
1595                         cur_body->offsets.cbBodyEnd = boundary_start;
1596                         list_add_tail(body_offsets, &cur_body->entry);
1597                     }
1598                     cur_body = HeapAlloc(GetProcessHeap(), 0, sizeof(*cur_body));
1599                     cur_body->offsets.cbBoundaryStart = boundary_start + 2; /* doesn't including the leading \r\n */
1600                     cur_body->offsets.cbHeaderStart = boundary_start + boundary_len + 6;
1601                 }
1602                 else if(*end == '-' && *(end + 1) == '-')
1603                 {
1604                     if(cur_body)
1605                     {
1606                         cur_body->offsets.cbBodyEnd = boundary_start;
1607                         list_add_tail(body_offsets, &cur_body->entry);
1608                         goto end;
1609                     }
1610                 }
1611                 ptr = end + 2;
1612             }
1613         } while(ptr);
1614
1615         if(overlap == buf) /* 1st iteration */
1616         {
1617             memcpy(buf, buf + PARSER_BUF_SIZE - overlap_no, overlap_no);
1618             overlap = buf + overlap_no;
1619             start += read - overlap_no;
1620         }
1621         else
1622         {
1623             memcpy(buf, buf + PARSER_BUF_SIZE, overlap_no);
1624             start += read;
1625         }
1626     } while(1);
1627
1628 end:
1629     HeapFree(GetProcessHeap(), 0, nl_boundary);
1630     HeapFree(GetProcessHeap(), 0, buf);
1631     return hr;
1632 }
1633
1634 static body_t *create_sub_body(MimeMessage *msg, IStream *pStm, BODYOFFSETS *offset, body_t *parent)
1635 {
1636     MimeBody *mime_body;
1637     HRESULT hr;
1638     body_t *body;
1639     ULARGE_INTEGER cur;
1640     LARGE_INTEGER zero;
1641
1642     mime_body = mimebody_create();
1643     IMimeBody_Load(&mime_body->IMimeBody_iface, pStm);
1644     zero.QuadPart = 0;
1645     hr = IStream_Seek(pStm, zero, STREAM_SEEK_CUR, &cur);
1646     offset->cbBodyStart = cur.u.LowPart + offset->cbHeaderStart;
1647     if (parent) MimeBody_set_offsets(mime_body, offset);
1648     IMimeBody_SetData(&mime_body->IMimeBody_iface, IET_BINARY, NULL, NULL, &IID_IStream, pStm);
1649     body = new_body_entry(mime_body, msg->next_index++, parent);
1650
1651     if(IMimeBody_IsContentType(&mime_body->IMimeBody_iface, "multipart", NULL) == S_OK)
1652     {
1653         MIMEPARAMINFO *param_info;
1654         ULONG count, i;
1655         IMimeAllocator *alloc;
1656
1657         hr = IMimeBody_GetParameters(&mime_body->IMimeBody_iface, "Content-Type", &count,
1658                 &param_info);
1659         if(hr != S_OK || count == 0) return body;
1660
1661         MimeOleGetAllocator(&alloc);
1662
1663         for(i = 0; i < count; i++)
1664         {
1665             if(!strcasecmp(param_info[i].pszName, "boundary"))
1666             {
1667                 struct list offset_list;
1668                 offset_entry_t *cur, *cursor2;
1669                 hr = create_body_offset_list(pStm, param_info[i].pszData, &offset_list);
1670                 LIST_FOR_EACH_ENTRY_SAFE(cur, cursor2, &offset_list, offset_entry_t, entry)
1671                 {
1672                     body_t *sub_body;
1673                     IStream *sub_stream;
1674                     ULARGE_INTEGER start, length;
1675
1676                     start.QuadPart = cur->offsets.cbHeaderStart;
1677                     length.QuadPart = cur->offsets.cbBodyEnd - cur->offsets.cbHeaderStart;
1678                     create_sub_stream(pStm, start, length, &sub_stream);
1679                     sub_body = create_sub_body(msg, sub_stream, &cur->offsets, body);
1680                     IStream_Release(sub_stream);
1681                     list_add_tail(&body->children, &sub_body->entry);
1682                     list_remove(&cur->entry);
1683                     HeapFree(GetProcessHeap(), 0, cur);
1684                 }
1685                 break;
1686             }
1687         }
1688         IMimeAllocator_FreeParamInfoArray(alloc, count, param_info, TRUE);
1689         IMimeAllocator_Release(alloc);
1690     }
1691     return body;
1692 }
1693
1694 static HRESULT WINAPI MimeMessage_Load(IMimeMessage *iface, IStream *pStm)
1695 {
1696     MimeMessage *This = impl_from_IMimeMessage(iface);
1697     body_t *root_body;
1698     BODYOFFSETS offsets;
1699     ULARGE_INTEGER cur;
1700     LARGE_INTEGER zero;
1701
1702     TRACE("(%p)->(%p)\n", iface, pStm);
1703
1704     if(This->stream)
1705     {
1706         FIXME("already loaded a message\n");
1707         return E_FAIL;
1708     }
1709
1710     IStream_AddRef(pStm);
1711     This->stream = pStm;
1712     offsets.cbBoundaryStart = offsets.cbHeaderStart = 0;
1713     offsets.cbBodyStart = offsets.cbBodyEnd = 0;
1714
1715     root_body = create_sub_body(This, pStm, &offsets, NULL);
1716
1717     zero.QuadPart = 0;
1718     IStream_Seek(pStm, zero, STREAM_SEEK_END, &cur);
1719     offsets.cbBodyEnd = cur.u.LowPart;
1720     MimeBody_set_offsets(root_body->mime_body, &offsets);
1721
1722     list_add_head(&This->body_tree, &root_body->entry);
1723
1724     return S_OK;
1725 }
1726
1727 static HRESULT WINAPI MimeMessage_Save(IMimeMessage *iface, IStream *pStm, BOOL fClearDirty)
1728 {
1729     FIXME("(%p)->(%p, %s)\n", iface, pStm, fClearDirty ? "TRUE" : "FALSE");
1730     return E_NOTIMPL;
1731 }
1732
1733 static HRESULT WINAPI MimeMessage_GetSizeMax(
1734     IMimeMessage *iface,
1735     ULARGE_INTEGER *pcbSize)
1736 {
1737     FIXME("(%p)->(%p)\n", iface, pcbSize);
1738     return E_NOTIMPL;
1739 }
1740
1741 static HRESULT WINAPI MimeMessage_InitNew(
1742     IMimeMessage *iface)
1743 {
1744     FIXME("(%p)->()\n", iface);
1745     return E_NOTIMPL;
1746 }
1747
1748 /*** IMimeMessageTree methods ***/
1749 static HRESULT WINAPI MimeMessage_GetMessageSource(IMimeMessage *iface, IStream **ppStream,
1750         DWORD dwFlags)
1751 {
1752     MimeMessage *This = impl_from_IMimeMessage(iface);
1753
1754     FIXME("(%p)->(%p, 0x%x)\n", iface, ppStream, dwFlags);
1755
1756     IStream_AddRef(This->stream);
1757     *ppStream = This->stream;
1758     return S_OK;
1759 }
1760
1761 static HRESULT WINAPI MimeMessage_GetMessageSize(
1762     IMimeMessage *iface,
1763     ULONG *pcbSize,
1764     DWORD dwFlags)
1765 {
1766     FIXME("(%p)->(%p, 0x%x)\n", iface, pcbSize, dwFlags);
1767     return E_NOTIMPL;
1768 }
1769
1770 static HRESULT WINAPI MimeMessage_LoadOffsetTable(
1771     IMimeMessage *iface,
1772     IStream *pStream)
1773 {
1774     FIXME("(%p)->(%p)\n", iface, pStream);
1775     return E_NOTIMPL;
1776 }
1777
1778 static HRESULT WINAPI MimeMessage_SaveOffsetTable(
1779     IMimeMessage *iface,
1780     IStream *pStream,
1781     DWORD dwFlags)
1782 {
1783     FIXME("(%p)->(%p, 0x%x)\n", iface, pStream, dwFlags);
1784     return E_NOTIMPL;
1785 }
1786
1787
1788 static HRESULT WINAPI MimeMessage_GetFlags(
1789     IMimeMessage *iface,
1790     DWORD *pdwFlags)
1791 {
1792     FIXME("(%p)->(%p)\n", iface, pdwFlags);
1793     return E_NOTIMPL;
1794 }
1795
1796 static HRESULT WINAPI MimeMessage_Commit(
1797     IMimeMessage *iface,
1798     DWORD dwFlags)
1799 {
1800     FIXME("(%p)->(0x%x)\n", iface, dwFlags);
1801     return E_NOTIMPL;
1802 }
1803
1804
1805 static HRESULT WINAPI MimeMessage_HandsOffStorage(
1806     IMimeMessage *iface)
1807 {
1808     FIXME("(%p)->()\n", iface);
1809     return E_NOTIMPL;
1810 }
1811
1812 static HRESULT find_body(struct list *list, HBODY hbody, body_t **body)
1813 {
1814     body_t *cur;
1815     HRESULT hr;
1816
1817     if(hbody == HBODY_ROOT)
1818     {
1819         *body = LIST_ENTRY(list_head(list), body_t, entry);
1820         return S_OK;
1821     }
1822
1823     LIST_FOR_EACH_ENTRY(cur, list, body_t, entry)
1824     {
1825         if(cur->index == HandleToUlong(hbody))
1826         {
1827             *body = cur;
1828             return S_OK;
1829         }
1830         hr = find_body(&cur->children, hbody, body);
1831         if(hr == S_OK) return S_OK;
1832     }
1833     return S_FALSE;
1834 }
1835
1836 static HRESULT WINAPI MimeMessage_BindToObject(IMimeMessage *iface, const HBODY hBody, REFIID riid,
1837         void **ppvObject)
1838 {
1839     MimeMessage *This = impl_from_IMimeMessage(iface);
1840     HRESULT hr;
1841     body_t *body;
1842
1843     TRACE("(%p)->(%p, %s, %p)\n", iface, hBody, debugstr_guid(riid), ppvObject);
1844
1845     hr = find_body(&This->body_tree, hBody, &body);
1846
1847     if(hr != S_OK) return hr;
1848
1849     if(IsEqualIID(riid, &IID_IMimeBody))
1850     {
1851         IMimeBody_AddRef(&body->mime_body->IMimeBody_iface);
1852         *ppvObject = &body->mime_body->IMimeBody_iface;
1853         return S_OK;
1854     }
1855
1856     return E_NOINTERFACE;
1857 }
1858
1859 static HRESULT WINAPI MimeMessage_SaveBody(
1860     IMimeMessage *iface,
1861     HBODY hBody,
1862     DWORD dwFlags,
1863     IStream *pStream)
1864 {
1865     FIXME("(%p)->(%p, 0x%x, %p)\n", iface, hBody, dwFlags, pStream);
1866     return E_NOTIMPL;
1867 }
1868
1869 static HRESULT get_body(MimeMessage *msg, BODYLOCATION location, HBODY pivot, body_t **out)
1870 {
1871     body_t *root = LIST_ENTRY(list_head(&msg->body_tree), body_t, entry);
1872     body_t *body;
1873     HRESULT hr;
1874     struct list *list;
1875
1876     if(location == IBL_ROOT)
1877     {
1878         *out = root;
1879         return S_OK;
1880     }
1881
1882     hr = find_body(&msg->body_tree, pivot, &body);
1883
1884     if(hr == S_OK)
1885     {
1886         switch(location)
1887         {
1888         case IBL_PARENT:
1889             *out = body->parent;
1890             break;
1891
1892         case IBL_FIRST:
1893             list = list_head(&body->children);
1894             if(list)
1895                 *out = LIST_ENTRY(list, body_t, entry);
1896             else
1897                 hr = MIME_E_NOT_FOUND;
1898             break;
1899
1900         case IBL_LAST:
1901             list = list_tail(&body->children);
1902             if(list)
1903                 *out = LIST_ENTRY(list, body_t, entry);
1904             else
1905                 hr = MIME_E_NOT_FOUND;
1906             break;
1907
1908         case IBL_NEXT:
1909             list = list_next(&body->parent->children, &body->entry);
1910             if(list)
1911                 *out = LIST_ENTRY(list, body_t, entry);
1912             else
1913                 hr = MIME_E_NOT_FOUND;
1914             break;
1915
1916         case IBL_PREVIOUS:
1917             list = list_prev(&body->parent->children, &body->entry);
1918             if(list)
1919                 *out = LIST_ENTRY(list, body_t, entry);
1920             else
1921                 hr = MIME_E_NOT_FOUND;
1922             break;
1923
1924         default:
1925             hr = E_FAIL;
1926             break;
1927         }
1928     }
1929
1930     return hr;
1931 }
1932
1933
1934 static HRESULT WINAPI MimeMessage_InsertBody(
1935     IMimeMessage *iface,
1936     BODYLOCATION location,
1937     HBODY hPivot,
1938     LPHBODY phBody)
1939 {
1940     FIXME("(%p)->(%d, %p, %p)\n", iface, location, hPivot, phBody);
1941     return E_NOTIMPL;
1942 }
1943
1944 static HRESULT WINAPI MimeMessage_GetBody(IMimeMessage *iface, BODYLOCATION location, HBODY hPivot,
1945         HBODY *phBody)
1946 {
1947     MimeMessage *This = impl_from_IMimeMessage(iface);
1948     body_t *body;
1949     HRESULT hr;
1950
1951     TRACE("(%p)->(%d, %p, %p)\n", iface, location, hPivot, phBody);
1952
1953     hr = get_body(This, location, hPivot, &body);
1954
1955     if(hr == S_OK) *phBody = UlongToHandle(body->index);
1956
1957     return hr;
1958 }
1959
1960 static HRESULT WINAPI MimeMessage_DeleteBody(
1961     IMimeMessage *iface,
1962     HBODY hBody,
1963     DWORD dwFlags)
1964 {
1965     FIXME("(%p)->(%p, %08x)\n", iface, hBody, dwFlags);
1966     return E_NOTIMPL;
1967 }
1968
1969 static HRESULT WINAPI MimeMessage_MoveBody(
1970     IMimeMessage *iface,
1971     HBODY hBody,
1972     BODYLOCATION location)
1973 {
1974     FIXME("(%p)->(%d)\n", iface, location);
1975     return E_NOTIMPL;
1976 }
1977
1978 static void count_children(body_t *body, boolean recurse, ULONG *count)
1979 {
1980     body_t *child;
1981
1982     LIST_FOR_EACH_ENTRY(child, &body->children, body_t, entry)
1983     {
1984         (*count)++;
1985         if(recurse) count_children(child, recurse, count);
1986     }
1987 }
1988
1989 static HRESULT WINAPI MimeMessage_CountBodies(IMimeMessage *iface, HBODY hParent, boolean fRecurse,
1990         ULONG *pcBodies)
1991 {
1992     HRESULT hr;
1993     MimeMessage *This = impl_from_IMimeMessage(iface);
1994     body_t *body;
1995
1996     TRACE("(%p)->(%p, %s, %p)\n", iface, hParent, fRecurse ? "TRUE" : "FALSE", pcBodies);
1997
1998     hr = find_body(&This->body_tree, hParent, &body);
1999     if(hr != S_OK) return hr;
2000
2001     *pcBodies = 1;
2002     count_children(body, fRecurse, pcBodies);
2003
2004     return S_OK;
2005 }
2006
2007 static HRESULT find_next(MimeMessage *This, body_t *body, FINDBODY *find, HBODY *out)
2008 {
2009     struct list *ptr;
2010     HBODY next;
2011
2012     for (;;)
2013     {
2014         if (!body) ptr = list_head( &This->body_tree );
2015         else
2016         {
2017             ptr = list_head( &body->children );
2018             while (!ptr)
2019             {
2020                 if (!body->parent) return MIME_E_NOT_FOUND;
2021                 if (!(ptr = list_next( &body->parent->children, &body->entry ))) body = body->parent;
2022             }
2023         }
2024
2025         body = LIST_ENTRY( ptr, body_t, entry );
2026         next = UlongToHandle( body->index );
2027         find->dwReserved = body->index;
2028         if (IMimeBody_IsContentType(&body->mime_body->IMimeBody_iface, find->pszPriType,
2029                     find->pszSubType) == S_OK)
2030         {
2031             *out = next;
2032             return S_OK;
2033         }
2034     }
2035     return MIME_E_NOT_FOUND;
2036 }
2037
2038 static HRESULT WINAPI MimeMessage_FindFirst(IMimeMessage *iface, FINDBODY *pFindBody, HBODY *phBody)
2039 {
2040     MimeMessage *This = impl_from_IMimeMessage(iface);
2041
2042     TRACE("(%p)->(%p, %p)\n", iface, pFindBody, phBody);
2043
2044     pFindBody->dwReserved = 0;
2045     return find_next(This, NULL, pFindBody, phBody);
2046 }
2047
2048 static HRESULT WINAPI MimeMessage_FindNext(IMimeMessage *iface, FINDBODY *pFindBody, HBODY *phBody)
2049 {
2050     MimeMessage *This = impl_from_IMimeMessage(iface);
2051     body_t *body;
2052     HRESULT hr;
2053
2054     TRACE("(%p)->(%p, %p)\n", iface, pFindBody, phBody);
2055
2056     hr = find_body( &This->body_tree, UlongToHandle( pFindBody->dwReserved ), &body );
2057     if (hr != S_OK) return MIME_E_NOT_FOUND;
2058     return find_next(This, body, pFindBody, phBody);
2059 }
2060
2061 static HRESULT WINAPI MimeMessage_ResolveURL(
2062     IMimeMessage *iface,
2063     HBODY hRelated,
2064     LPCSTR pszBase,
2065     LPCSTR pszURL,
2066     DWORD dwFlags,
2067     LPHBODY phBody)
2068 {
2069     FIXME("(%p)->(%p, %s, %s, 0x%x, %p)\n", iface, hRelated, pszBase, pszURL, dwFlags, phBody);
2070     return E_NOTIMPL;
2071 }
2072
2073 static HRESULT WINAPI MimeMessage_ToMultipart(
2074     IMimeMessage *iface,
2075     HBODY hBody,
2076     LPCSTR pszSubType,
2077     LPHBODY phMultipart)
2078 {
2079     FIXME("(%p)->(%p, %s, %p)\n", iface, hBody, pszSubType, phMultipart);
2080     return E_NOTIMPL;
2081 }
2082
2083 static HRESULT WINAPI MimeMessage_GetBodyOffsets(
2084     IMimeMessage *iface,
2085     HBODY hBody,
2086     LPBODYOFFSETS pOffsets)
2087 {
2088     FIXME("(%p)->(%p, %p)\n", iface, hBody, pOffsets);
2089     return E_NOTIMPL;
2090 }
2091
2092 static HRESULT WINAPI MimeMessage_GetCharset(
2093     IMimeMessage *iface,
2094     LPHCHARSET phCharset)
2095 {
2096     FIXME("(%p)->(%p)\n", iface, phCharset);
2097     *phCharset = NULL;
2098     return S_OK;
2099 }
2100
2101 static HRESULT WINAPI MimeMessage_SetCharset(
2102     IMimeMessage *iface,
2103     HCHARSET hCharset,
2104     CSETAPPLYTYPE applytype)
2105 {
2106     FIXME("(%p)->(%p, %d)\n", iface, hCharset, applytype);
2107     return E_NOTIMPL;
2108 }
2109
2110 static HRESULT WINAPI MimeMessage_IsBodyType(
2111     IMimeMessage *iface,
2112     HBODY hBody,
2113     IMSGBODYTYPE bodytype)
2114 {
2115     HRESULT hr;
2116     IMimeBody *mime_body;
2117     TRACE("(%p)->(%p, %d)\n", iface, hBody, bodytype);
2118
2119     hr = IMimeMessage_BindToObject(iface, hBody, &IID_IMimeBody, (void**)&mime_body);
2120     if(hr != S_OK) return hr;
2121
2122     hr = IMimeBody_IsType(mime_body, bodytype);
2123     MimeBody_Release(mime_body);
2124     return hr;
2125 }
2126
2127 static HRESULT WINAPI MimeMessage_IsContentType(
2128     IMimeMessage *iface,
2129     HBODY hBody,
2130     LPCSTR pszPriType,
2131     LPCSTR pszSubType)
2132 {
2133     HRESULT hr;
2134     IMimeBody *mime_body;
2135     TRACE("(%p)->(%p, %s, %s)\n", iface, hBody, debugstr_a(pszPriType),
2136           debugstr_a(pszSubType));
2137
2138     hr = IMimeMessage_BindToObject(iface, hBody, &IID_IMimeBody, (void**)&mime_body);
2139     if(FAILED(hr)) return hr;
2140
2141     hr = IMimeBody_IsContentType(mime_body, pszPriType, pszSubType);
2142     IMimeBody_Release(mime_body);
2143     return hr;
2144 }
2145
2146 static HRESULT WINAPI MimeMessage_QueryBodyProp(
2147     IMimeMessage *iface,
2148     HBODY hBody,
2149     LPCSTR pszName,
2150     LPCSTR pszCriteria,
2151     boolean fSubString,
2152     boolean fCaseSensitive)
2153 {
2154     FIXME("(%p)->(%p, %s, %s, %s, %s)\n", iface, hBody, pszName, pszCriteria, fSubString ? "TRUE" : "FALSE", fCaseSensitive ? "TRUE" : "FALSE");
2155     return E_NOTIMPL;
2156 }
2157
2158 static HRESULT WINAPI MimeMessage_GetBodyProp(
2159     IMimeMessage *iface,
2160     HBODY hBody,
2161     LPCSTR pszName,
2162     DWORD dwFlags,
2163     LPPROPVARIANT pValue)
2164 {
2165     HRESULT hr;
2166     IMimeBody *mime_body;
2167
2168     TRACE("(%p)->(%p, %s, 0x%x, %p)\n", iface, hBody, pszName, dwFlags, pValue);
2169
2170     hr = IMimeMessage_BindToObject(iface, hBody, &IID_IMimeBody, (void**)&mime_body);
2171     if(hr != S_OK) return hr;
2172
2173     hr = IMimeBody_GetProp(mime_body, pszName, dwFlags, pValue);
2174     IMimeBody_Release(mime_body);
2175
2176     return hr;
2177 }
2178
2179 static HRESULT WINAPI MimeMessage_SetBodyProp(
2180     IMimeMessage *iface,
2181     HBODY hBody,
2182     LPCSTR pszName,
2183     DWORD dwFlags,
2184     LPCPROPVARIANT pValue)
2185 {
2186     FIXME("(%p)->(%p, %s, 0x%x, %p)\n", iface, hBody, pszName, dwFlags, pValue);
2187     return E_NOTIMPL;
2188 }
2189
2190 static HRESULT WINAPI MimeMessage_DeleteBodyProp(
2191     IMimeMessage *iface,
2192     HBODY hBody,
2193     LPCSTR pszName)
2194 {
2195     FIXME("(%p)->(%p, %s)\n", iface, hBody, pszName);
2196     return E_NOTIMPL;
2197 }
2198
2199 static HRESULT WINAPI MimeMessage_SetOption(
2200     IMimeMessage *iface,
2201     const TYPEDID oid,
2202     LPCPROPVARIANT pValue)
2203 {
2204     HRESULT hr = E_NOTIMPL;
2205     TRACE("(%p)->(%08x, %p)\n", iface, oid, pValue);
2206
2207     if(pValue->vt != TYPEDID_TYPE(oid))
2208     {
2209         WARN("Called with vartype %04x and oid %08x\n", pValue->vt, oid);
2210         return E_INVALIDARG;
2211     }
2212
2213     switch(oid)
2214     {
2215     case OID_HIDE_TNEF_ATTACHMENTS:
2216         FIXME("OID_HIDE_TNEF_ATTACHMENTS (value %d): ignoring\n", pValue->u.boolVal);
2217         hr = S_OK;
2218         break;
2219     case OID_SHOW_MACBINARY:
2220         FIXME("OID_SHOW_MACBINARY (value %d): ignoring\n", pValue->u.boolVal);
2221         hr = S_OK;
2222         break;
2223     default:
2224         FIXME("Unhandled oid %08x\n", oid);
2225     }
2226
2227     return hr;
2228 }
2229
2230 static HRESULT WINAPI MimeMessage_GetOption(
2231     IMimeMessage *iface,
2232     const TYPEDID oid,
2233     LPPROPVARIANT pValue)
2234 {
2235     FIXME("(%p)->(%08x, %p)\n", iface, oid, pValue);
2236     return E_NOTIMPL;
2237 }
2238
2239 /*** IMimeMessage methods ***/
2240 static HRESULT WINAPI MimeMessage_CreateWebPage(
2241     IMimeMessage *iface,
2242     IStream *pRootStm,
2243     LPWEBPAGEOPTIONS pOptions,
2244     IMimeMessageCallback *pCallback,
2245     IMoniker **ppMoniker)
2246 {
2247     FIXME("(%p)->(%p, %p, %p, %p)\n", iface, pRootStm, pOptions, pCallback, ppMoniker);
2248     *ppMoniker = NULL;
2249     return E_NOTIMPL;
2250 }
2251
2252 static HRESULT WINAPI MimeMessage_GetProp(
2253     IMimeMessage *iface,
2254     LPCSTR pszName,
2255     DWORD dwFlags,
2256     LPPROPVARIANT pValue)
2257 {
2258     FIXME("(%p)->(%s, 0x%x, %p)\n", iface, pszName, dwFlags, pValue);
2259     return E_NOTIMPL;
2260 }
2261
2262 static HRESULT WINAPI MimeMessage_SetProp(
2263     IMimeMessage *iface,
2264     LPCSTR pszName,
2265     DWORD dwFlags,
2266     LPCPROPVARIANT pValue)
2267 {
2268     FIXME("(%p)->(%s, 0x%x, %p)\n", iface, pszName, dwFlags, pValue);
2269     return E_NOTIMPL;
2270 }
2271
2272 static HRESULT WINAPI MimeMessage_DeleteProp(
2273     IMimeMessage *iface,
2274     LPCSTR pszName)
2275 {
2276     FIXME("(%p)->(%s)\n", iface, pszName);
2277     return E_NOTIMPL;
2278 }
2279
2280 static HRESULT WINAPI MimeMessage_QueryProp(
2281     IMimeMessage *iface,
2282     LPCSTR pszName,
2283     LPCSTR pszCriteria,
2284     boolean fSubString,
2285     boolean fCaseSensitive)
2286 {
2287     FIXME("(%p)->(%s, %s, %s, %s)\n", iface, pszName, pszCriteria, fSubString ? "TRUE" : "FALSE", fCaseSensitive ? "TRUE" : "FALSE");
2288     return E_NOTIMPL;
2289 }
2290
2291 static HRESULT WINAPI MimeMessage_GetTextBody(
2292     IMimeMessage *iface,
2293     DWORD dwTxtType,
2294     ENCODINGTYPE ietEncoding,
2295     IStream **pStream,
2296     LPHBODY phBody)
2297 {
2298     HRESULT hr;
2299     HBODY hbody;
2300     FINDBODY find_struct;
2301     IMimeBody *mime_body;
2302     static char text[] = "text";
2303     static char plain[] = "plain";
2304     static char html[] = "html";
2305
2306     TRACE("(%p)->(%d, %d, %p, %p)\n", iface, dwTxtType, ietEncoding, pStream, phBody);
2307
2308     find_struct.pszPriType = text;
2309
2310     switch(dwTxtType)
2311     {
2312     case TXT_PLAIN:
2313         find_struct.pszSubType = plain;
2314         break;
2315     case TXT_HTML:
2316         find_struct.pszSubType = html;
2317         break;
2318     default:
2319         return MIME_E_INVALID_TEXT_TYPE;
2320     }
2321
2322     hr = IMimeMessage_FindFirst(iface, &find_struct, &hbody);
2323     if(hr != S_OK)
2324     {
2325         TRACE("not found hr %08x\n", hr);
2326         *phBody = NULL;
2327         return hr;
2328     }
2329
2330     IMimeMessage_BindToObject(iface, hbody, &IID_IMimeBody, (void**)&mime_body);
2331
2332     IMimeBody_GetData(mime_body, ietEncoding, pStream);
2333     *phBody = hbody;
2334     IMimeBody_Release(mime_body);
2335     return hr;
2336 }
2337
2338 static HRESULT WINAPI MimeMessage_SetTextBody(
2339     IMimeMessage *iface,
2340     DWORD dwTxtType,
2341     ENCODINGTYPE ietEncoding,
2342     HBODY hAlternative,
2343     IStream *pStream,
2344     LPHBODY phBody)
2345 {
2346     FIXME("(%p)->(%d, %d, %p, %p, %p)\n", iface, dwTxtType, ietEncoding, hAlternative, pStream, phBody);
2347     return E_NOTIMPL;
2348 }
2349
2350 static HRESULT WINAPI MimeMessage_AttachObject(
2351     IMimeMessage *iface,
2352     REFIID riid,
2353     void *pvObject,
2354     LPHBODY phBody)
2355 {
2356     FIXME("(%p)->(%s, %p, %p)\n", iface, debugstr_guid(riid), pvObject, phBody);
2357     return E_NOTIMPL;
2358 }
2359
2360 static HRESULT WINAPI MimeMessage_AttachFile(
2361     IMimeMessage *iface,
2362     LPCSTR pszFilePath,
2363     IStream *pstmFile,
2364     LPHBODY phBody)
2365 {
2366     FIXME("(%p)->(%s, %p, %p)\n", iface, pszFilePath, pstmFile, phBody);
2367     return E_NOTIMPL;
2368 }
2369
2370 static HRESULT WINAPI MimeMessage_AttachURL(
2371     IMimeMessage *iface,
2372     LPCSTR pszBase,
2373     LPCSTR pszURL,
2374     DWORD dwFlags,
2375     IStream *pstmURL,
2376     LPSTR *ppszCIDURL,
2377     LPHBODY phBody)
2378 {
2379     FIXME("(%p)->(%s, %s, 0x%x, %p, %p, %p)\n", iface, pszBase, pszURL, dwFlags, pstmURL, ppszCIDURL, phBody);
2380     return E_NOTIMPL;
2381 }
2382
2383 static HRESULT WINAPI MimeMessage_GetAttachments(
2384     IMimeMessage *iface,
2385     ULONG *pcAttach,
2386     LPHBODY *pprghAttach)
2387 {
2388     HRESULT hr;
2389     FINDBODY find_struct;
2390     HBODY hbody;
2391     LPHBODY array;
2392     ULONG size = 10;
2393
2394     TRACE("(%p)->(%p, %p)\n", iface, pcAttach, pprghAttach);
2395
2396     *pcAttach = 0;
2397     array = CoTaskMemAlloc(size * sizeof(HBODY));
2398
2399     find_struct.pszPriType = find_struct.pszSubType = NULL;
2400     hr = IMimeMessage_FindFirst(iface, &find_struct, &hbody);
2401     while(hr == S_OK)
2402     {
2403         hr = IMimeMessage_IsContentType(iface, hbody, "multipart", NULL);
2404         TRACE("IsCT rets %08x %d\n", hr, *pcAttach);
2405         if(hr != S_OK)
2406         {
2407             if(*pcAttach + 1 > size)
2408             {
2409                 size *= 2;
2410                 array = CoTaskMemRealloc(array, size * sizeof(HBODY));
2411             }
2412             array[*pcAttach] = hbody;
2413             (*pcAttach)++;
2414         }
2415         hr = IMimeMessage_FindNext(iface, &find_struct, &hbody);
2416     }
2417
2418     *pprghAttach = array;
2419     return S_OK;
2420 }
2421
2422 static HRESULT WINAPI MimeMessage_GetAddressTable(
2423     IMimeMessage *iface,
2424     IMimeAddressTable **ppTable)
2425 {
2426     FIXME("(%p)->(%p)\n", iface, ppTable);
2427     return E_NOTIMPL;
2428 }
2429
2430 static HRESULT WINAPI MimeMessage_GetSender(
2431     IMimeMessage *iface,
2432     LPADDRESSPROPS pAddress)
2433 {
2434     FIXME("(%p)->(%p)\n", iface, pAddress);
2435     return E_NOTIMPL;
2436 }
2437
2438 static HRESULT WINAPI MimeMessage_GetAddressTypes(
2439     IMimeMessage *iface,
2440     DWORD dwAdrTypes,
2441     DWORD dwProps,
2442     LPADDRESSLIST pList)
2443 {
2444     FIXME("(%p)->(%d, %d, %p)\n", iface, dwAdrTypes, dwProps, pList);
2445     return E_NOTIMPL;
2446 }
2447
2448 static HRESULT WINAPI MimeMessage_GetAddressFormat(
2449     IMimeMessage *iface,
2450     DWORD dwAdrTypes,
2451     ADDRESSFORMAT format,
2452     LPSTR *ppszFormat)
2453 {
2454     FIXME("(%p)->(%d, %d, %p)\n", iface, dwAdrTypes, format, ppszFormat);
2455     return E_NOTIMPL;
2456 }
2457
2458 static HRESULT WINAPI MimeMessage_EnumAddressTypes(
2459     IMimeMessage *iface,
2460     DWORD dwAdrTypes,
2461     DWORD dwProps,
2462     IMimeEnumAddressTypes **ppEnum)
2463 {
2464     FIXME("(%p)->(%d, %d, %p)\n", iface, dwAdrTypes, dwProps, ppEnum);
2465     return E_NOTIMPL;
2466 }
2467
2468 static HRESULT WINAPI MimeMessage_SplitMessage(
2469     IMimeMessage *iface,
2470     ULONG cbMaxPart,
2471     IMimeMessageParts **ppParts)
2472 {
2473     FIXME("(%p)->(%d, %p)\n", iface, cbMaxPart, ppParts);
2474     return E_NOTIMPL;
2475 }
2476
2477 static HRESULT WINAPI MimeMessage_GetRootMoniker(
2478     IMimeMessage *iface,
2479     IMoniker **ppMoniker)
2480 {
2481     FIXME("(%p)->(%p)\n", iface, ppMoniker);
2482     return E_NOTIMPL;
2483 }
2484
2485 static const IMimeMessageVtbl MimeMessageVtbl =
2486 {
2487     MimeMessage_QueryInterface,
2488     MimeMessage_AddRef,
2489     MimeMessage_Release,
2490     MimeMessage_GetClassID,
2491     MimeMessage_IsDirty,
2492     MimeMessage_Load,
2493     MimeMessage_Save,
2494     MimeMessage_GetSizeMax,
2495     MimeMessage_InitNew,
2496     MimeMessage_GetMessageSource,
2497     MimeMessage_GetMessageSize,
2498     MimeMessage_LoadOffsetTable,
2499     MimeMessage_SaveOffsetTable,
2500     MimeMessage_GetFlags,
2501     MimeMessage_Commit,
2502     MimeMessage_HandsOffStorage,
2503     MimeMessage_BindToObject,
2504     MimeMessage_SaveBody,
2505     MimeMessage_InsertBody,
2506     MimeMessage_GetBody,
2507     MimeMessage_DeleteBody,
2508     MimeMessage_MoveBody,
2509     MimeMessage_CountBodies,
2510     MimeMessage_FindFirst,
2511     MimeMessage_FindNext,
2512     MimeMessage_ResolveURL,
2513     MimeMessage_ToMultipart,
2514     MimeMessage_GetBodyOffsets,
2515     MimeMessage_GetCharset,
2516     MimeMessage_SetCharset,
2517     MimeMessage_IsBodyType,
2518     MimeMessage_IsContentType,
2519     MimeMessage_QueryBodyProp,
2520     MimeMessage_GetBodyProp,
2521     MimeMessage_SetBodyProp,
2522     MimeMessage_DeleteBodyProp,
2523     MimeMessage_SetOption,
2524     MimeMessage_GetOption,
2525     MimeMessage_CreateWebPage,
2526     MimeMessage_GetProp,
2527     MimeMessage_SetProp,
2528     MimeMessage_DeleteProp,
2529     MimeMessage_QueryProp,
2530     MimeMessage_GetTextBody,
2531     MimeMessage_SetTextBody,
2532     MimeMessage_AttachObject,
2533     MimeMessage_AttachFile,
2534     MimeMessage_AttachURL,
2535     MimeMessage_GetAttachments,
2536     MimeMessage_GetAddressTable,
2537     MimeMessage_GetSender,
2538     MimeMessage_GetAddressTypes,
2539     MimeMessage_GetAddressFormat,
2540     MimeMessage_EnumAddressTypes,
2541     MimeMessage_SplitMessage,
2542     MimeMessage_GetRootMoniker,
2543 };
2544
2545 HRESULT MimeMessage_create(IUnknown *outer, void **obj)
2546 {
2547     MimeMessage *This;
2548
2549     TRACE("(%p, %p)\n", outer, obj);
2550
2551     if (outer)
2552     {
2553         FIXME("outer unknown not supported yet\n");
2554         return E_NOTIMPL;
2555     }
2556
2557     *obj = NULL;
2558
2559     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
2560     if (!This) return E_OUTOFMEMORY;
2561
2562     This->IMimeMessage_iface.lpVtbl = &MimeMessageVtbl;
2563     This->ref = 1;
2564     This->stream = NULL;
2565     list_init(&This->body_tree);
2566     This->next_index = 1;
2567
2568     *obj = &This->IMimeMessage_iface;
2569     return S_OK;
2570 }
2571
2572 /***********************************************************************
2573  *              MimeOleCreateMessage (INETCOMM.@)
2574  */
2575 HRESULT WINAPI MimeOleCreateMessage(IUnknown *pUnkOuter, IMimeMessage **ppMessage)
2576 {
2577     TRACE("(%p, %p)\n", pUnkOuter, ppMessage);
2578     return MimeMessage_create(NULL, (void **)ppMessage);
2579 }
2580
2581 /***********************************************************************
2582  *              MimeOleSetCompatMode (INETCOMM.@)
2583  */
2584 HRESULT WINAPI MimeOleSetCompatMode(DWORD dwMode)
2585 {
2586     FIXME("(0x%x)\n", dwMode);
2587     return S_OK;
2588 }
2589
2590 /***********************************************************************
2591  *              MimeOleCreateVirtualStream (INETCOMM.@)
2592  */
2593 HRESULT WINAPI MimeOleCreateVirtualStream(IStream **ppStream)
2594 {
2595     HRESULT hr;
2596     FIXME("(%p)\n", ppStream);
2597
2598     hr = CreateStreamOnHGlobal(NULL, TRUE, ppStream);
2599     return hr;
2600 }
2601
2602 typedef struct MimeSecurity
2603 {
2604     IMimeSecurity IMimeSecurity_iface;
2605     LONG ref;
2606 } MimeSecurity;
2607
2608 static inline MimeSecurity *impl_from_IMimeSecurity(IMimeSecurity *iface)
2609 {
2610     return CONTAINING_RECORD(iface, MimeSecurity, IMimeSecurity_iface);
2611 }
2612
2613 static HRESULT WINAPI MimeSecurity_QueryInterface(IMimeSecurity *iface, REFIID riid, void **ppv)
2614 {
2615     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2616
2617     if (IsEqualIID(riid, &IID_IUnknown) ||
2618         IsEqualIID(riid, &IID_IMimeSecurity))
2619     {
2620         *ppv = iface;
2621         IMimeSecurity_AddRef(iface);
2622         return S_OK;
2623     }
2624
2625     FIXME("no interface for %s\n", debugstr_guid(riid));
2626     *ppv = NULL;
2627     return E_NOINTERFACE;
2628 }
2629
2630 static ULONG WINAPI MimeSecurity_AddRef(IMimeSecurity *iface)
2631 {
2632     MimeSecurity *This = impl_from_IMimeSecurity(iface);
2633     LONG ref = InterlockedIncrement(&This->ref);
2634
2635     TRACE("(%p) ref=%d\n", This, ref);
2636
2637     return ref;
2638 }
2639
2640 static ULONG WINAPI MimeSecurity_Release(IMimeSecurity *iface)
2641 {
2642     MimeSecurity *This = impl_from_IMimeSecurity(iface);
2643     LONG ref = InterlockedDecrement(&This->ref);
2644
2645     TRACE("(%p) ref=%d\n", This, ref);
2646
2647     if (!ref)
2648         HeapFree(GetProcessHeap(), 0, This);
2649
2650     return ref;
2651 }
2652
2653 static HRESULT WINAPI MimeSecurity_InitNew(
2654         IMimeSecurity* iface)
2655 {
2656     FIXME("(%p)->(): stub\n", iface);
2657     return S_OK;
2658 }
2659
2660 static HRESULT WINAPI MimeSecurity_CheckInit(
2661         IMimeSecurity* iface)
2662 {
2663     FIXME("(%p)->(): stub\n", iface);
2664     return E_NOTIMPL;
2665 }
2666
2667 static HRESULT WINAPI MimeSecurity_EncodeMessage(
2668         IMimeSecurity* iface,
2669         IMimeMessageTree* pTree,
2670         DWORD dwFlags)
2671 {
2672     FIXME("(%p)->(%p, %08x): stub\n", iface, pTree, dwFlags);
2673     return E_NOTIMPL;
2674 }
2675
2676 static HRESULT WINAPI MimeSecurity_EncodeBody(
2677         IMimeSecurity* iface,
2678         IMimeMessageTree* pTree,
2679         HBODY hEncodeRoot,
2680         DWORD dwFlags)
2681 {
2682     FIXME("(%p)->(%p, %p, %08x): stub\n", iface, pTree, hEncodeRoot, dwFlags);
2683     return E_NOTIMPL;
2684 }
2685
2686 static HRESULT WINAPI MimeSecurity_DecodeMessage(
2687         IMimeSecurity* iface,
2688         IMimeMessageTree* pTree,
2689         DWORD dwFlags)
2690 {
2691     FIXME("(%p)->(%p, %08x): stub\n", iface, pTree, dwFlags);
2692     return E_NOTIMPL;
2693 }
2694
2695 static HRESULT WINAPI MimeSecurity_DecodeBody(
2696         IMimeSecurity* iface,
2697         IMimeMessageTree* pTree,
2698         HBODY hDecodeRoot,
2699         DWORD dwFlags)
2700 {
2701     FIXME("(%p)->(%p, %p, %08x): stub\n", iface, pTree, hDecodeRoot, dwFlags);
2702     return E_NOTIMPL;
2703 }
2704
2705 static HRESULT WINAPI MimeSecurity_EnumCertificates(
2706         IMimeSecurity* iface,
2707         HCAPICERTSTORE hc,
2708         DWORD dwUsage,
2709         PCX509CERT pPrev,
2710         PCX509CERT* ppCert)
2711 {
2712     FIXME("(%p)->(%p, %08x, %p, %p): stub\n", iface, hc, dwUsage, pPrev, ppCert);
2713     return E_NOTIMPL;
2714 }
2715
2716 static HRESULT WINAPI MimeSecurity_GetCertificateName(
2717         IMimeSecurity* iface,
2718         const PCX509CERT pX509Cert,
2719         const CERTNAMETYPE cn,
2720         LPSTR* ppszName)
2721 {
2722     FIXME("(%p)->(%p, %08x, %p): stub\n", iface, pX509Cert, cn, ppszName);
2723     return E_NOTIMPL;
2724 }
2725
2726 static HRESULT WINAPI MimeSecurity_GetMessageType(
2727         IMimeSecurity* iface,
2728         const HWND hwndParent,
2729         IMimeBody* pBody,
2730         DWORD* pdwSecType)
2731 {
2732     FIXME("(%p)->(%p, %p, %p): stub\n", iface, hwndParent, pBody, pdwSecType);
2733     return E_NOTIMPL;
2734 }
2735
2736 static HRESULT WINAPI MimeSecurity_GetCertData(
2737         IMimeSecurity* iface,
2738         const PCX509CERT pX509Cert,
2739         const CERTDATAID dataid,
2740         LPPROPVARIANT pValue)
2741 {
2742     FIXME("(%p)->(%p, %x, %p): stub\n", iface, pX509Cert, dataid, pValue);
2743     return E_NOTIMPL;
2744 }
2745
2746
2747 static const IMimeSecurityVtbl MimeSecurityVtbl =
2748 {
2749     MimeSecurity_QueryInterface,
2750     MimeSecurity_AddRef,
2751     MimeSecurity_Release,
2752     MimeSecurity_InitNew,
2753     MimeSecurity_CheckInit,
2754     MimeSecurity_EncodeMessage,
2755     MimeSecurity_EncodeBody,
2756     MimeSecurity_DecodeMessage,
2757     MimeSecurity_DecodeBody,
2758     MimeSecurity_EnumCertificates,
2759     MimeSecurity_GetCertificateName,
2760     MimeSecurity_GetMessageType,
2761     MimeSecurity_GetCertData
2762 };
2763
2764 HRESULT MimeSecurity_create(IUnknown *outer, void **obj)
2765 {
2766     MimeSecurity *This;
2767
2768     *obj = NULL;
2769
2770     if (outer) return CLASS_E_NOAGGREGATION;
2771
2772     This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
2773     if (!This) return E_OUTOFMEMORY;
2774
2775     This->IMimeSecurity_iface.lpVtbl = &MimeSecurityVtbl;
2776     This->ref = 1;
2777
2778     *obj = &This->IMimeSecurity_iface;
2779     return S_OK;
2780 }
2781
2782 /***********************************************************************
2783  *              MimeOleCreateSecurity (INETCOMM.@)
2784  */
2785 HRESULT WINAPI MimeOleCreateSecurity(IMimeSecurity **ppSecurity)
2786 {
2787     return MimeSecurity_create(NULL, (void **)ppSecurity);
2788 }
2789
2790 static HRESULT WINAPI MimeAlloc_QueryInterface(
2791         IMimeAllocator* iface,
2792         REFIID riid,
2793         void **obj)
2794 {
2795     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), obj);
2796
2797     if (IsEqualIID(riid, &IID_IUnknown) ||
2798         IsEqualIID(riid, &IID_IMalloc) ||
2799         IsEqualIID(riid, &IID_IMimeAllocator))
2800     {
2801         *obj = iface;
2802         IMimeAllocator_AddRef(iface);
2803         return S_OK;
2804     }
2805
2806     FIXME("no interface for %s\n", debugstr_guid(riid));
2807     *obj = NULL;
2808     return E_NOINTERFACE;
2809 }
2810
2811 static ULONG WINAPI MimeAlloc_AddRef(
2812         IMimeAllocator* iface)
2813 {
2814     return 2;
2815 }
2816
2817 static ULONG WINAPI MimeAlloc_Release(
2818         IMimeAllocator* iface)
2819 {
2820     return 1;
2821 }
2822
2823 static LPVOID WINAPI MimeAlloc_Alloc(
2824         IMimeAllocator* iface,
2825         ULONG cb)
2826 {
2827     return CoTaskMemAlloc(cb);
2828 }
2829
2830 static LPVOID WINAPI MimeAlloc_Realloc(
2831         IMimeAllocator* iface,
2832         LPVOID pv,
2833         ULONG cb)
2834 {
2835     return CoTaskMemRealloc(pv, cb);
2836 }
2837
2838 static void WINAPI MimeAlloc_Free(
2839         IMimeAllocator* iface,
2840         LPVOID pv)
2841 {
2842     CoTaskMemFree(pv);
2843 }
2844
2845 static ULONG WINAPI MimeAlloc_GetSize(
2846         IMimeAllocator* iface,
2847         LPVOID pv)
2848 {
2849     FIXME("stub\n");
2850     return 0;
2851 }
2852
2853 static int WINAPI MimeAlloc_DidAlloc(
2854         IMimeAllocator* iface,
2855         LPVOID pv)
2856 {
2857     FIXME("stub\n");
2858     return 0;
2859 }
2860
2861 static void WINAPI MimeAlloc_HeapMinimize(
2862         IMimeAllocator* iface)
2863 {
2864     FIXME("stub\n");
2865     return;
2866 }
2867
2868 static HRESULT WINAPI MimeAlloc_FreeParamInfoArray(
2869         IMimeAllocator* iface,
2870         ULONG cParams,
2871         LPMIMEPARAMINFO prgParam,
2872         boolean fFreeArray)
2873 {
2874     ULONG i;
2875     TRACE("(%p)->(%d, %p, %d)\n", iface, cParams, prgParam, fFreeArray);
2876
2877     for(i = 0; i < cParams; i++)
2878     {
2879         IMimeAllocator_Free(iface, prgParam[i].pszName);
2880         IMimeAllocator_Free(iface, prgParam[i].pszData);
2881     }
2882     if(fFreeArray) IMimeAllocator_Free(iface, prgParam);
2883     return S_OK;
2884 }
2885
2886 static HRESULT WINAPI MimeAlloc_FreeAddressList(
2887         IMimeAllocator* iface,
2888         LPADDRESSLIST pList)
2889 {
2890     FIXME("stub\n");
2891     return E_NOTIMPL;
2892 }
2893
2894 static HRESULT WINAPI MimeAlloc_FreeAddressProps(
2895         IMimeAllocator* iface,
2896         LPADDRESSPROPS pAddress)
2897 {
2898     FIXME("stub\n");
2899     return E_NOTIMPL;
2900 }
2901
2902 static HRESULT WINAPI MimeAlloc_ReleaseObjects(
2903         IMimeAllocator* iface,
2904         ULONG cObjects,
2905         IUnknown **prgpUnknown,
2906         boolean fFreeArray)
2907 {
2908     FIXME("stub\n");
2909     return E_NOTIMPL;
2910 }
2911
2912
2913 static HRESULT WINAPI MimeAlloc_FreeEnumHeaderRowArray(
2914         IMimeAllocator* iface,
2915         ULONG cRows,
2916         LPENUMHEADERROW prgRow,
2917         boolean fFreeArray)
2918 {
2919     FIXME("stub\n");
2920     return E_NOTIMPL;
2921 }
2922
2923 static HRESULT WINAPI MimeAlloc_FreeEnumPropertyArray(
2924         IMimeAllocator* iface,
2925         ULONG cProps,
2926         LPENUMPROPERTY prgProp,
2927         boolean fFreeArray)
2928 {
2929     FIXME("stub\n");
2930     return E_NOTIMPL;
2931 }
2932
2933 static HRESULT WINAPI MimeAlloc_FreeThumbprint(
2934         IMimeAllocator* iface,
2935         THUMBBLOB *pthumbprint)
2936 {
2937     FIXME("stub\n");
2938     return E_NOTIMPL;
2939 }
2940
2941
2942 static HRESULT WINAPI MimeAlloc_PropVariantClear(
2943         IMimeAllocator* iface,
2944         LPPROPVARIANT pProp)
2945 {
2946     FIXME("stub\n");
2947     return E_NOTIMPL;
2948 }
2949
2950 static IMimeAllocatorVtbl mime_alloc_vtbl =
2951 {
2952     MimeAlloc_QueryInterface,
2953     MimeAlloc_AddRef,
2954     MimeAlloc_Release,
2955     MimeAlloc_Alloc,
2956     MimeAlloc_Realloc,
2957     MimeAlloc_Free,
2958     MimeAlloc_GetSize,
2959     MimeAlloc_DidAlloc,
2960     MimeAlloc_HeapMinimize,
2961     MimeAlloc_FreeParamInfoArray,
2962     MimeAlloc_FreeAddressList,
2963     MimeAlloc_FreeAddressProps,
2964     MimeAlloc_ReleaseObjects,
2965     MimeAlloc_FreeEnumHeaderRowArray,
2966     MimeAlloc_FreeEnumPropertyArray,
2967     MimeAlloc_FreeThumbprint,
2968     MimeAlloc_PropVariantClear
2969 };
2970
2971 static IMimeAllocator mime_allocator =
2972 {
2973     &mime_alloc_vtbl
2974 };
2975
2976 HRESULT MimeAllocator_create(IUnknown *outer, void **obj)
2977 {
2978     if(outer) return CLASS_E_NOAGGREGATION;
2979
2980     *obj = &mime_allocator;
2981     return S_OK;
2982 }
2983
2984 HRESULT WINAPI MimeOleGetAllocator(IMimeAllocator **alloc)
2985 {
2986     return MimeAllocator_create(NULL, (void**)alloc);
2987 }
2988
2989 HRESULT VirtualStream_create(IUnknown *outer, void **obj)
2990 {
2991     FIXME("(%p, %p)\n", outer, obj);
2992
2993     *obj = NULL;
2994     if (outer) return CLASS_E_NOAGGREGATION;
2995
2996     return MimeOleCreateVirtualStream((IStream **)obj);
2997 }