[IMP] New PROCESS_HEADER_BLOCK structure instead of ProcessHeader.

[IMP] PEF_SHARED_OBJECT_TRAITS with IsValid() method.

[IMP] HTTPS and ODBC for URLs support.

Signed-off-by: Amlal EL Mahrouss <amlalelmahrouss@icloud.com>

14 files changed, 89 insertions, 86 deletions

diff --git a/Kernel/HALKit/AMD64/HalCoreMultiProcessingAMD64.cxx b/Kernel/HALKit/AMD64/HalCoreMultiProcessingAMD64.cxx
index a79d1881..fd4774b1 100644
--- a/Kernel/HALKit/AMD64/HalCoreMultiProcessingAMD64.cxx
+++ b/Kernel/HALKit/AMD64/HalCoreMultiProcessingAMD64.cxx
@@ -179,7 +179,7 @@ namespace Kernel::HAL
 
 	struct PROCESS_CONTROL_BLOCK final
 	{
-		ProcessHeader*	   f_Header;
+		PROCESS_HEADER_BLOCK*	   f_Header;
 		HAL::StackFramePtr f_StackFrame;
 	} fBlocks[cMaxPCBBlocks] = {0};
 
diff --git a/Kernel/HALKit/AMD64/HalScheduler.cxx b/Kernel/HALKit/AMD64/HalScheduler.cxx
index 791361b5..1bc28752 100644
--- a/Kernel/HALKit/AMD64/HalScheduler.cxx
+++ b/Kernel/HALKit/AMD64/HalScheduler.cxx
@@ -7,7 +7,7 @@
 #include <KernelKit/ProcessScheduler.hxx>
 
 using namespace Kernel;
