// Process console messages sent by the system static BOOL WINAPI console_control_handler( DWORD dwCtrlType ){ BOOL bReturnStatus = FALSE; BOINCTRACE("***** Console Event Detected *****\n"); switch( dwCtrlType ){ case CTRL_LOGOFF_EVENT: BOINCTRACE("Event: CTRL-LOGOFF Event\n"); if (!gstate.executing_as_daemon) { quit_client(); } bReturnStatus = TRUE; break; case CTRL_C_EVENT: case CTRL_BREAK_EVENT: BOINCTRACE("Event: CTRL-C or CTRL-BREAK Event\n"); quit_client(); bReturnStatus = TRUE; break; case CTRL_CLOSE_EVENT: case CTRL_SHUTDOWN_EVENT: BOINCTRACE("Event: CTRL-CLOSE or CTRL-SHUTDOWN Event\n"); quit_client(); break; } return bReturnStatus; }
int CScreensaver::count_active_graphic_apps(RESULTS& res, RESULT* exclude) { int i = 0; unsigned int graphics_app_count = 0; // Count the number of active graphics-capable apps excluding the specified result. // If exclude is NULL, don't exclude any results. // for (i = res.results.size()-1; i >=0 ; i--) { BOINCTRACE(_T("count_active_graphic_apps -- active task detected\n")); BOINCTRACE( _T("count_active_graphic_apps -- name = '%s', path = '%s'\n"), res.results[i]->name, res.results[i]->graphics_exec_path ); if (!strlen(res.results[i]->graphics_exec_path)) continue; if (is_same_task(res.results[i], exclude)) continue; #ifdef __APPLE__ // Remove it from the vector if incompatible with current version of OS X if (isIncompatible(res.results[i]->graphics_exec_path)) { BOINCTRACE( _T("count_active_graphic_apps -- removing incompatible name = '%s', path = '%s'\n"), res.results[i]->name, res.results[i]->graphics_exec_path ); RESULT *rp = res.results[i]; res.results.erase(res.results.begin()+i); delete rp; continue; } #endif BOINCTRACE(_T("count_active_graphic_apps -- active task detected w/graphics\n")); graphics_app_count++; } return graphics_app_count; }
/// Initiate a connection to the core client. /// /// \param[in] host The host name of the machine the core client is running on. /// \param[in] port The port the core client is listening on for incoming /// connections. /// \return Zero on success, nonzero if any error occurred. int RPC_CLIENT::init(const char* host, int port) { memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(port); if (host) { hostent* hep = gethostbyname(host); if (!hep) { return ERR_GETHOSTBYNAME; } addr.sin_addr.s_addr = *(int*)hep->h_addr_list[0]; } else { addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); } boinc_socket(sock); int retval = connect(sock, (const sockaddr*)(&addr), sizeof(addr)); if (retval) { #ifdef _WIN32 BOINCTRACE("RPC_CLIENT::init connect 2: Winsock error '%d'\n", WSAGetLastError()); #endif BOINCTRACE("RPC_CLIENT::init connect on %d returned %d\n", sock, retval); close(); return ERR_CONNECT; } return 0; }
/// Initiate a connection to the core client using non-blocking operations. /// /// \param[in] host The host name of the machine the core client is running on. /// \param[in] _timeout How long to wait until give up /// If the caller (i.e. Synecdoche Manager) just launched /// the core client, this should be large enough to allow /// the process to run and open its listening socket /// (e.g. 60 sec). /// If connecting to a remote client, it should be large /// enough for the user to deal with a "personal firewall" /// popup (e.g. 60 sec). /// \param[in] _retry If true, keep retrying until succeed or timeout. /// Use this if just launched the core client. /// \param[in] port The port the core client is listening on for incoming /// connections. /// \return Zero on success, nonzero if any error occurred. int RPC_CLIENT::init_asynch(const char* host, double _timeout, bool _retry, int port) { memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(port); retry = _retry; timeout = _timeout; if (host) { hostent* hep = gethostbyname(host); if (!hep) { return ERR_GETHOSTBYNAME; } addr.sin_addr.s_addr = *(int*)hep->h_addr_list[0]; } else { addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); } int retval = boinc_socket(sock); BOINCTRACE("RPC_CLIENT::init boinc_socket returned %d\n", sock); if (retval) { return retval; } retval = boinc_socket_asynch(sock, true); if (retval) { BOINCTRACE("RPC_CLIENT::init asynch error: %d\n", retval); } start_time = dtime(); retval = connect(sock, (const sockaddr*)(&addr), sizeof(addr)); if (retval) { BOINCTRACE("RPC_CLIENT::init connect returned %d\n", retval); } BOINCTRACE("RPC_CLIENT::init attempting connect \n"); return 0; }
int CScreensaver::count_active_graphic_apps(RESULTS& results, RESULT* exclude) { unsigned int i = 0; unsigned int graphics_app_count = 0; m_bV5_GFX_app_is_running = false; // Count the number of active graphics-capable apps excluding the specified result. // If exclude is NULL, don't exclude any results. for (i = 0; i < results.results.size(); i++) { BOINCTRACE(_T("get_random_graphics_app -- active task detected\n")); BOINCTRACE( _T("get_random_graphics_app -- name = '%s', path = '%s'\n"), results.results[i]->name, results.results[i]->graphics_exec_path ); if (results.results[i]->supports_graphics) m_bV5_GFX_app_is_running = true; if (!strlen(results.results[i]->graphics_exec_path) && (state.executing_as_daemon || !(results.results[i]->supports_graphics)) ) { continue; } BOINCTRACE(_T("get_random_graphics_app -- active task detected w/graphics\n")); if (is_same_task(results.results[i], exclude)) continue; graphics_app_count++; } return graphics_app_count; }
// Choose a random graphics application out of the vector. // Exclude the specified result unless it is the only candidate. // If exclude is NULL or an empty string, don't exclude any results. // RESULT* CScreensaver::get_random_graphics_app( RESULTS& res, RESULT* exclude ) { RESULT* rp = NULL; unsigned int i = 0; unsigned int graphics_app_count = 0; unsigned int random_selection = 0; unsigned int current_counter = 0; RESULT *avoid = exclude; BOINCTRACE(_T("get_random_graphics_app -- Function Start\n")); graphics_app_count = count_active_graphic_apps(res, avoid); BOINCTRACE(_T("get_random_graphics_app -- graphics_app_count = '%d'\n"), graphics_app_count); // If no graphics app found other than the one excluded, count again without excluding any if ((0 == graphics_app_count) && (avoid != NULL)) { avoid = NULL; graphics_app_count = count_active_graphic_apps(res, avoid); } // If no graphics app was found, return NULL if (0 == graphics_app_count) { goto CLEANUP; } // Choose which application to display. // random_selection = (rand() % graphics_app_count) + 1; BOINCTRACE(_T("get_random_graphics_app -- random_selection = '%d'\n"), random_selection); // find the chosen graphics application. // for (i = 0; i < res.results.size(); i++) { if (!strlen(res.results[i]->graphics_exec_path)) continue; if (is_same_task(res.results[i], avoid)) continue; current_counter++; if (current_counter == random_selection) { rp = res.results[i]; break; } } CLEANUP: BOINCTRACE(_T("get_random_graphics_app -- Function End\n")); return rp; }
void CScreensaver::markAsIncompatible(char *gfxAppPath) { char *buf = (char *)malloc(strlen(gfxAppPath)+1); if (buf) { strlcpy(buf, gfxAppPath, malloc_size(buf)); m_vIncompatibleGfxApps.push_back(buf); BOINCTRACE(_T("markAsIncompatible -- path = '%s'\n"), gfxAppPath); } }
bool CScreensaver::isIncompatible(char *appPath) { unsigned int i = 0; for (i = 0; i < m_vIncompatibleGfxApps.size(); i++) { BOINCTRACE( _T("isIncompatible -- comparing incompatible path '%s' to candidate path %s\n"), m_vIncompatibleGfxApps[i], appPath ); if (strcmp(m_vIncompatibleGfxApps[i], appPath) == 0) { return true; } } return false; }
int CScreensaver::count_active_graphic_apps(RESULTS& res, RESULT* exclude) { unsigned int i = 0; unsigned int graphics_app_count = 0; // Count the number of active graphics-capable apps excluding the specified result. // If exclude is NULL, don't exclude any results. // for (i = 0; i < res.results.size(); i++) { BOINCTRACE(_T("get_random_graphics_app -- active task detected\n")); BOINCTRACE( _T("get_random_graphics_app -- name = '%s', path = '%s'\n"), res.results[i]->name, res.results[i]->graphics_exec_path ); if (!strlen(res.results[i]->graphics_exec_path)) continue; if (is_same_task(res.results[i], exclude)) continue; BOINCTRACE(_T("get_random_graphics_app -- active task detected w/graphics\n")); graphics_app_count++; } return graphics_app_count; }
int RPC_CLIENT::init_poll() { fd_set read_fds, write_fds, error_fds; struct timeval tv; int retval; FD_ZERO(&read_fds); FD_ZERO(&write_fds); FD_ZERO(&error_fds); FD_SET(sock, &read_fds); FD_SET(sock, &write_fds); FD_SET(sock, &error_fds); BOINCTRACE("RPC_CLIENT::init_poll sock = %d\n", sock); tv.tv_sec = tv.tv_usec = 0; select(FD_SETSIZE, &read_fds, &write_fds, &error_fds, &tv); retval = 0; if (FD_ISSET(sock, &error_fds)) { retval = ERR_CONNECT; } else if (FD_ISSET(sock, &write_fds)) { retval = get_socket_error(sock); if (!retval) { BOINCTRACE("RPC_CLIENT::init_poll connected to port %d\n", ntohs(addr.sin_port)); retval = boinc_socket_asynch(sock, false); if (retval) { BOINCTRACE("asynch error: %d\n", retval); return retval; } return 0; } else { BOINCTRACE("init_poll: get_socket_error(): %d\n", retval); } } if (dtime() > start_time + timeout) { BOINCTRACE("RPC_CLIENT init timed out\n"); return ERR_CONNECT; } if (retval) { if (retry) { boinc_close_socket(sock); retval = boinc_socket(sock); retval = boinc_socket_asynch(sock, true); retval = connect(sock, (const sockaddr*)(&addr), sizeof(addr)); BOINCTRACE("RPC_CLIENT::init_poll attempting connect\n"); return ERR_RETRY; } else { return ERR_CONNECT; } } return ERR_RETRY; }
void CScreensaver::GetDefaultDisplayPeriods(struct ss_periods &periods) { char* default_data_dir_path = NULL; char buf[1024]; FILE* f; MIOFILE mf; periods.GFXDefaultPeriod = GFX_DEFAULT_PERIOD; periods.GFXSciencePeriod = GFX_SCIENCE_PERIOD; periods.GFXChangePeriod = GFX_CHANGE_PERIOD; periods.Show_default_ss_first = false; #ifdef __APPLE__ default_data_dir_path = "/Library/Application Support/BOINC Data"; #else default_data_dir_path = (char*)m_strBOINCDataDirectory.c_str(); #endif strlcpy(buf, default_data_dir_path, sizeof(buf)); strlcat(buf, PATH_SEPARATOR, sizeof(buf)); strlcat(buf, THE_SS_CONFIG_FILE, sizeof(buf)); f = boinc_fopen(buf, "r"); if (!f) return; mf.init_file(f); XML_PARSER xp(&mf); while (!xp.get_tag()) { if (xp.parse_bool("default_ss_first", periods.Show_default_ss_first)) continue; if (xp.parse_double("default_gfx_duration", periods.GFXDefaultPeriod)) continue; if (xp.parse_double("science_gfx_duration", periods.GFXSciencePeriod)) continue; if (xp.parse_double("science_gfx_change_interval", periods.GFXChangePeriod)) continue; } fclose(f); BOINCTRACE( _T("CScreensaver::GetDefaultDisplayPeriods: m_bShow_default_ss_first=%d, m_fGFXDefaultPeriod=%f, m_fGFXSciencePeriod=%f, m_fGFXChangePeriod=%f\n"), (int)periods.Show_default_ss_first, periods.GFXDefaultPeriod, periods.GFXSciencePeriod, periods.GFXChangePeriod ); }
DataMgmtProcType CScreensaver::DataManagementProc() { int retval = 0; int suspend_reason = 0; RESULT* theResult = NULL; RESULT* graphics_app_result_ptr = NULL; RESULT previous_result; // previous_result_ptr = &previous_result when previous_result is valid, else NULL RESULT* previous_result_ptr = NULL; int iResultCount = 0; int iIndex = 0; double default_phase_start_time = 0.0; double science_phase_start_time = 0.0; double last_change_time = 0.0; // If we run default screensaver during science phase because no science graphics // are available, then shorten next default graphics phase by that much time. double default_saver_start_time_in_science_phase = 0.0; double default_saver_duration_in_science_phase = 0.0; SS_PHASE ss_phase = DEFAULT_SS_PHASE; bool switch_to_default_gfx = false; bool killing_default_gfx = false; int exit_status = 0; char* default_ss_dir_path = NULL; char full_path[1024]; BOINCTRACE(_T("CScreensaver::DataManagementProc - Display screen saver loading message\n")); SetError(TRUE, SCRAPPERR_BOINCSCREENSAVERLOADING); // No GFX App is running: show moving BOINC logo #ifdef _WIN32 m_tThreadCreateTime = time(0); // Set the starting point for iterating through the results m_iLastResultShown = 0; m_tLastResultChangeTime = 0; #endif m_bDefault_ss_exists = false; m_bScience_gfx_running = false; m_bDefault_gfx_running = false; m_bShow_default_ss_first = false; #ifdef __APPLE__ m_vIncompatibleGfxApps.clear(); default_ss_dir_path = "/Library/Application Support/BOINC Data"; #else default_ss_dir_path = (char*)m_strBOINCInstallDirectory.c_str(); #endif strlcpy(full_path, default_ss_dir_path, sizeof(full_path)); strlcat(full_path, PATH_SEPARATOR, sizeof(full_path)); strlcat(full_path, THE_DEFAULT_SS_EXECUTABLE, sizeof(full_path)); if (boinc_file_exists(full_path)) { m_bDefault_ss_exists = true; } else { SetError(TRUE, SCRAPPERR_CANTLAUNCHDEFAULTGFXAPP); // No GFX App is running: show moving BOINC logo } if (m_bDefault_ss_exists && m_bShow_default_ss_first) { ss_phase = DEFAULT_SS_PHASE; default_phase_start_time = dtime(); science_phase_start_time = 0; switch_to_default_gfx = true; } else { ss_phase = SCIENCE_SS_PHASE; default_phase_start_time = 0; science_phase_start_time = dtime(); } while (true) { for (int i = 0; i < 4; i++) { // *** // *** Things that should be run frequently. // *** 4 times per second. // *** // Are we supposed to exit the screensaver? if (m_bQuitDataManagementProc) { // If main thread has requested we exit BOINCTRACE(_T("CScreensaver::DataManagementProc - Thread told to stop\n")); if (m_hGraphicsApplication || graphics_app_result_ptr) { if (m_bDefault_gfx_running) { BOINCTRACE(_T("CScreensaver::DataManagementProc - Terminating default screensaver\n")); terminate_default_screensaver(m_hGraphicsApplication); } else { BOINCTRACE(_T("CScreensaver::DataManagementProc - Terminating screensaver\n")); terminate_screensaver(m_hGraphicsApplication, graphics_app_result_ptr); } graphics_app_result_ptr = NULL; previous_result_ptr = NULL; m_hGraphicsApplication = 0; } BOINCTRACE(_T("CScreensaver::DataManagementProc - Stopping...\n")); m_bDataManagementProcStopped = true; // Tell main thread that we exited return 0; // Exit the thread } boinc_sleep(0.25); } // *** // *** Things that should be run less frequently. // *** 1 time per second. // *** // Blank screen saver? if ((m_dwBlankScreen) && (time(0) > m_dwBlankTime) && (m_dwBlankTime > 0)) { BOINCTRACE(_T("CScreensaver::DataManagementProc - Time to blank\n")); SetError(FALSE, SCRAPPERR_SCREENSAVERBLANKED); // Blanked - hide moving BOINC logo m_bQuitDataManagementProc = true; continue; // Code above will exit the thread } BOINCTRACE(_T("CScreensaver::DataManagementProc - ErrorMode = '%d', ErrorCode = '%x'\n"), m_bErrorMode, m_hrError); if (!m_bConnected) { HandleRPCError(); } if (m_bConnected) { // Do we need to get the core client state? if (m_bResetCoreState) { // Try and get the current state of the CC retval = rpc->get_state(state); if (retval) { // CC may not yet be running HandleRPCError(); continue; } else { m_bResetCoreState = false; } } // Update our task list retval = rpc->get_screensaver_tasks(suspend_reason, results); if (retval) { // rpc call returned error HandleRPCError(); m_bResetCoreState = true; continue; } } else { results.clear(); } // Time to switch to default graphics phase? if (m_bDefault_ss_exists && (ss_phase == SCIENCE_SS_PHASE) && (m_fGFXDefaultPeriod > 0)) { if (science_phase_start_time && ((dtime() - science_phase_start_time) > m_fGFXSciencePeriod)) { if (!m_bDefault_gfx_running) { switch_to_default_gfx = true; } ss_phase = DEFAULT_SS_PHASE; default_phase_start_time = dtime(); science_phase_start_time = 0; if (m_bDefault_gfx_running && default_saver_start_time_in_science_phase) { // Remember how long default graphics ran during science phase default_saver_duration_in_science_phase += (dtime() - default_saver_start_time_in_science_phase); } default_saver_start_time_in_science_phase = 0; } } // Time to switch to science graphics phase? if ((ss_phase == DEFAULT_SS_PHASE) && m_bConnected && (m_fGFXSciencePeriod > 0)) { if (default_phase_start_time && ((dtime() - default_phase_start_time + default_saver_duration_in_science_phase) > m_fGFXDefaultPeriod)) { // BOINCTRACE(_T("CScreensaver::Ending Default phase: now=%f, default_phase_start_time=%f, default_saver_duration_in_science_phase=%f\n"), // dtime(), default_phase_start_time, default_saver_duration_in_science_phase); ss_phase = SCIENCE_SS_PHASE; default_phase_start_time = 0; default_saver_duration_in_science_phase = 0; science_phase_start_time = dtime(); if (m_bDefault_gfx_running) { default_saver_start_time_in_science_phase = science_phase_start_time; } switch_to_default_gfx = false; } } // Core client suspended? // We ignore SUSPEND_REASON_CPU_USAGE in SS coordinator, so it won't kill graphics apps for // short-term CPU usage spikes (such as anti-virus.) Added 9 April 2010 if (suspend_reason && !(suspend_reason & (SUSPEND_REASON_CPU_THROTTLE | SUSPEND_REASON_CPU_USAGE))) { if (!m_bDefault_gfx_running) { SetError(TRUE, m_hrError); // No GFX App is running: show moving BOINC logo if (m_bDefault_ss_exists) { switch_to_default_gfx = true; } } } if (switch_to_default_gfx) { if (m_bScience_gfx_running) { if (m_hGraphicsApplication || previous_result_ptr) { // use previous_result_ptr because graphics_app_result_ptr may no longer be valid terminate_screensaver(m_hGraphicsApplication, previous_result_ptr); if (m_hGraphicsApplication == 0) { graphics_app_result_ptr = NULL; m_bScience_gfx_running = false; } else { // HasProcessExited() test will clear m_hGraphicsApplication and graphics_app_result_ptr } previous_result_ptr = NULL; } } else { if (!m_bDefault_gfx_running) { switch_to_default_gfx = false; retval = launch_default_screensaver(default_ss_dir_path, m_hGraphicsApplication); if (retval) { m_hGraphicsApplication = 0; previous_result_ptr = NULL; graphics_app_result_ptr = NULL; m_bDefault_gfx_running = false; SetError(TRUE, SCRAPPERR_CANTLAUNCHDEFAULTGFXAPP); // No GFX App is running: show moving BOINC logo } else { m_bDefault_gfx_running = true; if (ss_phase == SCIENCE_SS_PHASE) { default_saver_start_time_in_science_phase = dtime(); } SetError(FALSE, SCRAPPERR_BOINCSCREENSAVERLOADING); // A GFX App is running: hide moving BOINC logo } } } } if ((ss_phase == SCIENCE_SS_PHASE) && !switch_to_default_gfx) { #if SIMULATE_NO_GRAPHICS /* FOR TESTING */ if (!m_bDefault_gfx_running) { SetError(TRUE, m_hrError); // No GFX App is running: show moving BOINC logo if (m_bDefault_ss_exists) { switch_to_default_gfx = true; } } #else /* NORMAL OPERATION */ if (m_bScience_gfx_running) { // Is the current graphics app's associated task still running? if ((m_hGraphicsApplication) || (graphics_app_result_ptr)) { iResultCount = (int)results.results.size(); graphics_app_result_ptr = NULL; // Find the current task in the new results vector (if it still exists) for (iIndex = 0; iIndex < iResultCount; iIndex++) { theResult = results.results.at(iIndex); if (is_same_task(theResult, previous_result_ptr)) { graphics_app_result_ptr = theResult; previous_result = *theResult; previous_result_ptr = &previous_result; break; } } // V6 graphics only: if worker application has stopped running, terminate_screensaver if ((graphics_app_result_ptr == NULL) && (m_hGraphicsApplication != 0)) { if (previous_result_ptr) { BOINCTRACE(_T("CScreensaver::DataManagementProc - %s finished\n"), previous_result.graphics_exec_path ); } terminate_screensaver(m_hGraphicsApplication, previous_result_ptr); previous_result_ptr = NULL; if (m_hGraphicsApplication == 0) { graphics_app_result_ptr = NULL; m_bScience_gfx_running = false; // Save previous_result and previous_result_ptr for get_random_graphics_app() call } else { // HasProcessExited() test will clear m_hGraphicsApplication and graphics_app_result_ptr } } if (last_change_time && (m_fGFXChangePeriod > 0) && ((dtime() - last_change_time) > m_fGFXChangePeriod) ) { if (count_active_graphic_apps(results, previous_result_ptr) > 0) { if (previous_result_ptr) { BOINCTRACE(_T("CScreensaver::DataManagementProc - time to change: %s / %s\n"), previous_result.name, previous_result.graphics_exec_path ); } terminate_screensaver(m_hGraphicsApplication, graphics_app_result_ptr); if (m_hGraphicsApplication == 0) { graphics_app_result_ptr = NULL; m_bScience_gfx_running = false; // Save previous_result and previous_result_ptr for get_random_graphics_app() call } else { // HasProcessExited() test will clear m_hGraphicsApplication and graphics_app_result_ptr } } last_change_time = dtime(); } } } // End if (m_bScience_gfx_running) // If no current graphics app, pick an active task at random // and launch its graphics app // if ((m_bDefault_gfx_running || (m_hGraphicsApplication == 0)) && (graphics_app_result_ptr == NULL)) { if (suspend_reason && !(suspend_reason & (SUSPEND_REASON_CPU_THROTTLE | SUSPEND_REASON_CPU_USAGE))) { graphics_app_result_ptr = NULL; } else { graphics_app_result_ptr = get_random_graphics_app(results, previous_result_ptr); previous_result_ptr = NULL; } if (graphics_app_result_ptr) { if (m_bDefault_gfx_running) { terminate_default_screensaver(m_hGraphicsApplication); killing_default_gfx = true; // Remember how long default graphics ran during science phase if (default_saver_start_time_in_science_phase) { default_saver_duration_in_science_phase += (dtime() - default_saver_start_time_in_science_phase); //BOINCTRACE(_T("CScreensaver::During Science phase: now=%f, default_saver_start_time=%f, default_saver_duration=%f\n"), // dtime(), default_saver_start_time_in_science_phase, default_saver_duration_in_science_phase); } default_saver_start_time_in_science_phase = 0; // HasProcessExited() test will clear // m_hGraphicsApplication and graphics_app_result_ptr } else { retval = launch_screensaver(graphics_app_result_ptr, m_hGraphicsApplication); if (retval) { m_hGraphicsApplication = 0; previous_result_ptr = NULL; graphics_app_result_ptr = NULL; m_bScience_gfx_running = false; } else { // A GFX App is running: hide moving BOINC logo // SetError(FALSE, SCRAPPERR_BOINCSCREENSAVERLOADING); last_change_time = dtime(); m_bScience_gfx_running = true; // Make a local copy of current result, since original pointer // may have been freed by the time we perform later tests previous_result = *graphics_app_result_ptr; previous_result_ptr = &previous_result; if (previous_result_ptr) { BOINCTRACE(_T("CScreensaver::DataManagementProc - launching %s\n"), previous_result.graphics_exec_path ); } } } } else { if (!m_bDefault_gfx_running) { // We can't run a science graphics app, so run the default graphics if available SetError(TRUE, m_hrError); if (m_bDefault_ss_exists) { switch_to_default_gfx = true; } } } // End if no science graphics available } // End if no current science graphics app is running #endif // ! SIMULATE_NO_GRAPHICS if (switch_to_default_gfx) { switch_to_default_gfx = false; if (!m_bDefault_gfx_running) { retval = launch_default_screensaver(default_ss_dir_path, m_hGraphicsApplication); if (retval) { m_hGraphicsApplication = 0; previous_result_ptr = NULL; graphics_app_result_ptr = NULL; m_bDefault_gfx_running = false; SetError(TRUE, SCRAPPERR_CANTLAUNCHDEFAULTGFXAPP); // No GFX App is running: show BOINC logo } else { m_bDefault_gfx_running = true; default_saver_start_time_in_science_phase = dtime(); SetError(FALSE, SCRAPPERR_BOINCSCREENSAVERLOADING); // Default GFX App is running: hide moving BOINC logo } } } } // End if ((ss_phase == SCIENCE_SS_PHASE) && !switch_to_default_gfx) // Is the graphics app still running? if (m_hGraphicsApplication) { if (HasProcessExited(m_hGraphicsApplication, exit_status)) { // Something has happened to the previously selected screensaver // application. Start a different one. BOINCTRACE(_T("CScreensaver::DataManagementProc - Graphics application isn't running, start a new one.\n")); if (m_bDefault_gfx_running) { // If we were able to connect to core client // but gfx app can't, don't use it. // BOINCTRACE(_T("CScreensaver::DataManagementProc - Default graphics application exited with code %d.\n"), exit_status); if (!killing_default_gfx) { // If this is an unexpected exit if (exit_status == DEFAULT_GFX_CANT_CONNECT) { SetError(TRUE, SCRAPPERR_DEFAULTGFXAPPCANTCONNECT); // No GFX App is running: show moving BOINC logo } else { SetError(TRUE, SCRAPPERR_DEFAULTGFXAPPCRASHED); // No GFX App is running: show moving BOINC logo } m_bDefault_ss_exists = false; ss_phase = SCIENCE_SS_PHASE; } killing_default_gfx = false; } SetError(TRUE, SCRAPPERR_BOINCNOGRAPHICSAPPSEXECUTING); // No GFX App is running: show moving BOINC logo m_hGraphicsApplication = 0; graphics_app_result_ptr = NULL; m_bDefault_gfx_running = false; m_bScience_gfx_running = false; #ifdef __APPLE__ launchedGfxApp("", 0, -1); #endif continue; } } } // end while(true) }
// Launch the default graphics application // int CScreensaver::launch_default_screensaver(char *dir_path, GFXAPP_ID& graphics_application) { int retval = 0; int num_args; #ifdef __APPLE__ // For sandbox security, use gfx_switcher to launch default // gfx app as user boinc_master and group boinc_master. char* argv[6]; argv[0] = "gfx_switcher"; argv[1] = "-default_gfx"; argv[2] = THE_DEFAULT_SS_EXECUTABLE; // Will be changed by gfx_switcher argv[3] = "--fullscreen"; argv[4] = 0; argv[5] = 0; if (!m_bConnected) { BOINCTRACE(_T("launch_default_screensaver using --retry_connect argument\n")); argv[4] = "--retry_connect"; num_args = 5; } else { num_args = 4; } retval = run_program( dir_path, m_gfx_Switcher_Path, num_args, argv, 0, graphics_application ); if (graphics_application) { launchedGfxApp("boincscr", graphics_application, -1); } BOINCTRACE(_T("launch_default_screensaver returned %d\n"), retval); #else char* argv[4]; char full_path[1024]; strlcpy(full_path, dir_path, sizeof(full_path)); strlcat(full_path, PATH_SEPARATOR, sizeof(full_path)); strlcat(full_path, THE_DEFAULT_SS_EXECUTABLE, sizeof(full_path)); argv[0] = full_path; argv[1] = "--fullscreen"; argv[2] = 0; argv[3] = 0; if (!m_bConnected) { BOINCTRACE(_T("launch_default_screensaver using --retry_connect argument\n")); argv[2] = "--retry_connect"; num_args = 3; } else { num_args = 2; } retval = run_program( dir_path, full_path, num_args, argv, 0, graphics_application ); BOINCTRACE(_T("launch_default_screensaver %s returned %d\n"), full_path, retval); #endif return retval; }
// Launch the default graphics application // int CScreensaver::launch_default_screensaver(char *dir_path, GFXAPP_ID& graphics_application) { int retval = 0; int num_args; #ifdef __APPLE__ // For sandbox security, use gfx_switcher to launch default // gfx app as user boinc_master and group boinc_master. char* argv[6]; argv[0] = "gfx_switcher"; argv[1] = "-default_gfx"; argv[2] = THE_DEFAULT_SS_EXECUTABLE; // Will be changed by gfx_switcher argv[3] = "--fullscreen"; argv[4] = 0; argv[5] = 0; if (!m_bConnected) { BOINCTRACE(_T("launch_default_screensaver using --retry_connect argument\n")); argv[4] = "--retry_connect"; num_args = 5; } else { num_args = 4; } retval = run_program( dir_path, m_gfx_Switcher_Path, num_args, argv, 0, graphics_application ); BOINCTRACE(_T("launch_default_screensaver returned %d\n"), retval); #else // For unknown reasons, the graphics application exits with // "RegisterProcess failed (error = -50)" unless we pass its // full path twice in the argument list to execv on Macs. char* argv[4]; char full_path[1024]; strlcpy(full_path, dir_path, sizeof(full_path)); strlcat(full_path, PATH_SEPARATOR, sizeof(full_path)); strlcat(full_path, THE_DEFAULT_SS_EXECUTABLE, sizeof(full_path)); argv[0] = full_path; // not used argv[1] = "--fullscreen"; argv[2] = 0; argv[3] = 0; if (!m_bConnected) { BOINCTRACE(_T("launch_default_screensaver using --retry_connect argument\n")); argv[2] = "--retry_connect"; num_args = 3; } else { num_args = 2; } retval = run_program( dir_path, full_path, num_args, argv, 0, graphics_application ); BOINCTRACE(_T("launch_default_screensaver %s returned %d\n"), full_path, retval); #endif return retval; }