#include "HandleSys.h"

#include "ShareSys.h"

#include "PluginSys.h"

#include <assert.h>

HandleSystem g_HandleSys;

QHandle *ignore_handle;

inline HandleType_t TypeParent(HandleType_t type)

{

	return (type & ~HANDLESYS_SUBTYPE_MASK);

}

inline HandleError IdentityHandle(IdentityToken_t *token, unsigned int *index)

{

	return g_HandleSys.GetHandle(token->ident, g_ShareSys.GetIdentRoot(), &ignore_handle, index);

}

HandleSystem::HandleSystem()

{

	m_Handles = new QHandle[HANDLESYS_MAX_HANDLES + 1];

	memset(m_Handles, 0, sizeof(QHandle) * (HANDLESYS_MAX_HANDLES + 1));

	m_Types = new QHandleType[HANDLESYS_TYPEARRAY_SIZE];

	memset(m_Types, 0, sizeof(QHandleType) * HANDLESYS_TYPEARRAY_SIZE);

	m_TypeLookup = sm_trie_create();

	m_strtab = new BaseStringTable(512);

	m_TypeTail = 0;

}

HandleSystem::~HandleSystem()

{

	delete [] m_Handles;

	delete [] m_Types;

	sm_trie_destroy(m_TypeLookup);

	delete m_strtab;

}

HandleType_t HandleSystem::CreateType(const char *name, 

									  IHandleTypeDispatch *dispatch, 

									  HandleType_t parent, 

									  const TypeAccess *typeAccess, 

									  const HandleAccess *hndlAccess, 

									  IdentityToken_t *ident,

									  HandleError *err)

{

	if (!dispatch)

	{

		if (err)

		{

			*err = HandleError_Parameter;

		}

		return 0;

	}

	if (typeAccess && typeAccess->hsVersion > SMINTERFACE_HANDLESYSTEM_VERSION)

	{

		if (err)

		{

			*err = HandleError_Version;

		}

		return 0;

	}

	if (hndlAccess && hndlAccess->hsVersion > SMINTERFACE_HANDLESYSTEM_VERSION)

	{

		if (err)

		{

			*err = HandleError_Version;

		}

		return 0;

	}

	bool isChild = false;

	if (parent != 0)

	{

		isChild = true;

		if (parent & HANDLESYS_SUBTYPE_MASK)

		{

			if (err)

			{

				*err = HandleError_NoInherit;

			}

			return 0;

		}

		if (parent >= HANDLESYS_TYPEARRAY_SIZE

			|| m_Types[parent].dispatch == NULL)

		{

			if (err)

			{

				*err = HandleError_Parameter;

			}

			return 0;

		}

		if (m_Types[parent].typeSec.access[HTypeAccess_Inherit] == false

			&& (m_Types[parent].typeSec.ident != ident))

		{

			if (err)

			{

				*err = HandleError_Access;

			}

			return 0;

		}

	}

	if (name && name[0] != '\0')

	{

		if (sm_trie_retrieve(m_TypeLookup, name, NULL))

		{

			if (err)

			{

				*err = HandleError_Parameter;

			}

			return 0;

		}

	}

	unsigned int index;

	if (isChild)

	{

		QHandleType *pParent = &m_Types[parent];

		if (pParent->children >= HANDLESYS_MAX_SUBTYPES)

		{

			if (err)

			{

				*err = HandleError_Limit;

			}

			return 0;

		}

		index = 0;

		for (unsigned int i=1; i<=HANDLESYS_MAX_SUBTYPES; i++)

		{

			if (m_Types[parent + i].dispatch == NULL)

			{

				index = parent + i;

				break;

			}

		}

		if (!index)

		{

			if (err)

			{

				*err = HandleError_Limit;

			}

			return 0;

		}

		pParent->children++;

	} else {

		if (m_FreeTypes == 0)

		{

			/* Reserve another index */

			if (m_TypeTail >= HANDLESYS_TYPEARRAY_SIZE)

			{

				if (err)

				{

					*err = HandleError_Limit;

				}

				return 0;

			} else {

				m_TypeTail += (HANDLESYS_MAX_SUBTYPES + 1);

				index = m_TypeTail;

			}

		} else {

			/* The "free array" is compacted into the normal array for easiness */

			index = m_Types[m_FreeTypes--].freeID;

		}

	}

	QHandleType *pType = &m_Types[index];

	pType->dispatch = dispatch;

	if (name && name[0] != '\0')

	{

		pType->nameIdx = m_strtab->AddString(name);

		sm_trie_insert(m_TypeLookup, name, (void *)pType);

	} else {

		pType->nameIdx = -1;

	}

	pType->opened = 0;

	if (typeAccess)

	{

		pType->typeSec = *typeAccess;

	} else {

		InitAccessDefaults(&pType->typeSec, NULL);

		pType->typeSec.ident = ident;

	}

	if (hndlAccess)

	{

		pType->hndlSec = *hndlAccess;

	} else {

		InitAccessDefaults(NULL, &pType->hndlSec);

	}

	if (!isChild)

	{

		pType->children = 0;

	}

	return index;

}

