sedna 0.5.1 → 0.6.0

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

@@ -0,0 +1,118 @@
+/*
+ * File:  usocket.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+#ifndef _USOCKET_H
+#define _USOCKET_H
+
+#include "common/u/u.h"
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#ifdef _WIN32
+    typedef SOCKET USOCKET;
+
+#define U_INVALID_SOCKET			INVALID_SOCKET
+#define U_SOCKET_ERROR              SOCKET_ERROR
+
+#else
+#include <sys/socket.h>
+    
+    typedef int USOCKET;
+
+#define U_INVALID_SOCKET			(-1)
+#define U_SOCKET_ERROR              (-1)
+
+#endif
+
+// defines for fd_set
+#define U_SSET 					fd_set
+#define U_SSET_SIZE				FD_SETSIZE
+
+#define U_SSET_SET 				FD_SET
+#define U_SSET_ISSET 			FD_ISSET
+#define U_SSET_CLR 				FD_CLR
+#define U_SSET_ZERO 			FD_ZERO
+
+/* returns zero if succeeded
+   returns U_SOCKET_ERROR if failed */
+    int uSocketInit(sys_call_error_fun fun);
+
+/* returns zero if succeeded
+   returns U_SOCKET_ERROR if failed */
+    int uSocketCleanup(sys_call_error_fun fun);
+
+/* returns U_INVALID_SOCKET if failed */
+    USOCKET usocket(int af, int type, int protocol, sys_call_error_fun fun);
+
+/* returns zero if succeeded
+   returns U_SOCKET_ERROR if failed */
+    int ubind_tcp(USOCKET s, int port, sys_call_error_fun fun);
+
+/* returns zero if succeeded
+   returns U_SOCKET_ERROR if failed */
+    int uconnect_tcp(USOCKET s, int port, const char *hostname, sys_call_error_fun fun);
+
+/* returns zero if succeeded
+   returns U_SOCKET_ERROR if failed */
+    int usetsockopt(USOCKET s, int level, int optname, const void* optval, unsigned int optlen, sys_call_error_fun fun);
+
+/* returns zero if succeeded
+   returns U_SOCKET_ERROR if failed */
+    int ugetsockopt(USOCKET s, int level, int optname, void* optval, unsigned int optlen, sys_call_error_fun fun);
+
+/* returns zero if succeeded
+   returns U_SOCKET_ERROR if failed */
+    int ulisten(USOCKET s, int backlog, sys_call_error_fun fun);
+
+/* returns U_INVALID_SOCKET if failed */
+    USOCKET uaccept(USOCKET s, sys_call_error_fun fun);
+
+/* return value indicates number of bytes received
+   returns zero if connection was gracefully closed
+   returns U_SOCKET_ERROR in the case of error */
+    int urecv(USOCKET s, char *buf, int len, sys_call_error_fun fun);
+
+/* return value indicates number of bytes send  
+   returns U_SOCKET_ERROR in the case of error  */
+    int usend(USOCKET s, const char *buf, int len, sys_call_error_fun fun);
+
+/* returns zero if succeeded
+   returns U_SOCKET_ERROR if failed */
+    int uclose_socket(USOCKET s, sys_call_error_fun fun);
+
+/* returns zero if succeeded
+   returns U_SOCKET_ERROR if failed */
+    int ushutdown_close_socket(USOCKET s, sys_call_error_fun fun);
+
+/* returns zero if succeeded
+   returns U_SOCKET_ERROR if failed */
+	int ushutdown_socket(USOCKET s, sys_call_error_fun fun);
+
+/* returns 1 (number of sockets ready to recv) if there is data pending in network connection
+   returns 0 if timeout
+   returns U_SOCKET_ERROR if failed */
+    int uselect_read(USOCKET s, struct timeval *timeout, sys_call_error_fun fun);
+
+/* returns number of sockets ready to recv if there is data pending in network connection 
+		(s is changed and contains result of FD_ISSET)
+   returns 0 if timeout
+   returns U_SOCKET_ERROR if failed */
+	int uselect_read_arr(U_SSET *s, int maxfd, struct timeval *timeout, sys_call_error_fun fun);
+
+/* retrieves the last socket error description */
+    const char *usocket_error_translator();
+
+/*  when connect has failed, utry_connect_again checks if it is reasonable to reconnect 
+    returns 1 if it is reasonable, zero if it is not */
+    int utry_connect_again();
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

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

