dlls/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->pszVal);
 414         break;
 415     case VT_LPWSTR:
 416         cpiSource = CP_UNICODE;
 417         src_len = lstrlenW(pIn->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->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->pszVal = CoTaskMemAlloc(out_size);
 436             if(!pOut->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->pszVal, &in_size,
 443                                                   (BYTE*)pOut->pszVal, &out_size);
 444
 445                 if(hr == S_OK)
 446                 {
 447                     if(cpiDest == CP_UNICODE)
 448                     {
 449                         pOut->pwszVal[out_size / sizeof(WCHAR)] = 0;
 450                         pOut->vt = VT_LPWSTR;
 451                     }
 452                     else
 453                     {
 454                         pOut->pszVal[out_size] = '\0';
 455                         pOut->vt = VT_LPSTR;
 456                     }
 457                 }
 458                 else
 459                     CoTaskMemFree(pOut->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 }