?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d2d1: Implement D2D1MakeSkewMatrix().
[wine.git] / dlls / inetcomm / mimeole.c
blobcb9ebcc382b8e1f81d339b7cf25a096c8a13dd8e
1 /*
2 * MIME OLE Interfaces
3 *
4 * Copyright 2006 Robert Shearman for CodeWeavers
5 * Copyright 2007 Huw Davies for CodeWeavers
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #define COBJMACROS
23 #define NONAMELESSUNION
24
25 #include <stdarg.h>
26 #include <stdio.h>
27
28 #include "windef.h"
29 #include "winbase.h"
30 #include "winuser.h"
31 #include "objbase.h"
32 #include "ole2.h"
33 #include "mimeole.h"
34 #include "propvarutil.h"
35
36 #include "wine/heap.h"
37 #include "wine/list.h"
38 #include "wine/debug.h"
39 #include "wine/unicode.h"
40
41 #include "inetcomm_private.h"
42
43 WINE_DEFAULT_DEBUG_CHANNEL(inetcomm);
44
45 typedef struct
46 {
47 LPCSTR name;
48 DWORD id;
49 DWORD flags; /* MIMEPROPFLAGS */
50 VARTYPE default_vt;
51 } property_t;
52
53 typedef struct
54 {
55 struct list entry;
56 property_t prop;
57 } property_list_entry_t;
58
59 static const property_t default_props[] =
60 {
61 {"X-Newsgroup", PID_HDR_NEWSGROUP, 0, VT_LPSTR},
62 {"Newsgroups", PID_HDR_NEWSGROUPS, 0, VT_LPSTR},
63 {"References", PID_HDR_REFS, 0, VT_LPSTR},
64 {"Subject", PID_HDR_SUBJECT, 0, VT_LPSTR},
65 {"From", PID_HDR_FROM, MPF_ADDRESS, VT_LPSTR},
66 {"Message-ID", PID_HDR_MESSAGEID, 0, VT_LPSTR},
67 {"Return-Path", PID_HDR_RETURNPATH, MPF_ADDRESS, VT_LPSTR},
68 {"Rr", PID_HDR_RR, 0, VT_LPSTR},
69 {"Return-Receipt-To", PID_HDR_RETRCPTO, MPF_ADDRESS, VT_LPSTR},
70 {"Apparently-To", PID_HDR_APPARTO, MPF_ADDRESS, VT_LPSTR},
71 {"Date", PID_HDR_DATE, 0, VT_LPSTR},
72 {"Received", PID_HDR_RECEIVED, 0, VT_LPSTR},
73 {"Reply-To", PID_HDR_REPLYTO, MPF_ADDRESS, VT_LPSTR},
74 {"X-Mailer", PID_HDR_XMAILER, 0, VT_LPSTR},
75 {"Bcc", PID_HDR_BCC, MPF_ADDRESS, VT_LPSTR},
76 {"MIME-Version", PID_HDR_MIMEVER, MPF_MIME, VT_LPSTR},
77 {"Content-Type", PID_HDR_CNTTYPE, MPF_MIME | MPF_HASPARAMS, VT_LPSTR},
78 {"Content-Transfer-Encoding", PID_HDR_CNTXFER, MPF_MIME, VT_LPSTR},
79 {"Content-ID", PID_HDR_CNTID, MPF_MIME, VT_LPSTR},
80 {"Content-Description", PID_HDR_CNTDESC, MPF_MIME, VT_LPSTR},
81 {"Content-Disposition", PID_HDR_CNTDISP, MPF_MIME | MPF_HASPARAMS, VT_LPSTR},
82 {"Content-Base", PID_HDR_CNTBASE, MPF_MIME, VT_LPSTR},
83 {"Content-Location", PID_HDR_CNTLOC, MPF_MIME, VT_LPSTR},
84 {"To", PID_HDR_TO, MPF_ADDRESS, VT_LPSTR},
85 {"Path", PID_HDR_PATH, 0, VT_LPSTR},
86 {"Followup-To", PID_HDR_FOLLOWUPTO, 0, VT_LPSTR},
87 {"Expires", PID_HDR_EXPIRES, 0, VT_LPSTR},
88 {"Cc", PID_HDR_CC, MPF_ADDRESS, VT_LPSTR},
89 {"Control", PID_HDR_CONTROL, 0, VT_LPSTR},
90 {"Distribution", PID_HDR_DISTRIB, 0, VT_LPSTR},
91 {"Keywords", PID_HDR_KEYWORDS, 0, VT_LPSTR},
92 {"Summary", PID_HDR_SUMMARY, 0, VT_LPSTR},
93 {"Approved", PID_HDR_APPROVED, 0, VT_LPSTR},
94 {"Lines", PID_HDR_LINES, 0, VT_LPSTR},
95 {"Xref", PID_HDR_XREF, 0, VT_LPSTR},
96 {"Organization", PID_HDR_ORG, 0, VT_LPSTR},
97 {"X-Newsreader", PID_HDR_XNEWSRDR, 0, VT_LPSTR},
98 {"X-Priority", PID_HDR_XPRI, 0, VT_LPSTR},
99 {"X-MSMail-Priority", PID_HDR_XMSPRI, 0, VT_LPSTR},
100 {"par:content-disposition:filename", PID_PAR_FILENAME, 0, VT_LPSTR},
101 {"par:content-type:boundary", PID_PAR_BOUNDARY, 0, VT_LPSTR},
102 {"par:content-type:charset", PID_PAR_CHARSET, 0, VT_LPSTR},
103 {"par:content-type:name", PID_PAR_NAME, 0, VT_LPSTR},
104 {"att:filename", PID_ATT_FILENAME, 0, VT_LPSTR},
105 {"att:pri-content-type", PID_ATT_PRITYPE, 0, VT_LPSTR},
106 {"att:sub-content-type", PID_ATT_SUBTYPE, 0, VT_LPSTR},
107 {"att:illegal-lines", PID_ATT_ILLEGAL, 0, VT_LPSTR},
108 {"att:rendered", PID_ATT_RENDERED, 0, VT_LPSTR},
109 {"att:sent-time", PID_ATT_SENTTIME, 0, VT_LPSTR},
110 {"att:priority", PID_ATT_PRIORITY, 0, VT_LPSTR},
111 {"Comment", PID_HDR_COMMENT, 0, VT_LPSTR},
112 {"Encoding", PID_HDR_ENCODING, 0, VT_LPSTR},
113 {"Encrypted", PID_HDR_ENCRYPTED, 0, VT_LPSTR},
114 {"X-Offsets", PID_HDR_OFFSETS, 0, VT_LPSTR},
115 {"X-Unsent", PID_HDR_XUNSENT, 0, VT_LPSTR},
116 {"X-ArticleId", PID_HDR_ARTICLEID, 0, VT_LPSTR},
117 {"Sender", PID_HDR_SENDER, MPF_ADDRESS, VT_LPSTR},
118 {"att:athena-server", PID_ATT_SERVER, 0, VT_LPSTR},
119 {"att:athena-account-id", PID_ATT_ACCOUNT, 0, VT_LPSTR},
120 {"att:athena-pop3-uidl", PID_ATT_UIDL, 0, VT_LPSTR},
121 {"att:athena-store-msgid", PID_ATT_STOREMSGID, 0, VT_LPSTR},
122 {"att:athena-user-name", PID_ATT_USERNAME, 0, VT_LPSTR},
123 {"att:athena-forward-to", PID_ATT_FORWARDTO, 0, VT_LPSTR},
124 {"att:athena-store-fdrid", PID_ATT_STOREFOLDERID,0, VT_LPSTR},
125 {"att:athena-ghosted", PID_ATT_GHOSTED, 0, VT_LPSTR},
126 {"att:athena-uncachedsize", PID_ATT_UNCACHEDSIZE, 0, VT_LPSTR},
127 {"att:athena-combined", PID_ATT_COMBINED, 0, VT_LPSTR},
128 {"att:auto-inlined", PID_ATT_AUTOINLINED, 0, VT_LPSTR},
129 {"Disposition-Notification-To", PID_HDR_DISP_NOTIFICATION_TO, 0, VT_LPSTR},
130 {"par:Content-Type:reply-type", PID_PAR_REPLYTYPE, 0, VT_LPSTR},
131 {"par:Content-Type:format", PID_PAR_FORMAT , 0, VT_LPSTR},
132 {"att:format", PID_ATT_FORMAT , 0, VT_LPSTR},
133 {"In-Reply-To", PID_HDR_INREPLYTO, 0, VT_LPSTR},
134 {"att:athena-account-name", PID_ATT_ACCOUNTNAME, 0, VT_LPSTR},
135 {NULL, 0, 0, 0}
136 };
137
138 typedef struct
139 {
140 struct list entry;
141 char *name;
142 char *value;
143 } param_t;
144
145 typedef struct
146 {
147 struct list entry;
148 const property_t *prop;
149 PROPVARIANT value;
150 struct list params;
151 } header_t;
152
153 typedef struct MimeBody
154 {
155 IMimeBody IMimeBody_iface;
156 LONG ref;
157
158 HBODY handle;
159
160 struct list headers;
161 struct list new_props; /* FIXME: This should be in a PropertySchema */
162 DWORD next_prop_id;
163 char *content_pri_type;
164 char *content_sub_type;
165 ENCODINGTYPE encoding;
166 void *data;
167 IID data_iid;
168 BODYOFFSETS body_offsets;
169 } MimeBody;
170
171 typedef struct
172 {
173 IStream IStream_iface;
174 LONG ref;
175 IStream *base;
176 ULARGE_INTEGER pos, start, length;
177 } sub_stream_t;
178
179 static inline sub_stream_t *impl_from_IStream(IStream *iface)
180 {
181 return CONTAINING_RECORD(iface, sub_stream_t, IStream_iface);
182 }
183
184 static HRESULT WINAPI sub_stream_QueryInterface(IStream *iface, REFIID riid, void **ppv)
185 {
186 sub_stream_t *This = impl_from_IStream(iface);
187
188 TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
189 *ppv = NULL;
190
191 if(IsEqualIID(riid, &IID_IUnknown) ||
192 IsEqualIID(riid, &IID_ISequentialStream) ||
193 IsEqualIID(riid, &IID_IStream))
194 {
195 IStream_AddRef(iface);
196 *ppv = iface;
197 return S_OK;
198 }
199 return E_NOINTERFACE;
200 }
201
202 static ULONG WINAPI sub_stream_AddRef(IStream *iface)
203 {
204 sub_stream_t *This = impl_from_IStream(iface);
205 LONG ref = InterlockedIncrement(&This->ref);
206
207 TRACE("(%p) ref=%d\n", This, ref);
208
209 return ref;
210 }
211
212 static ULONG WINAPI sub_stream_Release(IStream *iface)
213 {
214 sub_stream_t *This = impl_from_IStream(iface);
215 LONG ref = InterlockedDecrement(&This->ref);
216
217 TRACE("(%p) ref=%d\n", This, ref);
218
219 if(!ref)
220 {
221 IStream_Release(This->base);
222 HeapFree(GetProcessHeap(), 0, This);
223 }
224 return ref;
225 }
226
227 static HRESULT WINAPI sub_stream_Read(
228 IStream* iface,
229 void *pv,
230 ULONG cb,
231 ULONG *pcbRead)
232 {
233 sub_stream_t *This = impl_from_IStream(iface);
234 HRESULT hr;
235 LARGE_INTEGER tmp_pos;
236
237 TRACE("(%p, %d, %p)\n", pv, cb, pcbRead);
238
239 tmp_pos.QuadPart = This->pos.QuadPart + This->start.QuadPart;
240 IStream_Seek(This->base, tmp_pos, STREAM_SEEK_SET, NULL);
241
242 if(This->pos.QuadPart + cb > This->length.QuadPart)
243 cb = This->length.QuadPart - This->pos.QuadPart;
244
245 hr = IStream_Read(This->base, pv, cb, pcbRead);
246
247 This->pos.QuadPart += *pcbRead;
248
249 return hr;
250 }
251
252 static HRESULT WINAPI sub_stream_Write(
253 IStream* iface,
254 const void *pv,
255 ULONG cb,
256 ULONG *pcbWritten)
257 {
258 FIXME("stub\n");
259 return E_NOTIMPL;
260 }
261
262 static HRESULT WINAPI sub_stream_Seek(
263 IStream* iface,
264 LARGE_INTEGER dlibMove,
265 DWORD dwOrigin,
266 ULARGE_INTEGER *plibNewPosition)
267 {
268 sub_stream_t *This = impl_from_IStream(iface);
269 LARGE_INTEGER new_pos;
270
271 TRACE("(%08x.%08x, %x, %p)\n", dlibMove.u.HighPart, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
272
273 switch(dwOrigin)
274 {
275 case STREAM_SEEK_SET:
276 new_pos = dlibMove;
277 break;
278 case STREAM_SEEK_CUR:
279 new_pos.QuadPart = This->pos.QuadPart + dlibMove.QuadPart;
280 break;
281 case STREAM_SEEK_END:
282 new_pos.QuadPart = This->length.QuadPart + dlibMove.QuadPart;
283 break;
284 default:
285 return STG_E_INVALIDFUNCTION;
286 }
287
288 if(new_pos.QuadPart < 0) new_pos.QuadPart = 0;
289 else if(new_pos.QuadPart > This->length.QuadPart) new_pos.QuadPart = This->length.QuadPart;
290
291 This->pos.QuadPart = new_pos.QuadPart;
292
293 if(plibNewPosition) *plibNewPosition = This->pos;
294 return S_OK;
295 }
296
297 static HRESULT WINAPI sub_stream_SetSize(
298 IStream* iface,
299 ULARGE_INTEGER libNewSize)
300 {
301 FIXME("stub\n");
302 return E_NOTIMPL;
303 }
304
305 static HRESULT WINAPI sub_stream_CopyTo(
306 IStream* iface,
307 IStream *pstm,
308 ULARGE_INTEGER cb,
309 ULARGE_INTEGER *pcbRead,
310 ULARGE_INTEGER *pcbWritten)
311 {
312 HRESULT hr = S_OK;
313 BYTE tmpBuffer[128];
314 ULONG bytesRead, bytesWritten, copySize;
315 ULARGE_INTEGER totalBytesRead;
316 ULARGE_INTEGER totalBytesWritten;
317
318 TRACE("(%p)->(%p, %d, %p, %p)\n", iface, pstm, cb.u.LowPart, pcbRead, pcbWritten);
319
320 totalBytesRead.QuadPart = 0;
321 totalBytesWritten.QuadPart = 0;
322
323 while ( cb.QuadPart > 0 )
324 {
325 if ( cb.QuadPart >= sizeof(tmpBuffer) )
326 copySize = sizeof(tmpBuffer);
327 else
328 copySize = cb.u.LowPart;
329
330 hr = IStream_Read(iface, tmpBuffer, copySize, &bytesRead);
331 if (FAILED(hr)) break;
332
333 totalBytesRead.QuadPart += bytesRead;
334
335 if (bytesRead)
336 {
337 hr = IStream_Write(pstm, tmpBuffer, bytesRead, &bytesWritten);
338 if (FAILED(hr)) break;
339 totalBytesWritten.QuadPart += bytesWritten;
340 }
341
342 if (bytesRead != copySize)
343 cb.QuadPart = 0;
344 else
345 cb.QuadPart -= bytesRead;
346 }
347
348 if (pcbRead) pcbRead->QuadPart = totalBytesRead.QuadPart;
349 if (pcbWritten) pcbWritten->QuadPart = totalBytesWritten.QuadPart;
350
351 return hr;
352 }
353
354 static HRESULT WINAPI sub_stream_Commit(
355 IStream* iface,
356 DWORD grfCommitFlags)
357 {
358 FIXME("stub\n");
359 return E_NOTIMPL;
360 }
361
362 static HRESULT WINAPI sub_stream_Revert(
363 IStream* iface)
364 {
365 FIXME("stub\n");
366 return E_NOTIMPL;
367 }
368
369 static HRESULT WINAPI sub_stream_LockRegion(
370 IStream* iface,
371 ULARGE_INTEGER libOffset,
372 ULARGE_INTEGER cb,
373 DWORD dwLockType)
374 {
375 FIXME("stub\n");
376 return E_NOTIMPL;
377 }
378
379 static HRESULT WINAPI sub_stream_UnlockRegion(
380 IStream* iface,
381 ULARGE_INTEGER libOffset,
382 ULARGE_INTEGER cb,
383 DWORD dwLockType)
384 {
385 FIXME("stub\n");
386 return E_NOTIMPL;
387 }
388
389 static HRESULT WINAPI sub_stream_Stat(
390 IStream* iface,
391 STATSTG *pstatstg,
392 DWORD grfStatFlag)
393 {
394 sub_stream_t *This = impl_from_IStream(iface);
395 FIXME("(%p)->(%p, %08x)\n", This, pstatstg, grfStatFlag);
396 memset(pstatstg, 0, sizeof(*pstatstg));
397 pstatstg->cbSize = This->length;
398 return S_OK;
399 }
400
401 static HRESULT WINAPI sub_stream_Clone(
402 IStream* iface,
403 IStream **ppstm)
404 {
405 FIXME("stub\n");
406 return E_NOTIMPL;
407 }
408
409 static struct IStreamVtbl sub_stream_vtbl =
410 {
411 sub_stream_QueryInterface,
412 sub_stream_AddRef,
413 sub_stream_Release,
414 sub_stream_Read,
415 sub_stream_Write,
416 sub_stream_Seek,
417 sub_stream_SetSize,
418 sub_stream_CopyTo,
419 sub_stream_Commit,
420 sub_stream_Revert,
421 sub_stream_LockRegion,
422 sub_stream_UnlockRegion,
423 sub_stream_Stat,
424 sub_stream_Clone
425 };
426
427 static HRESULT create_sub_stream(IStream *stream, ULARGE_INTEGER start, ULARGE_INTEGER length, IStream **out)
428 {
429 sub_stream_t *This;
430
431 *out = NULL;
432 This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
433 if(!This) return E_OUTOFMEMORY;
434
435 This->IStream_iface.lpVtbl = &sub_stream_vtbl;
436 This->ref = 1;
437 This->start = start;
438 This->length = length;
439 This->pos.QuadPart = 0;
440 IStream_AddRef(stream);
441 This->base = stream;
442
443 *out = &This->IStream_iface;
444 return S_OK;
445 }
446
447 static HRESULT get_stream_size(IStream *stream, ULARGE_INTEGER *size)
448 {
449 STATSTG statstg = {NULL};
450 LARGE_INTEGER zero;
451 HRESULT hres;
452
453 hres = IStream_Stat(stream, &statstg, STATFLAG_NONAME);
454 if(SUCCEEDED(hres)) {
455 *size = statstg.cbSize;
456 return S_OK;
457 }
458
459 zero.QuadPart = 0;
460 return IStream_Seek(stream, zero, STREAM_SEEK_END, size);
461 }
462
463 static inline MimeBody *impl_from_IMimeBody(IMimeBody *iface)
464 {
465 return CONTAINING_RECORD(iface, MimeBody, IMimeBody_iface);
466 }
467
468 typedef struct propschema
469 {
470 IMimePropertySchema IMimePropertySchema_iface;
471 LONG ref;
472 } propschema;
473
474 static inline propschema *impl_from_IMimePropertySchema(IMimePropertySchema *iface)
475 {
476 return CONTAINING_RECORD(iface, propschema, IMimePropertySchema_iface);
477 }
478
479 static LPSTR strdupA(LPCSTR str)
480 {
481 char *ret;
482 int len = strlen(str);
483 ret = HeapAlloc(GetProcessHeap(), 0, len + 1);
484 memcpy(ret, str, len + 1);
485 return ret;
486 }
487
488 #define PARSER_BUF_SIZE 1024
489
490 /*****************************************************
491 * copy_headers_to_buf [internal]
492 *
493 * Copies the headers into a '\0' terminated memory block and leave
494 * the stream's current position set to after the blank line.
495 */
496 static HRESULT copy_headers_to_buf(IStream *stm, char **ptr)
497 {
498 char *buf = NULL;
499 DWORD size = PARSER_BUF_SIZE, offset = 0, last_end = 0;
500 HRESULT hr;
501 BOOL done = FALSE;
502
503 *ptr = NULL;
504
505 do
506 {
507 char *end;
508 DWORD read;
509
510 if(!buf)
511 buf = HeapAlloc(GetProcessHeap(), 0, size + 1);
512 else
513 {
514 size *= 2;
515 buf = HeapReAlloc(GetProcessHeap(), 0, buf, size + 1);
516 }
517 if(!buf)
518 {
519 hr = E_OUTOFMEMORY;
520 goto fail;
521 }
522
523 hr = IStream_Read(stm, buf + offset, size - offset, &read);
524 if(FAILED(hr)) goto fail;
525
526 offset += read;
527 buf[offset] = '\0';
528
529 if(read == 0) done = TRUE;
530
531 while(!done && (end = strstr(buf + last_end, "\r\n")))
532 {
533 DWORD new_end = end - buf + 2;
534 if(new_end - last_end == 2)
535 {
536 LARGE_INTEGER off;
537 off.QuadPart = (LONGLONG)new_end - offset;
538 IStream_Seek(stm, off, STREAM_SEEK_CUR, NULL);
539 buf[new_end] = '\0';
540 done = TRUE;
541 }
542 else
543 last_end = new_end;
544 }
545 } while(!done);
546
547 *ptr = buf;
548 return S_OK;
549
550 fail:
551 HeapFree(GetProcessHeap(), 0, buf);
552 return hr;
553 }
554
555 static header_t *read_prop(MimeBody *body, char **ptr)
556 {
557 char *colon = strchr(*ptr, ':');
558 const property_t *prop;
559 header_t *ret;
560
561 if(!colon) return NULL;
562
563 *colon = '\0';
564
565 for(prop = default_props; prop->name; prop++)
566 {
567 if(!lstrcmpiA(*ptr, prop->name))
568 {
569 TRACE("%s: found match with default property id %d\n", *ptr, prop->id);
570 break;
571 }
572 }
573
574 if(!prop->name)
575 {
576 property_list_entry_t *prop_entry;
577 LIST_FOR_EACH_ENTRY(prop_entry, &body->new_props, property_list_entry_t, entry)
578 {
579 if(!lstrcmpiA(*ptr, prop_entry->prop.name))
580 {
581 TRACE("%s: found match with already added new property id %d\n", *ptr, prop_entry->prop.id);
582 prop = &prop_entry->prop;
583 break;
584 }
585 }
586 if(!prop->name)
587 {
588 prop_entry = HeapAlloc(GetProcessHeap(), 0, sizeof(*prop_entry));
589 prop_entry->prop.name = strdupA(*ptr);
590 prop_entry->prop.id = body->next_prop_id++;
591 prop_entry->prop.flags = 0;
592 prop_entry->prop.default_vt = VT_LPSTR;
593 list_add_tail(&body->new_props, &prop_entry->entry);
594 prop = &prop_entry->prop;
595 TRACE("%s: allocating new prop id %d\n", *ptr, prop_entry->prop.id);
596 }
597 }
598
599 ret = HeapAlloc(GetProcessHeap(), 0, sizeof(*ret));
600 ret->prop = prop;
601 PropVariantInit(&ret->value);
602 list_init(&ret->params);
603 *ptr = colon + 1;
604
605 return ret;
606 }
607
608 static void unfold_header(char *header, int len)
609 {
610 char *start = header, *cp = header;
611
612 do {
613 while(*cp == ' ' || *cp == '\t')
614 {
615 cp++;
616 len--;
617 }
618 if(cp != start)
619 memmove(start, cp, len + 1);
620
621 cp = strstr(start, "\r\n");
622 len -= (cp - start);
623 start = cp;
624 *start = ' ';
625 start++;
626 len--;
627 cp += 2;
628 } while(*cp == ' ' || *cp == '\t');
629
630 *(start - 1) = '\0';
631 }
632
633 static char *unquote_string(const char *str)
634 {
635 BOOL quoted = FALSE;
636 char *ret, *cp;
637
638 while(*str == ' ' || *str == '\t') str++;
639
640 if(*str == '"')
641 {
642 quoted = TRUE;
643 str++;
644 }
645 ret = strdupA(str);
646 for(cp = ret; *cp; cp++)
647 {
648 if(*cp == '\\')
649 memmove(cp, cp + 1, strlen(cp + 1) + 1);
650 else if(*cp == '"')
651 {
652 if(!quoted)
653 {
654 WARN("quote in unquoted string\n");
655 }
656 else
657 {
658 *cp = '\0';
659 break;
660 }
661 }
662 }
663 return ret;
664 }
665
666 static void add_param(header_t *header, const char *p)
667 {
668 const char *key = p, *value, *cp = p;
669 param_t *param;
670 char *name;
671
672 TRACE("got param %s\n", p);
673
674 while (*key == ' ' || *key == '\t' ) key++;
675
676 cp = strchr(key, '=');
677 if(!cp)
678 {
679 WARN("malformed parameter - skipping\n");
680 return;
681 }
682
683 name = HeapAlloc(GetProcessHeap(), 0, cp - key + 1);
684 memcpy(name, key, cp - key);
685 name[cp - key] = '\0';
686
687 value = cp + 1;
688
689 param = HeapAlloc(GetProcessHeap(), 0, sizeof(*param));
690 param->name = name;
691 param->value = unquote_string(value);
692 list_add_tail(&header->params, &param->entry);
693 }
694
695 static void split_params(header_t *header, char *value)
696 {
697 char *cp = value, *start = value;
698 BOOL in_quotes = FALSE, done_value = FALSE;
699
700 while(*cp)
701 {
702 if(!in_quotes && *cp == ';')
703 {
704 *cp = '\0';
705 if(done_value) add_param(header, start);
706 done_value = TRUE;
707 start = cp + 1;
708 }
709 else if(*cp == '"')
710 in_quotes = !in_quotes;
711 cp++;
712 }
713 if(done_value) add_param(header, start);
714 }
715
716 static void read_value(header_t *header, char **cur)
717 {
718 char *end = *cur, *value;
719 DWORD len;
720
721 do {
722 end = strstr(end, "\r\n");
723 end += 2;
724 } while(*end == ' ' || *end == '\t');
725
726 len = end - *cur;
727 value = HeapAlloc(GetProcessHeap(), 0, len + 1);
728 memcpy(value, *cur, len);
729 value[len] = '\0';
730
731 unfold_header(value, len);
732 TRACE("value %s\n", debugstr_a(value));
733
734 if(header->prop->flags & MPF_HASPARAMS)
735 {
736 split_params(header, value);
737 TRACE("value w/o params %s\n", debugstr_a(value));
738 }
739
740 header->value.vt = VT_LPSTR;
741 header->value.u.pszVal = value;
742
743 *cur = end;
744 }
745
746 static void init_content_type(MimeBody *body, header_t *header)
747 {
748 char *slash;
749 DWORD len;
750
751 slash = strchr(header->value.u.pszVal, '/');
752 if(!slash)
753 {
754 WARN("malformed context type value\n");
755 return;
756 }
757 len = slash - header->value.u.pszVal;
758 body->content_pri_type = HeapAlloc(GetProcessHeap(), 0, len + 1);
759 memcpy(body->content_pri_type, header->value.u.pszVal, len);
760 body->content_pri_type[len] = '\0';
761 body->content_sub_type = strdupA(slash + 1);
762 }
763
764 static void init_content_encoding(MimeBody *body, header_t *header)
765 {
766 const char *encoding = header->value.u.pszVal;
767
768 if(!strcasecmp(encoding, "base64"))
769 body->encoding = IET_BASE64;
770 else if(!strcasecmp(encoding, "quoted-printable"))
771 body->encoding = IET_QP;
772 else if(!strcasecmp(encoding, "7bit"))
773 body->encoding = IET_7BIT;
774 else if(!strcasecmp(encoding, "8bit"))
775 body->encoding = IET_8BIT;
776 else
777 FIXME("unknown encoding %s\n", debugstr_a(encoding));
778 }
779
780 static HRESULT parse_headers(MimeBody *body, IStream *stm)
781 {
782 char *header_buf, *cur_header_ptr;
783 HRESULT hr;
784 header_t *header;
785
786 hr = copy_headers_to_buf(stm, &header_buf);
787 if(FAILED(hr)) return hr;
788
789 cur_header_ptr = header_buf;
790 while((header = read_prop(body, &cur_header_ptr)))
791 {
792 read_value(header, &cur_header_ptr);
793 list_add_tail(&body->headers, &header->entry);
794
795 switch(header->prop->id) {
796 case PID_HDR_CNTTYPE:
797 init_content_type(body, header);
798 break;
799 case PID_HDR_CNTXFER:
800 init_content_encoding(body, header);
801 break;
802 }
803 }
804
805 HeapFree(GetProcessHeap(), 0, header_buf);
806 return hr;
807 }
808
809 static void empty_param_list(struct list *list)
810 {
811 param_t *param, *cursor2;
812
813 LIST_FOR_EACH_ENTRY_SAFE(param, cursor2, list, param_t, entry)
814 {
815 list_remove(&param->entry);
816 HeapFree(GetProcessHeap(), 0, param->name);
817 HeapFree(GetProcessHeap(), 0, param->value);
818 HeapFree(GetProcessHeap(), 0, param);
819 }
820 }
821
822 static void empty_header_list(struct list *list)
823 {
824 header_t *header, *cursor2;
825
826 LIST_FOR_EACH_ENTRY_SAFE(header, cursor2, list, header_t, entry)
827 {
828 list_remove(&header->entry);
829 PropVariantClear(&header->value);
830 empty_param_list(&header->params);
831 HeapFree(GetProcessHeap(), 0, header);
832 }
833 }
834
835 static void empty_new_prop_list(struct list *list)
836 {
837 property_list_entry_t *prop, *cursor2;
838
839 LIST_FOR_EACH_ENTRY_SAFE(prop, cursor2, list, property_list_entry_t, entry)
840 {
841 list_remove(&prop->entry);
842 HeapFree(GetProcessHeap(), 0, (char *)prop->prop.name);
843 HeapFree(GetProcessHeap(), 0, prop);
844 }
845 }
846
847 static void release_data(REFIID riid, void *data)
848 {
849 if(!data) return;
850
851 if(IsEqualIID(riid, &IID_IStream))
852 IStream_Release((IStream *)data);
853 else
854 FIXME("Unhandled data format %s\n", debugstr_guid(riid));
855 }
856
857 static HRESULT find_prop(MimeBody *body, const char *name, header_t **prop)
858 {
859 header_t *header;
860
861 *prop = NULL;
862
863 LIST_FOR_EACH_ENTRY(header, &body->headers, header_t, entry)
864 {
865 if(ISPIDSTR(name))
866 {
867 if(STRTOPID(name) == header->prop->id)
868 {
869 *prop = header;
870 return S_OK;
871 }
872 }
873 else if(!lstrcmpiA(name, header->prop->name))
874 {
875 *prop = header;
876 return S_OK;
877 }
878 }
879
880 return MIME_E_NOT_FOUND;
881 }
882
883 static const property_t *find_default_prop(const char *name)
884 {
885 const property_t *prop_def = NULL;
886
887 for(prop_def = default_props; prop_def->name; prop_def++)
888 {
889 if(ISPIDSTR(name))
890 {
891 if(STRTOPID(name) == prop_def->id)
892 {
893 break;
894 }
895 }
896 else if(!lstrcmpiA(name, prop_def->name))
897 {
898 break;
899 }
900 }
901
902 if(prop_def->id)
903 TRACE("%s: found match with default property id %d\n", prop_def->name, prop_def->id);
904 else
905 prop_def = NULL;
906
907 return prop_def;
908 }
909
910 static HRESULT WINAPI MimeBody_QueryInterface(IMimeBody* iface,
911 REFIID riid,
912 void** ppvObject)
913 {
914 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppvObject);
915
916 *ppvObject = NULL;
917
918 if (IsEqualIID(riid, &IID_IUnknown) ||
919 IsEqualIID(riid, &IID_IPersist) ||
920 IsEqualIID(riid, &IID_IPersistStreamInit) ||
921 IsEqualIID(riid, &IID_IMimePropertySet) ||
922 IsEqualIID(riid, &IID_IMimeBody))
923 {
924 *ppvObject = iface;
925 }
926
927 if(*ppvObject)
928 {
929 IUnknown_AddRef((IUnknown*)*ppvObject);
930 return S_OK;
931 }
932
933 FIXME("no interface for %s\n", debugstr_guid(riid));
934 return E_NOINTERFACE;
935 }
936
937 static ULONG WINAPI MimeBody_AddRef(IMimeBody *iface)
938 {
939 MimeBody *This = impl_from_IMimeBody(iface);
940 LONG ref = InterlockedIncrement(&This->ref);
941
942 TRACE("(%p) ref=%d\n", This, ref);
943
944 return ref;
945 }
946
947 static ULONG WINAPI MimeBody_Release(IMimeBody *iface)
948 {
949 MimeBody *This = impl_from_IMimeBody(iface);
950 LONG ref = InterlockedDecrement(&This->ref);
951
952 TRACE("(%p) ref=%d\n", This, ref);
953
954 if (!ref)
955 {
956 empty_header_list(&This->headers);
957 empty_new_prop_list(&This->new_props);
958
959 HeapFree(GetProcessHeap(), 0, This->content_pri_type);
960 HeapFree(GetProcessHeap(), 0, This->content_sub_type);
961
962 release_data(&This->data_iid, This->data);
963
964 HeapFree(GetProcessHeap(), 0, This);
965 }
966
967 return ref;
968 }
969
970 static HRESULT WINAPI MimeBody_GetClassID(
971 IMimeBody* iface,
972 CLSID* pClassID)
973 {
974 MimeBody *This = impl_from_IMimeBody(iface);
975
976 TRACE("(%p)->(%p)\n", This, pClassID);
977
978 if(!pClassID)
979 return E_INVALIDARG;
980
981 *pClassID = IID_IMimeBody;
982 return S_OK;
983 }
984
985 static HRESULT WINAPI MimeBody_IsDirty(
986 IMimeBody* iface)
987 {
988 MimeBody *This = impl_from_IMimeBody(iface);
989 FIXME("(%p)->() stub\n", This);
990 return E_NOTIMPL;
991 }
992
993 static HRESULT WINAPI MimeBody_Load(IMimeBody *iface, IStream *pStm)
994 {
995 MimeBody *This = impl_from_IMimeBody(iface);
996 TRACE("(%p)->(%p)\n", This, pStm);
997 return parse_headers(This, pStm);
998 }
999
1000 static HRESULT WINAPI MimeBody_Save(IMimeBody *iface, IStream *pStm, BOOL fClearDirty)
1001 {
1002 MimeBody *This = impl_from_IMimeBody(iface);
1003 FIXME("(%p)->(%p, %d)\n", This, pStm, fClearDirty);
1004 return E_NOTIMPL;
1005 }
1006
1007 static HRESULT WINAPI MimeBody_GetSizeMax(
1008 IMimeBody* iface,
1009 ULARGE_INTEGER* pcbSize)
1010 {
1011 MimeBody *This = impl_from_IMimeBody(iface);
1012 FIXME("(%p)->(%p) stub\n", This, pcbSize);
1013 return E_NOTIMPL;
1014 }
1015
1016 static HRESULT WINAPI MimeBody_InitNew(
1017 IMimeBody* iface)
1018 {
1019 MimeBody *This = impl_from_IMimeBody(iface);
1020 TRACE("(%p)->()\n", This);
1021 return S_OK;
1022 }
1023
1024 static HRESULT WINAPI MimeBody_GetPropInfo(
1025 IMimeBody* iface,
1026 LPCSTR pszName,
1027 LPMIMEPROPINFO pInfo)
1028 {
1029 MimeBody *This = impl_from_IMimeBody(iface);
1030 header_t *header;
1031 HRESULT hr;
1032 DWORD supported = PIM_PROPID | PIM_VTDEFAULT;
1033
1034 TRACE("(%p)->(%s, %p) semi-stub\n", This, debugstr_a(pszName), pInfo);
1035
1036 if(!pszName || !pInfo)
1037 return E_INVALIDARG;
1038
1039 TRACE("mask 0x%04x\n", pInfo->dwMask);
1040
1041 if(pInfo->dwMask & ~supported)
1042 FIXME("Unsupported mask flags 0x%04x\n", pInfo->dwMask & ~supported);
1043
1044 hr = find_prop(This, pszName, &header);
1045 if(hr == S_OK)
1046 {
1047 if(pInfo->dwMask & PIM_CHARSET)
1048 pInfo->hCharset = 0;
1049 if(pInfo->dwMask & PIM_FLAGS)
1050 pInfo->dwFlags = 0x00000000;
1051 if(pInfo->dwMask & PIM_ROWNUMBER)
1052 pInfo->dwRowNumber = 0;
1053 if(pInfo->dwMask & PIM_ENCODINGTYPE)
1054 pInfo->ietEncoding = 0;
1055 if(pInfo->dwMask & PIM_VALUES)
1056 pInfo->cValues = 0;
1057 if(pInfo->dwMask & PIM_PROPID)
1058 pInfo->dwPropId = header->prop->id;
1059 if(pInfo->dwMask & PIM_VTDEFAULT)
1060 pInfo->vtDefault = header->prop->default_vt;
1061 if(pInfo->dwMask & PIM_VTCURRENT)
1062 pInfo->vtCurrent = 0;
1063 }
1064
1065 return hr;
1066 }
1067
1068 static HRESULT WINAPI MimeBody_SetPropInfo(
1069 IMimeBody* iface,
1070 LPCSTR pszName,
1071 LPCMIMEPROPINFO pInfo)
1072 {
1073 MimeBody *This = impl_from_IMimeBody(iface);
1074 FIXME("(%p)->(%s, %p) stub\n", This, debugstr_a(pszName), pInfo);
1075 return E_NOTIMPL;
1076 }
1077
1078 static HRESULT WINAPI MimeBody_GetProp(
1079 IMimeBody* iface,
1080 LPCSTR pszName,
1081 DWORD dwFlags,
1082 LPPROPVARIANT pValue)
1083 {
1084 MimeBody *This = impl_from_IMimeBody(iface);
1085 header_t *header;
1086 HRESULT hr;
1087
1088 TRACE("(%p)->(%s, 0x%x, %p)\n", This, debugstr_a(pszName), dwFlags, pValue);
1089
1090 if(!pszName || !pValue)
1091 return E_INVALIDARG;
1092
1093 if(!ISPIDSTR(pszName) && !lstrcmpiA(pszName, "att:pri-content-type"))
1094 {
1095 PropVariantClear(pValue);
1096 pValue->vt = VT_LPSTR;
1097 pValue->u.pszVal = strdupA(This->content_pri_type);
1098 return S_OK;
1099 }
1100
1101 hr = find_prop(This, pszName, &header);
1102 if(hr == S_OK)
1103 {
1104 TRACE("type %d->%d\n", header->value.vt, pValue->vt);
1105
1106 hr = PropVariantChangeType(pValue, &header->value, 0, pValue->vt);
1107 if(FAILED(hr))
1108 FIXME("Conversion not currently supported (%d->%d)\n", header->value.vt, pValue->vt);
1109 }
1110
1111 return hr;
1112 }
1113
1114 static HRESULT WINAPI MimeBody_SetProp(
1115 IMimeBody* iface,
1116 LPCSTR pszName,
1117 DWORD dwFlags,
1118 LPCPROPVARIANT pValue)
1119 {
1120 MimeBody *This = impl_from_IMimeBody(iface);
1121 header_t *header;
1122 HRESULT hr;
1123
1124 TRACE("(%p)->(%s, 0x%x, %p)\n", This, debugstr_a(pszName), dwFlags, pValue);
1125
1126 if(!pszName || !pValue)
1127 return E_INVALIDARG;
1128
1129 hr = find_prop(This, pszName, &header);
1130 if(hr != S_OK)
1131 {
1132 property_list_entry_t *prop_entry;
1133 const property_t *prop = NULL;
1134
1135 LIST_FOR_EACH_ENTRY(prop_entry, &This->new_props, property_list_entry_t, entry)
1136 {
1137 if(ISPIDSTR(pszName))
1138 {
1139 if(STRTOPID(pszName) == prop_entry->prop.id)
1140 {
1141 TRACE("Found match with already added new property id %d\n", prop_entry->prop.id);
1142 prop = &prop_entry->prop;
1143 break;
1144 }
1145 }
1146 else if(!lstrcmpiA(pszName, prop_entry->prop.name))
1147 {
1148 TRACE("Found match with already added new property id %d\n", prop_entry->prop.id);
1149 prop = &prop_entry->prop;
1150 break;
1151 }
1152 }
1153
1154 header = HeapAlloc(GetProcessHeap(), 0, sizeof(*header));
1155 if(!header)
1156 return E_OUTOFMEMORY;
1157
1158 if(!prop)
1159 {
1160 const property_t *prop_def = NULL;
1161 prop_entry = HeapAlloc(GetProcessHeap(), 0, sizeof(*prop_entry));
1162 if(!prop_entry)
1163 {
1164 HeapFree(GetProcessHeap(), 0, header);
1165 return E_OUTOFMEMORY;
1166 }
1167
1168 prop_def = find_default_prop(pszName);
1169 if(prop_def)
1170 {
1171 prop_entry->prop.name = strdupA(prop_def->name);
1172 prop_entry->prop.id = prop_def->id;
1173 }
1174 else
1175 {
1176 if(ISPIDSTR(pszName))
1177 {
1178 HeapFree(GetProcessHeap(), 0, prop_entry);
1179 HeapFree(GetProcessHeap(), 0, header);
1180 return MIME_E_NOT_FOUND;
1181 }
1182
1183 prop_entry->prop.name = strdupA(pszName);
1184 prop_entry->prop.id = This->next_prop_id++;
1185 }
1186
1187 prop_entry->prop.flags = 0;
1188 prop_entry->prop.default_vt = pValue->vt;
1189 list_add_tail(&This->new_props, &prop_entry->entry);
1190 prop = &prop_entry->prop;
1191 TRACE("Allocating new prop id %d\n", prop_entry->prop.id);
1192 }
1193
1194 header->prop = prop;
1195 PropVariantInit(&header->value);
1196 list_init(&header->params);
1197 list_add_tail(&This->headers, &header->entry);
1198 }
1199
1200 PropVariantCopy(&header->value, pValue);
1201
1202 return S_OK;
1203 }
1204
1205 static HRESULT WINAPI MimeBody_AppendProp(
1206 IMimeBody* iface,
1207 LPCSTR pszName,
1208 DWORD dwFlags,
1209 LPPROPVARIANT pValue)
1210 {
1211 MimeBody *This = impl_from_IMimeBody(iface);
1212 FIXME("(%p)->(%s, 0x%x, %p) stub\n", This, debugstr_a(pszName), dwFlags, pValue);
1213 return E_NOTIMPL;
1214 }
1215
1216 static HRESULT WINAPI MimeBody_DeleteProp(
1217 IMimeBody* iface,
1218 LPCSTR pszName)
1219 {
1220 MimeBody *This = impl_from_IMimeBody(iface);
1221 header_t *cursor;
1222 BOOL found;
1223
1224 TRACE("(%p)->(%s) stub\n", This, debugstr_a(pszName));
1225
1226 LIST_FOR_EACH_ENTRY(cursor, &This->headers, header_t, entry)
1227 {
1228 if(ISPIDSTR(pszName))
1229 found = STRTOPID(pszName) == cursor->prop->id;
1230 else
1231 found = !lstrcmpiA(pszName, cursor->prop->name);
1232
1233 if(found)
1234 {
1235 list_remove(&cursor->entry);
1236 HeapFree(GetProcessHeap(), 0, cursor);
1237 return S_OK;
1238 }
1239 }
1240
1241 return MIME_E_NOT_FOUND;
1242 }
1243
1244 static HRESULT WINAPI MimeBody_CopyProps(
1245 IMimeBody* iface,
1246 ULONG cNames,
1247 LPCSTR* prgszName,
1248 IMimePropertySet* pPropertySet)
1249 {
1250 MimeBody *This = impl_from_IMimeBody(iface);
1251 FIXME("(%p)->(%d, %p, %p) stub\n", This, cNames, prgszName, pPropertySet);
1252 return E_NOTIMPL;
1253 }
1254
1255 static HRESULT WINAPI MimeBody_MoveProps(
1256 IMimeBody* iface,
1257 ULONG cNames,
1258 LPCSTR* prgszName,
1259 IMimePropertySet* pPropertySet)
1260 {
1261 MimeBody *This = impl_from_IMimeBody(iface);
1262 FIXME("(%p)->(%d, %p, %p) stub\n", This, cNames, prgszName, pPropertySet);
1263 return E_NOTIMPL;
1264 }
1265
1266 static HRESULT WINAPI MimeBody_DeleteExcept(
1267 IMimeBody* iface,
1268 ULONG cNames,
1269 LPCSTR* prgszName)
1270 {
1271 MimeBody *This = impl_from_IMimeBody(iface);
1272 FIXME("(%p)->(%d, %p) stub\n", This, cNames, prgszName);
1273 return E_NOTIMPL;
1274 }
1275
1276 static HRESULT WINAPI MimeBody_QueryProp(
1277 IMimeBody* iface,
1278 LPCSTR pszName,
1279 LPCSTR pszCriteria,
1280 boolean fSubString,
1281 boolean fCaseSensitive)
1282 {
1283 MimeBody *This = impl_from_IMimeBody(iface);
1284 FIXME("(%p)->(%s, %s, %d, %d) stub\n", This, debugstr_a(pszName), debugstr_a(pszCriteria), fSubString, fCaseSensitive);
1285 return E_NOTIMPL;
1286 }
1287
1288 static HRESULT WINAPI MimeBody_GetCharset(
1289 IMimeBody* iface,
1290 LPHCHARSET phCharset)
1291 {
1292 MimeBody *This = impl_from_IMimeBody(iface);
1293 FIXME("(%p)->(%p) stub\n", This, phCharset);
1294 *phCharset = NULL;
1295 return S_OK;
1296 }
1297
1298 static HRESULT WINAPI MimeBody_SetCharset(
1299 IMimeBody* iface,
1300 HCHARSET hCharset,
1301 CSETAPPLYTYPE applytype)
1302 {
1303 MimeBody *This = impl_from_IMimeBody(iface);
1304 FIXME("(%p)->(%p, %d) stub\n", This, hCharset, applytype);
1305 return E_NOTIMPL;
1306 }
1307
1308 static HRESULT WINAPI MimeBody_GetParameters(
1309 IMimeBody* iface,
1310 LPCSTR pszName,
1311 ULONG* pcParams,
1312 LPMIMEPARAMINFO* pprgParam)
1313 {
1314 MimeBody *This = impl_from_IMimeBody(iface);
1315 HRESULT hr;
1316 header_t *header;
1317
1318 TRACE("(%p)->(%s, %p, %p)\n", iface, debugstr_a(pszName), pcParams, pprgParam);
1319
1320 *pprgParam = NULL;
1321 *pcParams = 0;
1322
1323 hr = find_prop(This, pszName, &header);
1324 if(hr != S_OK) return hr;
1325
1326 *pcParams = list_count(&header->params);
1327 if(*pcParams)
1328 {
1329 IMimeAllocator *alloc;
1330 param_t *param;
1331 MIMEPARAMINFO *info;
1332
1333 MimeOleGetAllocator(&alloc);
1334
1335 *pprgParam = info = IMimeAllocator_Alloc(alloc, *pcParams * sizeof(**pprgParam));
1336 LIST_FOR_EACH_ENTRY(param, &header->params, param_t, entry)
1337 {
1338 int len;
1339
1340 len = strlen(param->name) + 1;
1341 info->pszName = IMimeAllocator_Alloc(alloc, len);
1342 memcpy(info->pszName, param->name, len);
1343 len = strlen(param->value) + 1;
1344 info->pszData = IMimeAllocator_Alloc(alloc, len);
1345 memcpy(info->pszData, param->value, len);
1346 info++;
1347 }
1348 IMimeAllocator_Release(alloc);
1349 }
1350 return S_OK;
1351 }
1352
1353 static HRESULT WINAPI MimeBody_IsContentType(
1354 IMimeBody* iface,
1355 LPCSTR pszPriType,
1356 LPCSTR pszSubType)
1357 {
1358 MimeBody *This = impl_from_IMimeBody(iface);
1359
1360 TRACE("(%p)->(%s, %s)\n", This, debugstr_a(pszPriType), debugstr_a(pszSubType));
1361 if(pszPriType)
1362 {
1363 const char *pri = This->content_pri_type;
1364 if(!pri) pri = "text";
1365 if(lstrcmpiA(pri, pszPriType)) return S_FALSE;
1366 }
1367
1368 if(pszSubType)
1369 {
1370 const char *sub = This->content_sub_type;
1371 if(!sub) sub = "plain";
1372 if(lstrcmpiA(sub, pszSubType)) return S_FALSE;
1373 }
1374
1375 return S_OK;
1376 }
1377
1378 static HRESULT WINAPI MimeBody_BindToObject(
1379 IMimeBody* iface,
1380 REFIID riid,
1381 void** ppvObject)
1382 {
1383 MimeBody *This = impl_from_IMimeBody(iface);
1384 FIXME("(%p)->(%s, %p) stub\n", This, debugstr_guid(riid), ppvObject);
1385 return E_NOTIMPL;
1386 }
1387
1388 static HRESULT WINAPI MimeBody_Clone(
1389 IMimeBody* iface,
1390 IMimePropertySet** ppPropertySet)
1391 {
1392 MimeBody *This = impl_from_IMimeBody(iface);
1393 FIXME("(%p)->(%p) stub\n", This, ppPropertySet);
1394 return E_NOTIMPL;
1395 }
1396
1397 static HRESULT WINAPI MimeBody_SetOption(
1398 IMimeBody* iface,
1399 const TYPEDID oid,
1400 LPCPROPVARIANT pValue)
1401 {
1402 MimeBody *This = impl_from_IMimeBody(iface);
1403 HRESULT hr = E_NOTIMPL;
1404 TRACE("(%p)->(%08x, %p)\n", This, oid, pValue);
1405
1406 if(pValue->vt != TYPEDID_TYPE(oid))
1407 {
1408 WARN("Called with vartype %04x and oid %08x\n", pValue->vt, oid);
1409 return E_INVALIDARG;
1410 }
1411
1412 switch(oid)
1413 {
1414 case OID_SECURITY_HWND_OWNER:
1415 FIXME("OID_SECURITY_HWND_OWNER (value %08x): ignoring\n", pValue->u.ulVal);
1416 hr = S_OK;
1417 break;
1418 case OID_TRANSMIT_BODY_ENCODING:
1419 FIXME("OID_TRANSMIT_BODY_ENCODING (value %08x): ignoring\n", pValue->u.ulVal);
1420 hr = S_OK;
1421 break;
1422 default:
1423 FIXME("Unhandled oid %08x\n", oid);
1424 }
1425
1426 return hr;
1427 }
1428
1429 static HRESULT WINAPI MimeBody_GetOption(
1430 IMimeBody* iface,
1431 const TYPEDID oid,
1432 LPPROPVARIANT pValue)
1433 {
1434 MimeBody *This = impl_from_IMimeBody(iface);
1435 FIXME("(%p)->(%08x, %p): stub\n", This, oid, pValue);
1436 return E_NOTIMPL;
1437 }
1438
1439 static HRESULT WINAPI MimeBody_EnumProps(
1440 IMimeBody* iface,
1441 DWORD dwFlags,
1442 IMimeEnumProperties** ppEnum)
1443 {
1444 MimeBody *This = impl_from_IMimeBody(iface);
1445 FIXME("(%p)->(0x%x, %p) stub\n", This, dwFlags, ppEnum);
1446 return E_NOTIMPL;
1447 }
1448
1449 static HRESULT WINAPI MimeBody_IsType(
1450 IMimeBody* iface,
1451 IMSGBODYTYPE bodytype)
1452 {
1453 MimeBody *This = impl_from_IMimeBody(iface);
1454
1455 TRACE("(%p)->(%d)\n", This, bodytype);
1456 switch(bodytype)
1457 {
1458 case IBT_EMPTY:
1459 return This->data ? S_FALSE : S_OK;
1460 default:
1461 FIXME("Unimplemented bodytype %d - returning S_OK\n", bodytype);
1462 }
1463 return S_OK;
1464 }
1465
1466 static HRESULT WINAPI MimeBody_SetDisplayName(
1467 IMimeBody* iface,
1468 LPCSTR pszDisplay)
1469 {
1470 MimeBody *This = impl_from_IMimeBody(iface);
1471 FIXME("(%p)->(%s) stub\n", This, debugstr_a(pszDisplay));
1472 return E_NOTIMPL;
1473 }
1474
1475 static HRESULT WINAPI MimeBody_GetDisplayName(
1476 IMimeBody* iface,
1477 LPSTR* ppszDisplay)
1478 {
1479 MimeBody *This = impl_from_IMimeBody(iface);
1480 FIXME("(%p)->(%p) stub\n", This, ppszDisplay);
1481 return E_NOTIMPL;
1482 }
1483
1484 static HRESULT WINAPI MimeBody_GetOffsets(
1485 IMimeBody* iface,
1486 LPBODYOFFSETS pOffsets)
1487 {
1488 MimeBody *This = impl_from_IMimeBody(iface);
1489 TRACE("(%p)->(%p)\n", This, pOffsets);
1490
1491 *pOffsets = This->body_offsets;
1492
1493 if(This->body_offsets.cbBodyEnd == 0) return MIME_E_NO_DATA;
1494 return S_OK;
1495 }
1496
1497 static HRESULT WINAPI MimeBody_GetCurrentEncoding(
1498 IMimeBody* iface,
1499 ENCODINGTYPE* pietEncoding)
1500 {
1501 MimeBody *This = impl_from_IMimeBody(iface);
1502
1503 TRACE("(%p)->(%p)\n", This, pietEncoding);
1504
1505 *pietEncoding = This->encoding;
1506 return S_OK;
1507 }
1508
1509 static HRESULT WINAPI MimeBody_SetCurrentEncoding(
1510 IMimeBody* iface,
1511 ENCODINGTYPE ietEncoding)
1512 {
1513 MimeBody *This = impl_from_IMimeBody(iface);
1514
1515 TRACE("(%p)->(%d)\n", This, ietEncoding);
1516
1517 This->encoding = ietEncoding;
1518 return S_OK;
1519 }
1520
1521 static HRESULT WINAPI MimeBody_GetEstimatedSize(
1522 IMimeBody* iface,
1523 ENCODINGTYPE ietEncoding,
1524 ULONG* pcbSize)
1525 {
1526 MimeBody *This = impl_from_IMimeBody(iface);
1527 FIXME("(%p)->(%d, %p) stub\n", This, ietEncoding, pcbSize);
1528 return E_NOTIMPL;
1529 }
1530
1531 static HRESULT WINAPI MimeBody_GetDataHere(
1532 IMimeBody* iface,
1533 ENCODINGTYPE ietEncoding,
1534 IStream* pStream)
1535 {
1536 MimeBody *This = impl_from_IMimeBody(iface);
1537 FIXME("(%p)->(%d, %p) stub\n", This, ietEncoding, pStream);
1538 return E_NOTIMPL;
1539 }
1540
1541 static const signed char base64_decode_table[] =
1542 {
1543 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x00 */
1544 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 0x10 */
1545 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, /* 0x20 */
1546 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, /* 0x30 */
1547 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, /* 0x40 */
1548 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, /* 0x50 */
1549 -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, /* 0x60 */
1550 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1 /* 0x70 */
1551 };
1552
1553 static HRESULT decode_base64(IStream *input, IStream **ret_stream)
1554 {
1555 const unsigned char *ptr, *end;
1556 unsigned char buf[1024];
1557 LARGE_INTEGER pos;
1558 unsigned char *ret;
1559 unsigned char in[4];
1560 IStream *output;
1561 DWORD size;
1562 int n = 0;
1563 HRESULT hres;
1564
1565 pos.QuadPart = 0;
1566 hres = IStream_Seek(input, pos, STREAM_SEEK_SET, NULL);
1567 if(FAILED(hres))
1568 return hres;
1569
1570 hres = CreateStreamOnHGlobal(NULL, TRUE, &output);
1571 if(FAILED(hres))
1572 return hres;
1573
1574 while(1) {
1575 hres = IStream_Read(input, buf, sizeof(buf), &size);
1576 if(FAILED(hres) || !size)
1577 break;
1578
1579 ptr = ret = buf;
1580 end = buf + size;
1581
1582 while(1) {
1583 /* skip invalid chars */
1584 while(ptr < end && (*ptr >= ARRAY_SIZE(base64_decode_table)
1585 || base64_decode_table[*ptr] == -1))
1586 ptr++;
1587 if(ptr == end)
1588 break;
1589
1590 in[n++] = base64_decode_table[*ptr++];
1591 switch(n) {
1592 case 2:
1593 *ret++ = in[0] << 2 | in[1] >> 4;
1594 continue;
1595 case 3:
1596 *ret++ = in[1] << 4 | in[2] >> 2;
1597 continue;
1598 case 4:
1599 *ret++ = ((in[2] << 6) & 0xc0) | in[3];
1600 n = 0;
1601 }
1602 }
1603
1604 if(ret > buf) {
1605 hres = IStream_Write(output, buf, ret - buf, NULL);
1606 if(FAILED(hres))
1607 break;
1608 }
1609 }
1610
1611 if(SUCCEEDED(hres))
1612 hres = IStream_Seek(output, pos, STREAM_SEEK_SET, NULL);
1613 if(FAILED(hres)) {
1614 IStream_Release(output);
1615 return hres;
1616 }
1617
1618 *ret_stream = output;
1619 return S_OK;
1620 }
1621
1622 static int hex_digit(char c)
1623 {
1624 if('0' <= c && c <= '9')
1625 return c - '0';
1626 if('A' <= c && c <= 'F')
1627 return c - 'A' + 10;
1628 if('a' <= c && c <= 'f')
1629 return c - 'a' + 10;
1630 return -1;
1631 }
1632
1633 static HRESULT decode_qp(IStream *input, IStream **ret_stream)
1634 {
1635 const unsigned char *ptr, *end;
1636 unsigned char *ret, prev = 0;
1637 unsigned char buf[1024];
1638 LARGE_INTEGER pos;
1639 IStream *output;
1640 DWORD size;
1641 int n = -1;
1642 HRESULT hres;
1643
1644 pos.QuadPart = 0;
1645 hres = IStream_Seek(input, pos, STREAM_SEEK_SET, NULL);
1646 if(FAILED(hres))
1647 return hres;
1648
1649 hres = CreateStreamOnHGlobal(NULL, TRUE, &output);
1650 if(FAILED(hres))
1651 return hres;
1652
1653 while(1) {
1654 hres = IStream_Read(input, buf, sizeof(buf), &size);
1655 if(FAILED(hres) || !size)
1656 break;
1657
1658 ptr = ret = buf;
1659 end = buf + size;
1660
1661 while(ptr < end) {
1662 unsigned char byte = *ptr++;
1663
1664 switch(n) {
1665 case -1:
1666 if(byte == '=')
1667 n = 0;
1668 else
1669 *ret++ = byte;
1670 continue;
1671 case 0:
1672 prev = byte;
1673 n = 1;
1674 continue;
1675 case 1:
1676 if(prev != '\r' || byte != '\n') {
1677 int h1 = hex_digit(prev), h2 = hex_digit(byte);
1678 if(h1 != -1 && h2 != -1)
1679 *ret++ = (h1 << 4) | h2;
1680 else
1681 *ret++ = '=';
1682 }
1683 n = -1;
1684 continue;
1685 }
1686 }
1687
1688 if(ret > buf) {
1689 hres = IStream_Write(output, buf, ret - buf, NULL);
1690 if(FAILED(hres))
1691 break;
1692 }
1693 }
1694
1695 if(SUCCEEDED(hres))
1696 hres = IStream_Seek(output, pos, STREAM_SEEK_SET, NULL);
1697 if(FAILED(hres)) {
1698 IStream_Release(output);
1699 return hres;
1700 }
1701
1702 *ret_stream = output;
1703 return S_OK;
1704 }
1705
1706 static HRESULT WINAPI MimeBody_GetData(
1707 IMimeBody* iface,
1708 ENCODINGTYPE ietEncoding,
1709 IStream** ppStream)
1710 {
1711 MimeBody *This = impl_from_IMimeBody(iface);
1712 ULARGE_INTEGER start, size;
1713 HRESULT hres;
1714
1715 TRACE("(%p)->(%d %p)\n", This, ietEncoding, ppStream);
1716
1717 if(This->encoding != ietEncoding) {
1718 switch(This->encoding) {
1719 case IET_BASE64:
1720 hres = decode_base64(This->data, ppStream);
1721 break;
1722 case IET_QP:
1723 hres = decode_qp(This->data, ppStream);
1724 break;
1725 default:
1726 FIXME("Decoding %d is not supported.\n", This->encoding);
1727 hres = S_FALSE;
1728 }
1729 if(ietEncoding != IET_BINARY)
1730 FIXME("Encoding %d is not supported.\n", ietEncoding);
1731 if(hres != S_FALSE)
1732 return hres;
1733 }
1734
1735 start.QuadPart = 0;
1736 hres = get_stream_size(This->data, &size);
1737 if(SUCCEEDED(hres))
1738 hres = create_sub_stream(This->data, start, size, ppStream);
1739 return hres;
1740 }
1741
1742 static HRESULT WINAPI MimeBody_SetData(
1743 IMimeBody* iface,
1744 ENCODINGTYPE ietEncoding,
1745 LPCSTR pszPriType,
1746 LPCSTR pszSubType,
1747 REFIID riid,
1748 LPVOID pvObject)
1749 {
1750 MimeBody *This = impl_from_IMimeBody(iface);
1751 TRACE("(%p)->(%d, %s, %s, %s %p)\n", This, ietEncoding, debugstr_a(pszPriType), debugstr_a(pszSubType),
1752 debugstr_guid(riid), pvObject);
1753
1754 if(IsEqualIID(riid, &IID_IStream))
1755 IStream_AddRef((IStream *)pvObject);
1756 else
1757 {
1758 FIXME("Unhandled object type %s\n", debugstr_guid(riid));
1759 return E_INVALIDARG;
1760 }
1761
1762 if(This->data)
1763 release_data(&This->data_iid, This->data);
1764
1765 This->data_iid = *riid;
1766 This->data = pvObject;
1767
1768 IMimeBody_SetCurrentEncoding(iface, ietEncoding);
1769
1770 /* FIXME: Update the content type.
1771 If pszPriType == NULL use 'application'
1772 If pszSubType == NULL use 'octet-stream' */
1773
1774 return S_OK;
1775 }
1776
1777 static HRESULT WINAPI MimeBody_EmptyData(
1778 IMimeBody* iface)
1779 {
1780 MimeBody *This = impl_from_IMimeBody(iface);
1781 FIXME("(%p)->() stub\n", This);
1782 return E_NOTIMPL;
1783 }
1784
1785 static HRESULT WINAPI MimeBody_CopyTo(
1786 IMimeBody* iface,
1787 IMimeBody* pBody)
1788 {
1789 MimeBody *This = impl_from_IMimeBody(iface);
1790 FIXME("(%p)->(%p) stub\n", This, pBody);
1791 return E_NOTIMPL;
1792 }
1793
1794 static HRESULT WINAPI MimeBody_GetTransmitInfo(
1795 IMimeBody* iface,
1796 LPTRANSMITINFO pTransmitInfo)
1797 {
1798 MimeBody *This = impl_from_IMimeBody(iface);
1799 FIXME("(%p)->(%p) stub\n", This, pTransmitInfo);
1800 return E_NOTIMPL;
1801 }
1802
1803 static HRESULT WINAPI MimeBody_SaveToFile(
1804 IMimeBody* iface,
1805 ENCODINGTYPE ietEncoding,
1806 LPCSTR pszFilePath)
1807 {
1808 MimeBody *This = impl_from_IMimeBody(iface);
1809 FIXME("(%p)->(%d, %s) stub\n", This, ietEncoding, debugstr_a(pszFilePath));
1810 return E_NOTIMPL;
1811 }
1812
1813 static HRESULT WINAPI MimeBody_GetHandle(
1814 IMimeBody* iface,
1815 LPHBODY phBody)
1816 {
1817 MimeBody *This = impl_from_IMimeBody(iface);
1818 TRACE("(%p)->(%p)\n", iface, phBody);
1819
1820 if(!phBody)
1821 return E_INVALIDARG;
1822
1823 *phBody = This->handle;
1824 return This->handle ? S_OK : MIME_E_NO_DATA;
1825 }
1826
1827 static IMimeBodyVtbl body_vtbl =
1828 {
1829 MimeBody_QueryInterface,
1830 MimeBody_AddRef,
1831 MimeBody_Release,
1832 MimeBody_GetClassID,
1833 MimeBody_IsDirty,
1834 MimeBody_Load,
1835 MimeBody_Save,
1836 MimeBody_GetSizeMax,
1837 MimeBody_InitNew,
1838 MimeBody_GetPropInfo,
1839 MimeBody_SetPropInfo,
1840 MimeBody_GetProp,
1841 MimeBody_SetProp,
1842 MimeBody_AppendProp,
1843 MimeBody_DeleteProp,
1844 MimeBody_CopyProps,
1845 MimeBody_MoveProps,
1846 MimeBody_DeleteExcept,
1847 MimeBody_QueryProp,
1848 MimeBody_GetCharset,
1849 MimeBody_SetCharset,
1850 MimeBody_GetParameters,
1851 MimeBody_IsContentType,
1852 MimeBody_BindToObject,
1853 MimeBody_Clone,
1854 MimeBody_SetOption,
1855 MimeBody_GetOption,
1856 MimeBody_EnumProps,
1857 MimeBody_IsType,
1858 MimeBody_SetDisplayName,
1859 MimeBody_GetDisplayName,
1860 MimeBody_GetOffsets,
1861 MimeBody_GetCurrentEncoding,
1862 MimeBody_SetCurrentEncoding,
1863 MimeBody_GetEstimatedSize,
1864 MimeBody_GetDataHere,
1865 MimeBody_GetData,
1866 MimeBody_SetData,
1867 MimeBody_EmptyData,
1868 MimeBody_CopyTo,
1869 MimeBody_GetTransmitInfo,
1870 MimeBody_SaveToFile,
1871 MimeBody_GetHandle
1872 };
1873
1874 static HRESULT MimeBody_set_offsets(MimeBody *body, const BODYOFFSETS *offsets)
1875 {
1876 TRACE("setting offsets to %d, %d, %d, %d\n", offsets->cbBoundaryStart,
1877 offsets->cbHeaderStart, offsets->cbBodyStart, offsets->cbBodyEnd);
1878
1879 body->body_offsets = *offsets;
1880 return S_OK;
1881 }
1882
1883 #define FIRST_CUSTOM_PROP_ID 0x100
1884
1885 static MimeBody *mimebody_create(void)
1886 {
1887 MimeBody *This;
1888 BODYOFFSETS body_offsets;
1889
1890 This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1891 if (!This)
1892 return NULL;
1893
1894 This->IMimeBody_iface.lpVtbl = &body_vtbl;
1895 This->ref = 1;
1896 This->handle = NULL;
1897 list_init(&This->headers);
1898 list_init(&This->new_props);
1899 This->next_prop_id = FIRST_CUSTOM_PROP_ID;
1900 This->content_pri_type = NULL;
1901 This->content_sub_type = NULL;
1902 This->encoding = IET_7BIT;
1903 This->data = NULL;
1904 This->data_iid = IID_NULL;
1905
1906 body_offsets.cbBoundaryStart = body_offsets.cbHeaderStart = 0;
1907 body_offsets.cbBodyStart = body_offsets.cbBodyEnd = 0;
1908 MimeBody_set_offsets(This, &body_offsets);
1909
1910 return This;
1911 }
1912
1913 HRESULT MimeBody_create(IUnknown *outer, void **ppv)
1914 {
1915 MimeBody *mb;
1916
1917 if(outer)
1918 return CLASS_E_NOAGGREGATION;
1919
1920 if ((mb = mimebody_create()))
1921 {
1922 *ppv = &mb->IMimeBody_iface;
1923 return S_OK;
1924 }
1925 else
1926 {
1927 *ppv = NULL;
1928 return E_OUTOFMEMORY;
1929 }
1930 }
1931
1932 typedef struct body_t
1933 {
1934 struct list entry;
1935 DWORD index;
1936 MimeBody *mime_body;
1937
1938 struct body_t *parent;
1939 struct list children;
1940 } body_t;
1941
1942 typedef struct MimeMessage
1943 {
1944 IMimeMessage IMimeMessage_iface;
1945 LONG ref;
1946 IStream *stream;
1947
1948 struct list body_tree;
1949 DWORD next_index;
1950 } MimeMessage;
1951
1952 static inline MimeMessage *impl_from_IMimeMessage(IMimeMessage *iface)
1953 {
1954 return CONTAINING_RECORD(iface, MimeMessage, IMimeMessage_iface);
1955 }
1956
1957 static HRESULT WINAPI MimeMessage_QueryInterface(IMimeMessage *iface, REFIID riid, void **ppv)
1958 {
1959 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
1960
1961 if (IsEqualIID(riid, &IID_IUnknown) ||
1962 IsEqualIID(riid, &IID_IPersist) ||
1963 IsEqualIID(riid, &IID_IPersistStreamInit) ||
1964 IsEqualIID(riid, &IID_IMimeMessageTree) ||
1965 IsEqualIID(riid, &IID_IMimeMessage))
1966 {
1967 *ppv = iface;
1968 IMimeMessage_AddRef(iface);
1969 return S_OK;
1970 }
1971
1972 FIXME("no interface for %s\n", debugstr_guid(riid));
1973 *ppv = NULL;
1974 return E_NOINTERFACE;
1975 }
1976
1977 static ULONG WINAPI MimeMessage_AddRef(IMimeMessage *iface)
1978 {
1979 MimeMessage *This = impl_from_IMimeMessage(iface);
1980 ULONG ref = InterlockedIncrement(&This->ref);
1981
1982 TRACE("(%p) ref=%d\n", This, ref);
1983
1984 return ref;
1985 }
1986
1987 static void empty_body_list(struct list *list)
1988 {
1989 body_t *body, *cursor2;
1990 LIST_FOR_EACH_ENTRY_SAFE(body, cursor2, list, body_t, entry)
1991 {
1992 empty_body_list(&body->children);
1993 list_remove(&body->entry);
1994 IMimeBody_Release(&body->mime_body->IMimeBody_iface);
1995 HeapFree(GetProcessHeap(), 0, body);
1996 }
1997 }
1998
1999 static ULONG WINAPI MimeMessage_Release(IMimeMessage *iface)
2000 {
2001 MimeMessage *This = impl_from_IMimeMessage(iface);
2002 ULONG ref = InterlockedDecrement(&This->ref);
2003
2004 TRACE("(%p) ref=%d\n", This, ref);
2005
2006 if (!ref)
2007 {
2008 empty_body_list(&This->body_tree);
2009
2010 if(This->stream) IStream_Release(This->stream);
2011 HeapFree(GetProcessHeap(), 0, This);
2012 }
2013
2014 return ref;
2015 }
2016
2017 /*** IPersist methods ***/
2018 static HRESULT WINAPI MimeMessage_GetClassID(
2019 IMimeMessage *iface,
2020 CLSID *pClassID)
2021 {
2022 FIXME("(%p)->(%p)\n", iface, pClassID);
2023 return E_NOTIMPL;
2024 }
2025
2026 /*** IPersistStreamInit methods ***/
2027 static HRESULT WINAPI MimeMessage_IsDirty(
2028 IMimeMessage *iface)
2029 {
2030 FIXME("(%p)->()\n", iface);
2031 return E_NOTIMPL;
2032 }
2033
2034 static body_t *new_body_entry(MimeBody *mime_body, DWORD index, body_t *parent)
2035 {
2036 body_t *body = HeapAlloc(GetProcessHeap(), 0, sizeof(*body));
2037 if(body)
2038 {
2039 body->mime_body = mime_body;
2040 body->index = index;
2041 list_init(&body->children);
2042 body->parent = parent;
2043
2044 mime_body->handle = UlongToHandle(body->index);
2045 }
2046 return body;
2047 }
2048
2049 typedef struct
2050 {
2051 struct list entry;
2052 BODYOFFSETS offsets;
2053 } offset_entry_t;
2054
2055 static HRESULT create_body_offset_list(IStream *stm, const char *boundary, struct list *body_offsets)
2056 {
2057 HRESULT hr;
2058 DWORD read, boundary_start;
2059 int boundary_len = strlen(boundary);
2060 char *buf, *ptr, *overlap;
2061 DWORD start = 0, overlap_no;
2062 offset_entry_t *cur_body = NULL;
2063 BOOL is_first_line = TRUE;
2064 ULARGE_INTEGER cur;
2065 LARGE_INTEGER zero;
2066
2067 list_init(body_offsets);
2068
2069 overlap_no = boundary_len + 5;
2070
2071 overlap = buf = HeapAlloc(GetProcessHeap(), 0, overlap_no + PARSER_BUF_SIZE + 1);
2072
2073 zero.QuadPart = 0;
2074 hr = IStream_Seek(stm, zero, STREAM_SEEK_CUR, &cur);
2075 start = cur.u.LowPart;
2076
2077 do {
2078 hr = IStream_Read(stm, overlap, PARSER_BUF_SIZE, &read);
2079 if(FAILED(hr)) goto end;
2080 if(read == 0) break;
2081 overlap[read] = '\0';
2082
2083 ptr = buf;
2084 while(1) {
2085 if(is_first_line) {
2086 is_first_line = FALSE;
2087 }else {
2088 ptr = strstr(ptr, "\r\n");
2089 if(!ptr)
2090 break;
2091 ptr += 2;
2092 }
2093
2094 boundary_start = start + ptr - buf;
2095
2096 if(*ptr == '-' && *(ptr + 1) == '-' && !memcmp(ptr + 2, boundary, boundary_len)) {
2097 ptr += boundary_len + 2;
2098
2099 if(*ptr == '\r' && *(ptr + 1) == '\n')
2100 {
2101 ptr += 2;
2102 if(cur_body)
2103 {
2104 cur_body->offsets.cbBodyEnd = boundary_start - 2;
2105 list_add_tail(body_offsets, &cur_body->entry);
2106 }
2107 cur_body = HeapAlloc(GetProcessHeap(), 0, sizeof(*cur_body));
2108 cur_body->offsets.cbBoundaryStart = boundary_start;
2109 cur_body->offsets.cbHeaderStart = start + ptr - buf;
2110 }
2111 else if(*ptr == '-' && *(ptr + 1) == '-')
2112 {
2113 if(cur_body)
2114 {
2115 cur_body->offsets.cbBodyEnd = boundary_start - 2;
2116 list_add_tail(body_offsets, &cur_body->entry);
2117 goto end;
2118 }
2119 }
2120 }
2121 }
2122
2123 if(overlap == buf) /* 1st iteration */
2124 {
2125 memmove(buf, buf + PARSER_BUF_SIZE - overlap_no, overlap_no);
2126 overlap = buf + overlap_no;
2127 start += read - overlap_no;
2128 }
2129 else
2130 {
2131 memmove(buf, buf + PARSER_BUF_SIZE, overlap_no);
2132 start += read;
2133 }
2134 } while(1);
2135
2136 end:
2137 HeapFree(GetProcessHeap(), 0, buf);
2138 return hr;
2139 }
2140
2141 static body_t *create_sub_body(MimeMessage *msg, IStream *pStm, BODYOFFSETS *offset, body_t *parent)
2142 {
2143 ULARGE_INTEGER start, length;
2144 MimeBody *mime_body;
2145 HRESULT hr;
2146 body_t *body;
2147 LARGE_INTEGER pos;
2148
2149 pos.QuadPart = offset->cbHeaderStart;
2150 IStream_Seek(pStm, pos, STREAM_SEEK_SET, NULL);
2151
2152 mime_body = mimebody_create();
2153 IMimeBody_Load(&mime_body->IMimeBody_iface, pStm);
2154
2155 pos.QuadPart = 0;
2156 hr = IStream_Seek(pStm, pos, STREAM_SEEK_CUR, &start);
2157 offset->cbBodyStart = start.QuadPart;
2158 if (parent) MimeBody_set_offsets(mime_body, offset);
2159
2160 length.QuadPart = offset->cbBodyEnd - offset->cbBodyStart;
2161 create_sub_stream(pStm, start, length, (IStream**)&mime_body->data);
2162 mime_body->data_iid = IID_IStream;
2163
2164 body = new_body_entry(mime_body, msg->next_index++, parent);
2165
2166 if(IMimeBody_IsContentType(&mime_body->IMimeBody_iface, "multipart", NULL) == S_OK)
2167 {
2168 MIMEPARAMINFO *param_info;
2169 ULONG count, i;
2170 IMimeAllocator *alloc;
2171
2172 hr = IMimeBody_GetParameters(&mime_body->IMimeBody_iface, "Content-Type", &count,
2173 &param_info);
2174 if(hr != S_OK || count == 0) return body;
2175
2176 MimeOleGetAllocator(&alloc);
2177
2178 for(i = 0; i < count; i++)
2179 {
2180 if(!lstrcmpiA(param_info[i].pszName, "boundary"))
2181 {
2182 struct list offset_list;
2183 offset_entry_t *cur, *cursor2;
2184 hr = create_body_offset_list(pStm, param_info[i].pszData, &offset_list);
2185 LIST_FOR_EACH_ENTRY_SAFE(cur, cursor2, &offset_list, offset_entry_t, entry)
2186 {
2187 body_t *sub_body;
2188
2189 sub_body = create_sub_body(msg, pStm, &cur->offsets, body);
2190 list_add_tail(&body->children, &sub_body->entry);
2191 list_remove(&cur->entry);
2192 HeapFree(GetProcessHeap(), 0, cur);
2193 }
2194 break;
2195 }
2196 }
2197 IMimeAllocator_FreeParamInfoArray(alloc, count, param_info, TRUE);
2198 IMimeAllocator_Release(alloc);
2199 }
2200 return body;
2201 }
2202
2203 static HRESULT WINAPI MimeMessage_Load(IMimeMessage *iface, IStream *pStm)
2204 {
2205 MimeMessage *This = impl_from_IMimeMessage(iface);
2206 body_t *root_body;
2207 BODYOFFSETS offsets;
2208 ULARGE_INTEGER cur;
2209 LARGE_INTEGER zero;
2210
2211 TRACE("(%p)->(%p)\n", iface, pStm);
2212
2213 if(This->stream)
2214 {
2215 FIXME("already loaded a message\n");
2216 return E_FAIL;
2217 }
2218
2219 empty_body_list(&This->body_tree);
2220
2221 IStream_AddRef(pStm);
2222 This->stream = pStm;
2223 offsets.cbBoundaryStart = offsets.cbHeaderStart = 0;
2224 offsets.cbBodyStart = offsets.cbBodyEnd = 0;
2225
2226 root_body = create_sub_body(This, pStm, &offsets, NULL);
2227
2228 zero.QuadPart = 0;
2229 IStream_Seek(pStm, zero, STREAM_SEEK_END, &cur);
2230 offsets.cbBodyEnd = cur.u.LowPart;
2231 MimeBody_set_offsets(root_body->mime_body, &offsets);
2232
2233 list_add_head(&This->body_tree, &root_body->entry);
2234
2235 return S_OK;
2236 }
2237
2238 static HRESULT WINAPI MimeMessage_Save(IMimeMessage *iface, IStream *pStm, BOOL fClearDirty)
2239 {
2240 FIXME("(%p)->(%p, %s)\n", iface, pStm, fClearDirty ? "TRUE" : "FALSE");
2241 return E_NOTIMPL;
2242 }
2243
2244 static HRESULT WINAPI MimeMessage_GetSizeMax(
2245 IMimeMessage *iface,
2246 ULARGE_INTEGER *pcbSize)
2247 {
2248 FIXME("(%p)->(%p)\n", iface, pcbSize);
2249 return E_NOTIMPL;
2250 }
2251
2252 static HRESULT WINAPI MimeMessage_InitNew(
2253 IMimeMessage *iface)
2254 {
2255 FIXME("(%p)->()\n", iface);
2256 return E_NOTIMPL;
2257 }
2258
2259 /*** IMimeMessageTree methods ***/
2260 static HRESULT WINAPI MimeMessage_GetMessageSource(IMimeMessage *iface, IStream **ppStream,
2261 DWORD dwFlags)
2262 {
2263 MimeMessage *This = impl_from_IMimeMessage(iface);
2264
2265 FIXME("(%p)->(%p, 0x%x)\n", iface, ppStream, dwFlags);
2266
2267 IStream_AddRef(This->stream);
2268 *ppStream = This->stream;
2269 return S_OK;
2270 }
2271
2272 static HRESULT WINAPI MimeMessage_GetMessageSize(
2273 IMimeMessage *iface,
2274 ULONG *pcbSize,
2275 DWORD dwFlags)
2276 {
2277 FIXME("(%p)->(%p, 0x%x)\n", iface, pcbSize, dwFlags);
2278 return E_NOTIMPL;
2279 }
2280
2281 static HRESULT WINAPI MimeMessage_LoadOffsetTable(
2282 IMimeMessage *iface,
2283 IStream *pStream)
2284 {
2285 FIXME("(%p)->(%p)\n", iface, pStream);
2286 return E_NOTIMPL;
2287 }
2288
2289 static HRESULT WINAPI MimeMessage_SaveOffsetTable(
2290 IMimeMessage *iface,
2291 IStream *pStream,
2292 DWORD dwFlags)
2293 {
2294 FIXME("(%p)->(%p, 0x%x)\n", iface, pStream, dwFlags);
2295 return E_NOTIMPL;
2296 }
2297
2298
2299 static HRESULT WINAPI MimeMessage_GetFlags(
2300 IMimeMessage *iface,
2301 DWORD *pdwFlags)
2302 {
2303 FIXME("(%p)->(%p)\n", iface, pdwFlags);
2304 return E_NOTIMPL;
2305 }
2306
2307 static HRESULT WINAPI MimeMessage_Commit(
2308 IMimeMessage *iface,
2309 DWORD dwFlags)
2310 {
2311 FIXME("(%p)->(0x%x)\n", iface, dwFlags);
2312 return S_OK;
2313 }
2314
2315
2316 static HRESULT WINAPI MimeMessage_HandsOffStorage(
2317 IMimeMessage *iface)
2318 {
2319 FIXME("(%p)->()\n", iface);
2320 return E_NOTIMPL;
2321 }
2322
2323 static HRESULT find_body(struct list *list, HBODY hbody, body_t **body)
2324 {
2325 body_t *cur;
2326 HRESULT hr;
2327
2328 if(hbody == HBODY_ROOT)
2329 {
2330 *body = LIST_ENTRY(list_head(list), body_t, entry);
2331 return S_OK;
2332 }
2333
2334 LIST_FOR_EACH_ENTRY(cur, list, body_t, entry)
2335 {
2336 if(cur->index == HandleToUlong(hbody))
2337 {
2338 *body = cur;
2339 return S_OK;
2340 }
2341 hr = find_body(&cur->children, hbody, body);
2342 if(hr == S_OK) return S_OK;
2343 }
2344 return S_FALSE;
2345 }
2346
2347 static HRESULT WINAPI MimeMessage_BindToObject(IMimeMessage *iface, const HBODY hBody, REFIID riid,
2348 void **ppvObject)
2349 {
2350 MimeMessage *This = impl_from_IMimeMessage(iface);
2351 HRESULT hr;
2352 body_t *body;
2353
2354 TRACE("(%p)->(%p, %s, %p)\n", iface, hBody, debugstr_guid(riid), ppvObject);
2355
2356 hr = find_body(&This->body_tree, hBody, &body);
2357
2358 if(hr != S_OK) return hr;
2359
2360 if(IsEqualIID(riid, &IID_IMimeBody))
2361 {
2362 IMimeBody_AddRef(&body->mime_body->IMimeBody_iface);
2363 *ppvObject = &body->mime_body->IMimeBody_iface;
2364 return S_OK;
2365 }
2366
2367 return E_NOINTERFACE;
2368 }
2369
2370 static HRESULT WINAPI MimeMessage_SaveBody(
2371 IMimeMessage *iface,
2372 HBODY hBody,
2373 DWORD dwFlags,
2374 IStream *pStream)
2375 {
2376 FIXME("(%p)->(%p, 0x%x, %p)\n", iface, hBody, dwFlags, pStream);
2377 return E_NOTIMPL;
2378 }
2379
2380 static HRESULT get_body(MimeMessage *msg, BODYLOCATION location, HBODY pivot, body_t **out)
2381 {
2382 body_t *root = LIST_ENTRY(list_head(&msg->body_tree), body_t, entry);
2383 body_t *body;
2384 HRESULT hr;
2385 struct list *list;
2386
2387 if(location == IBL_ROOT)
2388 {
2389 *out = root;
2390 return S_OK;
2391 }
2392
2393 hr = find_body(&msg->body_tree, pivot, &body);
2394
2395 if(hr == S_OK)
2396 {
2397 switch(location)
2398 {
2399 case IBL_PARENT:
2400 if(body->parent)
2401 *out = body->parent;
2402 else
2403 hr = MIME_E_NOT_FOUND;
2404 break;
2405
2406 case IBL_FIRST:
2407 list = list_head(&body->children);
2408 if(list)
2409 *out = LIST_ENTRY(list, body_t, entry);
2410 else
2411 hr = MIME_E_NOT_FOUND;
2412 break;
2413
2414 case IBL_LAST:
2415 list = list_tail(&body->children);
2416 if(list)
2417 *out = LIST_ENTRY(list, body_t, entry);
2418 else
2419 hr = MIME_E_NOT_FOUND;
2420 break;
2421
2422 case IBL_NEXT:
2423 list = list_next(&body->parent->children, &body->entry);
2424 if(list)
2425 *out = LIST_ENTRY(list, body_t, entry);
2426 else
2427 hr = MIME_E_NOT_FOUND;
2428 break;
2429
2430 case IBL_PREVIOUS:
2431 list = list_prev(&body->parent->children, &body->entry);
2432 if(list)
2433 *out = LIST_ENTRY(list, body_t, entry);
2434 else
2435 hr = MIME_E_NOT_FOUND;
2436 break;
2437
2438 default:
2439 hr = E_FAIL;
2440 break;
2441 }
2442 }
2443
2444 return hr;
2445 }
2446
2447
2448 static HRESULT WINAPI MimeMessage_InsertBody(
2449 IMimeMessage *iface,
2450 BODYLOCATION location,
2451 HBODY hPivot,
2452 LPHBODY phBody)
2453 {
2454 FIXME("(%p)->(%d, %p, %p)\n", iface, location, hPivot, phBody);
2455 return E_NOTIMPL;
2456 }
2457
2458 static HRESULT WINAPI MimeMessage_GetBody(IMimeMessage *iface, BODYLOCATION location, HBODY hPivot,
2459 HBODY *phBody)
2460 {
2461 MimeMessage *This = impl_from_IMimeMessage(iface);
2462 body_t *body;
2463 HRESULT hr;
2464
2465 TRACE("(%p)->(%d, %p, %p)\n", iface, location, hPivot, phBody);
2466
2467 if(!phBody)
2468 return E_INVALIDARG;
2469
2470 *phBody = NULL;
2471
2472 hr = get_body(This, location, hPivot, &body);
2473
2474 if(hr == S_OK) *phBody = UlongToHandle(body->index);
2475
2476 return hr;
2477 }
2478
2479 static HRESULT WINAPI MimeMessage_DeleteBody(
2480 IMimeMessage *iface,
2481 HBODY hBody,
2482 DWORD dwFlags)
2483 {
2484 FIXME("(%p)->(%p, %08x)\n", iface, hBody, dwFlags);
2485 return E_NOTIMPL;
2486 }
2487
2488 static HRESULT WINAPI MimeMessage_MoveBody(
2489 IMimeMessage *iface,
2490 HBODY hBody,
2491 BODYLOCATION location)
2492 {
2493 FIXME("(%p)->(%d)\n", iface, location);
2494 return E_NOTIMPL;
2495 }
2496
2497 static void count_children(body_t *body, boolean recurse, ULONG *count)
2498 {
2499 body_t *child;
2500
2501 LIST_FOR_EACH_ENTRY(child, &body->children, body_t, entry)
2502 {
2503 (*count)++;
2504 if(recurse) count_children(child, recurse, count);
2505 }
2506 }
2507
2508 static HRESULT WINAPI MimeMessage_CountBodies(IMimeMessage *iface, HBODY hParent, boolean fRecurse,
2509 ULONG *pcBodies)
2510 {
2511 HRESULT hr;
2512 MimeMessage *This = impl_from_IMimeMessage(iface);
2513 body_t *body;
2514
2515 TRACE("(%p)->(%p, %s, %p)\n", iface, hParent, fRecurse ? "TRUE" : "FALSE", pcBodies);
2516
2517 hr = find_body(&This->body_tree, hParent, &body);
2518 if(hr != S_OK) return hr;
2519
2520 *pcBodies = 1;
2521 count_children(body, fRecurse, pcBodies);
2522
2523 return S_OK;
2524 }
2525
2526 static HRESULT find_next(MimeMessage *This, body_t *body, FINDBODY *find, HBODY *out)
2527 {
2528 struct list *ptr;
2529 HBODY next;
2530
2531 for (;;)
2532 {
2533 if (!body) ptr = list_head( &This->body_tree );
2534 else
2535 {
2536 ptr = list_head( &body->children );
2537 while (!ptr)
2538 {
2539 if (!body->parent) return MIME_E_NOT_FOUND;
2540 if (!(ptr = list_next( &body->parent->children, &body->entry ))) body = body->parent;
2541 }
2542 }
2543
2544 body = LIST_ENTRY( ptr, body_t, entry );
2545 next = UlongToHandle( body->index );
2546 find->dwReserved = body->index;
2547 if (IMimeBody_IsContentType(&body->mime_body->IMimeBody_iface, find->pszPriType,
2548 find->pszSubType) == S_OK)
2549 {
2550 *out = next;
2551 return S_OK;
2552 }
2553 }
2554 return MIME_E_NOT_FOUND;
2555 }
2556
2557 static HRESULT WINAPI MimeMessage_FindFirst(IMimeMessage *iface, FINDBODY *pFindBody, HBODY *phBody)
2558 {
2559 MimeMessage *This = impl_from_IMimeMessage(iface);
2560
2561 TRACE("(%p)->(%p, %p)\n", iface, pFindBody, phBody);
2562
2563 pFindBody->dwReserved = 0;
2564 return find_next(This, NULL, pFindBody, phBody);
2565 }
2566
2567 static HRESULT WINAPI MimeMessage_FindNext(IMimeMessage *iface, FINDBODY *pFindBody, HBODY *phBody)
2568 {
2569 MimeMessage *This = impl_from_IMimeMessage(iface);
2570 body_t *body;
2571 HRESULT hr;
2572
2573 TRACE("(%p)->(%p, %p)\n", iface, pFindBody, phBody);
2574
2575 hr = find_body( &This->body_tree, UlongToHandle( pFindBody->dwReserved ), &body );
2576 if (hr != S_OK) return MIME_E_NOT_FOUND;
2577 return find_next(This, body, pFindBody, phBody);
2578 }
2579
2580 static HRESULT WINAPI MimeMessage_ResolveURL(
2581 IMimeMessage *iface,
2582 HBODY hRelated,
2583 LPCSTR pszBase,
2584 LPCSTR pszURL,
2585 DWORD dwFlags,
2586 LPHBODY phBody)
2587 {
2588 FIXME("(%p)->(%p, %s, %s, 0x%x, %p)\n", iface, hRelated, pszBase, pszURL, dwFlags, phBody);
2589 return E_NOTIMPL;
2590 }
2591
2592 static HRESULT WINAPI MimeMessage_ToMultipart(
2593 IMimeMessage *iface,
2594 HBODY hBody,
2595 LPCSTR pszSubType,
2596 LPHBODY phMultipart)
2597 {
2598 FIXME("(%p)->(%p, %s, %p)\n", iface, hBody, pszSubType, phMultipart);
2599 return E_NOTIMPL;
2600 }
2601
2602 static HRESULT WINAPI MimeMessage_GetBodyOffsets(
2603 IMimeMessage *iface,
2604 HBODY hBody,
2605 LPBODYOFFSETS pOffsets)
2606 {
2607 FIXME("(%p)->(%p, %p)\n", iface, hBody, pOffsets);
2608 return E_NOTIMPL;
2609 }
2610
2611 static HRESULT WINAPI MimeMessage_GetCharset(
2612 IMimeMessage *iface,
2613 LPHCHARSET phCharset)
2614 {
2615 FIXME("(%p)->(%p)\n", iface, phCharset);
2616 *phCharset = NULL;
2617 return S_OK;
2618 }
2619
2620 static HRESULT WINAPI MimeMessage_SetCharset(
2621 IMimeMessage *iface,
2622 HCHARSET hCharset,
2623 CSETAPPLYTYPE applytype)
2624 {
2625 FIXME("(%p)->(%p, %d)\n", iface, hCharset, applytype);
2626 return E_NOTIMPL;
2627 }
2628
2629 static HRESULT WINAPI MimeMessage_IsBodyType(
2630 IMimeMessage *iface,
2631 HBODY hBody,
2632 IMSGBODYTYPE bodytype)
2633 {
2634 HRESULT hr;
2635 IMimeBody *mime_body;
2636 TRACE("(%p)->(%p, %d)\n", iface, hBody, bodytype);
2637
2638 hr = IMimeMessage_BindToObject(iface, hBody, &IID_IMimeBody, (void**)&mime_body);
2639 if(hr != S_OK) return hr;
2640
2641 hr = IMimeBody_IsType(mime_body, bodytype);
2642 MimeBody_Release(mime_body);
2643 return hr;
2644 }
2645
2646 static HRESULT WINAPI MimeMessage_IsContentType(
2647 IMimeMessage *iface,
2648 HBODY hBody,
2649 LPCSTR pszPriType,
2650 LPCSTR pszSubType)
2651 {
2652 HRESULT hr;
2653 IMimeBody *mime_body;
2654 TRACE("(%p)->(%p, %s, %s)\n", iface, hBody, debugstr_a(pszPriType),
2655 debugstr_a(pszSubType));
2656
2657 hr = IMimeMessage_BindToObject(iface, hBody, &IID_IMimeBody, (void**)&mime_body);
2658 if(FAILED(hr)) return hr;
2659
2660 hr = IMimeBody_IsContentType(mime_body, pszPriType, pszSubType);
2661 IMimeBody_Release(mime_body);
2662 return hr;
2663 }
2664
2665 static HRESULT WINAPI MimeMessage_QueryBodyProp(
2666 IMimeMessage *iface,
2667 HBODY hBody,
2668 LPCSTR pszName,
2669 LPCSTR pszCriteria,
2670 boolean fSubString,
2671 boolean fCaseSensitive)
2672 {
2673 FIXME("(%p)->(%p, %s, %s, %s, %s)\n", iface, hBody, pszName, pszCriteria, fSubString ? "TRUE" : "FALSE", fCaseSensitive ? "TRUE" : "FALSE");
2674 return E_NOTIMPL;
2675 }
2676
2677 static HRESULT WINAPI MimeMessage_GetBodyProp(
2678 IMimeMessage *iface,
2679 HBODY hBody,
2680 LPCSTR pszName,
2681 DWORD dwFlags,
2682 LPPROPVARIANT pValue)
2683 {
2684 HRESULT hr;
2685 IMimeBody *mime_body;
2686
2687 TRACE("(%p)->(%p, %s, 0x%x, %p)\n", iface, hBody, pszName, dwFlags, pValue);
2688
2689 hr = IMimeMessage_BindToObject(iface, hBody, &IID_IMimeBody, (void**)&mime_body);
2690 if(hr != S_OK) return hr;
2691
2692 hr = IMimeBody_GetProp(mime_body, pszName, dwFlags, pValue);
2693 IMimeBody_Release(mime_body);
2694
2695 return hr;
2696 }
2697
2698 static HRESULT WINAPI MimeMessage_SetBodyProp(
2699 IMimeMessage *iface,
2700 HBODY hBody,
2701 LPCSTR pszName,
2702 DWORD dwFlags,
2703 LPCPROPVARIANT pValue)
2704 {
2705 FIXME("(%p)->(%p, %s, 0x%x, %p)\n", iface, hBody, pszName, dwFlags, pValue);
2706 return E_NOTIMPL;
2707 }
2708
2709 static HRESULT WINAPI MimeMessage_DeleteBodyProp(
2710 IMimeMessage *iface,
2711 HBODY hBody,
2712 LPCSTR pszName)
2713 {
2714 FIXME("(%p)->(%p, %s)\n", iface, hBody, pszName);
2715 return E_NOTIMPL;
2716 }
2717
2718 static HRESULT WINAPI MimeMessage_SetOption(
2719 IMimeMessage *iface,
2720 const TYPEDID oid,
2721 LPCPROPVARIANT pValue)
2722 {
2723 HRESULT hr = S_OK;
2724 TRACE("(%p)->(%08x, %p)\n", iface, oid, pValue);
2725
2726 /* Message ID is checked before type.
2727 * OID 0x4D -> 0x56 and 0x58 aren't defined but will filtered out later.
2728 */
2729 if(TYPEDID_ID(oid) < TYPEDID_ID(OID_ALLOW_8BIT_HEADER) || TYPEDID_ID(oid) > TYPEDID_ID(OID_SECURITY_2KEY_CERT_BAG_64))
2730 {
2731 WARN("oid (%08x) out of range\n", oid);
2732 return MIME_E_INVALID_OPTION_ID;
2733 }
2734
2735 if(pValue->vt != TYPEDID_TYPE(oid))
2736 {
2737 WARN("Called with vartype %04x and oid %08x\n", pValue->vt, oid);
2738 return S_OK;
2739 }
2740
2741 switch(oid)
2742 {
2743 case OID_HIDE_TNEF_ATTACHMENTS:
2744 FIXME("OID_HIDE_TNEF_ATTACHMENTS (value %d): ignoring\n", pValue->u.boolVal);
2745 break;
2746 case OID_SHOW_MACBINARY:
2747 FIXME("OID_SHOW_MACBINARY (value %d): ignoring\n", pValue->u.boolVal);
2748 break;
2749 case OID_SAVEBODY_KEEPBOUNDARY:
2750 FIXME("OID_SAVEBODY_KEEPBOUNDARY (value %d): ignoring\n", pValue->u.boolVal);
2751 break;
2752 case OID_CLEANUP_TREE_ON_SAVE:
2753 FIXME("OID_CLEANUP_TREE_ON_SAVE (value %d): ignoring\n", pValue->u.boolVal);
2754 break;
2755 default:
2756 FIXME("Unhandled oid %08x\n", oid);
2757 hr = MIME_E_INVALID_OPTION_ID;
2758 }
2759
2760 return hr;
2761 }
2762
2763 static HRESULT WINAPI MimeMessage_GetOption(
2764 IMimeMessage *iface,
2765 const TYPEDID oid,
2766 LPPROPVARIANT pValue)
2767 {
2768 FIXME("(%p)->(%08x, %p)\n", iface, oid, pValue);
2769 return E_NOTIMPL;
2770 }
2771
2772 /*** IMimeMessage methods ***/
2773 static HRESULT WINAPI MimeMessage_CreateWebPage(
2774 IMimeMessage *iface,
2775 IStream *pRootStm,
2776 LPWEBPAGEOPTIONS pOptions,
2777 IMimeMessageCallback *pCallback,
2778 IMoniker **ppMoniker)
2779 {
2780 FIXME("(%p)->(%p, %p, %p, %p)\n", iface, pRootStm, pOptions, pCallback, ppMoniker);
2781 *ppMoniker = NULL;
2782 return E_NOTIMPL;
2783 }
2784
2785 static HRESULT WINAPI MimeMessage_GetProp(
2786 IMimeMessage *iface,
2787 LPCSTR pszName,
2788 DWORD dwFlags,
2789 LPPROPVARIANT pValue)
2790 {
2791 FIXME("(%p)->(%s, 0x%x, %p)\n", iface, pszName, dwFlags, pValue);
2792 return E_NOTIMPL;
2793 }
2794
2795 static HRESULT WINAPI MimeMessage_SetProp(
2796 IMimeMessage *iface,
2797 LPCSTR pszName,
2798 DWORD dwFlags,
2799 LPCPROPVARIANT pValue)
2800 {
2801 FIXME("(%p)->(%s, 0x%x, %p)\n", iface, pszName, dwFlags, pValue);
2802 return E_NOTIMPL;
2803 }
2804
2805 static HRESULT WINAPI MimeMessage_DeleteProp(
2806 IMimeMessage *iface,
2807 LPCSTR pszName)
2808 {
2809 FIXME("(%p)->(%s)\n", iface, pszName);
2810 return E_NOTIMPL;
2811 }
2812
2813 static HRESULT WINAPI MimeMessage_QueryProp(
2814 IMimeMessage *iface,
2815 LPCSTR pszName,
2816 LPCSTR pszCriteria,
2817 boolean fSubString,
2818 boolean fCaseSensitive)
2819 {
2820 FIXME("(%p)->(%s, %s, %s, %s)\n", iface, pszName, pszCriteria, fSubString ? "TRUE" : "FALSE", fCaseSensitive ? "TRUE" : "FALSE");
2821 return E_NOTIMPL;
2822 }
2823
2824 static HRESULT WINAPI MimeMessage_GetTextBody(
2825 IMimeMessage *iface,
2826 DWORD dwTxtType,
2827 ENCODINGTYPE ietEncoding,
2828 IStream **pStream,
2829 LPHBODY phBody)
2830 {
2831 HRESULT hr;
2832 HBODY hbody;
2833 FINDBODY find_struct;
2834 IMimeBody *mime_body;
2835 static char text[] = "text";
2836 static char plain[] = "plain";
2837 static char html[] = "html";
2838
2839 TRACE("(%p)->(%d, %d, %p, %p)\n", iface, dwTxtType, ietEncoding, pStream, phBody);
2840
2841 find_struct.pszPriType = text;
2842
2843 switch(dwTxtType)
2844 {
2845 case TXT_PLAIN:
2846 find_struct.pszSubType = plain;
2847 break;
2848 case TXT_HTML:
2849 find_struct.pszSubType = html;
2850 break;
2851 default:
2852 return MIME_E_INVALID_TEXT_TYPE;
2853 }
2854
2855 hr = IMimeMessage_FindFirst(iface, &find_struct, &hbody);
2856 if(hr != S_OK)
2857 {
2858 TRACE("not found hr %08x\n", hr);
2859 *phBody = NULL;
2860 return hr;
2861 }
2862
2863 IMimeMessage_BindToObject(iface, hbody, &IID_IMimeBody, (void**)&mime_body);
2864
2865 IMimeBody_GetData(mime_body, ietEncoding, pStream);
2866 *phBody = hbody;
2867 IMimeBody_Release(mime_body);
2868 return hr;
2869 }
2870
2871 static HRESULT WINAPI MimeMessage_SetTextBody(
2872 IMimeMessage *iface,
2873 DWORD dwTxtType,
2874 ENCODINGTYPE ietEncoding,
2875 HBODY hAlternative,
2876 IStream *pStream,
2877 LPHBODY phBody)
2878 {
2879 FIXME("(%p)->(%d, %d, %p, %p, %p)\n", iface, dwTxtType, ietEncoding, hAlternative, pStream, phBody);
2880 return E_NOTIMPL;
2881 }
2882
2883 static HRESULT WINAPI MimeMessage_AttachObject(
2884 IMimeMessage *iface,
2885 REFIID riid,
2886 void *pvObject,
2887 LPHBODY phBody)
2888 {
2889 FIXME("(%p)->(%s, %p, %p)\n", iface, debugstr_guid(riid), pvObject, phBody);
2890 return E_NOTIMPL;
2891 }
2892
2893 static HRESULT WINAPI MimeMessage_AttachFile(
2894 IMimeMessage *iface,
2895 LPCSTR pszFilePath,
2896 IStream *pstmFile,
2897 LPHBODY phBody)
2898 {
2899 FIXME("(%p)->(%s, %p, %p)\n", iface, pszFilePath, pstmFile, phBody);
2900 return E_NOTIMPL;
2901 }
2902
2903 static HRESULT WINAPI MimeMessage_AttachURL(
2904 IMimeMessage *iface,
2905 LPCSTR pszBase,
2906 LPCSTR pszURL,
2907 DWORD dwFlags,
2908 IStream *pstmURL,
2909 LPSTR *ppszCIDURL,
2910 LPHBODY phBody)
2911 {
2912 FIXME("(%p)->(%s, %s, 0x%x, %p, %p, %p)\n", iface, pszBase, pszURL, dwFlags, pstmURL, ppszCIDURL, phBody);
2913 return E_NOTIMPL;
2914 }
2915
2916 static HRESULT WINAPI MimeMessage_GetAttachments(
2917 IMimeMessage *iface,
2918 ULONG *pcAttach,
2919 LPHBODY *pprghAttach)
2920 {
2921 HRESULT hr;
2922 FINDBODY find_struct;
2923 HBODY hbody;
2924 LPHBODY array;
2925 ULONG size = 10;
2926
2927 TRACE("(%p)->(%p, %p)\n", iface, pcAttach, pprghAttach);
2928
2929 *pcAttach = 0;
2930 array = CoTaskMemAlloc(size * sizeof(HBODY));
2931
2932 find_struct.pszPriType = find_struct.pszSubType = NULL;
2933 hr = IMimeMessage_FindFirst(iface, &find_struct, &hbody);
2934 while(hr == S_OK)
2935 {
2936 hr = IMimeMessage_IsContentType(iface, hbody, "multipart", NULL);
2937 TRACE("IsCT rets %08x %d\n", hr, *pcAttach);
2938 if(hr != S_OK)
2939 {
2940 if(*pcAttach + 1 > size)
2941 {
2942 size *= 2;
2943 array = CoTaskMemRealloc(array, size * sizeof(HBODY));
2944 }
2945 array[*pcAttach] = hbody;
2946 (*pcAttach)++;
2947 }
2948 hr = IMimeMessage_FindNext(iface, &find_struct, &hbody);
2949 }
2950
2951 *pprghAttach = array;
2952 return S_OK;
2953 }
2954
2955 static HRESULT WINAPI MimeMessage_GetAddressTable(
2956 IMimeMessage *iface,
2957 IMimeAddressTable **ppTable)
2958 {
2959 FIXME("(%p)->(%p)\n", iface, ppTable);
2960 return E_NOTIMPL;
2961 }
2962
2963 static HRESULT WINAPI MimeMessage_GetSender(
2964 IMimeMessage *iface,
2965 LPADDRESSPROPS pAddress)
2966 {
2967 FIXME("(%p)->(%p)\n", iface, pAddress);
2968 return E_NOTIMPL;
2969 }
2970
2971 static HRESULT WINAPI MimeMessage_GetAddressTypes(
2972 IMimeMessage *iface,
2973 DWORD dwAdrTypes,
2974 DWORD dwProps,
2975 LPADDRESSLIST pList)
2976 {
2977 FIXME("(%p)->(%d, %d, %p)\n", iface, dwAdrTypes, dwProps, pList);
2978 return E_NOTIMPL;
2979 }
2980
2981 static HRESULT WINAPI MimeMessage_GetAddressFormat(
2982 IMimeMessage *iface,
2983 DWORD dwAdrTypes,
2984 ADDRESSFORMAT format,
2985 LPSTR *ppszFormat)
2986 {
2987 FIXME("(%p)->(%d, %d, %p)\n", iface, dwAdrTypes, format, ppszFormat);
2988 return E_NOTIMPL;
2989 }
2990
2991 static HRESULT WINAPI MimeMessage_EnumAddressTypes(
2992 IMimeMessage *iface,
2993 DWORD dwAdrTypes,
2994 DWORD dwProps,
2995 IMimeEnumAddressTypes **ppEnum)
2996 {
2997 FIXME("(%p)->(%d, %d, %p)\n", iface, dwAdrTypes, dwProps, ppEnum);
2998 return E_NOTIMPL;
2999 }
3000
3001 static HRESULT WINAPI MimeMessage_SplitMessage(
3002 IMimeMessage *iface,
3003 ULONG cbMaxPart,
3004 IMimeMessageParts **ppParts)
3005 {
3006 FIXME("(%p)->(%d, %p)\n", iface, cbMaxPart, ppParts);
3007 return E_NOTIMPL;
3008 }
3009
3010 static HRESULT WINAPI MimeMessage_GetRootMoniker(
3011 IMimeMessage *iface,
3012 IMoniker **ppMoniker)
3013 {
3014 FIXME("(%p)->(%p)\n", iface, ppMoniker);
3015 return E_NOTIMPL;
3016 }
3017
3018 static const IMimeMessageVtbl MimeMessageVtbl =
3019 {
3020 MimeMessage_QueryInterface,
3021 MimeMessage_AddRef,
3022 MimeMessage_Release,
3023 MimeMessage_GetClassID,
3024 MimeMessage_IsDirty,
3025 MimeMessage_Load,
3026 MimeMessage_Save,
3027 MimeMessage_GetSizeMax,
3028 MimeMessage_InitNew,
3029 MimeMessage_GetMessageSource,
3030 MimeMessage_GetMessageSize,
3031 MimeMessage_LoadOffsetTable,
3032 MimeMessage_SaveOffsetTable,
3033 MimeMessage_GetFlags,
3034 MimeMessage_Commit,
3035 MimeMessage_HandsOffStorage,
3036 MimeMessage_BindToObject,
3037 MimeMessage_SaveBody,
3038 MimeMessage_InsertBody,
3039 MimeMessage_GetBody,
3040 MimeMessage_DeleteBody,
3041 MimeMessage_MoveBody,
3042 MimeMessage_CountBodies,
3043 MimeMessage_FindFirst,
3044 MimeMessage_FindNext,
3045 MimeMessage_ResolveURL,
3046 MimeMessage_ToMultipart,
3047 MimeMessage_GetBodyOffsets,
3048 MimeMessage_GetCharset,
3049 MimeMessage_SetCharset,
3050 MimeMessage_IsBodyType,
3051 MimeMessage_IsContentType,
3052 MimeMessage_QueryBodyProp,
3053 MimeMessage_GetBodyProp,
3054 MimeMessage_SetBodyProp,
3055 MimeMessage_DeleteBodyProp,
3056 MimeMessage_SetOption,
3057 MimeMessage_GetOption,
3058 MimeMessage_CreateWebPage,
3059 MimeMessage_GetProp,
3060 MimeMessage_SetProp,
3061 MimeMessage_DeleteProp,
3062 MimeMessage_QueryProp,
3063 MimeMessage_GetTextBody,
3064 MimeMessage_SetTextBody,
3065 MimeMessage_AttachObject,
3066 MimeMessage_AttachFile,
3067 MimeMessage_AttachURL,
3068 MimeMessage_GetAttachments,
3069 MimeMessage_GetAddressTable,
3070 MimeMessage_GetSender,
3071 MimeMessage_GetAddressTypes,
3072 MimeMessage_GetAddressFormat,
3073 MimeMessage_EnumAddressTypes,
3074 MimeMessage_SplitMessage,
3075 MimeMessage_GetRootMoniker,
3076 };
3077
3078 HRESULT MimeMessage_create(IUnknown *outer, void **obj)
3079 {
3080 MimeMessage *This;
3081 MimeBody *mime_body;
3082 body_t *root_body;
3083
3084 TRACE("(%p, %p)\n", outer, obj);
3085
3086 if (outer)
3087 {
3088 FIXME("outer unknown not supported yet\n");
3089 return E_NOTIMPL;
3090 }
3091
3092 *obj = NULL;
3093
3094 This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
3095 if (!This) return E_OUTOFMEMORY;
3096
3097 This->IMimeMessage_iface.lpVtbl = &MimeMessageVtbl;
3098 This->ref = 1;
3099 This->stream = NULL;
3100 list_init(&This->body_tree);
3101 This->next_index = 1;
3102
3103 mime_body = mimebody_create();
3104 root_body = new_body_entry(mime_body, This->next_index++, NULL);
3105 list_add_head(&This->body_tree, &root_body->entry);
3106
3107 *obj = &This->IMimeMessage_iface;
3108 return S_OK;
3109 }
3110
3111 /***********************************************************************
3112 * MimeOleCreateMessage (INETCOMM.@)
3113 */
3114 HRESULT WINAPI MimeOleCreateMessage(IUnknown *pUnkOuter, IMimeMessage **ppMessage)
3115 {
3116 TRACE("(%p, %p)\n", pUnkOuter, ppMessage);
3117 return MimeMessage_create(NULL, (void **)ppMessage);
3118 }
3119
3120 /***********************************************************************
3121 * MimeOleSetCompatMode (INETCOMM.@)
3122 */
3123 HRESULT WINAPI MimeOleSetCompatMode(DWORD dwMode)
3124 {
3125 FIXME("(0x%x)\n", dwMode);
3126 return S_OK;
3127 }
3128
3129 /***********************************************************************
3130 * MimeOleCreateVirtualStream (INETCOMM.@)
3131 */
3132 HRESULT WINAPI MimeOleCreateVirtualStream(IStream **ppStream)
3133 {
3134 HRESULT hr;
3135 FIXME("(%p)\n", ppStream);
3136
3137 hr = CreateStreamOnHGlobal(NULL, TRUE, ppStream);
3138 return hr;
3139 }
3140
3141 typedef struct MimeSecurity
3142 {
3143 IMimeSecurity IMimeSecurity_iface;
3144 LONG ref;
3145 } MimeSecurity;
3146
3147 static inline MimeSecurity *impl_from_IMimeSecurity(IMimeSecurity *iface)
3148 {
3149 return CONTAINING_RECORD(iface, MimeSecurity, IMimeSecurity_iface);
3150 }
3151
3152 static HRESULT WINAPI MimeSecurity_QueryInterface(IMimeSecurity *iface, REFIID riid, void **ppv)
3153 {
3154 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
3155
3156 if (IsEqualIID(riid, &IID_IUnknown) ||
3157 IsEqualIID(riid, &IID_IMimeSecurity))
3158 {
3159 *ppv = iface;
3160 IMimeSecurity_AddRef(iface);
3161 return S_OK;
3162 }
3163
3164 FIXME("no interface for %s\n", debugstr_guid(riid));
3165 *ppv = NULL;
3166 return E_NOINTERFACE;
3167 }
3168
3169 static ULONG WINAPI MimeSecurity_AddRef(IMimeSecurity *iface)
3170 {
3171 MimeSecurity *This = impl_from_IMimeSecurity(iface);
3172 LONG ref = InterlockedIncrement(&This->ref);
3173
3174 TRACE("(%p) ref=%d\n", This, ref);
3175
3176 return ref;
3177 }
3178
3179 static ULONG WINAPI MimeSecurity_Release(IMimeSecurity *iface)
3180 {
3181 MimeSecurity *This = impl_from_IMimeSecurity(iface);
3182 LONG ref = InterlockedDecrement(&This->ref);
3183
3184 TRACE("(%p) ref=%d\n", This, ref);
3185
3186 if (!ref)
3187 HeapFree(GetProcessHeap(), 0, This);
3188
3189 return ref;
3190 }
3191
3192 static HRESULT WINAPI MimeSecurity_InitNew(
3193 IMimeSecurity* iface)
3194 {
3195 FIXME("(%p)->(): stub\n", iface);
3196 return S_OK;
3197 }
3198
3199 static HRESULT WINAPI MimeSecurity_CheckInit(
3200 IMimeSecurity* iface)
3201 {
3202 FIXME("(%p)->(): stub\n", iface);
3203 return E_NOTIMPL;
3204 }
3205
3206 static HRESULT WINAPI MimeSecurity_EncodeMessage(
3207 IMimeSecurity* iface,
3208 IMimeMessageTree* pTree,
3209 DWORD dwFlags)
3210 {
3211 FIXME("(%p)->(%p, %08x): stub\n", iface, pTree, dwFlags);
3212 return E_NOTIMPL;
3213 }
3214
3215 static HRESULT WINAPI MimeSecurity_EncodeBody(
3216 IMimeSecurity* iface,
3217 IMimeMessageTree* pTree,
3218 HBODY hEncodeRoot,
3219 DWORD dwFlags)
3220 {
3221 FIXME("(%p)->(%p, %p, %08x): stub\n", iface, pTree, hEncodeRoot, dwFlags);
3222 return E_NOTIMPL;
3223 }
3224
3225 static HRESULT WINAPI MimeSecurity_DecodeMessage(
3226 IMimeSecurity* iface,
3227 IMimeMessageTree* pTree,
3228 DWORD dwFlags)
3229 {
3230 FIXME("(%p)->(%p, %08x): stub\n", iface, pTree, dwFlags);
3231 return E_NOTIMPL;
3232 }
3233
3234 static HRESULT WINAPI MimeSecurity_DecodeBody(
3235 IMimeSecurity* iface,
3236 IMimeMessageTree* pTree,
3237 HBODY hDecodeRoot,
3238 DWORD dwFlags)
3239 {
3240 FIXME("(%p)->(%p, %p, %08x): stub\n", iface, pTree, hDecodeRoot, dwFlags);
3241 return E_NOTIMPL;
3242 }
3243
3244 static HRESULT WINAPI MimeSecurity_EnumCertificates(
3245 IMimeSecurity* iface,
3246 HCAPICERTSTORE hc,
3247 DWORD dwUsage,
3248 PCX509CERT pPrev,
3249 PCX509CERT* ppCert)
3250 {
3251 FIXME("(%p)->(%p, %08x, %p, %p): stub\n", iface, hc, dwUsage, pPrev, ppCert);
3252 return E_NOTIMPL;
3253 }
3254
3255 static HRESULT WINAPI MimeSecurity_GetCertificateName(
3256 IMimeSecurity* iface,
3257 const PCX509CERT pX509Cert,
3258 const CERTNAMETYPE cn,
3259 LPSTR* ppszName)
3260 {
3261 FIXME("(%p)->(%p, %08x, %p): stub\n", iface, pX509Cert, cn, ppszName);
3262 return E_NOTIMPL;
3263 }
3264
3265 static HRESULT WINAPI MimeSecurity_GetMessageType(
3266 IMimeSecurity* iface,
3267 const HWND hwndParent,
3268 IMimeBody* pBody,
3269 DWORD* pdwSecType)
3270 {
3271 FIXME("(%p)->(%p, %p, %p): stub\n", iface, hwndParent, pBody, pdwSecType);
3272 return E_NOTIMPL;
3273 }
3274
3275 static HRESULT WINAPI MimeSecurity_GetCertData(
3276 IMimeSecurity* iface,
3277 const PCX509CERT pX509Cert,
3278 const CERTDATAID dataid,
3279 LPPROPVARIANT pValue)
3280 {
3281 FIXME("(%p)->(%p, %x, %p): stub\n", iface, pX509Cert, dataid, pValue);
3282 return E_NOTIMPL;
3283 }
3284
3285
3286 static const IMimeSecurityVtbl MimeSecurityVtbl =
3287 {
3288 MimeSecurity_QueryInterface,
3289 MimeSecurity_AddRef,
3290 MimeSecurity_Release,
3291 MimeSecurity_InitNew,
3292 MimeSecurity_CheckInit,
3293 MimeSecurity_EncodeMessage,
3294 MimeSecurity_EncodeBody,
3295 MimeSecurity_DecodeMessage,
3296 MimeSecurity_DecodeBody,
3297 MimeSecurity_EnumCertificates,
3298 MimeSecurity_GetCertificateName,
3299 MimeSecurity_GetMessageType,
3300 MimeSecurity_GetCertData
3301 };
3302
3303 HRESULT MimeSecurity_create(IUnknown *outer, void **obj)
3304 {
3305 MimeSecurity *This;
3306
3307 *obj = NULL;
3308
3309 if (outer) return CLASS_E_NOAGGREGATION;
3310
3311 This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
3312 if (!This) return E_OUTOFMEMORY;
3313
3314 This->IMimeSecurity_iface.lpVtbl = &MimeSecurityVtbl;
3315 This->ref = 1;
3316
3317 *obj = &This->IMimeSecurity_iface;
3318 return S_OK;
3319 }
3320
3321 /***********************************************************************
3322 * MimeOleCreateSecurity (INETCOMM.@)
3323 */
3324 HRESULT WINAPI MimeOleCreateSecurity(IMimeSecurity **ppSecurity)
3325 {
3326 return MimeSecurity_create(NULL, (void **)ppSecurity);
3327 }
3328
3329 static HRESULT WINAPI MimeAlloc_QueryInterface(
3330 IMimeAllocator* iface,
3331 REFIID riid,
3332 void **obj)
3333 {
3334 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), obj);
3335
3336 if (IsEqualIID(riid, &IID_IUnknown) ||
3337 IsEqualIID(riid, &IID_IMalloc) ||
3338 IsEqualIID(riid, &IID_IMimeAllocator))
3339 {
3340 *obj = iface;
3341 IMimeAllocator_AddRef(iface);
3342 return S_OK;
3343 }
3344
3345 FIXME("no interface for %s\n", debugstr_guid(riid));
3346 *obj = NULL;
3347 return E_NOINTERFACE;
3348 }
3349
3350 static ULONG WINAPI MimeAlloc_AddRef(
3351 IMimeAllocator* iface)
3352 {
3353 return 2;
3354 }
3355
3356 static ULONG WINAPI MimeAlloc_Release(
3357 IMimeAllocator* iface)
3358 {
3359 return 1;
3360 }
3361
3362 static LPVOID WINAPI MimeAlloc_Alloc(
3363 IMimeAllocator* iface,
3364 SIZE_T cb)
3365 {
3366 return CoTaskMemAlloc(cb);
3367 }
3368
3369 static LPVOID WINAPI MimeAlloc_Realloc(
3370 IMimeAllocator* iface,
3371 LPVOID pv,
3372 SIZE_T cb)
3373 {
3374 return CoTaskMemRealloc(pv, cb);
3375 }
3376
3377 static void WINAPI MimeAlloc_Free(
3378 IMimeAllocator* iface,
3379 LPVOID pv)
3380 {
3381 CoTaskMemFree(pv);
3382 }
3383
3384 static SIZE_T WINAPI MimeAlloc_GetSize(
3385 IMimeAllocator* iface,
3386 LPVOID pv)
3387 {
3388 FIXME("stub\n");
3389 return 0;
3390 }
3391
3392 static int WINAPI MimeAlloc_DidAlloc(
3393 IMimeAllocator* iface,
3394 LPVOID pv)
3395 {
3396 FIXME("stub\n");
3397 return 0;
3398 }
3399
3400 static void WINAPI MimeAlloc_HeapMinimize(
3401 IMimeAllocator* iface)
3402 {
3403 FIXME("stub\n");
3404 return;
3405 }
3406
3407 static HRESULT WINAPI MimeAlloc_FreeParamInfoArray(
3408 IMimeAllocator* iface,
3409 ULONG cParams,
3410 LPMIMEPARAMINFO prgParam,
3411 boolean fFreeArray)
3412 {
3413 ULONG i;
3414 TRACE("(%p)->(%d, %p, %d)\n", iface, cParams, prgParam, fFreeArray);
3415
3416 for(i = 0; i < cParams; i++)
3417 {
3418 IMimeAllocator_Free(iface, prgParam[i].pszName);
3419 IMimeAllocator_Free(iface, prgParam[i].pszData);
3420 }
3421 if(fFreeArray) IMimeAllocator_Free(iface, prgParam);
3422 return S_OK;
3423 }
3424
3425 static HRESULT WINAPI MimeAlloc_FreeAddressList(
3426 IMimeAllocator* iface,
3427 LPADDRESSLIST pList)
3428 {
3429 FIXME("stub\n");
3430 return E_NOTIMPL;
3431 }
3432
3433 static HRESULT WINAPI MimeAlloc_FreeAddressProps(
3434 IMimeAllocator* iface,
3435 LPADDRESSPROPS pAddress)
3436 {
3437 FIXME("stub\n");
3438 return E_NOTIMPL;
3439 }
3440
3441 static HRESULT WINAPI MimeAlloc_ReleaseObjects(
3442 IMimeAllocator* iface,
3443 ULONG cObjects,
3444 IUnknown **prgpUnknown,
3445 boolean fFreeArray)
3446 {
3447 FIXME("stub\n");
3448 return E_NOTIMPL;
3449 }
3450
3451
3452 static HRESULT WINAPI MimeAlloc_FreeEnumHeaderRowArray(
3453 IMimeAllocator* iface,
3454 ULONG cRows,
3455 LPENUMHEADERROW prgRow,
3456 boolean fFreeArray)
3457 {
3458 FIXME("stub\n");
3459 return E_NOTIMPL;
3460 }
3461
3462 static HRESULT WINAPI MimeAlloc_FreeEnumPropertyArray(
3463 IMimeAllocator* iface,
3464 ULONG cProps,
3465 LPENUMPROPERTY prgProp,
3466 boolean fFreeArray)
3467 {
3468 FIXME("stub\n");
3469 return E_NOTIMPL;
3470 }
3471
3472 static HRESULT WINAPI MimeAlloc_FreeThumbprint(
3473 IMimeAllocator* iface,
3474 THUMBBLOB *pthumbprint)
3475 {
3476 FIXME("stub\n");
3477 return E_NOTIMPL;
3478 }
3479
3480
3481 static HRESULT WINAPI MimeAlloc_PropVariantClear(
3482 IMimeAllocator* iface,
3483 LPPROPVARIANT pProp)
3484 {
3485 FIXME("stub\n");
3486 return E_NOTIMPL;
3487 }
3488
3489 static IMimeAllocatorVtbl mime_alloc_vtbl =
3490 {
3491 MimeAlloc_QueryInterface,
3492 MimeAlloc_AddRef,
3493 MimeAlloc_Release,
3494 MimeAlloc_Alloc,
3495 MimeAlloc_Realloc,
3496 MimeAlloc_Free,
3497 MimeAlloc_GetSize,
3498 MimeAlloc_DidAlloc,
3499 MimeAlloc_HeapMinimize,
3500 MimeAlloc_FreeParamInfoArray,
3501 MimeAlloc_FreeAddressList,
3502 MimeAlloc_FreeAddressProps,
3503 MimeAlloc_ReleaseObjects,
3504 MimeAlloc_FreeEnumHeaderRowArray,
3505 MimeAlloc_FreeEnumPropertyArray,
3506 MimeAlloc_FreeThumbprint,
3507 MimeAlloc_PropVariantClear
3508 };
3509
3510 static IMimeAllocator mime_allocator =
3511 {
3512 &mime_alloc_vtbl
3513 };
3514
3515 HRESULT MimeAllocator_create(IUnknown *outer, void **obj)
3516 {
3517 if(outer) return CLASS_E_NOAGGREGATION;
3518
3519 *obj = &mime_allocator;
3520 return S_OK;
3521 }
3522
3523 HRESULT WINAPI MimeOleGetAllocator(IMimeAllocator **alloc)
3524 {
3525 return MimeAllocator_create(NULL, (void**)alloc);
3526 }
3527
3528 HRESULT VirtualStream_create(IUnknown *outer, void **obj)
3529 {
3530 FIXME("(%p, %p)\n", outer, obj);
3531
3532 *obj = NULL;
3533 if (outer) return CLASS_E_NOAGGREGATION;
3534
3535 return MimeOleCreateVirtualStream((IStream **)obj);
3536 }
3537
3538 /* IMimePropertySchema Interface */
3539 static HRESULT WINAPI propschema_QueryInterface(IMimePropertySchema *iface, REFIID riid, void **out)
3540 {
3541 propschema *This = impl_from_IMimePropertySchema(iface);
3542 TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), out);
3543
3544 *out = NULL;
3545
3546 if (IsEqualIID(riid, &IID_IUnknown) ||
3547 IsEqualIID(riid, &IID_IMimePropertySchema))
3548 {
3549 *out = iface;
3550 }
3551 else
3552 {
3553 FIXME("no interface for %s\n", debugstr_guid(riid));
3554 return E_NOINTERFACE;
3555 }
3556
3557 IMimePropertySchema_AddRef(iface);
3558 return S_OK;
3559 }
3560
3561 static ULONG WINAPI propschema_AddRef(IMimePropertySchema *iface)
3562 {
3563 propschema *This = impl_from_IMimePropertySchema(iface);
3564 LONG ref = InterlockedIncrement(&This->ref);
3565
3566 TRACE("(%p) ref=%d\n", This, ref);
3567
3568 return ref;
3569 }
3570
3571 static ULONG WINAPI propschema_Release(IMimePropertySchema *iface)
3572 {
3573 propschema *This = impl_from_IMimePropertySchema(iface);
3574 LONG ref = InterlockedDecrement(&This->ref);
3575
3576 TRACE("(%p) ref=%d\n", This, ref);
3577
3578 if (!ref)
3579 {
3580 HeapFree(GetProcessHeap(), 0, This);
3581 }
3582
3583 return ref;
3584 }
3585
3586 static HRESULT WINAPI propschema_RegisterProperty(IMimePropertySchema *iface, const char *name, DWORD flags,
3587 DWORD rownumber, VARTYPE vtdefault, DWORD *propid)
3588 {
3589 propschema *This = impl_from_IMimePropertySchema(iface);
3590 FIXME("(%p)->(%s, %x, %d, %d, %p) stub\n", This, debugstr_a(name), flags, rownumber, vtdefault, propid);
3591 return E_NOTIMPL;
3592 }
3593
3594 static HRESULT WINAPI propschema_ModifyProperty(IMimePropertySchema *iface, const char *name, DWORD flags,
3595 DWORD rownumber, VARTYPE vtdefault)
3596 {
3597 propschema *This = impl_from_IMimePropertySchema(iface);
3598 FIXME("(%p)->(%s, %x, %d, %d) stub\n", This, debugstr_a(name), flags, rownumber, vtdefault);
3599 return S_OK;
3600 }
3601
3602 static HRESULT WINAPI propschema_GetPropertyId(IMimePropertySchema *iface, const char *name, DWORD *propid)
3603 {
3604 propschema *This = impl_from_IMimePropertySchema(iface);
3605 FIXME("(%p)->(%s, %p) stub\n", This, debugstr_a(name), propid);
3606 return E_NOTIMPL;
3607 }
3608
3609 static HRESULT WINAPI propschema_GetPropertyName(IMimePropertySchema *iface, DWORD propid, char **name)
3610 {
3611 propschema *This = impl_from_IMimePropertySchema(iface);
3612 FIXME("(%p)->(%d, %p) stub\n", This, propid, name);
3613 return E_NOTIMPL;
3614 }
3615
3616 static HRESULT WINAPI propschema_RegisterAddressType(IMimePropertySchema *iface, const char *name, DWORD *adrtype)
3617 {
3618 propschema *This = impl_from_IMimePropertySchema(iface);
3619 FIXME("(%p)->(%s, %p) stub\n", This, debugstr_a(name), adrtype);
3620 return E_NOTIMPL;
3621 }
3622
3623 static IMimePropertySchemaVtbl prop_schema_vtbl =
3624 {
3625 propschema_QueryInterface,
3626 propschema_AddRef,
3627 propschema_Release,
3628 propschema_RegisterProperty,
3629 propschema_ModifyProperty,
3630 propschema_GetPropertyId,
3631 propschema_GetPropertyName,
3632 propschema_RegisterAddressType
3633 };
3634
3635
3636 HRESULT WINAPI MimeOleGetPropertySchema(IMimePropertySchema **schema)
3637 {
3638 propschema *This;
3639
3640 TRACE("(%p) stub\n", schema);
3641
3642 This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
3643 if (!This)
3644 return E_OUTOFMEMORY;
3645
3646 This->IMimePropertySchema_iface.lpVtbl = &prop_schema_vtbl;
3647 This->ref = 1;
3648
3649 *schema = &This->IMimePropertySchema_iface;
3650
3651 return S_OK;
3652 }
3653
3654 HRESULT WINAPI MimeGetAddressFormatW(REFIID riid, void *object, DWORD addr_type,
3655 ADDRESSFORMAT addr_format, WCHAR **address)
3656 {
3657 FIXME("(%s, %p, %d, %d, %p) stub\n", debugstr_guid(riid), object, addr_type, addr_format, address);
3658
3659 return E_NOTIMPL;
3660 }
3661
3662 static HRESULT WINAPI mime_obj_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
3663 {
3664 FIXME("(%s %p)\n", debugstr_guid(riid), ppv);
3665 *ppv = NULL;
3666 return E_NOINTERFACE;
3667 }
3668
3669 static ULONG WINAPI mime_obj_AddRef(IUnknown *iface)
3670 {
3671 TRACE("\n");
3672 return 2;
3673 }
3674
3675 static ULONG WINAPI mime_obj_Release(IUnknown *iface)
3676 {
3677 TRACE("\n");
3678 return 1;
3679 }
3680
3681 static const IUnknownVtbl mime_obj_vtbl = {
3682 mime_obj_QueryInterface,
3683 mime_obj_AddRef,
3684 mime_obj_Release
3685 };
3686
3687 static IUnknown mime_obj = { &mime_obj_vtbl };
3688
3689 HRESULT WINAPI MimeOleObjectFromMoniker(BINDF bindf, IMoniker *moniker, IBindCtx *binding,
3690 REFIID riid, void **out, IMoniker **moniker_new)
3691 {
3692 WCHAR *display_name, *mhtml_url;
3693 size_t len;
3694 HRESULT hres;
3695
3696 static const WCHAR mhtml_prefixW[] = {'m','h','t','m','l',':'};
3697
3698 WARN("(0x%08x, %p, %p, %s, %p, %p) semi-stub\n", bindf, moniker, binding, debugstr_guid(riid), out, moniker_new);
3699
3700 if(!IsEqualGUID(&IID_IUnknown, riid)) {
3701 FIXME("Unsupported riid %s\n", debugstr_guid(riid));
3702 return E_NOINTERFACE;
3703 }
3704
3705 hres = IMoniker_GetDisplayName(moniker, NULL, NULL, &display_name);
3706 if(FAILED(hres))
3707 return hres;
3708
3709 TRACE("display name %s\n", debugstr_w(display_name));
3710
3711 len = strlenW(display_name);
3712 mhtml_url = heap_alloc((len+1)*sizeof(WCHAR) + sizeof(mhtml_prefixW));
3713 if(!mhtml_url)
3714 return E_OUTOFMEMORY;
3715
3716 memcpy(mhtml_url, mhtml_prefixW, sizeof(mhtml_prefixW));
3717 strcpyW(mhtml_url + ARRAY_SIZE(mhtml_prefixW), display_name);
3718 HeapFree(GetProcessHeap(), 0, display_name);
3719
3720 hres = CreateURLMoniker(NULL, mhtml_url, moniker_new);
3721 heap_free(mhtml_url);
3722 if(FAILED(hres))
3723 return hres;
3724
3725 /* FIXME: We most likely should start binding here and return something more meaningful as mime object. */
3726 *out = &mime_obj;
3727 return S_OK;
3728 }
Windows API implementation