/// Parse XML information about an active task set
int ACTIVE_TASK_SET::parse(MIOFILE& fin) {
ACTIVE_TASK* atp;
char buf[256];
int retval;
while (fin.fgets(buf, 256)) {
if (match_tag(buf, "</active_task_set>")) return 0;
else if (match_tag(buf, "<active_task>")) {
atp = new ACTIVE_TASK;
retval = atp->parse(fin);
if (!retval) {
if (slot_taken(atp->slot)) {
msg_printf(atp->result->project, MSG_INTERNAL_ERROR,
"slot %d in use; discarding result %s",
atp->slot, atp->result->name
);
retval = ERR_XML_PARSE;
}
}
if (!retval) active_tasks.push_back(atp);
else delete atp;
} else {
handle_unparsed_xml_warning("ACTIVE_TASK_SET::parse", buf);
}
}
return ERR_XML_PARSE;
}
int PROXY_INFO::parse(MIOFILE& in) {
char buf[1024];
memset(this, 0, sizeof(PROXY_INFO));
while (in.fgets(buf, 256)) {
if (match_tag(buf, "</proxy_info>")) {
present = false;
if (strlen(http_server_name)) present = true;
if (strlen(socks_server_name)) present = true;
return 0;
}
else if (parse_bool(buf, "use_http_proxy", use_http_proxy)) continue;
else if (parse_bool(buf, "use_socks_proxy", use_socks_proxy)) continue;
else if (parse_bool(buf, "use_http_auth", use_http_auth)) continue;
else if (parse_str(buf, "<socks_server_name>", socks_server_name, sizeof(socks_server_name))) continue;
else if (parse_int(buf, "<socks_server_port>", socks_server_port)) continue;
else if (parse_str(buf, "<http_server_name>", http_server_name, sizeof(http_server_name))) continue;
else if (parse_int(buf, "<http_server_port>", http_server_port)) continue;
else if (parse_str(buf, "<socks5_user_name>", socks5_user_name,sizeof(socks5_user_name))) continue;
else if (parse_str(buf, "<socks5_user_passwd>", socks5_user_passwd,sizeof(socks5_user_passwd))) continue;
else if (parse_str(buf, "<http_user_name>", http_user_name,sizeof(http_user_name))) continue;
else if (parse_str(buf, "<http_user_passwd>", http_user_passwd,sizeof(http_user_passwd))) continue;
else if (parse_str(buf, "<no_proxy>", noproxy_hosts, sizeof(noproxy_hosts))) continue;
}
return ERR_XML_PARSE;
}
// we got an unrecognized line.
// If it has two <'s (e.g. <foo>xx</foo>) return 0.
// If it's of the form <foo/> return 0.
// If it's of the form <foo> then scan for </foo> and return 0.
// Otherwise return ERR_XML_PARSE
//
int skip_unrecognized(char* buf, MIOFILE& fin) {
char* p, *q, buf2[256];
std::string close_tag;
p = strchr(buf, '<');
if (!p) {
return ERR_XML_PARSE;
}
if (strchr(p+1, '<')) {
return 0;
}
q = strchr(p+1, '>');
if (!q) {
return ERR_XML_PARSE;
}
if (q[-1] == '/') return 0;
*q = 0;
close_tag = string("</") + string(p+1) + string(">");
while (fin.fgets(buf2, 256)) {
if (strstr(buf2, close_tag.c_str())) {
return 0;
}
}
return ERR_XML_PARSE;
}
int PROJECT_INIT::init() {
char buf[256];
MIOFILE mf;
FILE* p;
clear();
p = fopen(PROJECT_INIT_FILENAME, "r");
if (p) {
mf.init_file(p);
while(mf.fgets(buf, sizeof(buf))) {
if (match_tag(buf, "</project_init>")) break;
else if (parse_str(buf, "<name>", name, 256)) continue;
else if (parse_str(buf, "<team_name>", team_name, 256)) continue;
else if (parse_str(buf, "<url>", url, 256)) {
canonicalize_master_url(url);
continue;
} else if (parse_str(buf, "<account_key>", account_key, 256)) {
continue;
}
}
fclose(p);
msg_printf(0, MSG_INFO, "Found project_init.xml for %s", url);
}
return 0;
}
// we got an unrecognized line.
// If it has two <'s (e.g. <foo>xx</foo>) return 0.
// If it's of the form <foo/> return 0.
// If it's of the form <foo> then scan for </foo> and return 0.
// Otherwise return ERR_XML_PARSE
//
int skip_unrecognized(wxChar* buf, MIOFILE& fin) {
wxChar* p, *q, buf2[256];
std::wstring close_tag;
p = _tcschr(buf, wxT('<'));
if (!p) {
return -112;
}
if (_tcschr(p+1, wxT('<'))) {
return 0;
}
q = _tcschr(p+1, wxT('>'));
if (!q) {
return -112;
}
if (q[-1] == '/') return 0;
*q = 0;
close_tag = std::wstring(wxT("</")) + std::wstring(p+1) + std::wstring(wxT(">"));
while (fin.fgets(buf2, 256)) {
if (_tcsstr(buf2, close_tag.c_str())) {
return 0;
}
}
return -112;
}
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;
}
int CSkinManager::Parse(MIOFILE& in, wxString strDesiredLocale) {
char buf[256];
wxString strLocaleStartTag;
wxString strLocaleEndTag;
bool bLocaleFound = false;
// Construct the start and end tags for the locale we want.
strLocaleStartTag.Printf(wxT("<%s>"), strDesiredLocale.c_str());
strLocaleEndTag.Printf(wxT("</%s>"), strDesiredLocale.c_str());
// TODO: Eliminate the <en> tags: localization is no longer in skin files.
// Look for the begining of the desired locale.
while (in.fgets(buf, 256)) {
if (match_tag(buf, (const char*)strLocaleStartTag.mb_str(wxConvUTF8))) {
bLocaleFound = true;
break;
}
}
if (!bLocaleFound) return ERR_XML_PARSE;
while (in.fgets(buf, 256)) {
if (match_tag(buf, (const char*)strLocaleStartTag.mb_str(wxConvUTF8))) break;
else if (match_tag(buf, "<simple>")) {
m_SimpleSkin.Parse(in);
continue;
} else if (match_tag(buf, "<advanced>")) {
m_AdvancedSkin.Parse(in);
continue;
} else if (match_tag(buf, "<wizards>")) {
m_WizardsSkin.Parse(in);
continue;
}
}
InitializeDelayedValidation();
return 0;
}
int copy_element_contents(MIOFILE& in, const char* end_tag, string& str) {
char buf[256];
str.clear();
while (in.fgets(buf, 256)) {
if (strstr(buf, end_tag)) {
return 0;
}
str += buf;
}
fprintf(stderr, "copy_element_contents(): no end tag\n");
return ERR_XML_PARSE;
}
int COPROC_REQ::parse(MIOFILE& fin) {
char buf[1024];
strcpy(type, "");
count = 0;
while (fin.fgets(buf, sizeof(buf))) {
if (match_tag(buf, "</coproc>")) {
if (!strlen(type)) return ERR_XML_PARSE;
return 0;
}
if (parse_str(buf, "<type>", type, sizeof(type))) continue;
if (parse_double(buf, "<count>", count)) continue;
}
return ERR_XML_PARSE;
}
int CSkinWizardATP::Parse(MIOFILE& in) {
char buf[256];
std::string strBuffer;
while (in.fgets(buf, 256)) {
if (match_tag(buf, "</attach_to_project>")) break;
else if (parse_str(buf, "<title>", strBuffer)) {
m_strTitle = wxString(strBuffer.c_str(), wxConvUTF8);
continue;
}
}
InitializeDelayedValidation();
return 0;
}
/// Copy from a file to static buffer.
int copy_element_contents(MIOFILE& in, const char* end_tag, char* p, int len) {
char buf[256];
int n;
strcpy(p, "");
while (in.fgets(buf, 256)) {
if (strstr(buf, end_tag)) {
return 0;
}
n = (int)strlen(buf);
if (n >= len-1) return ERR_XML_PARSE;
strcat(p, buf);
len -= n;
}
return ERR_XML_PARSE;
}
int CSkinWizardATAM::Parse(MIOFILE& in) {
char buf[256];
std::string strBuffer;
while (in.fgets(buf, 256)) {
if (match_tag(buf, "</attach_to_account_manager>")) break;
else if (parse_str(buf, "<account_info_message>", strBuffer)) {
m_strAccountInfoMessage = wxString(strBuffer.c_str(), wxConvUTF8);
continue;
}
}
InitializeDelayedValidation();
return 0;
}
int MOZILLA_PROFILE::parse(MIOFILE& in) {
char buf[512];
std::string sn;
std::string sv;
while (in.fgets(buf, 512)) {
if (starts_with(buf, "\n")) return 0;
if (starts_with(buf, "\r\n")) return 0;
if (!parse_name_value_pair(buf, sn, sv)) continue;
if ("Name" == sn) name = sv;
if ("Path" == sn) path = sv;
if (("IsRelative" == sn) && ("1" == sv)) is_relative = true;
if (("Default" == sn) && ("1" == sv)) is_default = true;
}
return ERR_FREAD;
}
int MOZILLA_PROFILES::parse(MIOFILE& in) {
char buf[512];
MOZILLA_PROFILE* p = NULL;
while (in.fgets(buf, 512)) {
if (starts_with(buf, "[Profile")) {
p = new MOZILLA_PROFILE;
if (!p->parse( in )) {
profiles.push_back( p );
} else {
delete p;
}
}
}
return 0;
}
int NET_STATS::parse(MIOFILE& in) {
char buf[256];
up.clear();
down.clear();
while (in.fgets(buf, 256)) {
if (match_tag(buf, "</net_stats>")) return 0;
if (parse_double(buf, "<bwup>", up.max_rate)) continue;
if (parse_double(buf, "<avg_up>", up.avg_rate)) continue;
if (parse_double(buf, "<avg_time_up>", up.avg_time)) continue;
if (parse_double(buf, "<bwdown>", down.max_rate)) continue;
if (parse_double(buf, "<avg_down>", down.avg_rate)) continue;
if (parse_double(buf, "<avg_time_down>", down.avg_time)) continue;
handle_unparsed_xml_warning("NET_STATS::parse", buf);
}
return ERR_XML_PARSE;
}
int CSkinWizards::Parse(MIOFILE& in) {
char buf[256];
while (in.fgets(buf, 256)) {
if (match_tag(buf, "</wizards>")) break;
else if (match_tag(buf, "<attach_to_project>")) {
m_AttachToProjectWizard.Parse(in);
continue;
} else if (match_tag(buf, "<attach_to_account_manager>")) {
m_AttachToAccountManagerWizard.Parse(in);
continue;
}
}
InitializeDelayedValidation();
return 0;
}
int HOST_INFO::parse(MIOFILE& in, bool benchmarks_only) {
char buf[1024];
while (in.fgets(buf, sizeof(buf))) {
if (match_tag(buf, "</host_info>")) return 0;
else if (parse_double(buf, "<p_fpops>", p_fpops)) {
// fix foolishness that could result in negative value here
//
if (p_fpops < 0) p_fpops = -p_fpops;
continue;
}
else if (parse_double(buf, "<p_iops>", p_iops)) {
if (p_iops < 0) p_iops = -p_iops;
continue;
}
else if (parse_double(buf, "<p_membw>", p_membw)) {
if (p_membw < 0) p_membw = -p_membw;
continue;
}
else if (parse_double(buf, "<p_calculated>", p_calculated)) continue;
if (benchmarks_only) continue;
if (parse_int(buf, "<timezone>", timezone)) continue;
else if (parse_str(buf, "<domain_name>", domain_name, sizeof(domain_name))) continue;
else if (parse_str(buf, "<ip_addr>", ip_addr, sizeof(ip_addr))) continue;
else if (parse_str(buf, "<host_cpid>", host_cpid, sizeof(host_cpid))) continue;
else if (parse_int(buf, "<p_ncpus>", p_ncpus)) continue;
else if (parse_str(buf, "<p_vendor>", p_vendor, sizeof(p_vendor))) continue;
else if (parse_str(buf, "<p_model>", p_model, sizeof(p_model))) continue;
else if (parse_str(buf, "<p_features>", p_features, sizeof(p_features))) continue;
else if (parse_double(buf, "<m_nbytes>", m_nbytes)) continue;
else if (parse_double(buf, "<m_cache>", m_cache)) continue;
else if (parse_double(buf, "<m_swap>", m_swap)) continue;
else if (parse_double(buf, "<d_total>", d_total)) continue;
else if (parse_double(buf, "<d_free>", d_free)) continue;
else if (parse_str(buf, "<os_name>", os_name, sizeof(os_name))) continue;
else if (parse_str(buf, "<os_version>", os_version, sizeof(os_version))) continue;
else if (match_tag(buf, "<coprocs>")) {
coprocs.parse(in);
}
}
return ERR_XML_PARSE;
}
int CSkinSimple::Parse(MIOFILE& in) {
char buf[256];
std::string strBuffer;
while (in.fgets(buf, 256)) {
if (match_tag(buf, "</simple>")) break;
else if (match_tag(buf, "<background_image>")) {
m_BackgroundImage.Parse(in);
continue;
} else if (match_tag(buf, "<dialog_background_image>")) {
m_DialogBackgroundImage.Parse(in);
continue;
} else if (match_tag(buf, "<project_image>")) {
m_ProjectImage.Parse(in);
continue;
} else if (parse_str(buf, "<static_line_color>", strBuffer)) {
m_StaticLineColor = ParseColor(wxString(strBuffer.c_str(), wxConvUTF8));
continue;
} else if (parse_str(buf, "<notice_alert_color>", strBuffer)) {
m_NoticeAlertColor = ParseColor(wxString(strBuffer.c_str(), wxConvUTF8));
continue;
} else if (match_tag(buf, "<workunit_animation_image>")) {
m_WorkunitAnimationImage.Parse(in);
continue;
} else if (match_tag(buf, "<workunit_running_image>")) {
m_WorkunitRunningImage.Parse(in);
continue;
} else if (match_tag(buf, "<workunit_suspended_image>")) {
m_WorkunitSuspendedImage.Parse(in);
continue;
} else if (match_tag(buf, "<workunit_waiting_image>")) {
m_WorkunitWaitingImage.Parse(in);
continue;
} else if (parse_int(buf, "<panel_opacity>", m_iPanelOpacity)) {
continue;
}
}
InitializeDelayedValidation();
return 0;
}
int NET_STATS::parse(MIOFILE& in) {
char buf[256];
memset(this, 0, sizeof(NET_STATS));
while (in.fgets(buf, 256)) {
if (match_tag(buf, "</net_stats>")) return 0;
if (parse_double(buf, "<bwup>", up.max_rate)) continue;
if (parse_double(buf, "<avg_up>", up.avg_rate)) continue;
if (parse_double(buf, "<avg_time_up>", up.avg_time)) continue;
if (parse_double(buf, "<bwdown>", down.max_rate)) continue;
if (parse_double(buf, "<avg_down>", down.avg_rate)) continue;
if (parse_double(buf, "<avg_time_down>", down.avg_time)) continue;
if (log_flags.unparsed_xml) {
msg_printf(NULL, MSG_INFO,
"[unparsed_xml] Unrecognized network statistics line: %s", buf
);
}
}
return ERR_XML_PARSE;
}
int COPROC::parse(MIOFILE& fin) {
char buf[1024];
strcpy(type, "");
count = 0;
used = 0;
req_secs = 0;
estimated_delay = 0;
req_instances = 0;
while (fin.fgets(buf, sizeof(buf))) {
if (match_tag(buf, "</coproc>")) {
if (!strlen(type)) return ERR_XML_PARSE;
return 0;
}
if (parse_str(buf, "<type>", type, sizeof(type))) continue;
if (parse_int(buf, "<count>", count)) continue;
if (parse_double(buf, "<req_secs>", req_secs)) continue;
if (parse_double(buf, "<req_instances>", req_instances)) continue;
if (parse_double(buf, "<estimated_delay>", estimated_delay)) continue;
}
return ERR_XML_PARSE;
}
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 (mf.fgets(buf, sizeof(buf))) {
if (parse_bool(buf, "default_ss_first", periods.Show_default_ss_first)) continue;
if (parse_double(buf, "<default_gfx_duration>", periods.GFXDefaultPeriod)) continue;
if (parse_double(buf, "<science_gfx_duration>", periods.GFXSciencePeriod)) continue;
if (parse_double(buf, "<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);
}
int COPROCS::parse(MIOFILE& fin) {
char buf[1024];
int retval;
while (fin.fgets(buf, sizeof(buf))) {
if (match_tag(buf, "</coprocs>")) {
return 0;
}
if (strstr(buf, "<coproc_cuda>")) {
retval = cuda.parse(fin);
if (retval) {
cuda.clear();
}
}
if (strstr(buf, "<coproc_ati>")) {
retval = ati.parse(fin);
if (retval) {
ati.clear();
}
}
}
return ERR_XML_PARSE;
}
// Parse XML information about a persistent file transfer
//
int PERS_FILE_XFER::parse(MIOFILE& fin) {
char buf[256];
while (fin.fgets(buf, 256)) {
if (match_tag(buf, "</persistent_file_xfer>")) return 0;
else if (parse_int(buf, "<num_retries>", nretry)) continue;
else if (parse_double(buf, "<first_request_time>", first_request_time)) {
continue;
}
else if (parse_double(buf, "<next_request_time>", next_request_time)) {
continue;
}
else if (parse_double(buf, "<time_so_far>", time_so_far)) continue;
else if (parse_double(buf, "<last_bytes_xferred>", last_bytes_xferred)) continue;
else {
if (log_flags.unparsed_xml) {
msg_printf(NULL, MSG_INFO,
"[unparsed_xml] Unparsed line in file transfer info: %s", buf
);
}
}
}
return ERR_XML_PARSE;
}
int CSkinImage::Parse(MIOFILE& in) {
char buf[256];
std::string strBuffer;
while (in.fgets(buf, 256)) {
if (match_tag(buf, "</image>")) break;
else if (parse_str(buf, "<imagesrc>", strBuffer)) {
if (strBuffer.length()) {
m_strDesiredBitmap = wxString(
wxGetApp().GetSkinManager()->ConstructSkinPath() +
wxString(strBuffer.c_str(), wxConvUTF8)
);
}
continue;
} else if (parse_str(buf, "<background_color>", strBuffer)) {
if (strBuffer.length()) {
m_strDesiredBackgroundColor = wxString(strBuffer.c_str(), wxConvUTF8);
}
continue;
} else if (match_tag(buf, "<anchor_horizontal_left>")) {
m_iAnchorHorizontal = BKGD_ANCHOR_HORIZ_LEFT;
} else if (match_tag(buf, "<anchor_horizontal_center>")) {
m_iAnchorHorizontal = BKGD_ANCHOR_HORIZ_CENTER;
} else if (match_tag(buf, "<anchor_horizontal_right>")) {
m_iAnchorHorizontal = BKGD_ANCHOR_HORIZ_RIGHT;
} else if (match_tag(buf, "<anchor_vertical_top>")) {
m_iAnchorVertical = BKGD_ANCHOR_VERT_TOP;;
} else if (match_tag(buf, "<anchor_vertical_center>")) {
m_iAnchorVertical = BKGD_ANCHOR_VERT_CENTER;;
} else if (match_tag(buf, "<anchor_vertical_bottom>")) {
m_iAnchorVertical = BKGD_ANCHOR_VERT_BOTTOM;;
}
}
return BOINC_SUCCESS;
}
int CSkinIcon::Parse(MIOFILE& in) {
char buf[256];
std::string strBuffer;
while (in.fgets(buf, 256)) {
if (match_tag(buf, "</image>")) break;
else if (parse_str(buf, "<imagesrc>", strBuffer)) {
if (strBuffer.length()) {
m_strDesiredIcon = wxString(
wxGetApp().GetSkinManager()->ConstructSkinPath() +
wxString(strBuffer.c_str(), wxConvUTF8)
);
}
continue;
} else if (parse_str(buf, "<transparency_mask>", strBuffer)) {
if (strBuffer.length()) {
m_strDesiredTransparencyMask = wxString(strBuffer.c_str(), wxConvUTF8);
}
continue;
}
}
return BOINC_SUCCESS;
}
int CSkinImage::Parse(MIOFILE& in) {
char buf[256];
std::string strBuffer;
while (in.fgets(buf, 256)) {
if (match_tag(buf, "</image>")) break;
else if (parse_str(buf, "<imagesrc>", strBuffer)) {
if (strBuffer.length()) {
m_strDesiredBitmap = wxString(
wxGetApp().GetSkinManager()->ConstructSkinPath() +
wxString(strBuffer.c_str(), wxConvUTF8)
);
}
continue;
} else if (parse_str(buf, "<background_color>", strBuffer)) {
if (strBuffer.length()) {
m_strDesiredBackgroundColor = wxString(strBuffer.c_str(), wxConvUTF8);
}
continue;
}
}
return BOINC_SUCCESS;
}
// initialize the diagnostics environment.
//
int diagnostics_init(
int _flags, const char* stdout_prefix, const char* stderr_prefix
) {
// Check to see if we have already been called
//
if (diagnostics_initialized) {
return ERR_INVALID_PARAM;
}
diagnostics_initialized = true;
// Setup initial values
//
flags = _flags;
strcpy(stdout_log, "");
strcpy(stdout_archive, "");
strcpy(stderr_log, "");
strcpy(stderr_archive, "");
strcpy(boinc_dir, "");
strcpy(boinc_install_dir, "");
boinc_proxy_enabled = 0;
strcpy(boinc_proxy, "");
strcpy(symstore, "");
// Check for invalid parameter combinations
//
if ((flags & BOINC_DIAG_REDIRECTSTDERR) && (flags & BOINC_DIAG_REDIRECTSTDERROVERWRITE)) {
return ERR_INVALID_PARAM;
}
if ((flags & BOINC_DIAG_REDIRECTSTDOUT) && (flags & BOINC_DIAG_REDIRECTSTDOUTOVERWRITE)) {
return ERR_INVALID_PARAM;
}
// Determine where the log files are to be stored
//
if (flags & BOINC_DIAG_PERUSERLOGFILES) {
char user_dir[MAXPATHLEN];
#if defined(_WIN32)
snprintf(user_dir, sizeof(user_dir), "%s", getenv("APPDATA"));
strncat(user_dir, "/BOINC", sizeof(user_dir) - strlen(user_dir)-1);
#elif defined(__APPLE__)
snprintf(user_dir, sizeof(user_dir), "%s", getenv("HOME"));
strncat(user_dir, "/Library/Application Support/BOINC", sizeof(user_dir) - strlen(user_dir)-1);
#else
snprintf(user_dir, sizeof(user_dir), "%s", getenv("HOME"));
strncat(user_dir, "/.BOINC", sizeof(user_dir) - strlen(user_dir)-1);
#endif
// Check to see if the directory exists
if (!is_dir(user_dir)) {
boinc_mkdir(user_dir);
}
snprintf(stdout_log, sizeof(stdout_log), "%s/%s.txt", user_dir, stdout_prefix);
snprintf(stdout_archive, sizeof(stdout_archive), "%s/%s.old", user_dir, stdout_prefix);
snprintf(stderr_log, sizeof(stderr_log), "%s/%s.txt", user_dir, stderr_prefix);
snprintf(stderr_archive, sizeof(stderr_archive), "%s/%s.old", user_dir, stderr_prefix);
} else {
snprintf(stdout_log, sizeof(stdout_log), "%s.txt", stdout_prefix);
snprintf(stdout_archive, sizeof(stdout_archive), "%s.old", stdout_prefix);
snprintf(stderr_log, sizeof(stderr_log), "%s.txt", stderr_prefix);
snprintf(stderr_archive, sizeof(stderr_archive), "%s.old", stderr_prefix);
}
// Archive any old stderr.txt and stdout.txt files, if requested
//
if (flags & BOINC_DIAG_ARCHIVESTDERR) {
boinc_copy(stderr_log, stderr_archive);
}
if (flags & BOINC_DIAG_ARCHIVESTDOUT) {
boinc_copy(stdout_log, stdout_archive);
}
// Redirect stderr and/or stdout, if requested
//
if (flags & BOINC_DIAG_REDIRECTSTDERR) {
file_size(stderr_log, stderr_file_size);
stderr_file = freopen(stderr_log, "a", stderr);
if (!stderr_file) {
return ERR_FOPEN;
}
setbuf(stderr_file, 0);
}
if (flags & BOINC_DIAG_REDIRECTSTDERROVERWRITE) {
stderr_file = freopen(stderr_log, "w", stderr);
if (!stderr_file) {
return ERR_FOPEN;
}
setbuf(stderr_file, 0);
}
if (flags & BOINC_DIAG_REDIRECTSTDOUT) {
file_size(stdout_log, stdout_file_size);
stdout_file = freopen(stdout_log, "a", stdout);
if (!stdout_file) {
return ERR_FOPEN;
}
}
if (flags & BOINC_DIAG_REDIRECTSTDOUTOVERWRITE) {
stdout_file = freopen(stdout_log, "w", stdout);
if (!stdout_file) {
return ERR_FOPEN;
}
}
#if defined(_WIN32)
#if defined(_DEBUG)
_CrtSetReportHook(boinc_message_reporting);
if (flags & BOINC_DIAG_MEMORYLEAKCHECKENABLED) {
SET_CRT_DEBUG_FIELD(_CRTDBG_LEAK_CHECK_DF);
}
if (flags & BOINC_DIAG_HEAPCHECKENABLED) {
if (flags & BOINC_DIAG_HEAPCHECKEVERYALLOC) {
SET_CRT_DEBUG_FIELD(_CRTDBG_CHECK_ALWAYS_DF);
} else {
SET_CRT_DEBUG_FIELD(_CRTDBG_CHECK_EVERY_1024_DF);
}
}
if (flags & BOINC_DIAG_BOINCAPPLICATION) {
if (flags & BOINC_DIAG_MEMORYLEAKCHECKENABLED) {
_CrtMemCheckpoint(&start_snapshot);
}
}
#endif // defined(_DEBUG)
// Initialize the thread list structure
// The data for this structure should be set by
// boinc_init or boinc_init_graphics.
diagnostics_init_thread_list();
diagnostics_init_unhandled_exception_monitor();
diagnostics_init_message_monitor();
#endif // defined(_WIN32)
#ifdef ANDROID
#define resolve_func(l,x) \
x=(x##_t)dlsym(l,#x); \
if (!x) {\
fprintf(stderr,"Unable to resolve function %s\n",#x); \
unwind_backtrace_signal_arch=NULL; \
}
if ((libhandle=dlopen("libcorkscrew.so",RTLD_NOW|RTLD_GLOBAL))) {
resolve_func(libhandle,unwind_backtrace_signal_arch);
resolve_func(libhandle,acquire_my_map_info_list);
resolve_func(libhandle,release_my_map_info_list);
resolve_func(libhandle,get_backtrace_symbols);
resolve_func(libhandle,free_backtrace_symbols);
resolve_func(libhandle,format_backtrace_line);
resolve_func(libhandle,load_symbol_table);
resolve_func(libhandle,free_symbol_table);
resolve_func(libhandle,find_symbol);
} else {
fprintf(stderr,"stackdumps unavailable\n");
}
#endif // ANDROID
// Install unhandled exception filters and signal traps.
if (BOINC_SUCCESS != boinc_install_signal_handlers()) {
return ERR_SIGNAL_OP;
}
// Store various pieces of inforation for future use.
if (flags & BOINC_DIAG_BOINCAPPLICATION) {
char buf[256];
char proxy_address[256];
int proxy_port;
MIOFILE mf;
FILE* p;
#ifdef _WIN32
LONG lReturnValue;
HKEY hkSetupHive;
DWORD dwSize = 0;
#endif
strcpy(buf, "");
strcpy(proxy_address, "");
proxy_port = 0;
#ifndef _USING_FCGI_
p = fopen(INIT_DATA_FILE, "r");
#else
p = FCGI::fopen(INIT_DATA_FILE, "r");
#endif
if (p) {
mf.init_file(p);
while(mf.fgets(buf, sizeof(buf))) {
if (match_tag(buf, "</app_init_data>")) break;
else if (parse_str(buf, "<boinc_dir>", boinc_dir, sizeof(boinc_dir))) continue;
else if (parse_str(buf, "<symstore>", symstore, sizeof(symstore))) ;
else if (match_tag(buf, "<use_http_proxy/>")) {
boinc_proxy_enabled = true;
continue;
}
else if (parse_str(buf, "<http_server_name>", proxy_address, sizeof(proxy_address))) continue;
else if (parse_int(buf, "<http_server_port>", proxy_port)) continue;
}
fclose(p);
}
if (boinc_proxy_enabled) {
int buffer_used = snprintf(boinc_proxy, sizeof(boinc_proxy), "%s:%d", proxy_address, proxy_port);
if ((sizeof(boinc_proxy) == buffer_used) || (-1 == buffer_used)) {
boinc_proxy[sizeof(boinc_proxy)-1] = '\0';
}
}
#ifdef _WIN32
// Lookup the location of where BOINC was installed to and store
// that for future use.
lReturnValue = RegOpenKeyEx(
HKEY_LOCAL_MACHINE,
_T("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?
dwSize = sizeof(boinc_install_dir);
lReturnValue = RegQueryValueEx(
hkSetupHive,
_T("INSTALLDIR"),
NULL,
NULL,
(LPBYTE)&boinc_install_dir,
&dwSize
);
}
if (hkSetupHive) RegCloseKey(hkSetupHive);
#endif
}
return BOINC_SUCCESS;
}
int ACTIVE_TASK::parse(MIOFILE& fin) {
char buf[256], result_name[256], project_master_url[256];
int n, dummy;
unsigned int i;
PROJECT* project;
strcpy(result_name, "");
strcpy(project_master_url, "");
while (fin.fgets(buf, 256)) {
if (match_tag(buf, "</active_task>")) {
project = gstate.lookup_project(project_master_url);
if (!project) {
msg_printf(
NULL, MSG_INTERNAL_ERROR,
"State file error: project %s not found\n",
project_master_url
);
return ERR_NULL;
}
result = gstate.lookup_result(project, result_name);
if (!result) {
msg_printf(
project, MSG_INTERNAL_ERROR,
"State file error: result %s not found\n",
result_name
);
return ERR_NULL;
}
// various sanity checks
//
if (result->got_server_ack
|| result->ready_to_report
|| result->state() != RESULT_FILES_DOWNLOADED
) {
msg_printf(project, MSG_INTERNAL_ERROR,
"State file error: result %s is in wrong state\n",
result_name
);
return ERR_BAD_RESULT_STATE;
}
wup = result->wup;
app_version = gstate.lookup_app_version(
result->app, result->platform, result->version_num,
result->plan_class
);
if (!app_version) {
msg_printf(
project, MSG_INTERNAL_ERROR,
"State file error: app %s platform %s version %d not found\n",
result->app->name, result->platform, result->version_num
);
return ERR_NULL;
}
// make sure no two active tasks are in same slot
//
for (i=0; i<gstate.active_tasks.active_tasks.size(); i++) {
ACTIVE_TASK* atp = gstate.active_tasks.active_tasks[i];
if (atp->slot == slot) {
msg_printf(project, MSG_INTERNAL_ERROR,
"State file error: two tasks in slot %d\n", slot
);
return ERR_BAD_RESULT_STATE;
}
}
return 0;
}
else if (parse_str(buf, "<result_name>", result_name, sizeof(result_name))) continue;
else if (parse_str(buf, "<project_master_url>", project_master_url, sizeof(project_master_url))) continue;
else if (parse_int(buf, "<slot>", slot)) continue;
else if (parse_bool(buf, "full_init_done", full_init_done)) continue;
else if (parse_int(buf, "<active_task_state>", dummy)) continue;
else if (parse_double(buf, "<checkpoint_cpu_time>", checkpoint_cpu_time)) continue;
else if (parse_double(buf, "<fraction_done>", fraction_done)) continue;
else if (parse_double(buf, "<current_cpu_time>", current_cpu_time)) continue;
else if (parse_int(buf, "<app_version_num>", n)) continue;
else if (parse_double(buf, "<swap_size>", procinfo.swap_size)) continue;
else if (parse_double(buf, "<working_set_size>", procinfo.working_set_size)) continue;
else if (parse_double(buf, "<working_set_size_smoothed>", procinfo.working_set_size_smoothed)) continue;
else if (parse_double(buf, "<page_fault_rate>", procinfo.page_fault_rate)) continue;
else if (parse_double(buf, "<stats_mem>", stats_mem)) continue;
else if (parse_double(buf, "<stats_page>", stats_mem)) continue;
else if (parse_double(buf, "<stats_pagefault_rate>", stats_mem)) continue;
else if (parse_double(buf, "<stats_disk>", stats_disk)) continue;
else if (parse_int(buf, "<stats_checkpoint>", stats_checkpoint)) continue;
else {
handle_unparsed_xml_warning("ACTIVE_TASK::parse", buf);
}
}
return ERR_XML_PARSE;
}
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;
}
// initialize the diagnostics environment.
//
int diagnostics_init(
int _flags, const char* stdout_prefix, const char* stderr_prefix
) {
// Check to see if we have already been called
if (diagnostics_initialized) {
return ERR_INVALID_PARAM;
}
diagnostics_initialized = true;
// Setup initial values
flags = _flags;
snprintf(stdout_log, sizeof(stdout_log), "%s.txt", stdout_prefix);
snprintf(stdout_archive, sizeof(stdout_archive), "%s.old", stdout_prefix);
snprintf(stderr_log, sizeof(stderr_log), "%s.txt", stderr_prefix);
snprintf(stderr_archive, sizeof(stderr_archive), "%s.old", stderr_prefix);
strcpy(boinc_dir, "");
strcpy(boinc_install_dir, "");
boinc_proxy_enabled = 0;
strcpy(boinc_proxy, "");
strcpy(symstore, "");
// Check for invalid parameter combinations
if ((flags & BOINC_DIAG_REDIRECTSTDERR) && (flags & BOINC_DIAG_REDIRECTSTDERROVERWRITE)) {
return ERR_INVALID_PARAM;
}
if ((flags & BOINC_DIAG_REDIRECTSTDOUT) && (flags & BOINC_DIAG_REDIRECTSTDOUTOVERWRITE)) {
return ERR_INVALID_PARAM;
}
// Archive any old stderr.txt and stdout.txt files, if requested
if (flags & BOINC_DIAG_ARCHIVESTDERR) {
boinc_copy(stderr_log, stderr_archive);
}
if (flags & BOINC_DIAG_ARCHIVESTDOUT) {
boinc_copy(stdout_log, stdout_archive);
}
// Redirect stderr and/or stdout, if requested
//
if (flags & BOINC_DIAG_REDIRECTSTDERR) {
file_size(stderr_log, stderr_file_size);
stderr_file = freopen(stderr_log, "a", stderr);
if (!stderr_file) {
return ERR_FOPEN;
}
setbuf(stderr_file, 0);
}
if (flags & BOINC_DIAG_REDIRECTSTDERROVERWRITE) {
stderr_file = freopen(stderr_log, "w", stderr);
if (!stderr_file) {
return ERR_FOPEN;
}
setbuf(stderr_file, 0);
}
if (flags & BOINC_DIAG_REDIRECTSTDOUT) {
file_size(stdout_log, stdout_file_size);
stdout_file = freopen(stdout_log, "a", stdout);
if (!stdout_file) {
return ERR_FOPEN;
}
}
if (flags & BOINC_DIAG_REDIRECTSTDOUTOVERWRITE) {
stdout_file = freopen(stdout_log, "w", stdout);
if (!stdout_file) {
return ERR_FOPEN;
}
}
#if defined(_WIN32)
#if defined(_DEBUG)
_CrtSetReportHook(boinc_message_reporting);
if (flags & BOINC_DIAG_MEMORYLEAKCHECKENABLED) {
SET_CRT_DEBUG_FIELD(_CRTDBG_LEAK_CHECK_DF);
}
if (flags & BOINC_DIAG_HEAPCHECKENABLED) {
if (flags & BOINC_DIAG_HEAPCHECKEVERYALLOC) {
SET_CRT_DEBUG_FIELD(_CRTDBG_CHECK_ALWAYS_DF);
} else {
SET_CRT_DEBUG_FIELD(_CRTDBG_CHECK_EVERY_1024_DF);
}
}
if (flags & BOINC_DIAG_BOINCAPPLICATION) {
if (flags & BOINC_DIAG_MEMORYLEAKCHECKENABLED) {
_CrtMemCheckpoint(&start_snapshot);
}
}
#endif // defined(_DEBUG)
// Initialize the thread list structure
// The data for this structure should be set by
// boinc_init or boinc_init_graphics.
diagnostics_init_thread_list();
diagnostics_init_unhandled_exception_monitor();
diagnostics_init_message_monitor();
#endif // defined(_WIN32)
// Install unhandled exception filters and signal traps.
if (BOINC_SUCCESS != boinc_install_signal_handlers()) {
return ERR_SIGNAL_OP;
}
// Store various pieces of inforation for future use.
if (flags & BOINC_DIAG_BOINCAPPLICATION) {
char buf[256];
char proxy_address[256];
int proxy_port;
MIOFILE mf;
FILE* p;
#ifdef _WIN32
LONG lReturnValue;
HKEY hkSetupHive;
DWORD dwSize = 0;
#endif
strcpy(buf, "");
strcpy(proxy_address, "");
proxy_port = 0;
#ifndef _USING_FCGI_
p = fopen(INIT_DATA_FILE, "r");
#else
p = FCGI::fopen(INIT_DATA_FILE, "r");
#endif
if (p) {
mf.init_file(p);
while(mf.fgets(buf, sizeof(buf))) {
if (match_tag(buf, "</app_init_data>")) break;
else if (parse_str(buf, "<boinc_dir>", boinc_dir, 256)) continue;
else if (parse_str(buf, "<symstore>", symstore, 256)) continue;
else if (match_tag(buf, "<use_http_proxy/>")) {
boinc_proxy_enabled = true;
continue;
}
else if (parse_str(buf, "<http_server_name>", proxy_address, 256)) continue;
else if (parse_int(buf, "<http_server_port>", proxy_port)) continue;
}
fclose(p);
}
if (boinc_proxy_enabled) {
int buffer_used = snprintf(boinc_proxy, sizeof(boinc_proxy), "%s:%d", proxy_address, proxy_port);
if ((sizeof(boinc_proxy) == buffer_used) || (-1 == buffer_used)) {
boinc_proxy[sizeof(boinc_proxy)-1] = '\0';
}
}
#ifdef _WIN32
// Lookup the location of where BOINC was installed to and store
// that for future use.
lReturnValue = RegOpenKeyEx(
HKEY_LOCAL_MACHINE,
_T("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?
dwSize = sizeof(boinc_install_dir);
lReturnValue = RegQueryValueEx(
hkSetupHive,
_T("INSTALLDIR"),
NULL,
NULL,
(LPBYTE)&boinc_install_dir,
&dwSize
);
}
if (hkSetupHive) RegCloseKey(hkSetupHive);
#endif
}
return BOINC_SUCCESS;
}