tf2/tf2_src/utils/vcrtrace/vcrtrace.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//
//=============================================================================//
// vcrtrace.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <time.h>
#include "tier0/vcrmode.h"
#include "tier1/utlvector.h"



IVCRTrace *g_pTrace = 0;


class CVCRHelpers : public IVCRHelpers
{
public:
	virtual void	ErrorMessage( const char *pMsg )
	{
		Msg("ERROR: %s\n", pMsg);
	}

	virtual void*	GetMainWindow()
	{
		return 0;
	}
};

static CVCRHelpers g_VCRHelpers;


void ErrFunction( char const *pMsg )
{
	Msg( "%s", pMsg );
}


typedef struct
{
	int			m_Message;
	char const	*m_pName;
} WMessage;
#define DEFINE_WMESSAGE(x) x, #x


// Message table for windows messages.
WMessage g_WMessages[] =
{
	DEFINE_WMESSAGE(WM_NOTIFY),
	DEFINE_WMESSAGE(WM_INPUTLANGCHANGEREQUEST),
	DEFINE_WMESSAGE(WM_INPUTLANGCHANGE),
	DEFINE_WMESSAGE(WM_TCARD),
	DEFINE_WMESSAGE(WM_HELP),
	DEFINE_WMESSAGE(WM_USERCHANGED),
	DEFINE_WMESSAGE(WM_NOTIFYFORMAT),
	DEFINE_WMESSAGE(NFR_ANSI),
	DEFINE_WMESSAGE(NFR_UNICODE),
	DEFINE_WMESSAGE(NF_QUERY),
	DEFINE_WMESSAGE(NF_REQUERY),
	DEFINE_WMESSAGE(WM_CONTEXTMENU),
	DEFINE_WMESSAGE(WM_STYLECHANGING),
	DEFINE_WMESSAGE(WM_STYLECHANGED),
	DEFINE_WMESSAGE(WM_DISPLAYCHANGE),
	DEFINE_WMESSAGE(WM_GETICON),
	DEFINE_WMESSAGE(WM_SETICON),
	DEFINE_WMESSAGE(WM_NCCREATE),
	DEFINE_WMESSAGE(WM_NCDESTROY),
	DEFINE_WMESSAGE(WM_NCCALCSIZE),
	DEFINE_WMESSAGE(WM_NCHITTEST),
	DEFINE_WMESSAGE(WM_NCPAINT),
	DEFINE_WMESSAGE(WM_NCACTIVATE),
	DEFINE_WMESSAGE(WM_GETDLGCODE),
	DEFINE_WMESSAGE(WM_SYNCPAINT),
	DEFINE_WMESSAGE(WM_NCMOUSEMOVE),
	DEFINE_WMESSAGE(WM_NCLBUTTONDOWN),
	DEFINE_WMESSAGE(WM_NCLBUTTONUP),
	DEFINE_WMESSAGE(WM_NCLBUTTONDBLCLK),
	DEFINE_WMESSAGE(WM_NCRBUTTONDOWN),
	DEFINE_WMESSAGE(WM_NCRBUTTONUP),
	DEFINE_WMESSAGE(WM_NCRBUTTONDBLCLK),
	DEFINE_WMESSAGE(WM_NCMBUTTONDOWN),
	DEFINE_WMESSAGE(WM_NCMBUTTONUP),
	DEFINE_WMESSAGE(WM_NCMBUTTONDBLCLK),
	DEFINE_WMESSAGE(WM_KEYFIRST),
	DEFINE_WMESSAGE(WM_KEYDOWN),
	DEFINE_WMESSAGE(WM_KEYUP),
	DEFINE_WMESSAGE(WM_CHAR),
	DEFINE_WMESSAGE(WM_DEADCHAR),
	DEFINE_WMESSAGE(WM_SYSKEYDOWN),
	DEFINE_WMESSAGE(WM_SYSKEYUP),
	DEFINE_WMESSAGE(WM_SYSCHAR),
	DEFINE_WMESSAGE(WM_SYSDEADCHAR),
	DEFINE_WMESSAGE(WM_KEYLAST),
	DEFINE_WMESSAGE(WM_IME_STARTCOMPOSITION),
	DEFINE_WMESSAGE(WM_IME_ENDCOMPOSITION),
	DEFINE_WMESSAGE(WM_IME_COMPOSITION),
	DEFINE_WMESSAGE(WM_IME_KEYLAST),
	DEFINE_WMESSAGE(WM_INITDIALOG),
	DEFINE_WMESSAGE(WM_COMMAND),
	DEFINE_WMESSAGE(WM_SYSCOMMAND),
	DEFINE_WMESSAGE(WM_TIMER),
	DEFINE_WMESSAGE(WM_HSCROLL),
	DEFINE_WMESSAGE(WM_VSCROLL),
	DEFINE_WMESSAGE(WM_INITMENU),
	DEFINE_WMESSAGE(WM_INITMENUPOPUP),
	DEFINE_WMESSAGE(WM_MENUSELECT),
	DEFINE_WMESSAGE(WM_MENUCHAR),
	DEFINE_WMESSAGE(WM_ENTERIDLE),
	DEFINE_WMESSAGE(WM_CTLCOLORMSGBOX),
	DEFINE_WMESSAGE(WM_CTLCOLOREDIT),
	DEFINE_WMESSAGE(WM_CTLCOLORLISTBOX),
	DEFINE_WMESSAGE(WM_CTLCOLORBTN),
	DEFINE_WMESSAGE(WM_CTLCOLORDLG),
	DEFINE_WMESSAGE(WM_CTLCOLORSCROLLBAR),
	DEFINE_WMESSAGE(WM_CTLCOLORSTATIC),
	DEFINE_WMESSAGE(WM_MOUSEMOVE),
	DEFINE_WMESSAGE(WM_LBUTTONDOWN),
	DEFINE_WMESSAGE(WM_LBUTTONUP),
	DEFINE_WMESSAGE(WM_LBUTTONDBLCLK),
	DEFINE_WMESSAGE(WM_RBUTTONDOWN),
	DEFINE_WMESSAGE(WM_RBUTTONUP),
	DEFINE_WMESSAGE(WM_RBUTTONDBLCLK),
	DEFINE_WMESSAGE(WM_MBUTTONDOWN),
	DEFINE_WMESSAGE(WM_MBUTTONUP),
	DEFINE_WMESSAGE(WM_MBUTTONDBLCLK),
	DEFINE_WMESSAGE(WM_MOUSELAST),
	DEFINE_WMESSAGE(WM_PARENTNOTIFY),
	DEFINE_WMESSAGE(WM_ENTERMENULOOP),
	DEFINE_WMESSAGE(WM_EXITMENULOOP                 )
};

