winamp/Src/replicant/jnetlib/connection.cpp

/*
** JNetLib
** Copyright (C) 2000-2007 Nullsoft, Inc.
** Author: Justin Frankel
** File: connection.cpp - JNL TCP connection implementation
** License: see jnetlib.h
*/

#include "netinc.h"
#include "util.h"
#include "connection.h"
#include "asyncdns.h"
#include "foundation\error.h"


#ifndef min
#define min(X,Y) ((X) < (Y) ? (X) : (Y))
#endif

JNL_Connection::JNL_Connection()
{
	init();
}

JNL_Connection::JNL_Connection(JNL_AsyncDNS *dns, size_t sendbufsize, size_t recvbufsize)
{
	init();
	open(dns, sendbufsize, recvbufsize);
}


void JNL_Connection::init()
{
	m_errorstr="";
	address=0;
	m_dns=0;
	m_dns_owned=false;
	m_socket=-1;
	m_remote_port=0;
	m_state=STATE_NOCONNECTION;
	m_host[0]=0;
	saddr=0;
}

JNL_Connection::~JNL_Connection()
{
	/*
	**  Joshua Teitelbaum 1/27/2006
	**  virtualization for ssl, calling socket_shtudown()
	*/
	socket_shutdown();

	if (!saddr) // free it if it was passed to us (by JNL_Listen, presumably)
		free(address); // TODO: change this if we ever do round-robin DNS connecting or in any way change how we handle 'address'

	if (m_dns_owned) 
		delete m_dns;
}

void JNL_Connection::set_dns(JNL_AsyncDNS *dns)
{
	if (m_dns_owned)
		delete static_cast<JNL_AsyncDNS *>(m_dns);

	m_dns=dns;
	m_dns_owned=false;
}

void JNL_Connection::open(JNL_AsyncDNS *dns, size_t sendbufsize, size_t recvbufsize)
{
	if (dns != JNL_AUTODNS && dns)
	{
		m_dns=dns;
		m_dns_owned=false;
	}
	else if (!m_dns)
	{
		m_dns=new JNL_AsyncDNS;
		m_dns_owned=true;
	}

	recv_buffer.reserve(recvbufsize);
	send_buffer.reserve(sendbufsize);
}

void JNL_Connection::connect(SOCKET s, sockaddr *addr, socklen_t length)
{
	close(1);
	m_socket=s;
	address=(sockaddr *)malloc(length);
	memcpy(address, addr, length);

	m_remote_port=0;
	if (m_socket != -1)
	{
		SET_SOCK_BLOCK(m_socket,0);
		m_state=STATE_CONNECTED;
	}
	else 
	{
		m_errorstr="invalid socket passed to connect";
		m_state=STATE_ERROR;
	}

}

void JNL_Connection::connect(const char *hostname, int port)
{
	close(1);
	m_remote_port=(unsigned short)port;

#ifdef _WIN32
	lstrcpynA(m_host, hostname, sizeof(m_host));
#elif defined(__APPLE__)
	strlcpy(m_host, hostname, sizeof(m_host));
#else
	strncpy(m_host, hostname, sizeof(m_host)-1);
	m_host[sizeof(m_host)-1]=0;
#endif


	//memset(&m_saddr,0,sizeof(m_saddr));
	if (!m_host[0])
	{
		m_errorstr="empty hostname";
		m_state=STATE_ERROR;
	}
	else
	{
		m_state=STATE_RESOLVING;
	}
}

/*
**  Joshua Teitelbaum 1/27/2006
**  socket_shutdown
**  virtualization for ssl
*/
/* Virtual */ 
void JNL_Connection::socket_shutdown()
{
	if (m_socket >= 0)
	{
		::shutdown(m_socket, SHUT_RDWR);
		::closesocket(m_socket);

		m_socket=-1;
	}
}
/*
**  Joshua Teitelbaum 1/27/2006
**  socket_recv
**  virtualization for ssl
*/
/* Virtual */ 
ssize_t JNL_Connection::socket_recv(char *buf, size_t len, int options)
{
	return ::recv(m_socket,buf,(int)len,options);
}
/*
**  Joshua Teitelbaum 1/27/2006
**  socket_send
**  virtualization for ssl
*/
/* Virtual */ 
ssize_t JNL_Connection::socket_send(const char *buf, size_t len, int options)
{
	return ::send(m_socket,buf,(int)len,options);
}

int JNL_Connection::socket_connect()
{
	return ::connect(m_socket, saddr->ai_addr, (int)saddr->ai_addrlen);
}

