tf2/tf2_src/utils/getbugs/getbugs.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//
#include <stdio.h>
#include <windows.h>
#include "tier0/dbg.h"
#include "utldict.h"
#include "filesystem.h"
#include "KeyValues.h"
#include "cmdlib.h"
#include "interface.h"
#include "imysqlwrapper.h"
#include "../bugreporter/trktool.h"
#include "utlbuffer.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <direct.h>

bool uselogfile = false;

static bool spewed = false;

static char workingdir[ 256 ];

#define SCR_TYPE 1

#define DEFAULT_DBMS		"tracker"
#define DEFAULT_USERNAME	"PublicUser"
#define DEFAULT_PASSWORD	DEFAULT_USERNAME

#define BUG_REPOSITORY_FMT		"\\\\fileserver\\bugs\\public\\%s\\%s\\%s.zip"

struct BugField_t
{
	BugField_t()
	{
		value[ 0 ] = 0;
		numvalue = 0;
		trkfield[ 0 ] = 0;
		isdesc = false;
		isnumeric = false;
	}

	char	value[ 8192 ];
	int		numvalue;
	char	trkfield[ 256 ];
	bool	isdesc;
	bool	isnumeric;
};

#define SQL_SETVALUE( fieldname, sqlcolumn )	Q_strncpy( bug.m_pBug->fieldname, sqlcolumn.String(), sizeof( bug.m_pBug->fieldname ) );
#define SQL_SETVALUESTRING( fieldname, str )	Q_strncpy( bug.m_pBug->fieldname, str, sizeof( bug.m_pBug->fieldname ) );


class CBugReporter
{
public:

	CBugReporter();
	virtual ~CBugReporter();

	// Initialize and login with default username/password for this computer (from resource/bugreporter.res)
	virtual bool		Init( char const *projectname );
	virtual void		Shutdown();

	virtual bool		IsPublicUI() { return false; }

// Submission API
	virtual void		StartNewBugReport();
	virtual void		CancelNewBugReport();
	virtual bool		CommitBugReport( int& bugSubmissionId );

	virtual void		AddField( char const *fieldname, char const *value, bool isdesc = false );
	virtual void		AddNumericField( char const *fieldname, int value );

private:

	void				ReportError(TRK_UINT rc, char const *func, char const *msg );
	TRK_UINT			Login(TRK_HANDLE* pTrkHandle, char const *projectname );

	void				SubstituteBugId( int bugid, char *out, int outlen, CUtlBuffer& src );

	TRK_HANDLE					trkHandle;
	TRK_RECORD_HANDLE			trkRecHandle;

public:
	CUtlVector< BugField_t	>	m_Fields;
};

void CBugReporter::AddField( char const *fieldname, char const *value, bool isdesc /*=false*/ )
{
	BugField_t fld;
	Q_strncpy( fld.value, value, sizeof( fld.value ) );
	fld.isnumeric = false;
	Q_strncpy( fld.trkfield, fieldname, sizeof( fld.trkfield ) );
	fld.isdesc = isdesc;

	m_Fields.AddToTail( fld );
}

void CBugReporter::AddNumericField( char const *fieldname, int value )
{
	BugField_t fld;
	fld.numvalue = value;
	fld.isnumeric = true;
	Q_strncpy( fld.trkfield, fieldname, sizeof( fld.trkfield ) );
	fld.isdesc = false;

	m_Fields.AddToTail( fld );
}

CBugReporter::CBugReporter()
{
	trkHandle		= (TRK_HANDLE)0;
	trkRecHandle	= (TRK_RECORD_HANDLE)0;
}

CBugReporter::~CBugReporter()
{
	m_Fields.RemoveAll();
}

struct TRKELookup
{
	unsigned int id;
	char const *str;
};

#define TRKERROR( id )	{ id, #id }

