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