// Message table for winsock messages.
WMessage g_WinsockMessages[] = 
{
	DEFINE_WMESSAGE(WSAEWOULDBLOCK),
	DEFINE_WMESSAGE(WSAEINPROGRESS),
	DEFINE_WMESSAGE(WSAEALREADY),
	DEFINE_WMESSAGE(WSAENOTSOCK),
	DEFINE_WMESSAGE(WSAEDESTADDRREQ),
	DEFINE_WMESSAGE(WSAEMSGSIZE),
	DEFINE_WMESSAGE(WSAEPROTOTYPE),
	DEFINE_WMESSAGE(WSAENOPROTOOPT),
	DEFINE_WMESSAGE(WSAEPROTONOSUPPORT),
	DEFINE_WMESSAGE(WSAESOCKTNOSUPPORT),
	DEFINE_WMESSAGE(WSAEOPNOTSUPP),
	DEFINE_WMESSAGE(WSAEPFNOSUPPORT),
	DEFINE_WMESSAGE(WSAEAFNOSUPPORT),
	DEFINE_WMESSAGE(WSAEADDRINUSE),
	DEFINE_WMESSAGE(WSAEADDRNOTAVAIL),
	DEFINE_WMESSAGE(WSAENETDOWN),
	DEFINE_WMESSAGE(WSAENETUNREACH),
	DEFINE_WMESSAGE(WSAENETRESET),
	DEFINE_WMESSAGE(WSAECONNABORTED),
	DEFINE_WMESSAGE(WSAECONNRESET),
	DEFINE_WMESSAGE(WSAENOBUFS),
	DEFINE_WMESSAGE(WSAEISCONN),
	DEFINE_WMESSAGE(WSAENOTCONN),
	DEFINE_WMESSAGE(WSAESHUTDOWN),
	DEFINE_WMESSAGE(WSAETOOMANYREFS),
	DEFINE_WMESSAGE(WSAETIMEDOUT),
	DEFINE_WMESSAGE(WSAECONNREFUSED),
	DEFINE_WMESSAGE(WSAELOOP),
	DEFINE_WMESSAGE(WSAENAMETOOLONG),
	DEFINE_WMESSAGE(WSAEHOSTDOWN),
	DEFINE_WMESSAGE(WSAEHOSTUNREACH),
	DEFINE_WMESSAGE(WSAENOTEMPTY),
	DEFINE_WMESSAGE(WSAEPROCLIM),
	DEFINE_WMESSAGE(WSAEUSERS),
	DEFINE_WMESSAGE(WSAEDQUOT),
	DEFINE_WMESSAGE(WSAESTALE),
	DEFINE_WMESSAGE(WSAEREMOTE),
	DEFINE_WMESSAGE(WSAEDISCON),
	DEFINE_WMESSAGE(WSASYSNOTREADY),
	DEFINE_WMESSAGE(WSAVERNOTSUPPORTED),
	DEFINE_WMESSAGE(WSANOTINITIALISED)
};


