// RCS_ID: $Id$
// License: see wxWindows license
////////////////////////////////////////////////////////////////////////////////
-#ifdef __GNUG__
+#ifdef __GNUG__
#pragma implementation "socket.h"
-#pragma interface
-#pragma implementation "socket.cpp"
+// #pragma interface
+// #pragma implementation "socket.cpp"
+#endif
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+#pragma hdrstop
#endif
/////////////////////////////////////////////////////////////////////////////
#include <wx/timer.h>
#include <wx/utils.h>
+// Not enough OS behaviour defined for wxStubs
+#ifndef __WXSTUBS__
+
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <sys/time.h>
#include <unistd.h>
+#ifdef sun
+#include <sys/filio.h>
+#endif
+
#endif // __UNIX__
#include <signal.h>
#include <errno.h>
+#ifdef _MSC_VER
+#include <io.h>
+#endif
+
#if defined(__WXMOTIF__) || defined(__WXXT__)
#include <X11/Intrinsic.h>
/////////////////////////////////////////////////////////////////////////////
// wxSocket headers
/////////////////////////////////////////////////////////////////////////////
+#include "wx/module.h"
#define WXSOCK_INTERNAL
#include "wx/sckaddr.h"
#include "wx/socket.h"
-#ifdef __BORLANDC__
-#pragma hdrstop
-#endif
-
/////////////////////////////////////////////////////////////////////////////
// Some patch ///// BEGIN
/////////////////////////////////////////////////////////////////////////////
#ifdef __WINDOWS__
#define close closesocket
#define ioctl ioctlsocket
+#ifdef errno
+#undef errno
+#endif
#define errno WSAGetLastError()
#ifdef EWOULDBLOCK
#undef EWOULDBLOCK
#endif
#ifdef __WXMOTIF__
-#define wxAPP_CONTEXT wxTheApp->appContext
+#define wxAPP_CONTEXT ((XtAppContext)wxTheApp->GetAppContext())
#endif
#ifdef __WINDOWS__
#elif defined(__WXXT__) || defined(__WXMOTIF__)
#define PROCESS_EVENTS() XtAppProcessEvent(wxAPP_CONTEXT, XtIMAll)
#elif defined(__WXGTK__)
-#define PROCESS_EVENTS() gtk_main_iteration()
+#define PROCESS_EVENTS() wxYield()
#endif
/////////////////////////////////////////////////////////////////////////////
// Some patch ///// END
/////////////////////////////////////////////////////////////////////////////
+// --------------------------------------------------------------
+// Module
+// --------------------------------------------------------------
+class wxSocketModule: public wxModule
+{
+ DECLARE_DYNAMIC_CLASS(wxSocketModule)
+public:
+ wxSocketModule() {}
+ bool OnInit();
+ void OnExit();
+};
+
// --------------------------------------------------------------
// ClassInfos
// --------------------------------------------------------------
IMPLEMENT_CLASS(wxSocketClient, wxSocketBase)
IMPLEMENT_CLASS(wxSocketHandler, wxObject)
IMPLEMENT_DYNAMIC_CLASS(wxSocketEvent, wxEvent)
+IMPLEMENT_DYNAMIC_CLASS(wxSocketModule, wxModule)
#endif
-class wxSockWakeUp : public wxTimer {
+class wxSockWakeUp : public wxTimer
+{
public:
int *my_id;
int n_val;
wxSocketBase *sock;
- wxSockWakeUp(wxSocketBase *_sock, int *id, int new_val) {
+ wxSockWakeUp(wxSocketBase *_sock, int *id, int new_val)
+ {
my_id = id; n_val = new_val;
sock = _sock;
}
- virtual void Notify() {
+ virtual void Notify()
+ {
*my_id = n_val;
if (sock) sock->Notify(FALSE);
}
};
/// Socket request
-class SockRequest : public wxObject {
+class SockRequest : public wxObject
+{
public:
char *buffer;
size_t size, nbytes;
wxSockWakeUp *auto_wakeup;
wxSocketBase::wxRequestNotify type;
};
-
+
/////////////////////////////////////////////////////////////////////////////
// Some internal define
m_cbkon(FALSE),
m_unread(NULL), m_unrd_size(0),
m_processing(FALSE),
- m_timeout(3600), m_wantbuf(0)
+ m_timeout(1), m_wantbuf(0)
{
m_internal = new wxSockInternal;
#if defined(__WXXT__) || defined(__WXMOTIF__) || defined(__WXGTK__)
m_cbkon(FALSE),
m_unread(NULL), m_unrd_size(0),
m_processing(FALSE),
- m_timeout(3600), m_wantbuf(0)
+ m_timeout(1), m_wantbuf(0)
{
m_internal = new wxSockInternal;
#if defined(__WXXT__) || defined(__WXMOTIF__) || defined(__WXGTK__)
while (node) {
SockRequest *req = (SockRequest *)node->Data();
req->done = TRUE;
-
+
n = node->Next();
delete node;
node = n;
{
SockMsg msg;
size_t len, len2, sig;
-
+
Read((char *)&msg, sizeof(msg));
if (m_lcount != sizeof(msg))
return *this;
wxSocketBase& wxSocketBase::WriteMsg(const char *buffer, size_t nbytes)
{
SockMsg msg;
-
- msg.sig[0] = 0xad;
- msg.sig[1] = 0xde;
- msg.sig[2] = 0xed;
- msg.sig[3] = 0xfe;
- msg.len[0] = nbytes & 0xff;
- msg.len[1] = (nbytes >> 8) & 0xff;
- msg.len[2] = (nbytes >> 16) & 0xff;
- msg.len[3] = (nbytes >> 24) & 0xff;
+ msg.sig[0] = (char) 0xad;
+ msg.sig[1] = (char) 0xde;
+ msg.sig[2] = (char) 0xed;
+ msg.sig[3] = (char) 0xfe;
+
+ msg.len[0] = (char) nbytes & 0xff;
+ msg.len[1] = (char) (nbytes >> 8) & 0xff;
+ msg.len[2] = (char) (nbytes >> 16) & 0xff;
+ msg.len[3] = (char) (nbytes >> 24) & 0xff;
if (Write((char *)&msg, sizeof(msg)).LastCount() < sizeof(msg))
return *this;
if (Write(buffer, nbytes).LastCount() < nbytes)
- return *this;
+ return *this;
- msg.sig[0] = 0xed;
- msg.sig[1] = 0xfe;
- msg.sig[2] = 0xad;
- msg.sig[3] = 0xde;
- msg.len[0] = msg.len[1] = msg.len[2] = msg.len[3] = 0;
+ msg.sig[0] = (char) 0xed;
+ msg.sig[1] = (char) 0xfe;
+ msg.sig[2] = (char) 0xad;
+ msg.sig[3] = (char) 0xde;
+ msg.len[0] = msg.len[1] = msg.len[2] = msg.len[3] = (char) 0;
Write((char *)&msg, sizeof(msg));
return *this;
FD_ZERO(&sock_set);
FD_SET(m_fd, &sock_set);
select(FD_SETSIZE, &sock_set, NULL, NULL, &tv);
- return FD_ISSET(m_fd, &sock_set);
+ return (FD_ISSET(m_fd, &sock_set) != 0);
}
// ---------------------------------------------------------------------
SaveState();
SetFlags((wxSockFlags)(NOWAIT | SPEED));
-
+
while (recv_size == MAX_BUFSIZE) {
recv_size = Read(my_data, MAX_BUFSIZE).LastCount();
}
bool wxSocketBase::GetPeer(wxSockAddress& addr_man) const
{
struct sockaddr my_addr;
- size_t len_addr = sizeof(my_addr);
+ uint len_addr = sizeof(my_addr);
if (m_fd < 0)
return FALSE;
-#ifdef __WINDOWS__
- if (getpeername(m_fd, (struct sockaddr *)&my_addr, (int *)&len_addr) < 0)
-#else
- if (getpeername(m_fd, (struct sockaddr *)&my_addr, (unsigned int *)&len_addr) < 0)
-#endif
- return FALSE;
+ if (getpeername(m_fd, (struct sockaddr *)&my_addr, &len_addr) < 0)
+ return FALSE;
addr_man.Disassemble(&my_addr, len_addr);
return TRUE;
bool wxSocketBase::GetLocal(wxSockAddress& addr_man) const
{
struct sockaddr my_addr;
- size_t len_addr = sizeof(my_addr);
+ uint len_addr = sizeof(my_addr);
if (m_fd < 0)
return FALSE;
-#ifdef __WINDOWS__
- if (getsockname(m_fd, (struct sockaddr *)&my_addr, (int *)&len_addr) < 0)
-#else
- if (getsockname(m_fd, (struct sockaddr *)&my_addr, (unsigned int *)&len_addr) < 0)
-#endif
+ if (getsockname(m_fd, (struct sockaddr *)&my_addr, &len_addr) < 0)
+
return FALSE;
addr_man.Disassemble(&my_addr, len_addr);
// --------------------------------------------------------------
// --------- wxSocketBase wait functions ------------------------
// --------------------------------------------------------------
+
void wxSocketBase::SaveState()
{
wxSockState *state = new wxSockState;
return;
wxSockState *state = (wxSockState *)node->Data();
-
+
SetFlags(state->flags);
m_neededreq = state->cbk_set;
m_cbk = state->cbk;
// --------------------------------------------------------------
// --------- wxSocketBase wait functions ------------------------
// --------------------------------------------------------------
-//
+
bool wxSocketBase::_Wait(long seconds, long microseconds, int type)
{
if ((!m_connected && !m_connecting) || m_fd < 0)
if (seconds != -1)
wakeup.Start((int)(seconds*1000 + (microseconds / 1000)), TRUE);
-
+
m_waitflags = 0x80 | type;
while (m_waitflags & 0x80)
PROCESS_EVENTS();
wxSocketBase::wxRequestNotify wxSocketBase::EventToNotify(wxRequestEvent evt)
{
- switch (evt) {
+ switch (evt)
+ {
case EVT_READ:
return REQ_READ;
case EVT_PEEK:
void wxSocketBase::SetFlags(wxSockFlags _flags)
{
m_flags = _flags;
- if (_flags & SPEED) {
+ if (_flags & SPEED)
+ {
unsigned long flag = 0;
ioctl(m_fd, FIONBIO, &flag);
m_flags = (wxSockFlags)(m_flags & ~WAITALL);
Notify(FALSE);
- } else {
+ }
+ else
+ {
unsigned long flag = 1;
ioctl(m_fd, FIONBIO, &flag);
}
void wxSocketBase::SetNotify(wxRequestNotify flags)
{
wxRequestNotify old_needed_req = m_neededreq;
- if (flags & REQ_ACCEPT) {
+ if (flags & REQ_ACCEPT)
+ {
/* Check if server */
if (!(GetClassInfo()->IsKindOf(CLASSINFO(wxSocketServer))))
flags &= ~REQ_ACCEPT;
}
m_neededreq = flags;
- if (m_cbkon && old_needed_req != flags)
+
+/*
+ if (m_cbkon && old_needed_req != flags) seems to be wrong, Robert Roebling
+ SetupCallbacks();
+*/
+
+ if ((!m_cbkon) || (old_needed_req != flags))
SetupCallbacks();
}
}
if (m_neededreq & (REQ_CONNECT | REQ_WRITE)) {
#ifdef __WXGTK__
- m_internal->sock_inputid = gdk_input_add(m_fd, GDK_INPUT_WRITE,
+ m_internal->sock_outputid = gdk_input_add(m_fd, GDK_INPUT_WRITE,
wx_socket_write, (gpointer)this);
#else
m_internal->sock_outputid = XtAppAddInput (wxAPP_CONTEXT, m_fd,
{
if (!m_cbkon || !m_handler)
return;
+
m_cbkon = FALSE;
m_processing = FALSE;
#if defined(__WXMOTIF__) || defined(__WXXT__)
if (req_evt <= EVT_WRITE && DoRequests(req_evt))
return;
- if (m_waitflags & 0xF0) {
+ if (m_waitflags & 0xF0)
+ {
// Wake up
- if ((m_waitflags & 0x0F) == req_evt) {
+ if ((m_waitflags & 0x0F) == req_evt)
+ {
m_waitflags = 0x80;
#ifndef __WXGTK__
DestroyCallbacks(); // I disable it to prevent infinite loop on X11.
return;
}
- if (req_evt == EVT_LOST) {
+ if (req_evt == EVT_LOST)
+ {
m_connected = FALSE;
Close();
}
// --------------------------------------------------------------
// --------- wxSocketBase functions [Callback, CallbackData] ----
// --------------------------------------------------------------
+
wxSocketBase::wxSockCbk wxSocketBase::Callback(wxSocketBase::wxSockCbk _cbk)
{
wxSockCbk old_cbk = m_cbk;
// --------------------------------------------------------------
// --------- wxSocketBase pushback library ----------------------
// --------------------------------------------------------------
+
void wxSocketBase::CreatePushbackAfter(const char *buffer, size_t size)
{
char *curr_pos;
delete node;
- switch (req->type) {
+ switch (req->type)
+ {
case EVT_READ:
case EVT_PEEK:
ret = recv(m_fd, req->buffer, req->size,
void wxSocketBase::WantSpeedBuffer(char *buffer, size_t nbytes,
wxRequestEvent evt)
{
- int ret;
+ int ret = 0;
switch (evt) {
case EVT_PEEK:
case EVT_READ:
- ret = read(m_fd, buffer, nbytes);
+ ret = recv(m_fd, buffer, nbytes,
+ (evt == EVT_PEEK) ? MSG_PEEK : 0);
break;
case EVT_WRITE:
- ret = write(m_fd, buffer, nbytes);
+ ret = send(m_fd, buffer, nbytes, 0);
break;
}
if (ret < 0) {
m_lcount = 0;
m_error = errno;
- } else
+ } else {
m_lcount = ret;
+ m_error = 0;
+ }
}
void wxSocketBase::WantBuffer(char *buffer, size_t nbytes,
SockRequest *buf = new SockRequest;
wxSockWakeUp s_wake(NULL, (int *)&buf_timed_out, (int)TRUE);
-
+
m_wantbuf++;
req_list[evt].Append(buf);
buf_timed_out = FALSE;
s_wake.Start(m_timeout*1000, TRUE);
- if (m_flags & NOWAIT) {
+ if (m_flags & NOWAIT)
+ {
DoRequests(evt);
- } else {
+ }
+ else
+ {
while (!buf->done && !buf_timed_out)
PROCESS_EVENTS();
}
if (m_fd == INVALID_SOCKET)
return;
-
+
int flag = 1;
setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (char*)&flag, sizeof(int));
-
+
struct sockaddr *myaddr;
size_t len;
-
+
addr_man.Build(myaddr, len);
if (bind(m_fd, myaddr, addr_man.SockAddrLen()) < 0)
return;
-
+
if (listen(m_fd, 5) < 0) {
m_fd = INVALID_SOCKET;
return;
bool wxSocketServer::AcceptWith(wxSocketBase& sock)
{
int fd2;
-
+
if ((fd2 = accept(m_fd, 0, 0)) < 0)
return FALSE;
struct linger linger;
linger.l_onoff = 0;
linger.l_linger = 1;
-
+
setsockopt(fd2, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(linger));
-
+
int flag = 0;
setsockopt(fd2, SOL_SOCKET, SO_KEEPALIVE, (char*)&flag, sizeof(int));
-
+
if (!(sock.m_flags & SPEED)) {
unsigned long flag2 = 1;
ioctl(fd2, FIONBIO, &flag2);
}
-
+
sock.m_type = SOCK_INTERNAL;
sock.m_fd = fd2;
sock.m_connected = TRUE;
// --------------------------------------------------------------
// --------- wxSocketClient Connect functions -------------------
// --------------------------------------------------------------
-bool wxSocketClient::Connect(wxSockAddress& addr_man, bool wait)
+bool wxSocketClient::Connect(wxSockAddress& addr_man, bool WXUNUSED(wait) )
{
struct linger linger;
Close();
m_fd = socket(addr_man.GetFamily(), SOCK_STREAM, 0);
-
+
if (m_fd < 0)
return FALSE;
-
+
m_connected = FALSE;
linger.l_onoff = 1;
- linger.l_linger = 5;
+ linger.l_linger = 5;
setsockopt(m_fd, SOL_SOCKET, SO_LINGER, (char*)&linger, sizeof(linger));
-
+
// Stay in touch with the state of things...
-
+
unsigned long flag = 1;
setsockopt(m_fd, SOL_SOCKET, SO_KEEPALIVE, (char*)&flag, sizeof(int));
-
+
// Disable the nagle algorithm, which delays sends till the
// buffer is full (or a certain time period has passed?)...
flag = 1;
setsockopt(m_fd, IPPROTO_TCP, TCP_NODELAY, (char*)&flag, sizeof(int));
#endif
-
+
struct sockaddr *remote;
size_t len;
flag = 1;
ioctl(m_fd, FIONBIO, &flag);
}
-
+
Notify(TRUE);
m_connected = TRUE;
return TRUE;
}
-bool wxSocketClient::WaitOnConnect(long seconds)
+bool wxSocketClient::WaitOnConnect(long seconds, long microseconds)
{
- int ret = _Wait(seconds, 0, REQ_CONNECT | REQ_LOST);
-
+ int ret = _Wait(seconds, microseconds, REQ_CONNECT | REQ_LOST);
+
if (ret)
m_connected = TRUE;
-
- return m_connected;
+
+ return m_connected;
}
void wxSocketClient::OnRequest(wxRequestEvent evt)
return;
}
m_waitflags = 0x40;
- m_connected = TRUE;
+ m_connected = TRUE;
OldOnNotify(EVT_CONNECT);
DestroyCallbacks();
return;
LRESULT APIENTRY _EXPORT wxSocketHandlerWndProc(HWND hWnd, UINT message,
WPARAM wParam, LPARAM lParam)
{
+ if(message==WM_DESTROY)
+ {
+ ::SetWindowLong(hWnd, GWL_WNDPROC, (LONG) DefWindowProc);
+ return DefWindowProc(hWnd, message, wParam, lParam);
+ }
wxSocketHandler *h_sock = (wxSocketHandler *)GetWindowLong(hWnd, GWL_USERDATA);
wxNode *node = h_sock->smsg_list->Find(message);
wxSocketBase *sock;
for (node = socks->First(); node; node = node->Next()) {
wxSocketBase* s = (wxSocketBase*)node->Data();
-
+
if (s == sock) {
delete node;
sock->DestroyCallbacks();
}
#endif
+
+bool wxSocketModule::OnInit() {
+ wxSocketHandler::master = new wxSocketHandler();
+ return TRUE;
+}
+
+void wxSocketModule::OnExit() {
+ delete wxSocketHandler::master;
+ wxSocketHandler::master = NULL;
+}
+
+#endif
+ // __WXSTUBS__
projects / wxWidgets.git / blobdiff