
#include <winsock2.h>
#include <ws2tcpip.h>
#include "iphelpers.h"
#include "basetypes.h"
#include <assert.h>
#include "utllinkedlist.h"
#include "utlvector.h"
#include "vstdlib/strtools.h"


// This automatically calls WSAStartup for the app at startup.
class CIPStarter
{
public:
	CIPStarter()
	{
		WSADATA wsaData;
		WSAStartup( WINSOCK_VERSION, &wsaData );
	}
};
static CIPStarter g_Starter;


unsigned long SampleMilliseconds()
{
	CCycleCount cnt;
	cnt.Sample();
	return cnt.GetMilliseconds();
}


// ------------------------------------------------------------------------------------------ //
// CChunkWalker.
// ------------------------------------------------------------------------------------------ //

CChunkWalker::CChunkWalker( void const * const *pChunks, const int *pChunkLengths, int nChunks )
{
	m_TotalLength = 0;
	for ( int i=0; i < nChunks; i++ )
		m_TotalLength += pChunkLengths[i];
	
	m_iCurChunk = 0;
	m_iCurChunkPos = 0;
	m_pChunks = pChunks;
	m_pChunkLengths = pChunkLengths;
	m_nChunks = nChunks;
}

int CChunkWalker::GetTotalLength() const
{
	return m_TotalLength;
}

void CChunkWalker::CopyTo( void *pOut, int nBytes )
{
	unsigned char *pOutPos = (unsigned char*)pOut;

	int nBytesLeft = nBytes;
	while ( nBytesLeft > 0 )
	{
		int toCopy = nBytesLeft;
		int curChunkLen = m_pChunkLengths[m_iCurChunk];
		
		int amtLeft = curChunkLen - m_iCurChunkPos;
		if ( nBytesLeft > amtLeft )
		{
			toCopy = amtLeft;
		}

		unsigned char *pCurChunkData = (unsigned char*)m_pChunks[m_iCurChunk];
		memcpy( pOutPos, &pCurChunkData[m_iCurChunkPos], toCopy );
		nBytesLeft -= toCopy;
		pOutPos += toCopy;

		// Slide up to the next chunk if we're done with the one we're on.
		m_iCurChunkPos += toCopy;
		assert( m_iCurChunkPos <= curChunkLen );
		if ( m_iCurChunkPos == curChunkLen )
		{
			++m_iCurChunk;
			m_iCurChunkPos = 0;
			if ( m_iCurChunk == m_nChunks )
			{
				assert( nBytesLeft == 0 );
			}
		}
	}
}


// ------------------------------------------------------------------------------------------ //
// CWaitTimer
// ------------------------------------------------------------------------------------------ //

bool g_bForceWaitTimers = false;

CWaitTimer::CWaitTimer( double flSeconds )
{
	m_StartTime = SampleMilliseconds();
	m_WaitMS = (unsigned long)( flSeconds * 1000.0 );
}


bool CWaitTimer::ShouldKeepWaiting()
{
	if ( m_WaitMS == 0 )
	{
		return false;
	}
	else
	{
		return ( SampleMilliseconds() - m_StartTime ) <= m_WaitMS || g_bForceWaitTimers;
	}
}



// ------------------------------------------------------------------------------------------ //
// CIPAddr.
// ------------------------------------------------------------------------------------------ //

CIPAddr::CIPAddr()
{
	Init( 0, 0, 0, 0, 0 ); 
}


CIPAddr::CIPAddr( const int inputIP[4], const int inputPort )
{
	Init( inputIP[0], inputIP[1], inputIP[2], inputIP[3], inputPort ); 
}


CIPAddr::CIPAddr( int ip0, int ip1, int ip2, int ip3, int ipPort )
{
	Init( ip0, ip1, ip2, ip3, ipPort );
}


void CIPAddr::Init( int ip0, int ip1, int ip2, int ip3, int ipPort )
{
	ip[0] = (unsigned char)ip0;
	ip[1] = (unsigned char)ip1;
	ip[2] = (unsigned char)ip2;
	ip[3] = (unsigned char)ip3;
	port  = (unsigned short)ipPort;
}

