xtunnelstestmain.cpp

xtunnel nat/fw traversal source code

/*

	File:       XTunnelsTestMain.cp

	Contains:   Command line client to test XTunnels server with

	Copyright:  (c) 2003 by Xten Networks, Inc., all rights reserved.

*/


#include <iostream>
#include <unistd.h>
#include "uici.h"
#include "uiciudp.h"
#include "restart.h"
#include "uiciname.h"
#include "XTunnelsProtocol.h"
#include "XTunnelsByteOrder.h"
#include "XTunnelsCVsDES.h"
#include "XTunnelsCVsAES.h"
#include "XTunnelsFamilyData.h"
#include "XTunnelsChildData.h"
#include "XTunnelsXCipher.h"

using std::cout;
using std::cerr;
using std::endl;
using std::istrstream;
using namespace XTunnels;

#define UNITTEST_AES_ENCRYPTION 0
#if UNITTEST_AES_ENCRYPTION
#include <strstream>
using std::ostrstream;
#endif // UNITTEST_AES_ENCRYPTION

namespace {

int sClientTCPSocket = 0;
// for sending (receiving is in each packet) -- specified by however we the client want to pick it
// and expect server to echo the algorithm used on the last packet we sent
long sClientPacketEncryption = EAlgorithm_None;
unsigned long g_ulPacketIndex = 0; // all packets sent and received count, for the new security field

// for our load tests -- passed on command line
char g_szLoadTestDestinationAddress[EMaxSmallBufferSize] = { 0 };
unsigned long g_ulLoadTestSeconds = { 0 };
unsigned long g_ulLoadTestBytesPerSecond = { 0 };



// note that magic number and payload size are not set, 
// and inUnencryptedSize does not include magic number or packet index or encryption header
int SendPacketToMasterServer(
   TXTunnelsPacket* packet,
   ssize_t inUnencryptedSize)
	{
   TXTunnelsPacket* pTransmissionData = PreparePacketForTransmit(
      packet,
      inUnencryptedSize,
      sClientPacketEncryption,
      g_ulPacketIndex,
      ChildData()->m_szServerEncryptionKey
   );
   if (!pTransmissionData)
		return 1;

   int iTransmitErr = TransmitPreparedPacket(
      pTransmissionData,
      sClientTCPSocket,
      0,
      NULL
   );

	return iTransmitErr;
	}

void CheckNoMoreData()
	{
	char test;
	int result = 0, total = 0;
	
	setnonblock(sClientTCPSocket);
	while(1 == (result = r_read(sClientTCPSocket, &test, 1)))
		total++;
	setblock(sClientTCPSocket);
	
	if (total)
		cout << "WARNING: " << total << " bytes unknown extra data received!!" << endl;
	}

TXTunnelsPacket* GetMasterServerPacket(
   long& lInOutEncryptionType,
   unsigned long ulMessageType
   )
   {
   TXTunnelsPacket* pPacket = ReceivePacket(
      lInOutEncryptionType,
      sClientTCPSocket,
      0,
      NULL,
      0,
      0,
      10.0,
      ChildData()->m_szClientDecryptionKey
   );
   
   if (pPacket)
      {
      if (ulMessageType != pPacket->m_tHeaderBasic.commandid)
         {
		   cout << "PROTOCOL ERROR: GetMasterServerPacket() expected command ID " << ulMessageType << " not " << pPacket->m_tHeaderBasic.commandid << "!!" << endl;

         if (EMessageDisconnect == pPacket->m_tHeaderBasic.commandid)
            {
            unsigned long ulStringLength = XT2HOST16(pPacket->m_tData.disconnect.messagesize);
            unsigned long ulReason = ~EDisconnectDelayFlag & XT2HOST32(pPacket->m_tData.disconnect.reason);
	         // no trailing NUL
	         pPacket->m_tData.disconnect.message[ulStringLength] = 0;
	         cout << "DISCONNECT: got reason " << ulReason << endl;
	         cout << "DISCONNECT: got string[" << ulStringLength << "]: " << pPacket->m_tData.disconnect.message << endl;
            }
            
         return NULL;
         }
      }
   
   return pPacket;
   }
	
int TestServer(char* inHostName)
	{
	cout << "testxtunnels testing..." << endl;

	sClientTCPSocket = u_connect(kDefaultListenPort, inHostName);
	if (-1 == sClientTCPSocket)
		{
		cout << "testxtunnels failed to connect!" << endl;
		return 1;
		}
	cout << "testxtunnels connected to " << inHostName << endl;

#define TEST_TIMEOUT 0
#if TEST_TIMEOUT
	sleep(60);
#endif // TEST_TIMEOUT
	
	g_tSendingPacket.m_tData.m_ulPacketMagicNumber = HOST2XT32(EPacketMagicNumber);
	//ssize_t towrite, wrote;
	unsigned long ulPacketsize = 0;
   TXTunnelsPacket* pReturnedPacket = NULL;
	
//#pragma mark *** EMessagePing

	cout << "testing EMessagePing..." << endl;
	g_tSendingPacket.m_tHeaderBasic.commandid = HOST2XT32(EMessagePing);
	ulPacketsize = 0;
	g_tSendingPacket.m_tHeaderBasic.payloadsize = HOST2XT32(ulPacketsize);
	if (SendPacketToMasterServer(&g_tSendingPacket, ulPacketsize))
		{
		cout << "error sending EMessagePing!" << endl;
		return 1;
		}
	// no reply to EMessagePing
	CheckNoMoreData();

//#pragma mark *** EMessageVersion

	cout << "testing EMessageVersion..." << endl;
	ulPacketsize = sizeof(TVersionParam) ;
	g_tSendingPacket.m_tHeaderBasic.commandid = HOST2XT32(EMessageVersion);
	g_tSendingPacket.m_tHeaderBasic.payloadsize = HOST2XT32(ulPacketsize);
	g_tSendingPacket.m_tData.m_tVersion.m_byProtocolMajor = ECurrentProtocolMajorVersion;
	g_tSendingPacket.m_tData.m_tVersion.m_byProtocolMinor = ECurrentProtocolMinorVersion;
	g_tSendingPacket.m_tData.m_tVersion.m_wVersionID = HOST2XT16(ECurrentServerVersion);
	if (SendPacketToMasterServer(&g_tSendingPacket, ulPacketsize))
		{
		cout << "error sending EMessageVersion!" << endl;
		return 1;
		}
	// no reply to EMessageVersion, it seems 
	CheckNoMoreData();

//#pragma mark *** EMessageClientHello
   
   unsigned long ulLoginAlgorithm = EAlgorithm_SHA1; // EAlgorithm_MD5 // EAlgorithm_SHA1

	const char* userName = "alex";
	const char* userHost = "test.xten.net";
	//const char* userHost = "xten.net";
	const char* userPassword = "blah"; // for db tests
	//const char* userName = "elagerway";
	//const char* userHost = "xten.net";
	//const char* userPassword = "ymis0fat";

	//unsigned long ulConnectionType = ELoginAnonymous;
	unsigned long ulConnectionType = ELoginNamePassword;
   ServerChallengeParam tServerChallenge = { 0 };
   TClientToServerHelloParam tHelloUnpacked = { 0 };
   {
	cout << "testing EMessageClientHello..." << endl;
	FillWithRandomLongs(tHelloUnpacked.challengeblob, 20);
	tHelloUnpacked.challengeblobsize = 20;
   tHelloUnpacked.how = ulConnectionType;
   tHelloUnpacked.useridsize = strlen(userName);
   strcpy(tHelloUnpacked.m_szUserID, userName);
   tHelloUnpacked.userhostsize = strlen(userHost);
   strcpy(tHelloUnpacked.m_szHost, userHost);
	// this would be stored from previous session if we were to put something here
	memset(&tHelloUnpacked.sessionuuid, 0, 16);
	if (userName[0])
		{
		tHelloUnpacked.algorithm = ulLoginAlgorithm;
	   //tHelloUnpacked.challengeblobsize = challengerblobsize; -- set above
		}
	else
		{
		tHelloUnpacked.algorithm = EAlgorithm_None;
	   tHelloUnpacked.challengeblobsize = 0;
		}
	tHelloUnpacked.desiredtimeout = HOST2XT32(59);
   // now pack and send it
	ulPacketsize = 
	   sizeof(tHelloUnpacked.how)
	   + sizeof(tHelloUnpacked.useridsize)
	   + tHelloUnpacked.useridsize
	   + sizeof(tHelloUnpacked.userhostsize)
	   + tHelloUnpacked.userhostsize
	   + sizeof(tHelloUnpacked.sessionuuid)
	   + sizeof(tHelloUnpacked.algorithm)
	   + sizeof(tHelloUnpacked.desiredtimeout)
	   + sizeof(tHelloUnpacked.challengeblobsize)
	   + tHelloUnpacked.challengeblobsize;
	g_tSendingPacket.m_tHeaderBasic.commandid = HOST2XT32(EMessageClientHello);
	g_tSendingPacket.m_tHeaderBasic.payloadsize = HOST2XT32(ulPacketsize);
   char* pCurrentPayloadOffset = g_tSendingPacket.m_tData.m_pPayload;
   *(unsigned long*)pCurrentPayloadOffset = HOST2XT32(tHelloUnpacked.how);
   pCurrentPayloadOffset += sizeof(tHelloUnpacked.how);
   *(unsigned short*)pCurrentPayloadOffset = HOST2XT16(tHelloUnpacked.useridsize);
   pCurrentPayloadOffset += sizeof(tHelloUnpacked.useridsize);
   strncpy(pCurrentPayloadOffset, tHelloUnpacked.m_szUserID, tHelloUnpacked.useridsize);
   pCurrentPayloadOffset += tHelloUnpacked.useridsize;
   *(unsigned short*)pCurrentPayloadOffset = HOST2XT16(tHelloUnpacked.userhostsize);
   pCurrentPayloadOffset += sizeof(tHelloUnpacked.userhostsize);
   strncpy(pCurrentPayloadOffset, tHelloUnpacked.m_szHost, tHelloUnpacked.userhostsize);
   pCurrentPayloadOffset += tHelloUnpacked.userhostsize;
	memcpy(pCurrentPayloadOffset, &tHelloUnpacked.sessionuuid, sizeof(tHelloUnpacked.sessionuuid));
   pCurrentPayloadOffset += sizeof(tHelloUnpacked.sessionuuid);
   *(unsigned long*)pCurrentPayloadOffset = HOST2XT32(tHelloUnpacked.algorithm);
   pCurrentPayloadOffset += sizeof(tHelloUnpacked.algorithm);
   *(unsigned long*)pCurrentPayloadOffset = HOST2XT32(tHelloUnpacked.desiredtimeout);
   pCurrentPayloadOffset += sizeof(tHelloUnpacked.desiredtimeout);
   *(unsigned long*)pCurrentPayloadOffset = HOST2XT32(tHelloUnpacked.challengeblobsize);
   pCurrentPayloadOffset += sizeof(tHelloUnpacked.challengeblobsize);
	memcpy(pCurrentPayloadOffset, tHelloUnpacked.challengeblob, tHelloUnpacked.challengeblobsize);

	if (SendPacketToMasterServer(&g_tSendingPacket, ulPacketsize))
		{
		cout << "error sending EMessageClientHello!" << endl;
		return 1;
		}

	// expect version back
	
   pReturnedPacket = GetMasterServerPacket(sClientPacketEncryption, EMessageVersion);
   if (!pReturnedPacket)
		{
		cout << "error receiving EMessageVersion packet! " << endl;
		return 1;
		}
	cout << "got protocol " 
	      << (unsigned long)pReturnedPacket->m_tData.m_tVersion.m_byProtocolMajor
	      << "."
	      << (unsigned long)pReturnedPacket->m_tData.m_tVersion.m_byProtocolMinor
	      << " build "
	      << XT2HOST16(pReturnedPacket->m_tData.m_tVersion.m_wVersionID)
	      << endl;
	      
	// then expect challenge back
	
   pReturnedPacket = GetMasterServerPacket(sClientPacketEncryption, EMessageServerChallenge);
   if (!pReturnedPacket)
		{
		cout << "error receiving EMessageServerChallenge blob data!" << endl;
		return 1;
		}