}

		bFind = TRUE;        //Found one block fit the request.

		if(lpFreeHeader->dwBlockSize <= dwBoundrySize)  //Allocate the whole free block.
		{
			if(NULL == lpFreeHeader->lpPrevBlock)  //This block is the first free block.
			{
				if(NULL == lpFreeHeader->lpNextBlock)  //This is the last free block.
				{
					pControlBlock->lpFreeBufferHeader = NULL;
				}
				else    //This is not the last free block.
				{
					lpFreeHeader->lpNextBlock->lpPrevBlock = NULL;
					pControlBlock->lpFreeBufferHeader = lpFreeHeader->lpNextBlock;
				}
			}
			else        //This block is not the first free block.
			{
				if(NULL == lpFreeHeader->lpNextBlock)  //This is the last block.
				{
					lpFreeHeader->lpPrevBlock->lpNextBlock = NULL;
				}
				else    //This is not the last free block.
				{
					lpFreeHeader->lpNextBlock->lpPrevBlock = lpFreeHeader->lpPrevBlock;
					lpFreeHeader->lpPrevBlock->lpNextBlock = lpFreeHeader->lpNextBlock;
				}
			}
			lpUsedHeader = (__USED_BUFFER_HEADER*)lpFreeHeader;
			lpUsedHeader->dwFlags &= ~BUFFER_STATUS_FREE;  //Clear the free bit.
			lpUsedHeader->dwFlags |= BUFFER_STATUS_USED;   //Set the used bit.
			                                               //The used block's size
			                                               //is the same as when the
			                                               //block is free.

            lpBuffer = (LPVOID)((UCHAR*)lpUsedHeader + sizeof(__USED_BUFFER_HEADER));
			break;
		}
		else      //Can not allocate the whole free block,because it's size is enough to
			      //separate into two blocks,one block is allocated to client,and another
				  //is reserved free.
		{
			//The lpTmpHeader will be the header pointer of new separated free block.
            lpTmpHeader = (__FREE_BUFFER_HEADER*)((DWORD)lpFreeHeader + sizeof(__FREE_BUFFER_HEADER) + dwSize);
			lpTmpHeader->lpPrevBlock = lpFreeHeader->lpPrevBlock;
			lpTmpHeader->lpNextBlock = lpFreeHeader->lpNextBlock;
			lpTmpHeader->dwBlockSize = lpFreeHeader->dwBlockSize - sizeof(__FREE_BUFFER_HEADER)- dwSize;
			lpTmpHeader->dwFlags = 0L;
			lpTmpHeader->dwFlags |= BUFFER_STATUS_FREE;  //Set the free bit.

			//Now,the following code update the neighbor free blocks's member.
			if(NULL == lpFreeHeader->lpPrevBlock) //This block is the first free block.
			{
				if(NULL == lpFreeHeader->lpNextBlock)  //This is the last free block.
				{
					pControlBlock->lpFreeBufferHeader = lpTmpHeader;
				}
				else //This is not the last free block.
				{
					pControlBlock->lpFreeBufferHeader = lpTmpHeader;
					lpFreeHeader->lpNextBlock->lpPrevBlock = lpTmpHeader;
				}
			}
			else    //This is not the first free block.
			{
				if(NULL == lpFreeHeader->lpNextBlock)  //This is the last free block.
				{
					lpFreeHeader->lpPrevBlock->lpNextBlock = lpTmpHeader;
				}
				else  //This is not the first,and also not the last free block.
				{
					lpFreeHeader->lpPrevBlock->lpNextBlock = lpTmpHeader;
					lpFreeHeader->lpNextBlock->lpPrevBlock = lpTmpHeader;
				}
			}

			lpUsedHeader = (__USED_BUFFER_HEADER*)lpFreeHeader;
			lpUsedHeader->dwFlags &= ~BUFFER_STATUS_FREE;  //Clear the free bit.
			lpUsedHeader->dwFlags |= BUFFER_STATUS_USED;   //Set the used bit.
			lpUsedHeader->dwBlockSize = dwSize;

            lpBuffer = (LPVOID)((UCHAR*)lpUsedHeader + sizeof(__USED_BUFFER_HEADER));
			break;
		}
	}

	//LEAVE_CRITICAL_SECTION();
	__LEAVE_CRITICAL_SECTION(NULL,dwFlags);

	if(!bFind)    //If can not find the proper free block,then do a combine action,and
		          //refind again.
	{
		bFind = TRUE;
		CombineFreeBlock(pControlBlock,NULL);
		goto __BEGIN;
	}

__TERMINAL:

	return lpBuffer;
}

//
//Free buffer routine,this routine returns the buffer to buffer pool.
//

