H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-23 06:36:54 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
e10f29854e
source-engine/utils/getbugs/getbugs.cpp

1006 lines
24 KiB
C++
Raw Normal View History

1
2020-04-22 16:56:21 +00:00
//========= 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;
}
Reference in New Issue Copy Permalink