@@ -0,0 +1,57 @@
+/*
+ * File:  usystem.c
+ * Copyright (C) 2008 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+#include "common/u/usystem.h"
+#include "common/errdbg/d_printf.h"
+
+/* returns 0 if succeeded
+   returns 1 if failed */
+int uUname(U_UTSNAME* s, sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    BOOL res, bIsWow64 = FALSE;
+    OSVERSIONINFOEX osvi;
+    LPFN_ISWOW64PROCESS fnIsWow64Process;
+ 
+    ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
+
+    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
+    
+    if((res = GetVersionEx ((OSVERSIONINFO *) &osvi)) == 0)
+    {
+        sys_call_error("GetVersionEX");
+        return 1;
+    }
+
+    sprintf(s->sysname, "Windows");
+    sprintf(s->release, "%lu.%lu.%lu", osvi.dwMajorVersion, osvi.dwMinorVersion, osvi.dwBuildNumber);
+    sprintf(s->version, "SP%u.%u", osvi.wServicePackMajor, osvi.wServicePackMinor);
+    
+    fnIsWow64Process = (LPFN_ISWOW64PROCESS)GetProcAddress(GetModuleHandle("kernel32"),"IsWow64Process");
+ 
+    if (NULL != fnIsWow64Process)
+    {
+        if (!fnIsWow64Process(GetCurrentProcess(),&bIsWow64))
+        {
+            sys_call_error("IsWow64Process");
+            return 1;
+        }
+    }
+
+    sprintf(s->machine, bIsWow64 ? "x64" : "x86");
+
+    return 0;
+#else
+    int res = 0;
+    res = uname(s);
+    if(-1 == res)
+    {
+        sys_call_error("uname");
+        return 1;
+    }
+    return 0;
+#endif
+}
+

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

@@ -0,0 +1,46 @@
+/*
+ * File:  usystem.h
+ * Copyright (C) 2008 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+#ifndef _USYSTEM_H
+#define _USYSTEM_H
+
+#include "common/u/u.h"
+
+
+#ifdef _WIN32
+
+typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL);
+
+typedef struct {
+    char sysname[128];
+    char release[128];
+    char version[128];
+    char machine[128];
+} U_UTSNAME;
+
+#else
+
+#include <sys/utsname.h>
+typedef struct utsname U_UTSNAME;
+
+#endif /* _WIN32 */
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+/* returns 0 if succeeded
+   returns 1 if failed */
+    int uUname(U_UTSNAME* s, sys_call_error_fun fun);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* _USYSTEM_H */

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

