memlockbytes.c 14.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/*
 * Global memory implementation of ILockBytes.
 *
 * Copyright 1999 Thuy Nguyen
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * 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 22 23
 */

#include "config.h"

#include <assert.h>
24
#include <stdarg.h>
25 26 27 28 29
#include <string.h>

#define NONAMELESSUNION
#define NONAMELESSSTRUCT
#include "windef.h"
30
#include "winbase.h"
31
#include "wine/winbase16.h"
32
#include "winuser.h"
33 34 35 36 37 38 39 40 41 42 43 44 45
#include "objbase.h"
#include "ole2.h"
#include "winerror.h"

#include "ifs.h"

#include "wine/debug.h"

WINE_DEFAULT_DEBUG_CHANNEL(ole);

/******************************************************************************
 * HGLOBALLockBytesImpl16 definition.
 *
Huw Davies's avatar
Huw Davies committed
46
 * This class implements the ILockBytes interface and represents a byte array
47 48 49 50
 * object supported by an HGLOBAL pointer.
 */
struct HGLOBALLockBytesImpl16
{
51 52
  ILockBytes16 ILockBytes16_iface;
  LONG ref;
53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77

  /*
   * Support for the LockBytes object
   */
  HGLOBAL16 supportHandle;

  /*
   * This flag is TRUE if the HGLOBAL is destroyed when the object
   * is finally released.
   */
  BOOL    deleteOnRelease;
  /*
   * Helper variable that contains the size of the byte array
   */
  ULARGE_INTEGER     byteArraySize;
};

typedef struct HGLOBALLockBytesImpl16 HGLOBALLockBytesImpl16;

/******************************************************************************
 *
 * HGLOBALLockBytesImpl16 implementation
 *
 */

78 79 80 81 82
static inline HGLOBALLockBytesImpl16 *impl_from_ILockBytes16(ILockBytes16 *iface)
{
  return CONTAINING_RECORD(iface, HGLOBALLockBytesImpl16, ILockBytes16_iface);
}

83 84 85 86 87 88 89 90
/******************************************************************************
 * This is the constructor for the HGLOBALLockBytesImpl16 class.
 *
 * Params:
 *    hGlobal          - Handle that will support the stream. can be NULL.
 *    fDeleteOnRelease - Flag set to TRUE if the HGLOBAL16 will be released
 *                       when the IStream object is destroyed.
 */
91
static HGLOBALLockBytesImpl16*
92 93 94 95 96
HGLOBALLockBytesImpl16_Construct(HGLOBAL16 hGlobal,
				 BOOL16 fDeleteOnRelease)
{
  HGLOBALLockBytesImpl16* newLockBytes;

97
  static ILockBytes16Vtbl vt16;
98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121
  static SEGPTR msegvt16;
  HMODULE16 hcomp = GetModuleHandle16("OLE2");


  TRACE("(%x,%d)\n",hGlobal,fDeleteOnRelease);
  newLockBytes = HeapAlloc(GetProcessHeap(), 0, sizeof(HGLOBALLockBytesImpl16));
  if (newLockBytes == NULL)
    return NULL;

  /*
   * Set up the virtual function table and reference count.
   */
  if (!msegvt16)
  {
#define VTENT(x) vt16.x = (void*)GetProcAddress16(hcomp,"HGLOBALLockBytesImpl16_"#x);assert(vt16.x)
      VTENT(QueryInterface);
      VTENT(AddRef);
      VTENT(Release);
      VTENT(ReadAt);
      VTENT(WriteAt);
      VTENT(Flush);
      VTENT(SetSize);
      VTENT(LockRegion);
      VTENT(UnlockRegion);
122
      VTENT(Stat);
123 124 125
#undef VTENT
      msegvt16 = MapLS( &vt16 );
  }
126 127
  newLockBytes->ILockBytes16_iface.lpVtbl = (const ILockBytes16Vtbl*)msegvt16;
  newLockBytes->ref = 0;
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
  /*
   * Initialize the support.
   */
  newLockBytes->supportHandle = hGlobal;
  newLockBytes->deleteOnRelease = fDeleteOnRelease;

  /*
   * This method will allocate a handle if one is not supplied.
   */
  if (newLockBytes->supportHandle == 0)
    newLockBytes->supportHandle = GlobalAlloc16(GMEM_MOVEABLE | GMEM_NODISCARD, 0);

  /*
   * Initialize the size of the array to the size of the handle.
   */
143 144
  newLockBytes->byteArraySize.u.HighPart = 0;
  newLockBytes->byteArraySize.u.LowPart  = GlobalSize16(
145 146 147 148 149 150 151 152 153 154 155 156
					    newLockBytes->supportHandle);

  return (HGLOBALLockBytesImpl16*)MapLS(newLockBytes);
}

