Changeset 3205 for trunk/src

Timestamp:

Mar 23, 2000, 8:21:56 PM (25 years ago)

Author:

sandervl

Message:

wsock32\new update

Location:

trunk/src/wsock32

Files:

• asyncapi.cpp (deleted)
• new/asyncapi.cpp (modified) (9 diffs)
• new/asyncthread.cpp (modified) (10 diffs)
• new/asyncthread.h (modified) (4 diffs)
• new/wsa.cpp (modified) (6 diffs)
• new/wsock32.cpp (modified) (10 diffs)
• new/wsock32.h (modified) (4 diffs)
• new/wsock32exp.def (deleted)

trunk/src/wsock32/new/asyncapi.cpp

@@ -1 @@
-/* $Id: asyncapi.cpp,v 1.1 2000-03-22 20:01:04 sandervl Exp $ */
+/* $Id: asyncapi.cpp,v 1.2 2000-03-23 19:21:53 sandervl Exp $ */
 
 /*
@@ -7 +7 @@
  * Copyright (C) 2000 Sander van Leeuwen (sandervl@xs4all.nl)
  *
- * Based on Wine code: (dlls\winsock\async.c)
+ * Parts based on Wine code: (dlls\winsock\async.c)
  * (C) 1993,1994,1996,1997 John Brezak, Erik Bos, Alex Korobka.
  * (C) 1999 Marcus Meissner
@@ -17 +17 @@
 #include <os2wrap.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <odin.h>
@@ -152 +153 @@
                      (WPARAM)pThreadParm->hAsyncTaskHandle, lParam);
    }
-   RemoveFromQueue(pThreadParm); 
 }
 //******************************************************************************
@@ -161 +161 @@
 {
   PASYNCTHREADPARM pThreadParm;
-  LHANDLE          hHost = 0;
-  LPSTR            tempname;
-  LPSTR            tempproto;
-  LPSTR            tempaddr;
+  LHANDLE          hAsyncRequest = 0;
+  LPSTR            tempname  = 0;
+  LPSTR            tempproto = 0;
+  LPSTR            tempaddr  = 0;
 
    if(!fWSAInitialized)
@@ -193 +193 @@
                 return 0;
         }
+        memset(pThreadParm, 0, sizeof(*pThreadParm));
         pThreadParm->request= requesttype;
         pThreadParm->hwnd   = hwnd;
@@ -283 +284 @@
                 break;
         }
-        return (LHANDLE)QueueAsyncJob(WSAsyncThreadProc, pThreadParm);
+        hAsyncRequest = (LHANDLE)QueueAsyncJob(WSAsyncThreadProc, pThreadParm);
+        if(hAsyncRequest == 0) {
+                free(pThreadParm);
+                if(tempname)    free(tempname);
+                if(tempaddr)    free(tempaddr);
+                if(tempproto)   free(tempproto);
+
+                dprintf(("WSAAsyncRequest: QueueAsyncJob failure!"));
+                DebugInt3();
+                WSASetLastError(WSAEFAULT);
+                return 0;
+        }
+        return hAsyncRequest;
    }
    return 0;
@@ -377 +390 @@
 //******************************************************************************
 //******************************************************************************
+void AsyncNotifyEvent(PASYNCTHREADPARM pThreadParm, ULONG event, ULONG socket_error)
+{
+   pThreadParm->u.asyncselect.lEventsPending &= ~event;
+
+   event = WSAMAKESELECTREPLY(event, socket_error);
+
+   PostMessageA(pThreadParm->hwnd, pThreadParm->msg, (WPARAM)pThreadParm->u.asyncselect.s, 
+               (LPARAM)event);
+}
+//******************************************************************************
+#define  nr(i)          ((i != -1) ? 1 : 0)
+#define  ready(i)       ((i != -1) && (sockets[i] != -1))
+//******************************************************************************
+void ASYNCCNV WSAsyncSelectThreadProc(void *pparm)
+{
+ PASYNCTHREADPARM pThreadParm = (PASYNCTHREADPARM)pparm;
+ SOCKET           sockets[3];
+ SOCKET           s = pThreadParm->u.asyncselect.s;
+ int              noread, nowrite, noexcept, state, sockoptlen, sockoptval;
+ int              tmp, i, lEventsPending, ret, bytesread;
+  
+   while(TRUE)
+   {
+asyncloopstart:
+        i         = 0;
+        noread    = nowrite = noexcept = -1;
+
+        //break if user cancelled request
+        if(pThreadParm->u.asyncselect.lEvents == 0) {
+                break;
+        }
+
+        lEventsPending = pThreadParm->u.asyncselect.lEventsPending;
+        //block if no events are pending
+        if(lEventsPending == 0)
+        {
+                //wait for events to be enabled
+                pThreadParm->u.asyncselect.asyncSem->wait();
+                //reset event semaphore
+                pThreadParm->u.asyncselect.asyncSem->reset();
+                continue;
+        }
+
+        if(lEventsPending & (FD_READ | FD_CLOSE | FD_ACCEPT)) {
+                noread = i++;
+                sockets[noread] = s;
+        }
+        if(lEventsPending & (FD_WRITE | FD_CONNECT)) {
+                nowrite = i++;
+                sockets[nowrite] = s;
+        }
+        if(lEventsPending & FD_OOB) {
+                noexcept = i++;
+                sockets[noexcept] = s;
+        }
+
+        dprintf(("WSAsyncSelectThreadProc %x wrs=%d, rds=%d, oos =%d, pending = %x", pThreadParm->u.asyncselect.s, noread, nowrite, noexcept, lEventsPending));
+
+        ret = select((int *)sockets, nr(noread), nr(nowrite), nr(noexcept), -1);
+        if(ret == SOCKET_ERROR) {
+                int selecterr = sock_errno();
+                switch(selecterr) 
+                {
+                case SOCEINTR:
+                        goto asyncloopstart;    //so_cancel was called
+
+                case SOCECONNRESET:
+                case SOCEPIPE:
+                        if(lEventsPending & FD_CLOSE)
+                                AsyncNotifyEvent(pThreadParm, FD_CLOSE, WSAECONNRESET);
+
+                        //remote connection broken (so can't receive data anymore)
+                        //but can still send
+                        pThreadParm->u.asyncselect.lEventsPending &= ~(FD_READ | FD_ACCEPT);
+                        goto asyncloopstart; 
+
+                case SOCEINVAL:
+                        if(lEventsPending & FD_CLOSE)
+                                AsyncNotifyEvent(pThreadParm, FD_CLOSE, selecterr);
+                        break;
+                default:
+                        dprintf(("WSAsyncSelectThreadProc: select SOCKET_ERROR %x", selecterr));
+                        break; //something bad happened
+                }
+                break;
+        }
+
+        if(ready(nowrite))
+        {
+                state = ioctl(s, FIOBSTATUS, (char *)&tmp, sizeof(tmp));
+
+                if(lEventsPending & FD_CONNECT) {
+                        if(state & SS_ISCONNECTED) {
+                                AsyncNotifyEvent(pThreadParm, FD_CONNECT, NO_ERROR);
+                        }
+                        else {
+                                sockoptlen = sizeof(int);
+
+                                ret = getsockopt(s, SOL_SOCKET, SO_ERROR,
+                                                 (char *) &sockoptval, &sockoptlen);
+                                if(sockoptval == (WSAECONNREFUSED-WSABASEERR)) {
+                                        AsyncNotifyEvent(pThreadParm, FD_CONNECT, WSAECONNREFUSED);
+                                }
+                        }  
+                }
+                else
+                if(!(state & SS_CANTSENDMORE) && (lEventsPending & FD_WRITE)) {
+                        AsyncNotifyEvent(pThreadParm, FD_WRITE, NO_ERROR);
+                }
+        }
+
+        if(ready(noread))
+        {
+                state = ioctl(s, FIONREAD, (CHAR *) &bytesread, sizeof(bytesread));
+                if(state == SOCKET_ERROR) {
+                        if(lEventsPending & FD_CLOSE) 
+                        {
+                                AsyncNotifyEvent(pThreadParm, FD_CLOSE, NO_ERROR);
+                                //remote connection broken (so can't receive data anymore)
+                                //but can still send
+                                pThreadParm->u.asyncselect.lEventsPending &= ~(FD_READ | FD_ACCEPT);
+                                continue;
+                        }
+                        else {
+                                dprintf(("WSAsyncSelectThreadProc: ioctl SOCKET_ERROR!"));
+                                break; //todo: correct???
+                        }
+                }
+                if(lEventsPending & FD_ACCEPT) 
+                {
+                        sockoptlen = sizeof(sockoptlen);
+
+                        ret = getsockopt(s, SOL_SOCKET, SO_OPTIONS,
+                                         (char *) &sockoptval, &sockoptlen);
+                        if(ret == SOCKET_ERROR) {
+                                dprintf(("WSAsyncSelectThreadProc: getsockopt SOCKET_ERROR!"));
+                                break;
+                        }
+                        if((sockoptval & SO_ACCEPTCONN) == SO_ACCEPTCONN) {
+                                AsyncNotifyEvent(pThreadParm, FD_ACCEPT, NO_ERROR);
+                        }
+                }
+                if((lEventsPending & FD_READ) && bytesread > 0) {
+                        AsyncNotifyEvent(pThreadParm, FD_READ, NO_ERROR);
+                }
+        }
+        if(ready(noexcept))
+        {
+                if(lEventsPending & FD_OOB) {
+                        AsyncNotifyEvent(pThreadParm, FD_OOB, NO_ERROR);
+                }
+        }
+        if((pThreadParm->u.asyncselect.lEventsPending & (FD_ACCEPT|FD_CLOSE|FD_CONNECT)) == 
+            (lEventsPending & (FD_ACCEPT|FD_CLOSE|FD_CONNECT))) {
+                DosSleep(10);
+        }
+   }
+   delete pThreadParm->u.asyncselect.asyncSem;
+}
+//******************************************************************************
+//******************************************************************************
 ODINFUNCTION4(int,WSAAsyncSelect,
               SOCKET,s,
@@ -383 +557 @@
               long,lEvent)
 {
-  return SOCKET_ERROR;
-}
-//******************************************************************************
-//******************************************************************************
+  PASYNCTHREADPARM pThreadParm;
+  int              nonblock = 1;
+  int              ret;
+
+   if(!fWSAInitialized)
+   {
+        WSASetLastError(WSANOTINITIALISED);
+        return SOCKET_ERROR;
+   }
+   else
+   if(WSAIsBlocking())
+   {
+        WSASetLastError(WSAEINPROGRESS);        // blocking call in progress
+        return SOCKET_ERROR;
+   }
+   else
+   if(hWnd && !IsWindow(hWnd))
+   {
+        WSASetLastError(WSAEINVAL);             // invalid parameter
+        return SOCKET_ERROR;
+   }
+   //Set socket to non-blocking mode
+   ret = ioctl(s, FIONBIO, (char *) &nonblock, sizeof(nonblock));
+   if(ret == SOCKET_ERROR) {
+        WSASetLastError(wsaErrno());
+        return SOCKET_ERROR;
+   }
+   if(FindAndSetAsyncEvent(s, hWnd, wMsg, lEvent) == TRUE) {
+        //found and changed active async event
+        WSASetLastError(NO_ERROR);
+        return NO_ERROR;
+   }
+   pThreadParm = (PASYNCTHREADPARM)malloc(sizeof(ASYNCTHREADPARM));
+   if(pThreadParm == NULL) {
+        dprintf(("WSAAsyncSelect: malloc failure!"));
+        DebugInt3();
+        WSASetLastError(WSAEFAULT);
+        return SOCKET_ERROR;
+   }
+   memset(pThreadParm, 0, sizeof(*pThreadParm));
+   pThreadParm->request= ASYNC_SELECT;
+   pThreadParm->hwnd   = hWnd;
+   pThreadParm->msg    = wMsg;
+   pThreadParm->u.asyncselect.lEvents        = lEvent;
+   pThreadParm->u.asyncselect.lEventsPending = lEvent;
+   pThreadParm->u.asyncselect.s              = s;
+   pThreadParm->u.asyncselect.asyncSem       = new VSemaphore;
+   if(pThreadParm->u.asyncselect.asyncSem == NULL) {
+        dprintf(("WSAAsyncSelect: VSemaphore alloc failure!"));
+        DebugInt3();
+        WSASetLastError(WSAEFAULT);
+        return SOCKET_ERROR;
+   }
+   if(QueueAsyncJob(WSAsyncSelectThreadProc, pThreadParm) == 0) {
+        delete pThreadParm->u.asyncselect.asyncSem;
+        free(pThreadParm);
+        dprintf(("WSAAsyncSelect: QueueAsyncJob failure!"));
+        DebugInt3();
+        WSASetLastError(WSAEFAULT);
+        return SOCKET_ERROR;
+   }
+   WSASetLastError(NO_ERROR);
+   return NO_ERROR;
+}
+//******************************************************************************
+//******************************************************************************

trunk/src/wsock32/new/asyncthread.cpp

@@ -1 @@
-/* $Id: asyncthread.cpp,v 1.1 2000-03-22 20:01:04 sandervl Exp $ */
+/* $Id: asyncthread.cpp,v 1.2 2000-03-23 19:21:53 sandervl Exp $ */
 
 /*
@@ -6 +6 @@
  * Copyright 2000 Sander van Leeuwen (sandervl@xs4all.nl)
  *
- * 
- * Not everything is thread safe 
+ * TODO: Not everything is 100% thread safe  (i.e. async parameter updates)
  *
  * Project Odin Software License can be found in LICENSE.TXT
+ *
  */
 #define INCL_BASE
 #include <os2wrap.h>
 #include <os2sel.h>
