Initial community commit

1 files changed, 168 insertions, 0 deletions

diff --git a/Src/replicant/jnetlib/connection.h b/Src/replicant/jnetlib/connection.h
new file mode 100644
index 00000000..9d32cab2
--- /dev/null
+++ b/Src/replicant/jnetlib/connection.h
@@ -0,0 +1,168 @@
+/*
+** JNetLib
+** Copyright (C) 2000-2007 Nullsoft, Inc.
+** Author: Justin Frankel
+** File: connection.h - JNL TCP 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 _CONNECTION_H_
+#define _CONNECTION_H_
+
+#include "netinc.h"
+#include "asyncdns.h"
+#include "../nu/RingBuffer.h"
+#include "jnetlib_defines.h"
+#include <stddef.h>
+#include "nswasabi/ReferenceCounted.h"
+
+#if defined(_MSC_VER) && (_MSC_VER < 1200)
+typedef int intptr_t;
+#endif
+
+
+#define PACKET_SIZE 16384
+
+class JNL_Connection : 	private Filler, private Drainer, public ReferenceCountedBase<JNL_Connection>
+{
+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;
+
+	/*
+	**  Joshua Teitelbaum, 1/27/2006 adding virtual
+	*/
+	JNL_Connection();
+	JNL_Connection(JNL_AsyncDNS *dns, size_t sendbufsize, size_t recvbufsize);
+	virtual ~JNL_Connection();
+
+	void          open( JNL_AsyncDNS *dns = JNL_AUTODNS, size_t sendbufsize = 8192, size_t recvbufsize = 8192 );
+	void          connect( const char *hostname, int port );
+	virtual void  connect( SOCKET sock, sockaddr *addr, socklen_t length /* of addr */ ); // used by the listen object, usually not needed by users.
+
+	int           set_recv_buffer_size(size_t new_buffer_size);
+	/*
+	**  Joshua Teitelbaum 2/2/2006
+	**  Need to make this virtual to ensure SSL can init properly
+	*/
+	virtual 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; }
+	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
+	inline int      send_bytes( const void *data, size_t length )     { return send( data, length ); }
+	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
+
+	unsigned long   get_interface( void );                            // this returns the interface the connection is on
+	unsigned long   get_remote( void );                               // remote host ip.
+	unsigned short  get_remote_port( void );                          // this returns the remote port of connection
+
+	void            set_dns( JNL_AsyncDNS *dns );
+	void            reuse();
+
+protected:
+	SOCKET          m_socket;
+	unsigned short  m_remote_port;
+
+	RingBuffer      recv_buffer;
+	RingBuffer      send_buffer;
+
+	addrinfo       *saddr;
+	sockaddr       *address;
+
+	char            m_host[256];
+
+	JNL_AsyncDNS   *m_dns;
+	bool            m_dns_owned;
+
+	state           m_state;
+	char           *m_errorstr;
+
+	/*
+	**  Joshua Teitelbaum 1/27/2006 Adding new BSD socket analogues for SSL compatibility
+	*/
+	virtual void    socket_shutdown();
+	virtual ssize_t socket_recv( char *buf, size_t len, int options );
+	virtual ssize_t socket_send( const char *buf, size_t len, int options );
+	virtual int     socket_connect();
+	virtual void    on_socket_connected();
+
+private:
+	void            init();                                           // constructor helper function
+
+	// functions for RingBuffer
+	size_t          Read( void *dest, size_t len ) override;
+	size_t          Write( const void *dest, size_t len ) override;
+};
+#endif // _Connection_H_