static TRKELookup g_Lookup[] =
{
	TRKERROR( TRK_SUCCESS ),
	TRKERROR( TRK_E_VERSION_MISMATCH ),
	TRKERROR( TRK_E_OUT_OF_MEMORY ),
	TRKERROR( TRK_E_BAD_HANDLE ),
	TRKERROR( TRK_E_BAD_INPUT_POINTER ),
	TRKERROR( TRK_E_BAD_INPUT_VALUE ),
	TRKERROR( TRK_E_DATA_TRUNCATED ),
	TRKERROR( TRK_E_NO_MORE_DATA ),
	TRKERROR( TRK_E_LIST_NOT_INITIALIZED ),
	TRKERROR( TRK_E_END_OF_LIST ),
	TRKERROR( TRK_E_NOT_LOGGED_IN ),
	TRKERROR( TRK_E_SERVER_NOT_PREPARED ),
	TRKERROR( TRK_E_BAD_DATABASE_VERSION ),
	TRKERROR( TRK_E_UNABLE_TO_CONNECT ),
	TRKERROR( TRK_E_UNABLE_TO_DISCONNECT ),
	TRKERROR( TRK_E_UNABLE_TO_START_TIMER ),
	TRKERROR( TRK_E_NO_DATA_SOURCES ),
	TRKERROR( TRK_E_NO_PROJECTS ),
	TRKERROR( TRK_E_WRITE_FAILED ),
	TRKERROR( TRK_E_PERMISSION_DENIED ),
	TRKERROR( TRK_E_SET_FIELD_DENIED ),
	TRKERROR( TRK_E_ITEM_NOT_FOUND ),
	TRKERROR( TRK_E_CANNOT_ACCESS_DATABASE ),
	TRKERROR( TRK_E_CANNOT_ACCESS_QUERY ),
	TRKERROR( TRK_E_CANNOT_ACCESS_INTRAY ),
	TRKERROR( TRK_E_CANNOT_OPEN_FILE ),
	TRKERROR( TRK_E_INVALID_DBMS_TYPE ),
	TRKERROR( TRK_E_INVALID_RECORD_TYPE ),
	TRKERROR( TRK_E_INVALID_FIELD ),
	TRKERROR( TRK_E_INVALID_CHOICE ),
	TRKERROR( TRK_E_INVALID_USER ),
	TRKERROR( TRK_E_INVALID_SUBMITTER ),
	TRKERROR( TRK_E_INVALID_OWNER ),
	TRKERROR( TRK_E_INVALID_DATE ),
	TRKERROR( TRK_E_INVALID_STORED_QUERY ),
	TRKERROR( TRK_E_INVALID_MODE ),
	TRKERROR( TRK_E_INVALID_MESSAGE ),
	TRKERROR( TRK_E_VALUE_OUT_OF_RANGE ),
	TRKERROR( TRK_E_WRONG_FIELD_TYPE ),
	TRKERROR( TRK_E_NO_CURRENT_RECORD ),
	TRKERROR( TRK_E_NO_CURRENT_NOTE ),
	TRKERROR( TRK_E_NO_CURRENT_ATTACHED_FILE ),
	TRKERROR( TRK_E_NO_CURRENT_ASSOCIATION ),
	TRKERROR( TRK_E_NO_RECORD_BEGIN ),
	TRKERROR( TRK_E_NO_MODULE ),
	TRKERROR( TRK_E_USER_CANCELLED ),
	TRKERROR( TRK_E_SEMAPHORE_TIMEOUT ),
	TRKERROR( TRK_E_SEMAPHORE_ERROR ),
	TRKERROR( TRK_E_INVALID_SERVER_NAME ),
	TRKERROR( TRK_E_NOT_LICENSED )
};