+#include <stdlib.h>
 #include <wprocess.h>
 #include <win32api.h>
@@ -35 +36 @@
   pThreadParm->asyncProc((PVOID)arg);
 
-  WSASetBlocking(TRUE, pThreadParm->hThread);
+//only for blocking hooks (currently not implemented
+////  if(pThreadParm->request == ASYNC_BLOCKHOOK)
+////    WSASetBlocking(FALSE, pThreadParm->hThread);
+
+  pThreadParm->fActive = FALSE;
+  RemoveFromQueue(pThreadParm); 
+  free((PVOID)pThreadParm);
 
   DosExit(EXIT_THREAD, 0);
@@ -41 +48 @@
 //******************************************************************************
 //******************************************************************************
-ULONG QueueAsyncJob(ASYNCTHREADPROC asyncproc, PASYNCTHREADPARM pThreadParm)
+ULONG QueueAsyncJob(ASYNCTHREADPROC asyncproc, PASYNCTHREADPARM pThreadParm, BOOL fSetBlocking)
 {
  APIRET rc;
@@ -55 +62 @@
    AddToQueue(pThreadParm);
 
-   WSASetBlocking(TRUE);
+   if(fSetBlocking) WSASetBlocking(TRUE);
 
    rc = DosCreateThread(&tid, AsyncThread, (ULONG)pThreadParm, CREATE_READY, 16384);
@@ -61 +68 @@
    {
         dprintf(("QueueAsyncJob: DosCreateThread failed with error %x", rc));
-        WSASetBlocking(FALSE);
+        if(fSetBlocking) WSASetBlocking(FALSE);
         RemoveFromQueue(pThreadParm);
         WSASetLastError(WSAEFAULT);
@@ -83 +90 @@
 void RemoveFromQueue(PASYNCTHREADPARM pThreadParm)
 {
- PASYNCTHREADPARM parm;
-
-   asyncThreadMutex.enter();
-   parm = threadList;
-
-   if(parm == pThreadParm) {
+ PASYNCTHREADPARM pThreadInfo;
+
+   asyncThreadMutex.enter();
+   pThreadInfo = threadList;
+
+   if(pThreadInfo == pThreadParm) {
         threadList = pThreadParm->next;
    }
    else {
-        while(parm->next) {
-                if(parm->next == pThreadParm) {
-                        parm->next = pThreadParm->next;
+        while(pThreadInfo->next) {
+                if(pThreadInfo->next == pThreadParm) {
+                        pThreadInfo->next = pThreadParm->next;
                         break;
                 }
-                parm = parm->next;
-        }
-        if(parm == NULL) {
+                pThreadInfo = pThreadInfo->next;
+        }
+        if(pThreadInfo == NULL) {
                 dprintf(("RemoveFromQueue: parm %x not found!!", pThreadParm));
                 DebugInt3();
@@ -111 +118 @@
 int WIN32API WSACancelAsyncRequest(LHANDLE hAsyncTaskHandle)
 {
- PASYNCTHREADPARM parm;
+ PASYNCTHREADPARM pThreadInfo;
  BOOL             found = FALSE;
 
    dprintf(("WSACancelAsyncRequest: cancel task %x", hAsyncTaskHandle));
    asyncThreadMutex.enter();
-   parm = threadList;
-
-   while(parm) {
-        if(parm->hAsyncTaskHandle == hAsyncTaskHandle) {
-                parm->fCancelled = TRUE;
+   pThreadInfo = threadList;
+
+   while(pThreadInfo) {
+        if(pThreadInfo->hAsyncTaskHandle == hAsyncTaskHandle) {
+                pThreadInfo->fCancelled = TRUE;
                 found = TRUE;
                 break;
         }
-        parm = parm->next;
+        pThreadInfo = pThreadInfo->next;
    }
    asyncThreadMutex.leave();
@@ -134 +141 @@
 }
 //******************************************************************************
+//Only to cancel blocking hooks
+//******************************************************************************
+int WIN32API WSACancelBlockingCall()
+{
+ HANDLE hThread = GetCurrentThread();
+
+   dprintf(("WSACancelBlockingCall"));
+#if 0
+   asyncThreadMutex.enter();
+   pThreadInfo = threadList;
+
+   while(pThreadInfo) {
+        if(pThreadInfo->hThread == hThread) {
+                pThreadInfo->fCancelled = TRUE;
+
+                if(pThreadInfo->request == ASYNC_BLOCKHOOK) {
+                        ret = so_cancel(pThreadInfo->blockedsocket);
+                }
+
+                found = TRUE;
+                break;
+        }
+        pThreadInfo = pThreadInfo->next;
+   }
+   asyncThreadMutex.leave();
+#endif
+   return SOCKET_ERROR;
+}
+//******************************************************************************
+//Assumes caller owns async thread mutex!
+//******************************************************************************
+static PASYNCTHREADPARM FindAsyncEvent(SOCKET s)
+{
+ PASYNCTHREADPARM pThreadInfo;
+
+   pThreadInfo = threadList;
+   while(pThreadInfo) {
+        if(pThreadInfo->u.asyncselect.s == s) {
+                return pThreadInfo;
+        }
+        pThreadInfo = pThreadInfo->next;
+   }
+   return NULL;
+}
+//******************************************************************************
+//******************************************************************************
+BOOL FindAndSetAsyncEvent(SOCKET s, HWND hwnd, int msg, ULONG lEvent)
+{
+ PASYNCTHREADPARM pThreadInfo;
+ 
+   asyncThreadMutex.enter();
+   pThreadInfo = FindAsyncEvent(s);
+   if(pThreadInfo) {
+        pThreadInfo->u.asyncselect.lEvents = lEvent;
+        pThreadInfo->hwnd                  = hwnd;
+        pThreadInfo->msg                   = msg;
+        //cancel pending select in async select thread (if any)
+        so_cancel(s);
+
+        //unblock async thread if it was waiting
+        pThreadInfo->u.asyncselect.asyncSem->post();
+   }
+   asyncThreadMutex.leave();
+   return(pThreadInfo != NULL);
+}
+//******************************************************************************
 //******************************************************************************
 void EnableAsyncEvent(SOCKET s, ULONG flags)
 {
+ PASYNCTHREADPARM pThreadInfo;
+
+   asyncThreadMutex.enter();
+   pThreadInfo = FindAsyncEvent(s);
+   if(pThreadInfo) {
+        pThreadInfo->u.asyncselect.lEventsPending |= (pThreadInfo->u.asyncselect.lEvents & flags);
+        //cancel pending select in async select thread (if any)
+        so_cancel(s);
+
+        //unblock async thread if it was waiting
+        pThreadInfo->u.asyncselect.asyncSem->post();
+   }
+   asyncThreadMutex.leave();
 }
 //******************************************************************************
@@ -142 +228 @@
 BOOL QueryAsyncEvent(SOCKET s, HWND *pHwnd, int *pMsg, ULONG *plEvent)
 {
-   return FALSE;
-}
-//******************************************************************************
-//******************************************************************************
+ PASYNCTHREADPARM pThreadInfo;
+
+   asyncThreadMutex.enter();
+   pThreadInfo = FindAsyncEvent(s);
+   if(pThreadInfo) {
+        *pHwnd   = pThreadInfo->hwnd;
+        *pMsg    = pThreadInfo->msg;
+        *plEvent = pThreadInfo->u.asyncselect.lEvents;
+   }
+   asyncThreadMutex.leave();
+   return(pThreadInfo != NULL);
+}
+//******************************************************************************
+//******************************************************************************

trunk/src/wsock32/new/asyncthread.h

@@ -1 @@
-/* $Id: asyncthread.h,v 1.1 2000-03-22 20:01:04 sandervl Exp $ */
+/* $Id: asyncthread.h,v 1.2 2000-03-23 19:21:54 sandervl Exp $ */
 
 /*
@@ -12 +12 @@
 
 #include <vmutex.h>
+#include <vsemaphore.h>
 
 #define ASYNCCNV        _Optlink
@@ -23 +24 @@
   ASYNC_GETPROTOBYNUMBER,
   ASYNC_GETSERVBYNAME,
-  ASYNC_GETSERVBYPORT
+  ASYNC_GETSERVBYPORT,
+  ASYNC_SELECT
 } ;
 
@@ -62 +64 @@
                         LPSTR   proto;
                 } getservbyport;
+                struct {
+                        VSemaphore *asyncSem;
+                        DWORD       lEvents;
+                        DWORD       lEventsPending;
+                        SOCKET      s;
+                } asyncselect;
         } u;
         _ASYNCTHREADPARM *next;
 } ASYNCTHREADPARM, *PASYNCTHREADPARM;
 
-ULONG QueueAsyncJob(ASYNCTHREADPROC asyncproc, PASYNCTHREADPARM pThreadParm);
+ULONG QueueAsyncJob(ASYNCTHREADPROC asyncproc, PASYNCTHREADPARM pThreadParm, BOOL fSetBlocking = FALSE);
 void  RemoveFromQueue(PASYNCTHREADPARM pThreadParm);
 
 void  EnableAsyncEvent(SOCKET s, ULONG flags);
 BOOL  QueryAsyncEvent(SOCKET s, HWND *pHwnd, int *pMsg, ULONG *plEvent);
+BOOL  FindAndSetAsyncEvent(SOCKET s, HWND hwnd, int msg, ULONG lEvent);
 
 #endif  //__ASYNCTHREAD_H__

trunk/src/wsock32/new/wsa.cpp

@@ -1 @@
-/* $Id: wsa.cpp,v 1.1 2000-03-22 20:01:07 sandervl Exp $ */
+/* $Id: wsa.cpp,v 1.2 2000-03-23 19:21:54 sandervl Exp $ */
 
 /*
@@ -32 +32 @@
 ODINDEBUGCHANNEL(WSOCK32-WSA)
 
+#ifndef winsockcleanupsockets
+// Exported by SO32DLL.  Used to close all open sockets.
+void _System winsockcleanupsockets(void);
+#endif
+
 static void WSASetBlocking(BOOL fBlock);
 
@@ -53 +58 @@
     if (!lpWSAData) return WSAEINVAL;
 
-    pwsi = WINSOCK_GetIData();
-    if( pwsi == NULL )
+    if(fWSAInitialized == FALSE) 
     {
         WINSOCK_CreateIData();
         pwsi = WINSOCK_GetIData();
-        if (!pwsi) return WSASYSNOTREADY;
-    }
+
+        sock_init();
+    }
+    else pwsi = WINSOCK_GetIData();
+
+    if (!pwsi) return WSASYSNOTREADY;
+
     pwsi->num_startup++;
     fWSAInitialized = TRUE;
@@ -75 +84 @@
     if( pwsi ) {
         if( --pwsi->num_startup > 0 ) return 0;
+
+        winsockcleanupsockets();
 
         fWSAInitialized = FALSE;
@@ -103 +114 @@
 //TODO: Implement this
 //******************************************************************************
-ODINFUNCTION0(int,WSACancelBlockingCall)
-{
-  LPWSINFO pwsi = WINSOCK_GetIData();
-
-  if( pwsi ) return 0;
-  return SOCKET_ERROR;
-}
-//******************************************************************************
-//******************************************************************************
 ODINFUNCTION0(int,WSAUnhookBlockingHook)
 {
@@ -126 +128 @@
 //******************************************************************************
 //******************************************************************************
-ODINFUNCTION0(BOOL,WSAIsBlocking)
+BOOL WIN32API WSAIsBlocking()
 {
     LPWSINFO pwsi = WINSOCK_GetIData();

trunk/src/wsock32/new/wsock32.cpp

@@ -1 @@
-/* $Id: wsock32.cpp,v 1.16 2000-03-22 20:01:08 sandervl Exp $ */
+/* $Id: wsock32.cpp,v 1.17 2000-03-23 19:21:54 sandervl Exp $ */
 
 /*
@@ -94 +94 @@
         goto tryagain;
     }
-    else {
+    if(iData == NULL) {
         dprintf(("WINSOCK_GetIData: couldn't find struct for thread %x", tid));
         DebugInt3();// should never happen!!!!!!!
@@ -145 +145 @@
 //******************************************************************************
 //******************************************************************************
-ODINPROCEDURE1(WSASetLastError,
-               int,iError)
+void WIN32API WSASetLastError(int iError)
 {
   // according to the docs, WSASetLastError() is just a call-through
   // to SetLastError()
+  if(iError) {
+        dprintf(("WSASetLastError %x", iError));
+  }
   SetLastError(iError);
 }
 //******************************************************************************
 //******************************************************************************
-ODINFUNCTION0(int,WSAGetLastError)
+int WIN32API WSAGetLastError()
 {
   return GetLastError();
@@ -232 +234 @@
 
    //Close WSAAsyncSelect thread if one was created for this socket
-   EnableAsyncEvent(s, 0L);
+   WSAAsyncSelect(s, 0, 0, 0);
    
    if(ret == SOCKET_ERROR) {
@@ -291 +293 @@
         return SOCKET_ERROR;
    } 
+   // clear high word (not used in OS/2's tcpip stack)
+   cmd = LOUSHORT(cmd);
+
    if(cmd != FIONBIO && cmd != FIONREAD && cmd != SIOCATMARK) {
         WSASetLastError(WSAEINVAL);
@@ -317 +322 @@
         }
    }
-   // clear high word (not used in OS/2's tcpip stack)
-   ret = ioctl(s, LOUSHORT(cmd), (char *)argp, sizeof(int));
+   ret = ioctl(s, cmd, (char *)argp, sizeof(int));
 
    // Map EOPNOTSUPP to EINVAL
@@ -878 +882 @@
                 break;
         default: 
+                dprintf(("setsockopt: unknown option %x", optname));
                 WSASetLastError(WSAENOPROTOOPT);
                 return SOCKET_ERROR;
@@ -892 +897 @@
         } 
         else {
+                dprintf(("setsockopt: unknown option %x", optname));
                 WSASetLastError(WSAENOPROTOOPT);
                 return SOCKET_ERROR;
@@ -974 +980 @@
                 break;
         default: 
+                dprintf(("getsockopt: unknown option %x", optname));
                 WSASetLastError(WSAENOPROTOOPT);
                 return SOCKET_ERROR;
@@ -988 +995 @@
         } 
         else {
+                dprintf(("getsockopt: unknown option %x", optname));
                 WSASetLastError(WSAENOPROTOOPT);
                 return SOCKET_ERROR;

trunk/src/wsock32/new/wsock32.h

@@ -1 @@
-/* $Id: wsock32.h,v 1.4 2000-03-22 20:01:09 sandervl Exp $ */
+/* $Id: wsock32.h,v 1.5 2000-03-23 19:21:55 sandervl Exp $ */
 
 /* WSOCK32.H--definitions & conversions for Odin's wsock32.dll.
@@ -24 +24 @@
 #include <sys\time.h>
 
+#include <odinwrap.h>
+
 /*
  * Socket state bits.
@@ -45 +47 @@
 //socketopt options
 #define SO_DONTLINGER   (u_int)(~SO_LINGER)
+
+#define WSAMAKESELECTREPLY(event,error)     MAKELONG(event,error)
 
 // WSAAsyncSelect flags
@@ -216 +220 @@
 void WIN32API WSASetLastError(int iError);
 int  WIN32API WSAGetLastError(void);
+int  WIN32API WSAAsyncSelect(SOCKET s, HWND hWnd, u_int wMsg, long lEvent);
 BOOL WIN32API WSAIsBlocking(void);
-int  WIN32API WSAAsyncSelect(SOCKET s, HWND hWnd, u_int wMsg, long lEvent);
 
 extern BOOL fWSAInitialized;