bool CIPAddr::operator==( const CIPAddr &o ) const
{
	return ip[0] == o.ip[0] && ip[1] == o.ip[1] && ip[2] == o.ip[2] && ip[3] == o.ip[3] && port == o.port;
}


bool CIPAddr::operator!=( const CIPAddr &o ) const
{
	return !( *this == o );
}


void CIPAddr::SetupLocal( int inPort )
{
	ip[0] = 0x7f;
	ip[1] = 0;
	ip[2] = 0;
	ip[3] = 1;
	port = inPort;
}


// ------------------------------------------------------------------------------------------ //
// Static helpers.
// ------------------------------------------------------------------------------------------ //

static double IP_FloatTime()
{
	CCycleCount cnt;
	cnt.Sample();
	return cnt.GetSeconds();
}

TIMEVAL SetupTimeVal( double flTimeout )
{
	TIMEVAL timeVal;
	timeVal.tv_sec = (long)flTimeout;
	timeVal.tv_usec = (long)( (flTimeout - (long)flTimeout) * 1000.0 );
	return timeVal;
}

// Convert a CIPAddr to a sockaddr_in.
void IPAddrToInAddr( const CIPAddr *pIn, in_addr *pOut )
{
	u_char *p = (u_char*)pOut;
	p[0] = pIn->ip[0];
	p[1] = pIn->ip[1];
	p[2] = pIn->ip[2];
	p[3] = pIn->ip[3];
}

// Convert a CIPAddr to a sockaddr_in.
void IPAddrToSockAddr( const CIPAddr *pIn, struct sockaddr_in *pOut )
{
	memset( pOut, 0, sizeof(*pOut) );
	pOut->sin_family = AF_INET;
	pOut->sin_port = htons( pIn->port );
	
	IPAddrToInAddr( pIn, &pOut->sin_addr );
}

// Convert a CIPAddr to a sockaddr_in.
void SockAddrToIPAddr( const struct sockaddr_in *pIn, CIPAddr *pOut )
{
	const u_char *p = (const u_char*)&pIn->sin_addr;
	pOut->ip[0] = p[0];
	pOut->ip[1] = p[1];
	pOut->ip[2] = p[2];
	pOut->ip[3] = p[3];
	pOut->port = ntohs( pIn->sin_port );
}


class CIPSocket : public ISocket
{
public:
					CIPSocket()
					{
						m_Socket = INVALID_SOCKET;
						m_bSetupToBroadcast = false;
					}

	virtual			~CIPSocket()
	{
		Term();
	}


// ISocket implementation.
public:

	virtual void	Release()
	{
		delete this;
	}

	
	virtual bool CreateSocket()
	{
		// Clear any old socket we had around.
		Term();

		// Create a socket to send and receive through.
		SOCKET sock = socket( AF_INET, SOCK_DGRAM, IPPROTO_IP );
		if ( sock == INVALID_SOCKET )
		{
			Assert( false );
			return false;
		}

		// Nonblocking please..
		int status;
		DWORD val = 1;
		status = ioctlsocket( sock, FIONBIO, &val );
		if ( status != 0 )
		{
			assert( false );
			closesocket( sock );
			return false;
		}

		m_Socket = sock;
		return true;
	}


	// Called after we have a socket.
	virtual bool BindPart2( const CIPAddr *pAddr )
	{
		Assert( m_Socket != INVALID_SOCKET );

		// bind to it!
		sockaddr_in addr;
		IPAddrToSockAddr( pAddr, &addr );

		int status = bind( m_Socket, (sockaddr*)&addr, sizeof(addr) );
		if ( status == 0 )
		{
			return true;
		}
		else
		{
			Term();
			return false;
		}
	}


	virtual bool	Bind( const CIPAddr *pAddr )
	{
		if ( !CreateSocket() )
			return false;
    
		return BindPart2( pAddr );
	}

