sedna 0.5.1 → 0.6.0

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

@@ -0,0 +1,83 @@
+/*
+ * File:  usem.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#ifndef _USEM_H
+#define _USEM_H
+
+#include "common/u/u.h"
+#include "common/u/usecurity.h"
+
+#ifdef _WIN32
+
+typedef HANDLE USemaphore;        // named semaphore (interprocess semaphore)
+typedef HANDLE *USemaphoreArr;    // named array of semaphores (interprocess semaphore)
+typedef HANDLE UUnnamedSemaphore; // unnamed semaphore (intraprocess semaphore)
+
+#else
+
+#include <sys/sem.h>
+#include <pthread.h>
+
+typedef int USemaphore;           // named semaphore (interprocess semaphore)
+typedef int USemaphoreArr;        // named array of semaphores (interprocess semaphore)
+typedef struct {
+    pthread_mutex_t  mutex;
+    pthread_cond_t   condition;
+    int              count;
+} UUnnamedSemaphore;              // unnamed semaphore (intraprocess semaphore)
+
+
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// functions return 0 on success
+// sa - Security Attributes for the new semaphore
+int USemaphoreCreate(USemaphore *sem, int init_value, int max_value, global_name name, USECURITY_ATTRIBUTES* sa, sys_call_error_fun fun);
+int USemaphoreOpen(USemaphore *sem, global_name name, sys_call_error_fun fun);
+int USemaphoreRelease(USemaphore sem, sys_call_error_fun fun);
+int USemaphoreClose(USemaphore sem, sys_call_error_fun fun);
+int USemaphoreDown(USemaphore sem, sys_call_error_fun fun);
+// down with timout
+// return values: 0 - success
+//                1 - falure
+//                2 - timeout
+int USemaphoreDownTimeout(USemaphore sem, unsigned int millisec, sys_call_error_fun fun);
+int USemaphoreUp(USemaphore sem, sys_call_error_fun fun);
+
+
+// sa - Security Attributes for the new semaphores
+int USemaphoreArrCreate(USemaphoreArr *sem, int size, const int *init_values, global_name name, USECURITY_ATTRIBUTES* sa, sys_call_error_fun fun);
+int USemaphoreArrOpen(USemaphoreArr *sem, int size, global_name name, sys_call_error_fun fun);
+int USemaphoreArrRelease(USemaphoreArr sem, int size, sys_call_error_fun fun);
+int USemaphoreArrClose(USemaphoreArr sem, int size, sys_call_error_fun fun);
+int USemaphoreArrDown(USemaphoreArr sem, int i, sys_call_error_fun fun);
+int USemaphoreArrDownTimeout(USemaphoreArr sem, int i, unsigned int millisec, sys_call_error_fun fun);
+int USemaphoreArrUp(USemaphoreArr sem, int i, sys_call_error_fun fun);
+
+
+
+// sa - Security Attributes for the new unnamed semaphore
+int UUnnamedSemaphoreCreate(UUnnamedSemaphore *sem, int init_value, USECURITY_ATTRIBUTES* sa, sys_call_error_fun fun);
+int UUnnamedSemaphoreRelease(UUnnamedSemaphore *sem, sys_call_error_fun fun);
+int UUnnamedSemaphoreDown(UUnnamedSemaphore *sem, sys_call_error_fun fun);
+// down with timout
+// return values: 0 - success
+//                1 - falure
+//                2 - timeout
+int UUnnamedSemaphoreDownTimeout(UUnnamedSemaphore *sem, unsigned int millisec, sys_call_error_fun fun);
+int UUnnamedSemaphoreUp(UUnnamedSemaphore *sem, sys_call_error_fun fun);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+

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

@@ -0,0 +1,222 @@
+/*
+ * File:  ushm.cpp
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+
+#include "common/u/ushm.h"
+#include "common/errdbg/d_printf.h"
+#include "common/u/ugnames.h"
+
+//#define RIGHTS		0666
+
+int uCreateShMem(UShMem *id, global_name name, int size, USECURITY_ATTRIBUTES* sa, sys_call_error_fun fun)
+#ifdef _WIN32
+{
+	char buf[128];
+	const char *wName = NULL;
+
+	wName = UWinIPCNameFromGlobalName(name,buf,128);
+
+    //printf("uCreateShMem name = %s\n", name);
+    *id = CreateFileMapping(INVALID_HANDLE_VALUE,
+                            sa,
+                            PAGE_READWRITE,
+                            0,
+                            size,
+                            wName
+                           );
+
+    //printf("CreateFileMapping %s\n", name);
+ 
+    if (*id == NULL) 
+    {
+        sys_call_error("CreateFileMapping");
+        return 1;
+    }
+
+    return 0;
+}
+#else
+{
+	key_t key = IPC_PRIVATE;
+	key = USys5IPCKeyFromGlobalName(name);
+
+    USECURITY_ATTRIBUTES shm_access_mode = U_SEDNA_SHMEM_ACCESS_PERMISSIONS_MASK;
+    if (sa) shm_access_mode = *sa;
+	*id = shmget(key, size, IPC_CREAT | IPC_EXCL | shm_access_mode);
+
+	if(*id == -1)
+	{
+        sys_call_error("shmget");
+		return 1;
+	}
+/* 
+	shmid_ds info;
+
+	info.shm_perm.uid = geteuid();
+	info.shm_perm.gid = getegid();
+	info.shm_perm.mode |= 0600;
+
+	if (shmctl(*id, IPC_SET, &info) == -1)
+	{
+		printf("uCreateShMem failed\n");
+		return 1;
+	}
+*/
+	return 0;
+}
+#endif
+
+int uOpenShMem(UShMem *id, global_name name, int size, sys_call_error_fun fun)
+#ifdef _WIN32
+{
+	char buf[128];
+	const char *wName = NULL;
+
+	wName = UWinIPCNameFromGlobalName(name,buf,128);
+
+    //printf("uOpenShMem name = %s\n", name);
+    *id = OpenFileMapping(FILE_MAP_ALL_ACCESS,				// Read/write permission. 
+                          FALSE,							// Do not inherit the name
+                          wName								// of the mapping object. 
+                         );
+
+    //printf("OpenFileMapping %s\n", name);
+ 
+    if (*id == NULL) 
+    {
+        sys_call_error("OpenFileMapping");
+        return 1;
+    }
+
+    return 0;
+}
+#else
+{
+	key_t key = IPC_PRIVATE;
+	key = USys5IPCKeyFromGlobalName(name);
+
+    //d_printf2("name = %d\n", name);
+	*(id) = shmget(key, size, 0);
+
+	if(*id == -1)
+	{
+        sys_call_error("shmget");
+		return 1;
+	}
+
+	return 0;
+}
+#endif
+
+int uReleaseShMem(UShMem 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
+{
+	if(id < 0)
+	{
+		d_printf1("uReleaseShMem failed\n");
+		//d_printf2("Error %d\n", perror(semget));
+		return 1;
+	}
+	else
+	{
+		if (shmctl(id, IPC_RMID, NULL) < 0)
+		{
+			// if shared memory already destroyed don't raise an error
+			if (errno == EINVAL) return 0;
+
+            sys_call_error("shmctl");
+			return 1;
+		}
+	}
+	return 0;
+}
+#endif
+
+int uCloseShMem(UShMem 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
+
+void* uAttachShMem(UShMem id, void *ptr, int size, sys_call_error_fun fun)
+#ifdef _WIN32
+{
+    void *res = NULL;
+    res = MapViewOfFileEx(id,						// Handle to mapping object. 
+                          FILE_MAP_ALL_ACCESS,		// Read/write permission. 
+                          0,
+                          0,
+                          size,
+                          ptr
+                         );
+
+    if (res == NULL) 
+    {
+        sys_call_error("MapViewOfFileEx");
+        return NULL;
+    }
+
+    return res;
+}
+#else
+{
+	void *res = NULL;
+	if ((int)(res = shmat(id, ptr, 0)) == -1)
+	{
+        sys_call_error("shmat");
+    	return NULL;
+	}
+	return res;
+}
+#endif
+
+int uDettachShMem(UShMem id, void * ptr, sys_call_error_fun fun)
+#ifdef _WIN32
+{
+     BOOL res = 0;
+     res = UnmapViewOfFile(ptr);
+    if (res == 0) 
+	{
+        sys_call_error("UnmapViewOfFile");
+		return 1;
+	}
+
+    return 0;
+}
+#else
+{
+	if(shmdt(ptr) < 0)
+	{
+        sys_call_error("shmdt");
+		return 1;
+	}
+	return 0;
+}
+#endif

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

@@ -0,0 +1,46 @@
+/*
+ * File:  ushm.h
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+#ifndef _USHMEM_H
+#define _USHMEM_H
+
+#include "common/u/u.h"
+#include "common/u/usecurity.h"
+
+#ifdef _WIN32
+
+typedef HANDLE UShMem;
+
+#else
+
+#include <sys/shm.h>
+
+typedef int UShMem;
+
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int uCreateShMem(UShMem *id, global_name name, int size, USECURITY_ATTRIBUTES* sa, sys_call_error_fun fun);
+
+int uOpenShMem(UShMem *id, global_name key, int size, sys_call_error_fun fun);
+
+int uReleaseShMem(UShMem id, sys_call_error_fun fun);
+
+int uCloseShMem(UShMem id, sys_call_error_fun fun);
+
+void* uAttachShMem(UShMem id, void *ptr, int size, sys_call_error_fun fun);
+
+int uDettachShMem(UShMem id, void * ptr, sys_call_error_fun fun);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

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

@@ -0,0 +1,541 @@
+/*
+ * File:  usocket.c
+ * Copyright (C) 2004 The Institute for System Programming of the Russian Academy of Sciences (ISP RAS)
+ */
+
+#ifndef _WIN32
+#include <netdb.h>
+#include <string.h>
+#include <sys/types.h>
+#include <netinet/tcp.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#else
+#include <Winsock2.h>
+#endif
+
+
+#include "common/u/usocket.h"
+#include "common/errdbg/d_printf.h"
+
+
+/* returns zero if succeeded
+   returns U_SOCKET_ERROR if failed */
+int uSocketInit(sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    WORD wVersionRequested;
+    WSADATA wsaData;
+    int err;
+
+    wVersionRequested = MAKEWORD(2, 2);
+
+    err = WSAStartup(wVersionRequested, &wsaData);
+    if (err != 0)
+    {
+        sys_call_error2("WSAStartup", &err);
+        return U_SOCKET_ERROR;
+    }
+
+    if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2)
+    {
+        if (WSACleanup() != 0) sys_call_error("WSACleanup");
+
+        return U_SOCKET_ERROR;
+    }
+
+    return 0;
+#else
+    return 0;
+#endif
+}
+
+/* returns zero if succeeded
+   returns U_SOCKET_ERROR if failed */
+int uSocketCleanup(sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    int res = WSACleanup();
+    if (res != 0) sys_call_error("WSACleanup");
+    return res;
+#else
+    return 0;
+#endif
+}
+
+
+/* returns U_INVALID_SOCKET if failed */
+USOCKET usocket(int af, int type, int protocol, sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    USOCKET res = socket(af, type, protocol);
+    if (res == INVALID_SOCKET) sys_call_error("socket");
+    return res;
+#else
+    int param = 1, res = 0;
+    int sockfd = socket(af, type, protocol);
+    if (sockfd == U_SOCKET_ERROR)
+    {
+        sys_call_error("socket");
+        return U_INVALID_SOCKET;
+    }
+
+#if defined(DARWIN)  /// Under DARWIN this is the only way not to get damn SIGPIPE!
+    res = setsockopt(sockfd, SOL_SOCKET, SO_NOSIGPIPE, &param, sizeof(int));
+    if(-1 == res)
+    {
+        sys_call_error("setsockopt");
+        close(sockfd);
+        return U_INVALID_SOCKET;
+    } 
+#endif /* DARWIN */
+
+    return sockfd;
+#endif
+}
+
+/* returns zero if succeeded
+   returns U_SOCKET_ERROR if failed */
+int ubind_tcp(USOCKET s, int port, sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    struct hostent *hp;
+    struct sockaddr_in ownaddr;
+
+    if ((hp = gethostbyname("0.0.0.0")) == NULL)
+    {
+        sys_call_error("gethostbyname");
+        return U_SOCKET_ERROR;
+    }
+
+    memset(&ownaddr, 0, sizeof ownaddr);
+    ownaddr.sin_family = AF_INET;
+    ownaddr.sin_port = htons(port);
+    memcpy(&ownaddr.sin_addr, hp->h_addr, hp->h_length);
+
+    if (bind(s, (struct sockaddr *) &ownaddr, sizeof ownaddr) != 0)
+    {
+        sys_call_error("bind");
+        return U_SOCKET_ERROR;
+    }
+    return 0;
+#else
+    struct hostent *hp;
+    struct sockaddr_in ownaddr;
+
+    int t_reuse = 1;
+    setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *) &t_reuse, sizeof(int));
+
+    if ((hp = gethostbyname("0.0.0.0")) == NULL)
+    {
+        sys_call_error("gethostbyname");
+        return U_SOCKET_ERROR;
+    }
+
+    memset(&ownaddr, 0, sizeof ownaddr);
+    ownaddr.sin_family = AF_INET;
+    ownaddr.sin_port = htons(port);
+    memcpy(&ownaddr.sin_addr, hp->h_addr, hp->h_length);
+
+    if (bind(s, (struct sockaddr *) &ownaddr, sizeof ownaddr) != 0)
+    {
+        sys_call_error("bind");
+        return U_SOCKET_ERROR;
+    }
+    return 0;
+#endif
+}
+
+/* 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)
+{
+#ifdef _WIN32
+    struct hostent *hp;
+    struct sockaddr_in ownaddr;
+
+    if ((hp = gethostbyname(hostname)) == NULL)
+    {
+        sys_call_error("gethostbyname");
+        return U_SOCKET_ERROR;
+    }
+
+    memset(&ownaddr, 0, sizeof ownaddr);
+    ownaddr.sin_family = AF_INET;
+    ownaddr.sin_port = htons(port);
+    memcpy(&ownaddr.sin_addr, hp->h_addr, hp->h_length);
+
+    if (connect(s, (struct sockaddr *) &ownaddr, sizeof ownaddr) != 0)
+    {
+       sys_call_error("connect");
+       return U_SOCKET_ERROR;
+    }
+    return 0;
+#else
+    struct hostent *hp;
+    struct sockaddr_in ownaddr;
+
+    
+    if ((hp = gethostbyname(hostname)) == NULL)
+    {
+        sys_call_error("gethostbyname");
+        return U_SOCKET_ERROR;
+    }
+
+    memset(&ownaddr, 0, sizeof ownaddr);
+    ownaddr.sin_family = AF_INET;
+    ownaddr.sin_port = htons(port);
+    memcpy(&ownaddr.sin_addr, hp->h_addr, hp->h_length);
+
+    if (connect(s, (struct sockaddr *) &ownaddr, sizeof ownaddr) != 0)
+    {
+        sys_call_error("connect");
+        return U_SOCKET_ERROR;
+    }
+    return 0;
+#endif
+}
+
+/* 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)
+{
+#ifdef _WIN32
+    int res = setsockopt(s, level, optname, (const char*)optval, optlen);
+    if (res == U_SOCKET_ERROR) sys_call_error("setsockopt");
+    return res;
+#else
+    int res = setsockopt(s, level, optname, optval, optlen);
+    if (res == U_SOCKET_ERROR) sys_call_error("setsockopt");
+    return res;
+#endif
+}
+
+/* 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)
+{
+#ifdef _WIN32
+    int res = getsockopt(s, level, optname, (char*)optval, &optlen);
+    if (res == U_SOCKET_ERROR) sys_call_error("getsockopt");
+    return res;
+#else
+    int res = getsockopt(s, level, optname, optval, &optlen);
+    if (res == U_SOCKET_ERROR) sys_call_error("getsockopt");
+    return res;
+#endif
+}
+
+/* returns zero if succeeded
+   returns U_SOCKET_ERROR if failed */
+int ulisten(USOCKET s, int backlog, sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    int res = listen(s, backlog);
+    if (res == U_SOCKET_ERROR) sys_call_error("listen");
+    return res;
+#else
+    int res = listen(s, backlog);
+    if (res == U_SOCKET_ERROR) sys_call_error("listen");
+    return res;
+#endif
+}
+
+/* returns U_INVALID_SOCKET if failed */
+USOCKET uaccept(USOCKET s, sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    struct sockaddr_in commonaddr;
+    int commonlen;
+    USOCKET socknew;
+    memset(&commonaddr, 0, sizeof commonaddr);
+    commonlen = sizeof commonaddr;
+    socknew = accept(s, (struct sockaddr *) &commonaddr, &commonlen);
+    if (socknew == INVALID_SOCKET)
+    {
+        sys_call_error("accept");
+        return U_INVALID_SOCKET;
+    }
+    return socknew;
+#else
+    int res = 0, param = 1; 
+    struct sockaddr_in commonaddr;
+    unsigned int commonlen;
+    USOCKET socknew;
+    memset(&commonaddr, 0, sizeof commonaddr);
+    commonlen = sizeof commonaddr;
+    socknew = accept(s, (struct sockaddr *) &commonaddr, &commonlen);
+    if (socknew == U_INVALID_SOCKET)
+    {
+        sys_call_error("accept");
+        return U_INVALID_SOCKET;
+    }
+#if defined(DARWIN)  /// Under DARWIN this is the only way not to get damn SIGPIPE!
+    res = setsockopt(socknew, SOL_SOCKET, SO_NOSIGPIPE, &param, sizeof(int));
+    if(-1 == res)
+    {
+        sys_call_error("setsockopt");
+        close(socknew);
+        return U_INVALID_SOCKET;
+    } 
+#endif /* DARWIN */
+    return socknew;
+#endif
+}
+
+/* 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)
+{
+#ifdef _WIN32
+    int res_len = recv(s, buf, len, 0);
+    if (res_len == U_SOCKET_ERROR) sys_call_error("recv");
+    return res_len;
+#else
+    int res_len;
+
+    while (1)
+    {
+        res_len = recv(s, buf, len, 0);
+
+        if (res_len == U_SOCKET_ERROR)
+            if (errno == EINTR)
+                continue;
+            else
+            {
+                sys_call_error("recv");
+                return U_SOCKET_ERROR;
+            }
+        else
+            return res_len;
+    }
+#endif
+}
+
+/* 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)
+{
+#ifdef _WIN32
+    int res_len;
+    res_len = send(s, buf, len, 0);
+    if (res_len == U_SOCKET_ERROR)
+    {
+        sys_call_error("send");
+        return U_SOCKET_ERROR;
+    }
+
+    return res_len;
+#else
+    int res_len;
+
+    while (1)
+    {
+        res_len = send(s, buf, len, U_MSG_NOSIGNAL);
+        if (res_len == U_SOCKET_ERROR)
+            if (errno == EINTR)
+                continue;
+            else
+            {
+                sys_call_error("send");
+                return U_SOCKET_ERROR;
+            }
+        else
+            return res_len;
+    }
+#endif
+}
+
+/* returns zero if succeeded
+   returns U_SOCKET_ERROR if failed */
+int uclose_socket(USOCKET s, sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    int res = closesocket(s);
+    if (res == U_SOCKET_ERROR) sys_call_error("closesocket");
+    return res;
+#else
+    int res = close(s);
+    if (res == U_SOCKET_ERROR) sys_call_error("close"); 
+    return res;
+#endif
+}
+
+/* returns zero if succeeded
+   returns U_SOCKET_ERROR if failed */
+int ushutdown_close_socket(USOCKET s, sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    int res = shutdown(s, SD_BOTH);
+    if (res != 0)
+    {
+       sys_call_error("shutdown");
+       return U_SOCKET_ERROR;
+    }
+    res = closesocket(s);
+    if (res == U_SOCKET_ERROR) sys_call_error("closesocket");  
+    return res;
+#else
+    int res = shutdown(s, SHUT_RDWR);
+    if (res != 0)
+    {
+       if(errno != ENOTCONN)
+       {
+           sys_call_error("shutdown");       
+           return U_SOCKET_ERROR;
+       }
+    }
+    res = close(s);
+    if (res == U_SOCKET_ERROR) sys_call_error("close"); 
+    return res;
+#endif
+}
+
+/* returns zero if succeeded
+   returns U_SOCKET_ERROR if failed */
+int ushutdown_socket(USOCKET s, sys_call_error_fun fun)
+{
+#ifdef _WIN32
+    int res = shutdown(s, SD_BOTH);
+    if (res != 0)
+    {
+       sys_call_error("shutdown");
+       return U_SOCKET_ERROR;
+    }
+    return res;
+#else
+    int res = shutdown(s, SHUT_RDWR);
+    if (res != 0)
+    {
+       if(errno != ENOTCONN)
+       {
+           sys_call_error("shutdown");       
+           return U_SOCKET_ERROR;
+       }
+    }
+    return res;
+#endif
+}
+
+/* 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)
+{
+#ifdef _WIN32
+    fd_set socks;
+    int res = 0;
+
+    FD_ZERO(&socks);
+    FD_SET(s, &socks);
+    res = select(1, &socks, (fd_set *) NULL, (fd_set *) NULL, timeout);
+    if (res == U_SOCKET_ERROR) sys_call_error("select");
+    return res;
+#else
+    fd_set socks;
+    int res = 0;
+
+    FD_ZERO(&socks);
+    FD_SET(s, &socks);
+
+    while (1)
+    {
+        res = select(s + 1, &socks, (fd_set *) NULL, (fd_set *) NULL, timeout);
+
+        if (res == U_SOCKET_ERROR)
+            if (errno == EINTR)
+                continue;
+            else
+            {
+                sys_call_error("select");
+                return U_SOCKET_ERROR;
+            }
+        else
+            return res;
+    }
+#endif
+}
+
+/* returns number of sockets ready to recv if there is data pending in network connection 
+		(s is changed and contains result)
+   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)
+{
+#ifdef _WIN32
+    int res = 0, i;
+
+    res = select(1, s, (fd_set *) NULL, (fd_set *) NULL, timeout);
+    if (res == U_SOCKET_ERROR) sys_call_error("select");
+
+    return res;
+#else
+	int res = 0, i;
+
+    while (1)
+    {
+        res = select(maxfd + 1, s, (fd_set *) NULL, (fd_set *) NULL, timeout);
+
+        if (res == U_SOCKET_ERROR)
+            if (errno == EINTR)
+			{
+                continue;
+            }
+            else
+            {
+                sys_call_error("select");
+                return U_SOCKET_ERROR;
+            }
+        else
+        	return res;
+    }
+
+#endif
+}
+
+/* retrieves the last socket error description */
+const char *usocket_error_translator()
+{
+#ifdef _WIN32
+    static char se_socket_error_buf[1024];
+    
+    if (!FormatMessage( 
+        FORMAT_MESSAGE_FROM_SYSTEM | 
+        FORMAT_MESSAGE_IGNORE_INSERTS,
+        NULL,
+        WSAGetLastError(),
+        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+        (LPTSTR)se_socket_error_buf,
+        1024,
+        NULL ))
+    {
+        strcpy(se_socket_error_buf, "unknown error");
+    }
+    return se_socket_error_buf;
+#else
+    return strerror(errno);
+#endif
+
+}
+
+/*  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 _WIN32
+    int sock_error;
+    sock_error = WSAGetLastError();
+    if ((sock_error == WSAENETUNREACH) || (sock_error == WSAETIMEDOUT))
+        return 1;
+    else
+        return 0;
+#else
+    int sock_error;
+    sock_error = errno;
+    if ((sock_error == ENETUNREACH) || (sock_error == ETIMEDOUT))
+        return 1;
+    else
+        return 0;
+#endif
+}