ReactOS  0.4.14-dev-999-g61c8d34
clist.c
Go to the documentation of this file.
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 
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;
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 BOOL 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 FALSE;
77 
78  if (lpNewItem->cbSize < sizeof(DATABLOCK_HEADER) ||
79  lpNewItem->dwSignature == CLIST_ID_CONTAINER)
80  return FALSE;
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 = LocalAlloc(LMEM_ZEROINIT, ulSize + sizeof(ULONG));
95  lpInsertAt = *lppList;
96  }
97  else
98  {
99  /* Append to the end of the list */
100  ULONG ulTotalSize = 0;
101  LPDATABLOCK_HEADER lpIter = *lppList;
102 
103  /* Iterate to the end of the list, calculating the total size */
104  while (lpIter->cbSize)
105  {
106  ulTotalSize += lpIter->cbSize;
107  lpIter = NextItem(lpIter);
108  }
109 
110  /* Increase the size of the list */
111  lpIter = LocalReAlloc(*lppList, ulTotalSize + ulSize+sizeof(ULONG),
113  if(lpIter)
114  {
115  *lppList = lpIter;
116  lpInsertAt = (LPDATABLOCK_HEADER)((char*)lpIter + ulTotalSize); /* At end */
117  }
118  }
119 
120  if(lpInsertAt)
121  {
122  /* Copy in the new item */
123  LPDATABLOCK_HEADER lpDest = lpInsertAt;
124 
125  if(ulSize != lpNewItem->cbSize)
126  {
127  lpInsertAt->cbSize = ulSize;
128  lpInsertAt->dwSignature = CLIST_ID_CONTAINER;
129  lpDest++;
130  }
131  memcpy(lpDest, lpNewItem, lpNewItem->cbSize);
132 
133  /* Terminate the list */
134  lpInsertAt = NextItem(lpInsertAt);
135  lpInsertAt->cbSize = 0;
136 
137  return TRUE;
138  }
139  return FALSE;
140 }
141 
142 /*************************************************************************
143  * @ [SHLWAPI.17]
144  *
145  * Write a DataBlock list to an IStream object.
146  *
147  * PARAMS
148  * lpStream [I] IStream object to write the list to
149  * lpList [I] List of items to write
150  *
151  * RETURNS
152  * Success: S_OK. The object is written to the stream.
153  * Failure: An HRESULT error code
154  *
155  * NOTES
156  * Ordinals 17,18,19,20,21 and 22 are related and together provide a compact
157  * list structure (a "DataBlock List"), which may be stored and retrieved from
158  * an IStream object.
159  *
160  * The exposed API consists of:
161  *
162  * - SHWriteDataBlockList() - Write a DataBlock list to a stream,
163  * - SHReadDataBlockList() - Read and create a list from a stream,
164  * - SHFreeDataBlockList() - Free a list,
165  * - SHAddDataBlock() - Insert a new item into a list,
166  * - SHRemoveDataBlock() - Remove an item from a list,
167  * - SHFindDataBlock() - Find an item in a list.
168  *
169  * The DataBlock list is stored packed into a memory array. Each element has a
170  * size and an associated ID. Elements must be less than 64k if the list is
171  * to be subsequently read from a stream.
172  *
173  * Elements are aligned on DWORD boundaries. If an elements data size is not
174  * a DWORD size multiple, the element is wrapped by inserting a surrounding
175  * element with an Id of 0xFFFFFFFF, and size sufficient to pad to a DWORD boundary.
176  *
177  * These functions are slow for large objects and long lists.
178  */
180 {
181  ULONG ulSize;
182  HRESULT hRet = S_OK;
183 
184  TRACE("(%p,%p)\n", lpStream, lpList);
185 
186  if(lpList)
187  {
188  while (lpList->cbSize)
189  {
190  LPDATABLOCK_HEADER lpItem = lpList;
191 
192  if(lpList->dwSignature == CLIST_ID_CONTAINER)
193  lpItem++;
194 
195  hRet = IStream_Write(lpStream,lpItem,lpItem->cbSize,&ulSize);
196  if (FAILED(hRet))
197  return hRet;
198 
199  if(lpItem->cbSize != ulSize)
200  return STG_E_MEDIUMFULL;
201 
202  lpList = NextItem(lpList);
203  }
204  }
205 
206  if(SUCCEEDED(hRet))
207  {
208  ULONG ulDummy;
209  ulSize = 0;
210 
211  /* Write a terminating list entry with zero size */
212  hRet = IStream_Write(lpStream, &ulSize,sizeof(ulSize),&ulDummy);
213  }
214 
215  return hRet;
216 }
217 
218 /*************************************************************************
219  * @ [SHLWAPI.18]
220  *
221  * Read and create a DataBlock list from an IStream object.
222  *
223  * PARAMS
224  * lpStream [I] Stream to read the list from
225  * lppList [0] Pointer to receive the new List
226  *
227  * RETURNS
228  * Success: S_OK
229  * Failure: An HRESULT error code
230  *
231  * NOTES
232  * When read from a file, list objects are limited in size to 64k.
233  * See SHWriteDataBlockList.
234  */
236 {
237  DATABLOCK_HEADER bBuff[128]; /* Temporary storage for new list item */
238  ULONG ulBuffSize = sizeof(bBuff);
239  LPDATABLOCK_HEADER pItem = bBuff;
240  ULONG ulRead, ulSize;
241  HRESULT hRet = S_OK;
242 
243  TRACE("(%p,%p)\n", lpStream, lppList);
244 
245  if(*lppList)
246  {
247  /* Free any existing list */
248  LocalFree(*lppList);
249  *lppList = NULL;
250  }
251 
252  do
253  {
254  /* Read the size of the next item */
255  hRet = IStream_Read(lpStream, &ulSize,sizeof(ulSize),&ulRead);
256 
257  if(FAILED(hRet) || ulRead != sizeof(ulSize) || !ulSize)
258  break; /* Read failed or read zero size (the end of the list) */
259 
260  if(ulSize > 0xFFFF)
261  {
262  LARGE_INTEGER liZero;
263  ULARGE_INTEGER ulPos;
264 
265  liZero.QuadPart = 0;
266 
267  /* Back the stream up; this object is too big for the list */
268  if(SUCCEEDED(IStream_Seek(lpStream, liZero, STREAM_SEEK_CUR, &ulPos)))
269  {
270  liZero.QuadPart = ulPos.QuadPart - sizeof(ULONG);
271  IStream_Seek(lpStream, liZero, STREAM_SEEK_SET, NULL);
272  }
273  break;
274  }
275  else if (ulSize >= sizeof(DATABLOCK_HEADER))
276  {
277  /* Add this new item to the list */
278  if(ulSize > ulBuffSize)
279  {
280  /* We need more buffer space, allocate it */
281  LPDATABLOCK_HEADER lpTemp;
282 
283  if (pItem == bBuff)
284  lpTemp = LocalAlloc(LMEM_ZEROINIT, ulSize);
285  else
286  lpTemp = LocalReAlloc(pItem, ulSize, LMEM_ZEROINIT|LMEM_MOVEABLE);
287 
288  if(!lpTemp)
289  {
290  hRet = E_OUTOFMEMORY;
291  break;
292  }
293  ulBuffSize = ulSize;
294  pItem = lpTemp;
295  }
296 
297  pItem->cbSize = ulSize;
298  ulSize -= sizeof(pItem->cbSize); /* already read this member */
299 
300  /* Read the item Id and data */
301  hRet = IStream_Read(lpStream, &pItem->dwSignature, ulSize, &ulRead);
302 
303  if(FAILED(hRet) || ulRead != ulSize)
304  break;
305 
306  SHAddDataBlock(lppList, pItem); /* Insert Item */
307  }
308  } while(1);
309 
310  /* If we allocated space, free it */
311  if(pItem != bBuff)
312  LocalFree(pItem);
313 
314  return hRet;
315 }
316 
317 /*************************************************************************
318  * @ [SHLWAPI.19]
319  *
320  * Free a DataBlock list.
321  *
322  * PARAMS
323  * lpList [I] List to free
324  *
325  * RETURNS
326  * Nothing.
327  *
328  * NOTES
329  * See SHWriteDataBlockList.
330  */
332 {
333  TRACE("(%p)\n", lpList);
334 
335  if (lpList)
336  LocalFree(lpList);
337 }
338 
339 /*************************************************************************
340  * @ [SHLWAPI.21]
341  *
342  * Remove an item from a DataBlock list.
343  *
344  * PARAMS
345  * lppList [O] List to remove the item from
346  * dwSignature [I] Id of item to remove
347  *
348  * RETURNS
349  * Success: TRUE.
350  * Failure: FALSE, If any parameters are invalid, or the item was not found.
351  *
352  * NOTES
353  * See SHWriteDataBlockList.
354  */
356 {
357  LPDATABLOCK_HEADER lpList = NULL;
358  LPDATABLOCK_HEADER lpItem = NULL;
359  LPDATABLOCK_HEADER lpNext;
360  ULONG ulNewSize;
361 
362  TRACE("(%p,%d)\n", lppList, dwSignature);
363 
364  if(lppList && (lpList = *lppList))
365  {
366  /* Search for item in list */
367  while (lpList->cbSize)
368  {
369  if(lpList->dwSignature == dwSignature ||
370  (lpList->dwSignature == CLIST_ID_CONTAINER && lpList[1].dwSignature == dwSignature))
371  {
372  lpItem = lpList; /* Found */
373  break;
374  }
375  lpList = NextItem(lpList);
376  }
377  }
378 
379  if(!lpItem)
380  return FALSE;
381 
382  lpList = lpNext = NextItem(lpItem);
383 
384  /* Locate the end of the list */
385  while (lpList->cbSize)
386  lpList = NextItem(lpList);
387 
388  /* Resize the list */
389  ulNewSize = LocalSize(*lppList) - lpItem->cbSize;
390 
391  /* Copy following elements over lpItem */
392  memmove(lpItem, lpNext, (char *)lpList - (char *)lpNext + sizeof(ULONG));
393 
394  if(ulNewSize <= sizeof(ULONG))
395  {
396  LocalFree(*lppList);
397  *lppList = NULL; /* Removed the last element */
398  }
399  else
400  {
401  lpList = LocalReAlloc(*lppList, ulNewSize, LMEM_ZEROINIT|LMEM_MOVEABLE);
402  if(lpList)
403  *lppList = lpList;
404  }
405  return TRUE;
406 }
407 
408 /*************************************************************************
409  * @ [SHLWAPI.22]
410  *
411  * Find an item in a DataBlock list.
412  *
413  * PARAMS
414  * lpList [I] List to search
415  * dwSignature [I] Id of item to find
416  *
417  * RETURNS
418  * Success: A pointer to the list item found
419  * Failure: NULL
420  *
421  * NOTES
422  * See SHWriteDataBlockList.
423  */
425 {
426  TRACE("(%p,%d)\n", lpList, dwSignature);
427 
428  if(lpList)
429  {
430  while(lpList->cbSize)
431  {
432  if(lpList->dwSignature == dwSignature)
433  return lpList; /* Matched */
434  else if(lpList->dwSignature == CLIST_ID_CONTAINER && lpList[1].dwSignature == dwSignature)
435  return lpList + 1; /* Contained item matches */
436 
437  lpList = NextItem(lpList);
438  }
439  }
440  return NULL;
441 }
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
#define TRUE
Definition: types.h:120
#define CLIST_ID_CONTAINER
Definition: clist.c:35
static ULONG
Definition: clist.c:222
#define STG_E_MEDIUMFULL
Definition: winerror.h:2581
SIZE_T NTAPI LocalSize(HLOCAL hMem)
Definition: heapmem.c:1777
HRESULT WINAPI SHReadDataBlockList(IStream *lpStream, LPDBLIST *lppList)
Definition: clist.c:235
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
ULONGLONG QuadPart
Definition: ms-dtyp.idl:185
unsigned int BOOL
Definition: ntddk_ex.h:94
BOOL WINAPI SHAddDataBlock(LPDBLIST *lppList, const DATABLOCK_HEADER *lpNewItem)
Definition: clist.c:68
struct tagDATABLOCKHEADER * LPDATABLOCK_HEADER
smooth NULL
Definition: ftsmooth.c:416
WINE_DEFAULT_DEBUG_CHANNEL(shell)
#define TRACE(s)
Definition: solgame.cpp:4
#define LMEM_ZEROINIT
Definition: winbase.h:356
LONG HRESULT
Definition: typedefs.h:78
#define WINAPI
Definition: msvc.h:6
#define LMEM_MOVEABLE
Definition: winbase.h:350
DATABLOCK_HEADER *WINAPI SHFindDataBlock(LPDBLIST lpList, DWORD dwSignature)
Definition: clist.c:424
unsigned long DWORD
Definition: ntddk_ex.h:95
GLuint address
Definition: glext.h:9393
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
HRESULT WINAPI SHWriteDataBlockList(IStream *lpStream, LPDBLIST lpList)
Definition: clist.c:179
struct tagDATABLOCKHEADER DATABLOCK_HEADER
#define S_OK
Definition: intsafe.h:59
HLOCAL NTAPI LocalReAlloc(HLOCAL hMem, SIZE_T dwBytes, UINT uFlags)
Definition: heapmem.c:1608
BOOL WINAPI SHRemoveDataBlock(LPDBLIST *lppList, DWORD dwSignature)
Definition: clist.c:355
void shell(int argc, const char *argv[])
Definition: cmds.c:1231
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1577
VOID WINAPI SHFreeDataBlockList(LPDBLIST lpList)
Definition: clist.c:331
unsigned int ULONG
Definition: retypes.h:1
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1373
static LPDATABLOCK_HEADER NextItem(LPDBLIST lpList)
Definition: clist.c:42
#define SUCCEEDED(hr)
Definition: intsafe.h:57
LONGLONG QuadPart
Definition: typedefs.h:113