clist.c File Reference

#include <stdarg.h>
#include <string.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "objbase.h"
#include "shlobj.h"
#include "wine/debug.h"

Include dependency graph for clist.c:

Go to the source code of this file.

Macros
#define	COBJMACROS
#define	CLIST_ID_CONTAINER   (~0U)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (shell)
static LPDATABLOCK_HEADER	NextItem (LPDBLIST lpList)
BOOL WINAPI	SHAddDataBlock (LPDBLIST *lppList, const DATABLOCK_HEADER *lpNewItem)
HRESULT WINAPI	SHWriteDataBlockList (IStream *lpStream, LPDBLIST lpList)
HRESULT WINAPI	SHReadDataBlockList (IStream *lpStream, LPDBLIST *lppList)
VOID WINAPI	SHFreeDataBlockList (LPDBLIST lpList)
BOOL WINAPI	SHRemoveDataBlock (LPDBLIST *lppList, DWORD dwSignature)
DATABLOCK_HEADER *WINAPI	SHFindDataBlock (LPDBLIST lpList, DWORD dwSignature)

Macro Definition Documentation

CLIST_ID_CONTAINER

#define CLIST_ID_CONTAINER   (~0U)

Definition at line 35 of file clist.c.

COBJMACROS

#define COBJMACROS

Definition at line 23 of file clist.c.

Function Documentation

NextItem()

static LPDATABLOCK_HEADER NextItem ( LPDBLIST  lpList )

inlinestatic

Definition at line 42 of file clist.c.

{
  char* address = (char*)lpList;
  address += lpList->cbSize;
  return (LPDATABLOCK_HEADER)address;
}

Referenced by ClearCheckItems(), FreePrincipalsList(), InternalGetNextAttributeListItem(), SHAddDataBlock(), SHFindDataBlock(), SHRemoveDataBlock(), and SHWriteDataBlockList().

SHAddDataBlock()

BOOL WINAPI SHAddDataBlock	(	LPDBLIST *	lppList,
		const DATABLOCK_HEADER *	lpNewItem
	)

Definition at line 68 of file clist.c.

{
  LPDATABLOCK_HEADER lpInsertAt = NULL;
  ULONG ulSize;
 
  TRACE("(%p,%p)\n", lppList, lpNewItem);
 
  if(!lppList || !lpNewItem)
    return FALSE;
 
  if (lpNewItem->cbSize < sizeof(DATABLOCK_HEADER) ||
      lpNewItem->dwSignature == CLIST_ID_CONTAINER)
    return FALSE;
 
  ulSize = lpNewItem->cbSize;
 
  if(ulSize & 0x3)
  {
    /* Tune size to a ULONG boundary, add space for container element */
    ulSize = ((ulSize + 0x3) & 0xFFFFFFFC) + sizeof(DATABLOCK_HEADER);
    TRACE("Creating container item, new size = %d\n", ulSize);
  }
 
  if(!*lppList)
  {
    /* An empty list. Allocate space for terminal ulSize also */
    *lppList = LocalAlloc(LMEM_ZEROINIT, ulSize + sizeof(ULONG));
    lpInsertAt = *lppList;
  }
  else
  {
    /* Append to the end of the list */
    ULONG ulTotalSize = 0;
    LPDATABLOCK_HEADER lpIter = *lppList;
 
    /* Iterate to the end of the list, calculating the total size */
    while (lpIter->cbSize)
    {
      ulTotalSize += lpIter->cbSize;
      lpIter = NextItem(lpIter);
    }
 
    /* Increase the size of the list */
    lpIter = LocalReAlloc(*lppList, ulTotalSize + ulSize+sizeof(ULONG),
                                          LMEM_ZEROINIT | LMEM_MOVEABLE);
    if(lpIter)
    {
      *lppList = lpIter;
      lpInsertAt = (LPDATABLOCK_HEADER)((char*)lpIter + ulTotalSize); /* At end */
    }
  }
 
  if(lpInsertAt)
  {
    /* Copy in the new item */
    LPDATABLOCK_HEADER lpDest = lpInsertAt;
 
    if(ulSize != lpNewItem->cbSize)
    {
      lpInsertAt->cbSize = ulSize;
      lpInsertAt->dwSignature = CLIST_ID_CONTAINER;
      lpDest++;
    }
    memcpy(lpDest, lpNewItem, lpNewItem->cbSize);
 
    /* Terminate the list */
    lpInsertAt = NextItem(lpInsertAt);
    lpInsertAt->cbSize = 0;
 
    return TRUE;
  }
  return FALSE;
}

