sedna 0.5.1 → 0.6.0

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

@@ -0,0 +1,91 @@
+/*
+ * File:  uprocess.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#ifndef _UPROCESS_H
+#define _UPROCESS_H
+
+
+#include "common/u/u.h"
+#include "common/u/uthread.h"
+#include "common/u/usecurity.h"
+
+
+#ifdef _WIN32
+#define U_DETACHED_PROCESS			DETACHED_PROCESS
+
+typedef HANDLE UPHANDLE;
+typedef DWORD  UPID;
+#else
+#include <signal.h>
+#define U_DETACHED_PROCESS			1
+
+typedef int    UPHANDLE;
+typedef pid_t  UPID;
+#endif
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* return value 0 indicates success */
+int uSetEnvironmentVariable(const char* name, const char* value, char** buffer, sys_call_error_fun fun);
+int uGetEnvironmentVariable(const char* name, char* buf, int size, sys_call_error_fun fun);
+
+/* return value 0 indicates success */
+int uGetCurProcessWorkingSetSize(usize_t *MinWorkingSetSize, usize_t *MaxWorkingSetSize, sys_call_error_fun fun);
+int uSetCurProcessWorkingSetSize(usize_t MinWorkingSetSize, usize_t MaxWorkingSetSize, sys_call_error_fun fun);
+
+/* return value 0 indicates success */
+int uCreateProcess(
+           char *command_line,		/* command line string */
+           bool inherit_handles,	/* handle inheritance option */
+           const char *cur_dir,		/* current directory name */
+           UFlag flags,
+           UPHANDLE *process_handle,
+           UTHANDLE *thread_handle,
+           UPID *process_id,
+           UTID *thread_id,
+           USECURITY_ATTRIBUTES* sa,
+           sys_call_error_fun fun
+    );
+
+/* return value 0 indicates success */
+int uTerminateProcess(UPID pid, UPHANDLE h, int exit_code, sys_call_error_fun fun);
+/* momently terminates current process */
+void uExitProcess(int exit_code, sys_call_error_fun fun);
+
+UPID uGetCurrentProcessId(sys_call_error_fun fun);
+
+/*  uIsProcessExist, uOpenProcess
+ *  Return values: 0 - upon successfull completition, 
+ *                -1 - process doesn't exist, 
+ *                -2 - some error occurred
+ */
+int uIsProcessExist(UPID pid, UPHANDLE h, sys_call_error_fun fun);
+int uOpenProcess(UPID pid, UPHANDLE /*out*/ *h, sys_call_error_fun fun);
+
+int uCloseProcess(UPHANDLE h, sys_call_error_fun fun);
+
+int uWaitForChildProcess(UPID pid, UPHANDLE h, int *status, sys_call_error_fun fun);
+int uWaitForProcess(UPID pid, UPHANDLE h, sys_call_error_fun fun);
+
+int uNonBlockingWaitForChildProcess(UPID pid);
+
+
+extern char *program_name_argv_0;
+
+/*  The result if written to buf. The size of the buf should be
+ *  not less than U_MAX_PATH + 1. The function return buf. 
+ */
+char* uGetImageProcPath(char *buf, sys_call_error_fun fun);
+
+#ifdef __cplusplus
+}
+#endif 
+
+#endif /* _UPROCESS_H */

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

@@ -0,0 +1,41 @@
+/*
+ * File:  usafesync.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+#ifndef _USAFESYNC_H
+#define _USAFESYNC_H
+
+#include "common/u/u.h"
+#include "common/u/usem.h"
+#include "common/u/uthread.h"
+
+/*
+ * Exception safe syncronisation
+ */
+
+struct SafeSemaphore {
+private:
+    const USemaphore _sem;
+    bool _aquired;
+public:
+    inline void Aquire() { USemaphoreDown(_sem, __sys_call_error); _aquired = true; };
+    inline void Release() { USemaphoreUp(_sem, __sys_call_error); _aquired = false; };
+    inline ~SafeSemaphore() { if (_aquired) { USemaphoreUp(_sem, __sys_call_error); } };
+    inline SafeSemaphore(const USemaphore &sem) : _sem(sem), _aquired(false) { };
+};
+
+/*
+struct SafeSpinlock {
+private:
+    const USpinLockPointer _slock;
+    bool _aquired;
+public:
+    inline void Aquire() { uSpinLock(_slock); _aquired = true; };
+    inline void Release() { uSpinUnlock(_slock); _aquired = false; };
+    inline ~SafeSpinlock() { if (_aquired) { uSpinUnlock(_slock); } };
+    inline SafeSpinlock(const USpinLockPointer slock) : _slock(slock), _aquired(false) { };
+};
+*/
+
+#endif