void JNL_Connection::run(size_t max_send_bytes, size_t max_recv_bytes, size_t *bytes_sent, size_t *bytes_rcvd)
{
	socklen_t socket_buffer_size=0;
	socklen_t socket_buffer_size_len = sizeof(socket_buffer_size);
	socklen_t send_buffer_size;
	socklen_t recv_buffer_size;

	size_t bytes_allowed_to_send=(max_send_bytes==(size_t)-1)?send_buffer.size():max_send_bytes;
	size_t bytes_allowed_to_recv=(max_recv_bytes==(size_t)-1)?recv_buffer.avail():max_recv_bytes;

	if (bytes_sent) *bytes_sent=0;
	if (bytes_rcvd) *bytes_rcvd=0;

	switch (m_state)
	{
	case STATE_RESOLVING:
		if (saddr==0)
		{
			int a=m_dns->resolve(m_host, m_remote_port, &saddr, SOCK_STREAM);
			if (!a)
			{
				m_state=STATE_RESOLVED;
			}
			else if (a == 1)
			{
				m_state=STATE_RESOLVING; 
				break;
			}
			else
			{
				m_errorstr="resolving hostname"; 
				m_state=STATE_ERROR; 

				return;
			}
		}
		// fall through
	case STATE_RESOLVED:
		m_socket=::socket(saddr->ai_family, saddr->ai_socktype, saddr->ai_protocol);
		if (m_socket==-1)
		{
			m_errorstr="creating socket";
			m_state=STATE_ERROR;
		}
		else
		{
			SET_SOCK_BLOCK(m_socket,0);
		}

		socket_buffer_size=0;
		socket_buffer_size_len = sizeof(socket_buffer_size);
		getsockopt(m_socket, SOL_SOCKET, SO_SNDBUF, (char *)&socket_buffer_size, &socket_buffer_size_len);
		send_buffer_size = (int)(send_buffer.avail()+send_buffer.size());
		if (send_buffer_size > 65536)
			send_buffer_size=65536;
		if (socket_buffer_size < send_buffer_size)
			setsockopt(m_socket, SOL_SOCKET, SO_SNDBUF, (char *)&send_buffer_size, sizeof(send_buffer_size));
		getsockopt(m_socket, SOL_SOCKET, SO_SNDBUF, (char *)&socket_buffer_size, &socket_buffer_size_len);

		getsockopt(m_socket, SOL_SOCKET, SO_RCVBUF, (char *)&socket_buffer_size, &socket_buffer_size_len);
		recv_buffer_size = (int)recv_buffer.avail();
		if (recv_buffer_size > 65536)
			recv_buffer_size=65536;
		if (socket_buffer_size < recv_buffer_size)
			setsockopt(m_socket, SOL_SOCKET, SO_RCVBUF, (char *)&recv_buffer_size, sizeof(recv_buffer_size));
		getsockopt(m_socket, SOL_SOCKET, SO_RCVBUF, (char *)&socket_buffer_size, &socket_buffer_size_len);

		/*
		**  Joshua Teitelbaum 1/27/2006
		**  virtualization for ssl
		*/
		if(!socket_connect())
		{
			address=saddr->ai_addr;
			m_state=STATE_CONNECTED;

			on_socket_connected();
		}
		else if (ERRNO!=JNL_EINPROGRESS)
		{
			m_errorstr="Connecting to host";
			m_state=STATE_ERROR;
		}
		else
		{
			m_state=STATE_CONNECTING;
		}
		break;
	case STATE_CONNECTING:
		{		
			fd_set f[3];
			FD_ZERO(&f[0]);
			FD_ZERO(&f[1]);
			FD_ZERO(&f[2]);
			FD_SET(m_socket,&f[0]);
			FD_SET(m_socket,&f[1]);
			FD_SET(m_socket,&f[2]);
			struct timeval tv;
			memset(&tv,0,sizeof(tv));
			if (select((int)m_socket+1,&f[0],&f[1],&f[2],&tv)==-1)
			{
				m_errorstr="Connecting to host (calling select())";
				m_state=STATE_ERROR;
			}
			else if (FD_ISSET(m_socket,&f[1])) 
			{
				m_state=STATE_CONNECTED;
				on_socket_connected();
			}
			else if (FD_ISSET(m_socket,&f[2]))
			{
				m_errorstr="Connecting to host";
				m_state=STATE_ERROR;
			}
		}
		break;
	case STATE_CONNECTED:
	case STATE_CLOSING:
		/* --- send --- */		
		{
			size_t sent = send_buffer.drain(this, bytes_allowed_to_send);
			if (bytes_sent)
				*bytes_sent+=sent;

			if (m_state == STATE_CLOSED)
				break;

		/* --- receive --- */
			size_t received = recv_buffer.fill(this, bytes_allowed_to_recv);
			if (bytes_rcvd)
				*bytes_rcvd+=received;
		}

		if (m_state == STATE_CLOSING)
		{
			if (send_buffer.empty()) m_state = STATE_CLOSED;
		}
		break;
	default:
		break;
	}
}

