[wxWidgets.git] / include / wx / socket.h

/////////////////////////////////////////////////////////////////////////////
// Name:        socket.h
// Purpose:     Socket handling classes
// Author:      Guilhem Lavaux
// Modified by:
// Created:     April 1997
// RCS-ID:      $Id$
// Copyright:   (c) Guilhem Lavaux
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifndef _WX_NETWORK_SOCKET_H
#define _WX_NETWORK_SOCKET_H

#ifdef __GNUG__
#pragma interface "socket.h"
#endif

// ---------------------------------------------------------------------------
// Windows(tm) specific
// ---------------------------------------------------------------------------
#if defined(__WINDOWS__) && defined(WXSOCK_INTERNAL)
#include <winsock.h>
#include <wx/msw/private.h>
#endif // defined(__WINDOWS__) && defined(WXSOCK_INTERNAL)

// ---------------------------------------------------------------------------
// Unix specific
// ---------------------------------------------------------------------------
#if defined(__UNIX__) && defined(WXSOCK_INTERNAL)
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#endif // defined(__UNIX__) && defined(WXSOCK_INTERNAL)

// ---------------------------------------------------------------------------
// wxSocket headers (generic)
// ---------------------------------------------------------------------------
#ifdef WXPREC
#include <wx/wxprec.h>
#else
#include <wx/wx.h>
#endif
#include "wx/sckaddr.h"

class WXDLLEXPORT wxSocketEvent;
class WXDLLEXPORT wxSocketHandler;
class wxSocketInternal;
class WXDLLEXPORT wxSocketBase : public wxEvtHandler
{
  DECLARE_CLASS(wxSocketBase)
#ifdef __WXMAC__
  friend void wxMacSocketOnRequestProc(void *refcon , short event) ;
#endif
public:

  enum wxSockFlags { NONE=0, NOWAIT=1, WAITALL=2, SPEED=4 };
  // Type of request
  enum { REQ_READ=0x1, REQ_PEEK=0x2, REQ_WRITE=0x4, REQ_LOST=0x8,
         REQ_ACCEPT=0x10, REQ_CONNECT=0x20, REQ_WAIT=0x40};
  enum { EVT_READ=0, EVT_PEEK=1, EVT_WRITE=2, EVT_LOST=3, EVT_ACCEPT=4,
         EVT_CONNECT=5 };

  typedef int wxRequestNotify;
  typedef int wxRequestEvent;
  enum wxSockType { SOCK_CLIENT, SOCK_SERVER, SOCK_INTERNAL, SOCK_UNINIT }; 
  typedef void (*wxSockCbk)(wxSocketBase& sock,wxRequestEvent evt,char *cdata);

protected:
  wxSockFlags m_flags;
  wxSockType m_type;			// wxSocket type
  bool m_connected, m_connecting;	// State of the socket
  int m_fd;				// Socket file descriptors
  wxList m_states;			// States list
  int m_id;				// Socket id (for event handler)
  wxSocketHandler *m_handler;		// the current socket handler
  wxRequestNotify m_neededreq;		// Specify which requet signals we need
  unsigned long m_timeout;
  size_t m_lcount;			// Last IO request size
  int m_error;				// Last IO error
  wxSocketInternal *m_internal;
  char *m_unread;			// Pushback buffer
  size_t m_unrd_size;			// Pushback buffer size
  wxSockCbk m_cbk;
  char *m_cdata;
  bool m_notify_state;
  
public:
  wxSocketBase();
  virtual ~wxSocketBase();
  virtual bool Close();

  // Base IO
  wxSocketBase& Peek(char* buffer, size_t nbytes);
  wxSocketBase& Read(char* buffer, size_t nbytes);
  wxSocketBase& Write(const char *buffer, size_t nbytes);
  wxSocketBase& Unread(const char *buffer, size_t nbytes);
  void Discard();

  // Try not to use this two methods (they sould be protected)
  void CreatePushbackAfter(const char *buffer, size_t size);
  void CreatePushbackBefore(const char *buffer, size_t size);

  // Status
  inline bool Ok() const { return (m_fd < 0 ? 0 : 1); };
  inline bool Error() const { return (m_error != 0); };
  inline bool IsConnected() const { return m_connected; };
  inline bool IsDisconnected() const { return !IsConnected(); };
  inline bool IsNoWait() const { return m_flags & NOWAIT; };
  bool IsData() const;
  inline size_t LastCount() const { return m_lcount; }
  inline int LastError() const { return m_error; }
  inline wxSockType GetType() const { return m_type; }
  
  void SetFlags(wxSockFlags _flags);
  wxSockFlags GetFlags() const;
  inline void SetTimeout(unsigned long sec) { m_timeout = sec; }

