int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
int retCode = 1; // by default it's error
#ifdef DEBUG
// Memory leak detection (only enable _CRTDBG_LEAK_CHECK_DF for
// regular termination so that leaks aren't checked on exceptions,
// aborts, etc. where some clean-up might not take place)
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF);
//_CrtSetBreakAlloc(421);
TryLoadMemTrace();
#endif
DisableDataExecution();
// ensure that C functions behave consistently under all OS locales
// (use Win32 functions where localized input or output is desired)
setlocale(LC_ALL, "C");
// don't show system-provided dialog boxes when accessing files on drives
// that are not mounted (e.g. a: drive without floppy or cd rom drive
// without a cd).
SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);
#if defined(DEBUG) || defined(SVN_PRE_RELEASE_VER)
if (str::StartsWith(lpCmdLine, "/tester")) {
extern int TesterMain(); // in Tester.cpp
return TesterMain();
}
if (str::StartsWith(lpCmdLine, "/regress")) {
extern int RegressMain(); // in Regress.cpp
return RegressMain();
}
#endif
#ifdef SUPPORTS_AUTO_UPDATE
if (str::StartsWith(lpCmdLine, "-autoupdate")) {
bool quit = AutoUpdateMain();
if (quit)
return 0;
}
#endif
srand((unsigned int)time(NULL));
// load uiautomationcore.dll before installing crash handler (i.e. initializing
// dbghelp.dll), so that we get function names/offsets in GetCallstack()
uia::Initialize();
#ifdef DEBUG
dbghelp::RememberCallstackLogs();
#endif
SetupCrashHandler();
ScopedOle ole;
InitAllCommonControls();
ScopedGdiPlus gdiPlus(true);
mui::Initialize();
uitask::Initialize();
prefs::Load();
CommandLineInfo i(GetCommandLine());
SetCurrentLang(i.lang ? i.lang : gGlobalPrefs->uiLanguage);
// This allows ad-hoc comparison of gdi, gdi+ and gdi+ quick when used
// in layout
#if 0
RedirectIOToConsole();
BenchEbookLayout(L"C:\\kjk\\downloads\\pg12.mobi");
system("pause");
goto Exit;
#endif
if (i.showConsole) {
RedirectIOToConsole();
RedirectDllIOToConsole();
}
if (i.makeDefault)
AssociateExeWithPdfExtension();
if (i.pathsToBenchmark.Count() > 0) {
BenchFileOrDir(i.pathsToBenchmark);
if (i.showConsole)
system("pause");
}
if (i.exitImmediately)
goto Exit;
gCrashOnOpen = i.crashOnOpen;
gPolicyRestrictions = GetPolicies(i.restrictedUse);
GetFixedPageUiColors(gRenderCache.textColor, gRenderCache.backgroundColor);
DebugGdiPlusDevice(gUseGdiRenderer);
if (!RegisterWinClass())
goto Exit;
CrashIf(hInstance != GetModuleHandle(NULL));
if (!InstanceInit(nCmdShow))
goto Exit;
if (i.hwndPluginParent) {
if (!SetupPluginMode(i))
goto Exit;
}
if (i.printerName) {
// note: this prints all PDF files. Another option would be to
// print only the first one
for (size_t n = 0; n < i.fileNames.Count(); n++) {
bool ok = PrintFile(i.fileNames.At(n), i.printerName, !i.silent, i.printSettings);
if (!ok)
retCode++;
}
--retCode; // was 1 if no print failures, turn 1 into 0
goto Exit;
}
bool showStartPage = i.fileNames.Count() == 0 && gGlobalPrefs->rememberOpenedFiles && gGlobalPrefs->showStartPage;
if (showStartPage) {
// make the shell prepare the image list, so that it's ready when the first window's loaded
SHFILEINFO sfi;
SHGetFileInfo(L".pdf", 0, &sfi, sizeof(sfi), SHGFI_SYSICONINDEX | SHGFI_SMALLICON | SHGFI_USEFILEATTRIBUTES);
}
if (gGlobalPrefs->reopenOnce) {
WStrVec moreFileNames;
ParseCmdLine(gGlobalPrefs->reopenOnce, moreFileNames);
moreFileNames.Reverse();
for (WCHAR **fileName = moreFileNames.IterStart(); fileName; fileName = moreFileNames.IterNext()) {
i.fileNames.Append(*fileName);
}
moreFileNames.RemoveAt(0, moreFileNames.Count());
str::ReplacePtr(&gGlobalPrefs->reopenOnce, NULL);
}
HANDLE hMutex = NULL;
HWND hPrevWnd = NULL;
if (i.printDialog || i.stressTestPath || gPluginMode) {
// TODO: pass print request through to previous instance?
}
else if (i.reuseDdeInstance) {
hPrevWnd = FindWindow(FRAME_CLASS_NAME, NULL);
}
else if (gGlobalPrefs->reuseInstance || gGlobalPrefs->useTabs) {
hPrevWnd = FindPrevInstWindow(&hMutex);
}
if (hPrevWnd) {
for (size_t n = 0; n < i.fileNames.Count(); n++) {
OpenUsingDde(hPrevWnd, i.fileNames.At(n), i, 0 == n);
}
goto Exit;
}
WindowInfo *win = NULL;
for (size_t n = 0; n < i.fileNames.Count(); n++) {
win = LoadOnStartup(i.fileNames.At(n), i, !win);
if (!win) {
retCode++;
continue;
}
if (i.printDialog)
OnMenuPrint(win, i.exitWhenDone);
}
if (i.fileNames.Count() > 0 && !win) {
// failed to create any window, even though there
// were files to load (or show a failure message for)
goto Exit;
}
if (i.printDialog && i.exitWhenDone)
goto Exit;
if (!win) {
win = CreateAndShowWindowInfo();
if (!win)
goto Exit;
}
UpdateUITextForLanguage(); // needed for RTL languages
if (win->IsAboutWindow()) {
// TODO: shouldn't CreateAndShowWindowInfo take care of this?
UpdateToolbarAndScrollbarState(*win);
}
// Make sure that we're still registered as default,
// if the user has explicitly told us to be
if (gGlobalPrefs->associatedExtensions)
RegisterForPdfExtentions(win->hwndFrame);
if (i.stressTestPath) {
// don't save file history and preference changes
gPolicyRestrictions = (gPolicyRestrictions | Perm_RestrictedUse) & ~Perm_SavePreferences;
RebuildMenuBarForWindow(win);
StartStressTest(&i, win, &gRenderCache);
}
if (gGlobalPrefs->checkForUpdates)
UpdateCheckAsync(win, true);
// only hide newly missing files when showing the start page on startup
if (showStartPage && gFileHistory.Get(0)) {
gFileExistenceChecker = new FileExistenceChecker();
gFileExistenceChecker->Start();
}
// call this once it's clear whether Perm_SavePreferences has been granted
prefs::RegisterForFileChanges();
retCode = RunMessageLoop();
SafeCloseHandle(&hMutex);
CleanUpThumbnailCache(gFileHistory);
Exit:
prefs::UnregisterForFileChanges();
while (gWindows.Count() > 0) {
DeleteWindowInfo(gWindows.At(0));
}
#ifndef DEBUG
// leave all the remaining clean-up to the OS
// (as recommended for a quick exit)
ExitProcess(retCode);
#else
DeleteObject(GetDefaultGuiFont());
DeleteBitmap(gBitmapReloadingCue);
DeleteSplitterBrush();
// wait for FileExistenceChecker to terminate
// (which should be necessary only very rarely)
while (gFileExistenceChecker) {
Sleep(10);
uitask::DrainQueue();
}
mui::Destroy();
uitask::Destroy();
trans::Destroy();
SaveCallstackLogs();
dbghelp::FreeCallstackLogs();
// must be after uitask::Destroy() because we might have queued prefs::Reload()
// which crashes if gGlobalPrefs is freed
gFileHistory.UpdateStatesSource(NULL);
DeleteGlobalPrefs(gGlobalPrefs);
// it's still possible to crash after this (destructors of static classes,
// atexit() code etc.) point, but it's very unlikely
UninstallCrashHandler();
// output leaks after all destructors of static objects have run
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
return retCode;
#endif
}
int ms_load_plugins(const char *dir){
int num=0;
#if defined(WIN32) && !defined(_WIN32_WCE)
WIN32_FIND_DATA FileData;
HANDLE hSearch;
char szDirPath[1024];
char szPluginFile[1024];
BOOL fFinished = FALSE;
const char *tmp=getenv("DEBUG");
BOOL debug=(tmp!=NULL && atoi(tmp)==1);
snprintf(szDirPath, sizeof(szDirPath), "%s", dir);
// Start searching for .dll files in the current directory.
snprintf(szDirPath, sizeof(szDirPath), "%s\\*.dll", dir);
hSearch = FindFirstFile(szDirPath, &FileData);
if (hSearch == INVALID_HANDLE_VALUE)
{
ms_message("no plugin (*.dll) found in %s.", szDirPath);
return 0;
}
snprintf(szDirPath, sizeof(szDirPath), "%s", dir);
while (!fFinished)
{
/* load library */
HINSTANCE os_handle;
UINT em;
if (!debug) em = SetErrorMode (SEM_FAILCRITICALERRORS);
snprintf(szPluginFile, sizeof(szPluginFile), "%s\\%s", szDirPath, FileData.cFileName);
os_handle = LoadLibraryEx (szPluginFile, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
if (os_handle==NULL)
{
ms_message("Fail to load plugin %s with altered search path: error %i",szPluginFile,GetLastError());
os_handle = LoadLibraryEx (szPluginFile, NULL, 0);
}
if (!debug) SetErrorMode (em);
if (os_handle==NULL)
ms_error("Fail to load plugin %s", szPluginFile);
else{
init_func_t initroutine;
char szPluginName[256];
char szMethodName[256];
char *minus;
snprintf(szPluginName, 256, "%s", FileData.cFileName);
/*on mingw, dll names might be libsomething-3.dll. We must skip the -X.dll stuff*/
minus=strchr(szPluginName,'-');
if (minus) *minus='\0';
else szPluginName[strlen(szPluginName)-4]='\0'; /*remove .dll*/
snprintf(szMethodName, 256, "%s_init", szPluginName);
initroutine = (init_func_t) GetProcAddress (os_handle, szMethodName);
if (initroutine!=NULL){
initroutine();
ms_message("Plugin loaded (%s)", szPluginFile);
num++;
}else{
ms_warning("Could not locate init routine of plugin %s. Should be %s",
szPluginFile, szMethodName);
}
}
if (!FindNextFile(hSearch, &FileData)) {
if (GetLastError() == ERROR_NO_MORE_FILES){
fFinished = TRUE;
}
else
{
ms_error("couldn't find next plugin dll.");
fFinished = TRUE;
}
}
}
/* Close the search handle. */
FindClose(hSearch);
#elif HAVE_DLOPEN
DIR *ds;
struct dirent *de;
char *fullpath;
ds=opendir(dir);
if (ds==NULL){
ms_message("Cannot open directory %s: %s",dir,strerror(errno));
return -1;
}
while( (de=readdir(ds))!=NULL){
if ((de->d_type==DT_REG && strstr(de->d_name,PLUGINS_EXT)!=NULL)
|| (de->d_type==DT_UNKNOWN && strstr(de->d_name,PLUGINS_EXT)==de->d_name+strlen(de->d_name)-strlen(PLUGINS_EXT))) {
void *handle;
fullpath=ms_strdup_printf("%s/%s",dir,de->d_name);
ms_message("Loading plugin %s...",fullpath);
if ( (handle=dlopen(fullpath,RTLD_NOW))==NULL){
ms_warning("Fail to load plugin %s : %s",fullpath,dlerror());
}else {
char *initroutine_name=ms_malloc0(strlen(de->d_name)+10);
char *p;
void *initroutine=NULL;
strcpy(initroutine_name,de->d_name);
p=strstr(initroutine_name,PLUGINS_EXT);
if (p!=NULL){
strcpy(p,"_init");
initroutine=dlsym(handle,initroutine_name);
}
#ifdef __APPLE__
if (initroutine==NULL){
/* on macosx: library name are libxxxx.1.2.3.dylib */
/* -> MUST remove the .1.2.3 */
p=strstr(initroutine_name,".");
if (p!=NULL)
{
strcpy(p,"_init");
initroutine=dlsym(handle,initroutine_name);
}
}
#endif
if (initroutine!=NULL){
init_func_t func=(init_func_t)initroutine;
func();
ms_message("Plugin loaded (%s)", fullpath);
num++;
}else{
ms_warning("Could not locate init routine of plugin %s",de->d_name);
}
ms_free(initroutine_name);
}
ms_free(fullpath);
}
}
closedir(ds);
#else
ms_warning("no loadable plugin support: plugins cannot be loaded.");
num=-1;
#endif
return num;
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
char commandLine[MAX_STRING_CHARS] = { 0 };
char cwd[MAX_OSPATH];
// should never get a previous instance in Win32
if (hPrevInstance)
{
return EXIT_FAILURE;
}
#ifdef EXCEPTION_HANDLER
WinSetExceptionVersion(Q3_VERSION);
#endif
g_wv.hInstance = hInstance;
#if 1
commandLine[0] = '\0';
Sys_ParseArgs(__argc, __argv);
Sys_BuildCommandLine(__argc, __argv, commandLine, sizeof(commandLine));
#else
Q_strncpyz(commandLine, lpCmdLine, sizeof(commandLine));
#endif
#ifndef DEDICATED
Sys_SetProcessProperties();
//show the splash screen
Sys_Splash(qtrue);
#endif
#ifdef USE_WINDOWS_CONSOLE
// done before Com/Sys_Init since we need this for error output
Sys_CreateConsole();
#endif
#ifdef DEDICATED
Sys_ShowConsoleWindow(1, qtrue);
#endif
// no abort/retry/fail errors
SetErrorMode(SEM_FAILCRITICALERRORS);
// get the initial time base
Sys_Milliseconds();
Com_Init(commandLine);
NET_Init();
Sys_Splash(qfalse);
_getcwd(cwd, sizeof(cwd));
Com_Printf("Working directory: %s\n", cwd);
// hide the early console since we've reached the point where we
// have a working graphics subsystems
#ifndef LEGACY_DEBUG
if (!com_dedicated->integer && !com_viewlog->integer)
{
Sys_ShowConsoleWindow(0, qfalse);
}
#endif
// main game loop
Sys_GameLoop();
// never gets here
return EXIT_SUCCESS;
}
/*
==================
WinMain
==================
*/
int main(int argc, char *argv[]) {
const HCURSOR hcurSave = ::SetCursor( LoadCursor( 0, IDC_WAIT ) );
Sys_SetPhysicalWorkMemory( 192 << 20, 1024 << 20 );
win32.hInstance = GetModuleHandle(NULL);
// done before Com/Sys_Init since we need this for error output
Sys_CreateConsole();
// no abort/retry/fail errors
SetErrorMode( SEM_FAILCRITICALERRORS );
#ifdef DEBUG
// disable the painfully slow MS heap check every 1024 allocs
_CrtSetDbgFlag( 0 );
#endif
if ( argc > 1 ) {
common->Init( argc-1, &argv[1] );
} else {
common->Init( 0, NULL );
}
// hide or show the early console as necessary
if ( win32.win_viewlog.GetInteger() || com_skipRenderer.GetBool() || idAsyncNetwork::serverDedicated.GetInteger() ) {
Sys_ShowConsole( 1, true );
} else {
Sys_ShowConsole( 0, false );
}
#ifdef SET_THREAD_AFFINITY
// give the main thread an affinity for the first cpu
SetThreadAffinityMask( GetCurrentThread(), 1 );
#endif
::SetCursor( hcurSave );
// Launch the script debugger
if ( strstr( GetCommandLine(), "+debugger" ) ) {
// DebuggerClientInit( lpCmdLine );
return 0;
}
::SetFocus( win32.hWnd );
// main game loop
while( 1 ) {
Win_Frame();
#ifdef ID_ALLOW_TOOLS
if ( com_editors ) {
if ( com_editors & EDITOR_GUI ) {
// GUI editor
GUIEditorRun();
} else if ( com_editors & EDITOR_RADIANT ) {
// Level Editor
RadiantRun();
}
else if (com_editors & EDITOR_MATERIAL ) {
//BSM Nerve: Add support for the material editor
MaterialEditorRun();
}
else {
if ( com_editors & EDITOR_LIGHT ) {
// in-game Light Editor
LightEditorRun();
}
if ( com_editors & EDITOR_SOUND ) {
// in-game Sound Editor
SoundEditorRun();
}
if ( com_editors & EDITOR_DECL ) {
// in-game Declaration Browser
DeclBrowserRun();
}
if ( com_editors & EDITOR_AF ) {
// in-game Articulated Figure Editor
AFEditorRun();
}
if ( com_editors & EDITOR_PARTICLE ) {
// in-game Particle Editor
ParticleEditorRun();
}
if ( com_editors & EDITOR_SCRIPT ) {
// in-game Script Editor
ScriptEditorRun();
}
if ( com_editors & EDITOR_PDA ) {
// in-game PDA Editor
PDAEditorRun();
}
}
}
#endif
// run the game
common->Frame();
}
// never gets here
return 0;
}
int WINAPI WinMain(HINSTANCE hThisInst, HINSTANCE /*hPrevInst*/, LPSTR lpszArgs, int nWndMode)
{
/**************************************
*
* W i n M a i n
*
**************************************
*
* Functional description
* Run the server with NT named
* pipes and/or TCP/IP sockets.
*
**************************************/
hInst = hThisInst;
// We want server to crash without waiting for feedback from the user
try
{
if (!Config::getBugcheckAbort())
SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
}
catch (Firebird::fatal_exception& e)
{
MessageBox(NULL, e.what(), "Firebird server failure",
MB_OK | MB_ICONHAND | MB_SYSTEMMODAL | MB_DEFAULT_DESKTOP_ONLY);
return STARTUP_ERROR; // see /jrd/common.h
}
catch (Firebird::status_exception& e)
{
TEXT buffer[BUFFER_LARGE];
const ISC_STATUS* vector = e.value();
if (! (vector && fb_interpret(buffer, sizeof(buffer), &vector)))
{
strcpy(buffer, "Unknown internal failure");
}
MessageBox(NULL, buffer, "Firebird server failure",
MB_OK | MB_ICONHAND | MB_SYSTEMMODAL | MB_DEFAULT_DESKTOP_ONLY);
return STARTUP_ERROR; // see /jrd/common.h
}
#ifdef SUPERSERVER
server_flag = SRVR_multi_client;
#else
server_flag = 0;
#endif
#ifdef SUPERSERVER
SetProcessAffinityMask(GetCurrentProcess(), static_cast<DWORD>(Config::getCpuAffinityMask()));
#endif
protocol_inet[0] = 0;
protocol_wnet[0] = 0;
strcpy(instance, FB_DEFAULT_INSTANCE);
const HANDLE connection_handle = parse_args(lpszArgs, &server_flag);
#ifdef SUPERSERVER
// get priority class from the config file
int priority = Config::getProcessPriorityLevel();
// override it, if necessary
if (server_flag & SRVR_high_priority) {
priority = 1;
}
// set priority class
if (priority > 0) {
SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);
}
else if (priority < 0) {
SetPriorityClass(GetCurrentProcess(), IDLE_PRIORITY_CLASS);
}
#endif
TEXT mutex_name[MAXPATHLEN];
fb_utils::snprintf(mutex_name, sizeof(mutex_name), SERVER_MUTEX, instance);
fb_utils::prefix_kernel_object_name(mutex_name, sizeof(mutex_name));
CreateMutex(ISC_get_security_desc(), FALSE, mutex_name);
// Initialize the service
ISC_signal_init();
Firebird::FpeControl::maskAll();
int nReturnValue = 0;
ISC_STATUS_ARRAY status_vector;
fb_utils::init_status(status_vector);
fb_shutdown_callback(0, wait_threads, fb_shut_finish, NULL);
if (connection_handle != INVALID_HANDLE_VALUE)
{
rem_port* port = 0;
if (server_flag & SRVR_inet)
{
port = INET_reconnect((SOCKET) connection_handle, status_vector);
if (port)
{
SRVR_multi_thread(port, server_flag);
port = NULL;
}
}
else if (server_flag & SRVR_wnet)
port = WNET_reconnect(connection_handle, status_vector);
else if (server_flag & SRVR_xnet)
port = XNET_reconnect((ULONG) connection_handle, status_vector);
if (port) {
service_connection(port);
}
else if (status_vector[1])
gds__log_status(0, status_vector);
fb_shutdown(5 * 1000 /*5 seconds*/, fb_shutrsn_no_connection);
}
else if (!(server_flag & SRVR_non_service))
{
Firebird::string service_name;
service_name.printf(REMOTE_SERVICE, instance);
CNTL_init(start_connections_thread, instance);
const SERVICE_TABLE_ENTRY service_table[] =
{
{const_cast<char*>(service_name.c_str()), CNTL_main_thread},
{NULL, NULL}
};
// BRS There is a error in MinGW (3.1.0) headers
// the parameter of StartServiceCtrlDispatcher is declared const in msvc headers
#if defined(MINGW)
if (!StartServiceCtrlDispatcher(const_cast<SERVICE_TABLE_ENTRY*>(service_table)))
{
#else
if (!StartServiceCtrlDispatcher(service_table))
{
#endif
if (GetLastError() != ERROR_CALL_NOT_IMPLEMENTED) {
CNTL_shutdown_service("StartServiceCtrlDispatcher failed");
}
server_flag |= SRVR_non_service;
}
}
else
{
start_connections_thread(0);
nReturnValue = WINDOW_main(hThisInst, nWndMode, server_flag);
}
#ifdef DEBUG_GDS_ALLOC
// In Debug mode - this will report all server-side memory leaks
// due to remote access
//gds_alloc_report(0, __FILE__, __LINE__);
Firebird::PathName name = fb_utils::getPrefix(fb_utils::FB_DIR_LOG, "memdebug.log");
FILE* file = fopen(name.c_str(), "w+t");
if (file)
{
fprintf(file, "Global memory pool allocated objects\n");
getDefaultMemoryPool()->print_contents(file);
fclose(file);
}
#endif
return nReturnValue;
}
THREAD_ENTRY_DECLARE process_connection_thread(THREAD_ENTRY_PARAM arg)
{
/**************************************
*
* p r o c e s s _ c o n n e c t i o n _ t h r e a d
*
**************************************
*
* Functional description
*
**************************************/
ThreadCounter counter;
service_connection((rem_port*) arg);
return 0;
}
void
FileTransfer::ShowClientItems(char *path)
{
if (strlen(path) == 0) {
//Show Logical Drives
ListView_DeleteAllItems(m_hwndFTClientList);
m_FTClientItemInfo.Free();
int LengthDrivesString = 0;
char DrivesString[256];
char DriveName[rfbMAX_PATH] = "?:";
LengthDrivesString = GetLogicalDriveStrings(256, DrivesString);
if ((LengthDrivesString == 0) || (LengthDrivesString > 256)) {
BlockingFileTransferDialog(TRUE);
strcpy(m_ClientPathTmp, m_ClientPath);
return;
} else {
strcpy(m_ClientPath, m_ClientPathTmp);
SetWindowText(m_hwndFTClientPath, m_ClientPath);
for (int i=0; i<256; i++) {
DriveName[0] = DrivesString[i];
char txt[16];
strcpy(txt, m_FTClientItemInfo.folderText);
m_FTClientItemInfo.Add(DriveName, txt, 0);
DriveName[0] = '\0';
i+=3;
if ((DrivesString[i] == '\0') && (DrivesString[i+1] == '\0')) break;
}
m_FTClientItemInfo.Sort();
ShowListViewItems(m_hwndFTClientList, &m_FTClientItemInfo);
}
} else {
//Show Files
HANDLE m_handle;
int n = 0;
WIN32_FIND_DATA m_FindFileData;
strcat(path, "\\*");
SetErrorMode(SEM_FAILCRITICALERRORS);
m_handle = FindFirstFile(path, &m_FindFileData);
DWORD LastError = GetLastError();
SetErrorMode(0);
if (m_handle == INVALID_HANDLE_VALUE) {
if (LastError != ERROR_SUCCESS && LastError != ERROR_FILE_NOT_FOUND) {
strcpy(m_ClientPathTmp, m_ClientPath);
FindClose(m_handle);
BlockingFileTransferDialog(TRUE);
return;
}
path[strlen(path) - 2] = '\0';
strcpy(m_ClientPath, m_ClientPathTmp);
SetWindowText(m_hwndFTClientPath, m_ClientPath);
FindClose(m_handle);
ListView_DeleteAllItems(m_hwndFTClientList);
BlockingFileTransferDialog(TRUE);
return;
}
ListView_DeleteAllItems(m_hwndFTClientList);
m_FTClientItemInfo.Free();
char buffer[16];
while(1) {
if ((strcmp(m_FindFileData.cFileName, ".") != 0) &&
(strcmp(m_FindFileData.cFileName, "..") != 0)) {
if (!(m_FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
sprintf(buffer, "%d", m_FindFileData.nFileSizeLow);
LARGE_INTEGER li;
li.LowPart = m_FindFileData.ftLastWriteTime.dwLowDateTime;
li.HighPart = m_FindFileData.ftLastWriteTime.dwHighDateTime;
li.QuadPart = (li.QuadPart - 116444736000000000) / 10000000;
m_FTClientItemInfo.Add(m_FindFileData.cFileName, buffer, li.LowPart);
} else {
strcpy(buffer, m_FTClientItemInfo.folderText);
m_FTClientItemInfo.Add(m_FindFileData.cFileName, buffer, 0);
}
}
if (!FindNextFile(m_handle, &m_FindFileData)) break;
}
FindClose(m_handle);
m_FTClientItemInfo.Sort();
ShowListViewItems(m_hwndFTClientList, &m_FTClientItemInfo);
path[strlen(path) - 2] = '\0';
strcpy(m_ClientPath, m_ClientPathTmp);
SetWindowText(m_hwndFTClientPath, m_ClientPath);
}
BlockingFileTransferDialog(TRUE);
}
double hb_fsDiskSpace( const char * pszPath, HB_USHORT uiType )
{
char szPathBuf[ 2 ];
double dSpace = 0.0;
if( uiType > HB_DISK_TOTAL )
uiType = HB_DISK_AVAIL;
if( ! pszPath )
{
szPathBuf[ 0 ] = HB_OS_PATH_DELIM_CHR;
szPathBuf[ 1 ] = '\0';
pszPath = szPathBuf;
}
#if defined( HB_OS_WIN )
{
LPCTSTR lpPath;
LPTSTR lpFree;
lpPath = HB_FSNAMECONV( pszPath, &lpFree );
{
UINT uiErrMode = SetErrorMode( SEM_FAILCRITICALERRORS );
HB_BOOL fResult;
#if ! defined( HB_OS_WIN_CE ) && ! defined( HB_OS_WIN_64 )
/* NOTE: We need to call this function dynamically to maintain support
Win95 first edition. It was introduced in Win95B (aka OSR2) [vszakats] */
typedef BOOL ( WINAPI * P_GDFSE )( LPCTSTR, PULARGE_INTEGER,
PULARGE_INTEGER, PULARGE_INTEGER );
static P_GDFSE s_pGetDiskFreeSpaceEx = NULL;
static HB_BOOL s_fInit = HB_FALSE;
if( ! s_fInit )
{
HMODULE hModule = GetModuleHandle( HB_WINAPI_KERNEL32_DLL() );
if( hModule )
s_pGetDiskFreeSpaceEx = ( P_GDFSE )
HB_WINAPI_GETPROCADDRESST( hModule, "GetDiskFreeSpaceEx" );
s_fInit = HB_TRUE;
}
if( ! s_pGetDiskFreeSpaceEx )
{
DWORD dwSectorsPerCluster;
DWORD dwBytesPerSector;
DWORD dwNumberOfFreeClusters;
DWORD dwTotalNumberOfClusters;
fResult = GetDiskFreeSpace( lpPath,
&dwSectorsPerCluster,
&dwBytesPerSector,
&dwNumberOfFreeClusters,
&dwTotalNumberOfClusters ) ? HB_TRUE : HB_FALSE;
hb_fsSetIOError( fResult, 0 );
if( fResult )
{
switch( uiType )
{
case HB_DISK_AVAIL:
case HB_DISK_FREE:
dSpace = ( double ) dwNumberOfFreeClusters *
( double ) dwSectorsPerCluster *
( double ) dwBytesPerSector;
break;
case HB_DISK_USED:
case HB_DISK_TOTAL:
dSpace = ( double ) dwTotalNumberOfClusters *
( double ) dwSectorsPerCluster *
( double ) dwBytesPerSector;
if( uiType == HB_DISK_USED )
dSpace -= ( double ) dwNumberOfFreeClusters *
( double ) dwSectorsPerCluster *
( double ) dwBytesPerSector;
break;
}
}
}
else
#endif
{
#if defined( _MSC_VER ) || defined( __LCC__ ) || \
( defined( __GNUC__ ) && ! defined( __RSXNT__ ) )
# define HB_GET_LARGE_UINT( v ) ( ( double ) (v).LowPart + \
( double ) (v).HighPart * \
( ( ( double ) 0xFFFFFFFF ) + 1 ) )
#else
/* NOTE: Borland doesn't seem to deal with the un-named
struct that is part of ULARGE_INTEGER
[pt] */
# define HB_GET_LARGE_UINT( v ) ( ( double ) (v).u.LowPart + \
( double ) (v).u.HighPart * \
( ( ( double ) 0xFFFFFFFF ) + 1 ) )
#endif
ULARGE_INTEGER i64FreeBytesToCaller, i64TotalBytes, i64FreeBytes;
#if ! defined( HB_OS_WIN_CE ) && ! defined( HB_OS_WIN_64 )
fResult = s_pGetDiskFreeSpaceEx( lpPath,
( PULARGE_INTEGER ) &i64FreeBytesToCaller,
( PULARGE_INTEGER ) &i64TotalBytes,
( PULARGE_INTEGER ) &i64FreeBytes );
#else
fResult = GetDiskFreeSpaceEx( lpPath,
( PULARGE_INTEGER ) &i64FreeBytesToCaller,
( PULARGE_INTEGER ) &i64TotalBytes,
( PULARGE_INTEGER ) &i64FreeBytes );
#endif
hb_fsSetIOError( fResult, 0 );
if( fResult )
{
switch( uiType )
{
case HB_DISK_AVAIL:
dSpace = HB_GET_LARGE_UINT( i64FreeBytesToCaller );
break;
case HB_DISK_FREE:
dSpace = HB_GET_LARGE_UINT( i64FreeBytes );
break;
case HB_DISK_TOTAL:
dSpace = HB_GET_LARGE_UINT( i64TotalBytes );
break;
case HB_DISK_USED:
dSpace = HB_GET_LARGE_UINT( i64TotalBytes ) -
HB_GET_LARGE_UINT( i64FreeBytes );
break;
}
}
}
SetErrorMode( uiErrMode );
}
if( lpFree )
hb_xfree( lpFree );
}
#elif defined( HB_OS_DOS ) || defined( HB_OS_OS2 )
{
HB_USHORT uiDrive;
uiDrive = pszPath == NULL || pszPath[ 0 ] == 0 ||
pszPath[ 1 ] != HB_OS_DRIVE_DELIM_CHR ? 0 :
( pszPath[ 0 ] >= 'A' && pszPath[ 0 ] <= 'Z' ?
pszPath[ 0 ] - 'A' + 1 :
( pszPath[ 0 ] >= 'a' && pszPath[ 0 ] <= 'z' ?
pszPath[ 0 ] - 'a' + 1 : 0 ) );
#if defined( HB_OS_DOS )
for( ;; )
{
union REGS regs;
regs.HB_XREGS.dx = uiDrive;
regs.h.ah = 0x36;
HB_DOS_INT86( 0x21, ®s, ®s );
if( regs.HB_XREGS.ax != 0xFFFF )
{
HB_USHORT uiClusterTotal = regs.HB_XREGS.dx;
HB_USHORT uiClusterFree = regs.HB_XREGS.bx;
HB_USHORT uiSecPerCluster = regs.HB_XREGS.ax;
HB_USHORT uiSectorSize = regs.HB_XREGS.cx;
switch( uiType )
{
case HB_DISK_AVAIL:
case HB_DISK_FREE:
dSpace = ( double ) uiClusterFree *
( double ) uiSecPerCluster *
( double ) uiSectorSize;
break;
case HB_DISK_USED:
case HB_DISK_TOTAL:
dSpace = ( double ) uiClusterTotal *
( double ) uiSecPerCluster *
( double ) uiSectorSize;
if( uiType == HB_DISK_USED )
dSpace -= ( double ) uiClusterFree *
( double ) uiSecPerCluster *
( double ) uiSectorSize;
break;
}
}
else
{
if( hb_errRT_BASE_Ext1( EG_OPEN, 2018, NULL, NULL, 0, ( EF_CANDEFAULT | EF_CANRETRY ), HB_ERR_ARGS_BASEPARAMS ) == E_RETRY )
continue;
}
break;
}
#else /* HB_OS_OS2 */
{
struct _FSALLOCATE fsa;
APIRET rc;
/* Query level 1 info from filesystem */
while( ( rc = DosQueryFSInfo( uiDrive, 1, &fsa, sizeof( fsa ) ) ) != NO_ERROR )
{
if( hb_errRT_BASE_Ext1( EG_OPEN, 2018, NULL, NULL, 0, ( EF_CANDEFAULT | EF_CANRETRY ), HB_ERR_ARGS_BASEPARAMS ) != E_RETRY )
break;
}
hb_fsSetError( ( HB_ERRCODE ) rc );
if( rc == NO_ERROR )
{
switch( uiType )
{
case HB_DISK_AVAIL:
case HB_DISK_FREE:
dSpace = ( double ) fsa.cUnitAvail *
( double ) fsa.cSectorUnit *
( double ) fsa.cbSector;
break;
case HB_DISK_USED:
case HB_DISK_TOTAL:
dSpace = ( double ) fsa.cUnit *
( double ) fsa.cSectorUnit *
( double ) fsa.cbSector;
if( uiType == HB_DISK_USED )
dSpace -= ( double ) fsa.cUnitAvail *
( double ) fsa.cSectorUnit *
( double ) fsa.cbSector;
break;
}
}
}
#endif
}
#elif defined( HB_OS_UNIX ) && \
!( defined( __WATCOMC__ ) || defined( __CEGCC__ ) || defined( HB_OS_SYMBIAN ) )
{
#if defined( HB_OS_DARWIN ) || defined( HB_OS_ANDROID ) || \
defined( HB_OS_VXWORKS )
struct statfs sf;
#else
struct statvfs sf;
#endif
char * pszFree;
pszPath = hb_fsNameConv( pszPath, &pszFree );
#if defined( HB_OS_DARWIN ) || defined( HB_OS_ANDROID ) || \
defined( HB_OS_VXWORKS )
if( statfs( pszPath, &sf ) == 0 )
#else
if( statvfs( pszPath, &sf ) == 0 )
#endif
{
switch( uiType )
{
case HB_DISK_AVAIL:
dSpace = ( double ) sf.f_bavail * ( double ) sf.f_bsize;
break;
case HB_DISK_FREE:
dSpace = ( double ) sf.f_bfree * ( double ) sf.f_bsize;
break;
case HB_DISK_USED:
dSpace = ( double ) ( sf.f_blocks - sf.f_bfree ) *
( double ) sf.f_bsize;
break;
case HB_DISK_TOTAL:
dSpace = ( double ) sf.f_blocks * ( double ) sf.f_bsize;
break;
}
hb_fsSetIOError( HB_TRUE, 0 );
}
else
hb_fsSetIOError( HB_FALSE, 0 );
if( pszFree )
hb_xfree( pszFree );
}
#else
{
int iTODO;
HB_SYMBOL_UNUSED( uiType );
}
#endif
return dSpace;
}
INT WINAPI wWinMain(
_In_ HINSTANCE hInstance,
_In_opt_ HINSTANCE hPrevInstance,
_In_ PWSTR lpCmdLine,
_In_ INT nCmdShow
)
{
LONG result;
#ifdef DEBUG
PHP_BASE_THREAD_DBG dbg;
#endif
CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
#ifndef DEBUG
SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
#endif
PhInstanceHandle = (HINSTANCE)NtCurrentPeb()->ImageBaseAddress;
if (!NT_SUCCESS(PhInitializePhLib()))
return 1;
if (!PhInitializeAppSystem())
return 1;
PhInitializeCommonControls();
if (PhCurrentTokenQueryHandle)
{
PTOKEN_USER tokenUser;
if (NT_SUCCESS(PhGetTokenUser(PhCurrentTokenQueryHandle, &tokenUser)))
{
PhCurrentUserName = PhGetSidFullName(tokenUser->User.Sid, TRUE, NULL);
PhFree(tokenUser);
}
}
PhLocalSystemName = PhGetSidFullName(&PhSeLocalSystemSid, TRUE, NULL);
// There has been a report of the above call failing.
if (!PhLocalSystemName)
PhLocalSystemName = PhCreateString(L"NT AUTHORITY\\SYSTEM");
PhApplicationFileName = PhGetApplicationFileName();
PhApplicationDirectory = PhGetApplicationDirectory();
// Just in case
if (!PhApplicationFileName)
PhApplicationFileName = PhCreateString(L"ProcessHacker.exe");
if (!PhApplicationDirectory)
PhApplicationDirectory = PhReferenceEmptyString();
PhpProcessStartupParameters();
PhSettingsInitialization();
PhpEnablePrivileges();
if (PhStartupParameters.RunAsServiceMode)
{
RtlExitUserProcess(PhRunAsServiceStart(PhStartupParameters.RunAsServiceMode));
}
PhpInitializeSettings();
// Activate a previous instance if required.
if (PhGetIntegerSetting(L"AllowOnlyOneInstance") &&
!PhStartupParameters.NewInstance &&
!PhStartupParameters.ShowOptions &&
!PhStartupParameters.CommandMode &&
!PhStartupParameters.PhSvc)
{
PhActivatePreviousInstance();
}
if (PhGetIntegerSetting(L"EnableKph") && !PhStartupParameters.NoKph && !PhIsExecutingInWow64())
PhInitializeKph();
if (PhStartupParameters.CommandMode && PhStartupParameters.CommandType && PhStartupParameters.CommandAction)
{
NTSTATUS status;
status = PhCommandModeStart();
if (!NT_SUCCESS(status) && !PhStartupParameters.Silent)
{
PhShowStatus(NULL, L"Unable to execute the command", status, 0);
}
RtlExitUserProcess(status);
}
#ifdef DEBUG
dbg.ClientId = NtCurrentTeb()->ClientId;
dbg.StartAddress = wWinMain;
dbg.Parameter = NULL;
InsertTailList(&PhDbgThreadListHead, &dbg.ListEntry);
TlsSetValue(PhDbgThreadDbgTlsIndex, &dbg);
#endif
PhInitializeAutoPool(&BaseAutoPool);
PhEmInitialization();
PhGuiSupportInitialization();
PhTreeNewInitialization();
PhGraphControlInitialization();
PhHexEditInitialization();
PhColorBoxInitialization();
PhSmallIconSize.X = GetSystemMetrics(SM_CXSMICON);
PhSmallIconSize.Y = GetSystemMetrics(SM_CYSMICON);
PhLargeIconSize.X = GetSystemMetrics(SM_CXICON);
PhLargeIconSize.Y = GetSystemMetrics(SM_CYICON);
if (PhStartupParameters.ShowOptions)
{
// Elevated options dialog for changing the value of Replace Task Manager with Process Hacker.
PhShowOptionsDialog(PhStartupParameters.WindowHandle);
RtlExitUserProcess(STATUS_SUCCESS);
}
#ifndef DEBUG
if (PhIsExecutingInWow64() && !PhStartupParameters.PhSvc)
{
PhShowWarning(
NULL,
L"You are attempting to run the 32-bit version of Process Hacker on 64-bit Windows. "
L"Most features will not work correctly.\n\n"
L"Please run the 64-bit version of Process Hacker instead."
);
}
#endif
PhPluginsEnabled = PhGetIntegerSetting(L"EnablePlugins") && !PhStartupParameters.NoPlugins;
if (PhPluginsEnabled)
{
PhPluginsInitialization();
PhLoadPlugins();
}
if (PhStartupParameters.PhSvc)
{
MSG message;
// Turn the feedback cursor off.
PostMessage(NULL, WM_NULL, 0, 0);
GetMessage(&message, NULL, 0, 0);
RtlExitUserProcess(PhSvcMain(NULL, NULL, NULL));
}
// Create a mutant for the installer.
{
HANDLE mutantHandle;
OBJECT_ATTRIBUTES oa;
UNICODE_STRING mutantName;
RtlInitUnicodeString(&mutantName, L"\\BaseNamedObjects\\ProcessHacker2Mutant");
InitializeObjectAttributes(
&oa,
&mutantName,
0,
NULL,
NULL
);
NtCreateMutant(&mutantHandle, MUTANT_ALL_ACCESS, &oa, FALSE);
}
// Set priority.
{
PROCESS_PRIORITY_CLASS priorityClass;
priorityClass.Foreground = FALSE;
priorityClass.PriorityClass = PROCESS_PRIORITY_CLASS_HIGH;
if (PhStartupParameters.PriorityClass != 0)
priorityClass.PriorityClass = (UCHAR)PhStartupParameters.PriorityClass;
NtSetInformationProcess(NtCurrentProcess(), ProcessPriorityClass, &priorityClass, sizeof(PROCESS_PRIORITY_CLASS));
}
if (!PhMainWndInitialization(nCmdShow))
{
PhShowError(NULL, L"Unable to initialize the main window.");
return 1;
}
PhDrainAutoPool(&BaseAutoPool);
result = PhMainMessageLoop();
RtlExitUserProcess(result);
}
HRESULT CLoadDirectDraw::LoadDirectDraw(LPSTR szDevice)
{
PDRAWCREATE pDrawCreate;
PDRAWENUM pDrawEnum;
LPDIRECTDRAWENUMERATEEXA pDrawEnumEx;
HRESULT hr = NOERROR;
NOTE("Entering DoLoadDirectDraw");
// Is DirectDraw already loaded
if (m_pDirectDraw) {
NOTE("Already loaded");
ASSERT(m_hDirectDraw);
return NOERROR;
}
// Make sure the library is available
if(!m_hDirectDraw)
{
UINT ErrorMode = SetErrorMode(SEM_NOOPENFILEERRORBOX);
m_hDirectDraw = LoadLibrary(TEXT("DDRAW.DLL"));
SetErrorMode(ErrorMode);
if (m_hDirectDraw == NULL) {
DbgLog((LOG_ERROR,1,TEXT("Can't load DDRAW.DLL")));
NOTE("No library");
return E_NOINTERFACE;
}
}
// Get the DLL address for the creator function
pDrawCreate = (PDRAWCREATE)GetProcAddress(m_hDirectDraw,"DirectDrawCreate");
// force ANSI, we assume it
pDrawEnum = (PDRAWENUM)GetProcAddress(m_hDirectDraw,"DirectDrawEnumerateA");
pDrawEnumEx = (LPDIRECTDRAWENUMERATEEXA)GetProcAddress(m_hDirectDraw,
"DirectDrawEnumerateExA");
// We don't NEED DirectDrawEnumerateEx, that's just for multimon stuff
if (pDrawCreate == NULL || pDrawEnum == NULL) {
DbgLog((LOG_ERROR,1,TEXT("Can't get functions: Create=%x Enum=%x"),
pDrawCreate, pDrawEnum));
NOTE("No entry point");
ReleaseDirectDraw();
return E_NOINTERFACE;
}
DbgLog((LOG_TRACE,3,TEXT("Creating DDraw for device %s"),
szDevice ? szDevice : "<NULL>"));
// Create a DirectDraw display provider for this device, using the fancy
// multimon-aware version, if it exists
if (pDrawEnumEx)
m_pDirectDraw = DirectDrawCreateFromDeviceEx(szDevice, pDrawCreate,
pDrawEnumEx);
else
m_pDirectDraw = DirectDrawCreateFromDevice(szDevice, pDrawCreate,
pDrawEnum);
if (m_pDirectDraw == NULL) {
DbgLog((LOG_ERROR,1,TEXT("Can't create DDraw")));
NOTE("No instance");
ReleaseDirectDraw();
return E_NOINTERFACE;
}
return NOERROR;
}
void *dlopen( const char *file, int mode )
{
HMODULE hModule;
UINT uMode;
current_error = NULL;
/* Do not let Windows display the critical-error-handler message box */
uMode = SetErrorMode( SEM_FAILCRITICALERRORS );
if( file == 0 )
{
/* POSIX says that if the value of file is 0, a handle on a global
* symbol object must be provided. That object must be able to access
* all symbols from the original program file, and any objects loaded
* with the RTLD_GLOBAL flag.
* The return value from GetModuleHandle( ) allows us to retrieve
* symbols only from the original program file. For objects loaded with
* the RTLD_GLOBAL flag, we create our own list later on.
*/
hModule = GetModuleHandle( NULL );
if( !hModule )
save_err_ptr_str( file );
}
else
{
char lpFileName[MAX_PATH];
int i;
/* MSDN says backslashes *must* be used instead of forward slashes. */
for( i = 0 ; i < sizeof(lpFileName)-1 ; i++ )
{
if( !file[i] )
break;
else if( file[i] == '/' )
lpFileName[i] = '\\';
else
lpFileName[i] = file[i];
}
lpFileName[i] = '\0';
/* POSIX says the search path is implementation-defined.
* LOAD_WITH_ALTERED_SEARCH_PATH is used to make it behave more closely
* to UNIX's search paths (start with system folders instead of current
* folder).
*/
hModule = LoadLibraryEx( (LPSTR) lpFileName, NULL,
LOAD_WITH_ALTERED_SEARCH_PATH );
/* If the object was loaded with RTLD_GLOBAL, add it to list of global
* objects, so that its symbols may be retrieved even if the handle for
* the original program file is passed. POSIX says that if the same
* file is specified in multiple invocations, and any of them are
* RTLD_GLOBAL, even if any further invocations use RTLD_LOCAL, the
* symbols will remain global.
*/
if( !hModule )
save_err_str( lpFileName );
else if( (mode & RTLD_GLOBAL) )
global_add( hModule );
}
/* Return to previous state of the error-mode bit flags. */
SetErrorMode( uMode );
return (void *) hModule;
}
/* Attaches a signal handler for Ctrl+C or Ctrl+Break signals
* Returns 1 if successful or -1 on error
*/
int evtxtools_signal_attach(
void (*signal_handler)( evtxtools_signal_t ),
libcerror_error_t **error )
{
static char *function = "evtxtools_signal_attach";
if( signal_handler == NULL )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_ARGUMENTS,
LIBCERROR_ARGUMENT_ERROR_INVALID_VALUE,
"%s: invalid signal handler.",
function );
return( -1 );
}
evtxtools_signal_signal_handler = signal_handler;
if( SetConsoleCtrlHandler(
evtxtools_signal_handler,
TRUE ) == 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to attach signal handler.",
function );
return( -1 );
}
if( SetConsoleCtrlHandler(
NULL,
FALSE ) == 0 )
{
libcerror_error_set(
error,
LIBCERROR_ERROR_DOMAIN_RUNTIME,
LIBCERROR_RUNTIME_ERROR_SET_FAILED,
"%s: unable to attach break signal.",
function );
return( -1 );
}
#if defined( _MSC_VER )
evtxtools_signal_initialize_memory_debug();
#endif
SetErrorMode(
SEM_FAILCRITICALERRORS );
#if defined( LOCALE_SUPPORT )
/* Allow subsequent threads to have their own locale.
* If the application is single threaded this call has
* no practical effect.
*/
_configthreadlocale(
_ENABLE_PER_THREAD_LOCALE );
/* Set the current thread locale to the user default
* ANSI code page.
*/
setlocale(
LC_ALL,
"" );
/* Set the the code page used by multibyte functions
* to use the same code page as the previous call to setlocale.
*/
_setmbcp(
_MB_CP_LOCALE );
#endif /* defined( LOCALE_SUPPORT ) */
return( 1 );
}
int
main(
int argc,
char *argv[])
{
char msg[300];
DWORD dwWritten;
int chars;
/*
* Make sure children (cl.exe and link.exe) are kept quiet.
*/
SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX);
/*
* Make sure the compiler and linker aren't effected by the outside world.
*/
SetEnvironmentVariable("CL", "");
SetEnvironmentVariable("LINK", "");
if (argc > 1 && *argv[1] == '-') {
switch (*(argv[1]+1)) {
case 'c':
if (argc != 3) {
chars = snprintf(msg, sizeof(msg) - 1,
"usage: %s -c <compiler option>\n"
"Tests for whether cl.exe supports an option\n"
"exitcodes: 0 == no, 1 == yes, 2 == error\n", argv[0]);
WriteFile(GetStdHandle(STD_ERROR_HANDLE), msg, chars,
&dwWritten, NULL);
return 2;
}
return CheckForCompilerFeature(argv[2]);
case 'l':
if (argc != 3) {
chars = snprintf(msg, sizeof(msg) - 1,
"usage: %s -l <linker option>\n"
"Tests for whether link.exe supports an option\n"
"exitcodes: 0 == no, 1 == yes, 2 == error\n", argv[0]);
WriteFile(GetStdHandle(STD_ERROR_HANDLE), msg, chars,
&dwWritten, NULL);
return 2;
}
return CheckForLinkerFeature(argv[2]);
case 'f':
if (argc == 2) {
chars = snprintf(msg, sizeof(msg) - 1,
"usage: %s -f <string> <substring>\n"
"Find a substring within another\n"
"exitcodes: 0 == no, 1 == yes, 2 == error\n", argv[0]);
WriteFile(GetStdHandle(STD_ERROR_HANDLE), msg, chars,
&dwWritten, NULL);
return 2;
} else if (argc == 3) {
/*
* If the string is blank, there is no match.
*/
return 0;
} else {
return IsIn(argv[2], argv[3]);
}
case 'g':
if (argc == 2) {
chars = snprintf(msg, sizeof(msg) - 1,
"usage: %s -g <file> <string>\n"
"grep for a #define\n"
"exitcodes: integer of the found string (no decimals)\n",
argv[0]);
WriteFile(GetStdHandle(STD_ERROR_HANDLE), msg, chars,
&dwWritten, NULL);
return 2;
}
return GrepForDefine(argv[2], argv[3]);
case 's':
if (argc == 2) {
chars = snprintf(msg, sizeof(msg) - 1,
"usage: %s -s <substitutions file> <file>\n"
"Perform a set of string map type substutitions on a file\n"
"exitcodes: 0\n",
argv[0]);
WriteFile(GetStdHandle(STD_ERROR_HANDLE), msg, chars,
&dwWritten, NULL);
return 2;
}
return SubstituteFile(argv[2], argv[3]);
case 'V':
if (argc != 4) {
chars = snprintf(msg, sizeof(msg) - 1,
"usage: %s -V filename matchstring\n"
"Extract a version from a file:\n"
"eg: pkgIndex.tcl \"package ifneeded http\"",
argv[0]);
WriteFile(GetStdHandle(STD_ERROR_HANDLE), msg, chars,
&dwWritten, NULL);
return 0;
}
printf("%s\n", GetVersionFromFile(argv[2], argv[3]));
return 0;
}
}
chars = snprintf(msg, sizeof(msg) - 1,
"usage: %s -c|-l|-f|-g|-V ...\n"
"This is a little helper app to equalize shell differences between WinNT and\n"
"Win9x and get nmake.exe to accomplish its job.\n",
argv[0]);
WriteFile(GetStdHandle(STD_ERROR_HANDLE), msg, chars, &dwWritten, NULL);
return 2;
}
void CLocalTreeView::Refresh()
{
wxLogNull nullLog;
const wxString separator = wxFileName::GetPathSeparator();
std::list<t_dir> dirsToCheck;
#ifdef __WXMSW__
int prevErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
wxTreeItemIdValue tmp;
wxTreeItemId child = GetFirstChild(m_drives, tmp);
while (child)
{
if (IsExpanded(child))
{
wxString drive = GetItemText(child);
int pos = drive.Find(_T(" "));
if (pos != -1)
drive = drive.Left(pos);
t_dir dir;
dir.dir = drive + separator;
dir.item = child;
dirsToCheck.push_back(dir);
}
child = GetNextSibling(child);
}
#else
t_dir dir;
dir.dir = separator;
dir.item = GetRootItem();
dirsToCheck.push_back(dir);
#endif
CFilterManager filter;
while (!dirsToCheck.empty())
{
t_dir dir = dirsToCheck.front();
dirsToCheck.pop_front();
// Step 1: Check if directory exists
CLocalFileSystem local_filesystem;
if (!local_filesystem.BeginFindFiles(dir.dir, true))
{
// Dir does exist (listed in parent) but may not be accessible.
// Recurse into children anyhow, they might be accessible again.
wxTreeItemIdValue value;
wxTreeItemId child = GetFirstChild(dir.item, value);
while (child)
{
t_dir subdir;
subdir.dir = dir.dir + GetItemText(child) + separator;
subdir.item = child;
dirsToCheck.push_back(subdir);
child = GetNextSibling(child);
}
continue;
}
// Step 2: Enumerate subdirectories on disk and sort them
std::list<wxString> dirs;
wxString file;
const wxLongLong size(-1);
bool was_link;
bool is_dir;
int attributes;
wxDateTime date;
while (local_filesystem.GetNextFile(file, was_link, is_dir, 0, &date, &attributes))
{
if (file == _T(""))
{
wxGetApp().DisplayEncodingWarning();
continue;
}
if (filter.FilenameFiltered(file, dir.dir, true, size, true, attributes, date.IsValid() ? &date : 0))
continue;
dirs.push_back(file);
}
dirs.sort(sortfunc);
bool inserted = false;
// Step 3: Merge list of subdirectories with subtree.
wxTreeItemId child = GetLastChild(dir.item);
std::list<wxString>::reverse_iterator iter = dirs.rbegin();
while (child || iter != dirs.rend())
{
int cmp;
if (child && iter != dirs.rend())
#ifdef __WXMSW__
cmp = GetItemText(child).CmpNoCase(*iter);
#else
cmp = GetItemText(child).Cmp(*iter);
#endif
else if (child)
cmp = 1;
else
cmp = -1;
if (!cmp)
{
// Found item with same name. Mark it for further processing
if (!IsExpanded(child))
{
wxString path = dir.dir + *iter + separator;
if (!CheckSubdirStatus(child, path))
{
t_dir subdir;
subdir.dir = path;
subdir.item = child;
dirsToCheck.push_front(subdir);
}
}
else
{
t_dir subdir;
subdir.dir = dir.dir + *iter + separator;
subdir.item = child;
dirsToCheck.push_front(subdir);
}
child = GetPrevSibling(child);
++iter;
}
else if (cmp > 0)
{
// Subdirectory currently in tree no longer exists.
// Delete child from tree, unless current selection
// is in the subtree.
wxTreeItemId sel = GetSelection();
while (sel && sel != child)
sel = GetItemParent(sel);
wxTreeItemId prev = GetPrevSibling(child);
if (!sel)
Delete(child);
child = prev;
}
else if (cmp < 0)
{
// New subdirectory, add treeitem
wxString fullname = dir.dir + *iter + separator;
wxTreeItemId newItem = AppendItem(dir.item, *iter, GetIconIndex(::dir, fullname),
#ifdef __WXMSW__
-1
#else
GetIconIndex(opened_dir, fullname)
#endif
);
CheckSubdirStatus(newItem, fullname);
++iter;
inserted = true;
}
}
if (inserted)
SortChildren(dir.item);
}
bool QLibraryPrivate::load_sys()
{
//avoid 'Bad Image' message box
UINT oldmode = SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX);
// We make the following attempts at locating the library:
//
// WinCE
// if (loadHints & QLibrary::ImprovedSearchHeuristics)
// if (absolute)
// fileName
// fileName + ".dll"
// else
// fileName + ".dll"
// fileName
// QFileInfo(fileName).absoluteFilePath()
// else
// QFileInfo(fileName).absoluteFilePath();
// fileName
// fileName + ".dll"
//
// Windows
// if (loadHints & QLibrary::ImprovedSearchHeuristics)
// if (absolute)
// fileName
// fileName + ".dll"
// else
// fileName + ".dll"
// fileName
// else
// fileName
// fileName + ".dll"
//
// NB If it's a plugin we do not ever try the ".dll" extension
QStringList attempts;
QFileSystemEntry fsEntry(fileName);
if (loadHints & QLibrary::ImprovedSearchHeuristics) {
if (pluginState != IsAPlugin)
attempts.append(fileName + QLatin1String(".dll"));
// If the fileName is an absolute path we try that first, otherwise we
// use the system-specific suffix first
if (fsEntry.isAbsolute()) {
attempts.prepend(fileName);
} else {
attempts.append(fileName);
#if defined(Q_OS_WINCE)
attempts.append(QFileInfo(fileName).absoluteFilePath());
#endif
}
} else {
#ifdef Q_OS_WINCE
attempts.append(QFileInfo(fileName).absoluteFilePath());
#else
attempts.append(fileName);
#endif
if (pluginState != IsAPlugin) {
#if defined(Q_OS_WINCE)
attempts.append(fileName);
#endif
attempts.append(fileName + QLatin1String(".dll"));
}
}
Q_FOREACH (const QString &attempt, attempts) {
pHnd = LoadLibrary((wchar_t*)QDir::toNativeSeparators(attempt).utf16());
// If we have a handle or the last error is something other than "unable
// to find the module", then bail out
if (pHnd || ::GetLastError() != ERROR_MOD_NOT_FOUND)
break;
}
DBGSTATIC NET_API_STATUS
ReplInit(
VOID
)
{
NET_API_STATUS NetStatus;
// init global variable ..
// this needs to be done because the service can be stopped and started;
// still the service .exe running and the global data live forever.
// BUGBUG: memory leak of old values?
ReplConfigExportList = NULL;
ReplConfigImportList = NULL;
ReplGlobalClientTerminateEvent = NULL;
ReplGlobalMasterTerminateEvent = NULL;
ReplGlobalExportStartupEvent = NULL;
ReplGlobalImportStartupEvent = NULL;
ReplGlobalClientThreadHandle = NULL;
ReplGlobalMasterThreadHandle = NULL;
ReplGlobalUninstallUicCode = 0;
ReplGlobalIsServiceStopping = FALSE;
ReplGlobalCheckpoint = 1;
// Init lock for config data.
ReplConfigLock = NetpCreateLock(
CONFIG_DATA_LOCK_LEVEL, (LPTSTR) TEXT("config data") );
NetpAssert( ReplConfigLock != NULL );
// Init client list lock (needed by import lock/unlock APIs even if
// import side not running). Ditto for master list lock.
RCGlobalClientListLock = NetpCreateLock(
CLIENT_LIST_LOCK_LEVEL,
(LPTSTR) TEXT("client list") );
NetpAssert( RCGlobalClientListLock != NULL );
RCGlobalDuplListLock = NetpCreateLock(
DUPL_LIST_LOCK_LEVEL,
(LPTSTR) TEXT("dupl list") );
NetpAssert( RCGlobalDuplListLock != NULL );
RMGlobalListLock = NetpCreateLock(
MASTER_LIST_LOCK_LEVEL,
(LPTSTR) TEXT("master list") );
NetpAssert( RMGlobalListLock != NULL); // BUGBUG: out of memory?
// Create startup events.
ReplGlobalExportStartupEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if( ReplGlobalExportStartupEvent == NULL) {
return (GetLastError());
}
ReplGlobalImportStartupEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if( ReplGlobalImportStartupEvent == NULL) {
return (GetLastError());
}
//
// Create termination events.
//
ReplGlobalClientTerminateEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if( ReplGlobalClientTerminateEvent == NULL) {
return (GetLastError());
}
ReplGlobalMasterTerminateEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (ReplGlobalMasterTerminateEvent == NULL) {
return (GetLastError());
}
//
// Disable the dreaded "net name deleted" popup (and all other hard
// error popups).
//
(VOID) SetErrorMode( SEM_FAILCRITICALERRORS );
//
// Get local domain name, computer name, etc.
//
NetStatus = GetLocalInfo();
if (NetStatus != NO_ERROR) {
return (NetStatus);
}
return (NO_ERROR);
}
int Win_Main( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow ) {
char cwd[MAX_OSPATH];
int startTime, endTime;
// should never get a previous instance in Win32
if ( hPrevInstance ) {
return 0;
}
if( setjmp( sys_exitframe ) ) {
//make sure that any subsystems that may have spawned threads go down
__try {
#if !defined(DEDICATED)
S_Shutdown();
CL_ShutdownRef();
#endif
} __finally { //wheeeee...
Com_ReleaseMemory();
}
return sys_retcode;
}
#ifdef EXCEPTION_HANDLER
WinSetExceptionVersion( Q3_VERSION );
#endif
g_wv.hInstance = hInstance;
Q_strncpyz( sys_cmdline, lpCmdLine, sizeof( sys_cmdline ) );
// done before Com/Sys_Init since we need this for error output
Sys_CreateConsole();
// no abort/retry/fail errors
SetErrorMode( SEM_FAILCRITICALERRORS );
// get the initial time base
Sys_Milliseconds();
Com_Init( sys_cmdline );
NET_Init();
#ifndef DEDICATED
IN_Init(); // fretn - directinput must be inited after video etc
#endif
_getcwd( cwd, sizeof( cwd ) );
Com_Printf( "Working directory: %s\n", cwd );
// hide the early console since we've reached the point where we
// have a working graphics subsystems
#if defined (_WIN32) && !defined (_DEBUG)
if ( !com_dedicated->integer && !com_viewlog->integer ) {
Sys_ShowConsole( 0, qfalse );
}
#endif
SetFocus( g_wv.hWnd );
// main game loop
while( 1 ) {
// if not running as a game client, sleep a bit
if( g_wv.isMinimized || ( com_dedicated && com_dedicated->integer ) ) {
Sleep( 5 );
}
// set low precision every frame, because some system calls
// reset it arbitrarily
//_controlfp( _PC_24, _MCW_PC );
//_controlfp( -1, _MCW_EM ); // no exceptions, even if some crappy
// syscall turns them back on!
startTime = Sys_Milliseconds();
// make sure mouse and joystick are only called once a frame
IN_Frame();
// run the game
//Com_FrameExt();
Com_Frame();
endTime = Sys_Milliseconds();
totalMsec += endTime - startTime;
countMsec++;
}
// never gets here
}
void
FileTransfer::FileTransferUpload()
{
int numOfFilesToUpload = 0, currentUploadIndex = -1;
DWORD sz_rfbFileSize;
DWORD sz_rfbBlockSize= 8192;
DWORD dwNumberOfBytesRead = 0;
unsigned int mTime = 0;
char path[rfbMAX_PATH + rfbMAX_PATH + 2];
BOOL bResult;
numOfFilesToUpload = ListView_GetSelectedCount(m_hwndFTClientList);
if (numOfFilesToUpload < 0) {
SetWindowText(m_hwndFTStatus, "No file selected, nothing to upload.");
BlockingFileTransferDialog(TRUE);
EnableWindow(GetDlgItem(m_hwndFileTransfer, IDC_FTCANCEL), FALSE);
return;
}
for (int i = 0; i < numOfFilesToUpload; i++) {
BlockingFileTransferDialog(FALSE);
EnableWindow(GetDlgItem(m_hwndFileTransfer, IDC_FTCANCEL), TRUE);
int index = ListView_GetNextItem(m_hwndFTClientList, currentUploadIndex, LVNI_SELECTED);
if (index < 0) {
SetWindowText(m_hwndFTStatus, "No file is selected, nothing to download.");
return;
}
currentUploadIndex = index;
ListView_GetItemText(m_hwndFTClientList, currentUploadIndex, 0, m_ClientFilename, rfbMAX_PATH);
sprintf(path, "%s\\%s", m_ClientPath, m_ClientFilename);
strcpy(m_UploadFilename, path);
WIN32_FIND_DATA FindFileData;
SetErrorMode(SEM_FAILCRITICALERRORS);
HANDLE hFile = FindFirstFile(path, &FindFileData);
SetErrorMode(0);
if (hFile == INVALID_HANDLE_VALUE) {
SetWindowText(m_hwndFTStatus, "Could not find selected file, can't upload");
// Continue with upload of other files.
continue;
} else if ((FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
SetWindowText(m_hwndFTStatus, "Cannot upload a directory");
// Continue with upload of other files.
continue;
} else {
sz_rfbFileSize = FindFileData.nFileSizeLow;
mTime = FiletimeToTime70(FindFileData.ftLastWriteTime);
strcpy(m_ServerFilename, FindFileData.cFileName);
}
FindClose(hFile);
if ((sz_rfbFileSize != 0) && (sz_rfbFileSize <= sz_rfbBlockSize)) sz_rfbBlockSize = sz_rfbFileSize;
m_hFiletoRead = CreateFile(path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL);
if (m_hFiletoRead == INVALID_HANDLE_VALUE) {
SetWindowText(m_hwndFTStatus, "Upload failed: could not open selected file");
BlockingFileTransferDialog(TRUE);
EnableWindow(GetDlgItem(m_hwndFileTransfer, IDC_FTCANCEL), FALSE);
return;
}
char buffer[rfbMAX_PATH + rfbMAX_PATH + rfbMAX_PATH + rfbMAX_PATH + 20];
sprintf(buffer, "Uploading: %s\\%s -> %s\\%s ...",
m_ClientPath, m_ClientFilename, m_ServerPath, m_ServerFilename);
SetWindowText(m_hwndFTStatus, buffer);
sprintf(path, "%s\\%s", m_ServerPath, m_ClientFilename);
ConvertPath(path);
int pathLen = strlen(path);
char *pAllFURMessage = new char[sz_rfbFileUploadRequestMsg + pathLen];
rfbFileUploadRequestMsg *pFUR = (rfbFileUploadRequestMsg *) pAllFURMessage;
char *pFollowMsg = &pAllFURMessage[sz_rfbFileUploadRequestMsg];
pFUR->type = rfbFileUploadRequest;
pFUR->compressedLevel = 0;
pFUR->fNameSize = Swap16IfLE(pathLen);
pFUR->position = Swap32IfLE(0);
memcpy(pFollowMsg, path, pathLen);
m_clientconn->WriteExact(pAllFURMessage, sz_rfbFileUploadRequestMsg + pathLen);
delete [] pAllFURMessage;
if (sz_rfbFileSize == 0) {
SendFileUploadDataMessage(mTime);
} else {
int amount = sz_rfbFileSize / (sz_rfbBlockSize * 10);
InitProgressBar(0, 0, amount, 1);
DWORD dwPortionRead = 0;
char *pBuff = new char [sz_rfbBlockSize];
m_bUploadStarted = TRUE;
while(m_bUploadStarted) {
ProcessDlgMessage(m_hwndFileTransfer);
if (m_bTransferEnable == FALSE) {
SetWindowText(m_hwndFTStatus, "File transfer canceled");
EnableWindow(GetDlgItem(m_hwndFileTransfer, IDC_FTCANCEL), FALSE);
BlockingFileTransferDialog(TRUE);
char reason[] = "File transfer canceled by user";
int reasonLen = strlen(reason);
char *pFUFMessage = new char[sz_rfbFileUploadFailedMsg + reasonLen];
rfbFileUploadFailedMsg *pFUF = (rfbFileUploadFailedMsg *) pFUFMessage;
char *pReason = &pFUFMessage[sz_rfbFileUploadFailedMsg];
pFUF->type = rfbFileUploadFailed;
pFUF->reasonLen = Swap16IfLE(reasonLen);
memcpy(pReason, reason, reasonLen);
m_clientconn->WriteExact(pFUFMessage, sz_rfbFileUploadFailedMsg + reasonLen);
delete [] pFUFMessage;
break;
}
bResult = ReadFile(m_hFiletoRead, pBuff, sz_rfbBlockSize, &dwNumberOfBytesRead, NULL);
if (bResult && dwNumberOfBytesRead == 0) {
/* This is the end of the file. */
SendFileUploadDataMessage(mTime);
break;
}
SendFileUploadDataMessage((unsigned short)dwNumberOfBytesRead, pBuff);
dwPortionRead += dwNumberOfBytesRead;
if (dwPortionRead >= (10 * sz_rfbBlockSize)) {
dwPortionRead = 0;
SendMessage(m_hwndFTProgress, PBM_STEPIT, 0, 0);
}
}
if (m_bTransferEnable == FALSE)
break;
m_bUploadStarted = FALSE;
delete [] pBuff;
}
SendMessage(m_hwndFTProgress, PBM_SETPOS, 0, 0);
SetWindowText(m_hwndFTStatus, "");
CloseHandle(m_hFiletoRead);
}
EnableWindow(GetDlgItem(m_hwndFileTransfer, IDC_FTCANCEL), FALSE);
BlockingFileTransferDialog(TRUE);
SendFileListRequestMessage(m_ServerPath, 0);
}
LONG WINAPI MyExceptionCrashFunc(struct _EXCEPTION_POINTERS *pExceptionPointers)
{
SetErrorMode( SEM_NOGPFAULTERRORBOX );
//收集信息
CString strBuild;
strBuild.Format("Build: %s %s", __DATE__, __TIME__);
CString strError;
HMODULE hModule;
CHAR szModuleName[MAX_PATH] = "";
GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, (LPCSTR)pExceptionPointers->ExceptionRecord->ExceptionAddress, &hModule);
GetModuleFileName(hModule, szModuleName, ARRAYSIZE(szModuleName));
strError.AppendFormat("%s %d , %d ,%d.", szModuleName,pExceptionPointers->ExceptionRecord->ExceptionCode, pExceptionPointers->ExceptionRecord->ExceptionFlags, pExceptionPointers->ExceptionRecord->ExceptionAddress);
CString strAppFile = szModuleName;
int nFind = strAppFile.ReverseFind('\\');
CString strAppPath = strAppFile.Left(nFind+1);
strAppPath += "dump";
CString strAppName = strAppFile.Mid(nFind+1);
//{add by tian_yx 2011-07-22 09:36
// char szMyDir[MAX_PATH];
// ZeroMemory(szMyDir, sizeof(szMyDir));
// ::SHGetSpecialFolderPath(NULL,szMyDir,CSIDL_LOCAL_APPDATA,0);
// strAppPath = szMyDir;
// strAppPath +=TEXT("\\EZworking");
// CreateDirectory(strAppPath, NULL);
// strAppPath +=TEXT("\\dump");
CreateDirectory(strAppPath, NULL);
//}end by tian_yx 2011-07-22 09:36
//生成 mini crash dump
BOOL bMiniDumpSuccessful;
CHAR szFileName[512];
DWORD dwBufferSize = MAX_PATH;
HANDLE hDumpFile;
SYSTEMTIME stLocalTime;
MINIDUMP_EXCEPTION_INFORMATION ExpParam;
GetLocalTime( &stLocalTime );
CreateDirectory( strAppPath, NULL );
StringCchPrintf( szFileName, MAX_PATH, "%s\\%04d%02d%02d-%02dh%02dm%02ds.dmp",
strAppPath,
stLocalTime.wYear, stLocalTime.wMonth, stLocalTime.wDay,
stLocalTime.wHour, stLocalTime.wMinute, stLocalTime.wSecond,
GetCurrentProcessId(), GetCurrentThreadId());
hDumpFile = CreateFile(szFileName, GENERIC_READ|GENERIC_WRITE,
FILE_SHARE_WRITE|FILE_SHARE_READ, 0, CREATE_ALWAYS, 0, 0);
MINIDUMP_USER_STREAM UserStream[2];
MINIDUMP_USER_STREAM_INFORMATION UserInfo;
UserInfo.UserStreamCount = 1;
UserInfo.UserStreamArray = UserStream;
UserStream[0].Type = CommentStreamW;
UserStream[0].BufferSize = strBuild.GetLength()*sizeof(WCHAR);
UserStream[0].Buffer = strBuild.GetBuffer();
UserStream[1].Type = CommentStreamW;
UserStream[1].BufferSize = strError.GetLength()*sizeof(WCHAR);
UserStream[1].Buffer = strError.GetBuffer();
ExpParam.ThreadId = GetCurrentThreadId();
ExpParam.ExceptionPointers = pExceptionPointers;
ExpParam.ClientPointers = TRUE;
MINIDUMP_TYPE MiniDumpWithDataSegs = (MINIDUMP_TYPE)(
MiniDumpNormal
| MiniDumpWithHandleData
| MiniDumpWithUnloadedModules
| MiniDumpWithIndirectlyReferencedMemory
| MiniDumpScanMemory
| MiniDumpWithProcessThreadData
| MiniDumpWithThreadInfo);
bMiniDumpSuccessful = MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(),
hDumpFile, MiniDumpWithDataSegs, &ExpParam, NULL, NULL);
return TRUE;
}
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
int retCode = 1; // by default it's error
#ifdef DEBUG
// Memory leak detection (only enable _CRTDBG_LEAK_CHECK_DF for
// regular termination so that leaks aren't checked on exceptions,
// aborts, etc. where some clean-up might not take place)
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF);
//_CrtSetBreakAlloc(421);
TryLoadMemTrace();
#endif
//BenchMD5();
DisableDataExecution();
// ensure that C functions behave consistently under all OS locales
// (use Win32 functions where localized input or output is desired)
setlocale(LC_ALL, "C");
RunUnitTests();
// don't show system-provided dialog boxes when accessing files on drives
// that are not mounted (e.g. a: drive without floppy or cd rom drive
// without a cd).
SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);
srand((unsigned int)time(NULL));
// don't bother sending crash reports when running under Wine
// as they're not helpful
if (!RunningUnderWine()) {
ScopedMem<TCHAR> symDir;
ScopedMem<TCHAR> tmpDir(path::GetTempPath());
if (tmpDir)
symDir.Set(path::Join(tmpDir, _T("SumatraPDF-symbols")));
else
symDir.Set(AppGenDataFilename(_T("SumatraPDF-symbols")));
ScopedMem<TCHAR> crashDumpPath(AppGenDataFilename(CRASH_DUMP_FILE_NAME));
InstallCrashHandler(crashDumpPath, symDir);
}
ScopedOle ole;
InitAllCommonControls();
ScopedGdiPlus gdiPlus(true);
mui::Initialize();
uimsg::Initialize();
ScopedMem<TCHAR> prefsFilename(GetPrefsFileName());
if (!file::Exists(prefsFilename)) {
// guess the ui language on first start
CurrLangNameSet(Trans::GuessLanguage());
gFavorites = new Favorites();
} else {
assert(gFavorites == NULL);
Prefs::Load(prefsFilename, gGlobalPrefs, gFileHistory, &gFavorites);
CurrLangNameSet(gGlobalPrefs.currentLanguage);
}
prefsFilename.Set(NULL);
CommandLineInfo i;
GetCommandLineInfo(i);
if (i.showConsole)
RedirectIOToConsole();
if (i.makeDefault)
AssociateExeWithPdfExtension();
if (i.pathsToBenchmark.Count() > 0) {
BenchFileOrDir(i.pathsToBenchmark);
if (i.showConsole)
system("pause");
}
if (i.exitImmediately)
goto Exit;
gCrashOnOpen = i.crashOnOpen;
gGlobalPrefs.bgColor = i.bgColor;
gGlobalPrefs.fwdSearch.offset = i.fwdSearch.offset;
gGlobalPrefs.fwdSearch.width = i.fwdSearch.width;
gGlobalPrefs.fwdSearch.color = i.fwdSearch.color;
gGlobalPrefs.fwdSearch.permanent = i.fwdSearch.permanent;
gGlobalPrefs.escToExit = i.escToExit;
gGlobalPrefs.cbxR2L = i.cbxR2L;
gPolicyRestrictions = GetPolicies(i.restrictedUse);
gRenderCache.colorRange[0] = i.colorRange[0];
gRenderCache.colorRange[1] = i.colorRange[1];
DebugGdiPlusDevice(gUseGdiRenderer);
DebugAlternateChmEngine(!gUseEbookUI);
if (i.inverseSearchCmdLine) {
str::ReplacePtr(&gGlobalPrefs.inverseSearchCmdLine, i.inverseSearchCmdLine);
gGlobalPrefs.enableTeXEnhancements = true;
}
CurrLangNameSet(i.lang);
if (!RegisterWinClass(hInstance))
goto Exit;
if (!InstanceInit(hInstance, nCmdShow))
goto Exit;
if (i.hwndPluginParent) {
if (!SetupPluginMode(i))
goto Exit;
}
if (i.printerName) {
// note: this prints all PDF files. Another option would be to
// print only the first one
for (size_t n = 0; n < i.fileNames.Count(); n++) {
bool ok = PrintFile(i.fileNames.At(n), i.printerName, !i.silent, i.printSettings);
if (!ok)
retCode++;
}
--retCode; // was 1 if no print failures, turn 1 into 0
goto Exit;
}
if (i.fileNames.Count() == 0 && gGlobalPrefs.rememberOpenedFiles && gGlobalPrefs.showStartPage) {
// make the shell prepare the image list, so that it's ready when the first window's loaded
SHFILEINFO sfi;
SHGetFileInfo(_T(".pdf"), 0, &sfi, sizeof(sfi), SHGFI_SYSICONINDEX | SHGFI_SMALLICON | SHGFI_USEFILEATTRIBUTES);
}
WindowInfo *win = NULL;
bool isFirstWin = true;
for (size_t n = 0; n < i.fileNames.Count(); n++) {
if (i.reuseInstance && !i.printDialog) {
OpenUsingDde(i.fileNames.At(n), i, isFirstWin);
} else {
win = LoadOnStartup(i.fileNames.At(n), i, isFirstWin);
if (!win) {
retCode++;
continue;
}
if (i.printDialog)
OnMenuPrint(win, i.exitOnPrint);
}
isFirstWin = false;
}
if (i.fileNames.Count() > 0 && isFirstWin) {
// failed to create any window, even though there
// were files to load (or show a failure message for)
goto Exit;
}
if (i.reuseInstance && !i.printDialog || i.printDialog && i.exitOnPrint)
goto Exit;
if (isFirstWin) {
win = CreateAndShowWindowInfo();
if (!win)
goto Exit;
}
UpdateUITextForLanguage(); // needed for RTL languages
if (isFirstWin)
UpdateToolbarAndScrollbarState(*win);
// Make sure that we're still registered as default,
// if the user has explicitly told us to be
if (gGlobalPrefs.pdfAssociateShouldAssociate && win)
RegisterForPdfExtentions(win->hwndFrame);
if (gGlobalPrefs.enableAutoUpdate && gWindows.Count() > 0)
AutoUpdateCheckAsync(gWindows.At(0)->hwndFrame, true);
#ifndef THREAD_BASED_FILEWATCH
const UINT_PTR timerID = SetTimer(NULL, -1, FILEWATCH_DELAY_IN_MS, NULL);
#endif
if (i.stressTestPath) {
gIsStressTesting = true;
StartStressTest(win, i.stressTestPath, i.stressTestFilter,
i.stressTestRanges, i.stressTestCycles, &gRenderCache);
}
retCode = RunMessageLoop();
#ifndef THREAD_BASED_FILEWATCH
KillTimer(NULL, timerID);
#endif
CleanUpThumbnailCache(gFileHistory);
Exit:
while (gWindows.Count() > 0) {
DeleteWindowInfo(gWindows.At(0));
}
while (gEbookWindows.Count() > 0) {
DeleteEbookWindow(gEbookWindows.At(0), true);
}
#ifndef DEBUG
// leave all the remaining clean-up to the OS
// (as recommended for a quick exit)
ExitProcess(retCode);
#endif
DeleteObject(gBrushNoDocBg);
DeleteObject(gBrushLogoBg);
DeleteObject(gBrushAboutBg);
DeleteObject(gDefaultGuiFont);
DeleteBitmap(gBitmapReloadingCue);
delete gFavorites;
mui::Destroy();
DrainUiMsgQueue();
uimsg::Destroy();
// it's still possible to crash after this (destructors of static classes,
// atexit() code etc.) point, but it's very unlikely
if (!RunningUnderWine())
UninstallCrashHandler();
#ifdef DEBUG
// output leaks after all destructors of static objects have run
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif
return retCode;
}
/** public functions **/
BOOL WINAPI DllMain(HINSTANCE hinstDLL,ULONG fdwReason,LPVOID lpvReserved) {
hInstance = hinstDLL;
if ( !controlsInit ) {
controlsInit = TRUE;
// initialize Chicago controls
InitCommonControls();
}
// If we have already tried to load the resource
// file and failed just give up.
if (triedToLoad && ! resourcesLoaded)
return FALSE;
// Load our resources. We look for the file in the
// same directory where this DLL was found
if (! resourcesLoaded) {
// Where this DLL resides
char dirName[MAX_PATH_LENGTH];
// Full path name to resource DLL
char dllName[MAX_PATH_LENGTH];
char *chPtr;
GetModuleFileName (hinstDLL, dirName, MAX_PATH_LENGTH);
// Strip off the file name
chPtr = dirName + strlen (dirName);
while (*(--chPtr) != '\\')
;
*(chPtr+1) = 0;
// Add in "epsres.dll"
strcpy (dllName, dirName);
strcat (dllName, "pursuit.str");
// Load resource DLL
// Turn off error reporting
int errorMode = SetErrorMode(SEM_NOOPENFILEERRORBOX);
hResource = LoadLibraryEx(dllName, NULL, 0);
SetErrorMode(errorMode);
// Be sure to check to see if we succeeded
// loading resource DLL
if (hResource) {
resourcesLoaded = TRUE;
InitCustomControls (hResource);
} else {
triedToLoad = TRUE;
MessageBox (NULL,"Crowd Pursuit Behavior Plugin failed to load due to missing resource file pursuit.str",
"CROWD", MB_ICONINFORMATION);
return FALSE;
}
}
switch(fdwReason) {
case DLL_PROCESS_ATTACH:
break;
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
break;
case DLL_PROCESS_DETACH:
if (hResource)
{
FreeLibrary(hResource);
hResource = NULL;
}
break;
}
return(TRUE);
}
/******************************************************************
Function Name: CheckNetfxVersionUsingMscoree
Description: Uses the logic described in the sample code at http://msdn2.microsoft.com/library/ydh6b3yb.aspx
to load mscoree.dll and call its APIs to determine
whether or not a specific version of the .NET
Framework is installed on the system
Inputs: pszNetfxVersionToCheck - version to look for
Results: true if the requested version is installed
false otherwise
******************************************************************/
bool CheckNetfxVersionUsingMscoree(const TCHAR *pszNetfxVersionToCheck)
{
bool bFoundRequestedNetfxVersion = false;
HRESULT hr = S_OK;
// Check input parameter
if (NULL == pszNetfxVersionToCheck)
return false;
HMODULE hmodMscoree = LoadLibraryEx(_T("mscoree.dll"), NULL, 0);
if (NULL != hmodMscoree)
{
typedef HRESULT (STDAPICALLTYPE *GETCORVERSION)(LPWSTR szBuffer, DWORD cchBuffer, DWORD* dwLength);
GETCORVERSION pfnGETCORVERSION = (GETCORVERSION)GetProcAddress(hmodMscoree, "GetCORVersion");
// Some OSs shipped with a placeholder copy of mscoree.dll. The existence of mscoree.dll
// therefore does NOT mean that a version of the .NET Framework is installed.
// If this copy of mscoree.dll does not have an exported function named GetCORVersion
// then we know it is a placeholder DLL.
if (NULL == pfnGETCORVERSION)
goto Finish;
typedef HRESULT (STDAPICALLTYPE *CORBINDTORUNTIME)(LPCWSTR pwszVersion, LPCWSTR pwszBuildFlavor, REFCLSID rclsid, REFIID riid, LPVOID FAR *ppv);
CORBINDTORUNTIME pfnCORBINDTORUNTIME = (CORBINDTORUNTIME)GetProcAddress(hmodMscoree, "CorBindToRuntime");
typedef HRESULT (STDAPICALLTYPE *GETREQUESTEDRUNTIMEINFO)(LPCWSTR pExe, LPCWSTR pwszVersion, LPCWSTR pConfigurationFile, DWORD startupFlags, DWORD runtimeInfoFlags, LPWSTR pDirectory, DWORD dwDirectory, DWORD *dwDirectoryLength, LPWSTR pVersion, DWORD cchBuffer, DWORD* dwlength);
GETREQUESTEDRUNTIMEINFO pfnGETREQUESTEDRUNTIMEINFO = (GETREQUESTEDRUNTIMEINFO)GetProcAddress(hmodMscoree, "GetRequestedRuntimeInfo");
if (NULL != pfnCORBINDTORUNTIME)
{
TCHAR szRetrievedVersion[50];
DWORD dwLength = CountOf(szRetrievedVersion);
if (NULL == pfnGETREQUESTEDRUNTIMEINFO)
{
// Having CorBindToRuntimeHost but not having GetRequestedRuntimeInfo means that
// this machine contains no higher than .NET Framework 1.0, but the only way to
// 100% guarantee that the .NET Framework 1.0 is installed is to call a function
// to exercise its functionality
if (0 == _tcscmp(pszNetfxVersionToCheck, g_szNetfx10VersionString))
{
hr = pfnGETCORVERSION(szRetrievedVersion, dwLength, &dwLength);
if (SUCCEEDED(hr))
{
if (0 == _tcscmp(szRetrievedVersion, g_szNetfx10VersionString))
bFoundRequestedNetfxVersion = true;
}
goto Finish;
}
}
// Set error mode to prevent the .NET Framework from displaying
// unfriendly error dialogs
UINT uOldErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS);
TCHAR szDirectory[MAX_PATH];
DWORD dwDirectoryLength = 0;
DWORD dwRuntimeInfoFlags = RUNTIME_INFO_DONT_RETURN_DIRECTORY | GetProcessorArchitectureFlag();
// Check for the requested .NET Framework version
hr = pfnGETREQUESTEDRUNTIMEINFO(NULL, pszNetfxVersionToCheck, NULL, STARTUP_LOADER_OPTIMIZATION_MULTI_DOMAIN_HOST, NULL, szDirectory, CountOf(szDirectory), &dwDirectoryLength, szRetrievedVersion, CountOf(szRetrievedVersion), &dwLength);
if (SUCCEEDED(hr))
bFoundRequestedNetfxVersion = true;
// Restore the previous error mode
SetErrorMode(uOldErrorMode);
}
}
Finish:
if (hmodMscoree)
{
FreeLibrary(hmodMscoree);
}
return bFoundRequestedNetfxVersion;
}
// Entry point where control comes on an unhandled exception
static
LONG WINAPI TopLevelExceptionFilter(PEXCEPTION_POINTERS pExceptionInfo)
{
static BOOL bBeenHere = FALSE;
if(!bBeenHere)
{
UINT fuOldErrorMode;
bBeenHere = TRUE;
fuOldErrorMode = SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX);
hReportFile = CreateFile(
szLogFileName,
GENERIC_WRITE,
0,
0,
OPEN_ALWAYS,
FILE_FLAG_WRITE_THROUGH,
0
);
if (hReportFile == INVALID_HANDLE_VALUE)
{
// Retrieve the system error message for the last-error code
LPVOID lpMsgBuf;
LPVOID lpDisplayBuf;
DWORD dw = GetLastError();
TCHAR szBuffer[4196];
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
dw,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &lpMsgBuf,
0, NULL );
wsprintf(szBuffer, _T("Exception handler failed with error %d: %s\n"), dw, lpMsgBuf);
MessageBox(MB_ICONEXCLAMATION, szBuffer, _T("Error"), MB_OK);
LocalFree(lpMsgBuf);
LocalFree(lpDisplayBuf);
debug(LOG_ERROR, "Exception handler failed to create file!");
}
#ifdef HAVE_BFD
bfd_set_error_handler((bfd_error_handler_type) rprintf);
#endif /* HAVE_BFD */
if (hReportFile)
{
TCHAR szBuffer[4196];
int err;
SetFilePointer(hReportFile, 0, 0, FILE_END);
// FIXME: We don't return from the below function call
GenerateExceptionReport(pExceptionInfo);
CloseHandle(hReportFile);
wsprintf(szBuffer, _T("Warzone has crashed.\r\nSee %s for more details\r\n"), szLogFileName);
err = MessageBox(MB_ICONERROR, szBuffer, _T("Warzone Crashed!"), MB_OK | MB_ICONERROR);
if (err == 0)
{
LPVOID lpMsgBuf;
LPVOID lpDisplayBuf;
DWORD dw = GetLastError();
TCHAR szBuffer[4196];
FormatMessage(
FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
dw,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &lpMsgBuf,
0, NULL );
wsprintf(szBuffer, _T("Exception handler failed with error %d: %s\n"), dw, lpMsgBuf);
MessageBox(MB_ICONEXCLAMATION, szBuffer, _T("Error"), MB_OK);
LocalFree(lpMsgBuf);
LocalFree(lpDisplayBuf);
debug(LOG_ERROR, "Exception handler failed to create file!");
}
hReportFile = 0;
}
SetErrorMode(fuOldErrorMode);
}
if(prevExceptionFilter)
return prevExceptionFilter(pExceptionInfo);
else
return EXCEPTION_CONTINUE_SEARCH;
}
/*
==================
WinMain
==================
*/
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
char cwd[MAX_OSPATH];
// int startTime, endTime;
SET_CRT_DEBUG_FIELD( _CRTDBG_LEAK_CHECK_DF );
// _CrtSetBreakAlloc(34804);
// should never get a previous instance in Win32
if ( hPrevInstance ) {
return 0;
}
g_wv.hInstance = hInstance;
Q_strncpyz( sys_cmdline, lpCmdLine, sizeof( sys_cmdline ) );
// done before Com/Sys_Init since we need this for error output
Sys_CreateConsole();
// no abort/retry/fail errors
SetErrorMode( SEM_FAILCRITICALERRORS );
// get the initial time base
Sys_Milliseconds();
#if 0
// if we find the CD, add a +set cddir xxx command line
Sys_ScanForCD();
#endif
Sys_InitStreamThread();
Com_Init( sys_cmdline );
QuickMemTest();
_getcwd (cwd, sizeof(cwd));
Com_Printf("Working directory: %s\n", cwd);
// hide the early console since we've reached the point where we
// have a working graphics subsystems
if ( !com_viewlog->integer ) {
Sys_ShowConsole( 0, qfalse );
}
// main game loop
while( 1 ) {
// if not running as a game client, sleep a bit
if ( g_wv.isMinimized ) {
Sleep( 5 );
}
#ifdef _DEBUG
if (!g_wv.activeApp)
{
Sleep(50);
}
#endif // _DEBUG
// set low precision every frame, because some system calls
// reset it arbitrarily
// _controlfp( _PC_24, _MCW_PC );
// startTime = Sys_Milliseconds();
// make sure mouse and joystick are only called once a frame
IN_Frame();
// run the game
Com_Frame();
// endTime = Sys_Milliseconds();
// totalMsec += endTime - startTime;
// countMsec++;
}
// never gets here
}
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
int retCode = 1; // by default it's error
#ifdef DEBUG
// Memory leak detection (only enable _CRTDBG_LEAK_CHECK_DF for
// regular termination so that leaks aren't checked on exceptions,
// aborts, etc. where some clean-up might not take place)
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF);
//_CrtSetBreakAlloc(421);
TryLoadMemTrace();
#endif
DisableDataExecution();
// ensure that C functions behave consistently under all OS locales
// (use Win32 functions where localized input or output is desired)
setlocale(LC_ALL, "C");
// don't show system-provided dialog boxes when accessing files on drives
// that are not mounted (e.g. a: drive without floppy or cd rom drive
// without a cd).
SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);
#if defined(DEBUG) || defined(SVN_PRE_RELEASE_VER)
if (str::StartsWith(lpCmdLine, "/tester")) {
extern int TesterMain(); // in Tester.cpp
return TesterMain();
}
if (str::StartsWith(lpCmdLine, "/regress")) {
extern int RegressMain(); // in Regress.cpp
return RegressMain();
}
#endif
#ifdef SUPPORTS_AUTO_UPDATE
if (str::StartsWith(lpCmdLine, "-autoupdate")) {
bool quit = AutoUpdateMain();
if (quit)
return 0;
}
#endif
RunUnitTests();
srand((unsigned int)time(NULL));
{
ScopedMem<WCHAR> symDir;
ScopedMem<WCHAR> tmpDir(path::GetTempPath());
if (tmpDir)
symDir.Set(path::Join(tmpDir, L"SumatraPDF-symbols"));
else
symDir.Set(AppGenDataFilename(L"SumatraPDF-symbols"));
ScopedMem<WCHAR> crashDumpPath(AppGenDataFilename(CRASH_DUMP_FILE_NAME));
InstallCrashHandler(crashDumpPath, symDir);
}
ScopedOle ole;
InitAllCommonControls();
ScopedGdiPlus gdiPlus(true);
mui::Initialize();
uitask::Initialize();
LoadPrefs();
CommandLineInfo i;
GetCommandLineInfo(i);
SetCurrentLang(i.lang ? i.lang : gGlobalPrefs->currLangCode);
if (i.showConsole)
RedirectIOToConsole();
if (i.makeDefault)
AssociateExeWithPdfExtension();
if (i.pathsToBenchmark.Count() > 0) {
BenchFileOrDir(i.pathsToBenchmark);
if (i.showConsole)
system("pause");
}
if (i.exitImmediately)
goto Exit;
gCrashOnOpen = i.crashOnOpen;
gUserPrefs->mainWindowBackground = i.bgColor;
if (gUserPrefs->forwardSearch.highlightColor != i.forwardSearch.highlightColor ||
gUserPrefs->forwardSearch.highlightOffset != i.forwardSearch.highlightOffset ||
gUserPrefs->forwardSearch.highlightPermanent != i.forwardSearch.highlightPermanent ||
gUserPrefs->forwardSearch.highlightWidth != i.forwardSearch.highlightWidth) {
gGlobalPrefs->enableTeXEnhancements = true;
}
gUserPrefs->forwardSearch = i.forwardSearch;
gUserPrefs->escToExit = i.escToExit;
gGlobalPrefs->cbxR2L = i.cbxR2L;
gPolicyRestrictions = GetPolicies(i.restrictedUse);
gRenderCache.colorRange[0] = i.colorRange[0];
gRenderCache.colorRange[1] = i.colorRange[1];
DebugGdiPlusDevice(gUseGdiRenderer);
DebugAlternateChmEngine(gUserPrefs->ebookUI.traditionalEbookUI);
if (i.inverseSearchCmdLine) {
str::ReplacePtr(&gGlobalPrefs->inverseSearchCmdLine, i.inverseSearchCmdLine);
gGlobalPrefs->enableTeXEnhancements = true;
}
if (!RegisterWinClass(hInstance))
goto Exit;
if (!InstanceInit(hInstance, nCmdShow))
goto Exit;
if (i.hwndPluginParent) {
if (!SetupPluginMode(i))
goto Exit;
}
if (i.printerName) {
// note: this prints all PDF files. Another option would be to
// print only the first one
for (size_t n = 0; n < i.fileNames.Count(); n++) {
bool ok = PrintFile(i.fileNames.At(n), i.printerName, !i.silent, i.printSettings);
if (!ok)
retCode++;
}
--retCode; // was 1 if no print failures, turn 1 into 0
goto Exit;
}
if (i.fileNames.Count() == 0 && gGlobalPrefs->rememberOpenedFiles && gGlobalPrefs->showStartPage) {
// make the shell prepare the image list, so that it's ready when the first window's loaded
SHFILEINFO sfi;
SHGetFileInfo(L".pdf", 0, &sfi, sizeof(sfi), SHGFI_SYSICONINDEX | SHGFI_SMALLICON | SHGFI_USEFILEATTRIBUTES);
}
if (!i.reuseInstance && gUserPrefs->reuseInstance && FindWindow(FRAME_CLASS_NAME, 0))
i.reuseInstance = true;
WindowInfo *win = NULL;
bool isFirstWin = true;
for (size_t n = 0; n < i.fileNames.Count(); n++) {
if (i.reuseInstance && !i.printDialog) {
OpenUsingDde(i.fileNames.At(n), i, isFirstWin);
} else {
win = LoadOnStartup(i.fileNames.At(n), i, isFirstWin);
if (!win) {
retCode++;
continue;
}
if (i.printDialog)
OnMenuPrint(win, i.exitWhenDone);
}
isFirstWin = false;
}
if (i.fileNames.Count() > 0 && isFirstWin) {
// failed to create any window, even though there
// were files to load (or show a failure message for)
goto Exit;
}
if (i.reuseInstance && !i.printDialog || i.printDialog && i.exitWhenDone)
goto Exit;
if (isFirstWin) {
win = CreateAndShowWindowInfo();
if (!win)
goto Exit;
}
UpdateUITextForLanguage(); // needed for RTL languages
if (isFirstWin)
UpdateToolbarAndScrollbarState(*win);
// Make sure that we're still registered as default,
// if the user has explicitly told us to be
if (gGlobalPrefs->pdfAssociateShouldAssociate && win)
RegisterForPdfExtentions(win->hwndFrame);
if (gGlobalPrefs->enableAutoUpdate && gWindows.Count() > 0)
AutoUpdateCheckAsync(gWindows.At(0)->hwndFrame, true);
if (i.stressTestPath)
StartStressTest(&i, win, &gRenderCache);
if (gFileHistory.Get(0)) {
gFileExistenceChecker = new FileExistenceChecker();
gFileExistenceChecker->Start();
}
retCode = RunMessageLoop();
CleanUpThumbnailCache(gFileHistory);
Exit:
while (gWindows.Count() > 0) {
DeleteWindowInfo(gWindows.At(0));
}
while (gEbookWindows.Count() > 0) {
DeleteEbookWindow(gEbookWindows.At(0), true);
}
#ifndef DEBUG
// leave all the remaining clean-up to the OS
// (as recommended for a quick exit)
ExitProcess(retCode);
#else
CrashIf(gFileExistenceChecker);
DeleteObject(gBrushNoDocBg);
DeleteObject(gBrushLogoBg);
DeleteObject(gBrushAboutBg);
DeleteObject(gDefaultGuiFont);
DeleteBitmap(gBitmapReloadingCue);
gFileHistory.UpdateStatesSource(NULL);
DeleteGlobalPrefs(gGlobalPrefs);
mui::Destroy();
uitask::Destroy();
trans::Destroy();
// it's still possible to crash after this (destructors of static classes,
// atexit() code etc.) point, but it's very unlikely
UninstallCrashHandler();
// output leaks after all destructors of static objects have run
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
return retCode;
#endif
}
int main(int argc, char *argv[])
{
#ifdef _UNIX
setlocale(LC_ALL,"");
#endif
InitConsole();
ErrHandler.SetSignalHandlers(true);
#ifdef SFX_MODULE
wchar ModuleName[NM];
#ifdef _WIN_ALL
GetModuleFileName(NULL,ModuleName,ASIZE(ModuleName));
#else
CharToWide(argv[0],ModuleName,ASIZE(ModuleName));
#endif
#endif
#ifdef _WIN_ALL
SetErrorMode(SEM_NOALIGNMENTFAULTEXCEPT|SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX);
#endif
#if defined(_WIN_ALL) && !defined(SFX_MODULE) && !defined(SHELL_EXT)
// Must be initialized, normal initialization can be skipped in case of
// exception.
bool ShutdownOnClose=false;
#endif
try
{
CommandData *Cmd=new CommandData;
#ifdef SFX_MODULE
wcscpy(Cmd->Command,L"X");
char *Switch=argc>1 ? argv[1]:NULL;
if (Switch!=NULL && Cmd->IsSwitch(Switch[0]))
{
int UpperCmd=etoupper(Switch[1]);
switch(UpperCmd)
{
case 'T':
case 'V':
Cmd->Command[0]=UpperCmd;
break;
case '?':
Cmd->OutHelp(RARX_SUCCESS);
break;
}
}
Cmd->AddArcName(ModuleName);
Cmd->ParseDone();
#else // !SFX_MODULE
Cmd->ParseCommandLine(true,argc,argv);
if (!Cmd->ConfigDisabled)
{
Cmd->ReadConfig();
Cmd->ParseEnvVar();
}
Cmd->ParseCommandLine(false,argc,argv);
#endif
#if defined(_WIN_ALL) && !defined(SFX_MODULE) && !defined(SHELL_EXT)
ShutdownOnClose=Cmd->Shutdown;
#endif
uiInit(Cmd->Sound);
InitConsoleOptions(Cmd->MsgStream);
InitLogOptions(Cmd->LogName,Cmd->ErrlogCharset);
ErrHandler.SetSilent(Cmd->AllYes || Cmd->MsgStream==MSG_NULL);
ErrHandler.SetShutdown(Cmd->Shutdown);
Cmd->OutTitle();
Cmd->ProcessCommand();
delete Cmd;
}
catch (RAR_EXIT ErrCode)
{
ErrHandler.SetErrorCode(ErrCode);
}
catch (std::bad_alloc&)
{
ErrHandler.MemoryErrorMsg();
ErrHandler.SetErrorCode(RARX_MEMORY);
}
catch (...)
{
ErrHandler.SetErrorCode(RARX_FATAL);
}
#if defined(_WIN_ALL) && !defined(SFX_MODULE) && !defined(SHELL_EXT)
if (ShutdownOnClose)
Shutdown();
#endif
ErrHandler.MainExit=true;
return ErrHandler.GetErrorCode();
}
static int SDLCALL
windows_file_open(SDL_RWops * context, const char *filename, const char *mode)
{
UINT old_error_mode;
HANDLE h;
DWORD r_right, w_right;
DWORD must_exist, truncate;
int a_mode;
if (!context)
return -1; /* failed (invalid call) */
context->hidden.windowsio.h = INVALID_HANDLE_VALUE; /* mark this as unusable */
context->hidden.windowsio.buffer.data = NULL;
context->hidden.windowsio.buffer.size = 0;
context->hidden.windowsio.buffer.left = 0;
/* "r" = reading, file must exist */
/* "w" = writing, truncate existing, file may not exist */
/* "r+"= reading or writing, file must exist */
/* "a" = writing, append file may not exist */
/* "a+"= append + read, file may not exist */
/* "w+" = read, write, truncate. file may not exist */
must_exist = (SDL_strchr(mode, 'r') != NULL) ? OPEN_EXISTING : 0;
truncate = (SDL_strchr(mode, 'w') != NULL) ? CREATE_ALWAYS : 0;
r_right = (SDL_strchr(mode, '+') != NULL
|| must_exist) ? GENERIC_READ : 0;
a_mode = (SDL_strchr(mode, 'a') != NULL) ? OPEN_ALWAYS : 0;
w_right = (a_mode || SDL_strchr(mode, '+')
|| truncate) ? GENERIC_WRITE : 0;
if (!r_right && !w_right) /* inconsistent mode */
return -1; /* failed (invalid call) */
context->hidden.windowsio.buffer.data =
(char *) SDL_malloc(READAHEAD_BUFFER_SIZE);
if (!context->hidden.windowsio.buffer.data) {
SDL_OutOfMemory();
return -1;
}
/* Do not open a dialog box if failure */
old_error_mode =
SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);
{
LPTSTR tstr = WIN_UTF8ToString(filename);
h = CreateFile(tstr, (w_right | r_right),
(w_right) ? 0 : FILE_SHARE_READ, NULL,
(must_exist | truncate | a_mode),
FILE_ATTRIBUTE_NORMAL, NULL);
SDL_free(tstr);
}
/* restore old behavior */
SetErrorMode(old_error_mode);
if (h == INVALID_HANDLE_VALUE) {
SDL_free(context->hidden.windowsio.buffer.data);
context->hidden.windowsio.buffer.data = NULL;
SDL_SetError("Couldn't open %s", filename);
return -2; /* failed (CreateFile) */
}
context->hidden.windowsio.h = h;
context->hidden.windowsio.append = a_mode ? SDL_TRUE : SDL_FALSE;
return 0; /* ok */
}
THREAD_ENTRY_DECLARE start_and_watch_server(THREAD_ENTRY_PARAM)
{
/**************************************
*
* s t a r t _ a n d _ w a t c h _ s e r v e r
*
**************************************
*
* Functional description
*
* This function is where the server process is created and
* the thread waits for this process to exit.
*
**************************************/
Firebird::ContextPoolHolder threadContext(getDefaultMemoryPool());
HANDLE procHandle = NULL;
bool done = true;
const UINT error_mode = SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX |
SEM_NOOPENFILEERRORBOX | SEM_NOALIGNMENTFAULTEXCEPT;
SC_HANDLE hScManager = 0, hService = 0;
// get the guardian startup information
const short option = Config::getGuardianOption();
char prefix_buffer[MAXPATHLEN];
GetModuleFileName(NULL, prefix_buffer, sizeof(prefix_buffer));
Firebird::PathName path = prefix_buffer;
path = path.substr(0, path.rfind(PathUtils::dir_sep) + 1) + FBSERVER;
path = "\"" + path + "\"";
Firebird::PathName prog_name = path + " -a -n";
// if the guardian is set to FOREVER then set the error mode
UINT old_error_mode = 0;
if (option == START_FOREVER)
old_error_mode = SetErrorMode(error_mode);
// Spawn the new process
do {
SERVICE_STATUS ServiceStatus;
char out_buf[1024];
BOOL success;
int error = 0;
if (service_flag)
{
if (hService)
{
while ((QueryServiceStatus(hService, &ServiceStatus) == TRUE) &&
(ServiceStatus.dwCurrentState != SERVICE_STOPPED))
{
Sleep(500);
}
}
procHandle = CreateMutex(NULL, FALSE, mutex_name->c_str());
// start as a service. If the service can not be found or
// fails to start, close the handle to the mutex and set
// success = FALSE
if (!hScManager)
hScManager = OpenSCManager(NULL, NULL, GENERIC_READ);
if (!hService)
{
hService = OpenService(hScManager, remote_name->c_str(),
GENERIC_READ | GENERIC_EXECUTE);
}
success = StartService(hService, 0, NULL);
if (success != TRUE)
error = GetLastError();
// if the server is already running, then inform it that it should
// open the guardian mutex so that it may be governed.
if (!error || error == ERROR_SERVICE_ALREADY_RUNNING)
{
// Make sure that it is actually ready to receive commands.
// If we were the one who started it, then it will need a few
// seconds to get ready.
while ((QueryServiceStatus(hService, &ServiceStatus) == TRUE) &&
(ServiceStatus.dwCurrentState != SERVICE_RUNNING))
{
Sleep(500);
}
ControlService(hService, SERVICE_CREATE_GUARDIAN_MUTEX, &ServiceStatus);
success = TRUE;
}
}
else
{
HWND hTmpWnd = FindWindow(szClassName, szWindowName);
if (hTmpWnd == NULL)
{
STARTUPINFO si;
SECURITY_ATTRIBUTES sa;
PROCESS_INFORMATION pi;
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = NULL;
sa.bInheritHandle = TRUE;
success = CreateProcess(NULL, const_cast<char*>(prog_name.c_str()),
&sa, NULL, FALSE, 0, NULL, NULL, &si, &pi);
if (success != TRUE)
error = GetLastError();
procHandle = pi.hProcess;
// TMN: 04 Aug 2000 - closed the handle that previously leaked.
CloseHandle(pi.hThread);
}
else
{
SendMessage(hTmpWnd, WM_COMMAND, (WPARAM) IDM_GUARDED, 0);
DWORD server_pid;
GetWindowThreadProcessId(hTmpWnd, &server_pid);
procHandle = OpenProcess(SYNCHRONIZE | PROCESS_QUERY_INFORMATION, FALSE, server_pid);
if (procHandle == NULL)
{
error = GetLastError();
success = FALSE;
}
else {
success = TRUE;
}
}
}
if (success != TRUE)
{
// error creating new process
char szMsgString[256];
LoadString(hInstance_gbl, IDS_CANT_START_THREAD, szMsgString, 256);
sprintf(out_buf, "%s : %s errno : %d", path.c_str(), szMsgString, error);
write_log(IDS_CANT_START_THREAD, out_buf);
if (service_flag)
{
SERVICE_STATUS status_info;
// wait a second to get the mutex handle (just in case) and
// then close it
WaitForSingleObject(procHandle, 1000);
CloseHandle(procHandle);
hService = OpenService(hScManager, remote_name->c_str(),
GENERIC_READ | GENERIC_EXECUTE);
ControlService(hService, SERVICE_CONTROL_STOP, &status_info);
CloseServiceHandle(hScManager);
CloseServiceHandle(hService);
CNTL_stop_service(); //service_name->c_str());
}
else
{
MessageBox(NULL, out_buf, NULL, MB_OK | MB_ICONSTOP);
PostMessage(hWndGbl, WM_CLOSE, 0, 0);
}
return 0;
}
else
{
char szMsgString[256];
LoadString(hInstance_gbl, IDS_STARTING_GUARD, szMsgString, 256);
sprintf(out_buf, "%s: %s\n", szMsgString, path.c_str());
write_log(IDS_LOG_START, out_buf);
}
// wait for process to terminate
DWORD exit_status;
if (service_flag)
{
while (WaitForSingleObject(procHandle, 500) == WAIT_OBJECT_0)
{
ReleaseMutex(procHandle);
Sleep(100);
}
const int ret_val = WaitForSingleObject(procHandle, INFINITE);
if (ret_val == WAIT_ABANDONED)
exit_status = CRASHED;
else if (ret_val == WAIT_OBJECT_0)
exit_status = NORMAL_EXIT;
CloseHandle(procHandle);
}
else
{
while (WaitForSingleObject(procHandle, INFINITE) == WAIT_FAILED)
;
GetExitCodeProcess(procHandle, &exit_status);
CloseHandle(procHandle);
}
if (exit_status != NORMAL_EXIT)
{
// check for startup error
if (exit_status == STARTUP_ERROR)
{
char szMsgString[256];
LoadString(hInstance_gbl, IDS_STARTUP_ERROR, szMsgString, 256);
sprintf(out_buf, "%s: %s (%lu)\n", path.c_str(), szMsgString, exit_status);
write_log(IDS_STARTUP_ERROR, out_buf);
done = true;
}
else
{
char szMsgString[256];
LoadString(hInstance_gbl, IDS_ABNORMAL_TERM, szMsgString, 256);
sprintf(out_buf, "%s: %s (%lu)\n", path.c_str(), szMsgString, exit_status);
write_log(IDS_LOG_TERM, out_buf);
// switch the icons if the server restarted
if (!service_flag)
PostMessage(hWndGbl, WM_SWITCHICONS, 0, 0);
if (option == START_FOREVER)
done = false;
}
}
else
{
// Normal shutdown - ie: via ibmgr - don't restart the server
char szMsgString[256];
LoadString(hInstance_gbl, IDS_NORMAL_TERM, szMsgString, 256);
sprintf(out_buf, "%s: %s\n", path.c_str(), szMsgString);
write_log(IDS_LOG_STOP, out_buf);
done = true;
}
if (option == START_ONCE)
done = true;
} while (!done);
// If on WINNT
if (service_flag)
{
CloseServiceHandle(hScManager);
CloseServiceHandle(hService);
CNTL_stop_service(); //(service_name->c_str());
}
else
PostMessage(hWndGbl, WM_CLOSE, 0, 0);
return 0;
}
/**
* Opens a shared library.
*
* @param[in] portLibrary The port library.
* @param[in] name path Null-terminated string containing the shared library.
* @param[out] descriptor Pointer to memory which is filled in with shared-library handle on success.
* @param[in] decorate Boolean value indicates whether name should be decorated
* if it contains path information and cannot be found.
*
* @return 0 on success, any other value on failure.
*
* @note contents of descriptor are undefined on failure.
*/
UDATA VMCALL
hysl_open_shared_library (struct HyPortLibrary * portLibrary, char *name,
UDATA * descriptor, BOOLEAN decorate)
{
HINSTANCE dllHandle;
UINT prevMode;
DWORD error;
UDATA notFound;
const char *errorMessage;
char errBuf[512];
char mangledName[1024];
char *openName = name;
if (decorate)
{
portLibrary->str_printf (portLibrary, mangledName, 1024, "%s.dll",
name);
openName = mangledName;
} /* TODO make windows not try to append .dll if we do not want it to */
prevMode = SetErrorMode (SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);
/* LoadLibrary will try appending .DLL if necessary */
dllHandle = LoadLibrary ((LPCSTR) openName);
if (dllHandle >= (HINSTANCE) HINSTANCE_ERROR)
{
*descriptor = (UDATA) dllHandle;
SetErrorMode (prevMode);
return 0;
}
error = GetLastError ();
notFound = (error == ERROR_MOD_NOT_FOUND || error == ERROR_DLL_NOT_FOUND);
if (notFound)
{
/* try to report a better error message. Check if the library can be found at all. */
dllHandle =
LoadLibraryEx ((LPCSTR) openName, NULL, DONT_RESOLVE_DLL_REFERENCES);
if (dllHandle)
{
if (sizeof (errBuf))
{
errorMessage = portLibrary->nls_lookup_message (portLibrary,
HYNLS_ERROR |
HYNLS_DO_NOT_APPEND_NEWLINE,
HYNLS_PORT_SL_UNABLE_TO_RESOLVE_REFERENCES,
NULL);
strncpy (errBuf, errorMessage, sizeof (errBuf));
errBuf[sizeof (errBuf) - 1] = '\0';
}
FreeLibrary (dllHandle);
SetErrorMode (prevMode);
return portLibrary->error_set_last_error_with_message (portLibrary,
HYPORT_SL_INVALID,
errBuf);
}
}
if (sizeof (errBuf))
{
LPWSTR message = NULL;
int nameSize = strlen (name);
LPWSTR filename =
(LPWSTR) portLibrary->mem_allocate_memory (portLibrary,
nameSize * 2 + 2);
if (filename == NULL)
{
errorMessage = portLibrary->nls_lookup_message (portLibrary,
HYNLS_ERROR |
HYNLS_DO_NOT_APPEND_NEWLINE,
HYNLS_PORT_SL_INTERNAL_ERROR,
NULL);
portLibrary->str_printf (portLibrary, errBuf, sizeof (errBuf),
errorMessage, error);
errBuf[sizeof (errBuf) - 1] = '\0';
SetErrorMode (prevMode);
return portLibrary->error_set_last_error_with_message (portLibrary,
notFound ?
HYPORT_SL_NOT_FOUND
:
HYPORT_SL_INVALID,
errBuf);
}
MultiByteToWideChar (CP_ACP, 0, (LPCTSTR) name, -1, filename,
nameSize * 2 + 2);
filename[nameSize] = '\0';
FormatMessageW (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ARGUMENT_ARRAY | FORMAT_MESSAGE_MAX_WIDTH_MASK, NULL, error, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT), /* Default language */
(LPWSTR) & message, 0, (va_list *) & filename);
portLibrary->mem_free_memory (portLibrary, filename);
if (message)
{
WideCharToMultiByte (CP_UTF8, 0, (LPCWSTR) message, -1, errBuf,
sizeof (errBuf) - 1, NULL, NULL);
LocalFree (message);
}
else
{
errorMessage = portLibrary->nls_lookup_message (portLibrary,
HYNLS_ERROR |
HYNLS_DO_NOT_APPEND_NEWLINE,
HYNLS_PORT_SL_INTERNAL_ERROR,
NULL);
portLibrary->str_printf (portLibrary, errBuf, sizeof (errBuf),
errorMessage, error);
}
errBuf[sizeof (errBuf) - 1] = '\0';
}
SetErrorMode (prevMode);
return portLibrary->error_set_last_error_with_message (portLibrary,
notFound ?
HYPORT_SL_NOT_FOUND :
HYPORT_SL_INVALID,
errBuf);
}
BOOL CFormatRecoveryDlg::OnInitDialog()
{
CDialogEx::OnInitDialog();
// Set the icon for this dialog. The framework does this automatically
// when the application's main window is not a dialog
SetIcon(m_hIcon, TRUE); // Set big icon
SetIcon(m_hIcon, FALSE); // Set small icon
// if(__argc != 2 || 0 != strcmp(__argv[1],"NJU"))
// SendMessage(WM_CLOSE,0,0);
SetErrorMode( SEM_NOGPFAULTERRORBOX | SEM_FAILCRITICALERRORS);
// TODO: Add extra initialization here
m_allext.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES);
m_searchext.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES);
m_result.SetExtendedStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES);
m_result.InsertColumn(0,"序号",LVCFMT_LEFT,100);
m_result.InsertColumn(1,"文件类型",LVCFMT_LEFT,200);
m_result.InsertColumn(2,"文件大小",LVCFMT_LEFT,100);
m_result.InsertColumn(3,"是否有效",LVCFMT_LEFT,100);
pthread=NULL;
recover=NULL;
CFormatRecovery null(NULL,m_result,m_progress);//利用空类，仅仅获取dll支持类型，其他什么都不做
CList<CString,CString&> mylist;
null.GetSupportFileExtension(mylist);
POSITION pos=mylist.GetHeadPosition();
for(int i=0;i<mylist.GetCount();i++)
{
m_allext.InsertItem(i,mylist.GetNext(pos));
}
//枚举分区
int bufsize=GetLogicalDriveStrings(0,NULL);
char* buf=new char[bufsize+1];
GetLogicalDriveStrings(bufsize,buf);
char* ptr=buf;
int index=0;
while(*ptr)
{
UINT type=GetDriveType(ptr);
if(type == DRIVE_REMOVABLE || type == DRIVE_FIXED || type == DRIVE_REMOTE)
{
char drive[16]="\\\\.\\";
strcat_s(drive,ptr);//得到设备符号
drive[strlen(drive)-1]='\0';
m_searcharea.AddString(drive);
}
ptr+=strlen(ptr)+1;
}
delete []buf;
//枚举硬盘
char drive[32];
int disknum=0;
while(TRUE)
{
sprintf_s(drive,"\\\\.\\PHYSICALDRIVE%d",disknum++);//对于硬盘以0x1000为单位搜不到文件，以后的版本需要改善，改为0x08?
HANDLE hDisk=CreateFile(drive,0,FILE_SHARE_READ | FILE_SHARE_WRITE,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
if(hDisk == INVALID_HANDLE_VALUE)//如果句柄无效说明已经枚举完毕
break;
CloseHandle(hDisk);
m_searcharea.AddString(drive);
}
return TRUE; // return TRUE unless you set the focus to a control
}
static char *
run_tests (char *logname)
{
int nr_of_files = 0, nr_of_tests = 0, i;
char *tempdir, *shorttempdir;
int logfile;
char *strres, *eol, *nextline;
DWORD strsize;
SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX);
if (!logname) {
logname = tempnam (0, "res");
if (!logname) report (R_FATAL, "Can't name logfile.");
}
report (R_OUT, logname);
logfile = open (logname, O_WRONLY | O_CREAT | O_EXCL | O_APPEND,
0666);
if (-1 == logfile) {
if (EEXIST == errno)
report (R_FATAL, "File %s already exists.", logname);
else report (R_FATAL, "Could not open logfile: %d", errno);
}
if (-1 == dup2 (logfile, 1))
report (R_FATAL, "Can't redirect stdout: %d", errno);
close (logfile);
tempdir = tempnam (0, "wct");
if (!tempdir)
report (R_FATAL, "Can't name temporary dir (check %%TEMP%%).");
shorttempdir = strdup (tempdir);
if (shorttempdir) { /* try stable path for ZoneAlarm */
strstr (shorttempdir, "wct")[3] = 0;
if (CreateDirectoryA (shorttempdir, NULL)) {
free (tempdir);
tempdir = shorttempdir;
} else free (shorttempdir);
}
if (tempdir != shorttempdir && !CreateDirectoryA (tempdir, NULL))
report (R_FATAL, "Could not create directory: %s", tempdir);
report (R_DIR, tempdir);
xprintf ("Version 3\n");
strres = extract_rcdata (WINE_BUILD, STRINGRES, &strsize);
xprintf ("Tests from build ");
if (strres) xprintf ("%.*s", strsize, strres);
else xprintf ("-\n");
strres = extract_rcdata (TESTS_URL, STRINGRES, &strsize);
xprintf ("Archive: ");
if (strres) xprintf ("%.*s", strsize, strres);
else xprintf ("-\n");
xprintf ("Tag: %s\n", tag);
xprintf ("Build info:\n");
strres = extract_rcdata (BUILD_INFO, STRINGRES, &strsize);
while (strres) {
eol = memchr (strres, '\n', strsize);
if (!eol) {
nextline = NULL;
eol = strres + strsize;
} else {
strsize -= eol - strres + 1;
nextline = strsize?eol+1:NULL;
if (eol > strres && *(eol-1) == '\r') eol--;
}
xprintf (" %.*s\n", eol-strres, strres);
strres = nextline;
}
xprintf ("Operating system version:\n");
print_version ();
xprintf ("Test output:\n" );
report (R_STATUS, "Counting tests");
if (!EnumResourceNames (NULL, MAKEINTRESOURCE(TESTRES),
EnumTestFileProc, (LPARAM)&nr_of_files))
report (R_FATAL, "Can't enumerate test files: %d",
GetLastError ());
wine_tests = xmalloc (nr_of_files * sizeof wine_tests[0]);
report (R_STATUS, "Extracting tests");
report (R_PROGRESS, 0, nr_of_files);
for (i = 0; i < nr_of_files; i++) {
get_subtests (tempdir, wine_tests+i, i);
nr_of_tests += wine_tests[i].subtest_count;
}
report (R_DELTA, 0, "Extracting: Done");
report (R_STATUS, "Running tests");
report (R_PROGRESS, 1, nr_of_tests);
for (i = 0; i < nr_of_files; i++) {
struct wine_test *test = wine_tests + i;
int j;
for (j = 0; j < test->subtest_count; j++) {
report (R_STEP, "Running: %s:%s", test->name,
test->subtests[j]);
run_test (test, test->subtests[j]);
}
}
report (R_DELTA, 0, "Running: Done");
report (R_STATUS, "Cleaning up");
close (1);
remove_dir (tempdir);
free (tempdir);
free (wine_tests);
return logname;
}
