dlls/oleaut32/oleaut.c

   1 /*
   2  *      OLEAUT32
   3  *
   4  * Copyright 1999, 2000 Marcus Meissner
   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 #include <assert.h>
  22 #include <stdarg.h>
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <limits.h>
  26
  27 #define COBJMACROS
  28
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "wingdi.h"
  32 #include "winuser.h"
  33 #include "winerror.h"
  34
  35 #include "ole2.h"
  36 #include "olectl.h"
  37 #include "oleauto.h"
  38 #include "rpcproxy.h"
  39 #include "initguid.h"
  40 #include "typelib.h"
  41 #include "oleaut32_oaidl.h"
  42
  43 #include "wine/debug.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  46 WINE_DECLARE_DEBUG_CHANNEL(heap);
  47
  48 /******************************************************************************
  49  * BSTR  {OLEAUT32}
  50  *
  51  * NOTES
  52  *  BSTR is a simple typedef for a wide-character string used as the principle
  53  *  string type in ole automation. When encapsulated in a Variant type they are
  54  *  automatically copied and destroyed as the variant is processed.
  55  *
  56  *  The low level BSTR API allows manipulation of these strings and is used by
  57  *  higher level API calls to manage the strings transparently to the caller.
  58  *
  59  *  Internally the BSTR type is allocated with space for a DWORD byte count before
  60  *  the string data begins. This is undocumented and non-system code should not
  61  *  access the count directly. Use SysStringLen() or SysStringByteLen()
  62  *  instead. Note that the byte count does not include the terminating NUL.
  63  *
  64  *  To create a new BSTR, use SysAllocString(), SysAllocStringLen() or
  65  *  SysAllocStringByteLen(). To change the size of an existing BSTR, use SysReAllocString()
  66  *  or SysReAllocStringLen(). Finally to destroy a string use SysFreeString().
  67  *
  68  *  BSTR's are cached by Ole Automation by default. To override this behaviour
  69  *  either set the environment variable 'OANOCACHE', or call SetOaNoCache().
  70  *
  71  * SEE ALSO
  72  *  'Inside OLE, second edition' by Kraig Brockshmidt.
  73  */
  74
  75 static BOOL bstr_cache_enabled;
  76
  77 static CRITICAL_SECTION cs_bstr_cache;
  78 static CRITICAL_SECTION_DEBUG cs_bstr_cache_dbg =
  79 {
  80     0, 0, &cs_bstr_cache,
  81     { &cs_bstr_cache_dbg.ProcessLocksList, &cs_bstr_cache_dbg.ProcessLocksList },
  82       0, 0, { (DWORD_PTR)(__FILE__ ": bstr_cache") }
  83 };
  84 static CRITICAL_SECTION cs_bstr_cache = { &cs_bstr_cache_dbg, -1, 0, 0, 0, 0 };
  85
  86 typedef struct {
  87 #ifdef _WIN64
  88     DWORD pad;
  89 #endif
  90     DWORD size;
  91     union {
  92         char ptr[1];
  93         WCHAR str[1];
  94         DWORD dwptr[1];
  95     } u;
  96 } bstr_t;
  97
  98 #define BUCKET_SIZE 16
  99 #define BUCKET_BUFFER_SIZE 6
 100
 101 typedef struct {
 102     unsigned short head;
 103     unsigned short cnt;
 104     bstr_t *buf[BUCKET_BUFFER_SIZE];
 105 } bstr_cache_entry_t;
 106
 107 #define ARENA_INUSE_FILLER     0x55
 108 #define ARENA_TAIL_FILLER      0xab
 109 #define ARENA_FREE_FILLER      0xfeeefeee
 110
 111 static bstr_cache_entry_t bstr_cache[0x10000/BUCKET_SIZE];
 112
 113 static inline size_t bstr_alloc_size(size_t size)
 114 {
 115     return (FIELD_OFFSET(bstr_t, u.ptr[size]) + sizeof(WCHAR) + BUCKET_SIZE-1) & ~(BUCKET_SIZE-1);
 116 }
 117
 118 static inline bstr_t *bstr_from_str(BSTR str)
 119 {
 120     return CONTAINING_RECORD(str, bstr_t, u.str);
 121 }
 122
 123 static inline bstr_cache_entry_t *get_cache_entry_from_idx(unsigned cache_idx)
 124 {
 125     return bstr_cache_enabled && cache_idx < ARRAY_SIZE(bstr_cache) ? bstr_cache + cache_idx : NULL;
 126 }
 127
 128 static inline bstr_cache_entry_t *get_cache_entry(size_t size)
 129 {
 130     unsigned cache_idx = FIELD_OFFSET(bstr_t, u.ptr[size+sizeof(WCHAR)-1])/BUCKET_SIZE;
 131     return get_cache_entry_from_idx(cache_idx);
 132 }
 133
 134 static inline bstr_cache_entry_t *get_cache_entry_from_alloc_size(SIZE_T alloc_size)
 135 {
 136     unsigned cache_idx;
 137     if (alloc_size < BUCKET_SIZE) return NULL;
 138     cache_idx = (alloc_size - BUCKET_SIZE) / BUCKET_SIZE;
 139     return get_cache_entry_from_idx(cache_idx);
 140 }
 141
 142 static bstr_t *alloc_bstr(size_t size)
 143 {
 144     bstr_cache_entry_t *cache_entry = get_cache_entry(size);
 145     bstr_t *ret;
 146
 147     if(cache_entry) {
 148         EnterCriticalSection(&cs_bstr_cache);
 149
 150         if(!cache_entry->cnt) {
 151             cache_entry = get_cache_entry(size+BUCKET_SIZE);
 152             if(cache_entry && !cache_entry->cnt)
 153                 cache_entry = NULL;
 154         }
 155
 156         if(cache_entry) {
 157             ret = cache_entry->buf[cache_entry->head++];
 158             cache_entry->head %= BUCKET_BUFFER_SIZE;
 159             cache_entry->cnt--;
 160         }
 161
 162         LeaveCriticalSection(&cs_bstr_cache);
 163
 164         if(cache_entry) {
 165             if(WARN_ON(heap)) {
 166                 size_t fill_size = (FIELD_OFFSET(bstr_t, u.ptr[size])+2*sizeof(WCHAR)-1) & ~(sizeof(WCHAR)-1);
 167                 memset(ret, ARENA_INUSE_FILLER, fill_size);
 168                 memset((char *)ret+fill_size, ARENA_TAIL_FILLER, bstr_alloc_size(size)-fill_size);
 169             }
 170             ret->size = size;
 171             return ret;
 172         }
 173     }
 174
 175     ret = CoTaskMemAlloc(bstr_alloc_size(size));
 176     if(ret)
 177         ret->size = size;
 178     return ret;
 179 }
 180
 181 /******************************************************************************
 182  *             SysStringLen  [OLEAUT32.7]
 183  *
 184  * Get the allocated length of a BSTR in wide characters.
 185  *
 186  * PARAMS
 187  *  str [I] BSTR to find the length of
 188  *
 189  * RETURNS
 190  *  The allocated length of str, or 0 if str is NULL.
 191  *
 192  * NOTES
 193  *  See BSTR.
 194  *  The returned length may be different from the length of the string as
 195  *  calculated by lstrlenW(), since it returns the length that was used to
 196  *  allocate the string by SysAllocStringLen().
 197  */
 198 UINT WINAPI SysStringLen(BSTR str)
 199 {
 200     return str ? bstr_from_str(str)->size/sizeof(WCHAR) : 0;
 201 }
 202
 203 /******************************************************************************
 204  *             SysStringByteLen  [OLEAUT32.149]
 205  *
 206  * Get the allocated length of a BSTR in bytes.
 207  *
 208  * PARAMS
 209  *  str [I] BSTR to find the length of
 210  *
 211  * RETURNS
 212  *  The allocated length of str, or 0 if str is NULL.
 213  *
 214  * NOTES
 215  *  See SysStringLen(), BSTR().
 216  */
 217 UINT WINAPI SysStringByteLen(BSTR str)
 218 {
 219     return str ? bstr_from_str(str)->size : 0;
 220 }
 221
 222 /******************************************************************************
 223  *              SysAllocString  [OLEAUT32.2]
 224  *
 225  * Create a BSTR from an OLESTR.
 226  *
 227  * PARAMS
 228  *  str [I] Source to create BSTR from
 229  *
 230  * RETURNS
 231  *  Success: A BSTR allocated with SysAllocStringLen().
 232  *  Failure: NULL, if oleStr is NULL.
 233  *
 234  * NOTES
 235  *  See BSTR.
 236  *  MSDN (October 2001) incorrectly states that NULL is returned if oleStr has
 237  *  a length of 0. Native Win32 and this implementation both return a valid
 238  *  empty BSTR in this case.
 239  */
 240 BSTR WINAPI SysAllocString(LPCOLESTR str)
 241 {
 242     if (!str) return 0;
 243
 244     /* Delegate this to the SysAllocStringLen32 method. */
 245     return SysAllocStringLen(str, lstrlenW(str));
 246 }
 247
 248 static inline IMalloc *get_malloc(void)
 249 {
 250     static IMalloc *malloc;
 251
 252     if (!malloc)
 253         CoGetMalloc(1, &malloc);
 254
 255     return malloc;
 256 }
 257
 258 /******************************************************************************
 259  *              SysFreeString   [OLEAUT32.6]
 260  *
 261  * Free a BSTR.
 262  *
 263  * PARAMS
 264  *  str [I] BSTR to free.
 265  *
 266  * RETURNS
 267  *  Nothing.
 268  *
 269  * NOTES
 270  *  See BSTR.
 271  *  str may be NULL, in which case this function does nothing.
 272  */
 273 void WINAPI DECLSPEC_HOTPATCH SysFreeString(BSTR str)
 274 {
 275     bstr_cache_entry_t *cache_entry;
 276     bstr_t *bstr;
 277     IMalloc *malloc = get_malloc();
 278     SIZE_T alloc_size;
 279
 280     if(!str)
 281         return;
 282
 283     bstr = bstr_from_str(str);
 284
 285     alloc_size = IMalloc_GetSize(malloc, bstr);
 286     if (alloc_size == ~0UL)
 287         return;
 288
 289     cache_entry = get_cache_entry_from_alloc_size(alloc_size);
 290     if(cache_entry) {
 291         unsigned i;
 292
 293         EnterCriticalSection(&cs_bstr_cache);
 294
 295         /* According to tests, freeing a string that's already in cache doesn't corrupt anything.
 296          * For that to work we need to search the cache. */
 297         for(i=0; i < cache_entry->cnt; i++) {
 298             if(cache_entry->buf[(cache_entry->head+i) % BUCKET_BUFFER_SIZE] == bstr) {
 299                 WARN_(heap)("String already is in cache!\n");
 300                 LeaveCriticalSection(&cs_bstr_cache);
 301                 return;
 302             }
 303         }
 304
 305         if(cache_entry->cnt < ARRAY_SIZE(cache_entry->buf)) {
 306             cache_entry->buf[(cache_entry->head+cache_entry->cnt) % BUCKET_BUFFER_SIZE] = bstr;
 307             cache_entry->cnt++;
 308
 309             if(WARN_ON(heap)) {
 310                 unsigned n = (alloc_size-FIELD_OFFSET(bstr_t, u.ptr))/sizeof(DWORD);
 311                 for(i=0; i<n; i++)
 312                     bstr->u.dwptr[i] = ARENA_FREE_FILLER;
 313             }
 314
 315             LeaveCriticalSection(&cs_bstr_cache);
 316             return;
 317         }
 318
 319         LeaveCriticalSection(&cs_bstr_cache);
 320     }
 321
 322     CoTaskMemFree(bstr);
 323 }
 324
 325 /******************************************************************************
 326  *             SysAllocStringLen     [OLEAUT32.4]
 327  *
 328  * Create a BSTR from an OLESTR of a given wide character length.
 329  *
 330  * PARAMS
 331  *  str [I] Source to create BSTR from
 332  *  len [I] Length of oleStr in wide characters
 333  *
 334  * RETURNS
 335  *  Success: A newly allocated BSTR from SysAllocStringByteLen()
 336  *  Failure: NULL, if len is >= 0x80000000, or memory allocation fails.
 337  *
 338  * NOTES
 339  *  See BSTR(), SysAllocStringByteLen().
 340  */
 341 BSTR WINAPI SysAllocStringLen(const OLECHAR *str, unsigned int len)
 342 {
 343     bstr_t *bstr;
 344     DWORD size;
 345
 346     /* Detect integer overflow. */
 347     if (len >= ((UINT_MAX-sizeof(WCHAR)-sizeof(DWORD))/sizeof(WCHAR)))
 348         return NULL;
 349
 350     TRACE("%s\n", debugstr_wn(str, len));
 351
 352     size = len*sizeof(WCHAR);
 353     bstr = alloc_bstr(size);
 354     if(!bstr)
 355         return NULL;
 356
 357     if(str) {
 358         memcpy(bstr->u.str, str, size);
 359         bstr->u.str[len] = 0;
 360     }else {
 361         memset(bstr->u.str, 0, size+sizeof(WCHAR));
 362     }
 363
 364     return bstr->u.str;
 365 }
 366
 367 /******************************************************************************
 368  *             SysReAllocStringLen   [OLEAUT32.5]
 369  *
 370  * Change the length of a previously created BSTR.
 371  *
 372  * PARAMS
 373  *  old [O] BSTR to change the length of
 374  *  str [I] New source for pbstr
 375  *  len [I] Length of oleStr in wide characters
 376  *
 377  * RETURNS
 378  *  Success: 1. The size of pbstr is updated.
 379  *  Failure: 0, if len >= 0x80000000 or memory allocation fails.
 380  *
 381  * NOTES
 382  *  See BSTR(), SysAllocStringByteLen().
 383  *  *old may be changed by this function.
 384  */
 385 int WINAPI SysReAllocStringLen(BSTR* old, const OLECHAR* str, unsigned int len)
 386 {
 387     /* Detect integer overflow. */
 388     if (len >= ((UINT_MAX-sizeof(WCHAR)-sizeof(DWORD))/sizeof(WCHAR)))
 389         return FALSE;
 390
 391     if (*old!=NULL) {
 392       DWORD newbytelen = len*sizeof(WCHAR);
 393       bstr_t *old_bstr = bstr_from_str(*old);
 394       bstr_t *bstr = CoTaskMemRealloc(old_bstr, bstr_alloc_size(newbytelen));
 395
 396       if (!bstr) return FALSE;
 397
 398       *old = bstr->u.str;
 399       bstr->size = newbytelen;
 400       /* The old string data is still there when str is NULL */
 401       if (str && old_bstr->u.str != str) memmove(bstr->u.str, str, newbytelen);
 402       bstr->u.str[len] = 0;
 403     } else {
 404       *old = SysAllocStringLen(str, len);
 405     }
 406
 407     return TRUE;
 408 }
 409
 410 /******************************************************************************
 411  *             SysAllocStringByteLen     [OLEAUT32.150]
 412  *
 413  * Create a BSTR from an OLESTR of a given byte length.
 414  *
 415  * PARAMS
 416  *  str [I] Source to create BSTR from
 417  *  len [I] Length of oleStr in bytes
 418  *
 419  * RETURNS
 420  *  Success: A newly allocated BSTR
 421  *  Failure: NULL, if len is >= 0x80000000, or memory allocation fails.
 422  *
 423  * NOTES
 424  *  -If len is 0 or oleStr is NULL the resulting string is empty ("").
 425  *  -This function always NUL terminates the resulting BSTR.
 426  *  -oleStr may be either an LPCSTR or LPCOLESTR, since it is copied
 427  *  without checking for a terminating NUL.
 428  *  See BSTR.
 429  */
 430 BSTR WINAPI DECLSPEC_HOTPATCH SysAllocStringByteLen(LPCSTR str, UINT len)
 431 {
 432     bstr_t *bstr;
 433
 434     /* Detect integer overflow. */
 435     if (len >= (UINT_MAX-sizeof(WCHAR)-sizeof(DWORD)))
 436         return NULL;
 437
 438     bstr = alloc_bstr(len);
 439     if(!bstr)
 440         return NULL;
 441
 442     if(str) {
 443         memcpy(bstr->u.ptr, str, len);
 444         bstr->u.ptr[len] = 0;
 445     }else {
 446         memset(bstr->u.ptr, 0, len+1);
 447     }
 448     bstr->u.str[(len+sizeof(WCHAR)-1)/sizeof(WCHAR)] = 0;
 449
 450     return bstr->u.str;
 451 }
 452
 453 /******************************************************************************
 454  *              SysReAllocString        [OLEAUT32.3]
 455  *
 456  * Change the length of a previously created BSTR.
 457  *
 458  * PARAMS
 459  *  old [I/O] BSTR to change the length of
 460  *  str [I]   New source for pbstr
 461  *
 462  * RETURNS
 463  *  Success: 1
 464  *  Failure: 0.
 465  *
 466  * NOTES
 467  *  See BSTR(), SysAllocStringStringLen().
 468  */
 469 INT WINAPI SysReAllocString(LPBSTR old,LPCOLESTR str)
 470 {
 471     /*
 472      * Sanity check
 473      */
 474     if (old==NULL)
 475       return 0;
 476
 477     /*
 478      * Make sure we free the old string.
 479      */
 480     SysFreeString(*old);
 481
 482     /*
 483      * Allocate the new string
 484      */
 485     *old = SysAllocString(str);
 486
 487      return 1;
 488 }
 489
 490 /******************************************************************************
 491  *              SetOaNoCache (OLEAUT32.327)
 492  *
 493  * Instruct Ole Automation not to cache BSTR allocations.
 494  *
 495  * PARAMS
 496  *  None.
 497  *
 498  * RETURNS
 499  *  Nothing.
 500  *
 501  * NOTES
 502  *  SetOaNoCache does not release cached strings, so it leaks by design.
 503  */
 504 void WINAPI SetOaNoCache(void)
 505 {
 506     TRACE("\n");
 507     bstr_cache_enabled = FALSE;
 508 }
 509
 510 /***********************************************************************
 511  *              RegisterActiveObject (OLEAUT32.33)
 512  *
 513  * Registers an object in the global item table.
 514  *
 515  * PARAMS
 516  *  punk        [I] Object to register.
 517  *  rcid        [I] CLSID of the object.
 518  *  dwFlags     [I] Flags.
 519  *  pdwRegister [O] Address to store cookie of object registration in.
 520  *
 521  * RETURNS
 522  *  Success: S_OK.
 523  *  Failure: HRESULT code.
 524  */
 525 HRESULT WINAPI DECLSPEC_HOTPATCH RegisterActiveObject(
 526         LPUNKNOWN punk,REFCLSID rcid,DWORD dwFlags,LPDWORD pdwRegister
 527 ) {
 528         WCHAR                   guidbuf[80];
 529         HRESULT                 ret;
 530         LPRUNNINGOBJECTTABLE    runobtable;
 531         LPMONIKER               moniker;
 532         DWORD                   rot_flags = ROTFLAGS_REGISTRATIONKEEPSALIVE; /* default registration is strong */
 533
 534         StringFromGUID2(rcid,guidbuf,39);
 535         ret = CreateItemMoniker(L"!", guidbuf, &moniker);
 536         if (FAILED(ret))
 537                 return ret;
 538         ret = GetRunningObjectTable(0,&runobtable);
 539         if (FAILED(ret)) {
 540                 IMoniker_Release(moniker);
 541                 return ret;
 542         }
 543         if(dwFlags == ACTIVEOBJECT_WEAK)
 544           rot_flags = 0;
 545         ret = IRunningObjectTable_Register(runobtable,rot_flags,punk,moniker,pdwRegister);
 546         IRunningObjectTable_Release(runobtable);
 547         IMoniker_Release(moniker);
 548         return ret;
 549 }
 550
 551 /***********************************************************************
 552  *              RevokeActiveObject (OLEAUT32.34)
 553  *
 554  * Revokes an object from the global item table.
 555  *
 556  * PARAMS
 557  *  xregister [I] Registration cookie.
 558  *  reserved  [I] Reserved. Set to NULL.
 559  *
 560  * RETURNS
 561  *  Success: S_OK.
 562  *  Failure: HRESULT code.
 563  */
 564 HRESULT WINAPI DECLSPEC_HOTPATCH RevokeActiveObject(DWORD xregister,LPVOID reserved)
 565 {
 566         LPRUNNINGOBJECTTABLE    runobtable;
 567         HRESULT                 ret;
 568
 569         ret = GetRunningObjectTable(0,&runobtable);
 570         if (FAILED(ret)) return ret;
 571         ret = IRunningObjectTable_Revoke(runobtable,xregister);
 572         if (SUCCEEDED(ret)) ret = S_OK;
 573         IRunningObjectTable_Release(runobtable);
 574         return ret;
 575 }
 576
 577 /***********************************************************************
 578  *              GetActiveObject (OLEAUT32.35)
 579  *
 580  * Gets an object from the global item table.
 581  *
 582  * PARAMS
 583  *  rcid        [I] CLSID of the object.
 584  *  preserved   [I] Reserved. Set to NULL.
 585  *  ppunk       [O] Address to store object into.
 586  *
 587  * RETURNS
 588  *  Success: S_OK.
 589  *  Failure: HRESULT code.
 590  */
 591 HRESULT WINAPI DECLSPEC_HOTPATCH GetActiveObject(REFCLSID rcid,LPVOID preserved,LPUNKNOWN *ppunk)
 592 {
 593         WCHAR                   guidbuf[80];
 594         HRESULT                 ret;
 595         LPRUNNINGOBJECTTABLE    runobtable;
 596         LPMONIKER               moniker;
 597
 598         StringFromGUID2(rcid,guidbuf,39);
 599         ret = CreateItemMoniker(L"!", guidbuf, &moniker);
 600         if (FAILED(ret))
 601                 return ret;
 602         ret = GetRunningObjectTable(0,&runobtable);
 603         if (FAILED(ret)) {
 604                 IMoniker_Release(moniker);
 605                 return ret;
 606         }
 607         ret = IRunningObjectTable_GetObject(runobtable,moniker,ppunk);
 608         IRunningObjectTable_Release(runobtable);
 609         IMoniker_Release(moniker);
 610         return ret;
 611 }
 612
 613
 614 /***********************************************************************
 615  *           OaBuildVersion           [OLEAUT32.170]
 616  *
 617  * Get the Ole Automation build version.
 618  *
 619  * PARAMS
 620  *  None
 621  *
 622  * RETURNS
 623  *  The build version.
 624  *
 625  * NOTES
 626  *  Known oleaut32.dll versions:
 627  *| OLE Ver.  Comments                   Date     Build Ver.
 628  *| --------  -------------------------  ----     ---------
 629  *| OLE 2.1   NT                         1993-95  10 3023
 630  *| OLE 2.1                                       10 3027
 631  *| Win32s    Ver 1.1e                            20 4049
 632  *| OLE 2.20  W95/NT                     1993-96  20 4112
 633  *| OLE 2.20  W95/NT                     1993-96  20 4118
 634  *| OLE 2.20  W95/NT                     1993-96  20 4122
 635  *| OLE 2.30  W95/NT                     1993-98  30 4265
 636  *| OLE 2.40  NT??                       1993-98  40 4267
 637  *| OLE 2.40  W98 SE orig. file          1993-98  40 4275
 638  *| OLE 2.40  W2K orig. file             1993-XX  40 4514
 639  *
 640  * Currently the versions returned are 2.20 for Win3.1, 2.30 for Win95 & NT 3.51,
 641  * and 2.40 for all later versions. The build number is maximum, i.e. 0xffff.
 642  */
 643 ULONG WINAPI OaBuildVersion(void)
 644 {
 645     switch(GetVersion() & 0x8000ffff)  /* mask off build number */
 646     {
 647     case 0x80000a03:  /* WIN31 */
 648                 return MAKELONG(0xffff, 20);
 649     case 0x00003303:  /* NT351 */
 650                 return MAKELONG(0xffff, 30);
 651     case 0x80000004:  /* WIN95; I'd like to use the "standard" w95 minor
 652                          version here (30), but as we still use w95
 653                          as default winver (which is good IMHO), I better
 654                          play safe and use the latest value for w95 for now.
 655                          Change this as soon as default winver gets changed
 656                          to something more recent */
 657     case 0x80000a04:  /* WIN98 */
 658     case 0x00000004:  /* NT40 */
 659     case 0x00000005:  /* W2K */
 660                 return MAKELONG(0xffff, 40);
 661     case 0x00000105:  /* WinXP */
 662     case 0x00000006:  /* Vista */
 663     case 0x00000106:  /* Win7 */
 664                 return MAKELONG(0xffff, 50);
 665     default:
 666                 FIXME("Version value not known yet. Please investigate it !\n");
 667                 return MAKELONG(0xffff, 40);  /* for now return the same value as for w2k */
 668     }
 669 }
 670
 671 /******************************************************************************
 672  *              OleTranslateColor       [OLEAUT32.421]
 673  *
 674  * Convert an OLE_COLOR to a COLORREF.
 675  *
 676  * PARAMS
 677  *  clr       [I] Color to convert
 678  *  hpal      [I] Handle to a palette for the conversion
 679  *  pColorRef [O] Destination for converted color, or NULL to test if the conversion is ok
 680  *
 681  * RETURNS
 682  *  Success: S_OK. The conversion is ok, and pColorRef contains the converted color if non-NULL.
 683  *  Failure: E_INVALIDARG, if any argument is invalid.
 684  *
 685  * FIXME
 686  *  Document the conversion rules.
 687  */
 688 HRESULT WINAPI OleTranslateColor(
 689   OLE_COLOR clr,
 690   HPALETTE  hpal,
 691   COLORREF* pColorRef)
 692 {
 693   COLORREF colorref;
 694   BYTE b = HIBYTE(HIWORD(clr));
 695
 696   TRACE("%#lx, %p, %p.\n", clr, hpal, pColorRef);
 697
 698   /*
 699    * In case pColorRef is NULL, provide our own to simplify the code.
 700    */
 701   if (pColorRef == NULL)
 702     pColorRef = &colorref;
 703
 704   switch (b)
 705   {
 706     case 0x00:
 707     {
 708       if (hpal != 0)
 709         *pColorRef =  PALETTERGB(GetRValue(clr),
 710                                  GetGValue(clr),
 711                                  GetBValue(clr));
 712       else
 713         *pColorRef = clr;
 714
 715       break;
 716     }
 717
 718     case 0x01:
 719     {
 720       if (hpal != 0)
 721       {
 722         PALETTEENTRY pe;
 723         /*
 724          * Validate the palette index.
 725          */
 726         if (GetPaletteEntries(hpal, LOWORD(clr), 1, &pe) == 0)
 727           return E_INVALIDARG;
 728       }
 729
 730       *pColorRef = clr;
 731
 732       break;
 733     }
 734
 735     case 0x02:
 736       *pColorRef = clr;
 737       break;
 738
 739     case 0x80:
 740     {
 741       int index = LOBYTE(LOWORD(clr));
 742
 743       /*
 744        * Validate GetSysColor index.
 745        */
 746       if ((index < COLOR_SCROLLBAR) || (index > COLOR_MENUBAR))
 747         return E_INVALIDARG;
 748
 749       *pColorRef =  GetSysColor(index);
 750
 751       break;
 752     }
 753
 754     default:
 755       return E_INVALIDARG;
 756   }
 757
 758   return S_OK;
 759 }
 760
 761 extern HRESULT WINAPI OLEAUTPS_DllGetClassObject(REFCLSID, REFIID, LPVOID *) DECLSPEC_HIDDEN;
 762 extern BOOL WINAPI OLEAUTPS_DllMain(HINSTANCE, DWORD, LPVOID) DECLSPEC_HIDDEN;
 763 extern HRESULT WINAPI OLEAUTPS_DllRegisterServer(void) DECLSPEC_HIDDEN;
 764 extern HRESULT WINAPI OLEAUTPS_DllUnregisterServer(void) DECLSPEC_HIDDEN;
 765
 766 extern HRESULT WINAPI CreateProxyFromTypeInfo(ITypeInfo *typeinfo,
 767         IUnknown *outer, REFIID iid, IRpcProxyBuffer **proxy, void **obj);
 768 extern HRESULT WINAPI CreateStubFromTypeInfo(ITypeInfo *typeinfo, REFIID iid,
 769         IUnknown *server, IRpcStubBuffer **stub);
 770
 771 struct ifacepsredirect_data
 772 {
 773     ULONG size;
 774     DWORD mask;
 775     GUID  iid;
 776     ULONG nummethods;
 777     GUID  tlbid;
 778     GUID  base;
 779     ULONG name_len;
 780     ULONG name_offset;
 781 };
 782
 783 struct tlibredirect_data
 784 {
 785     ULONG  size;
 786     DWORD  res;
 787     ULONG  name_len;
 788     ULONG  name_offset;
 789     LANGID langid;
 790     WORD   flags;
 791     ULONG  help_len;
 792     ULONG  help_offset;
 793     WORD   major_version;
 794     WORD   minor_version;
 795 };
 796
 797 static BOOL actctx_get_typelib_module(REFIID iid, WCHAR *module, DWORD len)
 798 {
 799     struct ifacepsredirect_data *iface;
 800     struct tlibredirect_data *tlib;
 801     ACTCTX_SECTION_KEYED_DATA data;
 802     WCHAR *ptrW;
 803
 804     data.cbSize = sizeof(data);
 805     if (!FindActCtxSectionGuid(0, NULL, ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION,
 806             iid, &data))
 807         return FALSE;
 808
 809     iface = (struct ifacepsredirect_data *)data.lpData;
 810     if (!FindActCtxSectionGuid(0, NULL, ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION,
 811             &iface->tlbid, &data))
 812         return FALSE;
 813
 814     tlib = (struct tlibredirect_data *)data.lpData;
 815     ptrW = (WCHAR *)((BYTE *)data.lpSectionBase + tlib->name_offset);
 816
 817     if (tlib->name_len/sizeof(WCHAR) >= len)
 818     {
 819         ERR("need larger module buffer, %lu.\n", tlib->name_len);
 820         return FALSE;
 821     }
 822
 823     memcpy(module, ptrW, tlib->name_len);
 824     module[tlib->name_len/sizeof(WCHAR)] = 0;
 825     return TRUE;
 826 }
 827
 828 static HRESULT reg_get_typelib_module(REFIID iid, WCHAR *module, DWORD len)
 829 {
 830     REGSAM opposite = (sizeof(void*) == 8) ? KEY_WOW64_32KEY : KEY_WOW64_64KEY;
 831     char tlguid[200], typelibkey[316], interfacekey[300], ver[100], tlfn[260];
 832     DWORD tlguidlen, verlen, type;
 833     LONG tlfnlen, err;
 834     BOOL is_wow64;
 835     HKEY ikey;
 836
 837     sprintf( interfacekey, "Interface\\{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\\Typelib",
 838         iid->Data1, iid->Data2, iid->Data3,
 839         iid->Data4[0], iid->Data4[1], iid->Data4[2], iid->Data4[3],
 840         iid->Data4[4], iid->Data4[5], iid->Data4[6], iid->Data4[7]
 841     );
 842
 843     err = RegOpenKeyExA(HKEY_CLASSES_ROOT,interfacekey,0,KEY_READ,&ikey);
 844     if (err && (opposite == KEY_WOW64_32KEY || (IsWow64Process(GetCurrentProcess(), &is_wow64)
 845                                                 && is_wow64)))
 846         err = RegOpenKeyExA(HKEY_CLASSES_ROOT,interfacekey,0,KEY_READ|opposite,&ikey);
 847
 848     if (err)
 849     {
 850         ERR("No %s key found.\n", interfacekey);
 851         return E_FAIL;
 852     }
 853
 854     tlguidlen = sizeof(tlguid);
 855     if (RegQueryValueExA(ikey, NULL, NULL, &type, (BYTE *)tlguid, &tlguidlen))
 856     {
 857         ERR("Getting typelib guid failed.\n");
 858         RegCloseKey(ikey);
 859         return E_FAIL;
 860     }
 861
 862     verlen = sizeof(ver);
 863     if (RegQueryValueExA(ikey, "Version", NULL, &type, (BYTE *)ver, &verlen))
 864     {
 865         ERR("Could not get version value?\n");
 866         RegCloseKey(ikey);
 867         return E_FAIL;
 868     }
 869
 870     RegCloseKey(ikey);
 871
 872     sprintf(typelibkey, "Typelib\\%s\\%s\\0\\win%u", tlguid, ver, sizeof(void *) == 8 ? 64 : 32);
 873     tlfnlen = sizeof(tlfn);
 874     if (RegQueryValueA(HKEY_CLASSES_ROOT, typelibkey, tlfn, &tlfnlen))
 875     {
 876 #ifdef _WIN64
 877         sprintf(typelibkey, "Typelib\\%s\\%s\\0\\win32", tlguid, ver);
 878         tlfnlen = sizeof(tlfn);
 879         if (RegQueryValueA(HKEY_CLASSES_ROOT, typelibkey, tlfn, &tlfnlen))
 880         {
 881 #endif
 882             ERR("Could not get typelib fn?\n");
 883             return E_FAIL;
 884 #ifdef _WIN64
 885         }
 886 #endif
 887     }
 888     MultiByteToWideChar(CP_ACP, 0, tlfn, -1, module, len);
 889     return S_OK;
 890 }
 891
 892 static HRESULT get_typeinfo_for_iid(REFIID iid, ITypeInfo **typeinfo)
 893 {
 894     WCHAR module[MAX_PATH];
 895     ITypeLib *typelib;
 896     HRESULT hr;
 897
 898     *typeinfo = NULL;
 899
 900     module[0] = 0;
 901     if (!actctx_get_typelib_module(iid, module, ARRAY_SIZE(module)))
 902     {
 903         hr = reg_get_typelib_module(iid, module, ARRAY_SIZE(module));
 904         if (FAILED(hr))
 905             return hr;
 906     }
 907
 908     hr = LoadTypeLib(module, &typelib);
 909     if (hr != S_OK) {
 910         ERR("Failed to load typelib for %s, but it should be there.\n", debugstr_guid(iid));
 911         return hr;
 912     }
 913
 914     hr = ITypeLib_GetTypeInfoOfGuid(typelib, iid, typeinfo);
 915     ITypeLib_Release(typelib);
 916     if (hr != S_OK)
 917         ERR("typelib does not contain info for %s\n", debugstr_guid(iid));
 918
 919     return hr;
 920 }
 921
 922 static HRESULT WINAPI dispatch_typelib_ps_QueryInterface(IPSFactoryBuffer *iface, REFIID iid, void **out)
 923 {
 924     if (IsEqualIID(iid, &IID_IPSFactoryBuffer) || IsEqualIID(iid, &IID_IUnknown))
 925     {
 926         *out = iface;
 927         return S_OK;
 928     }
 929
 930     FIXME("No interface for %s.\n", debugstr_guid(iid));
 931     *out = NULL;
 932     return E_NOINTERFACE;
 933 }
 934
 935 static ULONG WINAPI dispatch_typelib_ps_AddRef(IPSFactoryBuffer *iface)
 936 {
 937     return 2;
 938 }
 939
 940 static ULONG WINAPI dispatch_typelib_ps_Release(IPSFactoryBuffer *iface)
 941 {
 942     return 1;
 943 }
 944
 945 static HRESULT dispatch_create_proxy(IUnknown *outer, IRpcProxyBuffer **proxy, void **out)
 946 {
 947     IPSFactoryBuffer *factory;
 948     HRESULT hr;
 949
 950     hr = OLEAUTPS_DllGetClassObject(&CLSID_PSFactoryBuffer, &IID_IPSFactoryBuffer, (void **)&factory);
 951     if (FAILED(hr)) return hr;
 952
 953     hr = IPSFactoryBuffer_CreateProxy(factory, outer, &IID_IDispatch, proxy, out);
 954     IPSFactoryBuffer_Release(factory);
 955     return hr;
 956 }
 957
 958 static HRESULT WINAPI dispatch_typelib_ps_CreateProxy(IPSFactoryBuffer *iface,
 959     IUnknown *outer, REFIID iid, IRpcProxyBuffer **proxy, void **out)
 960 {
 961     ITypeInfo *typeinfo;
 962     TYPEATTR *attr;
 963     HRESULT hr;
 964
 965     if (IsEqualGUID(iid, &IID_IDispatch))
 966         return dispatch_create_proxy(outer, proxy, out);
 967
 968     hr = get_typeinfo_for_iid(iid, &typeinfo);
 969     if (FAILED(hr)) return hr;
 970
 971     hr = ITypeInfo_GetTypeAttr(typeinfo, &attr);
 972     if (FAILED(hr))
 973     {
 974         ITypeInfo_Release(typeinfo);
 975         return hr;
 976     }
 977
 978     if (attr->typekind == TKIND_INTERFACE || (attr->wTypeFlags & TYPEFLAG_FDUAL))
 979         hr = CreateProxyFromTypeInfo(typeinfo, outer, iid, proxy, out);
 980     else
 981         hr = dispatch_create_proxy(outer, proxy, out);
 982
 983     if (FAILED(hr))
 984         ERR("Failed to create proxy, hr %#lx.\n", hr);
 985
 986     ITypeInfo_ReleaseTypeAttr(typeinfo, attr);
 987     ITypeInfo_Release(typeinfo);
 988     return hr;
 989 }
 990
 991 static HRESULT dispatch_create_stub(IUnknown *server, IRpcStubBuffer **stub)
 992 {
 993     IPSFactoryBuffer *factory;
 994     HRESULT hr;
 995
 996     hr = OLEAUTPS_DllGetClassObject(&CLSID_PSFactoryBuffer, &IID_IPSFactoryBuffer, (void **)&factory);
 997     if (FAILED(hr)) return hr;
 998
 999     hr = IPSFactoryBuffer_CreateStub(factory, &IID_IDispatch, server, stub);
1000     IPSFactoryBuffer_Release(factory);
1001     return hr;
1002 }
1003
1004 struct dispinterface_stub
1005 {
1006     CInterfaceStubVtbl stub_vtbl;
1007     CStdStubBuffer stub_buffer;
1008 };
1009
1010 static struct dispinterface_stub *impl_from_IRpcStubBuffer(IRpcStubBuffer *iface)
1011 {
1012     return CONTAINING_RECORD(&iface->lpVtbl, struct dispinterface_stub, stub_buffer.lpVtbl);
1013 }
1014
1015 static ULONG WINAPI dispinterface_stub_Release(IRpcStubBuffer *iface)
1016 {
1017     struct dispinterface_stub *stub = impl_from_IRpcStubBuffer(iface);
1018     unsigned int refcount = InterlockedDecrement(&stub->stub_buffer.RefCount);
1019
1020     TRACE("%p decreasing refcount to %u.\n", stub, refcount);
1021
1022     if (!refcount)
1023     {
1024         /* Copied from NdrCStdStubBuffer_Release(), but supposedly incorrect
1025          * according to the comment there. */
1026         IRpcStubBuffer_Disconnect(iface);
1027
1028         free(stub);
1029     }
1030     return refcount;
1031 }
1032
1033 extern const ExtendedProxyFileInfo oleaut32_oaidl_ProxyFileInfo;
1034
1035 static const CInterfaceStubVtbl *find_idispatch_stub_vtbl(void)
1036 {
1037     CInterfaceStubVtbl *const *vtbl;
1038
1039     for (vtbl = oleaut32_oaidl_ProxyFileInfo.pStubVtblList; *vtbl; ++vtbl)
1040     {
1041         if (IsEqualGUID((*vtbl)->header.piid, &IID_IDispatch))
1042             return *vtbl;
1043     }
1044
1045     assert(0);
1046     return NULL;
1047 }
1048
1049 /* Normal dispinterfaces have an IID specified by the IDL compiler as DIID_*,
1050  * but are otherwise identical to IDispatch. Unfortunately, such interfaces may
1051  * not actually support IDispatch in QueryInterface.
1052  *
1053  * This becomes a problem, since CreateStub() was designed such that, for some
1054  * reason, the caller need not actually pass the interface matching "iid". As
1055  * such the standard rpcrt4 implementation will query the server for the
1056  * relevant IID.
1057  *
1058  * This means that we cannot just pass IID_IDispatch with the object, even
1059  * though it is in theory an IDispatch. However, while the standard stub
1060  * constructor is not exported from rpcrt4, all of the vtbl methods are, and
1061  * the type is public, so we *can* manually create it ourselves, bypassing the
1062  * QueryInterface check.
1063  *
1064  * This relies on some rpcrt4 implementation details.
1065  */
1066 static HRESULT dispinterface_create_stub(IUnknown *server, const GUID *iid, IRpcStubBuffer **stub)
1067 {
1068     const CInterfaceStubVtbl *stub_vtbl = find_idispatch_stub_vtbl();
1069     struct dispinterface_stub *object;
1070     void *dispatch;
1071     HRESULT hr;
1072
1073     if (!(object = calloc(1, sizeof(*object))))
1074         return E_OUTOFMEMORY;
1075
1076     /* It's possible we can just assume that "server" is already the
1077      * dispinterface type—we don't have tests for this—but since rpcrt4 queries
1078      * (which we do have tests for) it makes sense for us to match that
1079      * behaviour. */
1080     if (FAILED(hr = IUnknown_QueryInterface(server, iid, &dispatch)))
1081     {
1082         ERR("Object does not support interface %s.\n", debugstr_guid(iid));
1083         free(object);
1084         return hr;
1085     }
1086
1087     object->stub_vtbl.header = stub_vtbl->header;
1088     object->stub_vtbl.Vtbl.QueryInterface             = CStdStubBuffer_QueryInterface;
1089     object->stub_vtbl.Vtbl.AddRef                     = CStdStubBuffer_AddRef;
1090     object->stub_vtbl.Vtbl.Release                    = dispinterface_stub_Release;
1091     object->stub_vtbl.Vtbl.Connect                    = CStdStubBuffer_Connect;
1092     object->stub_vtbl.Vtbl.Disconnect                 = CStdStubBuffer_Disconnect;
1093     object->stub_vtbl.Vtbl.Invoke                     = CStdStubBuffer_Invoke;
1094     object->stub_vtbl.Vtbl.IsIIDSupported             = CStdStubBuffer_IsIIDSupported;
1095     object->stub_vtbl.Vtbl.CountRefs                  = CStdStubBuffer_CountRefs;
1096     object->stub_vtbl.Vtbl.DebugServerQueryInterface  = CStdStubBuffer_DebugServerQueryInterface;
1097     object->stub_vtbl.Vtbl.DebugServerRelease         = CStdStubBuffer_DebugServerRelease;
1098     object->stub_buffer.lpVtbl = &object->stub_vtbl.Vtbl;
1099     object->stub_buffer.RefCount = 1;
1100     object->stub_buffer.pvServerObject = dispatch;
1101     /* rpcrt4 will also fill pPSFactory, but it never uses it except in the
1102      * Release method (which we reimplement). It's only to keep a reference to
1103      * the module to implement NdrDllCanUnloadNow(). We use the default
1104      * DllCanUnloadNow() from winecrt0, which always returns S_FALSE, so don't
1105      * bother filling pPSFactory. */
1106
1107     TRACE("Created stub %p.\n", object);
1108     *stub = (IRpcStubBuffer *)&object->stub_buffer.lpVtbl;
1109     return S_OK;
1110 }
1111
1112 static HRESULT WINAPI dispatch_typelib_ps_CreateStub(IPSFactoryBuffer *iface,
1113     REFIID iid, IUnknown *server, IRpcStubBuffer **stub)
1114 {
1115     ITypeInfo *typeinfo;
1116     TYPEATTR *attr;
1117     HRESULT hr;
1118
1119     if (IsEqualGUID(iid, &IID_IDispatch))
1120         return dispatch_create_stub(server, stub);
1121
1122     hr = get_typeinfo_for_iid(iid, &typeinfo);
1123     if (FAILED(hr)) return hr;
1124
1125     hr = ITypeInfo_GetTypeAttr(typeinfo, &attr);
1126     if (FAILED(hr))
1127     {
1128         ITypeInfo_Release(typeinfo);
1129         return hr;
1130     }
1131
1132     if (attr->typekind == TKIND_INTERFACE || (attr->wTypeFlags & TYPEFLAG_FDUAL))
1133         hr = CreateStubFromTypeInfo(typeinfo, iid, server, stub);
1134     else
1135         hr = dispinterface_create_stub(server, iid, stub);
1136
1137     if (FAILED(hr))
1138         ERR("Failed to create stub, hr %#lx.\n", hr);
1139
1140     ITypeInfo_ReleaseTypeAttr(typeinfo, attr);
1141     ITypeInfo_Release(typeinfo);
1142     return hr;
1143 }
1144
1145 static const IPSFactoryBufferVtbl dispatch_typelib_ps_vtbl =
1146 {
1147     dispatch_typelib_ps_QueryInterface,
1148     dispatch_typelib_ps_AddRef,
1149     dispatch_typelib_ps_Release,
1150     dispatch_typelib_ps_CreateProxy,
1151     dispatch_typelib_ps_CreateStub,
1152 };
1153
1154 static IPSFactoryBuffer dispatch_typelib_ps = { &dispatch_typelib_ps_vtbl };
1155
1156 extern void _get_STDFONT_CF(LPVOID *);
1157 extern void _get_STDPIC_CF(LPVOID *);
1158
1159 /***********************************************************************
1160  *              DllGetClassObject (OLEAUT32.@)
1161  */
1162 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv)
1163 {
1164     *ppv = NULL;
1165     if (IsEqualGUID(rclsid,&CLSID_StdFont)) {
1166         if (IsEqualGUID(iid,&IID_IClassFactory)) {
1167             _get_STDFONT_CF(ppv);
1168             IClassFactory_AddRef((IClassFactory*)*ppv);
1169             return S_OK;
1170         }
1171     }
1172     if (IsEqualGUID(rclsid,&CLSID_StdPicture)) {
1173         if (IsEqualGUID(iid,&IID_IClassFactory)) {
1174             _get_STDPIC_CF(ppv);
1175             IClassFactory_AddRef((IClassFactory*)*ppv);
1176             return S_OK;
1177         }
1178     }
1179
1180     if (IsEqualGUID(rclsid, &CLSID_PSDispatch) || IsEqualGUID(rclsid, &CLSID_PSOAInterface))
1181         return IPSFactoryBuffer_QueryInterface(&dispatch_typelib_ps, iid, ppv);
1182
1183     if (IsEqualCLSID(rclsid, &CLSID_PSTypeComp) ||
1184         IsEqualCLSID(rclsid, &CLSID_PSTypeInfo) ||
1185         IsEqualCLSID(rclsid, &CLSID_PSTypeLib) ||
1186         IsEqualCLSID(rclsid, &CLSID_PSDispatch) ||
1187         IsEqualCLSID(rclsid, &CLSID_PSEnumVariant))
1188         return OLEAUTPS_DllGetClassObject(&CLSID_PSFactoryBuffer, iid, ppv);
1189
1190     return OLEAUTPS_DllGetClassObject(rclsid, iid, ppv);
1191 }
1192
1193 /*****************************************************************************
1194  *              DllMain         [OLEAUT32.@]
1195  */
1196 BOOL WINAPI DllMain(HINSTANCE hInstDll, DWORD fdwReason, LPVOID lpvReserved)
1197 {
1198     if(fdwReason == DLL_PROCESS_ATTACH)
1199         bstr_cache_enabled = !GetEnvironmentVariableW(L"oanocache", NULL, 0);
1200
1201     return OLEAUTPS_DllMain( hInstDll, fdwReason, lpvReserved );
1202 }
1203
1204 /***********************************************************************
1205  *              DllRegisterServer (OLEAUT32.@)
1206  */
1207 HRESULT WINAPI DllRegisterServer(void)
1208 {
1209     return OLEAUTPS_DllRegisterServer();
1210 }
1211
1212 /***********************************************************************
1213  *              DllUnregisterServer (OLEAUT32.@)
1214  */
1215 HRESULT WINAPI DllUnregisterServer(void)
1216 {
1217     return OLEAUTPS_DllUnregisterServer();
1218 }
1219
1220 /***********************************************************************
1221  *              OleIconToCursor (OLEAUT32.415)
1222  */
1223 HCURSOR WINAPI OleIconToCursor( HINSTANCE hinstExe, HICON hIcon)
1224 {
1225     FIXME("(%p,%p), partially implemented.\n",hinstExe,hIcon);
1226     /* FIXME: make an extended conversation from HICON to HCURSOR */
1227     return CopyCursor(hIcon);
1228 }
1229
1230 /***********************************************************************
1231  *              GetAltMonthNames (OLEAUT32.@)
1232  */
1233 HRESULT WINAPI GetAltMonthNames(LCID lcid, LPOLESTR **str)
1234 {
1235     static const WCHAR *arabic_hijri[] =
1236     {
1237         L"\x0645\x062d\x0631\x0645",
1238         L"\x0635\x0641\x0631",
1239         L"\x0631\x0628\x064a\x0639 \x0627\x0644\x0627\x0648\x0644",
1240         L"\x0631\x0628\x064a\x0639 \x0627\x0644\x062b\x0627\x0646\x064a",
1241         L"\x062c\x0645\x0627\x062f\x0649 \x0627\x0644\x0627\x0648\x0644\x0649",
1242         L"\x062c\x0645\x0627\x062f\x0649 \x0627\x0644\x062b\x0627\x0646\x064a\x0629",
1243         L"\x0631\x062c\x0628",
1244         L"\x0634\x0639\x0628\x0627\x0646",
1245         L"\x0631\x0645\x0636\x0627\x0646",
1246         L"\x0634\x0648\x0627\x0643",
1247         L"\x0630\x0648 \x0627\x0644\x0642\x0639\x062f\x0629",
1248         L"\x0630\x0648 \x0627\x0644\x062d\x062c\x0629",
1249         NULL
1250     };
1251
1252     static const WCHAR *polish_genitive_names[] =
1253     {
1254         L"stycznia",
1255         L"lutego",
1256         L"marca",
1257         L"kwietnia",
1258         L"maja",
1259         L"czerwca",
1260         L"lipca",
1261         L"sierpnia",
1262         L"wrze\x015bnia",
1263         L"pa\x017a" "dziernika",
1264         L"listopada",
1265         L"grudnia",
1266         NULL
1267     };
1268
1269     static const WCHAR *russian_genitive_names[] =
1270     {
1271         L"\x044f\x043d\x0432\x0430\x0440\x044f",
1272         L"\x0444\x0435\x0432\x0440\x0430\x043b\x044f",
1273         L"\x043c\x0430\x0440\x0442\x0430",
1274         L"\x0430\x043f\x0440\x0435\x043b\x044f",
1275         L"\x043c\x0430\x044f",
1276         L"\x0438\x044e\x043d\x044f",
1277         L"\x0438\x044e\x043b\x044f",
1278         L"\x0430\x0432\x0433\x0443\x0441\x0442\x0430",
1279         L"\x0441\x0435\x043d\x0442\x044f\x0431\x0440\x044f",
1280         L"\x043e\x043a\x0442\x044f\x0431\x0440\x044f",
1281         L"\x043d\x043e\x044f\x0431\x0440\x044f",
1282         L"\x0434\x0435\x043a\x0430\x0431\x0440\x044f",
1283         NULL
1284     };
1285
1286     TRACE("%#lx, %p.\n", lcid, str);
1287
1288     if (PRIMARYLANGID(LANGIDFROMLCID(lcid)) == LANG_ARABIC)
1289         *str = (LPOLESTR *)arabic_hijri;
1290     else if (PRIMARYLANGID(LANGIDFROMLCID(lcid)) == LANG_POLISH)
1291         *str = (LPOLESTR *)polish_genitive_names;
1292     else if (PRIMARYLANGID(LANGIDFROMLCID(lcid)) == LANG_RUSSIAN)
1293         *str = (LPOLESTR *)russian_genitive_names;
1294     else
1295         *str = NULL;
1296
1297     return S_OK;
1298 }