Updated gsocket.c to current unix version, use gsockunx.h instead of gsockos2.h

Added gsockpm.c.
Hooked socket handling into main loop.


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@10242 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/os2/app.h

@@ -12,12 +12,16 @@
 #ifndef _WX_APP_H_
 #define _WX_APP_H_
 
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+
 #include "wx/event.h"
 #include "wx/icon.h"
 
 class WXDLLEXPORT wxFrame;
 class WXDLLEXPORT wxWindow;
-class WXDLLEXPORT wxApp ;
+class WXDLLEXPORT wxApp;
 class WXDLLEXPORT wxKeyEvent;
 class WXDLLEXPORT wxLog;
 
@@ -36,6 +40,7 @@ extern MRESULT EXPENTRY wxWndProc( HWND
                                   ,MPARAM
                                  );
 
+
 // Represents the application. Derive OnInit and declare
 // a new App object to start application
 class WXDLLEXPORT wxApp : public wxAppBase
@@ -76,6 +81,11 @@ public:
     void SetAuto3D(bool bFlag) { m_bAuto3D = bFlag; }
     bool GetAuto3D(void) const { return m_bAuto3D; }
 
+    int AddSocketHandler(int handle, int mask,
+                         void (*callback)(void*), void * gsock);
+    void RemoveSocketHandler(int handle);
+    void HandleSockets();
+
 protected:
     bool                            m_bShowOnInit;
     int                             m_nPrintMode; // wxPRINT_WINDOWS, wxPRINT_POSTSCRIPT
@@ -84,6 +94,13 @@ protected:
     //
     // PM-specific wxApp definitions */
     //
+private:
+    int m_maxSocketHandles;
+    int m_maxSocketNr;
+    int m_lastUsedHandle;
+    fd_set m_readfds, m_writefds;
+    void *m_sockCallbackInfo;
+
 public:
 
     // Implementation
@@ -98,13 +115,12 @@ public:
 
 public:
     int                             m_nCmdShow;
+    HMQ                             m_hMq;
 
 protected:
     bool                            m_bKeepGoing ;
 
     DECLARE_EVENT_TABLE()
-private:
-    HMQ                             m_hMq;
 };
 
 int WXDLLEXPORT wxEntry( int argc, char *argv[] );

include/wx/os2/gsockos2.h

@@ -1,105 +0,0 @@
-/* -------------------------------------------------------------------------
- * Project: GSocket (Generic Socket) for WX
- * Name:    gsockos2.h
- * Purpose: GSocket OS/2 header
- * CVSID:   $Id$
- * -------------------------------------------------------------------------
- */
-
-#ifndef __GSOCK_OS2_H
-#define __GSOCK_OS2_H
-
-#ifndef __GSOCKET_STANDALONE__
-#include "wx/setup.h"
-#endif
-
-#if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__)
-
-#ifndef __GSOCKET_STANDALONE__
-#include "wx/gsocket.h"
-#else
-#include "gsocket.h"
-#endif
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif /* __cplusplus */
-
-#define SIGPIPE 13
-
-/* Definition of GSocket */
-struct _GSocket
-{
-  int m_fd;
-  GAddress *m_local;
-  GAddress *m_peer;
-  GSocketError m_error;
-
-  int m_non_blocking;
-  int m_server;
-  int m_stream;
-  int m_oriented;
-  int m_establishing;
-  unsigned long m_timeout;
-
-  /* Callbacks */
-  GSocketEventFlags m_detected;
-  GSocketCallback m_cbacks[GSOCK_MAX_EVENT];
-  char *m_data[GSOCK_MAX_EVENT];
-
-  char *m_gui_dependent;
-};
-
-/* Definition of GAddress */
-struct _GAddress
-{
-  struct sockaddr *m_addr;
-  size_t m_len;
-
-  GAddressType m_family;
-  int m_realfamily;
-
-  GSocketError m_error;
-};
-
-/* Input / Output */
-
-GSocketError _GSocket_Input_Timeout(GSocket *socket);
-GSocketError _GSocket_Output_Timeout(GSocket *socket);
-int _GSocket_Recv_Stream(GSocket *socket, char *buffer, int size);
-int _GSocket_Recv_Dgram(GSocket *socket, char *buffer, int size);
-int _GSocket_Send_Stream(GSocket *socket, const char *buffer, int size);
-int _GSocket_Send_Dgram(GSocket *socket, const char *buffer, int size);
-
-/* Callbacks */
-
-void _GSocket_Enable(GSocket *socket, GSocketEvent event);
-void _GSocket_Disable(GSocket *socket, GSocketEvent event);
-void _GSocket_Detected_Read(GSocket *socket);
-void _GSocket_Detected_Write(GSocket *socket);
-
-void _GSocket_GUI_Init(GSocket *socket);
-void _GSocket_GUI_Destroy(GSocket *socket);
-void _GSocket_Enable_Events(GSocket *socket);
-void _GSocket_Disable_Events(GSocket *socket);
-void _GSocket_Install_Callback(GSocket *socket, GSocketEvent event);
-void _GSocket_Uninstall_Callback(GSocket *socket, GSocketEvent event);
-
-/* GAddress */
-
-GSocketError _GAddress_translate_from(GAddress *address,
-                                      struct sockaddr *addr, int len);
-GSocketError _GAddress_translate_to(GAddress *address,
-                                    struct sockaddr **addr, int *len);
-
-GSocketError _GAddress_Init_INET(GAddress *address);
-
-#ifdef __cplusplus
-}
-#endif  /* __cplusplus */
-
-#endif  /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */
-
-#endif  /* __GSOCK_UNX_H */
-

