dlls/ole2disp.dll16/ole2disp.c

   1 /*
   2  *      OLE2DISP library
   3  *
   4  *      Copyright 1995  Martin von Loewis
   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 "config.h"
  22
  23 #include <stdarg.h>
  24 #include <string.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "wingdi.h"
  29 #include "winuser.h"
  30 #include "ole2.h"
  31 #include "oleauto.h"
  32 #include "winerror.h"
  33 #include "wownt32.h"
  34 #include "wine/windef16.h"
  35 #include "wine/winbase16.h"
  36
  37 #include "ole2disp.h"
  38
  39 #include "wine/debug.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  42
  43 #define E_OUTOFMEMORY16 MAKE_SCODE(SEVERITY_ERROR, FACILITY_NULL, 2)
  44 #define E_INVALIDARG16  MAKE_SCODE(SEVERITY_ERROR, FACILITY_NULL, 3)
  45
  46 /* 16-bit SAFEARRAY implementation */
  47 typedef struct tagSAFEARRAYBOUND16
  48 {
  49     ULONG cElements;
  50     LONG  lLbound;
  51 } SAFEARRAYBOUND16;
  52
  53 typedef struct tagSAFEARRAY16
  54 {
  55     USHORT cDims;
  56     USHORT fFeatures;
  57     USHORT cbElements;
  58     USHORT cLocks;
  59     ULONG  handle;
  60     SEGPTR pvData;
  61     SAFEARRAYBOUND16 rgsabound[1];
  62 } SAFEARRAY16;
  63
  64 static SEGPTR safearray_alloc(ULONG size)
  65 {
  66     HANDLE16 h;
  67     return WOWGlobalAllocLock16(GPTR, size, &h);
  68 }
  69
  70 static void safearray_free(SEGPTR ptr)
  71 {
  72     WOWGlobalUnlockFree16(ptr);
  73 }
  74
  75 static ULONG safearray_getcellcount(const SAFEARRAY16 *sa)
  76 {
  77     const SAFEARRAYBOUND16 *sab = sa->rgsabound;
  78     USHORT count = sa->cDims;
  79     ULONG cells = 1;
  80
  81     while (count--)
  82     {
  83         if (!sab->cElements)
  84             return 0;
  85         cells *= sab->cElements;
  86         sab++;
  87     }
  88
  89     return cells;
  90 }
  91
  92 static HRESULT safearray_lock(SAFEARRAY16 *sa)
  93 {
  94     if (sa->cLocks == 0xffff)
  95         return E_UNEXPECTED;
  96
  97     sa->cLocks++;
  98     return S_OK;
  99 }
 100
 101 /******************************************************************************
 102  *    SafeArrayGetDim [OLE2DISP.17]
 103  */
 104 USHORT WINAPI SafeArrayGetDim16(SAFEARRAY16 *sa)
 105 {
 106     TRACE("(%p)\n", sa);
 107     return sa->cDims;
 108 }
 109
 110 /******************************************************************************
 111  *    SafeArrayGetElemsize [OLE2DISP.18]
 112  */
 113 USHORT WINAPI SafeArrayGetElemsize16(SAFEARRAY16 *sa)
 114 {
 115     TRACE("(%p)\n", sa);
 116     return sa->cbElements;
 117 }
 118
 119 /******************************************************************************
 120  *    SafeArrayGetUBound [OLE2DISP.19]
 121  */
 122 HRESULT WINAPI SafeArrayGetUBound16(SAFEARRAY16 *sa, UINT16 dim, LONG *ubound)
 123 {
 124     TRACE("(%p, %u, %p)\n", sa, dim, ubound);
 125
 126     if (!sa)
 127         return E_INVALIDARG16;
 128
 129     if (!dim || dim > sa->cDims)
 130         return DISP_E_BADINDEX;
 131
 132     *ubound = sa->rgsabound[sa->cDims - dim].lLbound + sa->rgsabound[sa->cDims - dim].cElements - 1;
 133
 134     return S_OK;
 135 }
 136
 137 /******************************************************************************
 138  *    SafeArrayGetLBound [OLE2DISP.20]
 139  */
 140 HRESULT WINAPI SafeArrayGetLBound16(SAFEARRAY16 *sa, UINT16 dim, LONG *lbound)
 141 {
 142     TRACE("(%p, %u, %p)\n", sa, dim, lbound);
 143
 144     if (!sa)
 145         return E_INVALIDARG16;
 146
 147     if (!dim || dim > sa->cDims)
 148         return DISP_E_BADINDEX;
 149
 150     *lbound = sa->rgsabound[sa->cDims - dim].lLbound;
 151
 152     return S_OK;
 153 }
 154
 155 /******************************************************************************
 156  *    SafeArrayLock [OLE2DISP.21]
 157  */
 158 HRESULT WINAPI SafeArrayLock16(SAFEARRAY16 *sa)
 159 {
 160     TRACE("(%p)\n", sa);
 161
 162     if (!sa)
 163         return E_INVALIDARG16;
 164
 165     return safearray_lock(sa);
 166 }
 167
 168 /******************************************************************************
 169  *    SafeArrayUnlock [OLE2DISP.22]
 170  */
 171 HRESULT WINAPI SafeArrayUnlock16(SAFEARRAY16 *sa)
 172 {
 173     TRACE("(%p)\n", sa);
 174
 175     if (!sa)
 176         return E_INVALIDARG16;
 177
 178     if (sa->cLocks == 0)
 179         return E_UNEXPECTED;
 180
 181     sa->cLocks--;
 182     return S_OK;
 183 }
 184
 185 /******************************************************************************
 186  *    SafeArrayAccessData [OLE2DISP.23]
 187  */
 188 HRESULT WINAPI SafeArrayAccessData16(SAFEARRAY16 *sa, SEGPTR *data)
 189 {
 190     HRESULT hr;
 191
 192     TRACE("(%p, %p)\n", sa, data);
 193
 194     /* arguments are not tested, it crashes if any of them is NULL */
 195
 196     hr = safearray_lock(sa);
 197     if (FAILED(hr))
 198         return hr;
 199
 200     *data = sa->pvData;
 201     return S_OK;
 202 }
 203
 204 /******************************************************************************
 205  *    SafeArrayUnaccessData [OLE2DISP.24]
 206  */
 207 HRESULT WINAPI SafeArrayUnaccessData16(SAFEARRAY16 *sa)
 208 {
 209     TRACE("(%p)\n", sa);
 210     return SafeArrayUnlock16(sa);
 211 }
 212
 213 /******************************************************************************
 214  *    SafeArrayAllocDescriptor [OLE2DISP.38]
 215  */
 216 HRESULT WINAPI SafeArrayAllocDescriptor16(UINT16 dims, SEGPTR *ret)
 217 {
 218     SAFEARRAY16 *sa;
 219     ULONG size;
 220
 221     TRACE("%u, %p\n", dims, ret);
 222
 223     if (!dims)
 224         return E_INVALIDARG16;
 225
 226     size = sizeof(SAFEARRAY16) + sizeof(SAFEARRAYBOUND16) * (dims - 1);
 227     *ret = safearray_alloc(size);
 228     if (!*ret)
 229         return E_OUTOFMEMORY16;
 230
 231     sa = MapSL(*ret);
 232     sa->cDims = dims;
 233     return S_OK;
 234 }
 235
 236 /******************************************************************************
 237  *    SafeArrayAllocData [OLE2DISP.39]
 238  */
 239 HRESULT WINAPI SafeArrayAllocData16(SAFEARRAY16 *sa)
 240 {
 241     ULONG size;
 242
 243     TRACE("%p\n", sa);
 244
 245     if (!sa)
 246         return E_INVALIDARG16;
 247
 248     size = safearray_getcellcount(sa);
 249     sa->pvData = safearray_alloc(size * sa->cbElements);
 250     return sa->pvData ? S_OK : E_OUTOFMEMORY16;
 251 }
 252
 253 /******************************************************************************
 254  *    SafeArrayDestroyDescriptor [OLE2DISP.40]
 255  */
 256 HRESULT WINAPI SafeArrayDestroyDescriptor16(SEGPTR s)
 257 {
 258     TRACE("0x%08x\n", s);
 259
 260     if (s)
 261     {
 262         SAFEARRAY16 *sa = MapSL(s);
 263
 264         if (sa->cLocks)
 265             return DISP_E_ARRAYISLOCKED;
 266
 267         safearray_free(s);
 268     }
 269
 270     return S_OK;
 271 }
 272
 273 /******************************************************************************
 274  *    SafeArrayDestroyData [OLE2DISP.41]
 275  */
 276 HRESULT WINAPI SafeArrayDestroyData16(SAFEARRAY16 *sa)
 277 {
 278     TRACE("%p\n", sa);
 279
 280     if (!sa)
 281         return S_OK;
 282
 283     if (sa->cLocks)
 284         return DISP_E_ARRAYISLOCKED;
 285
 286     if (!(sa->fFeatures & FADF_STATIC))
 287         safearray_free(sa->pvData);
 288
 289     return S_OK;
 290 }
 291
 292 /* This implementation of the BSTR API is 16-bit only. It
 293    represents BSTR as a 16:16 far pointer, and the strings
 294    as ISO-8859 */
 295
 296 /******************************************************************************
 297  *              BSTR_AllocBytes [Internal]
 298  */
 299 static BSTR16 BSTR_AllocBytes(int n)
 300 {
 301     void *ptr = HeapAlloc( GetProcessHeap(), 0, n );
 302     return (BSTR16)MapLS(ptr);
 303 }
 304
 305 /******************************************************************************
 306  * BSTR_Free [INTERNAL]
 307  */
 308 static void BSTR_Free(BSTR16 in)
 309 {
 310     void *ptr = MapSL( (SEGPTR)in );
 311     UnMapLS( (SEGPTR)in );
 312     HeapFree( GetProcessHeap(), 0, ptr );
 313 }
 314
 315 /******************************************************************************
 316  * BSTR_GetAddr [INTERNAL]
 317  */
 318 static void* BSTR_GetAddr(BSTR16 in)
 319 {
 320     return in ? MapSL((SEGPTR)in) : 0;
 321 }
 322
 323 /******************************************************************************
 324  *              SysAllocString  [OLE2DISP.2]
 325  *
 326  * Create a BSTR16 from an OLESTR16 (16 Bit).
 327  *
 328  * PARAMS
 329  *  oleStr [I] Source to create BSTR16 from
 330  *
 331  * RETURNS
 332  *  Success: A BSTR16 allocated with SysAllocStringLen16().
 333  *  Failure: NULL, if oleStr is NULL.
 334  */
 335 BSTR16 WINAPI SysAllocString16(LPCOLESTR16 oleStr)
 336 {
 337         BSTR16 out;
 338
 339         if (!oleStr) return 0;
 340
 341         out = BSTR_AllocBytes(strlen(oleStr)+1);
 342         if (!out) return 0;
 343         strcpy(BSTR_GetAddr(out),oleStr);
 344         return out;
 345 }
 346
 347 /******************************************************************************
 348  *              SysReallocString        [OLE2DISP.3]
 349  *
 350  * Change the length of a previously created BSTR16 (16 Bit).
 351  *
 352  * PARAMS
 353  *  pbstr  [I] BSTR16 to change the length of
 354  *  oleStr [I] New source for pbstr
 355  *
 356  * RETURNS
 357  *  Success: 1
 358  *  Failure: 0.
 359  *
 360  * NOTES
 361  *  SysAllocStringStringLen16().
 362  */
 363 INT16 WINAPI SysReAllocString16(LPBSTR16 pbstr,LPCOLESTR16 oleStr)
 364 {
 365         BSTR16 new=SysAllocString16(oleStr);
 366         BSTR_Free(*pbstr);
 367         *pbstr=new;
 368         return 1;
 369 }
 370
 371 /******************************************************************************
 372  *              SysAllocStringLen       [OLE2DISP.4]
 373  *
 374  * Create a BSTR16 from an OLESTR16 of a given character length (16 Bit).
 375  *
 376  * PARAMS
 377  *  oleStr [I] Source to create BSTR16 from
 378  *  len    [I] Length of oleStr in wide characters
 379  *
 380  * RETURNS
 381  *  Success: A newly allocated BSTR16 from SysAllocStringByteLen16()
 382  *  Failure: NULL, if len is >= 0x80000000, or memory allocation fails.
 383  *
 384  * NOTES
 385  *  See SysAllocStringByteLen16().
 386  */
 387 BSTR16 WINAPI SysAllocStringLen16(const char *oleStr, int len)
 388 {
 389     BSTR16 out=BSTR_AllocBytes(len+1);
 390
 391     if (!out)
 392         return 0;
 393
 394     /*
 395     * Copy the information in the buffer.
 396     * Since it is valid to pass a NULL pointer here, we'll initialize the
 397     * buffer to nul if it is the case.
 398     */
 399     if (oleStr != 0)
 400         strcpy(BSTR_GetAddr(out),oleStr);
 401     else
 402         memset(BSTR_GetAddr(out), 0, len+1);
 403
 404     return out;
 405 }
 406
 407 /******************************************************************************
 408  *              SysReAllocStringLen     [OLE2DISP.5]
 409  *
 410  * Change the length of a previously created BSTR16 (16 Bit).
 411  *
 412  * PARAMS
 413  *  pbstr  [I] BSTR16 to change the length of
 414  *  oleStr [I] New source for pbstr
 415  *  len    [I] Length of oleStr in characters
 416  *
 417  * RETURNS
 418  *  Success: 1. The size of pbstr is updated.
 419  *  Failure: 0, if len >= 0x8000 or memory allocation fails.
 420  *
 421  * NOTES
 422  *  See SysAllocStringByteLen16().
 423  *  *pbstr may be changed by this function.
 424  */
 425 int WINAPI SysReAllocStringLen16(BSTR16 *old,const char *in,int len)
 426 {
 427         /* FIXME: Check input length */
 428         BSTR16 new=SysAllocStringLen16(in,len);
 429         BSTR_Free(*old);
 430         *old=new;
 431         return 1;
 432 }
 433
 434 /******************************************************************************
 435  *              SysFreeString   [OLE2DISP.6]
 436  *
 437  * Free a BSTR16 (16 Bit).
 438  *
 439  * PARAMS
 440  *  str [I] String to free.
 441  *
 442  * RETURNS
 443  *  Nothing.
 444  */
 445 void WINAPI SysFreeString16(BSTR16 str)
 446 {
 447         BSTR_Free(str);
 448 }
 449
 450 /******************************************************************************
 451  *              SysStringLen    [OLE2DISP.7]
 452  *
 453  * Get the allocated length of a BSTR16 in characters (16 Bit).
 454  *
 455  * PARAMS
 456  *  str [I] BSTR16 to find the length of
 457  *
 458  * RETURNS
 459  *  The allocated length of str, or 0 if str is NULL.
 460  */
 461 int WINAPI SysStringLen16(BSTR16 str)
 462 {
 463         return strlen(BSTR_GetAddr(str));
 464 }
 465
 466 /******************************************************************************
 467  * VariantChangeType [OLE2DISP.12]
 468  */
 469 HRESULT WINAPI VariantChangeType16(VARIANTARG *vargDest, VARIANTARG *varSrc, unsigned short flags, VARTYPE vt)
 470 {
 471     FIXME("stub: (%p, %p, %d, %d)\n", vargDest, varSrc, flags, vt);
 472     return E_NOTIMPL;
 473 }
 474
 475
 476 /******************************************************************************
 477  * CreateDispTypeInfo [OLE2DISP.31]
 478  */
 479 HRESULT WINAPI CreateDispTypeInfo16(
 480         INTERFACEDATA *pidata,
 481         LCID lcid,
 482         ITypeInfo **pptinfo)
 483 {
 484         FIXME("(%p,%d,%p),stub\n",pidata,lcid,pptinfo);
 485         return E_NOTIMPL;
 486 }
 487
 488 /******************************************************************************
 489  * CreateStdDispatch [OLE2DISP.32]
 490  */
 491 HRESULT WINAPI CreateStdDispatch16(
 492         IUnknown* punkOuter,
 493         void* pvThis,
 494         ITypeInfo* ptinfo,
 495         IUnknown** ppunkStdDisp)
 496 {
 497         FIXME("(%p,%p,%p,%p),stub\n",punkOuter, pvThis, ptinfo,
 498                ppunkStdDisp);
 499         return 0;
 500 }
 501
 502 /******************************************************************************
 503  * RegisterActiveObject [OLE2DISP.35]
 504  */
 505 HRESULT WINAPI RegisterActiveObject16(
 506         IUnknown *punk, REFCLSID rclsid, DWORD dwFlags, unsigned long *pdwRegister
 507 ) {
 508         FIXME("(%p,%s,0x%08x,%p):stub\n",punk,debugstr_guid(rclsid),dwFlags,pdwRegister);
 509         return E_NOTIMPL;
 510 }
 511
 512 /******************************************************************************
 513  * VariantChangeTypeEx [OLE2DISP.108]
 514  */
 515 HRESULT WINAPI VariantChangeTypeEx16(VARIANTARG *dest, const VARIANTARG *src, LCID lcid, USHORT flags, VARTYPE vt)
 516 {
 517         FIXME("stub: %p %p %d %d %d\n", dest, src, lcid, flags, vt);
 518         return E_INVALIDARG;
 519 }
 520
 521 /******************************************************************************
 522  * SetErrorInfo [OLE2DISP.110]
 523  */
 524 HRESULT WINAPI SetErrorInfo16(ULONG dwReserved, IErrorInfo *perrinfo)
 525 {
 526         FIXME("stub: (%d, %p)\n", dwReserved, perrinfo);
 527         return E_INVALIDARG;
 528 }
 529
 530 /******************************************************************************
 531  * VariantInit [OLE2DISP.8]
 532  */
 533 void WINAPI VariantInit16(VARIANTARG16 *v)
 534 {
 535     TRACE("(%p)\n", v);
 536     v->vt = VT_EMPTY;
 537 }