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  *    SafeArrayLock [OLE2DISP.21]
 121  */
 122 HRESULT WINAPI SafeArrayLock16(SAFEARRAY16 *sa)
 123 {
 124     TRACE("(%p)\n", sa);
 125
 126     if (!sa)
 127         return E_INVALIDARG16;
 128
 129     return safearray_lock(sa);
 130 }
 131
 132 /******************************************************************************
 133  *    SafeArrayUnlock [OLE2DISP.22]
 134  */
 135 HRESULT WINAPI SafeArrayUnlock16(SAFEARRAY16 *sa)
 136 {
 137     TRACE("(%p)\n", sa);
 138
 139     if (!sa)
 140         return E_INVALIDARG16;
 141
 142     if (sa->cLocks == 0)
 143         return E_UNEXPECTED;
 144
 145     sa->cLocks--;
 146     return S_OK;
 147 }
 148
 149 /******************************************************************************
 150  *    SafeArrayAccessData [OLE2DISP.23]
 151  */
 152 HRESULT WINAPI SafeArrayAccessData16(SAFEARRAY16 *sa, SEGPTR *data)
 153 {
 154     HRESULT hr;
 155
 156     TRACE("(%p, %p)\n", sa, data);
 157
 158     /* arguments are not tested, it crashes if any of them is NULL */
 159
 160     hr = safearray_lock(sa);
 161     if (FAILED(hr))
 162         return hr;
 163
 164     *data = sa->pvData;
 165     return S_OK;
 166 }
 167
 168 /******************************************************************************
 169  *    SafeArrayUnaccessData [OLE2DISP.24]
 170  */
 171 HRESULT WINAPI SafeArrayUnaccessData16(SAFEARRAY16 *sa)
 172 {
 173     TRACE("(%p)\n", sa);
 174     return SafeArrayUnlock16(sa);
 175 }
 176
 177 /******************************************************************************
 178  *    SafeArrayAllocDescriptor [OLE2DISP.38]
 179  */
 180 HRESULT WINAPI SafeArrayAllocDescriptor16(UINT16 dims, SEGPTR *ret)
 181 {
 182     SAFEARRAY16 *sa;
 183     ULONG size;
 184
 185     TRACE("%u, %p\n", dims, ret);
 186
 187     if (!dims)
 188         return E_INVALIDARG16;
 189
 190     size = sizeof(SAFEARRAY16) + sizeof(SAFEARRAYBOUND16) * (dims - 1);
 191     *ret = safearray_alloc(size);
 192     if (!*ret)
 193         return E_OUTOFMEMORY16;
 194
 195     sa = MapSL(*ret);
 196     sa->cDims = dims;
 197     return S_OK;
 198 }
 199
 200 /******************************************************************************
 201  *    SafeArrayAllocData [OLE2DISP.39]
 202  */
 203 HRESULT WINAPI SafeArrayAllocData16(SAFEARRAY16 *sa)
 204 {
 205     ULONG size;
 206
 207     TRACE("%p\n", sa);
 208
 209     if (!sa)
 210         return E_INVALIDARG16;
 211
 212     size = safearray_getcellcount(sa);
 213     sa->pvData = safearray_alloc(size * sa->cbElements);
 214     return sa->pvData ? S_OK : E_OUTOFMEMORY16;
 215 }
 216
 217 /******************************************************************************
 218  *    SafeArrayDestroyDescriptor [OLE2DISP.40]
 219  */
 220 HRESULT WINAPI SafeArrayDestroyDescriptor16(SEGPTR s)
 221 {
 222     TRACE("0x%08x\n", s);
 223
 224     if (s)
 225     {
 226         SAFEARRAY16 *sa = MapSL(s);
 227
 228         if (sa->cLocks)
 229             return DISP_E_ARRAYISLOCKED;
 230
 231         safearray_free(s);
 232     }
 233
 234     return S_OK;
 235 }
 236
 237 /* This implementation of the BSTR API is 16-bit only. It
 238    represents BSTR as a 16:16 far pointer, and the strings
 239    as ISO-8859 */
 240
 241 /******************************************************************************
 242  *              BSTR_AllocBytes [Internal]
 243  */
 244 static BSTR16 BSTR_AllocBytes(int n)
 245 {
 246     void *ptr = HeapAlloc( GetProcessHeap(), 0, n );
 247     return (BSTR16)MapLS(ptr);
 248 }
 249
 250 /******************************************************************************
 251  * BSTR_Free [INTERNAL]
 252  */
 253 static void BSTR_Free(BSTR16 in)
 254 {
 255     void *ptr = MapSL( (SEGPTR)in );
 256     UnMapLS( (SEGPTR)in );
 257     HeapFree( GetProcessHeap(), 0, ptr );
 258 }
 259
 260 /******************************************************************************
 261  * BSTR_GetAddr [INTERNAL]
 262  */
 263 static void* BSTR_GetAddr(BSTR16 in)
 264 {
 265     return in ? MapSL((SEGPTR)in) : 0;
 266 }
 267
 268 /******************************************************************************
 269  *              SysAllocString  [OLE2DISP.2]
 270  *
 271  * Create a BSTR16 from an OLESTR16 (16 Bit).
 272  *
 273  * PARAMS
 274  *  oleStr [I] Source to create BSTR16 from
 275  *
 276  * RETURNS
 277  *  Success: A BSTR16 allocated with SysAllocStringLen16().
 278  *  Failure: NULL, if oleStr is NULL.
 279  */
 280 BSTR16 WINAPI SysAllocString16(LPCOLESTR16 oleStr)
 281 {
 282         BSTR16 out;
 283
 284         if (!oleStr) return 0;
 285
 286         out = BSTR_AllocBytes(strlen(oleStr)+1);
 287         if (!out) return 0;
 288         strcpy(BSTR_GetAddr(out),oleStr);
 289         return out;
 290 }
 291
 292 /******************************************************************************
 293  *              SysReallocString        [OLE2DISP.3]
 294  *
 295  * Change the length of a previously created BSTR16 (16 Bit).
 296  *
 297  * PARAMS
 298  *  pbstr  [I] BSTR16 to change the length of
 299  *  oleStr [I] New source for pbstr
 300  *
 301  * RETURNS
 302  *  Success: 1
 303  *  Failure: 0.
 304  *
 305  * NOTES
 306  *  SysAllocStringStringLen16().
 307  */
 308 INT16 WINAPI SysReAllocString16(LPBSTR16 pbstr,LPCOLESTR16 oleStr)
 309 {
 310         BSTR16 new=SysAllocString16(oleStr);
 311         BSTR_Free(*pbstr);
 312         *pbstr=new;
 313         return 1;
 314 }
 315
 316 /******************************************************************************
 317  *              SysAllocStringLen       [OLE2DISP.4]
 318  *
 319  * Create a BSTR16 from an OLESTR16 of a given character length (16 Bit).
 320  *
 321  * PARAMS
 322  *  oleStr [I] Source to create BSTR16 from
 323  *  len    [I] Length of oleStr in wide characters
 324  *
 325  * RETURNS
 326  *  Success: A newly allocated BSTR16 from SysAllocStringByteLen16()
 327  *  Failure: NULL, if len is >= 0x80000000, or memory allocation fails.
 328  *
 329  * NOTES
 330  *  See SysAllocStringByteLen16().
 331  */
 332 BSTR16 WINAPI SysAllocStringLen16(const char *oleStr, int len)
 333 {
 334     BSTR16 out=BSTR_AllocBytes(len+1);
 335
 336     if (!out)
 337         return 0;
 338
 339     /*
 340     * Copy the information in the buffer.
 341     * Since it is valid to pass a NULL pointer here, we'll initialize the
 342     * buffer to nul if it is the case.
 343     */
 344     if (oleStr != 0)
 345         strcpy(BSTR_GetAddr(out),oleStr);
 346     else
 347         memset(BSTR_GetAddr(out), 0, len+1);
 348
 349     return out;
 350 }
 351
 352 /******************************************************************************
 353  *              SysReAllocStringLen     [OLE2DISP.5]
 354  *
 355  * Change the length of a previously created BSTR16 (16 Bit).
 356  *
 357  * PARAMS
 358  *  pbstr  [I] BSTR16 to change the length of
 359  *  oleStr [I] New source for pbstr
 360  *  len    [I] Length of oleStr in characters
 361  *
 362  * RETURNS
 363  *  Success: 1. The size of pbstr is updated.
 364  *  Failure: 0, if len >= 0x8000 or memory allocation fails.
 365  *
 366  * NOTES
 367  *  See SysAllocStringByteLen16().
 368  *  *pbstr may be changed by this function.
 369  */
 370 int WINAPI SysReAllocStringLen16(BSTR16 *old,const char *in,int len)
 371 {
 372         /* FIXME: Check input length */
 373         BSTR16 new=SysAllocStringLen16(in,len);
 374         BSTR_Free(*old);
 375         *old=new;
 376         return 1;
 377 }
 378
 379 /******************************************************************************
 380  *              SysFreeString   [OLE2DISP.6]
 381  *
 382  * Free a BSTR16 (16 Bit).
 383  *
 384  * PARAMS
 385  *  str [I] String to free.
 386  *
 387  * RETURNS
 388  *  Nothing.
 389  */
 390 void WINAPI SysFreeString16(BSTR16 str)
 391 {
 392         BSTR_Free(str);
 393 }
 394
 395 /******************************************************************************
 396  *              SysStringLen    [OLE2DISP.7]
 397  *
 398  * Get the allocated length of a BSTR16 in characters (16 Bit).
 399  *
 400  * PARAMS
 401  *  str [I] BSTR16 to find the length of
 402  *
 403  * RETURNS
 404  *  The allocated length of str, or 0 if str is NULL.
 405  */
 406 int WINAPI SysStringLen16(BSTR16 str)
 407 {
 408         return strlen(BSTR_GetAddr(str));
 409 }
 410
 411 /******************************************************************************
 412  * VariantChangeType [OLE2DISP.12]
 413  */
 414 HRESULT WINAPI VariantChangeType16(VARIANTARG *vargDest, VARIANTARG *varSrc, unsigned short flags, VARTYPE vt)
 415 {
 416     FIXME("stub: (%p, %p, %d, %d)\n", vargDest, varSrc, flags, vt);
 417     return E_NOTIMPL;
 418 }
 419
 420
 421 /******************************************************************************
 422  * CreateDispTypeInfo [OLE2DISP.31]
 423  */
 424 HRESULT WINAPI CreateDispTypeInfo16(
 425         INTERFACEDATA *pidata,
 426         LCID lcid,
 427         ITypeInfo **pptinfo)
 428 {
 429         FIXME("(%p,%d,%p),stub\n",pidata,lcid,pptinfo);
 430         return E_NOTIMPL;
 431 }
 432
 433 /******************************************************************************
 434  * CreateStdDispatch [OLE2DISP.32]
 435  */
 436 HRESULT WINAPI CreateStdDispatch16(
 437         IUnknown* punkOuter,
 438         void* pvThis,
 439         ITypeInfo* ptinfo,
 440         IUnknown** ppunkStdDisp)
 441 {
 442         FIXME("(%p,%p,%p,%p),stub\n",punkOuter, pvThis, ptinfo,
 443                ppunkStdDisp);
 444         return 0;
 445 }
 446
 447 /******************************************************************************
 448  * RegisterActiveObject [OLE2DISP.35]
 449  */
 450 HRESULT WINAPI RegisterActiveObject16(
 451         IUnknown *punk, REFCLSID rclsid, DWORD dwFlags, unsigned long *pdwRegister
 452 ) {
 453         FIXME("(%p,%s,0x%08x,%p):stub\n",punk,debugstr_guid(rclsid),dwFlags,pdwRegister);
 454         return E_NOTIMPL;
 455 }
 456
 457 /******************************************************************************
 458  * VariantChangeTypeEx [OLE2DISP.108]
 459  */
 460 HRESULT WINAPI VariantChangeTypeEx16(VARIANTARG *dest, const VARIANTARG *src, LCID lcid, USHORT flags, VARTYPE vt)
 461 {
 462         FIXME("stub: %p %p %d %d %d\n", dest, src, lcid, flags, vt);
 463         return E_INVALIDARG;
 464 }
 465
 466 /******************************************************************************
 467  * SetErrorInfo [OLE2DISP.110]
 468  */
 469 HRESULT WINAPI SetErrorInfo16(ULONG dwReserved, IErrorInfo *perrinfo)
 470 {
 471         FIXME("stub: (%d, %p)\n", dwReserved, perrinfo);
 472         return E_INVALIDARG;
 473 }
 474
 475 /******************************************************************************
 476  * VariantInit [OLE2DISP.8]
 477  */
 478 void WINAPI VariantInit16(VARIANTARG16 *v)
 479 {
 480     TRACE("(%p)\n", v);
 481     v->vt = VT_EMPTY;
 482 }