Changeset 3199 for trunk/src

Timestamp:

Mar 22, 2000, 9:07:30 PM (25 years ago)

Author:

sandervl

Message:

put back old wsock32

Location:

trunk/src/wsock32

Files:

• asyncthread.cpp (deleted)
• asyncthread.h (deleted)
• dbglocal.cpp (modified) (2 diffs)
• dbglocal.h (modified) (2 diffs)
• makefile (modified) (4 diffs)
• relaywin.cpp (added)
• relaywin.h (added)
• unknown.cpp (modified) (4 diffs)
• wsa.cpp (deleted)
• wsastruct.cpp (deleted)
• wsastruct.h (deleted)
• wsock32.cpp (modified) (18 diffs)
• wsock32.def (modified) (2 diffs)
• wsock32.h (modified) (3 diffs)

trunk/src/wsock32/dbglocal.cpp

@@ -1 @@
-/* $Id: dbglocal.cpp,v 1.2 2000-03-22 18:46:15 sandervl Exp $ */
+/* $Id: dbglocal.cpp,v 1.3 2000-03-22 20:07:20 sandervl Exp $ */
 
 /*
@@ -20 +20 @@
 {
 "initterm",
-"wsastruct",
+"relaywin",
 "wsock32",
 "unknown",
 "async",
-"asyncthread",
-"wsa"
+"asyncthread"
 };
 //******************************************************************************

trunk/src/wsock32/dbglocal.h

@@ -1 @@
-/* $Id: dbglocal.h,v 1.2 2000-03-22 18:46:16 sandervl Exp $ */
+/* $Id: dbglocal.h,v 1.3 2000-03-22 20:07:21 sandervl Exp $ */
 
 /*
@@ -20 +20 @@
 
 #define DBG_initterm       0
-#define DBG_wsastruct      1
+#define DBG_relaywin       1
 #define DBG_wsock32        2
 #define DBG_unknown        3
 #define DBG_async          4
 #define DBG_asyncthread    5
-#define DBG_wsa            6
-#define DBG_MAXFILES       7
+#define DBG_MAXFILES       6
 
 extern USHORT DbgEnabled[DBG_MAXFILES];

trunk/src/wsock32/makefile

@@ -1 @@
-# $Id: makefile,v 1.23 2000-03-22 18:46:16 sandervl Exp $
+# $Id: makefile,v 1.24 2000-03-22 20:07:22 sandervl Exp $
 
 #
@@ -26 +26 @@
 $(OBJDIR)\wsock32.obj \
 $(OBJDIR)\unknown.obj \
-$(OBJDIR)\wsa.obj \
-$(OBJDIR)\wsastruct.obj \
+$(OBJDIR)\relaywin.obj \
 $(OBJDIR)\wsock32rsrc.obj \
 $(OBJDIR)\initterm.obj \
-$(OBJDIR)\asyncapi.obj \
-$(OBJDIR)\asyncthread.obj \
+#$(OBJDIR)\async.obj \
+#$(OBJDIR)\asyncthread.obj \
 $(OBJDIR)\dbglocal.obj
 
@@ -37 +36 @@
 # Target name - name of the dll without extention and path.
 TARGET = wsock32
-
-CXXFLAGS = $(CXXFLAGS) -DNEW_ASYNC
 
 
@@ -64 +61 @@
 $(OBJS)
 $(TARGET).def
-tcp32dll.lib so32dll.lib
+pmwsock.lib
 $(PDWIN32_LIB)\kernel32.lib
 $(PDWIN32_LIB)/user32.lib

trunk/src/wsock32/unknown.cpp

@@ -1 @@
-/* $Id: unknown.cpp,v 1.5 2000-03-22 18:46:18 sandervl Exp $ */
+/* $Id: unknown.cpp,v 1.6 2000-03-22 20:07:25 sandervl Exp $ */
 
 /*
@@ -15 +15 @@
 #include <misc.h>
 #include <odinwrap.h>
-#include "wsock32.h"
 
 #define DBG_LOCALLOG    DBG_unknown
@@ -21 +20 @@
 
 ODINDEBUGCHANNEL(WSOCK32-UNKNOWN)
+
+/*****************************************************************************
+ * Prototypes & Types & Defines                                              *
+ *****************************************************************************/
+
+typedef int SOCKET;
+
+int _System rexec(char **, int, char *, char *, char *, int *);
+int _System rcmd (char **, int, const char *, const char *, const char *, int *);
+
 
 /*****************************************************************************
@@ -98 +107 @@
  *****************************************************************************/
 