data/vendor/sedna/kernel/common/u/usecurity.c

@@ -0,0 +1,150 @@
+/*
+ * File:  usecurity.cpp
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+#include "common/u/usecurity.h"
+
+#ifdef _WIN32
+#include <Accctrl.h>
+#include <aclapi.h>
+#endif
+
+#include "common/errdbg/d_printf.h"
+#include "common/u/uhdd.h"
+
+int uCreateSA(USECURITY_ATTRIBUTES** sa, UAccess_Permissions access_permissions, int inherit_handle, sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    DWORD dwRes;
+    PACL pACL = NULL;
+    PSECURITY_DESCRIPTOR pSD = NULL;
+    EXPLICIT_ACCESS ea;
+    PSID SID;
+    HANDLE hToken;
+    PTOKEN_USER puser_info;
+    DWORD token_info_size = 0;
+    int res;
+
+    *sa = (USECURITY_ATTRIBUTES *) malloc(sizeof(USECURITY_ATTRIBUTES));
+
+    /* Initialize an EXPLICIT_ACCESS structure for an ACE. */
+    ZeroMemory(&ea, sizeof(EXPLICIT_ACCESS));
+    ea.grfAccessPermissions = access_permissions;
+    ea.grfAccessMode = SET_ACCESS;
+    ea.grfInheritance = NO_INHERITANCE;
+    ea.Trustee.TrusteeForm = TRUSTEE_IS_SID;
+    ea.Trustee.TrusteeType = TRUSTEE_IS_USER;
+
+    /* get Current User SID */
+    if (!OpenProcessToken(GetCurrentProcess(), TOKEN_READ, &hToken))
+    {
+        sys_call_error("OpenProcessToken");
+        return -1;
+    }
+
+    /* Call GetTokenInformation to get the buffer size. */
+    if (!GetTokenInformation(hToken, TokenUser, NULL, token_info_size, &token_info_size))
+    {
+        res = GetLastError();
+        if (res != ERROR_INSUFFICIENT_BUFFER)
+        {
+             sys_call_error("GetTokenInformation");
+             return -1;
+         }
+     }
+
+     /* Allocate the buffer.*/
+    puser_info = (PTOKEN_USER) (malloc(sizeof(char) * token_info_size));
+
+     /* Call GetTokenInformation again to get the user information. */
+    if (!GetTokenInformation(hToken, TokenUser, puser_info, token_info_size, &token_info_size))
+    {
+         sys_call_error("GetTokenInformation");
+         return -1;
+    }
+
+    ea.Trustee.ptstrName = (LPTSTR) puser_info->User.Sid;
+
+    /* Create a new ACL that contains the new ACEs.*/
+    dwRes = SetEntriesInAcl(1, &ea, NULL, &pACL);
+    if (ERROR_SUCCESS != dwRes)
+    {
+        sys_call_error("SetEntriesInAcl");
+        return -1;
+    }
+
+    /* Initialize a security descriptor.  */
+    pSD = (PSECURITY_DESCRIPTOR) (malloc(SECURITY_DESCRIPTOR_MIN_LENGTH));
+    if (NULL == pSD)
+        return -1;
+
+    if (!InitializeSecurityDescriptor(pSD, SECURITY_DESCRIPTOR_REVISION))
+    {
+        sys_call_error("InitializeSecurityDescriptor");
+        return -1;
+    }
+
+    /* Add the ACL to the security descriptor. */
+    if (!SetSecurityDescriptorDacl(pSD, TRUE,   /* bDaclPresent flag   */
+                                   pACL, FALSE))        /* not a default DACL */
+    {
+        sys_call_error("SetSecurityDescriptorDacl");
+        return -1;
+    }
+
+    free(puser_info);
+    if (CloseHandle(hToken) == 0) sys_call_error("CloseHandle");
+
+    /* Initialize a security attributes structure. */
+    (*sa)->nLength = sizeof(SECURITY_ATTRIBUTES);
+    (*sa)->lpSecurityDescriptor = pSD;
+    (*sa)->bInheritHandle = (BOOL)inherit_handle;
+
+    return 0;
+#else /*UNIX*/
+    *sa = (USECURITY_ATTRIBUTES *) malloc(sizeof(USECURITY_ATTRIBUTES));
+    (**sa) = access_permissions;
+    return 0;
+#endif
+}
+
+int uReleaseSA(USECURITY_ATTRIBUTES* sa, sys_call_error_fun fun)
+{
+#ifdef _WIN32 /* Security is on; WIN */
+    free(sa->lpSecurityDescriptor);
+    free(sa);
+    return 0;
+#else         /* Security is on; UNIX */
+    free(sa);
+    return 0;
+#endif
+}
+
+int uIsAdmin(sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    /* Open a handle to the access token for the calling process.*/
+    BOOL b;
+    SID_IDENTIFIER_AUTHORITY NtAuthority = SECURITY_NT_AUTHORITY;
+    PSID AdministratorsGroup;
+    b = AllocateAndInitializeSid(&NtAuthority, 2, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0, &AdministratorsGroup);
+    if (b)
+    {
+        if (!CheckTokenMembership(NULL, AdministratorsGroup, &b))
+        {
+            b = (int)FALSE;
+            sys_call_error("CheckTokenMembership");
+        }
+        FreeSid(AdministratorsGroup);
+    }
+    else sys_call_error("AllocateAndInitializeSid");
+
+    return (int)b;
+#else
+    if (geteuid() == 0)
+        return 1;
+    else
+        return 0;
+#endif
+}

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