bool HandleSystem::FindHandleType(const char *name, HandleType_t *type)

{

	QHandleType *_type;

	if (!sm_trie_retrieve(m_TypeLookup, name, (void **)&_type))

	{

		return false;

	}

	unsigned int offset = _type - m_Types;

	if (type)

	{

		*type = offset;

	}

	return true;

}

HandleError HandleSystem::MakePrimHandle(HandleType_t type, 

						   QHandle **in_pHandle, 

						   unsigned int *in_index, 

						   Handle_t *in_handle,

						   IdentityToken_t *owner,

						   bool identity)

{

	unsigned int owner_index = 0;

	if (owner && (IdentityHandle(owner, &owner_index) != HandleError_None))

	{

		return HandleError_Identity;

	}

	unsigned int handle;

	if (m_FreeHandles == 0)

	{

		if (m_HandleTail >= HANDLESYS_MAX_HANDLES)

		{

			return HandleError_Limit;;

		}

		handle = ++m_HandleTail;

	} else {

		handle = m_Handles[m_FreeHandles--].freeID;

	}

	QHandle *pHandle = &m_Handles[handle];

	assert(pHandle->set == false);

	if (++m_HSerial >= HANDLESYS_MAX_SERIALS)

	{

		m_HSerial = 1;

	}

	/* Set essential information */

	pHandle->set = identity ? HandleSet_Identity : HandleSet_Used;

	pHandle->refcount = 1;

	pHandle->type = type;

	pHandle->serial = m_HSerial;

	pHandle->owner = owner;

	pHandle->ch_next = 0;

	/* Create the hash value */

	Handle_t hash = pHandle->serial;

	hash <<= 16;

	hash |= handle;

	/* Add a reference count to the type */

	m_Types[type].opened++;

	/* Output */

	*in_pHandle = pHandle;

	*in_index = handle;

	*in_handle = hash;

	/* Decode the identity token 

	 * For now, we don't allow nested ownership

	 */

	if (owner && !identity)

	{

		QHandle *pIdentity = &m_Handles[owner_index];

		if (pIdentity->ch_prev == 0)

		{

			pIdentity->ch_prev = handle;

			pIdentity->ch_next = handle;

			pHandle->ch_prev = 0;

		} else {

			/* Link previous node to us (forward) */

			m_Handles[pIdentity->ch_next].ch_next = handle;

			/* Link us to previous node (backwards) */

			pHandle->ch_prev = pIdentity->ch_next;

			/* Set new tail */

			pIdentity->ch_next = handle;

		}

		pIdentity->refcount++;

	} else {

		pHandle->ch_prev = 0;

	}

	return HandleError_None;

}