  // seconds = -1 means infinite wait
  // seconds = 0 means no wait
  // seconds > 0 means specified wait
  bool Wait(long seconds = -1, long microseconds = 0);
  bool WaitForRead(long seconds = -1, long microseconds = 0);
  bool WaitForWrite(long seconds = -1, long microseconds = 0);
  bool WaitForLost(long seconds = -1, long microseconds = 0);
  
  // Save the current state of Socket
  void SaveState();
  void RestoreState();

  // Setup external callback
  wxSockCbk Callback(wxSockCbk cbk_);
  char *CallbackData(char *data);

  // Setup event handler
  void SetEventHandler(wxEvtHandler& evt_hdlr, int id = -1);
  
  // Method called when it happens something on the socket
  void SetNotify(wxRequestNotify flags);
  virtual void OnRequest(wxRequestEvent req_evt);

  // Public internal callback
  virtual void OldOnNotify(wxRequestEvent WXUNUSED(evt));

  // Some info on the socket...
  virtual bool GetPeer(wxSockAddress& addr_man) const;
  virtual bool GetLocal(wxSockAddress& addr_man) const;

  // Install or uninstall callbacks
  void Notify(bool notify);

  // So you can know what the socket driver is looking for ...
  inline wxRequestNotify NeededReq() const { return m_neededreq; }

  static wxRequestNotify EventToNotify(wxRequestEvent evt);

protected:
  friend class wxSocketServer;
  friend class wxSocketHandler;
  friend class wxSocketInternal;

#ifdef __SALFORDC__
public:
#endif

  wxSocketBase(wxSockFlags flags, wxSockType type);

#ifdef __SALFORDC__
protected:
#endif
  
  bool _Wait(long seconds, long microseconds, int type);
  
  // Set "my" handler
  inline virtual void SetHandler(wxSocketHandler *handler)
         { m_handler = handler; }

  // Pushback library
  size_t GetPushback(char *buffer, size_t size, bool peek);

  // To prevent many read or write on the same socket at the same time
  //   ==> cause strange things :-)
  void WantSpeedBuffer(char *buffer, size_t size, wxRequestEvent req);
  void WantBuffer(char *buffer, size_t size, wxRequestEvent req);
};

////////////////////////////////////////////////////////////////////////

class WXDLLEXPORT wxSocketServer : public wxSocketBase
{
  DECLARE_CLASS(wxSocketServer)
public:

  // 'service' can be a name or a port-number

  wxSocketServer(wxSockAddress& addr_man, wxSockFlags flags = wxSocketBase::NONE);

  wxSocketBase* Accept();
  bool AcceptWith(wxSocketBase& sock);
};

////////////////////////////////////////////////////////////////////////

class WXDLLEXPORT wxSocketClient : public wxSocketBase
{
  DECLARE_CLASS(wxSocketClient)
public:

  wxSocketClient(wxSockFlags flags = wxSocketBase::NONE);
  virtual ~wxSocketClient();

  virtual bool Connect(wxSockAddress& addr_man, bool wait = TRUE);

  bool WaitOnConnect(long seconds = -1, long microseconds = 0);

  virtual void OnRequest(wxRequestEvent flags);
};

////////////////////////////////////////////////////////////////////////

class WXDLLEXPORT wxSocketHandler : public wxObject
{
  DECLARE_CLASS(wxSocketHandler)
protected:
  wxList *socks;

public:
  enum SockStatus { SOCK_NONE, SOCK_DATA, SOCK_CONNECT, SOCK_DISCONNECT,
		    SOCK_ERROR };
  static wxSocketHandler *master;

  wxSocketHandler();
  virtual ~wxSocketHandler();
  
  void Register(wxSocketBase* sock);
  void UnRegister(wxSocketBase* sock);
  
  unsigned long Count() const;
  
  // seconds = -1 means indefinite wait
  // seconds = 0 means no wait
  // seconds > 0 means specified wait
  
  int Wait(long seconds = -1, long microseconds = 0);
  void YieldSock();
  
  wxSocketServer *CreateServer
                       (wxSockAddress& addr,
			wxSocketBase::wxSockFlags flags = wxSocketBase::NONE);
  wxSocketClient *CreateClient
                       (wxSocketBase::wxSockFlags flags = wxSocketBase::NONE);

  // Create or reuse a socket handler
  static wxSocketHandler& Master() { return *master; }

#if defined(WXSOCK_INTERNAL) && defined(__WINDOWS__)

  friend LRESULT APIENTRY _EXPORT wxSocketHandlerWndProc(HWND hWnd,
                        UINT message, WPARAM wParam, LPARAM lParam);