/******************************************************************************
 * This is the destructor of the HGLOBALStreamImpl class.
 *
 * This method will clean-up all the resources used-up by the given
 * HGLOBALLockBytesImpl16 class. The pointer passed-in to this function will be
 * freed and will not be valid anymore.
 */
157
static void HGLOBALLockBytesImpl16_Destroy(HGLOBALLockBytesImpl16* This)
158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
{
  TRACE("()\n");
  /*
   * Release the HGlobal if the constructor asked for that.
   */
  if (This->deleteOnRelease)
  {
    GlobalFree16(This->supportHandle);
    This->supportHandle = 0;
  }

  /*
   * Finally, free the memory used-up by the class.
   */
  HeapFree(GetProcessHeap(), 0, This);
}

175 176 177 178
/******************************************************************************
 * This implements the IUnknown method AddRef for this
 * class
 */
179
ULONG CDECL HGLOBALLockBytesImpl16_AddRef(ILockBytes16* iface)
180
{
181
  HGLOBALLockBytesImpl16* const This = impl_from_ILockBytes16(iface);
182 183 184 185 186 187 188

  TRACE("(%p)\n",This);

  return InterlockedIncrement(&This->ref);
}


189 190 191 192
/******************************************************************************
 * This implements the IUnknown method QueryInterface for this
 * class
 */
193
HRESULT CDECL HGLOBALLockBytesImpl16_QueryInterface(
194 195
      ILockBytes16*  iface,	/* [in] SEGPTR */
      REFIID       riid,        /* [in] */
196
      void**       ppvObject)   /* [out][iid_is] (ptr to SEGPTR!) */
197
{
198
  HGLOBALLockBytesImpl16* const This = MapSL((SEGPTR)iface);
199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221

  TRACE("(%p,%s,%p)\n",iface,debugstr_guid(riid),ppvObject);
  /*
   * Perform a sanity check on the parameters.
   */
  if (ppvObject==0)
    return E_INVALIDARG;

  /*
   * Initialize the return parameter.
   */
  *ppvObject = 0;
  /*
   * Compare the riid with the interface IDs implemented by this object.
   */
  if (	!memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) ||
        !memcmp(&IID_ILockBytes, riid, sizeof(IID_ILockBytes))
  )
    *ppvObject = (void*)iface;

  /*
   * Check that we obtained an interface.
   */
222 223
  if ((*ppvObject)==0) {
    FIXME("Unknown IID %s\n", debugstr_guid(riid));
224
    return E_NOINTERFACE;
225
  }
226 227 228 229 230

  /*
   * Query Interface always increases the reference count by one when it is
   * successful
   */
231
  HGLOBALLockBytesImpl16_AddRef(&This->ILockBytes16_iface);
232 233 234 235 236 237 238 239

  return S_OK;
}

/******************************************************************************
 * This implements the IUnknown method Release for this
 * class
 */
240
ULONG CDECL HGLOBALLockBytesImpl16_Release(ILockBytes16* iface)
241
{
242
  HGLOBALLockBytesImpl16* const This = impl_from_ILockBytes16(iface);
243
  ULONG ref;
244 245 246

  TRACE("(%p)\n",This);

247
  ref = InterlockedDecrement(&This->ref);
248 249 250 251

  /*
   * If the reference count goes down to 0, perform suicide.
   */
252
  if (ref==0)
253
    HGLOBALLockBytesImpl16_Destroy(This);
254
  return ref;
255 256 257 258 259 260 261 262 263 264
}

/******************************************************************************
 * This method is part of the ILockBytes interface.
 *
 * It reads a block of information from the byte array at the specified
 * offset.
 *
 * See the documentation of ILockBytes for more info.
 */