void HandleSystem::SetTypeSecurityOwner(HandleType_t type, IdentityToken_t *pToken)

{

	if (!type

		|| type >= HANDLESYS_TYPEARRAY_SIZE

		|| m_Types[type].dispatch == NULL)

	{

		return;

	}

	m_Types[type].typeSec.ident = pToken;

}

Handle_t HandleSystem::CreateHandleEx(HandleType_t type, void *object, IdentityToken_t *owner, IdentityToken_t *ident, HandleError *err, bool identity)

{

	if (!type 

		|| type >= HANDLESYS_TYPEARRAY_SIZE

		|| m_Types[type].dispatch == NULL)

	{

		if (err)

		{

			*err = HandleError_Parameter;

		}

		return 0;

	}

	/* Check to see if we're allowed to create this handle type */

	QHandleType *pType = &m_Types[type];

	if (!pType->typeSec.access[HTypeAccess_Create]

	&& (!pType->typeSec.ident

		|| pType->typeSec.ident != ident))

	{

		if (err)

		{

			*err = HandleError_Access;

		}

		return 0;

	}

	unsigned int index;

	Handle_t handle;

	QHandle *pHandle;

	HandleError _err;

	if ((_err=MakePrimHandle(type, &pHandle, &index, &handle, owner, identity)) != HandleError_None)

	{

		if (err)

		{

			*err = _err;

		}

		return 0;

	}

	pHandle->object = object;

	pHandle->clone = 0;

	return handle;

}

Handle_t HandleSystem::CreateHandle(HandleType_t type, void *object, IdentityToken_t *owner, IdentityToken_t *ident, HandleError *err)

{

	return CreateHandleEx(type, object, owner, ident, err, false);

}

bool HandleSystem::TypeCheck(HandleType_t intype, HandleType_t outtype)

{

	/* Check the type inheritance */

	if (intype & HANDLESYS_SUBTYPE_MASK)

	{

		if (intype != outtype

			&& (TypeParent(intype) != TypeParent(outtype)))

		{

			return false;

		}

	} else {

		if (intype != outtype)

		{

			return false;

		}

	}

	return true;

}

HandleError HandleSystem::GetHandle(Handle_t handle,

									IdentityToken_t *ident, 

									QHandle **in_pHandle, 

									unsigned int *in_index,

									bool ignoreFree)

{

	unsigned int serial = (handle >> 16);

	unsigned int index = (handle & HANDLESYS_HANDLE_MASK);

	if (index == 0 || index == 0xFFFF)

	{

		return HandleError_Index;

	}

	QHandle *pHandle = &m_Handles[index];

	QHandleType *pType = &m_Types[pHandle->type];

	if (!pHandle->set

		|| (pHandle->set == HandleSet_Freed && !ignoreFree))

	{

		return HandleError_Freed;

	} else if (pHandle->set == HandleSet_Identity

			   && ident != g_ShareSys.GetIdentRoot())

	{

		/* Only IdentityHandle() can read this! */

		return HandleError_Identity;

	}

	if (pHandle->serial != serial)

	{

		return HandleError_Changed;

	}

	*in_pHandle = pHandle;

	*in_index = index;

	return HandleError_None;

}

bool HandleSystem::CheckAccess(QHandle *pHandle, HandleAccessRight right, const HandleSecurity *pSecurity)

{

	QHandleType *pType = &m_Types[pHandle->type];

	unsigned int access = pType->hndlSec.access[right];

	/* Check if the type's identity matches */

	if (access & HANDLE_RESTRICT_IDENTITY)

	{

		IdentityToken_t *owner = pType->typeSec.ident;

		if (!owner

			|| (!pSecurity || pSecurity->pIdentity != owner))

		{

			return false;

		}

	}

	/* Check if the owner is allowed */

	if (access & HANDLE_RESTRICT_OWNER)

	{

		IdentityToken_t *owner = pHandle->owner;

		if (owner

			&& (!pSecurity || pSecurity->pOwner != owner))

		{

			return false;

		}

	}

	return true;

}