src/os2/app.cpp

@@ -37,6 +37,24 @@
 
 #include "wx/os2/private.h"
 
+#if defined(__VISAGECPP__) && __IBMCPP__ < 400
+#include <machine\endian.h>
+#include <ioctl.h>
+#include <select.h>
+#include <unistd.h>
+#else
+#include <sys\ioctl.h>
+#include <sys\select.h>
+#ifndef __EMX__
+#define select(a,b,c,d,e) bsdselect(a,b,c,d,e)
+int _System bsdselect(int,
+                      struct fd_set *,
+                      struct fd_set *,
+                      struct fd_set *,
+                      struct timeval *);
+#endif
+#endif
+
 #if wxUSE_THREADS
     #include "wx/thread.h"
 
@@ -100,6 +118,92 @@ MRESULT EXPENTRY wxFrameWndProc( HWND hWnd,ULONG message,MPARAM mp1,MPARAM mp2);
 // implementation
 // ===========================================================================
 
+// ---------------------------------------------------------------------------
+// helper struct and functions for socket handling
+// ---------------------------------------------------------------------------
+
+struct GsocketCallbackInfo{
+    void (*proc)(void *);
+    int type;
+    int handle;
+    void* gsock;
+};
+
+// These defines and wrapper functions are used here and in gsockpm.c
+#define wxSockReadMask  0x01
+#define wxSockWriteMask 0x02
+
+extern "C"
+int wxAppAddSocketHandler(int handle, int mask,
+                          void (*callback)(void*), void * gsock)
+{
+    return wxTheApp->AddSocketHandler(handle, mask, callback, gsock);
+}
+
+extern "C"
+void wxAppRemoveSocketHandler(int handle)
+{
+    wxTheApp->RemoveSocketHandler(handle);
+}
+
+void wxApp::HandleSockets()
+{
+    bool pendingEvent = false;
+
+    // Check whether it's time for Gsocket operation
+    if (m_maxSocketHandles > 0 && m_maxSocketNr > 0)
+    {
+        fd_set readfds = m_readfds;
+        fd_set writefds = m_writefds;
+        struct timeval timeout;
+        int i;
+        struct GsocketCallbackInfo
+          *CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;
+        int r = 0;
+        timeout.tv_sec = 0;
+        timeout.tv_usec = 0;
+        if ( select(m_maxSocketNr, &readfds, &writefds, 0, &timeout) > 0)
+        {
+            for (i = m_lastUsedHandle + 1; i != m_lastUsedHandle; i++)
+            {
+                if (i == m_maxSocketNr)
+                    i = 0;
+                if (FD_ISSET(i, &readfds))
+                {
+                    int r;
+                    for (r = 0; r < m_maxSocketHandles; r++){
+                        if(CallbackInfo[r].handle == i &&
+                           CallbackInfo[r].type == wxSockReadMask)
+                            break;
+                    }
+                    if (r < m_maxSocketHandles)
+                    {
+                        CallbackInfo[r].proc(CallbackInfo[r].gsock);
+                        pendingEvent = true;
+                        wxYield();
+                    }
+                }
+                if (FD_ISSET(i, &writefds))
+                {
+                    int r;
+                    for (r = 0; r < m_maxSocketHandles; r++)
+                        if(CallbackInfo[r].handle == i &&
+                           CallbackInfo[r].type == wxSockWriteMask)
+                            break;
+                    if (r < m_maxSocketHandles)
+                    {
+                        CallbackInfo[r].proc(CallbackInfo[r].gsock);
+                        pendingEvent = true;
+                        wxYield();
+                    }
+                }
+            }
+            m_lastUsedHandle = i;
+        }
+        if (pendingEvent)
+            wxYield();
+    }
+}
 // ---------------------------------------------------------------------------
 // wxApp
 // ---------------------------------------------------------------------------
