/* ** JNetLib ** Copyright (C) 2000-2001 Nullsoft, Inc. ** Author: Justin Frankel ** File: udpconnection.h - JNL UDP connection interface ** License: see jnetlib.h ** ** Usage: ** 1. Create a JNL_Connection object, optionally specifying a JNL_AsyncDNS ** object to use (or NULL for none, or WAC_NETWORK_CONNECTION_AUTODNS for auto), ** and the send and receive buffer sizes. ** 2. Call connect() to have it connect to a host/port (the hostname will be ** resolved if possible). ** 3. call run() with the maximum send/recv amounts, and optionally parameters ** so you can tell how much has been send/received. You want to do this a lot, while: ** 4. check get_state() to check the state of the connection. The states are: ** JNL_Connection::STATE_ERROR ** - an error has occured on the connection. the connection has closed, ** and you can no longer write to the socket (there still might be ** data in the receive buffer - use recv_bytes_available()). ** JNL_Connection::STATE_NOCONNECTION ** - no connection has been made yet. call connect() already! :) ** JNL_Connection::STATE_RESOLVING ** - the connection is still waiting for a JNL_AsycnDNS to resolve the ** host. ** JNL_Connection::STATE_CONNECTING ** - the asynchronous call to connect() is still running. ** JNL_Connection::STATE_CONNECTED ** - the connection has connected, all is well. ** JNL_Connection::STATE_CLOSING ** - the connection is closing. This happens after a call to close, ** without the quick parameter set. This means that the connection ** will close once the data in the send buffer is sent (data could ** still be being received when it would be closed). After it is ** closed, the state will transition to: ** JNL_Connection::STATE_CLOSED ** - the connection has closed, generally without error. There still ** might be data in the receieve buffer, use recv_bytes_available(). ** 5. Use send() and send_string() to send data. You can use ** send_bytes_in_queue() to see how much has yet to go out, or ** send_bytes_available() to see how much you can write. If you use send() ** or send_string() and not enough room is available, both functions will ** return error ( < 0) ** 6. Use recv() and recv_line() to get data. If you want to see how much data ** there is, use recv_bytes_available() and recv_lines_available(). If you ** call recv() and not enough data is available, recv() will return how much ** data was actually read. See comments at the function defs. ** ** 7. To close, call close(1) for a quick close, or close() for a close that will ** make the socket close after sending all the data sent. ** ** 8. delete ye' ol' object. */ #ifndef _UDPCONNECTION_H_ #define _UDPCONNECTION_H_ #include "asyncdns.h" #include "nu/RingBuffer.h" #include "jnetlib_defines.h" #define JNL_DEFAULT_BUFFER_SIZE 8192 class JNL_UDPConnection : private Drainer, private Filler { public: typedef enum { STATE_ERROR = JNL_CONNECTION_STATE_ERROR, STATE_NOCONNECTION = JNL_CONNECTION_STATE_NOCONNECTION, STATE_RESOLVING = JNL_CONNECTION_STATE_RESOLVING, STATE_CONNECTING = JNL_CONNECTION_STATE_CONNECTING, STATE_CONNECTED = JNL_CONNECTION_STATE_CONNECTED, STATE_CLOSING = JNL_CONNECTION_STATE_CLOSING, STATE_CLOSED = JNL_CONNECTION_STATE_CLOSED, STATE_RESOLVED = JNL_CONNECTION_STATE_RESOLVED, } state; JNL_UDPConnection(); JNL_UDPConnection( unsigned short port, JNL_AsyncDNS *dns, int sendbufsize = JNL_DEFAULT_BUFFER_SIZE, int recvbufsize = JNL_DEFAULT_BUFFER_SIZE ); ~JNL_UDPConnection(); void open( JNL_AsyncDNS *dns = JNL_AUTODNS, size_t sendbufsize = JNL_DEFAULT_BUFFER_SIZE, size_t recvbufsize = JNL_DEFAULT_BUFFER_SIZE ); void open( int incoming_socket, JNL_AsyncDNS *dns = JNL_AUTODNS, size_t sendbufsize = JNL_DEFAULT_BUFFER_SIZE, size_t recvbufsize = JNL_DEFAULT_BUFFER_SIZE ); void setpeer( const char *hostname, int port ); void setpeer( sockaddr *addr, socklen_t length /* of addr */ ); void run( size_t max_send_bytes = -1, size_t max_recv_bytes = -1, size_t *bytes_sent = NULL, size_t *bytes_rcvd = NULL ); int get_state() { return m_state; } const char *get_errstr() { return m_errorstr; } void close( int quick = 0 ); void flush_send( void ) { send_buffer.clear(); } size_t send_bytes_in_queue( void ); size_t send_bytes_available( void ); int send( const void *data, size_t length ); // returns -1 if not enough room int send_string( const char *line ); // returns -1 if not enough room size_t recv_bytes_available( void ); size_t recv_bytes( void *data, size_t maxlength ); // returns actual bytes read unsigned int recv_int( void ); int recv_lines_available( void ); int recv_line( char *line, size_t maxlength ); // returns 0 if the line was terminated with a \r or \n, 1 if not. // (i.e. if you specify maxlength=10, and the line is 12 bytes long // it will return 1. or if there is no \r or \n and that's all the data // the connection has.) size_t peek_bytes( void *data, size_t maxlength ); // returns bytes peeked int get_interface( sockaddr *sin, socklen_t *sin_length ); // this returns the interface the connection is on short get_remote_port( void ) { return m_remote_port; } // this returns the remote port of connection void get_last_recv_msg_addr( sockaddr **addr, socklen_t *len ) { *addr = (sockaddr *)&m_last_addr; *len = m_last_addr_len; } void set_ttl( uint8_t new_ttl ); protected: uint8_t ttl; SOCKET m_socket; unsigned short m_remote_port; RingBuffer recv_buffer; RingBuffer send_buffer; sockaddr *address; socklen_t address_len; sockaddr_storage m_last_addr; socklen_t m_last_addr_len; addrinfo *saddr; char *m_host; JNL_AsyncDNS *m_dns; int m_dns_owned; state m_state; const char *m_errorstr; private: void init(); // constructor helper function // functions for RingBuffer size_t Read( void *dest, size_t len ); size_t Write( const void *dest, size_t len ); }; #endif // _UDPConnection_H_