265
HRESULT CDECL HGLOBALLockBytesImpl16_ReadAt(
266 267
      ILockBytes16*  iface,
      ULARGE_INTEGER ulOffset,  /* [in] */
268
      void*          pv,        /* [out][length_is][size_is] */
269 270 271
      ULONG          cb,        /* [in] */
      ULONG*         pcbRead)   /* [out] */
{
272
  HGLOBALLockBytesImpl16* const This = impl_from_ILockBytes16(iface);
273 274 275 276 277

  void* supportBuffer;
  ULONG bytesReadBuffer = 0;
  ULONG bytesToReadFromBuffer;

278
  TRACE("(%p,%d,%p,%d,%p)\n",This,ulOffset.u.LowPart,pv,cb,pcbRead);
279 280 281 282 283 284 285 286 287 288
  /*
   * If the caller is not interested in the number of bytes read,
   * we use another buffer to avoid "if" statements in the code.
   */
  if (pcbRead == 0)
    pcbRead = &bytesReadBuffer;

  /*
   * Make sure the offset is valid.
   */
289
  if (ulOffset.u.LowPart > This->byteArraySize.u.LowPart)
290 291 292 293 294 295
    return E_FAIL;

  /*
   * Using the known size of the array, calculate the number of bytes
   * to read.
   */
296 297
  bytesToReadFromBuffer = min(This->byteArraySize.u.LowPart -
                              ulOffset.u.LowPart, cb);
298 299 300 301 302 303 304

  /*
   * Lock the buffer in position and copy the data.
   */
  supportBuffer = GlobalLock16(This->supportHandle);

  memcpy(pv,
305
         (char *) supportBuffer + ulOffset.u.LowPart,
306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329
         bytesToReadFromBuffer);

  /*
   * Return the number of bytes read.
   */
  *pcbRead = bytesToReadFromBuffer;

  /*
   * Cleanup
   */
  GlobalUnlock16(This->supportHandle);

  /*
   * The function returns S_OK if the specified number of bytes were read
   * or the end of the array was reached.
   * It returns STG_E_READFAULT if the number of bytes to read does not equal
   * the number of bytes actually read.
   */
  if(*pcbRead == cb)
    return S_OK;

  return STG_E_READFAULT;
}

330 331 332 333 334 335 336
/******************************************************************************
 * This method is part of the ILockBytes interface.
 *
 * It will change the size of the byte array.
 *
 * See the documentation of ILockBytes for more info.
 */
337
HRESULT CDECL HGLOBALLockBytesImpl16_SetSize(
338 339 340
      ILockBytes16*   iface,
      ULARGE_INTEGER  libNewSize)   /* [in] */
{
341
  HGLOBALLockBytesImpl16* const This = impl_from_ILockBytes16(iface);
342 343
  HGLOBAL16 supportHandle;

344
  TRACE("(%p,%d)\n",This,libNewSize.u.LowPart);
345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367
  /*
   * As documented.
   */
  if (libNewSize.u.HighPart != 0)
    return STG_E_INVALIDFUNCTION;

  if (This->byteArraySize.u.LowPart == libNewSize.u.LowPart)
    return S_OK;

  /*
   * Re allocate the HGlobal to fit the new size of the stream.
   */
  supportHandle = GlobalReAlloc16(This->supportHandle, libNewSize.u.LowPart, 0);

  if (supportHandle == 0)
    return STG_E_MEDIUMFULL;

  This->supportHandle = supportHandle;
  This->byteArraySize.u.LowPart = libNewSize.u.LowPart;

  return S_OK;
}

368 369 370 371 372 373 374 375
/******************************************************************************
 * This method is part of the ILockBytes interface.
 *
 * It writes the specified bytes at the specified offset.
 * position. If the array is too small, it will be resized.
 *
 * See the documentation of ILockBytes for more info.
 */
376
HRESULT CDECL HGLOBALLockBytesImpl16_WriteAt(
377 378
      ILockBytes16*  iface,
      ULARGE_INTEGER ulOffset,    /* [in] */
379
      const void*    pv,          /* [in][size_is] */
380 381 382
      ULONG          cb,          /* [in] */
      ULONG*         pcbWritten)  /* [out] */
{
383
  HGLOBALLockBytesImpl16* const This = impl_from_ILockBytes16(iface);
384 385 386 387 388

  void*          supportBuffer;
  ULARGE_INTEGER newSize;
  ULONG          bytesWritten = 0;

389
  TRACE("(%p,%d,%p,%d,%p)\n",This,ulOffset.u.LowPart,pv,cb,pcbWritten);
390 391 392 393 394 395 396 397 398 399
  /*
   * If the caller is not interested in the number of bytes written,
   * we use another buffer to avoid "if" statements in the code.
   */
  if (pcbWritten == 0)
    pcbWritten = &bytesWritten;

  if (cb == 0)
    return S_OK;

400 401
  newSize.u.HighPart = 0;
  newSize.u.LowPart = ulOffset.u.LowPart + cb;
402 403 404 405

  /*
   * Verify if we need to grow the stream
   */
406
  if (newSize.u.LowPart > This->byteArraySize.u.LowPart)
407 408 409 410 411 412 413 414 415 416 417
  {
    /* grow stream */
    if (HGLOBALLockBytesImpl16_SetSize(iface, newSize) == STG_E_MEDIUMFULL)
      return STG_E_MEDIUMFULL;
  }

  /*
   * Lock the buffer in position and copy the data.
   */
  supportBuffer = GlobalLock16(This->supportHandle);

418
  memcpy((char *) supportBuffer + ulOffset.u.LowPart, pv, cb);
419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437

  /*
   * Return the number of bytes written.
   */
  *pcbWritten = cb;

  /*
   * Cleanup
   */
  GlobalUnlock16(This->supportHandle);

  return S_OK;
}