-Void ProcessHeader::SetEntrypoint(UIntPtr& imageStart) noexcept
+Void PROCESS_HEADER_BLOCK::SetEntrypoint(UIntPtr& imageStart) noexcept
 {
 	if (imageStart == 0)
 		this->Crash();
diff --git a/Kernel/HALKit/ARM64/HalScheduler.cxx b/Kernel/HALKit/ARM64/HalScheduler.cxx
index 08703435..a55a77de 100644
--- a/Kernel/HALKit/ARM64/HalScheduler.cxx
+++ b/Kernel/HALKit/ARM64/HalScheduler.cxx
@@ -8,7 +8,7 @@
 
 using namespace Kernel;
 
-Void ProcessHeader::SetEntrypoint(UIntPtr& imageStart) noexcept
+Void PROCESS_HEADER_BLOCK::SetEntrypoint(UIntPtr& imageStart) noexcept
 {
 	if (imageStart == 0)
 		this->Crash();
diff --git a/Kernel/KernelKit/LockDelegate.hpp b/Kernel/KernelKit/LockDelegate.hpp
index 24eab70a..36a68054 100644
--- a/Kernel/KernelKit/LockDelegate.hpp
+++ b/Kernel/KernelKit/LockDelegate.hpp
@@ -9,11 +9,14 @@
 #include <NewKit/Atom.hpp>
 #include <NewKit/Defines.hpp>
 
-#define kLockDone	  (200U) /* job is done */
-#define kLockTimedOut (100U) /* job has timed out */
-
 namespace Kernel
 {
+	enum
+	{
+		kLockDone = 200,
+		kLockTimedOut,
+	};
+
 	/// @brief Lock condition pointer.
 	typedef Boolean* LockPtr;
 
diff --git a/Kernel/KernelKit/PEFSharedObject.hxx b/Kernel/KernelKit/PEFSharedObject.hxx
index d490c567..7b85937c 100644
--- a/Kernel/KernelKit/PEFSharedObject.hxx
+++ b/Kernel/KernelKit/PEFSharedObject.hxx
@@ -24,38 +24,40 @@ namespace Kernel
 	 * @brief Shared Library class
 	 * Load library from this class
 	 */
-	class SharedObject final
+	class PEFSharedObjectInterface final
 	{
 	public:
-		struct SharedObjectTrait final
+		struct PEF_SHARED_OBJECT_TRAITS final
 		{
-			VoidPtr fImageObject;
-			VoidPtr fImageEntrypointOffset;
+			VoidPtr fImageObject{nullptr};
+			VoidPtr fImageEntrypointOffset{nullptr};
+
+			Bool IsValid() { return fImageObject && fImageEntrypointOffset; }
 		};
 
 	public:
-		explicit SharedObject() = default;
-		~SharedObject()			= default;
+		explicit PEFSharedObjectInterface() = default;
+		~PEFSharedObjectInterface()			= default;
 
 	public:
-		NEWOS_COPY_DEFAULT(SharedObject);
+		NEWOS_COPY_DEFAULT(PEFSharedObjectInterface);
 
 	private:
-		SharedObjectTrait* fMounted{nullptr};
+		PEF_SHARED_OBJECT_TRAITS* fMounted{nullptr};
 
 	public:
-		SharedObjectTrait** GetAddressOf()
+		PEF_SHARED_OBJECT_TRAITS** GetAddressOf()
 		{
 			return &fMounted;
 		}
 
-		SharedObjectTrait* Get()
+		PEF_SHARED_OBJECT_TRAITS* Get()
 		{
 			return fMounted;
 		}
 
 	public:
-		void Mount(SharedObjectTrait* to_mount)
+		void Mount(PEF_SHARED_OBJECT_TRAITS* to_mount)
 		{
 			if (!to_mount || !to_mount->fImageObject)
 				return;
@@ -106,10 +108,10 @@ namespace Kernel
 		PEFLoader* fLoader{nullptr};
 	};
 
-	typedef SharedObject* SharedObjectPtr;
+	typedef PEFSharedObjectInterface* SharedObjectPtr;
 
-	EXTERN_C SharedObjectPtr rtl_init_shared_object(ProcessHeader* header);
-	EXTERN_C Void			 rtl_fini_shared_object(ProcessHeader* header, SharedObjectPtr lib, Bool* successful);
+	EXTERN_C SharedObjectPtr rtl_init_shared_object(PROCESS_HEADER_BLOCK* header);
+	EXTERN_C Void			 rtl_fini_shared_object(PROCESS_HEADER_BLOCK* header, SharedObjectPtr lib, Bool* successful);
 } // namespace Kernel
 
 #endif /* ifndef __KERNELKIT_SHARED_OBJECT_HXX__ */
diff --git a/Kernel/KernelKit/ProcessScheduler.hxx b/Kernel/KernelKit/ProcessScheduler.hxx
index b174858a..c15c5f76 100644
--- a/Kernel/KernelKit/ProcessScheduler.hxx
+++ b/Kernel/KernelKit/ProcessScheduler.hxx
@@ -26,9 +26,12 @@
 
 namespace Kernel
 {
-	class ProcessHeader;
+	//! @brief Forward declarations.
+	struct PROCESS_HEADER_BLOCK;
 	class ProcessTeam;
 	class ProcessScheduler;
+	class ProcessHelper;
+	class PEFSharedObjectInterface;
 
 	//! @brief Process identifier.
 	typedef Int64 ProcessID;
@@ -36,11 +39,6 @@ namespace Kernel
 	//! @brief Process name length.
 	inline constexpr SizeT kProcessLen = 256U;
 
-	//! @brief Forward declarations.
-	class ProcessHeader;
-	class ProcessScheduler;
-	class ProcessHelper;
-	class SharedObject;
 
 	//! @brief Process status enum.
 	enum class ProcessStatus : Int32
@@ -124,21 +122,19 @@ namespace Kernel
 	using ImagePtr	  = VoidPtr;
 	using HeapPtrKind = VoidPtr;
 
-	// @name ProcessHeader
-	// @brief Process Header (PH)
-	// Holds information about the running process.
-	// Thread execution is being abstracted away.
-	class ProcessHeader final
+	/// @name PROCESS_HEADER_BLOCK
+	/// @brief Process Header (PHB). Holds information about the running process. Thread execution the THREAD_INFORMATION_BLOCK.
+	struct PROCESS_HEADER_BLOCK final
 	{
 	public:
-		explicit ProcessHeader(VoidPtr startImage = nullptr)
+		explicit PROCESS_HEADER_BLOCK(VoidPtr startImage = nullptr)
 			: Image(startImage)
 		{
 		}
 
-		~ProcessHeader() = default;
+		~PROCESS_HEADER_BLOCK() = default;
 
-		NEWOS_COPY_DEFAULT(ProcessHeader)
+		NEWOS_COPY_DEFAULT(PROCESS_HEADER_BLOCK)
 
 	public:
 		void		 SetEntrypoint(UIntPtr& imageStart) noexcept;
@@ -158,7 +154,7 @@ namespace Kernel
 		HeapPtrKind HeapPtr{nullptr};
 
 		// shared library handle, reserved for .lib only.
-		SharedObject* SharedLibObjectPtr{nullptr};
+		PEFSharedObjectInterface* SharedObjectPEF{nullptr};
 
 		// Memory usage.
 		SizeT UsedMemory{0};
@@ -167,7 +163,7 @@ namespace Kernel
 		enum
 		{
 			kAppKind   = 1,
-			kShLibKind = 2,
+			kSharedObjectKind = 2,
 			kKindCount,
 		};
 
@@ -200,7 +196,7 @@ namespace Kernel
 		///! @brief Wakes up threads.
 		Void Wake(const bool wakeup = false);
 
-		// ProcessHeader getters.
+		// PROCESS_HEADER_BLOCK getters.
 	public:
 		///! @brief Get the process's name
 		///! @example 'C Runtime Library'
@@ -232,19 +228,19 @@ namespace Kernel
 
 		NEWOS_COPY_DEFAULT(ProcessTeam);
 
-		MutableArray<Ref<ProcessHeader>>& AsArray();
-		Ref<ProcessHeader>&				  AsRef();
+		MutableArray<Ref<PROCESS_HEADER_BLOCK>>& AsArray();
+		Ref<PROCESS_HEADER_BLOCK>&				  AsRef();
 		UInt64&							  Id() noexcept;
 
 	public:
-		MutableArray<Ref<ProcessHeader>> mProcessList;
-		Ref<ProcessHeader>				 mCurrentProcess;
+		MutableArray<Ref<PROCESS_HEADER_BLOCK>> mProcessList;
+		Ref<PROCESS_HEADER_BLOCK>				 mCurrentProcess;
 		UInt64							 mTeamId{0};
 	};
 
-	using ProcessHeaderRef = ProcessHeader*;
+	using ProcessHeaderRef = PROCESS_HEADER_BLOCK*;
 
-	/// @brief ProcessHeader manager class.
+	/// @brief PROCESS_HEADER_BLOCK manager class.
 	/// The main class which you call to schedule an app.
 	class ProcessScheduler final
 	{
@@ -262,11 +258,11 @@ namespace Kernel
 		ProcessTeam& CurrentTeam();
 
 	public:
-		SizeT Add(Ref<ProcessHeader>& processRef);
+		SizeT Add(Ref<PROCESS_HEADER_BLOCK>& processRef);
 		Bool  Remove(SizeT processSlot);
 
 	public:
-		Ref<ProcessHeader>& TheCurrent();
+		Ref<PROCESS_HEADER_BLOCK>& TheCurrent();
 		SizeT				Run() noexcept;
 
 	public:
@@ -284,7 +280,7 @@ namespace Kernel
 	{
 	public:
 		STATIC bool	 Switch(HAL::StackFrame* newStack, const PID& newPid);
-		STATIC bool	 CanBeScheduled(Ref<ProcessHeader>& process);
+		STATIC bool	 CanBeScheduled(Ref<PROCESS_HEADER_BLOCK>& process);
 		STATIC PID&	 TheCurrentPID();
 		STATIC SizeT StartScheduling();
 	};
diff --git a/Kernel/KernelKit/Semaphore.hpp b/Kernel/KernelKit/Semaphore.hpp
index 29223b6f..1f67dbc6 100644
--- a/Kernel/KernelKit/Semaphore.hpp
+++ b/Kernel/KernelKit/Semaphore.hpp
@@ -12,9 +12,9 @@
 
 namespace Kernel
 {
-	class ProcessHeader;
+	class PROCESS_HEADER_BLOCK;
 
-	typedef ProcessHeader* ProcessHeaderRef;
+	typedef PROCESS_HEADER_BLOCK* ProcessHeaderRef;
 
 	/// @brief Access control class, which locks a task until one is done.
 	class Semaphore final
@@ -31,8 +31,8 @@ namespace Kernel
 		void WaitForProcess() noexcept;
 
 	public:
-		bool Lock(ProcessHeader* process);
-		bool LockOrWait(ProcessHeader* process, HardwareTimerInterface* timer);
+		bool Lock(PROCESS_HEADER_BLOCK* process);
+		bool LockOrWait(PROCESS_HEADER_BLOCK* process, HardwareTimerInterface* timer);
 
 	public:
 		NEWOS_COPY_DEFAULT(Semaphore);
diff --git a/Kernel/Sources/CodeManager.cxx b/Kernel/Sources/CodeManager.cxx
index 3830e922..f48e8324 100644
--- a/Kernel/Sources/CodeManager.cxx
+++ b/Kernel/Sources/CodeManager.cxx
@@ -19,11 +19,11 @@ namespace Kernel
 		if (!main)
 			return false;
 
-		ProcessHeader proc((VoidPtr)main);
-		proc.Kind = ProcessHeader::kAppKind;
+		PROCESS_HEADER_BLOCK proc((VoidPtr)main);
+		proc.Kind = PROCESS_HEADER_BLOCK::kAppKind;
 		rt_copy_memory((VoidPtr)processName, proc.Name, rt_string_len(proc.Name));
 
-		Ref<ProcessHeader> refProc = proc;
+		Ref<PROCESS_HEADER_BLOCK> refProc = proc;
 
 		return ProcessScheduler::The().Leak().Add(refProc);
 	}
diff --git a/Kernel/Sources/PEFCodeManager.cxx b/Kernel/Sources/PEFCodeManager.cxx
index 223505b8..e95d9923 100644
--- a/Kernel/Sources/PEFCodeManager.cxx
+++ b/Kernel/Sources/PEFCodeManager.cxx
@@ -205,8 +205,8 @@ namespace Kernel
 			if (errOrStart.Error() != 0)
 				return false;
 
-			ProcessHeader	   proc(errOrStart.Leak().Leak());
-			Ref<ProcessHeader> refProc = proc;
+			PROCESS_HEADER_BLOCK	   proc(errOrStart.Leak().Leak());
+			Ref<PROCESS_HEADER_BLOCK> refProc = proc;
 
 			proc.Kind = procKind;
 
diff --git a/Kernel/Sources/PEFSharedObject.cxx b/Kernel/Sources/PEFSharedObject.cxx
index 7d02ac19..90f8e9b6 100644
--- a/Kernel/Sources/PEFSharedObject.cxx
+++ b/Kernel/Sources/PEFSharedObject.cxx
@@ -37,9 +37,9 @@ using namespace Kernel;
 /** @brief Library initializer. */
 /***********************************************************************************/
 
-EXTERN_C SharedObjectPtr rtl_init_shared_object(ProcessHeader* header)
+EXTERN_C SharedObjectPtr rtl_init_shared_object(PROCESS_HEADER_BLOCK* header)
 {
-	SharedObjectPtr sharedObj = tls_new_class<SharedObject>();
+	SharedObjectPtr sharedObj = tls_new_class<PEFSharedObjectInterface>();
 
 	if (!sharedObj)
 	{
@@ -48,7 +48,7 @@ EXTERN_C SharedObjectPtr rtl_init_shared_object(ProcessHeader* header)
 		return nullptr;
 	}
 
-	sharedObj->Mount(tls_new_class<SharedObject::SharedObjectTrait>());
+	sharedObj->Mount(tls_new_class<PEFSharedObjectInterface::PEF_SHARED_OBJECT_TRAITS>());
 
 	if (!sharedObj->Get())
 	{
@@ -80,7 +80,7 @@ EXTERN_C SharedObjectPtr rtl_init_shared_object(ProcessHeader* header)
 /** @param successful Reports if successful or not. */
 /***********************************************************************************/
 
-EXTERN_C Void rtl_fini_shared_object(ProcessHeader* header, SharedObjectPtr lib, Bool* successful)
+EXTERN_C Void rtl_fini_shared_object(PROCESS_HEADER_BLOCK* header, SharedObjectPtr lib, Bool* successful)
 {
 	MUST_PASS(successful);
 
diff --git a/Kernel/Sources/ProcessScheduler.cxx b/Kernel/Sources/ProcessScheduler.cxx
index 84fc7a1f..2033215e 100644
--- a/Kernel/Sources/ProcessScheduler.cxx
+++ b/Kernel/Sources/ProcessScheduler.cxx
@@ -42,7 +42,7 @@ namespace Kernel
 	/// @brief crash current process.
 	/***********************************************************************************/
 
-	void ProcessHeader::Crash()
+	void PROCESS_HEADER_BLOCK::Crash()
 	{
 		kcout << (*this->Name == 0 ? "Kernel" : this->Name) << ": crashed. (id = ";
 		kcout.Number(kErrorProcessFault);
@@ -60,17 +60,17 @@ namespace Kernel
 	/// @brief Gets the local last exit code.
 	/// @note Not thread-safe.
 	/// @return Int32 the last exit code.
-	const Int32& ProcessHeader::GetExitCode() noexcept
+	const Int32& PROCESS_HEADER_BLOCK::GetExitCode() noexcept
 	{
 		return this->fLastExitCode;
 	}
 
-	Int32& ProcessHeader::GetLocalCode() noexcept
+	Int32& PROCESS_HEADER_BLOCK::GetLocalCode() noexcept
 	{
 		return fLocalCode;
 	}
 
-	void ProcessHeader::Wake(const bool should_wakeup)
+	void PROCESS_HEADER_BLOCK::Wake(const bool should_wakeup)
 	{
 		this->Status =
 			should_wakeup ? ProcessStatus::kRunning : ProcessStatus::kFrozen;
@@ -78,7 +78,7 @@ namespace Kernel
 
 	/***********************************************************************************/
 
-	VoidPtr ProcessHeader::New(const SizeT& sz)
+	VoidPtr PROCESS_HEADER_BLOCK::New(const SizeT& sz)
 	{
 		if (this->HeapCursor)
 		{
@@ -121,7 +121,7 @@ namespace Kernel
 	}
 
 	/* @brief free pointer from usage. */
-	Boolean ProcessHeader::Delete(VoidPtr ptr, const SizeT& sz)
+	Boolean PROCESS_HEADER_BLOCK::Delete(VoidPtr ptr, const SizeT& sz)
 	{
 		if (sz < 1 || this->HeapCursor == this->HeapPtr)
 			return false;
@@ -145,19 +145,19 @@ namespace Kernel
 	}
 
 	/// @brief process name getter.
-	const Char* ProcessHeader::GetProcessName() noexcept
+	const Char* PROCESS_HEADER_BLOCK::GetProcessName() noexcept
 	{
 		return this->Name;
 	}
 
 	/// @brief process selector getter.
-	const ProcessSelector& ProcessHeader::GetSelector() noexcept
+	const ProcessSelector& PROCESS_HEADER_BLOCK::GetSelector() noexcept
 	{
 		return this->Selector;
 	}
 
 	/// @brief process status getter.
-	const ProcessStatus& ProcessHeader::GetStatus() noexcept
+	const ProcessStatus& PROCESS_HEADER_BLOCK::GetStatus() noexcept
 	{
 		return this->Status;
 	}
@@ -167,7 +167,7 @@ namespace Kernel
 	/**
 	@brief Affinity is the time slot allowed for the process.
 	*/
-	const AffinityKind& ProcessHeader::GetAffinity() noexcept
+	const AffinityKind& PROCESS_HEADER_BLOCK::GetAffinity() noexcept
 	{
 		return this->Affinity;
 	}
@@ -175,7 +175,7 @@ namespace Kernel
 	/**
 	@brief Standard exit proc.
 	*/
-	void ProcessHeader::Exit(const Int32& exit_code)
+	void PROCESS_HEADER_BLOCK::Exit(const Int32& exit_code)
 	{
 		if (this->ProcessId !=
 			ProcessScheduler::The().Leak().TheCurrent().Leak().ProcessId)
@@ -194,14 +194,14 @@ namespace Kernel
 		this->Image		 = nullptr;
 		this->StackFrame = nullptr;
 
-		if (this->Kind == kShLibKind)
+		if (this->Kind == kSharedObjectKind)
 		{
 			bool success = false;
-			rtl_fini_shared_object(this, this->SharedLibObjectPtr, &success);
+			rtl_fini_shared_object(this, this->SharedObjectPEF, &success);
 
 			if (success)
 			{
-				this->SharedLibObjectPtr = nullptr;
+				this->SharedObjectPEF = nullptr;
 			}
 		}
 
@@ -211,11 +211,11 @@ namespace Kernel
 	/// @brief Add process to list.
 	/// @param process
 	/// @return
-	SizeT ProcessScheduler::Add(Ref<ProcessHeader>& process)
+	SizeT ProcessScheduler::Add(Ref<PROCESS_HEADER_BLOCK>& process)
 	{
 		if (!process.Leak().Image)
 		{
-			if (process.Leak().Kind != ProcessHeader::kShLibKind)
+			if (process.Leak().Kind != PROCESS_HEADER_BLOCK::kSharedObjectKind)
 			{
 				return -kErrorNoEntrypoint;
 			}
@@ -227,13 +227,13 @@ namespace Kernel
 		kcout << "ProcessScheduler:: adding process to team...\r";
 
 		/// Create heap according to type of process.
-		if (process.Leak().Kind == ProcessHeader::kAppKind)
+		if (process.Leak().Kind == PROCESS_HEADER_BLOCK::kAppKind)
 		{
 			process.Leak().HeapPtr = sched_new_heap(kUserHeapUser | kUserHeapRw);
 		}
-		else if (process.Leak().Kind == ProcessHeader::kShLibKind)
+		else if (process.Leak().Kind == PROCESS_HEADER_BLOCK::kSharedObjectKind)
 		{
-			process.Leak().SharedLibObjectPtr = rtl_init_shared_object(&process.Leak());
+			process.Leak().SharedObjectPEF = rtl_init_shared_object(&process.Leak());
 			process.Leak().HeapPtr		 = sched_new_heap(kUserHeapUser | kUserHeapRw | kUserHeapShared);
 		}
 		else
@@ -333,7 +333,7 @@ namespace Kernel
 
 	/// @brief Gets current running process.
 	/// @return
-	Ref<ProcessHeader>& ProcessScheduler::TheCurrent()
+	Ref<PROCESS_HEADER_BLOCK>& ProcessScheduler::TheCurrent()
 	{
 		return mTeam.AsRef();
 	}
@@ -350,7 +350,7 @@ namespace Kernel
 	/// @param process the process reference.
 	/// @retval true can be schedulded.
 	/// @retval false cannot be schedulded.
-	bool ProcessHelper::CanBeScheduled(Ref<ProcessHeader>& process)
+	bool ProcessHelper::CanBeScheduled(Ref<PROCESS_HEADER_BLOCK>& process)
 	{
 		if (process.Leak().Status == ProcessStatus::kFrozen ||
 			process.Leak().Status == ProcessStatus::kDead)
diff --git a/Kernel/Sources/ProcessTeam.cxx b/Kernel/Sources/ProcessTeam.cxx
index 7f3fbcf8..52038b42 100644
--- a/Kernel/Sources/ProcessTeam.cxx
+++ b/Kernel/Sources/ProcessTeam.cxx
@@ -15,7 +15,7 @@ namespace Kernel
 {
 	/// @brief Process list array getter.
 	/// @return The list of process to schedule.
-	MutableArray<Ref<ProcessHeader>>& ProcessTeam::AsArray()
+	MutableArray<Ref<PROCESS_HEADER_BLOCK>>& ProcessTeam::AsArray()
 	{
 		return mProcessList;
 	}
@@ -29,7 +29,7 @@ namespace Kernel
 
 	/// @brief Current process getter.
 	/// @return The current process header.
-	Ref<ProcessHeader>& ProcessTeam::AsRef()
+	Ref<PROCESS_HEADER_BLOCK>& ProcessTeam::AsRef()
 	{
 		return mCurrentProcess;
 	}
diff --git a/Kernel/Sources/Semaphore.cxx b/Kernel/Sources/Semaphore.cxx
index ee89f482..49ec254a 100644
--- a/Kernel/Sources/Semaphore.cxx
+++ b/Kernel/Sources/Semaphore.cxx
@@ -17,7 +17,7 @@ namespace Kernel
 		return fLockingProcess == nullptr;
 	}
 
-	bool Semaphore::Lock(ProcessHeader* process)
+	bool Semaphore::Lock(PROCESS_HEADER_BLOCK* process)
 	{
 		if (!process || fLockingProcess)
 			return false;
@@ -32,7 +32,7 @@ namespace Kernel
 		return fLockingProcess;
 	}
 
-	bool Semaphore::LockOrWait(ProcessHeader* process, HardwareTimerInterface* timer)
+	bool Semaphore::LockOrWait(PROCESS_HEADER_BLOCK* process, HardwareTimerInterface* timer)
 	{
 		if (process == nullptr)
 			return false;
diff --git a/Kernel/Sources/URL.cxx b/Kernel/Sources/URL.cxx
index 88328ea6..69c4733f 100644
--- a/Kernel/Sources/URL.cxx
+++ b/Kernel/Sources/URL.cxx
@@ -22,12 +22,14 @@ namespace Kernel
 	/// @brief internal and reserved protocols by kernel.
 	constexpr const Char* kURLProtocols[] = {
 		"file", // Filesystem protocol
-		"zup",	// Zeta update protocol
+		"zup",	// ZKA update protocol
 		"oscc", // Open System Configuration Connectivity.
+		"odbc", // ODBC connectivity.
+		"https", // HTTPS layer driver (HTTPS.sys). 
 	};
 
 	constexpr const int kUrlOutSz	 = 1; //! such as: ://
-	constexpr const int kProtosCount = 3;
+	constexpr const int kProtosCount = 5;
 	constexpr const int kRangeSz	 = 4096;
 
 	ErrorOr<StringView> url_extract_location(const Char* url)