-#ifndef STLPLUS_UDP_SOCKET
-#define STLPLUS_UDP_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 UDP sockets
-
-////////////////////////////////////////////////////////////////////////////////
-
-#include "portability_fixes.hpp"
-#include "ip_sockets.hpp"
-#include <string>
-
-namespace stlplus
-{
-
- //////////////////////////////////////////////////////////////////////////////
- // UDP client - creates a connectioned socket
-
- class UDP_client : protected IP_socket
- {
- public:
-
- // create an uninitialised socket
- UDP_client(void);
-
- // Send/Receive datagram packets to/from the given address/remote port on the local port.
- // - remote_address: IP name or number of remote host
- // - remote_port: port number of remote host
- // - local_port: port number to receive on - 0 to get an ephemeral port.
- UDP_client(const std::string& remote_address, unsigned short remote_port, unsigned short local_port=0);
-
- // Send/Receive datagram packets to/from the given address/remote port on the given local port
- // Enables default send to remote address/port
- // - remote_address: IP address of remote host - pre-looked-up using ip_lookup
- // - remote_port: port number of remote host
- // - local_port: port number to receive on - 0 to get an ephemeral port.
- UDP_client(unsigned long remote_address, unsigned short remote_port, unsigned short local_port=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;
-
- // Send/Receive datagram packets to/from the given address/remote port on the local port.
- // Enables default send to remote address/port
- // - remote_address: IP name or number of remote host
- // - remote_port: port number of remote host
- // - local_port: port number to receive on - 0 to get an ephemeral port.
- // - returns a success flag
- bool initialise(const std::string& remote_address, unsigned short remote_port, unsigned short local_port=0);
-
- // Send/Receive datagram packets to/from the given address/remote port on the given local port
- // Enables default send to remote address/port
- // - remote_address: IP address of remote host - pre-looked-up using ip_lookup
- // - remote_port: port number of remote host
- // - local_port: port number to receive on - 0 to get an ephemeral port.
- // - returns a success flag
- bool initialise(unsigned long remote_address, unsigned short remote_port, unsigned short local_port=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;
-
- ////////////////////////////////////////////////////////////////////////////
- // 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 to the remote address/port setup in initialise, from the local port also setup in initialise.
- // send data through the socket as a single datagram
- // - packet: string containing data to be sent - if data is successfully sent it is removed
- // - returns success flag
- bool send(std::string& packet);
-
- // 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;
-
- // datagram receive
- // - packet: string to receive data from datagram - if data is successfully sent it is appended
- // - returns success flag - i.e. packet successfully received
- bool receive(std::string& packet);
-
- ////////////////////////////////////////////////////////////////////////////
- // 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 ANY address
- // 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 bound 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);
- 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;
-
- ////////////////////////////////////////////////////////////////////////////
-
- private:
- IP_socket m_socket;
- };
-
- ////////////////////////////////////////////////////////////////////////////////
- // UDP server - creates a connectionless (multicast) listener socket
-
- class UDP_server : protected IP_socket
- {
- public:
-
- // create an uninitialised socket
- UDP_server(void);
-
- // Initialise socket.
- // Receive datagram packets from any address on provided local receiving port.
- // - local_port: port number to receive on - 0 to get an ephemeral port.
- UDP_server(unsigned short local_port);
-
- ////////////////////////////////////////////////////////////////////////////
- // 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;
-
- // Initialise socket.
- // Receive datagram packets from any address on provided local receiving port.
- // - local_port: port number to receive on - 0 to get an ephemeral port.
- // - returns a success flag
- bool initialise(unsigned short local_port);
-
- // 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 to the address/port given here, from the local port setup in initialise.
- // send data through the socket as a single datagram
- // - packet: string containing data to be sent - if data is successfully sent it is removed
- // - remote_address: IP name (stlplus.sourceforge.net) or dotted number (216.34.181.96)
- // - remote_port: port number of remote host
- // - returns success flag
- bool send(std::string& packet, const std::string& remote_address, unsigned short remote_port);
-
- // send to the address/port given here, from the local port setup in initialise.
- // send data through the socket as a single datagram
- // - packet: string containing data to be sent - if data is successfully sent it is removed
- // - remote_address: pre-looked-up IP address of remote host
- // - remote_port: port number of remote host
- // - returns success flag
- bool send(std::string& packet, unsigned long remote_address, unsigned short remote_port);
-
- // 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;
-
- // datagram receive
- // - packet: string to receive data from datagram - if data is successfully sent it is appended
- // - remote_address: the address of the client that sent the packet, can then be used to reply
- // - remote_port: the port of the client that sent the packet, can then be used to reply
- // - returns success flag - i.e. packet successfully received
- bool receive(std::string& packet, unsigned long& remote_address, unsigned short& remote_port);
-
- ////////////////////////////////////////////////////////////////////////////
- // 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;
-
- ////////////////////////////////////////////////////////////////////////////
- // 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);
- 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;
-
- ////////////////////////////////////////////////////////////////////////////
- };
-
- /////////////////////////////////////////////////////////////////////////////
- // fire and forget UDP client packet send function
-
- bool UDP_send(const std::string& packet,
- const std::string& remote_address, unsigned short remote_port, unsigned short local_port = 0);
-
- ////////////////////////////////////////////////////////////////////////////////
-
-} // end namespace stlplus
-
-#endif
+#ifndef STLPLUS_UDP_SOCKET\r
+#define STLPLUS_UDP_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 UDP 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
+ // UDP client - creates a connectioned socket\r
+\r
+ class UDP_client : protected IP_socket\r
+ {\r
+ public:\r
+\r
+ // create an uninitialised socket\r
+ UDP_client(void);\r
+\r
+ // Send/Receive datagram packets to/from the given address/remote port on the local port.\r
+ // - remote_address: IP name or number of remote host\r
+ // - remote_port: port number of remote host\r
+ // - local_port: port number to receive on - 0 to get an ephemeral port.\r
+ UDP_client(const std::string& remote_address, unsigned short remote_port, unsigned short local_port=0);\r
+\r
+ // Send/Receive datagram packets to/from the given address/remote port on the given local port\r
+ // Enables default send to remote address/port\r
+ // - remote_address: IP address of remote host - pre-looked-up using ip_lookup\r
+ // - remote_port: port number of remote host\r
+ // - local_port: port number to receive on - 0 to get an ephemeral port.\r
+ UDP_client(unsigned long remote_address, unsigned short remote_port, unsigned short local_port=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
+ // Send/Receive datagram packets to/from the given address/remote port on the local port.\r
+ // Enables default send to remote address/port\r
+ // - remote_address: IP name or number of remote host\r
+ // - remote_port: port number of remote host\r
+ // - local_port: port number to receive on - 0 to get an ephemeral port.\r
+ // - returns a success flag\r
+ bool initialise(const std::string& remote_address, unsigned short remote_port, unsigned short local_port=0);\r
+\r
+ // Send/Receive datagram packets to/from the given address/remote port on the given local port\r
+ // Enables default send to remote address/port\r
+ // - remote_address: IP address of remote host - pre-looked-up using ip_lookup\r
+ // - remote_port: port number of remote host\r
+ // - local_port: port number to receive on - 0 to get an ephemeral port.\r
+ // - returns a success flag\r
+ bool initialise(unsigned long remote_address, unsigned short remote_port, unsigned short local_port=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
+ // 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 to the remote address/port setup in initialise, from the local port also setup in initialise.\r
+ // send data through the socket as a single datagram\r
+ // - packet: string containing data to be sent - if data is successfully sent it is removed\r
+ // - returns success flag\r
+ bool send(std::string& packet);\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
+ // datagram receive\r
+ // - packet: string to receive data from datagram - if data is successfully sent it is appended\r
+ // - returns success flag - i.e. packet successfully received\r
+ bool receive(std::string& packet);\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 ANY address\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 bound 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);\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
+ private:\r
+ IP_socket m_socket;\r
+ };\r
+\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+ // UDP server - creates a connectionless (multicast) listener socket\r
+\r
+ class UDP_server : protected IP_socket\r
+ {\r
+ public:\r
+\r
+ // create an uninitialised socket\r
+ UDP_server(void);\r
+\r
+ // Initialise socket.\r
+ // Receive datagram packets from any address on provided local receiving port.\r
+ // - local_port: port number to receive on - 0 to get an ephemeral port.\r
+ UDP_server(unsigned short local_port);\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
+ // Initialise socket.\r
+ // Receive datagram packets from any address on provided local receiving port.\r
+ // - local_port: port number to receive on - 0 to get an ephemeral port.\r
+ // - returns a success flag\r
+ bool initialise(unsigned short local_port);\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 to the address/port given here, from the local port setup in initialise.\r
+ // send data through the socket as a single datagram\r
+ // - packet: string containing data to be sent - if data is successfully sent it is removed\r
+ // - remote_address: IP name (stlplus.sourceforge.net) or dotted number (216.34.181.96)\r
+ // - remote_port: port number of remote host\r
+ // - returns success flag\r
+ bool send(std::string& packet, const std::string& remote_address, unsigned short remote_port);\r
+\r
+ // send to the address/port given here, from the local port setup in initialise.\r
+ // send data through the socket as a single datagram\r
+ // - packet: string containing data to be sent - if data is successfully sent it is removed\r
+ // - remote_address: pre-looked-up IP address of remote host\r
+ // - remote_port: port number of remote host\r
+ // - returns success flag\r
+ bool send(std::string& packet, unsigned long remote_address, unsigned short remote_port);\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
+ // datagram receive\r
+ // - packet: string to receive data from datagram - if data is successfully sent it is appended\r
+ // - remote_address: the address of the client that sent the packet, can then be used to reply\r
+ // - remote_port: the port of the client that sent the packet, can then be used to reply\r
+ // - returns success flag - i.e. packet successfully received\r
+ bool receive(std::string& packet, unsigned long& remote_address, unsigned short& remote_port);\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
+ ////////////////////////////////////////////////////////////////////////////\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);\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
+\r
+ /////////////////////////////////////////////////////////////////////////////\r
+ // fire and forget UDP client packet send function\r
+\r
+ bool UDP_send(const std::string& packet,\r
+ const std::string& remote_address, unsigned short remote_port, unsigned short local_port = 0);\r
+\r
+ ////////////////////////////////////////////////////////////////////////////////\r
+\r
+} // end namespace stlplus\r
+\r
+#endif\r
projects / chaz / yoink / blobdiff