static char const* GetWMessageName(WMessage *pMessages, int nMessages, int msg)
{
	static char str[128];
	int i;

	for(i=0; i < nMessages; i++)
	{
		if(pMessages[i].m_Message == msg)
			return pMessages[i].m_pName;
	}

	sprintf(str, "%d", msg);
	return str;
}

FILE *g_fpTrace = NULL;
bool g_bEndOfFile = false;

template<class T>
static void VCRTrace_ReadVal(T &val)
{
	if ( fread( &val, 1, sizeof( val ), g_fpTrace ) != sizeof( val ) )
		g_bEndOfFile = true;
}

static void VCRTrace_Read( void *pOut, int size )
{
	if ( fread( pOut, 1, size, g_fpTrace ) != (size_t)size )
		g_bEndOfFile = true;
}

void ReadAndPrintShortString( const char *pFormat )
{
	unsigned short len;
	VCRTrace_ReadVal( len );

	static CUtlVector<char> tempData;
	if ( tempData.Count() < len )
		tempData.SetSize( len );

	VCRTrace_Read( tempData.Base(), len );
	if ( len > 0 && ( tempData[len-2] == '\n' || tempData[len-2] == '\r' ) )
		tempData[len-2] = 0;

	Msg( pFormat, tempData.Base() );
}

