mimeole.c

Go to the documentation of this file.

/*
 * MIME OLE Interfaces
 *
 * Copyright 2006 Robert Shearman for CodeWeavers
 * Copyright 2007 Huw Davies for CodeWeavers
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
#define COBJMACROS
#define NONAMELESSUNION
 
#include <stdarg.h>
#include <stdio.h>
 
#include "windef.h"
#include "winbase.h"
#include "wine/winternl.h"
#include "winuser.h"
#include "objbase.h"
#include "ole2.h"
#include "mimeole.h"
#ifdef __REACTOS__
#include <winreg.h>
#endif
#include "propvarutil.h"
 
#include "wine/heap.h"
#include "wine/list.h"
#include "wine/debug.h"
 
#include "inetcomm_private.h"
 
WINE_DEFAULT_DEBUG_CHANNEL(inetcomm);
 
typedef struct
{
    LPCSTR     name;
    DWORD      id;
    DWORD      flags; /* MIMEPROPFLAGS */
    VARTYPE    default_vt;
} property_t;
 
typedef struct
{
    struct list entry;
    property_t prop;
} property_list_entry_t;
 
static const property_t default_props[] =
{
    {"X-Newsgroup",                  PID_HDR_NEWSGROUP,    0,                               VT_LPSTR},
    {"Newsgroups",                   PID_HDR_NEWSGROUPS,   0,                               VT_LPSTR},
    {"References",                   PID_HDR_REFS,         0,                               VT_LPSTR},
    {"Subject",                      PID_HDR_SUBJECT,      0,                               VT_LPSTR},
    {"From",                         PID_HDR_FROM,         MPF_ADDRESS,                     VT_LPSTR},
    {"Message-ID",                   PID_HDR_MESSAGEID,    0,                               VT_LPSTR},
    {"Return-Path",                  PID_HDR_RETURNPATH,   MPF_ADDRESS,                     VT_LPSTR},
    {"Rr",                           PID_HDR_RR,           0,                               VT_LPSTR},
    {"Return-Receipt-To",            PID_HDR_RETRCPTO,     MPF_ADDRESS,                     VT_LPSTR},
    {"Apparently-To",                PID_HDR_APPARTO,      MPF_ADDRESS,                     VT_LPSTR},
    {"Date",                         PID_HDR_DATE,         0,                               VT_LPSTR},
    {"Received",                     PID_HDR_RECEIVED,     0,                               VT_LPSTR},
    {"Reply-To",                     PID_HDR_REPLYTO,      MPF_ADDRESS,                     VT_LPSTR},
    {"X-Mailer",                     PID_HDR_XMAILER,      0,                               VT_LPSTR},
    {"Bcc",                          PID_HDR_BCC,          MPF_ADDRESS,                     VT_LPSTR},
    {"MIME-Version",                 PID_HDR_MIMEVER,      MPF_MIME,                        VT_LPSTR},
    {"Content-Type",                 PID_HDR_CNTTYPE,      MPF_MIME | MPF_HASPARAMS,        VT_LPSTR},
    {"Content-Transfer-Encoding",    PID_HDR_CNTXFER,      MPF_MIME,                        VT_LPSTR},
    {"Content-ID",                   PID_HDR_CNTID,        MPF_MIME,                        VT_LPSTR},
    {"Content-Description",          PID_HDR_CNTDESC,      MPF_MIME,                        VT_LPSTR},
    {"Content-Disposition",          PID_HDR_CNTDISP,      MPF_MIME | MPF_HASPARAMS,        VT_LPSTR},
    {"Content-Base",                 PID_HDR_CNTBASE,      MPF_MIME,                        VT_LPSTR},
    {"Content-Location",             PID_HDR_CNTLOC,       MPF_MIME,                        VT_LPSTR},
    {"To",                           PID_HDR_TO,           MPF_ADDRESS,                     VT_LPSTR},
    {"Path",                         PID_HDR_PATH,         0,                               VT_LPSTR},
    {"Followup-To",                  PID_HDR_FOLLOWUPTO,   0,                               VT_LPSTR},
    {"Expires",                      PID_HDR_EXPIRES,      0,                               VT_LPSTR},
    {"Cc",                           PID_HDR_CC,           MPF_ADDRESS,                     VT_LPSTR},
    {"Control",                      PID_HDR_CONTROL,      0,                               VT_LPSTR},
    {"Distribution",                 PID_HDR_DISTRIB,      0,                               VT_LPSTR},
    {"Keywords",                     PID_HDR_KEYWORDS,     0,                               VT_LPSTR},
    {"Summary",                      PID_HDR_SUMMARY,      0,                               VT_LPSTR},
    {"Approved",                     PID_HDR_APPROVED,     0,                               VT_LPSTR},
    {"Lines",                        PID_HDR_LINES,        0,                               VT_LPSTR},
    {"Xref",                         PID_HDR_XREF,         0,                               VT_LPSTR},
    {"Organization",                 PID_HDR_ORG,          0,                               VT_LPSTR},
    {"X-Newsreader",                 PID_HDR_XNEWSRDR,     0,                               VT_LPSTR},
    {"X-Priority",                   PID_HDR_XPRI,         0,                               VT_LPSTR},
    {"X-MSMail-Priority",            PID_HDR_XMSPRI,       0,                               VT_LPSTR},
    {"par:content-disposition:filename", PID_PAR_FILENAME, 0,                               VT_LPSTR},
    {"par:content-type:boundary",    PID_PAR_BOUNDARY,     0,                               VT_LPSTR},
    {"par:content-type:charset",     PID_PAR_CHARSET,      0,                               VT_LPSTR},
    {"par:content-type:name",        PID_PAR_NAME,         0,                               VT_LPSTR},
    {"att:filename",                 PID_ATT_FILENAME,     0,                               VT_LPSTR},
    {"att:pri-content-type",         PID_ATT_PRITYPE,      0,                               VT_LPSTR},
    {"att:sub-content-type",         PID_ATT_SUBTYPE,      0,                               VT_LPSTR},
    {"att:illegal-lines",            PID_ATT_ILLEGAL,      0,                               VT_LPSTR},
    {"att:rendered",                 PID_ATT_RENDERED,     0,                               VT_LPSTR},
    {"att:sent-time",                PID_ATT_SENTTIME,     0,                               VT_LPSTR},
    {"att:priority",                 PID_ATT_PRIORITY,     0,                               VT_LPSTR},
    {"Comment",                      PID_HDR_COMMENT,      0,                               VT_LPSTR},
    {"Encoding",                     PID_HDR_ENCODING,     0,                               VT_LPSTR},
    {"Encrypted",                    PID_HDR_ENCRYPTED,    0,                               VT_LPSTR},
    {"X-Offsets",                    PID_HDR_OFFSETS,      0,                               VT_LPSTR},
    {"X-Unsent",                     PID_HDR_XUNSENT,      0,                               VT_LPSTR},
    {"X-ArticleId",                  PID_HDR_ARTICLEID,    0,                               VT_LPSTR},
    {"Sender",                       PID_HDR_SENDER,       MPF_ADDRESS,                     VT_LPSTR},
    {"att:athena-server",            PID_ATT_SERVER,       0,                               VT_LPSTR},
    {"att:athena-account-id",        PID_ATT_ACCOUNT,      0,                               VT_LPSTR},
    {"att:athena-pop3-uidl",         PID_ATT_UIDL,         0,                               VT_LPSTR},
    {"att:athena-store-msgid",       PID_ATT_STOREMSGID,   0,                               VT_LPSTR},
    {"att:athena-user-name",         PID_ATT_USERNAME,     0,                               VT_LPSTR},
    {"att:athena-forward-to",        PID_ATT_FORWARDTO,    0,                               VT_LPSTR},
    {"att:athena-store-fdrid",       PID_ATT_STOREFOLDERID,0,                               VT_LPSTR},
    {"att:athena-ghosted",           PID_ATT_GHOSTED,      0,                               VT_LPSTR},
    {"att:athena-uncachedsize",      PID_ATT_UNCACHEDSIZE, 0,                               VT_LPSTR},
    {"att:athena-combined",          PID_ATT_COMBINED,     0,                               VT_LPSTR},
    {"att:auto-inlined",             PID_ATT_AUTOINLINED,  0,                               VT_LPSTR},
    {"Disposition-Notification-To",  PID_HDR_DISP_NOTIFICATION_TO,  0,                      VT_LPSTR},
    {"par:Content-Type:reply-type",  PID_PAR_REPLYTYPE,    0,                               VT_LPSTR},
    {"par:Content-Type:format",      PID_PAR_FORMAT ,      0,                               VT_LPSTR},
    {"att:format",                   PID_ATT_FORMAT ,      0,                               VT_LPSTR},
    {"In-Reply-To",                  PID_HDR_INREPLYTO,    0,                               VT_LPSTR},
    {"att:athena-account-name",      PID_ATT_ACCOUNTNAME,  0,                               VT_LPSTR},
    {NULL,                           0,                    0,                               0}
};
 
typedef struct
{
    struct list entry;
    char *name;
    char *value;
} param_t;
 
typedef struct
{
    struct list entry;
    const property_t *prop;
    PROPVARIANT value;
    struct list params;
} header_t;
 
typedef struct MimeBody
{
    IMimeBody IMimeBody_iface;
    LONG ref;
 
    HBODY handle;
 
    struct list headers;
    struct list new_props; /* FIXME: This should be in a PropertySchema */
    DWORD next_prop_id;
    char *content_pri_type;
    char *content_sub_type;
    ENCODINGTYPE encoding;
    void *data;
    IID data_iid;
    BODYOFFSETS body_offsets;
} MimeBody;
 
typedef struct
{
    IStream IStream_iface;
    LONG ref;
    IStream *base;
    ULARGE_INTEGER pos, start, length;
} sub_stream_t;
 
static inline sub_stream_t *impl_from_IStream(IStream *iface)
{
    return CONTAINING_RECORD(iface, sub_stream_t, IStream_iface);
}
 
static HRESULT WINAPI sub_stream_QueryInterface(IStream *iface, REFIID riid, void **ppv)
{
    sub_stream_t *This = impl_from_IStream(iface);
 
    TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
    *ppv = NULL;
 
    if(IsEqualIID(riid, &IID_IUnknown) ||
       IsEqualIID(riid, &IID_ISequentialStream) ||
       IsEqualIID(riid, &IID_IStream))
    {
        IStream_AddRef(iface);
        *ppv = iface;
        return S_OK;
    }
    return E_NOINTERFACE;
}
 
static ULONG WINAPI sub_stream_AddRef(IStream *iface)
{
    sub_stream_t *This = impl_from_IStream(iface);
    LONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p) ref=%d\n", This, ref);
 
    return ref;
}
 
static ULONG WINAPI sub_stream_Release(IStream *iface)
{
    sub_stream_t *This = impl_from_IStream(iface);
    LONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p) ref=%d\n", This, ref);
 
    if(!ref)
    {
        IStream_Release(This->base);
        HeapFree(GetProcessHeap(), 0, This);
    }
    return ref;
}
 
static HRESULT WINAPI sub_stream_Read(
        IStream* iface,
        void *pv,
        ULONG cb,
        ULONG *pcbRead)
{
    sub_stream_t *This = impl_from_IStream(iface);
    HRESULT hr;
    LARGE_INTEGER tmp_pos;
 
    TRACE("(%p, %d, %p)\n", pv, cb, pcbRead);
 
    tmp_pos.QuadPart = This->pos.QuadPart + This->start.QuadPart;
    IStream_Seek(This->base, tmp_pos, STREAM_SEEK_SET, NULL);
 
    if(This->pos.QuadPart + cb > This->length.QuadPart)
        cb = This->length.QuadPart - This->pos.QuadPart;
 
    hr = IStream_Read(This->base, pv, cb, pcbRead);
 
    This->pos.QuadPart += *pcbRead;
 
    return hr;
}
 
static HRESULT WINAPI sub_stream_Write(
        IStream* iface,
        const void *pv,
        ULONG cb,
        ULONG *pcbWritten)
{
    FIXME("stub\n");
    return E_NOTIMPL;
}
 