	virtual bool	BindToAny( const unsigned short port )
	{
		// (INADDR_ANY)
		CIPAddr addr;
		addr.ip[0] = addr.ip[1] = addr.ip[2] = addr.ip[3] = 0;
		addr.port = port;
		return Bind( &addr );
	}

	virtual bool	ListenToMulticastStream( const CIPAddr &addr, const CIPAddr &localInterface )
	{
		ip_mreq mr;
		IPAddrToInAddr( &addr, &mr.imr_multiaddr );
		IPAddrToInAddr( &localInterface, &mr.imr_interface );

		// This helps a lot if the stream is sending really fast.
		int rcvBuf = 1024*1024*2;
		int ret = setsockopt( m_Socket, SOL_SOCKET, SO_RCVBUF, (char*)&rcvBuf, sizeof( rcvBuf ) );

		return setsockopt( m_Socket, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char*)&mr, sizeof( mr ) ) == 0;
	}
	
	virtual bool	Broadcast( const void *pData, const int len, const unsigned short port )
	{
		assert( m_Socket != INVALID_SOCKET );

		// Make sure we're setup to broadcast.
		if ( !m_bSetupToBroadcast )
		{
			BOOL bBroadcast = true;
			if ( setsockopt( m_Socket, SOL_SOCKET, SO_BROADCAST, (char*)&bBroadcast, sizeof( bBroadcast ) ) != 0 )
			{
				assert( false );
				return false;
			}

			m_bSetupToBroadcast = true;
		}

		CIPAddr addr;
		addr.ip[0] = addr.ip[1] = addr.ip[2] = addr.ip[3] = 0xFF;
		addr.port = port;
		return SendTo( &addr, pData, len );
	}
	
	virtual bool	SendTo( const CIPAddr *pAddr, const void *pData, const int len )
	{
		return SendChunksTo( pAddr, &pData, &len, 1 );
	}

	virtual bool SendChunksTo( const CIPAddr *pAddr, void const * const *pChunks, const int *pChunkLengths, int nChunks )
	{
		WSABUF bufs[32];
		if ( nChunks > 32 )
		{
			Error( "CIPSocket::SendChunksTo: too many chunks (%d).", nChunks );
		}

		int nTotalBytes = 0;
		for ( int i=0; i < nChunks; i++ )
		{
			bufs[i].len = pChunkLengths[i];
			bufs[i].buf = (char*)pChunks[i];
			nTotalBytes += pChunkLengths[i];
		}

		assert( m_Socket != INVALID_SOCKET );

		// Translate the address.
		sockaddr_in addr;
		IPAddrToSockAddr( pAddr, &addr );

		DWORD dwNumBytesSent = 0;
		DWORD ret = WSASendTo( 
			m_Socket, 
			bufs,
			nChunks,
			&dwNumBytesSent,
			0,
			(sockaddr*)&addr,
			sizeof( addr ),
			NULL,
			NULL
			);

		return ret == 0 && (int)dwNumBytesSent == nTotalBytes;
	}

	virtual int		RecvFrom( void *pData, int maxDataLen, CIPAddr *pFrom )
	{
		assert( m_Socket != INVALID_SOCKET );

		fd_set readSet;
		readSet.fd_count = 1;
		readSet.fd_array[0] = m_Socket;

		TIMEVAL timeVal = SetupTimeVal( 0 );

		// See if it has a packet waiting.
		int status = select( 0, &readSet, NULL, NULL, &timeVal );
		if ( status == 0 || status == SOCKET_ERROR )
			return -1;

		// Get the data.
		sockaddr_in sender;
		int fromSize = sizeof( sockaddr_in );
		status = recvfrom( m_Socket, (char*)pData, maxDataLen, 0, (struct sockaddr*)&sender, &fromSize );
		if ( status == 0 || status == SOCKET_ERROR )
		{
			return -1;
		}
		else
		{
			if ( pFrom )
			{
				SockAddrToIPAddr( &sender, pFrom );
			}
	
			m_flLastRecvTime = IP_FloatTime();
			return status;
		}
	}

	virtual double	GetRecvTimeout()
	{
		return IP_FloatTime() - m_flLastRecvTime;
	}
	

