-#ifndef STLPLUS_TCP_SOCKET
-#define STLPLUS_TCP_SOCKET
-////////////////////////////////////////////////////////////////////////////////
-
-// Author: Andy Rushton
-// Copyright: (c) Southampton University 1999-2004
-// (c) Andy Rushton 2004-2009
-// License: BSD License, see ../docs/license.html
-
-// A platform-independent (Unix and Windows anyway) interface to TCP sockets
-
-////////////////////////////////////////////////////////////////////////////////
-
-#include "portability_fixes.hpp"
-#include "ip_sockets.hpp"
-#include <string>
-
-namespace stlplus
-{
-
- //////////////////////////////////////////////////////////////////////////////
- // Server Classes: A server creates a listening port which waits for incoming
- // connections. This is placed on the port number appropriate for the service
- // - for example, a Telnet server would typically use port 23. For a new
- // service you should of course use any port not allocated to a standard
- // service. I believe that RFC 1700 defines the standard service port numbers.
- // When an incoming connection is made, the server accepts it and in the
- // process creates a new connection on a different port. This leaves the
- // standard port listening for further connections. In effect, the server
- // farms out the handling of the connections themselves and only takes
- // responsibility for accepting the connection. This is reflected in the class
- // structure. A TCP_server performs the listening and accepting roles, but
- // creates a TCP_connection to handle the accepted connection.
- //////////////////////////////////////////////////////////////////////////////
-
- //////////////////////////////////////////////////////////////////////////////
- // connection class created by TCP_server when a connection is accepted
- // this is then used to perform any communications with the remote client
-
- class TCP_connection : protected IP_socket
- {
- private:
- // constructor to actually initialise the class - can only be constructed by TCP_server
- friend class TCP_server;
- TCP_connection(const IP_socket& socket);
-
- public:
-
- ////////////////////////////////////////////////////////////////////////////
- // constructors/destructors
-
- // create an uninitialised connection
- TCP_connection(void);
-
- ////////////////////////////////////////////////////////////////////////////
- // initialisation, connection control
- // Note: TCP connections can only be initialised by a TCP server
-
- // test whether this is an initialised socket
- // - returns whether this is initialised
- // bool initialised(void) const;
- using IP_socket::initialised;
-
- // close, i.e. disconnect the socket
- // - returns a success flag
- // bool close(void);
- using IP_socket::close;
-
- ////////////////////////////////////////////////////////////////////////////
- // sending/receiving
-
- // test whether a socket is connected and ready to send data, returns if ready or on timeout
- // - timeout: how long to wait in microseconds if not connected yet (blocking)
- // - returns status
- // bool send_ready(unsigned timeout = 0);
- using IP_socket::send_ready;
-
- // send data through the socket - if the data is long only part of it may
- // be sent. The sent part is removed from the data, so the same string can
- // be sent again and again until it is empty.
- // - data: string containing data to be sent - any data successfully sent is removed
- // - returns success flag
- // bool send (std::string& data);
- using IP_socket::send;
-
- // test whether a socket is connected and ready to receive data, returns if ready or on timeout
- // - timeout: how long to wait in microseconds if not connected yet (blocking)
- // - returns status
- // bool receive_ready(unsigned timeout = 0);
- using IP_socket::receive_ready;
-
- // receive data through the socket - if the data is long only part of it
- // may be received. The received data is appended to the string, building
- // it up in stages, so the same string can be received again and again
- // until all information has been received.
- // - data: string receiving data from socket - any data successfully received is appended
- // - returns success flag
- // bool receive (std::string& data);
- using IP_socket::receive;
-
- ////////////////////////////////////////////////////////////////////////////
- // informational
-
- // the local port number of the connection
- // - returns the port number, 0 if not bound to a port
- // unsigned short local_port(void) const;
- using IP_socket::local_port;
-
- // the remote address of the connection
- // - returns the address, 0 if not connected
- // unsigned long remote_address(void) const;
- using IP_socket::remote_address;
-
- // the remote port number of the connection
- // - returns the port number, 0 if not connected to a port
- // unsigned short remote_port(void) const;
- using IP_socket::remote_port;
-
- ////////////////////////////////////////////////////////////////////////////
- // error handling
- // errors are set internally
- // an error code of 0 is the test for no error, don't rely on the message being an empty string
- // an error code != 0 means an error, then there will be a message explaining the error
-
- // if an error is set it stays set - so you must clear it before further operations
- // void clear_error(void) const;
- using IP_socket::clear_error;
-
- // get the error code of the last error
- // int error(void) const;
- using IP_socket::error;
-
- // get the explanatory message of the last error
- // std::string message(void) const;
- using IP_socket::message;
-
- ////////////////////////////////////////////////////////////////////////////
-
- // deprecated version of remote_port
- unsigned short port(void) const;
-
- ////////////////////////////////////////////////////////////////////////////
- };
-
- //////////////////////////////////////////////////////////////////////////////
- // server class that does the listening on the designated port
- // incoming connections can be queued up to a maximum queue length specified
- // in the constructor/initialise
-
- class TCP_server : protected IP_socket
- {
- public:
-
- // create an uninitialised server
- TCP_server(void);
-
- // initialise a socket and set it up to be a listening port
- // - port: port to listen on
- // - queue: length of backlog queue to manage - may be zero
- // - returns success status
- TCP_server(unsigned short port, unsigned short queue = 0);
-
- ////////////////////////////////////////////////////////////////////////////
- // initialisation
-
- // initialise a socket and set it up to be a listening port
- // - port: port to listen on
- // - queue: length of backlog queue to manage - may be zero
- // - returns success status
- bool initialise(unsigned short port, unsigned short queue = 0);
-
- // test whether this is an initialised socket
- // - returns whether this is initialised
- // bool initialised(void) const;
- using IP_socket::initialised;
-
- // close, i.e. disconnect the socket
- // - returns a success flag
- // bool close(void);
- using IP_socket::close;
-
- //////////////////////////////////////////////////////////////////////////////
- // server operation - accepting a connection
-
- // test for a connection on the object's socket - only applicable if it has been set up as a listening port
- // - timeout: how long to wait in microseconds if not connected yet
- // - returns true if a connection is ready to be accepted
- // bool accept_ready(unsigned timeout = 0);
- using IP_socket::accept_ready;
-
- // accept a connection on the object's socket - only applicable if it has been set up as a listening port
- // - returns the connection as a new socket
- TCP_connection accept(void);
-
- ////////////////////////////////////////////////////////////////////////////
- // error handling
- // errors are set internally
- // an error code of 0 is the test for no error, don't rely on the message being an empty string
- // an error code != 0 means an error, then there will be a message explaining the error
-
- // if an error is set it stays set - so you must clear it before further operations
- // void clear_error (void) const;
- using IP_socket::clear_error;
-
- // get the error code of the last error
- // int error(void) const;
- using IP_socket::error;
-
- // get the explanatory message of the last error
- // std::string message(void) const;
- using IP_socket::message;
-
- //////////////////////////////////////////////////////////////////////////////
-
- // deprecated versions of accept_ready and accept
- bool connection_ready(unsigned timeout = 0);
- TCP_connection connection(void);
-
- //////////////////////////////////////////////////////////////////////////////
- };
-
- ////////////////////////////////////////////////////////////////////////////////
- // Client Class: a client is simpler in that there is no listening port - you
- // just create a connection and get on with it. Thus the client class does the
- // whole job - create the connection and handle communications to/from it.
- //
- // Blocking mode: To use the client in blocking mode, use non-zero timeout for
- // the initialisation method. In this mode, the connection operation must
- // complete before the call will return or an error is indicated if the
- // timeout is reached without completion. This usage was designed for
- // applications which either just to TCP and nothing else or which do TCP
- // operations in a separate thread.
- //
- // Non-blocking mode: To use the client in non-blocking mode, use a zero
- // timeout for the initialisation method. Instead, you can ask it if it has
- // connected once you've initialised it. It is not an error for it to be
- // initialised but not connected. This usage was designed so that you can poll
- // the connection periodically to implement a timeout for as long as you like for
- // the connection to occur without blocking the thread that uses the client.
- //
- // In both modes, the send_ready/receive_ready methods can be called with any
- // timeout including zero.
-
- class TCP_client : protected IP_socket
- {
- public:
-
- // create an uninitialised client
- TCP_client(void);
-
- // client connect to a server
- // - remote_address: IP name (stlplus.sourceforge.net) or dotted number (216.34.181.96)
- // - remote_port: port number of remote host
- // - timeout: if 0, don't wait; if >0 wait for that microseconds for connection to be confirmed
- TCP_client(const std::string& remote_address, unsigned short remote_port, unsigned timeout = 0);
-
- // client connect to a server
- // - remote_address: IP address as a long integer - generated by stlplus::ip_lookup
- // - remote_port: port number of remote host
- // - timeout: if 0, don't wait; if >0 wait for that microseconds for connection to be confirmed
- TCP_client(unsigned long remote_address, unsigned short remote_port, unsigned timeout = 0);
-
- ////////////////////////////////////////////////////////////////////////////
- // initialisation, connection
-
- // function for performing IP lookup (i.e. gethostbyname)
- // could be standalone but making it a member means that it can use the socket's error handler
- // i.e. if this fails, the sockets error code will be set - clear it to use the socket again
- // - remote_address: IP name (stlplus.sourceforge.net) or dotted number (216.34.181.96)
- // - returns the IP address as a long integer - zero if there's an error
- // unsigned long ip_lookup(const std::string& remote_address);
- using IP_socket::ip_lookup;
-
- // client connect to a server
- // - remote_address: IP name (stlplus.sourceforge.net) or dotted number (216.34.181.96)
- // - remote_port: port number of remote host
- // - timeout: if 0, don't wait; if >0 wait for that microseconds for connection to be confirmed
- // - returns a success flag
- bool initialise(const std::string& remote_address, unsigned short remote_port, unsigned timeout = 0);
-
- // client connect to a server
- // - remote_address: IP address as a long integer - generated by stlplus::ip_lookup
- // - remote_port: port number of remote host
- // - timeout: if 0, don't wait; if >0 wait for that microseconds for connection to be confirmed
- // - returns a success flag
- bool initialise(unsigned long remote_address, unsigned short remote_port, unsigned timeout = 0);
-
- // test whether this is an initialised socket
- // - returns whether this is initialised
- // bool initialised(void) const;
- using IP_socket::initialised;
-
- // test whether a socket is connected and ready to communicate, returns on successful connect or timeout
- // - timeout: how long to wait in microseconds if not connected yet
- // - returns success flag
- // bool connected(unsigned timeout = 0);
- using IP_socket::connected;
-
- // close, i.e. disconnect the socket
- // - returns a success flag
- // bool close(void);
- using IP_socket::close;
-
- ////////////////////////////////////////////////////////////////////////////
- // sending/receiving
-
- // test whether a socket is connected and ready to send data, returns if ready or on timeout
- // - timeout: how long to wait in microseconds if not connected yet (blocking)
- // - returns status
- // bool send_ready(unsigned timeout = 0);
- using IP_socket::send_ready;
-
- // send data through the socket - if the data is long only part of it may
- // be sent. The sent part is removed from the data, so the same string can
- // be sent again and again until it is empty.
- // - data: string containing data to be sent - any data successfully sent is removed
- // - returns success flag
- // bool send (std::string& data);
- using IP_socket::send;
-
- // test whether a socket is connected and ready to receive data, returns if ready or on timeout
- // - timeout: how long to wait in microseconds if not connected yet (blocking)
- // - returns status
- // bool receive_ready(unsigned timeout = 0);
- using IP_socket::receive_ready;
-
- // receive data through the socket - if the data is long only part of it
- // may be received. The received data is appended to the string, building
- // it up in stages, so the same string can be received again and again
- // until all information has been received.
- // - data: string receiving data from socket - any data successfully received is appended
- // - returns success flag
- // bool receive (std::string& data);
- using IP_socket::receive;
-
- ////////////////////////////////////////////////////////////////////////////
- // informational
-
- // the local port number of the connection
- // - returns the port number, 0 if not bound to a port
- // unsigned short local_port(void) const;
- using IP_socket::local_port;
-
- // the remote address of the connection
- // - returns the address, 0 if not connected
- // unsigned long remote_address(void) const;
- using IP_socket::remote_address;
-
- // the remote port number of the connection
- // - returns the port number, 0 if not connected to a port
- // unsigned short remote_port(void) const;
- using IP_socket::remote_port;
-
- ////////////////////////////////////////////////////////////////////////////
- // error handling
- // errors are set internally
- // an error code of 0 is the test for no error, don't rely on the message being an empty string
- // an error code != 0 means an error, then there will be a message explaining the error
-
- // if an error is set it stays set - so you must clear it before further operations
- // void clear_error (void) const;
- using IP_socket::clear_error;
-
- // get the error code of the last error
- // int error(void) const;
- using IP_socket::error;
-
- // get the explanatory message of the last error
- // std::string message(void) const;
- using IP_socket::message;
-
- //////////////////////////////////////////////////////////////////////////////
-
- // deprecated versions
- unsigned long address(void) const;
- unsigned short port(void) const;
-
- //////////////////////////////////////////////////////////////////////////////
- };
-
- ////////////////////////////////////////////////////////////////////////////////
-
-} // end namespace stlplus
-
-#endif
+#ifndef STLPLUS_TCP_SOCKET\r
+#define STLPLUS_TCP_SOCKET\r
+////////////////////////////////////////////////////////////////////////////////\r
+\r
+// Author: Andy Rushton\r
+// Copyright: (c) Southampton University 1999-2004\r
+// (c) Andy Rushton 2004 onwards\r
+// License: BSD License, see ../docs/license.html\r
+\r
+// A platform-independent (Unix and Windows anyway) interface to TCP sockets\r
+\r
+////////////////////////////////////////////////////////////////////////////////\r
+\r
+#include "portability_fixes.hpp"\r
+#include "ip_sockets.hpp"\r
+#include <string>\r
+\r
+namespace stlplus\r
+{\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ // Server Classes: A server creates a listening port which waits for incoming\r
+ // connections. This is placed on the port number appropriate for the service\r
+ // - for example, a Telnet server would typically use port 23. For a new\r
+ // service you should of course use any port not allocated to a standard\r
+ // service. I believe that RFC 1700 defines the standard service port numbers.\r
+ // When an incoming connection is made, the server accepts it and in the\r
+ // process creates a new connection on a different port. This leaves the\r
+ // standard port listening for further connections. In effect, the server\r
+ // farms out the handling of the connections themselves and only takes\r
+ // responsibility for accepting the connection. This is reflected in the class\r
+ // structure. A TCP_server performs the listening and accepting roles, but\r
+ // creates a TCP_connection to handle the accepted connection.\r
+ //////////////////////////////////////////////////////////////////////////////\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ // connection class created by TCP_server when a connection is accepted\r
+ // this is then used to perform any communications with the remote client\r
+\r
+ class TCP_connection : protected IP_socket\r
+ {\r
+ private:\r
+ // constructor to actually initialise the class - can only be constructed by TCP_server\r
+ friend class TCP_server;\r
+ TCP_connection(const IP_socket& socket);\r
+\r
+ public:\r
+\r
+ ////////////////////////////////////////////////////////////////////////////\r
+ // constructors/destructors\r
+\r
+ // create an uninitialised connection\r
+ TCP_connection(void);\r
+\r
+ ////////////////////////////////////////////////////////////////////////////\r
+ // initialisation, connection control\r
+ // Note: TCP connections can only be initialised by a TCP server\r
+\r
+ // test whether this is an initialised socket\r
+ // - returns whether this is initialised\r
+ // bool initialised(void) const;\r
+ using IP_socket::initialised;\r
+\r
+ // close, i.e. disconnect the socket\r
+ // - returns a success flag\r
+ // bool close(void);\r
+ using IP_socket::close;\r
+\r
+ ////////////////////////////////////////////////////////////////////////////\r
+ // sending/receiving\r
+\r
+ // test whether a socket is connected and ready to send data, returns if ready or on timeout\r
+ // - timeout: how long to wait in microseconds if not connected yet (blocking)\r
+ // - returns status\r
+ // bool send_ready(unsigned timeout = 0);\r
+ using IP_socket::send_ready;\r
+\r
+ // send data through the socket - if the data is long only part of it may\r
+ // be sent. The sent part is removed from the data, so the same string can\r
+ // be sent again and again until it is empty.\r
+ // - data: string containing data to be sent - any data successfully sent is removed\r
+ // - returns success flag\r
+ // bool send (std::string& data);\r
+ using IP_socket::send;\r
+\r
+ // test whether a socket is connected and ready to receive data, returns if ready or on timeout\r
+ // - timeout: how long to wait in microseconds if not connected yet (blocking)\r
+ // - returns status\r
+ // bool receive_ready(unsigned timeout = 0);\r
+ using IP_socket::receive_ready;\r
+\r
+ // receive data through the socket - if the data is long only part of it\r
+ // may be received. The received data is appended to the string, building\r
+ // it up in stages, so the same string can be received again and again\r
+ // until all information has been received.\r
+ // - data: string receiving data from socket - any data successfully received is appended\r
+ // - returns success flag\r
+ // bool receive (std::string& data);\r
+ using IP_socket::receive;\r
+\r
+ ////////////////////////////////////////////////////////////////////////////\r
+ // informational\r
+\r
+ // the local port number of the connection\r
+ // - returns the port number, 0 if not bound to a port\r
+ // unsigned short local_port(void) const;\r
+ using IP_socket::local_port;\r
+\r
+ // the remote address of the connection\r
+ // - returns the address, 0 if not connected\r
+ // unsigned long remote_address(void) const;\r
+ using IP_socket::remote_address;\r
+\r
+ // the remote port number of the connection\r
+ // - returns the port number, 0 if not connected to a port\r
+ // unsigned short remote_port(void) const;\r
+ using IP_socket::remote_port;\r
+\r
+ ////////////////////////////////////////////////////////////////////////////\r
+ // error handling\r
+ // errors are set internally\r
+ // an error code of 0 is the test for no error, don't rely on the message being an empty string\r
+ // an error code != 0 means an error, then there will be a message explaining the error\r
+\r
+ // if an error is set it stays set - so you must clear it before further operations\r
+ // void clear_error(void) const;\r
+ using IP_socket::clear_error;\r
+\r
+ // get the error code of the last error\r
+ // int error(void) const;\r
+ using IP_socket::error;\r
+\r
+ // get the explanatory message of the last error\r
+ // std::string message(void) const;\r
+ using IP_socket::message;\r
+\r
+ ////////////////////////////////////////////////////////////////////////////\r
+\r
+ // deprecated version of remote_port\r
+ unsigned short port(void) const;\r
+\r
+ ////////////////////////////////////////////////////////////////////////////\r
+ };\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ // server class that does the listening on the designated port\r
+ // incoming connections can be queued up to a maximum queue length specified\r
+ // in the constructor/initialise\r
+\r
+ class TCP_server : protected IP_socket\r
+ {\r
+ public:\r
+\r
+ // create an uninitialised server\r
+ TCP_server(void);\r
+\r
+ // initialise a socket and set it up to be a listening port\r
+ // - port: port to listen on\r
+ // - queue: length of backlog queue to manage - may be zero\r
+ // - returns success status\r
+ TCP_server(unsigned short port, unsigned short queue = 0);\r
+\r
+ ////////////////////////////////////////////////////////////////////////////\r
+ // initialisation\r
+\r
+ // initialise a socket and set it up to be a listening port\r
+ // - port: port to listen on\r
+ // - queue: length of backlog queue to manage - may be zero\r
+ // - returns success status\r
+ bool initialise(unsigned short port, unsigned short queue = 0);\r
+\r
+ // test whether this is an initialised socket\r
+ // - returns whether this is initialised\r
+ // bool initialised(void) const;\r
+ using IP_socket::initialised;\r
+\r
+ // close, i.e. disconnect the socket\r
+ // - returns a success flag\r
+ // bool close(void);\r
+ using IP_socket::close;\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ // server operation - accepting a connection\r
+\r
+ // test for a connection on the object's socket - only applicable if it has been set up as a listening port\r
+ // - timeout: how long to wait in microseconds if not connected yet\r
+ // - returns true if a connection is ready to be accepted\r
+ // bool accept_ready(unsigned timeout = 0);\r
+ using IP_socket::accept_ready;\r
+\r
+ // accept a connection on the object's socket - only applicable if it has been set up as a listening port\r
+ // - returns the connection as a new socket\r
+ TCP_connection accept(void);\r
+\r
+ ////////////////////////////////////////////////////////////////////////////\r
+ // error handling\r
+ // errors are set internally\r
+ // an error code of 0 is the test for no error, don't rely on the message being an empty string\r
+ // an error code != 0 means an error, then there will be a message explaining the error\r
+\r
+ // if an error is set it stays set - so you must clear it before further operations\r
+ // void clear_error (void) const;\r
+ using IP_socket::clear_error;\r
+\r
+ // get the error code of the last error\r
+ // int error(void) const;\r
+ using IP_socket::error;\r
+\r
+ // get the explanatory message of the last error\r
+ // std::string message(void) const;\r
+ using IP_socket::message;\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+\r
+ // deprecated versions of accept_ready and accept\r
+ bool connection_ready(unsigned timeout = 0);\r
+ TCP_connection connection(void);\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ };\r
+\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+ // Client Class: a client is simpler in that there is no listening port - you\r
+ // just create a connection and get on with it. Thus the client class does the\r
+ // whole job - create the connection and handle communications to/from it.\r
+ //\r
+ // Blocking mode: To use the client in blocking mode, use non-zero timeout for\r
+ // the initialisation method. In this mode, the connection operation must\r
+ // complete before the call will return or an error is indicated if the\r
+ // timeout is reached without completion. This usage was designed for\r
+ // applications which either just to TCP and nothing else or which do TCP\r
+ // operations in a separate thread.\r
+ //\r
+ // Non-blocking mode: To use the client in non-blocking mode, use a zero\r
+ // timeout for the initialisation method. Instead, you can ask it if it has\r
+ // connected once you've initialised it. It is not an error for it to be\r
+ // initialised but not connected. This usage was designed so that you can poll\r
+ // the connection periodically to implement a timeout for as long as you like for\r
+ // the connection to occur without blocking the thread that uses the client.\r
+ //\r
+ // In both modes, the send_ready/receive_ready methods can be called with any\r
+ // timeout including zero.\r
+\r
+ class TCP_client : protected IP_socket\r
+ {\r
+ public:\r
+\r
+ // create an uninitialised client\r
+ TCP_client(void);\r
+\r
+ // client connect to a server\r
+ // - remote_address: IP name (stlplus.sourceforge.net) or dotted number (216.34.181.96)\r
+ // - remote_port: port number of remote host\r
+ // - timeout: if 0, don't wait; if >0 wait for that microseconds for connection to be confirmed\r
+ TCP_client(const std::string& remote_address, unsigned short remote_port, unsigned timeout = 0);\r
+\r
+ // client connect to a server\r
+ // - remote_address: IP address as a long integer - generated by stlplus::ip_lookup\r
+ // - remote_port: port number of remote host\r
+ // - timeout: if 0, don't wait; if >0 wait for that microseconds for connection to be confirmed\r
+ TCP_client(unsigned long remote_address, unsigned short remote_port, unsigned timeout = 0);\r
+\r
+ ////////////////////////////////////////////////////////////////////////////\r
+ // initialisation, connection\r
+\r
+ // function for performing IP lookup (i.e. gethostbyname)\r
+ // could be standalone but making it a member means that it can use the socket's error handler\r
+ // i.e. if this fails, the sockets error code will be set - clear it to use the socket again\r
+ // - remote_address: IP name (stlplus.sourceforge.net) or dotted number (216.34.181.96)\r
+ // - returns the IP address as a long integer - zero if there's an error\r
+ // unsigned long ip_lookup(const std::string& remote_address);\r
+ using IP_socket::ip_lookup;\r
+\r
+ // client connect to a server\r
+ // - remote_address: IP name (stlplus.sourceforge.net) or dotted number (216.34.181.96)\r
+ // - remote_port: port number of remote host\r
+ // - timeout: if 0, don't wait; if >0 wait for that microseconds for connection to be confirmed\r
+ // - returns a success flag\r
+ bool initialise(const std::string& remote_address, unsigned short remote_port, unsigned timeout = 0);\r
+\r
+ // client connect to a server\r
+ // - remote_address: IP address as a long integer - generated by stlplus::ip_lookup\r
+ // - remote_port: port number of remote host\r
+ // - timeout: if 0, don't wait; if >0 wait for that microseconds for connection to be confirmed\r
+ // - returns a success flag\r
+ bool initialise(unsigned long remote_address, unsigned short remote_port, unsigned timeout = 0);\r
+\r
+ // test whether this is an initialised socket\r
+ // - returns whether this is initialised\r
+ // bool initialised(void) const;\r
+ using IP_socket::initialised;\r
+\r
+ // test whether a socket is connected and ready to communicate, returns on successful connect or timeout\r
+ // - timeout: how long to wait in microseconds if not connected yet\r
+ // - returns success flag\r
+ // bool connected(unsigned timeout = 0);\r
+ using IP_socket::connected;\r
+\r
+ // close, i.e. disconnect the socket\r
+ // - returns a success flag\r
+ // bool close(void);\r
+ using IP_socket::close;\r
+\r
+ ////////////////////////////////////////////////////////////////////////////\r
+ // sending/receiving\r
+\r
+ // test whether a socket is connected and ready to send data, returns if ready or on timeout\r
+ // - timeout: how long to wait in microseconds if not connected yet (blocking)\r
+ // - returns status\r
+ // bool send_ready(unsigned timeout = 0);\r
+ using IP_socket::send_ready;\r
+\r
+ // send data through the socket - if the data is long only part of it may\r
+ // be sent. The sent part is removed from the data, so the same string can\r
+ // be sent again and again until it is empty.\r
+ // - data: string containing data to be sent - any data successfully sent is removed\r
+ // - returns success flag\r
+ // bool send (std::string& data);\r
+ using IP_socket::send;\r
+\r
+ // test whether a socket is connected and ready to receive data, returns if ready or on timeout\r
+ // - timeout: how long to wait in microseconds if not connected yet (blocking)\r
+ // - returns status\r
+ // bool receive_ready(unsigned timeout = 0);\r
+ using IP_socket::receive_ready;\r
+\r
+ // receive data through the socket - if the data is long only part of it\r
+ // may be received. The received data is appended to the string, building\r
+ // it up in stages, so the same string can be received again and again\r
+ // until all information has been received.\r
+ // - data: string receiving data from socket - any data successfully received is appended\r
+ // - returns success flag\r
+ // bool receive (std::string& data);\r
+ using IP_socket::receive;\r
+\r
+ ////////////////////////////////////////////////////////////////////////////\r
+ // informational\r
+\r
+ // the local port number of the connection\r
+ // - returns the port number, 0 if not bound to a port\r
+ // unsigned short local_port(void) const;\r
+ using IP_socket::local_port;\r
+\r
+ // the remote address of the connection\r
+ // - returns the address, 0 if not connected\r
+ // unsigned long remote_address(void) const;\r
+ using IP_socket::remote_address;\r
+\r
+ // the remote port number of the connection\r
+ // - returns the port number, 0 if not connected to a port\r
+ // unsigned short remote_port(void) const;\r
+ using IP_socket::remote_port;\r
+\r
+ ////////////////////////////////////////////////////////////////////////////\r
+ // error handling\r
+ // errors are set internally\r
+ // an error code of 0 is the test for no error, don't rely on the message being an empty string\r
+ // an error code != 0 means an error, then there will be a message explaining the error\r
+\r
+ // if an error is set it stays set - so you must clear it before further operations\r
+ // void clear_error (void) const;\r
+ using IP_socket::clear_error;\r
+\r
+ // get the error code of the last error\r
+ // int error(void) const;\r
+ using IP_socket::error;\r
+\r
+ // get the explanatory message of the last error\r
+ // std::string message(void) const;\r
+ using IP_socket::message;\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+\r
+ // deprecated versions\r
+ unsigned long address(void) const;\r
+ unsigned short port(void) const;\r
+\r
+ //////////////////////////////////////////////////////////////////////////////\r
+ };\r
+\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+\r
+} // end namespace stlplus\r
+\r
+#endif\r
projects / chaz / yoink / blobdiff