// Given a filename, find its full path in the upload directory hierarchy // Return ERR_OPENDIR if dir isn't there (possibly recoverable error), // ERR_NOT_FOUND if dir is there but not file // int get_file_path( const char *filename, char* upload_dir, int fanout, char* path ) { dir_hier_path(filename, upload_dir, fanout, path, true); if (boinc_file_exists(path)) { return 0; } char* p = strrchr(path, '/'); *p = 0; if (boinc_file_exists(path)) { return ERR_NOT_FOUND; } return ERR_OPENDIR; }
int CBOINCClientManager::IsBOINCConfiguredAsDaemon() { bool bReturnValue = false; #if defined(__WXMSW__) if (is_daemon_installed()) bReturnValue = 1; #elif defined(__WXMAC__) if ( boinc_file_exists("/Library/LaunchDaemons/edu.berkeley.boinc.plist")) { bReturnValue = NewStyleDaemon; // New-style daemon uses launchd } if (boinc_file_exists("/Library/StartupItems/boinc/boinc") ) { bReturnValue = OldStyleDaemon; // Old-style daemon uses StartupItem } #endif return bReturnValue; }
int CBOINCClientManager::IsBOINCConfiguredAsDaemon() { bool bReturnValue = false; #if defined(__WXMSW__) if (IsBOINCServiceInstalled()) bReturnValue = 1; #elif defined(__WXMAC__) if ( boinc_file_exists("/Library/LaunchDaemons/com.googlecode.synecdoche.plist")) { bReturnValue = NewStyleDaemon; // New-style daemon uses launchd } if (boinc_file_exists("/Library/StartupItems/boinc/boinc") ) { bReturnValue = OldStyleDaemon; // Old-style daemon uses StartupItem } #endif return bReturnValue; }
int CSkinAdvanced::Parse(MIOFILE& in) { char buf[256]; std::string strBuffer; while (in.fgets(buf, 256)) { if (match_tag(buf, "</advanced>")) break; else if (parse_bool(buf, "is_branded", m_bIsBranded)) continue; else if (parse_str(buf, "<application_name>", strBuffer)) { m_strApplicationName = wxString(strBuffer.c_str(), wxConvUTF8); continue; } else if (parse_str(buf, "<application_short_name>", strBuffer)) { m_strApplicationShortName = wxString(strBuffer.c_str(), wxConvUTF8); continue; } else if (match_tag(buf, "<application_icon>")) { m_iconApplicationIcon.Parse(in); continue; } else if (match_tag(buf, "<application_icon32>")) { m_iconApplicationIcon32.Parse(in); continue; } else if (match_tag(buf, "<application_disconnected_icon>")) { m_iconApplicationDisconnectedIcon.Parse(in); continue; } else if (match_tag(buf, "<application_snooze_icon>")) { m_iconApplicationSnoozeIcon.Parse(in); continue; } else if (parse_str(buf, "<application_logo>", strBuffer)) { if(strBuffer.length()) { wxString str = wxString( wxGetApp().GetSkinManager()->ConstructSkinPath() + wxString(strBuffer.c_str(), wxConvUTF8) ); if (boinc_file_exists(str.c_str())) { m_bitmapApplicationLogo = wxBitmap(wxImage(str.c_str(), wxBITMAP_TYPE_ANY)); } } continue; } else if (parse_str(buf, "<organization_name>", strBuffer)) { m_strOrganizationName = wxString(strBuffer.c_str(), wxConvUTF8); continue; } else if (parse_str(buf, "<organization_website>", strBuffer)) { m_strOrganizationWebsite = wxString(strBuffer.c_str(), wxConvUTF8); continue; } else if (parse_str(buf, "<organization_help_url>", strBuffer)) { m_strOrganizationHelpUrl = wxString(strBuffer.c_str(), wxConvUTF8); continue; } else if (parse_int(buf, "<open_tab>", m_iDefaultTab)) { m_bDefaultTabSpecified = true; continue; } else if (parse_str(buf, "<exit_message>", strBuffer)) { m_strExitMessage = wxString(strBuffer.c_str(), wxConvUTF8); continue; } } InitializeDelayedValidation(); return 0; }
void CSimpleTaskPanel::FindSlideShowFiles(TaskSelectionData *selData) { RESULT* state_result; char urlDirectory[1024]; char fileName[1024]; char resolvedFileName[1024]; int j; CMainDocument* pDoc = wxGetApp().GetDocument(); wxASSERT(pDoc); selData->slideShowFileNames.Clear(); state_result = pDoc->state.lookup_result(selData->result->project_url, selData->result->name); if (!state_result) { pDoc->ForceCacheUpdate(); state_result = pDoc->state.lookup_result(selData->result->project_url, selData->result->name); } if (state_result) { url_to_project_dir(state_result->project->master_url, urlDirectory); for(j=0; j<99; ++j) { sprintf(fileName, "%s/slideshow_%s_%02d", urlDirectory, state_result->app->name, j); if(boinc_resolve_filename(fileName, resolvedFileName, sizeof(resolvedFileName)) == 0) { if (boinc_file_exists(resolvedFileName)) { selData->slideShowFileNames.Add(wxString(resolvedFileName,wxConvUTF8)); } } else { break; } } if ( selData->slideShowFileNames.size() == 0 ) { for(j=0; j<99; ++j) { sprintf(fileName, "%s/slideshow_%02d", urlDirectory, j); if(boinc_resolve_filename(fileName, resolvedFileName, sizeof(resolvedFileName)) == 0) { if (boinc_file_exists(resolvedFileName)) { selData->slideShowFileNames.Add(wxString(resolvedFileName,wxConvUTF8)); } } else { break; } } } } selData->lastSlideShown = -1; }
bool benchmark_time_to_stop(int which) { #ifndef _WIN32 if (getppid() == 1) { exit(0); } #endif if (boinc_file_exists(file_names[which])) { return false; } return true; }
/// Set up a file reference, given a slot dir and project dir. /// This means: /// -# copy the file to slot dir, if reference is by copy /// -# else make a soft link static int setup_file( const PROJECT* project, const FILE_INFO* fip, const FILE_REF& fref, const std::string& file_path, const std::string& slot_dir, bool input ) { int retval; std::string link_path = slot_dir + std::string("/"); if (strlen(fref.open_name)) { link_path += std::string(fref.open_name); } else { link_path += std::string(fip->name); } std::string rel_file_path = std::string("../../") + file_path; // if anonymous platform, this is called even if not first time, // so link may already be there // if (input && project->anonymous_platform && boinc_file_exists(link_path.c_str())) { return 0; } if (fref.copy_file) { if (input) { retval = boinc_copy(file_path.c_str(), link_path.c_str()); if (retval) { msg_printf(project, MSG_INTERNAL_ERROR, "Can't copy %s to %s: %s", file_path.c_str(), link_path.c_str(), boincerror(retval) ); return retval; } } return 0; } #ifdef _WIN32 retval = make_soft_link(project, link_path.c_str(), rel_file_path.c_str()); if (retval) return retval; #else if (project->use_symlinks) { retval = symlink(rel_file_path.c_str(), link_path.c_str()); } else { retval = make_soft_link(project, link_path.c_str(), rel_file_path.c_str()); } if (retval) return retval; #endif #ifdef SANDBOX return set_to_project_group(link_path.c_str()); #endif return 0; }
void check_stop_daemons() { if (caught_stop_signal) { log_messages.printf(MSG_NORMAL, "Quitting due to SIGHUP\n"); exit(0); } const char *stop_file = config.project_path(STOP_DAEMONS_FILENAME); if (boinc_file_exists(stop_file)) { log_messages.printf(MSG_NORMAL, "Quitting because trigger file '%s' is present\n", stop_file ); exit(0); } }
void benchmark_wait_to_start(int which) { while (1) { if (boinc_file_exists(file_names[which])) { break; } #ifndef _WIN32 // UNIX: check if client has died. // Not needed on windows, where we run as thread in client process // if (getppid() == 1) { exit(0); } #endif boinc_sleep(0.1); } }
// try and open up the JoyWarrior file descriptor bool CSensorLinuxUSBJW::detect() { setType(); setPort(); const char* strJWEnum[LINUX_JOYSTICK_NUM] = LINUX_JOYSTICK_ARRAY; // go through and try potential Linux joystick devices from define.h int i; for (i = 0; i < LINUX_JOYSTICK_NUM; i++) { if (! boinc_file_exists(strJWEnum[i]) ) continue; // first see if file (device) exists if ( ( m_fdJoy = open(strJWEnum[i], O_RDONLY)) != -1 && testJoystick() ) { fprintf(stdout, "%s detected on joystick device %s\n", m_strJoystick, strJWEnum[i]); break; // found a JW24F8 } } #ifdef QCN_RAW_DATA setSingleSampleDT(true); // set to true in raw mode so we don't get any interpolated/avg points (i.e. just the "integer" value hopefully) #else setSingleSampleDT(false); #endif return (bool)(getTypeEnum() == SENSOR_USB_JW24F8); }
void debug_sched(const char *trigger) { char tmpfilename[256]; #ifndef _USING_FCGI_ FILE *fp; #else FCGI_FILE *fp; #endif if (!boinc_file_exists(config.project_path("%s", trigger))) { return; } sprintf(tmpfilename, "sched_reply_%06d_%06d", g_request->hostid, g_request->rpc_seqno ); // use _XXXXXX if you want random filenames rather than // deterministic mkstemp(tmpfilename); #ifndef _USING_FCGI_ fp=fopen(tmpfilename, "w"); #else fp=FCGI::fopen(tmpfilename,"w"); #endif if (!fp) { log_messages.printf(MSG_CRITICAL, "Found %s, but can't open %s\n", trigger, tmpfilename ); return; } log_messages.printf(MSG_DEBUG, "Found %s, so writing %s\n", trigger, tmpfilename ); g_reply->write(fp, *g_request); fclose(fp); sprintf(tmpfilename, "sched_request_%06d_%06d", g_request->hostid, g_request->rpc_seqno ); #ifndef _USING_FCGI_ fp=fopen(tmpfilename, "w"); #else fp=FCGI::fopen(tmpfilename,"w"); #endif if (!fp) { log_messages.printf(MSG_CRITICAL, "Found %s, but can't open %s\n", trigger, tmpfilename ); return; } log_messages.printf(MSG_DEBUG, "Found %s, so writing %s\n", trigger, tmpfilename ); g_request->write(fp); fclose(fp); return; }
void PrintBacktrace(void) { int err; QCrashReportRef crRef = NULL; char nameBuf[256], pathToThisProcess[1024]; const NXArchInfo *localArch; char OSMinorVersion = '?'; time_t t; char atosPipeBuf[1024], cppfiltPipeBuf[1024]; char outBuf[1024], offsetBuf[32]; char *sourceSymbol, *symbolEnd; char **symbols = NULL; void *callstack[CALL_STACK_SIZE]; int frames, i; void *systemlib = NULL; FILE *atosPipe = NULL; FILE *cppfiltPipe = NULL; backtraceProc myBacktraceProc = NULL; backtrace_symbolsProc myBacktrace_symbolsProc = NULL; char saved_env[128], *env = NULL; bool atosExists = false, cppfiltExists = false; #if 0 // To debug backtrace logic: // * Enable this block of code. // * Set a breakpoint at sleep(1) call, and wherever else you wish. // * Launch built development application from Finder. // * Get this application's pid from Activity Monitor. // * Attach Debugger to this application. // * Continue until you reach this breakpoint. // * Change wait variable to 0 (false). // This is necessary because GDB intercepts signals even if you tell it // not to, so you must attach GDB after the signal handler is invoked. bool wait = true; while (wait) { fprintf(stderr, "waiting\n"); sleep(1); } #endif GetNameOfAndPathToThisProcess(nameBuf, sizeof(nameBuf), pathToThisProcess, sizeof(pathToThisProcess)); if (nameBuf[0]) { fprintf(stderr, "\nCrashed executable name: %s\n", nameBuf); } #ifdef BOINC_VERSION_STRING fprintf(stderr, "built using BOINC library version %s\n", BOINC_VERSION_STRING); #endif localArch = NXGetLocalArchInfo(); fprintf(stderr, "Machine type %s", localArch->description); #ifdef __LP64__ fprintf(stderr, " (64-bit executable)\n"); #else fprintf(stderr, " (32-bit executable)\n"); #endif PrintOSVersion(&OSMinorVersion); time(&t); fputs(asctime(localtime(&t)), stderr); fputc('\n', stderr); err = QCRCreateFromSelf(&crRef); if (OSMinorVersion == '5') { #ifdef __ppc__ fputs("BOINC backtrace under OS 10.5.x only shows exported (global) symbols\n", stderr); fputs("and may work poorly on a PowerPC Mac after a crash. For a better\n", stderr); fputs("backtrace, run under OS 10.4.x.\n\n", stderr); #else fputs("BOINC backtrace under OS 10.5.x only shows exported (global) symbols\n", stderr); fputs("and may not show the final location which caused a crash. For a better\n", stderr); fputs("backtrace, either run under OS 10.4.x or run under OS 10.6.x or later.\n\n", stderr); #endif } if (OSMinorVersion >= '5') { // Use new backtrace functions if available (only in OS 10.5 and later) systemlib = dlopen ("/usr/lib/libSystem.dylib", RTLD_NOW ); if (systemlib) { myBacktraceProc = (backtraceProc)dlsym(systemlib, "backtrace"); } if (! myBacktraceProc) { goto skipBackTrace; // Should never happen } frames = myBacktraceProc(callstack, CALL_STACK_SIZE); myBacktrace_symbolsProc = (backtrace_symbolsProc)dlsym(systemlib, "backtrace_symbols"); if (myBacktrace_symbolsProc) { symbols = myBacktrace_symbolsProc(callstack, frames); } else { goto skipBackTrace; // Should never happen } atosExists = boinc_file_exists("/usr/bin/atos"); cppfiltExists = boinc_file_exists("/usr/bin/atos"); if (atosExists || cppfiltExists) { // The bidirectional popen only works if the NSUnbufferedIO environment // variable is set, so we save and restore its current value. env = getenv("NSUnbufferedIO"); if (env) { strlcpy(saved_env, env, sizeof(saved_env)); } setenv("NSUnbufferedIO", "YES", 1); } if (atosExists) { // The backtrace_symbols() and backtrace_symbols() APIs are limited to // external symbols only, so we also use the atos command-line utility // which gives us debugging symbols when available. // // For some reason, using the -p option with the value from getpid() // fails here but the -o option with a path does work. #ifdef __x86_64__ snprintf(atosPipeBuf, sizeof(atosPipeBuf), "/usr/bin/atos -o \"%s\" -arch x86_64", pathToThisProcess); #elif defined (__i386__) snprintf(atosPipeBuf, sizeof(atosPipeBuf), "/usr/bin/atos -o \"%s\" -arch i386", pathToThisProcess); #else snprintf(atosPipeBuf, sizeof(atosPipeBuf), "/usr/bin/atos -o \"%s\" -arch ppc", pathToThisProcess); #endif atosPipe = popen(atosPipeBuf, "r+"); if (atosPipe) { setbuf(atosPipe, 0); } } if (cppfiltExists) { cppfiltPipe = popen("/usr/bin/c++filt -s gnu-v3 -n", "r+"); if (cppfiltPipe) { setbuf(cppfiltPipe, 0); } } for (i=0; i<frames; i++) { strlcpy(outBuf, symbols[i], sizeof(outBuf)); if (cppfiltPipe) { sourceSymbol = strstr(outBuf, "0x"); if (sourceSymbol) { sourceSymbol = strchr(sourceSymbol, (int)'_'); if (sourceSymbol) { strlcpy(cppfiltPipeBuf, sourceSymbol, sizeof(cppfiltPipeBuf)-1); *sourceSymbol = '\0'; symbolEnd = strchr(cppfiltPipeBuf, (int)' '); if (symbolEnd) { strlcpy(offsetBuf, symbolEnd, sizeof(offsetBuf)); *symbolEnd = '\0'; } fprintf(cppfiltPipe, "%s\n", cppfiltPipeBuf); BT_PersistentFGets(cppfiltPipeBuf, sizeof(cppfiltPipeBuf), cppfiltPipe); symbolEnd = strchr(cppfiltPipeBuf, (int)'\n'); if (symbolEnd) { *symbolEnd = '\0'; } strlcat(outBuf, cppfiltPipeBuf, sizeof(outBuf)); strlcat(outBuf, offsetBuf, sizeof(outBuf)); } } } if (atosPipe) { fprintf(atosPipe, "%#llx\n", (QTMAddr)callstack[i]); BT_PersistentFGets(atosPipeBuf, sizeof(atosPipeBuf), atosPipe); sourceSymbol = strstr(atosPipeBuf, "0x"); if (!sourceSymbol) { // If atos returned a symbol (not just a hex value) sourceSymbol = strstr(outBuf, "0x"); if (sourceSymbol) sourceSymbol = strstr(sourceSymbol, " "); if (sourceSymbol) *++sourceSymbol = '\0'; // Remove questionable symbol from backtrace_symbols() strlcat(outBuf, " ", sizeof(outBuf)); strlcat(outBuf, atosPipeBuf, sizeof(outBuf)); symbolEnd = strchr(outBuf, (int)'\n'); if (symbolEnd) { *symbolEnd = '\0'; } } } fprintf(stderr, "%s\n", outBuf); } if (atosPipe) { pclose(atosPipe); } if (cppfiltPipe) { pclose(cppfiltPipe); } if (atosExists || cppfiltExists) { if (env) { setenv("NSUnbufferedIO", saved_env, 1); } else { unsetenv("NSUnbufferedIO"); } } skipBackTrace: fprintf(stderr, "\n"); } else { // Not OS 10.5.x QCRPrintBacktraces(crRef, stderr); } // make sure this much gets written to file in case future // versions of OS break our crash dump code beyond this point. fflush(stderr); QCRPrintThreadState(crRef, stderr); QCRPrintImages(crRef, stderr); }
int main(int argc, char *argv[]) { char pkgPath[MAXPATHLEN]; char postInstallAppPath[MAXPATHLEN]; char temp[MAXPATHLEN], temp2[MAXPATHLEN]; char brand[64], s[256]; char *p; OSStatus err = noErr; Boolean restartNeeded = true; FILE *restartNeededFile; FILE *f; long oldBrandID; if (!check_branding_arrays(temp, sizeof(temp))) { ShowMessage((char *)_("Branding array has too few entries: %s"), temp); return -1; } if (Initialize() != noErr) { return 0; } strncpy(loginName, getenv("USER"), sizeof(loginName)-1); if (loginName[0] == '\0') { ShowMessage((char *)_("Could not get user login name")); return 0; } snprintf(tempDirName, sizeof(tempDirName), "InstallBOINC-%s", loginName); snprintf(temp, sizeof(temp), "/tmp/%s", tempDirName); mkdir(temp, 0777); chmod(temp, 0777); // Needed because mkdir sets permissions restricted by umask (022) snprintf(temp, sizeof(temp), "rm -dfR /tmp/%s/BOINC_Installer_Errors", tempDirName); err = callPosixSpawn(temp); snprintf(Catalogs_Dir, sizeof(Catalogs_Dir), "/tmp/%s/BOINC_payload/Library/Application Support/BOINC Data/locale/", tempDirName); // Get the full path to Installer package inside this application's bundle getPathToThisApp(pkgPath, sizeof(pkgPath)); strlcpy(temp, pkgPath, sizeof(temp)); strlcat(pkgPath, "/Contents/Resources/", sizeof(pkgPath)); strlcpy(postInstallAppPath, pkgPath, sizeof(postInstallAppPath)); strlcat(postInstallAppPath, "PostInstall.app", sizeof(postInstallAppPath)); p = strrchr(temp, '/'); // Point to name of this application (e.g., "BOINC Installer.app") if (p == NULL) { p = temp - 1; } else { *p = '\0'; } // Delete any old project auto-attach key file from our temp directory snprintf(temp2, sizeof(temp2), "rm -dfR \"/tmp/%s/%s\"", tempDirName, ACCOUNT_DATA_FILENAME); err = callPosixSpawn(temp2); REPORT_ERROR(err); // Write a file containing the project auto-attach key into our temp // directory because the BOINC Data directory may not yet exist. // PostInstall.app will copy it into the BOINC Data directory laer snprintf(temp2, sizeof(temp2), "%s/%s", temp, ACCOUNT_DATA_FILENAME); if (boinc_file_exists(temp2)) { // If the project server put account_data.txt file in the same // parent directory as this installer, copy it into our temp directory snprintf(temp2, sizeof(temp2), "cp \"%s/%s\" \"/tmp/%s/%s\"", temp, ACCOUNT_DATA_FILENAME, tempDirName, ACCOUNT_DATA_FILENAME); err = callPosixSpawn(temp2); REPORT_ERROR(err); } else { // Create an account_data.txt file containing our // installer's filename and put it in our temp directory snprintf(temp2, sizeof(temp2), "/tmp/%s/%s", tempDirName, ACCOUNT_DATA_FILENAME); f = fopen(temp2, "w"); fputs(p+1, f); fclose(f); } // Write a temp file to tell our PostInstall.app the previous branding, if any oldBrandID = GetOldBrandID(); snprintf(temp, sizeof(temp), "/tmp/%s/OldBranding", tempDirName); f = fopen(temp, "w"); if (!f) { REPORT_ERROR(true); } else { fprintf(f, "BrandId=%ld\n", oldBrandID); fclose(f); } // To allow for branding, assume name of installer package inside bundle corresponds to name of this application strlcpy(brand, p+1, sizeof(brand)); strlcat(pkgPath, p+1, sizeof(pkgPath)); p = strrchr(pkgPath, ' '); // Strip off last space character and everything following if (p) *p = '\0'; p = strrchr(brand, ' '); // Strip off last space character and everything following if (p) *p = '\0'; strlcat(pkgPath, ".pkg", sizeof(pkgPath)); // In the unlikely situation that /tmp has files from an earlier attempt to install // BOINC by a different user, we won't have permission to delete or overwrite them, // so include the current user's name as part of the paths to our temporary files. // Expand the installer package snprintf(temp, sizeof(temp), "rm -dfR /tmp/%s/BOINC.pkg", tempDirName); err = callPosixSpawn(temp); REPORT_ERROR(err); snprintf(temp, sizeof(temp), "rm -dfR /tmp/%s/expanded_BOINC.pkg", tempDirName); err = callPosixSpawn(temp); REPORT_ERROR(err); snprintf(temp, sizeof(temp), "rm -dfR /tmp/%s/PostInstall.app", tempDirName); err = callPosixSpawn(temp); REPORT_ERROR(err); snprintf(temp, sizeof(temp), "rm -f /tmp/%s/BOINC_preferred_languages", tempDirName); err = callPosixSpawn(temp); REPORT_ERROR(err); snprintf(temp, sizeof(temp), "rm -f /tmp/%s/BOINC_restart_flag", tempDirName); err = callPosixSpawn(temp); REPORT_ERROR(err); sprintf(temp, "cp -fpR \"%s\" /tmp/%s/PostInstall.app", postInstallAppPath, tempDirName); err = callPosixSpawn(temp); REPORT_ERROR(err); sprintf(temp, "pkgutil --expand \"%s\" /tmp/%s/expanded_BOINC.pkg", pkgPath, tempDirName); err = callPosixSpawn(temp); REPORT_ERROR(err); if (err == noErr) { GetPreferredLanguages(); } if (compareOSVersionTo(10, 6) < 0) { LoadPreferredLanguages(); BringAppToFront(); p = strrchr(brand, ' '); // Strip off last space character and everything following if (p) *p = '\0'; ShowMessage((char *)_("Sorry, this version of %s requires system 10.6 or higher."), brand); snprintf(temp, sizeof(temp), "rm -dfR /tmp/%s/BOINC_payload", tempDirName); err = callPosixSpawn(temp); REPORT_ERROR(err); return -1; } snprintf(temp, sizeof(temp), "rm -dfR /tmp/%s/BOINC_payload", tempDirName); err = callPosixSpawn(temp); REPORT_ERROR(err); // Remove previous installer package receipt so we can run installer again // (affects only older versions of OS X and fixes a bug in those versions) // "rm -rf /Library/Receipts/GridRepublic.pkg" sprintf(s, "rm -rf \"/Library/Receipts/%s.pkg\"", brand); err = callPosixSpawn (s); REPORT_ERROR(err); restartNeeded = IsRestartNeeded(); // Write a temp file to tell our PostInstall.app whether restart is needed snprintf(temp, sizeof(temp), "/tmp/%s/BOINC_restart_flag", tempDirName); restartNeededFile = fopen(temp, "w"); if (restartNeededFile) { fputs(restartNeeded ? "1\n" : "0\n", restartNeededFile); fclose(restartNeededFile); } if (restartNeeded) { if (err == noErr) { // Change onConclusion="none" to onConclusion="RequireRestart" snprintf(temp, sizeof(temp), "sed -i \".bak\" s/onConclusion=\"none\"/onConclusion=\"RequireRestart\"/g /tmp/%s/expanded_BOINC.pkg/Distribution", tempDirName); err = callPosixSpawn(temp); REPORT_ERROR(err); } if (err == noErr) { snprintf(temp, sizeof(temp), "rm -dfR /tmp/%s/expanded_BOINC.pkg/Distribution.bak", tempDirName); err = callPosixSpawn(temp); REPORT_ERROR(err); // Flatten the installer package sprintf(temp, "pkgutil --flatten /tmp/%s/expanded_BOINC.pkg /tmp/%s/%s.pkg", tempDirName, tempDirName, brand); err = callPosixSpawn(temp); REPORT_ERROR(err); } if (err == noErr) { snprintf(temp, sizeof(temp), "rm -dfR /tmp/%s/expanded_BOINC.pkg", tempDirName); err = callPosixSpawn(temp); REPORT_ERROR(err); sprintf(temp, "open \"/tmp/%s/%s.pkg\"", tempDirName, brand); err = callPosixSpawn(temp); REPORT_ERROR(err); return err; } } snprintf(temp, sizeof(temp), "rm -dfR /tmp/%s/expanded_BOINC.pkg", tempDirName); err = callPosixSpawn(temp); REPORT_ERROR(err); sprintf(temp, "open \"%s\"", pkgPath); err = callPosixSpawn(temp); REPORT_ERROR(err); return err; }
// do an account manager RPC; // if URL is null, detach from current account manager // int ACCT_MGR_OP::do_rpc(ACCT_MGR_INFO& _ami, bool _via_gui) { int retval; unsigned int i; char buf[256]; ami = _ami; error_num = ERR_IN_PROGRESS; error_str = ""; via_gui = _via_gui; global_prefs_xml = ""; // if null URL, detach from current AMS // if (!strlen(ami.master_url) && strlen(gstate.acct_mgr_info.master_url)) { msg_printf(NULL, MSG_INFO, "Removing account manager info"); gstate.acct_mgr_info.clear(); boinc_delete_file(ACCT_MGR_URL_FILENAME); boinc_delete_file(ACCT_MGR_LOGIN_FILENAME); error_num = 0; for (i=0; i<gstate.projects.size(); i++) { gstate.projects[i]->detach_ams(); } ::rss_feeds.update_feed_list(); gstate.set_client_state_dirty("detach from AMS"); return 0; } canonicalize_master_url(ami.master_url, sizeof(ami.master_url)); if (!valid_master_url(ami.master_url)) { error_num = ERR_INVALID_URL; return 0; } FILE* f = boinc_fopen(ACCT_MGR_REQUEST_FILENAME, "w"); if (!f) return ERR_FOPEN; fprintf(f, "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" "<acct_mgr_request>\n" ); if (strlen(ami.authenticator)) { fprintf(f, " <authenticator>%s</authenticator>\n", ami.authenticator ); } else { fprintf(f, " <name>%s</name>\n" " <password_hash>%s</password_hash>\n", ami.login_name, ami.password_hash ); } fprintf(f, " <host_cpid>%s</host_cpid>\n" " <domain_name>%s</domain_name>\n" " <client_version>%d.%d.%d</client_version>\n" " <run_mode>%s</run_mode>\n", gstate.host_info.host_cpid, gstate.host_info.domain_name, gstate.core_client_version.major, gstate.core_client_version.minor, gstate.core_client_version.release, run_mode_name[gstate.cpu_run_mode.get_perm()] ); gstate.write_platforms(NULL, f); if (strlen(gstate.acct_mgr_info.previous_host_cpid)) { fprintf(f, " <previous_host_cpid>%s</previous_host_cpid>\n", gstate.acct_mgr_info.previous_host_cpid ); } // If the AMS requested it, send GUI RPC port and password. // This is for the "farm" account manager so it // can know where to send GUI RPC requests to // without having to configure each host // if (gstate.acct_mgr_info.send_gui_rpc_info) { if (gstate.cmdline_gui_rpc_port) { fprintf(f," <gui_rpc_port>%d</gui_rpc_port>\n", gstate.cmdline_gui_rpc_port); } else { fprintf(f," <gui_rpc_port>%d</gui_rpc_port>\n", GUI_RPC_PORT); } if (boinc_file_exists(GUI_RPC_PASSWD_FILE)) { char gui_rpc_password[256]; safe_strcpy(gui_rpc_password, ""); FILE* pwdf = fopen(GUI_RPC_PASSWD_FILE, "r"); if (pwdf) { if (fgets(gui_rpc_password, 256, pwdf)) { strip_whitespace(gui_rpc_password); } fclose(pwdf); } fprintf(f, " <gui_rpc_password>%s</gui_rpc_password>\n", gui_rpc_password ); } } for (i=0; i<gstate.projects.size(); i++) { PROJECT* p = gstate.projects[i]; double not_started_dur, in_progress_dur; p->get_task_durs(not_started_dur, in_progress_dur); fprintf(f, " <project>\n" " <url>%s</url>\n" " <project_name>%s</project_name>\n" " <suspended_via_gui>%d</suspended_via_gui>\n" " <hostid>%d</hostid>\n" " <not_started_dur>%f</not_started_dur>\n" " <in_progress_dur>%f</in_progress_dur>\n" " <attached_via_acct_mgr>%d</attached_via_acct_mgr>\n" " <dont_request_more_work>%d</dont_request_more_work>\n" " <detach_when_done>%d</detach_when_done>\n" " <ended>%d</ended>\n" " <resource_share>%f</resource_share>\n" " <disk_usage>%f</disk_usage>\n" " <disk_share>%f</disk_share>\n", p->master_url, p->project_name, p->suspended_via_gui?1:0, p->hostid, not_started_dur, in_progress_dur, p->attached_via_acct_mgr?1:0, p->dont_request_more_work?1:0, p->detach_when_done?1:0, p->ended?1:0, p->resource_share, p->disk_usage, p->disk_share ); // send work and starvation-related info // if (ami.dynamic) { fprintf(f, " <nrpc_failures>%d</nrpc_failures>\n" " <cpu_ec>%f</cpu_ec>\n" " <cpu_time>%f</cpu_time>\n" " <gpu_ec>%f</gpu_ec>\n" " <gpu_time>%f</gpu_time>\n" " <njobs_success>%d</njobs_success>\n" " <njobs_error>%d</njobs_error>\n", p->nrpc_failures, p->cpu_ec, p->cpu_time, p->gpu_ec, p->gpu_time, p->njobs_success, p->njobs_error ); for (int j=0; j<coprocs.n_rsc; j++) { if (p->sched_req_no_work[j]) { fprintf(f, " <sched_req_no_work>%s</sched_req_no_work>\n", coprocs.coprocs[j].type ); } } } if (p->attached_via_acct_mgr) { fprintf(f, " <account_key>%s</account_key>\n", p->authenticator ); } fprintf(f, " </project>\n" ); } MIOFILE mf; mf.init_file(f); // send working prefs // fprintf(f, "<working_global_preferences>\n"); gstate.global_prefs.write(mf); fprintf(f, "</working_global_preferences>\n"); if (boinc_file_exists(GLOBAL_PREFS_FILE_NAME)) { FILE* fprefs = fopen(GLOBAL_PREFS_FILE_NAME, "r"); if (fprefs) { copy_stream(fprefs, f); fclose(fprefs); } } gstate.host_info.write(mf, !cc_config.suppress_net_info, true); if (strlen(gstate.acct_mgr_info.opaque)) { fprintf(f, " <opaque>\n%s\n" " </opaque>\n", gstate.acct_mgr_info.opaque ); } gstate.time_stats.write(mf, true); gstate.net_stats.write(mf); fprintf(f, "</acct_mgr_request>\n"); fclose(f); snprintf(buf, sizeof(buf), "%srpc.php", ami.master_url); retval = gui_http->do_rpc_post( this, buf, ACCT_MGR_REQUEST_FILENAME, ACCT_MGR_REPLY_FILENAME, true ); if (retval) { error_num = retval; return retval; } msg_printf(NULL, MSG_INFO, "Contacting account manager at %s", ami.master_url); return 0; }
// determine the list of supported platforms. // void CLIENT_STATE::detect_platforms() { #if defined(_WIN32) && !defined(__CYGWIN32__) #if defined(_WIN64) && defined(_M_X64) add_platform("windows_x86_64"); add_platform("windows_intelx86"); #else // see if 32-bit client is running on 64-bit machine // BOOL bIsWow64 = FALSE; fnIsWow64Process = (LPFN_ISWOW64PROCESS)GetProcAddress( GetModuleHandle(TEXT("kernel32")),"IsWow64Process" ); if (fnIsWow64Process) { if (fnIsWow64Process(GetCurrentProcess(), &bIsWow64)) { if (bIsWow64) { add_platform("windows_x86_64"); } } } add_platform("windows_intelx86"); #endif #elif defined(__APPLE__) #if defined(__i386__) || defined(__x86_64__) OSStatus err = noErr; SInt32 version = 0; int response = 0; int retval = 0; size_t len = sizeof(response); err = Gestalt(gestaltSystemVersion, &version); retval = sysctlbyname("hw.optional.x86_64", &response, &len, NULL, 0); if ((err == noErr) && (version >= 0x1050) && response && (!retval)) { HOSTTYPE = "x86_64-apple-darwin"; add_platform("x86_64-apple-darwin"); } else { HOSTTYPE = "i686-apple-darwin"; } // Supported on both Mac Intel architectures add_platform("i686-apple-darwin"); #endif // Supported on all 3 Mac architectures add_platform("powerpc-apple-darwin"); #elif defined(__linux__) && ( defined(__i386__) || defined(__x86_64__) ) // Let's try to support both 32 and 64 bit applications in one client // regardless of whether it is a 32 or 64 bit client const char *uname[]={"/bin/uname","/usr/bin/uname",0}; int eno=0, support64=0, support32=0; FILE *f; char cmdline[256]; cmdline[0]=0; // find the 'uname' executable do { if (boinc_file_exists(uname[eno])) break; } while (uname[++eno] != 0); // run it and check the kernel machine architecture. if ( uname[eno] != 0 ) { strlcpy(cmdline,uname[eno],256); strlcat(cmdline," -m",256); if ((f=popen(cmdline,"r"))) { while (!std::feof(f)) { fgets(cmdline,256,f); if (strstr(cmdline,"x86_64")) support64=1; } pclose(f); } if (!support64) { // we're running on a 32 bit kernel, so we will assume // we are i686-pc-linux-gnu only. support32=1; } else { // we're running on a 64 bit kernel. // Now comes the hard part. How to tell whether we can run // 32-bit binaries. #if defined(__i386__) && !defined(__x86_64__) // If we're a 32 bit binary, then we obviously can. support32=1; #else // If we're a 64 bit binary, the check is a bit harder. // We'll use the file command to check installation of // 32 bit libraries or executables. const char *file[]={"/usr/bin/file","/bin/file",0}; const char *libdir[]={"/lib","/lib32","/lib/32","/usr/lib","/usr/lib32","/usr/lib/32"}; const int nlibdirs=sizeof(libdir)/sizeof(char *); // find 'file' eno=0; do { if (boinc_file_exists(file[eno])) break; } while (file[++eno] != 0); // now try to find a 32-bit C library. if (file[eno] != 0) { int i; for (i=0; i < nlibdirs; i++) { struct dirent *entry; DIR *a = opendir(libdir[i]); // if dir doesn't exist, do to the next one if (a == 0) continue; // dir exists. read each entry until you find a 32bit lib while ((support32 == 0) && ((entry=readdir(a)) != 0)) { strlcpy(cmdline, file[eno], 256); strlcat(cmdline, " -L ", 256); strlcat(cmdline, libdir[i], 256); strlcat(cmdline, "/", 256); strlcat(cmdline, entry->d_name, 256); f = popen(cmdline, "r"); if (f) { while (!std::feof(f)) { fgets(cmdline,256,f); // If the library is 32-bit ELF, then we're // golden. if (strstr(cmdline, "ELF") && strstr(cmdline, "32-bit")) support32=1; } pclose(f); } } closedir(a); if (support32) break; } } #endif } } if (support64) { add_platform("x86_64-pc-linux-gnu"); } if (support32) { add_platform("i686-pc-linux-gnu"); } if (!(support64 || support32)) { // Something went wrong. Assume HOSTTYPE and HOSTTYPEALT // are correct add_platform(HOSTTYPE); #ifdef HOSTTYPEALT add_platform(HOSTTYPEALT); #endif } #elif defined(sun) // Check if we can run 64-bit binaries... // this assumes there isn't a 64-bit only solaris. (Every 64-bit solaris can run 32 bit binaries) #if defined(__sparc) || defined(sparc) char *exe64=const_cast<char *>("/usr/bin/sparcv9/ls"); char *platform64=const_cast<char *>("sparc64-sun-solaris"); char *platform32=const_cast<char *>("sparc-sun-solaris"); #elif defined(__i386) || defined(i386) || defined(__amd64) || defined(__x86_64__) char *exe64=const_cast<char *>("/usr/bin/amd64/ls"); char *platform64=const_cast<char *>("x86_64-pc-solaris"); char *platform32=const_cast<char *>("i686-pc-solaris"); #else #define UNKNOWN_SOLARIS_PROCESSOR #endif #ifndef UNKNOWN_SOLARIS_PROCESSOR FILE *f=fopen(exe64,"r"); char *argv[3]; pid_t pid; int rv=0; argv[0]=exe64; argv[1]=argv[0]; argv[2]=NULL; if (f) { fclose(f); if (0==(pid=fork())) { // we are in child process freopen("/dev/null","a",stderr); freopen("/dev/null","a",stdout); rv=execv(argv[0],argv); exit(rv); } else { // we are in the parent process. time_t start=time(0); int done; // wait 5 seconds or until the process exits. do { done=waitpid(pid,&rv,WNOHANG); sleep(1); } while (!done && ((time(0)-start)<5)); // if we timed out, kill the process if ((time(0)-start)>=5) { kill(pid,SIGKILL); done=-1; } // if we exited with success add the 64 bit platform if ((done == pid) && (rv == 0)) { add_platform(platform64); } } } add_platform(platform32); // the following platform is obsolete, but we'll add it anyway. #if defined(__sparc) || defined(sparc) add_platform("sparc-sun-solaris2.7"); #endif #else // !defined(UNKNOWN_SOLARIS_PROCESSOR) add_platform(HOSTTYPE); #ifdef HOSTTYPEALT add_platform(HOSTTYPEALT); #endif #endif // !defined(UNKNOWN_SOLARIS_PROCESSOR) #else // Any other platform, fall back to the previous method add_platform(HOSTTYPE); #ifdef HOSTTYPEALT add_platform(HOSTTYPEALT); #endif #endif if (config.no_alt_platform) { PLATFORM p = platforms[0]; platforms.clear(); platforms.push_back(p); } // add platforms listed in cc_config.xml AFTER the above. // for (unsigned int i=0; i<config.alt_platforms.size(); i++) { add_platform(config.alt_platforms[i].c_str()); } }
void do_client_simulation() { char buf[256], buf2[256]; int retval; FILE* f; sprintf(buf, "%s%s", infile_prefix, CONFIG_FILE); cc_config.defaults(); read_config_file(true, buf); log_flags.init(); sprintf(buf, "%s%s", outfile_prefix, "log_flags.xml"); f = fopen(buf, "r"); if (f) { MIOFILE mf; mf.init_file(f); XML_PARSER xp(&mf); xp.get_tag(); // skip open tag log_flags.parse(xp); fclose(f); } gstate.add_platform("client simulator"); sprintf(buf, "%s%s", infile_prefix, STATE_FILE_NAME); if (!boinc_file_exists(buf)) { fprintf(stderr, "No client state file\n"); exit(1); } retval = gstate.parse_state_file_aux(buf); if (retval) { fprintf(stderr, "state file parse error %d\n", retval); exit(1); } // if tasks have pending transfers, mark as completed // for (unsigned int i=0; i<gstate.results.size(); i++) { RESULT* rp = gstate.results[i]; if (rp->state() < RESULT_FILES_DOWNLOADED) { rp->set_state(RESULT_FILES_DOWNLOADED, "init"); } else if (rp->state() == RESULT_FILES_UPLOADING) { rp->set_state(RESULT_FILES_UPLOADED, "init"); } } check_app_config(infile_prefix); show_app_config(); cc_config.show(); log_flags.show(); sprintf(buf, "%s%s", infile_prefix, GLOBAL_PREFS_FILE_NAME); sprintf(buf2, "%s%s", infile_prefix, GLOBAL_PREFS_OVERRIDE_FILE); gstate.read_global_prefs(buf, buf2); fprintf(index_file, "<h3>Output files</h3>\n" "<a href=%s>Summary</a>\n" "<br><a href=%s>Log file</a>\n", SUMMARY_FNAME, LOG_FNAME ); // fill in GPU device nums and OpenCL flags // for (int i=0; i<coprocs.n_rsc; i++) { COPROC& cp = coprocs.coprocs[i]; for (int j=0; j<cp.count; j++) { cp.device_nums[j] = j; if (cp.have_opencl) { cp.instance_has_opencl[j] = true; } } } set_no_rsc_config(); process_gpu_exclusions(); get_app_params(); if (!include_empty_projects) { cull_projects(); } fprintf(summary_file, "--------------------------\n"); int j=0; for (unsigned int i=0; i<gstate.projects.size(); i++) { gstate.projects[i]->index = j++; } clear_backoff(); gstate.log_show_projects(); gstate.set_ncpus(); work_fetch.init(); //set_initial_rec(); rec_adjust_period = delta; gstate.request_work_fetch("init"); simulate(); sim_results.compute_figures_of_merit(); sprintf(buf, "%s%s", outfile_prefix, RESULTS_DAT_FNAME); f = fopen(buf, "w"); sim_results.print(f); fclose(f); sprintf(buf, "%s%s", outfile_prefix, RESULTS_TXT_FNAME); f = fopen(buf, "w"); sim_results.print(f, true); fclose(f); fprintf(summary_file, "Simulation done.\n" "-------------------------\n" "Figures of merit:\n" ); sim_results.print(summary_file, true); double cpu_time; boinc_calling_thread_cpu_time(cpu_time); fprintf(summary_file, "-------------------------\n" "Simulator CPU time: %f secs\n" "-------------------------\n" "Peak FLOPS: CPU %.2fG GPU %.2fG\n", cpu_time, cpu_peak_flops()/1e9, gpu_peak_flops()/1e9 ); print_project_results(summary_file); fclose(rec_file); make_graph("REC", "rec", 0); }
// assimilate_handler() is called by BOINC code and is passed the canonical // result for a workunit. assimilate_handler() reads the referenced result // file and inserts the result and its signals into the master science DB. // BOINC also passes the workunit (as it appears in the BOINC DB) and a vector // containing all results (including the canonical one) for that workunit. // We use the workunit to determine if there is an error condition. int assimilate_handler( WORKUNIT& boinc_wu, vector<RESULT>& boinc_results, RESULT& boinc_canonical_result ) { int retval=0; int spike_count=0, spike_inserted_count=0, gaussian_count=0, gaussian_inserted_count=0, pulse_count=0, pulse_inserted_count=0, triplet_count=0, triplet_inserted_count=0; static receiver_config receiver_cfg; static analysis_config analysis_cfg; workunit s_wu; workunit_grp s_wu_grp; result sah_result; spike sah_spike; gaussian sah_gaussian; pulse sah_pulse; triplet sah_triplet; char filename[256]; char * path; std::string path_str; long sah_result_id; sqlint8_t sah_spike_id, sah_gaussian_id, sah_pulse_id, sah_triplet_id; static bool first_time = true; int sql_error_code; long long seti_wu_id; time_t now; int hotpix_update_count; int hotpix_insert_count; APP_CONFIG sah_config; hotpix hotpix; list<long> qpixlist; // will be a unique list of qpixes for // updating the hotpix table list<long>::iterator qpix_i; nanotime.tv_sec = 0; nanotime.tv_nsec = 1000000; // app specific configuration if (first_time) { first_time = false; receiver_cfg.id = 0; analysis_cfg.id = 0; retval = sah_config.parse_file(".."); if (retval) { log_messages.printf(SCHED_MSG_LOG::MSG_CRITICAL, "First entrance to handler : can't parse config file. Exiting.\n" ); return(retval); } else { retval = db_change(sah_config.scidb_name); if (!retval) { log_messages.printf(SCHED_MSG_LOG::MSG_CRITICAL, "First entrance to handler : could not open science DB %s. Exiting.\n", sah_config.scidb_name ); return(retval); } else { log_messages.printf(SCHED_MSG_LOG::MSG_NORMAL, "First entrance to handler : using science DB %s\n", sah_config.scidb_name ); } } // Sometimes we want to perform all assimilation functions // *except* insertion into the science master DB. if (noinsert) { log_messages.printf(SCHED_MSG_LOG::MSG_NORMAL, "[%s] assimilator is in noinsert mode.\n", boinc_wu.name ); } } else { /* retval = db_change(sah_config.scidb_name); if (!retval) { log_messages.printf(SCHED_MSG_LOG::MSG_CRITICAL, "First entrance to handler : could not open science DB %s. Exiting.\n", sah_config.scidb_name ); return(retval); } else { log_messages.printf(SCHED_MSG_LOG::MSG_NORMAL, "First entrance to handler : using science DB %s\n", sah_config.scidb_name ); } */ } if (noinsert) return 0; // Note that this will result in the WU being marked as assimilated - // we will not see it again. // translate seti wuid for thos wus that changed ids during the DB merge seti_wu_id = new_wu_id((long long)boinc_wu.opaque); log_messages.printf(SCHED_MSG_LOG::MSG_DEBUG, "[%s] old seti WU id is : %lld new seti WU id is : %lld\n", boinc_wu.name, (long long)boinc_wu.opaque, seti_wu_id ); if (boinc_wu.canonical_resultid) { log_messages.printf(SCHED_MSG_LOG::MSG_DEBUG, "[%s] Canonical result is %d. SETI workunit ID is %lld.\n", boinc_wu.name, boinc_wu.canonical_resultid, seti_wu_id ); } else { log_messages.printf(SCHED_MSG_LOG::MSG_CRITICAL, "[%s] No canonical result\n", boinc_wu.name ); } if (!boinc_wu.canonical_resultid) { return 0; // Note that this will result in the WU being marked as assimilated - // we will not see it again. No canonical result means that // too many results were returned with no concensus. } // Obtain and check the full path to the boinc result file. retval = get_output_file_path(boinc_canonical_result, path_str); if (retval) { if (retval == ERR_XML_PARSE) { log_messages.printf(SCHED_MSG_LOG::MSG_CRITICAL, "[%s] Cannot extract filename from canonical result %ld.\n", boinc_wu.name, boinc_wu.canonical_resultid); return(retval); } else { log_messages.printf(SCHED_MSG_LOG::MSG_CRITICAL, "[%s] unknown error from get_output_file_path() for result %ld.\n", boinc_wu.name, boinc_wu.canonical_resultid); return(retval); } } else { path = (char *)path_str.c_str(); if (!boinc_file_exists(path)) { log_messages.printf(SCHED_MSG_LOG::MSG_CRITICAL, "[%s] Output file %s does not exist for result %ld.\n", boinc_wu.name, path, boinc_wu.canonical_resultid); return(-1); } else { log_messages.printf(SCHED_MSG_LOG::MSG_DEBUG, "[%s] Result %ld : using upload file %s\n", boinc_wu.name, boinc_wu.canonical_resultid, path); } } // Open it. std::ifstream result_file(path, ios_base::in); if (!result_file.is_open()) { log_messages.printf(SCHED_MSG_LOG::MSG_CRITICAL, "[%s] open error for result file %s : errno %d\n", boinc_wu.name, path, errno ); return -1; } retval = get_science_configs(boinc_wu, seti_wu_id, receiver_cfg, analysis_cfg); if (retval) { if (retval == 100) { return (0); } else { return (-1); } } log_messages.printf(SCHED_MSG_LOG::MSG_DEBUG, "[%s] Result %ld : using receiver_cfg %d and analysis_cfg %d\n", boinc_wu.name, boinc_wu.canonical_resultid, receiver_cfg.id, analysis_cfg.id); // Insert a sah result retval = populate_seti_result(sah_result, boinc_canonical_result, boinc_wu, seti_wu_id); sah_result_id = sah_result.insert(); if (sah_result_id) { log_messages.printf(SCHED_MSG_LOG::MSG_NORMAL, "[%s] Inserted result. Boinc result id is %d. Sah result id is %lld.\n", boinc_wu.name, boinc_canonical_result.id, (long long)sah_result_id ); } else { if (sql_last_error_code() == -239 || sql_last_error_code() == -268) { log_messages.printf(SCHED_MSG_LOG::MSG_CRITICAL, "[%s] Could not insert duplicate result. SQLCODE is %ld. SQLMSG is %s.\n", boinc_wu.name, sql_last_error_code(), sql_error_message() ); return 0; // non-fatal - we will never see this result again } else { log_messages.printf(SCHED_MSG_LOG::MSG_CRITICAL, "[%s] Could not insert result. SQLCODE is %ld. SQLMSG is %s.\n", boinc_wu.name, sql_last_error_code(), sql_error_message() ); return -1; // fatal - non-dup error } } // Insert all sah signals in turn insert_signals( sah_spike, "spike", boinc_wu.name, sah_result_id, result_file, receiver_cfg, boinc_canonical_result.appid, analysis_cfg.max_spikes, qpixlist); insert_signals( sah_gaussian, "gaussian", boinc_wu.name, sah_result_id, result_file, receiver_cfg, boinc_canonical_result.appid, analysis_cfg.max_gaussians, qpixlist); insert_signals( sah_pulse, "pulse", boinc_wu.name, sah_result_id, result_file, receiver_cfg, boinc_canonical_result.appid, analysis_cfg.max_pulses, qpixlist); insert_signals( sah_triplet, "triplet", boinc_wu.name, sah_result_id, result_file, receiver_cfg, boinc_canonical_result.appid, analysis_cfg.max_triplets, qpixlist); // update last hit time to now for each qpix hit qpixlist.unique(); hotpix_update_count = 0; hotpix_insert_count = 0; time(&now); for(qpix_i = qpixlist.begin(); qpix_i != qpixlist.end(); qpix_i++) { if (hotpix.fetch(*qpix_i)) { hotpix.last_hit_time = now; hotpix.update(); hotpix_update_count++; } else { hotpix.id = *qpix_i; hotpix.last_hit_time = now; hotpix.insert(*qpix_i); hotpix_insert_count++; } } log_messages.printf(SCHED_MSG_LOG::MSG_DEBUG, "[%s] Updated %d rows and inserted %d rows in the hotpix table\n", boinc_wu.name, hotpix_update_count, hotpix_insert_count ); return 0; // the successful assimilation of one WU }
int CSkinAdvanced::Parse(MIOFILE& in) { char buf[256]; std::string strBuffer; while (in.fgets(buf, 256)) { if (match_tag(buf, "</advanced>")) break; else if (parse_bool(buf, "is_branded", m_bIsBranded)) continue; else if (parse_str(buf, "<application_name>", strBuffer)) { m_strApplicationName = wxString(strBuffer.c_str(), wxConvUTF8); continue; } else if (parse_str(buf, "<application_short_name>", strBuffer)) { m_strApplicationShortName = wxString(strBuffer.c_str(), wxConvUTF8); continue; } else if (match_tag(buf, "<application_icon>")) { m_iconApplicationIcon.Parse(in); continue; } else if (match_tag(buf, "<application_icon32>")) { m_iconApplicationIcon.Parse32(in); continue; } else if (match_tag(buf, "<application_disconnected_icon>")) { m_iconApplicationDisconnectedIcon.Parse(in); continue; } else if (match_tag(buf, "<application_snooze_icon>")) { m_iconApplicationSnoozeIcon.Parse(in); continue; } else if (parse_str(buf, "<application_logo>", strBuffer)) { if(strBuffer.length()) { wxString str = wxString( wxGetApp().GetSkinManager()->ConstructSkinPath() + wxString(strBuffer.c_str(), wxConvUTF8) ); if (boinc_file_exists(str.c_str())) { wxImage img = wxImage(str.c_str(), wxBITMAP_TYPE_ANY); if (img.IsOk()) { #ifdef __WXMSW__ // TODO: Choose from multiple size images if provided, else resize the closest one if ((GetXDPIScaling() > 1.05) || (GetYDPIScaling() > 1.05)) { img.Rescale((int) (img.GetWidth()*GetXDPIScaling()), (int) (img.GetHeight()*GetYDPIScaling()), wxIMAGE_QUALITY_BILINEAR ); } #endif m_bitmapApplicationLogo = wxBitmap(img); } } } continue; } else if (parse_str(buf, "<organization_name>", strBuffer)) { m_strOrganizationName = wxString(strBuffer.c_str(), wxConvUTF8); continue; } else if (parse_str(buf, "<organization_website>", strBuffer)) { m_strOrganizationWebsite = wxString(strBuffer.c_str(), wxConvUTF8); continue; } else if (parse_str(buf, "<organization_help_url>", strBuffer)) { m_strOrganizationHelpUrl = wxString(strBuffer.c_str(), wxConvUTF8); continue; } else if (parse_int(buf, "<open_tab>", m_iDefaultTab)) { m_bDefaultTabSpecified = true; continue; } else if (parse_str(buf, "<exit_message>", strBuffer)) { m_strExitMessage = wxString(strBuffer.c_str(), wxConvUTF8); continue; } } InitializeDelayedValidation(); return 0; }
bool check_stop_sched() { return boinc_file_exists(config.project_path(STOP_SCHED_FILENAME)); }
// do an account manager RPC; // if URL is null, detach from current account manager // int ACCT_MGR_OP::do_rpc( std::string _url, std::string name, std::string password_hash, bool _via_gui ) { int retval; unsigned int i; char url[256], password[256], buf[256]; FILE *pwdf; strlcpy(url, _url.c_str(), sizeof(url)); error_num = ERR_IN_PROGRESS; via_gui = _via_gui; if (global_prefs_xml) { free(global_prefs_xml); global_prefs_xml = 0; } // if null URL, detach from current AMS // if (!strlen(url) && strlen(gstate.acct_mgr_info.acct_mgr_url)) { msg_printf(NULL, MSG_INFO, "Removing account manager info"); gstate.acct_mgr_info.clear(); boinc_delete_file(ACCT_MGR_URL_FILENAME); boinc_delete_file(ACCT_MGR_LOGIN_FILENAME); error_num = 0; for (i=0; i<gstate.projects.size(); i++) { PROJECT* p = gstate.projects[i]; p->attached_via_acct_mgr = false; p->ams_resource_share = -1; } return 0; } canonicalize_master_url(url); if (!valid_master_url(url)) { error_num = ERR_INVALID_URL; return 0; } strlcpy(ami.acct_mgr_url, url, sizeof(ami.acct_mgr_url)); strlcpy(ami.acct_mgr_name, "", sizeof(ami.acct_mgr_name)); strlcpy(ami.login_name, name.c_str(), sizeof(ami.login_name)); strlcpy(ami.password_hash, password_hash.c_str(), sizeof(ami.password_hash)); FILE* f = boinc_fopen(ACCT_MGR_REQUEST_FILENAME, "w"); if (!f) return ERR_FOPEN; fprintf(f, "<acct_mgr_request>\n" " <name>%s</name>\n" " <password_hash>%s</password_hash>\n" " <host_cpid>%s</host_cpid>\n" " <domain_name>%s</domain_name>\n" " <client_version>%d.%d.%d</client_version>\n" " <run_mode>%s</run_mode>\n", name.c_str(), password_hash.c_str(), gstate.host_info.host_cpid, gstate.host_info.domain_name, gstate.core_client_version.major, gstate.core_client_version.minor, gstate.core_client_version.release, run_mode_name[gstate.run_mode.get_perm()] ); if (strlen(gstate.acct_mgr_info.previous_host_cpid)) { fprintf(f, " <previous_host_cpid>%s</previous_host_cpid>\n", gstate.acct_mgr_info.previous_host_cpid ); } // If the AMS requested it, send GUI RPC port and password hash. // This is for the "farm" account manager so it // can know where to send GUI RPC requests to // without having to configure each host // if (gstate.acct_mgr_info.send_gui_rpc_info) { if (gstate.cmdline_gui_rpc_port) { fprintf(f," <gui_rpc_port>%d</gui_rpc_port>\n", gstate.cmdline_gui_rpc_port); } else { fprintf(f," <gui_rpc_port>%d</gui_rpc_port>\n", GUI_RPC_PORT); } if (boinc_file_exists(GUI_RPC_PASSWD_FILE)) { strcpy(password, ""); pwdf = fopen(GUI_RPC_PASSWD_FILE, "r"); if (pwdf) { if (fgets(password, 256, pwdf)) { strip_whitespace(password); } fclose(pwdf); } fprintf(f," <gui_rpc_password>%s</gui_rpc_password>\n", password); } } for (i=0; i<gstate.projects.size(); i++) { PROJECT* p = gstate.projects[i]; fprintf(f, " <project>\n" " <url>%s</url>\n" " <project_name>%s</project_name>\n" " <suspended_via_gui>%d</suspended_via_gui>\n" " <account_key>%s</account_key>\n" " <hostid>%d</hostid>\n" "%s" " </project>\n", p->master_url, p->project_name, p->suspended_via_gui, p->authenticator, p->hostid, p->attached_via_acct_mgr?" <attached_via_acct_mgr/>\n":"" ); } if (boinc_file_exists(GLOBAL_PREFS_FILE_NAME)) { FILE* fprefs = fopen(GLOBAL_PREFS_FILE_NAME, "r"); if (fprefs) { copy_stream(fprefs, f); fclose(fprefs); } } if (strlen(gstate.acct_mgr_info.opaque)) { fprintf(f, " <opaque>\n%s\n" " </opaque>\n", gstate.acct_mgr_info.opaque ); } fprintf(f, "</acct_mgr_request>\n"); fclose(f); sprintf(buf, "%srpc.php", url); retval = gstate.gui_http.do_rpc_post( this, buf, ACCT_MGR_REQUEST_FILENAME, ACCT_MGR_REPLY_FILENAME ); if (retval) { error_num = retval; return retval; } msg_printf(NULL, MSG_INFO, "Contacting account manager at %s", url); return 0; }
bool CBOINCClientManager::IsBOINCCoreRunning() { wxLogTrace(wxT("Function Start/End"), wxT("CBOINCClientManager::IsBOINCCoreRunning - Function Begin")); bool running = false; #ifdef __WXMSW__ char buf[MAX_PATH] = ""; if (is_daemon_installed()) { running = (FALSE != is_daemon_starting()) || (FALSE != is_daemon_running()); } else { // Global mutex on Win2k and later // safe_strcpy(buf, "Global\\"); strcat( buf, RUN_MUTEX); HANDLE h = CreateMutexA(NULL, true, buf); DWORD err = GetLastError(); if ((h==0) || (err == ERROR_ALREADY_EXISTS)) { running = true; } if (h) { CloseHandle(h); } } #elif defined(__WXMAC__) char path[1024]; static FILE_LOCK file_lock; sprintf(path, "%s/%s", (const char *)wxGetApp().GetDataDirectory().mb_str(), LOCK_FILE_NAME); if (boinc_file_exists(path)) { // If there is no lock file, core is not running if (file_lock.lock(path)) { running = true; } else { file_lock.unlock(path); } } #else PROC_MAP pm; int retval; if (m_lBOINCCoreProcessId) { // Prevent client from being a zombie if (waitpid(m_lBOINCCoreProcessId, 0, WNOHANG) == m_lBOINCCoreProcessId) { m_lBOINCCoreProcessId = 0; } } // Look for BOINC Client in list of all running processes retval = procinfo_setup(pm); if (retval) return false; // Should never happen PROC_MAP::iterator i; for (i=pm.begin(); i!=pm.end(); i++) { PROCINFO& pi = i->second; if (!strcmp(pi.command, "boinc")) { running = true; break; } if (!strcmp(pi.command, "boinc_client")) { running = true; break; } } #endif wxLogTrace(wxT("Function Status"), wxT("CBOINCClientManager::IsBOINCCoreRunning - Returning '%d'"), (int)running); wxLogTrace(wxT("Function Start/End"), wxT("CBOINCClientManager::IsBOINCCoreRunning - Function End")); return running; }
void chdir_to_data_dir() { LONG lReturnValue; HKEY hkSetupHive; char szPath[MAX_PATH]; LPSTR lpszValue = NULL; LPSTR lpszExpandedValue = NULL; DWORD dwValueType = REG_EXPAND_SZ; DWORD dwSize = 0; // change the current directory to the boinc data directory if it exists lReturnValue = RegOpenKeyExA( HKEY_LOCAL_MACHINE, "SOFTWARE\\Space Sciences Laboratory, U.C. Berkeley\\BOINC Setup", 0, KEY_READ, &hkSetupHive ); if (lReturnValue == ERROR_SUCCESS) { // How large does our buffer need to be? lReturnValue = RegQueryValueExA( hkSetupHive, "DATADIR", NULL, &dwValueType, NULL, &dwSize ); if (lReturnValue != ERROR_FILE_NOT_FOUND) { // Allocate the buffer space. lpszValue = (LPSTR) malloc(dwSize); (*lpszValue) = NULL; // Now get the data lReturnValue = RegQueryValueExA( hkSetupHive, "DATADIR", NULL, &dwValueType, (LPBYTE)lpszValue, &dwSize ); // Expand the Strings // We need to get the size of the buffer needed dwSize = 0; lReturnValue = ExpandEnvironmentStringsA(lpszValue, NULL, dwSize); if (lReturnValue) { // Make the buffer big enough for the expanded string lpszExpandedValue = (LPSTR) malloc(lReturnValue); (*lpszExpandedValue) = NULL; dwSize = lReturnValue; ExpandEnvironmentStringsA(lpszValue, lpszExpandedValue, dwSize); SetCurrentDirectoryA(lpszExpandedValue); } } } else { if (SUCCEEDED(SHGetFolderPathA(NULL, CSIDL_COMMON_APPDATA|CSIDL_FLAG_CREATE, NULL, SHGFP_TYPE_CURRENT, szPath))) { strncat(szPath, "\\boinc", (sizeof(szPath) - strlen(szPath))); if (boinc_file_exists(szPath)) { SetCurrentDirectoryA(szPath); } } } if (hkSetupHive) RegCloseKey(hkSetupHive); if (lpszValue) free(lpszValue); if (lpszExpandedValue) free(lpszExpandedValue); }
/// Start a task in a slot directory. /// This includes setting up soft links, /// passing preferences, and starting the process. /// /// Current dir is top-level Synecdoche dir. /// /// \post /// - If any error occurs /// - #task_state is #PROCESS_COULDNT_START /// - CLIENT_STATE::report_result_error() is called /// - else /// - #task_state is #PROCESS_EXECUTING /// /// \return 0 on success, nonzero otherwise. int ACTIVE_TASK::start() { char exec_name[256], exec_path[256]; unsigned int i; FILE_REF fref; int retval; // F*** goto, need to define some variables here instead of where they are used! std::ostringstream err_stream; #ifdef _WIN32 std::string cmd_line; std::string slotdirpath; #else // Needs to be defined here because those gotos would skip the // initialization of 'cmdline' and 'argv' if it would be defined later. std::ostringstream cmdline; std::list<std::string> argv; #endif if ((!full_init_done) && (log_flags.task)) { msg_printf(wup->project, MSG_INFO, "Starting %s", result->name ); } if (log_flags.cpu_sched) { msg_printf(wup->project, MSG_INFO, "[cpu_sched] Starting %s%s", result->name, (full_init_done) ? " (resume)" : " (initial)" ); } // Always check if all required files are present. If not, trigger // re-downloads and don't start the science application. FILE_INFO_PSET missing_file_infos; retval = gstate.input_files_available(result, true, &missing_file_infos); if (retval) { for (FILE_INFO_PSET::iterator it = missing_file_infos.begin(); it != missing_file_infos.end(); ++it) { FILE_INFO* fip = *it; if (fip) { err_stream << "Input file " << fip->name << " missing or invalid: " << retval; } else { err_stream << "Input file missing or invalid"; // We can't trigger a new download if we don't have // any file information. Just fail here as before. goto error; } fip->status = FILE_NOT_PRESENT; } } if (!missing_file_infos.empty()) { // Some files are missing and are set for re-transfer. // Update status and return without error. result->set_state(RESULT_FILES_DOWNLOADING, "start"); set_task_state(PROCESS_UNINITIALIZED, "start"); next_scheduler_state = PROCESS_UNINITIALIZED; return 0; } if (!full_init_done) { checkpoint_cpu_time = 0; checkpoint_wall_time = gstate.now; } current_cpu_time = checkpoint_cpu_time; episode_start_cpu_time = checkpoint_cpu_time; debt_interval_start_cpu_time = checkpoint_cpu_time; graphics_request_queue.init(result->name); // reset message queues process_control_queue.init(result->name); if (!app_client_shm.shm) { retval = get_shmem_seg_name(); if (retval) { err_stream << "Can't get shared memory segment name: " << boincerror(retval); goto error; } } // this must go AFTER creating shmem name, // since the shmem name is part of the file // retval = write_app_init_file(); if (retval) { err_stream << "Can't write init file: " << retval; goto error; } // set up applications files // strcpy(exec_name, ""); for (i=0; i<app_version->app_files.size(); i++) { fref = app_version->app_files[i]; FILE_INFO* fip = fref.file_info; std::string file_path = get_pathname(fip); if (fref.main_program) { if (is_image_file(fip->name)) { err_stream << "Main program " << fip->name << " is an image file"; retval = ERR_NO_SIGNATURE; goto error; } if (!fip->executable && !wup->project->anonymous_platform) { err_stream << "Main program " << fip->name << " is not executable"; retval = ERR_NO_SIGNATURE; goto error; } safe_strcpy(exec_name, fip->name.c_str()); safe_strcpy(exec_path, file_path.c_str()); } // anonymous platform may use different files than // when the result was started, so link files even if not first time if ((!full_init_done) || (wup->project->anonymous_platform)) { retval = setup_file(result->project, fip, fref, file_path, slot_dir, true); if (retval) { err_stream << "Can't link input file"; goto error; } } } if (!strlen(exec_name)) { err_stream << "No main program specified"; retval = ERR_NOT_FOUND; goto error; } // set up input, output files if (!full_init_done) { for (i=0; i<wup->input_files.size(); i++) { fref = wup->input_files[i]; const FILE_INFO* fip = fref.file_info; std::string file_path = get_pathname(fref.file_info); retval = setup_file(result->project, fip, fref, file_path, slot_dir, true); if (retval) { err_stream << "Can't link input file"; goto error; } } for (i=0; i<result->output_files.size(); i++) { fref = result->output_files[i]; if (fref.copy_file) continue; const FILE_INFO* fip = fref.file_info; std::string file_path = get_pathname(fref.file_info); retval = setup_file(result->project, fip, fref, file_path, slot_dir, false); if (retval) { err_stream << "Can't link output file"; goto error; } } full_init_done = true; } link_user_files(); if (gstate.exit_before_start) { exit(0); } #ifdef _WIN32 PROCESS_INFORMATION process_info; STARTUPINFO startup_info; LPVOID environment_block = NULL; char error_msg[1024]; char error_msg2[1024]; memset(&process_info, 0, sizeof(process_info)); memset(&startup_info, 0, sizeof(startup_info)); startup_info.cb = sizeof(startup_info); // suppress 2-sec rotating hourglass cursor on startup // startup_info.dwFlags = STARTF_FORCEOFFFEEDBACK; app_client_shm.reset_msgs(); if (config.run_apps_manually) { // fill in core client's PID so we won't think app has exited pid = GetCurrentProcessId(); pid_handle = GetCurrentProcess(); set_task_state(PROCESS_EXECUTING, "start"); return 0; } // NOTE: in Windows, stderr is redirected in boinc_init_diagnostics(); cmd_line = exec_path + std::string(" ") + wup->command_line; if (strlen(app_version->cmdline)) { cmd_line += std::string(" ") + app_version->cmdline; } slotdirpath = relative_to_absolute(slot_dir); bool success = false; for (i=0; i<5; i++) { if (sandbox_account_service_token != NULL) { // Find CreateEnvironmentBlock/DestroyEnvironmentBlock pointers tCEB pCEB = NULL; tDEB pDEB = NULL; HMODULE hUserEnvLib = NULL; hUserEnvLib = LoadLibrary("userenv.dll"); if (hUserEnvLib) { pCEB = (tCEB) GetProcAddress(hUserEnvLib, "CreateEnvironmentBlock"); pDEB = (tDEB) GetProcAddress(hUserEnvLib, "DestroyEnvironmentBlock"); } if (!pCEB(&environment_block, sandbox_account_service_token, FALSE)) { if (log_flags.task) { windows_error_string(error_msg, sizeof(error_msg)); msg_printf(wup->project, MSG_INFO, "Process environment block creation failed: %s", error_msg ); } } if (CreateProcessAsUser( sandbox_account_service_token, exec_path, (LPSTR)cmd_line.c_str(), NULL, NULL, FALSE, CREATE_NEW_PROCESS_GROUP|CREATE_NO_WINDOW|IDLE_PRIORITY_CLASS|CREATE_UNICODE_ENVIRONMENT, environment_block, slotdirpath.c_str(), &startup_info, &process_info )) { success = true; break; } else { windows_error_string(error_msg, sizeof(error_msg)); msg_printf(wup->project, MSG_INTERNAL_ERROR, "Process creation failed: %s", error_msg ); } if (!pDEB(environment_block)) { if (log_flags.task) { windows_error_string(error_msg, sizeof(error_msg2)); msg_printf(wup->project, MSG_INFO, "Process environment block cleanup failed: %s", error_msg2 ); } } if (hUserEnvLib) { pCEB = NULL; pDEB = NULL; FreeLibrary(hUserEnvLib); } } else { if (CreateProcess( exec_path, (LPSTR)cmd_line.c_str(), NULL, NULL, FALSE, CREATE_NEW_PROCESS_GROUP|CREATE_NO_WINDOW|IDLE_PRIORITY_CLASS, NULL, slotdirpath.c_str(), &startup_info, &process_info )) { success = true; break; } else { windows_error_string(error_msg, sizeof(error_msg)); msg_printf(wup->project, MSG_INTERNAL_ERROR, "Process creation failed: %s", error_msg ); } } boinc_sleep(drand()); } if (!success) { err_stream << "CreateProcess() failed - " << error_msg; retval = ERR_EXEC; goto error; } pid = process_info.dwProcessId; pid_handle = process_info.hProcess; CloseHandle(process_info.hThread); // thread handle is not used #else // Unix/Linux/Mac case // Set up core/app shared memory seg if needed // if (!app_client_shm.shm) { if (app_version->api_major_version() >= 6) { // Use mmap() shared memory std::string buf = slot_dir + std::string("/") + std::string(MMAPPED_FILE_NAME); if (g_use_sandbox) { if (!boinc_file_exists(buf.c_str())) { int fd = open(buf.c_str(), O_RDWR | O_CREAT, 0660); if (fd >= 0) { close (fd); #ifdef SANDBOX set_to_project_group(buf.c_str()); #endif } } } retval = create_shmem_mmap( buf.c_str(), sizeof(SHARED_MEM), (void**)&app_client_shm.shm ); } else { // Use shmget() shared memory retval = create_shmem( shmem_seg_name, sizeof(SHARED_MEM), gstate.boinc_project_gid, (void**)&app_client_shm.shm ); if (retval) { needs_shmem = true; destroy_shmem(shmem_seg_name); return retval; } } needs_shmem = false; } app_client_shm.reset_msgs(); #if (defined (__APPLE__) && (defined(__i386__) || defined(__x86_64__))) // PowerPC apps emulated on i386 Macs crash if running graphics powerpc_emulated_on_i386 = ! is_native_i386_app(exec_path); #endif if (config.run_apps_manually) { pid = getpid(); // use the client's PID set_task_state(PROCESS_EXECUTING, "start"); return 0; } // Prepare command line for the science app: cmdline << wup->command_line; if (strlen(app_version->cmdline)) { cmdline << ' ' << app_version->cmdline; } argv = parse_command_line(cmdline.str().c_str()); if (log_flags.task_debug) { debug_print_argv(argv); } pid = fork(); if (pid == -1) { err_stream << "fork() failed: " << strerror(errno); retval = ERR_FORK; goto error; } if (pid == 0) { // from here on we're running in a new process. // If an error happens, // exit nonzero so that the core client knows there was a problem. // don't pass stdout to the app // int fd = open("/dev/null", O_RDWR); dup2(fd, STDOUT_FILENO); close(fd); // add to library path: // - the project dir (../../projects/X) // - the slot dir (.) // - the Synecdoche dir (../..) // We use relative paths in case higher-level dirs // are not readable to the account under which app runs // std::string pdir = get_project_dir(wup->project); std::ostringstream libpath; const char* env_lib_path = getenv("LD_LIBRARY_PATH"); if (env_lib_path) { libpath << env_lib_path << ':'; } libpath << "../../" << pdir << ":.:../.."; setenv("LD_LIBRARY_PATH", libpath.str().c_str(), 1); retval = chdir(slot_dir.c_str()); if (retval) { perror("chdir"); fflush(NULL); _exit(errno); } #if 0 // set stack size limit to the max. // Some BOINC apps have reported problems with exceeding // small stack limits (e.g. 8 MB) // and it seems like the best thing to raise it as high as possible // struct rlimit rlim; #define MIN_STACK_LIMIT 64000000 getrlimit(RLIMIT_STACK, &rlim); if (rlim.rlim_cur != RLIM_INFINITY && rlim.rlim_cur <= MIN_STACK_LIMIT) { if (rlim.rlim_max == RLIM_INFINITY || rlim.rlim_max > MIN_STACK_LIMIT) { rlim.rlim_cur = MIN_STACK_LIMIT; } else { rlim.rlim_cur = rlim.rlim_max; } setrlimit(RLIMIT_STACK, &rlim); } #endif // hook up stderr to a specially-named file // freopen(STDERR_FILE, "a", stderr); // set idle process priority #ifdef HAVE_SETPRIORITY if (setpriority(PRIO_PROCESS, 0, PROCESS_IDLE_PRIORITY)) { perror("setpriority"); } #endif std::string path = std::string("../../") + std::string(exec_path); if (g_use_sandbox) { std::ostringstream switcher_path; switcher_path << "../../" << SWITCHER_DIR << '/' << SWITCHER_FILE_NAME; argv.push_front(exec_name); argv.push_front(path); argv.push_front(SWITCHER_FILE_NAME); // Files written by projects have user boinc_project and group boinc_project, // so they must be world-readable so Synecdoche can read them. umask(2); retval = do_execv(switcher_path.str(), argv); } else { argv.push_front(exec_name); retval = do_execv(path, argv); } msg_printf(wup->project, MSG_INTERNAL_ERROR, "Process creation (%s) failed: %s, errno=%d\n", path.c_str(), boincerror(retval), errno ); perror("execv"); fflush(NULL); _exit(errno); } if (log_flags.task_debug) { msg_printf(wup->project, MSG_INFO, "[task_debug] ACTIVE_TASK::start(): forked process: pid %d\n", pid ); } #endif set_task_state(PROCESS_EXECUTING, "start"); return 0; // go here on error; "error_msg" contains error message, "retval" is nonzero // error: // if something failed, it's possible that the executable was munged. // Verify it to trigger another download. // gstate.input_files_available(result, true); gstate.report_result_error(*result, "%s", err_stream.str().c_str()); set_task_state(PROCESS_COULDNT_START, "start"); return retval; }
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) }
OSStatus CScreensaver::initBOINCApp() { char boincPath[2048]; pid_t myPid; int status; OSStatus err; long brandId = 0; saverState = SaverState_CantLaunchCoreClient; brandId = GetBrandID(); switch(brandId) { case 1: m_BrandText = "GridRepublic Desktop"; break; case 2: m_BrandText = "Progress Thru Processors Desktop"; break; case 3: m_BrandText = "Charity Engine Desktop"; break; default: m_BrandText = "BOINC"; break; } m_CoreClientPID = FindProcessPID("boinc", 0); if (m_CoreClientPID) { m_wasAlreadyRunning = true; saverState = SaverState_LaunchingCoreClient; retryCount = 0; return noErr; } m_wasAlreadyRunning = false; if (++retryCount > 3) // Limit to 3 relaunches to prevent thrashing return -1; // Find boinc client within BOINCManager.app // First, try default path strcpy(boincPath, "/Applications/"); if (brandId) { strcat(boincPath, m_BrandText); } else { strcat(boincPath, "BOINCManager"); } strcat(boincPath, ".app/Contents/Resources/boinc"); // If not at default path, search for it by creator code and bundle identifier if (!boinc_file_exists(boincPath)) { err = GetpathToBOINCManagerApp(boincPath, sizeof(boincPath)); if (err) { saverState = SaverState_CantLaunchCoreClient; return err; } else { strcat(boincPath, "/Contents/Resources/boinc"); } } if ( (myPid = fork()) < 0) return -1; else if (myPid == 0) // child { // We don't customize BOINC Data directory name for branding #if 0 // Code for separate data in each user's private directory char buf[256]; safe_strcpy(buf, getenv("HOME")); safe_strcat(buf, "/Library/Application Support/BOINC Data"); status = chdir(buf); #else // All users share the same data status = chdir("/Library/Application Support/BOINC Data"); #endif if (status) { perror("chdir"); fflush(NULL); _exit(status); } status = execl(boincPath, boincPath, "-redirectio", "-saver", (char *) 0); fflush(NULL); _exit(127); // execl error (execl should never return) } else { m_CoreClientPID = myPid; // make this available globally saverState = SaverState_LaunchingCoreClient; } return noErr; }
int main(int argc, char *argv[]) { int retval; R_RSA_PUBLIC_KEY key; char log_path[MAXPATHLEN]; #ifdef _USING_FCGI_ unsigned int counter=0; #endif for(int c = 1; c < argc; c++) { std::string option(argv[c]); if(option == "-v" || option == "--version") { printf("%s\n", SVN_VERSION); exit(0); } else if(option == "-h" || option == "--help") { usage(argv[0]); exit(0); } else if (option.length()){ fprintf(stderr, "unknown command line argument: %s\n\n", argv[c]); usage(argv[0]); exit(1); } } installer(); get_log_path(log_path, "file_upload_handler.log"); #ifndef _USING_FCGI_ if (!freopen(log_path, "a", stderr)) { fprintf(stderr, "Can't open log file '%s' (errno: %d)\n", log_path, errno ); return_error(ERR_TRANSIENT, "can't open log file '%s' (errno: %d)", log_path, errno ); exit(1); } #else FCGI_FILE *f = FCGI::fopen(log_path, "a"); if (f) { log_messages.redirect(f); } else { fprintf(stderr, "Can't redirect FCGI log messages\n"); return_error(ERR_TRANSIENT, "can't open log file (FCGI)"); exit(1); } #endif retval = config.parse_file(); if (retval) { fprintf(stderr, "Can't parse config.xml: %s\n", boincerror(retval)); return_error(ERR_TRANSIENT, "can't parse config file", log_path, errno ); exit(1); } log_messages.pid = getpid(); log_messages.set_debug_level(config.fuh_debug_level); if (boinc_file_exists(config.project_path("stop_upload"))) { return_error(ERR_TRANSIENT, "Maintenance underway: file uploads are temporarily disabled."); exit(1); } if (!config.ignore_upload_certificates) { retval = get_key(key); if (retval) { return_error(ERR_TRANSIENT, "can't read key file"); exit(1); } } #ifdef _USING_FCGI_ while(FCGI_Accept() >= 0) { counter++; //fprintf(stderr, "file_upload_handler (FCGI): counter: %d\n", counter); log_messages.set_indent_level(0); #endif handle_request(stdin, key); #ifdef _USING_FCGI_ // flush log for FCGI, otherwise it just buffers a lot log_messages.flush(); } // when exiting, write headers back to apache so it won't complain // about "incomplete headers" fprintf(stdout,"Content-type: text/plain\n\n"); #endif return 0; }
// Write the client_state.xml file // int CLIENT_STATE::write_state_file() { MFILE mf; int retval, ret1, ret2, attempt; #ifdef _WIN32 char win_error_msg[4096]; #endif for (attempt=1; attempt<=MAX_STATE_FILE_WRITE_ATTEMPTS; attempt++) { if (attempt > 1) boinc_sleep(1.0); if (log_flags.statefile_debug) { msg_printf(0, MSG_INFO, "[statefile] Writing state file" ); } #ifdef _WIN32 retval = mf.open(STATE_FILE_NEXT, "wc"); #else retval = mf.open(STATE_FILE_NEXT, "w"); #endif if (retval) { if ((attempt == MAX_STATE_FILE_WRITE_ATTEMPTS) || log_flags.statefile_debug) { msg_printf(0, MSG_INTERNAL_ERROR, "Can't open %s: %s", STATE_FILE_NEXT, boincerror(retval) ); } if (attempt < MAX_STATE_FILE_WRITE_ATTEMPTS) continue; return ERR_FOPEN; } MIOFILE miof; miof.init_mfile(&mf); ret1 = write_state(miof); ret2 = mf.close(); if (ret1) { if ((attempt == MAX_STATE_FILE_WRITE_ATTEMPTS) || log_flags.statefile_debug) { msg_printf(NULL, MSG_INTERNAL_ERROR, "Couldn't write state file: %s", boincerror(retval) ); } if (attempt < MAX_STATE_FILE_WRITE_ATTEMPTS) continue; return ret1; } if (ret2) { if (attempt < MAX_STATE_FILE_WRITE_ATTEMPTS) continue; return ret2; } // only attempt to rename the current state file if it exists. // if (boinc_file_exists(STATE_FILE_NAME)) { if (boinc_file_exists(STATE_FILE_PREV)) { retval = boinc_delete_file(STATE_FILE_PREV); if (retval) { if ((attempt == MAX_STATE_FILE_WRITE_ATTEMPTS) || log_flags.statefile_debug) { #ifdef _WIN32 msg_printf(0, MSG_INFO, "Can't delete previous state file; %s", windows_format_error_string(GetLastError(), win_error_msg, sizeof(win_error_msg)) ); #else msg_printf(0, MSG_INFO, "Can't delete previous state file: %s", strerror(errno) ); #endif } if (attempt < MAX_STATE_FILE_WRITE_ATTEMPTS) continue; } } retval = boinc_rename(STATE_FILE_NAME, STATE_FILE_PREV); if (retval) { if ((attempt == MAX_STATE_FILE_WRITE_ATTEMPTS) || log_flags.statefile_debug) { #ifdef _WIN32 msg_printf(0, MSG_INFO, "Can't rename current state file to previous state file; %s", windows_format_error_string(GetLastError(), win_error_msg, sizeof(win_error_msg)) ); #else msg_printf(0, MSG_INFO, "Can't rename current state file to previous state file: %s", strerror(errno) ); #endif } if (attempt < MAX_STATE_FILE_WRITE_ATTEMPTS) continue; } } retval = boinc_rename(STATE_FILE_NEXT, STATE_FILE_NAME); if (log_flags.statefile_debug) { msg_printf(0, MSG_INFO, "[statefile] Done writing state file" ); } if (!retval) break; // Success! if ((attempt == MAX_STATE_FILE_WRITE_ATTEMPTS) || log_flags.statefile_debug) { #ifdef _WIN32 msg_printf(0, MSG_INFO, "rename error: %s", windows_format_error_string(GetLastError(), win_error_msg, sizeof(win_error_msg)) ); #elif defined (__APPLE__) if (log_flags.statefile_debug) { system("ls -al /Library/Application\\ Support/BOINC\\ Data/client*.*"); } #endif } if (attempt < MAX_STATE_FILE_WRITE_ATTEMPTS) continue; return ERR_RENAME; } return 0; }
// parse a project's app_info.xml (anonymous platform) file // int CLIENT_STATE::parse_app_info(PROJECT* p, FILE* in) { char buf[256], path[MAXPATHLEN]; MIOFILE mf; mf.init_file(in); XML_PARSER xp(&mf); while (!xp.get_tag()) { if (xp.match_tag("app_info")) continue; if (xp.match_tag("/app_info")) { notices.remove_notices(p, REMOVE_APP_INFO_MSG); return 0; } if (xp.match_tag("file_info") || xp.match_tag("file")) { FILE_INFO* fip = new FILE_INFO; if (fip->parse(xp)) { delete fip; continue; } if (!fip->download_urls.empty() || !fip->upload_urls.empty()) { msg_printf(p, MSG_INFO, "Can't specify URLs in app_info.xml" ); delete fip; continue; } if (link_file_info(p, fip)) { delete fip; continue; } // check that the file is actually there // get_pathname(fip, path, sizeof(path)); if (!boinc_file_exists(path)) { safe_strcpy(buf, _("File referenced in app_info.xml does not exist: ") ); strcat(buf, fip->name); msg_printf(p, MSG_USER_ALERT, "%s", buf); delete fip; continue; } fip->status = FILE_PRESENT; fip->anonymous_platform_file = true; file_infos.push_back(fip); continue; } if (xp.match_tag("app")) { APP* app = new APP; if (app->parse(xp)) { delete app; continue; } if (lookup_app(p, app->name)) { delete app; continue; } link_app(p, app); apps.push_back(app); continue; } if (xp.match_tag("app_version")) { APP_VERSION* avp = new APP_VERSION; if (avp->parse(xp)) { delete avp; continue; } if (cc_config.dont_use_vbox && strstr(avp->plan_class, "vbox")) { msg_printf(p, MSG_INFO, "skipping vbox app in app_info.xml; vbox disabled in cc_config.xml" ); delete avp; continue; } if (strlen(avp->platform) == 0) { safe_strcpy(avp->platform, get_primary_platform()); } if (link_app_version(p, avp)) { delete avp; continue; } app_versions.push_back(avp); continue; } if (log_flags.unparsed_xml) { msg_printf(p, MSG_INFO, "Unparsed line in app_info.xml: %s", xp.parsed_tag ); } } return ERR_XML_PARSE; }
// returns true if the work generator can not make more work for this // file, false if it can. // static bool work_generation_over(char *filename) { return boinc_file_exists(config.project_path("locality_scheduling/no_work_available/%s", filename)); }