/******************************************************************************
 * This method is part of the ILockBytes interface.
 *
 * See the documentation of ILockBytes for more info.
 */
438
HRESULT CDECL HGLOBALLockBytesImpl16_Flush(ILockBytes16* iface)
439 440 441 442 443 444 445 446 447 448 449 450
{
  TRACE("(%p)\n",iface);
  return S_OK;
}

/******************************************************************************
 * This method is part of the ILockBytes interface.
 *
 * The global memory implementation of ILockBytes does not support locking.
 *
 * See the documentation of ILockBytes for more info.
 */
451
HRESULT CDECL HGLOBALLockBytesImpl16_LockRegion(
452 453 454 455 456 457 458 459 460 461 462 463 464 465 466
      ILockBytes16*  iface,
      ULARGE_INTEGER libOffset,   /* [in] */
      ULARGE_INTEGER cb,          /* [in] */
      DWORD          dwLockType)  /* [in] */
{
  return STG_E_INVALIDFUNCTION;
}

/******************************************************************************
 * This method is part of the ILockBytes interface.
 *
 * The global memory implementation of ILockBytes does not support locking.
 *
 * See the documentation of ILockBytes for more info.
 */
467
HRESULT CDECL HGLOBALLockBytesImpl16_UnlockRegion(
468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483
      ILockBytes16*  iface,
      ULARGE_INTEGER libOffset,   /* [in] */
      ULARGE_INTEGER cb,          /* [in] */
      DWORD          dwLockType)  /* [in] */
{
  return STG_E_INVALIDFUNCTION;
}

/******************************************************************************
 * This method is part of the ILockBytes interface.
 *
 * This method returns information about the current
 * byte array object.
 *
 * See the documentation of ILockBytes for more info.
 */
484
HRESULT CDECL HGLOBALLockBytesImpl16_Stat(
485 486 487 488
      ILockBytes16*iface,
      STATSTG16*   pstatstg,     /* [out] */
      DWORD        grfStatFlag)  /* [in] */
{
489
  HGLOBALLockBytesImpl16* const This = impl_from_ILockBytes16(iface);
490 491 492 493 494 495 496 497 498 499 500 501

  memset(pstatstg, 0, sizeof(STATSTG16));

  pstatstg->pwcsName = NULL;
  pstatstg->type     = STGTY_LOCKBYTES;
  pstatstg->cbSize   = This->byteArraySize;

  return S_OK;
}

/******************************************************************************
 *           CreateILockBytesOnHGlobal     [OLE2.54]
502
 *
503 504
 * Creates an ILockBytes interface for a HGLOBAL handle.
 *
505
 * PARAMS
506 507 508 509
 * 	hGlobal			the global handle (16bit)
 *	fDeleteOnRelease	delete handle on release.
 *	ppLkbyt			pointer to ILockBytes interface.
 *
510
 * RETURNS
511 512 513
 *	Staddard OLE error return codes.
 *
 */
514 515 516 517
HRESULT WINAPI CreateILockBytesOnHGlobal16(
	HGLOBAL16      hGlobal,          /* [in] */
	BOOL16         fDeleteOnRelease, /* [in] */
	LPLOCKBYTES16 *ppLkbyt)          /* [out] (ptr to SEGPTR!) */
518 519 520 521 522 523
{
  HGLOBALLockBytesImpl16* newLockBytes; /* SEGPTR */

  newLockBytes = HGLOBALLockBytesImpl16_Construct(hGlobal, fDeleteOnRelease);

  if (newLockBytes != NULL)
524 525
    return HGLOBALLockBytesImpl16_QueryInterface(&newLockBytes->ILockBytes16_iface,
            &IID_ILockBytes, (void**)ppLkbyt);
526 527
  return E_OUTOFMEMORY;
}