?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wbemprox: Tweak a comment.
[wine.git] / dlls / inetcomm / mimeole.c
blob681ca820d4882fa2e5f08e8f735e92b8f4e8c64c
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 &&
1585 (*ptr >= sizeof(base64_decode_table)/sizeof(*base64_decode_table)
1586 || base64_decode_table[*ptr] == -1))
1587 ptr++;
1588 if(ptr == end)
1589 break;
1590
1591 in[n++] = base64_decode_table[*ptr++];
1592 switch(n) {
1593 case 2:
1594 *ret++ = in[0] << 2 | in[1] >> 4;
1595 continue;
1596 case 3:
1597 *ret++ = in[1] << 4 | in[2] >> 2;
1598 continue;
1599 case 4:
1600 *ret++ = ((in[2] << 6) & 0xc0) | in[3];
1601 n = 0;
1602 }
1603 }
1604
1605 if(ret > buf) {
1606 hres = IStream_Write(output, buf, ret - buf, NULL);
1607 if(FAILED(hres))
1608 break;
1609 }
1610 }
1611
1612 if(SUCCEEDED(hres))
1613 hres = IStream_Seek(output, pos, STREAM_SEEK_SET, NULL);
1614 if(FAILED(hres)) {
1615 IStream_Release(output);
1616 return hres;
1617 }
1618
1619 *ret_stream = output;
1620 return S_OK;
1621 }
1622
1623 static int hex_digit(char c)
1624 {
1625 if('0' <= c && c <= '9')
1626 return c - '0';
1627 if('A' <= c && c <= 'F')
1628 return c - 'A' + 10;
1629 if('a' <= c && c <= 'f')
1630 return c - 'a' + 10;
1631 return -1;
1632 }
1633
1634 static HRESULT decode_qp(IStream *input, IStream **ret_stream)
1635 {
1636 const unsigned char *ptr, *end;
1637 unsigned char *ret, prev = 0;
1638 unsigned char buf[1024];
1639 LARGE_INTEGER pos;
1640 IStream *output;
1641 DWORD size;
1642 int n = -1;
1643 HRESULT hres;
1644
1645 pos.QuadPart = 0;
1646 hres = IStream_Seek(input, pos, STREAM_SEEK_SET, NULL);
1647 if(FAILED(hres))
1648 return hres;
1649
1650 hres = CreateStreamOnHGlobal(NULL, TRUE, &output);
1651 if(FAILED(hres))
1652 return hres;
1653
1654 while(1) {
1655 hres = IStream_Read(input, buf, sizeof(buf), &size);
1656 if(FAILED(hres) || !size)
1657 break;
1658
1659 ptr = ret = buf;
1660 end = buf + size;
1661
1662 while(ptr < end) {
1663 unsigned char byte = *ptr++;
1664
1665 switch(n) {
1666 case -1:
1667 if(byte == '=')
1668 n = 0;
1669 else
1670 *ret++ = byte;
1671 continue;
1672 case 0:
1673 prev = byte;
1674 n = 1;
1675 continue;
1676 case 1:
1677 if(prev != '\r' || byte != '\n') {
1678 int h1 = hex_digit(prev), h2 = hex_digit(byte);
1679 if(h1 != -1 && h2 != -1)
1680 *ret++ = (h1 << 4) | h2;
1681 else
1682 *ret++ = '=';
1683 }
1684 n = -1;
1685 continue;
1686 }
1687 }
1688
1689 if(ret > buf) {
1690 hres = IStream_Write(output, buf, ret - buf, NULL);
1691 if(FAILED(hres))
1692 break;
1693 }
1694 }
1695
1696 if(SUCCEEDED(hres))
1697 hres = IStream_Seek(output, pos, STREAM_SEEK_SET, NULL);
1698 if(FAILED(hres)) {
1699 IStream_Release(output);
1700 return hres;
1701 }
1702
1703 *ret_stream = output;
1704 return S_OK;
1705 }
1706
1707 static HRESULT WINAPI MimeBody_GetData(
1708 IMimeBody* iface,
1709 ENCODINGTYPE ietEncoding,
1710 IStream** ppStream)
1711 {
1712 MimeBody *This = impl_from_IMimeBody(iface);
1713 ULARGE_INTEGER start, size;
1714 HRESULT hres;
1715
1716 TRACE("(%p)->(%d %p)\n", This, ietEncoding, ppStream);
1717
1718 if(This->encoding != ietEncoding) {
1719 switch(This->encoding) {
1720 case IET_BASE64:
1721 hres = decode_base64(This->data, ppStream);
1722 break;
1723 case IET_QP:
1724 hres = decode_qp(This->data, ppStream);
1725 break;
1726 default:
1727 FIXME("Decoding %d is not supported.\n", This->encoding);
1728 hres = S_FALSE;
1729 }
1730 if(ietEncoding != IET_BINARY)
1731 FIXME("Encoding %d is not supported.\n", ietEncoding);
1732 if(hres != S_FALSE)
1733 return hres;
1734 }
1735
1736 start.QuadPart = 0;
1737 hres = get_stream_size(This->data, &size);
1738 if(SUCCEEDED(hres))
1739 hres = create_sub_stream(This->data, start, size, ppStream);
1740 return hres;
1741 }
1742
1743 static HRESULT WINAPI MimeBody_SetData(
1744 IMimeBody* iface,
1745 ENCODINGTYPE ietEncoding,
1746 LPCSTR pszPriType,
1747 LPCSTR pszSubType,
1748 REFIID riid,
1749 LPVOID pvObject)
1750 {
1751 MimeBody *This = impl_from_IMimeBody(iface);
1752 TRACE("(%p)->(%d, %s, %s, %s %p)\n", This, ietEncoding, debugstr_a(pszPriType), debugstr_a(pszSubType),
1753 debugstr_guid(riid), pvObject);
1754
1755 if(IsEqualIID(riid, &IID_IStream))
1756 IStream_AddRef((IStream *)pvObject);
1757 else
1758 {
1759 FIXME("Unhandled object type %s\n", debugstr_guid(riid));
1760 return E_INVALIDARG;
1761 }
1762
1763 if(This->data)
1764 release_data(&This->data_iid, This->data);
1765
1766 This->data_iid = *riid;
1767 This->data = pvObject;
1768
1769 IMimeBody_SetCurrentEncoding(iface, ietEncoding);
1770
1771 /* FIXME: Update the content type.
1772 If pszPriType == NULL use 'application'
1773 If pszSubType == NULL use 'octet-stream' */
1774
1775 return S_OK;
1776 }
1777
1778 static HRESULT WINAPI MimeBody_EmptyData(
1779 IMimeBody* iface)
1780 {
1781 MimeBody *This = impl_from_IMimeBody(iface);
1782 FIXME("(%p)->() stub\n", This);
1783 return E_NOTIMPL;
1784 }
1785
1786 static HRESULT WINAPI MimeBody_CopyTo(
1787 IMimeBody* iface,
1788 IMimeBody* pBody)
1789 {
1790 MimeBody *This = impl_from_IMimeBody(iface);
1791 FIXME("(%p)->(%p) stub\n", This, pBody);
1792 return E_NOTIMPL;
1793 }
1794
1795 static HRESULT WINAPI MimeBody_GetTransmitInfo(
1796 IMimeBody* iface,
1797 LPTRANSMITINFO pTransmitInfo)
1798 {
1799 MimeBody *This = impl_from_IMimeBody(iface);
1800 FIXME("(%p)->(%p) stub\n", This, pTransmitInfo);
1801 return E_NOTIMPL;
1802 }
1803
1804 static HRESULT WINAPI MimeBody_SaveToFile(
1805 IMimeBody* iface,
1806 ENCODINGTYPE ietEncoding,
1807 LPCSTR pszFilePath)
1808 {
1809 MimeBody *This = impl_from_IMimeBody(iface);
1810 FIXME("(%p)->(%d, %s) stub\n", This, ietEncoding, debugstr_a(pszFilePath));
1811 return E_NOTIMPL;
1812 }
1813
1814 static HRESULT WINAPI MimeBody_GetHandle(
1815 IMimeBody* iface,
1816 LPHBODY phBody)
1817 {
1818 MimeBody *This = impl_from_IMimeBody(iface);
1819 TRACE("(%p)->(%p)\n", iface, phBody);
1820
1821 if(!phBody)
1822 return E_INVALIDARG;
1823
1824 *phBody = This->handle;
1825 return This->handle ? S_OK : MIME_E_NO_DATA;
1826 }
1827
1828 static IMimeBodyVtbl body_vtbl =
1829 {
1830 MimeBody_QueryInterface,
1831 MimeBody_AddRef,
1832 MimeBody_Release,
1833 MimeBody_GetClassID,
1834 MimeBody_IsDirty,
1835 MimeBody_Load,
1836 MimeBody_Save,
1837 MimeBody_GetSizeMax,
1838 MimeBody_InitNew,
1839 MimeBody_GetPropInfo,
1840 MimeBody_SetPropInfo,
1841 MimeBody_GetProp,
1842 MimeBody_SetProp,
1843 MimeBody_AppendProp,
1844 MimeBody_DeleteProp,
1845 MimeBody_CopyProps,
1846 MimeBody_MoveProps,
1847 MimeBody_DeleteExcept,
1848 MimeBody_QueryProp,
1849 MimeBody_GetCharset,
1850 MimeBody_SetCharset,
1851 MimeBody_GetParameters,
1852 MimeBody_IsContentType,
1853 MimeBody_BindToObject,
1854 MimeBody_Clone,
1855 MimeBody_SetOption,
1856 MimeBody_GetOption,
1857 MimeBody_EnumProps,
1858 MimeBody_IsType,
1859 MimeBody_SetDisplayName,
1860 MimeBody_GetDisplayName,
1861 MimeBody_GetOffsets,
1862 MimeBody_GetCurrentEncoding,
1863 MimeBody_SetCurrentEncoding,
1864 MimeBody_GetEstimatedSize,
1865 MimeBody_GetDataHere,
1866 MimeBody_GetData,
1867 MimeBody_SetData,
1868 MimeBody_EmptyData,
1869 MimeBody_CopyTo,
1870 MimeBody_GetTransmitInfo,
1871 MimeBody_SaveToFile,
1872 MimeBody_GetHandle
1873 };
1874
1875 static HRESULT MimeBody_set_offsets(MimeBody *body, const BODYOFFSETS *offsets)
1876 {
1877 TRACE("setting offsets to %d, %d, %d, %d\n", offsets->cbBoundaryStart,
1878 offsets->cbHeaderStart, offsets->cbBodyStart, offsets->cbBodyEnd);
1879
1880 body->body_offsets = *offsets;
1881 return S_OK;
1882 }
1883
1884 #define FIRST_CUSTOM_PROP_ID 0x100
1885
1886 static MimeBody *mimebody_create(void)
1887 {
1888 MimeBody *This;
1889 BODYOFFSETS body_offsets;
1890
1891 This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
1892 if (!This)
1893 return NULL;
1894
1895 This->IMimeBody_iface.lpVtbl = &body_vtbl;
1896 This->ref = 1;
1897 This->handle = NULL;
1898 list_init(&This->headers);
1899 list_init(&This->new_props);
1900 This->next_prop_id = FIRST_CUSTOM_PROP_ID;
1901 This->content_pri_type = NULL;
1902 This->content_sub_type = NULL;
1903 This->encoding = IET_7BIT;
1904 This->data = NULL;
1905 This->data_iid = IID_NULL;
1906
1907 body_offsets.cbBoundaryStart = body_offsets.cbHeaderStart = 0;
1908 body_offsets.cbBodyStart = body_offsets.cbBodyEnd = 0;
1909 MimeBody_set_offsets(This, &body_offsets);
1910
1911 return This;
1912 }
1913
1914 HRESULT MimeBody_create(IUnknown *outer, void **ppv)
1915 {
1916 MimeBody *mb;
1917
1918 if(outer)
1919 return CLASS_E_NOAGGREGATION;
1920
1921 if ((mb = mimebody_create()))
1922 {
1923 *ppv = &mb->IMimeBody_iface;
1924 return S_OK;
1925 }
1926 else
1927 {
1928 *ppv = NULL;
1929 return E_OUTOFMEMORY;
1930 }
1931 }
1932
1933 typedef struct body_t
1934 {
1935 struct list entry;
1936 DWORD index;
1937 MimeBody *mime_body;
1938
1939 struct body_t *parent;
1940 struct list children;
1941 } body_t;
1942
1943 typedef struct MimeMessage
1944 {
1945 IMimeMessage IMimeMessage_iface;
1946 LONG ref;
1947 IStream *stream;
1948
1949 struct list body_tree;
1950 DWORD next_index;
1951 } MimeMessage;
1952
1953 static inline MimeMessage *impl_from_IMimeMessage(IMimeMessage *iface)
1954 {
1955 return CONTAINING_RECORD(iface, MimeMessage, IMimeMessage_iface);
1956 }
1957
1958 static HRESULT WINAPI MimeMessage_QueryInterface(IMimeMessage *iface, REFIID riid, void **ppv)
1959 {
1960 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
1961
1962 if (IsEqualIID(riid, &IID_IUnknown) ||
1963 IsEqualIID(riid, &IID_IPersist) ||
1964 IsEqualIID(riid, &IID_IPersistStreamInit) ||
1965 IsEqualIID(riid, &IID_IMimeMessageTree) ||
1966 IsEqualIID(riid, &IID_IMimeMessage))
1967 {
1968 *ppv = iface;
1969 IMimeMessage_AddRef(iface);
1970 return S_OK;
1971 }
1972
1973 FIXME("no interface for %s\n", debugstr_guid(riid));
1974 *ppv = NULL;
1975 return E_NOINTERFACE;
1976 }
1977
1978 static ULONG WINAPI MimeMessage_AddRef(IMimeMessage *iface)
1979 {
1980 MimeMessage *This = impl_from_IMimeMessage(iface);
1981 ULONG ref = InterlockedIncrement(&This->ref);
1982
1983 TRACE("(%p) ref=%d\n", This, ref);
1984
1985 return ref;
1986 }
1987
1988 static void empty_body_list(struct list *list)
1989 {
1990 body_t *body, *cursor2;
1991 LIST_FOR_EACH_ENTRY_SAFE(body, cursor2, list, body_t, entry)
1992 {
1993 empty_body_list(&body->children);
1994 list_remove(&body->entry);
1995 IMimeBody_Release(&body->mime_body->IMimeBody_iface);
1996 HeapFree(GetProcessHeap(), 0, body);
1997 }
1998 }
1999
2000 static ULONG WINAPI MimeMessage_Release(IMimeMessage *iface)
2001 {
2002 MimeMessage *This = impl_from_IMimeMessage(iface);
2003 ULONG ref = InterlockedDecrement(&This->ref);
2004
2005 TRACE("(%p) ref=%d\n", This, ref);
2006
2007 if (!ref)
2008 {
2009 empty_body_list(&This->body_tree);
2010
2011 if(This->stream) IStream_Release(This->stream);
2012 HeapFree(GetProcessHeap(), 0, This);
2013 }
2014
2015 return ref;
2016 }
2017
2018 /*** IPersist methods ***/
2019 static HRESULT WINAPI MimeMessage_GetClassID(
2020 IMimeMessage *iface,
2021 CLSID *pClassID)
2022 {
2023 FIXME("(%p)->(%p)\n", iface, pClassID);
2024 return E_NOTIMPL;
2025 }
2026
2027 /*** IPersistStreamInit methods ***/
2028 static HRESULT WINAPI MimeMessage_IsDirty(
2029 IMimeMessage *iface)
2030 {
2031 FIXME("(%p)->()\n", iface);
2032 return E_NOTIMPL;
2033 }
2034
2035 static body_t *new_body_entry(MimeBody *mime_body, DWORD index, body_t *parent)
2036 {
2037 body_t *body = HeapAlloc(GetProcessHeap(), 0, sizeof(*body));
2038 if(body)
2039 {
2040 body->mime_body = mime_body;
2041 body->index = index;
2042 list_init(&body->children);
2043 body->parent = parent;
2044
2045 mime_body->handle = UlongToHandle(body->index);
2046 }
2047 return body;
2048 }
2049
2050 typedef struct
2051 {
2052 struct list entry;
2053 BODYOFFSETS offsets;
2054 } offset_entry_t;
2055
2056 static HRESULT create_body_offset_list(IStream *stm, const char *boundary, struct list *body_offsets)
2057 {
2058 HRESULT hr;
2059 DWORD read, boundary_start;
2060 int boundary_len = strlen(boundary);
2061 char *buf, *ptr, *overlap;
2062 DWORD start = 0, overlap_no;
2063 offset_entry_t *cur_body = NULL;
2064 BOOL is_first_line = TRUE;
2065 ULARGE_INTEGER cur;
2066 LARGE_INTEGER zero;
2067
2068 list_init(body_offsets);
2069
2070 overlap_no = boundary_len + 5;
2071
2072 overlap = buf = HeapAlloc(GetProcessHeap(), 0, overlap_no + PARSER_BUF_SIZE + 1);
2073
2074 zero.QuadPart = 0;
2075 hr = IStream_Seek(stm, zero, STREAM_SEEK_CUR, &cur);
2076 start = cur.u.LowPart;
2077
2078 do {
2079 hr = IStream_Read(stm, overlap, PARSER_BUF_SIZE, &read);
2080 if(FAILED(hr)) goto end;
2081 if(read == 0) break;
2082 overlap[read] = '\0';
2083
2084 ptr = buf;
2085 while(1) {
2086 if(is_first_line) {
2087 is_first_line = FALSE;
2088 }else {
2089 ptr = strstr(ptr, "\r\n");
2090 if(!ptr)
2091 break;
2092 ptr += 2;
2093 }
2094
2095 boundary_start = start + ptr - buf;
2096
2097 if(*ptr == '-' && *(ptr + 1) == '-' && !memcmp(ptr + 2, boundary, boundary_len)) {
2098 ptr += boundary_len + 2;
2099
2100 if(*ptr == '\r' && *(ptr + 1) == '\n')
2101 {
2102 ptr += 2;
2103 if(cur_body)
2104 {
2105 cur_body->offsets.cbBodyEnd = boundary_start - 2;
2106 list_add_tail(body_offsets, &cur_body->entry);
2107 }
2108 cur_body = HeapAlloc(GetProcessHeap(), 0, sizeof(*cur_body));
2109 cur_body->offsets.cbBoundaryStart = boundary_start;
2110 cur_body->offsets.cbHeaderStart = start + ptr - buf;
2111 }
2112 else if(*ptr == '-' && *(ptr + 1) == '-')
2113 {
2114 if(cur_body)
2115 {
2116 cur_body->offsets.cbBodyEnd = boundary_start - 2;
2117 list_add_tail(body_offsets, &cur_body->entry);
2118 goto end;
2119 }
2120 }
2121 }
2122 }
2123
2124 if(overlap == buf) /* 1st iteration */
2125 {
2126 memmove(buf, buf + PARSER_BUF_SIZE - overlap_no, overlap_no);
2127 overlap = buf + overlap_no;
2128 start += read - overlap_no;
2129 }
2130 else
2131 {
2132 memmove(buf, buf + PARSER_BUF_SIZE, overlap_no);
2133 start += read;
2134 }
2135 } while(1);
2136
2137 end:
2138 HeapFree(GetProcessHeap(), 0, buf);
2139 return hr;
2140 }
2141
2142 static body_t *create_sub_body(MimeMessage *msg, IStream *pStm, BODYOFFSETS *offset, body_t *parent)
2143 {
2144 ULARGE_INTEGER start, length;
2145 MimeBody *mime_body;
2146 HRESULT hr;
2147 body_t *body;
2148 LARGE_INTEGER pos;
2149
2150 pos.QuadPart = offset->cbHeaderStart;
2151 IStream_Seek(pStm, pos, STREAM_SEEK_SET, NULL);
2152
2153 mime_body = mimebody_create();
2154 IMimeBody_Load(&mime_body->IMimeBody_iface, pStm);
2155
2156 pos.QuadPart = 0;
2157 hr = IStream_Seek(pStm, pos, STREAM_SEEK_CUR, &start);
2158 offset->cbBodyStart = start.QuadPart;
2159 if (parent) MimeBody_set_offsets(mime_body, offset);
2160
2161 length.QuadPart = offset->cbBodyEnd - offset->cbBodyStart;
2162 create_sub_stream(pStm, start, length, (IStream**)&mime_body->data);
2163 mime_body->data_iid = IID_IStream;
2164
2165 body = new_body_entry(mime_body, msg->next_index++, parent);
2166
2167 if(IMimeBody_IsContentType(&mime_body->IMimeBody_iface, "multipart", NULL) == S_OK)
2168 {
2169 MIMEPARAMINFO *param_info;
2170 ULONG count, i;
2171 IMimeAllocator *alloc;
2172
2173 hr = IMimeBody_GetParameters(&mime_body->IMimeBody_iface, "Content-Type", &count,
2174 &param_info);
2175 if(hr != S_OK || count == 0) return body;
2176
2177 MimeOleGetAllocator(&alloc);
2178
2179 for(i = 0; i < count; i++)
2180 {
2181 if(!lstrcmpiA(param_info[i].pszName, "boundary"))
2182 {
2183 struct list offset_list;
2184 offset_entry_t *cur, *cursor2;
2185 hr = create_body_offset_list(pStm, param_info[i].pszData, &offset_list);
2186 LIST_FOR_EACH_ENTRY_SAFE(cur, cursor2, &offset_list, offset_entry_t, entry)
2187 {
2188 body_t *sub_body;
2189
2190 sub_body = create_sub_body(msg, pStm, &cur->offsets, body);
2191 list_add_tail(&body->children, &sub_body->entry);
2192 list_remove(&cur->entry);
2193 HeapFree(GetProcessHeap(), 0, cur);
2194 }
2195 break;
2196 }
2197 }
2198 IMimeAllocator_FreeParamInfoArray(alloc, count, param_info, TRUE);
2199 IMimeAllocator_Release(alloc);
2200 }
2201 return body;
2202 }
2203
2204 static HRESULT WINAPI MimeMessage_Load(IMimeMessage *iface, IStream *pStm)
2205 {
2206 MimeMessage *This = impl_from_IMimeMessage(iface);
2207 body_t *root_body;
2208 BODYOFFSETS offsets;
2209 ULARGE_INTEGER cur;
2210 LARGE_INTEGER zero;
2211
2212 TRACE("(%p)->(%p)\n", iface, pStm);
2213
2214 if(This->stream)
2215 {
2216 FIXME("already loaded a message\n");
2217 return E_FAIL;
2218 }
2219
2220 empty_body_list(&This->body_tree);
2221
2222 IStream_AddRef(pStm);
2223 This->stream = pStm;
2224 offsets.cbBoundaryStart = offsets.cbHeaderStart = 0;
2225 offsets.cbBodyStart = offsets.cbBodyEnd = 0;
2226
2227 root_body = create_sub_body(This, pStm, &offsets, NULL);
2228
2229 zero.QuadPart = 0;
2230 IStream_Seek(pStm, zero, STREAM_SEEK_END, &cur);
2231 offsets.cbBodyEnd = cur.u.LowPart;
2232 MimeBody_set_offsets(root_body->mime_body, &offsets);
2233
2234 list_add_head(&This->body_tree, &root_body->entry);
2235
2236 return S_OK;
2237 }
2238
2239 static HRESULT WINAPI MimeMessage_Save(IMimeMessage *iface, IStream *pStm, BOOL fClearDirty)
2240 {
2241 FIXME("(%p)->(%p, %s)\n", iface, pStm, fClearDirty ? "TRUE" : "FALSE");
2242 return E_NOTIMPL;
2243 }
2244
2245 static HRESULT WINAPI MimeMessage_GetSizeMax(
2246 IMimeMessage *iface,
2247 ULARGE_INTEGER *pcbSize)
2248 {
2249 FIXME("(%p)->(%p)\n", iface, pcbSize);
2250 return E_NOTIMPL;
2251 }
2252
2253 static HRESULT WINAPI MimeMessage_InitNew(
2254 IMimeMessage *iface)
2255 {
2256 FIXME("(%p)->()\n", iface);
2257 return E_NOTIMPL;
2258 }
2259
2260 /*** IMimeMessageTree methods ***/
2261 static HRESULT WINAPI MimeMessage_GetMessageSource(IMimeMessage *iface, IStream **ppStream,
2262 DWORD dwFlags)
2263 {
2264 MimeMessage *This = impl_from_IMimeMessage(iface);
2265
2266 FIXME("(%p)->(%p, 0x%x)\n", iface, ppStream, dwFlags);
2267
2268 IStream_AddRef(This->stream);
2269 *ppStream = This->stream;
2270 return S_OK;
2271 }
2272
2273 static HRESULT WINAPI MimeMessage_GetMessageSize(
2274 IMimeMessage *iface,
2275 ULONG *pcbSize,
2276 DWORD dwFlags)
2277 {
2278 FIXME("(%p)->(%p, 0x%x)\n", iface, pcbSize, dwFlags);
2279 return E_NOTIMPL;
2280 }
2281
2282 static HRESULT WINAPI MimeMessage_LoadOffsetTable(
2283 IMimeMessage *iface,
2284 IStream *pStream)
2285 {
2286 FIXME("(%p)->(%p)\n", iface, pStream);
2287 return E_NOTIMPL;
2288 }
2289
2290 static HRESULT WINAPI MimeMessage_SaveOffsetTable(
2291 IMimeMessage *iface,
2292 IStream *pStream,
2293 DWORD dwFlags)
2294 {
2295 FIXME("(%p)->(%p, 0x%x)\n", iface, pStream, dwFlags);
2296 return E_NOTIMPL;
2297 }
2298
2299
2300 static HRESULT WINAPI MimeMessage_GetFlags(
2301 IMimeMessage *iface,
2302 DWORD *pdwFlags)
2303 {
2304 FIXME("(%p)->(%p)\n", iface, pdwFlags);
2305 return E_NOTIMPL;
2306 }
2307
2308 static HRESULT WINAPI MimeMessage_Commit(
2309 IMimeMessage *iface,
2310 DWORD dwFlags)
2311 {
2312 FIXME("(%p)->(0x%x)\n", iface, dwFlags);
2313 return S_OK;
2314 }
2315
2316
2317 static HRESULT WINAPI MimeMessage_HandsOffStorage(
2318 IMimeMessage *iface)
2319 {
2320 FIXME("(%p)->()\n", iface);
2321 return E_NOTIMPL;
2322 }
2323
2324 static HRESULT find_body(struct list *list, HBODY hbody, body_t **body)
2325 {
2326 body_t *cur;
2327 HRESULT hr;
2328
2329 if(hbody == HBODY_ROOT)
2330 {
2331 *body = LIST_ENTRY(list_head(list), body_t, entry);
2332 return S_OK;
2333 }
2334
2335 LIST_FOR_EACH_ENTRY(cur, list, body_t, entry)
2336 {
2337 if(cur->index == HandleToUlong(hbody))
2338 {
2339 *body = cur;
2340 return S_OK;
2341 }
2342 hr = find_body(&cur->children, hbody, body);
2343 if(hr == S_OK) return S_OK;
2344 }
2345 return S_FALSE;
2346 }
2347
2348 static HRESULT WINAPI MimeMessage_BindToObject(IMimeMessage *iface, const HBODY hBody, REFIID riid,
2349 void **ppvObject)
2350 {
2351 MimeMessage *This = impl_from_IMimeMessage(iface);
2352 HRESULT hr;
2353 body_t *body;
2354
2355 TRACE("(%p)->(%p, %s, %p)\n", iface, hBody, debugstr_guid(riid), ppvObject);
2356
2357 hr = find_body(&This->body_tree, hBody, &body);
2358
2359 if(hr != S_OK) return hr;
2360
2361 if(IsEqualIID(riid, &IID_IMimeBody))
2362 {
2363 IMimeBody_AddRef(&body->mime_body->IMimeBody_iface);
2364 *ppvObject = &body->mime_body->IMimeBody_iface;
2365 return S_OK;
2366 }
2367
2368 return E_NOINTERFACE;
2369 }
2370
2371 static HRESULT WINAPI MimeMessage_SaveBody(
2372 IMimeMessage *iface,
2373 HBODY hBody,
2374 DWORD dwFlags,
2375 IStream *pStream)
2376 {
2377 FIXME("(%p)->(%p, 0x%x, %p)\n", iface, hBody, dwFlags, pStream);
2378 return E_NOTIMPL;
2379 }
2380
2381 static HRESULT get_body(MimeMessage *msg, BODYLOCATION location, HBODY pivot, body_t **out)
2382 {
2383 body_t *root = LIST_ENTRY(list_head(&msg->body_tree), body_t, entry);
2384 body_t *body;
2385 HRESULT hr;
2386 struct list *list;
2387
2388 if(location == IBL_ROOT)
2389 {
2390 *out = root;
2391 return S_OK;
2392 }
2393
2394 hr = find_body(&msg->body_tree, pivot, &body);
2395
2396 if(hr == S_OK)
2397 {
2398 switch(location)
2399 {
2400 case IBL_PARENT:
2401 if(body->parent)
2402 *out = body->parent;
2403 else
2404 hr = MIME_E_NOT_FOUND;
2405 break;
2406
2407 case IBL_FIRST:
2408 list = list_head(&body->children);
2409 if(list)
2410 *out = LIST_ENTRY(list, body_t, entry);
2411 else
2412 hr = MIME_E_NOT_FOUND;
2413 break;
2414
2415 case IBL_LAST:
2416 list = list_tail(&body->children);
2417 if(list)
2418 *out = LIST_ENTRY(list, body_t, entry);
2419 else
2420 hr = MIME_E_NOT_FOUND;
2421 break;
2422
2423 case IBL_NEXT:
2424 list = list_next(&body->parent->children, &body->entry);
2425 if(list)
2426 *out = LIST_ENTRY(list, body_t, entry);
2427 else
2428 hr = MIME_E_NOT_FOUND;
2429 break;
2430
2431 case IBL_PREVIOUS:
2432 list = list_prev(&body->parent->children, &body->entry);
2433 if(list)
2434 *out = LIST_ENTRY(list, body_t, entry);
2435 else
2436 hr = MIME_E_NOT_FOUND;
2437 break;
2438
2439 default:
2440 hr = E_FAIL;
2441 break;
2442 }
2443 }
2444
2445 return hr;
2446 }
2447
2448
2449 static HRESULT WINAPI MimeMessage_InsertBody(
2450 IMimeMessage *iface,
2451 BODYLOCATION location,
2452 HBODY hPivot,
2453 LPHBODY phBody)
2454 {
2455 FIXME("(%p)->(%d, %p, %p)\n", iface, location, hPivot, phBody);
2456 return E_NOTIMPL;
2457 }
2458
2459 static HRESULT WINAPI MimeMessage_GetBody(IMimeMessage *iface, BODYLOCATION location, HBODY hPivot,
2460 HBODY *phBody)
2461 {
2462 MimeMessage *This = impl_from_IMimeMessage(iface);
2463 body_t *body;
2464 HRESULT hr;
2465
2466 TRACE("(%p)->(%d, %p, %p)\n", iface, location, hPivot, phBody);
2467
2468 if(!phBody)
2469 return E_INVALIDARG;
2470
2471 *phBody = NULL;
2472
2473 hr = get_body(This, location, hPivot, &body);
2474
2475 if(hr == S_OK) *phBody = UlongToHandle(body->index);
2476
2477 return hr;
2478 }
2479
2480 static HRESULT WINAPI MimeMessage_DeleteBody(
2481 IMimeMessage *iface,
2482 HBODY hBody,
2483 DWORD dwFlags)
2484 {
2485 FIXME("(%p)->(%p, %08x)\n", iface, hBody, dwFlags);
2486 return E_NOTIMPL;
2487 }
2488
2489 static HRESULT WINAPI MimeMessage_MoveBody(
2490 IMimeMessage *iface,
2491 HBODY hBody,
2492 BODYLOCATION location)
2493 {
2494 FIXME("(%p)->(%d)\n", iface, location);
2495 return E_NOTIMPL;
2496 }
2497
2498 static void count_children(body_t *body, boolean recurse, ULONG *count)
2499 {
2500 body_t *child;
2501
2502 LIST_FOR_EACH_ENTRY(child, &body->children, body_t, entry)
2503 {
2504 (*count)++;
2505 if(recurse) count_children(child, recurse, count);
2506 }
2507 }
2508
2509 static HRESULT WINAPI MimeMessage_CountBodies(IMimeMessage *iface, HBODY hParent, boolean fRecurse,
2510 ULONG *pcBodies)
2511 {
2512 HRESULT hr;
2513 MimeMessage *This = impl_from_IMimeMessage(iface);
2514 body_t *body;
2515
2516 TRACE("(%p)->(%p, %s, %p)\n", iface, hParent, fRecurse ? "TRUE" : "FALSE", pcBodies);
2517
2518 hr = find_body(&This->body_tree, hParent, &body);
2519 if(hr != S_OK) return hr;
2520
2521 *pcBodies = 1;
2522 count_children(body, fRecurse, pcBodies);
2523
2524 return S_OK;
2525 }
2526
2527 static HRESULT find_next(MimeMessage *This, body_t *body, FINDBODY *find, HBODY *out)
2528 {
2529 struct list *ptr;
2530 HBODY next;
2531
2532 for (;;)
2533 {
2534 if (!body) ptr = list_head( &This->body_tree );
2535 else
2536 {
2537 ptr = list_head( &body->children );
2538 while (!ptr)
2539 {
2540 if (!body->parent) return MIME_E_NOT_FOUND;
2541 if (!(ptr = list_next( &body->parent->children, &body->entry ))) body = body->parent;
2542 }
2543 }
2544
2545 body = LIST_ENTRY( ptr, body_t, entry );
2546 next = UlongToHandle( body->index );
2547 find->dwReserved = body->index;
2548 if (IMimeBody_IsContentType(&body->mime_body->IMimeBody_iface, find->pszPriType,
2549 find->pszSubType) == S_OK)
2550 {
2551 *out = next;
2552 return S_OK;
2553 }
2554 }
2555 return MIME_E_NOT_FOUND;
2556 }
2557
2558 static HRESULT WINAPI MimeMessage_FindFirst(IMimeMessage *iface, FINDBODY *pFindBody, HBODY *phBody)
2559 {
2560 MimeMessage *This = impl_from_IMimeMessage(iface);
2561
2562 TRACE("(%p)->(%p, %p)\n", iface, pFindBody, phBody);
2563
2564 pFindBody->dwReserved = 0;
2565 return find_next(This, NULL, pFindBody, phBody);
2566 }
2567
2568 static HRESULT WINAPI MimeMessage_FindNext(IMimeMessage *iface, FINDBODY *pFindBody, HBODY *phBody)
2569 {
2570 MimeMessage *This = impl_from_IMimeMessage(iface);
2571 body_t *body;
2572 HRESULT hr;
2573
2574 TRACE("(%p)->(%p, %p)\n", iface, pFindBody, phBody);
2575
2576 hr = find_body( &This->body_tree, UlongToHandle( pFindBody->dwReserved ), &body );
2577 if (hr != S_OK) return MIME_E_NOT_FOUND;
2578 return find_next(This, body, pFindBody, phBody);
2579 }
2580
2581 static HRESULT WINAPI MimeMessage_ResolveURL(
2582 IMimeMessage *iface,
2583 HBODY hRelated,
2584 LPCSTR pszBase,
2585 LPCSTR pszURL,
2586 DWORD dwFlags,
2587 LPHBODY phBody)
2588 {
2589 FIXME("(%p)->(%p, %s, %s, 0x%x, %p)\n", iface, hRelated, pszBase, pszURL, dwFlags, phBody);
2590 return E_NOTIMPL;
2591 }
2592
2593 static HRESULT WINAPI MimeMessage_ToMultipart(
2594 IMimeMessage *iface,
2595 HBODY hBody,
2596 LPCSTR pszSubType,
2597 LPHBODY phMultipart)
2598 {
2599 FIXME("(%p)->(%p, %s, %p)\n", iface, hBody, pszSubType, phMultipart);
2600 return E_NOTIMPL;
2601 }
2602
2603 static HRESULT WINAPI MimeMessage_GetBodyOffsets(
2604 IMimeMessage *iface,
2605 HBODY hBody,
2606 LPBODYOFFSETS pOffsets)
2607 {
2608 FIXME("(%p)->(%p, %p)\n", iface, hBody, pOffsets);
2609 return E_NOTIMPL;
2610 }
2611
2612 static HRESULT WINAPI MimeMessage_GetCharset(
2613 IMimeMessage *iface,
2614 LPHCHARSET phCharset)
2615 {
2616 FIXME("(%p)->(%p)\n", iface, phCharset);
2617 *phCharset = NULL;
2618 return S_OK;
2619 }
2620
2621 static HRESULT WINAPI MimeMessage_SetCharset(
2622 IMimeMessage *iface,
2623 HCHARSET hCharset,
2624 CSETAPPLYTYPE applytype)
2625 {
2626 FIXME("(%p)->(%p, %d)\n", iface, hCharset, applytype);
2627 return E_NOTIMPL;
2628 }
2629
2630 static HRESULT WINAPI MimeMessage_IsBodyType(
2631 IMimeMessage *iface,
2632 HBODY hBody,
2633 IMSGBODYTYPE bodytype)
2634 {
2635 HRESULT hr;
2636 IMimeBody *mime_body;
2637 TRACE("(%p)->(%p, %d)\n", iface, hBody, bodytype);
2638
2639 hr = IMimeMessage_BindToObject(iface, hBody, &IID_IMimeBody, (void**)&mime_body);
2640 if(hr != S_OK) return hr;
2641
2642 hr = IMimeBody_IsType(mime_body, bodytype);
2643 MimeBody_Release(mime_body);
2644 return hr;
2645 }
2646
2647 static HRESULT WINAPI MimeMessage_IsContentType(
2648 IMimeMessage *iface,
2649 HBODY hBody,
2650 LPCSTR pszPriType,
2651 LPCSTR pszSubType)
2652 {
2653 HRESULT hr;
2654 IMimeBody *mime_body;
2655 TRACE("(%p)->(%p, %s, %s)\n", iface, hBody, debugstr_a(pszPriType),
2656 debugstr_a(pszSubType));
2657
2658 hr = IMimeMessage_BindToObject(iface, hBody, &IID_IMimeBody, (void**)&mime_body);
2659 if(FAILED(hr)) return hr;
2660
2661 hr = IMimeBody_IsContentType(mime_body, pszPriType, pszSubType);
2662 IMimeBody_Release(mime_body);
2663 return hr;
2664 }
2665
2666 static HRESULT WINAPI MimeMessage_QueryBodyProp(
2667 IMimeMessage *iface,
2668 HBODY hBody,
2669 LPCSTR pszName,
2670 LPCSTR pszCriteria,
2671 boolean fSubString,
2672 boolean fCaseSensitive)
2673 {
2674 FIXME("(%p)->(%p, %s, %s, %s, %s)\n", iface, hBody, pszName, pszCriteria, fSubString ? "TRUE" : "FALSE", fCaseSensitive ? "TRUE" : "FALSE");
2675 return E_NOTIMPL;
2676 }
2677
2678 static HRESULT WINAPI MimeMessage_GetBodyProp(
2679 IMimeMessage *iface,
2680 HBODY hBody,
2681 LPCSTR pszName,
2682 DWORD dwFlags,
2683 LPPROPVARIANT pValue)
2684 {
2685 HRESULT hr;
2686 IMimeBody *mime_body;
2687
2688 TRACE("(%p)->(%p, %s, 0x%x, %p)\n", iface, hBody, pszName, dwFlags, pValue);
2689
2690 hr = IMimeMessage_BindToObject(iface, hBody, &IID_IMimeBody, (void**)&mime_body);
2691 if(hr != S_OK) return hr;
2692
2693 hr = IMimeBody_GetProp(mime_body, pszName, dwFlags, pValue);
2694 IMimeBody_Release(mime_body);
2695
2696 return hr;
2697 }
2698
2699 static HRESULT WINAPI MimeMessage_SetBodyProp(
2700 IMimeMessage *iface,
2701 HBODY hBody,
2702 LPCSTR pszName,
2703 DWORD dwFlags,
2704 LPCPROPVARIANT pValue)
2705 {
2706 FIXME("(%p)->(%p, %s, 0x%x, %p)\n", iface, hBody, pszName, dwFlags, pValue);
2707 return E_NOTIMPL;
2708 }
2709
2710 static HRESULT WINAPI MimeMessage_DeleteBodyProp(
2711 IMimeMessage *iface,
2712 HBODY hBody,
2713 LPCSTR pszName)
2714 {
2715 FIXME("(%p)->(%p, %s)\n", iface, hBody, pszName);
2716 return E_NOTIMPL;
2717 }
2718
2719 static HRESULT WINAPI MimeMessage_SetOption(
2720 IMimeMessage *iface,
2721 const TYPEDID oid,
2722 LPCPROPVARIANT pValue)
2723 {
2724 HRESULT hr = S_OK;
2725 TRACE("(%p)->(%08x, %p)\n", iface, oid, pValue);
2726
2727 /* Message ID is checked before type.
2728 * OID 0x4D -> 0x56 and 0x58 aren't defined but will filtered out later.
2729 */
2730 if(TYPEDID_ID(oid) < TYPEDID_ID(OID_ALLOW_8BIT_HEADER) || TYPEDID_ID(oid) > TYPEDID_ID(OID_SECURITY_2KEY_CERT_BAG_64))
2731 {
2732 WARN("oid (%08x) out of range\n", oid);
2733 return MIME_E_INVALID_OPTION_ID;
2734 }
2735
2736 if(pValue->vt != TYPEDID_TYPE(oid))
2737 {
2738 WARN("Called with vartype %04x and oid %08x\n", pValue->vt, oid);
2739 return S_OK;
2740 }
2741
2742 switch(oid)
2743 {
2744 case OID_HIDE_TNEF_ATTACHMENTS:
2745 FIXME("OID_HIDE_TNEF_ATTACHMENTS (value %d): ignoring\n", pValue->u.boolVal);
2746 break;
2747 case OID_SHOW_MACBINARY:
2748 FIXME("OID_SHOW_MACBINARY (value %d): ignoring\n", pValue->u.boolVal);
2749 break;
2750 case OID_SAVEBODY_KEEPBOUNDARY:
2751 FIXME("OID_SAVEBODY_KEEPBOUNDARY (value %d): ignoring\n", pValue->u.boolVal);
2752 break;
2753 case OID_CLEANUP_TREE_ON_SAVE:
2754 FIXME("OID_CLEANUP_TREE_ON_SAVE (value %d): ignoring\n", pValue->u.boolVal);
2755 break;
2756 default:
2757 FIXME("Unhandled oid %08x\n", oid);
2758 hr = MIME_E_INVALID_OPTION_ID;
2759 }
2760
2761 return hr;
2762 }
2763
2764 static HRESULT WINAPI MimeMessage_GetOption(
2765 IMimeMessage *iface,
2766 const TYPEDID oid,
2767 LPPROPVARIANT pValue)
2768 {
2769 FIXME("(%p)->(%08x, %p)\n", iface, oid, pValue);
2770 return E_NOTIMPL;
2771 }
2772
2773 /*** IMimeMessage methods ***/
2774 static HRESULT WINAPI MimeMessage_CreateWebPage(
2775 IMimeMessage *iface,
2776 IStream *pRootStm,
2777 LPWEBPAGEOPTIONS pOptions,
2778 IMimeMessageCallback *pCallback,
2779 IMoniker **ppMoniker)
2780 {
2781 FIXME("(%p)->(%p, %p, %p, %p)\n", iface, pRootStm, pOptions, pCallback, ppMoniker);
2782 *ppMoniker = NULL;
2783 return E_NOTIMPL;
2784 }
2785
2786 static HRESULT WINAPI MimeMessage_GetProp(
2787 IMimeMessage *iface,
2788 LPCSTR pszName,
2789 DWORD dwFlags,
2790 LPPROPVARIANT pValue)
2791 {
2792 FIXME("(%p)->(%s, 0x%x, %p)\n", iface, pszName, dwFlags, pValue);
2793 return E_NOTIMPL;
2794 }
2795
2796 static HRESULT WINAPI MimeMessage_SetProp(
2797 IMimeMessage *iface,
2798 LPCSTR pszName,
2799 DWORD dwFlags,
2800 LPCPROPVARIANT pValue)
2801 {
2802 FIXME("(%p)->(%s, 0x%x, %p)\n", iface, pszName, dwFlags, pValue);
2803 return E_NOTIMPL;
2804 }
2805
2806 static HRESULT WINAPI MimeMessage_DeleteProp(
2807 IMimeMessage *iface,
2808 LPCSTR pszName)
2809 {
2810 FIXME("(%p)->(%s)\n", iface, pszName);
2811 return E_NOTIMPL;
2812 }
2813
2814 static HRESULT WINAPI MimeMessage_QueryProp(
2815 IMimeMessage *iface,
2816 LPCSTR pszName,
2817 LPCSTR pszCriteria,
2818 boolean fSubString,
2819 boolean fCaseSensitive)
2820 {
2821 FIXME("(%p)->(%s, %s, %s, %s)\n", iface, pszName, pszCriteria, fSubString ? "TRUE" : "FALSE", fCaseSensitive ? "TRUE" : "FALSE");
2822 return E_NOTIMPL;
2823 }
2824
2825 static HRESULT WINAPI MimeMessage_GetTextBody(
2826 IMimeMessage *iface,
2827 DWORD dwTxtType,
2828 ENCODINGTYPE ietEncoding,
2829 IStream **pStream,
2830 LPHBODY phBody)
2831 {
2832 HRESULT hr;
2833 HBODY hbody;
2834 FINDBODY find_struct;
2835 IMimeBody *mime_body;
2836 static char text[] = "text";
2837 static char plain[] = "plain";
2838 static char html[] = "html";
2839
2840 TRACE("(%p)->(%d, %d, %p, %p)\n", iface, dwTxtType, ietEncoding, pStream, phBody);
2841
2842 find_struct.pszPriType = text;
2843
2844 switch(dwTxtType)
2845 {
2846 case TXT_PLAIN:
2847 find_struct.pszSubType = plain;
2848 break;
2849 case TXT_HTML:
2850 find_struct.pszSubType = html;
2851 break;
2852 default:
2853 return MIME_E_INVALID_TEXT_TYPE;
2854 }
2855
2856 hr = IMimeMessage_FindFirst(iface, &find_struct, &hbody);
2857 if(hr != S_OK)
2858 {
2859 TRACE("not found hr %08x\n", hr);
2860 *phBody = NULL;
2861 return hr;
2862 }
2863
2864 IMimeMessage_BindToObject(iface, hbody, &IID_IMimeBody, (void**)&mime_body);
2865
2866 IMimeBody_GetData(mime_body, ietEncoding, pStream);
2867 *phBody = hbody;
2868 IMimeBody_Release(mime_body);
2869 return hr;
2870 }
2871
2872 static HRESULT WINAPI MimeMessage_SetTextBody(
2873 IMimeMessage *iface,
2874 DWORD dwTxtType,
2875 ENCODINGTYPE ietEncoding,
2876 HBODY hAlternative,
2877 IStream *pStream,
2878 LPHBODY phBody)
2879 {
2880 FIXME("(%p)->(%d, %d, %p, %p, %p)\n", iface, dwTxtType, ietEncoding, hAlternative, pStream, phBody);
2881 return E_NOTIMPL;
2882 }
2883
2884 static HRESULT WINAPI MimeMessage_AttachObject(
2885 IMimeMessage *iface,
2886 REFIID riid,
2887 void *pvObject,
2888 LPHBODY phBody)
2889 {
2890 FIXME("(%p)->(%s, %p, %p)\n", iface, debugstr_guid(riid), pvObject, phBody);
2891 return E_NOTIMPL;
2892 }
2893
2894 static HRESULT WINAPI MimeMessage_AttachFile(
2895 IMimeMessage *iface,
2896 LPCSTR pszFilePath,
2897 IStream *pstmFile,
2898 LPHBODY phBody)
2899 {
2900 FIXME("(%p)->(%s, %p, %p)\n", iface, pszFilePath, pstmFile, phBody);
2901 return E_NOTIMPL;
2902 }
2903
2904 static HRESULT WINAPI MimeMessage_AttachURL(
2905 IMimeMessage *iface,
2906 LPCSTR pszBase,
2907 LPCSTR pszURL,
2908 DWORD dwFlags,
2909 IStream *pstmURL,
2910 LPSTR *ppszCIDURL,
2911 LPHBODY phBody)
2912 {
2913 FIXME("(%p)->(%s, %s, 0x%x, %p, %p, %p)\n", iface, pszBase, pszURL, dwFlags, pstmURL, ppszCIDURL, phBody);
2914 return E_NOTIMPL;
2915 }
2916
2917 static HRESULT WINAPI MimeMessage_GetAttachments(
2918 IMimeMessage *iface,
2919 ULONG *pcAttach,
2920 LPHBODY *pprghAttach)
2921 {
2922 HRESULT hr;
2923 FINDBODY find_struct;
2924 HBODY hbody;
2925 LPHBODY array;
2926 ULONG size = 10;
2927
2928 TRACE("(%p)->(%p, %p)\n", iface, pcAttach, pprghAttach);
2929
2930 *pcAttach = 0;
2931 array = CoTaskMemAlloc(size * sizeof(HBODY));
2932
2933 find_struct.pszPriType = find_struct.pszSubType = NULL;
2934 hr = IMimeMessage_FindFirst(iface, &find_struct, &hbody);
2935 while(hr == S_OK)
2936 {
2937 hr = IMimeMessage_IsContentType(iface, hbody, "multipart", NULL);
2938 TRACE("IsCT rets %08x %d\n", hr, *pcAttach);
2939 if(hr != S_OK)
2940 {
2941 if(*pcAttach + 1 > size)
2942 {
2943 size *= 2;
2944 array = CoTaskMemRealloc(array, size * sizeof(HBODY));
2945 }
2946 array[*pcAttach] = hbody;
2947 (*pcAttach)++;
2948 }
2949 hr = IMimeMessage_FindNext(iface, &find_struct, &hbody);
2950 }
2951
2952 *pprghAttach = array;
2953 return S_OK;
2954 }
2955
2956 static HRESULT WINAPI MimeMessage_GetAddressTable(
2957 IMimeMessage *iface,
2958 IMimeAddressTable **ppTable)
2959 {
2960 FIXME("(%p)->(%p)\n", iface, ppTable);
2961 return E_NOTIMPL;
2962 }
2963
2964 static HRESULT WINAPI MimeMessage_GetSender(
2965 IMimeMessage *iface,
2966 LPADDRESSPROPS pAddress)
2967 {
2968 FIXME("(%p)->(%p)\n", iface, pAddress);
2969 return E_NOTIMPL;
2970 }
2971
2972 static HRESULT WINAPI MimeMessage_GetAddressTypes(
2973 IMimeMessage *iface,
2974 DWORD dwAdrTypes,
2975 DWORD dwProps,
2976 LPADDRESSLIST pList)
2977 {
2978 FIXME("(%p)->(%d, %d, %p)\n", iface, dwAdrTypes, dwProps, pList);
2979 return E_NOTIMPL;
2980 }
2981
2982 static HRESULT WINAPI MimeMessage_GetAddressFormat(
2983 IMimeMessage *iface,
2984 DWORD dwAdrTypes,
2985 ADDRESSFORMAT format,
2986 LPSTR *ppszFormat)
2987 {
2988 FIXME("(%p)->(%d, %d, %p)\n", iface, dwAdrTypes, format, ppszFormat);
2989 return E_NOTIMPL;
2990 }
2991
2992 static HRESULT WINAPI MimeMessage_EnumAddressTypes(
2993 IMimeMessage *iface,
2994 DWORD dwAdrTypes,
2995 DWORD dwProps,
2996 IMimeEnumAddressTypes **ppEnum)
2997 {
2998 FIXME("(%p)->(%d, %d, %p)\n", iface, dwAdrTypes, dwProps, ppEnum);
2999 return E_NOTIMPL;
3000 }
3001
3002 static HRESULT WINAPI MimeMessage_SplitMessage(
3003 IMimeMessage *iface,
3004 ULONG cbMaxPart,
3005 IMimeMessageParts **ppParts)
3006 {
3007 FIXME("(%p)->(%d, %p)\n", iface, cbMaxPart, ppParts);
3008 return E_NOTIMPL;
3009 }
3010
3011 static HRESULT WINAPI MimeMessage_GetRootMoniker(
3012 IMimeMessage *iface,
3013 IMoniker **ppMoniker)
3014 {
3015 FIXME("(%p)->(%p)\n", iface, ppMoniker);
3016 return E_NOTIMPL;
3017 }
3018
3019 static const IMimeMessageVtbl MimeMessageVtbl =
3020 {
3021 MimeMessage_QueryInterface,
3022 MimeMessage_AddRef,
3023 MimeMessage_Release,
3024 MimeMessage_GetClassID,
3025 MimeMessage_IsDirty,
3026 MimeMessage_Load,
3027 MimeMessage_Save,
3028 MimeMessage_GetSizeMax,
3029 MimeMessage_InitNew,
3030 MimeMessage_GetMessageSource,
3031 MimeMessage_GetMessageSize,
3032 MimeMessage_LoadOffsetTable,
3033 MimeMessage_SaveOffsetTable,
3034 MimeMessage_GetFlags,
3035 MimeMessage_Commit,
3036 MimeMessage_HandsOffStorage,
3037 MimeMessage_BindToObject,
3038 MimeMessage_SaveBody,
3039 MimeMessage_InsertBody,
3040 MimeMessage_GetBody,
3041 MimeMessage_DeleteBody,
3042 MimeMessage_MoveBody,
3043 MimeMessage_CountBodies,
3044 MimeMessage_FindFirst,
3045 MimeMessage_FindNext,
3046 MimeMessage_ResolveURL,
3047 MimeMessage_ToMultipart,
3048 MimeMessage_GetBodyOffsets,
3049 MimeMessage_GetCharset,
3050 MimeMessage_SetCharset,
3051 MimeMessage_IsBodyType,
3052 MimeMessage_IsContentType,
3053 MimeMessage_QueryBodyProp,
3054 MimeMessage_GetBodyProp,
3055 MimeMessage_SetBodyProp,
3056 MimeMessage_DeleteBodyProp,
3057 MimeMessage_SetOption,
3058 MimeMessage_GetOption,
3059 MimeMessage_CreateWebPage,
3060 MimeMessage_GetProp,
3061 MimeMessage_SetProp,
3062 MimeMessage_DeleteProp,
3063 MimeMessage_QueryProp,
3064 MimeMessage_GetTextBody,
3065 MimeMessage_SetTextBody,
3066 MimeMessage_AttachObject,
3067 MimeMessage_AttachFile,
3068 MimeMessage_AttachURL,
3069 MimeMessage_GetAttachments,
3070 MimeMessage_GetAddressTable,
3071 MimeMessage_GetSender,
3072 MimeMessage_GetAddressTypes,
3073 MimeMessage_GetAddressFormat,
3074 MimeMessage_EnumAddressTypes,
3075 MimeMessage_SplitMessage,
3076 MimeMessage_GetRootMoniker,
3077 };
3078
3079 HRESULT MimeMessage_create(IUnknown *outer, void **obj)
3080 {
3081 MimeMessage *This;
3082 MimeBody *mime_body;
3083 body_t *root_body;
3084
3085 TRACE("(%p, %p)\n", outer, obj);
3086
3087 if (outer)
3088 {
3089 FIXME("outer unknown not supported yet\n");
3090 return E_NOTIMPL;
3091 }
3092
3093 *obj = NULL;
3094
3095 This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
3096 if (!This) return E_OUTOFMEMORY;
3097
3098 This->IMimeMessage_iface.lpVtbl = &MimeMessageVtbl;
3099 This->ref = 1;
3100 This->stream = NULL;
3101 list_init(&This->body_tree);
3102 This->next_index = 1;
3103
3104 mime_body = mimebody_create();
3105 root_body = new_body_entry(mime_body, This->next_index++, NULL);
3106 list_add_head(&This->body_tree, &root_body->entry);
3107
3108 *obj = &This->IMimeMessage_iface;
3109 return S_OK;
3110 }
3111
3112 /***********************************************************************
3113 * MimeOleCreateMessage (INETCOMM.@)
3114 */
3115 HRESULT WINAPI MimeOleCreateMessage(IUnknown *pUnkOuter, IMimeMessage **ppMessage)
3116 {
3117 TRACE("(%p, %p)\n", pUnkOuter, ppMessage);
3118 return MimeMessage_create(NULL, (void **)ppMessage);
3119 }
3120
3121 /***********************************************************************
3122 * MimeOleSetCompatMode (INETCOMM.@)
3123 */
3124 HRESULT WINAPI MimeOleSetCompatMode(DWORD dwMode)
3125 {
3126 FIXME("(0x%x)\n", dwMode);
3127 return S_OK;
3128 }
3129
3130 /***********************************************************************
3131 * MimeOleCreateVirtualStream (INETCOMM.@)
3132 */
3133 HRESULT WINAPI MimeOleCreateVirtualStream(IStream **ppStream)
3134 {
3135 HRESULT hr;
3136 FIXME("(%p)\n", ppStream);
3137
3138 hr = CreateStreamOnHGlobal(NULL, TRUE, ppStream);
3139 return hr;
3140 }
3141
3142 typedef struct MimeSecurity
3143 {
3144 IMimeSecurity IMimeSecurity_iface;
3145 LONG ref;
3146 } MimeSecurity;
3147
3148 static inline MimeSecurity *impl_from_IMimeSecurity(IMimeSecurity *iface)
3149 {
3150 return CONTAINING_RECORD(iface, MimeSecurity, IMimeSecurity_iface);
3151 }
3152
3153 static HRESULT WINAPI MimeSecurity_QueryInterface(IMimeSecurity *iface, REFIID riid, void **ppv)
3154 {
3155 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
3156
3157 if (IsEqualIID(riid, &IID_IUnknown) ||
3158 IsEqualIID(riid, &IID_IMimeSecurity))
3159 {
3160 *ppv = iface;
3161 IMimeSecurity_AddRef(iface);
3162 return S_OK;
3163 }
3164
3165 FIXME("no interface for %s\n", debugstr_guid(riid));
3166 *ppv = NULL;
3167 return E_NOINTERFACE;
3168 }
3169
3170 static ULONG WINAPI MimeSecurity_AddRef(IMimeSecurity *iface)
3171 {
3172 MimeSecurity *This = impl_from_IMimeSecurity(iface);
3173 LONG ref = InterlockedIncrement(&This->ref);
3174
3175 TRACE("(%p) ref=%d\n", This, ref);
3176
3177 return ref;
3178 }
3179
3180 static ULONG WINAPI MimeSecurity_Release(IMimeSecurity *iface)
3181 {
3182 MimeSecurity *This = impl_from_IMimeSecurity(iface);
3183 LONG ref = InterlockedDecrement(&This->ref);
3184
3185 TRACE("(%p) ref=%d\n", This, ref);
3186
3187 if (!ref)
3188 HeapFree(GetProcessHeap(), 0, This);
3189
3190 return ref;
3191 }
3192
3193 static HRESULT WINAPI MimeSecurity_InitNew(
3194 IMimeSecurity* iface)
3195 {
3196 FIXME("(%p)->(): stub\n", iface);
3197 return S_OK;
3198 }
3199
3200 static HRESULT WINAPI MimeSecurity_CheckInit(
3201 IMimeSecurity* iface)
3202 {
3203 FIXME("(%p)->(): stub\n", iface);
3204 return E_NOTIMPL;
3205 }
3206
3207 static HRESULT WINAPI MimeSecurity_EncodeMessage(
3208 IMimeSecurity* iface,
3209 IMimeMessageTree* pTree,
3210 DWORD dwFlags)
3211 {
3212 FIXME("(%p)->(%p, %08x): stub\n", iface, pTree, dwFlags);
3213 return E_NOTIMPL;
3214 }
3215
3216 static HRESULT WINAPI MimeSecurity_EncodeBody(
3217 IMimeSecurity* iface,
3218 IMimeMessageTree* pTree,
3219 HBODY hEncodeRoot,
3220 DWORD dwFlags)
3221 {
3222 FIXME("(%p)->(%p, %p, %08x): stub\n", iface, pTree, hEncodeRoot, dwFlags);
3223 return E_NOTIMPL;
3224 }
3225
3226 static HRESULT WINAPI MimeSecurity_DecodeMessage(
3227 IMimeSecurity* iface,
3228 IMimeMessageTree* pTree,
3229 DWORD dwFlags)
3230 {
3231 FIXME("(%p)->(%p, %08x): stub\n", iface, pTree, dwFlags);
3232 return E_NOTIMPL;
3233 }
3234
3235 static HRESULT WINAPI MimeSecurity_DecodeBody(
3236 IMimeSecurity* iface,
3237 IMimeMessageTree* pTree,
3238 HBODY hDecodeRoot,
3239 DWORD dwFlags)
3240 {
3241 FIXME("(%p)->(%p, %p, %08x): stub\n", iface, pTree, hDecodeRoot, dwFlags);
3242 return E_NOTIMPL;
3243 }
3244
3245 static HRESULT WINAPI MimeSecurity_EnumCertificates(
3246 IMimeSecurity* iface,
3247 HCAPICERTSTORE hc,
3248 DWORD dwUsage,
3249 PCX509CERT pPrev,
3250 PCX509CERT* ppCert)
3251 {
3252 FIXME("(%p)->(%p, %08x, %p, %p): stub\n", iface, hc, dwUsage, pPrev, ppCert);
3253 return E_NOTIMPL;
3254 }
3255
3256 static HRESULT WINAPI MimeSecurity_GetCertificateName(
3257 IMimeSecurity* iface,
3258 const PCX509CERT pX509Cert,
3259 const CERTNAMETYPE cn,
3260 LPSTR* ppszName)
3261 {
3262 FIXME("(%p)->(%p, %08x, %p): stub\n", iface, pX509Cert, cn, ppszName);
3263 return E_NOTIMPL;
3264 }
3265
3266 static HRESULT WINAPI MimeSecurity_GetMessageType(
3267 IMimeSecurity* iface,
3268 const HWND hwndParent,
3269 IMimeBody* pBody,
3270 DWORD* pdwSecType)
3271 {
3272 FIXME("(%p)->(%p, %p, %p): stub\n", iface, hwndParent, pBody, pdwSecType);
3273 return E_NOTIMPL;
3274 }
3275
3276 static HRESULT WINAPI MimeSecurity_GetCertData(
3277 IMimeSecurity* iface,
3278 const PCX509CERT pX509Cert,
3279 const CERTDATAID dataid,
3280 LPPROPVARIANT pValue)
3281 {
3282 FIXME("(%p)->(%p, %x, %p): stub\n", iface, pX509Cert, dataid, pValue);
3283 return E_NOTIMPL;
3284 }
3285
3286
3287 static const IMimeSecurityVtbl MimeSecurityVtbl =
3288 {
3289 MimeSecurity_QueryInterface,
3290 MimeSecurity_AddRef,
3291 MimeSecurity_Release,
3292 MimeSecurity_InitNew,
3293 MimeSecurity_CheckInit,
3294 MimeSecurity_EncodeMessage,
3295 MimeSecurity_EncodeBody,
3296 MimeSecurity_DecodeMessage,
3297 MimeSecurity_DecodeBody,
3298 MimeSecurity_EnumCertificates,
3299 MimeSecurity_GetCertificateName,
3300 MimeSecurity_GetMessageType,
3301 MimeSecurity_GetCertData
3302 };
3303
3304 HRESULT MimeSecurity_create(IUnknown *outer, void **obj)
3305 {
3306 MimeSecurity *This;
3307
3308 *obj = NULL;
3309
3310 if (outer) return CLASS_E_NOAGGREGATION;
3311
3312 This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
3313 if (!This) return E_OUTOFMEMORY;
3314
3315 This->IMimeSecurity_iface.lpVtbl = &MimeSecurityVtbl;
3316 This->ref = 1;
3317
3318 *obj = &This->IMimeSecurity_iface;
3319 return S_OK;
3320 }
3321
3322 /***********************************************************************
3323 * MimeOleCreateSecurity (INETCOMM.@)
3324 */
3325 HRESULT WINAPI MimeOleCreateSecurity(IMimeSecurity **ppSecurity)
3326 {
3327 return MimeSecurity_create(NULL, (void **)ppSecurity);
3328 }
3329
3330 static HRESULT WINAPI MimeAlloc_QueryInterface(
3331 IMimeAllocator* iface,
3332 REFIID riid,
3333 void **obj)
3334 {
3335 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), obj);
3336
3337 if (IsEqualIID(riid, &IID_IUnknown) ||
3338 IsEqualIID(riid, &IID_IMalloc) ||
3339 IsEqualIID(riid, &IID_IMimeAllocator))
3340 {
3341 *obj = iface;
3342 IMimeAllocator_AddRef(iface);
3343 return S_OK;
3344 }
3345
3346 FIXME("no interface for %s\n", debugstr_guid(riid));
3347 *obj = NULL;
3348 return E_NOINTERFACE;
3349 }
3350
3351 static ULONG WINAPI MimeAlloc_AddRef(
3352 IMimeAllocator* iface)
3353 {
3354 return 2;
3355 }
3356
3357 static ULONG WINAPI MimeAlloc_Release(
3358 IMimeAllocator* iface)
3359 {
3360 return 1;
3361 }
3362
3363 static LPVOID WINAPI MimeAlloc_Alloc(
3364 IMimeAllocator* iface,
3365 SIZE_T cb)
3366 {
3367 return CoTaskMemAlloc(cb);
3368 }
3369
3370 static LPVOID WINAPI MimeAlloc_Realloc(
3371 IMimeAllocator* iface,
3372 LPVOID pv,
3373 SIZE_T cb)
3374 {
3375 return CoTaskMemRealloc(pv, cb);
3376 }
3377
3378 static void WINAPI MimeAlloc_Free(
3379 IMimeAllocator* iface,
3380 LPVOID pv)
3381 {
3382 CoTaskMemFree(pv);
3383 }
3384
3385 static SIZE_T WINAPI MimeAlloc_GetSize(
3386 IMimeAllocator* iface,
3387 LPVOID pv)
3388 {
3389 FIXME("stub\n");
3390 return 0;
3391 }
3392
3393 static int WINAPI MimeAlloc_DidAlloc(
3394 IMimeAllocator* iface,
3395 LPVOID pv)
3396 {
3397 FIXME("stub\n");
3398 return 0;
3399 }
3400
3401 static void WINAPI MimeAlloc_HeapMinimize(
3402 IMimeAllocator* iface)
3403 {
3404 FIXME("stub\n");
3405 return;
3406 }
3407
3408 static HRESULT WINAPI MimeAlloc_FreeParamInfoArray(
3409 IMimeAllocator* iface,
3410 ULONG cParams,
3411 LPMIMEPARAMINFO prgParam,
3412 boolean fFreeArray)
3413 {
3414 ULONG i;
3415 TRACE("(%p)->(%d, %p, %d)\n", iface, cParams, prgParam, fFreeArray);
3416
3417 for(i = 0; i < cParams; i++)
3418 {
3419 IMimeAllocator_Free(iface, prgParam[i].pszName);
3420 IMimeAllocator_Free(iface, prgParam[i].pszData);
3421 }
3422 if(fFreeArray) IMimeAllocator_Free(iface, prgParam);
3423 return S_OK;
3424 }
3425
3426 static HRESULT WINAPI MimeAlloc_FreeAddressList(
3427 IMimeAllocator* iface,
3428 LPADDRESSLIST pList)
3429 {
3430 FIXME("stub\n");
3431 return E_NOTIMPL;
3432 }
3433
3434 static HRESULT WINAPI MimeAlloc_FreeAddressProps(
3435 IMimeAllocator* iface,
3436 LPADDRESSPROPS pAddress)
3437 {
3438 FIXME("stub\n");
3439 return E_NOTIMPL;
3440 }
3441
3442 static HRESULT WINAPI MimeAlloc_ReleaseObjects(
3443 IMimeAllocator* iface,
3444 ULONG cObjects,
3445 IUnknown **prgpUnknown,
3446 boolean fFreeArray)
3447 {
3448 FIXME("stub\n");
3449 return E_NOTIMPL;
3450 }
3451
3452
3453 static HRESULT WINAPI MimeAlloc_FreeEnumHeaderRowArray(
3454 IMimeAllocator* iface,
3455 ULONG cRows,
3456 LPENUMHEADERROW prgRow,
3457 boolean fFreeArray)
3458 {
3459 FIXME("stub\n");
3460 return E_NOTIMPL;
3461 }
3462
3463 static HRESULT WINAPI MimeAlloc_FreeEnumPropertyArray(
3464 IMimeAllocator* iface,
3465 ULONG cProps,
3466 LPENUMPROPERTY prgProp,
3467 boolean fFreeArray)
3468 {
3469 FIXME("stub\n");
3470 return E_NOTIMPL;
3471 }
3472
3473 static HRESULT WINAPI MimeAlloc_FreeThumbprint(
3474 IMimeAllocator* iface,
3475 THUMBBLOB *pthumbprint)
3476 {
3477 FIXME("stub\n");
3478 return E_NOTIMPL;
3479 }
3480
3481
3482 static HRESULT WINAPI MimeAlloc_PropVariantClear(
3483 IMimeAllocator* iface,
3484 LPPROPVARIANT pProp)
3485 {
3486 FIXME("stub\n");
3487 return E_NOTIMPL;
3488 }
3489
3490 static IMimeAllocatorVtbl mime_alloc_vtbl =
3491 {
3492 MimeAlloc_QueryInterface,
3493 MimeAlloc_AddRef,
3494 MimeAlloc_Release,
3495 MimeAlloc_Alloc,
3496 MimeAlloc_Realloc,
3497 MimeAlloc_Free,
3498 MimeAlloc_GetSize,
3499 MimeAlloc_DidAlloc,
3500 MimeAlloc_HeapMinimize,
3501 MimeAlloc_FreeParamInfoArray,
3502 MimeAlloc_FreeAddressList,
3503 MimeAlloc_FreeAddressProps,
3504 MimeAlloc_ReleaseObjects,
3505 MimeAlloc_FreeEnumHeaderRowArray,
3506 MimeAlloc_FreeEnumPropertyArray,
3507 MimeAlloc_FreeThumbprint,
3508 MimeAlloc_PropVariantClear
3509 };
3510
3511 static IMimeAllocator mime_allocator =
3512 {
3513 &mime_alloc_vtbl
3514 };
3515
3516 HRESULT MimeAllocator_create(IUnknown *outer, void **obj)
3517 {
3518 if(outer) return CLASS_E_NOAGGREGATION;
3519
3520 *obj = &mime_allocator;
3521 return S_OK;
3522 }
3523
3524 HRESULT WINAPI MimeOleGetAllocator(IMimeAllocator **alloc)
3525 {
3526 return MimeAllocator_create(NULL, (void**)alloc);
3527 }
3528
3529 HRESULT VirtualStream_create(IUnknown *outer, void **obj)
3530 {
3531 FIXME("(%p, %p)\n", outer, obj);
3532
3533 *obj = NULL;
3534 if (outer) return CLASS_E_NOAGGREGATION;
3535
3536 return MimeOleCreateVirtualStream((IStream **)obj);
3537 }
3538
3539 /* IMimePropertySchema Interface */
3540 static HRESULT WINAPI propschema_QueryInterface(IMimePropertySchema *iface, REFIID riid, void **out)
3541 {
3542 propschema *This = impl_from_IMimePropertySchema(iface);
3543 TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), out);
3544
3545 *out = NULL;
3546
3547 if (IsEqualIID(riid, &IID_IUnknown) ||
3548 IsEqualIID(riid, &IID_IMimePropertySchema))
3549 {
3550 *out = iface;
3551 }
3552 else
3553 {
3554 FIXME("no interface for %s\n", debugstr_guid(riid));
3555 return E_NOINTERFACE;
3556 }
3557
3558 IMimePropertySchema_AddRef(iface);
3559 return S_OK;
3560 }
3561
3562 static ULONG WINAPI propschema_AddRef(IMimePropertySchema *iface)
3563 {
3564 propschema *This = impl_from_IMimePropertySchema(iface);
3565 LONG ref = InterlockedIncrement(&This->ref);
3566
3567 TRACE("(%p) ref=%d\n", This, ref);
3568
3569 return ref;
3570 }
3571
3572 static ULONG WINAPI propschema_Release(IMimePropertySchema *iface)
3573 {
3574 propschema *This = impl_from_IMimePropertySchema(iface);
3575 LONG ref = InterlockedDecrement(&This->ref);
3576
3577 TRACE("(%p) ref=%d\n", This, ref);
3578
3579 if (!ref)
3580 {
3581 HeapFree(GetProcessHeap(), 0, This);
3582 }
3583
3584 return ref;
3585 }
3586
3587 static HRESULT WINAPI propschema_RegisterProperty(IMimePropertySchema *iface, const char *name, DWORD flags,
3588 DWORD rownumber, VARTYPE vtdefault, DWORD *propid)
3589 {
3590 propschema *This = impl_from_IMimePropertySchema(iface);
3591 FIXME("(%p)->(%s, %x, %d, %d, %p) stub\n", This, debugstr_a(name), flags, rownumber, vtdefault, propid);
3592 return E_NOTIMPL;
3593 }
3594
3595 static HRESULT WINAPI propschema_ModifyProperty(IMimePropertySchema *iface, const char *name, DWORD flags,
3596 DWORD rownumber, VARTYPE vtdefault)
3597 {
3598 propschema *This = impl_from_IMimePropertySchema(iface);
3599 FIXME("(%p)->(%s, %x, %d, %d) stub\n", This, debugstr_a(name), flags, rownumber, vtdefault);
3600 return S_OK;
3601 }
3602
3603 static HRESULT WINAPI propschema_GetPropertyId(IMimePropertySchema *iface, const char *name, DWORD *propid)
3604 {
3605 propschema *This = impl_from_IMimePropertySchema(iface);
3606 FIXME("(%p)->(%s, %p) stub\n", This, debugstr_a(name), propid);
3607 return E_NOTIMPL;
3608 }
3609
3610 static HRESULT WINAPI propschema_GetPropertyName(IMimePropertySchema *iface, DWORD propid, char **name)
3611 {
3612 propschema *This = impl_from_IMimePropertySchema(iface);
3613 FIXME("(%p)->(%d, %p) stub\n", This, propid, name);
3614 return E_NOTIMPL;
3615 }
3616
3617 static HRESULT WINAPI propschema_RegisterAddressType(IMimePropertySchema *iface, const char *name, DWORD *adrtype)
3618 {
3619 propschema *This = impl_from_IMimePropertySchema(iface);
3620 FIXME("(%p)->(%s, %p) stub\n", This, debugstr_a(name), adrtype);
3621 return E_NOTIMPL;
3622 }
3623
3624 static IMimePropertySchemaVtbl prop_schema_vtbl =
3625 {
3626 propschema_QueryInterface,
3627 propschema_AddRef,
3628 propschema_Release,
3629 propschema_RegisterProperty,
3630 propschema_ModifyProperty,
3631 propschema_GetPropertyId,
3632 propschema_GetPropertyName,
3633 propschema_RegisterAddressType
3634 };
3635
3636
3637 HRESULT WINAPI MimeOleGetPropertySchema(IMimePropertySchema **schema)
3638 {
3639 propschema *This;
3640
3641 TRACE("(%p) stub\n", schema);
3642
3643 This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
3644 if (!This)
3645 return E_OUTOFMEMORY;
3646
3647 This->IMimePropertySchema_iface.lpVtbl = &prop_schema_vtbl;
3648 This->ref = 1;
3649
3650 *schema = &This->IMimePropertySchema_iface;
3651
3652 return S_OK;
3653 }
3654
3655 HRESULT WINAPI MimeGetAddressFormatW(REFIID riid, void *object, DWORD addr_type,
3656 ADDRESSFORMAT addr_format, WCHAR **address)
3657 {
3658 FIXME("(%s, %p, %d, %d, %p) stub\n", debugstr_guid(riid), object, addr_type, addr_format, address);
3659
3660 return E_NOTIMPL;
3661 }
3662
3663 static HRESULT WINAPI mime_obj_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
3664 {
3665 FIXME("(%s %p)\n", debugstr_guid(riid), ppv);
3666 *ppv = NULL;
3667 return E_NOINTERFACE;
3668 }
3669
3670 static ULONG WINAPI mime_obj_AddRef(IUnknown *iface)
3671 {
3672 TRACE("\n");
3673 return 2;
3674 }
3675
3676 static ULONG WINAPI mime_obj_Release(IUnknown *iface)
3677 {
3678 TRACE("\n");
3679 return 1;
3680 }
3681
3682 static const IUnknownVtbl mime_obj_vtbl = {
3683 mime_obj_QueryInterface,
3684 mime_obj_AddRef,
3685 mime_obj_Release
3686 };
3687
3688 static IUnknown mime_obj = { &mime_obj_vtbl };
3689
3690 HRESULT WINAPI MimeOleObjectFromMoniker(BINDF bindf, IMoniker *moniker, IBindCtx *binding,
3691 REFIID riid, void **out, IMoniker **moniker_new)
3692 {
3693 WCHAR *display_name, *mhtml_url;
3694 size_t len;
3695 HRESULT hres;
3696
3697 static const WCHAR mhtml_prefixW[] = {'m','h','t','m','l',':'};
3698
3699 WARN("(0x%08x, %p, %p, %s, %p, %p) semi-stub\n", bindf, moniker, binding, debugstr_guid(riid), out, moniker_new);
3700
3701 if(!IsEqualGUID(&IID_IUnknown, riid)) {
3702 FIXME("Unsupported riid %s\n", debugstr_guid(riid));
3703 return E_NOINTERFACE;
3704 }
3705
3706 hres = IMoniker_GetDisplayName(moniker, NULL, NULL, &display_name);
3707 if(FAILED(hres))
3708 return hres;
3709
3710 TRACE("display name %s\n", debugstr_w(display_name));
3711
3712 len = strlenW(display_name);
3713 mhtml_url = heap_alloc((len+1)*sizeof(WCHAR) + sizeof(mhtml_prefixW));
3714 if(!mhtml_url)
3715 return E_OUTOFMEMORY;
3716
3717 memcpy(mhtml_url, mhtml_prefixW, sizeof(mhtml_prefixW));
3718 strcpyW(mhtml_url + sizeof(mhtml_prefixW)/sizeof(WCHAR), display_name);
3719 HeapFree(GetProcessHeap(), 0, display_name);
3720
3721 hres = CreateURLMoniker(NULL, mhtml_url, moniker_new);
3722 heap_free(mhtml_url);
3723 if(FAILED(hres))
3724 return hres;
3725
3726 /* FIXME: We most likely should start binding here and return something more meaningful as mime object. */
3727 *out = &mime_obj;
3728 return S_OK;
3729 }
Windows API implementation