implemented and finalized initial HandleSystem API
--HG-- extra : convert_revision : svn%3A39bc706e-5318-0410-9160-8a85361fbb7c/trunk%40223
This commit is contained in:
David Anderson
parent
a4737a2808
commit
c189dfa991
@ -15,6 +15,19 @@ namespace SourceMod
|
||||
typedef unsigned int HandleType_t;
|
||||
typedef unsigned int Handle_t;
|
||||
|
||||
/**
|
||||
* About type checking:
|
||||
* Types can be inherited - a Parent type ("Supertype") can have child types.
|
||||
* When accessing handles, type checking is done. This table shows how this is resolved:
|
||||
*
|
||||
* HANDLE CHECK -> RESULT
|
||||
* ------ ----- ------
|
||||
* Parent Parent Success
|
||||
* Parent Child Fail
|
||||
* Child Parent Success
|
||||
* Child Child Success
|
||||
*/
|
||||
|
||||
enum HandleError
|
||||
{
|
||||
HandleError_None = 0, /* No error */
|
||||
@ -27,12 +40,12 @@ namespace SourceMod
|
||||
|
||||
struct HandleAccess
|
||||
{
|
||||
HandleAccess() : canRead(true), canDelete(true), canInherit(true)
|
||||
HandleAccess() : canRead(true), canDelete(true), canInherit(true), canCreate(true)
|
||||
{
|
||||
}
|
||||
bool canCreate; /* Instances can be created by other objects */
|
||||
bool canRead; /* Handle and type can be read by other objects */
|
||||
bool canDelete; /* Handle can be deleted by other objects */
|
||||
bool canCreate; /* Instances can be created by other objects (this makes it searchable) */
|
||||
bool canRead; /* Handles can be read by other objects */
|
||||
bool canDelete; /* Handles can be deleted by other objects */
|
||||
bool canInherit; /* Handle type can be inherited */
|
||||
};
|
||||
|
||||
@ -87,7 +100,8 @@ namespace SourceMod
|
||||
* @param name Name of handle type (NULL or "" to be anonymous)
|
||||
* @param dispatch Pointer to a valid IHandleTypeDispatch object.
|
||||
* @param parent Parent handle to inherit from, 0 for none.
|
||||
* @param security Pointer to a temporary HandleSecurity object, NULL to use defaults.
|
||||
* @param security Pointer to a temporary HandleSecurity object, NULL to use default
|
||||
* or inherited permissions.
|
||||
* @return A new HandleType_t unique ID.
|
||||
*/
|
||||
virtual HandleType_t CreateTypeEx(const char *name,
|
||||
@ -135,13 +149,13 @@ namespace SourceMod
|
||||
*
|
||||
* @param type Type to use on the handle.
|
||||
* @param object Object to bind to the handle.
|
||||
* @param owner Identity token for object using this handle.
|
||||
* @param source Identity token for object using this handle (for example, a script).
|
||||
* @param ident Identity token if any security rights are needed.
|
||||
* @return A new Handle_t, or 0 on failure.
|
||||
*/
|
||||
virtual Handle_t CreateHandleEx(HandleType_t type,
|
||||
virtual Handle_t CreateHandle(HandleType_t type,
|
||||
void *object,
|
||||
IdentityToken_t owner,
|
||||
IdentityToken_t source,
|
||||
IdentityToken_t ident) =0;
|
||||
|
||||
/**
|
||||
@ -151,27 +165,33 @@ namespace SourceMod
|
||||
* @param type Type to use on the handle.
|
||||
* @param object Object to bind to the handle.
|
||||
* @param ctx Plugin context that will own this handle. NULL for none.
|
||||
* @param ident Identity token if any security rights are needed.
|
||||
* @return A new Handle_t.
|
||||
*/
|
||||
virtual Handle_t CreateScriptHandle(HandleType_t type, void *object, sp_context_t *ctx) =0;
|
||||
virtual Handle_t CreateScriptHandle(HandleType_t type,
|
||||
void *object,
|
||||
sp_context_t *ctx,
|
||||
IdentityToken_t ident) =0;
|
||||
|
||||
/**
|
||||
* @brief Destroys a handle.
|
||||
*
|
||||
* @param type Handle_t identifier to destroy.
|
||||
* @param ident Identity token, for destroying secure handles (0 for none).
|
||||
* @return A HandleError error code.
|
||||
*/
|
||||
virtual HandleError DestroyHandle(Handle_t handle) =0;
|
||||
virtual HandleError DestroyHandle(Handle_t handle, IdentityToken_t ident) =0;
|
||||
|
||||
/**
|
||||
* @brief Retrieves the contents of a handle.
|
||||
*
|
||||
* @param handle Handle_t from which to retrieve contents.
|
||||
* @param type Expected type to read as.
|
||||
* @param ident Identity token to validate as.
|
||||
* @param object Address to store object in.
|
||||
* @return HandleError error code.
|
||||
*/
|
||||
virtual HandleError ReadHandle(Handle_t handle, HandleType_t type, void **object) =0;
|
||||
virtual HandleError ReadHandle(Handle_t handle, HandleType_t type, IdentityToken_t ident, void **object) =0;
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
@ -267,6 +267,10 @@
|
||||
RelativePath="..\systems\ForwardSys.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="..\systems\HandleSys.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="..\systems\LibrarySys.h"
|
||||
>
|
||||
@ -291,6 +295,10 @@
|
||||
RelativePath="..\systems\ForwardSys.cpp"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="..\systems\HandleSys.cpp"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="..\systems\LibrarySys.cpp"
|
||||
>
|
||||
@ -311,6 +319,10 @@
|
||||
RelativePath="..\interfaces\IForwardSys.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="..\interfaces\IHandleSys.h"
|
||||
>
|
||||
</File>
|
||||
<File
|
||||
RelativePath="..\interfaces\ILibrarySys.h"
|
||||
>
|
||||
|
||||
379
core/systems/HandleSys.cpp
Normal file
379
core/systems/HandleSys.cpp
Normal file
@ -0,0 +1,379 @@
|
||||
#include "HandleSys.h"
|
||||
#include "PluginSys.h"
|
||||
|
||||
HandleSystem g_HandleSys;
|
||||
|
||||
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)
|
||||
{
|
||||
return CreateTypeEx(name, dispatch, 0, NULL);
|
||||
}
|
||||
|
||||
HandleType_t HandleSystem::CreateChildType(const char *name, HandleType_t parent, IHandleTypeDispatch *dispatch)
|
||||
{
|
||||
return CreateTypeEx(name, dispatch, parent, NULL);
|
||||
}
|
||||
|
||||
HandleType_t HandleSystem::CreateTypeEx(const char *name,
|
||||
IHandleTypeDispatch *dispatch,
|
||||
HandleType_t parent,
|
||||
const HandleSecurity *security)
|
||||
{
|
||||
if (!dispatch)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool isChild = false;
|
||||
|
||||
if (parent != 0)
|
||||
{
|
||||
isChild = true;
|
||||
if (parent & HANDLESYS_SUBTYPE_MASK)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
if (parent >= HANDLESYS_TYPEARRAY_SIZE
|
||||
|| m_Types[parent].dispatch != NULL
|
||||
|| m_Types[parent].sec.all.canInherit == false)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (!security)
|
||||
{
|
||||
if (isChild)
|
||||
{
|
||||
security = &m_Types[parent].sec;
|
||||
} else {
|
||||
static HandleSecurity def_h = {0, HandleAccess() };
|
||||
security = &def_h;
|
||||
}
|
||||
}
|
||||
|
||||
if (security->all.canCreate && sm_trie_retrieve(m_TypeLookup, name, NULL))
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
unsigned int index;
|
||||
|
||||
if (isChild)
|
||||
{
|
||||
QHandleType *pParent = &m_Types[parent];
|
||||
if (pParent->children >= HANDLESYS_MAX_SUBTYPES)
|
||||
{
|
||||
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)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
pParent->children++;
|
||||
} else {
|
||||
if (m_FreeTypes == 0)
|
||||
{
|
||||
/* Reserve another index */
|
||||
if (m_TypeTail >= HANDLESYS_TYPEARRAY_SIZE)
|
||||
{
|
||||
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->sec = *security;
|
||||
pType->opened = 0;
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
Handle_t HandleSystem::CreateHandle(HandleType_t type, void *object, IdentityToken_t source, IdentityToken_t ident)
|
||||
{
|
||||
if (!type
|
||||
|| type >= HANDLESYS_TYPEARRAY_SIZE
|
||||
|| m_Types[type].dispatch == NULL)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Check the security of this handle */
|
||||
QHandleType *pType = &m_Types[type];
|
||||
if (!pType->sec.all.canCreate
|
||||
&& pType->sec.owner != ident)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
unsigned int handle = 0;
|
||||
if (m_FreeHandles == 0)
|
||||
{
|
||||
if (m_HandleTail >= HANDLESYS_MAX_HANDLES)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
handle = ++m_HandleTail;
|
||||
} else {
|
||||
handle = m_Handles[m_FreeHandles--].freeID;
|
||||
}
|
||||
|
||||
QHandle *pHandle = &m_Handles[handle];
|
||||
|
||||
pHandle->type = type;
|
||||
pHandle->source = source;
|
||||
pHandle->set = true;
|
||||
pHandle->object = object;
|
||||
|
||||
if (++m_HSerial >= HANDLESYS_MAX_SERIALS)
|
||||
{
|
||||
m_HSerial = 1;
|
||||
}
|
||||
pHandle->serial = m_HSerial;
|
||||
|
||||
Handle_t hash = pHandle->serial;
|
||||
hash <<= 16;
|
||||
hash |= handle;
|
||||
|
||||
pType->opened++;
|
||||
|
||||
return hash;
|
||||
}
|
||||
|
||||
Handle_t HandleSystem::CreateScriptHandle(HandleType_t type,
|
||||
void *object,
|
||||
sp_context_t *ctx,
|
||||
IdentityToken_t ident)
|
||||
{
|
||||
IPlugin *pPlugin = g_PluginSys.FindPluginByContext(ctx);
|
||||
|
||||
return CreateHandle(type, object, pPlugin->GetIdentity(), ident);
|
||||
}
|
||||
|
||||
HandleError HandleSystem::DestroyHandle(Handle_t handle, IdentityToken_t ident)
|
||||
{
|
||||
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 (!pType->sec.all.canDelete
|
||||
&& pType->sec.owner != ident)
|
||||
{
|
||||
return HandleError_Access;
|
||||
}
|
||||
if (!pHandle->set)
|
||||
{
|
||||
return HandleError_Freed;
|
||||
}
|
||||
if (pHandle->serial != serial)
|
||||
{
|
||||
return HandleError_Changed;
|
||||
}
|
||||
|
||||
pType->dispatch->OnHandleDestroy(pHandle->type, pHandle->object);
|
||||
pType->opened--;
|
||||
pHandle->set = false;
|
||||
m_Handles[++m_FreeTypes].freeID = index;
|
||||
|
||||
return HandleError_None;
|
||||
}
|
||||
|
||||
inline HandleType_t TypeParent(HandleType_t type)
|
||||
{
|
||||
return (type & ~HANDLESYS_SUBTYPE_MASK);
|
||||
}
|
||||
|
||||
HandleError HandleSystem::ReadHandle(Handle_t handle,
|
||||
HandleType_t type,
|
||||
IdentityToken_t ident,
|
||||
void **object)
|
||||
{
|
||||
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];
|
||||
|
||||
/* Do sanity checks first */
|
||||
if (!pHandle->set)
|
||||
{
|
||||
return HandleError_Freed;
|
||||
}
|
||||
if (pHandle->serial != serial)
|
||||
{
|
||||
return HandleError_Changed;
|
||||
}
|
||||
|
||||
/* Check the type inheritance */
|
||||
if (pHandle->type & HANDLESYS_SUBTYPE_MASK)
|
||||
{
|
||||
if (pHandle->type != type
|
||||
&& (TypeParent(pHandle->type) != TypeParent(type)))
|
||||
{
|
||||
return HandleError_Type;
|
||||
}
|
||||
} else {
|
||||
if (pHandle->type != type)
|
||||
{
|
||||
return HandleError_Type;
|
||||
}
|
||||
}
|
||||
|
||||
/* Now do security checks */
|
||||
QHandleType *pType = &m_Types[pHandle->type];
|
||||
if (!pType->sec.all.canRead
|
||||
&& pType->sec.owner != ident)
|
||||
{
|
||||
return HandleError_Access;
|
||||
}
|
||||
|
||||
if (object)
|
||||
{
|
||||
*object = pHandle->object;
|
||||
}
|
||||
|
||||
return HandleError_None;
|
||||
}
|
||||
|
||||
bool HandleSystem::RemoveType(HandleType_t type, IdentityToken_t ident)
|
||||
{
|
||||
if (type == 0 || type >= HANDLESYS_TYPEARRAY_SIZE)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
QHandleType *pType = &m_Types[type];
|
||||
|
||||
if (pType->sec.owner && pType->sec.owner != ident)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
if (pType->dispatch == NULL)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Remove children if we have to */
|
||||
if (!(type & HANDLESYS_SUBTYPE_MASK))
|
||||
{
|
||||
QHandleType *childType;
|
||||
for (unsigned int i=1; i<=HANDLESYS_MAX_SUBTYPES; i++)
|
||||
{
|
||||
childType = &m_Types[type + i];
|
||||
if (childType->dispatch)
|
||||
{
|
||||
RemoveType(type + i, childType->sec.owner);
|
||||
}
|
||||
}
|
||||
/* Link us into the free chain */
|
||||
m_Types[++m_FreeTypes].freeID = type;
|
||||
}
|
||||
|
||||
/* Invalidate the type now */
|
||||
IHandleTypeDispatch *dispatch = pType->dispatch;
|
||||
pType->dispatch = NULL;
|
||||
|
||||
/* Make sure nothing is using this type. */
|
||||
if (pType->opened)
|
||||
{
|
||||
QHandle *pHandle;
|
||||
for (unsigned int i=1; i<=HANDLESYS_MAX_HANDLES; i++)
|
||||
{
|
||||
pHandle = &m_Handles[i];
|
||||
if (!pHandle->set || pHandle->type != type)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
dispatch->OnHandleDestroy(type, pHandle->object);
|
||||
pHandle->set = false;
|
||||
m_Handles[++m_FreeHandles].freeID = i;
|
||||
if (--pType->opened == 0)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
75
core/systems/HandleSys.h
Normal file
75
core/systems/HandleSys.h
Normal file
@ -0,0 +1,75 @@
|
||||
#ifndef _INCLUDE_SOURCEMOD_HANDLESYSTEM_H_
|
||||
#define _INCLUDE_SOURCEMOD_HANDLESYSTEM_H_
|
||||
|
||||
#include <IHandleSys.h>
|
||||
#include "sm_globals.h"
|
||||
#include "sm_trie.h"
|
||||
#include "sourcemod.h"
|
||||
#include "sm_memtable.h"
|
||||
|
||||
#define HANDLESYS_MAX_HANDLES (1<<16)
|
||||
#define HANDLESYS_MAX_TYPES (1<<9)
|
||||
#define HANDLESYS_MAX_SUBTYPES 0xF
|
||||
#define HANDLESYS_SUBTYPE_MASK 0xF
|
||||
#define HANDLESYS_TYPEARRAY_SIZE (HANDLESYS_MAX_TYPES * (HANDLESYS_MAX_SUBTYPES + 1))
|
||||
#define HANDLESYS_MAX_SERIALS 0xFFFF
|
||||
#define HANDLESYS_SERIAL_MASK 0xFFFF0000
|
||||
#define HANDLESYS_HANDLE_MASK 0x0000FFFF
|
||||
|
||||
struct QHandle
|
||||
{
|
||||
HandleType_t type;
|
||||
void *object;
|
||||
unsigned int freeID;
|
||||
IdentityToken_t source;
|
||||
bool set;
|
||||
unsigned int serial;
|
||||
};
|
||||
|
||||
struct QHandleType
|
||||
{
|
||||
IHandleTypeDispatch *dispatch;
|
||||
unsigned int freeID;
|
||||
unsigned int children;
|
||||
HandleSecurity sec;
|
||||
unsigned int opened;
|
||||
int nameIdx;
|
||||
};
|
||||
|
||||
class HandleSystem :
|
||||
public IHandleSys
|
||||
{
|
||||
public:
|
||||
HandleSystem();
|
||||
~HandleSystem();
|
||||
public: //IHandleSystem
|
||||
HandleType_t CreateType(const char *name, IHandleTypeDispatch *dispatch);
|
||||
HandleType_t CreateTypeEx(const char *name,
|
||||
IHandleTypeDispatch *dispatch,
|
||||
HandleType_t parent,
|
||||
const HandleSecurity *security);
|
||||
HandleType_t CreateChildType(const char *name, HandleType_t parent, IHandleTypeDispatch *dispatch);
|
||||
bool RemoveType(HandleType_t type, IdentityToken_t ident);
|
||||
bool FindHandleType(const char *name, HandleType_t *type);
|
||||
Handle_t CreateHandle(HandleType_t type,
|
||||
void *object,
|
||||
IdentityToken_t source,
|
||||
IdentityToken_t ident);
|
||||
Handle_t CreateScriptHandle(HandleType_t type, void *object, sp_context_t *ctx, IdentityToken_t ident);
|
||||
HandleError DestroyHandle(Handle_t handle, IdentityToken_t ident);
|
||||
HandleError ReadHandle(Handle_t handle, HandleType_t type, IdentityToken_t ident, void **object);
|
||||
private:
|
||||
QHandle *m_Handles;
|
||||
QHandleType *m_Types;
|
||||
Trie *m_TypeLookup;
|
||||
unsigned int m_TypeTail;
|
||||
unsigned int m_FreeTypes;
|
||||
unsigned int m_HandleTail;
|
||||
unsigned int m_FreeHandles;
|
||||
unsigned int m_HSerial;
|
||||
BaseStringTable *m_strtab;
|
||||
};
|
||||
|
||||
extern HandleSystem g_HandleSys;
|
||||
|
||||
#endif //_INCLUDE_SOURCEMOD_HANDLESYSTEM_H_
|
||||
Loading…
Reference in New Issue
Block a user