static HRESULT WINAPI sub_stream_Seek(
        IStream* iface,
        LARGE_INTEGER dlibMove,
        DWORD dwOrigin,
        ULARGE_INTEGER *plibNewPosition)
{
    sub_stream_t *This = impl_from_IStream(iface);
    LARGE_INTEGER new_pos;
 
    TRACE("(%08x.%08x, %x, %p)\n", dlibMove.u.HighPart, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
 
    switch(dwOrigin)
    {
    case STREAM_SEEK_SET:
        new_pos = dlibMove;
        break;
    case STREAM_SEEK_CUR:
        new_pos.QuadPart = This->pos.QuadPart + dlibMove.QuadPart;
        break;
    case STREAM_SEEK_END:
        new_pos.QuadPart = This->length.QuadPart + dlibMove.QuadPart;
        break;
    default:
        return STG_E_INVALIDFUNCTION;
    }
 
    if(new_pos.QuadPart < 0) new_pos.QuadPart = 0;
    else if(new_pos.QuadPart > This->length.QuadPart) new_pos.QuadPart = This->length.QuadPart;
 
    This->pos.QuadPart = new_pos.QuadPart;
 
    if(plibNewPosition) *plibNewPosition = This->pos;
    return S_OK;
}
 
static HRESULT WINAPI sub_stream_SetSize(
        IStream* iface,
        ULARGE_INTEGER libNewSize)
{
    FIXME("stub\n");
    return E_NOTIMPL;
}
 
static HRESULT WINAPI sub_stream_CopyTo(
        IStream* iface,
        IStream *pstm,
        ULARGE_INTEGER cb,
        ULARGE_INTEGER *pcbRead,
        ULARGE_INTEGER *pcbWritten)
{
    HRESULT        hr = S_OK;
    BYTE           tmpBuffer[128];
    ULONG          bytesRead, bytesWritten, copySize;
    ULARGE_INTEGER totalBytesRead;
    ULARGE_INTEGER totalBytesWritten;
 
    TRACE("(%p)->(%p, %d, %p, %p)\n", iface, pstm, cb.u.LowPart, pcbRead, pcbWritten);
 
    totalBytesRead.QuadPart = 0;
    totalBytesWritten.QuadPart = 0;
 
    while ( cb.QuadPart > 0 )
    {
        if ( cb.QuadPart >= sizeof(tmpBuffer) )
            copySize = sizeof(tmpBuffer);
        else
            copySize = cb.u.LowPart;
 
        hr = IStream_Read(iface, tmpBuffer, copySize, &bytesRead);
        if (FAILED(hr)) break;
 
        totalBytesRead.QuadPart += bytesRead;
 
        if (bytesRead)
        {
            hr = IStream_Write(pstm, tmpBuffer, bytesRead, &bytesWritten);
            if (FAILED(hr)) break;
            totalBytesWritten.QuadPart += bytesWritten;
        }
 
        if (bytesRead != copySize)
            cb.QuadPart = 0;
        else
            cb.QuadPart -= bytesRead;
    }
 
    if (pcbRead) pcbRead->QuadPart = totalBytesRead.QuadPart;
    if (pcbWritten) pcbWritten->QuadPart = totalBytesWritten.QuadPart;
 
    return hr;
}
 
static HRESULT WINAPI sub_stream_Commit(
        IStream* iface,
        DWORD grfCommitFlags)
{
    FIXME("stub\n");
    return E_NOTIMPL;
}
 
static HRESULT WINAPI sub_stream_Revert(
        IStream* iface)
{
    FIXME("stub\n");
    return E_NOTIMPL;
}
 
static HRESULT WINAPI sub_stream_LockRegion(
        IStream* iface,
        ULARGE_INTEGER libOffset,
        ULARGE_INTEGER cb,
        DWORD dwLockType)
{
    FIXME("stub\n");
    return E_NOTIMPL;
}
 
static HRESULT WINAPI sub_stream_UnlockRegion(
        IStream* iface,
        ULARGE_INTEGER libOffset,
        ULARGE_INTEGER cb,
        DWORD dwLockType)
{
    FIXME("stub\n");
    return E_NOTIMPL;
}
 
static HRESULT WINAPI sub_stream_Stat(
        IStream* iface,
        STATSTG *pstatstg,
        DWORD grfStatFlag)
{
    sub_stream_t *This = impl_from_IStream(iface);
    FIXME("(%p)->(%p, %08x)\n", This, pstatstg, grfStatFlag);
    memset(pstatstg, 0, sizeof(*pstatstg));
    pstatstg->cbSize = This->length;
    return S_OK;
}
 
static HRESULT WINAPI sub_stream_Clone(
        IStream* iface,
        IStream **ppstm)
{
    FIXME("stub\n");
    return E_NOTIMPL;
}
 
static struct IStreamVtbl sub_stream_vtbl =
{
    sub_stream_QueryInterface,
    sub_stream_AddRef,
    sub_stream_Release,
    sub_stream_Read,
    sub_stream_Write,
    sub_stream_Seek,
    sub_stream_SetSize,
    sub_stream_CopyTo,
    sub_stream_Commit,
    sub_stream_Revert,
    sub_stream_LockRegion,
    sub_stream_UnlockRegion,
    sub_stream_Stat,
    sub_stream_Clone
};
 
static HRESULT create_sub_stream(IStream *stream, ULARGE_INTEGER start, ULARGE_INTEGER length, IStream **out)
{
    sub_stream_t *This;
 
    *out = NULL;
    This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
    if(!This) return E_OUTOFMEMORY;
 
    This->IStream_iface.lpVtbl = &sub_stream_vtbl;
    This->ref = 1;
    This->start = start;
    This->length = length;
    This->pos.QuadPart = 0;
    IStream_AddRef(stream);
    This->base = stream;
 
    *out = &This->IStream_iface;
    return S_OK;
}
 
static HRESULT get_stream_size(IStream *stream, ULARGE_INTEGER *size)
{
    STATSTG statstg = {NULL};
    LARGE_INTEGER zero;
    HRESULT hres;
 
    hres = IStream_Stat(stream, &statstg, STATFLAG_NONAME);
    if(SUCCEEDED(hres)) {
        *size = statstg.cbSize;
        return S_OK;
    }
 
    zero.QuadPart = 0;
    return IStream_Seek(stream, zero, STREAM_SEEK_END, size);
}
 
static inline MimeBody *impl_from_IMimeBody(IMimeBody *iface)
{
    return CONTAINING_RECORD(iface, MimeBody, IMimeBody_iface);
}
 
typedef struct propschema
{
    IMimePropertySchema IMimePropertySchema_iface;
    LONG ref;
} propschema;
 
static inline propschema *impl_from_IMimePropertySchema(IMimePropertySchema *iface)
{
    return CONTAINING_RECORD(iface, propschema, IMimePropertySchema_iface);
}
 
static LPSTR strdupA(LPCSTR str)
{
    char *ret;
    int len = strlen(str);
    ret = HeapAlloc(GetProcessHeap(), 0, len + 1);
    memcpy(ret, str, len + 1);
    return ret;
}
 
#define PARSER_BUF_SIZE 1024
 
/*****************************************************
 *        copy_headers_to_buf [internal]
 *
 * Copies the headers into a '\0' terminated memory block and leave
 * the stream's current position set to after the blank line.
 */
static HRESULT copy_headers_to_buf(IStream *stm, char **ptr)
{
    char *buf = NULL;
    DWORD size = PARSER_BUF_SIZE, offset = 0, last_end = 0;
    HRESULT hr;
    BOOL done = FALSE;
 
    *ptr = NULL;
 
    do
    {
        char *end;
        DWORD read;
 
        if(!buf)
            buf = HeapAlloc(GetProcessHeap(), 0, size + 1);
        else
        {
            size *= 2;
            buf = HeapReAlloc(GetProcessHeap(), 0, buf, size + 1);
        }
        if(!buf)
        {
            hr = E_OUTOFMEMORY;
            goto fail;
        }
 
        hr = IStream_Read(stm, buf + offset, size - offset, &read);
        if(FAILED(hr)) goto fail;
 
        offset += read;
        buf[offset] = '\0';
 
        if(read == 0) done = TRUE;
 
        while(!done && (end = strstr(buf + last_end, "\r\n")))
        {
            DWORD new_end = end - buf + 2;
            if(new_end - last_end == 2)
            {
                LARGE_INTEGER off;
                off.QuadPart = (LONGLONG)new_end - offset;
                IStream_Seek(stm, off, STREAM_SEEK_CUR, NULL);
                buf[new_end] = '\0';
                done = TRUE;
            }
            else
                last_end = new_end;
        }
    } while(!done);
 
    *ptr = buf;
    return S_OK;
 
fail:
    HeapFree(GetProcessHeap(), 0, buf);
    return hr;
}
 
static header_t *read_prop(MimeBody *body, char **ptr)
{
    char *colon = strchr(*ptr, ':');
    const property_t *prop;
    header_t *ret;
 
    if(!colon) return NULL;
 
    *colon = '\0';
 
    for(prop = default_props; prop->name; prop++)
    {
        if(!lstrcmpiA(*ptr, prop->name))
        {
            TRACE("%s: found match with default property id %d\n", *ptr, prop->id);
            break;
        }
    }
 
    if(!prop->name)
    {
        property_list_entry_t *prop_entry;
        LIST_FOR_EACH_ENTRY(prop_entry, &body->new_props, property_list_entry_t, entry)
        {
            if(!lstrcmpiA(*ptr, prop_entry->prop.name))
            {
                TRACE("%s: found match with already added new property id %d\n", *ptr, prop_entry->prop.id);
                prop = &prop_entry->prop;
                break;
            }
        }
        if(!prop->name)
        {
            prop_entry = HeapAlloc(GetProcessHeap(), 0, sizeof(*prop_entry));
            prop_entry->prop.name = strdupA(*ptr);
            prop_entry->prop.id = body->next_prop_id++;
            prop_entry->prop.flags = 0;
            prop_entry->prop.default_vt = VT_LPSTR;
            list_add_tail(&body->new_props, &prop_entry->entry);
            prop = &prop_entry->prop;
            TRACE("%s: allocating new prop id %d\n", *ptr, prop_entry->prop.id);
        }
    }
 
    ret = HeapAlloc(GetProcessHeap(), 0, sizeof(*ret));
    ret->prop = prop;
    PropVariantInit(&ret->value);
    list_init(&ret->params);
    *ptr = colon + 1;
 
    return ret;
}
 
static void unfold_header(char *header, int len)
{
    char *start = header, *cp = header;
 
    do {
        while(*cp == ' ' || *cp == '\t')
        {
            cp++;
            len--;
        }
        if(cp != start)
            memmove(start, cp, len + 1);
 
        cp = strstr(start, "\r\n");
        len -= (cp - start);
        start = cp;
        *start = ' ';
        start++;
        len--;
        cp += 2;
    } while(*cp == ' ' || *cp == '\t');
 
    *(start - 1) = '\0';
}
 
static char *unquote_string(const char *str)
{
    BOOL quoted = FALSE;
    char *ret, *cp;
 
    while(*str == ' ' || *str == '\t') str++;
 
    if(*str == '"')
    {
        quoted = TRUE;
        str++;
    }
    ret = strdupA(str);
    for(cp = ret; *cp; cp++)
    {
        if(*cp == '\\')
            memmove(cp, cp + 1, strlen(cp + 1) + 1);
        else if(*cp == '"')
        {
            if(!quoted)
            {
                WARN("quote in unquoted string\n");
            }
            else
            {
                *cp = '\0';
                break;
            }
        }
    }
    return ret;
}
 
static void add_param(header_t *header, const char *p)
{
    const char *key = p, *value, *cp = p;
    param_t *param;
    char *name;
 
    TRACE("got param %s\n", p);
 
    while (*key == ' ' || *key == '\t' ) key++;
 
    cp = strchr(key, '=');
    if(!cp)
    {
        WARN("malformed parameter - skipping\n");
        return;
    }
 
    name = HeapAlloc(GetProcessHeap(), 0, cp - key + 1);
    memcpy(name, key, cp - key);
    name[cp - key] = '\0';
 
    value = cp + 1;
 
    param = HeapAlloc(GetProcessHeap(), 0, sizeof(*param));
    param->name = name;
    param->value = unquote_string(value);
    list_add_tail(&header->params, &param->entry);
}
 
static void split_params(header_t *header, char *value)
{
    char *cp = value, *start = value;
    BOOL in_quotes = FALSE, done_value = FALSE;
 
    while(*cp)
    {
        if(!in_quotes && *cp == ';')
        {
            *cp = '\0';
            if(done_value) add_param(header, start);
            done_value = TRUE;
            start = cp + 1;
        }
        else if(*cp == '"')
            in_quotes = !in_quotes;
        cp++;
    }
    if(done_value) add_param(header, start);
}
 
static void read_value(header_t *header, char **cur)
{
    char *end = *cur, *value;
    DWORD len;
 
    do {
        end = strstr(end, "\r\n");
        end += 2;
    } while(*end == ' ' || *end == '\t');
 
    len = end - *cur;
    value = HeapAlloc(GetProcessHeap(), 0, len + 1);
    memcpy(value, *cur, len);
    value[len] = '\0';
 
    unfold_header(value, len);
    TRACE("value %s\n", debugstr_a(value));
 
    if(header->prop->flags & MPF_HASPARAMS)
    {
        split_params(header, value);
        TRACE("value w/o params %s\n", debugstr_a(value));
    }
 
    header->value.vt = VT_LPSTR;
    header->value.u.pszVal = value;
 
    *cur = end;
}
 
static void init_content_type(MimeBody *body, header_t *header)
{
    char *slash;
    DWORD len;
 
    slash = strchr(header->value.u.pszVal, '/');
    if(!slash)
    {
        WARN("malformed context type value\n");
        return;
    }
    len = slash - header->value.u.pszVal;
    body->content_pri_type = HeapAlloc(GetProcessHeap(), 0, len + 1);
    memcpy(body->content_pri_type, header->value.u.pszVal, len);
    body->content_pri_type[len] = '\0';
    body->content_sub_type = strdupA(slash + 1);
}
 
static void init_content_encoding(MimeBody *body, header_t *header)
{
    const char *encoding = header->value.u.pszVal;
 
    if(!_strnicmp(encoding, "base64", -1))
        body->encoding = IET_BASE64;
    else if(!_strnicmp(encoding, "quoted-printable", -1))
        body->encoding = IET_QP;
    else if(!_strnicmp(encoding, "7bit", -1))
        body->encoding = IET_7BIT;
    else if(!_strnicmp(encoding, "8bit", -1))
        body->encoding = IET_8BIT;
    else
        FIXME("unknown encoding %s\n", debugstr_a(encoding));
}
 
static HRESULT parse_headers(MimeBody *body, IStream *stm)
{
    char *header_buf, *cur_header_ptr;
    HRESULT hr;
    header_t *header;
 
    hr = copy_headers_to_buf(stm, &header_buf);
    if(FAILED(hr)) return hr;
 
    cur_header_ptr = header_buf;
    while((header = read_prop(body, &cur_header_ptr)))
    {
        read_value(header, &cur_header_ptr);
        list_add_tail(&body->headers, &header->entry);
 
        switch(header->prop->id) {
        case PID_HDR_CNTTYPE:
            init_content_type(body, header);
            break;
        case PID_HDR_CNTXFER:
            init_content_encoding(body, header);
            break;
        }
    }
 
    HeapFree(GetProcessHeap(), 0, header_buf);
    return hr;
}
 
static void empty_param_list(struct list *list)
{
    param_t *param, *cursor2;
 
    LIST_FOR_EACH_ENTRY_SAFE(param, cursor2, list, param_t, entry)
    {
        list_remove(&param->entry);
        HeapFree(GetProcessHeap(), 0, param->name);
        HeapFree(GetProcessHeap(), 0, param->value);
        HeapFree(GetProcessHeap(), 0, param);
    }
}
 
static void free_header(header_t *header)
{
    list_remove(&header->entry);
    PropVariantClear(&header->value);
    empty_param_list(&header->params);
    heap_free(header);
}
 
static void empty_header_list(struct list *list)
{
    header_t *header, *cursor2;
 
    LIST_FOR_EACH_ENTRY_SAFE(header, cursor2, list, header_t, entry)
    {
        free_header(header);
    }
}
 
static void empty_new_prop_list(struct list *list)
{
    property_list_entry_t *prop, *cursor2;
 
    LIST_FOR_EACH_ENTRY_SAFE(prop, cursor2, list, property_list_entry_t, entry)
    {
        list_remove(&prop->entry);
        HeapFree(GetProcessHeap(), 0, (char *)prop->prop.name);
        HeapFree(GetProcessHeap(), 0, prop);
    }
}
 
static void release_data(REFIID riid, void *data)
{
    if(!data) return;
 
    if(IsEqualIID(riid, &IID_IStream))
        IStream_Release((IStream *)data);
    else
        FIXME("Unhandled data format %s\n", debugstr_guid(riid));
}
 
static HRESULT find_prop(MimeBody *body, const char *name, header_t **prop)
{
    header_t *header;
 
    *prop = NULL;
 
    LIST_FOR_EACH_ENTRY(header, &body->headers, header_t, entry)
    {
        if(ISPIDSTR(name))
        {
            if(STRTOPID(name) == header->prop->id)
            {
                *prop = header;
                return S_OK;
            }
        }
        else if(!lstrcmpiA(name, header->prop->name))
        {
            *prop = header;
            return S_OK;
        }
    }
 
    return MIME_E_NOT_FOUND;
}
 
static const property_t *find_default_prop(const char *name)
{
    const property_t *prop_def = NULL;
 
    for(prop_def = default_props; prop_def->name; prop_def++)
    {
        if(ISPIDSTR(name))
        {
            if(STRTOPID(name) == prop_def->id)
            {
                break;
            }
        }
        else if(!lstrcmpiA(name, prop_def->name))
        {
            break;
        }
    }
 
    if(prop_def->id)
       TRACE("%s: found match with default property id %d\n", prop_def->name, prop_def->id);
    else
       prop_def = NULL;
 
    return prop_def;
}
 
static HRESULT WINAPI MimeBody_QueryInterface(IMimeBody* iface,
                                     REFIID riid,
                                     void** ppvObject)
{
    TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppvObject);
 
    *ppvObject = NULL;
 
    if (IsEqualIID(riid, &IID_IUnknown) ||
        IsEqualIID(riid, &IID_IPersist) ||
        IsEqualIID(riid, &IID_IPersistStreamInit) ||
        IsEqualIID(riid, &IID_IMimePropertySet) ||
        IsEqualIID(riid, &IID_IMimeBody))
    {
        *ppvObject = iface;
    }
 
    if(*ppvObject)
    {
        IUnknown_AddRef((IUnknown*)*ppvObject);
        return S_OK;
    }
 
    FIXME("no interface for %s\n", debugstr_guid(riid));
    return E_NOINTERFACE;
}
 
