/*******************************************************************************
 
Copyright (c) 2010, Perforce Software, Inc.  All rights reserved.
 
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
 
1.  Redistributions of source code must retain the above copyright
	notice, this list of conditions and the following disclaimer.
 
2.  Redistributions in binary form must reproduce the above copyright
	notice, this list of conditions and the following disclaimer in the
	documentation and/or other materials provided with the distribution.
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL PERFORCE SOFTWARE, INC. BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
*******************************************************************************/
 
/*******************************************************************************
 * Name		: p4base.h
 *
 * Author	: dbb
 *
 * Description	:  p4base is the base class for all classes which handles 
 *  (pointers)for instances of those classes are passed in and out if the DLL.
 *  It provides a mechanism to register the handles to those objects when they
 *  are created so they can be validated when passed in as parameters.
 *
 ******************************************************************************/
#include "StdAfx.h"
#include "p4base.h"
#include "lock.h"
 
/*******************************************************************************
* Keep a doubly linked list of handles for each type to be tracked.
*******************************************************************************/
#ifdef _DEBUG
#ifdef _DEBUG_MEMORY
 
#include <tchar.h>;
 
#endif
p4base** p4base::pFirstObject = NULL;
p4base** p4base::pLastObject = NULL;
 
int p4base::ItemCount = 0;
int p4base::ItemCounts[p4typesCount];
 
int p4base::TotalItems = 1;
int p4base::NextItemIds[p4typesCount];
 
#endif
 
int p4base::InitP4BaseLocker()
{
	Locker.InitCritSection();
	return 1;
}
 
// Used to lock access for multi threading
ILockable p4base::Locker = ILockable();
 
int p4base::P4BaseLockerInit = p4base::InitP4BaseLocker();
 
/*******************************************************************************
* Constructor
*
*   Add this object to the correct list, based on its type.
*
*   nType: The type of this object. It is passed from the derived objects 
*       constructer so it can be determined at run time. A call to the virtual
*       function GetType() does not work here in the base class constructor.
*
*******************************************************************************/
p4base::p4base(int ntype)
{
	// save the type for use in the destructor when we can no longer use the
	//  virtual function GetType().
	type =  ntype;
 
#ifdef _DEBUG
	LOCK(&Locker);
 
	// Check to see if we have allocated are array of lists yet. These will only
	//  be created when the first object is registered.
	if (!pFirstObject)
	{
		pFirstObject = new p4base*[p4typesCount];
		for (int i = 0; i < p4typesCount; i++)
		{
			pFirstObject[i] = NULL;
			ItemCounts[i] = 0;
			NextItemIds[i] = 0;
		}
	}
	if (!pLastObject)
	{
		pLastObject = new p4base*[p4typesCount];
		for (int i = 0; i < p4typesCount; i++)
		{
			pLastObject[i] = NULL;
		}
   }
 
	// Initialize the list pointers
	pNextItem = NULL;
	pPrevItem = NULL;
 
	// Add to the list of objects registered to be exported
	if(!pFirstObject[type])
	{
		// first object, initialize the list with this as the only element
		pFirstObject[type] = this;
		pLastObject[type] = this;
	}
	else
	{
		// add to the end of the list
		pLastObject[type]->pNextItem = this;
		pPrevItem = pLastObject[type];
		pLastObject[type] = this;
	}
	ItemCount++;
	ItemCounts[type]++;
	TotalItems++;
	ItemId = ++NextItemIds[type];
 
#ifdef _DEBUG_MEMORY
	LogMemoryEvent("Creating Object");
#endif
 
#endif
}
 
/*******************************************************************************
* Destructor
*
*   Remove this object from the correct list, based on its type.
*
*******************************************************************************/
p4base::~p4base(void)
{
#ifdef _DEBUG
	LOCK(&Locker); 
 
#ifdef _DEBUG_MEMORY
	LogMemoryEvent("Deleting Object");
#endif
 
	ItemCount--;
 
	ItemCounts[type]--;
 
	// Remove from the list
	if (!pPrevItem && !pNextItem)
	{
		// last object in the list, so NULL out the list head and tail pointers
		pFirstObject[type] = NULL;
		pLastObject[type] = NULL;
	}
	else if (!pPrevItem && pNextItem)
	{
		// first object in list, set the head to the next object in the list
		pFirstObject[type] = pNextItem;
		pNextItem->pPrevItem = NULL;
	}
	else if (pPrevItem && !pNextItem)
	{
		// last object, set the tail to the pervious object in the list
		pLastObject[type] = pPrevItem;
		pPrevItem->pNextItem = NULL;
	}
	else 
	{
		// in the middle of the list, so link the pointers for the previous 
		//  and next objects.
		pPrevItem->pNextItem = pNextItem;
		pNextItem->pPrevItem = pPrevItem;
	}
#endif
}
 
void p4base::Cleanup(void)
{
#ifdef _DEBUG
	if (pFirstObject)
	{
		delete[] pFirstObject;
	}
	if (pLastObject)
	{
		delete[] pLastObject;
   }
#endif
}
 
int p4base::ValidateHandle_Int( p4base* pObject, int type )
{
	if (!pObject)
		return 0;
 
	p4base* pCur = NULL;
 
	// Use Windows Structured Exception Handling to detect memory violations
	__try
	{
		if ((type < 0) || (type >=p4typesCount) || (type != pObject->Type()))
		{
			return 0; // invalid type
		}
#ifndef _DEBUG
		return 1;
	}
	__except (1) //EXCEPTION_EXECUTE_HANDLER
	{
		// access violation, so definitely not valid.
		return 0;
	}
#else
		pCur = pFirstObject[type];
	}
	__except (1) //EXCEPTION_EXECUTE_HANDLER
	{
		// access violation, so definitely not valid.
		return 0;
	}
	while ( pCur != NULL)
	{
		if (pObject == pCur)  // pointers are the same
		{   
			return 1;
		}
		pCur = pCur->pNextItem;
	}