HandleError HandleSystem::CloneHandle(QHandle *pHandle, unsigned int index, Handle_t *newhandle, IdentityToken_t *newOwner)

{

	/* Get a new Handle ID */

	unsigned int new_index;

	QHandle *pNewHandle;

	Handle_t new_handle;

	HandleError err;

	if ((err=MakePrimHandle(pHandle->type, &pNewHandle, &new_index, &new_handle, newOwner)) != HandleError_None)

	{

		return err;

	}

	pNewHandle->clone = index;

	pHandle->refcount++;

	*newhandle = new_handle;

	return HandleError_None;

}

HandleError HandleSystem::CloneHandle(Handle_t handle, Handle_t *newhandle, IdentityToken_t *newOwner, const HandleSecurity *pSecurity)

{

	HandleError err;

	QHandle *pHandle;

	unsigned int index;

	IdentityToken_t *ident = pSecurity ? pSecurity->pIdentity : NULL;

	if ((err=GetHandle(handle, ident, &pHandle, &index)) != HandleError_None)

	{

		return err;

	}

	/* Identities cannot be cloned */

	if (pHandle->set == HandleSet_Identity)

	{

		return HandleError_Identity;

	}

	/* Check if the handle can be cloned */

	if (!CheckAccess(pHandle, HandleAccess_Clone, pSecurity))

	{

		return HandleError_Access;

	}

	/* Make sure we're not cloning a clone */

	if (pHandle->clone)

	{

		QHandle *pParent = &m_Handles[pHandle->clone];

		return CloneHandle(pParent, pHandle->clone, newhandle, newOwner);

	}

	return CloneHandle(pHandle, index, newhandle, newOwner);

}

HandleError HandleSystem::FreeHandle(QHandle *pHandle, unsigned int index)

{

	QHandleType *pType = &m_Types[pHandle->type];

	if (pHandle->clone)

	{

		/* If we're a clone, decrease the parent reference count */

		QHandle *pMaster;

		unsigned int master;

		/* Note that if we ever have per-handle security, we would need to re-check

		* the access on this Handle. */

		master = pHandle->clone;

		pMaster = &m_Handles[master];

		/* Release the clone now */

		ReleasePrimHandle(index);

		/* Decrement the master's reference count */

		if (--pMaster->refcount == 0)

		{

			/* Type should be the same but do this anyway... */

			pType = &m_Types[pMaster->type];

			pType->dispatch->OnHandleDestroy(pMaster->type, pMaster->object);

			ReleasePrimHandle(master);

		}

	} else if (pHandle->set == HandleSet_Identity) {

		/* If we're an identity, skip all this stuff!

		 * NOTE: SHARESYS DOES NOT CARE ABOUT THE DESTRUCTOR

		 */

		ReleasePrimHandle(index);

	} else {

		/* Decrement, free if necessary */

		if (--pHandle->refcount == 0)

		{

			pType->dispatch->OnHandleDestroy(pHandle->type, pHandle->object);

			ReleasePrimHandle(index);

		} else {

			/* We must be cloned, so mark ourselves as freed */

			pHandle->set = HandleSet_Freed;

			/* Now, unlink us, so we're not being tracked by the owner */

			if (pHandle->owner)

			{

				UnlinkHandleFromOwner(pHandle, index);

			}

		}

	}

	return HandleError_None;

}

HandleError HandleSystem::FreeHandle(Handle_t handle, const HandleSecurity *pSecurity)

{

	unsigned int index;

	QHandle *pHandle;

	HandleError err;

	IdentityToken_t *ident = pSecurity ? pSecurity->pIdentity : NULL;

	if ((err=GetHandle(handle, ident, &pHandle, &index)) != HandleError_None)

	{

		return err;

	}