void CBugReporter::ReportError(TRK_UINT rc, char const *func, char const *msg )
{
    if ( rc != TRK_SUCCESS )
	{
		switch (rc)
		{
		case TRK_E_ITEM_NOT_FOUND:
		    Msg( "%s %s was not found!\n", func,  msg );
			break;
		case TRK_E_INVALID_FIELD:
			Msg( "%s %s Invalid field!\n", func,  msg );
			break;
		default:
			int i = 0;
			for ( i; i < ARRAYSIZE( g_Lookup ) ; ++i )
			{
				if ( g_Lookup[ i ].id == rc )
				{
					Msg( "%s returned %i - %s (%s)!\n", func,  rc, g_Lookup[ i ].str, msg );
					break;
				}
			}

			if ( i >= ARRAYSIZE( g_Lookup ) )
			{
				Msg( "%s returned %i - %s! (%s)\n", func,  rc, "???", msg );
			}
			break;
		}
    }
}

TRK_UINT CBugReporter::Login(TRK_HANDLE* pTrkHandle, char const *projectname )
{
	char dbms[50] = DEFAULT_DBMS;

	char username[ 50 ];
	char password[ 50 ];

	Q_strncpy( username, DEFAULT_USERNAME, sizeof( username ) );
	Q_strncpy( password, DEFAULT_PASSWORD, sizeof( password ) );

	TRK_UINT rc = TrkProjectLogin(*pTrkHandle,
		username,
		password,
		projectname,
		NULL,
		NULL,
		NULL,
		NULL,
		TRK_USE_INI_FILE_DBMS_LOGIN);

	if (rc != TRK_SUCCESS)
	{
		rc = TrkProjectLogin(*pTrkHandle,
			username,
			"",
			projectname,
			NULL,
			NULL,
			NULL,
			NULL,
			TRK_USE_INI_FILE_DBMS_LOGIN);
		if (rc != TRK_SUCCESS)
		{
			Msg("Bug reporter init failed: Your tracker password must be your user name or blank.\n");
			return rc;
		}
	}

	TrkGetLoginDBMSName(*pTrkHandle, sizeof(dbms), dbms );

	char projout[ 256 ];

	TrkGetLoginProjectName(*pTrkHandle, sizeof( projout ), projout );
	
	Msg( "Project:  %s\n", projout );
	Msg( "Server:  %s\n", dbms );

	return rc;
}

//-----------------------------------------------------------------------------
// Purpose: Initialize and login with default username/password for this computer (from resource/bugreporter.res)
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBugReporter::Init( char const *projectname )
{
	TRK_UINT			rc;
	rc = TrkHandleAlloc( TRK_VERSION_ID, &trkHandle);
	if ( rc != TRK_SUCCESS )
	{
		ReportError(rc, "TrkHandleAlloc", "Failed to Allocate Tracker Handle!");
		return false;
	}

	// Login to default project out of INI file.
	rc = Login( &trkHandle, projectname );
	if (rc != TRK_SUCCESS)
	{
		return false;
	}

	rc = TrkRecordHandleAlloc(trkHandle, &trkRecHandle);
	if (rc != TRK_SUCCESS)
	{
		ReportError(rc, "TrkRecordHandleAlloc", 
			"Failed to Allocate Tracker Record Handle!");
		return false;
	}

	return true;
}

void CBugReporter::Shutdown()
{
	TRK_UINT			rc;
	
	if ( trkRecHandle )
	{
		rc = TrkRecordHandleFree(&trkRecHandle);
		if (rc != TRK_SUCCESS)
		{
			ReportError(rc, "TrkRecordHandleFree", "Failed to Free Tracker Record Handle!");
		}
	}

	if ( trkHandle )
	{
		rc = TrkProjectLogout(trkHandle);		
		if (rc != TRK_SUCCESS)
		{
			ReportError(rc, "TrkProjectLogout", "Failed to Logout of Project!");
		}
		else
		{
			rc = TrkHandleFree(&trkHandle);     
			if (rc != TRK_SUCCESS)
			{
				ReportError(rc, "TrkHandleFree", "Failed to Free Tracker Handle!");
			}
		}
	}
}

void CBugReporter::StartNewBugReport()
{
	m_Fields.RemoveAll();
}

void CBugReporter::CancelNewBugReport()
{
	m_Fields.RemoveAll();
}