  UINT NewMessage(wxSocketBase *sock);
  void DestroyMessage(UINT msg);

  HWND GetHWND() const;
#endif
};

class WXDLLEXPORT wxSocketEvent : public wxEvent {
  DECLARE_DYNAMIC_CLASS(wxSocketEvent)
public:
  wxSocketEvent(int id = 0);

  wxSocketBase::wxRequestEvent SocketEvent() const { return m_skevt; }
  wxSocketBase *Socket() const { return m_socket; }

  wxObject *Clone() const;
public:
  wxSocketBase::wxRequestEvent m_skevt;
  wxSocketBase *m_socket;
};

typedef void (wxEvtHandler::*wxSocketEventFunction)(wxSocketEvent&);

#define EVT_SOCKET(id, func) { wxEVT_SOCKET, id, -1, \
  (wxObjectEventFunction) (wxEventFunction) (wxSocketEventFunction) & func, \
  (wxObject *) NULL  },

#endif
Commit	Line	Data
f4ada568 GL	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: socket.h
	3	// Purpose: Socket handling classes
	4	// Author: Guilhem Lavaux
	5	// Modified by:
	6	// Created: April 1997
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Guilhem Lavaux
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
0c32066b	11
f4ada568 GL	12	#ifndef _WX_NETWORK_SOCKET_H
	13	#define _WX_NETWORK_SOCKET_H
	14
	15	#ifdef __GNUG__
0c32066b	16	#pragma interface "socket.h"
f4ada568 GL	17	#endif
	18
	19	// ---------------------------------------------------------------------------
	20	// Windows(tm) specific
	21	// ---------------------------------------------------------------------------
	22	#if defined(__WINDOWS__) && defined(WXSOCK_INTERNAL)
	23	#include <winsock.h>
	24	#include <wx/msw/private.h>
f4ada568 GL	25	#endif // defined(__WINDOWS__) && defined(WXSOCK_INTERNAL)
	26
	27	// ---------------------------------------------------------------------------
	28	// Unix specific
	29	// ---------------------------------------------------------------------------
	30	#if defined(__UNIX__) && defined(WXSOCK_INTERNAL)
	31	#include <sys/types.h>
	32	#include <sys/socket.h>
	33	#include <netinet/in.h>
f4ada568 GL	34	#endif // defined(__UNIX__) && defined(WXSOCK_INTERNAL)
	35
	36	// ---------------------------------------------------------------------------
	37	// wxSocket headers (generic)
	38	// ---------------------------------------------------------------------------
	39	#ifdef WXPREC
	40	#include <wx/wxprec.h>
	41	#else
	42	#include <wx/wx.h>
	43	#endif
	44	#include "wx/sckaddr.h"
	45
	46	class WXDLLEXPORT wxSocketEvent;
	47	class WXDLLEXPORT wxSocketHandler;