private:

	void			Term()
	{
		if ( m_Socket != INVALID_SOCKET )
		{
			closesocket( m_Socket );
			m_Socket = INVALID_SOCKET;
		}

		m_bSetupToBroadcast = false;
	}


private:

	SOCKET			m_Socket;
	bool			m_bSetupToBroadcast;
	double			m_flLastRecvTime;
	bool			m_bListenSocket;
};



ISocket* CreateIPSocket()
{
	return new CIPSocket;
}


ISocket* CreateMulticastListenSocket( 
	const CIPAddr &addr, 
	const CIPAddr &localInterface )
{
	CIPSocket *pSocket = new CIPSocket;

	CIPAddr bindAddr = localInterface;
	bindAddr.port = addr.port;

	if ( pSocket->Bind( &bindAddr ) &&
		pSocket->ListenToMulticastStream( addr, localInterface )
		)
	{
		return pSocket;
	}
	else
	{
		pSocket->Release();
		return NULL;
	}
}


bool ConvertStringToIPAddr( const char *pStr, CIPAddr *pOut )
{
	char ipStr[512];

	char *pColon = strchr( pStr, ':' );
	if ( pColon )
	{
		int toCopy = pColon - pStr;
		if ( toCopy < 2 || toCopy > sizeof(ipStr)-1 )
		{
			assert( false );
			return false;
		}

		memcpy( ipStr, pStr, toCopy );
		ipStr[toCopy] = 0;

		pOut->port = (unsigned short)atoi( pColon+1 );
	}
	else
	{
		strncpy( ipStr, pStr, sizeof( ipStr ) );
		ipStr[ sizeof(ipStr)-1 ] = 0;
	}

	if ( ipStr[0] >= '0' && ipStr[0] <= '9' )
	{
		// It's numbers.
		const char *pCurPos = pStr;
		for ( int i=0; i < 4; i++ )
		{
			while ( *pCurPos == ' ' || *pCurPos == ':' )
				++pCurPos;

			if ( *pCurPos == 0 )
				return false;

			int val = 0;
			while ( *pCurPos >= '0' && *pCurPos < '9' )
			{
				val *= 10;
				val += *pCurPos - '0';
			}

			if ( val >= 256 )
			{
				assert( false );
				return false;
			}

			pOut->ip[i] = (unsigned char)val;
		}
	}
	else
	{
		// It's a text string.
		struct hostent *pHost = gethostbyname( ipStr );
		if( !pHost )
			return false;

		pOut->ip[0] = pHost->h_addr_list[0][0];
		pOut->ip[1] = pHost->h_addr_list[0][1];
		pOut->ip[2] = pHost->h_addr_list[0][2];
		pOut->ip[3] = pHost->h_addr_list[0][3];
	}

	return true;
}


bool ConvertIPAddrToString( const CIPAddr *pIn, char *pOut, int outLen )
{
	in_addr addr;
	addr.S_un.S_un_b.s_b1 = pIn->ip[0];
	addr.S_un.S_un_b.s_b2 = pIn->ip[1];
	addr.S_un.S_un_b.s_b3 = pIn->ip[2];
	addr.S_un.S_un_b.s_b4 = pIn->ip[3];

	HOSTENT *pEnt = gethostbyaddr( (char*)&addr, sizeof( addr ), AF_INET );
	if ( pEnt )
	{
		Q_strncpy( pOut, pEnt->h_name, outLen );
		return true;
	}
	else
	{
		return false;
	}
}


void IP_GetLastErrorString( char *pStr, int maxLen )
{
	char *lpMsgBuf;
	FormatMessage( 
		FORMAT_MESSAGE_ALLOCATE_BUFFER | 
		FORMAT_MESSAGE_FROM_SYSTEM | 
		FORMAT_MESSAGE_IGNORE_INSERTS,
		NULL,
		GetLastError(),
		MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
		(LPTSTR) &lpMsgBuf,
		0,
		NULL 
	);

	Q_strncpy( pStr, lpMsgBuf, maxLen );
	LocalFree( lpMsgBuf );	
}