void CBugReporter::SubstituteBugId( int bugid, char *out, int outlen, CUtlBuffer& src )
{
	out[ 0 ] = 0;

	char *dest = out;

	src.SeekGet( CUtlBuffer::SEEK_HEAD, 0 );

	char const *replace = "\\BugId\\";
	int replace_len = Q_strlen( replace );

	for ( int pos = 0; pos <= src.TellPut() && ( ( dest - out ) < outlen ); )
	{
		char const *str = ( char const * )src.PeekGet( pos );
		if ( !Q_strnicmp( str, replace, replace_len ) )
		{
			*dest++ = '\\';

			char num[ 32 ];
			Q_snprintf( num, sizeof( num ), "%i", bugid );
			char *pnum = num;
			while ( *pnum )
			{
				*dest++ = *pnum++;
			}

			*dest++ = '\\';
			pos += replace_len;
			continue;
		}

		*dest++ = *str;
		++pos;
	}
	*dest = 0;
}

bool CBugReporter::CommitBugReport( int& bugSubmissionId )
{
	bugSubmissionId = -1;

	int fieldCount = m_Fields.Count();
	if ( fieldCount == 0 )
		return false;

	TRK_UINT rc = 0;
	rc = TrkNewRecordBegin( trkRecHandle, SCR_TYPE );
	if ( rc != TRK_SUCCESS )
	{
		ReportError(rc, "TrkNewRecordBegin", 
			"Failed to TrkNewRecordBegin!");
		return false;
	}

	CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );

	for ( int i = 0; i < fieldCount; ++i )
	{
		BugField_t& fld = m_Fields[ i ];

		if ( !fld.isdesc )
		{
			// Populate fields
			if ( !fld.isnumeric )
			{
				rc = TrkSetStringFieldValue( 
					trkRecHandle,
					fld.trkfield,
					fld.value );
			}
			else
			{
				rc = TrkSetNumericFieldValue( 
					trkRecHandle,
					fld.trkfield,
					fld.numvalue );
			}
			if ( rc != TRK_SUCCESS )
			{
				char es[ 256 ];
				Q_snprintf( es, sizeof( es ), "Failed to add '%s'", fld.trkfield );

				ReportError( rc, "TrkSetStringFieldValue",  es );
				return false;
			}
		}
		else
		{
			buf.Printf( "%s\n", fld.value );

			buf.PutChar( 0 );

			rc = TrkSetDescriptionData( trkRecHandle,
				buf.TellPut(),
				(const char * )buf.Base(),
				0 );
			if ( rc != TRK_SUCCESS )
			{
				ReportError(rc, "TrkSetDescriptionData", 
					"Failed to set description data!");
				return false;
			}
		}

	}

	TRK_TRANSACTION_ID id;
	rc = TrkNewRecordCommit( trkRecHandle, &id );
	if ( rc != TRK_SUCCESS )
	{
		ReportError(rc, "TrkNewRecordCommit", 
			"Failed to TrkNewRecordCommit!");
		return false;
	}

	TRK_UINT bugId;
	rc = TrkGetNumericFieldValue( trkRecHandle, "Id", &bugId );
	if ( rc != TRK_SUCCESS )
	{
		ReportError(rc, "TrkGetNumericFieldValue", 
			"Failed to TrkGetNumericFieldValue for bug Id #!");
	}
	else
	{
		bugSubmissionId = (int)bugId;
	}

	rc = TrkGetSingleRecord( trkRecHandle, bugId, SCR_TYPE );
	if ( rc != TRK_SUCCESS )
	{
		ReportError( rc, "TrkGetSingleRecord",
			"Failed to open bug id for update" );
		return false;
	}

	rc = TrkUpdateRecordBegin( trkRecHandle );
	if ( rc != TRK_SUCCESS )
	{
		ReportError( rc, "TrkUpdateRecordBegin",
			"Failed to open bug id for update" );
		return false;
	}
	else
	{
		int textbuflen = 2 * buf.TellPut() + 1;

		char *textbuf = new char [ textbuflen ];
		Q_memset( textbuf, 0, textbuflen );

		SubstituteBugId( (int)bugId, textbuf, textbuflen, buf );

		// Update the description with the substituted text!!!
		rc = TrkSetDescriptionData( trkRecHandle,
			Q_strlen( textbuf ) + 1,
			(const char * )textbuf,
			0 );

		delete[] textbuf;

		if ( rc != TRK_SUCCESS )
		{
			ReportError(rc, "TrkSetDescriptionData(update)", 
				"Failed to set description data!");
			return false;
		}

		rc = TrkUpdateRecordCommit( trkRecHandle, &id );
		if ( rc != TRK_SUCCESS )
		{
			ReportError(rc, "TrkUpdateRecordCommit", 
				"Failed to TrkUpdateRecordCommit for bug Id #!");
			return false;
		}
	}

	m_Fields.RemoveAll();

	return true;
}

