From dbad4b699e35442920baa60c13f76e95904fe317 Mon Sep 17 00:00:00 2001 From: Marcos Magueta Date: Fri, 8 May 2026 21:20:01 -0300 Subject: restructure project and add readme --- Makefile | 69 ++++++++++-- README.org | 35 ++++++ RelationalNT.vcxproj | 19 ++++ RelationalNT.vcxproj.filters | 57 ++++++++++ images/logo.png | Bin 0 -> 1324 bytes include/Api.h | 11 ++ include/CursorManager.h | 10 ++ include/HandlerManager.h | 25 +++++ include/IdentityManager.h | 15 +++ include/LifecycleManager.h | 28 +++++ include/NT.h | 210 ++---------------------------------- include/NamespaceReferenceManager.h | 10 ++ include/ObjectManager.h | 47 ++++++++ include/PermissionsManager.h | 19 ++++ include/Runtime.h | 13 +++ include/Types.h | 26 +++++ include/WAM.h | 10 ++ src/CursorManager.cpp | 5 + src/HandlerManager.cpp | 63 +++++++++++ src/IdentityManager.cpp | 14 +++ src/LifecycleManager.cpp | 17 +++ src/NT.cpp | 6 +- src/NamespaceReferenceManager.cpp | 5 + src/ObjectManager.cpp | 9 ++ src/PermissionsManager.cpp | 19 ++++ src/WAM.cpp | 5 + 26 files changed, 536 insertions(+), 211 deletions(-) create mode 100644 README.org create mode 100644 images/logo.png create mode 100644 include/Api.h create mode 100644 include/CursorManager.h create mode 100644 include/HandlerManager.h create mode 100644 include/IdentityManager.h create mode 100644 include/LifecycleManager.h create mode 100644 include/NamespaceReferenceManager.h create mode 100644 include/ObjectManager.h create mode 100644 include/PermissionsManager.h create mode 100644 include/Runtime.h create mode 100644 include/Types.h create mode 100644 include/WAM.h create mode 100644 src/CursorManager.cpp create mode 100644 src/HandlerManager.cpp create mode 100644 src/IdentityManager.cpp create mode 100644 src/LifecycleManager.cpp create mode 100644 src/NamespaceReferenceManager.cpp create mode 100644 src/ObjectManager.cpp create mode 100644 src/PermissionsManager.cpp create mode 100644 src/WAM.cpp diff --git a/Makefile b/Makefile index 5ab688b..7a09a1f 100644 --- a/Makefile +++ b/Makefile @@ -1,13 +1,11 @@ CXX = cl TARGET = RNT.exe -OBJECT = NT.obj -SOURCE = src\NT.cpp +OBJECTS = NT.obj ObjectManager.obj PermissionsManager.obj NamespaceReferenceManager.obj CursorManager.obj IdentityManager.obj LifecycleManager.obj HandlerManager.obj WAM.obj INCDIR = include DEFINES = /DNT_CONSOLE_APP /DNT_WAIT_ON_EXIT INCLUDE_FLAG = /I$(INCDIR) COMPILE_FLAGS = /std:c++17 /W4 /EHsc COMPILE_ONLY = /c -OBJECT_OUT = /Fo:$(OBJECT) LINK_FLAGS = TARGET_OUT = /Fe:$(TARGET) REMOVE = del /Q @@ -17,18 +15,69 @@ all: $(TARGET) windows: all unix: - $(MAKE) CXX=c++ TARGET=RNT OBJECT=NT.o SOURCE=src/NT.cpp DEFINES=-DNT_CONSOLE_APP INCLUDE_FLAG=-Iinclude COMPILE_FLAGS="-std=c++17 -Wall -Wextra" COMPILE_ONLY=-c OBJECT_OUT="-o NT.o" LINK_FLAGS= TARGET_OUT="-o RNT" REMOVE="rm -f" all + $(MAKE) CXX=c++ TARGET=RNT OBJECTS="NT.o ObjectManager.o PermissionsManager.o NamespaceReferenceManager.o CursorManager.o IdentityManager.o LifecycleManager.o HandlerManager.o WAM.o" DEFINES=-DNT_CONSOLE_APP INCLUDE_FLAG=-Iinclude COMPILE_FLAGS="-std=c++17 -Wall -Wextra" COMPILE_ONLY=-c LINK_FLAGS= TARGET_OUT="-o RNT" REMOVE="rm -f" all linux: unix macos: - $(MAKE) CXX=c++ TARGET=RNT OBJECT=NT.o SOURCE=src/NT.cpp DEFINES=-DNT_CONSOLE_APP INCLUDE_FLAG=-Iinclude COMPILE_FLAGS="-std=c++17 -Wall -Wextra" COMPILE_ONLY=-c OBJECT_OUT="-o NT.o" LINK_FLAGS= TARGET_OUT="-o RNT" REMOVE="rm -f" all + $(MAKE) CXX=c++ TARGET=RNT OBJECTS="NT.o ObjectManager.o PermissionsManager.o NamespaceReferenceManager.o CursorManager.o IdentityManager.o LifecycleManager.o HandlerManager.o WAM.o" DEFINES=-DNT_CONSOLE_APP INCLUDE_FLAG=-Iinclude COMPILE_FLAGS="-std=c++17 -Wall -Wextra" COMPILE_ONLY=-c LINK_FLAGS= TARGET_OUT="-o RNT" REMOVE="rm -f" all -$(TARGET): $(OBJECT) - $(CXX) $(LINK_FLAGS) $(OBJECT) $(TARGET_OUT) +$(TARGET): $(OBJECTS) + $(CXX) $(LINK_FLAGS) $(OBJECTS) $(TARGET_OUT) -$(OBJECT): $(SOURCE) - $(CXX) $(DEFINES) $(INCLUDE_FLAG) $(COMPILE_FLAGS) $(COMPILE_ONLY) $(SOURCE) $(OBJECT_OUT) +NT.obj: src\NT.cpp + $(CXX) $(DEFINES) $(INCLUDE_FLAG) $(COMPILE_FLAGS) $(COMPILE_ONLY) src\NT.cpp /Fo:NT.obj + +ObjectManager.obj: src\ObjectManager.cpp + $(CXX) $(DEFINES) $(INCLUDE_FLAG) $(COMPILE_FLAGS) $(COMPILE_ONLY) src\ObjectManager.cpp /Fo:ObjectManager.obj + +PermissionsManager.obj: src\PermissionsManager.cpp + $(CXX) $(DEFINES) $(INCLUDE_FLAG) $(COMPILE_FLAGS) $(COMPILE_ONLY) src\PermissionsManager.cpp /Fo:PermissionsManager.obj + +NamespaceReferenceManager.obj: src\NamespaceReferenceManager.cpp + $(CXX) $(DEFINES) $(INCLUDE_FLAG) $(COMPILE_FLAGS) $(COMPILE_ONLY) src\NamespaceReferenceManager.cpp /Fo:NamespaceReferenceManager.obj + +CursorManager.obj: src\CursorManager.cpp + $(CXX) $(DEFINES) $(INCLUDE_FLAG) $(COMPILE_FLAGS) $(COMPILE_ONLY) src\CursorManager.cpp /Fo:CursorManager.obj + +IdentityManager.obj: src\IdentityManager.cpp + $(CXX) $(DEFINES) $(INCLUDE_FLAG) $(COMPILE_FLAGS) $(COMPILE_ONLY) src\IdentityManager.cpp /Fo:IdentityManager.obj + +LifecycleManager.obj: src\LifecycleManager.cpp + $(CXX) $(DEFINES) $(INCLUDE_FLAG) $(COMPILE_FLAGS) $(COMPILE_ONLY) src\LifecycleManager.cpp /Fo:LifecycleManager.obj + +HandlerManager.obj: src\HandlerManager.cpp + $(CXX) $(DEFINES) $(INCLUDE_FLAG) $(COMPILE_FLAGS) $(COMPILE_ONLY) src\HandlerManager.cpp /Fo:HandlerManager.obj + +WAM.obj: src\WAM.cpp + $(CXX) $(DEFINES) $(INCLUDE_FLAG) $(COMPILE_FLAGS) $(COMPILE_ONLY) src\WAM.cpp /Fo:WAM.obj + +NT.o: src/NT.cpp + $(CXX) $(DEFINES) $(INCLUDE_FLAG) $(COMPILE_FLAGS) $(COMPILE_ONLY) src/NT.cpp -o NT.o + +ObjectManager.o: src/ObjectManager.cpp + $(CXX) $(DEFINES) $(INCLUDE_FLAG) $(COMPILE_FLAGS) $(COMPILE_ONLY) src/ObjectManager.cpp -o ObjectManager.o + +PermissionsManager.o: src/PermissionsManager.cpp + $(CXX) $(DEFINES) $(INCLUDE_FLAG) $(COMPILE_FLAGS) $(COMPILE_ONLY) src/PermissionsManager.cpp -o PermissionsManager.o + +NamespaceReferenceManager.o: src/NamespaceReferenceManager.cpp + $(CXX) $(DEFINES) $(INCLUDE_FLAG) $(COMPILE_FLAGS) $(COMPILE_ONLY) src/NamespaceReferenceManager.cpp -o NamespaceReferenceManager.o + +CursorManager.o: src/CursorManager.cpp + $(CXX) $(DEFINES) $(INCLUDE_FLAG) $(COMPILE_FLAGS) $(COMPILE_ONLY) src/CursorManager.cpp -o CursorManager.o + +IdentityManager.o: src/IdentityManager.cpp + $(CXX) $(DEFINES) $(INCLUDE_FLAG) $(COMPILE_FLAGS) $(COMPILE_ONLY) src/IdentityManager.cpp -o IdentityManager.o + +LifecycleManager.o: src/LifecycleManager.cpp + $(CXX) $(DEFINES) $(INCLUDE_FLAG) $(COMPILE_FLAGS) $(COMPILE_ONLY) src/LifecycleManager.cpp -o LifecycleManager.o + +HandlerManager.o: src/HandlerManager.cpp + $(CXX) $(DEFINES) $(INCLUDE_FLAG) $(COMPILE_FLAGS) $(COMPILE_ONLY) src/HandlerManager.cpp -o HandlerManager.o + +WAM.o: src/WAM.cpp + $(CXX) $(DEFINES) $(INCLUDE_FLAG) $(COMPILE_FLAGS) $(COMPILE_ONLY) src/WAM.cpp -o WAM.o clean: - -$(REMOVE) RNT.exe RNT $(OBJECT) NT.o RNT.exp RNT.lib + -$(REMOVE) RNT.exe RNT $(OBJECTS) NT.obj ObjectManager.obj PermissionsManager.obj NamespaceReferenceManager.obj CursorManager.obj IdentityManager.obj LifecycleManager.obj HandlerManager.obj WAM.obj NT.o ObjectManager.o PermissionsManager.o NamespaceReferenceManager.o CursorManager.o IdentityManager.o LifecycleManager.o HandlerManager.o WAM.o RNT.exp RNT.lib diff --git a/README.org b/README.org new file mode 100644 index 0000000..f8da320 --- /dev/null +++ b/README.org @@ -0,0 +1,35 @@ +#+TITLE: Relational NT + +#+ATTR_ORG: :width 320 +[[file:images/logo.png]] + +* About + +This is a Relational NT-inspired database kernel. The goal of the project is to offer an approach similar to how the NT kernel offers for an OS, but for administrating database objects and state. + +Relational NT explores database internals through an object-manager style architecture. Instead of treating relations, tuples, transactions, namespaces, permissions, and handles as unrelated mechanisms, the runtime models them as managed objects with explicit lifecycle, uniform access paths and explicit security enforcement. + +* Design Direction + +- Object management: database objects are registered, located, and referenced through a central object manager. +- Permissions: access checks are separated from object lookup so security policy can evolve independently. +- Identity and lifecycle: opening, closing, monitoring, and contention decisions are represented as runtime responsibilities. +- Handles: authorized access to objects is modeled explicitly, making ownership and cleanup visible. + +* Current Status + +The project is early-stage and focused on shaping the runtime structure. Many components are intentionally skeletal while the core abstractions settle. + +* Building + +The repository includes a Visual Studio makefile project and a root =Makefile=. On Windows, build with the Visual Studio/NMake environment available: + +#+begin_src shell +nmake /f Makefile windows +#+end_src + +For Unix-like environments with a C++17 compiler and Make installed: + +#+begin_src shell +make unix +#+end_src diff --git a/RelationalNT.vcxproj b/RelationalNT.vcxproj index 8176edc..9827b07 100644 --- a/RelationalNT.vcxproj +++ b/RelationalNT.vcxproj @@ -85,10 +85,29 @@ + + + + + + + + + + + + + + + + + + + diff --git a/RelationalNT.vcxproj.filters b/RelationalNT.vcxproj.filters index c942ddf..29a22eb 100644 --- a/RelationalNT.vcxproj.filters +++ b/RelationalNT.vcxproj.filters @@ -14,14 +14,71 @@ + + Source Files + + + Source Files + + + Source Files + + + Source Files + + + Source Files + Source Files + + Source Files + + + Source Files + + + Source Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + Header Files + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + diff --git a/images/logo.png b/images/logo.png new file mode 100644 index 0000000..7277e7d Binary files /dev/null and b/images/logo.png differ diff --git a/include/Api.h b/include/Api.h new file mode 100644 index 0000000..d47636d --- /dev/null +++ b/include/Api.h @@ -0,0 +1,11 @@ +#pragma once + +#if defined(_WIN32) && defined(NT_CONSOLE_APP) +#define NT_API +#elif defined(_WIN32) && defined(NT_EXPORTS) +#define NT_API __declspec(dllexport) +#elif defined(_WIN32) +#define NT_API __declspec(dllimport) +#else +#define NT_API +#endif diff --git a/include/CursorManager.h b/include/CursorManager.h new file mode 100644 index 0000000..33230ab --- /dev/null +++ b/include/CursorManager.h @@ -0,0 +1,10 @@ +#pragma once + +#include "Api.h" + +namespace nt +{ + class NT_API CursorManager + { + }; +} diff --git a/include/HandlerManager.h b/include/HandlerManager.h new file mode 100644 index 0000000..d126680 --- /dev/null +++ b/include/HandlerManager.h @@ -0,0 +1,25 @@ +#pragma once + +#include "Api.h" +#include "ObjectManager.h" + +#include +#include + +namespace nt +{ + class NT_API HandlerManager + { + public: + // This is supposed to represent an authorized access to a certain object in the registry + // This increases the handle count in the object manager + // We should consider adding on the object manager a vector of all the handles that refer to an object + struct handle { + ObjectManager::registry* object = nullptr; + void* connection_context = nullptr; + }; + void DeallocateHandle(struct handle* handle); + struct handle Open(std::vector object_path, void* connection_context); + bool Close(struct handle* handle); + }; +} diff --git a/include/IdentityManager.h b/include/IdentityManager.h new file mode 100644 index 0000000..1a03fff --- /dev/null +++ b/include/IdentityManager.h @@ -0,0 +1,15 @@ +#pragma once + +#include "Api.h" +#include "ObjectManager.h" + +namespace nt +{ + class NT_API IdentityManager + { + public: + // Looks into the methods of the object type and asserts if it can be opened + const bool CanOpen(ObjectManager::registry* object); + const bool CanClose(ObjectManager::registry* object); + }; +} diff --git a/include/LifecycleManager.h b/include/LifecycleManager.h new file mode 100644 index 0000000..2cd270d --- /dev/null +++ b/include/LifecycleManager.h @@ -0,0 +1,28 @@ +#pragma once + +#include "Api.h" +#include "ObjectManager.h" + +namespace nt +{ + class NT_API LifecycleManager + { + public: + // If object is not being monitored already, monitors the lifecycle by updating the handle count. + // Maybe also look at the reference count and kill some categories of disposable objects no longer referenced by other objects, like transactions. + // Think of other use cases later. + void Monitor(ObjectManager::registry* object); + // Serializes contention for the change of a mutable reference. + // This can be used in, for example, the HEAD of a branch to serialize the access. + // If the object does not causes contention, like a relation (since they are immutable, just like multigroups, all snapshots) + // then just approve, as they do not cause any contention. Transactions also do not cause any, + // the only things that do are mutable reference states in shared sessions, + // for example: the HEAD of a branch, namespace collisions (creating two branches with the same name, or two multigroups with the same name from the same state, etc), + // multi-branch atomic commits (which I wish to not have as it damages isolation), + // garbage collection of old state (as in, we want to delete an old-enough history to save up space), etc. + const bool Contention(ObjectManager::registry* object); + // The inverse of `Monitor`, stops monitoring. + // Maybe garbage collect here also if the counters goes to zero. + void Unmonitor(ObjectManager::registry* object); + }; +} diff --git a/include/NT.h b/include/NT.h index a24d9d4..a97f6c8 100644 --- a/include/NT.h +++ b/include/NT.h @@ -1,202 +1,12 @@ #pragma once -#include -#include -#include -#include -#if defined(_WIN32) && defined(NT_CONSOLE_APP) -#define NT_API -#elif defined(_WIN32) && defined(NT_EXPORTS) -#define NT_API __declspec(dllexport) -#elif defined(_WIN32) -#define NT_API __declspec(dllimport) -#else -#define NT_API -#endif - -enum OBJECT_TYPE { - MULTIGROUP, - RELATION, - TUPLE, - ATTRIBUTE, - TRANSACTION -}; - -enum METHOD { - OPEN, - CLOSE, - PARSE, // To plug a secondary namespace - SECURITY -}; - -enum AUTH_CLAIM { - READ, - WRITE -}; - -enum AUTH_METHOD { - CERTIFICATE, - PLAIN_TEXT -}; - -namespace nt -{ - class NT_API ObjectManager - { - public: - class IObject { - public: - virtual ~IObject() = default; - }; - class Multigroup : IObject {}; - class Relation : IObject {}; - class Tuple : IObject {}; - class Transaction : IObject {}; - struct object_type { - OBJECT_TYPE label; - // If the object is not durable. E.g.: TRANSACTION - bool disposable; - std::set methods; - }; - struct registry_head { - uint32_t reference_count; - uint32_t handle_count; - struct object_type* type; - std::vector path; - //security_descriptor to be added later, maybe also a set of labels - }; - struct registry { - struct registry_head* head; - IObject object; - // TODO: Treat as a list for now, but ideally it's a tree - struct registry* next; - }; - struct registry** entries; - // Looks into this registry and attempts to retrieve the entry - struct registry* Find(const std::vector object_path) { return nullptr; } - }; - - class NT_API PermissionsManager - { - public: - // For validating connections at login - std::set Firewall(AUTH_METHOD method) { return {}; } - // For validating permission to an object - const bool Access(const ObjectManager::registry* object, const void* connection_context) { - // Checks the security descriptor on the head of the object we find in the ObjectManager::registry - // Then additionally check other metadata yet to be defined in the connection_context, - // like user group, policy, etc. - // Yet to decide if this should be summoned at every attempt to get ahold of an object, - // that might produce significant overhead. How can we solve this? - return object != nullptr && connection_context != nullptr; - } - }; - - class NT_API NamespaceReferenceManager - { - }; - - class NT_API CursorManager - { - }; - - class NT_API IdentityManager - { - public: - // Looks into the methods of the object type and asserts if it can be opened - const bool CanOpen(ObjectManager::registry* object) { return object != nullptr; } - const bool CanClose(ObjectManager::registry* object) { return object != nullptr; } - }; - - class NT_API LifecycleManager - { - public: - // If object is not being monitored already, monitors the lifecycle by updating the handle count. - // Maybe also look at the reference count and kill some categories of disposable objects no longer referenced by other objects, like transactions. - // Think of other use cases later. - void Monitor(ObjectManager::registry* object) {} - // Serializes contention for the change of a mutable reference. - // This can be used in, for example, the HEAD of a branch to serialize the access. - // If the object does not causes contention, like a relation (since they are immutable, just like multigroups, all snapshots) - // then just approve, as they do not cause any contention. Transactions also do not cause any, - // the only things that do are mutable reference states in shared sessions, - // for example: the HEAD of a branch, namespace collisions (creating two branches with the same name, or two multigroups with the same name from the same state, etc), - // multi-branch atomic commits (which I wish to not have as it damages isolation), - // garbage collection of old state (as in, we want to delete an old-enough history to save up space), etc. - const bool Contention(ObjectManager::registry* object){ return object != nullptr; } - // The inverse of `Monitor`, stops monitoring. - // Maybe garbage collect here also if the counters goes to zero. - void Unmonitor(ObjectManager::registry* object) {} - }; - - class NT_API HandlerManager - { - public: - // This is supposed to represent an authorized access to a certain object in the registry - // This increases the handle count in the object manager - // We should consider adding on the object manager a vector of all the handles that refer to an object - struct handle { - ObjectManager::registry* object = nullptr; - void* connection_context = nullptr; - }; - void DeallocateHandle(struct handle* handle) {} - struct handle Open(std::vector object_path, void* connection_context) { - ObjectManager objects; - PermissionsManager permissions; - IdentityManager identities; - LifecycleManager lifecycles; - ObjectManager::registry* retrieved_object = objects.Find((const std::vector)object_path); - if (permissions.Access(retrieved_object, (const void*)connection_context) - && identities.CanOpen(retrieved_object) - && lifecycles.Contention(retrieved_object)) { - // Starts monitoring this guy - lifecycles.Monitor(retrieved_object); - return { retrieved_object, connection_context }; // Return a successful handle - } - else { - // Return something more algebraic instead of null or an int - return {}; - }; - } - bool Close(struct handle *handle) { - if (handle == nullptr) { - return false; - } - PermissionsManager permissions; - IdentityManager identities; - LifecycleManager lifecycles; - // Somehow grab the object pointer and connection (maybe drop it...) from the handle - ObjectManager::registry* object = handle->object; - void* connection_context = handle->connection_context; - // Checking for permissions here may be relevant. - // What if we have a handle but no permission? Spooky - if (permissions.Access(object, connection_context) - && identities.CanClose(object) - // TODO: I think that in this case we do not need to worry about contention. - // But be careful to evaluate this scenario later. - //&& LifecycleManager::Contention(retrieved_object) - ) { - // Stops monitoring this guy - lifecycles.Unmonitor(object); - DeallocateHandle(handle); - return true; // Return a successful handle - } - else { - // Return something more algebraic instead of null or an int. - // It's kinda bad to not even report what went wrong. - return false; - }; - } - }; - - class NT_API WAM - { - }; - - class NT_API NT - { - public: - bool IsRunning() const; - void SimulateEntryCall() {}; - }; -} +#include "Types.h" +#include "ObjectManager.h" +#include "PermissionsManager.h" +#include "NamespaceReferenceManager.h" +#include "CursorManager.h" +#include "IdentityManager.h" +#include "LifecycleManager.h" +#include "HandlerManager.h" +#include "WAM.h" +#include "Runtime.h" diff --git a/include/NamespaceReferenceManager.h b/include/NamespaceReferenceManager.h new file mode 100644 index 0000000..922a0ca --- /dev/null +++ b/include/NamespaceReferenceManager.h @@ -0,0 +1,10 @@ +#pragma once + +#include "Api.h" + +namespace nt +{ + class NT_API NamespaceReferenceManager + { + }; +} diff --git a/include/ObjectManager.h b/include/ObjectManager.h new file mode 100644 index 0000000..8abf44c --- /dev/null +++ b/include/ObjectManager.h @@ -0,0 +1,47 @@ +#pragma once + +#include "Api.h" +#include "Types.h" + +#include +#include +#include +#include + +namespace nt +{ + class NT_API ObjectManager + { + public: + class IObject { + public: + virtual ~IObject() = default; + }; + class Multigroup : IObject {}; + class Relation : IObject {}; + class Tuple : IObject {}; + class Transaction : IObject {}; + struct object_type { + OBJECT_TYPE label; + // If the object is not durable. E.g.: TRANSACTION + bool disposable; + std::set methods; + }; + struct registry_head { + uint32_t reference_count; + uint32_t handle_count; + struct object_type* type; + std::vector path; + //security_descriptor to be added later, maybe also a set of labels + }; + struct registry { + struct registry_head* head; + IObject object; + // TODO: Treat as a list for now, but ideally it's a tree + struct registry* next; + }; + struct registry** entries; + // Looks into this registry and attempts to retrieve the entry + struct registry* Find(const std::vector object_path); + }; +} diff --git a/include/PermissionsManager.h b/include/PermissionsManager.h new file mode 100644 index 0000000..c51bd27 --- /dev/null +++ b/include/PermissionsManager.h @@ -0,0 +1,19 @@ +#pragma once + +#include "Api.h" +#include "ObjectManager.h" +#include "Types.h" + +#include + +namespace nt +{ + class NT_API PermissionsManager + { + public: + // For validating connections at login + std::set Firewall(AUTH_METHOD method); + // For validating permission to an object + const bool Access(const ObjectManager::registry* object, const void* connection_context); + }; +} diff --git a/include/Runtime.h b/include/Runtime.h new file mode 100644 index 0000000..60a0b90 --- /dev/null +++ b/include/Runtime.h @@ -0,0 +1,13 @@ +#pragma once + +#include "Api.h" + +namespace nt +{ + class NT_API NT + { + public: + bool IsRunning() const; + void SimulateEntryCall(); + }; +} diff --git a/include/Types.h b/include/Types.h new file mode 100644 index 0000000..fe6afed --- /dev/null +++ b/include/Types.h @@ -0,0 +1,26 @@ +#pragma once + +enum OBJECT_TYPE { + MULTIGROUP, + RELATION, + TUPLE, + ATTRIBUTE, + TRANSACTION +}; + +enum METHOD { + OPEN, + CLOSE, + PARSE, // To plug a secondary namespace + SECURITY +}; + +enum AUTH_CLAIM { + READ, + WRITE +}; + +enum AUTH_METHOD { + CERTIFICATE, + PLAIN_TEXT +}; diff --git a/include/WAM.h b/include/WAM.h new file mode 100644 index 0000000..8f0cb11 --- /dev/null +++ b/include/WAM.h @@ -0,0 +1,10 @@ +#pragma once + +#include "Api.h" + +namespace nt +{ + class NT_API WAM + { + }; +} diff --git a/src/CursorManager.cpp b/src/CursorManager.cpp new file mode 100644 index 0000000..8ae4496 --- /dev/null +++ b/src/CursorManager.cpp @@ -0,0 +1,5 @@ +#include "CursorManager.h" + +namespace nt +{ +} diff --git a/src/HandlerManager.cpp b/src/HandlerManager.cpp new file mode 100644 index 0000000..895f553 --- /dev/null +++ b/src/HandlerManager.cpp @@ -0,0 +1,63 @@ +#include "HandlerManager.h" + +#include "IdentityManager.h" +#include "LifecycleManager.h" +#include "PermissionsManager.h" + +namespace nt +{ + void HandlerManager::DeallocateHandle(struct handle* handle) + { + } + + struct HandlerManager::handle HandlerManager::Open(std::vector object_path, void* connection_context) + { + ObjectManager objects; + PermissionsManager permissions; + IdentityManager identities; + LifecycleManager lifecycles; + ObjectManager::registry* retrieved_object = objects.Find((const std::vector)object_path); + if (permissions.Access(retrieved_object, (const void*)connection_context) + && identities.CanOpen(retrieved_object) + && lifecycles.Contention(retrieved_object)) { + // Starts monitoring this guy + lifecycles.Monitor(retrieved_object); + return { retrieved_object, connection_context }; // Return a successful handle + } + else { + // Return something more algebraic instead of null or an int + return {}; + }; + } + + bool HandlerManager::Close(struct handle* handle) + { + if (handle == nullptr) { + return false; + } + PermissionsManager permissions; + IdentityManager identities; + LifecycleManager lifecycles; + // Somehow grab the object pointer and connection (maybe drop it...) from the handle + ObjectManager::registry* object = handle->object; + void* connection_context = handle->connection_context; + // Checking for permissions here may be relevant. + // What if we have a handle but no permission? Spooky + if (permissions.Access(object, connection_context) + && identities.CanClose(object) + // TODO: I think that in this case we do not need to worry about contention. + // But be careful to evaluate this scenario later. + //&& LifecycleManager::Contention(retrieved_object) + ) { + // Stops monitoring this guy + lifecycles.Unmonitor(object); + DeallocateHandle(handle); + return true; // Return a successful handle + } + else { + // Return something more algebraic instead of null or an int. + // It's kinda bad to not even report what went wrong. + return false; + }; + } +} diff --git a/src/IdentityManager.cpp b/src/IdentityManager.cpp new file mode 100644 index 0000000..93ad705 --- /dev/null +++ b/src/IdentityManager.cpp @@ -0,0 +1,14 @@ +#include "IdentityManager.h" + +namespace nt +{ + const bool IdentityManager::CanOpen(ObjectManager::registry* object) + { + return object != nullptr; + } + + const bool IdentityManager::CanClose(ObjectManager::registry* object) + { + return object != nullptr; + } +} diff --git a/src/LifecycleManager.cpp b/src/LifecycleManager.cpp new file mode 100644 index 0000000..bcab4b5 --- /dev/null +++ b/src/LifecycleManager.cpp @@ -0,0 +1,17 @@ +#include "LifecycleManager.h" + +namespace nt +{ + void LifecycleManager::Monitor(ObjectManager::registry* object) + { + } + + const bool LifecycleManager::Contention(ObjectManager::registry* object) + { + return object != nullptr; + } + + void LifecycleManager::Unmonitor(ObjectManager::registry* object) + { + } +} diff --git a/src/NT.cpp b/src/NT.cpp index 15bf63d..4d391a8 100644 --- a/src/NT.cpp +++ b/src/NT.cpp @@ -1,4 +1,4 @@ -#include "NT.h" +#include "Runtime.h" #ifdef NT_CONSOLE_APP #include @@ -10,6 +10,10 @@ namespace nt { return true; } + + void NT::SimulateEntryCall() + { + } } #ifdef NT_CONSOLE_APP diff --git a/src/NamespaceReferenceManager.cpp b/src/NamespaceReferenceManager.cpp new file mode 100644 index 0000000..1d9baac --- /dev/null +++ b/src/NamespaceReferenceManager.cpp @@ -0,0 +1,5 @@ +#include "NamespaceReferenceManager.h" + +namespace nt +{ +} diff --git a/src/ObjectManager.cpp b/src/ObjectManager.cpp new file mode 100644 index 0000000..ff85af2 --- /dev/null +++ b/src/ObjectManager.cpp @@ -0,0 +1,9 @@ +#include "ObjectManager.h" + +namespace nt +{ + struct ObjectManager::registry* ObjectManager::Find(const std::vector object_path) + { + return nullptr; + } +} diff --git a/src/PermissionsManager.cpp b/src/PermissionsManager.cpp new file mode 100644 index 0000000..228dd2d --- /dev/null +++ b/src/PermissionsManager.cpp @@ -0,0 +1,19 @@ +#include "PermissionsManager.h" + +namespace nt +{ + std::set PermissionsManager::Firewall(AUTH_METHOD method) + { + return {}; + } + + const bool PermissionsManager::Access(const ObjectManager::registry* object, const void* connection_context) + { + // Checks the security descriptor on the head of the object we find in the ObjectManager::registry + // Then additionally check other metadata yet to be defined in the connection_context, + // like user group, policy, etc. + // Yet to decide if this should be summoned at every attempt to get ahold of an object, + // that might produce significant overhead. How can we solve this? + return object != nullptr && connection_context != nullptr; + } +} diff --git a/src/WAM.cpp b/src/WAM.cpp new file mode 100644 index 0000000..9088cd0 --- /dev/null +++ b/src/WAM.cpp @@ -0,0 +1,5 @@ +#include "WAM.h" + +namespace nt +{ +} -- cgit v1.2.3