// parse a <result> element from scheduling server.
//
int RESULT::parse_server(XML_PARSER& xp) {
FILE_REF file_ref;
clear();
while (!xp.get_tag()) {
if (xp.match_tag("/result")) return 0;
if (xp.parse_str("name", name, sizeof(name))) continue;
if (xp.parse_str("wu_name", wu_name, sizeof(wu_name))) continue;
if (xp.parse_double("report_deadline", report_deadline)) continue;
if (xp.parse_str("platform", platform, sizeof(platform))) continue;
if (xp.parse_str("plan_class", plan_class, sizeof(plan_class))) continue;
if (xp.parse_int("version_num", version_num)) continue;
if (xp.match_tag("file_ref")) {
file_ref.parse(xp);
output_files.push_back(file_ref);
continue;
}
if (xp.parse_bool("report_immediately", report_immediately)) continue;
if (log_flags.unparsed_xml) {
msg_printf(0, MSG_INFO,
"[unparsed_xml] RESULT::parse(): unrecognized: %s\n",
xp.parsed_tag
);
}
xp.skip_unexpected();
}
return ERR_XML_PARSE;
}
int OUTPUT_FILE_INFO::parse(XML_PARSER& xp) {
bool found=false;
optional = false;
no_validate = false;
while (!xp.get_tag()) {
if (!xp.is_tag) continue;
if (xp.match_tag("/file_ref")) {
return found?0:ERR_XML_PARSE;
}
if (xp.parse_string("file_name", name)) {
found = true;
continue;
}
if (xp.parse_bool("optional", optional)) continue;
if (xp.parse_bool("no_validate", no_validate)) continue;
}
return ERR_XML_PARSE;
}
int SCHED_DB_RESULT::parse_from_client(XML_PARSER& xp) {
double dtemp;
bool btemp;
string stemp;
int itemp;
// should be non-zero if exit_status is not found
exit_status = ERR_NO_EXIT_STATUS;
memset(this, 0, sizeof(*this));
while (!xp.get_tag()) {
if (xp.match_tag("/result")) {
return 0;
}
if (xp.parse_str("name", name, sizeof(name))) continue;
if (xp.parse_int("state", client_state)) continue;
if (xp.parse_double("final_cpu_time", cpu_time)) continue;
if (xp.parse_double("final_elapsed_time", elapsed_time)) continue;
if (xp.parse_int("exit_status", exit_status)) continue;
if (xp.parse_int("app_version_num", app_version_num)) continue;
if (xp.match_tag("file_info")) {
string s;
xp.copy_element(s);
safe_strcat(xml_doc_out, s.c_str());
continue;
}
if (xp.match_tag("stderr_out" )) {
copy_element_contents(xp.f->f, "</stderr_out>", stderr_out, sizeof(stderr_out));
continue;
}
if (xp.parse_string("platform", stemp)) continue;
if (xp.parse_int("version_num", itemp)) continue;
if (xp.parse_string("plan_class", stemp)) continue;
if (xp.parse_double("completed_time", dtemp)) continue;
if (xp.parse_string("file_name", stemp)) continue;
if (xp.match_tag("file_ref")) {
xp.copy_element(stemp);
continue;
}
if (xp.parse_string("open_name", stemp)) continue;
if (xp.parse_bool("ready_to_report", btemp)) continue;
if (xp.parse_double("report_deadline", dtemp)) continue;
if (xp.parse_string("wu_name", stemp)) continue;
// deprecated stuff
if (xp.parse_double("fpops_per_cpu_sec", dtemp)) continue;
if (xp.parse_double("fpops_cumulative", dtemp)) continue;
if (xp.parse_double("intops_per_cpu_sec", dtemp)) continue;
if (xp.parse_double("intops_cumulative", dtemp)) continue;
log_messages.printf(MSG_NORMAL,
"RESULT::parse_from_client(): unrecognized: %s\n",
xp.parsed_tag
);
}
return ERR_XML_PARSE;
}
int HOST::parse(XML_PARSER& xp) {
p_ncpus = 1;
double dtemp;
string stemp;
while (!xp.get_tag()) {
if (xp.match_tag("/host_info")) return 0;
if (xp.parse_int("timezone", timezone)) continue;
if (xp.parse_str("domain_name", domain_name, sizeof(domain_name))) continue;
if (xp.parse_str("ip_addr", last_ip_addr, sizeof(last_ip_addr))) continue;
if (xp.parse_str("host_cpid", host_cpid, sizeof(host_cpid))) continue;
if (xp.parse_int("p_ncpus", p_ncpus)) continue;
if (xp.parse_str("p_vendor", p_vendor, sizeof(p_vendor))) continue;
if (xp.parse_str("p_model", p_model, sizeof(p_model))) continue;
if (xp.parse_double("p_fpops", p_fpops)) continue;
if (xp.parse_double("p_iops", p_iops)) continue;
if (xp.parse_double("p_membw", p_membw)) continue;
if (xp.parse_str("os_name", os_name, sizeof(os_name))) continue;
if (xp.parse_str("os_version", os_version, sizeof(os_version))) continue;
if (xp.parse_double("m_nbytes", m_nbytes)) continue;
if (xp.parse_double("m_cache", m_cache)) continue;
if (xp.parse_double("m_swap", m_swap)) continue;
if (xp.parse_double("d_total", d_total)) continue;
if (xp.parse_double("d_free", d_free)) continue;
if (xp.parse_double("n_bwup", n_bwup)) continue;
if (xp.parse_double("n_bwdown", n_bwdown)) continue;
if (xp.parse_str("p_features", p_features, sizeof(p_features))) continue;
if (xp.parse_str("virtualbox_version", virtualbox_version, sizeof(virtualbox_version))) continue;
if (xp.parse_bool("p_vm_extensions_disabled", p_vm_extensions_disabled)) continue;
// parse deprecated fields to avoid error messages
//
if (xp.parse_double("p_calculated", dtemp)) continue;
if (xp.match_tag("p_fpop_err")) continue;
if (xp.match_tag("p_iop_err")) continue;
if (xp.match_tag("p_membw_err")) continue;
// fields reported by 5.5+ clients, not currently used
//
if (xp.parse_string("p_capabilities", stemp)) continue;
if (xp.parse_string("accelerators", stemp)) continue;
#if 1
// not sure where these fields belong in the above categories
//
if (xp.parse_string("cpu_caps", stemp)) continue;
if (xp.parse_string("cache_l1", stemp)) continue;
if (xp.parse_string("cache_l2", stemp)) continue;
if (xp.parse_string("cache_l3", stemp)) continue;
#endif
log_messages.printf(MSG_NORMAL,
"HOST::parse(): unrecognized: %s\n", xp.parsed_tag
);
}
return ERR_XML_PARSE;
}
int FILE_INFO::parse(XML_PARSER& xp) {
memset(this, 0, sizeof(*this));
while (!xp.get_tag()) {
if (xp.match_tag("/file_info")) {
if (!strlen(name)) return ERR_XML_PARSE;
return 0;
}
if (xp.parse_str("name", name, 256)) continue;
if (xp.parse_double("nbytes", nbytes)) continue;
if (xp.parse_int("status", status)) continue;
if (xp.parse_bool("sticky", sticky)) continue;
}
return ERR_XML_PARSE;
}
int HOST_INFO::parse(XML_PARSER& xp, bool benchmarks_only) {
while (!xp.get_tag()) {
if (xp.match_tag("/host_info")) return 0;
if (xp.parse_double("p_fpops", p_fpops)) {
// fix foolishness that could result in negative value here
//
if (p_fpops < 0) p_fpops = -p_fpops;
continue;
}
if (xp.parse_double("p_iops", p_iops)) {
if (p_iops < 0) p_iops = -p_iops;
continue;
}
if (xp.parse_double("p_membw", p_membw)) {
if (p_membw < 0) p_membw = -p_membw;
continue;
}
if (xp.parse_double("p_calculated", p_calculated)) continue;
if (xp.parse_bool("p_vm_extensions_disabled", p_vm_extensions_disabled)) continue;
if (benchmarks_only) continue;
// WARNING: NOTHING AFTER HERE IS READ FROM STATE FILE ON THE CLIENT
if (xp.parse_int("timezone", timezone)) continue;
if (xp.parse_str("domain_name", domain_name, sizeof(domain_name))) continue;
if (xp.parse_str("ip_addr", ip_addr, sizeof(ip_addr))) continue;
if (xp.parse_str("host_cpid", host_cpid, sizeof(host_cpid))) continue;
if (xp.parse_int("p_ncpus", p_ncpus)) continue;
if (xp.parse_str("p_vendor", p_vendor, sizeof(p_vendor))) continue;
if (xp.parse_str("p_model", p_model, sizeof(p_model))) continue;
if (xp.parse_str("p_features", p_features, sizeof(p_features))) {
downcase_string(p_features);
continue;
}
if (xp.parse_double("m_nbytes", m_nbytes)) continue;
if (xp.parse_double("m_cache", m_cache)) continue;
if (xp.parse_double("m_swap", m_swap)) continue;
if (xp.parse_double("d_total", d_total)) continue;
if (xp.parse_double("d_free", d_free)) continue;
if (xp.parse_str("os_name", os_name, sizeof(os_name))) continue;
if (xp.parse_str("os_version", os_version, sizeof(os_version))) continue;
if (xp.parse_str("virtualbox_version", virtualbox_version, sizeof(virtualbox_version))) continue;
if (xp.match_tag("coprocs")) {
this->coprocs.parse(xp);
}
}
return ERR_XML_PARSE;
}
int PROXY_INFO::parse(XML_PARSER& xp) {
memset(this, 0, sizeof(PROXY_INFO));
while (!xp.get_tag()) {
if (xp.match_tag("/proxy_info")) {
present = false;
if (strlen(http_server_name)) present = true;
if (strlen(socks_server_name)) present = true;
return 0;
}
if (xp.parse_bool("use_http_proxy", use_http_proxy)) continue;
if (xp.parse_bool("use_socks_proxy", use_socks_proxy)) continue;
if (xp.parse_bool("use_http_auth", use_http_auth)) continue;
if (xp.parse_str("socks_server_name", socks_server_name, sizeof(socks_server_name))) continue;
if (xp.parse_int("socks_server_port", socks_server_port)) continue;
if (xp.parse_str("http_server_name", http_server_name, sizeof(http_server_name))) continue;
if (xp.parse_int("http_server_port", http_server_port)) continue;
if (xp.parse_str("socks5_user_name", socks5_user_name,sizeof(socks5_user_name))) continue;
if (xp.parse_str("socks5_user_passwd", socks5_user_passwd,sizeof(socks5_user_passwd))) continue;
if (xp.parse_str("http_user_name", http_user_name,sizeof(http_user_name))) continue;
if (xp.parse_str("http_user_passwd", http_user_passwd,sizeof(http_user_passwd))) continue;
if (xp.parse_str("no_proxy", noproxy_hosts, sizeof(noproxy_hosts))) continue;
}
return ERR_XML_PARSE;
}
int RSC_JOB_LIMIT::parse(XML_PARSER& xp, const char* end_tag) {
per_proc = false;
while (!xp.get_tag()) {
if (!xp.is_tag) {
continue;
}
if (xp.match_tag(end_tag)) {
return 0;
}
if (xp.parse_int("jobs", base_limit)) {
continue;
}
if (xp.parse_bool("per_proc", per_proc)) {
continue;
}
}
return ERR_XML_PARSE;
}
int APP_CONFIGS::parse(XML_PARSER& xp, MSG_VEC& mv, LOG_FLAGS& log_flags) {
char buf[1024];
int n;
clear();
while (!xp.get_tag()) {
if (!xp.is_tag) {
sprintf(buf, "unexpected text '%s' in app_config.xml", xp.parsed_tag);
mv.push_back(string(buf));
return ERR_XML_PARSE;
}
if (xp.match_tag("/app_config")) return 0;
if (xp.match_tag("app")) {
APP_CONFIG ac;
int retval = ac.parse(xp, mv, log_flags);
if (retval) return retval;
app_configs.push_back(ac);
continue;
}
if (xp.match_tag("app_version")) {
APP_VERSION_CONFIG avc;
int retval = avc.parse(xp, mv, log_flags);
if (retval) return retval;
app_version_configs.push_back(avc);
continue;
}
if (xp.parse_int("project_max_concurrent", n)) {
if (n >= 0) {
have_max_concurrent = true;
project_max_concurrent = n;
}
continue;
}
if (xp.parse_bool("report_results_immediately", report_results_immediately)) {
continue;
}
sprintf(buf, "Unknown tag in app_config.xml: %s", xp.parsed_tag);
mv.push_back(string(buf));
xp.skip_unexpected(log_flags.unparsed_xml, "APP_CONFIGS::parse");
}
mv.push_back(string("Missing </app_config> in app_config.xml"));
return ERR_XML_PARSE;
}
int APP::parse(XML_PARSER& xp) {
strcpy(name, "");
strcpy(user_friendly_name, "");
project = NULL;
non_cpu_intensive = false;
while (!xp.get_tag()) {
if (xp.match_tag("/app")) {
if (!strlen(user_friendly_name)) {
safe_strcpy(user_friendly_name, name);
}
return 0;
}
if (xp.parse_str("name", name, sizeof(name))) continue;
if (xp.parse_str("user_friendly_name", user_friendly_name, sizeof(user_friendly_name))) continue;
if (xp.parse_bool("non_cpu_intensive", non_cpu_intensive)) continue;
#ifdef SIM
if (xp.parse_double("latency_bound", latency_bound)) continue;
if (xp.parse_double("fpops_est", fpops_est)) continue;
if (xp.parse_double("weight", weight)) continue;
if (xp.parse_double("working_set", working_set)) continue;
if (xp.match_tag("fpops")) {
fpops.parse(xp, "/fpops");
continue;
}
if (xp.parse_int("max_concurrent", max_concurrent)) {
if (max_concurrent) have_max_concurrent = true;
continue;
}
if (xp.match_tag("checkpoint_period")) {
checkpoint_period.parse(xp, "/checkpoint_period");
continue;
}
#endif
if (log_flags.unparsed_xml) {
msg_printf(0, MSG_INFO,
"[unparsed_xml] APP::parse(): unrecognized: %s\n",
xp.parsed_tag
);
}
xp.skip_unexpected();
}
return ERR_XML_PARSE;
}
int VBOX_PORT_FORWARD::parse(XML_PARSER& xp) {
while (!xp.get_tag()) {
if (xp.match_tag("/port_forward")) {
if (!host_port) {
vboxlog_msg("VBOX_PORT_FORWARD::parse(): unspecified host port");
return ERR_XML_PARSE;
}
if (!guest_port) {
vboxlog_msg("VBOX_PORT_FORWARD::parse(): unspecified guest port");
return ERR_XML_PARSE;
}
return 0;
}
else if (xp.parse_bool("is_remote", is_remote)) continue;
else if (xp.parse_int("host_port", host_port)) continue;
else if (xp.parse_int("guest_port", guest_port)) continue;
else if (xp.parse_int("nports", nports)) continue;
else {
vboxlog_msg("VBOX_PORT_FORWARD::parse(): unexpected text %s", xp.parsed_tag);
}
}
return ERR_XML_PARSE;
}
// Parse XML information about a persistent file transfer
//
int PERS_FILE_XFER::parse(XML_PARSER& xp) {
while (!xp.get_tag()) {
if (xp.match_tag("/persistent_file_xfer")) return 0;
else if (xp.parse_int("num_retries", nretry)) continue;
else if (xp.parse_double("first_request_time", first_request_time)) {
continue;
}
else if (xp.parse_double("next_request_time", next_request_time)) {
continue;
}
else if (xp.parse_double("time_so_far", time_so_far)) continue;
else if (xp.parse_double("last_bytes_xferred", last_bytes_xferred)) continue;
else if (xp.parse_bool("is_upload", is_upload)) continue;
else {
if (log_flags.unparsed_xml) {
msg_printf(NULL, MSG_INFO,
"[unparsed_xml] Unparsed line in file transfer info: %s",
xp.parsed_tag
);
}
}
}
return ERR_XML_PARSE;
}
// This is to parse our own XML.
// parse_rss() parses an RSS feed item.
//
int NOTICE::parse(XML_PARSER& xp) {
clear();
while (!xp.get_tag()) {
if (!xp.is_tag) continue;
if (xp.match_tag("/notice")) {
return 0;
}
if (xp.parse_int("seqno", seqno)) continue;
if (xp.parse_str("title", title, sizeof(title))) continue;
if (xp.parse_string("description", description)) {
xml_unescape(description); // 2nd pass
continue;
}
if (xp.parse_double("create_time", create_time)) continue;
if (xp.parse_double("arrival_time", arrival_time)) continue;
if (xp.parse_bool("is_private", is_private)) continue;
if (xp.parse_str("category", category, sizeof(category))) continue;
if (xp.parse_str("link", link, sizeof(link))) continue;
if (xp.parse_str("project_name", project_name, sizeof(project_name))) continue;
if (xp.parse_str("guid", guid, sizeof(guid))) continue;
if (xp.parse_str("feed_url", feed_url, sizeof(feed_url))) continue;
}
return ERR_XML_PARSE;
}
int PLAN_CLASS_SPEC::parse(XML_PARSER& xp) {
char buf[256];
int i;
while (!xp.get_tag()) {
if (xp.match_tag("/plan_class")) {
return 0;
}
if (xp.parse_str("name", name, sizeof(name))) continue;
if (xp.parse_int("min_core_client_version", min_core_client_version)) continue;
if (xp.parse_int("max_core_client_version", max_core_client_version)) continue;
if (xp.parse_str("gpu_type", gpu_type, sizeof(gpu_type))) continue;
if (xp.parse_bool("cuda", cuda)) continue;
if (xp.parse_bool("cal", cal)) continue;
if (xp.parse_bool("opencl", opencl)) continue;
if (xp.parse_bool("virtualbox", virtualbox)) continue;
if (xp.parse_bool("is64bit", is64bit)) continue;
if (xp.parse_str("cpu_feature", buf, sizeof(buf))) {
cpu_features.push_back(" " + (string)buf + " ");
continue;
}
if (xp.parse_double("min_ncpus", min_ncpus)) continue;
if (xp.parse_int("max_threads", max_threads)) continue;
if (xp.parse_bool("nthreads_cmdline", nthreads_cmdline)) continue;
if (xp.parse_double("projected_flops_scale", projected_flops_scale)) continue;
if (xp.parse_str("os_regex", buf, sizeof(buf))) {
if (regcomp(&(os_regex), buf, REG_EXTENDED|REG_NOSUB) ) {
log_messages.printf(MSG_CRITICAL, "BAD OS REGEXP: %s\n", buf);
return ERR_XML_PARSE;
}
have_os_regex = true;
continue;
}
if (xp.parse_str("cpu_vendor_regex", buf, sizeof(buf))) {
if (regcomp(&(cpu_vendor_regex), buf, REG_EXTENDED|REG_NOSUB) ) {
log_messages.printf(MSG_CRITICAL, "BAD CPU VENDOR REGEXP: %s\n", buf);
return ERR_XML_PARSE;
}
have_cpu_vendor_regex = true;
continue;
}
if (xp.parse_str("host_summary_regex", buf, sizeof(buf))) {
if (regcomp(&(host_summary_regex), buf, REG_EXTENDED|REG_NOSUB) ) {
log_messages.printf(MSG_CRITICAL, "BAD HOST SUMMARY REGEXP: %s\n", buf);
return ERR_XML_PARSE;
}
have_host_summary_regex = true;
continue;
}
if (xp.parse_double("min_os_version", min_os_version)) continue;
if (xp.parse_double("max_os_version", max_os_version)) continue;
if (xp.parse_int("min_android_version", min_android_version)) continue;
if (xp.parse_int("max_android_version", max_android_version)) continue;
if (xp.parse_str("project_prefs_tag", project_prefs_tag, sizeof(project_prefs_tag))) continue;
if (xp.parse_str("project_prefs_regex", buf, sizeof(buf))) {
if (regcomp(&(project_prefs_regex), buf, REG_EXTENDED|REG_NOSUB) ) {
log_messages.printf(MSG_CRITICAL, "BAD PROJECT PREFS REGEXP: %s\n", buf);
return ERR_XML_PARSE;
}
have_project_prefs_regex = true;
continue;
}
if (xp.parse_bool("project_prefs_default_true", project_prefs_default_true)) continue;
if (xp.parse_double("avg_ncpus", avg_ncpus)) continue;
if (xp.parse_double("cpu_frac", cpu_frac)) continue;
if (xp.parse_double("min_gpu_ram_mb", min_gpu_ram_mb)) continue;
if (xp.parse_double("gpu_ram_used_mb", gpu_ram_used_mb)) continue;
if (xp.parse_double("gpu_peak_flops_scale", gpu_peak_flops_scale)) continue;
if (xp.parse_double("ngpus", ngpus)) continue;
if (xp.parse_int("min_driver_version", min_driver_version)) continue;
if (xp.parse_int("max_driver_version", max_driver_version)) continue;
if (xp.parse_str("gpu_utilization_tag", gpu_utilization_tag, sizeof(gpu_utilization_tag))) continue;
if (xp.parse_bool("need_ati_libs", need_ati_libs)) continue;
if (xp.parse_bool("need_amd_libs", need_amd_libs)) continue;
if (xp.parse_bool("without_opencl", without_opencl)) continue;
if (xp.parse_int("min_cal_target", min_cal_target)) continue;
if (xp.parse_int("max_cal_target", max_cal_target)) continue;
if (xp.parse_int("min_nvidia_compcap", min_nvidia_compcap)) continue;
if (xp.parse_int("max_nvidia_compcap", max_nvidia_compcap)) continue;
if (xp.parse_int("min_cuda_version", min_cuda_version)) continue;
if (xp.parse_int("max_cuda_version", max_cuda_version)) continue;
if (xp.parse_int("min_opencl_version", min_opencl_version)) continue;
if (xp.parse_int("max_opencl_version", max_opencl_version)) continue;
if (xp.parse_int("min_opencl_driver_revision", min_opencl_driver_revision)) continue;
if (xp.parse_int("max_opencl_driver_revision", max_opencl_driver_revision)) continue;
if (xp.parse_bool("double_precision_fp", double_precision_fp)) continue;
if (xp.parse_int("min_vbox_version", min_vbox_version)) continue;
if (xp.parse_int("max_vbox_version", max_vbox_version)) continue;
if (xp.parse_int("exclude_vbox_version", i)) {
exclude_vbox_version.push_back(i);
continue;
}
if (xp.parse_bool("vm_accel_required", vm_accel_required)) continue;
}
return ERR_XML_PARSE;
}
// parse a <result> element from state file
//
int RESULT::parse_state(XML_PARSER& xp) {
FILE_REF file_ref;
clear();
while (!xp.get_tag()) {
if (xp.match_tag("/result")) {
// set state to something reasonable in case of bad state file
//
if (got_server_ack || ready_to_report) {
switch (state()) {
case RESULT_NEW:
case RESULT_FILES_DOWNLOADING:
case RESULT_FILES_DOWNLOADED:
case RESULT_FILES_UPLOADING:
set_state(RESULT_FILES_UPLOADED, "RESULT::parse_state");
break;
}
}
return 0;
}
if (xp.parse_str("name", name, sizeof(name))) continue;
if (xp.parse_str("wu_name", wu_name, sizeof(wu_name))) continue;
if (xp.parse_double("received_time", received_time)) continue;
if (xp.parse_double("report_deadline", report_deadline)) {
continue;
}
if (xp.match_tag("file_ref")) {
file_ref.parse(xp);
#ifndef SIM
output_files.push_back(file_ref);
#endif
continue;
}
if (xp.parse_double("final_cpu_time", final_cpu_time)) continue;
if (xp.parse_double("final_elapsed_time", final_elapsed_time)) continue;
if (xp.parse_double("final_peak_working_set_size", final_peak_working_set_size)) continue;
if (xp.parse_double("final_peak_swap_size", final_peak_swap_size)) continue;
if (xp.parse_double("final_peak_disk_usage", final_peak_disk_usage)) continue;
if (xp.parse_double("final_bytes_sent", final_bytes_sent)) continue;
if (xp.parse_double("final_bytes_received", final_bytes_received)) continue;
if (xp.parse_int("exit_status", exit_status)) continue;
if (xp.parse_bool("got_server_ack", got_server_ack)) continue;
if (xp.parse_bool("ready_to_report", ready_to_report)) continue;
if (xp.parse_double("completed_time", completed_time)) continue;
if (xp.parse_bool("suspended_via_gui", suspended_via_gui)) continue;
if (xp.parse_bool("report_immediately", report_immediately)) continue;
if (xp.parse_int("state", _state)) continue;
if (xp.parse_string("stderr_out", stderr_out)) continue;
if (xp.parse_double("fpops_per_cpu_sec", fpops_per_cpu_sec)) continue;
if (xp.parse_double("fpops_cumulative", fpops_cumulative)) continue;
if (xp.parse_double("intops_per_cpu_sec", intops_per_cpu_sec)) continue;
if (xp.parse_double("intops_cumulative", intops_cumulative)) continue;
if (xp.parse_str("platform", platform, sizeof(platform))) continue;
if (xp.parse_str("plan_class", plan_class, sizeof(plan_class))) continue;
if (xp.parse_int("version_num", version_num)) continue;
if (log_flags.unparsed_xml) {
msg_printf(0, MSG_INFO,
"[unparsed_xml] RESULT::parse(): unrecognized: %s\n",
xp.parsed_tag
);
}
xp.skip_unexpected();
}
return ERR_XML_PARSE;
}
int AM_ACCOUNT::parse(XML_PARSER& xp) {
char tag[256];
bool is_tag, btemp;
int retval;
double dtemp;
detach = false;
update = false;
dont_request_more_work.init();
detach_when_done.init();
url = "";
strcpy(url_signature, "");
authenticator = "";
resource_share.init();
while (!xp.get(tag, sizeof(tag), is_tag)) {
if (!is_tag) {
if (log_flags.unparsed_xml) {
msg_printf(0, MSG_INFO,
"[unparsed_xml] AM_ACCOUNT::parse: unexpected text %s",
tag
);
}
continue;
}
if (!strcmp(tag, "/account")) {
if (url.length()) return 0;
return ERR_XML_PARSE;
}
if (xp.parse_string(tag, "url", url)) continue;
if (!strcmp(tag, "url_signature")) {
retval = xp.element_contents("</url_signature>", url_signature, sizeof(url_signature));
if (retval) return retval;
strcat(url_signature, "\n");
continue;
}
if (xp.parse_string(tag, "authenticator", authenticator)) continue;
if (xp.parse_bool(tag, "detach", detach)) continue;
if (xp.parse_bool(tag, "update", update)) continue;
if (xp.parse_bool(tag, "dont_request_more_work", btemp)) {
dont_request_more_work.set(btemp);
continue;
}
if (xp.parse_bool(tag, "detach_when_done", btemp)) {
detach_when_done.set(btemp);
continue;
}
if (xp.parse_double(tag, "resource_share", dtemp)) {
if (dtemp >= 0) {
resource_share.set(dtemp);
} else {
msg_printf(NULL, MSG_INFO,
"Resource share out of range: %f", dtemp
);
}
continue;
}
if (log_flags.unparsed_xml) {
msg_printf(NULL, MSG_INFO,
"[unparsed_xml] AM_ACCOUNT: unrecognized %s", tag
);
}
xp.skip_unexpected(tag, log_flags.unparsed_xml, "AM_ACCOUNT::parse");
}
return ERR_XML_PARSE;
}
// This is used by GUI RPC clients, NOT by the BOINC client
// KEEP IN SYNCH WITH CONFIG::parse_options_client()!!
//
int CONFIG::parse_options(XML_PARSER& xp) {
string s;
int n, retval;
//clear();
// don't do this here because some options are set by cmdline args,
// which are parsed first
// but do clear these, which aren't accessable via cmdline:
//
alt_platforms.clear();
exclusive_apps.clear();
exclusive_gpu_apps.clear();
for (int i=1; i<NPROC_TYPES; i++) {
ignore_gpu_instance[i].clear();
}
exclude_gpus.clear();
while (!xp.get_tag()) {
if (!xp.is_tag) {
continue;
}
if (xp.match_tag("/options")) {
return 0;
}
if (xp.parse_bool("abort_jobs_on_exit", abort_jobs_on_exit)) continue;
if (xp.parse_bool("allow_multiple_clients", allow_multiple_clients)) continue;
if (xp.parse_bool("allow_remote_gui_rpc", allow_remote_gui_rpc)) continue;
if (xp.parse_string("alt_platform", s)) {
alt_platforms.push_back(s);
continue;
}
if (xp.parse_string("client_download_url", client_download_url)) {
downcase_string(client_download_url);
continue;
}
if (xp.parse_string("client_version_check_url", client_version_check_url)) {
downcase_string(client_version_check_url);
continue;
}
if (xp.match_tag("coproc")) {
COPROC c;
retval = c.parse(xp);
if (retval) return retval;
c.specified_in_config = true;
if (!strcmp(c.type, "CPU")) continue;
config_coprocs.add(c);
continue;
}
if (xp.parse_str("data_dir", data_dir, sizeof(data_dir))) {
continue;
}
if (xp.parse_bool("disallow_attach", disallow_attach)) continue;
if (xp.parse_bool("dont_check_file_sizes", dont_check_file_sizes)) continue;
if (xp.parse_bool("dont_contact_ref_site", dont_contact_ref_site)) continue;
if (xp.match_tag("exclude_gpu")) {
EXCLUDE_GPU eg;
retval = eg.parse(xp);
if (retval) return retval;
exclude_gpus.push_back(eg);
continue;
}
if (xp.parse_string("exclusive_app", s)) {
if (!strstr(s.c_str(), "boinc")) {
exclusive_apps.push_back(s);
}
continue;
}
if (xp.parse_string("exclusive_gpu_app", s)) {
if (!strstr(s.c_str(), "boinc")) {
exclusive_gpu_apps.push_back(s);
}
continue;
}
if (xp.parse_bool("exit_after_finish", exit_after_finish)) continue;
if (xp.parse_bool("exit_before_start", exit_before_start)) continue;
if (xp.parse_bool("exit_when_idle", exit_when_idle)) {
if (exit_when_idle) {
report_results_immediately = true;
}
continue;
}
if (xp.parse_bool("fetch_minimal_work", fetch_minimal_work)) continue;
if (xp.parse_bool("fetch_on_update", fetch_on_update)) continue;
if (xp.parse_string("force_auth", force_auth)) {
downcase_string(force_auth);
continue;
}
if (xp.parse_bool("http_1_0", http_1_0)) continue;
if (xp.parse_int("http_transfer_timeout", http_transfer_timeout)) continue;
if (xp.parse_int("http_transfer_timeout_bps", http_transfer_timeout_bps)) continue;
if (xp.parse_int("ignore_cuda_dev", n) || xp.parse_int("ignore_nvidia_dev", n)) {
ignore_gpu_instance[PROC_TYPE_NVIDIA_GPU].push_back(n);
continue;
}
if (xp.parse_int("ignore_ati_dev", n)) {
ignore_gpu_instance[PROC_TYPE_AMD_GPU].push_back(n);
continue;
}
if (xp.parse_int("ignore_intel_gpu_dev", n)) {
ignore_gpu_instance[PROC_TYPE_INTEL_GPU].push_back(n);
continue;
}
if (xp.parse_int("max_file_xfers", max_file_xfers)) continue;
if (xp.parse_int("max_file_xfers_per_project", max_file_xfers_per_project)) continue;
if (xp.parse_int("max_stderr_file_size", max_stderr_file_size)) continue;
if (xp.parse_int("max_stdout_file_size", max_stdout_file_size)) continue;
if (xp.parse_int("max_tasks_reported", max_tasks_reported)) continue;
if (xp.parse_int("ncpus", ncpus)) continue;
if (xp.parse_string("network_test_url", network_test_url)) {
downcase_string(network_test_url);
continue;
}
if (xp.parse_bool("no_alt_platform", no_alt_platform)) continue;
if (xp.parse_bool("no_gpus", no_gpus)) continue;
if (xp.parse_bool("no_info_fetch", no_info_fetch)) continue;
if (xp.parse_bool("no_priority_change", no_priority_change)) continue;
if (xp.parse_bool("os_random_only", os_random_only)) continue;
#ifndef SIM
if (xp.match_tag("proxy_info")) {
proxy_info.parse_config(xp);
continue;
}
#endif
if (xp.parse_double("rec_half_life_days", rec_half_life)) {
if (rec_half_life <= 0) rec_half_life = 10;
rec_half_life *= 86400;
continue;
}
if (xp.parse_bool("report_results_immediately", report_results_immediately)) continue;
if (xp.parse_bool("run_apps_manually", run_apps_manually)) continue;
if (xp.parse_int("save_stats_days", save_stats_days)) continue;
if (xp.parse_bool("simple_gui_only", simple_gui_only)) continue;
if (xp.parse_bool("skip_cpu_benchmarks", skip_cpu_benchmarks)) continue;
if (xp.parse_double("start_delay", start_delay)) continue;
if (xp.parse_bool("stderr_head", stderr_head)) continue;
if (xp.parse_bool("suppress_net_info", suppress_net_info)) continue;
if (xp.parse_bool("unsigned_apps_ok", unsigned_apps_ok)) continue;
if (xp.parse_bool("use_all_gpus", use_all_gpus)) continue;
if (xp.parse_bool("use_certs", use_certs)) continue;
if (xp.parse_bool("use_certs_only", use_certs_only)) continue;
if (xp.parse_bool("vbox_window", vbox_window)) continue;
xp.skip_unexpected(true, "CONFIG::parse_options");
}
return ERR_XML_PARSE;
}
int CC_CONFIG::parse_options_client(XML_PARSER& xp) {
string s;
int n, retval;
//clear();
// don't do this here because some options are set by cmdline args,
// which are parsed first
// but do clear these, which aren't accessable via cmdline:
//
alt_platforms.clear();
exclusive_apps.clear();
exclusive_gpu_apps.clear();
for (int i=1; i<NPROC_TYPES; i++) {
ignore_gpu_instance[i].clear();
}
while (!xp.get_tag()) {
if (!xp.is_tag) {
msg_printf_notice(NULL, false,
"https://boinc.berkeley.edu/manager_links.php?target=notice&controlid=config",
"%s: %s",
_("Unexpected text in cc_config.xml"),
xp.parsed_tag
);
continue;
}
if (xp.match_tag("/options")) {
return 0;
}
if (xp.parse_bool("abort_jobs_on_exit", abort_jobs_on_exit)) continue;
if (xp.parse_bool("allow_multiple_clients", allow_multiple_clients)) continue;
if (xp.parse_bool("allow_remote_gui_rpc", allow_remote_gui_rpc)) continue;
if (xp.parse_string("alt_platform", s)) {
alt_platforms.push_back(s);
continue;
}
if (xp.match_tag("coproc")) {
COPROC c;
retval = c.parse(xp);
if (retval) {
msg_printf_notice(NULL, false, NULL,
"Can't parse <coproc> element in cc_config.xml"
);
continue;
}
retval = config_coprocs.add(c);
if (retval) {
msg_printf_notice(NULL, false, NULL,
"Duplicate <coproc> element in cc_config.xml"
);
}
continue;
}
if (xp.parse_bool("disallow_attach", disallow_attach)) continue;
if (xp.parse_bool("dont_check_file_sizes", dont_check_file_sizes)) continue;
if (xp.parse_bool("dont_contact_ref_site", dont_contact_ref_site)) continue;
if (xp.parse_bool("lower_client_priority", lower_client_priority)) continue;
if (xp.parse_bool("dont_suspend_nci", dont_suspend_nci)) continue;
if (xp.parse_bool("dont_use_vbox", dont_use_vbox)) continue;
if (xp.parse_bool("dont_use_wsl", dont_use_wsl)) continue;
if (xp.match_tag("exclude_gpu")) {
EXCLUDE_GPU eg;
retval = eg.parse(xp);
if (retval) {
msg_printf_notice(NULL, false, NULL,
"Can't parse <exclude_gpu> element in cc_config.xml"
);
} else {
exclude_gpus.push_back(eg);
}
continue;
}
if (xp.parse_string("exclusive_app", s)) {
if (!strstr(s.c_str(), "boinc")) {
exclusive_apps.push_back(s);
}
continue;
}
if (xp.parse_string("exclusive_gpu_app", s)) {
if (!strstr(s.c_str(), "boinc")) {
exclusive_gpu_apps.push_back(s);
}
continue;
}
if (xp.parse_bool("exit_after_finish", exit_after_finish)) continue;
if (xp.parse_bool("exit_before_start", exit_before_start)) continue;
if (xp.parse_bool("exit_when_idle", exit_when_idle)) {
if (exit_when_idle) {
report_results_immediately = true;
}
continue;
}
if (xp.parse_bool("fetch_minimal_work", fetch_minimal_work)) continue;
if (xp.parse_bool("fetch_on_update", fetch_on_update)) continue;
if (xp.parse_string("force_auth", force_auth)) {
downcase_string(force_auth);
continue;
}
if (xp.parse_bool("http_1_0", http_1_0)) continue;
if (xp.parse_int("http_transfer_timeout", http_transfer_timeout)) continue;
if (xp.parse_int("http_transfer_timeout_bps", http_transfer_timeout_bps)) continue;
if (xp.parse_int("ignore_cuda_dev", n)||xp.parse_int("ignore_nvidia_dev", n)) {
ignore_gpu_instance[PROC_TYPE_NVIDIA_GPU].push_back(n);
continue;
}
if (xp.parse_int("ignore_ati_dev", n)) {
ignore_gpu_instance[PROC_TYPE_AMD_GPU].push_back(n);
continue;
}
if (xp.parse_int("ignore_intel_dev", n)) {
ignore_gpu_instance[PROC_TYPE_INTEL_GPU].push_back(n);
continue;
}
if (xp.parse_int("max_event_log_lines", max_event_log_lines)) continue;
if (xp.parse_int("max_file_xfers", max_file_xfers)) continue;
if (xp.parse_int("max_file_xfers_per_project", max_file_xfers_per_project)) continue;
if (xp.parse_int("max_stderr_file_size", max_stderr_file_size)) continue;
if (xp.parse_int("max_stdout_file_size", max_stdout_file_size)) continue;
if (xp.parse_int("max_tasks_reported", max_tasks_reported)) continue;
if (xp.parse_int("ncpus", ncpus)) continue;
if (xp.parse_bool("no_alt_platform", no_alt_platform)) continue;
if (xp.parse_bool("no_gpus", no_gpus)) continue;
if (xp.parse_bool("no_info_fetch", no_info_fetch)) continue;
if (xp.parse_bool("no_opencl", no_opencl)) continue;
if (xp.parse_bool("no_priority_change", no_priority_change)) continue;
if (xp.parse_bool("os_random_only", os_random_only)) continue;
if (xp.parse_int("process_priority", process_priority)) continue;
if (xp.parse_int("process_priority_special", process_priority_special)) continue;
#ifndef SIM
if (xp.match_tag("proxy_info")) {
retval = proxy_info.parse_config(xp);
if (retval) {
msg_printf_notice(NULL, false, NULL,
"Can't parse <proxy_info> element in cc_config.xml"
);
}
continue;
}
#endif
if (xp.parse_double("rec_half_life_days", rec_half_life)) {
if (rec_half_life <= 0) rec_half_life = 10;
rec_half_life *= 86400;
continue;
}
if (xp.parse_bool("report_results_immediately", report_results_immediately)) continue;
if (xp.parse_bool("run_apps_manually", run_apps_manually)) continue;
if (xp.parse_int("save_stats_days", save_stats_days)) continue;
if (xp.parse_bool("simple_gui_only", simple_gui_only)) continue;
if (xp.parse_bool("skip_cpu_benchmarks", skip_cpu_benchmarks)) continue;
if (xp.parse_double("start_delay", start_delay)) continue;
if (xp.parse_bool("stderr_head", stderr_head)) continue;
if (xp.parse_bool("suppress_net_info", suppress_net_info)) continue;
if (xp.parse_bool("unsigned_apps_ok", unsigned_apps_ok)) continue;
if (xp.parse_bool("use_all_gpus", use_all_gpus)) continue;
if (xp.parse_bool("use_certs", use_certs)) continue;
if (xp.parse_bool("use_certs_only", use_certs_only)) continue;
if (xp.parse_bool("vbox_window", vbox_window)) continue;
// The following 3 tags have been moved to nvc_config and
// NVC_CONFIG_FILE, but CC_CONFIG::write() in older clients
// may have written their default values to CONFIG_FILE.
// Silently skip them if present.
if (xp.parse_string("client_download_url", s)) continue;
if (xp.parse_string("client_new_version_text", s)) continue;
if (xp.parse_string("client_version_check_url", s)) continue;
if (xp.parse_string("network_test_url", s)) continue;
msg_printf_notice(NULL, false,
"https://boinc.berkeley.edu/manager_links.php?target=notice&controlid=config",
"%s: <%s>",
_("Unrecognized tag in cc_config.xml"),
xp.parsed_tag
);
xp.skip_unexpected(true, "CC_CONFIG::parse_options");
}
return ERR_XML_PARSE;
}
int PLAN_CLASS_SPEC::parse(XML_PARSER& xp) {
char buf[256];
while (!xp.get_tag()) {
if (xp.match_tag("/plan_class")) {
return 0;
}
if (xp.parse_str("name", name, sizeof(name))) continue;
if (xp.parse_int("min_core_client_version", min_core_client_version)) continue;
if (xp.parse_int("max_core_client_version", max_core_client_version)) continue;
if (xp.parse_str("gpu_type", gpu_type, sizeof(gpu_type))) continue;
if (xp.parse_bool("cuda", cuda)) continue;
if (xp.parse_bool("cal", cal)) continue;
if (xp.parse_bool("opencl", opencl)) continue;
if (xp.parse_bool("virtualbox", virtualbox)) continue;
if (xp.parse_bool("is64bit", is64bit)) continue;
if (xp.parse_str("cpu_feature", buf, sizeof(buf))) {
cpu_features.push_back(" " + (string)buf + " ");
continue;
}
if (xp.parse_double("min_ncpus", min_ncpus)) continue;
if (xp.parse_int("max_threads", max_threads)) continue;
if (xp.parse_double("projected_flops_scale", projected_flops_scale)) continue;
if (xp.parse_str("os_regex", buf, sizeof(buf))) {
if (regcomp(&(os_regex), buf, REG_EXTENDED|REG_NOSUB) ) {
log_messages.printf(MSG_CRITICAL, "BAD REGEXP: %s\n", buf);
return ERR_XML_PARSE;
}
have_os_regex = true;
continue;
}
if (xp.parse_str("project_prefs_tag", project_prefs_tag, sizeof(project_prefs_tag))) continue;
if (xp.parse_str("project_prefs_regex", buf, sizeof(buf))) {
if (regcomp(&(project_prefs_regex), buf, REG_EXTENDED|REG_NOSUB) ) {
log_messages.printf(MSG_CRITICAL, "BAD REGEXP: %s\n", buf);
return ERR_XML_PARSE;
}
have_project_prefs_regex = true;
continue;
}
if (xp.parse_double("avg_ncpus", avg_ncpus)) continue;
if (xp.parse_double("cpu_frac", cpu_frac)) continue;
if (xp.parse_double("min_gpu_ram_mb", min_gpu_ram_mb)) continue;
if (xp.parse_double("gpu_ram_used_mb", gpu_ram_used_mb)) continue;
if (xp.parse_double("gpu_peak_flops_scale", gpu_peak_flops_scale)) continue;
if (xp.parse_double("ngpus", ngpus)) continue;
if (xp.parse_int("min_driver_version", min_driver_version)) continue;
if (xp.parse_int("max_driver_version", max_driver_version)) continue;
if (xp.parse_str("gpu_utilization_tag", gpu_utilization_tag, sizeof(gpu_utilization_tag))) continue;
if (xp.parse_bool("need_ati_libs", need_ati_libs)) continue;
if (xp.parse_int("min_cal_target", min_cal_target)) continue;
if (xp.parse_int("max_cal_target", max_cal_target)) continue;
if (xp.parse_int("min_nvidia_compcap", min_nvidia_compcap)) continue;
if (xp.parse_int("max_nvidia_compcap", max_nvidia_compcap)) continue;
if (xp.parse_int("min_cuda_version", min_cuda_version)) continue;
if (xp.parse_int("max_cuda_version", max_cuda_version)) continue;
if (xp.parse_int("min_opencl_version", min_opencl_version)) continue;
if (xp.parse_int("max_opencl_version", max_opencl_version)) continue;
if (xp.parse_int("min_vbox_version", min_vbox_version)) continue;
if (xp.parse_int("max_vbox_version", max_vbox_version)) continue;
}
return ERR_XML_PARSE;
}
// Parse global prefs, overriding whatever is currently in the structure.
//
// If host_venue is nonempty and we find an element of the form
// <venue name="X">
// ...
// </venue>
// where X==host_venue, then parse that and ignore the rest.
// Otherwise ignore <venue> elements.
//
// The start tag may or may not have already been parsed
//
int GLOBAL_PREFS::parse_override(
XML_PARSER& xp, const char* host_venue, bool& found_venue, GLOBAL_PREFS_MASK& mask
) {
char buf2[256], attrs[256];
bool in_venue = false, in_correct_venue=false;
double dtemp;
int itemp;
found_venue = false;
mask.clear();
while (!xp.get_tag(attrs, sizeof(attrs))) {
if (!xp.is_tag) continue;
if (xp.match_tag("global_preferences")) continue;
if (xp.match_tag("/global_preferences")) {
return 0;
}
if (in_venue) {
if (xp.match_tag("/venue")) {
if (in_correct_venue) {
return 0;
} else {
in_venue = false;
continue;
}
} else {
if (!in_correct_venue) continue;
}
} else {
if (strstr(xp.parsed_tag, "venue")) {
in_venue = true;
parse_attr(attrs, "name", buf2, sizeof(buf2));
if (!strcmp(buf2, host_venue)) {
defaults();
clear_bools();
mask.clear();
in_correct_venue = true;
found_venue = true;
} else {
in_correct_venue = false;
}
continue;
}
}
if (xp.parse_str("source_project", source_project, sizeof(source_project))) continue;
if (xp.parse_str("source_scheduler", source_scheduler, sizeof(source_scheduler))) {
continue;
}
if (xp.parse_double("mod_time", mod_time)) {
double now = dtime();
if (mod_time > now) {
mod_time = now;
}
continue;
}
if (xp.parse_double("battery_charge_min_pct", battery_charge_min_pct)) {
mask.battery_charge_min_pct = true;
continue;
}
if (xp.parse_double("battery_max_temperature", battery_max_temperature)) {
mask.battery_max_temperature = true;
continue;
}
if (xp.parse_bool("run_on_batteries", run_on_batteries)) {
mask.run_on_batteries = true;
continue;
}
if (xp.parse_bool("run_if_user_active", run_if_user_active)) {
mask.run_if_user_active = true;
continue;
}
if (xp.parse_bool("run_gpu_if_user_active", run_gpu_if_user_active)) {
mask.run_gpu_if_user_active = true;
continue;
}
if (xp.parse_double("idle_time_to_run", idle_time_to_run)) {
mask.idle_time_to_run = true;
continue;
}
if (xp.parse_double("suspend_if_no_recent_input", suspend_if_no_recent_input)) {
mask.suspend_if_no_recent_input = true;
continue;
}
if (xp.parse_double("suspend_cpu_usage", suspend_cpu_usage)) {
mask.suspend_cpu_usage = true;
continue;
}
if (xp.parse_double("start_hour", cpu_times.start_hour)) {
mask.start_hour = true;
continue;
}
if (xp.parse_double("end_hour", cpu_times.end_hour)) {
mask.end_hour = true;
continue;
}
if (xp.parse_double("net_start_hour", net_times.start_hour)) {
mask.net_start_hour = true;
continue;
}
if (xp.parse_double("net_end_hour", net_times.end_hour)) {
mask.net_end_hour = true;
continue;
}
if (xp.match_tag("day_prefs")) {
parse_day(xp);
continue;
}
if (xp.parse_bool("leave_apps_in_memory", leave_apps_in_memory)) {
mask.leave_apps_in_memory = true;
continue;
}
if (xp.parse_bool("confirm_before_connecting", confirm_before_connecting)) {
mask.confirm_before_connecting = true;
continue;
}
if (xp.parse_bool("hangup_if_dialed", hangup_if_dialed)) {
mask.hangup_if_dialed = true;
continue;
}
if (xp.parse_bool("dont_verify_images", dont_verify_images)) {
mask.dont_verify_images = true;
continue;
}
if (xp.parse_double("work_buf_min_days", work_buf_min_days)) {
if (work_buf_min_days < 0) work_buf_min_days = 0;
mask.work_buf_min_days = true;
continue;
}
if (xp.parse_double("work_buf_additional_days", work_buf_additional_days)) {
if (work_buf_additional_days < 0) work_buf_additional_days = 0;
mask.work_buf_additional_days = true;
continue;
}
if (xp.parse_double("max_ncpus_pct", max_ncpus_pct)) {
if (max_ncpus_pct < 0) max_ncpus_pct = 0;
if (max_ncpus_pct > 100) max_ncpus_pct = 100;
mask.max_ncpus_pct = true;
continue;
}
if (xp.parse_int("max_cpus", max_ncpus)) {
if (max_ncpus < 0) max_ncpus = 0;
mask.max_ncpus = true;
continue;
}
if (xp.parse_double("disk_interval", disk_interval)) {
if (disk_interval<0) disk_interval = 0;
mask.disk_interval = true;
continue;
}
if (xp.parse_double("cpu_scheduling_period_minutes", cpu_scheduling_period_minutes)) {
if (cpu_scheduling_period_minutes < 0.0001) cpu_scheduling_period_minutes = 60;
mask.cpu_scheduling_period_minutes = true;
continue;
}
if (xp.parse_double("disk_max_used_gb", disk_max_used_gb)) {
mask.disk_max_used_gb = true;
continue;
}
if (xp.parse_double("disk_max_used_pct", disk_max_used_pct)) {
mask.disk_max_used_pct = true;
continue;
}
if (xp.parse_double("disk_min_free_gb", disk_min_free_gb)) {
mask.disk_min_free_gb = true;
continue;
}
if (xp.parse_double("vm_max_used_pct", dtemp)) {
vm_max_used_frac = dtemp/100;
mask.vm_max_used_frac = true;
continue;
}
if (xp.parse_double("ram_max_used_busy_pct", dtemp)) {
if (!dtemp) dtemp = 100;
ram_max_used_busy_frac = dtemp/100;
mask.ram_max_used_busy_frac = true;
continue;
}
if (xp.parse_double("ram_max_used_idle_pct", dtemp)) {
if (!dtemp) dtemp = 100;
ram_max_used_idle_frac = dtemp/100;
mask.ram_max_used_idle_frac = true;
continue;
}
if (xp.parse_double("max_bytes_sec_up", max_bytes_sec_up)) {
if (max_bytes_sec_up < 0) max_bytes_sec_up = 0;
mask.max_bytes_sec_up = true;
continue;
}
if (xp.parse_double("max_bytes_sec_down", max_bytes_sec_down)) {
if (max_bytes_sec_down < 0) max_bytes_sec_down = 0;
mask.max_bytes_sec_down = true;
continue;
}
if (xp.parse_double("cpu_usage_limit", dtemp)) {
if (dtemp > 0 && dtemp <= 100) {
cpu_usage_limit = dtemp;
mask.cpu_usage_limit = true;
}
continue;
}
if (xp.parse_double("daily_xfer_limit_mb", dtemp)) {
if (dtemp >= 0) {
daily_xfer_limit_mb = dtemp;
mask.daily_xfer_limit_mb = true;
}
continue;
}
if (xp.parse_int("daily_xfer_period_days", itemp)) {
if (itemp >= 0) {
daily_xfer_period_days = itemp;
mask.daily_xfer_period_days = true;
}
continue;
}
if (xp.parse_bool("network_wifi_only", network_wifi_only)) {
continue;
}
if (xp.parse_bool("host_specific", host_specific)) {
continue;
}
// false means don't print anything
xp.skip_unexpected(false, "GLOBAL_PREFS::parse_override");
}
return ERR_XML_PARSE;
}
int FILE_INFO::parse(XML_PARSER& xp) {
char buf2[1024];
std::string url;
PERS_FILE_XFER *pfxp;
int retval;
bool btemp;
vector<string>gzipped_urls;
while (!xp.get_tag()) {
if (xp.match_tag("/file_info") || xp.match_tag("/file")) {
if (!strlen(name)) return ERR_BAD_FILENAME;
if (strstr(name, "..")) return ERR_BAD_FILENAME;
if (strstr(name, "%")) return ERR_BAD_FILENAME;
if (gzipped_urls.size() > 0) {
download_urls.clear();
download_urls.urls = gzipped_urls;
download_gzipped = true;
}
return 0;
}
if (xp.match_tag("xml_signature")) {
retval = copy_element_contents(
xp.f->f,
"</xml_signature>",
xml_signature,
sizeof(xml_signature)
);
if (retval) return retval;
strip_whitespace(xml_signature);
continue;
}
if (xp.match_tag("file_signature")) {
retval = copy_element_contents(
xp.f->f,
"</file_signature>",
file_signature,
sizeof(file_signature)
);
if (retval) return retval;
strip_whitespace(file_signature);
continue;
}
if (xp.match_tag("signatures")) {
if (!cert_sigs->parse(xp)) {
msg_printf(0, MSG_INTERNAL_ERROR,
"FILE_INFO::parse(): cannot parse <signatures>\n"
);
return ERR_XML_PARSE;
}
continue;
}
if (xp.parse_str("name", name, sizeof(name))) continue;
if (xp.parse_string("url", url)) {
if (strstr(url.c_str(), "file_upload_handler")) {
upload_urls.urls.push_back(url);
} else {
download_urls.urls.push_back(url);
}
continue;
}
if (xp.parse_string("download_url", url)) {
download_urls.urls.push_back(url);
continue;
}
if (xp.parse_string("upload_url", url)) {
upload_urls.urls.push_back(url);
continue;
}
if (xp.parse_string("gzipped_url", url)) {
gzipped_urls.push_back(url);
continue;
}
if (xp.parse_str("md5_cksum", md5_cksum, sizeof(md5_cksum))) continue;
if (xp.parse_double("nbytes", nbytes)) continue;
if (xp.parse_double("gzipped_nbytes", gzipped_nbytes)) continue;
if (xp.parse_double("max_nbytes", max_nbytes)) continue;
if (xp.parse_int("status", status)) {
// on startup, VERIFY_PENDING is meaningless
if (status == FILE_VERIFY_PENDING) {
status = FILE_NOT_PRESENT;
}
continue;
}
if (xp.parse_bool("executable", executable)) continue;
if (xp.parse_bool("uploaded", uploaded)) continue;
if (xp.parse_bool("sticky", sticky)) continue;
if (xp.parse_bool("gzip_when_done", gzip_when_done)) continue;
if (xp.parse_bool("download_gzipped", download_gzipped)) continue;
if (xp.parse_bool("signature_required", signature_required)) continue;
if (xp.parse_bool("is_project_file", is_project_file)) continue;
if (xp.parse_bool("no_delete", btemp)) continue;
if (xp.match_tag("persistent_file_xfer")) {
pfxp = new PERS_FILE_XFER;
retval = pfxp->parse(xp);
#ifdef SIM
delete pfxp;
continue;
#endif
if (!retval) {
pers_file_xfer = pfxp;
} else {
delete pfxp;
}
continue;
}
if (xp.match_tag("file_xfer")) {
while (!xp.get_tag()) {
if (xp.match_tag("/file_xfer")) break;
}
continue;
}
if (xp.match_tag("error_msg")) {
retval = copy_element_contents(
xp.f->f,
"</error_msg>", buf2, sizeof(buf2)
);
if (retval) return retval;
error_msg = buf2;
continue;
}
// deprecated tags
if (xp.parse_bool("generated_locally", btemp)) continue;
if (xp.parse_bool("upload_when_present", btemp)) continue;
if (log_flags.unparsed_xml) {
msg_printf(0, MSG_INFO,
"[unparsed_xml] FILE_INFO::parse(): unrecognized: %s\n",
xp.parsed_tag
);
}
xp.skip_unexpected();
}
return ERR_XML_PARSE;
}
// Parse log flag preferences
//
int LOG_FLAGS::parse(XML_PARSER& xp) {
while (!xp.get_tag()) {
if (!xp.is_tag) {
continue;
}
if (xp.match_tag("/log_flags")) return 0;
if (xp.parse_bool("file_xfer", file_xfer)) continue;
if (xp.parse_bool("sched_ops", sched_ops)) continue;
if (xp.parse_bool("task", task)) continue;
if (xp.parse_bool("app_msg_receive", app_msg_receive)) continue;
if (xp.parse_bool("app_msg_send", app_msg_send)) continue;
if (xp.parse_bool("async_file_debug", async_file_debug)) continue;
if (xp.parse_bool("benchmark_debug", benchmark_debug)) continue;
if (xp.parse_bool("checkpoint_debug", checkpoint_debug)) continue;
if (xp.parse_bool("coproc_debug", coproc_debug)) continue;
if (xp.parse_bool("cpu_sched", cpu_sched)) continue;
if (xp.parse_bool("cpu_sched_debug", cpu_sched_debug)) continue;
if (xp.parse_bool("cpu_sched_status", cpu_sched_status)) continue;
if (xp.parse_bool("dcf_debug", dcf_debug)) continue;
if (xp.parse_bool("disk_usage_debug", disk_usage_debug)) continue;
if (xp.parse_bool("file_xfer_debug", file_xfer_debug)) continue;
if (xp.parse_bool("gui_rpc_debug", gui_rpc_debug)) continue;
if (xp.parse_bool("heartbeat_debug", heartbeat_debug)) continue;
if (xp.parse_bool("http_debug", http_debug)) continue;
if (xp.parse_bool("http_xfer_debug", http_xfer_debug)) continue;
if (xp.parse_bool("mem_usage_debug", mem_usage_debug)) continue;
if (xp.parse_bool("network_status_debug", network_status_debug)) continue;
if (xp.parse_bool("notice_debug", notice_debug)) continue;
if (xp.parse_bool("poll_debug", poll_debug)) continue;
if (xp.parse_bool("priority_debug", priority_debug)) continue;
if (xp.parse_bool("proxy_debug", proxy_debug)) continue;
if (xp.parse_bool("rr_simulation", rr_simulation)) continue;
if (xp.parse_bool("rrsim_detail", rrsim_detail)) continue;
if (xp.parse_bool("sched_op_debug", sched_op_debug)) continue;
if (xp.parse_bool("scrsave_debug", scrsave_debug)) continue;
if (xp.parse_bool("slot_debug", slot_debug)) continue;
if (xp.parse_bool("state_debug", state_debug)) continue;
if (xp.parse_bool("statefile_debug", statefile_debug)) continue;
if (xp.parse_bool("suspend_debug", suspend_debug)) continue;
if (xp.parse_bool("task_debug", task_debug)) continue;
if (xp.parse_bool("time_debug", time_debug)) continue;
if (xp.parse_bool("trickle_debug", trickle_debug)) continue;
if (xp.parse_bool("unparsed_xml", unparsed_xml)) continue;
if (xp.parse_bool("work_fetch_debug", work_fetch_debug)) continue;
xp.skip_unexpected(true, "LOG_FLAGS::parse");
}
return ERR_XML_PARSE;
}
static int process_file_info(
XML_PARSER& xp, string& out, int ninfiles, const char** infiles,
SCHED_CONFIG& config_loc
) {
vector<string> urls;
bool generated_locally = false;
int retval, file_number = -1;
double nbytes, nbytesdef = -1;
string md5str, urlstr, tmpstr;
char buf[BLOB_SIZE], path[MAXPATHLEN], top_download_path[MAXPATHLEN], md5[33], url[256];
out += "<file_info>\n";
while (!xp.get_tag()) {
if (xp.parse_int("number", file_number)) {
continue;
} else if (xp.parse_bool("generated_locally", generated_locally)) {
continue;
} else if (xp.parse_string("url", urlstr)) {
urls.push_back(urlstr);
continue;
} else if (xp.parse_string("md5_cksum", md5str)) {
continue;
} else if (xp.parse_double("nbytes", nbytesdef)) {
continue;
} else if (xp.match_tag("/file_info")) {
if (nbytesdef != -1 || md5str != "" || urlstr != "") {
if (nbytesdef == -1 || md5str == "" || urlstr == "") {
fprintf(stderr, "All file properties must be defined "
"if at least one is defined (url, md5_cksum, nbytes)!\n"
);
return ERR_XML_PARSE;
}
}
if (file_number < 0) {
fprintf(stderr, "No file number found\n");
return ERR_XML_PARSE;
}
if (file_number >= ninfiles) {
fprintf(stderr,
"Too few input files given; need at least %d\n",
file_number+1
);
return ERR_XML_PARSE;
}
if (input_file_found[file_number]) {
fprintf(stderr,
"Input file %d listed twice\n", file_number
);
return ERR_XML_PARSE;
}
input_file_found[file_number] = true;
if (generated_locally) {
sprintf(buf,
" <name>%s</name>\n"
" <generated_locally/>\n"
"</file_info>\n",
infiles[file_number]
);
} else if (nbytesdef == -1) {
// here if nybtes was not supplied; stage the file
//
dir_hier_path(
infiles[file_number], config_loc.download_dir,
config_loc.uldl_dir_fanout, path, true
);
// if file isn't found in hierarchy,
// look for it at top level and copy
//
if (!boinc_file_exists(path)) {
sprintf(top_download_path,
"%s/%s",config_loc.download_dir,
infiles[file_number]
);
boinc_copy(top_download_path, path);
}
if (!config_loc.cache_md5_info || !got_md5_info(path, md5, &nbytes)) {
retval = md5_file(path, md5, nbytes);
if (retval) {
fprintf(stderr, "process_input_template: md5_file %d\n", retval);
return retval;
} else if (config_loc.cache_md5_info) {
write_md5_info(path, md5, nbytes);
}
}
dir_hier_url(
infiles[file_number], config_loc.download_url,
config_loc.uldl_dir_fanout, url
);
sprintf(buf,
" <name>%s</name>\n"
" <url>%s</url>\n"
" <md5_cksum>%s</md5_cksum>\n"
" <nbytes>%.0f</nbytes>\n"
"</file_info>\n",
infiles[file_number],
url,
md5,
nbytes
);
} else {
// here if nbytes etc. was supplied,
// i.e the file is already staged, possibly remotely
//
urlstr = "";
for (unsigned int i=0; i<urls.size(); i++) {
urlstr += " <url>" + urls.at(i) + "</url>\n";
}
sprintf(buf,
" <name>%s</name>\n"
"%s"
" <md5_cksum>%s</md5_cksum>\n"
" <nbytes>%.0f</nbytes>\n"
"</file_info>\n",
infiles[file_number],
urlstr.c_str(),
md5str.c_str(),
nbytesdef
);
}
out += buf;
break;
} else {
retval = xp.copy_element(tmpstr);
if (retval) return retval;
out += tmpstr;
out += "\n";
}
}
return 0;
}
// Parse log flag preferences
//
int LOG_FLAGS::parse(XML_PARSER& xp) {
char tag[1024];
bool is_tag;
while (!xp.get(tag, sizeof(tag), is_tag)) {
if (!is_tag) {
msg_printf(NULL, MSG_USER_ALERT,
"Unexpected text %s in %s", tag, CONFIG_FILE
);
continue;
}
if (!strcmp(tag, "/log_flags")) return 0;
if (xp.parse_bool(tag, "file_xfer", file_xfer)) continue;
if (xp.parse_bool(tag, "sched_ops", sched_ops)) continue;
if (xp.parse_bool(tag, "task", task)) continue;
if (xp.parse_bool(tag, "app_msg_receive", app_msg_receive)) continue;
if (xp.parse_bool(tag, "app_msg_send", app_msg_send)) continue;
if (xp.parse_bool(tag, "benchmark_debug", benchmark_debug)) continue;
if (xp.parse_bool(tag, "checkpoint_debug", checkpoint_debug)) continue;
if (xp.parse_bool(tag, "coproc_debug", coproc_debug)) continue;
if (xp.parse_bool(tag, "cpu_sched", cpu_sched)) continue;
if (xp.parse_bool(tag, "cpu_sched_debug", cpu_sched_debug)) continue;
if (xp.parse_bool(tag, "cpu_sched_status", cpu_sched_status)) continue;
if (xp.parse_bool(tag, "dcf_debug", dcf_debug)) continue;
if (xp.parse_bool(tag, "debt_debug", debt_debug)) continue;
if (xp.parse_bool(tag, "std_debug", std_debug)) continue;
if (xp.parse_bool(tag, "file_xfer_debug", file_xfer_debug)) continue;
if (xp.parse_bool(tag, "gui_rpc_debug", gui_rpc_debug)) continue;
if (xp.parse_bool(tag, "http_debug", http_debug)) continue;
if (xp.parse_bool(tag, "http_xfer_debug", http_xfer_debug)) continue;
if (xp.parse_bool(tag, "mem_usage_debug", mem_usage_debug)) continue;
if (xp.parse_bool(tag, "network_status_debug", network_status_debug)) continue;
if (xp.parse_bool(tag, "poll_debug", poll_debug)) continue;
if (xp.parse_bool(tag, "proxy_debug", proxy_debug)) continue;
if (xp.parse_bool(tag, "rr_simulation", rr_simulation)) continue;
if (xp.parse_bool(tag, "sched_op_debug", sched_op_debug)) continue;
if (xp.parse_bool(tag, "scrsave_debug", scrsave_debug)) continue;
if (xp.parse_bool(tag, "slot_debug", slot_debug)) continue;
if (xp.parse_bool(tag, "state_debug", state_debug)) continue;
if (xp.parse_bool(tag, "statefile_debug", statefile_debug)) continue;
if (xp.parse_bool(tag, "task_debug", task_debug)) continue;
if (xp.parse_bool(tag, "time_debug", time_debug)) continue;
if (xp.parse_bool(tag, "unparsed_xml", unparsed_xml)) continue;
if (xp.parse_bool(tag, "work_fetch_debug", work_fetch_debug)) continue;
if (xp.parse_bool(tag, "notice_debug", notice_debug)) continue;
msg_printf(NULL, MSG_USER_ALERT, "Unrecognized tag in %s: <%s>\n",
CONFIG_FILE, tag
);
xp.skip_unexpected(tag, true, "LOG_FLAGS::parse");
}
return ERR_XML_PARSE;
}
int APP_VERSION::parse(XML_PARSER& xp) {
FILE_REF file_ref;
double dtemp;
int rt;
strcpy(app_name, "");
strcpy(api_version, "");
version_num = 0;
strcpy(platform, "");
strcpy(plan_class, "");
strcpy(cmdline, "");
strcpy(file_prefix, "");
avg_ncpus = 1;
max_ncpus = 1;
gpu_usage.rsc_type = 0;
gpu_usage.usage = 0;
gpu_ram = 0;
app = NULL;
project = NULL;
flops = gstate.host_info.p_fpops;
missing_coproc = false;
strcpy(missing_coproc_name, "");
dont_throttle = false;
needs_network = false;
while (!xp.get_tag()) {
if (xp.match_tag("/app_version")) {
rt = gpu_usage.rsc_type;
if (rt) {
if (strstr(plan_class, "opencl")) {
if (!coprocs.coprocs[rt].have_opencl) {
msg_printf(0, MSG_INFO,
"App version needs OpenCL but GPU doesn't support it"
);
missing_coproc = true;
missing_coproc_usage = gpu_usage.usage;
strcpy(missing_coproc_name, coprocs.coprocs[rt].type);
}
} else if (strstr(plan_class, "cuda")) {
if (!coprocs.coprocs[rt].have_cuda) {
msg_printf(0, MSG_INFO,
"App version needs CUDA but GPU doesn't support it"
);
missing_coproc = true;
missing_coproc_usage = gpu_usage.usage;
strcpy(missing_coproc_name, coprocs.coprocs[rt].type);
}
} else if (strstr(plan_class, "ati")) {
if (!coprocs.coprocs[rt].have_cal) {
msg_printf(0, MSG_INFO,
"App version needs CAL but GPU doesn't support it"
);
missing_coproc = true;
missing_coproc_usage = gpu_usage.usage;
strcpy(missing_coproc_name, coprocs.coprocs[rt].type);
}
}
}
return 0;
}
if (xp.parse_str("app_name", app_name, sizeof(app_name))) continue;
if (xp.match_tag("file_ref")) {
file_ref.parse(xp);
app_files.push_back(file_ref);
continue;
}
if (xp.parse_int("version_num", version_num)) continue;
if (xp.parse_str("api_version", api_version, sizeof(api_version))) continue;
if (xp.parse_str("platform", platform, sizeof(platform))) continue;
if (xp.parse_str("plan_class", plan_class, sizeof(plan_class))) continue;
if (xp.parse_double("avg_ncpus", avg_ncpus)) continue;
if (xp.parse_double("max_ncpus", max_ncpus)) continue;
if (xp.parse_double("flops", dtemp)) {
if (dtemp <= 0) {
msg_printf(0, MSG_INTERNAL_ERROR,
"non-positive FLOPS in app version"
);
} else {
flops = dtemp;
}
continue;
}
if (xp.parse_str("cmdline", cmdline, sizeof(cmdline))) continue;
if (xp.parse_str("file_prefix", file_prefix, sizeof(file_prefix))) continue;
if (xp.parse_double("gpu_ram", gpu_ram)) continue;
if (xp.match_tag("coproc")) {
COPROC_REQ cp;
int retval = cp.parse(xp);
if (!retval) {
rt = rsc_index(cp.type);
if (rt <= 0) {
missing_coproc = true;
missing_coproc_usage = cp.count;
strcpy(missing_coproc_name, cp.type);
continue;
}
gpu_usage.rsc_type = rt;
gpu_usage.usage = cp.count;
} else {
msg_printf(0, MSG_INTERNAL_ERROR, "Error parsing <coproc>");
}
continue;
}
if (xp.parse_bool("dont_throttle", dont_throttle)) continue;
if (xp.parse_bool("needs_network", needs_network)) continue;
if (log_flags.unparsed_xml) {
msg_printf(0, MSG_INFO,
"[unparsed_xml] APP_VERSION::parse(): unrecognized: %s\n",
xp.parsed_tag
);
}
xp.skip_unexpected();
}
return ERR_XML_PARSE;
}
// parse a project account from AM reply
//
int AM_ACCOUNT::parse(XML_PARSER& xp) {
char buf[256];
bool btemp;
int retval;
double dtemp;
detach = false;
update = false;
memset(no_rsc, 0, sizeof(no_rsc));
dont_request_more_work.init();
detach_when_done.init();
suspend.init();
abort_not_started.init();
url = "";
safe_strcpy(url_signature, "");
authenticator = "";
resource_share.init();
while (!xp.get_tag()) {
if (!xp.is_tag) {
if (log_flags.unparsed_xml) {
msg_printf(0, MSG_INFO,
"[unparsed_xml] AM_ACCOUNT::parse: unexpected text %s",
xp.parsed_tag
);
}
continue;
}
if (xp.match_tag("/account")) {
if (url.length()) return 0;
return ERR_XML_PARSE;
}
if (xp.parse_string("url", url)) continue;
if (xp.match_tag("url_signature")) {
retval = xp.element_contents("</url_signature>", url_signature, sizeof(url_signature));
if (retval) return retval;
safe_strcat(url_signature, "\n");
continue;
}
if (xp.parse_string("authenticator", authenticator)) continue;
if (xp.parse_bool("detach", detach)) continue;
if (xp.parse_bool("update", update)) continue;
if (xp.parse_bool("no_cpu", btemp)) {
handle_no_rsc("CPU", btemp);
continue;
}
// deprecated
if (xp.parse_bool("no_cuda", btemp)) {
handle_no_rsc(GPU_TYPE_NVIDIA, btemp);
continue;
}
if (xp.parse_bool("no_ati", btemp)) {
handle_no_rsc(GPU_TYPE_NVIDIA, btemp);
continue;
}
if (xp.parse_str("no_rsc", buf, sizeof(buf))) {
handle_no_rsc(buf, true);
continue;
}
if (xp.parse_bool("dont_request_more_work", btemp)) {
dont_request_more_work.set(btemp);
continue;
}
if (xp.parse_bool("detach_when_done", btemp)) {
detach_when_done.set(btemp);
continue;
}
if (xp.parse_double("resource_share", dtemp)) {
if (dtemp >= 0) {
resource_share.set(dtemp);
} else {
msg_printf(NULL, MSG_INFO,
"Resource share out of range: %f", dtemp
);
}
continue;
}
if (xp.parse_bool("suspend", btemp)) {
suspend.set(btemp);
continue;
}
if (xp.parse_bool("abort_not_started", btemp)) {
abort_not_started.set(btemp);
continue;
}
if (log_flags.unparsed_xml) {
msg_printf(NULL, MSG_INFO,
"[unparsed_xml] AM_ACCOUNT: unrecognized %s", xp.parsed_tag
);
}
xp.skip_unexpected(log_flags.unparsed_xml, "AM_ACCOUNT::parse");
}
return ERR_XML_PARSE;
}
// parse project fields from client_state.xml
//
int PROJECT::parse_state(XML_PARSER& xp) {
char buf[256];
std::string sched_url, stemp;
string str1, str2;
int retval, rt;
double x;
bool btemp;
init();
while (!xp.get_tag()) {
if (xp.match_tag("/project")) {
if (cpid_time == 0) {
cpid_time = user_create_time;
}
if (dont_use_dcf) {
duration_correction_factor = 1;
}
return 0;
}
if (xp.parse_string("scheduler_url", sched_url)) {
scheduler_urls.push_back(sched_url);
continue;
}
if (xp.parse_str("master_url", master_url, sizeof(master_url))) continue;
if (xp.parse_str("project_name", project_name, sizeof(project_name))) continue;
if (xp.parse_str("symstore", symstore, sizeof(symstore))) continue;
if (xp.parse_str("user_name", user_name, sizeof(user_name))) continue;
if (xp.parse_str("team_name", team_name, sizeof(team_name))) continue;
if (xp.parse_str("host_venue", host_venue, sizeof(host_venue))) continue;
if (xp.parse_str("email_hash", email_hash, sizeof(email_hash))) continue;
if (xp.parse_str("cross_project_id", cross_project_id, sizeof(cross_project_id))) continue;
if (xp.parse_str("external_cpid", external_cpid, sizeof(external_cpid))) continue;
if (xp.parse_double("cpid_time", cpid_time)) continue;
if (xp.parse_double("user_total_credit", user_total_credit)) continue;
if (xp.parse_double("user_expavg_credit", user_expavg_credit)) continue;
if (xp.parse_double("user_create_time", user_create_time)) continue;
if (xp.parse_int("rpc_seqno", rpc_seqno)) continue;
if (xp.parse_int("userid", userid)) continue;
if (xp.parse_int("teamid", teamid)) continue;
if (xp.parse_int("hostid", hostid)) continue;
if (xp.parse_double("host_total_credit", host_total_credit)) continue;
if (xp.parse_double("host_expavg_credit", host_expavg_credit)) continue;
if (xp.parse_double("host_create_time", host_create_time)) continue;
if (xp.match_tag("code_sign_key")) {
retval = copy_element_contents(
xp.f->f,
"</code_sign_key>",
code_sign_key,
sizeof(code_sign_key)
);
if (retval) return retval;
strip_whitespace(code_sign_key);
continue;
}
if (xp.parse_int("nrpc_failures", nrpc_failures)) continue;
if (xp.parse_int("master_fetch_failures", master_fetch_failures)) continue;
if (xp.parse_double("min_rpc_time", x)) continue;
if (xp.parse_bool("master_url_fetch_pending", master_url_fetch_pending)) continue;
if (xp.parse_int("sched_rpc_pending", sched_rpc_pending)) continue;
if (xp.parse_double("next_rpc_time", next_rpc_time)) continue;
if (xp.parse_bool("trickle_up_pending", trickle_up_pending)) continue;
if (xp.parse_int("send_time_stats_log", send_time_stats_log)) continue;
if (xp.parse_int("send_job_log", send_job_log)) continue;
if (xp.parse_bool("send_full_workload", send_full_workload)) continue;
if (xp.parse_bool("dont_use_dcf", dont_use_dcf)) continue;
if (xp.parse_bool("non_cpu_intensive", non_cpu_intensive)) continue;
if (xp.parse_bool("verify_files_on_app_start", verify_files_on_app_start)) continue;
if (xp.parse_bool("suspended_via_gui", suspended_via_gui)) continue;
if (xp.parse_bool("dont_request_more_work", dont_request_more_work)) continue;
if (xp.parse_bool("detach_when_done", detach_when_done)) continue;
if (xp.parse_bool("ended", ended)) continue;
if (xp.parse_double("rec", pwf.rec)) continue;
if (xp.parse_double("rec_time", pwf.rec_time)) continue;
if (xp.parse_double("cpu_backoff_interval", rsc_pwf[0].backoff_interval)) continue;
if (xp.parse_double("cpu_backoff_time", rsc_pwf[0].backoff_time)) {
if (rsc_pwf[0].backoff_time > gstate.now + 28*SECONDS_PER_DAY) {
rsc_pwf[0].backoff_time = gstate.now + 28*SECONDS_PER_DAY;
}
continue;
}
if (xp.match_tag("rsc_backoff_interval")) {
if (parse_rsc_param(xp, "/rsc_backoff_interval", rt, x)) {
rsc_pwf[rt].backoff_interval = x;
}
continue;
}
if (xp.match_tag("rsc_backoff_time")) {
if (parse_rsc_param(xp, "/rsc_backoff_time", rt, x)) {
rsc_pwf[rt].backoff_time = x;
}
continue;
}
if (xp.parse_double("resource_share", resource_share)) continue;
// not authoritative
if (xp.parse_double("duration_correction_factor", duration_correction_factor)) continue;
if (xp.parse_bool("attached_via_acct_mgr", attached_via_acct_mgr)) continue;
if (xp.parse_bool("no_cpu_apps", btemp)) {
if (btemp) handle_no_rsc_apps(this, "CPU");
continue;
}
// deprecated
if (xp.parse_bool("no_cuda_apps", btemp)) {
if (btemp) handle_no_rsc_apps(this, GPU_TYPE_NVIDIA);
continue;
}
if (xp.parse_bool("no_ati_apps", btemp)) {
if (btemp) handle_no_rsc_apps(this, GPU_TYPE_ATI);
continue;
}
if (xp.parse_str("no_rsc_apps", buf, sizeof(buf))) {
handle_no_rsc_apps(this, buf);
continue;
}
if (xp.parse_bool("no_cpu_ams", btemp)) {
if (btemp) handle_no_rsc_ams(this, "CPU");
continue;
}
if (xp.parse_bool("no_cuda_ams", btemp)) {
if (btemp) handle_no_rsc_ams(this, GPU_TYPE_NVIDIA);
continue;
}
if (xp.parse_bool("no_ati_ams", btemp)) {
if (btemp) handle_no_rsc_ams(this, GPU_TYPE_ATI);
continue;
}
if (xp.parse_bool("no_intel_gpu_ams", btemp)) {
if (btemp) handle_no_rsc_ams(this, GPU_TYPE_INTEL);
continue;
}
if (xp.parse_str("no_rsc_ams", buf, sizeof(buf))) {
handle_no_rsc_ams(this, buf);
continue;
}
if (xp.parse_str("no_rsc_pref", buf, sizeof(buf))) {
handle_no_rsc_pref(this, buf);
continue;
}
// backwards compat - old state files had ams_resource_share = 0
if (xp.parse_double("ams_resource_share_new", ams_resource_share)) continue;
if (xp.parse_double("ams_resource_share", x)) {
if (x > 0) ams_resource_share = x;
continue;
}
if (xp.parse_bool("scheduler_rpc_in_progress", btemp)) continue;
if (xp.parse_bool("use_symlinks", use_symlinks)) continue;
if (xp.parse_bool("anonymous_platform", btemp)) continue;
if (xp.parse_string("trickle_up_url", stemp)) {
trickle_up_ops.push_back(new TRICKLE_UP_OP(stemp));
continue;
}
if (xp.parse_double("desired_disk_usage", desired_disk_usage)) continue;
if (xp.parse_int("njobs_success", njobs_success)) continue;
if (xp.parse_int("njobs_error", njobs_error)) continue;
if (xp.parse_double("elapsed_time", elapsed_time)) continue;
if (xp.parse_double("last_rpc_time", last_rpc_time)) continue;
#ifdef SIM
if (xp.match_tag("available")) {
available.parse(xp, "/available");
continue;
}
#endif
if (log_flags.unparsed_xml) {
msg_printf(0, MSG_INFO,
"[unparsed_xml] PROJECT::parse_state(): unrecognized: %s",
xp.parsed_tag
);
}
xp.skip_unexpected();
}
return ERR_XML_PARSE;
}
static int process_file_info(
XML_PARSER& xp, string& out, vector<INFILE_DESC> infiles,
SCHED_CONFIG& config_loc
) {
vector<string> urls;
bool gzip = false;
int retval, file_number = -1;
double nbytes, nbytesdef = -1, gzipped_nbytes;
string md5str, urlstr, tmpstr;
char buf[BLOB_SIZE], path[MAXPATHLEN], top_download_path[MAXPATHLEN];
char gzip_path[MAXPATHLEN];
char md5[33], url[256], gzipped_url[256], buf2[256];
out += "<file_info>\n";
while (!xp.get_tag()) {
if (xp.parse_int("number", file_number)) {
continue;
} else if (xp.parse_bool("gzip", gzip)) {
continue;
} else if (xp.parse_string("url", urlstr)) {
urls.push_back(urlstr);
continue;
} else if (xp.parse_string("md5_cksum", md5str)) {
continue;
} else if (xp.parse_double("nbytes", nbytesdef)) {
continue;
} else if (xp.parse_double("gzipped_nbytes", gzipped_nbytes)) {
continue;
} else if (xp.match_tag("/file_info")) {
if (nbytesdef != -1 || md5str != "" || urlstr != "") {
if (nbytesdef == -1 || md5str == "" || urlstr == "") {
fprintf(stderr, "All file properties must be defined "
"if at least one is defined (url, md5_cksum, nbytes)!\n"
);
return ERR_XML_PARSE;
}
if (gzip && !gzipped_nbytes) {
fprintf(stderr, "Must specify gzipped_nbytes\n");
return ERR_XML_PARSE;
}
}
if (file_number < 0) {
fprintf(stderr, "No file number found\n");
return ERR_XML_PARSE;
}
if (file_number >= (int)infiles.size()) {
fprintf(stderr,
"Too few input files given; need at least %d\n",
file_number+1
);
return ERR_XML_PARSE;
}
if (input_file_found[file_number]) {
fprintf(stderr,
"Input file %d listed twice\n", file_number
);
return ERR_XML_PARSE;
}
input_file_found[file_number] = true;
INFILE_DESC& infile = infiles[file_number];
if (nbytesdef > 0) {
// here if the file was specified in the input template;
// i.e it's already staged, possibly remotely
//
urlstr = "";
for (unsigned int i=0; i<urls.size(); i++) {
urlstr += " <url>" + urls.at(i) + string(infile.name) + "</url>\n";
if (gzip) {
urlstr += " <gzipped_url>" + urls.at(i) + string(infile.name) + ".gz</gzipped_url>\n";
}
}
sprintf(buf,
" <name>%s</name>\n"
"%s"
" <md5_cksum>%s</md5_cksum>\n"
" <nbytes>%.0f</nbytes>\n",
infile.name,
urlstr.c_str(),
md5str.c_str(),
nbytesdef
);
if (gzip) {
sprintf(buf2, " <gzipped_nbytes>%.0f</gzipped_nbytes>\n",
gzipped_nbytes
);
strcat(buf, buf2);
}
strcat(buf, "</file_info>\n");
} else if (infile.is_remote) {
sprintf(buf,
" <name>jf_%s</name>\n"
" <url>%s</url>\n"
" <md5_cksum>%s</md5_cksum>\n"
" <nbytes>%.0f</nbytes>\n"
"</file_info>\n",
infile.md5,
infile.url,
infile.md5,
infile.nbytes
);
} else {
// here if file is local; we need to find its size and MD5;
// stage the file if needed
//
dir_hier_path(
infile.name, config_loc.download_dir,
config_loc.uldl_dir_fanout, path, true
);
// if file isn't found in hierarchy,
// look for it at top level and copy
//
if (!boinc_file_exists(path)) {
sprintf(top_download_path,
"%s/%s",config_loc.download_dir, infile.name
);
boinc_copy(top_download_path, path);
}
if (!config_loc.cache_md5_info || !got_md5_info(path, md5, &nbytes)) {
retval = md5_file(path, md5, nbytes);
if (retval) {
fprintf(stderr,
"process_input_template: md5_file %s\n",
boincerror(retval)
);
return retval;
} else if (config_loc.cache_md5_info) {
write_md5_info(path, md5, nbytes);
}
}
dir_hier_url(
infile.name, config_loc.download_url,
config_loc.uldl_dir_fanout, url
);
if (gzip) {
sprintf(gzip_path, "%s.gz", path);
retval = file_size(gzip_path, gzipped_nbytes);
if (retval) {
fprintf(stderr,
"process_input_template: missing gzip file %s\n",
gzip_path
);
return ERR_FILE_MISSING;
}
sprintf(gzipped_url,
" <gzipped_url>%s.gz</gzipped_url>\n"
" <gzipped_nbytes>%.0f</gzipped_nbytes>\n",
url, gzipped_nbytes
);
} else {
strcpy(gzipped_url, "");
}
sprintf(buf,
" <name>%s</name>\n"
" <url>%s</url>\n"
"%s"
" <md5_cksum>%s</md5_cksum>\n"
" <nbytes>%.0f</nbytes>\n"
"</file_info>\n",
infile.name,
url,
gzipped_url,
md5,
nbytes
);
}
out += buf;
break;
} else {
// copy any other elements from input template to XML doc
//
retval = xp.copy_element(tmpstr);
if (retval) return retval;
out += tmpstr;
out += "\n";
}
}
return 0;
}
int ACTIVE_TASK::parse(XML_PARSER& xp) {
char result_name[256], project_master_url[256];
int n, dummy;
unsigned int i;
PROJECT* project=0;
double x;
safe_strcpy(result_name, "");
safe_strcpy(project_master_url, "");
while (!xp.get_tag()) {
if (xp.match_tag("/active_task")) {
project = gstate.lookup_project(project_master_url);
if (!project) {
msg_printf(
NULL, MSG_INTERNAL_ERROR,
"State file error: project %s not found for task\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 for task\n",
result_name
);
return ERR_NULL;
}
// various sanity checks
//
if (result->got_server_ack
|| result->ready_to_report
|| result->state() != RESULT_FILES_DOWNLOADED
) {
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;
}
}
// for 6.2/6.4 transition
//
if (checkpoint_elapsed_time == 0) {
elapsed_time = checkpoint_cpu_time;
checkpoint_elapsed_time = elapsed_time;
}
// for 6.12.25-26 transition;
// old clients write fraction_done to state file;
// new clients don't
if (fraction_done && checkpoint_elapsed_time) {
checkpoint_fraction_done = fraction_done;
checkpoint_fraction_done_elapsed_time = checkpoint_elapsed_time;
fraction_done_elapsed_time = checkpoint_elapsed_time;
} else {
fraction_done = checkpoint_fraction_done;
fraction_done_elapsed_time = checkpoint_fraction_done_elapsed_time;
}
return 0;
}
else if (xp.parse_str("result_name", result_name, sizeof(result_name))) continue;
else if (xp.parse_str("project_master_url", project_master_url, sizeof(project_master_url))) continue;
else if (xp.parse_int("slot", slot)) continue;
else if (xp.parse_int("active_task_state", dummy)) continue;
else if (xp.parse_double("checkpoint_cpu_time", checkpoint_cpu_time)) continue;
else if (xp.parse_double("checkpoint_elapsed_time", checkpoint_elapsed_time)) continue;
else if (xp.parse_double("checkpoint_fraction_done", checkpoint_fraction_done)) continue;
else if (xp.parse_double("checkpoint_fraction_done_elapsed_time", checkpoint_fraction_done_elapsed_time)) continue;
else if (xp.parse_bool("once_ran_edf", once_ran_edf)) continue;
else if (xp.parse_double("fraction_done", fraction_done)) continue;
// deprecated - for backwards compat
else if (xp.parse_int("app_version_num", n)) continue;
else if (xp.parse_double("swap_size", procinfo.swap_size)) continue;
else if (xp.parse_double("working_set_size", procinfo.working_set_size)) continue;
else if (xp.parse_double("working_set_size_smoothed", procinfo.working_set_size_smoothed)) continue;
else if (xp.parse_double("page_fault_rate", procinfo.page_fault_rate)) continue;
else if (xp.parse_double("current_cpu_time", x)) continue;
else if (xp.parse_double("bytes_sent", bytes_sent)) continue;
else if (xp.parse_double("bytes_received", bytes_received)) continue;
else {
if (log_flags.unparsed_xml) {
msg_printf(project, MSG_INFO,
"[unparsed_xml] ACTIVE_TASK::parse(): unrecognized %s\n",
xp.parsed_tag
);
}
}
}
return ERR_XML_PARSE;
}
int CONFIG::parse_options(XML_PARSER& xp) {
char tag[1024], path[256];
bool is_tag, btemp;
string s;
int n;
//clear();
// don't do this here because some options are set by cmdline args,
// which are parsed first
// but do clear these, which aren't accessable via cmdline:
//
alt_platforms.clear();
exclusive_apps.clear();
exclusive_gpu_apps.clear();
ignore_cuda_dev.clear();
ignore_ati_dev.clear();
while (!xp.get(tag, sizeof(tag), is_tag)) {
if (!is_tag) {
msg_printf(NULL, MSG_USER_ALERT,
"Unexpected text %s in %s", tag, CONFIG_FILE
);
continue;
}
if (!strcmp(tag, "/options")) {
return 0;
}
if (xp.parse_bool(tag, "abort_jobs_on_exit", abort_jobs_on_exit)) continue;
if (xp.parse_bool(tag, "allow_multiple_clients", allow_multiple_clients)) continue;
if (xp.parse_bool(tag, "allow_remote_gui_rpc", allow_remote_gui_rpc)) continue;
if (xp.parse_string(tag, "alt_platform", s)) {
alt_platforms.push_back(s);
continue;
}
if (xp.parse_string(tag, "client_download_url", client_download_url)) {
downcase_string(client_download_url);
continue;
}
if (xp.parse_string(tag, "client_version_check_url", client_version_check_url)) {
downcase_string(client_version_check_url);
continue;
}
if (xp.parse_str(tag, "data_dir", path, sizeof(path))) {
if (chdir(path)) {
perror("chdir");
exit(1);
}
continue;
}
if (xp.parse_bool(tag, "disallow_attach", disallow_attach)) continue;
if (xp.parse_bool(tag, "dont_check_file_sizes", dont_check_file_sizes)) continue;
if (xp.parse_bool(tag, "dont_contact_ref_site", dont_contact_ref_site)) continue;
if (xp.parse_string(tag, "exclusive_app", s)) {
exclusive_apps.push_back(s);
continue;
}
if (xp.parse_string(tag, "exclusive_gpu_app", s)) {
exclusive_gpu_apps.push_back(s);
continue;
}
if (xp.parse_string(tag, "force_auth", force_auth)) {
downcase_string(force_auth);
continue;
}
if (xp.parse_bool(tag, "http_1_0", http_1_0)) continue;
if (xp.parse_int(tag, "ignore_cuda_dev", n)) {
ignore_cuda_dev.push_back(n);
continue;
}
if (xp.parse_int(tag, "ignore_ati_dev", n)) {
ignore_ati_dev.push_back(n);
continue;
}
if (xp.parse_int(tag, "max_file_xfers", max_file_xfers)) continue;
if (xp.parse_int(tag, "max_file_xfers_per_project", max_file_xfers_per_project)) continue;
if (xp.parse_int(tag, "max_stderr_file_size", max_stderr_file_size)) continue;
if (xp.parse_int(tag, "max_stdout_file_size", max_stdout_file_size)) continue;
if (xp.parse_int(tag, "ncpus", ncpus)) continue;
if (xp.parse_string(tag, "network_test_url", network_test_url)) {
downcase_string(network_test_url);
continue;
}
if (xp.parse_bool(tag, "no_alt_platform", no_alt_platform)) continue;
if (xp.parse_bool(tag, "no_gpus", no_gpus)) continue;
if (xp.parse_bool(tag, "no_priority_change", no_priority_change)) continue;
if (xp.parse_bool(tag, "os_random_only", os_random_only)) continue;
#ifndef SIM
if (!strcmp(tag, "proxy_info")) {
int retval = config_proxy_info.parse_config(*xp.f);
if (retval) return retval;
continue;
}
#endif
if (xp.parse_bool(tag, "report_results_immediately", report_results_immediately)) continue;
if (xp.parse_bool(tag, "run_apps_manually", run_apps_manually)) continue;
if (xp.parse_int(tag, "save_stats_days", save_stats_days)) continue;
if (xp.parse_bool(tag, "simple_gui_only", simple_gui_only)) continue;
if (xp.parse_double(tag, "start_delay", start_delay)) continue;
if (xp.parse_bool(tag, "stderr_head", stderr_head)) continue;
if (xp.parse_bool(tag, "suppress_net_info", suppress_net_info)) continue;
if (xp.parse_bool(tag, "use_all_gpus", use_all_gpus)) continue;
if (xp.parse_bool(tag, "use_certs", use_certs)) continue;
if (xp.parse_bool(tag, "use_certs_only", use_certs_only)) continue;
if (xp.parse_bool(tag, "zero_debts", zero_debts)) continue;
if (xp.parse_bool(tag, "skip_cpu_benchmarks", btemp)) {
gstate.skip_cpu_benchmarks = btemp;
continue;
}
if (xp.parse_bool(tag, "unsigned_apps_ok", btemp)) {
gstate.unsigned_apps_ok = btemp;
continue;
}
if (xp.parse_bool(tag, "exit_after_finish", btemp)) {
gstate.exit_after_finish = btemp;
continue;
}
msg_printf(NULL, MSG_USER_ALERT, "Unrecognized tag in %s: <%s>\n",
CONFIG_FILE, tag
);
xp.skip_unexpected(tag, true, "CONFIG::parse_options");
}
return ERR_XML_PARSE;
}