static ULONG WINAPI MimeBody_AddRef(IMimeBody *iface)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    LONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p) ref=%d\n", This, ref);
 
    return ref;
}
 
static ULONG WINAPI MimeBody_Release(IMimeBody *iface)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    LONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p) ref=%d\n", This, ref);
 
    if (!ref)
    {
        empty_header_list(&This->headers);
        empty_new_prop_list(&This->new_props);
 
        HeapFree(GetProcessHeap(), 0, This->content_pri_type);
        HeapFree(GetProcessHeap(), 0, This->content_sub_type);
 
        release_data(&This->data_iid, This->data);
 
        HeapFree(GetProcessHeap(), 0, This);
    }
 
    return ref;
}
 
static HRESULT WINAPI MimeBody_GetClassID(
                                 IMimeBody* iface,
                                 CLSID* pClassID)
{
    MimeBody *This = impl_from_IMimeBody(iface);
 
    TRACE("(%p)->(%p)\n", This, pClassID);
 
    if(!pClassID)
        return E_INVALIDARG;
 
    *pClassID = IID_IMimeBody;
    return S_OK;
}
 
static HRESULT WINAPI MimeBody_IsDirty(
                              IMimeBody* iface)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    FIXME("(%p)->() stub\n", This);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeBody_Load(IMimeBody *iface, IStream *pStm)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    TRACE("(%p)->(%p)\n", This, pStm);
    return parse_headers(This, pStm);
}
 
static HRESULT WINAPI MimeBody_Save(IMimeBody *iface, IStream *pStm, BOOL fClearDirty)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    FIXME("(%p)->(%p, %d)\n", This, pStm, fClearDirty);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeBody_GetSizeMax(
                                 IMimeBody* iface,
                                 ULARGE_INTEGER* pcbSize)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    FIXME("(%p)->(%p) stub\n", This, pcbSize);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeBody_InitNew(
                              IMimeBody* iface)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    TRACE("(%p)->()\n", This);
    return S_OK;
}
 
static HRESULT WINAPI MimeBody_GetPropInfo(
                                  IMimeBody* iface,
                                  LPCSTR pszName,
                                  LPMIMEPROPINFO pInfo)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    header_t *header;
    HRESULT hr;
    DWORD supported = PIM_PROPID | PIM_VTDEFAULT;
 
    TRACE("(%p)->(%s, %p) semi-stub\n", This, debugstr_a(pszName), pInfo);
 
    if(!pszName || !pInfo)
        return E_INVALIDARG;
 
    TRACE("mask 0x%04x\n", pInfo->dwMask);
 
    if(pInfo->dwMask & ~supported)
         FIXME("Unsupported mask flags 0x%04x\n", pInfo->dwMask & ~supported);
 
    hr = find_prop(This, pszName, &header);
    if(hr == S_OK)
    {
        if(pInfo->dwMask & PIM_CHARSET)
            pInfo->hCharset = 0;
        if(pInfo->dwMask & PIM_FLAGS)
            pInfo->dwFlags = 0x00000000;
        if(pInfo->dwMask & PIM_ROWNUMBER)
            pInfo->dwRowNumber = 0;
        if(pInfo->dwMask & PIM_ENCODINGTYPE)
            pInfo->ietEncoding = 0;
        if(pInfo->dwMask & PIM_VALUES)
            pInfo->cValues = 0;
        if(pInfo->dwMask & PIM_PROPID)
            pInfo->dwPropId = header->prop->id;
        if(pInfo->dwMask & PIM_VTDEFAULT)
            pInfo->vtDefault = header->prop->default_vt;
        if(pInfo->dwMask & PIM_VTCURRENT)
            pInfo->vtCurrent = 0;
    }
 
    return hr;
}
 
static HRESULT WINAPI MimeBody_SetPropInfo(
                                  IMimeBody* iface,
                                  LPCSTR pszName,
                                  LPCMIMEPROPINFO pInfo)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    FIXME("(%p)->(%s, %p) stub\n", This, debugstr_a(pszName), pInfo);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeBody_GetProp(
                              IMimeBody* iface,
                              LPCSTR pszName,
                              DWORD dwFlags,
                              LPPROPVARIANT pValue)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    header_t *header;
    HRESULT hr;
 
    TRACE("(%p)->(%s, 0x%x, %p)\n", This, debugstr_a(pszName), dwFlags, pValue);
 
    if(!pszName || !pValue)
        return E_INVALIDARG;
 
    if(!ISPIDSTR(pszName) && !lstrcmpiA(pszName, "att:pri-content-type"))
    {
        PropVariantClear(pValue);
        pValue->vt = VT_LPSTR;
        pValue->u.pszVal = strdupA(This->content_pri_type);
        return S_OK;
    }
 
    hr = find_prop(This, pszName, &header);
    if(hr == S_OK)
    {
        TRACE("type %d->%d\n", header->value.vt, pValue->vt);
 
        hr = PropVariantChangeType(pValue, &header->value, 0,  pValue->vt);
        if(FAILED(hr))
            FIXME("Conversion not currently supported (%d->%d)\n", header->value.vt, pValue->vt);
    }
 
    return hr;
}
 
static HRESULT WINAPI MimeBody_SetProp(
                              IMimeBody* iface,
                              LPCSTR pszName,
                              DWORD dwFlags,
                              LPCPROPVARIANT pValue)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    header_t *header;
    HRESULT hr;
 
    TRACE("(%p)->(%s, 0x%x, %p)\n", This, debugstr_a(pszName), dwFlags, pValue);
 
    if(!pszName || !pValue)
        return E_INVALIDARG;
 
    hr = find_prop(This, pszName, &header);
    if(hr != S_OK)
    {
        property_list_entry_t *prop_entry;
        const property_t *prop = NULL;
 
        LIST_FOR_EACH_ENTRY(prop_entry, &This->new_props, property_list_entry_t, entry)
        {
            if(ISPIDSTR(pszName))
            {
                if(STRTOPID(pszName) == prop_entry->prop.id)
                {
                    TRACE("Found match with already added new property id %d\n", prop_entry->prop.id);
                    prop = &prop_entry->prop;
                    break;
                }
            }
            else if(!lstrcmpiA(pszName, prop_entry->prop.name))
            {
                TRACE("Found match with already added new property id %d\n", prop_entry->prop.id);
                prop = &prop_entry->prop;
                break;
            }
        }
 
        header = HeapAlloc(GetProcessHeap(), 0, sizeof(*header));
        if(!header)
            return E_OUTOFMEMORY;
 
        if(!prop)
        {
            const property_t *prop_def = NULL;
            prop_entry = HeapAlloc(GetProcessHeap(), 0, sizeof(*prop_entry));
            if(!prop_entry)
            {
                HeapFree(GetProcessHeap(), 0, header);
                return E_OUTOFMEMORY;
            }
 
            prop_def = find_default_prop(pszName);
            if(prop_def)
            {
                prop_entry->prop.name = strdupA(prop_def->name);
                prop_entry->prop.id =  prop_def->id;
            }
            else
            {
                if(ISPIDSTR(pszName))
                {
                    HeapFree(GetProcessHeap(), 0, prop_entry);
                    HeapFree(GetProcessHeap(), 0, header);
                    return MIME_E_NOT_FOUND;
                }
 
                prop_entry->prop.name = strdupA(pszName);
                prop_entry->prop.id = This->next_prop_id++;
            }
 
            prop_entry->prop.flags = 0;
            prop_entry->prop.default_vt = pValue->vt;
            list_add_tail(&This->new_props, &prop_entry->entry);
            prop = &prop_entry->prop;
            TRACE("Allocating new prop id %d\n", prop_entry->prop.id);
        }
 
        header->prop = prop;
        PropVariantInit(&header->value);
        list_init(&header->params);
        list_add_tail(&This->headers, &header->entry);
    }
 
    PropVariantCopy(&header->value, pValue);
 
    return S_OK;
}
 
static HRESULT WINAPI MimeBody_AppendProp(
                                 IMimeBody* iface,
                                 LPCSTR pszName,
                                 DWORD dwFlags,
                                 LPPROPVARIANT pValue)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    FIXME("(%p)->(%s, 0x%x, %p) stub\n", This, debugstr_a(pszName), dwFlags, pValue);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeBody_DeleteProp(
                                 IMimeBody* iface,
                                 LPCSTR pszName)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    header_t *cursor;
    BOOL found;
 
    TRACE("(%p)->(%s) stub\n", This, debugstr_a(pszName));
 
    LIST_FOR_EACH_ENTRY(cursor, &This->headers, header_t, entry)
    {
        if(ISPIDSTR(pszName))
            found = STRTOPID(pszName) == cursor->prop->id;
        else
            found = !lstrcmpiA(pszName, cursor->prop->name);
 
        if(found)
        {
             free_header(cursor);
             return S_OK;
        }
    }
 
    return MIME_E_NOT_FOUND;
}
 
static HRESULT WINAPI MimeBody_CopyProps(
                                IMimeBody* iface,
                                ULONG cNames,
                                LPCSTR* prgszName,
                                IMimePropertySet* pPropertySet)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    FIXME("(%p)->(%d, %p, %p) stub\n", This, cNames, prgszName, pPropertySet);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeBody_MoveProps(
                                IMimeBody* iface,
                                ULONG cNames,
                                LPCSTR* prgszName,
                                IMimePropertySet* pPropertySet)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    FIXME("(%p)->(%d, %p, %p) stub\n", This, cNames, prgszName, pPropertySet);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeBody_DeleteExcept(
                                   IMimeBody* iface,
                                   ULONG cNames,
                                   LPCSTR* prgszName)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    FIXME("(%p)->(%d, %p) stub\n", This, cNames, prgszName);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeBody_QueryProp(
                                IMimeBody* iface,
                                LPCSTR pszName,
                                LPCSTR pszCriteria,
                                boolean fSubString,
                                boolean fCaseSensitive)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    FIXME("(%p)->(%s, %s, %d, %d) stub\n", This, debugstr_a(pszName), debugstr_a(pszCriteria), fSubString, fCaseSensitive);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeBody_GetCharset(
                                 IMimeBody* iface,
                                 LPHCHARSET phCharset)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    FIXME("(%p)->(%p) stub\n", This, phCharset);
    *phCharset = NULL;
    return S_OK;
}
 
static HRESULT WINAPI MimeBody_SetCharset(
                                 IMimeBody* iface,
                                 HCHARSET hCharset,
                                 CSETAPPLYTYPE applytype)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    FIXME("(%p)->(%p, %d) stub\n", This, hCharset, applytype);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeBody_GetParameters(
                                    IMimeBody* iface,
                                    LPCSTR pszName,
                                    ULONG* pcParams,
                                    LPMIMEPARAMINFO* pprgParam)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    HRESULT hr;
    header_t *header;
 
    TRACE("(%p)->(%s, %p, %p)\n", iface, debugstr_a(pszName), pcParams, pprgParam);
 
    *pprgParam = NULL;
    *pcParams = 0;
 
    hr = find_prop(This, pszName, &header);
    if(hr != S_OK) return hr;
 
    *pcParams = list_count(&header->params);
    if(*pcParams)
    {
        IMimeAllocator *alloc;
        param_t *param;
        MIMEPARAMINFO *info;
 
        MimeOleGetAllocator(&alloc);
 
        *pprgParam = info = IMimeAllocator_Alloc(alloc, *pcParams * sizeof(**pprgParam));
        LIST_FOR_EACH_ENTRY(param, &header->params, param_t, entry)
        {
            int len;
 
            len = strlen(param->name) + 1;
            info->pszName = IMimeAllocator_Alloc(alloc, len);
            memcpy(info->pszName, param->name, len);
            len = strlen(param->value) + 1;
            info->pszData = IMimeAllocator_Alloc(alloc, len);
            memcpy(info->pszData, param->value, len);
            info++;
        }
        IMimeAllocator_Release(alloc);
    }
    return S_OK;
}
 
