// parse a project's app_info.xml (anonymous platform) file
//
int CLIENT_STATE::parse_app_info(PROJECT* p, FILE* in) {
char buf[256], path[MAXPATHLEN];
MIOFILE mf;
mf.init_file(in);
XML_PARSER xp(&mf);
while (!xp.get_tag()) {
if (xp.match_tag("app_info")) continue;
if (xp.match_tag("/app_info")) {
notices.remove_notices(p, REMOVE_APP_INFO_MSG);
return 0;
}
if (xp.match_tag("file_info") || xp.match_tag("file")) {
FILE_INFO* fip = new FILE_INFO;
if (fip->parse(xp)) {
delete fip;
continue;
}
if (!fip->download_urls.empty() || !fip->upload_urls.empty()) {
msg_printf(p, MSG_INFO,
"Can't specify URLs in app_info.xml"
);
delete fip;
continue;
}
if (link_file_info(p, fip)) {
delete fip;
continue;
}
// check that the file is actually there
//
get_pathname(fip, path, sizeof(path));
if (!boinc_file_exists(path)) {
safe_strcpy(buf,
_("File referenced in app_info.xml does not exist: ")
);
strcat(buf, fip->name);
msg_printf(p, MSG_USER_ALERT, "%s", buf);
delete fip;
continue;
}
fip->status = FILE_PRESENT;
fip->anonymous_platform_file = true;
file_infos.push_back(fip);
continue;
}
if (xp.match_tag("app")) {
APP* app = new APP;
if (app->parse(xp)) {
delete app;
continue;
}
if (lookup_app(p, app->name)) {
delete app;
continue;
}
link_app(p, app);
apps.push_back(app);
continue;
}
if (xp.match_tag("app_version")) {
APP_VERSION* avp = new APP_VERSION;
if (avp->parse(xp)) {
delete avp;
continue;
}
if (cc_config.dont_use_vbox && strstr(avp->plan_class, "vbox")) {
msg_printf(p, MSG_INFO,
"skipping vbox app in app_info.xml; vbox disabled in cc_config.xml"
);
delete avp;
continue;
}
if (strlen(avp->platform) == 0) {
safe_strcpy(avp->platform, get_primary_platform());
}
if (link_app_version(p, avp)) {
delete avp;
continue;
}
app_versions.push_back(avp);
continue;
}
if (log_flags.unparsed_xml) {
msg_printf(p, MSG_INFO,
"Unparsed line in app_info.xml: %s",
xp.parsed_tag
);
}
}
return ERR_XML_PARSE;
}
// parse a scheduler reply.
// Some of the items go into the SCHEDULER_REPLY object.
// Others are copied straight to the PROJECT
//
int SCHEDULER_REPLY::parse(FILE* in, PROJECT* project) {
char buf[256], msg_buf[1024], pri_buf[256], attr_buf[256];
int retval;
MIOFILE mf;
XML_PARSER xp(&mf);
std::string delete_file_name;
mf.init_file(in);
bool found_start_tag = false, btemp;
double cpid_time = 0;
clear();
safe_strcpy(host_venue, project->host_venue);
// the project won't send us a venue if it's doing maintenance
// or doesn't check the DB because no work.
// Don't overwrite the host venue in that case.
sr_feeds.clear();
trickle_up_urls.clear();
if (!project->anonymous_platform) {
for (int i=0; i<MAX_RSC; i++) {
project->no_rsc_apps[i] = false;
}
}
// First line should either be tag (HTTP 1.0) or
// hex length of response (HTTP 1.1)
//
while (!xp.get_tag(attr_buf, sizeof(attr_buf))) {
if (!found_start_tag) {
if (xp.match_tag("scheduler_reply")) {
found_start_tag = true;
}
continue;
}
if (xp.match_tag("/scheduler_reply")) {
// update statistics after parsing the scheduler reply
// add new record if vector is empty or we have a new day
//
if (project->statistics.empty() || project->statistics.back().day!=dday()) {
project->trim_statistics();
DAILY_STATS nds;
project->statistics.push_back(nds);
}
DAILY_STATS& ds = project->statistics.back();
ds.day=dday();
ds.user_total_credit=project->user_total_credit;
ds.user_expavg_credit=project->user_expavg_credit;
ds.host_total_credit=project->host_total_credit;
ds.host_expavg_credit=project->host_expavg_credit;
project->write_statistics_file();
if (cpid_time) {
project->cpid_time = cpid_time;
} else {
project->cpid_time = project->user_create_time;
}
if (project->dont_use_dcf) {
project->duration_correction_factor = 1;
}
return 0;
}
else if (xp.parse_str("project_name", project->project_name, sizeof(project->project_name))) {
continue;
}
else if (xp.parse_str("master_url", master_url, sizeof(master_url))) {
continue;
}
else if (xp.parse_str("symstore", project->symstore, sizeof(project->symstore))) continue;
else if (xp.parse_str("user_name", project->user_name, sizeof(project->user_name))) continue;
else if (xp.parse_double("user_total_credit", project->user_total_credit)) continue;
else if (xp.parse_double("user_expavg_credit", project->user_expavg_credit)) continue;
else if (xp.parse_double("user_create_time", project->user_create_time)) continue;
else if (xp.parse_double("cpid_time", cpid_time)) continue;
else if (xp.parse_str("team_name", project->team_name, sizeof(project->team_name))) continue;
else if (xp.parse_int("hostid", hostid)) continue;
else if (xp.parse_double("host_total_credit", project->host_total_credit)) continue;
else if (xp.parse_double("host_expavg_credit", project->host_expavg_credit)) continue;
else if (xp.parse_str("host_venue", host_venue, sizeof(host_venue))) continue;
else if (xp.parse_double("host_create_time", project->host_create_time)) continue;
else if (xp.parse_double("request_delay", request_delay)) continue;
else if (xp.parse_double("next_rpc_delay", next_rpc_delay)) continue;
else if (xp.match_tag("global_preferences")) {
retval = dup_element_contents(
xp.f->f,
"</global_preferences>",
&global_prefs_xml
);
if (retval) {
msg_printf(project, MSG_INTERNAL_ERROR,
"Can't parse global prefs in scheduler reply: %s",
boincerror(retval)
);
return retval;
}
} else if (xp.match_tag("project_preferences")) {
retval = dup_element_contents(
xp.f->f,
"</project_preferences>",
&project_prefs_xml
);
if (retval) {
msg_printf(project, MSG_INTERNAL_ERROR,
"Can't parse project prefs in scheduler reply: %s",
boincerror(retval)
);
return retval;
}
} else if (xp.match_tag("gui_urls")) {
std::string foo;
retval = copy_element_contents(xp.f->f, "</gui_urls>", foo);
if (retval) {
msg_printf(project, MSG_INTERNAL_ERROR,
"Can't parse GUI URLs in scheduler reply: %s",
boincerror(retval)
);
return retval;
}
project->gui_urls = "<gui_urls>\n"+foo+"</gui_urls>\n";
} else if (xp.match_tag("code_sign_key")) {
retval = dup_element_contents(
xp.f->f,
"</code_sign_key>",
&code_sign_key
);
if (retval) {
msg_printf(project, MSG_INTERNAL_ERROR,
"Can't parse code sign key in scheduler reply: %s",
boincerror(retval)
);
return ERR_XML_PARSE;
}
strip_whitespace(code_sign_key);
} else if (xp.match_tag("code_sign_key_signature")) {
retval = dup_element_contents(
xp.f->f,
"</code_sign_key_signature>",
&code_sign_key_signature
);
if (retval) {
msg_printf(project, MSG_INTERNAL_ERROR,
"Can't parse code sign key signature in scheduler reply: %s",
boincerror(retval)
);
return ERR_XML_PARSE;
}
} else if (xp.match_tag("app")) {
APP app;
retval = app.parse(xp);
if (retval) {
msg_printf(project, MSG_INTERNAL_ERROR,
"Can't parse application in scheduler reply: %s",
boincerror(retval)
);
} else {
apps.push_back(app);
}
} else if (xp.match_tag("file_info")) {
FILE_INFO file_info;
retval = file_info.parse(xp);
if (retval) {
msg_printf(project, MSG_INTERNAL_ERROR,
"Can't parse file info in scheduler reply: %s",
boincerror(retval)
);
} else {
file_infos.push_back(file_info);
}
} else if (xp.match_tag("app_version")) {
APP_VERSION av;
retval = av.parse(xp);
if (retval) {
msg_printf(project, MSG_INTERNAL_ERROR,
"Can't parse application version in scheduler reply: %s",
boincerror(retval)
);
} else {
app_versions.push_back(av);
}
} else if (xp.match_tag("workunit")) {
WORKUNIT wu;
retval = wu.parse(xp);
if (retval) {
msg_printf(project, MSG_INTERNAL_ERROR,
"Can't parse workunit in scheduler reply: %s",
boincerror(retval)
);
} else {
workunits.push_back(wu);
}
} else if (xp.match_tag("result")) {
RESULT result; // make sure this is here so constructor
// gets called each time
retval = result.parse_server(xp);
if (retval) {
msg_printf(project, MSG_INTERNAL_ERROR,
"Can't parse task in scheduler reply: %s",
boincerror(retval)
);
} else {
results.push_back(result);
}
} else if (xp.match_tag("result_ack")) {
RESULT result;
retval = result.parse_name(xp, "/result_ack");
if (retval) {
msg_printf(project, MSG_INTERNAL_ERROR,
"Can't parse ack in scheduler reply: %s",
boincerror(retval)
);
} else {
result_acks.push_back(result);
}
} else if (xp.match_tag("result_abort")) {
RESULT result;
retval = result.parse_name(xp, "/result_abort");
if (retval) {
msg_printf(project, MSG_INTERNAL_ERROR,
"Can't parse result abort in scheduler reply: %s",
boincerror(retval)
);
} else {
result_abort.push_back(result);
}
} else if (xp.match_tag("result_abort_if_not_started")) {
RESULT result;
retval = result.parse_name(xp, "/result_abort_if_not_started");
if (retval) {
msg_printf(project, MSG_INTERNAL_ERROR,
"Can't parse result abort-if-not-started in scheduler reply: %s",
boincerror(retval)
);
} else {
result_abort_if_not_started.push_back(result);
}
} else if (xp.parse_string("delete_file_info", delete_file_name)) {
file_deletes.push_back(delete_file_name);
} else if (xp.parse_str("message", msg_buf, sizeof(msg_buf))) {
parse_attr(attr_buf, "priority", pri_buf, sizeof(pri_buf));
USER_MESSAGE um(msg_buf, pri_buf);
messages.push_back(um);
continue;
} else if (xp.parse_bool("message_ack", message_ack)) {
continue;
} else if (xp.parse_bool("project_is_down", project_is_down)) {
continue;
} else if (xp.parse_str("email_hash", project->email_hash, sizeof(project->email_hash))) {
continue;
} else if (xp.parse_str("cross_project_id", project->cross_project_id, sizeof(project->cross_project_id))) {
continue;
} else if (xp.parse_str("external_cpid", project->external_cpid, sizeof(project->external_cpid))) {
continue;
} else if (xp.match_tag("trickle_down")) {
retval = gstate.handle_trickle_down(project, in);
if (retval) {
msg_printf(project, MSG_INTERNAL_ERROR,
"handle_trickle_down failed: %s", boincerror(retval)
);
}
continue;
} else if (xp.parse_bool("non_cpu_intensive", project->non_cpu_intensive)) {
continue;
} else if (xp.parse_bool("ended", project->ended)) {
continue;
} else if (xp.parse_bool("no_cpu_apps", btemp)) {
if (!project->anonymous_platform) {
handle_no_rsc_apps("CPU", project, btemp);
}
continue;
// deprecated syntax
} else if (xp.parse_bool("no_cuda_apps", btemp)) {
if (!project->anonymous_platform) {
handle_no_rsc_apps(GPU_TYPE_NVIDIA, project, btemp);
}
continue;
} else if (xp.parse_bool("no_ati_apps", btemp)) {
if (!project->anonymous_platform) {
handle_no_rsc_apps(GPU_TYPE_ATI, project, btemp);
}
continue;
} else if (xp.parse_str("no_rsc_apps", buf, sizeof(buf))) {
if (!project->anonymous_platform) {
handle_no_rsc_apps(buf, project, true);
}
continue;
} else if (xp.parse_bool("verify_files_on_app_start", project->verify_files_on_app_start)) {
continue;
} else if (xp.parse_bool("send_full_workload", send_full_workload)) {
continue;
} else if (xp.parse_bool("dont_use_dcf", dont_use_dcf)) {
continue;
} else if (xp.parse_int("send_time_stats_log", send_time_stats_log)){
continue;
} else if (xp.parse_int("send_job_log", send_job_log)) {
continue;
} else if (xp.parse_int("scheduler_version", scheduler_version)) {
continue;
} else if (xp.match_tag("project_files")) {
retval = parse_project_files(xp, project_files);
#ifdef ENABLE_AUTO_UPDATE
} else if (xp.match_tag("auto_update")) {
retval = auto_update.parse(xp);
if (!retval) auto_update.present = true;
#endif
} else if (xp.match_tag("rss_feeds")) {
got_rss_feeds = true;
parse_rss_feed_descs(xp, sr_feeds);
continue;
} else if (xp.match_tag("trickle_up_urls")) {
parse_trickle_up_urls(xp, trickle_up_urls);
continue;
} else if (xp.parse_int("userid", project->userid)) {
continue;
} else if (xp.parse_int("teamid", project->teamid)) {
continue;
} else if (xp.parse_double("desired_disk_usage", project->desired_disk_usage)) {
continue;
} else {
if (log_flags.unparsed_xml) {
msg_printf(project, MSG_INFO,
"[unparsed_xml] SCHEDULER_REPLY::parse(): unrecognized %s\n",
xp.parsed_tag
);
}
}
}
if (found_start_tag) {
msg_printf(project, MSG_INTERNAL_ERROR, "No close tag in scheduler reply");
} else {
msg_printf(project, MSG_INTERNAL_ERROR, "No start tag in scheduler reply");
}
return ERR_XML_PARSE;
}
int CLIENT_STATE::parse_state_file_aux(const char* fname) {
PROJECT *project=NULL;
int retval=0;
string stemp;
FILE* f = fopen(fname, "r");
if (!f) return ERR_FOPEN;
MIOFILE mf;
XML_PARSER xp(&mf);
mf.init_file(f);
while (!xp.get_tag()) {
if (xp.match_tag("/client_state")) {
break;
}
if (xp.match_tag("client_state")) {
continue;
}
if (xp.match_tag("project")) {
PROJECT temp_project;
retval = temp_project.parse_state(xp);
if (retval) {
msg_printf(NULL, MSG_INTERNAL_ERROR, "Can't parse project in state file");
} else {
#ifdef SIM
project = new PROJECT;
*project = temp_project;
projects.push_back(project);
#else
project = lookup_project(temp_project.master_url);
if (project) {
project->copy_state_fields(temp_project);
} else {
msg_printf(&temp_project, MSG_INTERNAL_ERROR,
"Project %s is in state file but no account file found",
temp_project.get_project_name()
);
}
#endif
}
continue;
}
if (xp.match_tag("app")) {
APP* app = new APP;
retval = app->parse(xp);
if (!project) {
msg_printf(NULL, MSG_INTERNAL_ERROR,
"Application %s outside project in state file",
app->name
);
delete app;
continue;
}
if (project->anonymous_platform) {
delete app;
continue;
}
if (retval) {
msg_printf(NULL, MSG_INTERNAL_ERROR,
"Can't parse application in state file"
);
delete app;
continue;
}
retval = link_app(project, app);
if (retval) {
msg_printf(project, MSG_INTERNAL_ERROR,
"Can't handle application %s in state file",
app->name
);
delete app;
continue;
}
apps.push_back(app);
continue;
}
if (xp.match_tag("file_info") || xp.match_tag("file")) {
FILE_INFO* fip = new FILE_INFO;
retval = fip->parse(xp);
if (!project) {
msg_printf(NULL, MSG_INTERNAL_ERROR,
"File info outside project in state file"
);
delete fip;
continue;
}
if (retval) {
msg_printf(NULL, MSG_INTERNAL_ERROR,
"Can't handle file info in state file"
);
delete fip;
continue;
}
retval = link_file_info(project, fip);
if (project->anonymous_platform && retval == ERR_NOT_UNIQUE) {
delete fip;
continue;
}
if (retval) {
msg_printf(project, MSG_INTERNAL_ERROR,
"Can't handle file info %s in state file",
fip->name
);
delete fip;
continue;
}
file_infos.push_back(fip);
#ifndef SIM
// If the file had a failure before,
// don't start another file transfer
//
int failnum;
if (fip->had_failure(failnum)) {
if (fip->pers_file_xfer) {
delete fip->pers_file_xfer;
fip->pers_file_xfer = NULL;
}
}
if (fip->pers_file_xfer) {
retval = fip->pers_file_xfer->init(fip, fip->pers_file_xfer->is_upload);
if (retval) {
msg_printf(project, MSG_INTERNAL_ERROR,
"Can't initialize file transfer for %s",
fip->name
);
}
retval = pers_file_xfers->insert(fip->pers_file_xfer);
if (retval) {
msg_printf(project, MSG_INTERNAL_ERROR,
"Can't start persistent file transfer for %s",
fip->name
);
}
}
#endif
continue;
}
if (xp.match_tag("app_version")) {
APP_VERSION* avp = new APP_VERSION;
retval = avp->parse(xp);
if (!project) {
msg_printf(NULL, MSG_INTERNAL_ERROR,
"Application version outside project in state file"
);
delete avp;
continue;
}
if (project->anonymous_platform) {
delete avp;
continue;
}
if (retval) {
msg_printf(NULL, MSG_INTERNAL_ERROR,
"Can't parse application version in state file"
);
delete avp;
continue;
}
if (strlen(avp->platform) == 0) {
safe_strcpy(avp->platform, get_primary_platform());
} else {
if (!is_supported_platform(avp->platform)) {
// if it's a platform we haven't heard of,
// must be that the user tried out a 64 bit client
// and then reverted to a 32-bit client.
// Let's not throw away the app version and its WUs
//
#ifndef SIM
msg_printf(project, MSG_INTERNAL_ERROR,
"App version has unsupported platform %s; changing to %s",
avp->platform, get_primary_platform()
);
#endif
safe_strcpy(avp->platform, get_primary_platform());
}
}
if (avp->missing_coproc) {
msg_printf(project, MSG_INFO,
"Application uses missing %s GPU",
avp->missing_coproc_name
);
}
retval = link_app_version(project, avp);
if (retval) {
delete avp;
continue;
}
app_versions.push_back(avp);
continue;
}
if (xp.match_tag("workunit")) {
WORKUNIT* wup = new WORKUNIT;
retval = wup->parse(xp);
if (!project) {
msg_printf(NULL, MSG_INTERNAL_ERROR,
"Workunit outside project in state file"
);
delete wup;
continue;
}
if (retval) {
msg_printf(NULL, MSG_INTERNAL_ERROR,
"Can't parse workunit in state file"
);
delete wup;
continue;
}
retval = link_workunit(project, wup);
if (retval) {
msg_printf(project, MSG_INTERNAL_ERROR,
"Can't handle workunit in state file"
);
delete wup;
continue;
}
workunits.push_back(wup);
continue;
}
if (xp.match_tag("result")) {
RESULT* rp = new RESULT;
retval = rp->parse_state(xp);
if (!project) {
msg_printf(NULL, MSG_INTERNAL_ERROR,
"Task %s outside project in state file",
rp->name
);
delete rp;
continue;
}
if (retval) {
msg_printf(NULL, MSG_INTERNAL_ERROR,
"Can't parse task in state file"
);
delete rp;
continue;
}
retval = link_result(project, rp);
if (retval) {
msg_printf(project, MSG_INTERNAL_ERROR,
"Can't link task %s in state file",
rp->name
);
delete rp;
continue;
}
// handle transition from old clients which didn't store result.platform;
// skip for anon platform
if (!project->anonymous_platform) {
if (!strlen(rp->platform) || !is_supported_platform(rp->platform)) {
safe_strcpy(rp->platform, get_primary_platform());
rp->version_num = latest_version(rp->wup->app, rp->platform);
}
}
rp->avp = lookup_app_version(
rp->wup->app, rp->platform, rp->version_num, rp->plan_class
);
if (!rp->avp) {
msg_printf(project, MSG_INTERNAL_ERROR,
"No application found for task: %s %d %s; discarding",
rp->platform, rp->version_num, rp->plan_class
);
delete rp;
continue;
}
if (rp->avp->missing_coproc) {
msg_printf(project, MSG_INFO,
"Missing coprocessor for task %s", rp->name
);
rp->coproc_missing = true;
}
rp->wup->version_num = rp->version_num;
results.push_back(rp);
continue;
}
if (xp.match_tag("project_files")) {
if (!project) {
msg_printf(NULL, MSG_INTERNAL_ERROR,
"Project files outside project in state file"
);
xp.skip_unexpected();
continue;
}
parse_project_files(xp, project->project_files);
project->link_project_files();
continue;
}
if (xp.match_tag("host_info")) {
#ifdef SIM
retval = host_info.parse(xp, false);
coprocs = host_info.coprocs;
coprocs.bound_counts();
#else
retval = host_info.parse(xp, true);
#endif
if (retval) {
msg_printf(NULL, MSG_INTERNAL_ERROR,
"Can't parse host info in state file"
);
}
continue;
}
if (xp.match_tag("time_stats")) {
retval = time_stats.parse(xp);
if (retval) {
msg_printf(NULL, MSG_INTERNAL_ERROR,
"Can't parse time stats in state file"
);
}
continue;
}
if (xp.match_tag("net_stats")) {
retval = net_stats.parse(xp);
if (retval) {
msg_printf(NULL, MSG_INTERNAL_ERROR,
"Can't parse network stats in state file"
);
}
continue;
}
if (xp.match_tag("active_task_set")) {
retval = active_tasks.parse(xp);
if (retval) {
msg_printf(NULL, MSG_INTERNAL_ERROR,
"Can't parse active tasks in state file"
);
}
continue;
}
if (xp.parse_string("platform_name", statefile_platform_name)) {
continue;
}
if (xp.parse_string("alt_platform", stemp)) {
continue;
}
if (xp.parse_int("user_run_request", retval)) {
cpu_run_mode.set(retval, 0);
continue;
}
if (xp.parse_int("user_run_prev_request", retval)) {
cpu_run_mode.set_prev(retval);
continue;
}
if (xp.parse_int("user_gpu_request", retval)) {
gpu_run_mode.set(retval, 0);
continue;
}
if (xp.parse_int("user_gpu_prev_request", retval)) {
gpu_run_mode.set_prev(retval);
continue;
}
if (xp.parse_int("user_network_request", retval)) {
network_run_mode.set(retval, 0);
continue;
}
if (xp.parse_int("core_client_major_version", old_major_version)) {
continue;
}
if (xp.parse_int("core_client_minor_version", old_minor_version)) {
continue;
}
if (xp.parse_int("core_client_release", old_release)) {
continue;
}
if (xp.parse_str("language", language, sizeof(language))) {
continue;
}
if (xp.match_tag("proxy_info")) {
retval = gui_proxy_info.parse(xp);
if (retval) {
msg_printf(NULL, MSG_INTERNAL_ERROR,
"Can't parse proxy info in state file"
);
}
continue;
}
if (xp.parse_str("host_venue", main_host_venue, sizeof(main_host_venue))) {
continue;
}
if (xp.parse_double("new_version_check_time", new_version_check_time)) {
continue;
}
if (xp.parse_double("all_projects_list_check_time", all_projects_list_check_time)) {
continue;
}
if (xp.parse_string("newer_version", newer_version)) {
continue;
}
#ifdef ENABLE_AUTO_UPDATE
if (xp.match_tag("auto_update")) {
if (!project) {
msg_printf(NULL, MSG_INTERNAL_ERROR,
"auto update outside project in state file"
);
xp.skip_unexpected();
continue;
}
if (!auto_update.parse(xp) && !auto_update.validate_and_link(project)) {
auto_update.present = true;
}
continue;
}
#endif
if (log_flags.unparsed_xml) {
msg_printf(0, MSG_INFO,
"[unparsed_xml] state_file: unrecognized: %s",
xp.parsed_tag
);
}
xp.skip_unexpected();
}
sort_results();
fclose(f);
// if total resource share is zero, set all shares to 1
//
if (projects.size()) {
unsigned int i;
double x=0;
for (i=0; i<projects.size(); i++) {
x += projects[i]->resource_share;
}
if (!x) {
msg_printf(NULL, MSG_INFO,
"All projects have zero resource share; setting to 100"
);
for (i=0; i<projects.size(); i++) {
projects[i]->resource_share = 100;
}
}
}
return 0;
}
