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