static HRESULT WINAPI MimeBody_IsContentType(
                                    IMimeBody* iface,
                                    LPCSTR pszPriType,
                                    LPCSTR pszSubType)
{
    MimeBody *This = impl_from_IMimeBody(iface);
 
    TRACE("(%p)->(%s, %s)\n", This, debugstr_a(pszPriType), debugstr_a(pszSubType));
    if(pszPriType)
    {
        const char *pri = This->content_pri_type;
        if(!pri) pri = "text";
        if(lstrcmpiA(pri, pszPriType)) return S_FALSE;
    }
 
    if(pszSubType)
    {
        const char *sub = This->content_sub_type;
        if(!sub) sub = "plain";
        if(lstrcmpiA(sub, pszSubType)) return S_FALSE;
    }
 
    return S_OK;
}
 
static HRESULT WINAPI MimeBody_BindToObject(
                                   IMimeBody* iface,
                                   REFIID riid,
                                   void** ppvObject)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    FIXME("(%p)->(%s, %p) stub\n", This, debugstr_guid(riid), ppvObject);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeBody_Clone(
                            IMimeBody* iface,
                            IMimePropertySet** ppPropertySet)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    FIXME("(%p)->(%p) stub\n", This, ppPropertySet);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeBody_SetOption(
                                IMimeBody* iface,
                                const TYPEDID oid,
                                LPCPROPVARIANT pValue)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    HRESULT hr = E_NOTIMPL;
    TRACE("(%p)->(%08x, %p)\n", This, oid, pValue);
 
    if(pValue->vt != TYPEDID_TYPE(oid))
    {
        WARN("Called with vartype %04x and oid %08x\n", pValue->vt, oid);
        return E_INVALIDARG;
    }
 
    switch(oid)
    {
    case OID_SECURITY_HWND_OWNER:
        FIXME("OID_SECURITY_HWND_OWNER (value %08x): ignoring\n", pValue->u.ulVal);
        hr = S_OK;
        break;
    case OID_TRANSMIT_BODY_ENCODING:
        FIXME("OID_TRANSMIT_BODY_ENCODING (value %08x): ignoring\n", pValue->u.ulVal);
        hr = S_OK;
        break;
    default:
        FIXME("Unhandled oid %08x\n", oid);
    }
 
    return hr;
}
 
static HRESULT WINAPI MimeBody_GetOption(
                                IMimeBody* iface,
                                const TYPEDID oid,
                                LPPROPVARIANT pValue)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    FIXME("(%p)->(%08x, %p): stub\n", This, oid, pValue);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeBody_EnumProps(
                                IMimeBody* iface,
                                DWORD dwFlags,
                                IMimeEnumProperties** ppEnum)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    FIXME("(%p)->(0x%x, %p) stub\n", This, dwFlags, ppEnum);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeBody_IsType(
                             IMimeBody* iface,
                             IMSGBODYTYPE bodytype)
{
    MimeBody *This = impl_from_IMimeBody(iface);
 
    TRACE("(%p)->(%d)\n", This, bodytype);
    switch(bodytype)
    {
    case IBT_EMPTY:
        return This->data ? S_FALSE : S_OK;
    default:
        FIXME("Unimplemented bodytype %d - returning S_OK\n", bodytype);
    }
    return S_OK;
}
 
static HRESULT WINAPI MimeBody_SetDisplayName(
                                     IMimeBody* iface,
                                     LPCSTR pszDisplay)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    FIXME("(%p)->(%s) stub\n", This, debugstr_a(pszDisplay));
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeBody_GetDisplayName(
                                     IMimeBody* iface,
                                     LPSTR* ppszDisplay)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    FIXME("(%p)->(%p) stub\n", This, ppszDisplay);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeBody_GetOffsets(
                                 IMimeBody* iface,
                                 LPBODYOFFSETS pOffsets)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    TRACE("(%p)->(%p)\n", This, pOffsets);
 
    *pOffsets = This->body_offsets;
 
    if(This->body_offsets.cbBodyEnd == 0) return MIME_E_NO_DATA;
    return S_OK;
}
 
static HRESULT WINAPI MimeBody_GetCurrentEncoding(
                                         IMimeBody* iface,
                                         ENCODINGTYPE* pietEncoding)
{
    MimeBody *This = impl_from_IMimeBody(iface);
 
    TRACE("(%p)->(%p)\n", This, pietEncoding);
 
    *pietEncoding = This->encoding;
    return S_OK;
}
 
static HRESULT WINAPI MimeBody_SetCurrentEncoding(
                                         IMimeBody* iface,
                                         ENCODINGTYPE ietEncoding)
{
    MimeBody *This = impl_from_IMimeBody(iface);
 
    TRACE("(%p)->(%d)\n", This, ietEncoding);
 
    This->encoding = ietEncoding;
    return S_OK;
}
 
static HRESULT WINAPI MimeBody_GetEstimatedSize(
                                       IMimeBody* iface,
                                       ENCODINGTYPE ietEncoding,
                                       ULONG* pcbSize)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    FIXME("(%p)->(%d, %p) stub\n", This, ietEncoding, pcbSize);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeBody_GetDataHere(
                                  IMimeBody* iface,
                                  ENCODINGTYPE ietEncoding,
                                  IStream* pStream)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    FIXME("(%p)->(%d, %p) stub\n", This, ietEncoding, pStream);
    return E_NOTIMPL;
}
 
static const signed char base64_decode_table[] =
{
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x00 */
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x10 */
    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, /* 0x20 */
    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, /* 0x30 */
    -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, /* 0x40 */
    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, /* 0x50 */
    -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, /* 0x60 */
    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1  /* 0x70 */
};
 
static HRESULT decode_base64(IStream *input, IStream **ret_stream)
{
    const unsigned char *ptr, *end;
    unsigned char buf[1024];
    LARGE_INTEGER pos;
    unsigned char *ret;
    unsigned char in[4];
    IStream *output;
    DWORD size;
    int n = 0;
    HRESULT hres;
 
    pos.QuadPart = 0;
    hres = IStream_Seek(input, pos, STREAM_SEEK_SET, NULL);
    if(FAILED(hres))
        return hres;
 
    hres = CreateStreamOnHGlobal(NULL, TRUE, &output);
    if(FAILED(hres))
        return hres;
 
    while(1) {
        hres = IStream_Read(input, buf, sizeof(buf), &size);
        if(FAILED(hres) || !size)
            break;
 
        ptr = ret = buf;
        end = buf + size;
 
        while(1) {
            /* skip invalid chars */
            while(ptr < end && (*ptr >= ARRAY_SIZE(base64_decode_table)
                                || base64_decode_table[*ptr] == -1))
                ptr++;
            if(ptr == end)
                break;
 
            in[n++] = base64_decode_table[*ptr++];
            switch(n) {
            case 2:
                *ret++ = in[0] << 2 | in[1] >> 4;
                continue;
            case 3:
                *ret++ = in[1] << 4 | in[2] >> 2;
                continue;
            case 4:
                *ret++ = ((in[2] << 6) & 0xc0) | in[3];
                n = 0;
            }
        }
 
        if(ret > buf) {
            hres = IStream_Write(output, buf, ret - buf, NULL);
            if(FAILED(hres))
                break;
        }
    }
 
    if(SUCCEEDED(hres))
        hres = IStream_Seek(output, pos, STREAM_SEEK_SET, NULL);
    if(FAILED(hres)) {
        IStream_Release(output);
        return hres;
    }
 
    *ret_stream = output;
    return S_OK;
}
 
static int hex_digit(char c)
{
    if('0' <= c && c <= '9')
        return c - '0';
    if('A' <= c && c <= 'F')
        return c - 'A' + 10;
    if('a' <= c && c <= 'f')
        return c - 'a' + 10;
    return -1;
}
 
static HRESULT decode_qp(IStream *input, IStream **ret_stream)
{
    const unsigned char *ptr, *end;
    unsigned char *ret, prev = 0;
    unsigned char buf[1024];
    LARGE_INTEGER pos;
    IStream *output;
    DWORD size;
    int n = -1;
    HRESULT hres;
 
    pos.QuadPart = 0;
    hres = IStream_Seek(input, pos, STREAM_SEEK_SET, NULL);
    if(FAILED(hres))
        return hres;
 
    hres = CreateStreamOnHGlobal(NULL, TRUE, &output);
    if(FAILED(hres))
        return hres;
 
    while(1) {
        hres = IStream_Read(input, buf, sizeof(buf), &size);
        if(FAILED(hres) || !size)
            break;
 
        ptr = ret = buf;
        end = buf + size;
 
        while(ptr < end) {
            unsigned char byte = *ptr++;
 
            switch(n) {
            case -1:
                if(byte == '=')
                    n = 0;
                else
                    *ret++ = byte;
                continue;
            case 0:
                prev = byte;
                n = 1;
                continue;
            case 1:
                if(prev != '\r' || byte != '\n') {
                    int h1 = hex_digit(prev), h2 = hex_digit(byte);
                    if(h1 != -1 && h2 != -1)
                        *ret++ = (h1 << 4) | h2;
                    else
                        *ret++ = '=';
                }
                n = -1;
                continue;
            }
        }
 
        if(ret > buf) {
            hres = IStream_Write(output, buf, ret - buf, NULL);
            if(FAILED(hres))
                break;
        }
    }
 
    if(SUCCEEDED(hres))
        hres = IStream_Seek(output, pos, STREAM_SEEK_SET, NULL);
    if(FAILED(hres)) {
        IStream_Release(output);
        return hres;
    }
 
    *ret_stream = output;
    return S_OK;
}
 
static HRESULT WINAPI MimeBody_GetData(
                              IMimeBody* iface,
                              ENCODINGTYPE ietEncoding,
                              IStream** ppStream)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    ULARGE_INTEGER start, size;
    HRESULT hres;
 
    TRACE("(%p)->(%d %p)\n", This, ietEncoding, ppStream);
 
    if(This->encoding != ietEncoding) {
        switch(This->encoding) {
        case IET_BASE64:
            hres = decode_base64(This->data, ppStream);
            break;
        case IET_QP:
            hres = decode_qp(This->data, ppStream);
            break;
        default:
            FIXME("Decoding %d is not supported.\n", This->encoding);
            hres = S_FALSE;
        }
        if(ietEncoding != IET_BINARY)
            FIXME("Encoding %d is not supported.\n", ietEncoding);
        if(hres != S_FALSE)
            return hres;
    }
 
    start.QuadPart = 0;
    hres = get_stream_size(This->data, &size);
    if(SUCCEEDED(hres))
        hres = create_sub_stream(This->data, start, size, ppStream);
    return hres;
}
 
static HRESULT WINAPI MimeBody_SetData(
                              IMimeBody* iface,
                              ENCODINGTYPE ietEncoding,
                              LPCSTR pszPriType,
                              LPCSTR pszSubType,
                              REFIID riid,
                              LPVOID pvObject)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    TRACE("(%p)->(%d, %s, %s, %s %p)\n", This, ietEncoding, debugstr_a(pszPriType), debugstr_a(pszSubType),
          debugstr_guid(riid), pvObject);
 
    if(IsEqualIID(riid, &IID_IStream))
        IStream_AddRef((IStream *)pvObject);
    else
    {
        FIXME("Unhandled object type %s\n", debugstr_guid(riid));
        return E_INVALIDARG;
    }
 
    if(This->data)
        release_data(&This->data_iid, This->data);
 
    This->data_iid = *riid;
    This->data = pvObject;
 
    IMimeBody_SetCurrentEncoding(iface, ietEncoding);
 
    /* FIXME: Update the content type.
       If pszPriType == NULL use 'application'
       If pszSubType == NULL use 'octet-stream' */
 
    return S_OK;
}
 
static HRESULT WINAPI MimeBody_EmptyData(
                                IMimeBody* iface)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    FIXME("(%p)->() stub\n", This);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeBody_CopyTo(
                             IMimeBody* iface,
                             IMimeBody* pBody)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    FIXME("(%p)->(%p) stub\n", This, pBody);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeBody_GetTransmitInfo(
                                      IMimeBody* iface,
                                      LPTRANSMITINFO pTransmitInfo)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    FIXME("(%p)->(%p) stub\n", This, pTransmitInfo);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeBody_SaveToFile(
                                 IMimeBody* iface,
                                 ENCODINGTYPE ietEncoding,
                                 LPCSTR pszFilePath)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    FIXME("(%p)->(%d, %s) stub\n", This, ietEncoding, debugstr_a(pszFilePath));
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeBody_GetHandle(
                                IMimeBody* iface,
                                LPHBODY phBody)
{
    MimeBody *This = impl_from_IMimeBody(iface);
    TRACE("(%p)->(%p)\n", iface, phBody);
 
    if(!phBody)
        return E_INVALIDARG;
 
    *phBody = This->handle;
    return This->handle ? S_OK : MIME_E_NO_DATA;
}
 
static IMimeBodyVtbl body_vtbl =
{
    MimeBody_QueryInterface,
    MimeBody_AddRef,
    MimeBody_Release,
    MimeBody_GetClassID,
    MimeBody_IsDirty,
    MimeBody_Load,
    MimeBody_Save,
    MimeBody_GetSizeMax,
    MimeBody_InitNew,
    MimeBody_GetPropInfo,
    MimeBody_SetPropInfo,
    MimeBody_GetProp,
    MimeBody_SetProp,
    MimeBody_AppendProp,
    MimeBody_DeleteProp,
    MimeBody_CopyProps,
    MimeBody_MoveProps,
    MimeBody_DeleteExcept,
    MimeBody_QueryProp,
    MimeBody_GetCharset,
    MimeBody_SetCharset,
    MimeBody_GetParameters,
    MimeBody_IsContentType,
    MimeBody_BindToObject,
    MimeBody_Clone,
    MimeBody_SetOption,
    MimeBody_GetOption,
    MimeBody_EnumProps,
    MimeBody_IsType,
    MimeBody_SetDisplayName,
    MimeBody_GetDisplayName,
    MimeBody_GetOffsets,
    MimeBody_GetCurrentEncoding,
    MimeBody_SetCurrentEncoding,
    MimeBody_GetEstimatedSize,
    MimeBody_GetDataHere,
    MimeBody_GetData,
    MimeBody_SetData,
    MimeBody_EmptyData,
    MimeBody_CopyTo,
    MimeBody_GetTransmitInfo,
    MimeBody_SaveToFile,
    MimeBody_GetHandle
};
 
