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     const IMimeInternationalVtbl *lpVtbl;
  52     LONG refs;
  53     CRITICAL_SECTION cs;
  54
  55     struct list charsets;
  56     LONG next_charset_handle;
  57     HCHARSET default_charset;
  58 } internat;
  59
  60 static inline internat *impl_from_IMimeInternational( IMimeInternational *iface )
  61 {
  62     return (internat *)((char*)iface - FIELD_OFFSET(internat, lpVtbl));
  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 *This = impl_from_IMimeInternational( iface );
  88     return InterlockedIncrement(&This->refs);
  89 }
  90
  91 static ULONG WINAPI MimeInternat_Release( IMimeInternational *iface )
  92 {
  93     internat *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         HeapFree(GetProcessHeap(), 0, This);
 107     }
 108
 109     return refs;
 110 }
 111
 112 static HRESULT WINAPI MimeInternat_SetDefaultCharset(IMimeInternational *iface, HCHARSET hCharset)
 113 {
 114     internat *This = impl_from_IMimeInternational( iface );
 115
 116     TRACE("(%p)->(%p)\n", iface, hCharset);
 117
 118     if(hCharset == NULL) return E_INVALIDARG;
 119     /* FIXME check hCharset is valid */
 120
 121     InterlockedExchangePointer(&This->default_charset, hCharset);
 122
 123     return S_OK;
 124 }
 125
 126 static HRESULT WINAPI MimeInternat_GetDefaultCharset(IMimeInternational *iface, LPHCHARSET phCharset)
 127 {
 128     internat *This = impl_from_IMimeInternational( iface );
 129     HRESULT hr = S_OK;
 130
 131     TRACE("(%p)->(%p)\n", iface, phCharset);
 132
 133     if(This->default_charset == NULL)
 134     {
 135         HCHARSET hcs;
 136         hr = IMimeInternational_GetCodePageCharset(iface, GetACP(), CHARSET_BODY, &hcs);
 137         if(SUCCEEDED(hr))
 138             InterlockedCompareExchangePointer(&This->default_charset, hcs, NULL);
 139     }
 140     *phCharset = This->default_charset;
 141
 142     return hr;
 143 }
 144
 145 static HRESULT mlang_getcodepageinfo(UINT cp, MIMECPINFO *mlang_cp_info)
 146 {
 147     HRESULT hr;
 148     IMultiLanguage *ml;
 149
 150     hr = get_mlang(&ml);
 151
 152     if(SUCCEEDED(hr))
 153     {
 154         hr = IMultiLanguage_GetCodePageInfo(ml, cp, mlang_cp_info);
 155         IMultiLanguage_Release(ml);
 156     }
 157     return hr;
 158 }
 159
 160 static HRESULT WINAPI MimeInternat_GetCodePageCharset(IMimeInternational *iface, CODEPAGEID cpiCodePage,
 161                                                       CHARSETTYPE ctCsetType,
 162                                                       LPHCHARSET phCharset)
 163 {
 164     HRESULT hr;
 165     MIMECPINFO mlang_cp_info;
 166
 167     TRACE("(%p)->(%d, %d, %p)\n", iface, cpiCodePage, ctCsetType, phCharset);
 168
 169     *phCharset = NULL;
 170
 171     hr = mlang_getcodepageinfo(cpiCodePage, &mlang_cp_info);
 172     if(SUCCEEDED(hr))
 173     {
 174         const WCHAR *charset_nameW = NULL;
 175         char *charset_name;
 176         DWORD len;
 177
 178         switch(ctCsetType)
 179         {
 180         case CHARSET_BODY:
 181             charset_nameW = mlang_cp_info.wszBodyCharset;
 182             break;
 183         case CHARSET_HEADER:
 184             charset_nameW = mlang_cp_info.wszHeaderCharset;
 185             break;
 186         case CHARSET_WEB:
 187             charset_nameW = mlang_cp_info.wszWebCharset;
 188             break;
 189         default:
 190             return MIME_E_INVALID_CHARSET_TYPE;
 191         }
 192         len = WideCharToMultiByte(CP_ACP, 0, charset_nameW, -1, NULL, 0, NULL, NULL);
 193         charset_name = HeapAlloc(GetProcessHeap(), 0, len);
 194         WideCharToMultiByte(CP_ACP, 0, charset_nameW, -1, charset_name, len, NULL, NULL);
 195         hr = IMimeInternational_FindCharset(iface, charset_name, phCharset);
 196         HeapFree(GetProcessHeap(), 0, charset_name);
 197     }
 198     return hr;
 199 }
 200
 201 static HRESULT mlang_getcsetinfo(const char *charset, MIMECSETINFO *mlang_info)
 202 {
 203     DWORD len = MultiByteToWideChar(CP_ACP, 0, charset, -1, NULL, 0);
 204     BSTR bstr = SysAllocStringLen(NULL, len - 1);
 205     HRESULT hr;
 206     IMultiLanguage *ml;
 207
 208     MultiByteToWideChar(CP_ACP, 0, charset, -1, bstr, len);
 209
 210     hr = get_mlang(&ml);
 211
 212     if(SUCCEEDED(hr))
 213     {
 214         hr = IMultiLanguage_GetCharsetInfo(ml, bstr, mlang_info);
 215         IMultiLanguage_Release(ml);
 216     }
 217     SysFreeString(bstr);
 218     if(FAILED(hr)) hr = MIME_E_NOT_FOUND;
 219     return hr;
 220 }
 221
 222 static HCHARSET add_charset(struct list *list, MIMECSETINFO *mlang_info, HCHARSET handle)
 223 {
 224     charset_entry *charset = HeapAlloc(GetProcessHeap(), 0, sizeof(*charset));
 225
 226     WideCharToMultiByte(CP_ACP, 0, mlang_info->wszCharset, -1,
 227                         charset->cs_info.szName, sizeof(charset->cs_info.szName), NULL, NULL);
 228     charset->cs_info.cpiWindows = mlang_info->uiCodePage;
 229     charset->cs_info.cpiInternet = mlang_info->uiInternetEncoding;
 230     charset->cs_info.hCharset = handle;
 231     charset->cs_info.dwReserved1 = 0;
 232     list_add_head(list, &charset->entry);
 233
 234     return charset->cs_info.hCharset;
 235 }
 236
 237 static HRESULT WINAPI MimeInternat_FindCharset(IMimeInternational *iface, LPCSTR pszCharset,
 238                                                LPHCHARSET phCharset)
 239 {
 240     internat *This = impl_from_IMimeInternational( iface );
 241     HRESULT hr = MIME_E_NOT_FOUND;
 242     charset_entry *charset;
 243
 244     TRACE("(%p)->(%s, %p)\n", iface, debugstr_a(pszCharset), phCharset);
 245
 246     *phCharset = NULL;
 247
 248     EnterCriticalSection(&This->cs);
 249
 250     LIST_FOR_EACH_ENTRY(charset, &This->charsets, charset_entry, entry)
 251     {
 252         if(!strcmp(charset->cs_info.szName, pszCharset))
 253         {
 254             *phCharset = charset->cs_info.hCharset;
 255             hr = S_OK;
 256             break;
 257         }
 258     }
 259
 260     if(hr == MIME_E_NOT_FOUND)
 261     {
 262         MIMECSETINFO mlang_info;
 263
 264         LeaveCriticalSection(&This->cs);
 265         hr = mlang_getcsetinfo(pszCharset, &mlang_info);
 266         EnterCriticalSection(&This->cs);
 267
 268         if(SUCCEEDED(hr))
 269             *phCharset = add_charset(&This->charsets, &mlang_info,
 270                                      (HCHARSET)InterlockedIncrement(&This->next_charset_handle));
 271     }
 272
 273     LeaveCriticalSection(&This->cs);
 274     return hr;
 275 }
 276
 277 static HRESULT WINAPI MimeInternat_GetCharsetInfo(IMimeInternational *iface, HCHARSET hCharset,
 278                                                   LPINETCSETINFO pCsetInfo)
 279 {
 280     internat *This = impl_from_IMimeInternational( iface );
 281     HRESULT hr = MIME_E_INVALID_HANDLE;
 282     charset_entry *charset;
 283
 284     TRACE("(%p)->(%p, %p)\n", iface, hCharset, pCsetInfo);
 285
 286     EnterCriticalSection(&This->cs);
 287
 288     LIST_FOR_EACH_ENTRY(charset, &This->charsets, charset_entry, entry)
 289     {
 290         if(charset->cs_info.hCharset ==  hCharset)
 291         {
 292             *pCsetInfo = charset->cs_info;
 293             hr = S_OK;
 294             break;
 295         }
 296     }
 297
 298     LeaveCriticalSection(&This->cs);
 299
 300     return hr;
 301 }
 302
 303 static HRESULT WINAPI MimeInternat_GetCodePageInfo(IMimeInternational *iface, CODEPAGEID cpiCodePage,
 304                                                    LPCODEPAGEINFO pCodePageInfo)
 305 {
 306     FIXME("stub\n");
 307     return E_NOTIMPL;
 308 }
 309
 310 static HRESULT WINAPI MimeInternat_CanConvertCodePages(IMimeInternational *iface, CODEPAGEID cpiSource,
 311                                                        CODEPAGEID cpiDest)
 312 {
 313     HRESULT hr;
 314     IMultiLanguage *ml;
 315
 316     TRACE("(%p)->(%d, %d)\n", iface, cpiSource, cpiDest);
 317
 318     /* Could call mlang.IsConvertINetStringAvailable() to avoid the COM overhead if need be. */
 319
 320     hr = get_mlang(&ml);
 321     if(SUCCEEDED(hr))
 322     {
 323         hr = IMultiLanguage_IsConvertible(ml, cpiSource, cpiDest);
 324         IMultiLanguage_Release(ml);
 325     }
 326
 327     return hr;
 328 }
 329
 330 static HRESULT WINAPI MimeInternat_DecodeHeader(IMimeInternational *iface, HCHARSET hCharset,
 331                                                 LPCSTR pszData,
 332                                                 LPPROPVARIANT pDecoded,
 333                                                 LPRFC1522INFO pRfc1522Info)
 334 {
 335     FIXME("stub\n");
 336     return E_NOTIMPL;
 337 }
 338
 339 static HRESULT WINAPI MimeInternat_EncodeHeader(IMimeInternational *iface, HCHARSET hCharset,
 340                                                 LPPROPVARIANT pData,
 341                                                 LPSTR *ppszEncoded,
 342                                                 LPRFC1522INFO pRfc1522Info)
 343 {
 344     FIXME("stub\n");
 345     return E_NOTIMPL;
 346 }
 347
 348 static HRESULT WINAPI MimeInternat_ConvertBuffer(IMimeInternational *iface, CODEPAGEID cpiSource,
 349                                                  CODEPAGEID cpiDest, LPBLOB pIn, LPBLOB pOut,
 350                                                  ULONG *pcbRead)
 351 {
 352     HRESULT hr;
 353     IMultiLanguage *ml;
 354
 355     TRACE("(%p)->(%d, %d, %p, %p, %p)\n", iface, cpiSource, cpiDest, pIn, pOut, pcbRead);
 356
 357     *pcbRead = 0;
 358     pOut->cbSize = 0;
 359
 360     /* Could call mlang.ConvertINetString() to avoid the COM overhead if need be. */
 361
 362     hr = get_mlang(&ml);
 363     if(SUCCEEDED(hr))
 364     {
 365         DWORD mode = 0;
 366         UINT in_size = pIn->cbSize, out_size;
 367
 368         hr = IMultiLanguage_ConvertString(ml, &mode, cpiSource, cpiDest, pIn->pBlobData, &in_size,
 369                                           NULL, &out_size);
 370         if(hr == S_OK) /* S_FALSE means the conversion could not be performed */
 371         {
 372             pOut->pBlobData = CoTaskMemAlloc(out_size);
 373             if(!pOut->pBlobData)
 374                 hr = E_OUTOFMEMORY;
 375             else
 376             {
 377                 mode = 0;
 378                 in_size = pIn->cbSize;
 379                 hr = IMultiLanguage_ConvertString(ml, &mode, cpiSource, cpiDest, pIn->pBlobData, &in_size,
 380                                                   pOut->pBlobData, &out_size);
 381
 382                 if(hr == S_OK)
 383                 {
 384                     *pcbRead = in_size;
 385                     pOut->cbSize = out_size;
 386                 }
 387                 else
 388                     CoTaskMemFree(pOut->pBlobData);
 389             }
 390         }
 391         IMultiLanguage_Release(ml);
 392     }
 393
 394     return hr;
 395 }
 396
 397 static HRESULT WINAPI MimeInternat_ConvertString(IMimeInternational *iface, CODEPAGEID cpiSource,
 398                                                  CODEPAGEID cpiDest,
 399                                                  LPPROPVARIANT pIn,
 400                                                  LPPROPVARIANT pOut)
 401 {
 402     FIXME("stub\n");
 403     return E_NOTIMPL;
 404 }
 405
 406 static HRESULT WINAPI MimeInternat_MLANG_ConvertInetReset(IMimeInternational *iface)
 407 {
 408     FIXME("stub\n");
 409     return E_NOTIMPL;
 410 }
 411
 412 static HRESULT WINAPI MimeInternat_MLANG_ConvertInetString(IMimeInternational *iface, CODEPAGEID cpiSource,
 413                                                            CODEPAGEID cpiDest,
 414                                                            LPCSTR pSource,
 415                                                            int *pnSizeOfSource,
 416                                                            LPSTR pDestination,
 417                                                            int *pnDstSize)
 418 {
 419     FIXME("stub\n");
 420     return E_NOTIMPL;
 421 }
 422
 423 static HRESULT WINAPI MimeInternat_Rfc1522Decode(IMimeInternational *iface, LPCSTR pszValue,
 424                                                  LPSTR pszCharset,
 425                                                  ULONG cchmax,
 426                                                  LPSTR *ppszDecoded)
 427 {
 428     FIXME("stub\n");
 429     return E_NOTIMPL;
 430 }
 431
 432 static HRESULT WINAPI MimeInternat_Rfc1522Encode(IMimeInternational *iface, LPCSTR pszValue,
 433                                                  HCHARSET hCharset,
 434                                                  LPSTR *ppszEncoded)
 435 {
 436     FIXME("stub\n");
 437     return E_NOTIMPL;
 438 }
 439
 440 static IMimeInternationalVtbl mime_internat_vtbl =
 441 {
 442     MimeInternat_QueryInterface,
 443     MimeInternat_AddRef,
 444     MimeInternat_Release,
 445     MimeInternat_SetDefaultCharset,
 446     MimeInternat_GetDefaultCharset,
 447     MimeInternat_GetCodePageCharset,
 448     MimeInternat_FindCharset,
 449     MimeInternat_GetCharsetInfo,
 450     MimeInternat_GetCodePageInfo,
 451     MimeInternat_CanConvertCodePages,
 452     MimeInternat_DecodeHeader,
 453     MimeInternat_EncodeHeader,
 454     MimeInternat_ConvertBuffer,
 455     MimeInternat_ConvertString,
 456     MimeInternat_MLANG_ConvertInetReset,
 457     MimeInternat_MLANG_ConvertInetString,
 458     MimeInternat_Rfc1522Decode,
 459     MimeInternat_Rfc1522Encode
 460 };
 461
 462 static internat *global_internat;
 463
 464 HRESULT MimeInternational_Construct(IMimeInternational **internat)
 465 {
 466     global_internat = HeapAlloc(GetProcessHeap(), 0, sizeof(*global_internat));
 467     global_internat->lpVtbl = &mime_internat_vtbl;
 468     global_internat->refs = 0;
 469     InitializeCriticalSection(&global_internat->cs);
 470
 471     list_init(&global_internat->charsets);
 472     global_internat->next_charset_handle = 0;
 473     global_internat->default_charset = NULL;
 474
 475     *internat = (IMimeInternational*)&global_internat->lpVtbl;
 476
 477     IMimeInternational_AddRef(*internat);
 478     return S_OK;
 479 }
 480
 481 HRESULT WINAPI MimeOleGetInternat(IMimeInternational **internat)
 482 {
 483     TRACE("(%p)\n", internat);
 484
 485     *internat = (IMimeInternational *)&global_internat->lpVtbl;
 486     IMimeInternational_AddRef(*internat);
 487     return S_OK;
 488 }