@@ -560,6 +664,9 @@ wxApp::wxApp()
     m_exitOnFrameDelete = TRUE;
     m_bAuto3D = TRUE;
     m_hMq = 0;
+    m_maxSocketHandles = 0;
+    m_maxSocketNr = 0;
+    m_sockCallbackInfo = 0;
 } // end of wxApp::wxApp
 
 wxApp::~wxApp()
@@ -590,6 +697,7 @@ bool wxApp::Initialized()
 // Get and process a message, returning FALSE if WM_QUIT
 // received (and also set the flag telling the app to exit the main loop)
 //
+
 bool wxApp::DoMessage()
 {
     BOOL                            bRc = ::WinGetMsg(vHabmain, &svCurrentMsg, HWND(NULL), 0, 0);
@@ -694,11 +802,17 @@ int wxApp::MainLoop()
 #if wxUSE_THREADS
         wxMutexGuiLeaveOrEnter();
 #endif // wxUSE_THREADS
-        while (/*Pending() &&*/ ProcessIdle())
+        while (!Pending() && ProcessIdle())
         {
-//          wxUsleep(10000);
+            HandleSockets();
+            wxUsleep(10000);
         }
-        DoMessage();
+        HandleSockets();
+        if (Pending())
+            DoMessage();
+        else
+            wxUsleep(10000);
+
     }
     return (int)svCurrentMsg.mp1;
 } // end of wxApp::MainLoop
@@ -1041,6 +1155,54 @@ wxIcon wxApp::GetStdIcon(
     return wxIcon("wxICON_ERROR");
 } // end of wxApp::GetStdIcon
 
+int wxApp::AddSocketHandler(int handle, int mask,
+                            void (*callback)(void*), void * gsock)
+{
+    int find;
+    struct GsocketCallbackInfo
+        *CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;
+
+    for (find = 0; find < m_maxSocketHandles; find++)
+        if (CallbackInfo[find].handle == -1)
+            break;
+    if (find == m_maxSocketHandles)
+    {
+        // Allocate new memory
+        m_sockCallbackInfo = realloc(m_sockCallbackInfo,
+                                     (m_maxSocketHandles+=10)*
+                                     sizeof(struct GsocketCallbackInfo));
+        CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;
+        for (find = m_maxSocketHandles - 10; find < m_maxSocketHandles; find++)
+            CallbackInfo[find].handle = -1;
+        find = m_maxSocketHandles - 10;
+    }
+    CallbackInfo[find].proc = callback;
+    CallbackInfo[find].type = mask;
+    CallbackInfo[find].handle = handle;
+    CallbackInfo[find].gsock = gsock;
+    if (mask & wxSockReadMask)
+        FD_SET(handle, &m_readfds);
+    if (mask & wxSockWriteMask)
+        FD_SET(handle, &m_writefds);
+    if (handle >= m_maxSocketNr)
+        m_maxSocketNr = handle + 1;
+    return find;
+}
+
+void wxApp::RemoveSocketHandler(int handle)
+{
+    struct GsocketCallbackInfo
+        *CallbackInfo = (struct GsocketCallbackInfo *)m_sockCallbackInfo;
+    if (handle < m_maxSocketHandles)
+    {
+        if (CallbackInfo[handle].type & wxSockReadMask)
+            FD_CLR(CallbackInfo[handle].handle, &m_readfds);
+        if (CallbackInfo[handle].type & wxSockWriteMask)
+            FD_CLR(CallbackInfo[handle].handle, &m_writefds);
+        CallbackInfo[handle].handle = -1;
+    }
+}
+
 //-----------------------------------------------------------------------------
 // wxWakeUpIdle
 //-----------------------------------------------------------------------------

