[INETCOMM] Sync with Wine Staging 4.18. CORE-16441
[reactos.git] / dll / win32 / inetcomm / mimeintl.c
1 /*
2 * MIME OLE International interface
3 *
4 * Copyright 2008 Huw Davies for CodeWeavers
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #define COBJMACROS
22 #define NONAMELESSUNION
23
24 #include <stdarg.h>
25 #include <stdio.h>
26
27 #include "windef.h"
28 #include "winbase.h"
29 #include "winuser.h"
30 #include "winnls.h"
31 #include "objbase.h"
32 #include "ole2.h"
33 #include "mimeole.h"
34 #include "mlang.h"
35
36 #include "wine/list.h"
37 #include "wine/debug.h"
38
39 #include "inetcomm_private.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(inetcomm);
42
43 typedef struct
44 {
45 struct list entry;
46 INETCSETINFO cs_info;
47 } charset_entry;
48
49 typedef struct
50 {
51 IMimeInternational IMimeInternational_iface;
52 LONG refs;
53 CRITICAL_SECTION cs;
54
55 struct list charsets;
56 LONG next_charset_handle;
57 HCHARSET default_charset;
58 } internat_impl;
59
60 static inline internat_impl *impl_from_IMimeInternational(IMimeInternational *iface)
61 {
62 return CONTAINING_RECORD(iface, internat_impl, IMimeInternational_iface);
63 }
64
65 static inline HRESULT get_mlang(IMultiLanguage **ml)
66 {
67 return CoCreateInstance(&CLSID_CMultiLanguage, NULL, CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER,
68 &IID_IMultiLanguage, (void **)ml);
69 }
70
71 static HRESULT WINAPI MimeInternat_QueryInterface( IMimeInternational *iface, REFIID riid, LPVOID *ppobj )
72 {
73 if (IsEqualGUID(riid, &IID_IUnknown) ||
74 IsEqualGUID(riid, &IID_IMimeInternational))
75 {
76 IMimeInternational_AddRef( iface );
77 *ppobj = iface;
78 return S_OK;
79 }
80
81 FIXME("interface %s not implemented\n", debugstr_guid(riid));
82 return E_NOINTERFACE;
83 }
84
85 static ULONG WINAPI MimeInternat_AddRef( IMimeInternational *iface )
86 {
87 internat_impl *This = impl_from_IMimeInternational( iface );
88 return InterlockedIncrement(&This->refs);
89 }
90
91 static ULONG WINAPI MimeInternat_Release( IMimeInternational *iface )
92 {
93 internat_impl *This = impl_from_IMimeInternational( iface );
94 ULONG refs;
95
96 refs = InterlockedDecrement(&This->refs);
97 if (!refs)
98 {
99 charset_entry *charset, *cursor2;
100
101 LIST_FOR_EACH_ENTRY_SAFE(charset, cursor2, &This->charsets, charset_entry, entry)
102 {
103 list_remove(&charset->entry);
104 HeapFree(GetProcessHeap(), 0, charset);
105 }
106 This->cs.DebugInfo->Spare[0] = 0;
107 DeleteCriticalSection(&This->cs);
108 HeapFree(GetProcessHeap(), 0, This);
109 }
110
111 return refs;
112 }
113
114 static HRESULT WINAPI MimeInternat_SetDefaultCharset(IMimeInternational *iface, HCHARSET hCharset)
115 {
116 internat_impl *This = impl_from_IMimeInternational( iface );
117
118 TRACE("(%p)->(%p)\n", iface, hCharset);
119
120 if(hCharset == NULL) return E_INVALIDARG;
121 /* FIXME check hCharset is valid */
122
123 InterlockedExchangePointer(&This->default_charset, hCharset);
124
125 return S_OK;
126 }
127
128 static HRESULT WINAPI MimeInternat_GetDefaultCharset(IMimeInternational *iface, LPHCHARSET phCharset)
129 {
130 internat_impl *This = impl_from_IMimeInternational( iface );
131 HRESULT hr = S_OK;
132
133 TRACE("(%p)->(%p)\n", iface, phCharset);
134
135 if(This->default_charset == NULL)
136 {
137 HCHARSET hcs;
138 hr = IMimeInternational_GetCodePageCharset(iface, GetACP(), CHARSET_BODY, &hcs);
139 if(SUCCEEDED(hr))
140 InterlockedCompareExchangePointer(&This->default_charset, hcs, NULL);
141 }
142 *phCharset = This->default_charset;
143
144 return hr;
145 }
146
147 static HRESULT mlang_getcodepageinfo(UINT cp, MIMECPINFO *mlang_cp_info)
148 {
149 HRESULT hr;
150 IMultiLanguage *ml;
151
152 hr = get_mlang(&ml);
153
154 if(SUCCEEDED(hr))
155 {
156 hr = IMultiLanguage_GetCodePageInfo(ml, cp, mlang_cp_info);
157 IMultiLanguage_Release(ml);
158 }
159 return hr;
160 }
161
162 static HRESULT WINAPI MimeInternat_GetCodePageCharset(IMimeInternational *iface, CODEPAGEID cpiCodePage,
163 CHARSETTYPE ctCsetType,
164 LPHCHARSET phCharset)
165 {
166 HRESULT hr;
167 MIMECPINFO mlang_cp_info;
168
169 TRACE("(%p)->(%d, %d, %p)\n", iface, cpiCodePage, ctCsetType, phCharset);
170
171 *phCharset = NULL;
172
173 hr = mlang_getcodepageinfo(cpiCodePage, &mlang_cp_info);
174 if(SUCCEEDED(hr))
175 {
176 const WCHAR *charset_nameW = NULL;
177 char *charset_name;
178 DWORD len;
179
180 switch(ctCsetType)
181 {
182 case CHARSET_BODY:
183 charset_nameW = mlang_cp_info.wszBodyCharset;
184 break;
185 case CHARSET_HEADER:
186 charset_nameW = mlang_cp_info.wszHeaderCharset;
187 break;
188 case CHARSET_WEB:
189 charset_nameW = mlang_cp_info.wszWebCharset;
190 break;
191 default:
192 return MIME_E_INVALID_CHARSET_TYPE;
193 }
194 len = WideCharToMultiByte(CP_ACP, 0, charset_nameW, -1, NULL, 0, NULL, NULL);
195 charset_name = HeapAlloc(GetProcessHeap(), 0, len);
196 WideCharToMultiByte(CP_ACP, 0, charset_nameW, -1, charset_name, len, NULL, NULL);
197 hr = IMimeInternational_FindCharset(iface, charset_name, phCharset);
198 HeapFree(GetProcessHeap(), 0, charset_name);
199 }
200 return hr;
201 }
202
203 static HRESULT mlang_getcsetinfo(const char *charset, MIMECSETINFO *mlang_info)
204 {
205 DWORD len = MultiByteToWideChar(CP_ACP, 0, charset, -1, NULL, 0);
206 BSTR bstr = SysAllocStringLen(NULL, len - 1);
207 HRESULT hr;
208 IMultiLanguage *ml;
209
210 MultiByteToWideChar(CP_ACP, 0, charset, -1, bstr, len);
211
212 hr = get_mlang(&ml);
213
214 if(SUCCEEDED(hr))
215 {
216 hr = IMultiLanguage_GetCharsetInfo(ml, bstr, mlang_info);
217 IMultiLanguage_Release(ml);
218 }
219 SysFreeString(bstr);
220 if(FAILED(hr)) hr = MIME_E_NOT_FOUND;
221 return hr;
222 }
223
224 static HCHARSET add_charset(struct list *list, MIMECSETINFO *mlang_info, HCHARSET handle)
225 {
226 charset_entry *charset = HeapAlloc(GetProcessHeap(), 0, sizeof(*charset));
227
228 WideCharToMultiByte(CP_ACP, 0, mlang_info->wszCharset, -1,
229 charset->cs_info.szName, sizeof(charset->cs_info.szName), NULL, NULL);
230 charset->cs_info.cpiWindows = mlang_info->uiCodePage;
231 charset->cs_info.cpiInternet = mlang_info->uiInternetEncoding;
232 charset->cs_info.hCharset = handle;
233 charset->cs_info.dwReserved1 = 0;
234 list_add_head(list, &charset->entry);
235
236 return charset->cs_info.hCharset;
237 }
238
239 static HRESULT WINAPI MimeInternat_FindCharset(IMimeInternational *iface, LPCSTR pszCharset,
240 LPHCHARSET phCharset)
241 {
242 internat_impl *This = impl_from_IMimeInternational( iface );
243 HRESULT hr = MIME_E_NOT_FOUND;
244 charset_entry *charset;
245
246 TRACE("(%p)->(%s, %p)\n", iface, debugstr_a(pszCharset), phCharset);
247
248 *phCharset = NULL;
249
250 EnterCriticalSection(&This->cs);
251
252 LIST_FOR_EACH_ENTRY(charset, &This->charsets, charset_entry, entry)
253 {
254 if(!lstrcmpiA(charset->cs_info.szName, pszCharset))
255 {
256 *phCharset = charset->cs_info.hCharset;
257 hr = S_OK;
258 break;
259 }
260 }
261
262 if(hr == MIME_E_NOT_FOUND)
263 {
264 MIMECSETINFO mlang_info;
265
266 LeaveCriticalSection(&This->cs);
267 hr = mlang_getcsetinfo(pszCharset, &mlang_info);
268 EnterCriticalSection(&This->cs);
269
270 if(SUCCEEDED(hr))
271 *phCharset = add_charset(&This->charsets, &mlang_info,
272 UlongToHandle(InterlockedIncrement(&This->next_charset_handle)));
273 }
274
275 LeaveCriticalSection(&This->cs);
276 return hr;
277 }
278
279 static HRESULT WINAPI MimeInternat_GetCharsetInfo(IMimeInternational *iface, HCHARSET hCharset,
280 LPINETCSETINFO pCsetInfo)
281 {
282 internat_impl *This = impl_from_IMimeInternational( iface );
283 HRESULT hr = MIME_E_INVALID_HANDLE;
284 charset_entry *charset;
285
286 TRACE("(%p)->(%p, %p)\n", iface, hCharset, pCsetInfo);
287
288 EnterCriticalSection(&This->cs);
289
290 LIST_FOR_EACH_ENTRY(charset, &This->charsets, charset_entry, entry)
291 {
292 if(charset->cs_info.hCharset == hCharset)
293 {
294 *pCsetInfo = charset->cs_info;
295 hr = S_OK;
296 break;
297 }
298 }
299
300 LeaveCriticalSection(&This->cs);
301
302 return hr;
303 }
304
305 static HRESULT WINAPI MimeInternat_GetCodePageInfo(IMimeInternational *iface, CODEPAGEID cpiCodePage,
306 LPCODEPAGEINFO pCodePageInfo)
307 {
308 FIXME("stub\n");
309 return E_NOTIMPL;
310 }
311
312 static HRESULT WINAPI MimeInternat_CanConvertCodePages(IMimeInternational *iface, CODEPAGEID cpiSource,
313 CODEPAGEID cpiDest)
314 {
315 HRESULT hr;
316 IMultiLanguage *ml;
317
318 TRACE("(%p)->(%d, %d)\n", iface, cpiSource, cpiDest);
319
320 /* Could call mlang.IsConvertINetStringAvailable() to avoid the COM overhead if need be. */
321
322 hr = get_mlang(&ml);
323 if(SUCCEEDED(hr))
324 {
325 hr = IMultiLanguage_IsConvertible(ml, cpiSource, cpiDest);
326 IMultiLanguage_Release(ml);
327 }
328
329 return hr;
330 }
331
332 static HRESULT WINAPI MimeInternat_DecodeHeader(IMimeInternational *iface, HCHARSET hCharset,
333 LPCSTR pszData,
334 LPPROPVARIANT pDecoded,
335 LPRFC1522INFO pRfc1522Info)
336 {
337 FIXME("stub\n");
338 return E_NOTIMPL;
339 }
340
341 static HRESULT WINAPI MimeInternat_EncodeHeader(IMimeInternational *iface, HCHARSET hCharset,
342 LPPROPVARIANT pData,
343 LPSTR *ppszEncoded,
344 LPRFC1522INFO pRfc1522Info)
345 {
346 FIXME("stub\n");
347 return E_NOTIMPL;
348 }
349
350 static HRESULT WINAPI MimeInternat_ConvertBuffer(IMimeInternational *iface, CODEPAGEID cpiSource,
351 CODEPAGEID cpiDest, LPBLOB pIn, LPBLOB pOut,
352 ULONG *pcbRead)
353 {
354 HRESULT hr;
355 IMultiLanguage *ml;
356
357 TRACE("(%p)->(%d, %d, %p, %p, %p)\n", iface, cpiSource, cpiDest, pIn, pOut, pcbRead);
358
359 *pcbRead = 0;
360 pOut->cbSize = 0;
361
362 /* Could call mlang.ConvertINetString() to avoid the COM overhead if need be. */
363
364 hr = get_mlang(&ml);
365 if(SUCCEEDED(hr))
366 {
367 DWORD mode = 0;
368 UINT in_size = pIn->cbSize, out_size;
369
370 hr = IMultiLanguage_ConvertString(ml, &mode, cpiSource, cpiDest, pIn->pBlobData, &in_size,
371 NULL, &out_size);
372 if(hr == S_OK) /* S_FALSE means the conversion could not be performed */
373 {
374 pOut->pBlobData = CoTaskMemAlloc(out_size);
375 if(!pOut->pBlobData)
376 hr = E_OUTOFMEMORY;
377 else
378 {
379 mode = 0;
380 in_size = pIn->cbSize;
381 hr = IMultiLanguage_ConvertString(ml, &mode, cpiSource, cpiDest, pIn->pBlobData, &in_size,
382 pOut->pBlobData, &out_size);
383
384 if(hr == S_OK)
385 {
386 *pcbRead = in_size;
387 pOut->cbSize = out_size;
388 }
389 else
390 CoTaskMemFree(pOut->pBlobData);
391 }
392 }
393 IMultiLanguage_Release(ml);
394 }
395
396 return hr;
397 }
398
399 static HRESULT WINAPI MimeInternat_ConvertString(IMimeInternational *iface, CODEPAGEID cpiSource,
400 CODEPAGEID cpiDest, LPPROPVARIANT pIn,
401 LPPROPVARIANT pOut)
402 {
403 HRESULT hr;
404 int src_len;
405 IMultiLanguage *ml;
406
407 TRACE("(%p)->(%d, %d, %p %p)\n", iface, cpiSource, cpiDest, pIn, pOut);
408
409 switch(pIn->vt)
410 {
411 case VT_LPSTR:
412 if(cpiSource == CP_UNICODE) cpiSource = GetACP();
413 src_len = strlen(pIn->u.pszVal);
414 break;
415 case VT_LPWSTR:
416 cpiSource = CP_UNICODE;
417 src_len = lstrlenW(pIn->u.pwszVal) * sizeof(WCHAR);
418 break;
419 default:
420 return E_INVALIDARG;
421 }
422
423 hr = get_mlang(&ml);
424 if(SUCCEEDED(hr))
425 {
426 DWORD mode = 0;
427 UINT in_size = src_len, out_size;
428
429 hr = IMultiLanguage_ConvertString(ml, &mode, cpiSource, cpiDest, (BYTE*)pIn->u.pszVal, &in_size,
430 NULL, &out_size);
431 if(hr == S_OK) /* S_FALSE means the conversion could not be performed */
432 {
433 out_size += (cpiDest == CP_UNICODE) ? sizeof(WCHAR) : sizeof(char);
434
435 pOut->u.pszVal = CoTaskMemAlloc(out_size);
436 if(!pOut->u.pszVal)
437 hr = E_OUTOFMEMORY;
438 else
439 {
440 mode = 0;
441 in_size = src_len;
442 hr = IMultiLanguage_ConvertString(ml, &mode, cpiSource, cpiDest, (BYTE*)pIn->u.pszVal, &in_size,
443 (BYTE*)pOut->u.pszVal, &out_size);
444
445 if(hr == S_OK)
446 {
447 if(cpiDest == CP_UNICODE)
448 {
449 pOut->u.pwszVal[out_size / sizeof(WCHAR)] = 0;
450 pOut->vt = VT_LPWSTR;
451 }
452 else
453 {
454 pOut->u.pszVal[out_size] = '\0';
455 pOut->vt = VT_LPSTR;
456 }
457 }
458 else
459 CoTaskMemFree(pOut->u.pszVal);
460 }
461 }
462 IMultiLanguage_Release(ml);
463 }
464 return hr;
465 }
466
467 static HRESULT WINAPI MimeInternat_MLANG_ConvertInetReset(IMimeInternational *iface)
468 {
469 FIXME("stub\n");
470 return E_NOTIMPL;
471 }
472
473 static HRESULT WINAPI MimeInternat_MLANG_ConvertInetString(IMimeInternational *iface, CODEPAGEID cpiSource,
474 CODEPAGEID cpiDest,
475 LPCSTR pSource,
476 int *pnSizeOfSource,
477 LPSTR pDestination,
478 int *pnDstSize)
479 {
480 FIXME("stub\n");
481 return E_NOTIMPL;
482 }
483
484 static HRESULT WINAPI MimeInternat_Rfc1522Decode(IMimeInternational *iface, LPCSTR pszValue,
485 LPSTR pszCharset,
486 ULONG cchmax,
487 LPSTR *ppszDecoded)
488 {
489 FIXME("stub\n");
490 return E_NOTIMPL;
491 }
492
493 static HRESULT WINAPI MimeInternat_Rfc1522Encode(IMimeInternational *iface, LPCSTR pszValue,
494 HCHARSET hCharset,
495 LPSTR *ppszEncoded)
496 {
497 FIXME("stub\n");
498 return E_NOTIMPL;
499 }
500
501 static IMimeInternationalVtbl mime_internat_vtbl =
502 {
503 MimeInternat_QueryInterface,
504 MimeInternat_AddRef,
505 MimeInternat_Release,
506 MimeInternat_SetDefaultCharset,
507 MimeInternat_GetDefaultCharset,
508 MimeInternat_GetCodePageCharset,
509 MimeInternat_FindCharset,
510 MimeInternat_GetCharsetInfo,
511 MimeInternat_GetCodePageInfo,
512 MimeInternat_CanConvertCodePages,
513 MimeInternat_DecodeHeader,
514 MimeInternat_EncodeHeader,
515 MimeInternat_ConvertBuffer,
516 MimeInternat_ConvertString,
517 MimeInternat_MLANG_ConvertInetReset,
518 MimeInternat_MLANG_ConvertInetString,
519 MimeInternat_Rfc1522Decode,
520 MimeInternat_Rfc1522Encode
521 };
522
523 static internat_impl *global_internat;
524
525 HRESULT MimeInternational_Construct(IMimeInternational **internat)
526 {
527 global_internat = HeapAlloc(GetProcessHeap(), 0, sizeof(*global_internat));
528 global_internat->IMimeInternational_iface.lpVtbl = &mime_internat_vtbl;
529 global_internat->refs = 0;
530 InitializeCriticalSection(&global_internat->cs);
531 global_internat->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": global_internat.cs");
532
533 list_init(&global_internat->charsets);
534 global_internat->next_charset_handle = 0;
535 global_internat->default_charset = NULL;
536
537 *internat = &global_internat->IMimeInternational_iface;
538
539 IMimeInternational_AddRef(*internat);
540 return S_OK;
541 }
542
543 HRESULT WINAPI MimeOleGetInternat(IMimeInternational **internat)
544 {
545 TRACE("(%p)\n", internat);
546
547 *internat = &global_internat->IMimeInternational_iface;
548 IMimeInternational_AddRef(*internat);
549 return S_OK;
550 }
551
552 HRESULT WINAPI MimeOleFindCharset(LPCSTR name, LPHCHARSET charset)
553 {
554 IMimeInternational *internat;
555 HRESULT hr;
556
557 TRACE("(%s, %p)\n", debugstr_a(name), charset);
558
559 hr = MimeOleGetInternat(&internat);
560 if(SUCCEEDED(hr))
561 {
562 hr = IMimeInternational_FindCharset(internat, name, charset);
563 IMimeInternational_Release(internat);
564 }
565 return hr;
566 }
567
568 HRESULT WINAPI MimeOleGetCharsetInfo(HCHARSET hCharset, LPINETCSETINFO pCsetInfo)
569 {
570 IMimeInternational *internat;
571 HRESULT hr;
572
573 TRACE("(%p, %p)\n", hCharset, pCsetInfo);
574
575 hr = MimeOleGetInternat(&internat);
576 if(SUCCEEDED(hr))
577 {
578 hr = IMimeInternational_GetCharsetInfo(internat, hCharset, pCsetInfo);
579 IMimeInternational_Release(internat);
580 }
581 return hr;
582 }
583
584 HRESULT WINAPI MimeOleGetDefaultCharset(LPHCHARSET charset)
585 {
586 IMimeInternational *internat;
587 HRESULT hr;
588
589 TRACE("(%p)\n", charset);
590
591 hr = MimeOleGetInternat(&internat);
592 if(SUCCEEDED(hr))
593 {
594 hr = IMimeInternational_GetDefaultCharset(internat, charset);
595 IMimeInternational_Release(internat);
596 }
597 return hr;
598 }