ReactOS  0.4.12-dev-934-g9a4676f
util.c
Go to the documentation of this file.
1 /*
2  * MAPI Utility functions
3  *
4  * Copyright 2004 Jon Griffiths
5  * Copyright 2009 Owen Rudge for CodeWeavers
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21 
22 #include <stdarg.h>
23 #include <stdio.h>
24 
25 #define COBJMACROS
26 
27 #include "windef.h"
28 #include "winbase.h"
29 #include "winreg.h"
30 #include "winuser.h"
31 #include "winerror.h"
32 #include "winternl.h"
33 #include "objbase.h"
34 #include "shlwapi.h"
35 #include "wine/debug.h"
36 #include "wine/unicode.h"
37 #include "mapival.h"
38 #include "xcmc.h"
39 #include "msi.h"
40 #include "util.h"
41 
43 
44 static const BYTE digitsToHex[] = {
45  0,1,2,3,4,5,6,7,8,9,0xff,0xff,0xff,0xff,0xff,0xff,0xff,10,11,12,13,14,15,
46  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
47  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,10,11,12,13,
48  14,15 };
49 
51 
52 /**************************************************************************
53  * ScInitMapiUtil (MAPI32.33)
54  *
55  * Initialise Mapi utility functions.
56  *
57  * PARAMS
58  * ulReserved [I] Reserved, pass 0.
59  *
60  * RETURNS
61  * Success: S_OK. Mapi utility functions may be called.
62  * Failure: MAPI_E_INVALID_PARAMETER, if ulReserved is not 0.
63  *
64  * NOTES
65  * Your application does not need to call this function unless it does not
66  * call MAPIInitialize()/MAPIUninitialize().
67  */
69 {
70  if (mapiFunctions.ScInitMapiUtil)
71  return mapiFunctions.ScInitMapiUtil(ulReserved);
72 
73  FIXME("(0x%08x)stub!\n", ulReserved);
74  if (ulReserved)
76  return S_OK;
77 }
78 
79 /**************************************************************************
80  * DeinitMapiUtil (MAPI32.34)
81  *
82  * Uninitialise Mapi utility functions.
83  *
84  * PARAMS
85  * None.
86  *
87  * RETURNS
88  * Nothing.
89  *
90  * NOTES
91  * Your application does not need to call this function unless it does not
92  * call MAPIInitialize()/MAPIUninitialize().
93  */
95 {
96  if (mapiFunctions.DeinitMapiUtil)
97  mapiFunctions.DeinitMapiUtil();
98  else
99  FIXME("()stub!\n");
100 }
101 
103 
104 /**************************************************************************
105  * MAPIAllocateBuffer (MAPI32.12)
106  * MAPIAllocateBuffer@8 (MAPI32.13)
107  *
108  * Allocate a block of memory.
109  *
110  * PARAMS
111  * cbSize [I] Size of the block to allocate in bytes
112  * lppBuffer [O] Destination for pointer to allocated memory
113  *
114  * RETURNS
115  * Success: S_OK. *lppBuffer is filled with a pointer to a memory block of
116  * length cbSize bytes.
117  * Failure: MAPI_E_INVALID_PARAMETER, if lppBuffer is NULL.
118  * MAPI_E_NOT_ENOUGH_MEMORY, if the memory allocation fails.
119  *
120  * NOTES
121  * Memory allocated with this function should be freed with MAPIFreeBuffer().
122  * Further allocations of memory may be linked to the pointer returned using
123  * MAPIAllocateMore(). Linked allocations are freed when the initial pointer
124  * is feed.
125  */
127 {
128  LPMAPIALLOCBUFFER lpBuff;
129 
130  TRACE("(%d,%p)\n", cbSize, lppBuffer);
131 
132  if (mapiFunctions.MAPIAllocateBuffer)
133  return mapiFunctions.MAPIAllocateBuffer(cbSize, lppBuffer);
134 
135  if (!lppBuffer)
136  return E_INVALIDARG;
137 
138  lpBuff = HeapAlloc(GetProcessHeap(), 0, cbSize + sizeof(*lpBuff));
139  if (!lpBuff)
141 
142  TRACE("initial allocation:%p, returning %p\n", lpBuff, lpBuff + 1);
143  *lpBuff++ = NULL;
144  *lppBuffer = lpBuff;
145  return S_OK;
146 }
147 
148 /**************************************************************************
149  * MAPIAllocateMore (MAPI32.14)
150  * MAPIAllocateMore@12 (MAPI32.15)
151  *
152  * Allocate a block of memory linked to a previous allocation.
153  *
154  * PARAMS
155  * cbSize [I] Size of the block to allocate in bytes
156  * lpOrig [I] Initial allocation to link to, from MAPIAllocateBuffer()
157  * lppBuffer [O] Destination for pointer to allocated memory
158  *
159  * RETURNS
160  * Success: S_OK. *lppBuffer is filled with a pointer to a memory block of
161  * length cbSize bytes.
162  * Failure: MAPI_E_INVALID_PARAMETER, if lpOrig or lppBuffer is invalid.
163  * MAPI_E_NOT_ENOUGH_MEMORY, if memory allocation fails.
164  *
165  * NOTES
166  * Memory allocated with this function and stored in *lppBuffer is freed
167  * when lpOrig is passed to MAPIFreeBuffer(). It should not be freed independently.
168  */
169 SCODE WINAPI MAPIAllocateMore(ULONG cbSize, LPVOID lpOrig, LPVOID *lppBuffer)
170 {
171  LPMAPIALLOCBUFFER lpBuff = lpOrig;
172 
173  TRACE("(%d,%p,%p)\n", cbSize, lpOrig, lppBuffer);
174 
175  if (mapiFunctions.MAPIAllocateMore)
176  return mapiFunctions.MAPIAllocateMore(cbSize, lpOrig, lppBuffer);
177 
178  if (!lppBuffer || !lpBuff || !--lpBuff)
179  return E_INVALIDARG;
180 
181  /* Find the last allocation in the chain */
182  while (*lpBuff)
183  {
184  TRACE("linked:%p->%p\n", lpBuff, *lpBuff);
185  lpBuff = *lpBuff;
186  }
187 
188  if (SUCCEEDED(MAPIAllocateBuffer(cbSize, lppBuffer)))
189  {
190  *lpBuff = ((LPMAPIALLOCBUFFER)*lppBuffer) - 1;
191  TRACE("linking %p->%p\n", lpBuff, *lpBuff);
192  }
193  return *lppBuffer ? S_OK : MAPI_E_NOT_ENOUGH_MEMORY;
194 }
195 
196 /**************************************************************************
197  * MAPIFreeBuffer (MAPI32.16)
198  * MAPIFreeBuffer@4 (MAPI32.17)
199  *
200  * Free a block of memory and any linked allocations associated with it.
201  *
202  * PARAMS
203  * lpBuffer [I] Memory to free, returned from MAPIAllocateBuffer()
204  *
205  * RETURNS
206  * S_OK.
207  */
209 {
210  LPMAPIALLOCBUFFER lpBuff = lpBuffer;
211 
212  TRACE("(%p)\n", lpBuffer);
213 
214  if (mapiFunctions.MAPIFreeBuffer)
215  return mapiFunctions.MAPIFreeBuffer(lpBuffer);
216 
217  if (lpBuff && --lpBuff)
218  {
219  while (lpBuff)
220  {
221  LPVOID lpFree = lpBuff;
222 
223  lpBuff = *lpBuff;
224 
225  TRACE("linked:%p->%p, freeing %p\n", lpFree, lpBuff, lpFree);
226  HeapFree(GetProcessHeap(), 0, lpFree);
227  }
228  }
229  return S_OK;
230 }
231 
232 /**************************************************************************
233  * WrapProgress@20 (MAPI32.41)
234  */
236 {
237  /* Native does not implement this function */
238  return MAPI_E_NO_SUPPORT;
239 }
240 
241 /*************************************************************************
242  * HrDispatchNotifications@4 (MAPI32.239)
243  */
245 {
246  FIXME("(%08x)\n", flags);
247  return S_OK;
248 }
249 
250 /*************************************************************************
251  * HrThisThreadAdviseSink@8 (MAPI32.42)
252  *
253  * Ensure that an advise sink is only notified in its originating thread.
254  *
255  * PARAMS
256  * lpSink [I] IMAPIAdviseSink interface to be protected
257  * lppNewSink [I] Destination for wrapper IMAPIAdviseSink interface
258  *
259  * RETURNS
260  * Success: S_OK. *lppNewSink contains a new sink to use in place of lpSink.
261  * Failure: E_INVALIDARG, if any parameter is invalid.
262  */
264 {
265  if (mapiFunctions.HrThisThreadAdviseSink)
266  return mapiFunctions.HrThisThreadAdviseSink(lpSink, lppNewSink);
267 
268  FIXME("(%p,%p)semi-stub\n", lpSink, lppNewSink);
269 
270  if (!lpSink || !lppNewSink)
271  return E_INVALIDARG;
272 
273  /* Don't wrap the sink for now, just copy it */
274  *lppNewSink = lpSink;
275  IMAPIAdviseSink_AddRef(lpSink);
276  return S_OK;
277 }
278 
279 /*************************************************************************
280  * FBinFromHex (MAPI32.44)
281  *
282  * Create an array of binary data from a string.
283  *
284  * PARAMS
285  * lpszHex [I] String to convert to binary data
286  * lpOut [O] Destination for resulting binary data
287  *
288  * RETURNS
289  * Success: TRUE. lpOut contains the decoded binary data.
290  * Failure: FALSE, if lpszHex does not represent a binary string.
291  *
292  * NOTES
293  * - lpOut must be at least half the length of lpszHex in bytes.
294  * - Although the Mapi headers prototype this function as both
295  * Ascii and Unicode, there is only one (Ascii) implementation. This
296  * means that lpszHex is treated as an Ascii string (i.e. a single NUL
297  * character in the byte stream terminates the string).
298  */
300 {
301  LPSTR lpStr = (LPSTR)lpszHex;
302 
303  TRACE("(%p,%p)\n", lpszHex, lpOut);
304 
305  while (*lpStr)
306  {
307  if (lpStr[0] < '0' || lpStr[0] > 'f' || digitsToHex[lpStr[0] - '0'] == 0xff ||
308  lpStr[1] < '0' || lpStr[1] > 'f' || digitsToHex[lpStr[1] - '0'] == 0xff)
309  return FALSE;
310 
311  *lpOut++ = (digitsToHex[lpStr[0] - '0'] << 4) | digitsToHex[lpStr[1] - '0'];
312  lpStr += 2;
313  }
314  return TRUE;
315 }
316 
317 /*************************************************************************
318  * HexFromBin (MAPI32.45)
319  *
320  * Create a string from an array of binary data.
321  *
322  * PARAMS
323  * lpHex [I] Binary data to convert to string
324  * iCount [I] Length of lpHex in bytes
325  * lpszOut [O] Destination for resulting hex string
326  *
327  * RETURNS
328  * Nothing.
329  *
330  * NOTES
331  * - lpszOut must be at least 2 * iCount + 1 bytes characters long.
332  * - Although the Mapi headers prototype this function as both
333  * Ascii and Unicode, there is only one (Ascii) implementation. This
334  * means that the resulting string is not properly NUL terminated
335  * if the caller expects it to be a Unicode string.
336  */
337 void WINAPI HexFromBin(LPBYTE lpHex, int iCount, LPWSTR lpszOut)
338 {
339  static const char hexDigits[] = { "0123456789ABCDEF" };
340  LPSTR lpStr = (LPSTR)lpszOut;
341 
342  TRACE("(%p,%d,%p)\n", lpHex, iCount, lpszOut);
343 
344  while (iCount-- > 0)
345  {
346  *lpStr++ = hexDigits[*lpHex >> 4];
347  *lpStr++ = hexDigits[*lpHex & 0xf];
348  lpHex++;
349  }
350  *lpStr = '\0';
351 }
352 
353 /*************************************************************************
354  * SwapPlong@8 (MAPI32.47)
355  *
356  * Swap the bytes in a ULONG array.
357  *
358  * PARAMS
359  * lpData [O] Array to swap bytes in
360  * ulLen [I] Number of ULONG element to swap the bytes of
361  *
362  * RETURNS
363  * Nothing.
364  */
366 {
367  ULONG i;
368 
369  for (i = 0; i < ulLen; i++)
370  lpData[i] = RtlUlongByteSwap(lpData[i]);
371 }
372 
373 /*************************************************************************
374  * SwapPword@8 (MAPI32.48)
375  *
376  * Swap the bytes in a USHORT array.
377  *
378  * PARAMS
379  * lpData [O] Array to swap bytes in
380  * ulLen [I] Number of USHORT element to swap the bytes of
381  *
382  * RETURNS
383  * Nothing.
384  */
386 {
387  ULONG i;
388 
389  for (i = 0; i < ulLen; i++)
390  lpData[i] = RtlUshortByteSwap(lpData[i]);
391 }
392 
393 /**************************************************************************
394  * MNLS_lstrlenW@4 (MAPI32.62)
395  *
396  * Calculate the length of a Unicode string.
397  *
398  * PARAMS
399  * lpszStr [I] String to calculate the length of
400  *
401  * RETURNS
402  * The length of lpszStr in Unicode characters.
403  */
405 {
406  TRACE("(%s)\n", debugstr_w(lpszStr));
407  return strlenW(lpszStr);
408 }
409 
410 /*************************************************************************
411  * MNLS_lstrcmpW@8 (MAPI32.63)
412  *
413  * Compare two Unicode strings.
414  *
415  * PARAMS
416  * lpszLeft [I] First string to compare
417  * lpszRight [I] Second string to compare
418  *
419  * RETURNS
420  * An integer less than, equal to or greater than 0, indicating that
421  * lpszLeft is less than, the same, or greater than lpszRight.
422  */
423 INT WINAPI MNLS_lstrcmpW(LPCWSTR lpszLeft, LPCWSTR lpszRight)
424 {
425  TRACE("(%s,%s)\n", debugstr_w(lpszLeft), debugstr_w(lpszRight));
426  return strcmpW(lpszLeft, lpszRight);
427 }
428 
429 /*************************************************************************
430  * MNLS_lstrcpyW@8 (MAPI32.64)
431  *
432  * Copy a Unicode string to another string.
433  *
434  * PARAMS
435  * lpszDest [O] Destination string
436  * lpszSrc [I] Source string
437  *
438  * RETURNS
439  * The length lpszDest in Unicode characters.
440  */
442 {
443  ULONG len;
444 
445  TRACE("(%p,%s)\n", lpszDest, debugstr_w(lpszSrc));
446  len = (strlenW(lpszSrc) + 1) * sizeof(WCHAR);
447  memcpy(lpszDest, lpszSrc, len);
448  return len;
449 }
450 
451 /*************************************************************************
452  * MNLS_CompareStringW@12 (MAPI32.65)
453  *
454  * Compare two Unicode strings.
455  *
456  * PARAMS
457  * dwCp [I] Code page for the comparison
458  * lpszLeft [I] First string to compare
459  * lpszRight [I] Second string to compare
460  *
461  * RETURNS
462  * CSTR_LESS_THAN, CSTR_EQUAL or CSTR_GREATER_THAN, indicating that
463  * lpszLeft is less than, the same, or greater than lpszRight.
464  */
465 INT WINAPI MNLS_CompareStringW(DWORD dwCp, LPCWSTR lpszLeft, LPCWSTR lpszRight)
466 {
467  INT ret;
468 
469  TRACE("0x%08x,%s,%s\n", dwCp, debugstr_w(lpszLeft), debugstr_w(lpszRight));
470  ret = MNLS_lstrcmpW(lpszLeft, lpszRight);
472 }
473 
474 /**************************************************************************
475  * FEqualNames@8 (MAPI32.72)
476  *
477  * Compare two Mapi names.
478  *
479  * PARAMS
480  * lpName1 [I] First name to compare to lpName2
481  * lpName2 [I] Second name to compare to lpName1
482  *
483  * RETURNS
484  * TRUE, if the names are the same,
485  * FALSE, Otherwise.
486  */
488 {
489  TRACE("(%p,%p)\n", lpName1, lpName2);
490 
491  if (!lpName1 || !lpName2 ||
492  !IsEqualGUID(lpName1->lpguid, lpName2->lpguid) ||
493  lpName1->ulKind != lpName2->ulKind)
494  return FALSE;
495 
496  if (lpName1->ulKind == MNID_STRING)
497  return !strcmpW(lpName1->Kind.lpwstrName, lpName2->Kind.lpwstrName);
498 
499  return lpName1->Kind.lID == lpName2->Kind.lID;
500 }
501 
502 /**************************************************************************
503  * IsBadBoundedStringPtr@8 (MAPI32.71)
504  *
505  * Determine if a string pointer is valid.
506  *
507  * PARAMS
508  * lpszStr [I] String to check
509  * ulLen [I] Maximum length of lpszStr
510  *
511  * RETURNS
512  * TRUE, if lpszStr is invalid or longer than ulLen,
513  * FALSE, otherwise.
514  */
516 {
517  if (!lpszStr || IsBadStringPtrA(lpszStr, -1) || strlen(lpszStr) >= ulLen)
518  return TRUE;
519  return FALSE;
520 }
521 
522 /**************************************************************************
523  * FtAddFt@16 (MAPI32.121)
524  *
525  * Add two FILETIME's together.
526  *
527  * PARAMS
528  * ftLeft [I] FILETIME to add to ftRight
529  * ftRight [I] FILETIME to add to ftLeft
530  *
531  * RETURNS
532  * The sum of ftLeft and ftRight
533  */
535 {
536  LONGLONG *pl = (LONGLONG*)&ftLeft, *pr = (LONGLONG*)&ftRight;
537 
538  return *pl + *pr;
539 }
540 
541 /**************************************************************************
542  * FtSubFt@16 (MAPI32.123)
543  *
544  * Subtract two FILETIME's together.
545  *
546  * PARAMS
547  * ftLeft [I] Initial FILETIME
548  * ftRight [I] FILETIME to subtract from ftLeft
549  *
550  * RETURNS
551  * The remainder after ftRight is subtracted from ftLeft.
552  */
554 {
555  LONGLONG *pl = (LONGLONG*)&ftLeft, *pr = (LONGLONG*)&ftRight;
556 
557  return *pr - *pl;
558 }
559 
560 /**************************************************************************
561  * FtMulDw@12 (MAPI32.124)
562  *
563  * Multiply a FILETIME by a DWORD.
564  *
565  * PARAMS
566  * dwLeft [I] DWORD to multiply with ftRight
567  * ftRight [I] FILETIME to multiply with dwLeft
568  *
569  * RETURNS
570  * The product of dwLeft and ftRight
571  */
573 {
574  LONGLONG *pr = (LONGLONG*)&ftRight;
575 
576  return (LONGLONG)dwLeft * (*pr);
577 }
578 
579 /**************************************************************************
580  * FtMulDwDw@8 (MAPI32.125)
581  *
582  * Multiply two DWORD, giving the result as a FILETIME.
583  *
584  * PARAMS
585  * dwLeft [I] DWORD to multiply with dwRight
586  * dwRight [I] DWORD to multiply with dwLeft
587  *
588  * RETURNS
589  * The product of ftMultiplier and ftMultiplicand as a FILETIME.
590  */
592 {
593  return (LONGLONG)dwLeft * (LONGLONG)dwRight;
594 }
595 
596 /**************************************************************************
597  * FtNegFt@8 (MAPI32.126)
598  *
599  * Negate a FILETIME.
600  *
601  * PARAMS
602  * ft [I] FILETIME to negate
603  *
604  * RETURNS
605  * The negation of ft.
606  */
608 {
609  LONGLONG *p = (LONGLONG*)&ft;
610 
611  return - *p;
612 }
613 
614 /**************************************************************************
615  * UlAddRef@4 (MAPI32.128)
616  *
617  * Add a reference to an object.
618  *
619  * PARAMS
620  * lpUnk [I] Object to add a reference to.
621  *
622  * RETURNS
623  * The new reference count of the object, or 0 if lpUnk is NULL.
624  *
625  * NOTES
626  * See IUnknown_AddRef.
627  */
628 ULONG WINAPI UlAddRef(void *lpUnk)
629 {
630  TRACE("(%p)\n", lpUnk);
631 
632  if (!lpUnk)
633  return 0UL;
634  return IUnknown_AddRef((LPUNKNOWN)lpUnk);
635 }
636 
637 /**************************************************************************
638  * UlRelease@4 (MAPI32.129)
639  *
640  * Remove a reference from an object.
641  *
642  * PARAMS
643  * lpUnk [I] Object to remove reference from.
644  *
645  * RETURNS
646  * The new reference count of the object, or 0 if lpUnk is NULL. If lpUnk is
647  * non-NULL and this function returns 0, the object pointed to by lpUnk has
648  * been released.
649  *
650  * NOTES
651  * See IUnknown_Release.
652  */
653 ULONG WINAPI UlRelease(void *lpUnk)
654 {
655  TRACE("(%p)\n", lpUnk);
656 
657  if (!lpUnk)
658  return 0UL;
659  return IUnknown_Release((LPUNKNOWN)lpUnk);
660 }
661 
662 /**************************************************************************
663  * UFromSz@4 (MAPI32.133)
664  *
665  * Read an integer from a string
666  *
667  * PARAMS
668  * lpszStr [I] String to read the integer from.
669  *
670  * RETURNS
671  * Success: The integer read from lpszStr.
672  * Failure: 0, if the first character in lpszStr is not 0-9.
673  *
674  * NOTES
675  * This function does not accept whitespace and stops at the first non-digit
676  * character.
677  */
679 {
680  ULONG ulRet = 0;
681 
682  TRACE("(%s)\n", debugstr_a(lpszStr));
683 
684  if (lpszStr)
685  {
686  while (*lpszStr >= '0' && *lpszStr <= '9')
687  {
688  ulRet = ulRet * 10 + (*lpszStr - '0');
689  lpszStr++;
690  }
691  }
692  return ulRet;
693 }
694 
695 /*************************************************************************
696  * OpenStreamOnFile@24 (MAPI32.147)
697  *
698  * Create a stream on a file.
699  *
700  * PARAMS
701  * lpAlloc [I] Memory allocation function
702  * lpFree [I] Memory free function
703  * ulFlags [I] Flags controlling the opening process
704  * lpszPath [I] Path of file to create stream on
705  * lpszPrefix [I] Prefix of the temporary file name (if ulFlags includes SOF_UNIQUEFILENAME)
706  * lppStream [O] Destination for created stream
707  *
708  * RETURNS
709  * Success: S_OK. lppStream contains the new stream object
710  * Failure: E_INVALIDARG if any parameter is invalid, or an HRESULT error code
711  * describing the error.
712  */
714  ULONG ulFlags, LPWSTR lpszPath, LPWSTR lpszPrefix,
715  LPSTREAM *lppStream)
716 {
717  WCHAR szBuff[MAX_PATH];
718  DWORD dwMode = STGM_READWRITE, dwAttributes = 0;
719  HRESULT hRet;
720 
721  TRACE("(%p,%p,0x%08x,%s,%s,%p)\n", lpAlloc, lpFree, ulFlags,
722  debugstr_a((LPSTR)lpszPath), debugstr_a((LPSTR)lpszPrefix), lppStream);
723 
724  if (mapiFunctions.OpenStreamOnFile)
725  return mapiFunctions.OpenStreamOnFile(lpAlloc, lpFree, ulFlags, lpszPath, lpszPrefix, lppStream);
726 
727  if (lppStream)
728  *lppStream = NULL;
729 
730  if (ulFlags & SOF_UNIQUEFILENAME)
731  {
732  FIXME("Should generate a temporary name\n");
733  return E_INVALIDARG;
734  }
735 
736  if (!lpszPath || !lppStream)
737  return E_INVALIDARG;
738 
739  /* FIXME: Should probably munge mode and attributes, and should handle
740  * Unicode arguments (I assume MAPI_UNICODE is set in ulFlags if
741  * we are being passed Unicode strings; MSDN doesn't say).
742  * This implementation is just enough for Outlook97 to start.
743  */
744  MultiByteToWideChar(CP_ACP, 0, (LPSTR)lpszPath, -1, szBuff, MAX_PATH);
745  hRet = SHCreateStreamOnFileEx(szBuff, dwMode, dwAttributes, TRUE,
746  NULL, lppStream);
747  return hRet;
748 }
749 
750 /*************************************************************************
751  * UlFromSzHex@4 (MAPI32.155)
752  *
753  * Read an integer from a hexadecimal string.
754  *
755  * PARAMS
756  * lpSzHex [I] String containing the hexadecimal number to read
757  *
758  * RETURNS
759  * Success: The number represented by lpszHex.
760  * Failure: 0, if lpszHex does not contain a hex string.
761  *
762  * NOTES
763  * This function does not accept whitespace and stops at the first non-hex
764  * character.
765  */
767 {
768  LPCSTR lpStr = (LPCSTR)lpszHex;
769  ULONG ulRet = 0;
770 
771  TRACE("(%s)\n", debugstr_a(lpStr));
772 
773  while (*lpStr)
774  {
775  if (lpStr[0] < '0' || lpStr[0] > 'f' || digitsToHex[lpStr[0] - '0'] == 0xff ||
776  lpStr[1] < '0' || lpStr[1] > 'f' || digitsToHex[lpStr[1] - '0'] == 0xff)
777  break;
778 
779  ulRet = ulRet * 16 + ((digitsToHex[lpStr[0] - '0'] << 4) | digitsToHex[lpStr[1] - '0']);
780  lpStr += 2;
781  }
782  return ulRet;
783 }
784 
785 /************************************************************************
786  * FBadEntryList@4 (MAPI32.190)
787  *
788  * Determine is an entry list is invalid.
789  *
790  * PARAMS
791  * lpEntryList [I] List to check
792  *
793  * RETURNS
794  * TRUE, if lpEntryList is invalid,
795  * FALSE, otherwise.
796  */
798 {
799  ULONG i;
800 
801  if (IsBadReadPtr(lpEntryList, sizeof(*lpEntryList)) ||
802  IsBadReadPtr(lpEntryList->lpbin,
803  lpEntryList->cValues * sizeof(*lpEntryList->lpbin)))
804  return TRUE;
805 
806  for (i = 0; i < lpEntryList->cValues; i++)
807  if(IsBadReadPtr(lpEntryList->lpbin[i].lpb, lpEntryList->lpbin[i].cb))
808  return TRUE;
809 
810  return FALSE;
811 }
812 
813 /*************************************************************************
814  * CbOfEncoded@4 (MAPI32.207)
815  *
816  * Return the length of an encoded string.
817  *
818  * PARAMS
819  * lpSzEnc [I] Encoded string to get the length of.
820  *
821  * RETURNS
822  * The length of the encoded string in bytes.
823  */
825 {
826  ULONG ulRet = 0;
827 
828  TRACE("(%s)\n", debugstr_a(lpszEnc));
829 
830  if (lpszEnc)
831  ulRet = (((strlen(lpszEnc) | 3) >> 2) + 1) * 3;
832  return ulRet;
833 }
834 
835 /*************************************************************************
836  * cmc_query_configuration (MAPI32.235)
837  *
838  * Retrieves the configuration information for the installed CMC
839  *
840  * PARAMS
841  * session [I] MAPI session handle
842  * item [I] Enumerated variable that identifies which
843  * configuration information is being requested
844  * reference [O] Buffer where configuration information is written
845  * config_extensions[I/O] Path of file to create stream on
846  *
847  * RETURNS
848  * A CMD define
849  */
851  CMC_session_id session,
852  CMC_enum item,
854  CMC_extension *config_extensions)
855 {
856  FIXME("stub\n");
857  return CMC_E_NOT_SUPPORTED;
858 }
859 
860 /**************************************************************************
861  * FGetComponentPath (MAPI32.254)
862  * FGetComponentPath@20 (MAPI32.255)
863  *
864  * Return the installed component path, usually to the private mapi32.dll.
865  *
866  * PARAMS
867  * component [I] Component ID
868  * qualifier [I] Application LCID
869  * dll_path [O] returned component path
870  * dll_path_length [I] component path length
871  * install [I] install mode
872  *
873  * RETURNS
874  * Success: TRUE.
875  * Failure: FALSE.
876  *
877  * NOTES
878  * Previously documented in Q229700 "How to locate the correct path
879  * to the Mapisvc.inf file in Microsoft Outlook".
880  */
882  DWORD dll_path_length, BOOL install)
883 {
884  BOOL ret = FALSE;
885  HMODULE hmsi;
886 
887  TRACE("%s %s %p %u %d\n", component, qualifier, dll_path, dll_path_length, install);
888 
889  if (mapiFunctions.FGetComponentPath)
890  return mapiFunctions.FGetComponentPath(component, qualifier, dll_path, dll_path_length, install);
891 
892  dll_path[0] = 0;
893 
894  hmsi = LoadLibraryA("msi.dll");
895  if (hmsi)
896  {
897  UINT (WINAPI *pMsiProvideQualifiedComponentA)(LPCSTR, LPCSTR, DWORD, LPSTR, LPDWORD);
898 
899  pMsiProvideQualifiedComponentA = (void *)GetProcAddress(hmsi, "MsiProvideQualifiedComponentA");
900  if (pMsiProvideQualifiedComponentA)
901  {
902  static const char * const fmt[] = { "%d\\NT", "%d\\95", "%d" };
903  char lcid_ver[20];
904  UINT i;
905 
906  for (i = 0; i < ARRAY_SIZE(fmt); i++)
907  {
908  /* FIXME: what's the correct behaviour here? */
909  if (!qualifier || qualifier == lcid_ver)
910  {
911  sprintf(lcid_ver, fmt[i], GetUserDefaultUILanguage());
912  qualifier = lcid_ver;
913  }
914 
915  if (pMsiProvideQualifiedComponentA(component, qualifier,
917  dll_path, &dll_path_length) == ERROR_SUCCESS)
918  {
919  ret = TRUE;
920  break;
921  }
922 
923  if (qualifier != lcid_ver) break;
924  }
925  }
926  FreeLibrary(hmsi);
927  }
928  return ret;
929 }
930 
931 /**************************************************************************
932  * HrQueryAllRows (MAPI32.75)
933  */
935  LPSRestriction lpRestriction, LPSSortOrderSet lpSortOrderSet,
936  LONG crowsMax, LPSRowSet *lppRows)
937 {
938  if (mapiFunctions.HrQueryAllRows)
939  return mapiFunctions.HrQueryAllRows(lpTable, lpPropTags, lpRestriction, lpSortOrderSet, crowsMax, lppRows);
940 
941  FIXME("(%p, %p, %p, %p, %d, %p): stub\n", lpTable, lpPropTags, lpRestriction, lpSortOrderSet, crowsMax, lppRows);
942  *lppRows = NULL;
943  return MAPI_E_CALL_FAILED;
944 }
945 
946 /**************************************************************************
947  * WrapCompressedRTFStream (MAPI32.186)
948  */
950 {
951  if (mapiFunctions.WrapCompressedRTFStream)
952  return mapiFunctions.WrapCompressedRTFStream(compressed, flags, uncompressed);
953 
954  FIXME("(%p, 0x%08x, %p): stub\n", compressed, flags, uncompressed);
955  return MAPI_E_NO_SUPPORT;
956 }
957 
960 
961 /**************************************************************************
962  * load_mapi_provider
963  *
964  * Attempts to load a MAPI provider from the specified registry key.
965  *
966  * Returns a handle to the loaded module in `mapi_provider' if successful.
967  */
968 static void load_mapi_provider(HKEY hkeyMail, LPCWSTR valueName, HMODULE *mapi_provider)
969 {
970  static const WCHAR mapi32_dll[] = {'m','a','p','i','3','2','.','d','l','l',0 };
971 
972  DWORD dwType, dwLen = 0;
973  LPWSTR dllPath;
974 
975  /* Check if we have a value set for DLLPath */
976  if ((RegQueryValueExW(hkeyMail, valueName, NULL, &dwType, NULL, &dwLen) == ERROR_SUCCESS) &&
977  ((dwType == REG_SZ) || (dwType == REG_EXPAND_SZ)) && (dwLen > 0))
978  {
979  dllPath = HeapAlloc(GetProcessHeap(), 0, dwLen);
980 
981  if (dllPath)
982  {
983  RegQueryValueExW(hkeyMail, valueName, NULL, NULL, (LPBYTE)dllPath, &dwLen);
984 
985  /* Check that this value doesn't refer to mapi32.dll (eg, as Outlook does) */
986  if (lstrcmpiW(dllPath, mapi32_dll) != 0)
987  {
988  if (dwType == REG_EXPAND_SZ)
989  {
990  DWORD dwExpandLen;
991  LPWSTR dllPathExpanded;
992 
993  /* Expand the path if necessary */
994  dwExpandLen = ExpandEnvironmentStringsW(dllPath, NULL, 0);
995  dllPathExpanded = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * dwExpandLen + 1);
996 
997  if (dllPathExpanded)
998  {
999  ExpandEnvironmentStringsW(dllPath, dllPathExpanded, dwExpandLen + 1);
1000 
1001  HeapFree(GetProcessHeap(), 0, dllPath);
1002  dllPath = dllPathExpanded;
1003  }
1004  }
1005 
1006  /* Load the DLL */
1007  TRACE("loading %s\n", debugstr_w(dllPath));
1008  *mapi_provider = LoadLibraryW(dllPath);
1009  }
1010 
1011  HeapFree(GetProcessHeap(), 0, dllPath);
1012  }
1013  }
1014 }
1015 
1016 /**************************************************************************
1017  * load_mapi_providers
1018  *
1019  * Scans the registry for MAPI providers and attempts to load a Simple and
1020  * Extended MAPI library.
1021  *
1022  * Returns TRUE if at least one library loaded, FALSE otherwise.
1023  */
1025 {
1026  static const WCHAR regkey_mail[] = {
1027  'S','o','f','t','w','a','r','e','\\','C','l','i','e','n','t','s','\\',
1028  'M','a','i','l',0 };
1029 
1030  static const WCHAR regkey_dllpath[] = {'D','L','L','P','a','t','h',0 };
1031  static const WCHAR regkey_dllpath_ex[] = {'D','L','L','P','a','t','h','E','x',0 };
1032  static const WCHAR regkey_backslash[] = { '\\', 0 };
1033 
1034  HKEY hkeyMail;
1035  DWORD dwType, dwLen = 0;
1036  LPWSTR appName = NULL, appKey = NULL;
1037 
1038  TRACE("()\n");
1039 
1040  /* Open the Mail key */
1041  if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, regkey_mail, 0, KEY_READ, &hkeyMail) != ERROR_SUCCESS)
1042  return;
1043 
1044  /* Check if we have a default value set, and the length of it */
1045  if ((RegQueryValueExW(hkeyMail, NULL, NULL, &dwType, NULL, &dwLen) != ERROR_SUCCESS) ||
1046  !((dwType == REG_SZ) || (dwType == REG_EXPAND_SZ)) || (dwLen == 0))
1047  goto cleanUp;
1048 
1049  appName = HeapAlloc(GetProcessHeap(), 0, dwLen);
1050 
1051  if (!appName)
1052  goto cleanUp;
1053 
1054  /* Get the value, and get the path to the app key */
1055  RegQueryValueExW(hkeyMail, NULL, NULL, NULL, (LPBYTE)appName, &dwLen);
1056 
1057  TRACE("appName: %s\n", debugstr_w(appName));
1058 
1059  appKey = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * (lstrlenW(regkey_mail) +
1060  lstrlenW(regkey_backslash) + lstrlenW(appName) + 1));
1061 
1062  if (!appKey)
1063  goto cleanUp;
1064 
1065  lstrcpyW(appKey, regkey_mail);
1066  lstrcatW(appKey, regkey_backslash);
1067  lstrcatW(appKey, appName);
1068 
1069  RegCloseKey(hkeyMail);
1070 
1071  TRACE("appKey: %s\n", debugstr_w(appKey));
1072 
1073  /* Open the app's key */
1074  if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, appKey, 0, KEY_READ, &hkeyMail) != ERROR_SUCCESS)
1075  goto cleanUp;
1076 
1077  /* Try to load the providers */
1078  load_mapi_provider(hkeyMail, regkey_dllpath, &mapi_provider);
1079  load_mapi_provider(hkeyMail, regkey_dllpath_ex, &mapi_ex_provider);
1080 
1081  /* Now try to load our function pointers */
1083 
1084  /* Simple MAPI functions */
1085  if (mapi_provider)
1086  {
1087  mapiFunctions.MAPIAddress = (void*) GetProcAddress(mapi_provider, "MAPIAddress");
1088  mapiFunctions.MAPIDeleteMail = (void*) GetProcAddress(mapi_provider, "MAPIDeleteMail");
1089  mapiFunctions.MAPIDetails = (void*) GetProcAddress(mapi_provider, "MAPIDetails");
1090  mapiFunctions.MAPIFindNext = (void*) GetProcAddress(mapi_provider, "MAPIFindNext");
1091  mapiFunctions.MAPILogoff = (void*) GetProcAddress(mapi_provider, "MAPILogoff");
1092  mapiFunctions.MAPILogon = (void*) GetProcAddress(mapi_provider, "MAPILogon");
1093  mapiFunctions.MAPIReadMail = (void*) GetProcAddress(mapi_provider, "MAPIReadMail");
1094  mapiFunctions.MAPIResolveName = (void*) GetProcAddress(mapi_provider, "MAPIResolveName");
1095  mapiFunctions.MAPISaveMail = (void*) GetProcAddress(mapi_provider, "MAPISaveMail");
1096  mapiFunctions.MAPISendDocuments = (void*) GetProcAddress(mapi_provider, "MAPISendDocuments");
1097  mapiFunctions.MAPISendMail = (void*) GetProcAddress(mapi_provider, "MAPISendMail");
1098  mapiFunctions.MAPISendMailW = (void*) GetProcAddress(mapi_provider, "MAPISendMailW");
1099  }
1100 
1101  /* Extended MAPI functions */
1102  if (mapi_ex_provider)
1103  {
1104  mapiFunctions.MAPIInitialize = (void*) GetProcAddress(mapi_ex_provider, "MAPIInitialize");
1105  mapiFunctions.MAPILogonEx = (void*) GetProcAddress(mapi_ex_provider, "MAPILogonEx");
1106  mapiFunctions.MAPIUninitialize = (void*) GetProcAddress(mapi_ex_provider, "MAPIUninitialize");
1107 
1108  mapiFunctions.DeinitMapiUtil = (void*) GetProcAddress(mapi_ex_provider, "DeinitMapiUtil@0");
1109  mapiFunctions.DllCanUnloadNow = (void*) GetProcAddress(mapi_ex_provider, "DllCanUnloadNow");
1110  mapiFunctions.DllGetClassObject = (void*) GetProcAddress(mapi_ex_provider, "DllGetClassObject");
1111  mapiFunctions.FGetComponentPath = (void*) GetProcAddress(mapi_ex_provider, "FGetComponentPath");
1112  mapiFunctions.HrThisThreadAdviseSink = (void*) GetProcAddress(mapi_ex_provider, "HrThisThreadAdviseSink@8");
1113  mapiFunctions.HrQueryAllRows = (void*) GetProcAddress(mapi_ex_provider, "HrQueryAllRows@24");
1114  mapiFunctions.MAPIAdminProfiles = (void*) GetProcAddress(mapi_ex_provider, "MAPIAdminProfiles");
1115  mapiFunctions.MAPIAllocateBuffer = (void*) GetProcAddress(mapi_ex_provider, "MAPIAllocateBuffer");
1116  mapiFunctions.MAPIAllocateMore = (void*) GetProcAddress(mapi_ex_provider, "MAPIAllocateMore");
1117  mapiFunctions.MAPIFreeBuffer = (void*) GetProcAddress(mapi_ex_provider, "MAPIFreeBuffer");
1118  mapiFunctions.MAPIGetDefaultMalloc = (void*) GetProcAddress(mapi_ex_provider, "MAPIGetDefaultMalloc@0");
1119  mapiFunctions.MAPIOpenLocalFormContainer = (void *) GetProcAddress(mapi_ex_provider, "MAPIOpenLocalFormContainer");
1120  mapiFunctions.OpenStreamOnFile = (void*) GetProcAddress(mapi_ex_provider, "OpenStreamOnFile@24");
1121  mapiFunctions.ScInitMapiUtil = (void*) GetProcAddress(mapi_ex_provider, "ScInitMapiUtil@4");
1122  mapiFunctions.WrapCompressedRTFStream = (void*) GetProcAddress(mapi_ex_provider, "WrapCompressedRTFStream@12");
1123  }
1124 
1125 cleanUp:
1126  RegCloseKey(hkeyMail);
1127  HeapFree(GetProcessHeap(), 0, appKey);
1129 }
1130 
1131 /**************************************************************************
1132  * unload_mapi_providers
1133  *
1134  * Unloads any loaded MAPI libraries.
1135  */
1137 {
1138  TRACE("()\n");
1139 
1142 }
LPMAPIDETAILS MAPIDetails
Definition: util.h:34
ULONG WINAPI UlRelease(void *lpUnk)
Definition: util.c:653
LANGID WINAPI GetUserDefaultUILanguage(void)
Definition: lang.c:803
WINE_DEFAULT_DEBUG_CHANNEL(d3dx)
#define TRUE
Definition: types.h:120
static AsnOctetString UINT
Definition: util.c:31
#define CSTR_GREATER_THAN
Definition: winnls.h:454
WINE_UNICODE_INLINE unsigned int strlenW(const WCHAR *str)
Definition: unicode.h:212
#define ERROR_SUCCESS
Definition: deptool.c:10
LONGLONG WINAPI MAPI32_FtMulDwDw(DWORD dwLeft, DWORD dwRight)
Definition: util.c:591
INT WINAPI MNLS_lstrcmpW(LPCWSTR lpszLeft, LPCWSTR lpszRight)
Definition: util.c:423
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
LONGLONG WINAPI MAPI32_FtMulDw(DWORD dwLeft, FILETIME ftRight)
Definition: util.c:572
int install
Definition: msacm.c:1353
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define KEY_READ
Definition: nt_native.h:1023
ULONG cValues
Definition: mapidefs.h:296
#define RtlUshortByteSwap(_x)
Definition: rtlfuncs.h:3199
INT WINAPI MNLS_CompareStringW(DWORD dwCp, LPCWSTR lpszLeft, LPCWSTR lpszRight)
Definition: util.c:465
ULONG WINAPI MAPIFreeBuffer(LPVOID lpBuffer)
Definition: util.c:208
#define CP_ACP
Definition: compat.h:99
LPMAPIRESOLVENAME MAPIResolveName
Definition: util.h:41
HRESULT WINAPI HrDispatchNotifications(ULONG flags)
Definition: util.c:244
BOOL WINAPI FGetComponentPath(LPCSTR component, LPCSTR qualifier, LPSTR dll_path, DWORD dll_path_length, BOOL install)
Definition: util.c:881
IMAPITable * LPMAPITABLE
Definition: mapidefs.h:840
LONGLONG WINAPI MAPI32_FtNegFt(FILETIME ft)
Definition: util.c:607
ULONG cb
Definition: mapidefs.h:289
BOOL WINAPI FEqualNames(LPMAPINAMEID lpName1, LPMAPINAMEID lpName2)
Definition: util.c:487
LPMAPIADDRESS MAPIAddress
Definition: util.h:32
#define ZeroMemory
Definition: winbase.h:1635
#define IMAPIAdviseSink_AddRef(p)
Definition: mapidefs.h:860
ULONG WINAPI MNLS_lstrcpyW(LPWSTR lpszDest, LPCWSTR lpszSrc)
Definition: util.c:441
#define MAPI_E_NOT_ENOUGH_MEMORY
Definition: mapicode.h:74
interface IStream * LPSTREAM
Definition: objfwd.h:10
BOOL WINAPI IsBadBoundedStringPtr(LPCSTR lpszStr, ULONG ulLen)
Definition: util.c:515
SBinary * lpbin
Definition: mapidefs.h:297
char * LPSTR
Definition: xmlstorage.h:182
#define lstrlenW
Definition: compat.h:407
VOID WINAPI SwapPword(PUSHORT lpData, ULONG ulLen)
Definition: util.c:385
#define DWORD
Definition: nt_native.h:44
int32_t INT
Definition: typedefs.h:56
#define CMC_E_NOT_SUPPORTED
Definition: xcmc.h:67
LONGLONG WINAPI MAPI32_FtSubFt(FILETIME ftLeft, FILETIME ftRight)
Definition: util.c:553
DWORD dwAttributes
Definition: vdmdbg.h:34
static const BYTE uncompressed[]
Definition: misc.c:392
int WINAPI lstrcmpiW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:194
HRESULT WINAPI WrapProgress(PVOID unk1, PVOID unk2, PVOID unk3, PVOID unk4, PVOID unk5)
Definition: util.c:235
#define MAPI_E_NO_SUPPORT
Definition: mapicode.h:71
CMC_uint32 CMC_session_id
Definition: xcmc.h:39
#define sprintf(buf, format,...)
Definition: sprintf.c:55
static DWORD unk1
Definition: cursoricon.c:1521
UINT WINAPI UFromSz(LPCSTR lpszStr)
Definition: util.c:678
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
LPMAPILOGONEX MAPILogonEx
Definition: util.h:39
unsigned char * LPBYTE
Definition: typedefs.h:52
static const CHAR hexDigits[]
Definition: url.c:109
BOOL WINAPI FBinFromHex(LPWSTR lpszHex, LPBYTE lpOut)
Definition: util.c:299
unsigned int BOOL
Definition: ntddk_ex.h:94
LONGLONG WINAPI MAPI32_FtAddFt(FILETIME ftLeft, FILETIME ftRight)
Definition: util.c:534
long LONG
Definition: pedump.c:60
static LPUNKNOWN
Definition: ndr_ole.c:49
#define debugstr_w
Definition: kernel32.h:32
HINSTANCE WINAPI DECLSPEC_HOTPATCH LoadLibraryA(LPCSTR lpLibFileName)
Definition: loader.c:111
#define FIXME(fmt,...)
Definition: debug.h:110
static HMODULE mapi_ex_provider
Definition: util.c:959
static TAGREF LPCWSTR LPDWORD LPVOID lpBuffer
Definition: db.cpp:173
ULONG ulKind
Definition: mapidefs.h:643
LONG SCODE
Definition: compat.h:1886
#define E_INVALIDARG
Definition: ddrawi.h:101
LPMAPISENDDOCUMENTS MAPISendDocuments
Definition: util.h:45
#define LoadLibraryW(x)
Definition: compat.h:404
smooth NULL
Definition: ftsmooth.c:416
static APTTYPEQUALIFIER * qualifier
Definition: compobj.c:74
CMC_sint32 CMC_enum
Definition: xcmc.h:35
LPMAPISENDMAIL MAPISendMail
Definition: util.h:43
WCHAR lpszDest[260]
BOOL WINAPI FBadEntryList(LPENTRYLIST lpEntryList)
Definition: util.c:797
LPMAPIREADMAIL MAPIReadMail
Definition: util.h:40
#define MAPI_E_INVALID_PARAMETER
Definition: mapicode.h:62
const char * LPCSTR
Definition: xmlstorage.h:183
struct IMAPIAdviseSink * LPMAPIADVISESINK
Definition: mapidefs.h:92
void WINAPI HexFromBin(LPBYTE lpHex, int iCount, LPWSTR lpszOut)
Definition: util.c:337
LPGUID lpguid
Definition: mapidefs.h:642
LPMAPIDELETEMAIL MAPIDeleteMail
Definition: util.h:33
LPMAPIUNINITIALIZE MAPIUninitialize
Definition: util.h:46
int64_t LONGLONG
Definition: typedefs.h:66
CMC_uint32 CMC_return_code
Definition: xcmc.h:36
#define TRACE(s)
Definition: solgame.cpp:4
#define FreeLibrary(x)
Definition: compat.h:405
HRESULT WINAPI HrThisThreadAdviseSink(LPMAPIADVISESINK lpSink, LPMAPIADVISESINK *lppNewSink)
Definition: util.c:263
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4134
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define debugstr_a
Definition: kernel32.h:31
LONG HRESULT
Definition: typedefs.h:77
ULONG WINAPI CbOfEncoded(LPCSTR lpszEnc)
Definition: util.c:824
_In_ SURFOBJ _In_ CLIPOBJ _In_opt_ XLATEOBJ _In_ RECTL _In_ RECTL _In_ ULONG _In_ ULONG ulReserved
Definition: winddi.h:4190
HRESULT WINAPI HrQueryAllRows(LPMAPITABLE lpTable, LPSPropTagArray lpPropTags, LPSRestriction lpRestriction, LPSSortOrderSet lpSortOrderSet, LONG crowsMax, LPSRowSet *lppRows)
Definition: util.c:934
#define MAX_PATH
Definition: compat.h:26
ALLOCATEBUFFER * LPALLOCATEBUFFER
Definition: mapidefs.h:76
#define WINAPI
Definition: msvc.h:8
SCODE WINAPI MAPIAllocateBuffer(ULONG cbSize, LPVOID *lppBuffer)
Definition: util.c:126
unsigned long DWORD
Definition: ntddk_ex.h:95
LPMAPISAVEMAIL MAPISaveMail
Definition: util.h:42
SCODE WINAPI ScInitMapiUtil(ULONG ulReserved)
Definition: util.c:68
HRESULT WINAPI SHCreateStreamOnFileEx(LPCWSTR lpszPath, DWORD dwMode, DWORD dwAttributes, BOOL bCreate, IStream *lpTemplate, IStream **lppStream)
Definition: istream.c:401
GLbitfield flags
Definition: glext.h:7161
LONG lID
Definition: mapidefs.h:646
LPMAPIFINDNEXT MAPIFindNext
Definition: util.h:35
int ret
#define LPDWORD
Definition: nt_native.h:46
GLint reference
Definition: glext.h:11729
LPMAPILOGON MAPILogon
Definition: util.h:38
static const BYTE digitsToHex[]
Definition: util.c:44
MAPI_FUNCTIONS mapiFunctions
Definition: util.c:50
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum GLsizei len
Definition: glext.h:6722
unsigned char BYTE
Definition: mem.h:68
void load_mapi_providers(void)
Definition: util.c:1024
#define CSTR_EQUAL
Definition: winnls.h:453
LPBYTE lpb
Definition: mapidefs.h:290
void unload_mapi_providers(void)
Definition: util.c:1136
#define RtlUlongByteSwap(_x)
Definition: compat.h:465
#define STGM_READWRITE
Definition: objbase.h:918
LPWSTR lpwstrName
Definition: mapidefs.h:647
VOID WINAPI SwapPlong(PULONG lpData, ULONG ulLen)
Definition: util.c:365
static HMODULE mapi_provider
Definition: util.c:958
#define S_OK
Definition: intsafe.h:59
HRESULT WINAPI WrapCompressedRTFStream(LPSTREAM compressed, ULONG flags, LPSTREAM *uncompressed)
Definition: util.c:949
ULONG WINAPI MNLS_lstrlenW(LPCWSTR lpszStr)
Definition: util.c:404
#define MAPI_E_CALL_FAILED
Definition: mapicode.h:43
BOOL NTAPI IsBadStringPtrA(IN LPCSTR lpsz, IN UINT_PTR ucchMax)
Definition: except.c:991
static ATOM item
Definition: dde.c:856
#define lstrcpyW
Definition: compat.h:406
#define ARRAY_SIZE(a)
Definition: main.h:24
#define REG_EXPAND_SZ
Definition: nt_native.h:1494
ULONG WINAPI UlFromSzHex(LPCWSTR lpszHex)
Definition: util.c:766
#define CSTR_LESS_THAN
Definition: winnls.h:452
BOOL WINAPI IsBadReadPtr(IN LPCVOID lp, IN UINT_PTR ucb)
Definition: except.c:807
unsigned int * PULONG
Definition: retypes.h:1
unsigned int UINT
Definition: ndis.h:50
BOOL WINAPI IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
Definition: compobj.c:4021
DWORD WINAPI ExpandEnvironmentStringsW(IN LPCWSTR lpSrc, IN LPWSTR lpDst, IN DWORD nSize)
Definition: environ.c:519
#define MultiByteToWideChar
Definition: compat.h:100
VOID WINAPI DeinitMapiUtil(void)
Definition: util.c:94
LPMAPILOGOFF MAPILogoff
Definition: util.h:37
WINE_UNICODE_INLINE int strcmpW(const WCHAR *str1, const WCHAR *str2)
Definition: unicode.h:229
static void load_mapi_provider(HKEY hkeyMail, LPCWSTR valueName, HMODULE *mapi_provider)
Definition: util.c:968
unsigned int ULONG
Definition: retypes.h:1
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3381
const char * appName(const char *argv0)
Definition: loadlib.c:89
#define GetProcAddress(x, y)
Definition: compat.h:410
#define SOF_UNIQUEFILENAME
Definition: mapiutil.h:32
FREEBUFFER * LPFREEBUFFER
Definition: mapidefs.h:78
CMC_return_code WINAPI cmc_query_configuration(CMC_session_id session, CMC_enum item, CMC_buffer reference, CMC_extension *config_extensions)
Definition: util.c:850
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274
LPMAPIINITIALIZE MAPIInitialize
Definition: util.h:36
GLfloat GLfloat p
Definition: glext.h:8902
WCHAR * LPWSTR
Definition: xmlstorage.h:184
union _MAPINAMEID::@2899 Kind
#define MNID_STRING
Definition: mapidefs.h:638
LPVOID * LPMAPIALLOCBUFFER
Definition: util.c:102
void cleanUp()
Definition: main.cpp:472
ULONG WINAPI UlAddRef(void *lpUnk)
Definition: util.c:628
LPMAPISENDMAILW MAPISendMailW
Definition: util.h:44
#define UL
Definition: tui.h:70
SCODE WINAPI MAPIAllocateMore(ULONG cbSize, LPVOID lpOrig, LPVOID *lppBuffer)
Definition: util.c:169
Definition: dsound.c:943
#define HeapFree(x, y, z)
Definition: compat.h:394
unsigned short * PUSHORT
Definition: retypes.h:2
#define SUCCEEDED(hr)
Definition: intsafe.h:57
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
HRESULT WINAPI OpenStreamOnFile(LPALLOCATEBUFFER lpAlloc, LPFREEBUFFER lpFree, ULONG ulFlags, LPWSTR lpszPath, LPWSTR lpszPrefix, LPSTREAM *lppStream)
Definition: util.c:713
#define REG_SZ
Definition: layer.c:22