char *select_image(char *image)
/* Look image up on the filesystem, if it is a file then we're done, but
* if its a directory then we want the newest file in that directory. If
* it doesn't exist at all, then see if it is 'number:number' and get the
* image from that absolute offset off the disk.
*/
{
ino_t image_ino;
struct stat st;
image= strcpy(malloc((strlen(image) + 1 + NAME_MAX + 1)
* sizeof(char)), image);
fsok= r_super(&block_size) != 0;
if (!fsok || (image_ino= r_lookup(ROOT_INO, image)) == 0) {
char *size;
if (numprefix(image, &size) && *size++ == ':'
&& numeric(size)) {
vir2sec= flat_vir2sec;
image_off= a2l(image);
image_sectors= a2l(size);
strcpy(image, "Minix");
return image;
}
if (!fsok)
printf("No image selected\n");
else
printf("Can't load %s: %s\n", image, unix_err(errno));
goto bail_out;
}
r_stat(image_ino, &st);
image_bytes = st.st_size;
if (!S_ISREG(st.st_mode)) {
char *version= image + strlen(image);
char dots[NAME_MAX + 1];
if (!S_ISDIR(st.st_mode)) {
printf("%s: %s\n", image, unix_err(ENOTDIR));
goto bail_out;
}
(void) r_readdir(dots);
(void) r_readdir(dots); /* "." & ".." */
*version++= '/';
*version= 0;
if ((image_ino= latest_version(version, &st)) == 0) {
printf("There are no images in %s\n", image);
goto bail_out;
}
r_stat(image_ino, &st);
}
vir2sec= file_vir2sec;
image_sectors= (st.st_size + SECTOR_SIZE - 1) >> SECTOR_SHIFT;
return image;
bail_out:
free(image);
return nil;
}
ino_t latest_version(char *version, struct stat *stp)
/* Recursively read the current directory, selecting the newest image on
* the way up. (One can't use r_stat while reading a directory.)
*/
{
char name[NAME_MAX + 1];
ino_t ino, newest;
time_t mtime;
if ((ino= r_readdir(name)) == 0) {
stp->st_mtime= 0;
return 0;
}
newest= latest_version(version, stp);
mtime= stp->st_mtime;
r_stat(ino, stp);
if (S_ISREG(stp->st_mode) && stp->st_mtime > mtime) {
newest= ino;
strcpy(version, name);
} else {
stp->st_mtime= mtime;
}
return newest;
}
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;
}