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 <stdarg.h>
  22 #include <string.h>
  23 #include <limits.h>
  24
  25 #define COBJMACROS
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "wingdi.h"
  30 #include "winuser.h"
  31 #include "winerror.h"
  32
  33 #include "ole2.h"
  34 #include "olectl.h"
  35 #include "oleauto.h"
  36 #include "typelib.h"
  37
  38 #include "wine/debug.h"
  39
  40 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  41
  42 static BOOL BSTR_bCache = TRUE; /* Cache allocations to minimise alloc calls? */
  43
  44 HMODULE OLEAUT32_hModule = NULL;
  45
  46 /******************************************************************************
  47  * BSTR  {OLEAUT32}
  48  *
  49  * NOTES
  50  *  BSTR is a simple typedef for a wide-character string used as the principle
  51  *  string type in ole automation. When encapsulated in a Variant type they are
  52  *  automatically copied and destroyed as the variant is processed.
  53  *
  54  *  The low level BSTR Api allows manipulation of these strings and is used by
  55  *  higher level Api calls to manage the strings transparently to the caller.
  56  *
  57  *  Internally the BSTR type is allocated with space for a DWORD byte count before
  58  *  the string data begins. This is undocumented and non-system code should not
  59  *  access the count directly. Use SysStringLen() or SysStringByteLen()
  60  *  instead. Note that the byte count does not include the terminating NUL.
  61  *
  62  *  To create a new BSTR, use SysAllocString(), SysAllocStringLen() or
  63  *  SysAllocStringByteLen(). To change the size of an existing BSTR, use SysReAllocString()
  64  *  or SysReAllocStringLen(). Finally to destroy a string use SysFreeString().
  65  *
  66  *  BSTR's are cached by Ole Automation by default. To override this behaviour
  67  *  either set the environment variable 'OANOCACHE', or call SetOaNoCache().
  68  *
  69  * SEE ALSO
  70  *  'Inside OLE, second edition' by Kraig Brockshmidt.
  71  */
  72
  73 /******************************************************************************
  74  *             SysStringLen  [OLEAUT32.7]
  75  *
  76  * Get the allocated length of a BSTR in wide characters.
  77  *
  78  * PARAMS
  79  *  str [I] BSTR to find the length of
  80  *
  81  * RETURNS
  82  *  The allocated length of str, or 0 if str is NULL.
  83  *
  84  * NOTES
  85  *  See BSTR.
  86  *  The returned length may be different from the length of the string as
  87  *  calculated by lstrlenW(), since it returns the length that was used to
  88  *  allocate the string by SysAllocStringLen().
  89  */
  90 UINT WINAPI SysStringLen(BSTR str)
  91 {
  92     DWORD* bufferPointer;
  93
  94      if (!str) return 0;
  95     /*
  96      * The length of the string (in bytes) is contained in a DWORD placed
  97      * just before the BSTR pointer
  98      */
  99     bufferPointer = (DWORD*)str;
 100
 101     bufferPointer--;
 102
 103     return (int)(*bufferPointer/sizeof(WCHAR));
 104 }
 105
 106 /******************************************************************************
 107  *             SysStringByteLen  [OLEAUT32.149]
 108  *
 109  * Get the allocated length of a BSTR in bytes.
 110  *
 111  * PARAMS
 112  *  str [I] BSTR to find the length of
 113  *
 114  * RETURNS
 115  *  The allocated length of str, or 0 if str is NULL.
 116  *
 117  * NOTES
 118  *  See SysStringLen(), BSTR().
 119  */
 120 UINT WINAPI SysStringByteLen(BSTR str)
 121 {
 122     DWORD* bufferPointer;
 123
 124      if (!str) return 0;
 125     /*
 126      * The length of the string (in bytes) is contained in a DWORD placed
 127      * just before the BSTR pointer
 128      */
 129     bufferPointer = (DWORD*)str;
 130
 131     bufferPointer--;
 132
 133     return (int)(*bufferPointer);
 134 }
 135
 136 /******************************************************************************
 137  *              SysAllocString  [OLEAUT32.2]
 138  *
 139  * Create a BSTR from an OLESTR.
 140  *
 141  * PARAMS
 142  *  str [I] Source to create BSTR from
 143  *
 144  * RETURNS
 145  *  Success: A BSTR allocated with SysAllocStringLen().
 146  *  Failure: NULL, if oleStr is NULL.
 147  *
 148  * NOTES
 149  *  See BSTR.
 150  *  MSDN (October 2001) incorrectly states that NULL is returned if oleStr has
 151  *  a length of 0. Native Win32 and this implementation both return a valid
 152  *  empty BSTR in this case.
 153  */
 154 BSTR WINAPI SysAllocString(LPCOLESTR str)
 155 {
 156     if (!str) return 0;
 157
 158     /* Delegate this to the SysAllocStringLen32 method. */
 159     return SysAllocStringLen(str, lstrlenW(str));
 160 }
 161
 162 /******************************************************************************
 163  *              SysFreeString   [OLEAUT32.6]
 164  *
 165  * Free a BSTR.
 166  *
 167  * PARAMS
 168  *  str [I] BSTR to free.
 169  *
 170  * RETURNS
 171  *  Nothing.
 172  *
 173  * NOTES
 174  *  See BSTR.
 175  *  str may be NULL, in which case this function does nothing.
 176  */
 177 void WINAPI SysFreeString(BSTR str)
 178 {
 179     DWORD* bufferPointer;
 180
 181     /* NULL is a valid parameter */
 182     if(!str) return;
 183
 184     /*
 185      * We have to be careful when we free a BSTR pointer, it points to
 186      * the beginning of the string but it skips the byte count contained
 187      * before the string.
 188      */
 189     bufferPointer = (DWORD*)str;
 190
 191     bufferPointer--;
 192
 193     /*
 194      * Free the memory from its "real" origin.
 195      */
 196     HeapFree(GetProcessHeap(), 0, bufferPointer);
 197 }
 198
 199 /******************************************************************************
 200  *             SysAllocStringLen     [OLEAUT32.4]
 201  *
 202  * Create a BSTR from an OLESTR of a given wide character length.
 203  *
 204  * PARAMS
 205  *  str [I] Source to create BSTR from
 206  *  len [I] Length of oleStr in wide characters
 207  *
 208  * RETURNS
 209  *  Success: A newly allocated BSTR from SysAllocStringByteLen()
 210  *  Failure: NULL, if len is >= 0x80000000, or memory allocation fails.
 211  *
 212  * NOTES
 213  *  See BSTR(), SysAllocStringByteLen().
 214  */
 215 BSTR WINAPI SysAllocStringLen(const OLECHAR *str, unsigned int len)
 216 {
 217     DWORD  bufferSize;
 218     DWORD* newBuffer;
 219     WCHAR* stringBuffer;
 220
 221     /* Detect integer overflow. */
 222     if (len >= ((UINT_MAX-sizeof(WCHAR)-sizeof(DWORD))/sizeof(WCHAR)))
 223         return NULL;
 224     /*
 225      * Find the length of the buffer passed-in, in bytes.
 226      */
 227     bufferSize = len * sizeof (WCHAR);
 228
 229     /*
 230      * Allocate a new buffer to hold the string.
 231      * don't forget to keep an empty spot at the beginning of the
 232      * buffer for the character count and an extra character at the
 233      * end for the NULL.
 234      */
 235     newBuffer = HeapAlloc(GetProcessHeap(), 0,
 236                           bufferSize + sizeof(WCHAR) + sizeof(DWORD));
 237
 238     /*
 239      * If the memory allocation failed, return a null pointer.
 240      */
 241     if (!newBuffer)
 242       return NULL;
 243
 244     /*
 245      * Copy the length of the string in the placeholder.
 246      */
 247     *newBuffer = bufferSize;
 248
 249     /*
 250      * Skip the byte count.
 251      */
 252     newBuffer++;
 253
 254     /*
 255      * Copy the information in the buffer.
 256      * Since it is valid to pass a NULL pointer here, we'll initialize the
 257      * buffer to nul if it is the case.
 258      */
 259     if (str != 0)
 260       memcpy(newBuffer, str, bufferSize);
 261     else
 262       memset(newBuffer, 0, bufferSize);
 263
 264     /*
 265      * Make sure that there is a nul character at the end of the
 266      * string.
 267      */
 268     stringBuffer = (WCHAR*)newBuffer;
 269     stringBuffer[len] = '\0';
 270
 271     return (LPWSTR)stringBuffer;
 272 }
 273
 274 /******************************************************************************
 275  *             SysReAllocStringLen   [OLEAUT32.5]
 276  *
 277  * Change the length of a previously created BSTR.
 278  *
 279  * PARAMS
 280  *  old [O] BSTR to change the length of
 281  *  str [I] New source for pbstr
 282  *  len [I] Length of oleStr in wide characters
 283  *
 284  * RETURNS
 285  *  Success: 1. The size of pbstr is updated.
 286  *  Failure: 0, if len >= 0x80000000 or memory allocation fails.
 287  *
 288  * NOTES
 289  *  See BSTR(), SysAllocStringByteLen().
 290  *  *old may be changed by this function.
 291  */
 292 int WINAPI SysReAllocStringLen(BSTR* old, const OLECHAR* str, unsigned int len)
 293 {
 294     /* Detect integer overflow. */
 295     if (len >= ((UINT_MAX-sizeof(WCHAR)-sizeof(DWORD))/sizeof(WCHAR)))
 296         return 0;
 297
 298     if (*old!=NULL) {
 299       DWORD newbytelen = len*sizeof(WCHAR);
 300       DWORD *ptr = HeapReAlloc(GetProcessHeap(),0,((DWORD*)*old)-1,newbytelen+sizeof(WCHAR)+sizeof(DWORD));
 301       *old = (BSTR)(ptr+1);
 302       *ptr = newbytelen;
 303       if (str) {
 304         memmove(*old, str, newbytelen);
 305         (*old)[len] = 0;
 306       } else {
 307         /* Subtle hidden feature: The old string data is still there
 308          * when 'in' is NULL!
 309          * Some Microsoft program needs it.
 310          */
 311       }
 312     } else {
 313       /*
 314        * Allocate the new string
 315        */
 316       *old = SysAllocStringLen(str, len);
 317     }
 318
 319     return 1;
 320 }
 321
 322 /******************************************************************************
 323  *             SysAllocStringByteLen     [OLEAUT32.150]
 324  *
 325  * Create a BSTR from an OLESTR of a given byte length.
 326  *
 327  * PARAMS
 328  *  str [I] Source to create BSTR from
 329  *  len [I] Length of oleStr in bytes
 330  *
 331  * RETURNS
 332  *  Success: A newly allocated BSTR
 333  *  Failure: NULL, if len is >= 0x80000000, or memory allocation fails.
 334  *
 335  * NOTES
 336  *  -If len is 0 or oleStr is NULL the resulting string is empty ("").
 337  *  -This function always NUL terminates the resulting BSTR.
 338  *  -oleStr may be either an LPCSTR or LPCOLESTR, since it is copied
 339  *  without checking for a terminating NUL.
 340  *  See BSTR.
 341  */
 342 BSTR WINAPI SysAllocStringByteLen(LPCSTR str, UINT len)
 343 {
 344     DWORD* newBuffer;
 345     char* stringBuffer;
 346
 347     /* Detect integer overflow. */
 348     if (len >= (UINT_MAX-sizeof(WCHAR)-sizeof(DWORD)))
 349         return NULL;
 350
 351     /*
 352      * Allocate a new buffer to hold the string.
 353      * don't forget to keep an empty spot at the beginning of the
 354      * buffer for the character count and an extra character at the
 355      * end for the NULL.
 356      */
 357     newBuffer = HeapAlloc(GetProcessHeap(), 0,
 358                           len + sizeof(WCHAR) + sizeof(DWORD));
 359
 360     /*
 361      * If the memory allocation failed, return a null pointer.
 362      */
 363     if (newBuffer==0)
 364       return 0;
 365
 366     /*
 367      * Copy the length of the string in the placeholder.
 368      */
 369     *newBuffer = len;
 370
 371     /*
 372      * Skip the byte count.
 373      */
 374     newBuffer++;
 375
 376     /*
 377      * Copy the information in the buffer.
 378      * Since it is valid to pass a NULL pointer here, we'll initialize the
 379      * buffer to nul if it is the case.
 380      */
 381     if (str != 0)
 382       memcpy(newBuffer, str, len);
 383
 384     /*
 385      * Make sure that there is a nul character at the end of the
 386      * string.
 387      */
 388     stringBuffer = (char *)newBuffer;
 389     stringBuffer[len] = 0;
 390     stringBuffer[len+1] = 0;
 391
 392     return (LPWSTR)stringBuffer;
 393 }
 394
 395 /******************************************************************************
 396  *              SysReAllocString        [OLEAUT32.3]
 397  *
 398  * Change the length of a previously created BSTR.
 399  *
 400  * PARAMS
 401  *  old [I/O] BSTR to change the length of
 402  *  str [I]   New source for pbstr
 403  *
 404  * RETURNS
 405  *  Success: 1
 406  *  Failure: 0.
 407  *
 408  * NOTES
 409  *  See BSTR(), SysAllocStringStringLen().
 410  */
 411 INT WINAPI SysReAllocString(LPBSTR old,LPCOLESTR str)
 412 {
 413     /*
 414      * Sanity check
 415      */
 416     if (old==NULL)
 417       return 0;
 418
 419     /*
 420      * Make sure we free the old string.
 421      */
 422     if (*old!=NULL)
 423       SysFreeString(*old);
 424
 425     /*
 426      * Allocate the new string
 427      */
 428     *old = SysAllocString(str);
 429
 430      return 1;
 431 }
 432
 433 /******************************************************************************
 434  *              SetOaNoCache (OLEAUT32.327)
 435  *
 436  * Instruct Ole Automation not to cache BSTR allocations.
 437  *
 438  * PARAMS
 439  *  None.
 440  *
 441  * RETURNS
 442  *  Nothing.
 443  *
 444  * NOTES
 445  *  See BSTR.
 446  */
 447 void WINAPI SetOaNoCache(void)
 448 {
 449   BSTR_bCache = FALSE;
 450 }
 451
 452 static const WCHAR      _delimiter[2] = {'!',0}; /* default delimiter apparently */
 453 static const WCHAR      *pdelimiter = &_delimiter[0];
 454
 455 /***********************************************************************
 456  *              RegisterActiveObject (OLEAUT32.33)
 457  *
 458  * Registers an object in the global item table.
 459  *
 460  * PARAMS
 461  *  punk        [I] Object to register.
 462  *  rcid        [I] CLSID of the object.
 463  *  dwFlags     [I] Flags.
 464  *  pdwRegister [O] Address to store cookie of object registration in.
 465  *
 466  * RETURNS
 467  *  Success: S_OK.
 468  *  Failure: HRESULT code.
 469  */
 470 HRESULT WINAPI RegisterActiveObject(
 471         LPUNKNOWN punk,REFCLSID rcid,DWORD dwFlags,LPDWORD pdwRegister
 472 ) {
 473         WCHAR                   guidbuf[80];
 474         HRESULT                 ret;
 475         LPRUNNINGOBJECTTABLE    runobtable;
 476         LPMONIKER               moniker;
 477
 478         StringFromGUID2(rcid,guidbuf,39);
 479         ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
 480         if (FAILED(ret))
 481                 return ret;
 482         ret = GetRunningObjectTable(0,&runobtable);
 483         if (FAILED(ret)) {
 484                 IMoniker_Release(moniker);
 485                 return ret;
 486         }
 487         ret = IRunningObjectTable_Register(runobtable,dwFlags,punk,moniker,pdwRegister);
 488         IRunningObjectTable_Release(runobtable);
 489         IMoniker_Release(moniker);
 490         return ret;
 491 }
 492
 493 /***********************************************************************
 494  *              RevokeActiveObject (OLEAUT32.34)
 495  *
 496  * Revokes an object from the global item table.
 497  *
 498  * PARAMS
 499  *  xregister [I] Registration cookie.
 500  *  reserved  [I] Reserved. Set to NULL.
 501  *
 502  * RETURNS
 503  *  Success: S_OK.
 504  *  Failure: HRESULT code.
 505  */
 506 HRESULT WINAPI RevokeActiveObject(DWORD xregister,LPVOID reserved)
 507 {
 508         LPRUNNINGOBJECTTABLE    runobtable;
 509         HRESULT                 ret;
 510
 511         ret = GetRunningObjectTable(0,&runobtable);
 512         if (FAILED(ret)) return ret;
 513         ret = IRunningObjectTable_Revoke(runobtable,xregister);
 514         if (SUCCEEDED(ret)) ret = S_OK;
 515         IRunningObjectTable_Release(runobtable);
 516         return ret;
 517 }
 518
 519 /***********************************************************************
 520  *              GetActiveObject (OLEAUT32.35)
 521  *
 522  * Gets an object from the global item table.
 523  *
 524  * PARAMS
 525  *  rcid        [I] CLSID of the object.
 526  *  preserved   [I] Reserved. Set to NULL.
 527  *  ppunk       [O] Address to store object into.
 528  *
 529  * RETURNS
 530  *  Success: S_OK.
 531  *  Failure: HRESULT code.
 532  */
 533 HRESULT WINAPI GetActiveObject(REFCLSID rcid,LPVOID preserved,LPUNKNOWN *ppunk)
 534 {
 535         WCHAR                   guidbuf[80];
 536         HRESULT                 ret;
 537         LPRUNNINGOBJECTTABLE    runobtable;
 538         LPMONIKER               moniker;
 539
 540         StringFromGUID2(rcid,guidbuf,39);
 541         ret = CreateItemMoniker(pdelimiter,guidbuf,&moniker);
 542         if (FAILED(ret))
 543                 return ret;
 544         ret = GetRunningObjectTable(0,&runobtable);
 545         if (FAILED(ret)) {
 546                 IMoniker_Release(moniker);
 547                 return ret;
 548         }
 549         ret = IRunningObjectTable_GetObject(runobtable,moniker,ppunk);
 550         IRunningObjectTable_Release(runobtable);
 551         IMoniker_Release(moniker);
 552         return ret;
 553 }
 554
 555
 556 /***********************************************************************
 557  *           OaBuildVersion           [OLEAUT32.170]
 558  *
 559  * Get the Ole Automation build version.
 560  *
 561  * PARAMS
 562  *  None
 563  *
 564  * RETURNS
 565  *  The build version.
 566  *
 567  * NOTES
 568  *  Known oleaut32.dll versions:
 569  *| OLE Ver.  Comments                   Date     Build Ver.
 570  *| --------  -------------------------  ----     ---------
 571  *| OLE 2.1   NT                         1993-95  10 3023
 572  *| OLE 2.1                                       10 3027
 573  *| Win32s    Ver 1.1e                            20 4049
 574  *| OLE 2.20  W95/NT                     1993-96  20 4112
 575  *| OLE 2.20  W95/NT                     1993-96  20 4118
 576  *| OLE 2.20  W95/NT                     1993-96  20 4122
 577  *| OLE 2.30  W95/NT                     1993-98  30 4265
 578  *| OLE 2.40  NT??                       1993-98  40 4267
 579  *| OLE 2.40  W98 SE orig. file          1993-98  40 4275
 580  *| OLE 2.40  W2K orig. file             1993-XX  40 4514
 581  *
 582  * Currently the versions returned are 2.20 for Win3.1, 2.30 for Win95 & NT 3.51,
 583  * and 2.40 for all later versions. The build number is maximum, i.e. 0xffff.
 584  */
 585 ULONG WINAPI OaBuildVersion(void)
 586 {
 587     switch(GetVersion() & 0x8000ffff)  /* mask off build number */
 588     {
 589     case 0x80000a03:  /* WIN31 */
 590                 return MAKELONG(0xffff, 20);
 591     case 0x00003303:  /* NT351 */
 592                 return MAKELONG(0xffff, 30);
 593     case 0x80000004:  /* WIN95; I'd like to use the "standard" w95 minor
 594                          version here (30), but as we still use w95
 595                          as default winver (which is good IMHO), I better
 596                          play safe and use the latest value for w95 for now.
 597                          Change this as soon as default winver gets changed
 598                          to something more recent */
 599     case 0x80000a04:  /* WIN98 */
 600     case 0x00000004:  /* NT40 */
 601     case 0x00000005:  /* W2K */
 602     case 0x00000105:  /* WinXP */
 603                 return MAKELONG(0xffff, 40);
 604     default:
 605                 FIXME("Version value not known yet. Please investigate it !\n");
 606                 return MAKELONG(0xffff, 40);  /* for now return the same value as for w2k */
 607     }
 608 }
 609
 610 /******************************************************************************
 611  *              OleTranslateColor       [OLEAUT32.421]
 612  *
 613  * Convert an OLE_COLOR to a COLORREF.
 614  *
 615  * PARAMS
 616  *  clr       [I] Color to convert
 617  *  hpal      [I] Handle to a palette for the conversion
 618  *  pColorRef [O] Destination for converted color, or NULL to test if the conversion is ok
 619  *
 620  * RETURNS
 621  *  Success: S_OK. The conversion is ok, and pColorRef contains the converted color if non-NULL.
 622  *  Failure: E_INVALIDARG, if any argument is invalid.
 623  *
 624  * FIXME
 625  *  Document the conversion rules.
 626  */
 627 HRESULT WINAPI OleTranslateColor(
 628   OLE_COLOR clr,
 629   HPALETTE  hpal,
 630   COLORREF* pColorRef)
 631 {
 632   COLORREF colorref;
 633   BYTE b = HIBYTE(HIWORD(clr));
 634
 635   TRACE("(%08x, %p, %p)\n", clr, hpal, pColorRef);
 636
 637   /*
 638    * In case pColorRef is NULL, provide our own to simplify the code.
 639    */
 640   if (pColorRef == NULL)
 641     pColorRef = &colorref;
 642
 643   switch (b)
 644   {
 645     case 0x00:
 646     {
 647       if (hpal != 0)
 648         *pColorRef =  PALETTERGB(GetRValue(clr),
 649                                  GetGValue(clr),
 650                                  GetBValue(clr));
 651       else
 652         *pColorRef = clr;
 653
 654       break;
 655     }
 656
 657     case 0x01:
 658     {
 659       if (hpal != 0)
 660       {
 661         PALETTEENTRY pe;
 662         /*
 663          * Validate the palette index.
 664          */
 665         if (GetPaletteEntries(hpal, LOWORD(clr), 1, &pe) == 0)
 666           return E_INVALIDARG;
 667       }
 668
 669       *pColorRef = clr;
 670
 671       break;
 672     }
 673
 674     case 0x02:
 675       *pColorRef = clr;
 676       break;
 677
 678     case 0x80:
 679     {
 680       int index = LOBYTE(LOWORD(clr));
 681
 682       /*
 683        * Validate GetSysColor index.
 684        */
 685       if ((index < COLOR_SCROLLBAR) || (index > COLOR_MENUBAR))
 686         return E_INVALIDARG;
 687
 688       *pColorRef =  GetSysColor(index);
 689
 690       break;
 691     }
 692
 693     default:
 694       return E_INVALIDARG;
 695   }
 696
 697   return S_OK;
 698 }
 699
 700 extern HRESULT OLEAUTPS_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv);
 701
 702 extern void _get_STDFONT_CF(LPVOID *);
 703 extern void _get_STDPIC_CF(LPVOID *);
 704
 705 static HRESULT WINAPI PSDispatchFacBuf_QueryInterface(IPSFactoryBuffer *iface, REFIID riid, void **ppv)
 706 {
 707     if (IsEqualIID(riid, &IID_IUnknown) ||
 708         IsEqualIID(riid, &IID_IPSFactoryBuffer))
 709     {
 710         IUnknown_AddRef(iface);
 711         *ppv = (void *)iface;
 712         return S_OK;
 713     }
 714     return E_NOINTERFACE;
 715 }
 716
 717 static ULONG WINAPI PSDispatchFacBuf_AddRef(IPSFactoryBuffer *iface)
 718 {
 719     return 2;
 720 }
 721
 722 static ULONG WINAPI PSDispatchFacBuf_Release(IPSFactoryBuffer *iface)
 723 {
 724     return 1;
 725 }
 726
 727 static HRESULT WINAPI PSDispatchFacBuf_CreateProxy(IPSFactoryBuffer *iface, IUnknown *pUnkOuter, REFIID riid, IRpcProxyBuffer **ppProxy, void **ppv)
 728 {
 729     IPSFactoryBuffer *pPSFB;
 730     HRESULT hr;
 731
 732     if (IsEqualIID(riid, &IID_IDispatch))
 733         hr = OLEAUTPS_DllGetClassObject(&CLSID_PSDispatch, &IID_IPSFactoryBuffer, (void **)&pPSFB);
 734     else
 735         hr = TMARSHAL_DllGetClassObject(&CLSID_PSOAInterface, &IID_IPSFactoryBuffer, (void **)&pPSFB);
 736
 737     if (FAILED(hr)) return hr;
 738
 739     hr = IPSFactoryBuffer_CreateProxy(pPSFB, pUnkOuter, riid, ppProxy, ppv);
 740
 741     IPSFactoryBuffer_Release(pPSFB);
 742     return hr;
 743 }
 744
 745 static HRESULT WINAPI PSDispatchFacBuf_CreateStub(IPSFactoryBuffer *iface, REFIID riid, IUnknown *pUnkOuter, IRpcStubBuffer **ppStub)
 746 {
 747     IPSFactoryBuffer *pPSFB;
 748     HRESULT hr;
 749
 750     if (IsEqualIID(riid, &IID_IDispatch))
 751         hr = OLEAUTPS_DllGetClassObject(&CLSID_PSDispatch, &IID_IPSFactoryBuffer, (void **)&pPSFB);
 752     else
 753         hr = TMARSHAL_DllGetClassObject(&CLSID_PSOAInterface, &IID_IPSFactoryBuffer, (void **)&pPSFB);
 754
 755     if (FAILED(hr)) return hr;
 756
 757     hr = IPSFactoryBuffer_CreateStub(pPSFB, riid, pUnkOuter, ppStub);
 758
 759     IPSFactoryBuffer_Release(pPSFB);
 760     return hr;
 761 }
 762
 763 static const IPSFactoryBufferVtbl PSDispatchFacBuf_Vtbl =
 764 {
 765     PSDispatchFacBuf_QueryInterface,
 766     PSDispatchFacBuf_AddRef,
 767     PSDispatchFacBuf_Release,
 768     PSDispatchFacBuf_CreateProxy,
 769     PSDispatchFacBuf_CreateStub
 770 };
 771
 772 /* This is the whole PSFactoryBuffer object, just the vtableptr */
 773 static const IPSFactoryBufferVtbl *pPSDispatchFacBuf = &PSDispatchFacBuf_Vtbl;
 774
 775 /***********************************************************************
 776  *              DllGetClassObject (OLEAUT32.@)
 777  */
 778 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID iid, LPVOID *ppv)
 779 {
 780     *ppv = NULL;
 781     if (IsEqualGUID(rclsid,&CLSID_StdFont)) {
 782         if (IsEqualGUID(iid,&IID_IClassFactory)) {
 783             _get_STDFONT_CF(ppv);
 784             IClassFactory_AddRef((IClassFactory*)*ppv);
 785             return S_OK;
 786         }
 787     }
 788     if (IsEqualGUID(rclsid,&CLSID_StdPicture)) {
 789         if (IsEqualGUID(iid,&IID_IClassFactory)) {
 790             _get_STDPIC_CF(ppv);
 791             IClassFactory_AddRef((IClassFactory*)*ppv);
 792             return S_OK;
 793         }
 794     }
 795     if (IsEqualCLSID(rclsid, &CLSID_PSTypeInfo) ||
 796         IsEqualCLSID(rclsid, &CLSID_PSTypeLib) ||
 797         IsEqualCLSID(rclsid, &CLSID_PSEnumVariant)) {
 798         return OLEAUTPS_DllGetClassObject(&CLSID_PSDispatch, iid, ppv);
 799     }
 800     if (IsEqualCLSID(rclsid, &CLSID_PSDispatch) && IsEqualIID(iid, &IID_IPSFactoryBuffer)) {
 801         *ppv = &pPSDispatchFacBuf;
 802         IPSFactoryBuffer_AddRef((IPSFactoryBuffer *)*ppv);
 803         return S_OK;
 804     }
 805     if (IsEqualGUID(rclsid,&CLSID_PSOAInterface)) {
 806         if (S_OK==TMARSHAL_DllGetClassObject(rclsid,iid,ppv))
 807             return S_OK;
 808         /*FALLTHROUGH*/
 809     }
 810     return OLEAUTPS_DllGetClassObject(rclsid, iid, ppv);
 811 }
 812
 813 /***********************************************************************
 814  *              DllCanUnloadNow (OLEAUT32.@)
 815  *
 816  * Determine if this dll can be unloaded from the callers address space.
 817  *
 818  * PARAMS
 819  *  None.
 820  *
 821  * RETURNS
 822  *  Always returns S_FALSE. This dll cannot be unloaded.
 823  */
 824 HRESULT WINAPI DllCanUnloadNow(void)
 825 {
 826     return S_FALSE;
 827 }
 828
 829 /*****************************************************************************
 830  *              DllMain         [OLEAUT32.@]
 831  */
 832 BOOL WINAPI DllMain(HINSTANCE hInstDll, DWORD fdwReason, LPVOID lpvReserved)
 833 {
 834   TRACE("(%p,%d,%p)\n", hInstDll, fdwReason, lpvReserved);
 835
 836   switch (fdwReason) {
 837   case DLL_PROCESS_ATTACH:
 838     DisableThreadLibraryCalls(hInstDll);
 839     OLEAUT32_hModule = hInstDll;
 840     break;
 841   case DLL_PROCESS_DETACH:
 842     break;
 843   };
 844
 845   return TRUE;
 846 }
 847
 848 /***********************************************************************
 849  *              OleIconToCursor (OLEAUT32.415)
 850  */
 851 HCURSOR WINAPI OleIconToCursor( HINSTANCE hinstExe, HICON hIcon)
 852 {
 853     FIXME("(%p,%p), partially implemented.\n",hinstExe,hIcon);
 854     /* FIXME: make a extended conversation from HICON to HCURSOR */
 855     return CopyCursor(hIcon);
 856 }