X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/cf85cb95f19ee1471cbf9fb5e30f9a5a4e11c725..7946d7deaac081a745dc616a5eb13ae864865fa2:/docs/latex/wx/socket.tex?ds=inline diff --git a/docs/latex/wx/socket.tex b/docs/latex/wx/socket.tex index 4e67a9352b..56959fca5e 100644 --- a/docs/latex/wx/socket.tex +++ b/docs/latex/wx/socket.tex @@ -1,14 +1,28 @@ +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +%% Name: socket.tex +%% Purpose: wxSocket docs +%% Author: Guillermo Rodriguez Garcia +%% Modified by: +%% Created: 1999 +%% RCS-ID: $Id$ +%% Copyright: (c) wxWindows team +%% License: wxWindows license +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + \section{\class{wxSocketBase}}\label{wxsocketbase} +wxSocketBase is the base class for all socket-related objects, and it +defines all basic IO functionality. + \wxheading{Derived from} -\helpref{wxEvtHandler}{wxevthandler} +\helpref{wxObject}{wxobject} \wxheading{Include files} -\wxheading{wxSocket errors}%\label{wxsocketerrs} % Labels don't work on a non-section! +\wxheading{wxSocket errors} \twocolwidtha{7cm} \begin{twocollist}\itemsep=0pt @@ -22,239 +36,418 @@ \twocolitem{{\bf wxSOCKET\_WOULDBLOCK}}{The socket is non-blocking and the operation would block.} \twocolitem{{\bf wxSOCKET\_TIMEDOUT}}{The timeout for this operation expired.} \twocolitem{{\bf wxSOCKET\_MEMERR}}{Memory exhausted.} -\end{twocollist}% +\end{twocollist} \wxheading{wxSocket events} \twocolwidtha{7cm} \begin{twocollist}\itemsep=0pt -\twocolitem{{\bf wxSOCKET\_INPUT}}{Some data has arrived to the socket.} +\twocolitem{{\bf wxSOCKET\_INPUT}}{There is data available for reading.} \twocolitem{{\bf wxSOCKET\_OUTPUT}}{The socket is ready to be written to.} -\twocolitem{{\bf wxSOCKET\_CONNECTION}}{Incoming connection arrival (server), or connection establishment (client).} +\twocolitem{{\bf wxSOCKET\_CONNECTION}}{Incoming connection request (server), or successful connection establishment (client).} \twocolitem{{\bf wxSOCKET\_LOST}}{The connection has been closed.} -\twocolitem{{\bf wxSOCKET\_MAX\_EVENT}}{This should never happen but the compiler may complain about it.} -\end{twocollist}% +\end{twocollist} A brief note on how to use these events: -The {\bf wxSOCKET\_INPUT} event will be issued when the incoming queue -was empty and new data arrives, but NOT if new data arrives when there -was data waiting in the incoming queue. - -The {\bf wxSOCKET\_OUTPUT} event is issued when a socket is first connected -with Connect or accepted with Accept, and then, only after an output operation -fails because the output buffer was full, and buffer space becomes available -again. - -The {\bf wxSOCKET\_CONNECTION} event is issued when a connection request -completes (client) or when a new connection arrives at the pending -connections queue (server). +The {\bf wxSOCKET\_INPUT} event will be issued whenever there is data +available for reading. This will be the case if the input queue was +empty and new data arrives, or if the application has read some data +yet there is still more data available. This means that the application +does not need to read all available data in response to a +{\bf wxSOCKET\_INPUT} event, as more events will be produced as +necessary. + +The {\bf wxSOCKET\_OUTPUT} event is issued when a socket is first +connected with \helpref{Connect}{wxsocketclientconnect} or accepted +with \helpref{Accept}{wxsocketserveraccept}. After that, new +events will be generated only after an output operation fails +with {\bf wxSOCKET\_WOULDBLOCK} and buffer space becomes available +again. This means that the application should assume that it +can write data to the socket until an {\bf wxSOCKET\_WOULDBLOCK} +error occurs; after this, whenever the socket becomes writable +again the application will be notified with another +{\bf wxSOCKET\_OUTPUT} event. + +The {\bf wxSOCKET\_CONNECTION} event is issued when a delayed connection +request completes succesfully (client) or when a new connection arrives +at the incoming queue (server). The {\bf wxSOCKET\_LOST} event is issued when a close indication is received for the socket. This means that the connection broke down or -that it was closed by the peer. +that it was closed by the peer. Also, this event will be issued if +a connection request fails. -% --------------------------------------------------------------------------- -% Event handling -% --------------------------------------------------------------------------- \wxheading{Event handling} -To process events from a socket, use the following event handler macro to direct -input to member functions that take a \helpref{wxSocketEvent}{wxsocketevent} argument. +To process events coming from a socket object, use the following event +handler macro to direct events to member functions that take +a \helpref{wxSocketEvent}{wxsocketevent} argument. \twocolwidtha{7cm}% \begin{twocollist}\itemsep=0pt -\twocolitem{{\bf EVT\_SOCKET(id, func)}}{A socket event occured.} -\end{twocollist}% +\twocolitem{{\bf EVT\_SOCKET(id, func)}}{Process a wxEVT\_SOCKET event.} +\end{twocollist} -% --------------------------------------------------------------------------- -% See also ... -% --------------------------------------------------------------------------- \wxheading{See also} -\helpref{wxSocketEvent}{wxsocketevent}\\ -\helpref{wxSocketClient}{wxsocketclient}\\ -\helpref{wxSocketServer}{wxsocketserver} +\helpref{wxSocketEvent}{wxsocketevent}, +\helpref{wxSocketClient}{wxsocketclient}, +\helpref{wxSocketServer}{wxsocketserver}, +\helpref{Sockets sample}{samplesockets} % --------------------------------------------------------------------------- -% Members +% Function groups % --------------------------------------------------------------------------- -\latexignore{\rtfignore{\wxheading{Members}}} -\membersection{wxSocketBase::wxSocketBase} +\latexignore{\rtfignore{\wxheading{Function groups}}} -\func{}{wxSocketBase}{\void} +\membersection{Construction and destruction} -Default constructor. Don't use it; use \helpref{wxSocketClient}{wxsocketclient} -or \helpref{wxSocketServer}{wxsocketserver}. +\helpref{wxSocketBase}{wxsocketbaseconstruct}\\ +\helpref{\destruct{wxSocketBase}}{wxsocketbasedestruct}\\ +\helpref{Destroy}{wxsocketbasedestroy} -\membersection{wxSocketBase::\destruct{wxSocketBase}} +\membersection{Socket state} -\func{}{\destruct{wxSocketBase}}{\void} +Functions to retrieve current state and miscellaneous info. + +\helpref{Error}{wxsocketbaseerror}\\ +\helpref{GetLocal}{wxsocketbasegetlocal}\\ +\helpref{GetPeer}{wxsocketbasegetpeer} +\helpref{IsConnected}{wxsocketbaseisconnected}\\ +\helpref{IsData}{wxsocketbaseisdata}\\ +\helpref{IsDisconnected}{wxsocketbaseisdisconnected}\\ +\helpref{LastCount}{wxsocketbaselastcount}\\ +\helpref{LastError}{wxsocketbaselasterror}\\ +\helpref{Ok}{wxsocketbaseok}\\ +\helpref{SaveState}{wxsocketbasesavestate}\\ +\helpref{RestoreState}{wxsocketbaserestorestate} + +\membersection{Basic IO} + +Functions that perform basic IO functionality. + +\helpref{Close}{wxsocketbaseclose}\\ +\helpref{Discard}{wxsocketbasediscard}\\ +\helpref{Peek}{wxsocketbasepeek}\\ +\helpref{Read}{wxsocketbaseread}\\ +\helpref{ReadMsg}{wxsocketbasereadmsg}\\ +\helpref{Unread}{wxsocketbaseunread}\\ +\helpref{Write}{wxsocketbasewrite}\\ +\helpref{WriteMsg}{wxsocketbasewritemsg} + +Functions that perform a timed wait on a certain IO condition. + +\helpref{InterruptWait}{wxsocketbaseinterruptwait}\\ +\helpref{Wait}{wxsocketbasewait}\\ +\helpref{WaitForLost}{wxsocketbasewaitforlost}\\ +\helpref{WaitForRead}{wxsocketbasewaitforread}\\ +\helpref{WaitForWrite}{wxsocketbasewaitforwrite}\\ + +and also: + +\helpref{wxSocketServer::WaitForAccept}{wxsocketserverwaitforaccept}\\ +\helpref{wxSocketClient::WaitOnConnect}{wxsocketclientwaitonconnect} + +Functions that allow applications to customize socket IO as needed. + +\helpref{GetFlags}{wxsocketbasegetflags}\\ +\helpref{SetFlags}{wxsocketbasesetflags}\\ +\helpref{SetTimeout}{wxsocketbasesettimeout} + +\membersection{Handling socket events} + +Functions that allow applications to receive socket events. + +\helpref{Notify}{wxsocketbasenotify}\\ +\helpref{SetNotify}{wxsocketbasesetnotify}\\ +\helpref{GetClientData}{wxsocketbasegetclientdata}\\ +\helpref{SetClientData}{wxsocketbasesetclientdata}\\ +\helpref{SetEventHandler}{wxsocketbaseseteventhandler} + +Callback functions are also available, but they are provided for backwards +compatibility only. Their use is strongly discouraged in favour of events, +and should be considered deprecated. Callbacks may be unsupported in future +releases of wxWindows. + +\helpref{Callback}{wxsocketbasecallback}\\ +\helpref{CallbackData}{wxsocketbasecallbackdata} -Destroys the wxSocketBase object. % --------------------------------------------------------------------------- -% State functions +% Members here % --------------------------------------------------------------------------- +\helponly{\insertatlevel{2}{ + +\wxheading{Members} + +}} + +\membersection{wxSocketBase::wxSocketBase}\label{wxsocketbaseconstruct} + +\func{}{wxSocketBase}{\void} + +Default constructor. Don't use it directly; instead, use +\helpref{wxSocketClient}{wxsocketclient} to construct a socket client, or +\helpref{wxSocketServer}{wxsocketserver} to construct a socket server. + +\membersection{wxSocketBase::\destruct{wxSocketBase}}\label{wxsocketbasedestruct} + +\func{}{\destruct{wxSocketBase}}{\void} + +Destructor. Do not destroy a socket using the delete operator directly; +use \helpref{Destroy}{wxsocketbasedestroy} instead. Also, do not create +socket objects in the stack. + % -% SetFlags +% Callback % +\membersection{wxSocketBase::Callback}\label{wxsocketbasecallback} -\membersection{wxSocketBase::SetFlags}\label{wxsocketbasesetflags} +\func{wxSocketBase::wxSockCbk}{Callback}{\param{wxSocketBase::wxSockCbk}{ callback}} -\func{void}{SetFlags}{\param{wxSocketBase::wxSockFlags}{ flags}} +You can setup a callback function to be called when an event occurs. +The function will be called only for those events for which notification +has been enabled with \helpref{Notify}{wxsocketbasenotify} and +\helpref{SetNotify}{wxsocketbasesetnotify}. The prototype of the +callback must be as follows: -\twocolwidtha{7cm} -\begin{twocollist}\itemsep=0pt -\twocolitem{{\bf wxSOCKET\_NONE}}{Normal functionnality.} -\twocolitem{{\bf wxSOCKET\_NOWAIT}}{Get the available data in the input queue and return immediately.} -\twocolitem{{\bf wxSOCKET\_WAITALL}}{Wait for all required data unless an error occurs.} -\twocolitem{{\bf wxSOCKET\_BLOCK}}{Block the GUI (do not wxYield) while reading / writing data.} -\end{twocollist} +\begin{verbatim} +void SocketCallback(wxSocketBase& sock, wxSocketNotify evt, char *cdata); +\end{verbatim} -A brief overview on how to use these flags follows. +The first parameter is a reference to the socket object in which the +event occurred. The second parameter tells you which event occurred. +(See \helpref{wxSocket events}{wxsocketbase}). The third parameter +is the user data you specified using \helpref{CallbackData}{wxsocketbasecallbackdata}. -If no flag is specified (this is the same as {\bf wxSOCKET\_NONE}), -IO calls will return after some data has been read or written, even -when the transfer might not be complete. This is the same as issuing -exactly one blocking low-level call to recv() or send(). Note that -blocking here refers to when the function returns, not to whether -the GUI blocks during this time. +\wxheading{Return value} -If {\bf wxSOCKET\_NOWAIT} is specified, IO calls will return immediately. -Read operations will retrieve only available data. Write operations will -write as much data as possible, depending on how much space is available -in the output buffer. This is the same as issuing exactly one nonblocking -low-level call to recv() or send(). Note that nonblocking here refers to -when the function returns, not to whether the GUI blocks during this time. +A pointer to the previous callback. -If {\bf wxSOCKET\_WAITALL} is specified, IO calls won't return until ALL -the data has been read or written (or until an error occurs), blocking if -necessary, and issuing several low level calls if necessary. This is the -same as having a loop which makes as many blocking low-level calls to -recv() or send() as needed so as to transfer all the data. Note that -"blocking" here refers to when the function returns, not to whether -the GUI blocks during this time. +\wxheading{Remark/Warning} -The {\bf wxSOCKET\_BLOCK} controls whether the GUI blocks during IO -operations. If this flag is not used, then the application must take -extra care to avoid unwanted reentrance. +Note that callbacks are now deprecated and unsupported, and they remain +for backwards compatibility only. Use events instead. -So: +\wxheading{See also} -{\bf wxSOCKET\_NONE} will try to read SOME data, no matter how much. -{\bf wxSOCKET\_NOWAIT} will always return immediately, even if it cannot -read or write ANY data. -{\bf wxSOCKET\_WAITALL} will only return when it has read or written ALL -the data. -{\bf wxSOCKET\_BLOCK} has nothing to do with the previous flags and -it control whether the GUI blocks. +\helpref{wxSocketBase::CallbackData}{wxsocketbasecallbackdata}, +\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}, +\helpref{wxSocketBase::Notify}{wxsocketbasenotify} % -% SetNotify +% CallbackData % -\membersection{wxSocketBase::SetNotify}\label{wxsocketbasesetnotify} +\membersection{wxSocketBase::CallbackData}\label{wxsocketbasecallbackdata} -\func{void}{SetNotify}{\param{wxSocketEventFlags}{ flags}} +\func{char *}{CallbackData}{\param{char *}{cdata}} -SetNotify specifies which socket events are to be sent to the event handler. -The {\it flags} parameter is a combination of flags ORed toghether. The -following flags can be used: +This function sets the the user data which will be passed to a +callback function set via \helpref{Callback}{wxsocketbasecallback}. -\twocolwidtha{7cm} -\begin{twocollist}\itemsep=0pt -\twocolitem{{\bf wxSOCKET\_INPUT\_FLAG}}{to receive wxSOCKET\_INPUT} -\twocolitem{{\bf wxSOCKET\_OUTPUT\_FLAG}}{to receive wxSOCKET\_OUTPUT} -\twocolitem{{\bf wxSOCKET\_CONNECTION\_FLAG}}{to receive wxSOCKET\_CONNECTION} -\twocolitem{{\bf wxSOCKET\_LOST\_FLAG}}{to receive wxSOCKET\_LOST} -\end{twocollist}% +\wxheading{Return value} -For example: -\begin{verbatim} - sock.SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG); -\end{verbatim} -In this example, the user will be notified about incoming socket data and -whenever the connection is closed. +A pointer to the previous user data. -For more information on socket events see \helpref{wxSocket events}{wxsocketbase}. +\wxheading{Remark/Warning} + +Note that callbacks are now deprecated and unsupported, and they remain +for backwards compatibility only. Use events instead. + +\wxheading{See also} + +\helpref{wxSocketBase::Callback}{wxsocketbasecallback}, +\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}, +\helpref{wxSocketBase::Notify}{wxsocketbasenotify} % -% SetTimeout +% Close % -\membersection{wxSocketBase::SetTimeout}{wxsocketbasesettimeout} +\membersection{wxSocketBase::Close}\label{wxsocketbaseclose} -\func{void}{SetTimeout}{\param{int }{seconds}} +\func{void}{Close}{\void} -This function sets the default socket timeout in seconds. This -timeout applies to IO calls and also to Wait functions if you -don't specify a wait interval. If you never use SetTimeout, the -default timeout will be 10 minutes. +This function shuts down the socket, disabling further transmission and +reception of data; it also disables events for the socket and frees the +associated system resources. Upon socket destruction, Close is automatically +called, so in most cases you won't need to do it yourself, unless you +explicitly want to shut down the socket, typically to notify the peer +that you are closing the connection. + +\wxheading{Remark/Warning} + +Although Close immediately disables events for the socket, it is possible +that event messages may be waiting in the application's event queue. The +application must therefore be prepared to handle socket event messages +even after calling Close. % -% Notify +% Destroy % -\membersection{wxSocketBase::Notify}\label{wxsocketbasenotify} +\membersection{wxSocketBase::Destroy}\label{wxsocketbasedestroy} -\func{void}{Notify}{\param{bool}{ notify}} +\func{bool}{Destroy}{\void} -Notify will enable (notify is TRUE) or disable (notify is FALSE) the propagation -of socket events. +Destroys the socket safely. Use this function instead of the delete operator, +since otherwise socket events could reach the application even after the +socket has been destroyed. To prevent this problem, this function appends +the wxSocket to a list of object to be deleted on idle time, after all +events have been processed. For the same reason, you should avoid creating +socket objects in the stack. + +Destroy calls \helpref{Close}{wxsocketbaseclose} automatically. + +\wxheading{Return value} + +Always TRUE. -% -% Ok % +% Discard +% +\membersection{wxSocketBase::Discard}\label{wxsocketbasediscard} -\membersection{wxSocketBase::Ok}\label{wxsocketbaseok} +\func{wxSocketBase\&}{Discard}{\void} -\constfunc{bool}{Ok}{\void} +This function simply deletes all bytes in the incoming queue. This function +always returns immediately and its operation is not affected by IO flags. -Returns TRUE if the socket is initialized and ready and FALSE in other -cases. +Use \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually discarded. + +If you use \helpref{Error}{wxsocketbaseerror}, it will always return FALSE. +% +% Error +% \membersection{wxSocketBase::Error}\label{wxsocketbaseerror} \constfunc{bool}{Error}{\void} -Returns TRUE if an error occured in the last IO operation. +Returns TRUE if an error occurred in the last IO operation. + +Use this function to check for an error condition after one of the +following calls: Discard, Peek, Read, ReadMsg, Unread, Write, WriteMsg. + +% +% GetClientData +% +\membersection{wxSocketBase::GetClientData}\label{wxsocketbasegetclientdata} + +\constfunc{void *}{GetClientData}{\void} + +Returns a pointer of the client data for this socket, as set with +\helpref{SetClientData}{wxsocketbasesetclientdata} + +% +% GetLocal +% +\membersection{wxSocketBase::GetLocal}\label{wxsocketbasegetlocal} + +\constfunc{bool}{GetLocal}{\param{wxSockAddress\& }{addr}} + +This function returns the local address field of the socket. The local +address field contains the complete local address of the socket (local +address, local port, ...). + +\wxheading{Return value} + +TRUE if no error happened, FALSE otherwise. + +% +% GetFlags +% +\membersection{wxSocketBase::GetFlags}\label{wxsocketbasegetflags} + +\constfunc{wxSocketFlags}{GetFlags}{\void} -The following operations update the Error() status: -Read, Write, ReadMsg, WriteMsg, Peek, Unread, Discard. +Returns current IO flags, as set with \helpref{SetFlags}{wxsocketbasesetflags} -\membersection{wxSocketBase::IsConnected}\label{wxsocketbaseconnected} +% +% GetPeer +% +\membersection{wxSocketBase::GetPeer}\label{wxsocketbasegetpeer} + +\constfunc{bool}{GetPeer}{\param{wxSockAddress\& }{addr}} + +This function returns the peer address field of the socket. The peer +address field contains the complete peer host address of the socket +(address, port, ...). + +\wxheading{Return value} + +TRUE if no error happened, FALSE otherwise. + +% +% InterruptWait +% +\membersection{wxSocketBase::InterruptWait}\label{wxsocketbaseinterruptwait} + +\func{void}{InterruptWait}{\void} + +Use this function to interrupt any wait operation currently in progress. +Note that this is not intended as a regular way to interrupt a Wait call, +but only as an escape mechanism for exceptional situations where it is +absolutely necessary to use it, for example to abort an operation due to +some exception or abnormal problem. InterruptWait is automatically called +when you \helpref{Close}{wxsocketbaseclose} a socket (and thus also upon +socket destruction), so you don't need to use it in these cases. + +\helpref{wxSocketBase::Wait}{wxsocketbasewait}, +\helpref{wxSocketServer::WaitForAccept}{wxsocketserverwaitforaccept}, +\helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost}, +\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread}, +\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite}, +\helpref{wxSocketClient::WaitOnConnect}{wxsocketclientwaitonconnect} + +% +% IsConnected +% +\membersection{wxSocketBase::IsConnected}\label{wxsocketbaseisconnected} \constfunc{bool}{IsConnected}{\void} Returns TRUE if the socket is connected. +% +% IsData +% \membersection{wxSocketBase::IsData}\label{wxsocketbaseisdata} \constfunc{bool}{IsData}{\void} -Returns TRUE if there is data available to be read. +This function waits until the socket is readable. This might mean that +queued data is available for reading or, for streamed sockets, that +the connection has been closed, so that a read operation will complete +immediately without blocking (unless the {\bf wxSOCKET\_WAITALL} flag +is set, in which case the operation might still block). -\membersection{wxSocketBase::IsDisconnected}\label{wxsocketbasedisconnected} +\membersection{wxSocketBase::IsDisconnected}\label{wxsocketbaseisdisconnected} +% +% IsDisconnected +% \constfunc{bool}{IsDisconnected}{\void} -Returns TRUE if the socket is disconnected. - -\membersection{wxSocketBase::IsNoWait}\label{wxsocketbasenowait} - -\constfunc{bool}{IsNoWait}{\void} - -Returns TRUE if the socket mustn't wait. +Returns TRUE if the socket is not connected. \membersection{wxSocketBase::LastCount}\label{wxsocketbaselastcount} +% +% LastCount +% \constfunc{wxUint32}{LastCount}{\void} Returns the number of bytes read or written by the last IO call. -The following operations update the LastCount() value: -Read, Write, ReadMsg, WriteMsg, Peek, Unread, Discard. +Use this function to get the number of bytes actually transferred +after using one of the following IO calls: Discard, Peek, Read, +ReadMsg, Unread, Write, WriteMsg. +% +% LastError +% \membersection{wxSocketBase::LastError}\label{wxsocketbaselasterror} \constfunc{wxSocketError}{LastError}{\void} @@ -262,102 +455,243 @@ Read, Write, ReadMsg, WriteMsg, Peek, Unread, Discard. Returns the last wxSocket error. See \helpref{wxSocket errors}{wxsocketbase}. Please note that this function merely returns the last error code, -but it should not be used to determine if an error has occured (this -is because successful operations do not change tha LastError value). -Use Error, instead of LastError, to determine if the last IO call -failed. If Error returns TRUE, use LastError to discover the -cause of the error. +but it should not be used to determine if an error has occurred (this +is because successful operations do not change the LastError value). +Use \helpref{Error}{wxsocketbaseerror} first, in order to determine +if the last IO call failed. If this returns TRUE, use LastError +to discover the cause of the error. -% --------------------------------------------------------------------------- -% IO calls -% --------------------------------------------------------------------------- % -% Peek +% Notify % -\membersection{wxSocketBase::Peek}\label{wxsocketbasepeek} +\membersection{wxSocketBase::Notify}\label{wxsocketbasenotify} -\func{wxSocketBase\&}{Peek}{\param{char *}{ buffer}, \param{wxUint32}{ nbytes}} +\func{void}{Notify}{\param{bool}{ notify}} -This function peeks a buffer of {\it nbytes} bytes from the socket. Peeking a buffer -doesn't delete it from the system socket in-queue. +According to the {\it notify} value, this function enables +or disables socket events. If {\it notify} is TRUE, the events +configured with \helpref{SetNotify}{wxsocketbasesetnotify} will +be sent to the application. If {\it notify} is FALSE; no events +will be sent. -Use LastCount to verify the number of bytes actually peeked. +% +% Ok +% +\membersection{wxSocketBase::Ok}\label{wxsocketbaseok} -Use Error to determine if the operation succeeded. +\constfunc{bool}{Ok}{\void} -\wxheading{Parameters} +Returns TRUE if the socket is initialized and ready and FALSE in other +cases. -\docparam{buffer}{Buffer where to put peeked data.} +\wxheading{Remark/Warning} -\docparam{nbytes}{Number of bytes.} +For \helpref{wxSocketClient}{wxsocketclient}, Ok won't return TRUE unless +the client is connected to a server. -\wxheading{Return value} +For \helpref{wxSocketServer}{wxsocketserver}, Ok will return TRUE if the +server could bind to the specified address and is already listening for +new connections. -Returns a reference to the current object. +Ok does not check for IO errors; +use \helpref{Error}{wxsocketbaseerror} instead for that purpose. -\wxheading{Remark/Warning} +% +% RestoreState +% +\membersection{wxSocketBase::RestoreState}\label{wxsocketbaserestorestate} -The exact behaviour of wxSocketBase::Peek() depends on the combination -of flags being used. For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags} +\func{void}{RestoreState}{\void} + +This function restores the previous state of the socket, as saved +with \helpref{SaveState}{wxsocketbasesavestate} + +Calls to SaveState and RestoreState can be nested. \wxheading{See also} -\helpref{wxSocketBase::Error}{wxsocketbaseerror}\\ -\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}\\ -\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\ -\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags} +\helpref{wxSocketBase::SaveState}{wxsocketbasesavestate} % -% Read +% SaveState % -\membersection{wxSocketBase::Read}\label{wxsocketbaseread} +\membersection{wxSocketBase::SaveState}\label{wxsocketbasesavestate} -\func{wxSocketBase\&}{Read}{\param{char *}{ buffer}, \param{wxUint32}{ nbytes}} +\func{void}{SaveState}{\void} -This function reads a buffer of {\it nbytes} bytes from the socket. +This function saves the current state of the socket in a stack. Socket +state includes flags, as set with \helpref{SetFlags}{wxsocketbasesetflags}, +event mask, as set with \helpref{SetNotify}{wxsocketbasesetnotify} and +\helpref{Notify}{wxsocketbasenotify}, user data, as set with +\helpref{SetClientData}{wxsocketbasesetclientdata}, and asynchronous +callback settings, as set with \helpref{Callback}{wxsocketbasecallback} +and \helpref{CallbackData}{wxsocketbasecallbackdata}. -Use LastCount to verify the number of bytes actually read. +Calls to SaveState and RestoreState can be nested. -Use Error to determine if the operation succeeded. +\wxheading{See also} -\wxheading{Parameters} +\helpref{wxSocketBase::RestoreState}{wxsocketbaserestorestate} -\docparam{buffer}{Buffer where to put read data.} +% +% SetClientData +% +\membersection{wxSocketBase::SetClientData}\label{wxsocketbasesetclientdata} -\docparam{nbytes}{Number of bytes.} +\func{void}{SetClientData}{\param{void *}{data}} -\wxheading{Return value} +Sets user-supplied client data for this socket. All socket events will +contain a pointer to this data, which can be retrieved with +the \helpref{wxSocketEvent::GetClientData}{wxsocketeventgetclientdata} function. -Returns a reference to the current object. +% +% SetEventHandler +% +\membersection{wxSocketBase::SetEventHandler}\label{wxsocketbaseseteventhandler} -\wxheading{Remark/Warning} +\func{void}{SetEventHandler}{\param{wxEvtHandler\&}{ handler}, \param{int}{ id = -1}} -The exact behaviour of wxSocketBase::Read() depends on the combination -of flags being used. For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags} +Sets an event handler to be called when a socket event occurs. The +handler will be called for those events for which notification is +enabled with \helpref{SetNotify}{wxsocketbasesetnotify} and +\helpref{Notify}{wxsocketbasenotify}. + +\wxheading{Parameters} + +\docparam{handler}{Specifies the event handler you want to use.} + +\docparam{id}{The id of socket event.} \wxheading{See also} -\helpref{wxSocketBase::Error}{wxsocketbaseerror}\\ -\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}\\ -\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\ -\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags} +\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}, +\helpref{wxSocketBase::Notify}{wxsocketbasenotify}, +\helpref{wxSocketEvent}{wxsocketevent}, +\helpref{wxEvtHandler}{wxevthandler} % -% Write +% SetFlags % -\membersection{wxSocketBase::Write}\label{wxsocketbasewrite} +\membersection{wxSocketBase::SetFlags}\label{wxsocketbasesetflags} -\func{wxSocketBase\&}{Write}{\param{const char *}{ buffer}, \param{wxUint32}{ nbytes}} +\func{void}{SetFlags}{\param{wxSocketFlags}{ flags}} -This function writes a buffer of {\it nbytes} bytes to the socket. +Use SetFlags to customize IO operation for this socket. +The {\it flags} parameter may be a combination of flags ORed toghether. +The following flags can be used: + +\twocolwidtha{7cm} +\begin{twocollist}\itemsep=0pt +\twocolitem{{\bf wxSOCKET\_NONE}}{Normal functionality.} +\twocolitem{{\bf wxSOCKET\_NOWAIT}}{Read/write as much data as possible and return immediately.} +\twocolitem{{\bf wxSOCKET\_WAITALL}}{Wait for all required data to be read/written unless an error occurs.} +\twocolitem{{\bf wxSOCKET\_BLOCK}}{Block the GUI (do not yield) while reading/writing data.} +\end{twocollist} -Use LastCount to verify the number of bytes actually written. +A brief overview on how to use these flags follows. -Use Error to determine if the operation succeeded. +If no flag is specified (this is the same as {\bf wxSOCKET\_NONE}), +IO calls will return after some data has been read or written, even +when the transfer might not be complete. This is the same as issuing +exactly one blocking low-level call to recv() or send(). Note +that {\it blocking} here refers to when the function returns, not +to whether the GUI blocks during this time. + +If {\bf wxSOCKET\_NOWAIT} is specified, IO calls will return immediately. +Read operations will retrieve only available data. Write operations will +write as much data as possible, depending on how much space is available +in the output buffer. This is the same as issuing exactly one nonblocking +low-level call to recv() or send(). Note that {\it nonblocking} here +refers to when the function returns, not to whether the GUI blocks during +this time. + +If {\bf wxSOCKET\_WAITALL} is specified, IO calls won't return until ALL +the data has been read or written (or until an error occurs), blocking if +necessary, and issuing several low level calls if necessary. This is the +same as having a loop which makes as many blocking low-level calls to +recv() or send() as needed so as to transfer all the data. Note +that {\it blocking} here refers to when the function returns, not +to whether the GUI blocks during this time. + +The {\bf wxSOCKET\_BLOCK} flag controls whether the GUI blocks during +IO operations. If this flag is specified, the socket will not yield +during IO calls, so the GUI will remain blocked until the operation +completes. If it is not used, then the application must take extra +care to avoid unwanted reentrance. + +So: + +{\bf wxSOCKET\_NONE} will try to read at least SOME data, no matter how much. + +{\bf wxSOCKET\_NOWAIT} will always return immediately, even if it cannot +read or write ANY data. + +{\bf wxSOCKET\_WAITALL} will only return when it has read or written ALL +the data. + +{\bf wxSOCKET\_BLOCK} has nothing to do with the previous flags and +it controls whether the GUI blocks. + +% +% SetNotify +% +\membersection{wxSocketBase::SetNotify}\label{wxsocketbasesetnotify} + +\func{void}{SetNotify}{\param{wxSocketEventFlags}{ flags}} + +SetNotify specifies which socket events are to be sent to the event handler. +The {\it flags} parameter may be combination of flags ORed toghether. The +following flags can be used: + +\twocolwidtha{7cm} +\begin{twocollist}\itemsep=0pt +\twocolitem{{\bf wxSOCKET\_INPUT\_FLAG}}{to receive wxSOCKET\_INPUT} +\twocolitem{{\bf wxSOCKET\_OUTPUT\_FLAG}}{to receive wxSOCKET\_OUTPUT} +\twocolitem{{\bf wxSOCKET\_CONNECTION\_FLAG}}{to receive wxSOCKET\_CONNECTION} +\twocolitem{{\bf wxSOCKET\_LOST\_FLAG}}{to receive wxSOCKET\_LOST} +\end{twocollist} + +For example: + +\begin{verbatim} + sock.SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG); + sock.Notify(TRUE); +\end{verbatim} + +In this example, the user will be notified about incoming socket data and +whenever the connection is closed. + +For more information on socket events see \helpref{wxSocket events}{wxsocketbase}. + +% +% SetTimeout +% +\membersection{wxSocketBase::SetTimeout}\label{wxsocketbasesettimeout} + +\func{void}{SetTimeout}{\param{int }{seconds}} + +This function sets the default socket timeout in seconds. This timeout +applies to all IO calls, and also to the \helpref{Wait}{wxsocketbasewait} family +of functions if you don't specify a wait interval. Initially, the default +timeout is 10 minutes. + +% +% Peek +% +\membersection{wxSocketBase::Peek}\label{wxsocketbasepeek} + +\func{wxSocketBase\&}{Peek}{\param{void *}{ buffer}, \param{wxUint32}{ nbytes}} + +This function peeks a buffer of {\it nbytes} bytes from the socket. +Peeking a buffer doesn't delete it from the socket input queue. + +Use \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually peeked. + +Use \helpref{Error}{wxsocketbaseerror} to determine if the operation succeeded. \wxheading{Parameters} -\docparam{buffer}{Buffer with the data to be sent.} +\docparam{buffer}{Buffer where to put peeked data.} \docparam{nbytes}{Number of bytes.} @@ -367,36 +701,32 @@ Returns a reference to the current object. \wxheading{Remark/Warning} -The exact behaviour of wxSocketBase::Write() depends on the combination +The exact behaviour of wxSocketBase::Peek depends on the combination of flags being used. For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags} \wxheading{See also} -\helpref{wxSocketBase::Error}{wxsocketbaseerror}\\ -\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}\\ -\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\ +\helpref{wxSocketBase::Error}{wxsocketbaseerror}, +\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}, +\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags} % -% WriteMsg +% Read % -\membersection{wxSocketBase::WriteMsg}\label{wxsocketbasewritemsg} +\membersection{wxSocketBase::Read}\label{wxsocketbaseread} -\func{wxSocketBase\&}{WriteMsg}{\param{const char *}{ buffer}, \param{wxUint32}{ nbytes}} +\func{wxSocketBase\&}{Read}{\param{void *}{ buffer}, \param{wxUint32}{ nbytes}} -This function writes a buffer of {\it nbytes} bytes from the socket, but it -writes a short header before so that ReadMsg can alloc the right size for -the buffer. So, a buffer sent with WriteMsg {\bf must} be read with ReadMsg. -This function always waits for the entire buffer to be sent, unless an -error occurs. +This function reads a buffer of {\it nbytes} bytes from the socket. -Use LastCount to verify the number of bytes actually written. +Use \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually read. -Use Error to determine if the operation succeeded. +Use \helpref{Error}{wxsocketbaseerror} to determine if the operation succeeded. \wxheading{Parameters} -\docparam{buffer}{Buffer with the data to be sent.} +\docparam{buffer}{Buffer where to put read data.} \docparam{nbytes}{Number of bytes.} @@ -406,38 +736,37 @@ Returns a reference to the current object. \wxheading{Remark/Warning} -wxSocketBase::WriteMsg() will behave as if the wxSOCKET_WAITALL flag was always set -and it will always ignore the wxSOCKET_NOWAIT flag. The exact behaviour of WriteMsg -depends on the wxSOCKET_BLOCK flag. For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}. +The exact behaviour of wxSocketBase::Read depends on the combination +of flags being used. For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}. \wxheading{See also} -\helpref{wxSocketBase::Error}{wxsocketbaseerror}\\ -\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}\\ -\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\ -\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}\\ -\helpref{wxSocketBase::ReadMsg}{wxsocketbasereadmsg} +\helpref{wxSocketBase::Error}{wxsocketbaseerror}, +\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}, +\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, +\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags} % % ReadMsg % \membersection{wxSocketBase::ReadMsg}\label{wxsocketbasereadmsg} -\func{wxSocketBase\&}{ReadMsg}{\param{char *}{ buffer}, \param{wxUint32}{ nbytes}} +\func{wxSocketBase\&}{ReadMsg}{\param{void *}{ buffer}, \param{wxUint32}{ nbytes}} -This function reads a buffer sent by WriteMsg on a socket. If the buffer passed -to the function isn't big enough, the remaining bytes will be discarded. This -function always waits for the buffer to be entirely filled, unless an error occurs. +This function reads a buffer sent by \helpref{WriteMsg}{wxsocketbasewritemsg} +on a socket. If the buffer passed to the function isn't big enough, the +remaining bytes will be discarded. This function always waits for the +buffer to be entirely filled, unless an error occurs. -Use LastCount to verify the number of bytes actually read. +Use \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually read. -Use Error to determine if the operation succeeded. +Use \helpref{Error}{wxsocketbaseerror} to determine if the operation succeeded. \wxheading{Parameters} \docparam{buffer}{Buffer where to put read data.} -\docparam{nbytes}{Number of bytes allocated for the buffer.} +\docparam{nbytes}{Size of the buffer.} \wxheading{Return value} @@ -445,16 +774,17 @@ Returns a reference to the current object. \wxheading{Remark/Warning} -wxSocketBase::ReadMsg() will behave as if the wxSOCKET_WAITALL flag was always set -and it will always ignore the wxSOCKET_NOWAIT flag. The exact behaviour of ReadMsg -depends on the wxSOCKET_SPEED flag. For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}. +wxSocketBase::ReadMsg will behave as if the {\bf wxSOCKET\_WAITALL} flag +was always set and it will always ignore the {\bf wxSOCKET\_NOWAIT} flag. +The exact behaviour of ReadMsg depends on the {\bf wxSOCKET\_BLOCK} flag. +For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}. \wxheading{See also} -\helpref{wxSocketBase::Error}{wxsocketbaseerror}\\ -\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}\\ -\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\ -\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}\\ +\helpref{wxSocketBase::Error}{wxsocketbaseerror}, +\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}, +\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, +\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}, \helpref{wxSocketBase::WriteMsg}{wxsocketbasewritemsg} % @@ -462,14 +792,14 @@ depends on the wxSOCKET_SPEED flag. For a detailed explanation, see \helpref{wxS % \membersection{wxSocketBase::Unread}\label{wxsocketbaseunread} -\func{wxSocketBase\&}{Unread}{\param{const char *}{ buffer}, \param{wxUint32}{ nbytes}} +\func{wxSocketBase\&}{Unread}{\param{const void *}{ buffer}, \param{wxUint32}{ nbytes}} This function unreads a buffer. That is, the data in the buffer is put back in the incoming queue. This function is not affected by wxSocket flags. -If you use LastCount, it will always return {\it nbytes}. +If you use \helpref{LastCount}{wxsocketbaselastcount}, it will always return {\it nbytes}. -If you use Error, it will always return FALSE. +If you use \helpref{Error}{wxsocketbaseerror}, it will always return FALSE. \wxheading{Parameters} @@ -483,268 +813,221 @@ Returns a reference to the current object. \wxheading{See also} -\helpref{wxSocketBase::Error}{wxsocketbaseerror}\\ -\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}\\ +\helpref{wxSocketBase::Error}{wxsocketbaseerror}, +\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, \helpref{wxSocketBase::LastError}{wxsocketbaselasterror} % -% Discard +% Wait % -\membersection{wxSocketBase::Discard}\label{wxsocketbasediscard} - -\func{wxSocketBase\&}{Discard}{\void} - -This function simply deletes all bytes in the incoming queue. This function -doesn't wait. That is, it will behave as if the wxSOCKET_NOWAIT flag was set. The -wxSOCKET_SPEED and wxSOCKET_WAITALL flags have no effect on this function. - -Use LastCount to see the number of bytes discarded. - -If you use Error, it will always return FALSE. - -% --------------------------------------------------------------------------- -% Wait functions -% --------------------------------------------------------------------------- \membersection{wxSocketBase::Wait}\label{wxsocketbasewait} \func{bool}{Wait}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}} -This function waits until one of the following conditions is true: there -is data available for reading; the output buffer is empty (you can send -new data); the connection has been lost; an incoming connection arrived -(only for servers); a connection request has completed (only for clients). +This function waits until any of the following conditions is TRUE: + +\begin{itemize} +\item The socket becomes readable. +\item The socket becomes writable. +\item An ongoing connection request has completed (\helpref{wxSocketClient}{wxsocketclient} only) +\item An incoming connection request has arrived (\helpref{wxSocketServer}{wxsocketserver} only) +\item The connection has been closed. +\end{itemize} + +Note that it is recommended to use the individual Wait functions +to wait for the required condition, instead of this one. \wxheading{Parameters} -\docparam{seconds}{Number of seconds to wait. If -1, it will wait for the default timeout set with SetTimeout.} +\docparam{seconds}{Number of seconds to wait. +If -1, it will wait for the default timeout, +as set with \helpref{SetTimeout}{wxsocketbasesettimeout}.} \docparam{millisecond}{Number of milliseconds to wait.} \wxheading{Return value} -Returns TRUE if an event occured, FALSE if the timeout was reached. +Returns TRUE when any of the above conditions is satisfied, +FALSE if the timeout was reached. \wxheading{See also} -\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread}\\ -\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite}\\ -\helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost} +\helpref{wxSocketBase::InterruptWait}{wxsocketbaseinterruptwait}, +\helpref{wxSocketServer::WaitForAccept}{wxsocketserverwaitforaccept}, +\helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost}, +\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread}, +\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite}, +\helpref{wxSocketClient::WaitOnConnect}{wxsocketclientwaitonconnect} % -% WaitForRead +% WaitForLost % -\membersection{wxSocketBase::WaitForRead}\label{wxsocketbasewaitforread} +\membersection{wxSocketBase::WaitForLost}\label{wxsocketbasewaitforlost} -\func{bool}{WaitForRead}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}} +\func{bool}{Wait}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}} -This function waits until there is data available to be read. +This function waits until the connection is lost. This may happen if +the peer gracefully closes the connection or if the connection breaks. \wxheading{Parameters} -\docparam{seconds}{Number of seconds to wait. If -1, it will wait for the default timeout set with SetTimeout.} +\docparam{seconds}{Number of seconds to wait. +If -1, it will wait for the default timeout, +as set with \helpref{SetTimeout}{wxsocketbasesettimeout}.} \docparam{millisecond}{Number of milliseconds to wait.} \wxheading{Return value} -Returns TRUE if there is data to be read, FALSE if the timeout was reached. +Returns TRUE if the connection was lost, FALSE if the timeout was reached. \wxheading{See also} -\helpref{wxSocketBase::Wait}{wxsocketbasewait}\\ -\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite}\\ -\helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost} +\helpref{wxSocketBase::InterruptWait}{wxsocketbaseinterruptwait}, +\helpref{wxSocketBase::Wait}{wxsocketbasewait} % -% WaitForWrite +% WaitForRead % -\membersection{wxSocketBase::WaitForWrite}\label{wxsocketbasewaitforwrite} +\membersection{wxSocketBase::WaitForRead}\label{wxsocketbasewaitforread} -\func{bool}{WaitForWrite}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}} +\func{bool}{WaitForRead}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}} -This function waits until you can write to the socket. +This function waits until the socket is readable. This might mean that +queued data is available for reading or, for streamed sockets, that +the connection has been closed, so that a read operation will complete +immediately without blocking (unless the {\bf wxSOCKET\_WAITALL} flag +is set, in which case the operation might still block). \wxheading{Parameters} -\docparam{seconds}{Number of seconds to wait. If -1, it will wait for the default timeout set with SetTimeout.} +\docparam{seconds}{Number of seconds to wait. +If -1, it will wait for the default timeout, +as set with \helpref{SetTimeout}{wxsocketbasesettimeout}.} \docparam{millisecond}{Number of milliseconds to wait.} \wxheading{Return value} -Returns TRUE if you can write to the socket, FALSE if the timeout was reached. +Returns TRUE if the socket becomes readable, FALSE on timeout. \wxheading{See also} -\helpref{wxSocketBase::Wait}{wxsocketbasewait}\\ -\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread}\\ -\helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost} +\helpref{wxSocketBase::InterruptWait}{wxsocketbaseinterruptwait}, +\helpref{wxSocketBase::Wait}{wxsocketbasewait} % -% WaitForLost +% WaitForWrite % -\membersection{wxSocketBase::WaitForLost}\label{wxsocketbasewaitforlost} +\membersection{wxSocketBase::WaitForWrite}\label{wxsocketbasewaitforwrite} -\func{bool}{Wait}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}} +\func{bool}{WaitForWrite}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}} -This function waits until the connection is lost. This may happen if the -peer closes the connection or if the connection breaks. +This function waits until the socket becomes writable. This might mean that +the socket is ready to send new data, or for streamed sockets, that the +connection has been closed, so that a write operation is guaranteed to +complete immediately (unless the {\bf wxSOCKET\_WAITALL} flag is set, +in which case the operation might still block). \wxheading{Parameters} -\docparam{seconds}{Number of seconds to wait. If -1, it will wait for the default timeout set with SetTimeout.} +\docparam{seconds}{Number of seconds to wait. +If -1, it will wait for the default timeout, +as set with \helpref{SetTimeout}{wxsocketbasesettimeout}.} \docparam{millisecond}{Number of milliseconds to wait.} \wxheading{Return value} -Returns TRUE if the connection was lost, FALSE if the timeout was reached. +Returns TRUE if the socket becomes writable, FALSE on timeout. \wxheading{See also} -\helpref{wxSocketBase::WaitForRead}{wxsocketbasewaitforread}\\ -\helpref{wxSocketBase::WaitForWrite}{wxsocketbasewaitforwrite}\\ -\helpref{wxSocketBase::WaitForLost}{wxsocketbasewaitforlost} - -% --------------------------------------------------------------------------- -% Socket state -% --------------------------------------------------------------------------- +\helpref{wxSocketBase::InterruptWait}{wxsocketbaseinterruptwait}, +\helpref{wxSocketBase::Wait}{wxsocketbasewait} % -% RestoreState +% Write % -\membersection{wxSocketBase::RestoreState}\label{wxsocketbaserestorestate} - -\func{void}{RestoreState}{\void} - -This function restores the previous state of the socket, as saved -with SaveState. - -Calls to SaveState / RestoreState can be nested. +\membersection{wxSocketBase::Write}\label{wxsocketbasewrite} -\wxheading{See also} +\func{wxSocketBase\&}{Write}{\param{const void *}{ buffer}, \param{wxUint32}{ nbytes}} -\helpref{wxSocketBase::SaveState}{wxsocketbasesavestate} +This function writes a buffer of {\it nbytes} bytes to the socket. -% -% SaveState -% -\membersection{wxSocketBase::SaveState}\label{wxsocketbasesavestate} +Use \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually written. -\func{void}{SaveState}{\void} +Use \helpref{Error}{wxsocketbaseerror} to determine if the operation succeeded. -This function saves the current state of the socket object in a stack: -actually it saves all flags (those set with SetFlags, SetNotify, Notfy) -and the state of the asynchronous callbacks (Callback, CallbackData). +\wxheading{Parameters} -Calls to SaveState / RestoreState can be nested. +\docparam{buffer}{Buffer with the data to be sent.} -\wxheading{See also} +\docparam{nbytes}{Number of bytes.} -\helpref{wxSocketBase::RestoreState}{wxsocketbaserestorestate} +\wxheading{Return value} -% -% GetLocal -% -\membersection{wxSocketBase::GetLocal}{wxsocketbasegetlocal} +Returns a reference to the current object. -\constfunc{bool}{GetLocal}{\param{wxSockAddress\& }{addr_man}} +\wxheading{Remark/Warning} -This function returns the local address field of the socket. The local -address field contains the complete local address of the socket (local -address, local port, ...). +The exact behaviour of wxSocketBase::Write depends on the combination +of flags being used. For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}. -\wxheading{Return value} +\wxheading{See also} -It returns TRUE if no errors happened, FALSE otherwise. +\helpref{wxSocketBase::Error}{wxsocketbaseerror}, +\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}, +\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, +\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags} % -% GetPeer +% WriteMsg % -\membersection{wxSocketBase::GetPeer}{wxsocketbasegetlocal} - -\constfunc{bool}{GetPeer}{\param{wxSockAddress\& }{addr_man}} - -This function returns the peer address field of the socket. The peer -address field contains the complete peer host address of the socket -(address, port, ...). - -\wxheading{Return value} - -It returns TRUE if no errors happened, FALSE otherwise. +\membersection{wxSocketBase::WriteMsg}\label{wxsocketbasewritemsg} -% --------------------------------------------------------------------------- -% Socket callbacks -% --------------------------------------------------------------------------- -\membersection{wxSocketBase::SetEventHandler}\label{wxsocketbaseseteventhandler} +\func{wxSocketBase\&}{WriteMsg}{\param{const void *}{ buffer}, \param{wxUint32}{ nbytes}} -\func{void}{SetEventHandler}{\param{wxEvtHandler\&}{ evt\_hdlr}, \param{int}{ id = -1}} +This function writes a buffer of {\it nbytes} bytes from the socket, but it +writes a short header before so that \helpref{ReadMsg}{wxsocketbasereadmsg} +knows how much data should it actually read. So, a buffer sent with WriteMsg +{\bf must} be read with ReadMsg. This function always waits for the entire +buffer to be sent, unless an error occurs. -Sets an event handler to be called when a socket event occurs. The handler -will be called for those events for which notification is enabled with -SetNotify and Notify. +Use \helpref{LastCount}{wxsocketbaselastcount} to verify the number of bytes actually written. -You can also specify a C callback to be called when an event occurs. See -Callback and CallbackData. +Use \helpref{Error}{wxsocketbaseerror} to determine if the operation succeeded. \wxheading{Parameters} -\docparam{evt\_hdlr}{Specifies the event handler you want to use.} - -\docparam{id}{The id of socket event.} - -\wxheading{See also} - -\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}\\ -\helpref{wxSocketBase::Notify}{wxsocketbasenotify}\\ -\helpref{wxSocketEvent}{wxsocketevent}\\ -\helpref{wxEvtHandler}{wxevthandler}\\ -\helpref{wxSocketBase::Callback}{wxsocketbasecallback}\\ -\helpref{wxSocketBase::CallbackData}{wxsocketbasecallbackdata} - -\membersection{wxSocketBase::Callback}\label{wxsocketbasecallback} - -\func{wxSocketBase::wxSockCbk}{Callback}{\param{wxSocketBase::wxSockCbk}{ callback}} - -You can setup a C callback to be called when an event occurs. The callback -will be called only for those events for which notification has been enabled -with Notify and SetNotify. The prototype of the callback must be as follows: - -\begin{verbatim} -void SocketCallback(wxSocketBase& sock,wxSocketNotify evt,char *cdata); -\end{verbatim} +\docparam{buffer}{Buffer with the data to be sent.} -The first parameter is a reference to the socket object in which the event -occured. The second parameter tells you which event occured. (See \helpref{wxSocket events}{wxsocketbase}). -The third parameter is the user data you specified using \helpref{CallbackData}{wxsocketcallbackdata}. +\docparam{nbytes}{Number of bytes to send.} \wxheading{Return value} -A pointer to the previous callback. - -\wxheading{See also} - -\helpref{wxSocketBase::CallbackData}{wxsocketbasecallbackdata}\\ -\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}\\ -\helpref{wxSocketBase::Notify}{wxsocketbasenotify} - -\membersection{wxSocketBase::CallbackData}\label{wxsocketbasecallbackdata} +Returns a reference to the current object. -\func{char *}{CallbackData}{\param{char *}{cdata}} +\wxheading{Remark/Warning} -This function sets the the user data which will be passed to a \helpref{C callback}{wxsocketbasecallback}. +wxSocketBase::WriteMsg will behave as if the {\bf wxSOCKET\_WAITALL} flag +was always set and it will always ignore the {\bf wxSOCKET\_NOWAIT} flag. +The exact behaviour of WriteMsg depends on the {\bf wxSOCKET\_BLOCK} flag. +For a detailed explanation, see \helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}. -\wxheading{Return value} +\wxheading{See also} -A pointer to the previous user data. +\helpref{wxSocketBase::Error}{wxsocketbaseerror}, +\helpref{wxSocketBase::LastError}{wxsocketbaselasterror}, +\helpref{wxSocketBase::LastCount}{wxsocketbaselastcount}, +\helpref{wxSocketBase::SetFlags}{wxsocketbasesetflags}, +\helpref{wxSocketBase::ReadMsg}{wxsocketbasereadmsg} -\helpref{wxSocketBase::Callback}{wxsocketbasecallback}\\ -\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}\\ -\helpref{wxSocketBase::Notify}{wxsocketbasenotify} % --------------------------------------------------------------------------- % CLASS wxSocketClient % --------------------------------------------------------------------------- + \section{\class{wxSocketClient}}\label{wxsocketclient} \wxheading{Derived from} @@ -755,6 +1038,8 @@ A pointer to the previous user data. +\latexignore{\rtfignore{\wxheading{Members}}} + % --------------------------------------------------------------------------- % Members % --------------------------------------------------------------------------- @@ -763,9 +1048,9 @@ A pointer to the previous user data. % \membersection{wxSocketClient::wxSocketClient} -\func{}{wxSocketClient}{\param{wxSockFlags}{ flags = wxSocketBase::NONE}} +\func{}{wxSocketClient}{\param{wxSocketFlags}{ flags = wxSOCKET\_NONE}} -Constructs a new wxSocketClient. +Constructor. \wxheading{Parameters} @@ -778,7 +1063,7 @@ Constructs a new wxSocketClient. \func{}{\destruct{wxSocketClient}}{\void} -Destroys a wxSocketClient object. +Destructor. Please see \helpref{wxSocketBase::Destroy}{wxsocketbasedestroy}. % % Connect @@ -789,38 +1074,38 @@ Destroys a wxSocketClient object. Connects to a server using the specified address. -If {\it wait} is TRUE, Connect will wait until the connection completes and -the socket is ready to send or receive data, or until an event occurs. -{\bf Warning !} This will block the GUI. +If {\it wait} is TRUE, Connect will wait until the connection +completes. {\bf Warning:} This will block the GUI. If {\it wait} is FALSE, Connect will try to establish the connection and return immediately, without blocking the GUI. When used this way, even if Connect returns FALSE, the connection request can be completed later. -To detect this, use WaitConnection, or watch "connection" events (for -succesful establishment) and "lost" events (for connection failure) - +To detect this, use \helpref{WaitOnConnect}{wxsocketclientwaitonconnect}, +or catch {\bf wxSOCKET\_CONNECTION} events (for successful establishment) +and {\bf wxSOCKET\_LOST} events (for connection failure). \wxheading{Parameters} \docparam{address}{Address of the server.} -\docparam{wait}{If true, waits for the connection to be ready.} +\docparam{wait}{If TRUE, waits for the connection to complete.} \wxheading{Return value} Returns TRUE if the connection is established and no error occurs. -If {\it wait} was TRUE, and Connect returns FALSE, an error occured +If {\it wait} was TRUE, and Connect returns FALSE, an error occurred and the connection failed. If {\it wait} was FALSE, and Connect returns FALSE, you should still be prepared to handle the completion of this connection request, either -with WaitOnConnect or by watching "connection" and "lost" events. +with \helpref{WaitOnConnect}{wxsocketclientwaitonconnect} or by +watching {\bf wxSOCKET\_CONNECTION} and {\bf wxSOCKET\_LOST} events. \wxheading{See also} -\helpref{wxSocketClient::WaitOnConnect}{wxsocketclientwaitonconnect}\\ -\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}\\ +\helpref{wxSocketClient::WaitOnConnect}{wxsocketclientwaitonconnect}, +\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}, \helpref{wxSocketBase::Notify}{wxsocketbasenotify} % @@ -830,24 +1115,49 @@ with WaitOnConnect or by watching "connection" and "lost" events. \func{bool}{WaitOnConnect}{\param{long}{ seconds = -1}, \param{long}{ milliseconds = 0}} -Wait until the connection is succesfully established or until it fails. -Use this function after a call to Connect with {\it wait} set to FALSE. +Wait until a connection request completes, or until the specified timeout +elapses. Use this function after issuing a call +to \helpref{Connect}{wxsocketclientconnect} with {\it wait} set to FALSE. \wxheading{Parameters} -\docparam{seconds}{Number of seconds to wait. If -1, it will wait for the default timeout set with SetTimeout.} +\docparam{seconds}{Number of seconds to wait. +If -1, it will wait for the default timeout, +as set with \helpref{SetTimeout}{wxsocketbasesettimeout}.} \docparam{millisecond}{Number of milliseconds to wait.} \wxheading{Return value} -If the connection is succesfully established, it returns TRUE. +WaitOnConnect returns TRUE if the connection request completes. This +does not necessarily mean that the connection was succesfully established; +it might also happen that the connection was refused by the peer. Use +\helpref{IsConnected}{wxsocketbaseisconnected} to distinguish between +these two situations. + +If the timeout elapses, WaitOnConnect returns FALSE. -If the timeout expires, or if the connection fails, it returns FALSE. +These semantics allow code like this: + +\begin{verbatim} +// Issue the connection request +client->Connect(addr, FALSE); + +// Wait until the request completes or until we decide to give up +bool waitmore = TRUE; +while ( !client->WaitOnConnect(seconds, millis) && waitmore ) +{ + // possibly give some feedback to the user, + // and update waitmore as needed. +} +bool success = client->IsConnected(); +\end{verbatim} \wxheading{See also} -\helpref{wxSocketClient::Connect}{wxsocketclientconnect} +\helpref{wxSocketClient::Connect}{wxsocketclientconnect}, +\helpref{wxSocketBase::InterruptWait}{wxsocketbaseinterruptwait}, +\helpref{wxSocketBase::IsConnected}{wxsocketbaseisconnected} % --------------------------------------------------------------------------- % CLASS: wxSocketEvent @@ -866,22 +1176,18 @@ This event class contains information about socket events. \wxheading{Event table macros} -To process a socket event, use these event handler macros to direct input to member -functions that take a wxSocketEvent argument. +To process a socket event, use these event handler macros to direct input +to member functions that take a wxSocketEvent argument. \twocolwidtha{7cm} \begin{twocollist}\itemsep=0pt \twocolitem{{\bf EVT\_SOCKET(id, func)}}{Process a socket event, supplying the member function.} -\end{twocollist}% - -[TODO:] -A brief note on how to use events. -The wxSOCKET_INPUT event is generated when the +\end{twocollist} \wxheading{See also} -\helpref{wxSocketBase}{wxsocketbase},\rtfsp -\helpref{wxSocketClient}{wxsocketclient},\rtfsp +\helpref{wxSocketBase}{wxsocketbase}, +\helpref{wxSocketClient}{wxsocketclient}, \helpref{wxSocketServer}{wxsocketserver} \latexignore{\rtfignore{\wxheading{Members}}} @@ -892,9 +1198,23 @@ The wxSOCKET_INPUT event is generated when the Constructor. -\membersection{wxSocketEvent::SocketEvent}\label{wxsocketeventsocketevent} +\membersection{wxSocketEvent::GetClientData}\label{wxsocketeventgetclientdata} + +\func{void *}{GetClientData}{\void} + +Gets the client data of the socket which generated this event, as +set with \helpref{wxSocketBase::SetClientData}{wxsocketbasesetclientdata}. -\constfunc{wxSocketNotify}{SocketEvent}{\void} +\membersection{wxSocketEvent::GetSocket}\label{wxsocketeventgetsocket} + +\constfunc{wxSocketBase *}{GetSocket}{\void} + +Returns the socket object to which this event refers to. This makes +it possible to use the same event handler for different sockets. + +\membersection{wxSocketEvent::GetSocketEvent}\label{wxsocketeventgetsocketevent} + +\constfunc{wxSocketNotify}{GetSocketEvent}{\void} Returns the socket event type. @@ -921,9 +1241,11 @@ Returns the socket event type. % \membersection{wxSocketServer::wxSocketServer}\label{wxsocketserverconstr} -\func{}{wxSocketServer}{\param{wxSockAddress\&}{ address}, \param{wxSockFlags}{ flags = wxSocketBase::NONE}} +\func{}{wxSocketServer}{\param{wxSockAddress\&}{ address}, \param{wxSocketFlags}{ flags = wxSOCKET\_NONE}} -Constructs a new wxSocketServer. +Constructs a new server and tries to bind to the specified {\it address}. +Before trying to accept new connections, test whether it succeeded with +\helpref{wxSocketBase::Ok}{wxsocketbaseok}. \wxheading{Parameters} @@ -938,39 +1260,41 @@ Constructs a new wxSocketServer. \func{}{\destruct{wxSocketServer}}{\void} -Destroys a wxSocketServer object (it doesn't close the accepted connections). +Destructor (it doesn't close the accepted connections). % % Accept % -\membersection{wxSocketServer::Accept} +\membersection{wxSocketServer::Accept}\label{wxsocketserveraccept} \func{wxSocketBase *}{Accept}{\param{bool}{ wait = TRUE}} -Creates a new object wxSocketBase and accepts an incoming connection. +Accepts an incoming connection request, and creates a new +\helpref{wxSocketBase}{wxsocketbase} object which represents +the server-side of the connection. If {\it wait} is TRUE and there are no pending connections to be -accepted, it will wait for the next incoming connection to arrive. -{\bf Warning !} This will block the GUI. +accepted, it will wait for the next incoming connection to +arrive. {\bf Warning:} This will block the GUI. If {\it wait} is FALSE, it will try to accept a pending connection -if there is one, but it will always return immediately without -blocking the GUI. If you want to use Accept in this way, you can -either check for incoming connections with WaitForAccept or watch -"connection" events, then call Accept once you know that there is -an incoming connection waiting to be accepted. +if there is one, but it will always return immediately without blocking +the GUI. If you want to use Accept in this way, you can either check for +incoming connections with \helpref{WaitForAccept}{wxsocketserverwaitforaccept} +or catch {\bf wxSOCKET\_CONNECTION} events, then call Accept once you know +that there is an incoming connection waiting to be accepted. \wxheading{Return value} -Returns an opened socket connection, or NULL if an error occured or +Returns an opened socket connection, or NULL if an error occurred or if the {\it wait} parameter was FALSE and there were no pending connections. \wxheading{See also} -\helpref{wxSocketServer::WaitForAccept}{wxsocketbasewaitforaccept}\\ -\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}\\ -\helpref{wxSocketBase::Notify}{wxsocketbasenotify}\\ +\helpref{wxSocketServer::WaitForAccept}{wxsocketserverwaitforaccept}, +\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}, +\helpref{wxSocketBase::Notify}{wxsocketbasenotify}, \helpref{wxSocketServer::AcceptWith}{wxsocketserveracceptwith} % @@ -981,7 +1305,6 @@ connections. \func{bool}{AcceptWith}{\param{wxSocketBase\&}{ socket}, \param{bool}{ wait = TRUE}} Accept an incoming connection using the specified socket object. -This is useful when someone wants to inherit wxSocketBase. \wxheading{Parameters} @@ -989,15 +1312,14 @@ This is useful when someone wants to inherit wxSocketBase. \wxheading{Return value} -Returns TRUE on success, or FALSE if an error occured or if the +Returns TRUE on success, or FALSE if an error occurred or if the {\it wait} parameter was FALSE and there were no pending connections. -\helpref{wxSocketServer::WaitForAccept}{wxsocketbasewaitforaccept}\\ -\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}\\ -\helpref{wxSocketBase::Notify}{wxsocketbasenotify}\\ -\helpref{wxSocketServer::Accept}{wxsocketserveraccept} for a detailed explanation - +\helpref{wxSocketServer::WaitForAccept}{wxsocketserverwaitforaccept}, +\helpref{wxSocketBase::SetNotify}{wxsocketbasesetnotify}, +\helpref{wxSocketBase::Notify}{wxsocketbasenotify}, +\helpref{wxSocketServer::Accept}{wxsocketserveraccept} % % WaitForAccept @@ -1006,23 +1328,26 @@ connections. \func{bool}{WaitForAccept}{\param{long}{ seconds = -1}, \param{long}{ millisecond = 0}} -This function waits for an incoming connection. Use it if you want to call -Accept or AcceptWith with {\it wait} set to FALSE, to detect when an incoming -connection is waiting to be accepted. +This function waits for an incoming connection. Use it if you want to call +\helpref{Accept}{wxsocketserveraccept} or \helpref{AcceptWith}{wxsocketserveracceptwith} +with {\it wait} set to FALSE, to detect when an incoming connection is waiting +to be accepted. \wxheading{Parameters} -\docparam{seconds}{Number of seconds to wait. If -1, it will wait for the default timeout set with SetTimeout.} +\docparam{seconds}{Number of seconds to wait. +If -1, it will wait for the default timeout, +as set with \helpref{SetTimeout}{wxsocketbasesettimeout}.} \docparam{millisecond}{Number of milliseconds to wait.} \wxheading{Return value} -Returns TRUE if an incoming connection arrived, FALSE if the timeout expired. +Returns TRUE if an incoming connection arrived, FALSE if the timeout elapsed. \wxheading{See also} -\helpref{wxSocketServer::Accept}{wxsocketserveraccept}\\ -\helpref{wxSocketServer::AcceptWith}{wxsocketserveracceptwith} - +\helpref{wxSocketServer::Accept}{wxsocketserveraccept}, +\helpref{wxSocketServer::AcceptWith}{wxsocketserveracceptwith}, +\helpref{wxSocketBase::InterruptWait}{wxsocketbaseinterruptwait}