ReactOS  0.4.14-dev-49-gfb4591c
mimeintl.c
Go to the documentation of this file.
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 
43 
44 typedef struct
45 {
46  struct list entry;
47  INETCSETINFO cs_info;
49 
50 typedef struct
51 {
52  IMimeInternational IMimeInternational_iface;
55 
56  struct list charsets;
58  HCHARSET default_charset;
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 {
89  return InterlockedIncrement(&This->refs);
90 }
91 
92 static ULONG WINAPI MimeInternat_Release( IMimeInternational *iface )
93 {
95  ULONG refs;
96 
97  refs = InterlockedDecrement(&This->refs);
98  if (!refs)
99  {
100  charset_entry *charset, *cursor2;
101 
103  {
104  list_remove(&charset->entry);
106  }
107  This->cs.DebugInfo->Spare[0] = 0;
110  }
111 
112  return refs;
113 }
114 
115 static HRESULT WINAPI MimeInternat_SetDefaultCharset(IMimeInternational *iface, HCHARSET hCharset)
116 {
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 {
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 {
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 {
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 {
244  HRESULT hr = MIME_E_NOT_FOUND;
246 
247  TRACE("(%p)->(%s, %p)\n", iface, debugstr_a(pszCharset), phCharset);
248 
249  *phCharset = NULL;
250 
252 
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 
268  hr = mlang_getcsetinfo(pszCharset, &mlang_info);
270 
271  if(SUCCEEDED(hr))
272  *phCharset = add_charset(&This->charsets, &mlang_info,
273  UlongToHandle(InterlockedIncrement(&This->next_charset_handle)));
274  }
275 
277  return hr;
278 }
279 
280 static HRESULT WINAPI MimeInternat_GetCharsetInfo(IMimeInternational *iface, HCHARSET hCharset,
281  LPINETCSETINFO pCsetInfo)
282 {
284  HRESULT hr = MIME_E_INVALID_HANDLE;
286 
287  TRACE("(%p)->(%p, %p)\n", iface, hCharset, pCsetInfo);
288 
290 
292  {
293  if(charset->cs_info.hCharset == hCharset)
294  {
295  *pCsetInfo = charset->cs_info;
296  hr = S_OK;
297  break;
298  }
299  }
300 
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  {
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 {
522 };
523 
525 
526 HRESULT MimeInternational_Construct(IMimeInternational **internat)
527 {
530  global_internat->refs = 0;
532  global_internat->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": global_internat.cs");
533 
537 
539 
540  IMimeInternational_AddRef(*internat);
541  return S_OK;
542 }
543 
544 HRESULT WINAPI MimeOleGetInternat(IMimeInternational **internat)
545 {
546  TRACE("(%p)\n", internat);
547 
549  IMimeInternational_AddRef(*internat);
550  return S_OK;
551 }
552 
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 
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 }
static ULONG WINAPI MimeInternat_Release(IMimeInternational *iface)
Definition: mimeintl.c:92
static HRESULT WINAPI MimeInternat_ConvertString(IMimeInternational *iface, CODEPAGEID cpiSource, CODEPAGEID cpiDest, LPPROPVARIANT pIn, LPPROPVARIANT pOut)
Definition: mimeintl.c:400
static HRESULT WINAPI MimeInternat_SetDefaultCharset(IMimeInternational *iface, HCHARSET hCharset)
Definition: mimeintl.c:115
namespace GUID const ADDRINFOEXW ADDRINFOEXW struct timeval OVERLAPPED LPLOOKUPSERVICE_COMPLETION_ROUTINE HANDLE * handle
Definition: sock.c:82
#define REFIID
Definition: guiddef.h:118
static HANDLE PIO_APC_ROUTINE PVOID PIO_STATUS_BLOCK ULONG PVOID ULONG PVOID ULONG out_size
Definition: file.c:100
HRESULT WINAPI MimeOleGetDefaultCharset(LPHCHARSET charset)
Definition: mimeintl.c:585
#define E_NOINTERFACE
Definition: winerror.h:2364
VOID WINAPI CoTaskMemFree(LPVOID ptr)
Definition: ifs.c:422
WINE_UNICODE_INLINE unsigned int strlenW(const WCHAR *str)
Definition: unicode.h:212
CFF_Charset charset
Definition: cffcmap.c:138
int WINAPI lstrcmpiA(LPCSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:42
#define DWORD_PTR
Definition: treelist.c:76
#define WideCharToMultiByte
Definition: compat.h:101
HRESULT hr
Definition: shlfolder.c:183
static HRESULT WINAPI MimeInternat_GetCodePageCharset(IMimeInternational *iface, CODEPAGEID cpiCodePage, CHARSETTYPE ctCsetType, LPHCHARSET phCharset)
Definition: mimeintl.c:163
BSTR WINAPI SysAllocStringLen(const OLECHAR *str, unsigned int len)
Definition: oleaut.c:342
static HRESULT WINAPI MimeInternat_GetCharsetInfo(IMimeInternational *iface, HCHARSET hCharset, LPINETCSETINFO pCsetInfo)
Definition: mimeintl.c:280
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
static internat_impl * global_internat
Definition: mimeintl.c:524
IMimeInternational IMimeInternational_iface
Definition: mimeintl.c:52
REFIID riid
Definition: precomp.h:44
#define CP_ACP
Definition: compat.h:99
static HRESULT WINAPI MimeInternat_CanConvertCodePages(IMimeInternational *iface, CODEPAGEID cpiSource, CODEPAGEID cpiDest)
Definition: mimeintl.c:313
static HRESULT WINAPI MimeInternat_ConvertBuffer(IMimeInternational *iface, CODEPAGEID cpiSource, CODEPAGEID cpiDest, LPBLOB pIn, LPBLOB pOut, ULONG *pcbRead)
Definition: mimeintl.c:351
__WINE_SERVER_LIST_INLINE void list_add_head(struct list *list, struct list *elem)
Definition: list.h:96
HRESULT WINAPI MimeOleFindCharset(LPCSTR name, LPHCHARSET charset)
Definition: mimeintl.c:553
static HRESULT WINAPI MimeInternat_EncodeHeader(IMimeInternational *iface, HCHARSET hCharset, LPPROPVARIANT pData, LPSTR *ppszEncoded, LPRFC1522INFO pRfc1522Info)
Definition: mimeintl.c:342
OLECHAR * BSTR
Definition: compat.h:1934
Definition: mimeintl.c:44
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
Definition: nspapi.h:57
char * LPSTR
Definition: xmlstorage.h:182
HRESULT WINAPI MimeOleGetCharsetInfo(HCHARSET hCharset, LPINETCSETINFO pCsetInfo)
Definition: mimeintl.c:569
BYTE * pBlobData
Definition: nspapi.h:59
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
Definition: list.h:198
static HRESULT get_mlang(IMultiLanguage **ml)
Definition: mimeintl.c:66
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
long LONG
Definition: pedump.c:60
#define FIXME(fmt,...)
Definition: debug.h:110
#define InterlockedCompareExchangePointer
Definition: interlocked.h:129
struct list charsets
Definition: mimeintl.c:56
#define E_INVALIDARG
Definition: ddrawi.h:101
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:751
smooth NULL
Definition: ftsmooth.c:416
unsigned char
Definition: typeof.h:29
UINT WINAPI GetACP(VOID)
Definition: nls.c:2169
static HRESULT WINAPI MimeInternat_FindCharset(IMimeInternational *iface, LPCSTR pszCharset, LPHCHARSET phCharset)
Definition: mimeintl.c:240
INETCSETINFO cs_info
Definition: mimeintl.c:47
const char * LPCSTR
Definition: xmlstorage.h:183
static ULONG WINAPI MimeInternat_AddRef(IMimeInternational *iface)
Definition: mimeintl.c:86
static HCHARSET add_charset(struct list *list, MIMECSETINFO *mlang_info, HCHARSET handle)
Definition: mimeintl.c:225
#define debugstr_guid
Definition: kernel32.h:35
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
HCHARSET * LPHCHARSET
Definition: mimeole.idl:202
__WINE_SERVER_LIST_INLINE void list_remove(struct list *elem)
Definition: list.h:108
#define TRACE(s)
Definition: solgame.cpp:4
#define InterlockedExchangePointer(Target, Value)
Definition: dshow.h:45
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
__wchar_t WCHAR
Definition: xmlstorage.h:180
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)
#define debugstr_a
Definition: kernel32.h:31
LONG HRESULT
Definition: typedefs.h:77
#define UlongToHandle(ul)
Definition: basetsd.h:97
const GUID IID_IUnknown
ULONG cbSize
Definition: nspapi.h:58
static HRESULT WINAPI MimeInternat_GetDefaultCharset(IMimeInternational *iface, LPHCHARSET phCharset)
Definition: mimeintl.c:129
#define WINAPI
Definition: msvc.h:8
static HRESULT WINAPI MimeInternat_DecodeHeader(IMimeInternational *iface, HCHARSET hCharset, LPCSTR pszData, LPPROPVARIANT pDecoded, LPRFC1522INFO pRfc1522Info)
Definition: mimeintl.c:333
unsigned long DWORD
Definition: ntddk_ex.h:95
static HANDLE PIO_APC_ROUTINE PVOID PIO_STATUS_BLOCK ULONG PVOID ULONG in_size
Definition: file.c:100
HCHARSET default_charset
Definition: mimeintl.c:58
PCRITICAL_SECTION_DEBUG DebugInfo
Definition: winbase.h:859
static HRESULT WINAPI MimeInternat_MLANG_ConvertInetString(IMimeInternational *iface, CODEPAGEID cpiSource, CODEPAGEID cpiDest, LPCSTR pSource, int *pnSizeOfSource, LPSTR pDestination, int *pnDstSize)
Definition: mimeintl.c:474
#define InterlockedDecrement
Definition: armddk.h:52
uint32_t entry
Definition: isohybrid.c:63
GLenum GLsizei len
Definition: glext.h:6722
unsigned char BYTE
Definition: mem.h:68
Definition: _list.h:228
static HRESULT WINAPI MimeInternat_MLANG_ConvertInetReset(IMimeInternational *iface)
Definition: mimeintl.c:468
GLenum mode
Definition: glext.h:6217
WINE_DEFAULT_DEBUG_CHANNEL(inetcomm)
HRESULT WINAPI MimeOleGetInternat(IMimeInternational **internat)
Definition: mimeintl.c:544
HRESULT MimeInternational_Construct(IMimeInternational **internat)
Definition: mimeintl.c:526
HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID iid, LPVOID *ppv)
Definition: compobj.c:3234
static internat_impl * impl_from_IMimeInternational(IMimeInternational *iface)
Definition: mimeintl.c:61
#define S_OK
Definition: intsafe.h:59
#define LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, list, type, field)
Definition: list.h:204
#define InterlockedIncrement
Definition: armddk.h:53
static HRESULT WINAPI MimeInternat_Rfc1522Encode(IMimeInternational *iface, LPCSTR pszValue, HCHARSET hCharset, LPSTR *ppszEncoded)
Definition: mimeintl.c:494
static HRESULT WINAPI MimeInternat_GetCodePageInfo(IMimeInternational *iface, CODEPAGEID cpiCodePage, LPCODEPAGEINFO pCodePageInfo)
Definition: mimeintl.c:306
#define E_NOTIMPL
Definition: ddrawi.h:99
void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str)
Definition: oleaut.c:274
unsigned int UINT
Definition: ndis.h:50
BOOL WINAPI IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
Definition: compobj.c:4021
#define MultiByteToWideChar
Definition: compat.h:100
POINT cp
Definition: magnifier.c:59
Definition: name.c:36
__WINE_SERVER_LIST_INLINE void list_init(struct list *list)
Definition: list.h:149
unsigned int ULONG
Definition: retypes.h:1
static IMimeInternationalVtbl mime_internat_vtbl
Definition: mimeintl.c:502
static HRESULT WINAPI MimeInternat_QueryInterface(IMimeInternational *iface, REFIID riid, LPVOID *ppobj)
Definition: mimeintl.c:72
CRITICAL_SECTION cs
Definition: mimeintl.c:54
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
TW_UINT32 TW_UINT16 TW_UINT16 TW_MEMREF pData
Definition: twain.h:1827
LONG next_charset_handle
Definition: mimeintl.c:57
static HRESULT mlang_getcsetinfo(const char *charset, MIMECSETINFO *mlang_info)
Definition: mimeintl.c:204
#define CP_UNICODE
Definition: stg_prop.c:81
LPVOID WINAPI CoTaskMemAlloc(SIZE_T size)
Definition: ifs.c:406
#define HeapFree(x, y, z)
Definition: compat.h:394
#define SUCCEEDED(hr)
Definition: intsafe.h:57
static HRESULT mlang_getcodepageinfo(UINT cp, MIMECPINFO *mlang_cp_info)
Definition: mimeintl.c:148
DWORD_PTR Spare[8/sizeof(DWORD_PTR)]
Definition: winbase.h:852
static HRESULT WINAPI MimeInternat_Rfc1522Decode(IMimeInternational *iface, LPCSTR pszValue, LPSTR pszCharset, ULONG cchmax, LPSTR *ppszDecoded)
Definition: mimeintl.c:485