user32/tests: Add more A and W test combinations for dde.
[wine] / dlls / shlwapi / clist.c
1 /*
2  * SHLWAPI DataBlock List functions
3  *
4  * Copyright 2002 Jon Griffiths
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 #include <stdarg.h>
21 #include <string.h>
22
23 #define COBJMACROS
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "winuser.h"
28 #include "objbase.h"
29 #include "shlobj.h"
30 #include "wine/debug.h"
31
32 WINE_DEFAULT_DEBUG_CHANNEL(shell);
33
34 /* dwSignature for contained DATABLOCK_HEADER items */
35 #define CLIST_ID_CONTAINER (~0U)
36
37 /*************************************************************************
38  * NextItem
39  *
40  * Internal helper: move a DataBlock pointer to the next item.
41  */
42 static inline LPDATABLOCK_HEADER NextItem(LPDBLIST lpList)
43 {
44   char* address = (char*)lpList;
45   address += lpList->cbSize;
46   return (LPDATABLOCK_HEADER)address;
47 }
48
49 /*************************************************************************
50  *      @       [SHLWAPI.20]
51  *
52  * Insert a new item into a DataBlock list.
53  *
54  * PARAMS
55  *  lppList   [0] Pointer to the List
56  *  lpNewItem [I] The new item to add to the list
57  *
58  * RETURNS
59  *  Success: S_OK. The item is added to the list.
60  *  Failure: An HRESULT error code.
61  *
62  * NOTES
63  *  If the size of the element to be inserted is less than the size of a
64  *  DATABLOCK_HEADER node, or the Id for the item is CLIST_ID_CONTAINER,
65  *  the call returns S_OK but does not actually add the element.
66  *  See SHWriteDataBlockList.
67  */
68 HRESULT WINAPI SHAddDataBlock(LPDBLIST* lppList, const DATABLOCK_HEADER *lpNewItem)
69 {
70   LPDATABLOCK_HEADER lpInsertAt = NULL;
71   ULONG ulSize;
72
73   TRACE("(%p,%p)\n", lppList, lpNewItem);
74
75   if(!lppList || !lpNewItem )
76     return E_INVALIDARG;
77
78   if (lpNewItem->cbSize < sizeof(DATABLOCK_HEADER) ||
79       lpNewItem->dwSignature == CLIST_ID_CONTAINER)
80     return S_OK;
81
82   ulSize = lpNewItem->cbSize;
83
84   if(ulSize & 0x3)
85   {
86     /* Tune size to a ULONG boundary, add space for container element */
87     ulSize = ((ulSize + 0x3) & 0xFFFFFFFC) + sizeof(DATABLOCK_HEADER);
88     TRACE("Creating container item, new size = %d\n", ulSize);
89   }
90
91   if(!*lppList)
92   {
93     /* An empty list. Allocate space for terminal ulSize also */
94     *lppList = (LPDATABLOCK_HEADER)LocalAlloc(LMEM_ZEROINIT,
95                                            ulSize + sizeof(ULONG));
96     lpInsertAt = *lppList;
97   }
98   else
99   {
100     /* Append to the end of the list */
101     ULONG ulTotalSize = 0;
102     LPDATABLOCK_HEADER lpIter = *lppList;
103
104     /* Iterate to the end of the list, calculating the total size */
105     while (lpIter->cbSize)
106     {
107       ulTotalSize += lpIter->cbSize;
108       lpIter = NextItem(lpIter);
109     }
110
111     /* Increase the size of the list */
112     lpIter = (LPDATABLOCK_HEADER)LocalReAlloc((HLOCAL)*lppList,
113                                           ulTotalSize + ulSize+sizeof(ULONG),
114                                           LMEM_ZEROINIT | LMEM_MOVEABLE);
115     if(lpIter)
116     {
117       *lppList = lpIter;
118       lpInsertAt = (LPDATABLOCK_HEADER)((char*)lpIter + ulTotalSize); /* At end */
119     }
120   }
121
122   if(lpInsertAt)
123   {
124     /* Copy in the new item */
125     LPDATABLOCK_HEADER lpDest = lpInsertAt;
126
127     if(ulSize != lpNewItem->cbSize)
128     {
129       lpInsertAt->cbSize = ulSize;
130       lpInsertAt->dwSignature = CLIST_ID_CONTAINER;
131       lpDest++;
132     }
133     memcpy(lpDest, lpNewItem, lpNewItem->cbSize);
134
135     /* Terminate the list */
136     lpInsertAt = NextItem(lpInsertAt);
137     lpInsertAt->cbSize = 0;
138
139     return lpNewItem->cbSize;
140   }
141   return S_OK;
142 }
143
144 /*************************************************************************
145  *      @       [SHLWAPI.17]
146  *
147  * Write a DataBlock list to an IStream object.
148  *
149  * PARAMS
150  *  lpStream  [I] IStream object to write the list to
151  *  lpList    [I] List of items to write
152  *
153  * RETURNS
154  *  Success: S_OK. The object is written to the stream.
155  *  Failure: An HRESULT error code
156  *
157  * NOTES
158  *  Ordinals 17,18,19,20,21 and 22 are related and together provide a compact
159  *  list structure (a "DataBlock List"), which may be stored and retrieved from
160  *  an IStream object.
161  *
162  *  The exposed API consists of:
163  *
164  *  - SHWriteDataBlockList() - Write a DataBlock list to a stream,
165  *  - SHReadDataBlockList() - Read and create a list from a stream,
166  *  - SHFreeDataBlockList() - Free a list,
167  *  - SHAddDataBlock() - Insert a new item into a list,
168  *  - SHRemoveDataBlock() - Remove an item from a list,
169  *  - SHFindDataBlock() - Find an item in a list.
170  *
171  *  The DataBlock list is stored packed into a memory array. Each element has a
172  *  size and an associated ID. Elements must be less than 64k if the list is
173  *  to be subsequently read from a stream.
174  *
175  *  Elements are aligned on DWORD boundaries. If an elements data size is not
176  *  a DWORD size multiple, the element is wrapped by inserting a surrounding
177  *  element with an Id of 0xFFFFFFFF, and size sufficient to pad to a DWORD boundary.
178  *
179  *  These functions are slow for large objects and long lists.
180  */
181 HRESULT WINAPI SHWriteDataBlockList(IStream* lpStream, LPDBLIST lpList)
182 {
183   ULONG ulSize;
184   HRESULT hRet = S_OK;
185
186   TRACE("(%p,%p)\n", lpStream, lpList);
187
188   if(lpList)
189   {
190     while (lpList->cbSize)
191     {
192       LPDATABLOCK_HEADER lpItem = lpList;
193
194       if(lpList->dwSignature == CLIST_ID_CONTAINER)
195         lpItem++;
196
197       hRet = IStream_Write(lpStream,lpItem,lpItem->cbSize,&ulSize);
198       if (FAILED(hRet))
199         return hRet;
200
201       if(lpItem->cbSize != ulSize)
202         return STG_E_MEDIUMFULL;
203
204       lpList = NextItem(lpList);
205     }
206   }
207
208   if(SUCCEEDED(hRet))
209   {
210     ULONG ulDummy;
211     ulSize = 0;
212
213     /* Write a terminating list entry with zero size */
214     hRet = IStream_Write(lpStream, &ulSize,sizeof(ulSize),&ulDummy);
215   }
216
217   return hRet;
218 }
219
220 /*************************************************************************
221  *      @       [SHLWAPI.18]
222  *
223  * Read and create a DataBlock list from an IStream object.
224  *
225  * PARAMS
226  *  lpStream  [I] Stream to read the list from
227  *  lppList   [0] Pointer to receive the new List
228  *
229  * RETURNS
230  *  Success: S_OK
231  *  Failure: An HRESULT error code
232  *
233  * NOTES
234  *  When read from a file, list objects are limited in size to 64k.
235  *  See SHWriteDataBlockList.
236  */
237 HRESULT WINAPI SHReadDataBlockList(IStream* lpStream, LPDBLIST* lppList)
238 {
239   DATABLOCK_HEADER bBuff[128]; /* Temporary storage for new list item */
240   ULONG ulBuffSize = sizeof(bBuff);
241   LPDATABLOCK_HEADER pItem = bBuff;
242   ULONG ulRead, ulSize;
243   HRESULT hRet = S_OK;
244
245   TRACE("(%p,%p)\n", lpStream, lppList);
246
247   if(*lppList)
248   {
249     /* Free any existing list */
250     LocalFree((HLOCAL)*lppList);
251     *lppList = NULL;
252   }
253
254   do
255   {
256     /* Read the size of the next item */
257     hRet = IStream_Read(lpStream, &ulSize,sizeof(ulSize),&ulRead);
258
259     if(FAILED(hRet) || ulRead != sizeof(ulSize) || !ulSize)
260       break; /* Read failed or read zero size (the end of the list) */
261
262     if(ulSize > 0xFFFF)
263     {
264       LARGE_INTEGER liZero;
265       ULARGE_INTEGER ulPos;
266
267       liZero.QuadPart = 0;
268
269       /* Back the stream up; this object is too big for the list */
270       if(SUCCEEDED(IStream_Seek(lpStream, liZero, STREAM_SEEK_CUR, &ulPos)))
271       {
272         liZero.QuadPart = ulPos.QuadPart - sizeof(ULONG);
273         IStream_Seek(lpStream, liZero, STREAM_SEEK_SET, NULL);
274       }
275       break;
276     }
277     else if (ulSize >= sizeof(DATABLOCK_HEADER))
278     {
279       /* Add this new item to the list */
280       if(ulSize > ulBuffSize)
281       {
282         /* We need more buffer space, allocate it */
283         LPDATABLOCK_HEADER lpTemp;
284
285         if (pItem == bBuff)
286           lpTemp = (LPDATABLOCK_HEADER)LocalAlloc(LMEM_ZEROINIT, ulSize);
287         else
288           lpTemp = (LPDATABLOCK_HEADER)LocalReAlloc((HLOCAL)pItem, ulSize,
289                                                  LMEM_ZEROINIT|LMEM_MOVEABLE);
290
291         if(!lpTemp)
292         {
293           hRet = E_OUTOFMEMORY;
294           break;
295         }
296         ulBuffSize = ulSize;
297         pItem = lpTemp;
298       }
299
300       pItem->cbSize = ulSize;
301       ulSize -= sizeof(pItem->cbSize); /* already read this member */
302
303       /* Read the item Id and data */
304       hRet = IStream_Read(lpStream, &pItem->dwSignature, ulSize, &ulRead);
305
306       if(FAILED(hRet) || ulRead != ulSize)
307         break;
308
309       SHAddDataBlock(lppList, pItem); /* Insert Item */
310     }
311   } while(1);
312
313   /* If we allocated space, free it */
314   if(pItem != bBuff)
315     LocalFree((HLOCAL)pItem);
316
317   return hRet;
318 }
319
320 /*************************************************************************
321  *      @       [SHLWAPI.19]
322  *
323  * Free a DataBlock list.
324  *
325  * PARAMS
326  *  lpList [I] List to free
327  *
328  * RETURNS
329  *  Nothing.
330  *
331  * NOTES
332  *  See SHWriteDataBlockList.
333  */
334 VOID WINAPI SHFreeDataBlockList(LPDBLIST lpList)
335 {
336   TRACE("(%p)\n", lpList);
337
338   if (lpList)
339     LocalFree((HLOCAL)lpList);
340 }
341
342 /*************************************************************************
343  *      @       [SHLWAPI.21]
344  *
345  * Remove an item from a DataBlock list.
346  *
347  * PARAMS
348  *  lppList     [O] List to remove the item from
349  *  dwSignature [I] Id of item to remove
350  *
351  * RETURNS
352  *  Success: TRUE.
353  *  Failure: FALSE, If any parameters are invalid, or the item was not found.
354  *
355  * NOTES
356  *  See SHWriteDataBlockList.
357  */
358 BOOL WINAPI SHRemoveDataBlock(LPDBLIST* lppList, DWORD dwSignature)
359 {
360   LPDATABLOCK_HEADER lpList = 0;
361   LPDATABLOCK_HEADER lpItem = NULL;
362   LPDATABLOCK_HEADER lpNext;
363   ULONG ulNewSize;
364
365   TRACE("(%p,%d)\n", lppList, dwSignature);
366
367   if(lppList && (lpList = *lppList))
368   {
369     /* Search for item in list */
370     while (lpList->cbSize)
371     {
372       if(lpList->dwSignature == dwSignature ||
373         (lpList->dwSignature == CLIST_ID_CONTAINER && lpList[1].dwSignature == dwSignature))
374       {
375         lpItem = lpList; /* Found */
376         break;
377       }
378       lpList = NextItem(lpList);
379     }
380   }
381
382   if(!lpItem)
383     return FALSE;
384
385   lpList = lpNext = NextItem(lpItem);
386
387   /* Locate the end of the list */
388   while (lpList->cbSize)
389     lpList = NextItem(lpList);
390
391   /* Resize the list */
392   ulNewSize = LocalSize((HLOCAL)*lppList) - lpItem->cbSize;
393
394   /* Copy following elements over lpItem */
395   memmove(lpItem, lpNext, (char *)lpList - (char *)lpNext + sizeof(ULONG));
396
397   if(ulNewSize <= sizeof(ULONG))
398   {
399     LocalFree((HLOCAL)*lppList);
400     *lppList = NULL; /* Removed the last element */
401   }
402   else
403   {
404     lpList = (LPDATABLOCK_HEADER)LocalReAlloc((HLOCAL)*lppList, ulNewSize,
405                                            LMEM_ZEROINIT|LMEM_MOVEABLE);
406     if(lpList)
407       *lppList = lpList;
408   }
409   return TRUE;
410 }
411
412 /*************************************************************************
413  *      @       [SHLWAPI.22]
414  *
415  * Find an item in a DataBlock list.
416  *
417  * PARAMS
418  *  lpList      [I] List to search
419  *  dwSignature [I] Id of item to find
420  *
421  * RETURNS
422  *  Success: A pointer to the list item found
423  *  Failure: NULL
424  *
425  * NOTES
426  *  See SHWriteDataBlockList.
427  */
428 DATABLOCK_HEADER* WINAPI SHFindDataBlock(LPDBLIST lpList, DWORD dwSignature)
429 {
430   TRACE("(%p,%d)\n", lpList, dwSignature);
431
432   if(lpList)
433   {
434     while(lpList->cbSize)
435     {
436       if(lpList->dwSignature == dwSignature)
437         return lpList; /* Matched */
438       else if(lpList->dwSignature == CLIST_ID_CONTAINER && lpList[1].dwSignature == dwSignature)
439         return lpList + 1; /* Contained item matches */
440
441       lpList = NextItem(lpList);
442     }
443   }
444   return NULL;
445 }