Referenced by CShellLink::AddDataBlock(), and SHReadDataBlockList().

SHFindDataBlock()

DATABLOCK_HEADER *WINAPI SHFindDataBlock	(	LPDBLIST	lpList,
		DWORD	dwSignature
	)

Definition at line 424 of file clist.c.

{
  TRACE("(%p,%d)\n", lpList, dwSignature);
 
  if(lpList)
  {
    while(lpList->cbSize)
    {
      if(lpList->dwSignature == dwSignature)
        return lpList; /* Matched */
      else if(lpList->dwSignature == CLIST_ID_CONTAINER && lpList[1].dwSignature == dwSignature)
        return lpList + 1; /* Contained item matches */
 
      lpList = NextItem(lpList);
    }
  }
  return NULL;
}

Referenced by CShellLink::CopyDataBlock(), CShellLink::GetAdvertiseInfo(), CShellLink::GetIconLocation(), CShellLink::GetPath(), CShellLink::SetIconLocation(), CShellLink::SetPath(), and CShellLink::WriteAdvertiseInfo().

SHFreeDataBlockList()

VOID WINAPI SHFreeDataBlockList

(

LPDBLIST

lpList

)

Definition at line 331 of file clist.c.

{
  TRACE("(%p)\n", lpList);
 
  if (lpList)
    LocalFree(lpList);
}

Referenced by CShellLink::Reset(), and CShellLink::~CShellLink().

SHReadDataBlockList()

HRESULT WINAPI SHReadDataBlockList	(	IStream *	lpStream,
		LPDBLIST *	lppList
	)

Definition at line 235 of file clist.c.

{
  DATABLOCK_HEADER bBuff[128]; /* Temporary storage for new list item */
  ULONG ulBuffSize = sizeof(bBuff);
  LPDATABLOCK_HEADER pItem = bBuff;
  ULONG ulRead, ulSize;
  HRESULT hRet = S_OK;
 
  TRACE("(%p,%p)\n", lpStream, lppList);
 
  if(*lppList)
  {
    /* Free any existing list */
    LocalFree(*lppList);
    *lppList = NULL;
  }
 
  do
  {
    /* Read the size of the next item */
    hRet = IStream_Read(lpStream, &ulSize,sizeof(ulSize),&ulRead);
 
    if(FAILED(hRet) || ulRead != sizeof(ulSize) || !ulSize)
      break; /* Read failed or read zero size (the end of the list) */
 
    if(ulSize > 0xFFFF)
    {
      LARGE_INTEGER liZero;
      ULARGE_INTEGER ulPos;
 
      liZero.QuadPart = 0;
 
      /* Back the stream up; this object is too big for the list */
      if(SUCCEEDED(IStream_Seek(lpStream, liZero, STREAM_SEEK_CUR, &ulPos)))
      {
        liZero.QuadPart = ulPos.QuadPart - sizeof(ULONG);
        IStream_Seek(lpStream, liZero, STREAM_SEEK_SET, NULL);
      }
      break;
    }
    else if (ulSize >= sizeof(DATABLOCK_HEADER))
    {
      /* Add this new item to the list */
      if(ulSize > ulBuffSize)
      {
        /* We need more buffer space, allocate it */
        LPDATABLOCK_HEADER lpTemp;
 
        if (pItem == bBuff)
          lpTemp = LocalAlloc(LMEM_ZEROINIT, ulSize);
        else
          lpTemp = LocalReAlloc(pItem, ulSize, LMEM_ZEROINIT|LMEM_MOVEABLE);
 
        if(!lpTemp)
        {
          hRet = E_OUTOFMEMORY;
          break;
        }
        ulBuffSize = ulSize;
        pItem = lpTemp;
      }
 
      pItem->cbSize = ulSize;
      ulSize -= sizeof(pItem->cbSize); /* already read this member */
 
      /* Read the item Id and data */
      hRet = IStream_Read(lpStream, &pItem->dwSignature, ulSize, &ulRead);
 
      if(FAILED(hRet) || ulRead != ulSize)
        break;
 
      SHAddDataBlock(lppList, pItem); /* Insert Item */
    }
  } while(1);
 
  /* If we allocated space, free it */
  if(pItem != bBuff)
    LocalFree(pItem);
 
  return hRet;
}