-ODINFUNCTION4(int, WSARecvEx, SOCKET,    s,
+ODINFUNCTION4(int, OS2WSARecvEx, SOCKET,    s,
                                  char FAR*, buf,
                                  int,       len,

trunk/src/wsock32/wsock32.cpp

@@ -1 @@
-/* $Id: wsock32.cpp,v 1.22 2000-03-22 18:46:19 sandervl Exp $ */
+/* $Id: wsock32.cpp,v 1.23 2000-03-22 20:07:28 sandervl Exp $ */
 
 /*
@@ -8 +8 @@
  *
  * Copyright (C) 1999 Patrick Haller <phaller@gmx.net>
- * Copyright (C) 2000 Sander van Leeuwen (sandervl@xs4all.nl)
- *
- * Some parts based on Wine code: (dlls\winsock\socket.c)
- * (C) 1993,1994,1996,1997 John Brezak, Erik Bos, Alex Korobka.
  *
  */
@@ -21 +17 @@
  *            -> open issue: WSASetLastError / WSAGetLastError
  *               call SetLastError / GetLastError according to docs
- *
- * 2000/22/03 Complete rewrite -> got rid of pmwsock
  *
  * identical structures:
@@ -44 +38 @@
  *****************************************************************************/
 
-#define INCL_BASE
-#include <os2wrap.h>    //Odin32 OS/2 api wrappers
-
-#include <string.h>
+#include <pmwsock.h>
+#include <odin.h>
 #include <odinwrap.h>
 #include <os2sel.h>
+#include <misc.h>
+#include <wprocess.h>
+#include <heapstring.h>
+#include <win32wnd.h>
 #include <stdlib.h>
 #include <win32api.h>
-#include <win32wnd.h>
-#include <wprocess.h>
-#include <misc.h>
 
 #include "wsock32.h"
-#include "wsastruct.h"
-#include "asyncthread.h"
-
+#include "relaywin.h"
 #define DBG_LOCALLOG    DBG_wsock32
 #include "dbglocal.h"
@@ -71 +62 @@
  *****************************************************************************/
 
-static LPWSINFO lpFirstIData = NULL;
-
-//******************************************************************************
-//******************************************************************************
-LPWSINFO WINSOCK_GetIData(HANDLE tid)
-{
-    LPWSINFO iData;
-    BOOL     fCurrentThread = FALSE;
-
-    if(tid == CURRENT_THREAD) {
-        tid = GetCurrentThread();
-        fCurrentThread = TRUE;
+#define ERROR_SUCCESS 0
+
+
+static WSOCKTHREADDATA wstdFallthru; // for emergency only
+
+static HWND hwndRelay = NULL; // handle to our relay window
+
+BOOL fWSAInitialized = FALSE;
+
+/*****************************************************************************
+ * Prototypes                                                                *
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    : free memory when thread dies
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Tue, 1998/06/16 23:00]
+ *****************************************************************************/
+
+PWSOCKTHREADDATA iQueryWsockThreadData(void)
+{
+  struct _THDB*     pThreadDB = (struct _THDB*)GetThreadTHDB();
+  PWSOCKTHREADDATA pwstd;
+
+  // check for existing pointer
+  if (pThreadDB != NULL)
+  {
+    if (pThreadDB->pWsockData == NULL)
+    {
+      // allocate on demand + initialize
+      pwstd = (PWSOCKTHREADDATA)HEAP_malloc (sizeof(WSOCKTHREADDATA));
+      pThreadDB->pWsockData = (LPVOID)pwstd;
     }
-tryagain:
-    for (iData = lpFirstIData; iData; iData = iData->lpNextIData) {
-        if (iData->dwThisThread == tid)
-            break;
-    }
-    if(iData == NULL && fCurrentThread) {
-        WINSOCK_CreateIData();
-        fCurrentThread = FALSE; //just to prevent infinite loops
-        goto tryagain;
-    }
-    else {
-        dprintf(("WINSOCK_GetIData: couldn't find struct for thread %x", tid));
-        DebugInt3();// should never happen!!!!!!!
-    }
-    return iData;
-}
-//******************************************************************************
-//******************************************************************************
-BOOL WINSOCK_CreateIData(void)
-{
-    LPWSINFO iData;
-    
-    iData = (LPWSINFO)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WSINFO));
-    if (!iData)
-        return FALSE;
-    iData->dwThisThread = GetCurrentThread();
-    iData->lpNextIData = lpFirstIData;
-    lpFirstIData = iData;
-    return TRUE;
-}
-//******************************************************************************
-//******************************************************************************
-void WINSOCK_DeleteIData(void)
-{
-    LPWSINFO ppid, iData;
-
-    if (iData) {
-        ppid = lpFirstIData;
-        while(ppid) 
-        {
-                iData = ppid;
-                ppid  = ppid->lpNextIData;
-
-                if( iData->flags & WSI_BLOCKINGCALL )
-                        dprintf(("\tinside blocking call!\n"));
-
-                /* delete scratch buffers */
-
-                if(iData->he)   free(iData->he);
-                if(iData->se)   free(iData->se);
-                if(iData->pe)   free(iData->pe);
-
-        ////    if( iData->buffer ) SEGPTR_FREE(iData->buffer);
-        ////    if( iData->dbuffer ) SEGPTR_FREE(iData->dbuffer);
-
-                HeapFree(GetProcessHeap(), 0, iData);
-        }
-    }
-}
-//******************************************************************************
-//******************************************************************************
-ODINPROCEDURE1(WSASetLastError,
+    else
+      // use already allocated memory
+      pwstd = (PWSOCKTHREADDATA)pThreadDB->pWsockData;
+  }
+
+  if (pwstd == NULL)
+    pwstd = &wstdFallthru; // no memory and not allocated already
+
+  return pwstd;
+}
+
+
+#if 0
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+#define CASEERR2(a) case SOC##a: case a: return WSA##a;
+#define CASEERR1(a) case SOC##a: return WSA##a;
+
+int iTranslateSockErrToWSock(int iError)
+{
+  switch(iError)
+  {
+    CASEERR2(EINTR)
+    CASEERR2(EBADF)
+    CASEERR2(EACCES)
+    CASEERR2(EINVAL)
+    CASEERR2(EMFILE)
+
+    CASEERR1(EWOULDBLOCK)
+    CASEERR1(EINPROGRESS)
+    CASEERR1(EALREADY)
+    CASEERR1(ENOTSOCK)
+//  CASEERR1(EDESTADRREQ)
+    CASEERR1(EMSGSIZE)
+    CASEERR1(EPROTOTYPE)
+    CASEERR1(ENOPROTOOPT)
+    CASEERR1(EPROTONOSUPPORT)
+    CASEERR1(ESOCKTNOSUPPORT)
+    CASEERR1(EOPNOTSUPP)
+    CASEERR1(EPFNOSUPPORT)
+    CASEERR1(EAFNOSUPPORT)
+    CASEERR1(EADDRINUSE)
+    CASEERR1(EADDRNOTAVAIL)
+    CASEERR1(ENETDOWN)
+    CASEERR1(ENETUNREACH)
+    CASEERR1(ENETRESET)
+    CASEERR1(ECONNABORTED)
+    CASEERR1(ECONNRESET)
+    CASEERR1(ENOBUFS)
+    CASEERR1(EISCONN)
+    CASEERR1(ENOTCONN)
+    CASEERR1(ESHUTDOWN)
+    CASEERR1(ETOOMANYREFS)
+    CASEERR1(ETIMEDOUT)
+    CASEERR1(ECONNREFUSED)
+    CASEERR1(ELOOP)
+    CASEERR1(ENAMETOOLONG)
+    CASEERR1(EHOSTDOWN)
+    CASEERR1(EHOSTUNREACH)
+
+    CASEERR1(ENOTEMPTY)
+//    CASEERR(EPROCLIM)
+//    CASEERR(EUSERS)
+//    CASEERR(EDQUOT)
+//    CASEERR(ESTALE)
+//    CASEERR(EREMOTE)
+//    CASEERR(EDISCON)
+
+
+    default:
+      dprintf(("WSOCK32: Unknown error condition: %d\n",
+               iError));
+      return iError;
+  }
+}
+
+#endif
+
+
+
+
+
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+
+ODINPROCEDURE1(OS2WSASetLastError,
                int,iError)
 {
   // according to the docs, WSASetLastError() is just a call-through
   // to SetLastError()
+  WSASetLastError(iError);
   SetLastError(iError);
 }
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION0(int,WSAGetLastError)
-{
-  return GetLastError();
-}
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION2(int,OS2shutdown,
-              SOCKET,s,
-              int,how)
-{
- int ret;
-
-   if(!fWSAInitialized) {
-        WSASetLastError(WSANOTINITIALISED);
-        return SOCKET_ERROR;
-   } 
-   else 
-   if(WSAIsBlocking()) {
-        WSASetLastError(WSAEINPROGRESS);
-        return SOCKET_ERROR;
-   } 
-   ret = shutdown(s, how);
-   
-   if(ret == SOCKET_ERROR) {
-        WSASetLastError(wsaErrno());
-   }
-   else WSASetLastError(NO_ERROR);
-   return ret;
-}
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION3(SOCKET,OS2socket,
-              int,af,
-              int,type,
-              int,protocol)
-{
- SOCKET s;
-
-   if(!fWSAInitialized) {
-        WSASetLastError(WSANOTINITIALISED);
-        return SOCKET_ERROR;
-   } 
-   else 
-   if(WSAIsBlocking()) {
-        WSASetLastError(WSAEINPROGRESS);
-        return SOCKET_ERROR;
-   } 
-   s = socket(af, type, protocol);
-   
-   if(s == SOCKET_ERROR && sock_errno() == SOCEPFNOSUPPORT) {
-        //map SOCEPFNOSUPPORT to SOCEPFNOSUPPORT
-        WSASetLastError(SOCEPFNOSUPPORT);
-   }
-   else
-   if(s == SOCKET_ERROR) {
-        WSASetLastError(wsaErrno());
-   }
-   else WSASetLastError(NO_ERROR);
-   return s;
-}
-//******************************************************************************
-//******************************************************************************
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION0(int,OS2WSAGetLastError)
+{
+  // according to the docs, WSASetLastError() is just a call-through
+  // to SetLastError(). However, what can be implemented here?
+  return WSAGetLastError();
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION2(int,OS2__WSAFDIsSet,SOCKET, s,
+                                  fd_set*,fds)
+{
+  return (__WSAFDIsSet(s,fds));
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION3(SOCKET,OS2accept, SOCKET,           s,
+                                struct sockaddr *,addr,
+                                int *,            addrlen)
+{
+  return(accept(s,addr,addrlen));
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION3(int,OS2bind,
+              SOCKET ,s,
+              const struct sockaddr *,addr,
+              int, namelen)
+{
+  return(bind(s,addr,namelen));
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
 ODINFUNCTION1(int,OS2closesocket,SOCKET, s)
 {
- int ret;
-
-   if(!fWSAInitialized) {
-        WSASetLastError(WSANOTINITIALISED);
-        return SOCKET_ERROR;
-   } 
-   else 
-   if(WSAIsBlocking()) {
-        WSASetLastError(WSAEINPROGRESS);
-        return SOCKET_ERROR;
-   } 
-   ret = soclose(s);
-
-   //Close WSAAsyncSelect thread if one was created for this socket
-   EnableAsyncEvent(s, 0L);
-   
-   if(ret == SOCKET_ERROR) {
-        WSASetLastError(wsaErrno());
-   }
-   else WSASetLastError(NO_ERROR);
-   return ret;
-}
-//******************************************************************************
-//******************************************************************************
+  return(closesocket(s));
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
 ODINFUNCTION3(int,OS2connect,
               SOCKET, s,
@@ -247 +333 @@
               int, namelen)
 {
- int ret;
-
-   if(!fWSAInitialized) {
-        WSASetLastError(WSANOTINITIALISED);
-        return SOCKET_ERROR;
-   } 
-   else 
-   if(WSAIsBlocking()) {
-        WSASetLastError(WSAEINPROGRESS);
-        return SOCKET_ERROR;
-   } 
-   ret = connect(s, (sockaddr *)name, namelen);
-   // map BSD error codes
-   if(ret == SOCKET_ERROR) {
-        if(sock_errno() == SOCEINPROGRESS) {
-                WSASetLastError(WSAEWOULDBLOCK);
-        } 
-        else 
-        if (sock_errno() == SOCEOPNOTSUPP) {
-                WSASetLastError(WSAEINVAL);
-        }
-        else    WSASetLastError(wsaErrno());
-   }
-   else WSASetLastError(NO_ERROR);
-   return ret;
-}
-//******************************************************************************
-//******************************************************************************
+  return(connect(s,name,namelen));
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
 ODINFUNCTION3(int,OS2ioctlsocket,
               SOCKET,s,
@@ -280 +354 @@
               u_long *,argp)
 {
- int ret;
-
-   if(!fWSAInitialized) {
-        WSASetLastError(WSANOTINITIALISED);
-        return SOCKET_ERROR;
-   } 
-   else 
-   if(WSAIsBlocking()) {
-        WSASetLastError(WSAEINPROGRESS);
-        return SOCKET_ERROR;
-   } 
-   if(cmd != FIONBIO && cmd != FIONREAD && cmd != SIOCATMARK) {
-        WSASetLastError(WSAEINVAL);
-        return SOCKET_ERROR;
-   }
-
-   WSASetLastError(NO_ERROR);
-
-   //check if app want to set a socket, which has an outstanding async select,
-   //to blocking mode
-   if (cmd == FIONBIO) {
-        HWND  hwnd;
-        int   msg;
-        ULONG lEvent;
-
-        if(QueryAsyncEvent(s, &hwnd, &msg, &lEvent) == TRUE) {
-                if(*argp != 0) {
-                        //nothing to do; already non-blocking
-                        return NO_ERROR;
-                }
-                else {
-                        dprintf(("Trying to set socket to blocking mode while async select active -> return error!"));
-                        WSASetLastError(WSAEINVAL);
-                        return SOCKET_ERROR;
-                }
-        }
-   }
-   // clear high word (not used in OS/2's tcpip stack)
-   ret = ioctl(s, LOUSHORT(cmd), (char *)argp, sizeof(int));
-
-   // Map EOPNOTSUPP to EINVAL
-   if(ret == SOCKET_ERROR && sock_errno() == SOCEOPNOTSUPP)
-        WSASetLastError(WSAEINVAL);
-   else
-   if(ret == SOCKET_ERROR) {
-        WSASetLastError(wsaErrno());
-   }
-   else WSASetLastError(NO_ERROR);
-   return ret;
-}
-//******************************************************************************
-//******************************************************************************
+  return(ioctlsocket(s,cmd,argp));
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
 ODINFUNCTION3(int,OS2getpeername,
               SOCKET, s,
@@ -337 +375 @@
               int *, namelen)
 {
- int ret;
-
-   if(!fWSAInitialized) {
-        WSASetLastError(WSANOTINITIALISED);
-        return SOCKET_ERROR;
-   } 
-   else 
-   if(WSAIsBlocking()) {
-        WSASetLastError(WSAEINPROGRESS);
-        return SOCKET_ERROR;
-   } 
-   else 
-   if (namelen == NULL || *namelen < (int)sizeof(struct sockaddr_in)) {
-        WSASetLastError(WSAEFAULT);
-        return SOCKET_ERROR;
-   }
-   ret = getsockname(s, name, namelen);
-   if(ret == SOCKET_ERROR) {
-        WSASetLastError(wsaErrno());
-   }
-   else WSASetLastError(NO_ERROR);
-   return ret;
-}
-//******************************************************************************
-//******************************************************************************
+  return(getpeername(s,name,namelen));
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
 ODINFUNCTION3(int,OS2getsockname,
               SOCKET,s,
@@ -367 +396 @@
               int *, namelen)
 {
- int ret;
-
-   if(!fWSAInitialized) {
-        WSASetLastError(WSANOTINITIALISED);
-        return SOCKET_ERROR;
-   } 
-   else 
-   if(WSAIsBlocking()) {
-        WSASetLastError(WSAEINPROGRESS);
-        return SOCKET_ERROR;
-   } 
-   else 
-   if (namelen == NULL || *namelen < (int)sizeof(struct sockaddr_in)) {
-        WSASetLastError(WSAEFAULT);
-        return SOCKET_ERROR;
-   }
-   ret = getsockname(s, name, namelen);
-   if(ret == SOCKET_ERROR) {
-        WSASetLastError(wsaErrno());
-   }
-   else WSASetLastError(NO_ERROR);
-   return ret;
-}
-//******************************************************************************
-//******************************************************************************
+  return(getsockname(s,name,namelen));
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION5(int,OS2getsockopt,
+              SOCKET, s,
+              int, level,
+              int, optname,
+              char *, optval,
+              int *,optlen)
+{
+  return(getsockopt(s,
+                    level,
+                    optname,
+                    optval,
+                    optlen));
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
 ODINFUNCTION1(u_long,OS2htonl,
               u_long,hostlong)
@@ -397 +444 @@
   return(htonl(hostlong));
 }
-//******************************************************************************
-//******************************************************************************
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
 ODINFUNCTION1(u_short,OS2htons,
               u_short,hostshort)
@@ -404 +463 @@
   return(htons(hostshort));
 }
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION1(u_long,OS2ntohl,
-              u_long,netlong)
-{
-  return(ntohl(netlong));
-}
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION1(u_short,OS2ntohs,
-              u_short,netshort)
-{
-  return(ntohs(netshort));
-}
-//******************************************************************************
-//******************************************************************************
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
 ODINFUNCTION1(unsigned long,OS2inet_addr,
               const char *, cp)
@@ -426 +483 @@
            cp));
 
-  return (inet_addr((char *)cp));
-}
-//******************************************************************************
-//******************************************************************************
+  return (inet_addr(cp));
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
 ODINFUNCTION1(char *,OS2inet_ntoa,
               struct in_addr, in)
@@ -435 +504 @@
   return(inet_ntoa(in));
 }
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION3(SOCKET,OS2accept, SOCKET,           s,
-                                struct sockaddr *,addr,
-                                int *,            addrlen)
-{
- int   ret, msg;
- HWND  hwnd;
- ULONG lEvent;
-
-   if(!fWSAInitialized) {
-        WSASetLastError(WSANOTINITIALISED);
-        return SOCKET_ERROR;
-   } 
-   else 
-   if(WSAIsBlocking()) {
-        WSASetLastError(WSAEINPROGRESS);
-        return SOCKET_ERROR;
-   } 
-   else 
-   if ((addr != NULL) && (addrlen != NULL)) {
-        if (*addrlen < (int)sizeof(struct sockaddr_in)) {
-                WSASetLastError(WSAEFAULT);
-                return SOCKET_ERROR;
-        }
-   }
-   ret = accept(s, addr, addrlen);
-
-   if(ret != SOCKET_ERROR) {
-        //Enable FD_ACCEPT event flag if WSAAsyncSelect was called for this socket
-        EnableAsyncEvent(s, FD_ACCEPT);
-
-        //if this socket has an active async. select pending, then call WSAAsyncSelect
-        //with the same parameters for the new socket (see docs)
-        if(QueryAsyncEvent(s, &hwnd, &msg, &lEvent) == TRUE) {
-                if(WSAAsyncSelect(ret, hwnd, msg, lEvent) == SOCKET_ERROR) {
-                        ret = SOCKET_ERROR;
-                }
-        }
-   }
-   if(ret == SOCKET_ERROR) {
-        WSASetLastError(wsaErrno());
-   }
-   else WSASetLastError(NO_ERROR);
-   return ret;
-}
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION3(int,OS2bind,
-              SOCKET ,s,
-              const struct sockaddr *,addr,
-              int, namelen)
-{
- int ret;
-
-   if(!fWSAInitialized) {
-        WSASetLastError(WSANOTINITIALISED);
-        return SOCKET_ERROR;
-   } 
-   else 
-   if(WSAIsBlocking()) {
-        WSASetLastError(WSAEINPROGRESS);
-        return SOCKET_ERROR;
-   } 
-   else 
-   if(namelen < (int)sizeof(struct sockaddr_in)) {
-        WSASetLastError(WSAEFAULT);
-        return SOCKET_ERROR;
-   }
-   ret = bind(s, (struct sockaddr *)addr, namelen);
-
-   if(ret == SOCKET_ERROR) {
-        WSASetLastError(wsaErrno());
-   }
-   else WSASetLastError(NO_ERROR);
-   return ret;
-}
-//******************************************************************************
-//******************************************************************************
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
 ODINFUNCTION2(int,OS2listen,
               SOCKET, s,
               int, backlog)
 {
-   int ret, tmp, namelen;
-   struct sockaddr_in name;
-
-   if(!fWSAInitialized) {
-        WSASetLastError(WSANOTINITIALISED);
-        return SOCKET_ERROR;
-   } 
-   else 
-   if(WSAIsBlocking()) {
-        WSASetLastError(WSAEINPROGRESS);
-        return SOCKET_ERROR;
-   } 
-   namelen = sizeof(name);
-   ret = getsockname(s, (struct sockaddr *)&name, &namelen);
-   if (ret == 0) {
-        if (name.sin_port == 0 && name.sin_addr.s_addr == 0) {
-                // Socket is not bound
-                WSASetLastError(WSAEINVAL);
-                return SOCKET_ERROR;
-        } 
-        ret = ioctl(s, FIOBSTATUS, (char *)&tmp, sizeof(tmp)) &
-                   (SS_ISCONNECTING | SS_ISCONNECTED | SS_ISDISCONNECTING);
-        if(ret) {
-                // Socket is already connected
-                WSASetLastError(WSAEISCONN);
-                return SOCKET_ERROR;
-        }
-        ret = listen(s, backlog);
-        //todo: reset FD_ACCEPT bit? (wine seems to do this, but it's not documented)
-   }
-   if(ret == SOCKET_ERROR) {
-        WSASetLastError(wsaErrno());
-   }
-   else WSASetLastError(NO_ERROR);
-   return ret;
-}
-//******************************************************************************
-//******************************************************************************
+  return(listen(s,backlog));
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION1(u_long,OS2ntohl,
+              u_long,netlong)
+{
+  return(ntohl(netlong));
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION1(u_short,OS2ntohs,
+              u_short,netshort)
+{
+  return(ntohs(netshort));
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
 ODINFUNCTION4(int,OS2recv,
               SOCKET,s,
@@ -562 +582 @@
               int,flags)
 {
-   int ret;
-
-   if(!fWSAInitialized) {
-        WSASetLastError(WSANOTINITIALISED);
-        return SOCKET_ERROR;
-   } 
-   else 
-   if(WSAIsBlocking()) {
-        WSASetLastError(WSAEINPROGRESS);
-        return SOCKET_ERROR;
-   } 
-   ret = recv(s, buf, len, flags);
-
-   if(ret == SOCKET_ERROR) {
-        WSASetLastError(wsaErrno());
-   }
-   else WSASetLastError(NO_ERROR);
-
-   //Reset FD_READ event flagfor  WSAAsyncSelect thread if one was created for this socket
-   EnableAsyncEvent(s, FD_READ);
-   return ret;
-}
-//******************************************************************************
-//******************************************************************************
+  return(recv(s,
+              buf,
+              len,
+              flags));
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
 ODINFUNCTION6(int,OS2recvfrom,
               SOCKET,s,
@@ -594 +609 @@
               int *,fromlen)
 {
-   int ret;
-
-   if(!fWSAInitialized) {
-        WSASetLastError(WSANOTINITIALISED);
-        return SOCKET_ERROR;
-   } 
-   else 
-   if(WSAIsBlocking()) {
-        WSASetLastError(WSAEINPROGRESS);
-        return SOCKET_ERROR;
-   } 
-   else 
-   if(fromlen == NULL || *fromlen < (int)sizeof(struct sockaddr_in)) {
-        WSASetLastError(WSAEFAULT);
-        return SOCKET_ERROR;
-   }
-   ret = recvfrom(s, buf, len, flags, from, fromlen);
-
-   if(ret == SOCKET_ERROR) {
-        WSASetLastError(wsaErrno());
-   }
-   else WSASetLastError(NO_ERROR);
-
-   //Reset FD_READ event flagfor  WSAAsyncSelect thread if one was created for this socket
-   EnableAsyncEvent(s, FD_READ);
-   return ret;
-}
-//******************************************************************************
-//******************************************************************************
+
+  return(recvfrom(s,
+                buf,
+                len,
+                flags,
+                from,
+                fromlen));
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION5(int,OS2select,
+              int,nfds,
+              fd_set *,readfds,
+              fd_set *,writefds,
+              fd_set *,exceptfds,
+              const struct timeval *,timeout)
+{
+  return(select(nfds,
+                readfds,
+                writefds,
+                exceptfds,
+                timeout));
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
 ODINFUNCTION4(int,OS2send,
               SOCKET,s,
@@ -629 +664 @@
               int,flags)
 {
-   int ret;
-
-   if(!fWSAInitialized) {
-        WSASetLastError(WSANOTINITIALISED);
-        return SOCKET_ERROR;
-   } 
-   else 
-   if(WSAIsBlocking()) {
-        WSASetLastError(WSAEINPROGRESS);
-        return SOCKET_ERROR;
-   } 
-   ret = send(s, (char *)buf, len, flags);
-
-   if(ret == SOCKET_ERROR) {
-        WSASetLastError(wsaErrno());
-   }
-   else WSASetLastError(NO_ERROR);
-
-   //Reset FD_WRITE event flagfor  WSAAsyncSelect thread if one was created for this socket
-   EnableAsyncEvent(s, FD_WRITE);
-   return ret;
-}
-//******************************************************************************
-//******************************************************************************
+  return(send(s,
+              buf,
+              len,
+              flags));
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
 ODINFUNCTION6(int,OS2sendto,
               SOCKET,s,
@@ -661 +691 @@
               int,tolen)
 {
-   int ret;
-
-   if(!fWSAInitialized) {
-        WSASetLastError(WSANOTINITIALISED);
-        return SOCKET_ERROR;
-   } 
-   else 
-   if(WSAIsBlocking()) {
-        WSASetLastError(WSAEINPROGRESS);
-        return SOCKET_ERROR;
-   } 
-   else 
-   if(tolen < (int)sizeof(struct sockaddr_in)) {
-        WSASetLastError(WSAEFAULT);
-        return SOCKET_ERROR;
-   }
-   ret = sendto(s, (char *)buf, len, flags, (struct sockaddr *)to, tolen);
-
-   if(ret == SOCKET_ERROR) {
-        WSASetLastError(wsaErrno());
-   }
-   else WSASetLastError(NO_ERROR);
-
-   //Reset FD_WRITE event flagfor  WSAAsyncSelect thread if one was created for this socket
-   EnableAsyncEvent(s, FD_WRITE);
-   return ret;
-}
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION5(int,OS2select,
-              int,nfds,
-              ws_fd_set *,readfds,
-              ws_fd_set *,writefds,
-              ws_fd_set *,exceptfds,
-              const struct timeval *,timeout)
-{
- int ret, i, j;
- int *sockets, *socktmp;
- int nrread, nrwrite, nrexcept;
- ULONG ttimeout;
-
-   WSASetLastError(NO_ERROR);
-
-   if(!fWSAInitialized) {
-        WSASetLastError(WSANOTINITIALISED);
-        return SOCKET_ERROR;
-   } 
-   else 
-   if(WSAIsBlocking()) {
-        WSASetLastError(WSAEINPROGRESS);
-        return SOCKET_ERROR;
-   } 
-   else {
-        nrread = nrwrite = nrexcept = 0;
-        if(readfds) {
-                nrread += readfds->fd_count;
-        }
-        if(writefds) {
-                nrwrite += writefds->fd_count;
-        }
-        if(exceptfds) {
-                nrexcept += exceptfds->fd_count;
-        }
-        if(nrread + nrwrite + nrexcept  == 0) {
-                WSASetLastError(WSAEINVAL);
-                return SOCKET_ERROR;
-        }
-        if(timeout != NULL && (timeout->tv_sec < 0 || timeout->tv_usec < 0)) {
-                WSASetLastError(WSAEINVAL);
-                return SOCKET_ERROR;
-        }
-        if(timeout == NULL) {
-                ttimeout = -1L; // no timeout
-        } 
-        else    ttimeout = timeout->tv_sec * 1000 + timeout->tv_usec / 1000;
-        
-        sockets = (int *)malloc(sizeof(int) * (nrread+nrwrite+nrexcept));
-        if(readfds) {
-                memcpy(&sockets[0], readfds->fd_array, nrread * sizeof(SOCKET));
-        }
-        if(writefds) {
-                memcpy(&sockets[nrread], writefds->fd_array, nrwrite * sizeof(SOCKET));
-        }
-        if(exceptfds) {
-                memcpy(&sockets[nrread+nrwrite], exceptfds->fd_array, nrexcept * sizeof(SOCKET));
-        }
-
-        ret = select(sockets, nrread, nrwrite, nrexcept, ttimeout);
-
-        if(ret == SOCKET_ERROR) 
-        {
-                if(readfds != NULL)
-                        readfds->fd_count = 0;
-
-                if(writefds != NULL)
-                        writefds->fd_count = 0;
-
-                if(exceptfds != NULL)
-                        exceptfds->fd_count = 0;
-
-                WSASetLastError(wsaErrno());
-                free(sockets);
-                return SOCKET_ERROR;
-        } 
-
-        if(ret != 0) {
-                socktmp = sockets;
-                if(readfds != NULL) {
-                        for(i=0;i<nrread;i++) {
-                                if(socktmp[i] != -1) {
-                                        readfds->fd_array[j] = socktmp[i];
-                                }
-                        }
-                        readfds->fd_count = i;
-                        socktmp += nrread;
-                }
-
-                if(writefds != NULL) {
-                        for(i=0;i<nrwrite;i++) {
-                                if(socktmp[i] != -1) {
-                                        writefds->fd_array[j] = socktmp[i];
-                                }
-                        }
-                        writefds->fd_count = i;
-                        socktmp += nrwrite;
-                }
-                if(exceptfds != NULL) {
-                        for(i=0;i<nrexcept;i++) {
-                                if(socktmp[i] != -1) {
-                                        exceptfds->fd_array[j] = socktmp[i];
-                                }
-                        }
-                        exceptfds->fd_count = i;
-                }
-         } 
-        else {
-            if(readfds != NULL)
-               readfds->fd_count = 0;
-
-            if(writefds != NULL)
-               writefds->fd_count = 0;
-
-            if(exceptfds != NULL)
-               exceptfds->fd_count = 0;
-        }
-        free(sockets);
-   }
-   return ret;
-}
-//******************************************************************************
-//******************************************************************************
+  return(sendto(s,
+              buf,
+              len,
+              flags,
+              to,
+              tolen));
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
 ODINFUNCTION5(int,OS2setsockopt,
               SOCKET,s,
@@ -819 +719 @@
               int,optlen)
 {
-  struct ws_linger *yy;
-  struct linger     xx;
-  int               ret;
-  ULONG             size;
-
-   if(!fWSAInitialized) {
-        WSASetLastError(WSANOTINITIALISED);
-        return SOCKET_ERROR;
-   } 
-   else 
-   if(WSAIsBlocking()) {
-        WSASetLastError(WSAEINPROGRESS);
-        return SOCKET_ERROR;
-   } 
-   if (level == SOL_SOCKET) {
-        switch(optname) {
-        case SO_DONTLINGER:
-        case SO_LINGER:
-                if(optlen < (int)sizeof(ws_linger)) {
-                        WSASetLastError(WSAEFAULT);
-                        return SOCKET_ERROR;
-                }
-                yy = (struct ws_linger *)optval;
-                xx.l_onoff  = (optname == SO_DONTLINGER) ? !yy->l_onoff : yy->l_onoff;
-                xx.l_linger = yy->l_linger;
-
-                ret = setsockopt(s,level,optname,(char *)&xx, sizeof(xx));
-                break;
-        case SO_SNDBUF:
-        case SO_RCVBUF:
-                if(optlen < (int)sizeof(int)) {
-                        WSASetLastError(WSAEFAULT);
-                        return SOCKET_ERROR;
-                }
-
-                size = *(ULONG *)optval;
+  struct Wlinger *yy;
+  struct linger xx;
+  int    rc;
+
+  if(level   == SOL_SOCKET &&
+     optname == SO_LINGER)
+  {
+    yy = (struct Wlinger *)optval;
+    xx.l_onoff = (int)yy->l_onoff;
+    xx.l_linger = (int)yy->l_linger;
+
+    rc = setsockopt(s,level,optname,(char *)&xx, sizeof(xx));
+  }
+  else 
+  if(level == SOL_SOCKET && (optname == SO_SNDBUF || optname == SO_RCVBUF)) {
+        ULONG size;
+
+        size = *(ULONG *)optval;
 tryagain:
-                ret = setsockopt(s,level,optname, (char *)&size, sizeof(ULONG));
-                if(ret == SOCKET_ERROR && size > 65535) {
-                        //SvL: Limit send & receive buffer length to 64k
-                        //     (only happens with 16 bits tcpip stack?)
-                        size = 65000;
-                        goto tryagain;
-                }
-                break;
-
-        case SO_BROADCAST:
-        case SO_DEBUG:
-        case SO_KEEPALIVE:
-        case SO_DONTROUTE:
-        case SO_OOBINLINE:
-        case SO_REUSEADDR:
-                if(optlen < (int)sizeof(int)) {
-                        WSASetLastError(WSAEFAULT);
-                        return SOCKET_ERROR;
-                }
-                ret = setsockopt(s, level, optname, (char *)optval, optlen);
-                break;
-        default: 
-                WSASetLastError(WSAENOPROTOOPT);
-                return SOCKET_ERROR;
-        } 
-   }
-   else 
-   if(level == IPPROTO_TCP) {
-        if(optname == TCP_NODELAY) {
-                if(optlen < (int)sizeof(int)) {
-                        WSASetLastError(WSAEFAULT);
-                        return SOCKET_ERROR;
-                }
-                ret = setsockopt(s, level, optname, (char *)optval, optlen);
-        } 
-        else {
-                WSASetLastError(WSAENOPROTOOPT);
-                return SOCKET_ERROR;
-        }
-   } 
-   else {
-        WSASetLastError(WSAEINVAL);
-        return SOCKET_ERROR;
-   }
-
-   if(ret == SOCKET_ERROR) {
-        WSASetLastError(wsaErrno());
-   }
-   else WSASetLastError(NO_ERROR);
-   return ret;
-}
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION5(int,OS2getsockopt,
-              SOCKET, s,
-              int, level,
-              int, optname,
-              char *, optval,
-              int *,optlen)
-{
-  struct ws_linger *yy;
-  struct linger     xx;
-  int               ret;
-  int               size, options;
-
-   if(!fWSAInitialized) {
-        WSASetLastError(WSANOTINITIALISED);
-        return SOCKET_ERROR;
-   } 
-   else 
-   if(WSAIsBlocking()) {
-        WSASetLastError(WSAEINPROGRESS);
-        return SOCKET_ERROR;
-   } 
-   if (level == SOL_SOCKET) {
-        switch(optname) {
-        case SO_DONTLINGER:
-        case SO_LINGER:
-                if(optlen == NULL || *optlen < sizeof(ws_linger)) {
-                        WSASetLastError(WSAEFAULT);
-                        return SOCKET_ERROR;
-                }
-                size = sizeof(xx);
-                ret = getsockopt(s,level,optname,(char *)&xx, &size);
-                yy = (struct ws_linger *)optval;
-                yy->l_onoff  = (optname == SO_DONTLINGER) ? !xx.l_onoff : xx.l_onoff;
-                yy->l_linger = xx.l_linger;
-                *optlen = size;
-                break;
-
-        case SO_SNDBUF:
-        case SO_RCVBUF:
-        case SO_BROADCAST:
-        case SO_DEBUG:
-        case SO_KEEPALIVE:
-        case SO_DONTROUTE:
-        case SO_OOBINLINE:
-        case SO_REUSEADDR:
-        case SO_TYPE:
-                if(optlen == NULL || *optlen < sizeof(int)) {
-                        WSASetLastError(WSAEFAULT);
-                        return SOCKET_ERROR;
-                }
-                ret = getsockopt(s, level, optname, (char *)optval, optlen);
-                break;
-        case SO_ACCEPTCONN:
-                if(optlen == NULL || *optlen < sizeof(int)) {
-                        WSASetLastError(WSAEFAULT);
-                        return SOCKET_ERROR;
-                }
-                size = sizeof(options);
-                ret = getsockopt(s, SOL_SOCKET, SO_OPTIONS, (char *)&options, &size);
-                if(ret != SOCKET_ERROR) {
-                        *(BOOL *)optval = (options & SO_ACCEPTCONN) == SO_ACCEPTCONN;
-                        *optlen = sizeof(BOOL);
-                }
-                break;
-        default: 
-                WSASetLastError(WSAENOPROTOOPT);
-                return SOCKET_ERROR;
-        } 
-   }
-   else 
-   if(level == IPPROTO_TCP) {
-        if(optname == TCP_NODELAY) {
-                if(optlen == NULL || *optlen < sizeof(int)) {
-                        WSASetLastError(WSAEFAULT);
-                        return SOCKET_ERROR;
-                }
-                ret = getsockopt(s, level, optname, (char *)optval, optlen);
-        } 
-        else {
-                WSASetLastError(WSAENOPROTOOPT);
-                return SOCKET_ERROR;
-        }
-   } 
-   else {
-        WSASetLastError(WSAEINVAL);
-        return SOCKET_ERROR;
-   }
-
-   if(ret == SOCKET_ERROR) {
-        WSASetLastError(wsaErrno());
-   }
-   else WSASetLastError(NO_ERROR);
-   return ret;
-}
-//******************************************************************************
-//******************************************************************************
+        rc = setsockopt(s,level,optname, (char *)&size, sizeof(ULONG));
+        if(rc == SOCKET_ERROR && size > 65535) {
+                //SvL: Limit send & receive buffer length to 64k
+                //     (only happens with 16 bits tcpip stack?)
+                size = 65000;
+                goto tryagain;
+        }
+
+  }
+  else {
+    rc = setsockopt(s,level,optname,(char *)optval,optlen);
+  }
+
+  if (rc == SOCKET_ERROR)
+    //OS2WSASetLastError(iTranslateSockErrToWSock(sock_errno()));
+    OS2WSASetLastError(WSAEINVAL);
+  else
+    OS2WSASetLastError(ERROR_SUCCESS);
+
+  return rc;
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION2(int,OS2shutdown,
+              SOCKET,s,
+              int,how)
+{
+  return(shutdown(s,
+                  how));
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION3(SOCKET,OS2socket,
+              int,af,
+              int,type,
+              int,protocol)
+{
+  return(socket(af,
+                type,
+                protocol));
+}
+
+
 /* Database function prototypes */
-//******************************************************************************
-//******************************************************************************
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION3(struct Whostent *,OS2gethostbyaddr,
+              const char *,addr,
+              int,len,
+              int,type)
+{
+  WHOSTENT         *yy;
+  struct hostent   *xx;
+  PWSOCKTHREADDATA pwstd;
+
+  xx = gethostbyaddr((char *)addr,len,type);
+  //PH: we assume PMWSOCK sets WSASetLastError correctly!
+
+  if(xx == NULL)
+     return (WHOSTENT *)NULL;
+
+  // access current thread wsock data block
+  pwstd = iQueryWsockThreadData();
+
+  pwstd->whsnt.h_name      = xx->h_name;
+  pwstd->whsnt.h_aliases   = xx->h_aliases;
+  pwstd->whsnt.h_addrtype  = (short)xx->h_addrtype;
+  pwstd->whsnt.h_length    = (short)xx->h_length;
+  pwstd->whsnt.h_addr_list = xx->h_addr_list;
+
+  return &pwstd->whsnt;
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION1(struct Whostent *,OS2gethostbyname,
+              const char *,name)
+{
+  WHOSTENT         *yy;
+  struct hostent   *xx;
+  PWSOCKTHREADDATA pwstd;
+
+
+  xx = gethostbyname((char *)name);
+  //PH: we assume PMWSOCK sets WSASetLastError correctly!
+
+  if(xx == NULL)
+    return (WHOSTENT *)NULL;
+
+  // access current thread wsock data block
+  pwstd = iQueryWsockThreadData();
+
+  pwstd->whsnt.h_name      = xx->h_name;
+  pwstd->whsnt.h_aliases   = xx->h_aliases;
+  pwstd->whsnt.h_addrtype  = (short)xx->h_addrtype;
+  pwstd->whsnt.h_length    = (short)xx->h_length;
+  pwstd->whsnt.h_addr_list = xx->h_addr_list;
+
+  return &pwstd->whsnt;
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
 ODINFUNCTION2(int,OS2gethostname,
               char *,name,
               int,namelen)
 {
- int ret;
-
-   ret = gethostname(name, namelen);
-   if(ret == NULL) {
-        WSASetLastError(NO_ERROR);
-        return 0;
-   }
-   WSASetLastError((errno == EINVAL) ? WSAEFAULT : wsaErrno());
-   return SOCKET_ERROR;
-}
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION3(ws_hostent *,OS2gethostbyaddr,
+   //PH: we assume PMWSOCK sets WSASetLastError correctly!
+   return(gethostname(name,
+                     namelen));
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION2(struct Wservent *,OS2getservbyport,
+              int,              port,
+              const char *,     proto)
+{
+  struct servent   *xx;
+  PWSOCKTHREADDATA pwstd;
+
+  //PH: we assume PMWSOCK sets WSASetLastError correctly!
+  xx = getservbyport(port,(char *)proto);
+
+  if(xx == NULL)
+    return (WSERVENT *)NULL;
+
+  // access current thread wsock data block
+  pwstd = iQueryWsockThreadData();
+
+  pwstd->wsvnt.s_name    = xx->s_name;
+  pwstd->wsvnt.s_aliases = xx->s_aliases;
+  pwstd->wsvnt.s_port    = (short)xx->s_port;
+  pwstd->wsvnt.s_proto   = xx->s_proto;
+
+  return &pwstd->wsvnt;
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION2(struct Wservent *,OS2getservbyname,
+              const char *,     name,
+              const char *,     proto)
+{
+  WSERVENT         *yy;
+  struct servent   *xx;
+  PWSOCKTHREADDATA pwstd;
+
+
+  //PH: we assume PMWSOCK sets WSASetLastError correctly!
+  xx = getservbyname((char *)name,(char *)proto);
+
+  if(xx == NULL)
+    return (WSERVENT *)NULL;
+
+  // access current thread wsock data block
+  pwstd = iQueryWsockThreadData();
+
+  pwstd->wsvnt.s_name    = xx->s_name;
+  pwstd->wsvnt.s_aliases = xx->s_aliases;
+  pwstd->wsvnt.s_port    = (short)xx->s_port;
+  pwstd->wsvnt.s_proto   = xx->s_proto;
+
+  return &pwstd->wsvnt;
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION1(struct Wprotoent *,OS2getprotobynumber,
+              int,proto)
+{
+  struct protoent  *xx;
+  PWSOCKTHREADDATA pwstd;
+
+  //PH: we assume PMWSOCK sets WSASetLastError correctly!
+  xx = getprotobynumber(proto);
+
+  if(xx == NULL)
+    return (WPROTOENT *)NULL;
+
+  // access current thread wsock data block
+  pwstd = iQueryWsockThreadData();
+
+  pwstd->wptnt.p_name    = xx->p_name;
+  pwstd->wptnt.p_aliases = xx->p_aliases;
+  pwstd->wptnt.p_proto   = (short)xx->p_proto;
+
+  return &pwstd->wptnt;
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION1(struct Wprotoent *,OS2getprotobyname,
+              const char *,name)
+{
+  struct protoent  *xx;
+  PWSOCKTHREADDATA pwstd;
+
+  //PH: we assume PMWSOCK sets WSASetLastError correctly!
+  xx = getprotobyname((char *)name);
+
+  if(xx == NULL)
+    return (WPROTOENT *)NULL;
+
+  // access current thread wsock data block
+  pwstd = iQueryWsockThreadData();
+
+  pwstd->wptnt.p_name    = xx->p_name;
+  pwstd->wptnt.p_aliases = xx->p_aliases;
+  pwstd->wptnt.p_proto   = (short)xx->p_proto;
+
+  return &pwstd->wptnt;
+}
+
+
+
+/* Microsoft Windows Extension function prototypes */
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION2(int,OS2WSAStartup,
+              USHORT,wVersionRequired,
+              LPWSADATA,lpWSAData)
+{
+  fWSAInitialized = TRUE;
+  return(WSAStartup(wVersionRequired,
+                    lpWSAData));
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION0(int,OS2WSACleanup)
+{
+  fWSAInitialized = FALSE;
+  return(WSACleanup());
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION0(BOOL,OS2WSAIsBlocking)
+{
+  return WSAIsBlocking();
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION0(int,OS2WSAUnhookBlockingHook)
+{
+  return WSAUnhookBlockingHook();
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION1(PFN,OS2WSASetBlockingHook,
+              PFN,lpBlockFunc)
+{
+  return(WSASetBlockingHook(lpBlockFunc));
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION0(int,OS2WSACancelBlockingCall)
+{
+  return(WSACancelBlockingCall());
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION6(LHANDLE,OS2WSAAsyncGetServByName,
+              HWND,hWnd,
+              u_int,wMsg,
+              const char *,name,
+              const char *,proto,
+              char *,buf,
+              int,buflen)
+{
+  int   rc;
+  HWND  hwndOS2 = Win32ToOS2Handle(hWnd);
+  ULONG ulNewID;
+
+  if (hwndRelay == NULL) // already initialized ?
+    hwndRelay = RelayInitialize(hwndOS2);
+
+  // add entry to list, we need to store both our temp buffer and the apps buffer
+  ulNewID = RelayAlloc(hWnd,
+                       wMsg,
+                       ASYNCREQUEST_GETSERVBYNAME,
+                       FALSE,
+                       buf);
+
+  // call pmwsock function, will fill our temp buffer
+  rc = WSAAsyncGetServByName(hwndRelay,
+                              ulNewID,
+                              name,
+                              proto,
+                              buf,
+                              buflen);
+
+  // if an error occurs, free the allocated relay entry
+  if (rc == SOCKET_ERROR)
+    RelayFree(ulNewID);
+
+  return (rc);
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION6(LHANDLE,OS2WSAAsyncGetServByPort,
+              HWND,hWnd,
+              u_int,wMsg,
+              int,port,
+              const char *,proto,
+              char *,buf,
+              int,buflen)
+{
+  int   rc;
+  HWND  hwndOS2 = Win32ToOS2Handle(hWnd);
+  ULONG ulNewID;
+
+  if (hwndRelay == NULL) // already initialized ?
+    hwndRelay = RelayInitialize(hwndOS2);
+
+  // add entry to list, we need to store both our temp buffer and the apps buffer
+  ulNewID = RelayAlloc(hWnd,
+                       wMsg,
+                       ASYNCREQUEST_GETSERVBYPORT,
+                       FALSE,
+                       buf);
+
+  // call pmwsock function, will fill our temp buffer
+  rc = WSAAsyncGetServByPort(hwndRelay,
+                             ulNewID,
+                             port,
+                             proto,
+                             buf,
+                             buflen);
+
+  // if an error occurs, free the allocated relay entry
+  if (rc == SOCKET_ERROR)
+    RelayFree(ulNewID);
+
+  return rc;
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION5(LHANDLE,OS2WSAAsyncGetProtoByName,
+              HWND,hWnd,
+              u_int,wMsg,
+              const char *,name,
+              char *,buf,
+              int,buflen)
+{
+  int   rc;
+  HWND  hwndOS2 = Win32ToOS2Handle(hWnd);
+  ULONG ulNewID;
+
+  if (hwndRelay == NULL) // already initialized ?
+    hwndRelay = RelayInitialize(hwndOS2);
+
+  // add entry to list, we need to store both our temp buffer and the apps buffer
+  ulNewID = RelayAlloc(hWnd,
+                       wMsg,
+                       ASYNCREQUEST_GETPROTOBYNAME,
+                       FALSE,
+                       buf);
+
+  // call pmwsock function, will fill our temp buffer
+  rc = WSAAsyncGetProtoByName(hwndRelay,
+                              ulNewID,
+                              name,
+                              buf,
+                              buflen);
+
+  // if an error occurs, free the allocated relay entry
+  if (rc == SOCKET_ERROR)
+    RelayFree(ulNewID);
+
+  return (rc);
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION5(LHANDLE,OS2WSAAsyncGetProtoByNumber,
+              HWND,hWnd,
+              u_int,wMsg,
+              int,number,
+              char *,buf,
+              int,buflen)
+{
+  int   rc;
+  HWND  hwndOS2 = Win32ToOS2Handle(hWnd);
+  ULONG ulNewID;
+
+  if (hwndRelay == NULL) // already initialized ?
+    hwndRelay = RelayInitialize(hwndOS2);
+
+  // add entry to list, we need to store both our temp buffer and the apps buffer
+  ulNewID = RelayAlloc(hWnd,
+                       wMsg,
+                       ASYNCREQUEST_GETPROTOBYNUMBER,
+                       FALSE,
+                       buf);
+
+  // call pmwsock function, will fill our temp buffer
+  rc = WSAAsyncGetProtoByNumber(hwndRelay,
+                                ulNewID,
+                                number,
+                                buf,
+                                buflen);
+
+  // if an error occurs, free the allocated relay entry
+  if (rc == SOCKET_ERROR)
+    RelayFree(ulNewID);
+
+  return rc;
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION5(LHANDLE,OS2WSAAsyncGetHostByName,
+              HWND,hWnd,
+              u_int,wMsg,
+              const char *,name,
+              char *,buf,
+              int,buflen)
+{
+  int   rc;
+  HWND  hwndOS2 = Win32ToOS2Handle(hWnd);
+  ULONG ulNewID;
+
+  dprintf(("WSAAsyncGetHostByName %s", name));
+
+  if (hwndRelay == NULL) // already initialized ?
+    hwndRelay = RelayInitialize(hwndOS2);
+
+  // add entry to list, we need to store both our temp buffer and the apps buffer
+  ulNewID = RelayAlloc(hWnd,
+                       wMsg,
+                       ASYNCREQUEST_GETHOSTBYNAME,
+                       FALSE,
+                       (PVOID)buf, (PVOID)buflen);
+
+  // call pmwsock function, will fill our temp buffer
+  rc = WSAAsyncGetHostByName(hwndRelay,
+                             ulNewID,
+                             name,
+                             buf,
+                             buflen);
+
+  // if an error occurs, free the allocated relay entry
+  if (rc == SOCKET_ERROR)
+    RelayFree(ulNewID);
+
+  return rc;
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION7(LHANDLE,OS2WSAAsyncGetHostByAddr,
+              HWND,hWnd,
+              u_int,wMsg,
               const char *,addr,
               int,len,
-              int,type)
-{
-    LPWSINFO pwsi = WINSOCK_GetIData();
-
-    if( pwsi )
-    {
-        struct hostent* host;
-        if( (host = gethostbyaddr((char *)addr, len, type)) != NULL ) {
-                if( WS_dup_he(pwsi, host) ) {
-                        WSASetLastError(NO_ERROR);
-                        return pwsi->he;
-                }
-                else    WSASetLastError(WSAENOBUFS);
-        }
-        else    WSASetLastError((h_errno < 0) ? wsaErrno() : wsaHerrno());
-    }
-    else WSASetLastError(WSANOTINITIALISED);
-    return NULL;
-}
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION1(ws_hostent *,OS2gethostbyname,
-              const char *,name)
-{
-    LPWSINFO pwsi = WINSOCK_GetIData();
-
-    if( pwsi )
-    {
-        struct hostent*     host;
-        if( (host = gethostbyname((char *)name)) != NULL ) {
-                if( WS_dup_he(pwsi, host) ) {
-                        WSASetLastError(NO_ERROR);
-                        return pwsi->he;
-                }
-                else    WSASetLastError(WSAENOBUFS);
-        }
-        else    WSASetLastError((h_errno < 0) ? wsaErrno() : wsaHerrno());
-    }
-    else WSASetLastError(WSANOTINITIALISED);
-    return NULL;
-}
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION2(struct ws_servent *,OS2getservbyport,
-              int,              port,
-              const char *,     proto)
-{
-    LPWSINFO pwsi = WINSOCK_GetIData();
-
-    if( pwsi )
-    {
-        struct servent* serv;
-        if( (serv = getservbyport(port, pwsi->buffer)) != NULL ) {
-                if( WS_dup_se(pwsi, serv) ) {
-                        WSASetLastError(NO_ERROR);
-                        return pwsi->se;
-                }
-                else    WSASetLastError(WSAENOBUFS);
-        }
-        else    WSASetLastError(WSANO_DATA);
-    } 
-    else WSASetLastError(WSANOTINITIALISED);
-    return NULL;
-}
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION2(struct ws_servent *,OS2getservbyname,
-              const char *,     name,
-              const char *,     proto)
-{
-    LPWSINFO pwsi = WINSOCK_GetIData();
-
-    if( pwsi )
-    {
-        struct servent*     serv;
-        if( (serv = getservbyname(pwsi->buffer, pwsi->buffer)) != NULL ) {
-                if( WS_dup_se(pwsi, serv) ) {
-                        WSASetLastError(NO_ERROR);
-                        return pwsi->se;
-                }
-                else    WSASetLastError(WSAENOBUFS);
-        }
-        else    WSASetLastError(WSANO_DATA);
-    } 
-    else WSASetLastError(WSANOTINITIALISED);
-    return NULL;
-}
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION1(struct ws_protoent *,OS2getprotobynumber,
-              int,number)
-{
-    LPWSINFO pwsi = WINSOCK_GetIData();
-
-    if( pwsi )
-    {
-        struct protoent* proto;
-        if( (proto = getprotobynumber(number)) != NULL ) {
-                if( WS_dup_pe(pwsi, proto) ) {
-                        WSASetLastError(NO_ERROR);
-                        return pwsi->pe;
-                }
-                else    WSASetLastError(WSAENOBUFS);
-        }
-        else    WSASetLastError(WSANO_DATA);
-    }
-    else WSASetLastError(WSANOTINITIALISED);
-    return NULL;
-}
-//******************************************************************************
-//******************************************************************************
-ODINFUNCTION1(struct ws_protoent *,OS2getprotobyname,
-              const char *,name)
-{
-    LPWSINFO pwsi = WINSOCK_GetIData();
-
-    if( pwsi )
-    {
-        struct protoent * proto;
-        if( (proto = getprotobyname((char *)name)) != NULL ) {
-                if(WS_dup_pe(pwsi, proto)) {
-                        WSASetLastError(NO_ERROR);
-                        return pwsi->pe;
-                }
-                else    WSASetLastError(WSAENOBUFS);
-        }
-        else    WSASetLastError((h_errno < 0) ? wsaErrno() : wsaHerrno());
-    }
-    else WSASetLastError(WSANOTINITIALISED);
-    return NULL;
-}
-//******************************************************************************
-//******************************************************************************
+              int,type,
+              char *,buf,
+              int,buflen)
+{
+  int   rc;
+  HWND  hwndOS2 = Win32ToOS2Handle(hWnd);
+  ULONG ulNewID;
+
+  if (hwndRelay == NULL) // already initialized ?
+    hwndRelay = RelayInitialize(hwndOS2);
+
+  // add entry to list, we need to store both our temp buffer and the apps buffer
+  ulNewID = RelayAlloc(hWnd,
+                       wMsg,
+                       ASYNCREQUEST_GETHOSTBYADDR,
+                       FALSE,
+                       buf);
+
+  // call pmwsock function, will fill our temp buffer
+  rc = WSAAsyncGetHostByAddr(hwndRelay,
+                             ulNewID,
+                             addr,
+                             len,
+                             type,
+                             buf,
+                             buflen);
+
+  // if an error occurs, free the allocated relay entry
+  if (rc == SOCKET_ERROR)
+    RelayFree(ulNewID);
+
+  return (rc);
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION1(int,OS2WSACancelAsyncRequest,
+              LHANDLE,hAsyncTaskHandle)
+{
+  return(WSACancelAsyncRequest(hAsyncTaskHandle));
+}
+
+
+/*****************************************************************************
+ * Name      :
+ * Purpose   :
+ * Parameters:
+ * Variables :
+ * Result    :
+ * Remark    :
+ * Status    : UNTESTED STUB
+ *
+ * Author    : Patrick Haller [Thu, 1999/11/25 23:00]
+ *****************************************************************************/
+
+ODINFUNCTION4(int,OS2WSAAsyncSelect,
+              SOCKET,s,
+              HWND,hWnd,
+              u_int,wMsg,
+              long,lEvent)
+{
+  int   rc;
+//  int   iError;
+  HWND  hwndOS2 = Win32ToOS2Handle(hWnd);
+  ULONG ulNewID;
+
+  if (hwndRelay == NULL) // already initialized ?
+    hwndRelay = RelayInitialize(hwndOS2);
+
+  /* @@@PH: our source window doesn't seem to have an anchor block.
+            Docs suggest we've missed to call WinInitialize on the
+            caller thread.
+
+            Cause however is the Open32 handle is (of course!) invalid
+            in plain PM Window Manager! -> use DAPWSOCK
+
+            Unfortunately, DAPWSOCK calls WinQueryAnchorBlock(hOpen32), too.
+            So, we're stuck until I resolve hWnd to it's valid PM
+            counterpart.
+
+            new problem: we've ultimately got to use PostMessageA instead
+            anything else. => create invisible msg relay window:
+            - hMsg = registerMessage(hWnd, wMsg)
+            - call WSAAsyncSelect with object window handle
+            - overwrite hWnd relay for "same handles"
+   */
+
+  // add event to list or remove any list entry in case of WSAAsyncSelect(hwnd,0,0)
+  if ( (wMsg == 0) && (lEvent == 0) )
+  {
+    // remove entry from list
+    RelayFreeByHwnd(hWnd);
+  }
+  else
+    // add entry to list
+    ulNewID = RelayAlloc(hWnd,
+                         wMsg,
+                         ASYNCREQUEST_SELECT,
+                         FALSE); //SvL: allow multiple selects -> pmwsock should fail if it not allowed
+//                         TRUE);
+
+  rc = WSAAsyncSelect(s,
+                      hwndRelay,
+                      ulNewID,
+                      lEvent);
+
+  // if an error occurs, free the allocated relay entry
+  if (rc == SOCKET_ERROR)
+    RelayFree(ulNewID);
+
+  return (rc);
+}

trunk/src/wsock32/wsock32.def

@@ -1 @@
-; $Id: wsock32.def,v 1.16 2000-03-22 18:46:20 sandervl Exp $
+/* $Id: wsock32.def,v 1.17 2000-03-22 20:07:29 sandervl Exp $ */
 
 ;Created by BLAST for IBM's compiler
@@ -48 +48 @@
 ; ----------------------------
 
-   WSAAsyncSelect              = _WSAAsyncSelect@16                    @101
-   WSAAsyncGetHostByAddr       = _WSAAsyncGetHostByAddr@28             @102
-   WSAAsyncGetHostByName       = _WSAAsyncGetHostByName@20             @103
-   WSAAsyncGetProtoByNumber    = _WSAAsyncGetProtoByNumber@20          @104
-   WSAAsyncGetProtoByName      = _WSAAsyncGetProtoByName@20            @105
-   WSAAsyncGetServByPort       = _WSAAsyncGetServByPort@24             @106
-   WSAAsyncGetServByName       = _WSAAsyncGetServByName@24             @107
-   WSACancelAsyncRequest       = _WSACancelAsyncRequest@4              @108
-   WSASetBlockingHook          = _WSASetBlockingHook@4                 @109
-   WSAUnhookBlockingHook       = _WSAUnhookBlockingHook@0              @110
-   WSAGetLastError             = _WSAGetLastError@0                    @111
-   WSASetLastError             = _WSASetLastError@4                    @112
-   WSACancelBlockingCall       = _WSACancelBlockingCall@0              @113
-   WSAIsBlocking               = _WSAIsBlocking@0                      @114
-   WSAStartup                  = _WSAStartup@8                         @115
-   WSACleanup                  = _WSACleanup@0                         @116
-   __WSAFDIsSet                = ___WSAFDIsSet@8                       @151
+   WSAAsyncSelect              = _OS2WSAAsyncSelect@16                    @101
+   WSAAsyncGetHostByAddr       = _OS2WSAAsyncGetHostByAddr@28             @102
+   WSAAsyncGetHostByName       = _OS2WSAAsyncGetHostByName@20             @103
+   WSAAsyncGetProtoByNumber    = _OS2WSAAsyncGetProtoByNumber@20          @104
+   WSAAsyncGetProtoByName      = _OS2WSAAsyncGetProtoByName@20            @105
+   WSAAsyncGetServByPort       = _OS2WSAAsyncGetServByPort@24             @106
+   WSAAsyncGetServByName       = _OS2WSAAsyncGetServByName@24             @107
+   WSACancelAsyncRequest       = _OS2WSACancelAsyncRequest@4              @108
+   WSASetBlockingHook          = _OS2WSASetBlockingHook@4                 @109
+   WSAUnhookBlockingHook       = _OS2WSAUnhookBlockingHook@0              @110
+   WSAGetLastError             = _OS2WSAGetLastError@0                    @111
+   WSASetLastError             = _OS2WSASetLastError@4                    @112
+   WSACancelBlockingCall       = _OS2WSACancelBlockingCall@0              @113
+   WSAIsBlocking               = _OS2WSAIsBlocking@0                      @114
+   WSAStartup                  = _OS2WSAStartup@8                         @115
+   WSACleanup                  = _OS2WSACleanup@0                         @116
+   __WSAFDIsSet                = _OS2__WSAFDIsSet@8                       @151
 
    rcmd                        = _OS2rcmd@24                              @1102
    rexec                       = _OS2rexec@24                             @1103
-   WSARecvEx                   = _WSARecvEx@16                         @1107
+   WSARecvEx                   = _OS2WSARecvEx@16                         @1107
    s_perror                    = _OS2s_perror@8                           @1108
 

trunk/src/wsock32/wsock32.h

@@ -1 @@
-/* $Id: wsock32.h,v 1.11 2000-03-22 18:46:20 sandervl Exp $ */
+; $Id: wsock32.h,v 1.12 2000-03-22 20:07:30 sandervl Exp $
 
 /* WSOCK32.H--definitions & conversions for Odin's wsock32.dll.
@@ -16 +16 @@
 #define _WINSOCK32CONST_
 
-#include <sys\socket.h>
-#include <sys\ioctl.h>
-#include <netdb.h>
-#include <netinet\in.h>
-#include <netinet\tcp.h>
-#include <nerrno.h>
-#include <sys\time.h>
-
-/*
- * Socket state bits.
- */
-#define SS_NOFDREF              0x0001  /* no file table ref any more */
-#define SS_ISCONNECTED          0x0002  /* socket connected to a peer */
-#define SS_ISCONNECTING         0x0004  /* in process of connecting to peer */
-#define SS_ISDISCONNECTING      0x0008  /* in process of disconnecting */
-#define SS_CANTSENDMORE         0x0010  /* can't send more data to peer */
-#define SS_CANTRCVMORE          0x0020  /* can't receive more data from peer */
-#define SS_RCVATMARK            0x0040  /* at mark on input */
-
-#define SS_NBIO                 0x0100  /* non-blocking ops */
-#define SS_ASYNC                0x0200  /* async i/o notify */
-#define SS_ISCONFIRMING         0x0400  /* deciding to accept connection req */
-
-#define SS_INCOMP               0x0800  /* unaccepted, incomplete connection */
-#define SS_COMP                 0x1000  /* unaccepted, complete connection */
-#define SS_ISDISCONNECTED       0x2000  /* socket disconnected from peer */
-
-//socketopt options
-#define SO_DONTLINGER   (u_int)(~SO_LINGER)
-
-// WSAAsyncSelect flags
-#define FD_READ         0x01
-#define FD_WRITE        0x02
-#define FD_OOB          0x04
-#define FD_ACCEPT       0x08
-#define FD_CONNECT      0x10
-#define FD_CLOSE        0x20
-
-#define SOCKET_ERROR            -1
-#define NO_ERROR                0
-
-#define WSABASEERR              10000
-
-#define WSAEINTR                (WSABASEERR+4)
-#define WSAEBADF                (WSABASEERR+9)
-#define WSAEACCES               (WSABASEERR+13)
-#define WSAEFAULT               (WSABASEERR+14)
-#define WSAEINVAL               (WSABASEERR+22)
-#define WSAEMFILE               (WSABASEERR+24)
-
-#define WSAEWOULDBLOCK          (WSABASEERR+35)
-#define WSAEINPROGRESS          (WSABASEERR+36)
-#define WSAEALREADY             (WSABASEERR+37)
-#define WSAENOTSOCK             (WSABASEERR+38)
-#define WSAEDESTADDRREQ         (WSABASEERR+39)
-#define WSAEMSGSIZE             (WSABASEERR+40)
-#define WSAEPROTOTYPE           (WSABASEERR+41)
-#define WSAENOPROTOOPT          (WSABASEERR+42)
-#define WSAEPROTONOSUPPORT      (WSABASEERR+43)
-#define WSAESOCKTNOSUPPORT      (WSABASEERR+44)
-#define WSAEOPNOTSUPP           (WSABASEERR+45)
-#define WSAEPFNOSUPPORT         (WSABASEERR+46)
-#define WSAEAFNOSUPPORT         (WSABASEERR+47)
-#define WSAEADDRINUSE           (WSABASEERR+48)
-#define WSAEADDRNOTAVAIL        (WSABASEERR+49)
-#define WSAENETDOWN             (WSABASEERR+50)
-#define WSAENETUNREACH          (WSABASEERR+51)
-#define WSAENETRESET            (WSABASEERR+52)
-#define WSAECONNABORTED         (WSABASEERR+53)
-#define WSAECONNRESET           (WSABASEERR+54)
-#define WSAENOBUFS              (WSABASEERR+55)
-#define WSAEISCONN              (WSABASEERR+56)
-#define WSAENOTCONN             (WSABASEERR+57)
-#define WSAESHUTDOWN            (WSABASEERR+58)
-#define WSAETOOMANYREFS         (WSABASEERR+59)
-#define WSAETIMEDOUT            (WSABASEERR+60)
-#define WSAECONNREFUSED         (WSABASEERR+61)
-#define WSAELOOP                (WSABASEERR+62)
-#define WSAENAMETOOLONG         (WSABASEERR+63)
-#define WSAEHOSTDOWN            (WSABASEERR+64)
-#define WSAEHOSTUNREACH         (WSABASEERR+65)
-#define WSAENOTEMPTY            (WSABASEERR+66)
-#define WSAEPROCLIM             (WSABASEERR+67)
-#define WSAEUSERS               (WSABASEERR+68)
-#define WSAEDQUOT               (WSABASEERR+69)
-#define WSAESTALE               (WSABASEERR+70)
-#define WSAEREMOTE              (WSABASEERR+71)
-#define WSASYSNOTREADY          (WSABASEERR+91)
-#define WSAVERNOTSUPPORTED      (WSABASEERR+92)
-#define WSANOTINITIALISED       (WSABASEERR+93)
-#define WSAHOST_NOT_FOUND       (WSABASEERR+1001)
-#define WSATRY_AGAIN            (WSABASEERR+1002)
-#define WSANO_RECOVERY          (WSABASEERR+1003)
-#define WSANO_DATA              (WSABASEERR+1004)
-#define WSANO_ADDRESS           WSANO_DATA
-
-typedef u_int           SOCKET;
-
-#define FD_SETSIZE      64
-
-#pragma pack(1)
-
-#define WSADESCRIPTION_LEN      256
-#define WSASYS_STATUS_LEN       128
-
-typedef struct WSAData {
-        USHORT              wVersion;
-        USHORT              wHighVersion;
-        char                szDescription[WSADESCRIPTION_LEN+1];
-        char                szSystemStatus[WSASYS_STATUS_LEN+1];
-        unsigned short      iMaxSockets;
-        unsigned short      iMaxUdpDg;
-        char *              lpVendorInfo;
-} WSADATA;
-typedef WSADATA *PWSADATA;
-typedef WSADATA *LPWSADATA;
-
-typedef struct ws_fd_set {
-        u_int   fd_count;
-        SOCKET  fd_array[FD_SETSIZE];
-} _ws_fd_set;
 
 /*
  * Structure used for manipulating linger option.
  */
-typedef struct  ws_linger {
+struct  Wlinger {
         u_short l_onoff;                /* option on/off */
         u_short l_linger;               /* linger time */
-} _ws_linger;
+};
+
 
 /*
@@ -152 +32 @@
  */
 
-typedef struct ws_hostent
+struct  Whostent {
+        char     * h_name;           /* official name of host */
+        char     *  * h_aliases;  /* alias list */
+        short   h_addrtype;             /* host address type */
+        short   h_length;               /* length of address */
+        char     *  * h_addr_list; /* list of addresses */
+#define h_addr  h_addr_list[0]          /* address, for backward compat */
+};
+
+/*
+ * It is assumed here that a network number
+ * fits in 32 bits.
+ */
+struct  Wnetent {
+        char     * n_name;           /* official name of net */
+        char     *  * n_aliases;  /* alias list */
+        short   n_addrtype;             /* net address type */
+        u_long  n_net;                  /* network # */
+};
+typedef struct Whostent WHOSTENT;
+typedef WHOSTENT *PWHOSTENT;
+
+struct  Wservent {
+        char     * s_name;           /* official service name */
+        char     *  * s_aliases;  /* alias list */
+        short   s_port;                 /* port # */
+        char     * s_proto;          /* protocol to use */
+};
+typedef struct Wservent WSERVENT;
+typedef WSERVENT *PWSERVENT;
+
+struct  Wprotoent {
+        char     * p_name;           /* official protocol name */
+        char     *  * p_aliases;  /* alias list */
+        short   p_proto;                /* protocol # */
+};
+typedef struct Wprotoent WPROTOENT;
+typedef WPROTOENT *PWPROTOENT;
+
+typedef struct tagWsockThreadData
 {
-        char *  h_name;         /* official name of host */
-        char ** h_aliases;      /* alias list */
-        INT16   h_addrtype;     /* host address type */
-        INT16   h_length;       /* length of address */
-        char ** h_addr_list;    /* list of addresses from name server */
-} _ws_hostent;
+  int              dwLastError; // Get/SetLastError
+  struct Whostent  whsnt;       // database conversion buffers
+  struct Wservent  wsvnt;
+  struct Wprotoent wptnt;
+  struct Wnetent   wntnt;
+  struct Wlinger   wlinger;
+} WSOCKTHREADDATA, *PWSOCKTHREADDATA;
 
-typedef struct ws_protoent
-{
-        char *  p_name;         /* official protocol name */
-        char ** p_aliases;      /* alias list */
-        INT16   p_proto;        /* protocol # */
-} _ws_protoent;
+// internal prototype
+PWSOCKTHREADDATA iQueryWsockThreadData(void);
 
-typedef struct ws_servent 
-{
-        char *  s_name;         /* official service name */
-        char ** s_aliases;      /* alias list */
-        INT16   s_port;         /* port # */
-        char *  s_proto;        /* protocol to use */
-} _ws_servent;
-
-typedef struct ws_netent
-{
-        char *  n_name;         /* official name of net */
-        char ** n_aliases;      /* alias list */
-        INT16   n_addrtype;     /* net address type */
-        INT     n_net;          /* network # */
-} _ws_netent;
-
-#pragma pack()
-
-#define WS_MAX_SOCKETS_PER_PROCESS      128     /* reasonable guess */
-#define WS_MAX_UDP_DATAGRAM             1024
-
-#define WSI_BLOCKINGCALL        0x00000001      /* per-thread info flags */
-#define WSI_BLOCKINGHOOK        0x00000002      /* 32-bit callback */
-
-typedef struct _WSINFO
-{
-  DWORD                 dwThisThread;
-  struct _WSINFO       *lpNextIData;
-
-  unsigned              flags;
-  INT16                 num_startup;            /* reference counter */
-  INT16                 num_async_rq;
-  INT16                 last_free;              /* entry in the socket table */
-  USHORT                buflen;
-  char*                 buffer;                 /* allocated from char * heap */
-  struct ws_hostent     *he;
-  int                   helen;
-  struct ws_servent     *se;
-  int                   selen;
-  struct ws_protoent    *pe;
-  int                   pelen;
-  char*                 dbuffer;                /* buffer for dummies (32 bytes) */
-
-  DWORD                 blocking_hook;
-} WSINFO, *LPWSINFO;
-
-void WIN32API WSASetLastError(int iError);
-int  WIN32API WSAGetLastError(void);
-BOOL WIN32API WSAIsBlocking(void);
-int  WIN32API WSAAsyncSelect(SOCKET s, HWND hWnd, u_int wMsg, long lEvent);
 
 extern BOOL fWSAInitialized;
 
-UINT wsaErrno();
-UINT wsaHerrno();
+void WIN32API OS2WSASetLastError(int iError);
 
-#define CURRENT_THREAD -1
-void WSASetBlocking(BOOL fBlock, HANDLE tid = CURRENT_THREAD);
+int  WIN32API OS2WSAGetLastError(void);
 
-void WINSOCK_DeleteIData(void);
-BOOL WINSOCK_CreateIData(void);
-LPWSINFO WINSOCK_GetIData(HANDLE tid = CURRENT_THREAD);
+BOOL WIN32API OS2WSAIsBlocking(void);
 
 #endif  /* _WINSOCK32CONST_ */