sedna 0.5.1 → 0.6.0

data/vendor/sedna/kernel/common/u/uevent.h

@@ -0,0 +1,71 @@
+/*
+ * File:  uevent.h
+ * Copyright (C) 2008 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+#if (_MSC_VER>1000)
+#pragma once
+#endif
+
+#ifndef UEVENT_H_INCLUDED
+#define UEVENT_H_INCLUDED
+
+#include "common/u/u.h"
+#include "common/u/usecurity.h"
+
+#define U_AUTORESET_EVENT				99
+#define U_MANUALRESET_EVENT				17
+
+typedef struct UEvent_tag_
+{
+#ifdef __cplusplus
+private:
+#endif
+#ifdef _WIN32
+	HANDLE handle;
+#else
+	int semid;
+#endif
+}
+UEvent;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+int UEventUnlink(global_name gn,
+				 sys_call_error_fun fun);
+
+int UEventCreate(UEvent *uEvent, 
+				 USECURITY_ATTRIBUTES* sa,
+				 int eventType,
+				 int isSet,
+				 global_name gn, 
+				 sys_call_error_fun fun);
+
+int UEventOpen(UEvent *uEvent, 
+			   global_name gn, 
+			   sys_call_error_fun fun);
+
+int UEventClose(UEvent *uEvent,
+				sys_call_error_fun fun);
+
+int UEventCloseAndUnlink(UEvent *uEvent,
+						 sys_call_error_fun fun);
+
+int UEventSet(UEvent *uEvent,
+			  sys_call_error_fun fun);
+
+int UEventReset(UEvent *uEvent,
+				sys_call_error_fun fun);
+
+int UEventWait(UEvent *uEvent,
+			   sys_call_error_fun fun);
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif

data/vendor/sedna/kernel/common/u/ugnames.cpp

@@ -0,0 +1,330 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+#include "common/errdbg/exceptions.h"
+#include "ugnames.h"
+
+/* {% globals */ 
+
+static UGlobalNamesRegistryItem *registry = NULL;
+static UGlobalNamesRegistrySearchProc searchProc = NULL;
+
+/* }% */ 
+
+#ifdef _WIN32
+#define IPC_PRIVATE 0
+#ifndef snprintf
+#define snprintf _snprintf
+#endif
+#else 
+#include <sys/types.h>
+#include <sys/ipc.h>
+#endif
+
+void
+UReleaseGlobalNamesRegistry()
+{
+	registry = NULL;
+	searchProc = NULL;
+}
+
+static 
+const UGlobalNamesRegistryItem *
+SearchGlobalNamesRegistry(const UGlobalNamesRegistryItem *registry,
+						  const char *basename)
+{
+	assert(registry);
+	while (registry->basename && 0!=strcmp(registry->basename,basename)) ++registry;
+	return registry->basename ? registry : NULL;
+}
+
+static void ThrowSystemException(const char *msg)
+{
+	throw SYSTEM_EXCEPTION(msg);
+}
+
+static int ValidateBaseName(const char *baseName)
+{
+	/* TODO: implement validation */ 
+	return 1;
+}
+
+static int ValidateGlobalName(const char *globalName)
+{
+	/* TODO: implement validation */ 
+	return 1;
+}
+
+static int ValidateCompoundName(const char *compoundName)
+{
+	/* TODO: implement validation */ 
+	return 1;
+}
+
+void 
+UInitGlobalNamesRegistry(UGlobalNamesRegistryItem *registryParam,
+						 UGlobalNamesRegistrySearchProc searchProcParam,
+						 int rangeBegin,
+						 int rangeEnd)
+{
+	int rangeSizeMin = 0;
+	UGlobalNamesRegistryItem *i = NULL;
+	char errorBuf[128];
+
+	assert(registryParam);
+	/* first let's estimate the required range size */ 
+	for (i = registryParam; i->basename; ++i) 
+	{
+		if (!ValidateBaseName(i->basename) || i->nObjectsMax<1 || (i->prefix==NULL && i->nObjectsMax > 1))
+		{
+			snprintf(errorBuf, sizeof errorBuf, 
+				"UInitGlobalNamesRegistry: bad item '%s'", i->basename);
+			errorBuf[(sizeof errorBuf)-1]=0;
+			ThrowSystemException(errorBuf);
+		}
+		rangeSizeMin+=i->nObjectsMax;
+	}
+	registry = registryParam;
+	/* check if the passed range is ok */ 
+	if (rangeEnd - rangeBegin < rangeSizeMin)
+		ThrowSystemException("InitGlobalNamesRegistry: range too small");
+	/* now initialize per-entry ranges */ 
+	for (i = registry; i->basename; ++i)
+	{
+		i->rangeBegin = rangeBegin;
+		rangeBegin = i->rangeEnd = rangeBegin + i->nObjectsMax;
+	}
+	/* complete initialization */ 
+	searchProc = (searchProcParam ? searchProcParam : SearchGlobalNamesRegistry);
+}
+
+const char *
+UCreateGlobalName(const char *basename,
+				  int objectId,
+				  char *buf,
+				  size_t bufSize)
+{
+	char prefix[32] = "", errorBuf[128];
+	int ordinal = 0;
+	const UGlobalNamesRegistryItem *item = NULL;
+	size_t stored = 0;
+
+	assert (basename);
+	item = searchProc(registry, basename);
+	if (!item)
+	{
+		snprintf(errorBuf, sizeof errorBuf, "CreateGlobalName: '%s' not found", basename);
+		errorBuf[(sizeof errorBuf)-1]=0;
+		ThrowSystemException(errorBuf);
+	}
+	ordinal = item->rangeBegin + objectId;
+	if (item->prefix)
+	{
+		stored = snprintf(prefix, sizeof prefix, "%s%d.", item->prefix, objectId);
+		if (stored<0 || stored>=(sizeof prefix))
+			ThrowSystemException("UCreateGlobalName: prefix too long");
+	}
+	if (ordinal >= item->rangeEnd || ordinal < item->rangeBegin)
+		ThrowSystemException("CreateGlobalName: generated ordinal out of range");
+
+	stored = snprintf(buf, bufSize, "SEDNA%d.%s%s@%d", registry->rangeBegin, prefix, basename, ordinal);
+	if (stored<0 || stored>=bufSize)
+		ThrowSystemException("CreateGlobalName: buffer too small");
+
+	return buf;
+}
+
+struct GlobalNameComponents
+{
+	const char *strNameBegin, *strNameEnd;
+	int base, ordinal;
+};
+
+static
+void ParseGlobalName(GlobalNameComponents *components,
+					 const char *globalName)
+{
+	assert(components);
+	if (globalName==NULL)
+	{
+		components->strNameBegin = NULL;
+		components->strNameEnd = NULL;
+		components->base = 0;
+		components->ordinal = 0;
+	}
+	else
+	{
+		const char *sep = NULL;
+		char *tail = NULL;
+		int ordinal = 0, base = 0;
+
+		sep = strchr(globalName,'@');
+		if (sep==NULL || (ordinal=strtol(sep+1,&tail,10), *tail!='\0'))
+		{
+			ThrowSystemException("ParseGlobalName: bad global name syntax");
+		}
+		components->strNameBegin = globalName;
+		components->strNameEnd = sep;
+		components->base = base;
+		components->ordinal = ordinal;
+	}
+}
+
+static
+const char *StrNameFromGlobalName(const char *globalName,
+								  size_t limit,
+								  const char *prefix,
+								  char *buf,
+								  size_t bufSize)
+{
+	char bufjr[16];
+	size_t partSz = 0, stored = 0;
+	GlobalNameComponents components = {NULL};
+
+	assert(prefix);
+	ParseGlobalName(&components,globalName);
+	if (globalName == NULL) 
+	{
+		buf = NULL;
+	}
+	else
+	{
+		partSz = (size_t)(components.strNameEnd - components.strNameBegin);
+		stored = snprintf(buf, bufSize, "%s%.*s", prefix, partSz, components.strNameBegin);
+		if (stored<0 || stored>=bufSize)
+			ThrowSystemException("StrNameFromGlobalName: buffer too small");
+		if (limit>0 && stored>limit)
+		{
+			stored = snprintf(bufjr, sizeof bufjr, "~%d", components.ordinal);
+			if (stored<0 || stored>=sizeof bufjr) ThrowSystemException("StrNameFromGlobalName: internal error");
+			if (stored>limit) ThrowSystemException("StrNameFromGlobalName: impossible limit");
+			strcpy(buf+limit-stored, bufjr);
+		}			
+	}
+	return buf;
+}
+
+const char *UWinIPCNameFromGlobalName(const char *globalName,
+									  char *buf,
+									  size_t bufSize)
+{
+	return StrNameFromGlobalName(globalName, 0, "", buf, bufSize);
+}
+
+const char *UPosixIPCNameFromGlobalName(const char *globalName,
+										char *buf,
+										size_t bufSize)
+{
+	const char *prefix = "/";
+	size_t limit = 0;
+
+#if (defined(FreeBSD) || defined(DARWIN))
+	prefix = "/tmp/";
+#endif
+
+#if defined(DARWIN)
+    limit = 30;
+#endif
+
+	return StrNameFromGlobalName(globalName, limit, prefix, buf, bufSize);
+}
+
+int USys5IPCKeyFromGlobalName(const char *globalName)
+{
+	int key = 0;
+	GlobalNameComponents components = {NULL};
+
+	ParseGlobalName(&components,globalName);
+	if (globalName == NULL)
+	{
+		key = IPC_PRIVATE;
+	}
+	else
+	{
+		key = components.ordinal;
+		if (key==IPC_PRIVATE)
+			ThrowSystemException("USys5IPCKeyFromGlobalName: bad key");
+	}
+	return key;
+}
+
+const char *
+UCreateCompoundName(const char **namesVec,
+					size_t namesCount,
+					char *buf,
+					size_t bufSize)
+{
+	size_t nameLen = 0;
+	const char **nameCur = namesVec, **namesEnd = namesVec+namesCount;
+	char *bufpos = buf;
+	assert(buf && bufSize>0);
+	strcpy(bufpos,"");
+	while(nameCur != namesEnd)
+	{
+		if (nameCur!=namesVec)
+		{
+			/* checked there is enough room in buf on previous iteration */ 
+			strcpy(bufpos,",");
+			++bufpos; bufSize-=1;
+		}
+		if (!ValidateGlobalName(*nameCur))
+			ThrowSystemException("UCreateCompoundName: bad global name syntax");
+		nameLen = (*nameCur?strlen(*nameCur):0);
+		if (bufSize < nameLen + 2)
+			ThrowSystemException("UCreateCompoundName: buffer too small");
+		if (*nameCur)
+		{
+			strcpy(bufpos, *nameCur);
+			bufpos+=nameLen;
+			bufSize-=nameLen;
+		}
+		++nameCur;
+	}
+	return buf;
+}
+
+const char *
+UGlobalNameFromCompoundName(const char *compoundName,
+							int index,
+							char *buf,
+							size_t bufSize)
+{
+	const char *pos = NULL, *epos=NULL;
+	assert(buf && compoundName);
+	if (!ValidateCompoundName(compoundName))
+	{
+		ThrowSystemException("UGlobalNameFromCompoundName: bad compound name syntax");
+	}
+	else
+	{
+		pos = compoundName;
+		while(index > 0 && pos)
+		{
+			pos = strchr(pos,',');
+			if (pos) pos+=1;
+			--index;
+		}
+		if (!pos || index<0)
+		{
+			ThrowSystemException("UGlobalNameFromCompoundName: index out of range");
+		}
+		epos = strchr(pos,',');
+		if (!epos) epos=pos+strlen(pos);
+		if (bufSize < (unsigned int) (epos-pos+1))
+		{
+			ThrowSystemException("UGlobalNameFromCompoundName: buffer too small");
+		}
+		if (pos == epos)
+		{
+			buf = NULL;
+		}
+		else
+		{
+			memcpy(buf,pos,epos-pos);
+			buf[epos-pos]=0;
+		}
+	}
+	return buf;
+}
+

