/**

 * vim: set ts=4 :

 * =============================================================================

 * SourceMod

 * Copyright (C) 2004-2007 AlliedModders LLC.  All rights reserved.

 * =============================================================================

 *

 * This program is free software; you can redistribute it and/or modify it under

 * the terms of the GNU General Public License, version 3.0, as published by the

 * Free Software Foundation.

 * 

 * This program is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more

 * details.

 *

 * You should have received a copy of the GNU General Public License along with

 * this program.  If not, see <http://www.gnu.org/licenses/>.

 *

 * As a special exception, AlliedModders LLC gives you permission to link the

 * code of this program (as well as its derivative works) to "Half-Life 2," the

 * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software

 * by the Valve Corporation.  You must obey the GNU General Public License in

 * all respects for all other code used.  Additionally, AlliedModders LLC grants

 * this exception to all derivative works.  AlliedModders LLC defines further

 * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),

 * or <http://www.sourcemod.net/license.php>.

 *

 * Version: $Id$

 */

#include "HandleSys.h"

#include "ShareSys.h"

#include "PluginSys.h"

#include "ExtensionSys.h"

#include "Logger.h"

#include <assert.h>

#include <string.h>

#include "sm_stringutil.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::TryAllocHandle(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;

	}

	return HandleError_None;

}

HandleError HandleSystem::MakePrimHandle(HandleType_t type, 

						   QHandle **in_pHandle, 

						   unsigned int *in_index, 

						   Handle_t *in_handle,

						   IdentityToken_t *owner,

						   bool identity)

{

	HandleError err;

	unsigned int owner_index = 0;

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

	{

		return HandleError_Identity;

	}

	unsigned int handle;

	if ((err = TryAllocHandle(&handle)) != HandleError_None)

	{

		if (!TryAndFreeSomeHandles()

			|| (err = TryAllocHandle(&handle)) != HandleError_None)

		{

			return err;

		}

	}

	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;

	pHandle->access_special = false;

	pHandle->is_destroying = false;

	/* 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::CreateHandleInt(HandleType_t type, 

									   void *object, 

									   const HandleSecurity *pSec,

									   HandleError *err, 

									   const HandleAccess *pAccess,

									   bool identity)

{

	IdentityToken_t *ident;

	IdentityToken_t *owner;

	if (pSec)

	{

		ident = pSec->pIdentity;

		owner = pSec->pOwner;

	} else {

		ident = NULL;

		owner = NULL;

	}

	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;

	}

	if (pAccess)

	{

		pHandle->access_special = true;

		pHandle->sec = *pAccess;

	}

	pHandle->object = object;

	pHandle->clone = 0;

	return handle;

}

Handle_t HandleSystem::CreateHandleEx(HandleType_t type, void *object, const HandleSecurity *pSec, const HandleAccess *pAccess, HandleError *err)

{

	return CreateHandleInt(type, object, pSec, err, pAccess, false);

}

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

{

	HandleSecurity sec;

	sec.pIdentity = ident;

	sec.pOwner = owner;

	return CreateHandleEx(type, object, &sec, NULL, err);

}

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];

	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;

	if (pHandle->access_special)

	{

		access = pHandle->sec.access[right];

	} else {

		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;

	}

	/* Assign permissions from parent */

	if (pHandle->access_special)

	{

		pNewHandle->access_special = true;

		pNewHandle->sec = pHandle->sec;

	}

	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)