Moved midimap to the top-level dlls directory.
[wine] / dlls / ole32 / memlockbytes.c
1 /******************************************************************************
2  *
3  * Global memory implementation of ILockBytes.
4  *
5  * Copyright 1999 Thuy Nguyen
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  */
21
22 #include "config.h"
23
24 #include <assert.h>
25 #include <stdarg.h>
26 #include <string.h>
27
28 #define COBJMACROS
29 #define NONAMELESSUNION
30 #define NONAMELESSSTRUCT
31
32 #include "windef.h"
33 #include "winbase.h"
34 #include "winuser.h"
35 #include "objbase.h"
36 #include "ole2.h"
37 #include "winerror.h"
38
39 #include "wine/debug.h"
40
41 WINE_DEFAULT_DEBUG_CHANNEL(ole);
42
43 /******************************************************************************
44  * HGLOBALLockBytesImpl definition.
45  *
46  * This class imlements the ILockBytes inteface and represents a byte array
47  * object supported by an HGLOBAL pointer.
48  */
49 struct HGLOBALLockBytesImpl
50 {
51   /*
52    * Needs to be the first item in the struct
53    * since we want to cast this in an ILockBytes pointer
54    */
55   const ILockBytesVtbl *lpVtbl;
56
57   /*
58    * Reference count
59    */
60   LONG        ref;
61
62   /*
63    * Support for the LockBytes object
64    */
65   HGLOBAL supportHandle;
66
67   /*
68    * This flag is TRUE if the HGLOBAL is destroyed when the object
69    * is finally released.
70    */
71   BOOL    deleteOnRelease;
72
73   /*
74    * Helper variable that contains the size of the byte array
75    */
76   ULARGE_INTEGER     byteArraySize;
77 };
78
79 typedef struct HGLOBALLockBytesImpl HGLOBALLockBytesImpl;
80
81 /*
82  * Method definition for the HGLOBALLockBytesImpl class.
83  */
84 HGLOBALLockBytesImpl* HGLOBALLockBytesImpl_Construct(
85     HGLOBAL  hGlobal,
86     BOOL     fDeleteOnRelease);
87
88 void HGLOBALLockBytesImpl_Destroy(HGLOBALLockBytesImpl* This);
89
90 HRESULT WINAPI HGLOBALLockBytesImpl_QueryInterface(
91     ILockBytes*   iface,
92     REFIID        riid,        /* [in] */
93     void**        ppvObject);  /* [iid_is][out] */
94
95 ULONG WINAPI HGLOBALLockBytesImpl_AddRef(
96     ILockBytes*   iface);
97
98 ULONG WINAPI HGLOBALLockBytesImpl_Release(
99     ILockBytes*   iface);
100
101 HRESULT WINAPI HGLOBALLockBytesImpl_ReadAt(
102     ILockBytes*    iface,
103     ULARGE_INTEGER ulOffset,  /* [in] */
104     void*          pv,        /* [length_is][size_is][out] */
105     ULONG          cb,        /* [in] */
106     ULONG*         pcbRead);  /* [out] */
107
108 HRESULT WINAPI HGLOBALLockBytesImpl_WriteAt(
109     ILockBytes*    iface,
110     ULARGE_INTEGER ulOffset,    /* [in] */
111     const void*    pv,          /* [size_is][in] */
112     ULONG          cb,          /* [in] */
113     ULONG*         pcbWritten); /* [out] */
114
115 HRESULT WINAPI HGLOBALLockBytesImpl_Flush(
116     ILockBytes*     iface);
117
118 HRESULT WINAPI HGLOBALLockBytesImpl_SetSize(
119     ILockBytes*     iface,
120     ULARGE_INTEGER  libNewSize);  /* [in] */
121
122 HRESULT WINAPI HGLOBALLockBytesImpl_LockRegion(
123     ILockBytes*    iface,
124     ULARGE_INTEGER libOffset,   /* [in] */
125     ULARGE_INTEGER cb,          /* [in] */
126     DWORD          dwLockType); /* [in] */
127
128 HRESULT WINAPI HGLOBALLockBytesImpl_UnlockRegion(
129     ILockBytes*    iface,
130     ULARGE_INTEGER libOffset,   /* [in] */
131     ULARGE_INTEGER cb,          /* [in] */
132     DWORD          dwLockType); /* [in] */
133
134 HRESULT WINAPI HGLOBALLockBytesImpl_Stat(
135     ILockBytes*    iface,
136     STATSTG*       pstatstg,     /* [out] */
137     DWORD          grfStatFlag); /* [in]  */
138
139 /*
140  * Virtual function table for the HGLOBALLockBytesImpl class.
141  */
142 static const ILockBytesVtbl HGLOBALLockBytesImpl_Vtbl =
143 {
144     HGLOBALLockBytesImpl_QueryInterface,
145     HGLOBALLockBytesImpl_AddRef,
146     HGLOBALLockBytesImpl_Release,
147     HGLOBALLockBytesImpl_ReadAt,
148     HGLOBALLockBytesImpl_WriteAt,
149     HGLOBALLockBytesImpl_Flush,
150     HGLOBALLockBytesImpl_SetSize,
151     HGLOBALLockBytesImpl_LockRegion,
152     HGLOBALLockBytesImpl_UnlockRegion,
153     HGLOBALLockBytesImpl_Stat,
154 };
155
156 /******************************************************************************
157  *           CreateILockBytesOnHGlobal     [OLE32.@]
158  *
159  * Create a byte array object which is intended to be the compound file foundation.
160  * This object supports a COM implementation of the ILockBytes interface.
161  *
162  * PARAMS
163  *  hGlobal           [ I] Global memory handle
164  *  fDeleteOnRelease  [ I] Whether the handle should be freed when the object is released. 
165  *  ppLkbyt           [ O] Address of ILockBytes pointer that receives
166  *                         the interface pointer to the new byte array object.
167  *
168  * RETURNS
169  *  Success: S_OK
170  *
171  * NOTES
172  *  The supplied ILockBytes pointer can be used by the StgCreateDocfileOnILockBytes
173  *  function to build a compound file on top of this byte array object.
174  *  The ILockBytes interface instance calls the GlobalReAlloc function to grow
175  *  the memory block as required.
176  */
177 HRESULT WINAPI CreateILockBytesOnHGlobal(HGLOBAL      hGlobal,
178                                          BOOL         fDeleteOnRelease,
179                                          LPLOCKBYTES* ppLkbyt)
180 {
181   HGLOBALLockBytesImpl* newLockBytes;
182
183   newLockBytes = HGLOBALLockBytesImpl_Construct(hGlobal, fDeleteOnRelease);
184
185   if (newLockBytes != NULL)
186   {
187     return IUnknown_QueryInterface((IUnknown*)newLockBytes,
188                                    &IID_ILockBytes,
189                                    (void**)ppLkbyt);
190   }
191
192   return E_OUTOFMEMORY;
193 }
194
195 /******************************************************************************
196  *           GetHGlobalFromILockBytes     [OLE32.@]
197  *
198  * Retrieve a global memory handle to a byte array object created
199  * using the CreateILockBytesOnHGlobal function.
200  *
201  * PARAMS
202  *  plkbyt   [ I]  Pointer to the ILockBytes interface on byte array object
203  *  phglobal [ O]  Address to store a global memory handle
204  * RETURNS
205  *  S_OK          if *phglobal has a correct value
206  *  E_INVALIDARG  if any parameters are invalid
207  *  
208  */
209 HRESULT WINAPI GetHGlobalFromILockBytes(ILockBytes* plkbyt, HGLOBAL* phglobal)
210 {
211   HGLOBALLockBytesImpl* const pMemLockBytes = (HGLOBALLockBytesImpl*)plkbyt;
212   STATSTG stbuf;
213   HRESULT hres;
214   ULARGE_INTEGER start;
215   ULONG xread;
216
217   *phglobal = 0;
218   if (pMemLockBytes->lpVtbl == &HGLOBALLockBytesImpl_Vtbl) {
219     *phglobal = pMemLockBytes->supportHandle;
220     if (*phglobal == 0)
221       return E_INVALIDARG;
222     return S_OK;
223   }
224   /* It is not our lockbytes implementation, so use a more generic way */
225   hres = ILockBytes_Stat(plkbyt,&stbuf,0);
226   if (hres != S_OK) {
227      ERR("Cannot ILockBytes_Stat, %lx\n",hres);
228      return hres;
229   }
230   FIXME("cbSize is %ld\n",stbuf.cbSize.u.LowPart);
231   *phglobal = GlobalAlloc( GMEM_MOVEABLE|GMEM_SHARE, stbuf.cbSize.u.LowPart);
232   if (!*phglobal)
233     return E_INVALIDARG;
234   memset(&start,0,sizeof(start));
235   hres = ILockBytes_ReadAt(plkbyt, start, GlobalLock(*phglobal), stbuf.cbSize.u.LowPart, &xread);
236   GlobalUnlock(*phglobal);
237   if (hres != S_OK) {
238     FIXME("%p->ReadAt failed with %lx\n",plkbyt,hres);
239     return hres;
240   }
241   if (stbuf.cbSize.u.LowPart != xread) {
242     FIXME("Read size is not requested size %ld vs %ld?\n",stbuf.cbSize.u.LowPart, xread);
243   }
244   return S_OK;
245 }
246
247 /******************************************************************************
248  *
249  * HGLOBALLockBytesImpl implementation
250  *
251  */
252
253 /******************************************************************************
254  * This is the constructor for the HGLOBALLockBytesImpl class.
255  *
256  * PARAMS
257  *    hGlobal          [ I] Handle that will support the stream. can be NULL.
258  *    fDeleteOnRelease [ I] Flag set to TRUE if the HGLOBAL will be released
259  *                          when the IStream object is destroyed.
260  */
261 HGLOBALLockBytesImpl* HGLOBALLockBytesImpl_Construct(HGLOBAL hGlobal,
262                                                      BOOL    fDeleteOnRelease)
263 {
264   HGLOBALLockBytesImpl* newLockBytes;
265   newLockBytes = HeapAlloc(GetProcessHeap(), 0, sizeof(HGLOBALLockBytesImpl));
266
267   if (newLockBytes!=0)
268   {
269     /*
270      * Set up the virtual function table and reference count.
271      */
272     newLockBytes->lpVtbl = &HGLOBALLockBytesImpl_Vtbl;
273     newLockBytes->ref    = 0;
274
275     /*
276      * Initialize the support.
277      */
278     newLockBytes->supportHandle = hGlobal;
279     newLockBytes->deleteOnRelease = fDeleteOnRelease;
280
281     /*
282      * This method will allocate a handle if one is not supplied.
283      */
284     if (newLockBytes->supportHandle == 0)
285     {
286       newLockBytes->supportHandle = GlobalAlloc(GMEM_MOVEABLE |
287                                                 GMEM_NODISCARD,
288                                                 0);
289     }
290
291     /*
292      * Initialize the size of the array to the size of the handle.
293      */
294     newLockBytes->byteArraySize.u.HighPart = 0;
295     newLockBytes->byteArraySize.u.LowPart  = GlobalSize(
296                                               newLockBytes->supportHandle);
297   }
298
299   return newLockBytes;
300 }
301
302 /******************************************************************************
303  * This is the destructor of the HGLOBALStreamImpl class.
304  *
305  * This method will clean-up all the resources used-up by the given
306  * HGLOBALLockBytesImpl class. The pointer passed-in to this function will be
307  * freed and will not be valid anymore.
308  */
309 void HGLOBALLockBytesImpl_Destroy(HGLOBALLockBytesImpl* This)
310 {
311   /*
312    * Release the HGlobal if the constructor asked for that.
313    */
314   if (This->deleteOnRelease)
315   {
316     GlobalFree(This->supportHandle);
317     This->supportHandle = 0;
318   }
319
320   /*
321    * Finally, free the memory used-up by the class.
322    */
323   HeapFree(GetProcessHeap(), 0, This);
324 }
325
326 /******************************************************************************
327  * This implements the IUnknown method QueryInterface for this
328  * class
329  */
330 HRESULT WINAPI HGLOBALLockBytesImpl_QueryInterface(
331       ILockBytes*  iface,
332       REFIID       riid,        /* [in] */
333       void**       ppvObject)   /* [iid_is][out] */
334 {
335   HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
336
337   /*
338    * Perform a sanity check on the parameters.
339    */
340   if (ppvObject==0)
341     return E_INVALIDARG;
342
343   /*
344    * Initialize the return parameter.
345    */
346   *ppvObject = 0;
347
348   /*
349    * Compare the riid with the interface IDs implemented by this object.
350    */
351   if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0)
352   {
353     *ppvObject = (ILockBytes*)This;
354   }
355   else if (memcmp(&IID_ILockBytes, riid, sizeof(IID_ILockBytes)) == 0)
356   {
357     *ppvObject = (ILockBytes*)This;
358   }
359
360   /*
361    * Check that we obtained an interface.
362    */
363   if ((*ppvObject)==0)
364     return E_NOINTERFACE;
365
366   /*
367    * Query Interface always increases the reference count by one when it is
368    * successful
369    */
370   HGLOBALLockBytesImpl_AddRef(iface);
371
372   return S_OK;
373 }
374
375 /******************************************************************************
376  * This implements the IUnknown method AddRef for this
377  * class
378  */
379 ULONG WINAPI HGLOBALLockBytesImpl_AddRef(ILockBytes* iface)
380 {
381   HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
382   return InterlockedIncrement(&This->ref);
383 }
384
385 /******************************************************************************
386  * This implements the IUnknown method Release for this
387  * class
388  */
389 ULONG WINAPI HGLOBALLockBytesImpl_Release(ILockBytes* iface)
390 {
391   HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
392   ULONG ref;
393
394   ref = InterlockedDecrement(&This->ref);
395
396   /*
397    * If the reference count goes down to 0, perform suicide.
398    */
399   if (ref==0)
400   {
401     HGLOBALLockBytesImpl_Destroy(This);
402   }
403
404   return ref;
405 }
406
407 /******************************************************************************
408  * This method is part of the ILockBytes interface.
409  *
410  * It reads a block of information from the byte array at the specified
411  * offset.
412  *
413  * See the documentation of ILockBytes for more info.
414  */
415 HRESULT WINAPI HGLOBALLockBytesImpl_ReadAt(
416       ILockBytes*    iface,
417       ULARGE_INTEGER ulOffset,  /* [in] */
418       void*          pv,        /* [length_is][size_is][out] */
419       ULONG          cb,        /* [in] */
420       ULONG*         pcbRead)   /* [out] */
421 {
422   HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
423
424   void* supportBuffer;
425   ULONG bytesReadBuffer = 0;
426   ULONG bytesToReadFromBuffer;
427
428   /*
429    * If the caller is not interested in the number of bytes read,
430    * we use another buffer to avoid "if" statements in the code.
431    */
432   if (pcbRead == 0)
433     pcbRead = &bytesReadBuffer;
434
435   /*
436    * Make sure the offset is valid.
437    */
438   if (ulOffset.u.LowPart > This->byteArraySize.u.LowPart)
439     return E_FAIL;
440
441   /*
442    * Using the known size of the array, calculate the number of bytes
443    * to read.
444    */
445   bytesToReadFromBuffer = min(This->byteArraySize.u.LowPart -
446                               ulOffset.u.LowPart, cb);
447
448   /*
449    * Lock the buffer in position and copy the data.
450    */
451   supportBuffer = GlobalLock(This->supportHandle);
452
453   memcpy(pv,
454          (char *) supportBuffer + ulOffset.u.LowPart,
455          bytesToReadFromBuffer);
456
457   /*
458    * Return the number of bytes read.
459    */
460   *pcbRead = bytesToReadFromBuffer;
461
462   /*
463    * Cleanup
464    */
465   GlobalUnlock(This->supportHandle);
466
467   /*
468    * The function returns S_OK if the specified number of bytes were read
469    * or the end of the array was reached.
470    * It returns STG_E_READFAULT if the number of bytes to read does not equal
471    * the number of bytes actually read.
472    */
473   if(*pcbRead == cb)
474     return S_OK;
475
476   return STG_E_READFAULT;
477 }
478
479 /******************************************************************************
480  * This method is part of the ILockBytes interface.
481  *
482  * It writes the specified bytes at the specified offset.
483  * position. If the array is too small, it will be resized.
484  *
485  * See the documentation of ILockBytes for more info.
486  */
487 HRESULT WINAPI HGLOBALLockBytesImpl_WriteAt(
488       ILockBytes*    iface,
489       ULARGE_INTEGER ulOffset,    /* [in] */
490       const void*    pv,          /* [size_is][in] */
491       ULONG          cb,          /* [in] */
492       ULONG*         pcbWritten)  /* [out] */
493 {
494   HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
495
496   void*          supportBuffer;
497   ULARGE_INTEGER newSize;
498   ULONG          bytesWritten = 0;
499
500   /*
501    * If the caller is not interested in the number of bytes written,
502    * we use another buffer to avoid "if" statements in the code.
503    */
504   if (pcbWritten == 0)
505     pcbWritten = &bytesWritten;
506
507   if (cb == 0)
508   {
509     return S_OK;
510   }
511   else
512   {
513     newSize.u.HighPart = 0;
514     newSize.u.LowPart = ulOffset.u.LowPart + cb;
515   }
516
517   /*
518    * Verify if we need to grow the stream
519    */
520   if (newSize.u.LowPart > This->byteArraySize.u.LowPart)
521   {
522     /* grow stream */
523     if (HGLOBALLockBytesImpl_SetSize(iface, newSize) == STG_E_MEDIUMFULL)
524       return STG_E_MEDIUMFULL;
525   }
526
527   /*
528    * Lock the buffer in position and copy the data.
529    */
530   supportBuffer = GlobalLock(This->supportHandle);
531
532   memcpy((char *) supportBuffer + ulOffset.u.LowPart, pv, cb);
533
534   /*
535    * Return the number of bytes written.
536    */
537   *pcbWritten = cb;
538
539   /*
540    * Cleanup
541    */
542   GlobalUnlock(This->supportHandle);
543
544   return S_OK;
545 }
546
547 /******************************************************************************
548  * This method is part of the ILockBytes interface.
549  *
550  * See the documentation of ILockBytes for more info.
551  */
552 HRESULT WINAPI HGLOBALLockBytesImpl_Flush(ILockBytes* iface)
553 {
554   return S_OK;
555 }
556
557 /******************************************************************************
558  * This method is part of the ILockBytes interface.
559  *
560  * It will change the size of the byte array.
561  *
562  * See the documentation of ILockBytes for more info.
563  */
564 HRESULT WINAPI HGLOBALLockBytesImpl_SetSize(
565       ILockBytes*     iface,
566       ULARGE_INTEGER  libNewSize)   /* [in] */
567 {
568   HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
569   HGLOBAL supportHandle;
570
571   /*
572    * As documented.
573    */
574   if (libNewSize.u.HighPart != 0)
575     return STG_E_INVALIDFUNCTION;
576
577   if (This->byteArraySize.u.LowPart == libNewSize.u.LowPart)
578     return S_OK;
579
580   /*
581    * Re allocate the HGlobal to fit the new size of the stream.
582    */
583   supportHandle = GlobalReAlloc(This->supportHandle, libNewSize.u.LowPart, 0);
584
585   if (supportHandle == 0)
586     return STG_E_MEDIUMFULL;
587
588   This->supportHandle = supportHandle;
589   This->byteArraySize.u.LowPart = libNewSize.u.LowPart;
590
591   return S_OK;
592 }
593
594 /******************************************************************************
595  * This method is part of the ILockBytes interface.
596  *
597  * The global memory implementation of ILockBytes does not support locking.
598  *
599  * See the documentation of ILockBytes for more info.
600  */
601 HRESULT WINAPI HGLOBALLockBytesImpl_LockRegion(
602       ILockBytes*    iface,
603       ULARGE_INTEGER libOffset,   /* [in] */
604       ULARGE_INTEGER cb,          /* [in] */
605       DWORD          dwLockType)  /* [in] */
606 {
607   return STG_E_INVALIDFUNCTION;
608 }
609
610 /******************************************************************************
611  * This method is part of the ILockBytes interface.
612  *
613  * The global memory implementation of ILockBytes does not support locking.
614  *
615  * See the documentation of ILockBytes for more info.
616  */
617 HRESULT WINAPI HGLOBALLockBytesImpl_UnlockRegion(
618       ILockBytes*    iface,
619       ULARGE_INTEGER libOffset,   /* [in] */
620       ULARGE_INTEGER cb,          /* [in] */
621       DWORD          dwLockType)  /* [in] */
622 {
623   return STG_E_INVALIDFUNCTION;
624 }
625
626 /******************************************************************************
627  * This method is part of the ILockBytes interface.
628  *
629  * This method returns information about the current
630  * byte array object.
631  *
632  * See the documentation of ILockBytes for more info.
633  */
634 HRESULT WINAPI HGLOBALLockBytesImpl_Stat(
635       ILockBytes*  iface,
636       STATSTG*     pstatstg,     /* [out] */
637       DWORD        grfStatFlag)  /* [in] */
638 {
639   HGLOBALLockBytesImpl* const This=(HGLOBALLockBytesImpl*)iface;
640
641   memset(pstatstg, 0, sizeof(STATSTG));
642
643   pstatstg->pwcsName = NULL;
644   pstatstg->type     = STGTY_LOCKBYTES;
645   pstatstg->cbSize   = This->byteArraySize;
646
647   return S_OK;
648 }