static VOID Free(__BUFFER_CONTROL_BLOCK* pControlBlock,LPVOID lpBuffer)
{
	__FREE_BUFFER_HEADER*       lpFreeHeader  = NULL;
	DWORD                       dwFlags       = 0L;

	lpFreeHeader = (__FREE_BUFFER_HEADER*)((DWORD)lpBuffer - sizeof(__FREE_BUFFER_HEADER));

	//ENTER_CRITICAL_SECTION();
	__ENTER_CRITICAL_SECTION(NULL,dwFlags);

	lpFreeHeader->dwFlags &= ~BUFFER_STATUS_USED;  //Clear the used bit.
	lpFreeHeader->dwFlags |= BUFFER_STATUS_FREE;  //Set the free bit.
	lpFreeHeader->lpNextBlock = pControlBlock->lpFreeBufferHeader;  //Insert the current
	                                                                //free blocks into free list.
	lpFreeHeader->lpPrevBlock = NULL;
	pControlBlock->lpFreeBufferHeader = lpFreeHeader;
	if(NULL != lpFreeHeader->lpNextBlock)
	{
		lpFreeHeader->lpNextBlock->lpPrevBlock = lpFreeHeader;
	}

	//LEAVE_CRITICAL_SECTION();
	__LEAVE_CRITICAL_SECTION(NULL,dwFlags);

	CombineFreeBlock(pControlBlock,(LPVOID)lpFreeHeader);  //Combine the free blocks.
}

//
//Buffer flags operating routine,these routine set or get the buffer's flags.
//

static DWORD GetBufferFlag(__BUFFER_CONTROL_BLOCK* pControlBlock,LPVOID lpBuffer)
{
	DWORD                  dwFlag       = 0L;
	__USED_BUFFER_HEADER*  lpUsedHeader = NULL;

	if(NULL == lpBuffer)  //Parameter check.
		return dwFlag;

	lpUsedHeader = (__USED_BUFFER_HEADER*)((DWORD)lpBuffer - sizeof(__USED_BUFFER_HEADER));
	dwFlag = lpUsedHeader->dwFlags;

	return dwFlag;
}

//
//NOTICE : The following routine reset the used buffer's flags,overwrite the previous flags.
//

static BOOL SetBufferFlag(__BUFFER_CONTROL_BLOCK* pControlBlock,LPVOID lpBuffer,DWORD dwFlag)
{
	BOOL                   bResult      = FALSE;
	__USED_BUFFER_HEADER*  lpUsedHeader = NULL;

	if(NULL == lpBuffer)
		return bResult;

	lpUsedHeader = (__USED_BUFFER_HEADER*)((DWORD)lpBuffer - sizeof(__USED_BUFFER_HEADER));
	lpUsedHeader->dwFlags = dwFlag;
	bResult = TRUE;

	return bResult;
}

//
//Destroy buffer pool routine.
//

static VOID DestroyBuffer(__BUFFER_CONTROL_BLOCK* pControlBlock)
{
	if(pControlBlock->dwFlags | CREATED_BY_SELF)
	{
		KMemFree((LPVOID)pControlBlock->lpPoolStartAddress,
			KMEM_SIZE_TYPE_4K,
			4096);
		pControlBlock->dwFlags            = 0L;
		pControlBlock->dwFreeSize         = 0L;
		pControlBlock->dwPoolSize         = 0L;
		pControlBlock->lpFreeBufferHeader = NULL;
		pControlBlock->lpPoolStartAddress = NULL;
	}
}

//
//The following routine get the buffer control block's flags.
//

static DWORD GetControlBlockFlag(__BUFFER_CONTROL_BLOCK* pControlBlock)
{
	return pControlBlock->dwFlags;
}

//
//The global routine used to initialize a buffer manager.
//This routine set the buffer manager's operating routine.
//

BOOL InitBufferMgr(__BUFFER_CONTROL_BLOCK* pControlBlock)
{
	BOOL                  bResult = FALSE;

	if(NULL == pControlBlock)
		goto __TERMINAL;

	pControlBlock->BufferOperations.lpCreateBuffer1 = CreateBuffer1;
	pControlBlock->BufferOperations.lpCreateBuffer2 = CreateBuffer2;
	pControlBlock->BufferOperations.lpAllocate      = Allocate;
	pControlBlock->BufferOperations.lpFree          = Free;
	pControlBlock->BufferOperations.lpGetBufferFlag = GetBufferFlag;
	pControlBlock->BufferOperations.lpSetBufferFlag = SetBufferFlag;
	pControlBlock->BufferOperations.lpDestroyBuffer = DestroyBuffer;

	pControlBlock->GetControlBlockFlag = GetControlBlockFlag;

	pControlBlock->lpFreeBufferHeader  = NULL;
	pControlBlock->lpPoolStartAddress  = NULL;
	pControlBlock->dwFlags             = 0L;
	pControlBlock->dwFlags             |= OPERATIONS_INITIALIZED;
	pControlBlock->dwFreeSize          = 0L;
	pControlBlock->dwPoolSize          = 0L;
	bResult = TRUE;

__TERMINAL:

	return bResult;
}