Referenced by CShellLink::Load().

SHRemoveDataBlock()

BOOL WINAPI SHRemoveDataBlock	(	LPDBLIST *	lppList,
		DWORD	dwSignature
	)

Definition at line 355 of file clist.c.

{
  LPDATABLOCK_HEADER lpList = NULL;
  LPDATABLOCK_HEADER lpItem = NULL;
  LPDATABLOCK_HEADER lpNext;
  ULONG ulNewSize;
 
  TRACE("(%p,%d)\n", lppList, dwSignature);
 
  if(lppList && (lpList = *lppList))
  {
    /* Search for item in list */
    while (lpList->cbSize)
    {
      if(lpList->dwSignature == dwSignature ||
        (lpList->dwSignature == CLIST_ID_CONTAINER && lpList[1].dwSignature == dwSignature))
      {
        lpItem = lpList; /* Found */
        break;
      }
      lpList = NextItem(lpList);
    }
  }
 
  if(!lpItem)
    return FALSE;
 
  lpList = lpNext = NextItem(lpItem);
 
  /* Locate the end of the list */
  while (lpList->cbSize)
    lpList = NextItem(lpList);
 
  /* Resize the list */
  ulNewSize = LocalSize(*lppList) - lpItem->cbSize;
 
  /* Copy following elements over lpItem */
  memmove(lpItem, lpNext, (char *)lpList - (char *)lpNext + sizeof(ULONG));
 
  if(ulNewSize <= sizeof(ULONG))
  {
    LocalFree(*lppList);
    *lppList = NULL; /* Removed the last element */
  }
  else
  {
    lpList = LocalReAlloc(*lppList, ulNewSize, LMEM_ZEROINIT|LMEM_MOVEABLE);
    if(lpList)
      *lppList = lpList;
  }
  return TRUE;
}

Referenced by CShellLink::RemoveDataBlock().

SHWriteDataBlockList()

HRESULT WINAPI SHWriteDataBlockList	(	IStream *	lpStream,
		LPDBLIST	lpList
	)

Definition at line 179 of file clist.c.

{
  ULONG ulSize;
  HRESULT hRet = S_OK;
 
  TRACE("(%p,%p)\n", lpStream, lpList);
 
  if(lpList)
  {
    while (lpList->cbSize)
    {
      LPDATABLOCK_HEADER lpItem = lpList;
 
      if(lpList->dwSignature == CLIST_ID_CONTAINER)
        lpItem++;
 
      hRet = IStream_Write(lpStream,lpItem,lpItem->cbSize,&ulSize);
      if (FAILED(hRet))
        return hRet;
 
      if(lpItem->cbSize != ulSize)
        return STG_E_MEDIUMFULL;
 
      lpList = NextItem(lpList);
    }
  }
 
  if(SUCCEEDED(hRet))
  {
    ULONG ulDummy;
    ulSize = 0;
 
    /* Write a terminating list entry with zero size */
    hRet = IStream_Write(lpStream, &ulSize,sizeof(ulSize),&ulDummy);
  }
 
  return hRet;
}

Referenced by CShellLink::Save().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

shell

)