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