SpewRetval_t SpewFunc( SpewType_t type, char const *pMsg )
{	
	spewed = true;

	printf( "%s", pMsg );
	OutputDebugString( pMsg );
	
	if ( type == SPEW_ERROR )
	{
		printf( "\n" );
		OutputDebugString( "\n" );
	}

	return SPEW_CONTINUE;
}


//-----------------------------------------------------------------------------
// Purpose: 
// Input  : depth - 
//			*fmt - 
//			... - 
//-----------------------------------------------------------------------------
void vprint( int depth, const char *fmt, ... )
{
	char string[ 8192 ];
	va_list va;
	va_start( va, fmt );
	vsprintf( string, fmt, va );
	va_end( va );

	FILE *fp = NULL;

	if ( uselogfile )
	{
		fp = fopen( "log.txt", "ab" );
	}

	while ( depth-- > 0 )
	{
		printf( "  " );
		OutputDebugString( "  " );
		if ( fp )
		{
			fprintf( fp, "  " );
		}
	}

	::printf( "%s", string );
	OutputDebugString( string );

	if ( fp )
	{
		char *p = string;
		while ( *p )
		{
			if ( *p == '\n' )
			{
				fputc( '\r', fp );
			}
			fputc( *p, fp );
			p++;
		}
		fclose( fp );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void printusage( void )
{
	vprint( 0, "usage:  getbugs pvcsproject hostname database username password contentadminexe <startbug endbug>\n\
		\ne.g.:  getbugs \"Steam Beta\" steamweb cserr username password \"u:/p4clients/yahn_steam_work/projects/gazelleproto/tools/contentadmin/vc70_debug_static/contentadmin.exe\" 1 10\n" );

	// Exit app
	exit( 1 );
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
void CheckLogFile( void )
{
	if ( uselogfile )
	{
		_unlink( "log.txt" );
		vprint( 0, "    Outputting to log.txt\n" );
	}
}

void PrintHeader()
{
	vprint( 0, "Valve Software - getbugs.exe (%s)\n", __DATE__ );
	vprint( 0, "--- Pulls public bugreporter bugs into PVCS tracker ---\n" );
}

bool GetBugZip( int bugnum, char const *admin )
{
	bool retval = false;

	char commandline[ 512 ];
	char directory[ 512 ];

	Q_strncpy( directory, admin, sizeof( directory ) );
	Q_StripFilename( directory );


	//	sprintf( commandline, "msdev engdll.dsw /MAKE \"quiver - Win32 GL Debug\" /OUT log.txt" );

	// Builds the default configuration
	sprintf( commandline, "\"%s\" bugreport %i", admin, bugnum );

	PROCESS_INFORMATION pi;
	memset( &pi, 0, sizeof( pi ) );

	STARTUPINFO si;
	memset( &si, 0, sizeof( si ) );
	si.cb = sizeof( si );

	if ( !CreateProcess( NULL, commandline, NULL, NULL, TRUE, 0, NULL, directory, &si, &pi ) )
	{
		LPVOID 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 
		);
		// Process any inserts in lpMsgBuf.
		// ...
		// Display the string.
		MessageBox( NULL, (LPCTSTR)lpMsgBuf, "Error", MB_OK | MB_ICONINFORMATION );
		// Free the buffer.
		LocalFree( lpMsgBuf );
		return retval;
	}

	// Wait until child process exits.
    WaitForSingleObject( pi.hProcess, INFINITE );

	DWORD exitCode = (DWORD)-1;
	if ( GetExitCodeProcess( pi.hProcess, &exitCode ) )
	{
		if ( exitCode == 0 )
		{
			retval = true;
		}
	}
	
    // Close process and thread handles. 
    CloseHandle( pi.hProcess );
    CloseHandle( pi.hThread );

	return retval;
}

void CreateDirHierarchy(const char *path)
{
	char temppath[512];
	Q_strncpy( temppath, path, sizeof(temppath) );
	
	for (char *ofs = temppath+1 ; *ofs ; ofs++)
	{
		if (*ofs == '/' || *ofs == '\\')
		{       // create the directory
			char old = *ofs;
			*ofs = 0;
			_mkdir (temppath);
			*ofs = old;
		}
	}
}


void GetBugInfo( CBugReporter& bug, char const *host, char const *database, char const *username, char const *password, char const *admin, int startbug, int endbug )
{
	// Now connect to steamweb and update the engineaccess table
	CSysModule *sql = Sys_LoadModule( "mysql_wrapper" );
	if ( sql )
	{
		CreateInterfaceFn factory = Sys_GetFactory( sql );
		if ( factory )
		{
			IMySQL *mysql = ( IMySQL * )factory( MYSQL_WRAPPER_VERSION_NAME, NULL );
			if ( mysql )
			{
				if ( mysql->InitMySQL( database, host, username, password ) )
				{
					char q[ 512 ];

					/*
					Q_snprintf( q, sizeof( q ), "insert into engineaccess (BuildIdentifier,AllowAccess) values (\"%s\",1);",
						argv[2] );

					int retcode = mysql->Execute( q );
					if ( retcode != 0 )
					{
						printf( "Query %s failed\n", q );
					}
					else
					{
						printf( "Successfully added buildidentifier '%s' to %s:%s\n",
							argv[ 2 ], argv[ 3 ], argv[ 4 ] );
					}
					*/

					char where[ 256 ];
					where[ 0 ] = 0;
					if ( startbug != -1 && endbug != -1 )
					{
						Q_snprintf( where, sizeof( where ), "BugId>=%i and BugId<=%i and ", startbug, endbug );
					}

					Q_snprintf( q, sizeof( q ), "select BugId, Time, BuildNumber, ExeName, GameDirectory, MapName, Title, Description, IP,"
						"BaseIP, RAM, CPU, ProcessorVendor, DXVersionHighPart, DXVersionLowPart, DXVendorID, DXDeviceID, OSVersion, "
						"BugReportFilePath, ReportType, EMail, AccountName, SteamID, Processed, Important from bugreports where %s ( Processed is NULL or Processed = 0 );", where );


					int retcode = mysql->Execute( q );
					if ( retcode != 0 )
					{
						vprint( 0, "Query %s failed\n", q );
					}
					else
					{
						IMySQLRowSet *rows = mysql->DuplicateRowSet();

						CUtlVector< int >	processed;

						if ( rows && rows->NumFields() > 0 )
						{
							while ( rows->NextRow() )
							{
								CColumnValue BugId = rows->GetColumnValue( "BugId" );
								CColumnValue Time = rows->GetColumnValue( "Time" );
								CColumnValue BuildNumber = rows->GetColumnValue( "BuildNumber" );
								CColumnValue ExeName = rows->GetColumnValue( "ExeName" );
								CColumnValue GameDirectory = rows->GetColumnValue( "GameDirectory" );
								CColumnValue MapName = rows->GetColumnValue( "MapName" );
								CColumnValue Title = rows->GetColumnValue( "Title" );
								CColumnValue Description = rows->GetColumnValue( "Description" );
								CColumnValue IP = rows->GetColumnValue( "IP" );
								CColumnValue BaseIP = rows->GetColumnValue( "BaseIP" );
								CColumnValue RAM = rows->GetColumnValue( "RAM" );
								CColumnValue CPU = rows->GetColumnValue( "CPU" );
								CColumnValue ProcessorVendor = rows->GetColumnValue( "ProcessorVendor" );
								CColumnValue DXVersionHighPart = rows->GetColumnValue( "DXVersionHighPart" );
								CColumnValue DXVersionLowPart = rows->GetColumnValue( "DXVersionLowPart" );
								CColumnValue DXVendorID = rows->GetColumnValue( "DXVendorID" );
								CColumnValue DXDeviceID = rows->GetColumnValue( "DXDeviceID" );
								CColumnValue OSVersion = rows->GetColumnValue( "OSVersion" );
								CColumnValue BugReportFilePath = rows->GetColumnValue( "BugReportFilePath" );
								CColumnValue ReportType = rows->GetColumnValue( "ReportType" );
								CColumnValue EMail = rows->GetColumnValue( "EMail" );
								CColumnValue Accountname = rows->GetColumnValue( "Accountname" );
								CColumnValue SteamID = rows->GetColumnValue( "SteamID" );
								CColumnValue Processed = rows->GetColumnValue( "Processed" );
								CColumnValue Important = rows->GetColumnValue( "Important" );

								bug.StartNewBugReport();
								
								vprint( 1, "Processing bug %i\n", BugId.Int32() );

								bug.AddField( "Owner", "PublicUser" );
								bug.AddField( "Submitter", "PublicUser" );
								bug.AddField( "Title", Title.String() );


								bug.AddNumericField( "BugId", BugId.Int32() );
								bug.AddNumericField( "Build", BuildNumber.Int32() );
								bug.AddField( "Exe", ExeName.String() );
								bug.AddField( "Gamedir", GameDirectory.String() );
								bug.AddField( "Map", MapName.String() );
								bug.AddField( "Operating System", OSVersion.String() );
								bug.AddField( "Processor", ProcessorVendor.String() );
								bug.AddNumericField( "Memory", RAM.Int32() );
								bug.AddField( "SteamID", SteamID.String() );
								bug.AddNumericField( "CPU", CPU.Int32() );

								bug.AddField( "Time", Time.String() );

								char dxversion[ 512 ];
								int vhigh = DXVersionHighPart.Int32();
								int vlow = DXVersionLowPart.Int32();

								Q_snprintf( dxversion, sizeof( dxversion ), "%u.%u.%u.%u", ( vhigh >> 16 ) , vhigh & 0xffff, ( vlow >> 16 ), vlow & 0xffff );

								bug.AddField( "DXVersion", dxversion);

								bug.AddNumericField( "DXDevice", DXDeviceID.Int32() );
								bug.AddNumericField( "DXVendor", DXVendorID.Int32() );

								bug.AddField( "BugType", ReportType.String() );
								bug.AddField( "E-Mail Address", EMail.String() );
								bug.AddField( "Account Name", Accountname.String() );

								char zipurl[ 512 ];
								zipurl[ 0 ] = 0;

								char basepath[ 512 ];
								Q_FileBase( BugReportFilePath.String(), basepath, sizeof( basepath ) );

								char desc[ 8192 ];
								
								if ( BugReportFilePath.String()[ 0 ] )
								{
									Q_snprintf( zipurl, sizeof( zipurl ), BUG_REPOSITORY_FMT, database, "BugId", basepath );

									Q_snprintf( desc, sizeof( desc ), "%s\n\nzip url:  %s\n", Description.String(), zipurl );
								}
								else
								{
									Q_strncpy( desc, Description.String(), sizeof( desc ) );
								}

								bug.AddField( "Description", desc, true );

								int trackerBugId = -1;

								bool success = bug.CommitBugReport( trackerBugId );
								if ( success )
								{
									// The public UI handles uploading on it's own...
									// Fixup URL
									if ( zipurl[ 0 ] )
									{
										char zipurlfixed[ 512 ];
										char id[ 32 ];
										Q_snprintf( id, sizeof( id ), "%i", trackerBugId );

										// The upload destination
										Q_snprintf( zipurlfixed, sizeof( zipurlfixed ), BUG_REPOSITORY_FMT, database, id, basepath );
										Q_strlower( zipurlfixed );
										Q_FixSlashes( zipurlfixed );

										char admindir[ 512 ];
										Q_strncpy( admindir, admin, sizeof( admindir ) );
										Q_StripFilename( admindir );
										Q_strlower( admindir );
										Q_FixSlashes( admindir );


										char zipurllocal[ 512 ];
										Q_snprintf( zipurllocal, sizeof( zipurllocal ), "%s\\%s.zip", admindir, basepath );
										Q_strlower( zipurllocal );
										Q_FixSlashes( zipurllocal );

										// Get local copy of .zip file

										if ( GetBugZip( BugId.Int32(), admin ) )
										{
											struct _stat statbuf;

											if ( _stat( zipurllocal, &statbuf ) == 0 )
											{
												CreateDirHierarchy( zipurlfixed );

												MoveFile( zipurllocal, zipurlfixed );

												// Mark processed
												processed.AddToTail( BugId.Int32() );
											}
										}
										else
										{
											Warning( "Unable to retrieve bug file for %i\n", BugId.Int32() );
										}
									}
									else
									{
										processed.AddToTail( BugId.Int32() );
									}

								}
								else
								{
									Warning( "Unable to post bug report to database\n" );
								}
							}

							// Discard memory
							rows->Release();

							int c = processed.Count();
							for ( int i = 0; i < c; ++i )
							{
								Q_snprintf( q, sizeof( q ), "update bugreports set Processed=1 where BugId=%i;", processed[ i ] );

								retcode = mysql->Execute( q );
								if ( retcode != 0 )
								{
									Msg( "Query failed '%s'\n", q );
								}
							}
						}
					}
				}
				else
				{
					vprint( 0, "InitMySQL failed\n" );
				}

				mysql->Release();
			}
			else
			{
				vprint( 0, "Unable to connect via mysql_wrapper\n");
			}
		}
		else
		{
			vprint( 0, "Unable to get factory from mysql_wrapper.dll, not updating access mysql table!!!" );
		}

		Sys_UnloadModule( sql );
	}
	else
	{
		vprint( 0, "Unable to load mysql_wrapper.dll, not updating access mysql table!!!" );
	}
}

//-----------------------------------------------------------------------------
// Purpose: 
// Input  : argc - 
//			argv[] - 
// Output : int
//-----------------------------------------------------------------------------
int main( int argc, char* argv[] )
{
	SpewOutputFunc( SpewFunc );
	SpewActivate( "getbugs", 2 );

	uselogfile = true;
	verbose = true;

	if ( argc != 7 && argc != 9  )
	{
		PrintHeader();
		printusage();
	}

	CheckLogFile();

	PrintHeader();

	vprint( 0, "    Getting bugs...\n" );

	workingdir[0] = 0;
	Q_getwd( workingdir, sizeof( workingdir ) );

	// If they didn't specify -game on the command line, use VPROJECT.
	CmdLib_InitFileSystem( workingdir );


	CBugReporter bugreporter;
	if ( !bugreporter.Init( argv[ 1 ] ) )
	{
		vprint( 0, "Couldn't init bug reporter\n" );
		return 0;
	}

	if ( argc == 9 )
	{
		GetBugInfo( bugreporter, argv[2], argv[3], argv[4], argv[5], argv[ 6 ], atoi( argv[ 7 ] ), atoi( argv[ 8 ] ) );
	}
	else
	{
		GetBugInfo( bugreporter, argv[2], argv[3], argv[4], argv[5], argv[ 6 ], -1, -1 );
	}


	bugreporter.Shutdown();
	CmdLib_TermFileSystem();

	return 0;
}