| /* |
| * MIME OLE International interface |
| * |
| * Copyright 2008 Huw Davies for CodeWeavers |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #define COBJMACROS |
| #define NONAMELESSUNION |
| |
| #include <stdarg.h> |
| #include <stdio.h> |
| |
| #include "windef.h" |
| #include "winbase.h" |
| #include "winuser.h" |
| #include "winnls.h" |
| #include "objbase.h" |
| #include "ole2.h" |
| #include "mimeole.h" |
| #include "mlang.h" |
| |
| #include "wine/list.h" |
| #include "wine/unicode.h" |
| #include "wine/debug.h" |
| |
| #include "inetcomm_private.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(inetcomm); |
| |
| typedef struct |
| { |
| struct list entry; |
| INETCSETINFO cs_info; |
| } charset_entry; |
| |
| typedef struct |
| { |
| const IMimeInternationalVtbl *lpVtbl; |
| LONG refs; |
| CRITICAL_SECTION cs; |
| |
| struct list charsets; |
| LONG next_charset_handle; |
| HCHARSET default_charset; |
| } internat; |
| |
| static inline internat *impl_from_IMimeInternational( IMimeInternational *iface ) |
| { |
| return (internat *)((char*)iface - FIELD_OFFSET(internat, lpVtbl)); |
| } |
| |
| static inline HRESULT get_mlang(IMultiLanguage **ml) |
| { |
| return CoCreateInstance(&CLSID_CMultiLanguage, NULL, CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER, |
| &IID_IMultiLanguage, (void **)ml); |
| } |
| |
| static HRESULT WINAPI MimeInternat_QueryInterface( IMimeInternational *iface, REFIID riid, LPVOID *ppobj ) |
| { |
| if (IsEqualGUID(riid, &IID_IUnknown) || |
| IsEqualGUID(riid, &IID_IMimeInternational)) |
| { |
| IMimeInternational_AddRef( iface ); |
| *ppobj = iface; |
| return S_OK; |
| } |
| |
| FIXME("interface %s not implemented\n", debugstr_guid(riid)); |
| return E_NOINTERFACE; |
| } |
| |
| static ULONG WINAPI MimeInternat_AddRef( IMimeInternational *iface ) |
| { |
| internat *This = impl_from_IMimeInternational( iface ); |
| return InterlockedIncrement(&This->refs); |
| } |
| |
| static ULONG WINAPI MimeInternat_Release( IMimeInternational *iface ) |
| { |
| internat *This = impl_from_IMimeInternational( iface ); |
| ULONG refs; |
| |
| refs = InterlockedDecrement(&This->refs); |
| if (!refs) |
| { |
| charset_entry *charset, *cursor2; |
| |
| LIST_FOR_EACH_ENTRY_SAFE(charset, cursor2, &This->charsets, charset_entry, entry) |
| { |
| list_remove(&charset->entry); |
| HeapFree(GetProcessHeap(), 0, charset); |
| } |
| HeapFree(GetProcessHeap(), 0, This); |
| } |
| |
| return refs; |
| } |
| |
| static HRESULT WINAPI MimeInternat_SetDefaultCharset(IMimeInternational *iface, HCHARSET hCharset) |
| { |
| internat *This = impl_from_IMimeInternational( iface ); |
| |
| TRACE("(%p)->(%p)\n", iface, hCharset); |
| |
| if(hCharset == NULL) return E_INVALIDARG; |
| /* FIXME check hCharset is valid */ |
| |
| InterlockedExchangePointer(&This->default_charset, hCharset); |
| |
| return S_OK; |
| } |
| |
| static HRESULT WINAPI MimeInternat_GetDefaultCharset(IMimeInternational *iface, LPHCHARSET phCharset) |
| { |
| internat *This = impl_from_IMimeInternational( iface ); |
| HRESULT hr = S_OK; |
| |
| TRACE("(%p)->(%p)\n", iface, phCharset); |
| |
| if(This->default_charset == NULL) |
| { |
| HCHARSET hcs; |
| hr = IMimeInternational_GetCodePageCharset(iface, GetACP(), CHARSET_BODY, &hcs); |
| if(SUCCEEDED(hr)) |
| InterlockedCompareExchangePointer(&This->default_charset, hcs, NULL); |
| } |
| *phCharset = This->default_charset; |
| |
| return hr; |
| } |
| |
| static HRESULT mlang_getcodepageinfo(UINT cp, MIMECPINFO *mlang_cp_info) |
| { |
| HRESULT hr; |
| IMultiLanguage *ml; |
| |
| hr = get_mlang(&ml); |
| |
| if(SUCCEEDED(hr)) |
| { |
| hr = IMultiLanguage_GetCodePageInfo(ml, cp, mlang_cp_info); |
| IMultiLanguage_Release(ml); |
| } |
| return hr; |
| } |
| |
| static HRESULT WINAPI MimeInternat_GetCodePageCharset(IMimeInternational *iface, CODEPAGEID cpiCodePage, |
| CHARSETTYPE ctCsetType, |
| LPHCHARSET phCharset) |
| { |
| HRESULT hr; |
| MIMECPINFO mlang_cp_info; |
| |
| TRACE("(%p)->(%d, %d, %p)\n", iface, cpiCodePage, ctCsetType, phCharset); |
| |
| *phCharset = NULL; |
| |
| hr = mlang_getcodepageinfo(cpiCodePage, &mlang_cp_info); |
| if(SUCCEEDED(hr)) |
| { |
| const WCHAR *charset_nameW = NULL; |
| char *charset_name; |
| DWORD len; |
| |
| switch(ctCsetType) |
| { |
| case CHARSET_BODY: |
| charset_nameW = mlang_cp_info.wszBodyCharset; |
| break; |
| case CHARSET_HEADER: |
| charset_nameW = mlang_cp_info.wszHeaderCharset; |
| break; |
| case CHARSET_WEB: |
| charset_nameW = mlang_cp_info.wszWebCharset; |
| break; |
| default: |
| return MIME_E_INVALID_CHARSET_TYPE; |
| } |
| len = WideCharToMultiByte(CP_ACP, 0, charset_nameW, -1, NULL, 0, NULL, NULL); |
| charset_name = HeapAlloc(GetProcessHeap(), 0, len); |
| WideCharToMultiByte(CP_ACP, 0, charset_nameW, -1, charset_name, len, NULL, NULL); |
| hr = IMimeInternational_FindCharset(iface, charset_name, phCharset); |
| HeapFree(GetProcessHeap(), 0, charset_name); |
| } |
| return hr; |
| } |
| |
| static HRESULT mlang_getcsetinfo(const char *charset, MIMECSETINFO *mlang_info) |
| { |
| DWORD len = MultiByteToWideChar(CP_ACP, 0, charset, -1, NULL, 0); |
| BSTR bstr = SysAllocStringLen(NULL, len - 1); |
| HRESULT hr; |
| IMultiLanguage *ml; |
| |
| MultiByteToWideChar(CP_ACP, 0, charset, -1, bstr, len); |
| |
| hr = get_mlang(&ml); |
| |
| if(SUCCEEDED(hr)) |
| { |
| hr = IMultiLanguage_GetCharsetInfo(ml, bstr, mlang_info); |
| IMultiLanguage_Release(ml); |
| } |
| SysFreeString(bstr); |
| if(FAILED(hr)) hr = MIME_E_NOT_FOUND; |
| return hr; |
| } |
| |
| static HCHARSET add_charset(struct list *list, MIMECSETINFO *mlang_info, HCHARSET handle) |
| { |
| charset_entry *charset = HeapAlloc(GetProcessHeap(), 0, sizeof(*charset)); |
| |
| WideCharToMultiByte(CP_ACP, 0, mlang_info->wszCharset, -1, |
| charset->cs_info.szName, sizeof(charset->cs_info.szName), NULL, NULL); |
| charset->cs_info.cpiWindows = mlang_info->uiCodePage; |
| charset->cs_info.cpiInternet = mlang_info->uiInternetEncoding; |
| charset->cs_info.hCharset = handle; |
| charset->cs_info.dwReserved1 = 0; |
| list_add_head(list, &charset->entry); |
| |
| return charset->cs_info.hCharset; |
| } |
| |
| static HRESULT WINAPI MimeInternat_FindCharset(IMimeInternational *iface, LPCSTR pszCharset, |
| LPHCHARSET phCharset) |
| { |
| internat *This = impl_from_IMimeInternational( iface ); |
| HRESULT hr = MIME_E_NOT_FOUND; |
| charset_entry *charset; |
| |
| TRACE("(%p)->(%s, %p)\n", iface, debugstr_a(pszCharset), phCharset); |
| |
| *phCharset = NULL; |
| |
| EnterCriticalSection(&This->cs); |
| |
| LIST_FOR_EACH_ENTRY(charset, &This->charsets, charset_entry, entry) |
| { |
| if(!lstrcmpiA(charset->cs_info.szName, pszCharset)) |
| { |
| *phCharset = charset->cs_info.hCharset; |
| hr = S_OK; |
| break; |
| } |
| } |
| |
| if(hr == MIME_E_NOT_FOUND) |
| { |
| MIMECSETINFO mlang_info; |
| |
| LeaveCriticalSection(&This->cs); |
| hr = mlang_getcsetinfo(pszCharset, &mlang_info); |
| EnterCriticalSection(&This->cs); |
| |
| if(SUCCEEDED(hr)) |
| *phCharset = add_charset(&This->charsets, &mlang_info, |
| (HCHARSET)InterlockedIncrement(&This->next_charset_handle)); |
| } |
| |
| LeaveCriticalSection(&This->cs); |
| return hr; |
| } |
| |
| static HRESULT WINAPI MimeInternat_GetCharsetInfo(IMimeInternational *iface, HCHARSET hCharset, |
| LPINETCSETINFO pCsetInfo) |
| { |
| internat *This = impl_from_IMimeInternational( iface ); |
| HRESULT hr = MIME_E_INVALID_HANDLE; |
| charset_entry *charset; |
| |
| TRACE("(%p)->(%p, %p)\n", iface, hCharset, pCsetInfo); |
| |
| EnterCriticalSection(&This->cs); |
| |
| LIST_FOR_EACH_ENTRY(charset, &This->charsets, charset_entry, entry) |
| { |
| if(charset->cs_info.hCharset == hCharset) |
| { |
| *pCsetInfo = charset->cs_info; |
| hr = S_OK; |
| break; |
| } |
| } |
| |
| LeaveCriticalSection(&This->cs); |
| |
| return hr; |
| } |
| |
| static HRESULT WINAPI MimeInternat_GetCodePageInfo(IMimeInternational *iface, CODEPAGEID cpiCodePage, |
| LPCODEPAGEINFO pCodePageInfo) |
| { |
| FIXME("stub\n"); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI MimeInternat_CanConvertCodePages(IMimeInternational *iface, CODEPAGEID cpiSource, |
| CODEPAGEID cpiDest) |
| { |
| HRESULT hr; |
| IMultiLanguage *ml; |
| |
| TRACE("(%p)->(%d, %d)\n", iface, cpiSource, cpiDest); |
| |
| /* Could call mlang.IsConvertINetStringAvailable() to avoid the COM overhead if need be. */ |
| |
| hr = get_mlang(&ml); |
| if(SUCCEEDED(hr)) |
| { |
| hr = IMultiLanguage_IsConvertible(ml, cpiSource, cpiDest); |
| IMultiLanguage_Release(ml); |
| } |
| |
| return hr; |
| } |
| |
| static HRESULT WINAPI MimeInternat_DecodeHeader(IMimeInternational *iface, HCHARSET hCharset, |
| LPCSTR pszData, |
| LPPROPVARIANT pDecoded, |
| LPRFC1522INFO pRfc1522Info) |
| { |
| FIXME("stub\n"); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI MimeInternat_EncodeHeader(IMimeInternational *iface, HCHARSET hCharset, |
| LPPROPVARIANT pData, |
| LPSTR *ppszEncoded, |
| LPRFC1522INFO pRfc1522Info) |
| { |
| FIXME("stub\n"); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI MimeInternat_ConvertBuffer(IMimeInternational *iface, CODEPAGEID cpiSource, |
| CODEPAGEID cpiDest, LPBLOB pIn, LPBLOB pOut, |
| ULONG *pcbRead) |
| { |
| HRESULT hr; |
| IMultiLanguage *ml; |
| |
| TRACE("(%p)->(%d, %d, %p, %p, %p)\n", iface, cpiSource, cpiDest, pIn, pOut, pcbRead); |
| |
| *pcbRead = 0; |
| pOut->cbSize = 0; |
| |
| /* Could call mlang.ConvertINetString() to avoid the COM overhead if need be. */ |
| |
| hr = get_mlang(&ml); |
| if(SUCCEEDED(hr)) |
| { |
| DWORD mode = 0; |
| UINT in_size = pIn->cbSize, out_size; |
| |
| hr = IMultiLanguage_ConvertString(ml, &mode, cpiSource, cpiDest, pIn->pBlobData, &in_size, |
| NULL, &out_size); |
| if(hr == S_OK) /* S_FALSE means the conversion could not be performed */ |
| { |
| pOut->pBlobData = CoTaskMemAlloc(out_size); |
| if(!pOut->pBlobData) |
| hr = E_OUTOFMEMORY; |
| else |
| { |
| mode = 0; |
| in_size = pIn->cbSize; |
| hr = IMultiLanguage_ConvertString(ml, &mode, cpiSource, cpiDest, pIn->pBlobData, &in_size, |
| pOut->pBlobData, &out_size); |
| |
| if(hr == S_OK) |
| { |
| *pcbRead = in_size; |
| pOut->cbSize = out_size; |
| } |
| else |
| CoTaskMemFree(pOut->pBlobData); |
| } |
| } |
| IMultiLanguage_Release(ml); |
| } |
| |
| return hr; |
| } |
| |
| static HRESULT WINAPI MimeInternat_ConvertString(IMimeInternational *iface, CODEPAGEID cpiSource, |
| CODEPAGEID cpiDest, LPPROPVARIANT pIn, |
| LPPROPVARIANT pOut) |
| { |
| HRESULT hr; |
| int src_len; |
| IMultiLanguage *ml; |
| |
| TRACE("(%p)->(%d, %d, %p %p)\n", iface, cpiSource, cpiDest, pIn, pOut); |
| |
| switch(pIn->vt) |
| { |
| case VT_LPSTR: |
| if(cpiSource == CP_UNICODE) cpiSource = GetACP(); |
| src_len = strlen(pIn->u.pszVal); |
| break; |
| case VT_LPWSTR: |
| cpiSource = CP_UNICODE; |
| src_len = strlenW(pIn->u.pwszVal) * sizeof(WCHAR); |
| break; |
| default: |
| return E_INVALIDARG; |
| } |
| |
| hr = get_mlang(&ml); |
| if(SUCCEEDED(hr)) |
| { |
| DWORD mode = 0; |
| UINT in_size = src_len, out_size; |
| |
| hr = IMultiLanguage_ConvertString(ml, &mode, cpiSource, cpiDest, (BYTE*)pIn->u.pszVal, &in_size, |
| NULL, &out_size); |
| if(hr == S_OK) /* S_FALSE means the conversion could not be performed */ |
| { |
| out_size += (cpiDest == CP_UNICODE) ? sizeof(WCHAR) : sizeof(char); |
| |
| pOut->u.pszVal = CoTaskMemAlloc(out_size); |
| if(!pOut->u.pszVal) |
| hr = E_OUTOFMEMORY; |
| else |
| { |
| mode = 0; |
| in_size = src_len; |
| hr = IMultiLanguage_ConvertString(ml, &mode, cpiSource, cpiDest, (BYTE*)pIn->u.pszVal, &in_size, |
| (BYTE*)pOut->u.pszVal, &out_size); |
| |
| if(hr == S_OK) |
| { |
| if(cpiDest == CP_UNICODE) |
| { |
| pOut->u.pwszVal[out_size / sizeof(WCHAR)] = 0; |
| pOut->vt = VT_LPWSTR; |
| } |
| else |
| { |
| pOut->u.pszVal[out_size] = '\0'; |
| pOut->vt = VT_LPSTR; |
| } |
| } |
| else |
| CoTaskMemFree(pOut->u.pszVal); |
| } |
| } |
| IMultiLanguage_Release(ml); |
| } |
| return hr; |
| } |
| |
| static HRESULT WINAPI MimeInternat_MLANG_ConvertInetReset(IMimeInternational *iface) |
| { |
| FIXME("stub\n"); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI MimeInternat_MLANG_ConvertInetString(IMimeInternational *iface, CODEPAGEID cpiSource, |
| CODEPAGEID cpiDest, |
| LPCSTR pSource, |
| int *pnSizeOfSource, |
| LPSTR pDestination, |
| int *pnDstSize) |
| { |
| FIXME("stub\n"); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI MimeInternat_Rfc1522Decode(IMimeInternational *iface, LPCSTR pszValue, |
| LPSTR pszCharset, |
| ULONG cchmax, |
| LPSTR *ppszDecoded) |
| { |
| FIXME("stub\n"); |
| return E_NOTIMPL; |
| } |
| |
| static HRESULT WINAPI MimeInternat_Rfc1522Encode(IMimeInternational *iface, LPCSTR pszValue, |
| HCHARSET hCharset, |
| LPSTR *ppszEncoded) |
| { |
| FIXME("stub\n"); |
| return E_NOTIMPL; |
| } |
| |
| static IMimeInternationalVtbl mime_internat_vtbl = |
| { |
| MimeInternat_QueryInterface, |
| MimeInternat_AddRef, |
| MimeInternat_Release, |
| MimeInternat_SetDefaultCharset, |
| MimeInternat_GetDefaultCharset, |
| MimeInternat_GetCodePageCharset, |
| MimeInternat_FindCharset, |
| MimeInternat_GetCharsetInfo, |
| MimeInternat_GetCodePageInfo, |
| MimeInternat_CanConvertCodePages, |
| MimeInternat_DecodeHeader, |
| MimeInternat_EncodeHeader, |
| MimeInternat_ConvertBuffer, |
| MimeInternat_ConvertString, |
| MimeInternat_MLANG_ConvertInetReset, |
| MimeInternat_MLANG_ConvertInetString, |
| MimeInternat_Rfc1522Decode, |
| MimeInternat_Rfc1522Encode |
| }; |
| |
| static internat *global_internat; |
| |
| HRESULT MimeInternational_Construct(IMimeInternational **internat) |
| { |
| global_internat = HeapAlloc(GetProcessHeap(), 0, sizeof(*global_internat)); |
| global_internat->lpVtbl = &mime_internat_vtbl; |
| global_internat->refs = 0; |
| InitializeCriticalSection(&global_internat->cs); |
| |
| list_init(&global_internat->charsets); |
| global_internat->next_charset_handle = 0; |
| global_internat->default_charset = NULL; |
| |
| *internat = (IMimeInternational*)&global_internat->lpVtbl; |
| |
| IMimeInternational_AddRef(*internat); |
| return S_OK; |
| } |
| |
| HRESULT WINAPI MimeOleGetInternat(IMimeInternational **internat) |
| { |
| TRACE("(%p)\n", internat); |
| |
| *internat = (IMimeInternational *)&global_internat->lpVtbl; |
| IMimeInternational_AddRef(*internat); |
| return S_OK; |
| } |
| |
| HRESULT WINAPI MimeOleFindCharset(LPCSTR name, LPHCHARSET charset) |
| { |
| IMimeInternational *internat; |
| HRESULT hr; |
| |
| TRACE("(%s, %p)\n", debugstr_a(name), charset); |
| |
| hr = MimeOleGetInternat(&internat); |
| if(SUCCEEDED(hr)) |
| { |
| hr = IMimeInternational_FindCharset(internat, name, charset); |
| IMimeInternational_Release(internat); |
| } |
| return hr; |
| } |
| |
| HRESULT WINAPI MimeOleGetCharsetInfo(HCHARSET hCharset, LPINETCSETINFO pCsetInfo) |
| { |
| IMimeInternational *internat; |
| HRESULT hr; |
| |
| TRACE("(%p, %p)\n", hCharset, pCsetInfo); |
| |
| hr = MimeOleGetInternat(&internat); |
| if(SUCCEEDED(hr)) |
| { |
| hr = IMimeInternational_GetCharsetInfo(internat, hCharset, pCsetInfo); |
| IMimeInternational_Release(internat); |
| } |
| return hr; |
| } |
| |
| HRESULT WINAPI MimeOleGetDefaultCharset(LPHCHARSET charset) |
| { |
| IMimeInternational *internat; |
| HRESULT hr; |
| |
| TRACE("(%p)\n", charset); |
| |
| hr = MimeOleGetInternat(&internat); |
| if(SUCCEEDED(hr)) |
| { |
| hr = IMimeInternational_GetDefaultCharset(internat, charset); |
| IMimeInternational_Release(internat); |
| } |
| return hr; |
| } |