data/vendor/sedna/kernel/common/u/ugnames.h

@@ -0,0 +1,134 @@
+#if (_MSC_VER>1000)
+#pragma once
+#endif
+
+#ifndef UGNAMES_H_INCLUDED
+#define UGNAMES_H_INCLUDED
+
+/*	Introducing a novel approach to cross-platform global names.
+
+	Problem:
+		Windows uses strings for naming IPC objects.
+		SYS 5 IPC uses key_t integers.
+		Posix IPC uses strings.
+		We are using both SYS 5 and Posix IPC on Linux.
+
+	Solution:
+		We define global_name type to hold a global name.
+		Global_name is a c-string and it is the same on all
+		platforms. In the 'U' layer the global_name is converted
+		into platform-specific IPC name.
+
+	Example:
+		base name -							SHMEM_BUFFERS
+		global name -						SEDNA1500.DB7.SHMEM_BUFFERS@1802
+		UWinIPCNameFromGlobalName() -		SEDNA1500.DB7.SHMEM_BUFFERS
+		USys5IPCKeyFromGlobalName() -		1802
+		UPosixIPCNameFromGlobalName() -		/SEDNA1500.DB7.SHMEM_BUFFERS
+
+	Generation:
+		Global names generation is automated. All global names
+		should be listed in globalNamesRegistry table. Entries
+		in the table are not for *individual* names but rather
+		for *name families*. Consider a shared memory segment
+		used as the buffer memory. Every database instance has 
+		it's own buffer memory, but only one entry in the registry
+		is made for SHMEM_BUFFERS (the basename). 
+
+		The global name is generated with UCreateGlobalName() function.
+		The function prepends prefixes to the basename resulting in
+		(assume database id is 7) SEDNA1500.DB7.SHMEM_BUFFERS. Finally a '@1802'
+		part is appended (1802 is a generated ordinal number).
+		The call to CreateGlobalName() with the same 
+		parameters produces the same global name. If parameters change
+		the generated name is not the same (including the ordinal number).
+		
+		The ordinal number is used as the source for SYS 5 IPC key.
+
+	Private IPC objects:
+		NULL global name by convention stands for "private" object.
+		
+	Compound names:
+		Sometimes it is handy to pass only one name while multiple
+		IPC objects are to be created. Compound name is just an
+		array of global names packed in the single string, ex:
+		"SEDNA1500.DB7.SHMEM_SM_TALK@1852,SEDNA1500.DB7.SEMARR_SM_TALK@1902" */ 
+
+#ifndef EXTERNC
+#ifdef __cplusplus
+#define EXTERNC extern "C" 
+#else
+#define EXTERNC
+#endif
+#endif
+
+/*	An item of the global names registry. */ 
+typedef struct UGlobalNamesRegistryItem_tag_
+{
+	const char *basename;	/* used for registry lookup and for names generation */ 
+	const char *prefix;		/* when we have multiple global names in the family we need prefix */ 
+	int nObjectsMax;		/* how many objects we are going to have */ 
+	int rangeBegin;			/* internal */ 
+	int rangeEnd;			/* internal */ 
+}
+UGlobalNamesRegistryItem;
+
+typedef 
+const UGlobalNamesRegistryItem *
+(* UGlobalNamesRegistrySearchProc)(const UGlobalNamesRegistryItem *registry, 
+								   const char *basename);
+
+/* Initialize global names registry. */ 
+EXTERNC
+void 
+UInitGlobalNamesRegistry(UGlobalNamesRegistryItem *registry,
+						 UGlobalNamesRegistrySearchProc searchProc,
+						 int rangeBegin,
+						 int rangeEnd);
+
+/* Release allocated resources. */ 
+EXTERNC
+void
+UReleaseGlobalNamesRegistry();
+
+/*	Create a global name. */ 
+EXTERNC
+const char *
+UCreateGlobalName(const char *basename,
+				  int objectId,
+				  char *buf,
+				  size_t bufSize);
+
+/* Create a compound name (an array of global names). */ 
+EXTERNC
+const char *
+UCreateCompoundName(const char **nameVec,
+					size_t namesCount,
+					char *buf,
+					size_t bufSize);
+
+/* Extract a component of the compound name. */ 
+EXTERNC
+const char *
+UGlobalNameFromCompoundName(const char *compoundName,
+							int index,
+							char *buf,
+							size_t bufSize);
+
+/* Create a Windows IPC object name from the global name. */ 
+EXTERNC
+const char *UWinIPCNameFromGlobalName(const char *globalName,
+									  char *buf,
+									  size_t bufSize);
+
+/* Create a SYS 5 IPC key from the global name. */ 
+EXTERNC
+int USys5IPCKeyFromGlobalName(const char *globalName);
+
+/* Create a Posix IPC name from the global name. */ 
+EXTERNC
+const char *UPosixIPCNameFromGlobalName(const char *globalName,
+										char *buf,
+										size_t bufSize);
+
+#endif