2008-08-06 18:36:30 +00:00
|
|
|
// This file is part of BOINC.
|
2005-04-23 15:14:52 +00:00
|
|
|
// http://boinc.berkeley.edu
|
2008-08-06 18:36:30 +00:00
|
|
|
// Copyright (C) 2008 University of California
|
2005-04-23 15:14:52 +00:00
|
|
|
//
|
2008-08-06 18:36:30 +00:00
|
|
|
// BOINC is free software; you can redistribute it and/or modify it
|
|
|
|
// under the terms of the GNU Lesser General Public License
|
|
|
|
// as published by the Free Software Foundation,
|
|
|
|
// either version 3 of the License, or (at your option) any later version.
|
2005-04-23 15:14:52 +00:00
|
|
|
//
|
2008-08-06 18:36:30 +00:00
|
|
|
// BOINC is distributed in the hope that it will be useful,
|
2005-04-23 15:14:52 +00:00
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
|
|
// See the GNU Lesser General Public License for more details.
|
|
|
|
//
|
2008-08-06 18:36:30 +00:00
|
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
|
|
// along with BOINC. If not, see <http://www.gnu.org/licenses/>.
|
2005-04-23 15:14:52 +00:00
|
|
|
|
|
|
|
//
|
|
|
|
// mac_saver_module.cpp
|
|
|
|
// BOINC_Saver_Module
|
|
|
|
//
|
|
|
|
|
|
|
|
#include <Carbon/Carbon.h>
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <time.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/ipc.h>
|
|
|
|
#include <sys/shm.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <limits.h>
|
|
|
|
#include <sys/stat.h>
|
2007-09-19 09:41:23 +00:00
|
|
|
#include <sys/param.h> // for MAXPATHLEN
|
2005-04-23 15:14:52 +00:00
|
|
|
|
|
|
|
#include "gui_rpc_client.h"
|
2006-09-05 08:56:57 +00:00
|
|
|
#include "common_defs.h"
|
2007-08-31 14:23:07 +00:00
|
|
|
#include "util.h"
|
2007-10-05 13:28:11 +00:00
|
|
|
#include "Mac_Saver_Module.h"
|
2007-08-31 14:23:07 +00:00
|
|
|
#include "screensaver.h"
|
2008-09-05 02:47:10 +00:00
|
|
|
#include "diagnostics.h"
|
|
|
|
|
2005-04-23 15:14:52 +00:00
|
|
|
//#include <drivers/event_status_driver.h>
|
|
|
|
|
2005-04-27 12:59:53 +00:00
|
|
|
// Flags for testing & debugging
|
2009-04-02 10:25:16 +00:00
|
|
|
#define CREATE_LOG 0
|
2009-02-27 11:20:08 +00:00
|
|
|
#define USE_SPECIAL_LOG_FILE 0
|
2005-04-23 15:14:52 +00:00
|
|
|
|
2008-02-22 08:58:07 +00:00
|
|
|
#define TEXTLOGOFREQUENCY 60 /* Number of times per second to update moving logo with text */
|
2008-02-19 13:26:26 +00:00
|
|
|
#define NOTEXTLOGOFREQUENCY 4 /* Times per second to call animateOneFrame if no moving logo with text */
|
2008-02-26 01:53:36 +00:00
|
|
|
#define GFX_STARTING_MSG_DURATION 45 /* seconds to show ScreenSaverAppStartingMsg */
|
2009-03-03 12:08:49 +00:00
|
|
|
#define RPC_RETRY_INTERVAL 10 /* # of seconds between retries connecting to core client */
|
|
|
|
|
2005-04-23 15:14:52 +00:00
|
|
|
|
|
|
|
enum SaverState {
|
|
|
|
SaverState_Idle,
|
|
|
|
SaverState_LaunchingCoreClient,
|
|
|
|
SaverState_CoreClientRunning,
|
2007-03-01 02:46:13 +00:00
|
|
|
SaverState_RelaunchCoreClient,
|
2007-09-14 01:45:00 +00:00
|
|
|
SaverState_ConnectedToCoreClient,
|
2005-04-23 15:14:52 +00:00
|
|
|
|
|
|
|
SaverState_CantLaunchCoreClient,
|
2005-04-27 12:59:53 +00:00
|
|
|
SaverState_ControlPanelTestMode,
|
2005-04-23 15:14:52 +00:00
|
|
|
SaverState_UnrecoverableError
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2007-10-05 13:28:11 +00:00
|
|
|
static CScreensaver* gspScreensaver = NULL;
|
|
|
|
|
2005-04-23 15:14:52 +00:00
|
|
|
extern int gGoToBlank; // True if we are to blank the screen
|
|
|
|
extern int gBlankingTime; // Delay in minutes before blanking the screen
|
2007-09-19 09:41:23 +00:00
|
|
|
extern CFStringRef gPathToBundleResources;
|
2005-04-23 15:14:52 +00:00
|
|
|
|
|
|
|
static SaverState saverState = SaverState_Idle;
|
2007-10-05 13:28:11 +00:00
|
|
|
// int gQuitCounter = 0;
|
2008-02-27 07:50:58 +00:00
|
|
|
static long gSystemVersion = 0;
|
|
|
|
|
2005-04-27 12:59:53 +00:00
|
|
|
|
2006-01-20 11:44:30 +00:00
|
|
|
const char * CantLaunchCCMsg = "Unable to launch BOINC application.";
|
|
|
|
const char * LaunchingCCMsg = "Launching BOINC application.";
|
|
|
|
const char * ConnectingCCMsg = "Connecting to BOINC application.";
|
2009-02-20 11:49:49 +00:00
|
|
|
const char * ConnectedCCMsg = "Communicating with BOINC application.";
|
2006-01-20 11:44:30 +00:00
|
|
|
const char * BOINCUnrecoverableErrorMsg = "Sorry, an unrecoverable error occurred";
|
2009-02-27 11:20:08 +00:00
|
|
|
const char * BOINCTestModeMsg = "BOINC screensaver test: success.";
|
2008-02-27 03:21:46 +00:00
|
|
|
const char * ScreenSaverAppStartingMsg = "Starting screensaver graphics.\nPlease wait ...";
|
2009-02-27 11:20:08 +00:00
|
|
|
const char * CantLaunchDefaultGFXAppMsg = "Can't launch default screensaver module. Please reinstall BOINC";
|
|
|
|
const char * DefaultGFXAppCantRPCMsg = "Default screensaver module couldn't connect to BOINC application";
|
|
|
|
const char * DefaultGFXAppCrashedMsg = "Default screensaver module had an unrecoverable error";
|
2008-01-30 02:47:06 +00:00
|
|
|
|
2006-01-20 11:44:30 +00:00
|
|
|
//const char * BOINCExitedSaverMode = "BOINC is no longer in screensaver mode.";
|
2005-04-23 15:14:52 +00:00
|
|
|
|
2008-11-01 09:05:23 +00:00
|
|
|
// If there are multiple displays, this may get called
|
|
|
|
// multiple times (once for each display), so we need to guard
|
|
|
|
// against any problems that may cause.
|
|
|
|
int initBOINCSaver() {
|
2008-09-05 02:47:10 +00:00
|
|
|
#ifdef _DEBUG
|
|
|
|
char buf1[256], buf2[256];
|
|
|
|
strcpy(buf1, getenv("HOME"));
|
|
|
|
strcat(buf1, "/Documents/ss_stdout");
|
|
|
|
strcpy(buf2, getenv("HOME"));
|
|
|
|
strcat(buf2, "/Documents/ss_stderr");
|
|
|
|
|
|
|
|
diagnostics_init(BOINC_DIAG_REDIRECTSTDOUTOVERWRITE
|
|
|
|
| BOINC_DIAG_REDIRECTSTDERROVERWRITE
|
|
|
|
| BOINC_DIAG_TRACETOSTDOUT, buf1, buf2
|
|
|
|
);
|
|
|
|
#endif
|
|
|
|
|
2008-10-31 13:44:52 +00:00
|
|
|
if (gspScreensaver == NULL) {
|
|
|
|
gspScreensaver = new CScreensaver();
|
|
|
|
return gspScreensaver->Create();
|
|
|
|
}
|
|
|
|
return TEXTLOGOFREQUENCY;
|
2007-10-05 13:28:11 +00:00
|
|
|
}
|
|
|
|
|
2008-02-27 03:21:46 +00:00
|
|
|
int getSSMessage(char **theMessage, int* coveredFreq) {
|
2008-10-31 13:44:52 +00:00
|
|
|
if (gspScreensaver) {
|
|
|
|
return gspScreensaver->getSSMessage(theMessage, coveredFreq);
|
|
|
|
} else {
|
|
|
|
*theMessage = "";
|
|
|
|
*coveredFreq = 0;
|
|
|
|
return NOTEXTLOGOFREQUENCY;
|
|
|
|
}
|
2007-10-05 13:28:11 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2009-02-27 11:20:08 +00:00
|
|
|
void windowIsCovered() {
|
|
|
|
if (gspScreensaver) {
|
|
|
|
gspScreensaver->windowIsCovered();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-02-19 13:26:26 +00:00
|
|
|
void drawPreview(CGContextRef myContext) {
|
2008-10-31 13:44:52 +00:00
|
|
|
if (gspScreensaver) {
|
|
|
|
gspScreensaver->drawPreview(myContext);
|
|
|
|
}
|
2007-10-05 13:28:11 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
2008-11-01 09:05:23 +00:00
|
|
|
// If there are multiple displays, this may get called
|
|
|
|
// multiple times (once for each display), so we need to guard
|
|
|
|
// against any problems that may cause.
|
2007-10-05 13:28:11 +00:00
|
|
|
void closeBOINCSaver() {
|
2008-10-31 13:44:52 +00:00
|
|
|
if (gspScreensaver) {
|
|
|
|
gspScreensaver->ShutdownSaver();
|
|
|
|
delete gspScreensaver;
|
|
|
|
gspScreensaver = NULL;
|
|
|
|
}
|
2007-10-05 13:28:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
CScreensaver::CScreensaver() {
|
2008-02-27 07:50:58 +00:00
|
|
|
OSStatus err;
|
2007-10-05 13:28:11 +00:00
|
|
|
|
|
|
|
m_dwBlankScreen = 0;
|
|
|
|
m_dwBlankTime = 0;
|
|
|
|
m_bErrorMode = false;
|
|
|
|
m_hrError = 0;
|
2007-10-09 10:00:53 +00:00
|
|
|
// Display first status update after 5 seconds
|
2008-02-26 01:53:36 +00:00
|
|
|
m_iGraphicsStartingMsgCounter = 0;
|
2007-10-05 13:28:11 +00:00
|
|
|
saverState = SaverState_Idle;
|
|
|
|
m_wasAlreadyRunning = false;
|
|
|
|
m_CoreClientPID = nil;
|
2008-02-19 13:26:26 +00:00
|
|
|
setSSMessageText(0);
|
2007-10-05 13:28:11 +00:00
|
|
|
m_CurrentBannerMessage = 0;
|
|
|
|
m_QuitDataManagementProc = false;
|
|
|
|
m_BrandText = "BOINC";
|
|
|
|
|
|
|
|
m_hDataManagementThread = NULL;
|
|
|
|
m_hGraphicsApplication = NULL;
|
|
|
|
m_bResetCoreState = TRUE;
|
|
|
|
rpc = 0;
|
2009-02-20 11:49:49 +00:00
|
|
|
m_bConnected = false;
|
2008-02-27 07:50:58 +00:00
|
|
|
|
|
|
|
err = Gestalt(gestaltSystemVersion, &gSystemVersion);
|
|
|
|
if (err != noErr) {
|
|
|
|
gSystemVersion = 0;
|
|
|
|
}
|
2007-10-05 13:28:11 +00:00
|
|
|
}
|
2005-04-23 15:14:52 +00:00
|
|
|
|
2007-10-05 13:28:11 +00:00
|
|
|
|
|
|
|
int CScreensaver::Create() {
|
|
|
|
ProcessSerialNumber psn;
|
|
|
|
ProcessInfoRec pInfo;
|
|
|
|
OSStatus err;
|
|
|
|
|
2005-04-27 12:59:53 +00:00
|
|
|
// Ugly workaround for a problem with the System Preferences app
|
|
|
|
// For an unknown reason, when this screensaver is run using the
|
|
|
|
// Test button in the System Prefs Screensaver control panel, the
|
|
|
|
// control panel calls our stopAnimation function as soon as the
|
|
|
|
// science application opens a GLUT window. This problem does not
|
2007-03-01 02:46:13 +00:00
|
|
|
// occur when the screensaver is run normally (from the screensaver
|
2005-04-27 12:59:53 +00:00
|
|
|
// engine.) So we just display a message and don't access the core
|
|
|
|
// client.
|
2008-09-05 02:47:10 +00:00
|
|
|
// With V6 graphics when using gfx_switcher, the graphics application
|
|
|
|
// fails to run and stderr shows the message:
|
|
|
|
// "The process has forked and you cannot use this CoreFoundation
|
|
|
|
// functionality safely. You MUST exec()"
|
2005-04-27 12:59:53 +00:00
|
|
|
GetCurrentProcess(&psn);
|
|
|
|
memset(&pInfo, 0, sizeof(pInfo));
|
|
|
|
pInfo.processInfoLength = sizeof( ProcessInfoRec );
|
|
|
|
pInfo.processName = NULL;
|
|
|
|
err = GetProcessInformation(&psn, &pInfo);
|
|
|
|
if ( (err == noErr) && (pInfo.processSignature == 'sprf') ) {
|
|
|
|
saverState = SaverState_ControlPanelTestMode;
|
|
|
|
}
|
|
|
|
|
2005-04-23 15:14:52 +00:00
|
|
|
// If there are multiple displays, initBOINCSaver may get called
|
|
|
|
// multiple times (once for each display), so we need to guard
|
|
|
|
// against launching multiple instances of the core client
|
|
|
|
if (saverState == SaverState_Idle) {
|
2007-10-05 13:28:11 +00:00
|
|
|
// Calculate the estimated blank time by adding the starting
|
|
|
|
// time and and the user-specified time which is in minutes
|
|
|
|
m_dwBlankScreen = gGoToBlank;
|
|
|
|
if (gGoToBlank)
|
|
|
|
m_dwBlankTime = time(0) + (gBlankingTime * 60);
|
|
|
|
else
|
|
|
|
m_dwBlankTime = 0;
|
|
|
|
|
|
|
|
CFStringGetCString(gPathToBundleResources, m_gfx_Switcher_Path, sizeof(m_gfx_Switcher_Path), kCFStringEncodingMacRoman);
|
|
|
|
strlcat(m_gfx_Switcher_Path, "/gfx_switcher", sizeof(m_gfx_Switcher_Path));
|
2007-09-19 09:41:23 +00:00
|
|
|
|
2005-04-23 15:14:52 +00:00
|
|
|
err = initBOINCApp();
|
|
|
|
|
2008-02-19 13:26:26 +00:00
|
|
|
CGDisplayHideCursor(kCGNullDirectDisplay);
|
|
|
|
|
2005-04-23 15:14:52 +00:00
|
|
|
if (saverState == SaverState_LaunchingCoreClient)
|
|
|
|
{
|
2007-10-05 13:28:11 +00:00
|
|
|
SetError(FALSE, 0);
|
|
|
|
m_QuitDataManagementProc = false;
|
2008-02-19 13:26:26 +00:00
|
|
|
if (rpc == NULL) {
|
2005-04-23 15:14:52 +00:00
|
|
|
rpc = new RPC_CLIENT;
|
2008-02-19 13:26:26 +00:00
|
|
|
}
|
2005-04-23 15:14:52 +00:00
|
|
|
}
|
|
|
|
}
|
2008-02-19 13:26:26 +00:00
|
|
|
return TEXTLOGOFREQUENCY;
|
2005-04-23 15:14:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-10-05 13:28:11 +00:00
|
|
|
OSStatus CScreensaver::initBOINCApp() {
|
2006-10-28 11:18:09 +00:00
|
|
|
char boincPath[2048];
|
2005-04-23 15:14:52 +00:00
|
|
|
pid_t myPid;
|
|
|
|
int status;
|
|
|
|
OSStatus err;
|
2007-02-28 08:34:54 +00:00
|
|
|
static int retryCount = 0;
|
2007-10-05 13:28:11 +00:00
|
|
|
long brandId = 0;
|
2007-02-28 08:34:54 +00:00
|
|
|
|
2005-04-23 15:14:52 +00:00
|
|
|
saverState = SaverState_CantLaunchCoreClient;
|
|
|
|
|
2007-10-05 13:28:11 +00:00
|
|
|
brandId = GetBrandID();
|
|
|
|
switch(brandId) {
|
|
|
|
case 1:
|
|
|
|
m_BrandText = "GridRepublic";
|
2008-02-19 13:26:26 +00:00
|
|
|
break;
|
2009-06-10 10:49:46 +00:00
|
|
|
case 2:
|
2009-06-11 00:36:15 +00:00
|
|
|
m_BrandText = "Progress Thru Processors";
|
2009-06-10 10:49:46 +00:00
|
|
|
break;
|
2007-10-05 13:28:11 +00:00
|
|
|
default:
|
|
|
|
m_BrandText = "BOINC";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2007-10-26 10:00:00 +00:00
|
|
|
m_CoreClientPID = FindProcessPID("boinc", 0);
|
|
|
|
if (m_CoreClientPID) {
|
2009-02-20 11:49:49 +00:00
|
|
|
m_wasAlreadyRunning = true;
|
2007-10-26 10:00:00 +00:00
|
|
|
saverState = SaverState_LaunchingCoreClient;
|
|
|
|
return noErr;
|
|
|
|
}
|
|
|
|
|
|
|
|
m_wasAlreadyRunning = false;
|
|
|
|
|
|
|
|
if (++retryCount > 3) // Limit to 3 relaunches to prevent thrashing
|
|
|
|
return -1;
|
|
|
|
|
2005-04-23 15:14:52 +00:00
|
|
|
err = GetpathToBOINCManagerApp(boincPath, sizeof(boincPath));
|
2006-01-20 14:04:06 +00:00
|
|
|
if (err) { // If we couldn't find BOINCManager.app, try default path
|
|
|
|
strcpy(boincPath, "/Applications/");
|
2007-10-05 13:28:11 +00:00
|
|
|
if (brandId)
|
|
|
|
strcat(boincPath, m_BrandText);
|
2006-01-20 14:04:06 +00:00
|
|
|
else
|
|
|
|
strcat(boincPath, "BOINCManager");
|
|
|
|
strcat(boincPath, ".app");
|
|
|
|
}
|
|
|
|
|
2005-04-23 15:14:52 +00:00
|
|
|
strcat(boincPath, "/Contents/Resources/boinc");
|
|
|
|
|
|
|
|
if ( (myPid = fork()) < 0)
|
|
|
|
return -1;
|
|
|
|
else if (myPid == 0) // child
|
|
|
|
{
|
2006-10-28 11:18:09 +00:00
|
|
|
// We don't customize BOINC Data directory name for branding
|
2005-04-27 12:59:53 +00:00
|
|
|
#if 0 // Code for separate data in each user's private directory
|
2006-10-28 11:18:09 +00:00
|
|
|
char buf[256];
|
2005-04-23 15:14:52 +00:00
|
|
|
strcpy(buf, getenv("HOME"));
|
2006-10-28 11:18:09 +00:00
|
|
|
strcat(buf, "/Library/Application Support/BOINC Data");
|
|
|
|
status = chdir(buf);
|
2005-04-27 12:59:53 +00:00
|
|
|
#else // All users share the same data
|
2006-10-28 11:18:09 +00:00
|
|
|
status = chdir("/Library/Application Support/BOINC Data");
|
2005-04-27 12:59:53 +00:00
|
|
|
#endif
|
2005-04-23 15:14:52 +00:00
|
|
|
if (status) {
|
|
|
|
perror("chdir");
|
2005-10-05 20:39:00 +00:00
|
|
|
fflush(NULL);
|
2005-04-23 15:14:52 +00:00
|
|
|
_exit(status);
|
|
|
|
}
|
|
|
|
|
2007-02-28 08:34:54 +00:00
|
|
|
status = execl(boincPath, boincPath, "-redirectio", "-saver", (char *) 0);
|
2005-10-05 20:39:00 +00:00
|
|
|
fflush(NULL);
|
2005-04-23 15:14:52 +00:00
|
|
|
_exit(127); // execl error (execl should never return)
|
|
|
|
} else {
|
2007-10-05 13:28:11 +00:00
|
|
|
m_CoreClientPID = myPid; // make this available globally
|
2005-04-23 15:14:52 +00:00
|
|
|
saverState = SaverState_LaunchingCoreClient;
|
|
|
|
}
|
|
|
|
|
|
|
|
return noErr;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Returns new desired Animation Frequency (per second) or 0 for no change
|
2008-02-27 03:21:46 +00:00
|
|
|
int CScreensaver::getSSMessage(char **theMessage, int* coveredFreq) {
|
2008-02-19 13:26:26 +00:00
|
|
|
int newFrequency = TEXTLOGOFREQUENCY;
|
2008-02-27 03:21:46 +00:00
|
|
|
*coveredFreq = 0;
|
2005-04-23 15:14:52 +00:00
|
|
|
pid_t myPid;
|
|
|
|
OSStatus err;
|
|
|
|
|
|
|
|
switch (saverState) {
|
2007-03-01 02:46:13 +00:00
|
|
|
case SaverState_RelaunchCoreClient:
|
|
|
|
err = initBOINCApp();
|
|
|
|
break;
|
|
|
|
|
2005-04-23 15:14:52 +00:00
|
|
|
case SaverState_LaunchingCoreClient:
|
2007-10-05 13:28:11 +00:00
|
|
|
if (m_wasAlreadyRunning)
|
2008-02-19 13:26:26 +00:00
|
|
|
setSSMessageText(ConnectingCCMsg);
|
2005-04-26 15:51:40 +00:00
|
|
|
else
|
2008-02-19 13:26:26 +00:00
|
|
|
setSSMessageText(LaunchingCCMsg);
|
2005-04-26 15:51:40 +00:00
|
|
|
|
2007-10-05 13:28:11 +00:00
|
|
|
myPid = FindProcessPID(NULL, m_CoreClientPID);
|
2009-02-20 11:49:49 +00:00
|
|
|
if (myPid) {
|
2005-04-23 15:14:52 +00:00
|
|
|
saverState = SaverState_CoreClientRunning;
|
2009-02-20 11:49:49 +00:00
|
|
|
if (!rpc->init(NULL)) { // Initialize communications with Core Client
|
|
|
|
m_bConnected = true;
|
|
|
|
}
|
2005-04-23 15:14:52 +00:00
|
|
|
|
2009-02-20 11:49:49 +00:00
|
|
|
// Set up a separate thread for communicating with Core Client
|
|
|
|
// and running screensaver graphics
|
2007-10-05 13:28:11 +00:00
|
|
|
CreateDataManagementThread();
|
2007-03-01 02:46:13 +00:00
|
|
|
// ToDo: Add a timeout after which we display error message
|
|
|
|
} else
|
|
|
|
// Take care of the possible race condition where the Core Client was in the
|
|
|
|
// process of shutting down just as ScreenSaver started, so initBOINCApp()
|
|
|
|
// found it already running but now it has shut down.
|
2008-09-05 02:47:10 +00:00
|
|
|
if (m_wasAlreadyRunning) { // If we launched it, then just wait for it to start
|
2007-03-01 02:46:13 +00:00
|
|
|
saverState = SaverState_RelaunchCoreClient;
|
2008-09-05 02:47:10 +00:00
|
|
|
}
|
2007-03-01 02:46:13 +00:00
|
|
|
break;
|
2005-04-23 15:14:52 +00:00
|
|
|
|
|
|
|
case SaverState_CoreClientRunning:
|
2007-10-05 13:28:11 +00:00
|
|
|
// RPC called in DataManagementProc()
|
2008-02-19 13:26:26 +00:00
|
|
|
setSSMessageText(ConnectingCCMsg);
|
2007-10-05 13:28:11 +00:00
|
|
|
if (! m_bResetCoreState) {
|
|
|
|
saverState = SaverState_ConnectedToCoreClient;
|
|
|
|
}
|
2005-04-23 15:14:52 +00:00
|
|
|
break;
|
|
|
|
|
2007-09-14 01:45:00 +00:00
|
|
|
case SaverState_ConnectedToCoreClient:
|
2007-10-05 13:28:11 +00:00
|
|
|
switch (m_hrError) {
|
2005-04-23 15:14:52 +00:00
|
|
|
case 0:
|
2009-02-20 11:49:49 +00:00
|
|
|
setSSMessageText(ConnectedCCMsg);
|
2007-10-05 13:28:11 +00:00
|
|
|
break; // No status response yet from DataManagementProc
|
|
|
|
case SCRAPPERR_SCREENSAVERBLANKED:
|
2008-02-19 13:26:26 +00:00
|
|
|
setSSMessageText(0); // No text message
|
2005-04-23 15:14:52 +00:00
|
|
|
break;
|
2009-02-27 11:20:08 +00:00
|
|
|
#if 0 // Not currently used
|
2007-10-05 13:28:11 +00:00
|
|
|
case SCRAPPERR_QUITSCREENSAVERREQUESTED:
|
2008-02-19 13:26:26 +00:00
|
|
|
// setSSMessageText(BOINCExitedSaverMode);
|
2007-10-05 13:28:11 +00:00
|
|
|
// Wait 1 second to allow ScreenSaver engine to close us down
|
2008-02-19 13:26:26 +00:00
|
|
|
if (++gQuitCounter > (m_MessageText[0] ? TEXTLOGOFREQUENCY : NOTEXTLOGOFREQUENCY)) {
|
2005-05-25 11:18:05 +00:00
|
|
|
closeBOINCSaver();
|
|
|
|
KillScreenSaver(); // Stop the ScreenSaver Engine
|
|
|
|
}
|
2005-04-23 15:14:52 +00:00
|
|
|
break;
|
2007-08-31 14:23:07 +00:00
|
|
|
#endif
|
2009-02-27 11:20:08 +00:00
|
|
|
case SCRAPPERR_CANTLAUNCHDEFAULTGFXAPP:
|
|
|
|
setSSMessageText(CantLaunchDefaultGFXAppMsg);
|
|
|
|
break;
|
|
|
|
case SCRAPPERR_DEFAULTGFXAPPCANTCONNECT:
|
|
|
|
setSSMessageText(DefaultGFXAppCantRPCMsg);
|
|
|
|
break;
|
|
|
|
case SCRAPPERR_DEFAULTGFXAPPCRASHED:
|
|
|
|
setSSMessageText(DefaultGFXAppCrashedMsg);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
// m_bErrorMode is TRUE if we should display moving logo (no graphics app is running)
|
|
|
|
// m_bErrorMode is FALSE if a graphics app was launched and has not exit
|
|
|
|
if (! m_bErrorMode) {
|
|
|
|
// NOTE: My tests seem to confirm that the top window is always the first
|
|
|
|
// window returned by NSWindowList under OS 10.5 and the second window
|
|
|
|
// returned by NSWindowList under OS 10.3.9 and OS 10.4. However, Apple's
|
|
|
|
// documentation is unclear whether we can depend on this. So I have
|
|
|
|
// added some safety by doing two things:
|
|
|
|
// [1] Only use the NSWindowList test when we have started project or default
|
|
|
|
// graphics.
|
|
|
|
// [2] Assume that our window is covered 45 seconds after starting project
|
|
|
|
// graphics even if the NSWindowList test did not indicate that is so.
|
|
|
|
//
|
|
|
|
// The -animateOneFrame method in Mac_SaverModuleView.m does the NSWindowList test
|
|
|
|
// only if we return a non-zero value for coveredFreq.
|
|
|
|
//
|
|
|
|
// Tell the calling routine to set the frame rate to NOTEXTLOGOFREQUENCY if
|
|
|
|
// NSWindowList indicates that science app graphics window has covered our window.
|
|
|
|
*coveredFreq = NOTEXTLOGOFREQUENCY;
|
|
|
|
|
|
|
|
if (m_iGraphicsStartingMsgCounter > 0) {
|
|
|
|
// Show ScreenSaverAppStartingMsg for GFX_STARTING_MSG_DURATION seconds or until
|
|
|
|
// NSWindowList indicates that science app graphics window has covered our window
|
|
|
|
setSSMessageText(ScreenSaverAppStartingMsg);
|
|
|
|
m_iGraphicsStartingMsgCounter--;
|
|
|
|
} else {
|
|
|
|
// Don't waste CPU cycles when the science app is drawing over our window
|
|
|
|
setSSMessageText(0); // No text message
|
|
|
|
}
|
|
|
|
} // End if (! m_bErrorMode)
|
|
|
|
break; // End default case of switch (m_hrError)
|
|
|
|
|
2007-10-05 13:28:11 +00:00
|
|
|
} // end switch (m_hrError)
|
2009-02-27 11:20:08 +00:00
|
|
|
break; // End case SaverState_ConnectedToCoreClient of switch (saverState)
|
2005-04-23 15:14:52 +00:00
|
|
|
|
2005-04-27 12:59:53 +00:00
|
|
|
case SaverState_ControlPanelTestMode:
|
2009-02-27 11:20:08 +00:00
|
|
|
setSSMessageText(BOINCTestModeMsg);
|
2005-04-27 12:59:53 +00:00
|
|
|
break;
|
|
|
|
|
2005-04-23 15:14:52 +00:00
|
|
|
case SaverState_UnrecoverableError:
|
2008-02-19 13:26:26 +00:00
|
|
|
setSSMessageText(BOINCUnrecoverableErrorMsg);
|
2005-04-23 15:14:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SaverState_CantLaunchCoreClient:
|
2008-02-19 13:26:26 +00:00
|
|
|
setSSMessageText(CantLaunchCCMsg);
|
2009-02-20 11:49:49 +00:00
|
|
|
// Set up a separate thread for running screensaver graphics
|
|
|
|
// even if we can't communicate with core client
|
|
|
|
CreateDataManagementThread();
|
2005-04-23 15:14:52 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SaverState_Idle:
|
|
|
|
break; // Should never get here; fixes compiler warning
|
|
|
|
} // end switch (saverState)
|
|
|
|
|
2009-02-27 11:20:08 +00:00
|
|
|
|
2008-02-19 13:26:26 +00:00
|
|
|
if (m_MessageText[0]) {
|
|
|
|
newFrequency = TEXTLOGOFREQUENCY;
|
2008-02-27 03:21:46 +00:00
|
|
|
} else {
|
2008-02-19 13:26:26 +00:00
|
|
|
newFrequency = NOTEXTLOGOFREQUENCY;
|
2008-02-27 03:21:46 +00:00
|
|
|
}
|
2005-04-23 15:14:52 +00:00
|
|
|
|
2008-02-19 13:26:26 +00:00
|
|
|
*theMessage = m_MessageText;
|
2005-04-23 15:14:52 +00:00
|
|
|
return newFrequency;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-02-27 11:20:08 +00:00
|
|
|
void CScreensaver::windowIsCovered() {
|
|
|
|
m_iGraphicsStartingMsgCounter = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-02-19 13:26:26 +00:00
|
|
|
void CScreensaver::drawPreview(CGContextRef myContext) {
|
|
|
|
// For possible future use
|
2005-04-23 15:14:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-10-05 13:28:11 +00:00
|
|
|
void CScreensaver::ShutdownSaver() {
|
2007-10-09 10:00:53 +00:00
|
|
|
DestroyDataManagementThread();
|
2005-04-23 15:14:52 +00:00
|
|
|
|
2007-02-28 16:10:17 +00:00
|
|
|
if (rpc) {
|
2007-09-11 23:21:58 +00:00
|
|
|
#if 0 // OS X calls closeBOINCSaver() when energy saver puts display
|
2007-09-12 00:39:41 +00:00
|
|
|
// to sleep, but we want to keep crunching. So don't kill it.
|
2007-02-28 08:34:54 +00:00
|
|
|
// Code in core client now quits on user activity if screen
|
|
|
|
// saver launched it (2/28/07).
|
2007-09-11 23:21:58 +00:00
|
|
|
// Also, under sandbox security, screensaver doesn't have access
|
|
|
|
// to rpc password in gui_rpc_auth.cfg file, so core client won't
|
|
|
|
// accept rpc->quit from screensaver.
|
2007-10-05 13:28:11 +00:00
|
|
|
if (m_CoreClientPID && (!m_wasAlreadyRunning)) {
|
2007-02-28 16:10:17 +00:00
|
|
|
rpc->quit(); // Kill core client if we launched it
|
2005-04-23 15:14:52 +00:00
|
|
|
}
|
2007-02-28 08:34:54 +00:00
|
|
|
#endif
|
2007-02-28 16:10:17 +00:00
|
|
|
delete rpc;
|
2007-09-21 11:46:31 +00:00
|
|
|
rpc = NULL;
|
2007-02-28 16:10:17 +00:00
|
|
|
}
|
|
|
|
|
2008-02-19 13:26:26 +00:00
|
|
|
setSSMessageText(0);
|
2007-02-28 16:10:17 +00:00
|
|
|
|
2007-10-05 13:28:11 +00:00
|
|
|
m_CoreClientPID = 0;
|
|
|
|
// gQuitCounter = 0;
|
|
|
|
m_wasAlreadyRunning = false;
|
|
|
|
m_QuitDataManagementProc = false;
|
2007-02-28 08:34:54 +00:00
|
|
|
saverState = SaverState_Idle;
|
2005-04-23 15:14:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-10-05 13:28:11 +00:00
|
|
|
// This function forwards to DataManagementProc, which has access to the
|
|
|
|
// "this" pointer.
|
|
|
|
//
|
|
|
|
void * CScreensaver::DataManagementProcStub(void* param) {
|
|
|
|
return gspScreensaver->DataManagementProc();
|
2005-04-23 15:14:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-10-05 13:28:11 +00:00
|
|
|
void CScreensaver::HandleRPCError() {
|
2009-02-20 11:49:49 +00:00
|
|
|
static time_t last_RPC_retry = 0;
|
2009-03-03 12:08:49 +00:00
|
|
|
time_t now = time(0);
|
|
|
|
|
2007-03-01 02:46:13 +00:00
|
|
|
// Attempt to restart BOINC Client if needed, reinitialize the RPC client and state
|
|
|
|
rpc->close();
|
2009-02-20 11:49:49 +00:00
|
|
|
m_bConnected = false;
|
2007-03-01 02:46:13 +00:00
|
|
|
|
2009-02-20 11:49:49 +00:00
|
|
|
if (saverState == SaverState_CantLaunchCoreClient) {
|
2009-03-03 12:08:49 +00:00
|
|
|
if ((now - last_RPC_retry) < RPC_RETRY_INTERVAL) {
|
2009-02-20 11:49:49 +00:00
|
|
|
return;
|
|
|
|
}
|
2009-03-03 12:08:49 +00:00
|
|
|
last_RPC_retry = now;
|
2009-02-20 11:49:49 +00:00
|
|
|
} else {
|
|
|
|
// There is a possible race condition where the Core Client was in the
|
|
|
|
// process of shutting down just as ScreenSaver started, so initBOINCApp()
|
|
|
|
// found it already running but now it has shut down. This code takes
|
|
|
|
// care of that and other situations where the Core Client quits unexpectedy.
|
|
|
|
// Code in initBOINC_App() limits # launch retries to 3 to prevent thrashing.
|
|
|
|
if (FindProcessPID("boinc", 0) == 0) {
|
|
|
|
saverState = SaverState_RelaunchCoreClient;
|
|
|
|
m_bResetCoreState = true;
|
|
|
|
}
|
|
|
|
}
|
2009-03-03 12:08:49 +00:00
|
|
|
|
|
|
|
// If Core Client is hung, it might cause RPCs to hang, preventing us from
|
|
|
|
// shutting down the Data Management Thread, so don't reinitialize the RPC
|
|
|
|
// client if we have told the Data Management Thread to exit.
|
|
|
|
if (m_QuitDataManagementProc) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-02-20 11:49:49 +00:00
|
|
|
// Otherwise just reinitialize the RPC client and state and keep trying
|
|
|
|
if (!rpc->init(NULL)) {
|
|
|
|
m_bConnected = true;
|
|
|
|
}
|
2007-03-01 02:46:13 +00:00
|
|
|
// Error message after timeout?
|
|
|
|
}
|
|
|
|
|
2007-10-05 13:28:11 +00:00
|
|
|
bool CScreensaver::CreateDataManagementThread() {
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
if (m_hDataManagementThread == NULL) {
|
|
|
|
retval = pthread_create(&m_hDataManagementThread, NULL, DataManagementProcStub, 0);
|
|
|
|
if (retval) {
|
|
|
|
saverState = SaverState_UnrecoverableError;
|
|
|
|
return false;
|
|
|
|
}
|
2009-03-03 12:08:49 +00:00
|
|
|
pthread_detach(m_hDataManagementThread);
|
2007-10-05 13:28:11 +00:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-10-09 10:00:53 +00:00
|
|
|
bool CScreensaver::DestroyDataManagementThread() {
|
2009-03-03 12:08:49 +00:00
|
|
|
int i;
|
|
|
|
|
2007-10-05 13:28:11 +00:00
|
|
|
m_QuitDataManagementProc = true; // Tell DataManagementProc thread to exit
|
2009-03-03 12:08:49 +00:00
|
|
|
|
|
|
|
for (i=0; i<10; i++) { // Wait up to 1 second for DataManagementProc thread to exit
|
|
|
|
if (m_hDataManagementThread == NULL) return true;
|
|
|
|
boinc_sleep(0.1);
|
|
|
|
}
|
|
|
|
rpc->close(); // In case DataManagementProc is hung waiting for RPC
|
|
|
|
m_hDataManagementThread = NULL; // Don't delay more if this routine is called again.
|
|
|
|
if (m_hGraphicsApplication) {
|
|
|
|
terminate_screensaver(m_hGraphicsApplication, NULL);
|
|
|
|
m_hGraphicsApplication = 0;
|
2007-10-05 13:28:11 +00:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2007-03-01 02:46:13 +00:00
|
|
|
|
2009-02-27 11:20:08 +00:00
|
|
|
//
|
2007-10-09 10:00:53 +00:00
|
|
|
bool CScreensaver::SetError(bool bErrorMode, unsigned int hrError) {
|
2009-02-27 11:20:08 +00:00
|
|
|
// bErrorMode is TRUE if we should display moving logo (no graphics app is running)
|
|
|
|
// bErrorMode is FALSE if a graphics app was launched and has not exit
|
2007-10-05 13:28:11 +00:00
|
|
|
m_bErrorMode = bErrorMode;
|
|
|
|
m_hrError = hrError;
|
2008-02-26 01:53:36 +00:00
|
|
|
|
2009-02-27 11:20:08 +00:00
|
|
|
if (bErrorMode) {
|
|
|
|
// Reset our timer for showing ScreenSaverAppStartingMsg to
|
|
|
|
// GFX_STARTING_MSG_DURATION seconds
|
2008-02-26 01:53:36 +00:00
|
|
|
m_iGraphicsStartingMsgCounter = GFX_STARTING_MSG_DURATION * TEXTLOGOFREQUENCY;
|
|
|
|
}
|
2007-10-05 13:28:11 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2008-02-19 13:26:26 +00:00
|
|
|
void CScreensaver::setSSMessageText(const char * msg) {
|
2005-04-27 12:59:53 +00:00
|
|
|
if (msg == 0)
|
2008-02-19 13:26:26 +00:00
|
|
|
m_MessageText[0] = 0;
|
2005-04-27 12:59:53 +00:00
|
|
|
|
2008-02-14 12:26:13 +00:00
|
|
|
if (m_CurrentBannerMessage != msg)
|
2008-02-19 13:26:26 +00:00
|
|
|
updateSSMessageText((char *)msg);
|
2005-04-27 12:59:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-02-19 13:26:26 +00:00
|
|
|
void CScreensaver::updateSSMessageText(char *msg) {
|
2006-01-20 11:44:30 +00:00
|
|
|
char *p, *s;
|
2005-04-23 15:14:52 +00:00
|
|
|
|
2008-02-14 12:26:13 +00:00
|
|
|
m_CurrentBannerMessage = msg;
|
2005-04-27 12:59:53 +00:00
|
|
|
|
|
|
|
if (msg) {
|
2006-01-20 11:44:30 +00:00
|
|
|
s = msg;
|
2008-02-19 13:26:26 +00:00
|
|
|
m_MessageText[0] = '\0';
|
2006-01-20 11:44:30 +00:00
|
|
|
do {
|
|
|
|
p = strstr(s, "BOINC");
|
|
|
|
if (p == NULL) {
|
2008-02-19 13:26:26 +00:00
|
|
|
strcat(m_MessageText, s);
|
2006-01-20 11:44:30 +00:00
|
|
|
} else {
|
2008-02-19 13:26:26 +00:00
|
|
|
strncat(m_MessageText, s, p - s);
|
|
|
|
strcat(m_MessageText, m_BrandText);
|
2006-01-20 11:44:30 +00:00
|
|
|
s = p + 5; // s = p + strlen("BOINC");
|
|
|
|
}
|
|
|
|
} while (p);
|
|
|
|
|
2005-04-27 12:59:53 +00:00
|
|
|
}
|
2005-04-23 15:14:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-10-05 13:28:11 +00:00
|
|
|
int CScreensaver::GetBrandID()
|
2006-01-20 11:44:30 +00:00
|
|
|
{
|
|
|
|
char buf[1024];
|
|
|
|
long iBrandId;
|
|
|
|
OSErr err;
|
|
|
|
|
|
|
|
iBrandId = 0; // Default value
|
|
|
|
|
|
|
|
err = GetpathToBOINCManagerApp(buf, sizeof(buf));
|
2006-10-28 11:18:09 +00:00
|
|
|
if (err) {
|
|
|
|
// If we couldn't find our application bundle, look in BOINC Data Directory
|
|
|
|
// (the installer put a copy there for us)
|
|
|
|
strcpy(buf, "/Library/Application Support/BOINC Data/Branding");
|
|
|
|
} else
|
|
|
|
strcat(buf, "/Contents/Resources/Branding");
|
2006-01-20 14:04:06 +00:00
|
|
|
|
|
|
|
FILE *f = fopen(buf, "r");
|
|
|
|
if (f) {
|
|
|
|
fscanf(f, "BrandId=%ld\n", &iBrandId);
|
|
|
|
fclose(f);
|
2006-01-20 11:44:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return iBrandId;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-10-05 13:28:11 +00:00
|
|
|
char * CScreensaver::PersistentFGets(char *buf, size_t buflen, FILE *f) {
|
2005-09-20 00:45:00 +00:00
|
|
|
char *p = buf;
|
|
|
|
size_t len = buflen;
|
|
|
|
size_t datalen = 0;
|
|
|
|
|
|
|
|
*buf = '\0';
|
|
|
|
while (datalen < (buflen - 1)) {
|
|
|
|
fgets(p, len, f);
|
|
|
|
if (feof(f)) break;
|
|
|
|
if (ferror(f) && (errno != EINTR)) break;
|
|
|
|
if (strchr(buf, '\n')) break;
|
|
|
|
datalen = strlen(buf);
|
|
|
|
p = buf + datalen;
|
|
|
|
len -= datalen;
|
|
|
|
}
|
|
|
|
return (buf[0] ? buf : NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-10-05 13:28:11 +00:00
|
|
|
pid_t CScreensaver::FindProcessPID(char* name, pid_t thePID)
|
2005-04-23 15:14:52 +00:00
|
|
|
{
|
|
|
|
FILE *f;
|
|
|
|
char buf[1024];
|
2005-04-27 12:59:53 +00:00
|
|
|
size_t n = 0;
|
2007-09-19 09:41:23 +00:00
|
|
|
pid_t aPID;
|
2005-04-23 15:14:52 +00:00
|
|
|
|
2007-10-03 06:16:58 +00:00
|
|
|
if (name != NULL) // Search ny name
|
2005-04-23 15:14:52 +00:00
|
|
|
n = strlen(name);
|
|
|
|
|
2007-10-03 06:16:58 +00:00
|
|
|
f = popen("ps -a -x -c -o command,pid", "r");
|
2005-04-23 15:14:52 +00:00
|
|
|
if (f == NULL)
|
|
|
|
return 0;
|
|
|
|
|
2005-09-20 00:45:00 +00:00
|
|
|
while (PersistentFGets(buf, sizeof(buf), f))
|
2005-04-23 15:14:52 +00:00
|
|
|
{
|
2007-10-03 06:16:58 +00:00
|
|
|
if (name != NULL) { // Search ny name
|
|
|
|
if (strncmp(buf, name, n) == 0)
|
2005-04-23 15:14:52 +00:00
|
|
|
{
|
2007-10-03 06:16:58 +00:00
|
|
|
aPID = atol(buf+16);
|
2005-04-23 15:14:52 +00:00
|
|
|
pclose(f);
|
|
|
|
return aPID;
|
|
|
|
}
|
2007-10-03 06:16:58 +00:00
|
|
|
} else { // Search by PID
|
|
|
|
aPID = atol(buf+16);
|
2005-04-23 15:14:52 +00:00
|
|
|
if (aPID == thePID) {
|
|
|
|
pclose(f);
|
|
|
|
return aPID;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
pclose(f);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-10-05 13:28:11 +00:00
|
|
|
OSErr CScreensaver::GetpathToBOINCManagerApp(char* path, int maxLen)
|
2005-04-23 15:14:52 +00:00
|
|
|
{
|
|
|
|
CFStringRef bundleID = CFSTR("edu.berkeley.boinc");
|
|
|
|
OSType creator = 'BNC!';
|
|
|
|
FSRef theFSRef;
|
|
|
|
OSStatus status = noErr;
|
|
|
|
|
|
|
|
status = LSFindApplicationForInfo(creator, bundleID, NULL, &theFSRef, NULL);
|
|
|
|
if (status == noErr)
|
|
|
|
status = FSRefMakePath(&theFSRef, (unsigned char *)path, maxLen);
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-05-25 11:18:05 +00:00
|
|
|
// Send a Quit AppleEvent to the process which called this module
|
|
|
|
// (i.e., tell the ScreenSaver engine to quit)
|
2007-10-05 13:28:11 +00:00
|
|
|
OSErr CScreensaver::KillScreenSaver() {
|
2005-05-25 11:18:05 +00:00
|
|
|
ProcessSerialNumber thisPSN;
|
|
|
|
pid_t thisPID;
|
|
|
|
OSErr err = noErr;
|
|
|
|
|
|
|
|
GetCurrentProcess(&thisPSN);
|
|
|
|
err = GetProcessPID(&thisPSN , &thisPID);
|
|
|
|
if (err == noErr)
|
|
|
|
err = kill(thisPID, SIGABRT); // SIGINT
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-02-14 12:26:13 +00:00
|
|
|
void print_to_log_file(const char *format, ...) {
|
2005-04-23 15:14:52 +00:00
|
|
|
#if CREATE_LOG
|
|
|
|
va_list args;
|
|
|
|
char buf[256];
|
|
|
|
time_t t;
|
2009-02-27 11:20:08 +00:00
|
|
|
#if USE_SPECIAL_LOG_FILE
|
2005-04-23 15:14:52 +00:00
|
|
|
strcpy(buf, getenv("HOME"));
|
|
|
|
strcat(buf, "/Documents/test_log.txt");
|
2009-02-27 11:20:08 +00:00
|
|
|
FILE *f;
|
2005-04-23 15:14:52 +00:00
|
|
|
f = fopen(buf, "a");
|
|
|
|
if (!f) return;
|
|
|
|
|
2009-02-27 11:20:08 +00:00
|
|
|
freopen(buf, "a", stdout);
|
|
|
|
freopen(buf, "a", stderr);
|
|
|
|
#else
|
|
|
|
#define f stderr
|
|
|
|
#endif
|
2005-04-23 15:14:52 +00:00
|
|
|
time(&t);
|
|
|
|
strcpy(buf, asctime(localtime(&t)));
|
|
|
|
strip_cr(buf);
|
|
|
|
|
|
|
|
fputs(buf, f);
|
|
|
|
fputs(" ", f);
|
|
|
|
|
|
|
|
va_start(args, format);
|
|
|
|
vfprintf(f, format, args);
|
|
|
|
va_end(args);
|
|
|
|
|
|
|
|
fputs("\n", f);
|
2009-02-27 11:20:08 +00:00
|
|
|
#if USE_SPECIAL_LOG_FILE
|
2007-08-31 14:23:07 +00:00
|
|
|
fflush(f);
|
2005-04-23 15:14:52 +00:00
|
|
|
fclose(f);
|
|
|
|
#endif
|
2009-02-27 11:20:08 +00:00
|
|
|
#endif
|
2005-04-23 15:14:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#if CREATE_LOG
|
2008-02-14 12:26:13 +00:00
|
|
|
void strip_cr(char *buf)
|
2005-04-23 15:14:52 +00:00
|
|
|
{
|
|
|
|
char *theCR;
|
|
|
|
|
|
|
|
theCR = strrchr(buf, '\n');
|
|
|
|
if (theCR)
|
|
|
|
*theCR = '\0';
|
|
|
|
theCR = strrchr(buf, '\r');
|
|
|
|
if (theCR)
|
|
|
|
*theCR = '\0';
|
|
|
|
}
|
|
|
|
#endif // CREATE_LOG
|
2008-09-05 02:47:10 +00:00
|
|
|
|
|
|
|
void PrintBacktrace(void) {
|
2009-02-27 11:20:08 +00:00
|
|
|
// Dummy routine to satisfy linker
|
2008-09-05 02:47:10 +00:00
|
|
|
}
|
|
|
|
|
2005-09-13 09:01:56 +00:00
|
|
|
const char *BOINC_RCSID_7ce0778d35="$Id$";
|