void JNL_Connection::on_socket_connected(void)
{
	return;
}

void JNL_Connection::close(int quick)
{
	if (quick || m_state == STATE_RESOLVING || m_state == STATE_CONNECTING)
	{
		m_state=STATE_CLOSED;
		/*
		**  Joshua Teitelbaum 1/27/2006
		**  virualization for ssl
		*/
		socket_shutdown();

		m_socket=-1;

		recv_buffer.clear();
		send_buffer.clear();

		m_remote_port=0;
		m_host[0]=0;
		//memset(&m_saddr,0,sizeof(m_saddr));
	}
	else
	{
		if (m_state == STATE_CONNECTED)
			m_state=STATE_CLOSING;
	}
}

size_t JNL_Connection::send_bytes_in_queue(void)
{
	return send_buffer.size();
}

size_t JNL_Connection::send_bytes_available(void)
{
	return send_buffer.avail();
}

int JNL_Connection::send(const void *data, size_t length)
{
	if (length > send_bytes_available())
		return -1;

	send_buffer.write(data, length);
	return 0;
}

int JNL_Connection::send_string(const char *line)
{
	return send(line,strlen(line));
}

size_t JNL_Connection::recv_bytes_available(void)
{
	return recv_buffer.size();
}

size_t JNL_Connection::peek_bytes(void *data, size_t maxlength)
{
	if (data)
		return recv_buffer.peek(data, maxlength);
	else
		return min(maxlength, recv_bytes_available());
}

size_t JNL_Connection::recv_bytes(void *data, size_t maxlength)
{
	if (data)
		return recv_buffer.read(data, maxlength);
	else
		return recv_buffer.advance(maxlength);
}

int JNL_Connection::recv_lines_available(void)
{
	int l = (int)recv_bytes_available();
	int lcount = 0;
	int lastch = 0;
	
	for (int pos = 0; pos < l; pos ++)
	{
		char t;
		if (recv_buffer.at(pos, &t, 1) != 1)
			return lcount;
			
		if ((t=='\r' || t=='\n') &&( (lastch != '\r' && lastch != '\n') || lastch==t ))
			lcount++;

		lastch=t;
	}

	return lcount;
}

int JNL_Connection::recv_line(char *line, size_t maxlength)
{
	while (maxlength--)
	{
		char t;
		if (recv_buffer.read(&t, 1) == 0) 
		{
			*line=0;
			return 0;
		}

		if (t == '\r' || t == '\n')
		{
			char r;
			if (recv_buffer.peek(&r, 1) != 0)
			{
				if ((r == '\r' || r == '\n') && r != t)
					recv_buffer.advance(1);
			}

			*line=0;
			return 0;
			
		}

		*line++=t;
	}

	return 1;
}

unsigned long JNL_Connection::get_interface(void)
{
	if (m_socket==-1)
		return 0;

	struct sockaddr_in sin;
	memset(&sin,0,sizeof(sin));
	socklen_t len=sizeof(sin);

	if (::getsockname(m_socket,(struct sockaddr *)&sin,&len))
		return 0;

	return (unsigned long) sin.sin_addr.s_addr;
}

unsigned long JNL_Connection::get_remote()
{
	// TODO: IPv6
	if (address)
	{
		sockaddr_in *ipv4 = (sockaddr_in *)address;
		return ipv4->sin_addr.s_addr;
	}

	return 0;

}

unsigned short JNL_Connection::get_remote_port()
{
	return m_remote_port;
}

/* RingBuffer client function */
size_t JNL_Connection::Read(void *dest, size_t len)
{
	if (!len)
		return 0;

	int res=(int)socket_recv((char *)dest,len,0);

	if (res == 0 || (res < 0 && ERRNO != JNL_EWOULDBLOCK))
	{        
		m_state=STATE_CLOSED;
		return 0;
	}

	if (res > 0)
		return res;
	else
		return 0;
}

/* RingBuffer client function */
size_t JNL_Connection::Write(const void *dest, size_t len)
{
	if (!len)
		return 0;

	int res=(int)socket_send((const char *)dest,len,0);

	if (res==-1 && ERRNO != JNL_EWOULDBLOCK)
	{
		return 0;
		//              m_state=STATE_CLOSED;
	}

	if (res > 0)
		return res;
	else
		return 0;
}

int JNL_Connection::set_recv_buffer_size(size_t new_buffer_size)
{
	return recv_buffer.expand(new_buffer_size);
}

void JNL_Connection::reuse()
{
	if (m_state == STATE_CLOSED)
	{
		m_state = STATE_CONNECTED;
		recv_buffer.clear();
	}
}