ole32: Move the code to set the clipboard formats to a separate function.
[wine] / dlls / ole32 / hglobalstream.c
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 = RtlLargeIntegerAdd(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 }