2 * SHLWAPI DataBlock List functions
4 * Copyright 2002 Jon Griffiths
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.
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.
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
30 #include "wine/debug.h"
32 WINE_DEFAULT_DEBUG_CHANNEL(shell);
34 /* dwSignature for contained DATABLOCK_HEADER items */
35 #define CLIST_ID_CONTAINER (~0U)
37 HRESULT WINAPI SHAddDataBlock(LPDBLIST*,const DATABLOCK_HEADER*);
39 /*************************************************************************
42 * Internal helper: move a DataBlock pointer to the next item.
44 static inline LPDATABLOCK_HEADER NextItem(LPDBLIST lpList)
46 char* address = (char*)lpList;
47 address += lpList->cbSize;
48 return (LPDATABLOCK_HEADER)address;
51 /*************************************************************************
54 * Write a DataBlock list to an IStream object.
57 * lpStream [I] IStream object to write the list to
58 * lpList [I] List of items to write
61 * Success: S_OK. The object is written to the stream.
62 * Failure: An HRESULT error code
65 * Ordinals 17,18,19,20,21 and 22 are related and together provide a compact
66 * list structure (a "DataBlock List"), which may be stored and retrieved from
69 * The exposed API consists of:
71 * - SHWriteDataBlockList() - Write a DataBlock list to a stream,
72 * - SHReadDataBlockList() - Read and create a list from a stream,
73 * - SHFreeDataBlockList() - Free a list,
74 * - SHAddDataBlock() - Insert a new item into a list,
75 * - SHRemoveDataBlock() - Remove an item from a list,
76 * - SHFindDataBlock() - Find an item in a list.
78 * The DataBlock list is stored packed into a memory array. Each element has a
79 * size and an associated ID. Elements must be less than 64k if the list is
80 * to be subsequently read from a stream.
82 * Elements are aligned on DWORD boundaries. If an elements data size is not
83 * a DWORD size multiple, the element is wrapped by inserting a surrounding
84 * element with an Id of 0xFFFFFFFF, and size sufficient to pad to a DWORD boundary.
86 * These functions are slow for large objects and long lists.
88 HRESULT WINAPI SHWriteDataBlockList(IStream* lpStream, LPDBLIST lpList)
93 TRACE("(%p,%p)\n", lpStream, lpList);
97 while (lpList->cbSize)
99 LPDATABLOCK_HEADER lpItem = lpList;
101 if(lpList->dwSignature == CLIST_ID_CONTAINER)
104 hRet = IStream_Write(lpStream,lpItem,lpItem->cbSize,&ulSize);
108 if(lpItem->cbSize != ulSize)
109 return STG_E_MEDIUMFULL;
111 lpList = NextItem(lpList);
120 /* Write a terminating list entry with zero size */
121 hRet = IStream_Write(lpStream, &ulSize,sizeof(ulSize),&ulDummy);
127 /*************************************************************************
130 * Read and create a DataBlock list from an IStream object.
133 * lpStream [I] Stream to read the list from
134 * lppList [0] Pointer to receive the new List
138 * Failure: An HRESULT error code
141 * When read from a file, list objects are limited in size to 64k.
142 * See SHWriteDataBlockList.
144 HRESULT WINAPI SHReadDataBlockList(IStream* lpStream, LPDBLIST* lppList)
146 DATABLOCK_HEADER bBuff[128]; /* Temporary storage for new list item */
147 ULONG ulBuffSize = sizeof(bBuff);
148 LPDATABLOCK_HEADER pItem = bBuff;
149 ULONG ulRead, ulSize;
152 TRACE("(%p,%p)\n", lpStream, lppList);
156 /* Free any existing list */
157 LocalFree((HLOCAL)*lppList);
163 /* Read the size of the next item */
164 hRet = IStream_Read(lpStream, &ulSize,sizeof(ulSize),&ulRead);
166 if(FAILED(hRet) || ulRead != sizeof(ulSize) || !ulSize)
167 break; /* Read failed or read zero size (the end of the list) */
171 LARGE_INTEGER liZero;
172 ULARGE_INTEGER ulPos;
176 /* Back the stream up; this object is too big for the list */
177 if(SUCCEEDED(IStream_Seek(lpStream, liZero, STREAM_SEEK_CUR, &ulPos)))
179 liZero.QuadPart = ulPos.QuadPart - sizeof(ULONG);
180 IStream_Seek(lpStream, liZero, STREAM_SEEK_SET, NULL);
184 else if (ulSize >= sizeof(DATABLOCK_HEADER))
186 /* Add this new item to the list */
187 if(ulSize > ulBuffSize)
189 /* We need more buffer space, allocate it */
190 LPDATABLOCK_HEADER lpTemp;
193 lpTemp = (LPDATABLOCK_HEADER)LocalAlloc(LMEM_ZEROINIT, ulSize);
195 lpTemp = (LPDATABLOCK_HEADER)LocalReAlloc((HLOCAL)pItem, ulSize,
196 LMEM_ZEROINIT|LMEM_MOVEABLE);
200 hRet = E_OUTOFMEMORY;
207 pItem->cbSize = ulSize;
208 ulSize -= sizeof(pItem->cbSize); /* already read this member */
210 /* Read the item Id and data */
211 hRet = IStream_Read(lpStream, &pItem->dwSignature, ulSize, &ulRead);
213 if(FAILED(hRet) || ulRead != ulSize)
216 SHAddDataBlock(lppList, pItem); /* Insert Item */
220 /* If we allocated space, free it */
222 LocalFree((HLOCAL)pItem);
227 /*************************************************************************
230 * Free a DataBlock list.
233 * lpList [I] List to free
239 * See SHWriteDataBlockList.
241 VOID WINAPI SHFreeDataBlockList(LPDBLIST lpList)
243 TRACE("(%p)\n", lpList);
246 LocalFree((HLOCAL)lpList);
249 /*************************************************************************
252 * Insert a new item into a DataBlock list.
255 * lppList [0] Pointer to the List
256 * lpNewItem [I] The new item to add to the list
259 * Success: S_OK. The item is added to the list.
260 * Failure: An HRESULT error code.
263 * If the size of the element to be inserted is less than the size of a
264 * DATABLOCK_HEADER node, or the Id for the item is CLIST_ID_CONTAINER,
265 * the call returns S_OK but does not actually add the element.
266 * See SHWriteDataBlockList.
268 HRESULT WINAPI SHAddDataBlock(LPDBLIST* lppList, const DATABLOCK_HEADER *lpNewItem)
270 LPDATABLOCK_HEADER lpInsertAt = NULL;
273 TRACE("(%p,%p)\n", lppList, lpNewItem);
275 if(!lppList || !lpNewItem )
278 if (lpNewItem->cbSize < sizeof(DATABLOCK_HEADER) ||
279 lpNewItem->dwSignature == CLIST_ID_CONTAINER)
282 ulSize = lpNewItem->cbSize;
286 /* Tune size to a ULONG boundary, add space for container element */
287 ulSize = ((ulSize + 0x3) & 0xFFFFFFFC) + sizeof(DATABLOCK_HEADER);
288 TRACE("Creating container item, new size = %d\n", ulSize);
293 /* An empty list. Allocate space for terminal ulSize also */
294 *lppList = (LPDATABLOCK_HEADER)LocalAlloc(LMEM_ZEROINIT,
295 ulSize + sizeof(ULONG));
296 lpInsertAt = *lppList;
300 /* Append to the end of the list */
301 ULONG ulTotalSize = 0;
302 LPDATABLOCK_HEADER lpIter = *lppList;
304 /* Iterate to the end of the list, calculating the total size */
305 while (lpIter->cbSize)
307 ulTotalSize += lpIter->cbSize;
308 lpIter = NextItem(lpIter);
311 /* Increase the size of the list */
312 lpIter = (LPDATABLOCK_HEADER)LocalReAlloc((HLOCAL)*lppList,
313 ulTotalSize + ulSize+sizeof(ULONG),
314 LMEM_ZEROINIT | LMEM_MOVEABLE);
318 lpInsertAt = (LPDATABLOCK_HEADER)((char*)lpIter + ulTotalSize); /* At end */
324 /* Copy in the new item */
325 LPDATABLOCK_HEADER lpDest = lpInsertAt;
327 if(ulSize != lpNewItem->cbSize)
329 lpInsertAt->cbSize = ulSize;
330 lpInsertAt->dwSignature = CLIST_ID_CONTAINER;
333 memcpy(lpDest, lpNewItem, lpNewItem->cbSize);
335 /* Terminate the list */
336 lpInsertAt = NextItem(lpInsertAt);
337 lpInsertAt->cbSize = 0;
339 return lpNewItem->cbSize;
344 /*************************************************************************
347 * Remove an item from a DataBlock list.
350 * lppList [O] List to remove the item from
351 * dwSignature [I] Id of item to remove
355 * Failure: FALSE, If any parameters are invalid, or the item was not found.
358 * See SHWriteDataBlockList.
360 BOOL WINAPI SHRemoveDataBlock(LPDBLIST* lppList, DWORD dwSignature)
362 LPDATABLOCK_HEADER lpList = 0;
363 LPDATABLOCK_HEADER lpItem = NULL;
364 LPDATABLOCK_HEADER lpNext;
367 TRACE("(%p,%d)\n", lppList, dwSignature);
369 if(lppList && (lpList = *lppList))
371 /* Search for item in list */
372 while (lpList->cbSize)
374 if(lpList->dwSignature == dwSignature ||
375 (lpList->dwSignature == CLIST_ID_CONTAINER && lpList[1].dwSignature == dwSignature))
377 lpItem = lpList; /* Found */
380 lpList = NextItem(lpList);
387 lpList = lpNext = NextItem(lpItem);
389 /* Locate the end of the list */
390 while (lpList->cbSize)
391 lpList = NextItem(lpList);
393 /* Resize the list */
394 ulNewSize = LocalSize((HLOCAL)*lppList) - lpItem->cbSize;
396 /* Copy following elements over lpItem */
397 memmove(lpItem, lpNext, (char *)lpList - (char *)lpNext + sizeof(ULONG));
399 if(ulNewSize <= sizeof(ULONG))
401 LocalFree((HLOCAL)*lppList);
402 *lppList = NULL; /* Removed the last element */
406 lpList = (LPDATABLOCK_HEADER)LocalReAlloc((HLOCAL)*lppList, ulNewSize,
407 LMEM_ZEROINIT|LMEM_MOVEABLE);
414 /*************************************************************************
417 * Find an item in a DataBlock list.
420 * lpList [I] List to search
421 * dwSignature [I] Id of item to find
424 * Success: A pointer to the list item found
428 * See SHWriteDataBlockList.
430 LPDATABLOCK_HEADER WINAPI SHFindDataBlock(LPDBLIST lpList, DWORD dwSignature)
432 TRACE("(%p,%d)\n", lpList, dwSignature);
436 while(lpList->cbSize)
438 if(lpList->dwSignature == dwSignature)
439 return lpList; /* Matched */
440 else if(lpList->dwSignature == CLIST_ID_CONTAINER && lpList[1].dwSignature == dwSignature)
441 return lpList + 1; /* Contained item matches */
443 lpList = NextItem(lpList);