static HRESULT MimeBody_set_offsets(MimeBody *body, const BODYOFFSETS *offsets)
{
    TRACE("setting offsets to %d, %d, %d, %d\n", offsets->cbBoundaryStart,
          offsets->cbHeaderStart, offsets->cbBodyStart, offsets->cbBodyEnd);
 
    body->body_offsets = *offsets;
    return S_OK;
}
 
#define FIRST_CUSTOM_PROP_ID 0x100
 
static MimeBody *mimebody_create(void)
{
    MimeBody *This;
    BODYOFFSETS body_offsets;
 
    This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
    if (!This)
        return NULL;
 
    This->IMimeBody_iface.lpVtbl = &body_vtbl;
    This->ref = 1;
    This->handle = NULL;
    list_init(&This->headers);
    list_init(&This->new_props);
    This->next_prop_id = FIRST_CUSTOM_PROP_ID;
    This->content_pri_type = NULL;
    This->content_sub_type = NULL;
    This->encoding = IET_7BIT;
    This->data = NULL;
    This->data_iid = IID_NULL;
 
    body_offsets.cbBoundaryStart = body_offsets.cbHeaderStart = 0;
    body_offsets.cbBodyStart     = body_offsets.cbBodyEnd     = 0;
    MimeBody_set_offsets(This, &body_offsets);
 
    return This;
}
 
HRESULT MimeBody_create(IUnknown *outer, void **ppv)
{
    MimeBody *mb;
 
    if(outer)
        return CLASS_E_NOAGGREGATION;
 
    if ((mb = mimebody_create()))
    {
        *ppv = &mb->IMimeBody_iface;
        return S_OK;
    }
    else
    {
        *ppv = NULL;
        return E_OUTOFMEMORY;
    }
}
 
typedef struct body_t
{
    struct list entry;
    DWORD index;
    MimeBody *mime_body;
 
    struct body_t *parent;
    struct list children;
} body_t;
 
typedef struct MimeMessage
{
    IMimeMessage IMimeMessage_iface;
    LONG ref;
    IStream *stream;
 
    struct list body_tree;
    DWORD next_index;
} MimeMessage;
 
static inline MimeMessage *impl_from_IMimeMessage(IMimeMessage *iface)
{
    return CONTAINING_RECORD(iface, MimeMessage, IMimeMessage_iface);
}
 
static HRESULT WINAPI MimeMessage_QueryInterface(IMimeMessage *iface, REFIID riid, void **ppv)
{
    TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 
    if (IsEqualIID(riid, &IID_IUnknown) ||
        IsEqualIID(riid, &IID_IPersist) ||
        IsEqualIID(riid, &IID_IPersistStreamInit) ||
        IsEqualIID(riid, &IID_IMimeMessageTree) ||
        IsEqualIID(riid, &IID_IMimeMessage))
    {
        *ppv = iface;
        IMimeMessage_AddRef(iface);
        return S_OK;
    }
 
    FIXME("no interface for %s\n", debugstr_guid(riid));
    *ppv = NULL;
    return E_NOINTERFACE;
}
 
static ULONG WINAPI MimeMessage_AddRef(IMimeMessage *iface)
{
    MimeMessage *This = impl_from_IMimeMessage(iface);
    ULONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p) ref=%d\n", This, ref);
 
    return ref;
}
 
static void empty_body_list(struct list *list)
{
    body_t *body, *cursor2;
    LIST_FOR_EACH_ENTRY_SAFE(body, cursor2, list, body_t, entry)
    {
        empty_body_list(&body->children);
        list_remove(&body->entry);
        IMimeBody_Release(&body->mime_body->IMimeBody_iface);
        HeapFree(GetProcessHeap(), 0, body);
    }
}
 
static ULONG WINAPI MimeMessage_Release(IMimeMessage *iface)
{
    MimeMessage *This = impl_from_IMimeMessage(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p) ref=%d\n", This, ref);
 
    if (!ref)
    {
        empty_body_list(&This->body_tree);
 
        if(This->stream) IStream_Release(This->stream);
        HeapFree(GetProcessHeap(), 0, This);
    }
 
    return ref;
}
 
/*** IPersist methods ***/
static HRESULT WINAPI MimeMessage_GetClassID(
    IMimeMessage *iface,
    CLSID *pClassID)
{
    FIXME("(%p)->(%p)\n", iface, pClassID);
    return E_NOTIMPL;
}
 
/*** IPersistStreamInit methods ***/
static HRESULT WINAPI MimeMessage_IsDirty(
    IMimeMessage *iface)
{
    FIXME("(%p)->()\n", iface);
    return E_NOTIMPL;
}
 
static body_t *new_body_entry(MimeBody *mime_body, DWORD index, body_t *parent)
{
    body_t *body = HeapAlloc(GetProcessHeap(), 0, sizeof(*body));
    if(body)
    {
        body->mime_body = mime_body;
        body->index = index;
        list_init(&body->children);
        body->parent = parent;
 
        mime_body->handle = UlongToHandle(body->index);
    }
    return body;
}
 
typedef struct
{
    struct list entry;
    BODYOFFSETS offsets;
} offset_entry_t;
 
static HRESULT create_body_offset_list(IStream *stm, const char *boundary, struct list *body_offsets)
{
    HRESULT hr;
    DWORD read, boundary_start;
    int boundary_len = strlen(boundary);
    char *buf, *ptr, *overlap;
    DWORD start = 0, overlap_no;
    offset_entry_t *cur_body = NULL;
    BOOL is_first_line = TRUE;
    ULARGE_INTEGER cur;
    LARGE_INTEGER zero;
 
    list_init(body_offsets);
 
    overlap_no = boundary_len + 5;
 
    overlap = buf = HeapAlloc(GetProcessHeap(), 0, overlap_no + PARSER_BUF_SIZE + 1);
 
    zero.QuadPart = 0;
    hr = IStream_Seek(stm, zero, STREAM_SEEK_CUR, &cur);
    start = cur.u.LowPart;
 
    do {
        hr = IStream_Read(stm, overlap, PARSER_BUF_SIZE, &read);
        if(FAILED(hr)) goto end;
        if(read == 0) break;
        overlap[read] = '\0';
 
        ptr = buf;
        while(1) {
            if(is_first_line) {
                is_first_line = FALSE;
            }else {
                ptr = strstr(ptr, "\r\n");
                if(!ptr)
                    break;
                ptr += 2;
            }
 
            boundary_start = start + ptr - buf;
 
            if(*ptr == '-' && *(ptr + 1) == '-' && !memcmp(ptr + 2, boundary, boundary_len)) {
                ptr += boundary_len + 2;
 
                if(*ptr == '\r' && *(ptr + 1) == '\n')
                {
                    ptr += 2;
                    if(cur_body)
                    {
                        cur_body->offsets.cbBodyEnd = boundary_start - 2;
                        list_add_tail(body_offsets, &cur_body->entry);
                    }
                    cur_body = HeapAlloc(GetProcessHeap(), 0, sizeof(*cur_body));
                    cur_body->offsets.cbBoundaryStart = boundary_start;
                    cur_body->offsets.cbHeaderStart = start + ptr - buf;
                }
                else if(*ptr == '-' && *(ptr + 1) == '-')
                {
                    if(cur_body)
                    {
                        cur_body->offsets.cbBodyEnd = boundary_start - 2;
                        list_add_tail(body_offsets, &cur_body->entry);
                        goto end;
                    }
                }
            }
        }
 
        if(overlap == buf) /* 1st iteration */
        {
            memmove(buf, buf + PARSER_BUF_SIZE - overlap_no, overlap_no);
            overlap = buf + overlap_no;
            start += read - overlap_no;
        }
        else
        {
            memmove(buf, buf + PARSER_BUF_SIZE, overlap_no);
            start += read;
        }
    } while(1);
 
end:
    HeapFree(GetProcessHeap(), 0, buf);
    return hr;
}
 
static body_t *create_sub_body(MimeMessage *msg, IStream *pStm, BODYOFFSETS *offset, body_t *parent)
{
    ULARGE_INTEGER start, length;
    MimeBody *mime_body;
    HRESULT hr;
    body_t *body;
    LARGE_INTEGER pos;
 
    pos.QuadPart = offset->cbHeaderStart;
    IStream_Seek(pStm, pos, STREAM_SEEK_SET, NULL);
 
    mime_body = mimebody_create();
    IMimeBody_Load(&mime_body->IMimeBody_iface, pStm);
 
    pos.QuadPart = 0;
    hr = IStream_Seek(pStm, pos, STREAM_SEEK_CUR, &start);
    offset->cbBodyStart = start.QuadPart;
    if (parent) MimeBody_set_offsets(mime_body, offset);
 
    length.QuadPart = offset->cbBodyEnd - offset->cbBodyStart;
    create_sub_stream(pStm, start, length, (IStream**)&mime_body->data);
    mime_body->data_iid = IID_IStream;
 
    body = new_body_entry(mime_body, msg->next_index++, parent);
 
    if(IMimeBody_IsContentType(&mime_body->IMimeBody_iface, "multipart", NULL) == S_OK)
    {
        MIMEPARAMINFO *param_info;
        ULONG count, i;
        IMimeAllocator *alloc;
 
        hr = IMimeBody_GetParameters(&mime_body->IMimeBody_iface, "Content-Type", &count,
                &param_info);
        if(hr != S_OK || count == 0) return body;
 
        MimeOleGetAllocator(&alloc);
 
        for(i = 0; i < count; i++)
        {
            if(!lstrcmpiA(param_info[i].pszName, "boundary"))
            {
                struct list offset_list;
                offset_entry_t *cur, *cursor2;
                hr = create_body_offset_list(pStm, param_info[i].pszData, &offset_list);
                LIST_FOR_EACH_ENTRY_SAFE(cur, cursor2, &offset_list, offset_entry_t, entry)
                {
                    body_t *sub_body;
 
                    sub_body = create_sub_body(msg, pStm, &cur->offsets, body);
                    list_add_tail(&body->children, &sub_body->entry);
                    list_remove(&cur->entry);
                    HeapFree(GetProcessHeap(), 0, cur);
                }
                break;
            }
        }
        IMimeAllocator_FreeParamInfoArray(alloc, count, param_info, TRUE);
        IMimeAllocator_Release(alloc);
    }
    return body;
}
 
static HRESULT WINAPI MimeMessage_Load(IMimeMessage *iface, IStream *pStm)
{
    MimeMessage *This = impl_from_IMimeMessage(iface);
    body_t *root_body;
    BODYOFFSETS offsets;
    ULARGE_INTEGER cur;
    LARGE_INTEGER zero;
 
    TRACE("(%p)->(%p)\n", iface, pStm);
 
    if(This->stream)
    {
        FIXME("already loaded a message\n");
        return E_FAIL;
    }
 
    empty_body_list(&This->body_tree);
 
    IStream_AddRef(pStm);
    This->stream = pStm;
    offsets.cbBoundaryStart = offsets.cbHeaderStart = 0;
    offsets.cbBodyStart = offsets.cbBodyEnd = 0;
 
    root_body = create_sub_body(This, pStm, &offsets, NULL);
 
    zero.QuadPart = 0;
    IStream_Seek(pStm, zero, STREAM_SEEK_END, &cur);
    offsets.cbBodyEnd = cur.u.LowPart;
    MimeBody_set_offsets(root_body->mime_body, &offsets);
 
    list_add_head(&This->body_tree, &root_body->entry);
 
    return S_OK;
}
 