@@ -0,0 +1,55 @@
+/*
+ * File:  usecurity.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+#ifndef __USECURITY_H
+#define __USECURITY_H
+
+#ifdef _WIN32
+#include <Accctrl.h>
+#include <aclapi.h>
+#endif
+
+
+#include "common/u/u.h"
+
+//#define REQUIRE_ROOT
+
+#ifdef _WIN32
+#define U_SEDNA_DEFAULT_ACCESS_PERMISSIONS_MASK             GENERIC_ALL
+#define U_SEDNA_DIRECTORY_ACCESS_PERMISSIONS_MASK           GENERIC_ALL
+#define U_SEDNA_SHMEM_ACCESS_PERMISSIONS_MASK               GENERIC_ALL
+#define U_SEDNA_SEMAPHORE_ACCESS_PERMISSIONS_MASK           GENERIC_ALL
+typedef SECURITY_ATTRIBUTES USECURITY_ATTRIBUTES;
+typedef ACL UACL;
+typedef PSID UPSID;
+typedef DWORD UAccess_Permissions;
+#else
+#define U_SEDNA_DEFAULT_ACCESS_PERMISSIONS_MASK             S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP  /* 00660 */
+#define U_SEDNA_SHMEM_ACCESS_PERMISSIONS_MASK               00666
+#define U_SEDNA_DIRECTORY_ACCESS_PERMISSIONS_MASK           00755
+#define U_SEDNA_SEMAPHORE_ACCESS_PERMISSIONS_MASK           00777
+typedef mode_t USECURITY_ATTRIBUTES;
+typedef mode_t UAccess_Permissions;
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    int uCreateSA(USECURITY_ATTRIBUTES** sa, UAccess_Permissions access_permissions, int inherit_handle, sys_call_error_fun fun);
+
+    int uReleaseSA(USECURITY_ATTRIBUTES* sa, sys_call_error_fun fun);
+
+/* returns true if 
+   Windows: current user is in the Administrators Group
+   Unix: current user is root
+   returns false otherwise (including errors) */
+    int uIsAdmin(sys_call_error_fun fun);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/vendor/sedna/kernel/common/u/usem.c

