1 /*
2 * HGLOBAL Stream implementation
3 *
4 * This file contains the implementation of the stream interface
5 * for streams contained supported by an HGLOBAL pointer.
6 *
7 * Copyright 1999 Francis Beaudet
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24 #include "config.h"
25
26 #include <assert.h>
27 #include <stdlib.h>
28 #include <stdarg.h>
29 #include <stdio.h>
30 #include <string.h>
31
32 #define COBJMACROS
33 #define NONAMELESSUNION
34 #define NONAMELESSSTRUCT
35
36 #include "windef.h"
37 #include "winbase.h"
38 #include "winuser.h"
39 #include "objbase.h"
40 #include "ole2.h"
41 #include "winerror.h"
42 #include "winternl.h"
43
44 #include "wine/debug.h"
45
46 WINE_DEFAULT_DEBUG_CHANNEL(storage);
47
48 /****************************************************************************
49 * HGLOBALStreamImpl definition.
50 *
51 * This class implements the IStream interface and represents a stream
52 * supported by an HGLOBAL pointer.
53 */
54 struct HGLOBALStreamImpl
55 {
56 const IStreamVtbl *lpVtbl; /* Needs to be the first item in the struct
57 * since we want to cast this in an IStream pointer */
58
59 /*
60 * Reference count
61 */
62 LONG ref;
63
64 /*
65 * Support for the stream
66 */
67 HGLOBAL supportHandle;
68
69 /*
70 * This flag is TRUE if the HGLOBAL is destroyed when the stream
71 * is finally released.
72 */
73 BOOL deleteOnRelease;
74
75 /*
76 * Helper variable that contains the size of the stream
77 */
78 ULARGE_INTEGER streamSize;
79
80 /*
81 * This is the current position of the cursor in the stream
82 */
83 ULARGE_INTEGER currentPosition;
84 };
85
86 typedef struct HGLOBALStreamImpl HGLOBALStreamImpl;
87
88 /***
89 * This is the destructor of the HGLOBALStreamImpl class.
90 *
91 * This method will clean-up all the resources used-up by the given HGLOBALStreamImpl
92 * class. The pointer passed-in to this function will be freed and will not
93 * be valid anymore.
94 */
95 static void HGLOBALStreamImpl_Destroy(HGLOBALStreamImpl* This)
96 {
97 TRACE("(%p)\n", This);
98
99 /*
100 * Release the HGlobal if the constructor asked for that.
101 */
102 if (This->deleteOnRelease)
103 {
104 GlobalFree(This->supportHandle);
105 This->supportHandle=0;
106 }
107
108 /*
109 * Finally, free the memory used-up by the class.
110 */
111 HeapFree(GetProcessHeap(), 0, This);
112 }
113
114 /***
115 * This implements the IUnknown method AddRef for this
116 * class
117 */
118 static ULONG WINAPI HGLOBALStreamImpl_AddRef(
119 IStream* iface)
120 {
121 HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
122 return InterlockedIncrement(&This->ref);
123 }
124
125 /***
126 * This implements the IUnknown method QueryInterface for this
127 * class
128 */
129 static HRESULT WINAPI HGLOBALStreamImpl_QueryInterface(
130 IStream* iface,
131 REFIID riid, /* [in] */
132 void** ppvObject) /* [iid_is][out] */
133 {
134 HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
135
136 /*
137 * Perform a sanity check on the parameters.
138 */
139 if (ppvObject==0)
140 return E_INVALIDARG;
141
142 /*
143 * Initialize the return parameter.
144 */
145 *ppvObject = 0;
146
147 /*
148 * Compare the riid with the interface IDs implemented by this object.
149 */
150 if (IsEqualIID(&IID_IUnknown, riid) ||
151 IsEqualIID(&IID_ISequentialStream, riid) ||
152 IsEqualIID(&IID_IStream, riid))
153 {
154 *ppvObject = This;
155 }
156
157 /*
158 * Check that we obtained an interface.
159 */
160 if ((*ppvObject)==0)
161 return E_NOINTERFACE;
162
163 /*
164 * Query Interface always increases the reference count by one when it is
165 * successful
166 */
167 HGLOBALStreamImpl_AddRef(iface);
168
169 return S_OK;
170 }
171
172 /***
173 * This implements the IUnknown method Release for this
174 * class
175 */
176 static ULONG WINAPI HGLOBALStreamImpl_Release(
177 IStream* iface)
178 {
179 HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
180 ULONG newRef;
181
182 newRef = InterlockedDecrement(&This->ref);
183
184 /*
185 * If the reference count goes down to 0, perform suicide.
186 */
187 if (newRef==0)
188 {
189 HGLOBALStreamImpl_Destroy(This);
190 }
191
192 return newRef;
193 }
194
195 /***
196 * This method is part of the ISequentialStream interface.
197 *
198 * If reads a block of information from the stream at the current
199 * position. It then moves the current position at the end of the
200 * read block
201 *
202 * See the documentation of ISequentialStream for more info.
203 */
204 static HRESULT WINAPI HGLOBALStreamImpl_Read(
205 IStream* iface,
206 void* pv, /* [length_is][size_is][out] */
207 ULONG cb, /* [in] */
208 ULONG* pcbRead) /* [out] */
209 {
210 HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
211
212 void* supportBuffer;
213 ULONG bytesReadBuffer;
214 ULONG bytesToReadFromBuffer;
215
216 TRACE("(%p, %p, %d, %p)\n", iface,
217 pv, cb, pcbRead);
218
219 /*
220 * If the caller is not interested in the nubmer of bytes read,
221 * we use another buffer to avoid "if" statements in the code.
222 */
223 if (pcbRead==0)
224 pcbRead = &bytesReadBuffer;
225
226 /*
227 * Using the known size of the stream, calculate the number of bytes
228 * to read from the block chain
229 */
230 bytesToReadFromBuffer = min( This->streamSize.u.LowPart - This->currentPosition.u.LowPart, cb);
231
232 /*
233 * Lock the buffer in position and copy the data.
234 */
235 supportBuffer = GlobalLock(This->supportHandle);
236 if (!supportBuffer)
237 {
238 WARN("read from invalid hglobal %p\n", This->supportHandle);
239 *pcbRead = 0;
240 return S_OK;
241 }
242
243 memcpy(pv, (char *) supportBuffer+This->currentPosition.u.LowPart, bytesToReadFromBuffer);
244
245 /*
246 * Move the current position to the new position
247 */
248 This->currentPosition.u.LowPart+=bytesToReadFromBuffer;
249
250 /*
251 * Return the number of bytes read.
252 */
253 *pcbRead = bytesToReadFromBuffer;
254
255 /*
256 * Cleanup
257 */
258 GlobalUnlock(This->supportHandle);
259
260 /*
261 * Always returns S_OK even if the end of the stream is reached before the
262 * buffer is filled
263 */
264
265 return S_OK;
266 }
267
268 /***
269 * This method is part of the ISequentialStream interface.
270 *
271 * It writes a block of information to the stream at the current
272 * position. It then moves the current position at the end of the
273 * written block. If the stream is too small to fit the block,
274 * the stream is grown to fit.
275 *
276 * See the documentation of ISequentialStream for more info.
277 */
278 static HRESULT WINAPI HGLOBALStreamImpl_Write(
279 IStream* iface,
280 const void* pv, /* [size_is][in] */
281 ULONG cb, /* [in] */
282 ULONG* pcbWritten) /* [out] */
283 {
284 HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
285
286 void* supportBuffer;
287 ULARGE_INTEGER newSize;
288 ULONG bytesWritten = 0;
289
290 TRACE("(%p, %p, %d, %p)\n", iface, pv, cb, pcbWritten);
291
292 /*
293 * If the caller is not interested in the number of bytes written,
294 * we use another buffer to avoid "if" statements in the code.
295 */
296 if (pcbWritten == 0)
297 pcbWritten = &bytesWritten;
298
299 if (cb == 0)
300 goto out;
301
302 *pcbWritten = 0;
303
304 newSize.u.HighPart = 0;
305 newSize.u.LowPart = This->currentPosition.u.LowPart + cb;
306
307 /*
308 * Verify if we need to grow the stream
309 */
310 if (newSize.u.LowPart > This->streamSize.u.LowPart)
311 {
312 /* grow stream */
313 HRESULT hr = IStream_SetSize(iface, newSize);
314 if (FAILED(hr))
315 {
316 ERR("IStream_SetSize failed with error 0x%08x\n", hr);
317 return hr;
318 }
319 }
320
321 /*
322 * Lock the buffer in position and copy the data.
323 */
324 supportBuffer = GlobalLock(This->supportHandle);
325 if (!supportBuffer)
326 {
327 WARN("write to invalid hglobal %p\n", This->supportHandle);
328 return S_OK;
329 }
330
331 memcpy((char *) supportBuffer+This->currentPosition.u.LowPart, pv, cb);
332
333 /*
334 * Move the current position to the new position
335 */
336 This->currentPosition.u.LowPart+=cb;
337
338 /*
339 * Cleanup
340 */
341 GlobalUnlock(This->supportHandle);
342
343 out:
344 /*
345 * Return the number of bytes read.
346 */
347 *pcbWritten = cb;
348
349 return S_OK;
350 }
351
352 /***
353 * This method is part of the IStream interface.
354 *
355 * It will move the current stream pointer according to the parameters
356 * given.
357 *
358 * See the documentation of IStream for more info.
359 */
360 static HRESULT WINAPI HGLOBALStreamImpl_Seek(
361 IStream* iface,
362 LARGE_INTEGER dlibMove, /* [in] */
363 DWORD dwOrigin, /* [in] */
364 ULARGE_INTEGER* plibNewPosition) /* [out] */
365 {
366 HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
367
368 ULARGE_INTEGER newPosition;
369
370 TRACE("(%p, %x%08x, %d, %p)\n", iface, dlibMove.u.HighPart,
371 dlibMove.u.LowPart, dwOrigin, plibNewPosition);
372
373 /*
374 * The file pointer is moved depending on the given "function"
375 * parameter.
376 */
377 switch (dwOrigin)
378 {
379 case STREAM_SEEK_SET:
380 newPosition.u.HighPart = 0;
381 newPosition.u.LowPart = 0;
382 break;
383 case STREAM_SEEK_CUR:
384 newPosition = This->currentPosition;
385 break;
386 case STREAM_SEEK_END:
387 newPosition = This->streamSize;
388 break;
389 default:
390 return STG_E_INVALIDFUNCTION;
391 }
392
393 /*
394 * Move the actual file pointer
395 * If the file pointer ends-up after the end of the stream, the next Write operation will
396 * make the file larger. This is how it is documented.
397 */
398 if (dlibMove.QuadPart < 0 && newPosition.QuadPart < -dlibMove.QuadPart) return STG_E_INVALIDFUNCTION;
399
400 newPosition.QuadPart += dlibMove.QuadPart;
401
402 if (plibNewPosition) *plibNewPosition = newPosition;
403 This->currentPosition = newPosition;
404
405 return S_OK;
406 }
407
408 /***
409 * This method is part of the IStream interface.
410 *
411 * It will change the size of a stream.
412 *
413 * TODO: Switch from small blocks to big blocks and vice versa.
414 *
415 * See the documentation of IStream for more info.
416 */
417 static HRESULT WINAPI HGLOBALStreamImpl_SetSize(
418 IStream* iface,
419 ULARGE_INTEGER libNewSize) /* [in] */
420 {
421 HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
422 HGLOBAL supportHandle;
423
424 TRACE("(%p, %d)\n", iface, libNewSize.u.LowPart);
425
426 /*
427 * HighPart is ignored as shown in tests
428 */
429
430 if (This->streamSize.u.LowPart == libNewSize.u.LowPart)
431 return S_OK;
432
433 /*
434 * Re allocate the HGlobal to fit the new size of the stream.
435 */
436 supportHandle = GlobalReAlloc(This->supportHandle, libNewSize.u.LowPart, 0);
437
438 if (supportHandle == 0)
439 return E_OUTOFMEMORY;
440
441 This->supportHandle = supportHandle;
442 This->streamSize.u.LowPart = libNewSize.u.LowPart;
443
444 return S_OK;
445 }
446
447 /***
448 * This method is part of the IStream interface.
449 *
450 * It will copy the 'cb' Bytes to 'pstm' IStream.
451 *
452 * See the documentation of IStream for more info.
453 */
454 static HRESULT WINAPI HGLOBALStreamImpl_CopyTo(
455 IStream* iface,
456 IStream* pstm, /* [unique][in] */
457 ULARGE_INTEGER cb, /* [in] */
458 ULARGE_INTEGER* pcbRead, /* [out] */
459 ULARGE_INTEGER* pcbWritten) /* [out] */
460 {
461 HRESULT hr = S_OK;
462 BYTE tmpBuffer[128];
463 ULONG bytesRead, bytesWritten, copySize;
464 ULARGE_INTEGER totalBytesRead;
465 ULARGE_INTEGER totalBytesWritten;
466
467 TRACE("(%p, %p, %d, %p, %p)\n", iface, pstm,
468 cb.u.LowPart, pcbRead, pcbWritten);
469
470 if ( pstm == 0 )
471 return STG_E_INVALIDPOINTER;
472
473 totalBytesRead.QuadPart = 0;
474 totalBytesWritten.QuadPart = 0;
475
476 while ( cb.QuadPart > 0 )
477 {
478 if ( cb.QuadPart >= sizeof(tmpBuffer) )
479 copySize = sizeof(tmpBuffer);
480 else
481 copySize = cb.u.LowPart;
482
483 hr = IStream_Read(iface, tmpBuffer, copySize, &bytesRead);
484 if (FAILED(hr))
485 break;
486
487 totalBytesRead.QuadPart += bytesRead;
488
489 if (bytesRead)
490 {
491 hr = IStream_Write(pstm, tmpBuffer, bytesRead, &bytesWritten);
492 if (FAILED(hr))
493 break;
494
495 totalBytesWritten.QuadPart += bytesWritten;
496 }
497
498 if (bytesRead!=copySize)
499 cb.QuadPart = 0;
500 else
501 cb.QuadPart -= bytesRead;
502 }
503
504 if (pcbRead) pcbRead->QuadPart = totalBytesRead.QuadPart;
505 if (pcbWritten) pcbWritten->QuadPart = totalBytesWritten.QuadPart;
506
507 return hr;
508 }
509
510 /***
511 * This method is part of the IStream interface.
512 *
513 * For streams supported by HGLOBALS, this function does nothing.
514 * This is what the documentation tells us.
515 *
516 * See the documentation of IStream for more info.
517 */
518 static HRESULT WINAPI HGLOBALStreamImpl_Commit(
519 IStream* iface,
520 DWORD grfCommitFlags) /* [in] */
521 {
522 return S_OK;
523 }
524
525 /***
526 * This method is part of the IStream interface.
527 *
528 * For streams supported by HGLOBALS, this function does nothing.
529 * This is what the documentation tells us.
530 *
531 * See the documentation of IStream for more info.
532 */
533 static HRESULT WINAPI HGLOBALStreamImpl_Revert(
534 IStream* iface)
535 {
536 return S_OK;
537 }
538
539 /***
540 * This method is part of the IStream interface.
541 *
542 * For streams supported by HGLOBALS, this function does nothing.
543 * This is what the documentation tells us.
544 *
545 * See the documentation of IStream for more info.
546 */
547 static HRESULT WINAPI HGLOBALStreamImpl_LockRegion(
548 IStream* iface,
549 ULARGE_INTEGER libOffset, /* [in] */
550 ULARGE_INTEGER cb, /* [in] */
551 DWORD dwLockType) /* [in] */
552 {
553 return STG_E_INVALIDFUNCTION;
554 }
555
556 /*
557 * This method is part of the IStream interface.
558 *
559 * For streams supported by HGLOBALS, this function does nothing.
560 * This is what the documentation tells us.
561 *
562 * See the documentation of IStream for more info.
563 */
564 static HRESULT WINAPI HGLOBALStreamImpl_UnlockRegion(
565 IStream* iface,
566 ULARGE_INTEGER libOffset, /* [in] */
567 ULARGE_INTEGER cb, /* [in] */
568 DWORD dwLockType) /* [in] */
569 {
570 return S_OK;
571 }
572
573 /***
574 * This method is part of the IStream interface.
575 *
576 * This method returns information about the current
577 * stream.
578 *
579 * See the documentation of IStream for more info.
580 */
581 static HRESULT WINAPI HGLOBALStreamImpl_Stat(
582 IStream* iface,
583 STATSTG* pstatstg, /* [out] */
584 DWORD grfStatFlag) /* [in] */
585 {
586 HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
587
588 memset(pstatstg, 0, sizeof(STATSTG));
589
590 pstatstg->pwcsName = NULL;
591 pstatstg->type = STGTY_STREAM;
592 pstatstg->cbSize = This->streamSize;
593
594 return S_OK;
595 }
596
597 static HRESULT WINAPI HGLOBALStreamImpl_Clone(
598 IStream* iface,
599 IStream** ppstm) /* [out] */
600 {
601 ULARGE_INTEGER dummy;
602 LARGE_INTEGER offset;
603 HRESULT hr;
604 HGLOBALStreamImpl* const This=(HGLOBALStreamImpl*)iface;
605 TRACE(" Cloning %p (deleteOnRelease=%d seek position=%ld)\n",iface,This->deleteOnRelease,(long)This->currentPosition.QuadPart);
606 hr=CreateStreamOnHGlobal(This->supportHandle, FALSE, ppstm);
607 if(FAILED(hr))
608 return hr;
609 offset.QuadPart=(LONGLONG)This->currentPosition.QuadPart;
610 HGLOBALStreamImpl_Seek(*ppstm,offset,STREAM_SEEK_SET,&dummy);
611 return S_OK;
612 }
613
614 /*
615 * Virtual function table for the HGLOBALStreamImpl class.
616 */
617 static const IStreamVtbl HGLOBALStreamImpl_Vtbl =
618 {
619 HGLOBALStreamImpl_QueryInterface,
620 HGLOBALStreamImpl_AddRef,
621 HGLOBALStreamImpl_Release,
622 HGLOBALStreamImpl_Read,
623 HGLOBALStreamImpl_Write,
624 HGLOBALStreamImpl_Seek,
625 HGLOBALStreamImpl_SetSize,
626 HGLOBALStreamImpl_CopyTo,
627 HGLOBALStreamImpl_Commit,
628 HGLOBALStreamImpl_Revert,
629 HGLOBALStreamImpl_LockRegion,
630 HGLOBALStreamImpl_UnlockRegion,
631 HGLOBALStreamImpl_Stat,
632 HGLOBALStreamImpl_Clone
633 };
634
635 /******************************************************************************
636 ** HGLOBALStreamImpl implementation
637 */
638
639 /***
640 * This is the constructor for the HGLOBALStreamImpl class.
641 *
642 * Params:
643 * hGlobal - Handle that will support the stream. can be NULL.
644 * fDeleteOnRelease - Flag set to TRUE if the HGLOBAL will be released
645 * when the IStream object is destroyed.
646 */
647 static HGLOBALStreamImpl* HGLOBALStreamImpl_Construct(
648 HGLOBAL hGlobal,
649 BOOL fDeleteOnRelease)
650 {
651 HGLOBALStreamImpl* newStream;
652
653 newStream = HeapAlloc(GetProcessHeap(), 0, sizeof(HGLOBALStreamImpl));
654
655 if (newStream!=0)
656 {
657 /*
658 * Set-up the virtual function table and reference count.
659 */
660 newStream->lpVtbl = &HGLOBALStreamImpl_Vtbl;
661 newStream->ref = 0;
662
663 /*
664 * Initialize the support.
665 */
666 newStream->supportHandle = hGlobal;
667 newStream->deleteOnRelease = fDeleteOnRelease;
668
669 /*
670 * This method will allocate a handle if one is not supplied.
671 */
672 if (!newStream->supportHandle)
673 {
674 newStream->supportHandle = GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD |
675 GMEM_SHARE, 0);
676 }
677
678 /*
679 * Start the stream at the beginning.
680 */
681 newStream->currentPosition.u.HighPart = 0;
682 newStream->currentPosition.u.LowPart = 0;
683
684 /*
685 * Initialize the size of the stream to the size of the handle.
686 */
687 newStream->streamSize.u.HighPart = 0;
688 newStream->streamSize.u.LowPart = GlobalSize(newStream->supportHandle);
689 }
690
691 return newStream;
692 }
693
694
695 /***********************************************************************
696 * CreateStreamOnHGlobal [OLE32.@]
697 */
698 HRESULT WINAPI CreateStreamOnHGlobal(
699 HGLOBAL hGlobal,
700 BOOL fDeleteOnRelease,
701 LPSTREAM* ppstm)
702 {
703 HGLOBALStreamImpl* newStream;
704
705 if (!ppstm)
706 return E_INVALIDARG;
707
708 newStream = HGLOBALStreamImpl_Construct(hGlobal,
709 fDeleteOnRelease);
710
711 if (newStream!=NULL)
712 {
713 return IUnknown_QueryInterface((IUnknown*)newStream,
714 &IID_IStream,
715 (void**)ppstm);
716 }
717
718 return E_OUTOFMEMORY;
719 }
720
721 /***********************************************************************
722 * GetHGlobalFromStream [OLE32.@]
723 */
724 HRESULT WINAPI GetHGlobalFromStream(IStream* pstm, HGLOBAL* phglobal)
725 {
726 HGLOBALStreamImpl* pStream;
727
728 if (pstm == NULL)
729 return E_INVALIDARG;
730
731 pStream = (HGLOBALStreamImpl*) pstm;
732
733 /*
734 * Verify that the stream object was created with CreateStreamOnHGlobal.
735 */
736 if (pStream->lpVtbl == &HGLOBALStreamImpl_Vtbl)
737 *phglobal = pStream->supportHandle;
738 else
739 {
740 *phglobal = 0;
741 return E_INVALIDARG;
742 }
743
744 return S_OK;
745 }
746
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.