static HRESULT WINAPI MimeMessage_Save(IMimeMessage *iface, IStream *pStm, BOOL fClearDirty)
{
    FIXME("(%p)->(%p, %s)\n", iface, pStm, fClearDirty ? "TRUE" : "FALSE");
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_GetSizeMax(
    IMimeMessage *iface,
    ULARGE_INTEGER *pcbSize)
{
    FIXME("(%p)->(%p)\n", iface, pcbSize);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_InitNew(
    IMimeMessage *iface)
{
    FIXME("(%p)->()\n", iface);
    return E_NOTIMPL;
}
 
/*** IMimeMessageTree methods ***/
static HRESULT WINAPI MimeMessage_GetMessageSource(IMimeMessage *iface, IStream **ppStream,
        DWORD dwFlags)
{
    MimeMessage *This = impl_from_IMimeMessage(iface);
 
    FIXME("(%p)->(%p, 0x%x)\n", iface, ppStream, dwFlags);
 
    IStream_AddRef(This->stream);
    *ppStream = This->stream;
    return S_OK;
}
 
static HRESULT WINAPI MimeMessage_GetMessageSize(
    IMimeMessage *iface,
    ULONG *pcbSize,
    DWORD dwFlags)
{
    FIXME("(%p)->(%p, 0x%x)\n", iface, pcbSize, dwFlags);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_LoadOffsetTable(
    IMimeMessage *iface,
    IStream *pStream)
{
    FIXME("(%p)->(%p)\n", iface, pStream);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_SaveOffsetTable(
    IMimeMessage *iface,
    IStream *pStream,
    DWORD dwFlags)
{
    FIXME("(%p)->(%p, 0x%x)\n", iface, pStream, dwFlags);
    return E_NOTIMPL;
}
 
 
static HRESULT WINAPI MimeMessage_GetFlags(
    IMimeMessage *iface,
    DWORD *pdwFlags)
{
    FIXME("(%p)->(%p)\n", iface, pdwFlags);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_Commit(
    IMimeMessage *iface,
    DWORD dwFlags)
{
    FIXME("(%p)->(0x%x)\n", iface, dwFlags);
    return S_OK;
}
 
 
static HRESULT WINAPI MimeMessage_HandsOffStorage(
    IMimeMessage *iface)
{
    FIXME("(%p)->()\n", iface);
    return E_NOTIMPL;
}
 
static HRESULT find_body(struct list *list, HBODY hbody, body_t **body)
{
    body_t *cur;
    HRESULT hr;
 
    if(hbody == HBODY_ROOT)
    {
        *body = LIST_ENTRY(list_head(list), body_t, entry);
        return S_OK;
    }
 
    LIST_FOR_EACH_ENTRY(cur, list, body_t, entry)
    {
        if(cur->index == HandleToUlong(hbody))
        {
            *body = cur;
            return S_OK;
        }
        hr = find_body(&cur->children, hbody, body);
        if(hr == S_OK) return S_OK;
    }
    return S_FALSE;
}
 
static HRESULT WINAPI MimeMessage_BindToObject(IMimeMessage *iface, const HBODY hBody, REFIID riid,
        void **ppvObject)
{
    MimeMessage *This = impl_from_IMimeMessage(iface);
    HRESULT hr;
    body_t *body;
 
    TRACE("(%p)->(%p, %s, %p)\n", iface, hBody, debugstr_guid(riid), ppvObject);
 
    hr = find_body(&This->body_tree, hBody, &body);
 
    if(hr != S_OK) return hr;
 
    if(IsEqualIID(riid, &IID_IMimeBody))
    {
        IMimeBody_AddRef(&body->mime_body->IMimeBody_iface);
        *ppvObject = &body->mime_body->IMimeBody_iface;
        return S_OK;
    }
 
    return E_NOINTERFACE;
}
 
static HRESULT WINAPI MimeMessage_SaveBody(
    IMimeMessage *iface,
    HBODY hBody,
    DWORD dwFlags,
    IStream *pStream)
{
    FIXME("(%p)->(%p, 0x%x, %p)\n", iface, hBody, dwFlags, pStream);
    return E_NOTIMPL;
}
 
static HRESULT get_body(MimeMessage *msg, BODYLOCATION location, HBODY pivot, body_t **out)
{
    body_t *root = LIST_ENTRY(list_head(&msg->body_tree), body_t, entry);
    body_t *body;
    HRESULT hr;
    struct list *list;
 
    if(location == IBL_ROOT)
    {
        *out = root;
        return S_OK;
    }
 
    hr = find_body(&msg->body_tree, pivot, &body);
 
    if(hr == S_OK)
    {
        switch(location)
        {
        case IBL_PARENT:
            if(body->parent)
                *out = body->parent;
            else
                hr = MIME_E_NOT_FOUND;
            break;
 
        case IBL_FIRST:
            list = list_head(&body->children);
            if(list)
                *out = LIST_ENTRY(list, body_t, entry);
            else
                hr = MIME_E_NOT_FOUND;
            break;
 
        case IBL_LAST:
            list = list_tail(&body->children);
            if(list)
                *out = LIST_ENTRY(list, body_t, entry);
            else
                hr = MIME_E_NOT_FOUND;
            break;
 
        case IBL_NEXT:
            list = list_next(&body->parent->children, &body->entry);
            if(list)
                *out = LIST_ENTRY(list, body_t, entry);
            else
                hr = MIME_E_NOT_FOUND;
            break;
 
        case IBL_PREVIOUS:
            list = list_prev(&body->parent->children, &body->entry);
            if(list)
                *out = LIST_ENTRY(list, body_t, entry);
            else
                hr = MIME_E_NOT_FOUND;
            break;
 
        default:
            hr = E_FAIL;
            break;
        }
    }
 
    return hr;
}
 
 
static HRESULT WINAPI MimeMessage_InsertBody(
    IMimeMessage *iface,
    BODYLOCATION location,
    HBODY hPivot,
    LPHBODY phBody)
{
    FIXME("(%p)->(%d, %p, %p)\n", iface, location, hPivot, phBody);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_GetBody(IMimeMessage *iface, BODYLOCATION location, HBODY hPivot,
        HBODY *phBody)
{
    MimeMessage *This = impl_from_IMimeMessage(iface);
    body_t *body;
    HRESULT hr;
 
    TRACE("(%p)->(%d, %p, %p)\n", iface, location, hPivot, phBody);
 
    if(!phBody)
        return E_INVALIDARG;
 
    *phBody = NULL;
 
    hr = get_body(This, location, hPivot, &body);
 
    if(hr == S_OK) *phBody = UlongToHandle(body->index);
 
    return hr;
}
 
static HRESULT WINAPI MimeMessage_DeleteBody(
    IMimeMessage *iface,
    HBODY hBody,
    DWORD dwFlags)
{
    FIXME("(%p)->(%p, %08x)\n", iface, hBody, dwFlags);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_MoveBody(
    IMimeMessage *iface,
    HBODY hBody,
    BODYLOCATION location)
{
    FIXME("(%p)->(%d)\n", iface, location);
    return E_NOTIMPL;
}
 
static void count_children(body_t *body, boolean recurse, ULONG *count)
{
    body_t *child;
 
    LIST_FOR_EACH_ENTRY(child, &body->children, body_t, entry)
    {
        (*count)++;
        if(recurse) count_children(child, recurse, count);
    }
}
 
static HRESULT WINAPI MimeMessage_CountBodies(IMimeMessage *iface, HBODY hParent, boolean fRecurse,
        ULONG *pcBodies)
{
    HRESULT hr;
    MimeMessage *This = impl_from_IMimeMessage(iface);
    body_t *body;
 
    TRACE("(%p)->(%p, %s, %p)\n", iface, hParent, fRecurse ? "TRUE" : "FALSE", pcBodies);
 
    hr = find_body(&This->body_tree, hParent, &body);
    if(hr != S_OK) return hr;
 
    *pcBodies = 1;
    count_children(body, fRecurse, pcBodies);
 
    return S_OK;
}
 
static HRESULT find_next(MimeMessage *This, body_t *body, FINDBODY *find, HBODY *out)
{
    struct list *ptr;
    HBODY next;
 
    for (;;)
    {
        if (!body) ptr = list_head( &This->body_tree );
        else
        {
            ptr = list_head( &body->children );
            while (!ptr)
            {
                if (!body->parent) return MIME_E_NOT_FOUND;
                if (!(ptr = list_next( &body->parent->children, &body->entry ))) body = body->parent;
            }
        }
 
        body = LIST_ENTRY( ptr, body_t, entry );
        next = UlongToHandle( body->index );
        find->dwReserved = body->index;
        if (IMimeBody_IsContentType(&body->mime_body->IMimeBody_iface, find->pszPriType,
                    find->pszSubType) == S_OK)
        {
            *out = next;
            return S_OK;
        }
    }
    return MIME_E_NOT_FOUND;
}
 
static HRESULT WINAPI MimeMessage_FindFirst(IMimeMessage *iface, FINDBODY *pFindBody, HBODY *phBody)
{
    MimeMessage *This = impl_from_IMimeMessage(iface);
 
    TRACE("(%p)->(%p, %p)\n", iface, pFindBody, phBody);
 
    pFindBody->dwReserved = 0;
    return find_next(This, NULL, pFindBody, phBody);
}
 
static HRESULT WINAPI MimeMessage_FindNext(IMimeMessage *iface, FINDBODY *pFindBody, HBODY *phBody)
{
    MimeMessage *This = impl_from_IMimeMessage(iface);
    body_t *body;
    HRESULT hr;
 
    TRACE("(%p)->(%p, %p)\n", iface, pFindBody, phBody);
 
    hr = find_body( &This->body_tree, UlongToHandle( pFindBody->dwReserved ), &body );
    if (hr != S_OK) return MIME_E_NOT_FOUND;
    return find_next(This, body, pFindBody, phBody);
}
 
static HRESULT WINAPI MimeMessage_ResolveURL(
    IMimeMessage *iface,
    HBODY hRelated,
    LPCSTR pszBase,
    LPCSTR pszURL,
    DWORD dwFlags,
    LPHBODY phBody)
{
    FIXME("(%p)->(%p, %s, %s, 0x%x, %p)\n", iface, hRelated, pszBase, pszURL, dwFlags, phBody);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_ToMultipart(
    IMimeMessage *iface,
    HBODY hBody,
    LPCSTR pszSubType,
    LPHBODY phMultipart)
{
    FIXME("(%p)->(%p, %s, %p)\n", iface, hBody, pszSubType, phMultipart);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_GetBodyOffsets(
    IMimeMessage *iface,
    HBODY hBody,
    LPBODYOFFSETS pOffsets)
{
    FIXME("(%p)->(%p, %p)\n", iface, hBody, pOffsets);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_GetCharset(
    IMimeMessage *iface,
    LPHCHARSET phCharset)
{
    FIXME("(%p)->(%p)\n", iface, phCharset);
    *phCharset = NULL;
    return S_OK;
}
 
static HRESULT WINAPI MimeMessage_SetCharset(
    IMimeMessage *iface,
    HCHARSET hCharset,
    CSETAPPLYTYPE applytype)
{
    FIXME("(%p)->(%p, %d)\n", iface, hCharset, applytype);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_IsBodyType(
    IMimeMessage *iface,
    HBODY hBody,
    IMSGBODYTYPE bodytype)
{
    HRESULT hr;
    IMimeBody *mime_body;
    TRACE("(%p)->(%p, %d)\n", iface, hBody, bodytype);
 
    hr = IMimeMessage_BindToObject(iface, hBody, &IID_IMimeBody, (void**)&mime_body);
    if(hr != S_OK) return hr;
 
    hr = IMimeBody_IsType(mime_body, bodytype);
    MimeBody_Release(mime_body);
    return hr;
}
 
static HRESULT WINAPI MimeMessage_IsContentType(
    IMimeMessage *iface,
    HBODY hBody,
    LPCSTR pszPriType,
    LPCSTR pszSubType)
{
    HRESULT hr;
    IMimeBody *mime_body;
    TRACE("(%p)->(%p, %s, %s)\n", iface, hBody, debugstr_a(pszPriType),
          debugstr_a(pszSubType));
 
    hr = IMimeMessage_BindToObject(iface, hBody, &IID_IMimeBody, (void**)&mime_body);
    if(FAILED(hr)) return hr;
 
    hr = IMimeBody_IsContentType(mime_body, pszPriType, pszSubType);
    IMimeBody_Release(mime_body);
    return hr;
}
 
static HRESULT WINAPI MimeMessage_QueryBodyProp(
    IMimeMessage *iface,
    HBODY hBody,
    LPCSTR pszName,
    LPCSTR pszCriteria,
    boolean fSubString,
    boolean fCaseSensitive)
{
    FIXME("(%p)->(%p, %s, %s, %s, %s)\n", iface, hBody, pszName, pszCriteria, fSubString ? "TRUE" : "FALSE", fCaseSensitive ? "TRUE" : "FALSE");
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_GetBodyProp(
    IMimeMessage *iface,
    HBODY hBody,
    LPCSTR pszName,
    DWORD dwFlags,
    LPPROPVARIANT pValue)
{
    HRESULT hr;
    IMimeBody *mime_body;
 
    TRACE("(%p)->(%p, %s, 0x%x, %p)\n", iface, hBody, pszName, dwFlags, pValue);
 
    hr = IMimeMessage_BindToObject(iface, hBody, &IID_IMimeBody, (void**)&mime_body);
    if(hr != S_OK) return hr;
 
    hr = IMimeBody_GetProp(mime_body, pszName, dwFlags, pValue);
    IMimeBody_Release(mime_body);
 
    return hr;
}
 
static HRESULT WINAPI MimeMessage_SetBodyProp(
    IMimeMessage *iface,
    HBODY hBody,
    LPCSTR pszName,
    DWORD dwFlags,
    LPCPROPVARIANT pValue)
{
    FIXME("(%p)->(%p, %s, 0x%x, %p)\n", iface, hBody, pszName, dwFlags, pValue);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_DeleteBodyProp(
    IMimeMessage *iface,
    HBODY hBody,
    LPCSTR pszName)
{
    FIXME("(%p)->(%p, %s)\n", iface, hBody, pszName);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_SetOption(
    IMimeMessage *iface,
    const TYPEDID oid,
    LPCPROPVARIANT pValue)
{
    HRESULT hr = S_OK;
    TRACE("(%p)->(%08x, %p)\n", iface, oid, pValue);
 
    /* Message ID is checked before type.
     *  OID 0x4D -> 0x56 and 0x58 aren't defined but will filtered out later.
     */
    if(TYPEDID_ID(oid) < TYPEDID_ID(OID_ALLOW_8BIT_HEADER) || TYPEDID_ID(oid) > TYPEDID_ID(OID_SECURITY_2KEY_CERT_BAG_64))
    {
        WARN("oid (%08x) out of range\n", oid);
        return MIME_E_INVALID_OPTION_ID;
    }
 
    if(pValue->vt != TYPEDID_TYPE(oid))
    {
        WARN("Called with vartype %04x and oid %08x\n", pValue->vt, oid);
        return S_OK;
    }
 
    switch(oid)
    {
    case OID_HIDE_TNEF_ATTACHMENTS:
        FIXME("OID_HIDE_TNEF_ATTACHMENTS (value %d): ignoring\n", pValue->u.boolVal);
        break;
    case OID_SHOW_MACBINARY:
        FIXME("OID_SHOW_MACBINARY (value %d): ignoring\n", pValue->u.boolVal);
        break;
    case OID_SAVEBODY_KEEPBOUNDARY:
        FIXME("OID_SAVEBODY_KEEPBOUNDARY (value %d): ignoring\n", pValue->u.boolVal);
        break;
    case OID_CLEANUP_TREE_ON_SAVE:
        FIXME("OID_CLEANUP_TREE_ON_SAVE (value %d): ignoring\n", pValue->u.boolVal);
        break;
    default:
        FIXME("Unhandled oid %08x\n", oid);
        hr = MIME_E_INVALID_OPTION_ID;
    }
 
    return hr;
}
 
static HRESULT WINAPI MimeMessage_GetOption(
    IMimeMessage *iface,
    const TYPEDID oid,
    LPPROPVARIANT pValue)
{
    FIXME("(%p)->(%08x, %p)\n", iface, oid, pValue);
    return E_NOTIMPL;
}
 
/*** IMimeMessage methods ***/
static HRESULT WINAPI MimeMessage_CreateWebPage(
    IMimeMessage *iface,
    IStream *pRootStm,
    LPWEBPAGEOPTIONS pOptions,
    IMimeMessageCallback *pCallback,
    IMoniker **ppMoniker)
{
    FIXME("(%p)->(%p, %p, %p, %p)\n", iface, pRootStm, pOptions, pCallback, ppMoniker);
    *ppMoniker = NULL;
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_GetProp(
    IMimeMessage *iface,
    LPCSTR pszName,
    DWORD dwFlags,
    LPPROPVARIANT pValue)
{
    FIXME("(%p)->(%s, 0x%x, %p)\n", iface, pszName, dwFlags, pValue);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_SetProp(
    IMimeMessage *iface,
    LPCSTR pszName,
    DWORD dwFlags,
    LPCPROPVARIANT pValue)
{
    FIXME("(%p)->(%s, 0x%x, %p)\n", iface, pszName, dwFlags, pValue);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_DeleteProp(
    IMimeMessage *iface,
    LPCSTR pszName)
{
    FIXME("(%p)->(%s)\n", iface, pszName);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_QueryProp(
    IMimeMessage *iface,
    LPCSTR pszName,
    LPCSTR pszCriteria,
    boolean fSubString,
    boolean fCaseSensitive)
{
    FIXME("(%p)->(%s, %s, %s, %s)\n", iface, pszName, pszCriteria, fSubString ? "TRUE" : "FALSE", fCaseSensitive ? "TRUE" : "FALSE");
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_GetTextBody(
    IMimeMessage *iface,
    DWORD dwTxtType,
    ENCODINGTYPE ietEncoding,
    IStream **pStream,
    LPHBODY phBody)
{
    HRESULT hr;
    HBODY hbody;
    FINDBODY find_struct;
    IMimeBody *mime_body;
    static char text[] = "text";
    static char plain[] = "plain";
    static char html[] = "html";
 
    TRACE("(%p)->(%d, %d, %p, %p)\n", iface, dwTxtType, ietEncoding, pStream, phBody);
 
    find_struct.pszPriType = text;
 
    switch(dwTxtType)
    {
    case TXT_PLAIN:
        find_struct.pszSubType = plain;
        break;
    case TXT_HTML:
        find_struct.pszSubType = html;
        break;
    default:
        return MIME_E_INVALID_TEXT_TYPE;
    }
 
    hr = IMimeMessage_FindFirst(iface, &find_struct, &hbody);
    if(hr != S_OK)
    {
        TRACE("not found hr %08x\n", hr);
        *phBody = NULL;
        return hr;
    }
 
    IMimeMessage_BindToObject(iface, hbody, &IID_IMimeBody, (void**)&mime_body);
 
    IMimeBody_GetData(mime_body, ietEncoding, pStream);
    *phBody = hbody;
    IMimeBody_Release(mime_body);
    return hr;
}
 
static HRESULT WINAPI MimeMessage_SetTextBody(
    IMimeMessage *iface,
    DWORD dwTxtType,
    ENCODINGTYPE ietEncoding,
    HBODY hAlternative,
    IStream *pStream,
    LPHBODY phBody)
{
    FIXME("(%p)->(%d, %d, %p, %p, %p)\n", iface, dwTxtType, ietEncoding, hAlternative, pStream, phBody);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_AttachObject(
    IMimeMessage *iface,
    REFIID riid,
    void *pvObject,
    LPHBODY phBody)
{
    FIXME("(%p)->(%s, %p, %p)\n", iface, debugstr_guid(riid), pvObject, phBody);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_AttachFile(
    IMimeMessage *iface,
    LPCSTR pszFilePath,
    IStream *pstmFile,
    LPHBODY phBody)
{
    FIXME("(%p)->(%s, %p, %p)\n", iface, pszFilePath, pstmFile, phBody);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_AttachURL(
    IMimeMessage *iface,
    LPCSTR pszBase,
    LPCSTR pszURL,
    DWORD dwFlags,
    IStream *pstmURL,
    LPSTR *ppszCIDURL,
    LPHBODY phBody)
{
    FIXME("(%p)->(%s, %s, 0x%x, %p, %p, %p)\n", iface, pszBase, pszURL, dwFlags, pstmURL, ppszCIDURL, phBody);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_GetAttachments(
    IMimeMessage *iface,
    ULONG *pcAttach,
    LPHBODY *pprghAttach)
{
    HRESULT hr;
    FINDBODY find_struct;
    HBODY hbody;
    LPHBODY array;
    ULONG size = 10;
 
    TRACE("(%p)->(%p, %p)\n", iface, pcAttach, pprghAttach);
 
    *pcAttach = 0;
    array = CoTaskMemAlloc(size * sizeof(HBODY));
 
    find_struct.pszPriType = find_struct.pszSubType = NULL;
    hr = IMimeMessage_FindFirst(iface, &find_struct, &hbody);
    while(hr == S_OK)
    {
        hr = IMimeMessage_IsContentType(iface, hbody, "multipart", NULL);
        TRACE("IsCT rets %08x %d\n", hr, *pcAttach);
        if(hr != S_OK)
        {
            if(*pcAttach + 1 > size)
            {
                size *= 2;
                array = CoTaskMemRealloc(array, size * sizeof(HBODY));
            }
            array[*pcAttach] = hbody;
            (*pcAttach)++;
        }
        hr = IMimeMessage_FindNext(iface, &find_struct, &hbody);
    }
 
    *pprghAttach = array;
    return S_OK;
}
 
static HRESULT WINAPI MimeMessage_GetAddressTable(
    IMimeMessage *iface,
    IMimeAddressTable **ppTable)
{
    FIXME("(%p)->(%p)\n", iface, ppTable);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_GetSender(
    IMimeMessage *iface,
    LPADDRESSPROPS pAddress)
{
    FIXME("(%p)->(%p)\n", iface, pAddress);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_GetAddressTypes(
    IMimeMessage *iface,
    DWORD dwAdrTypes,
    DWORD dwProps,
    LPADDRESSLIST pList)
{
    FIXME("(%p)->(%d, %d, %p)\n", iface, dwAdrTypes, dwProps, pList);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_GetAddressFormat(
    IMimeMessage *iface,
    DWORD dwAdrTypes,
    ADDRESSFORMAT format,
    LPSTR *ppszFormat)
{
    FIXME("(%p)->(%d, %d, %p)\n", iface, dwAdrTypes, format, ppszFormat);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_EnumAddressTypes(
    IMimeMessage *iface,
    DWORD dwAdrTypes,
    DWORD dwProps,
    IMimeEnumAddressTypes **ppEnum)
{
    FIXME("(%p)->(%d, %d, %p)\n", iface, dwAdrTypes, dwProps, ppEnum);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_SplitMessage(
    IMimeMessage *iface,
    ULONG cbMaxPart,
    IMimeMessageParts **ppParts)
{
    FIXME("(%p)->(%d, %p)\n", iface, cbMaxPart, ppParts);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeMessage_GetRootMoniker(
    IMimeMessage *iface,
    IMoniker **ppMoniker)
{
    FIXME("(%p)->(%p)\n", iface, ppMoniker);
    return E_NOTIMPL;
}
 
static const IMimeMessageVtbl MimeMessageVtbl =
{
    MimeMessage_QueryInterface,
    MimeMessage_AddRef,
    MimeMessage_Release,
    MimeMessage_GetClassID,
    MimeMessage_IsDirty,
    MimeMessage_Load,
    MimeMessage_Save,
    MimeMessage_GetSizeMax,
    MimeMessage_InitNew,
    MimeMessage_GetMessageSource,
    MimeMessage_GetMessageSize,
    MimeMessage_LoadOffsetTable,
    MimeMessage_SaveOffsetTable,
    MimeMessage_GetFlags,
    MimeMessage_Commit,
    MimeMessage_HandsOffStorage,
    MimeMessage_BindToObject,
    MimeMessage_SaveBody,
    MimeMessage_InsertBody,
    MimeMessage_GetBody,
    MimeMessage_DeleteBody,
    MimeMessage_MoveBody,
    MimeMessage_CountBodies,
    MimeMessage_FindFirst,
    MimeMessage_FindNext,
    MimeMessage_ResolveURL,
    MimeMessage_ToMultipart,
    MimeMessage_GetBodyOffsets,
    MimeMessage_GetCharset,
    MimeMessage_SetCharset,
    MimeMessage_IsBodyType,
    MimeMessage_IsContentType,
    MimeMessage_QueryBodyProp,
    MimeMessage_GetBodyProp,
    MimeMessage_SetBodyProp,
    MimeMessage_DeleteBodyProp,
    MimeMessage_SetOption,
    MimeMessage_GetOption,
    MimeMessage_CreateWebPage,
    MimeMessage_GetProp,
    MimeMessage_SetProp,
    MimeMessage_DeleteProp,
    MimeMessage_QueryProp,
    MimeMessage_GetTextBody,
    MimeMessage_SetTextBody,
    MimeMessage_AttachObject,
    MimeMessage_AttachFile,
    MimeMessage_AttachURL,
    MimeMessage_GetAttachments,
    MimeMessage_GetAddressTable,
    MimeMessage_GetSender,
    MimeMessage_GetAddressTypes,
    MimeMessage_GetAddressFormat,
    MimeMessage_EnumAddressTypes,
    MimeMessage_SplitMessage,
    MimeMessage_GetRootMoniker,
};
 
HRESULT MimeMessage_create(IUnknown *outer, void **obj)
{
    MimeMessage *This;
    MimeBody *mime_body;
    body_t *root_body;
 
    TRACE("(%p, %p)\n", outer, obj);
 
    if (outer)
    {
        FIXME("outer unknown not supported yet\n");
        return E_NOTIMPL;
    }
 
    *obj = NULL;
 
    This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
    if (!This) return E_OUTOFMEMORY;
 
    This->IMimeMessage_iface.lpVtbl = &MimeMessageVtbl;
    This->ref = 1;
    This->stream = NULL;
    list_init(&This->body_tree);
    This->next_index = 1;
 
    mime_body = mimebody_create();
    root_body = new_body_entry(mime_body, This->next_index++, NULL);
    list_add_head(&This->body_tree, &root_body->entry);
 
    *obj = &This->IMimeMessage_iface;
    return S_OK;
}
 
/***********************************************************************
 *              MimeOleCreateMessage (INETCOMM.@)
 */
HRESULT WINAPI MimeOleCreateMessage(IUnknown *pUnkOuter, IMimeMessage **ppMessage)
{
    TRACE("(%p, %p)\n", pUnkOuter, ppMessage);
    return MimeMessage_create(NULL, (void **)ppMessage);
}
 
/***********************************************************************
 *              MimeOleSetCompatMode (INETCOMM.@)
 */
HRESULT WINAPI MimeOleSetCompatMode(DWORD dwMode)
{
    FIXME("(0x%x)\n", dwMode);
    return S_OK;
}
 
/***********************************************************************
 *              MimeOleCreateVirtualStream (INETCOMM.@)
 */
HRESULT WINAPI MimeOleCreateVirtualStream(IStream **ppStream)
{
    HRESULT hr;
    FIXME("(%p)\n", ppStream);
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, ppStream);
    return hr;
}
 
typedef struct MimeSecurity
{
    IMimeSecurity IMimeSecurity_iface;
    LONG ref;
} MimeSecurity;
 
static inline MimeSecurity *impl_from_IMimeSecurity(IMimeSecurity *iface)
{
    return CONTAINING_RECORD(iface, MimeSecurity, IMimeSecurity_iface);
}
 
static HRESULT WINAPI MimeSecurity_QueryInterface(IMimeSecurity *iface, REFIID riid, void **ppv)
{
    TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 
    if (IsEqualIID(riid, &IID_IUnknown) ||
        IsEqualIID(riid, &IID_IMimeSecurity))
    {
        *ppv = iface;
        IMimeSecurity_AddRef(iface);
        return S_OK;
    }
 
    FIXME("no interface for %s\n", debugstr_guid(riid));
    *ppv = NULL;
    return E_NOINTERFACE;
}
 
static ULONG WINAPI MimeSecurity_AddRef(IMimeSecurity *iface)
{
    MimeSecurity *This = impl_from_IMimeSecurity(iface);
    LONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p) ref=%d\n", This, ref);
 
    return ref;
}
 
static ULONG WINAPI MimeSecurity_Release(IMimeSecurity *iface)
{
    MimeSecurity *This = impl_from_IMimeSecurity(iface);
    LONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p) ref=%d\n", This, ref);
 
    if (!ref)
        HeapFree(GetProcessHeap(), 0, This);
 
    return ref;
}
 
static HRESULT WINAPI MimeSecurity_InitNew(
        IMimeSecurity* iface)
{
    FIXME("(%p)->(): stub\n", iface);
    return S_OK;
}
 
static HRESULT WINAPI MimeSecurity_CheckInit(
        IMimeSecurity* iface)
{
    FIXME("(%p)->(): stub\n", iface);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeSecurity_EncodeMessage(
        IMimeSecurity* iface,
        IMimeMessageTree* pTree,
        DWORD dwFlags)
{
    FIXME("(%p)->(%p, %08x): stub\n", iface, pTree, dwFlags);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeSecurity_EncodeBody(
        IMimeSecurity* iface,
        IMimeMessageTree* pTree,
        HBODY hEncodeRoot,
        DWORD dwFlags)
{
    FIXME("(%p)->(%p, %p, %08x): stub\n", iface, pTree, hEncodeRoot, dwFlags);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeSecurity_DecodeMessage(
        IMimeSecurity* iface,
        IMimeMessageTree* pTree,
        DWORD dwFlags)
{
    FIXME("(%p)->(%p, %08x): stub\n", iface, pTree, dwFlags);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeSecurity_DecodeBody(
        IMimeSecurity* iface,
        IMimeMessageTree* pTree,
        HBODY hDecodeRoot,
        DWORD dwFlags)
{
    FIXME("(%p)->(%p, %p, %08x): stub\n", iface, pTree, hDecodeRoot, dwFlags);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeSecurity_EnumCertificates(
        IMimeSecurity* iface,
        HCAPICERTSTORE hc,
        DWORD dwUsage,
        PCX509CERT pPrev,
        PCX509CERT* ppCert)
{
    FIXME("(%p)->(%p, %08x, %p, %p): stub\n", iface, hc, dwUsage, pPrev, ppCert);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeSecurity_GetCertificateName(
        IMimeSecurity* iface,
        const PCX509CERT pX509Cert,
        const CERTNAMETYPE cn,
        LPSTR* ppszName)
{
    FIXME("(%p)->(%p, %08x, %p): stub\n", iface, pX509Cert, cn, ppszName);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeSecurity_GetMessageType(
        IMimeSecurity* iface,
        const HWND hwndParent,
        IMimeBody* pBody,
        DWORD* pdwSecType)
{
    FIXME("(%p)->(%p, %p, %p): stub\n", iface, hwndParent, pBody, pdwSecType);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeSecurity_GetCertData(
        IMimeSecurity* iface,
        const PCX509CERT pX509Cert,
        const CERTDATAID dataid,
        LPPROPVARIANT pValue)
{
    FIXME("(%p)->(%p, %x, %p): stub\n", iface, pX509Cert, dataid, pValue);
    return E_NOTIMPL;
}
 
 
static const IMimeSecurityVtbl MimeSecurityVtbl =
{
    MimeSecurity_QueryInterface,
    MimeSecurity_AddRef,
    MimeSecurity_Release,
    MimeSecurity_InitNew,
    MimeSecurity_CheckInit,
    MimeSecurity_EncodeMessage,
    MimeSecurity_EncodeBody,
    MimeSecurity_DecodeMessage,
    MimeSecurity_DecodeBody,
    MimeSecurity_EnumCertificates,
    MimeSecurity_GetCertificateName,
    MimeSecurity_GetMessageType,
    MimeSecurity_GetCertData
};
 
HRESULT MimeSecurity_create(IUnknown *outer, void **obj)
{
    MimeSecurity *This;
 
    *obj = NULL;
 
    if (outer) return CLASS_E_NOAGGREGATION;
 
    This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
    if (!This) return E_OUTOFMEMORY;
 
    This->IMimeSecurity_iface.lpVtbl = &MimeSecurityVtbl;
    This->ref = 1;
 
    *obj = &This->IMimeSecurity_iface;
    return S_OK;
}
 
/***********************************************************************
 *              MimeOleCreateSecurity (INETCOMM.@)
 */
HRESULT WINAPI MimeOleCreateSecurity(IMimeSecurity **ppSecurity)
{
    return MimeSecurity_create(NULL, (void **)ppSecurity);
}
 
static HRESULT WINAPI MimeAlloc_QueryInterface(
        IMimeAllocator* iface,
        REFIID riid,
        void **obj)
{
    TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), obj);
 
    if (IsEqualIID(riid, &IID_IUnknown) ||
        IsEqualIID(riid, &IID_IMalloc) ||
        IsEqualIID(riid, &IID_IMimeAllocator))
    {
        *obj = iface;
        IMimeAllocator_AddRef(iface);
        return S_OK;
    }
 
    FIXME("no interface for %s\n", debugstr_guid(riid));
    *obj = NULL;
    return E_NOINTERFACE;
}
 
static ULONG WINAPI MimeAlloc_AddRef(
        IMimeAllocator* iface)
{
    return 2;
}
 
static ULONG WINAPI MimeAlloc_Release(
        IMimeAllocator* iface)
{
    return 1;
}
 
static LPVOID WINAPI MimeAlloc_Alloc(
        IMimeAllocator* iface,
        SIZE_T cb)
{
    return CoTaskMemAlloc(cb);
}
 
static LPVOID WINAPI MimeAlloc_Realloc(
        IMimeAllocator* iface,
        LPVOID pv,
        SIZE_T cb)
{
    return CoTaskMemRealloc(pv, cb);
}
 
static void WINAPI MimeAlloc_Free(
        IMimeAllocator* iface,
        LPVOID pv)
{
    CoTaskMemFree(pv);
}
 
static SIZE_T WINAPI MimeAlloc_GetSize(
        IMimeAllocator* iface,
        LPVOID pv)
{
    FIXME("stub\n");
    return 0;
}
 
static int WINAPI MimeAlloc_DidAlloc(
        IMimeAllocator* iface,
        LPVOID pv)
{
    FIXME("stub\n");
    return 0;
}
 
static void WINAPI MimeAlloc_HeapMinimize(
        IMimeAllocator* iface)
{
    FIXME("stub\n");
    return;
}
 
static HRESULT WINAPI MimeAlloc_FreeParamInfoArray(
        IMimeAllocator* iface,
        ULONG cParams,
        LPMIMEPARAMINFO prgParam,
        boolean fFreeArray)
{
    ULONG i;
    TRACE("(%p)->(%d, %p, %d)\n", iface, cParams, prgParam, fFreeArray);
 
    for(i = 0; i < cParams; i++)
    {
        IMimeAllocator_Free(iface, prgParam[i].pszName);
        IMimeAllocator_Free(iface, prgParam[i].pszData);
    }
    if(fFreeArray) IMimeAllocator_Free(iface, prgParam);
    return S_OK;
}
 
static HRESULT WINAPI MimeAlloc_FreeAddressList(
        IMimeAllocator* iface,
        LPADDRESSLIST pList)
{
    FIXME("stub\n");
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeAlloc_FreeAddressProps(
        IMimeAllocator* iface,
        LPADDRESSPROPS pAddress)
{
    FIXME("stub\n");
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeAlloc_ReleaseObjects(
        IMimeAllocator* iface,
        ULONG cObjects,
        IUnknown **prgpUnknown,
        boolean fFreeArray)
{
    FIXME("stub\n");
    return E_NOTIMPL;
}
 
 
static HRESULT WINAPI MimeAlloc_FreeEnumHeaderRowArray(
        IMimeAllocator* iface,
        ULONG cRows,
        LPENUMHEADERROW prgRow,
        boolean fFreeArray)
{
    FIXME("stub\n");
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeAlloc_FreeEnumPropertyArray(
        IMimeAllocator* iface,
        ULONG cProps,
        LPENUMPROPERTY prgProp,
        boolean fFreeArray)
{
    FIXME("stub\n");
    return E_NOTIMPL;
}
 
static HRESULT WINAPI MimeAlloc_FreeThumbprint(
        IMimeAllocator* iface,
        THUMBBLOB *pthumbprint)
{
    FIXME("stub\n");
    return E_NOTIMPL;
}
 
 
static HRESULT WINAPI MimeAlloc_PropVariantClear(
        IMimeAllocator* iface,
        LPPROPVARIANT pProp)
{
    FIXME("stub\n");
    return E_NOTIMPL;
}
 
static IMimeAllocatorVtbl mime_alloc_vtbl =
{
    MimeAlloc_QueryInterface,
    MimeAlloc_AddRef,
    MimeAlloc_Release,
    MimeAlloc_Alloc,
    MimeAlloc_Realloc,
    MimeAlloc_Free,
    MimeAlloc_GetSize,
    MimeAlloc_DidAlloc,
    MimeAlloc_HeapMinimize,
    MimeAlloc_FreeParamInfoArray,
    MimeAlloc_FreeAddressList,
    MimeAlloc_FreeAddressProps,
    MimeAlloc_ReleaseObjects,
    MimeAlloc_FreeEnumHeaderRowArray,
    MimeAlloc_FreeEnumPropertyArray,
    MimeAlloc_FreeThumbprint,
    MimeAlloc_PropVariantClear
};
 
static IMimeAllocator mime_allocator =
{
    &mime_alloc_vtbl
};
 
HRESULT MimeAllocator_create(IUnknown *outer, void **obj)
{
    if(outer) return CLASS_E_NOAGGREGATION;
 
    *obj = &mime_allocator;
    return S_OK;
}
 
HRESULT WINAPI MimeOleGetAllocator(IMimeAllocator **alloc)
{
    return MimeAllocator_create(NULL, (void**)alloc);
}
 
HRESULT VirtualStream_create(IUnknown *outer, void **obj)
{
    FIXME("(%p, %p)\n", outer, obj);
 
    *obj = NULL;
    if (outer) return CLASS_E_NOAGGREGATION;
 
    return MimeOleCreateVirtualStream((IStream **)obj);
}
 
/* IMimePropertySchema Interface */
static HRESULT WINAPI propschema_QueryInterface(IMimePropertySchema *iface, REFIID riid, void **out)
{
    propschema *This = impl_from_IMimePropertySchema(iface);
    TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), out);
 
    *out = NULL;
 
    if (IsEqualIID(riid, &IID_IUnknown) ||
        IsEqualIID(riid, &IID_IMimePropertySchema))
    {
        *out = iface;
    }
    else
    {
        FIXME("no interface for %s\n", debugstr_guid(riid));
        return E_NOINTERFACE;
    }
 
    IMimePropertySchema_AddRef(iface);
    return S_OK;
}
 
static ULONG WINAPI propschema_AddRef(IMimePropertySchema *iface)
{
    propschema *This = impl_from_IMimePropertySchema(iface);
    LONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p) ref=%d\n", This, ref);
 
    return ref;
}
 
static ULONG WINAPI propschema_Release(IMimePropertySchema *iface)
{
    propschema *This = impl_from_IMimePropertySchema(iface);
    LONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p) ref=%d\n", This, ref);
 
    if (!ref)
    {
        HeapFree(GetProcessHeap(), 0, This);
    }
 
    return ref;
}
 
static HRESULT WINAPI propschema_RegisterProperty(IMimePropertySchema *iface, const char *name, DWORD flags,
        DWORD rownumber, VARTYPE vtdefault, DWORD *propid)
{
    propschema *This = impl_from_IMimePropertySchema(iface);
    FIXME("(%p)->(%s, %x, %d, %d, %p) stub\n", This, debugstr_a(name), flags, rownumber, vtdefault, propid);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI propschema_ModifyProperty(IMimePropertySchema *iface, const char *name, DWORD flags,
        DWORD rownumber, VARTYPE vtdefault)
{
    propschema *This = impl_from_IMimePropertySchema(iface);
    FIXME("(%p)->(%s, %x, %d, %d) stub\n", This, debugstr_a(name), flags, rownumber, vtdefault);
    return S_OK;
}
 
static HRESULT WINAPI propschema_GetPropertyId(IMimePropertySchema *iface, const char *name, DWORD *propid)
{
    propschema *This = impl_from_IMimePropertySchema(iface);
    FIXME("(%p)->(%s, %p) stub\n", This, debugstr_a(name), propid);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI propschema_GetPropertyName(IMimePropertySchema *iface, DWORD propid, char **name)
{
    propschema *This = impl_from_IMimePropertySchema(iface);
    FIXME("(%p)->(%d, %p) stub\n", This, propid, name);
    return E_NOTIMPL;
}
 
static HRESULT WINAPI propschema_RegisterAddressType(IMimePropertySchema *iface, const char *name, DWORD *adrtype)
{
    propschema *This = impl_from_IMimePropertySchema(iface);
    FIXME("(%p)->(%s, %p) stub\n", This, debugstr_a(name), adrtype);
    return E_NOTIMPL;
}
 
static IMimePropertySchemaVtbl prop_schema_vtbl =
{
    propschema_QueryInterface,
    propschema_AddRef,
    propschema_Release,
    propschema_RegisterProperty,
    propschema_ModifyProperty,
    propschema_GetPropertyId,
    propschema_GetPropertyName,
    propschema_RegisterAddressType
};
 
 
HRESULT WINAPI MimeOleGetPropertySchema(IMimePropertySchema **schema)
{
    propschema *This;
 
    TRACE("(%p) stub\n", schema);
 
    This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
    if (!This)
        return E_OUTOFMEMORY;
 
    This->IMimePropertySchema_iface.lpVtbl = &prop_schema_vtbl;
    This->ref = 1;
 
    *schema = &This->IMimePropertySchema_iface;
 
    return S_OK;
}
 
HRESULT WINAPI MimeGetAddressFormatW(REFIID riid, void *object, DWORD addr_type,
       ADDRESSFORMAT addr_format, WCHAR **address)
{
    FIXME("(%s, %p, %d, %d, %p) stub\n", debugstr_guid(riid), object, addr_type, addr_format, address);
 
    return E_NOTIMPL;
}
 
static HRESULT WINAPI mime_obj_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
{
    FIXME("(%s %p)\n", debugstr_guid(riid), ppv);
    *ppv = NULL;
    return E_NOINTERFACE;
}
 
static ULONG WINAPI mime_obj_AddRef(IUnknown *iface)
{
    TRACE("\n");
    return 2;
}
 
static ULONG WINAPI mime_obj_Release(IUnknown *iface)
{
    TRACE("\n");
    return 1;
}
 
static const IUnknownVtbl mime_obj_vtbl = {
    mime_obj_QueryInterface,
    mime_obj_AddRef,
    mime_obj_Release
};
 
static IUnknown mime_obj = { &mime_obj_vtbl };
 
HRESULT WINAPI MimeOleObjectFromMoniker(BINDF bindf, IMoniker *moniker, IBindCtx *binding,
       REFIID riid, void **out, IMoniker **moniker_new)
{
    WCHAR *display_name, *mhtml_url;
    size_t len;
    HRESULT hres;
 
    static const WCHAR mhtml_prefixW[] = {'m','h','t','m','l',':'};
 
    WARN("(0x%08x, %p, %p, %s, %p, %p) semi-stub\n", bindf, moniker, binding, debugstr_guid(riid), out, moniker_new);
 
    if(!IsEqualGUID(&IID_IUnknown, riid)) {
        FIXME("Unsupported riid %s\n", debugstr_guid(riid));
        return E_NOINTERFACE;
    }
 
    hres = IMoniker_GetDisplayName(moniker, NULL, NULL, &display_name);
    if(FAILED(hres))
        return hres;
 
    TRACE("display name %s\n", debugstr_w(display_name));
 
    len = lstrlenW(display_name);
    mhtml_url = heap_alloc((len+1)*sizeof(WCHAR) + sizeof(mhtml_prefixW));
    if(!mhtml_url)
        return E_OUTOFMEMORY;
 
    memcpy(mhtml_url, mhtml_prefixW, sizeof(mhtml_prefixW));
    lstrcpyW(mhtml_url + ARRAY_SIZE(mhtml_prefixW), display_name);
    HeapFree(GetProcessHeap(), 0, display_name);
 
    hres = CreateURLMoniker(NULL, mhtml_url, moniker_new);
    heap_free(mhtml_url);
    if(FAILED(hres))
        return hres;
 
    /* FIXME: We most likely should start binding here and return something more meaningful as mime object. */
    *out = &mime_obj;
    return S_OK;
}