static void VCR_TraceEvents()
{
	int iEvent = 0;

	g_pTrace = g_pVCR->GetVCRTraceInterface();
	
	while ( !g_bEndOfFile )
	{
		++iEvent;

		unsigned char eventCode;
		VCRTrace_Read( &eventCode, sizeof( eventCode ) );

		unsigned short iThread = 0;
		if ( eventCode & 0x80 )
		{
			VCRTrace_Read( &iThread, sizeof( iThread ) );
			eventCode &= ~0x80;
		}

		Msg( "%5d (thread %d): ", iEvent, iThread );

		VCREvent event = (VCREvent)eventCode;
		switch(event)
		{
			case VCREvent_Sys_FloatTime:
			{
				double ret;
				VCRTrace_Read(&ret, sizeof(ret));
				Msg("Sys_FloatTime: %f\n", ret);
			}
			break;
			
			case VCREvent_recvfrom:
			{
				int ret;
				char buf[8192];
				
				VCRTrace_Read(&ret, sizeof(ret));

				Assert(ret < (int)sizeof(buf));
				if(ret == SOCKET_ERROR)
				{
					int err;
					VCRTrace_ReadVal(err);

					Msg("recvfrom: %d (error %s)\n", ret, GetWMessageName(g_WinsockMessages, sizeof(g_WinsockMessages)/sizeof(g_WinsockMessages[0]), err));
				}
				else
				{
					Msg("recvfrom: %d\n", ret);
					VCRTrace_Read(buf, ret);

					char bFrom;
					VCRTrace_ReadVal( bFrom );
					if ( bFrom )
					{
						sockaddr_in from;
						VCRTrace_Read( &from, sizeof( from ) );
					}
				}
			}
			break;

			case VCREvent_SyncToken:
			{
				char len;
				char buf[256];

				VCRTrace_Read(&len, 1);
				VCRTrace_Read(buf, len);
				buf[len] = 0;

				Msg("SyncToken: %s\n", buf);
			}
			break;

			case VCREvent_GetCursorPos:
			{
				POINT pt;
				VCRTrace_ReadVal(pt);
				Msg("GetCursorPos: (%d, %d)\n", pt.x, pt.y);
			}
			break;

			case VCREvent_SetCursorPos:
			{
				int x, y;
				VCRTrace_Read(&x, sizeof(x));
				VCRTrace_Read(&y, sizeof(y));
				Msg("SetCursorPos: (%d, %d)\n", x, y);
			}
			break;

			case VCREvent_ScreenToClient:
			{
				POINT pt;
				VCRTrace_ReadVal(pt);
				Msg("ScreenToClient: (%d, %d)\n", pt.x, pt.y);
			}
			break;

			case VCREvent_Cmd_Exec:
			{
				int len;
				char *f;

				VCRTrace_Read(&len, sizeof(len));
				
				if(len != -1)
				{
					f = (char*)malloc(len);
					VCRTrace_Read(f, len);
				}
				
				Msg("Cmd_Exec: %d\n", len);
			}
			break;

			case VCREvent_CmdLine:
			{
				int len;
				char str[8192];

				VCRTrace_Read(&len, sizeof(len));
				Assert(len < sizeof(str));
				VCRTrace_Read(str, len);

				Msg("CmdLine: %s\n", str);
			}
			break;

			case VCREvent_RegOpenKeyEx:
			{
				long ret;
				VCRTrace_ReadVal(ret);
				Msg("RegOpenKeyEx: %d\n", ret);
			}
			break;

			case VCREvent_RegSetValueEx:
			{
				long ret;
				VCRTrace_ReadVal(ret);
				Msg("RegSetValueEx: %d\n", ret);
			}
			break;

			case VCREvent_RegQueryValueEx:
			{
				long ret;
				unsigned long type, cbData;
				char dummy;

				VCRTrace_ReadVal(ret);
				VCRTrace_ReadVal(type);
				VCRTrace_ReadVal(cbData);
				while(cbData)
				{
					VCRTrace_ReadVal(dummy);
					cbData--;
				}

				Msg("RegQueryValueEx\n");
			}
			break;

			case VCREvent_RegCreateKeyEx:
			{
				long ret;
				VCRTrace_ReadVal(ret);
				Msg("RegCreateKeyEx: %d\n", ret);
			}
			break;

			case VCREvent_RegCloseKey:
			{
				Msg("VCREvent_RegCloseKey\n");
			}
			break;
			
			case VCREvent_PeekMessage:
			{
				MSG msg;
				int valid;

				VCRTrace_Read(&valid, sizeof(valid));
				if(valid)
				{
					VCRTrace_Read(&msg, sizeof(MSG));
				}

				Msg("PeekMessage - msg: %s, wParam: %x, lParam: %x\n", GetWMessageName(g_WMessages, sizeof(g_WMessages)/sizeof(g_WMessages[0]), msg.message), msg.wParam, msg.lParam);
			}
			break;

			case VCREvent_GameMsg:
			{
				char valid;
				VCRTrace_Read( &valid, sizeof(valid) );

				if ( valid )
				{
					UINT uMsg;
					WPARAM wParam;
					LPARAM lParam;
					VCRTrace_Read( &uMsg, sizeof(uMsg) );
					VCRTrace_Read( &wParam, sizeof(wParam) );
					VCRTrace_Read( &lParam, sizeof(lParam) );
					Msg( "GameMsg - msg: %s, wParam: %x, lParam: %x\n", GetWMessageName(g_WMessages, sizeof(g_WMessages)/sizeof(g_WMessages[0]), uMsg), wParam, lParam );
				}
				else
				{
					Msg("GameMsg - <end>\n" );
				}
			}
			break;

			case VCREvent_GetNumberOfConsoleInputEvents:
			{
				char val;
				unsigned long nEvents;
				
				VCRTrace_ReadVal( val );
				VCRTrace_ReadVal( nEvents );

				Msg( "GetNumberOfConsoleInputEvents (returned %d, nEvents = %d)\n", val, nEvents );
			}
			break;

			case VCREvent_ReadConsoleInput:
			{
				char val;
				unsigned long nRead;
				INPUT_RECORD recs[1024];

				VCRTrace_ReadVal( val );
				if ( val )
				{
					VCRTrace_ReadVal( nRead );
					VCRTrace_Read( recs, nRead * sizeof( INPUT_RECORD ) );
				}
				else
				{
					nRead = 0;
				}

				Msg( "ReadConsoleInput (returned %d, nRead = %d)\n", val, nRead );
			}
			break;

			case VCREvent_GetKeyState:
			{
				short ret;
				VCRTrace_ReadVal( ret );
				Msg( "VCREvent_GetKeyState: %d\n", ret );
			}
			break;

			case VCREvent_recv:
			{
				int ret;
				
				// Get the result from our file.
				VCRTrace_ReadVal( ret );
				if ( ret == SOCKET_ERROR )
				{
					int err;
					VCRTrace_ReadVal( err );
					Msg( "VCREvent_recv - SOCKET_ERROR - %d\n", err );
				}
				else
				{
					CUtlVector<char> dummyData;
					dummyData.SetSize( ret );
					VCRTrace_Read( dummyData.Base(), ret );
					Msg( "VCREvent_recv - size %d", ret );
				}
			}
			break;

			case VCREvent_send:
			{
				int ret;

				// Get the result from our file.
				VCRTrace_ReadVal( ret );										   
				if ( ret == SOCKET_ERROR )
				{
					int err;
					VCRTrace_ReadVal(err);
					Msg( "VCREvent_send - SOCKET_ERROR - %d\n", err );
				}
				else
				{
					Msg( "VCREvent_send - %d\n", ret );
				}
			}
			break;

			case VCREvent_Generic:
			{
				unsigned char nameLen;
				VCRTrace_ReadVal( nameLen );
				char testName[512] = "(none)";

				if ( nameLen != 255 )
				{
					VCRTrace_Read( testName, nameLen );
				}

				int dataLen;
				VCRTrace_ReadVal( dataLen );

				CUtlVector<char> tempData;
				tempData.SetSize( dataLen );
				VCRTrace_Read( tempData.Base(), dataLen );

				Msg( "VCREvent_Generic (name: %s, len: %d)\n", testName, dataLen );
			}
			break;

			case VCREvent_CreateThread:
			{
				Msg( "VCREvent_CreateThread\n" );
			}
			break;

			case VCREvent_WaitForSingleObject:
			{
				char val;
				VCRTrace_ReadVal( val );
				
				Msg( "VCREvent_WaitForSingleObject " );
				if ( val == 1 )
					Msg( "(WAIT_OBJECT_0)\n" );
				else if ( val == 2 )
					Msg( "(WAIT_ABANDONED)\n" );
				else
					Msg( "(WAIT_TIMEOUT)\n" );
			}
			break;

			case VCREvent_EnterCriticalSection:
			{
				Msg( "VCREvent_EnterCriticalSection\n" );
			}
			break;

			case VCREvent_LocalTime:
			{
				tm today;
				VCRTrace_ReadVal( today );
				Msg( "VCREvent_LocalTime\n" );
			}
			break;

			case VCREvent_Time:
			{
				long today;
				VCRTrace_ReadVal( today );
				Msg( "VCREvent_Time\n" );
			}
			break;

			case VCREvent_GenericString:
			{
				Msg( "VCREvent_GenericString: " );

				ReadAndPrintShortString( "[%s]  " );
				ReadAndPrintShortString( "%s" );
				Msg( "\n" );
			}
			break;

			default:
			{
				Msg( "***ERROR*** VCR_TraceEvent: invalid event" );
				return;
			}
		}
	}
}


SpewRetval_t MySpewOutput( SpewType_t spewType, tchar const *pMsg )
{
	printf( "%s", pMsg );
	OutputDebugString( pMsg );

	if ( spewType == SPEW_ASSERT )
		return SPEW_DEBUGGER;
	
	else if ( spewType == SPEW_ERROR )
		return SPEW_ABORT;
	
	else
		return SPEW_CONTINUE;
}


int main(int argc, char* argv[])
{
	if(argc <= 1)
	{
		Msg("vcrtrace <vcr filename>\n");
		return 1;
	}

	SpewOutputFunc( MySpewOutput );

	g_fpTrace = fopen( argv[1], "rb" );
	if ( !g_fpTrace )
	{
		Msg("Invalid or mission VCR file '%s'\n", argv[1]);
		return 1;
	}

	unsigned long version;
	VCRTrace_ReadVal( version );
	if ( version != VCRFILE_VERSION )
	{
		Msg( "Invalid VCR file version (is %d, but we need %d).\n", version, VCRFILE_VERSION );
		return 1;
	}

	VCR_TraceEvents();
	return 0;
}