@@ -0,0 +1,891 @@
+/*
+ * File:  usem.cpp
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+#include "common/u/usem.h"
+#include "common/u/uutils.h"
+#include "common/errdbg/d_printf.h"
+#include "common/u/ugnames.h"
+
+///////////////////////////////////////////////////////////////////////////////
+// Semaphore implementation
+///////////////////////////////////////////////////////////////////////////////
+
+int USemaphoreCreate(USemaphore *sem, int init_value, int max_value, global_name name, USECURITY_ATTRIBUTES* sa, sys_call_error_fun fun)
+#ifdef _WIN32
+{
+	char buf[128];
+	const char *wName = UWinIPCNameFromGlobalName(name,buf,128);
+
+    *sem = CreateSemaphore(sa, init_value, max_value, wName);
+
+    if (*sem == NULL)
+    {
+        sys_call_error("CreateSemaphore");
+        return 1;
+    }
+    else
+    {
+        if (GetLastError() == ERROR_ALREADY_EXISTS)
+        {
+            d_printf1("CreateSemaphore: already exists\n");
+            return 1;
+        }	
+    }
+
+    return 0;
+}
+#else
+{
+	union {
+	    int val;
+	    struct semid_sd *buf;
+	    ushort *array;
+	} semctl_arg;
+	key_t key = IPC_PRIVATE;
+
+	key = USys5IPCKeyFromGlobalName(name);
+
+    USECURITY_ATTRIBUTES sem_access_mode = U_SEDNA_SEMAPHORE_ACCESS_PERMISSIONS_MASK;
+    if (sa) sem_access_mode = *sa;
+    int res = semget(key, 1, IPC_CREAT | IPC_EXCL | sem_access_mode);
+    *sem = res;
+
+    if (*sem < 0)
+    {
+        sys_call_error("semget");
+        return 1;
+    }
+	semctl_arg.val = init_value;
+
+	if(semctl(*sem, 0, SETVAL, semctl_arg) < 0)
+	{
+        sys_call_error("semctl");
+		return 1;
+	}
+
+    return 0;
+}
+#endif
+
+
+int USemaphoreOpen(USemaphore *sem, global_name name, sys_call_error_fun fun)
+#ifdef _WIN32
+{
+	char buf[128];
+	const char *wName = UWinIPCNameFromGlobalName(name,buf,128);
+    *sem = OpenSemaphore(SEMAPHORE_ALL_ACCESS, FALSE, wName);
+
+    if (*sem == NULL)
+    {
+        sys_call_error("OpenSemaphore");
+        return 1;
+    }
+
+    return 0;
+}
+#else
+{
+	key_t key = IPC_PRIVATE;
+	key = USys5IPCKeyFromGlobalName(name);
+
+    *sem = semget(key, 1, 0);
+
+    if (*sem < 0)
+    {
+        sys_call_error("semget");
+        return 1;
+    }
+
+    return 0;
+}
+#endif
+
+int USemaphoreRelease(USemaphore sem, sys_call_error_fun fun)
+#ifdef _WIN32
+{
+    BOOL res =  CloseHandle(sem);
+
+    if (res == 0)
+    {
+        sys_call_error("CloseHandle");
+        return 1;
+    }
+
+    return 0;
+}
+#else
+{
+/*    union {
+	int val;
+	struct semid_sd *buf;
+	ushort *array;
+    } semctl_arg;*/
+
+    if (sem < 0)
+    {
+        return 1;
+    }
+	else
+	{
+		if (semctl(sem, 0, IPC_RMID) < 0)
+		{
+            sys_call_error("semctl");
+			return 1;
+		}
+	}
+    return 0;
+}
+#endif
+
+
+int USemaphoreClose(USemaphore sem, sys_call_error_fun fun)
+#ifdef _WIN32
+{
+    BOOL res =  CloseHandle(sem);
+
+    if (res == 0)
+    {
+        sys_call_error("CloseHandle");
+        return 1;
+    }
+
+    return 0;
+}
+#else
+{
+    return 0;
+}
+#endif
+
+int USemaphoreDown(USemaphore sem, sys_call_error_fun fun)
+#ifdef _WIN32
+{
+    DWORD res; 
+    res = WaitForSingleObject(sem, INFINITE);
+    if (res == WAIT_FAILED || res != WAIT_OBJECT_0)
+    {
+        sys_call_error("WaitForSingleObject");
+        return 1;
+    }
+
+    return 0;
+}
+#else
+{
+    int res;
+	
+    //struct sembuf op_op[1] = {{0, -1, 0}};
+    struct sembuf op_op[1];
+    op_op[0].sem_num = 0;
+    op_op[0].sem_op = -1;
+    op_op[0].sem_flg = 0;
+
+
+    while (true)
+    {
+        res = semop(sem, op_op, 1);
+	
+        if (res == 0) return 0;
+        else if (errno == EINTR) continue;
+        else 
+        {
+            sys_call_error("semop");
+            return 1;
+        }
+    }
+}
+#endif
+
+
+int USemaphoreDownTimeout(USemaphore sem, unsigned int millisec, sys_call_error_fun fun)
+#ifdef _WIN32
+{
+    DWORD res;
+    res = WaitForSingleObject(sem, millisec);
+
+    if (res == WAIT_FAILED)
+    {
+        sys_call_error("WaitForSingleObject");
+        return 1;
+    }
+ 
+    if (res == WAIT_OBJECT_0) return 0;
+
+    if (res == WAIT_TIMEOUT) return 2;
+
+    return 1;
+}
+#else
+{
+    int res = 0;
+    unsigned int count = 0;
+    
+    //struct sembuf op_op[1] = {{0, -1, IPC_NOWAIT}};
+    struct sembuf op_op[1];
+    op_op[0].sem_num = 0;
+    op_op[0].sem_op = -1;
+    op_op[0].sem_flg = IPC_NOWAIT;
+
+        
+    for(; count < (millisec/1000); count++)
+    {    
+    	res = semop(sem, op_op, 1);
+	
+    	if (res == 0) return 0; 
+        else if (errno == EAGAIN)
+        {
+            sleep(1);
+        }
+        else 
+        {
+            sys_call_error("semop");
+            return 1;
+        }
+    }
+
+    return 2;
+} 
+#endif
+
+int USemaphoreUp(USemaphore sem, sys_call_error_fun fun)
+#ifdef _WIN32
+{
+    BOOL res;
+
+    res = ReleaseSemaphore(sem, 1, NULL);
+
+    if (res == 0) 
+    {
+        sys_call_error("ReleaseSemaphore");
+        return 1;
+    }
+
+    return 0;
+}
+#else
+{
+	int res;
+	
+	//struct sembuf op_op[1] = {{0, 1, IPC_NOWAIT}};
+    struct sembuf op_op[1];
+    op_op[0].sem_num = 0;
+    op_op[0].sem_op = 1;
+    op_op[0].sem_flg = IPC_NOWAIT;
+
+	res = semop(sem, op_op, 1);	
+	if(res < 0)
+	{
+        sys_call_error("semop");
+		return 1;	
+	}
+	return 0;
+}
+#endif
+
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Array of semaphore implementation
+///////////////////////////////////////////////////////////////////////////////
+
+#define SIZE_OF_BUF_FOR_ADJUSTED_NAME 128
+
+int USemaphoreArrCreate(USemaphoreArr *sem, int size, const int *init_values, global_name name, USECURITY_ATTRIBUTES* sa, sys_call_error_fun fun)
+#ifdef _WIN32
+{
+    int i = 0;
+    char buf[128];
+	const char *wName = NULL;
+    size_t name_len = 0;
+
+	wName = UWinIPCNameFromGlobalName(name,buf,128);
+	if (wName) name_len = strlen(wName);
+
+    /*
+     * We concatenate name with a number and put the result to buf. 
+     * Because int2c_str requieres 20 bytes the length of the name
+     * must not be greater than (SIZE_OF_BUF_FOR_ADJUSTED_NAME - 20)
+     */
+    *sem = (USemaphoreArr)malloc(sizeof(HANDLE) * size);
+
+    for (i = 0; i < size; i++)
+    {
+		sprintf(buf+name_len,":%d",i);
+
+        (*sem)[i] = CreateSemaphore(sa,
+                                    init_values[i],
+                                    INT_MAX,
+                                    wName);
+
+        if ((*sem)[i] == NULL)
+        {
+            free(*sem);
+            sys_call_error("CreateSemaphore");
+            return 1;
+        }
+        else
+        {
+            if (GetLastError() == ERROR_ALREADY_EXISTS)
+            {
+                free(*sem);
+                d_printf1("CreateSemaphore: already exists\n");
+                return 1;
+            }	
+        }
+    }
+
+    return 0;
+}
+#else
+{
+	union {
+	    int val;
+	    struct semid_sd *buf;
+	    ushort *array;
+	} semctl_arg;
+	key_t key = IPC_PRIVATE;
+    int i = 0;
+
+	key = USys5IPCKeyFromGlobalName(name);
+
+    USECURITY_ATTRIBUTES sem_access_mode = U_SEDNA_SEMAPHORE_ACCESS_PERMISSIONS_MASK;
+    if (sa) sem_access_mode = *sa;
+    *sem = semget(key, size, IPC_CREAT | IPC_EXCL | sem_access_mode);
+
+    if (*sem < 0)
+    {
+        sys_call_error("semget");
+        return 1;
+    }
+
+    for (i = 0; i < size; i++)
+    {
+	    semctl_arg.val = init_values[i];
+
+        if(semctl(*sem, i, SETVAL, semctl_arg) < 0)
+        {
+		    //d_printf3("ERRROR: %d. Can't set initial value for %x semaphore\n", perror(semctl), (int)name);
+		    //d_printf2("Can't set initial value for %x semaphore\n", (int)name);
+            sys_call_error("semctl");
+		    return 1;
+    	}
+    }
+
+    return 0;
+}
+#endif
+
+int USemaphoreArrOpen(USemaphoreArr *sem, int size, global_name name, sys_call_error_fun fun)
+#ifdef _WIN32
+{
+    int i = 0;
+    char buf[128];
+    size_t name_len = 0;
+	const char *wName = NULL;
+
+	wName = UWinIPCNameFromGlobalName(name,buf,128);
+	if (wName) name_len = strlen(wName);
+
+    *sem = (USemaphoreArr)malloc(sizeof(HANDLE) * size);
+
+    for (i = 0; i < size; i++)
+    {
+		sprintf(buf+name_len,":%d",i);
+
+        (*sem)[i] = OpenSemaphore(SEMAPHORE_ALL_ACCESS, 
+                                  FALSE, 
+                                  wName);
+
+        if ((*sem)[i] == NULL)
+        {
+            free(*sem);
+            sys_call_error("OpenSemaphore");
+            return 1;
+        }
+    }
+
+    return 0;
+}
+#else
+{
+	key_t key = IPC_PRIVATE;
+	key = USys5IPCKeyFromGlobalName(name);
+
+    *sem = semget(key, size, 0);
+
+    if (*sem < 0)
+    {
+        sys_call_error("semget"); 
+        return 1;
+    }
+
+    return 0;
+}
+#endif
+
+
+int USemaphoreArrRelease(USemaphoreArr sem, int size, sys_call_error_fun fun)
+#ifdef _WIN32
+{
+    int i = 0;
+    BOOL res;
+
+    for (i = 0; i < size; i++)
+    {
+        res = CloseHandle(sem[i]);
+
+        if (res == 0)
+        {
+            sys_call_error("CloseHandle");
+            return 1;
+        }
+    }
+
+    free(sem);
+
+    return 0;
+}
+#else
+{
+/*    union {
+        int val;
+        struct semid_sd *buf;
+        ushort *array;
+    } semctl_arg;*/
+
+    if (sem < 0)
+    {
+        d_printf1("CloseHandle failed\n");
+        //d_printf2("Error %d\n", perror(semget));
+        return 1;
+    }
+	else
+	{
+		//semctl_arg.val = 0;
+		if (semctl(sem, 0, IPC_RMID/*, semctl_arg*/) < 0)
+		{
+            sys_call_error("semctl");
+			return 1;
+		}
+	}
+    return 0;
+}
+#endif
+
+
+int USemaphoreArrClose(USemaphoreArr sem, int size, sys_call_error_fun fun)
+#ifdef _WIN32
+{
+    int i = 0;
+    BOOL res;
+
+    for (i = 0; i < size; i++)
+    {
+        res = CloseHandle(sem[i]);
+
+        if (res == 0)
+        {
+            sys_call_error("CloseHandle");
+            return 1;
+        }
+    }
+
+    free(sem);
+
+    return 0;
+}
+#else
+{
+    return 0;
+}
+#endif
+
+int USemaphoreArrDown(USemaphoreArr sem, int i, sys_call_error_fun fun)
+#ifdef _WIN32
+{
+    DWORD res;
+    res = WaitForSingleObject(sem[i], INFINITE);
+
+    if (res == WAIT_FAILED || res != WAIT_OBJECT_0)
+    {
+        sys_call_error("WaitForSingleObject");
+        return 1;
+    }
+
+    return 0;
+}
+#else
+{
+    int res;
+	
+    //struct sembuf op_op[1] = {{0, -1, 0}};
+    struct sembuf op_op[1];
+    op_op[0].sem_num = i;
+    op_op[0].sem_op = -1;
+    op_op[0].sem_flg = 0;
+
+
+    while (true)
+    {
+	int attempt = 0;
+	res = semop(sem, op_op, 1);
+	
+        if (res == 0) return 0;
+        else if (errno == EINTR) continue;
+        else 
+        {
+            sys_call_error("semop");
+            return 1;
+        }
+    }
+}
+#endif
+
+
+int USemaphoreArrDownTimeout(USemaphoreArr sem, int i, unsigned int millisec, sys_call_error_fun fun)
+#ifdef _WIN32
+{
+    DWORD res;
+    res = WaitForSingleObject(sem[i], millisec);
+
+    if (res == WAIT_FAILED)
+    {
+        sys_call_error("WaitForSingleObject");
+        return 1;
+    }
+ 
+    if (res == WAIT_OBJECT_0) return 0;
+    if (res == WAIT_TIMEOUT) return 2;
+
+    return 1;
+}
+#else
+{
+    int res = 0;
+    unsigned int count = 0;
+    
+    //struct sembuf op_op[1] = {{0, -1, IPC_NOWAIT}};
+    struct sembuf op_op[1];
+    op_op[0].sem_num = i;
+    op_op[0].sem_op = -1;
+    op_op[0].sem_flg = IPC_NOWAIT;
+
+        
+    for(; count < (millisec/1000); count++)
+    {    
+    	res = semop(sem, op_op, 1);
+	
+    	if (res == 0) return 0; 
+        else if (errno == EAGAIN)
+        {
+            sleep(1);
+        }
+        else 
+        {
+            sys_call_error("semop");
+            return 1;
+        }
+
+    	//else sleep(1);
+    }
+
+    return 2;
+} 
+#endif
+
+int USemaphoreArrUp(USemaphoreArr sem, int i, sys_call_error_fun fun)
+#ifdef _WIN32
+{
+    BOOL res;
+
+    res = ReleaseSemaphore(sem[i], 1, NULL);
+
+    if (res == 0) 
+    {
+        sys_call_error("ReleaseSemaphore");
+        return 1;
+    }
+
+    return 0;
+}
+#else
+{
+	int res;
+	
+	//struct sembuf op_op[1] = {{0, 1, IPC_NOWAIT}};
+	struct sembuf op_op[1];
+    op_op[0].sem_num = i;
+    op_op[0].sem_op = 1;
+    op_op[0].sem_flg = IPC_NOWAIT;
+
+	res = semop(sem, op_op, 1);
+	
+	if(res < 0)
+	{
+        sys_call_error("semop");
+		return 1;	
+	}
+	return 0;
+}
+#endif
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Unnamed semaphore implementation
+///////////////////////////////////////////////////////////////////////////////
+
+int UUnnamedSemaphoreCreate(UUnnamedSemaphore *sem, int init_value, USECURITY_ATTRIBUTES* sa, sys_call_error_fun fun)
+#ifdef _WIN32
+{
+    *sem = CreateSemaphore(sa, init_value, INT_MAX, NULL);
+
+    if (*sem == NULL)
+    {
+        sys_call_error("CreateSemaphore");
+        return 1;
+    }
+
+    return 0;
+}
+#else
+{
+    int res = 0;
+
+    res = pthread_mutex_init(&(sem->mutex), NULL);
+    if (res != 0)
+    {
+        sys_call_error("pthread_mutex_init");
+        return 1;
+    }
+
+    res = pthread_cond_init(&(sem->condition), NULL);
+    if (res != 0)
+    {
+        sys_call_error("pthread_cond_init"); 
+        if (pthread_mutex_destroy(&(sem->mutex)) != 0) 
+           sys_call_error("pthread_mutex_destroy");
+        return 1;
+    }
+
+    sem->count = init_value;
+
+    return 0;
+}
+#endif
+
+int UUnnamedSemaphoreRelease(UUnnamedSemaphore *sem, sys_call_error_fun fun)
+#ifdef _WIN32
+{
+    BOOL res =  CloseHandle(*sem);
+
+    if (res == 0)
+    {
+        sys_call_error("CloseHandle");
+        return 1;
+    }
+
+    return 0;
+}
+#else
+{
+    int res = 0;
+    res = pthread_mutex_destroy(&(sem->mutex));
+    if (res != 0)
+    {
+        sys_call_error("pthread_mutex_destroy");
+        return 1;
+    }
+
+    res = pthread_cond_destroy(&(sem->condition));
+    if (res != 0)
+    {
+        sys_call_error("pthread_cond_destroy");
+        return 1;
+    }
+
+    return 0;
+}
+#endif
+
+int UUnnamedSemaphoreDown(UUnnamedSemaphore *sem, sys_call_error_fun fun)
+#ifdef _WIN32
+{
+    DWORD res;
+    res = WaitForSingleObject(*sem, INFINITE);
+
+    if (res == WAIT_FAILED || res != WAIT_OBJECT_0)
+    {
+        sys_call_error("WaitForSingleObject");
+        return 1;
+    }
+
+    return 0;
+}
+#else
+{
+    int res = 0;
+
+    res = pthread_mutex_lock(&(sem->mutex));
+    if (res != 0)
+    {
+        sys_call_error("pthread_mutex_lock");
+        return 1;
+    }
+
+    while (sem->count <= 0)
+    {
+        res = pthread_cond_wait(&(sem->condition), &(sem->mutex));
+        if (res != 0)
+        {
+            sys_call_error("pthread_cond_wait");
+            return 1;
+        }
+    }
+
+    sem->count--;
+
+    res = pthread_mutex_unlock(&(sem->mutex));
+    if (res != 0)
+    {
+        sys_call_error("pthread_mutex_unlock");
+        return 1;
+    }
+
+    return 0;
+}
+#endif
+
+// down with timout
+// return values: 0 - success
+//                1 - falure
+//                2 - timeout
+int UUnnamedSemaphoreDownTimeout(UUnnamedSemaphore *sem, unsigned int millisec, sys_call_error_fun fun)
+#ifdef _WIN32
+{
+    DWORD res;
+    res = WaitForSingleObject(*sem, millisec);
+
+    if (res == WAIT_FAILED)
+    {
+        sys_call_error("WaitForSingleObject");
+        return 1;
+    }
+ 
+    if (res == WAIT_OBJECT_0) return 0;
+
+    if (res == WAIT_TIMEOUT) return 2;
+
+    return 1;
+}
+#else
+{
+    int res = 0;
+    struct timeval tv;
+    struct timespec timeout;
+    
+    if(gettimeofday(&tv, NULL) == -1)
+    {
+        sys_call_error("gettimeofday");
+        return 1;
+    }
+
+    timeout.tv_sec = tv.tv_sec  + millisec / 1000;
+    timeout.tv_nsec = tv.tv_usec * 1000;
+
+    res = pthread_mutex_lock(&(sem->mutex));
+    if (res != 0)
+    {
+        sys_call_error("pthread_mutex_lock");
+        return 1;
+    }
+
+    while (sem->count <= 0)
+    {
+        //d_printf1("timedwait: cycle\n");
+        res = pthread_cond_timedwait(&(sem->condition), &(sem->mutex), &timeout);
+        if (res == ETIMEDOUT)
+        {
+            res = pthread_mutex_unlock(&(sem->mutex));
+            if (res != 0)
+            {
+                sys_call_error("pthread_mutex_unlock");
+                return 1;
+            }
+            //d_printf1("timedwait: timeout\n");
+            return 2;
+        }
+        else if (res != 0)
+        {
+            sys_call_error("pthread_cond_timedwait");
+            return 1;
+        }
+    }
+
+    sem->count--;
+
+    res = pthread_mutex_unlock(&(sem->mutex));
+    if (res != 0)
+    {
+        sys_call_error("pthread_mutex_unlock");
+        return 1;
+    }
+
+    //d_printf1("timedwait: signal\n");
+    return 0;
+} 
+#endif
+
+
+int UUnnamedSemaphoreUp(UUnnamedSemaphore *sem, sys_call_error_fun fun)
+#ifdef _WIN32
+{
+    BOOL res;
+    res = ReleaseSemaphore(*sem, 1, NULL);
+
+    if (res == 0) 
+    {
+        sys_call_error("ReleaseSemaphore");
+        return 1;
+    }
+
+    return 0;
+}
+#else
+{
+    int res = 0;
+
+    res = pthread_mutex_lock(&(sem->mutex));
+    if (res != 0)
+    {
+        sys_call_error("pthread_mutex_lock");
+        return 1;
+    }
+
+    sem->count++;
+
+    res = pthread_mutex_unlock(&(sem->mutex));
+    if (res != 0)
+    {
+        sys_call_error("pthread_mutex_unlock");
+        return 1;
+    }
+
+    res = pthread_cond_signal(&(sem->condition));
+    if (res != 0)
+    {
+        sys_call_error("pthread_cond_signal");
+        return 1;
+    }
+
+    return 0;
+}
+#endif
+
+