src/os2/gsockpm.c

@@ -0,0 +1,119 @@
+/* -------------------------------------------------------------------------
+ * Project: GSocket (Generic Socket) for WX
+ * Name:    gsockpm.c
+ * Purpose: GSocket: PM part
+ * CVSID:   $Id$
+ * ------------------------------------------------------------------------- */
+
+#include "wx/setup.h"
+
+#if wxUSE_SOCKETS
+
+#include <stdlib.h>
+#include "wx/unix/gsockunx.h"
+#include "wx/gsocket.h"
+
+extern int wxAppAddSocketHandler(int handle, int mask,
+				 void (*callback)(void*), void * gsock);
+
+extern void wxAppRemoveSocketHandler(int handle);
+
+#define wxSockReadMask  0x01
+#define wxSockWriteMask 0x02
+
+static void _GSocket_PM_Input(void *data)
+{
+    GSocket *socket = (GSocket *) data;
+    _GSocket_Detected_Read(socket);
+}
+
+static void _GSocket_PM_Output(void *data)
+{
+    GSocket *socket = (GSocket *) data;
+    _GSocket_Detected_Write(socket);
+}
+
+int _GSocket_GUI_Init(GSocket *socket)
+{
+    int *m_id;
+    socket->m_gui_dependent = (char *)malloc(sizeof(int)*2);
+    m_id = (int *)(socket->m_gui_dependent);
+
+    m_id[0] = -1;
+    m_id[1] = -1;
+    return TRUE;
+}
+
+void _GSocket_GUI_Destroy(GSocket *socket)
+{
+    free(socket->m_gui_dependent);
+}
+
+void _GSocket_Install_Callback(GSocket *socket, GSocketEvent event)
+{
+    int *m_id = (int *)(socket->m_gui_dependent);
+    int c;
+
+    if (socket->m_fd == -1)
+        return;
+
+    switch (event)
+    {
+        case GSOCK_LOST:       /* fall-through */
+        case GSOCK_INPUT:      c = 0; break;
+        case GSOCK_OUTPUT:     c = 1; break;
+        case GSOCK_CONNECTION: c = ((socket->m_server) ? 0 : 1); break;
+        default: return;
+    }
+
+    if (m_id[c] != -1)
+        wxAppRemoveSocketHandler(m_id[c]);
+
+    if (c == 0)
+    {
+	m_id[0] = wxAppAddSocketHandler(socket->m_fd, wxSockReadMask,
+					_GSocket_PM_Input, (void *)socket);
+    }
+    else
+    {
+	m_id[1] = wxAppAddSocketHandler(socket->m_fd, wxSockWriteMask,
+					_GSocket_PM_Output, (void *)socket);
+    }
+}
+
+void _GSocket_Uninstall_Callback(GSocket *socket, GSocketEvent event)
+{
+    int *m_id = (int *)(socket->m_gui_dependent);
+    int c;
+    switch (event)
+    {
+	case GSOCK_LOST:       /* fall-through */
+	case GSOCK_INPUT:      c = 0; break;
+	case GSOCK_OUTPUT:     c = 1; break;
+	case GSOCK_CONNECTION: c = ((socket->m_server) ? 0 : 1); break;
+	default: return;
+    }
+    if (m_id[c] != -1)
+        wxAppRemoveSocketHandler(m_id[c]);
+
+    m_id[c] = -1;
+}
+
+void _GSocket_Enable_Events(GSocket *socket)
+{
+    _GSocket_Install_Callback(socket, GSOCK_INPUT);
+    _GSocket_Install_Callback(socket, GSOCK_OUTPUT);
+}
+
+void _GSocket_Disable_Events(GSocket *socket)
+{
+    _GSocket_Uninstall_Callback(socket, GSOCK_INPUT);
+    _GSocket_Uninstall_Callback(socket, GSOCK_OUTPUT);
+}
+
+#else /* !wxUSE_SOCKETS */
+
+/* some compilers don't like having empty source files */
+static int wxDummyGsockVar = 0;
+
+#endif /* wxUSE_SOCKETS/!wxUSE_SOCKETS */