#endif
 
	return 0;
}
 
/*******************************************************************************
* ValidateHandle( p4base* pObject )
*
*   Static function to validate a handle
*
*   nType: The type of this object. It is passed from the derived objects 
*       constructer so it can be determined at run time. A call to the virtual
*       function GetType() does not work here in the base class constructor.
*
*******************************************************************************/
int p4base::ValidateHandle( p4base* pObject, int type )
{
	LOCK(&Locker);
 
	return ValidateHandle_Int( pObject, type );
}
 
#ifdef _DEBUG
 
char* p4base::GetTypeStr(int type)
{
	switch (type)
	{
	case tP4BridgeServer:
		return "P4BridgeServer";
	case tP4BridgeClient:
		return "BridgeClient";
	case tStrDictListIterator:
		return "StrDictListIterator";
	case tStrDictList:
		return "StrDictList";
	case tKeyValuePair:
		return "KeyValuePair";
	case tP4ClientError:
		return "P4ClientError";
	case tP4MapApi:
		return "P4MapApi";
	case tP4P4FileSys:
		return "P4P4FileSys";
	case tP4ClientMerge:
		return "P4ClientMerge";
	case tP4ClientResolve:
		return "P4ClientResolve";
	case tP4ClientInfoMsg:
		return "P4ClientInfoMsg";
	case p4typesCount:
		return "Error!p4typesCount";
#ifdef _DEBUG_MEMORY
	case tConnectionManager:
		return "ConnectionManager";
	case tP4Connection:
		return "P4Connection";
	//case tIdleConnection:
	//	return "IdleConnection";
#endif
	default:
		return "Error!UnknownType";
	}
}
 
#ifdef _DEBUG_MEMORY
 
static char* MemLogFile = "c:\\tmp\\p4bridge.memory.log.txt"; 
 
void  p4base::LogMemoryEvent(char * Event)
{
	HANDLE  hLogFile = CreateFile( MemLogFile,GENERIC_WRITE,0,NULL,OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
 
	SetFilePointer(hLogFile,0,NULL,FILE_END);
 
	if (hLogFile == INVALID_HANDLE_VALUE) 
	{ 
		return;
	}
	DWORD dwBytesWritten = 0;
 
	int bErrorFlag = WriteFile( 
					hLogFile,           // open file handle
					Event,				// start of data to write
					strlen(Event),		// number of bytes to write
					&dwBytesWritten,	// number of bytes that were written
					NULL);				// no overlapped structure
 
	char lineBuf[1024];
 
	int chars = _snprintf(lineBuf, 1024, ": Type:%s, ItemId = %d, ItemCount = %d\r\n", GetTypeStr(type), GetItemId(), GetItemCount(type));
	
	bErrorFlag = WriteFile( 
					hLogFile,           // open file handle
					lineBuf,			// start of data to write
					chars,				// number of bytes to write
					&dwBytesWritten,	// number of bytes that were written
					NULL);				// no overlapped structure
 
	CloseHandle(hLogFile);
}
 
void  p4base::PrintMemoryState(char *Title)
{
	printf("%s: Object Count Dump\r\n", Title);
		
	printf("All Item Types : %d Items Created, %d items remaining \r\n", GetTotalItemCount(), GetItemCount());
 
	for (int i = 0; i < p4typesCount; i++)
	{
		printf("Type:%s : %d Items Created, %d items remaining \r\n", GetTypeStr(i), NextItemIds[i],  GetItemCount(i));
	}
}
 
void  p4base::DumpMemoryState(char *Title)
{
	char lineBuf[1024] ;
	int chars;
	int bErrorFlag;
	DWORD dwBytesWritten = 0;
 
	HANDLE  hLogFile = CreateFile(  MemLogFile,GENERIC_WRITE,0,NULL,OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
 
	SetFilePointer(hLogFile,0,NULL,FILE_END);
 
	chars = _snprintf(lineBuf, 1024, "%s: Object Count Dump\r\n", Title);
	bErrorFlag = WriteFile( 
			hLogFile,           // open file handle
			lineBuf,			// start of data to write
			chars,				// number of bytes to write
			&dwBytesWritten,	// number of bytes that were written
			NULL);				// no overlapped structure
		
	chars = _snprintf(lineBuf, 1024, "All Item Types : %d Items Created, %d items remaining \r\n", GetTotalItemCount(), GetItemCount());
	bErrorFlag = WriteFile( 
			hLogFile,           // open file handle
			lineBuf,			// start of data to write
			chars,				// number of bytes to write
			&dwBytesWritten,	// number of bytes that were written
			NULL);				// no overlapped structure
 
	for (int i = 0; i < p4typesCount; i++)
	{
		chars = _snprintf(lineBuf, 1024, "Type:%s : %d Items Created, %d items remaining \r\n", GetTypeStr(i), NextItemIds[i],  GetItemCount(i));
		bErrorFlag = WriteFile( 
					hLogFile,           // open file handle
					lineBuf,			// start of data to write
					chars,				// number of bytes to write
					&dwBytesWritten,	// number of bytes that were written
					NULL);				// no overlapped structure
	}
 
	CloseHandle(hLogFile);
}
#else
void  p4base::LogMemoryEvent(char * Event) {}
void  p4base::PrintMemoryState(char *Title) {}
void  p4base::DumpMemoryState(char *Title) {}
#endif
#endif