@@ -0,0 +1,259 @@
+/*
+ * File:  uthread.cpp
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#include "common/errdbg/d_printf.h"
+#include "common/u/uthread.h"
+
+
+uResVal uCreateThread(
+  uThreadProc proc,
+  uArg        arg,
+  UTHANDLE    *id,
+  uStackSize  size,
+  USECURITY_ATTRIBUTES* sa,
+  sys_call_error_fun fun
+)
+{
+#ifdef _WIN32
+    DWORD threadId = 0;
+    HANDLE hndl = CreateThread(
+                      sa,
+                      size,
+                      proc,
+                      arg,
+                      0,
+                      &threadId);
+    *id = hndl;
+    if (hndl != 0) return 0;
+    else
+    {
+       sys_call_error("CreateThread");
+       return (void*)-1; 
+    }
+#else
+    pthread_attr_t attr;
+    int set_res = 0;
+    set_res = pthread_attr_init(&attr);
+    if (set_res != 0)
+    {  
+       sys_call_error("pthread_attr_init");
+       return set_res;
+    }
+    set_res = pthread_attr_setstacksize(&attr, size);
+    if (set_res != 0) 
+    {
+       sys_call_error("pthread_attr_setstacksize"); 
+       return set_res;
+    }
+    pthread_t threadId = 0;
+    int     res = pthread_create(
+                      &threadId,
+                      &attr,
+                      proc,
+                      arg);
+
+    if (res != 0) sys_call_error("pthread_create");
+
+    *id = threadId;
+    return res;
+#endif
+}
+
+#ifdef _WIN32
+#else
+static void _suspend_thread_signal_handler(int signo, siginfo_t *info, void *cxt)
+{
+	sys_call_error_fun fun=NULL;
+    d_printf1("suspend\n");
+    int sig = 0;
+    sigset_t signalSet;
+    if (sigfillset(&signalSet) == -1) sys_call_error("sigfillset");
+    if (sigwait(&signalSet, &sig) != 0) sys_call_error("sigwait");
+}
+static void _resume_thread_signal_handler(int signo, siginfo_t *info, void *cxt)
+{
+    d_printf1("resume\n");
+}
+#endif
+
+int uEnableSuspend(sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    return 0;
+#else
+    struct sigaction sigsegv_act;
+                                                                                                                             
+    memset(&sigsegv_act, '\0', sizeof(struct sigaction));
+    sigsegv_act.sa_sigaction = _suspend_thread_signal_handler;
+    sigsegv_act.sa_flags = SA_SIGINFO;
+    if (sigaction(SIGUSR1, &sigsegv_act, NULL) == -1)
+    {
+        sys_call_error("sigaction");
+        return 1;
+    }
+                                                                                                                             
+    memset(&sigsegv_act, '\0', sizeof(struct sigaction));
+    sigsegv_act.sa_sigaction = _resume_thread_signal_handler;
+    sigsegv_act.sa_flags = SA_SIGINFO;
+    if (sigaction(SIGUSR2, &sigsegv_act, NULL) == -1)
+    {
+        sys_call_error("sigaction");
+        return 1;
+    }
+
+    return 0;
+#endif
+}
+
+int uSuspendThread(UTHANDLE id, sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    if (SuspendThread(id) == -1)
+    {
+       sys_call_error("SuspendThread");
+       return 1;
+    }
+    else return 0;
+#else
+    int res = pthread_kill(id, SIGUSR1);
+    if (res != 0) sys_call_error("pthread_kill");
+    return res;
+#endif
+}
+
+int uResumeThread(UTHANDLE id, sys_call_error_fun fun) 
+{
+#ifdef _WIN32
+    if (ResumeThread(id) == -1)
+    {
+       sys_call_error("ResumeThread");
+       return 1;
+    }
+    else return 0;
+#else
+    int res = pthread_kill(id, SIGUSR2); 
+    if (res != 0) sys_call_error("pthread_kill");
+    return res;
+#endif
+}
+
+int uTerminateThread(UTHANDLE id, sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    BOOL res = 0;
+    res = TerminateThread(id, 0);
+    if (res == 0)
+    {
+        sys_call_error("TerminateThread");
+        return 1;
+    }
+
+    return 0;
+#else
+    int res = pthread_cancel(id);
+    if (res != 0) sys_call_error("pthread_cancel");
+    return res;
+#endif
+}
+
+int uCloseThreadHandle(UTHANDLE id, sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    BOOL res = 0;
+    res = CloseHandle(id);
+    if (res == 0)
+    {
+        sys_call_error("CloseHandle");
+        return 1;
+    }
+
+    return 0;
+#else
+    return 0;
+#endif
+}
+
+int uThreadJoin(UTHANDLE id, sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    DWORD res = 0;
+    do {
+        res = WaitForSingleObjectEx(id, INFINITE, TRUE);
+    } while (res == WAIT_IO_COMPLETION);
+    if (res == WAIT_FAILED) sys_call_error("WaitForSingleObject");
+
+    if (res != WAIT_OBJECT_0) return 1;
+    else return 0;
+#else
+    int res = pthread_join(id, NULL);
+    if (res != 0) sys_call_error("pthread_join");
+    return res;
+#endif
+}
+
+void uExitThread(int rc, sys_call_error_fun fun) 
+{
+#ifdef _WIN32
+	ExitThread(rc);
+#else
+    pthread_exit((void*)rc); 
+#endif
+}
+
+UTHANDLE uGetCurrentThread(sys_call_error_fun fun)
+{
+#ifdef _WIN32
+	UTHANDLE result;
+
+	if (DuplicateHandle(GetCurrentProcess(),
+                        GetCurrentThread(),
+                        GetCurrentProcess(),
+                        &result,
+                        0,
+                        FALSE,
+                        DUPLICATE_SAME_ACCESS | DUPLICATE_CLOSE_SOURCE) == 0)
+       sys_call_error("DuplicateHandle");
+
+	return result;
+#else
+    return pthread_self();
+#endif
+}
+
+
+int uThreadBlockAllSignals(sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    return 0;
+#else
+    sigset_t new_sigset, old_sigset;
+    if (sigfillset(&new_sigset) == -1)
+    {
+      sys_call_error("sigfillset");
+      return -1;
+    }
+    if (pthread_sigmask(SIG_SETMASK, &new_sigset, &old_sigset) == -1)
+    {
+       sys_call_error("pthread_sigmask");
+       return -1;
+    }
+    return 0;
+#endif
+}
+
+/*
+int uTime()
+{
+#ifdef _WIN32
+    time_t t;
+    time(&t);
+    return t;
+#else
+    time_t t;
+    return time(&t);
+#endif
+}
+*/