a737331d	48	class wxSocketInternal;
f4ada568 GL	49	class WXDLLEXPORT wxSocketBase : public wxEvtHandler
	50	{
	51	DECLARE_CLASS(wxSocketBase)
17dff81c	52	#ifdef __WXMAC__
375abe3d GL	53	friend void wxMacSocketOnRequestProc(void *refcon , short event) ;
375abe3d GL	54	#endif
f4ada568 GL	55	public:
	56
	57	enum wxSockFlags { NONE=0, NOWAIT=1, WAITALL=2, SPEED=4 };
	58	// Type of request
	59	enum { REQ_READ=0x1, REQ_PEEK=0x2, REQ_WRITE=0x4, REQ_LOST=0x8,
a737331d	60	REQ_ACCEPT=0x10, REQ_CONNECT=0x20, REQ_WAIT=0x40};
f4ada568 GL	61	enum { EVT_READ=0, EVT_PEEK=1, EVT_WRITE=2, EVT_LOST=3, EVT_ACCEPT=4,
	62	EVT_CONNECT=5 };
	63
	64	typedef int wxRequestNotify;
	65	typedef int wxRequestEvent;
a737331d	66	enum wxSockType { SOCK_CLIENT, SOCK_SERVER, SOCK_INTERNAL, SOCK_UNINIT };
f4ada568 GL	67	typedef void (wxSockCbk)(wxSocketBase& sock,wxRequestEvent evt,char cdata);
	68
	69	protected:
f4ada568 GL	70	wxSockFlags m_flags;
	71	wxSockType m_type; // wxSocket type
	72	bool m_connected, m_connecting; // State of the socket
	73	int m_fd; // Socket file descriptors
f4ada568	74	wxList m_states; // States list
f4ada568 GL	75	int m_id; // Socket id (for event handler)
	76	wxSocketHandler *m_handler; // the current socket handler
	77	wxRequestNotify m_neededreq; // Specify which requet signals we need
f4ada568	78	unsigned long m_timeout;
f4ada568 GL	79	size_t m_lcount; // Last IO request size
f4ada568 GL	80	int m_error; // Last IO error
a737331d GL	81	wxSocketInternal *m_internal;
	82	char *m_unread; // Pushback buffer
	83	size_t m_unrd_size; // Pushback buffer size
	84	wxSockCbk m_cbk;
	85	char *m_cdata;
	86	bool m_notify_state;
	87
f4ada568 GL	88	public:
	89	wxSocketBase();
	90	virtual ~wxSocketBase();
	91	virtual bool Close();
	92
	93	// Base IO
	94	wxSocketBase& Peek(char* buffer, size_t nbytes);
	95	wxSocketBase& Read(char* buffer, size_t nbytes);
	96	wxSocketBase& Write(const char *buffer, size_t nbytes);
f4ada568 GL	97	wxSocketBase& Unread(const char *buffer, size_t nbytes);
	98	void Discard();
	99
	100	// Try not to use this two methods (they sould be protected)
	101	void CreatePushbackAfter(const char *buffer, size_t size);
	102	void CreatePushbackBefore(const char *buffer, size_t size);
	103
	104	// Status
	105	inline bool Ok() const { return (m_fd < 0 ? 0 : 1); };
	106	inline bool Error() const { return (m_error != 0); };
	107	inline bool IsConnected() const { return m_connected; };
	108	inline bool IsDisconnected() const { return !IsConnected(); };
	109	inline bool IsNoWait() const { return m_flags & NOWAIT; };
	110	bool IsData() const;
	111	inline size_t LastCount() const { return m_lcount; }
	112	inline int LastError() const { return m_error; }
a737331d	113	inline wxSockType GetType() const { return m_type; }
f4ada568	114
20e85460	115	void SetFlags(wxSockFlags _flags);
a737331d	116	wxSockFlags GetFlags() const;
f4ada568 GL	117	inline void SetTimeout(unsigned long sec) { m_timeout = sec; }
	118
	119	// seconds = -1 means infinite wait
	120	// seconds = 0 means no wait
	121	// seconds > 0 means specified wait
	122	bool Wait(long seconds = -1, long microseconds = 0);
	123	bool WaitForRead(long seconds = -1, long microseconds = 0);
	124	bool WaitForWrite(long seconds = -1, long microseconds = 0);
	125	bool WaitForLost(long seconds = -1, long microseconds = 0);
	126
	127	// Save the current state of Socket
	128	void SaveState();
	129	void RestoreState();
	130
	131	// Setup external callback
	132	wxSockCbk Callback(wxSockCbk cbk_);
	133	char CallbackData(char data);
	134
	135	// Setup event handler
	136	void SetEventHandler(wxEvtHandler& evt_hdlr, int id = -1);
	137
	138	// Method called when it happens something on the socket
	139	void SetNotify(wxRequestNotify flags);
	140	virtual void OnRequest(wxRequestEvent req_evt);
	141
	142	// Public internal callback
	143	virtual void OldOnNotify(wxRequestEvent WXUNUSED(evt));
	144
	145	// Some info on the socket...
	146	virtual bool GetPeer(wxSockAddress& addr_man) const;
	147	virtual bool GetLocal(wxSockAddress& addr_man) const;
	148
	149	// Install or uninstall callbacks
	150	void Notify(bool notify);
	151
	152	// So you can know what the socket driver is looking for ...
	153	inline wxRequestNotify NeededReq() const { return m_neededreq; }
	154
	155	static wxRequestNotify EventToNotify(wxRequestEvent evt);
	156
	157	protected:
	158	friend class wxSocketServer;
	159	friend class wxSocketHandler;
a737331d	160	friend class wxSocketInternal;
f4ada568	161
ce3ed50d JS	162	#ifdef __SALFORDC__
	163	public:
	164	#endif
	165
f4ada568	166	wxSocketBase(wxSockFlags flags, wxSockType type);
ce3ed50d JS	167
	168	#ifdef __SALFORDC__
	169	protected:
	170	#endif
f4ada568 GL	171
	172	bool _Wait(long seconds, long microseconds, int type);
	173
	174	// Set "my" handler
	175	inline virtual void SetHandler(wxSocketHandler *handler)
	176	{ m_handler = handler; }
	177
f4ada568 GL	178	// Pushback library
	179	size_t GetPushback(char *buffer, size_t size, bool peek);
	180
	181	// To prevent many read or write on the same socket at the same time
	182	// ==> cause strange things :-)
	183	void WantSpeedBuffer(char *buffer, size_t size, wxRequestEvent req);
	184	void WantBuffer(char *buffer, size_t size, wxRequestEvent req);
f4ada568 GL	185	};
	186
	187	////////////////////////////////////////////////////////////////////////
	188
	189	class WXDLLEXPORT wxSocketServer : public wxSocketBase
	190	{
	191	DECLARE_CLASS(wxSocketServer)
	192	public:
	193
	194	// 'service' can be a name or a port-number
	195
	196	wxSocketServer(wxSockAddress& addr_man, wxSockFlags flags = wxSocketBase::NONE);
	197
	198	wxSocketBase* Accept();
	199	bool AcceptWith(wxSocketBase& sock);
f4ada568 GL	200	};
	201
	202	////////////////////////////////////////////////////////////////////////
	203
	204	class WXDLLEXPORT wxSocketClient : public wxSocketBase
	205	{
	206	DECLARE_CLASS(wxSocketClient)
	207	public:
	208
	209	wxSocketClient(wxSockFlags flags = wxSocketBase::NONE);
	210	virtual ~wxSocketClient();
	211
	212	virtual bool Connect(wxSockAddress& addr_man, bool wait = TRUE);
	213
75ed1d15	214	bool WaitOnConnect(long seconds = -1, long microseconds = 0);
f4ada568 GL	215
	216	virtual void OnRequest(wxRequestEvent flags);
	217	};
	218
	219	////////////////////////////////////////////////////////////////////////
	220
	221	class WXDLLEXPORT wxSocketHandler : public wxObject
	222	{
	223	DECLARE_CLASS(wxSocketHandler)
	224	protected:
f4ada568 GL	225	wxList *socks;
	226
	227	public:
	228	enum SockStatus { SOCK_NONE, SOCK_DATA, SOCK_CONNECT, SOCK_DISCONNECT,
	229	SOCK_ERROR };
3b4183d8	230	static wxSocketHandler *master;
f4ada568 GL	231
	232	wxSocketHandler();
	233	virtual ~wxSocketHandler();
	234
	235	void Register(wxSocketBase* sock);
	236	void UnRegister(wxSocketBase* sock);
	237
	238	unsigned long Count() const;
	239
	240	// seconds = -1 means indefinite wait
	241	// seconds = 0 means no wait
	242	// seconds > 0 means specified wait
	243
	244	int Wait(long seconds = -1, long microseconds = 0);
	245	void YieldSock();
	246
	247	wxSocketServer *CreateServer
	248	(wxSockAddress& addr,
	249	wxSocketBase::wxSockFlags flags = wxSocketBase::NONE);
	250	wxSocketClient *CreateClient
	251	(wxSocketBase::wxSockFlags flags = wxSocketBase::NONE);
	252
	253	// Create or reuse a socket handler
3b4183d8	254	static wxSocketHandler& Master() { return *master; }
f4ada568 GL	255
	256	#if defined(WXSOCK_INTERNAL) && defined(__WINDOWS__)
	257
	258	friend LRESULT APIENTRY _EXPORT wxSocketHandlerWndProc(HWND hWnd,
	259	UINT message, WPARAM wParam, LPARAM lParam);
	260
	261	UINT NewMessage(wxSocketBase *sock);
	262	void DestroyMessage(UINT msg);
	263
	264	HWND GetHWND() const;
	265	#endif
	266	};
	267
	268	class WXDLLEXPORT wxSocketEvent : public wxEvent {
	269	DECLARE_DYNAMIC_CLASS(wxSocketEvent)
	270	public:
	271	wxSocketEvent(int id = 0);
	272
	273	wxSocketBase::wxRequestEvent SocketEvent() const { return m_skevt; }
a737331d GL	274	wxSocketBase *Socket() const { return m_socket; }
	275
	276	wxObject *Clone() const;
f4ada568 GL	277	public:
f4ada568 GL	278	wxSocketBase::wxRequestEvent m_skevt;
a737331d	279	wxSocketBase *m_socket;
f4ada568 GL	280	};
	281
	282	typedef void (wxEvtHandler::*wxSocketEventFunction)(wxSocketEvent&);
	283
a737331d	284	#define EVT_SOCKET(id, func) { wxEVT_SOCKET, id, -1, \
db131261 RR	285	(wxObjectEventFunction) (wxEventFunction) (wxSocketEventFunction) & func, \
db131261 RR	286	(wxObject *) NULL },
f4ada568 GL	287
f4ada568 GL	288	#endif