/*
* Cancel a job -- typically called by the UA (Console program), but may also
* be called by the job watchdog.
*
* Returns: true if cancel appears to be successful
* false on failure. Message sent to ua->jcr.
*/
bool cancel_job(UAContext *ua, JCR *jcr)
{
char ed1[50];
int32_t old_status = jcr->JobStatus;
jcr->setJobStatus(JS_Canceled);
switch (old_status) {
case JS_Created:
case JS_WaitJobRes:
case JS_WaitClientRes:
case JS_WaitStoreRes:
case JS_WaitPriority:
case JS_WaitMaxJobs:
case JS_WaitStartTime:
ua->info_msg(_("JobId %s, Job %s marked to be canceled.\n"),
edit_uint64(jcr->JobId, ed1), jcr->Job);
jobq_remove(&job_queue, jcr); /* attempt to remove it from queue */
break;
default:
/*
* Cancel File daemon
*/
if (jcr->file_bsock) {
if (!cancel_file_daemon_job(ua, jcr)) {
return false;
}
}
/*
* Cancel Storage daemon
*/
if (jcr->store_bsock) {
if (!cancel_storage_daemon_job(ua, jcr)) {
return false;
}
}
break;
}
run_scripts(jcr, jcr->res.job->RunScripts, "AfterJob");
return true;
}
// Oles:
// changed to process one script per-frame
// changed log-output to stack-based buffer (avoid persistent 4K storage)
void CScriptProcess::update()
{
#ifdef DBG_DISABLE_SCRIPTS
m_scripts_to_run.clear();
return;
#endif
run_scripts ();
if (m_scripts.empty())
return;
// update script
g_ca_stdout[0] = 0;
u32 _id = (++m_iterator)%m_scripts.size();
if (!m_scripts[_id]->update()) {
xr_delete (m_scripts[_id]);
m_scripts.erase (m_scripts.begin() + _id);
--m_iterator; // try to avoid skipping
}
if (g_ca_stdout[0]) {
fputc (0,stderr);
ai().script_engine().script_log (ScriptStorage::eLuaMessageTypeInfo,"%s",g_ca_stdout);
fflush (stderr);
}
#if defined(DEBUG)
try {
#pragma todo ("Dima cant find this function 'lua_setgcthreshold' ")
lua_gc (ai().script_engine().lua(), LUA_GCSTEP, 0);
}
catch(...) {
}
#endif
}
/* Bundle install one ore more bundles passed in bundles
* param as a null terminated array of strings
*/
int install_bundles(char **bundles)
{
int lock_fd;
int ret = 0;
int current_version;
struct manifest *mom;
struct list *iter;
struct sub *sub;
struct file *file;
/* step 1: initialize swupd and get current version from OS */
if (!init_globals()) {
return EINIT_GLOBALS;
}
ret = swupd_init(&lock_fd);
if (ret != 0) {
printf("Failed updater initialization, exiting now.\n");
return ret;
}
current_version = read_version_from_subvol_file(path_prefix);
swupd_curl_set_current_version(current_version);
/* first of all, make sure STATE_DIR is there, recreate if necessary*/
ret = create_required_dirs();
if (ret != 0) {
printf("State directory %s cannot be recreated, aborting installation\n", STATE_DIR);
goto clean_and_exit;
}
ret = load_manifests(current_version, current_version, "MoM", NULL, &mom);
if (ret != 0) {
printf("Cannot load official manifest MoM for version %i\n", current_version);
ret = EMOM_NOTFOUND;
goto clean_and_exit;
}
/* step 2: check bundle args are valid if so populate subs struct */
int i;
for (i = 0; *bundles; ++bundles) {
if (is_tracked_bundle(*bundles)) {
printf("%s bundle already installed, skipping it\n", *bundles);
continue;
}
if (!manifest_has_component(mom, *bundles)) {
printf("%s bundle name is invalid, skipping it...\n", *bundles);
continue;
}
if (component_subscribed(*bundles)) {
continue;
}
create_and_append_subscription(*bundles);
i++;
printf("Added bundle %s for installation\n", *bundles);
}
if (i == 0) {
printf("There are no pending bundles to install, exiting now\n");
ret = EBUNDLE_INSTALL;
goto clean_manifest_and_exit;
}
subscription_versions_from_MoM(mom, 0);
recurse_manifest(mom, NULL);
consolidate_submanifests(mom);
/* step 3: download neccessary packs */
ret = rm_staging_dir_contents("download");
printf("Downloading required packs...\n");
ret = download_subscribed_packs(0, current_version, true);
if (ret != 0) {
printf("pack downloads failed, cannot proceed with the installation, exiting.\n");
goto clean_subs_and_exit;
}
/* step 4: Install all bundle(s) files into the fs */
printf("Installing bundle(s) files...\n");
iter = list_head(mom->files);
while (iter) {
file = iter->data;
iter = iter->next;
if (file->is_deleted || file->do_not_update || ignore(file)) {
continue;
}
ret = do_staging(file);
if (ret == 0) {
rename_staged_file_to_final(file);
}
}
sync();
/* step 5: create bundle(s) subscription entries to track them
*
* Strictly speaking each manifest has an entry to write its own bundle filename
* and thus tracking automagically, here just making sure.
*/
iter = list_head(subs);
while (iter) {
sub = iter->data;
iter = iter->next;
printf("Tracking %s bundle on the system\n", sub->component);
ret = track_bundle_in_system(sub->component);
if (ret != 0) {
printf("Cannot track %s bundle on the system\n", sub->component);
}
}
/* Run any scripts that are needed to complete update */
run_scripts();
ret = 0;
printf("Bundle(s) installation done.\n");
clean_subs_and_exit:
free_subscriptions();
clean_manifest_and_exit:
free_manifest(mom);
clean_and_exit:
swupd_curl_cleanup();
v_lockfile(lock_fd);
dump_file_descriptor_leaks();
free_globals();
return ret;
}
int install_bundles(struct list *bundles, int current_version, struct manifest *mom)
{
int ret;
struct file *file;
struct list *iter;
struct list *to_install_bundles, *to_install_files;
/* step 1: check bundle args are valid if so populate subs struct */
ret = add_subscriptions(bundles, current_version, mom);
if (ret) {
if (ret == 1) {
printf("bundle(s) already installed, exiting now\n");
}
ret = EBUNDLE_INSTALL;
goto out;
}
subscription_versions_from_MoM(mom, 0);
to_install_bundles = recurse_manifest(mom, NULL);
if (!to_install_bundles) {
printf("Error: Cannot load to install bundles\n");
ret = ERECURSE_MANIFEST;
goto out;
}
to_install_files = files_from_bundles(to_install_bundles);
to_install_files = consolidate_files(to_install_files);
/* step 2: download neccessary packs */
(void)rm_staging_dir_contents("download");
printf("Downloading packs...\n");
(void)download_subscribed_packs(true);
/* step 3: Add tracked bundles */
read_subscriptions_alt();
subscription_versions_from_MoM(mom, 0);
mom->submanifests = recurse_manifest(mom, NULL);
if (!mom->submanifests) {
printf("Error: Cannot load installed bundles\n");
ret = ERECURSE_MANIFEST;
goto out;
}
mom->files = files_from_bundles(mom->submanifests);
mom->files = consolidate_files(mom->files);
/* step 4: Install all bundle(s) files into the fs */
printf("Installing bundle(s) files...\n");
iter = list_head(to_install_files);
while (iter) {
file = iter->data;
iter = iter->next;
if (file->is_deleted || file->do_not_update || ignore(file)) {
continue;
}
ret = do_staging(file, mom);
if (ret) {
ret = verify_fix_path(file->filename, mom);
}
if (ret) {
ret = EBUNDLE_INSTALL;
goto out;
}
}
iter = list_head(to_install_files);
while (iter) {
file = iter->data;
iter = iter->next;
if (file->is_deleted || file->do_not_update || ignore(file)) {
continue;
}
/* This was staged by verify_fix_path */
if (!file->staging) {
file = search_file_in_manifest(mom, file->filename);
}
rename_staged_file_to_final(file);
}
sync();
/* step 5: Run any scripts that are needed to complete update */
run_scripts();
ret = 0;
printf("Bundle(s) installation done.\n");
out:
free_subscriptions();
return ret;
}
int main_update()
{
int current_version = -1, server_version = -1;
struct manifest *current_manifest = NULL, *server_manifest = NULL;
struct list *updates = NULL;
int ret;
int lock_fd;
int retries = 0;
int timeout = 10;
srand(time(NULL));
ret = swupd_init(&lock_fd);
if (ret != 0) {
/* being here means we already close log by a previously caught error */
printf("Updater failed to initialize, exiting now.\n");
return ret;
}
if (!check_network()) {
printf("Error: Network issue, unable to proceed with update\n");
ret = EXIT_FAILURE;
goto clean_curl;
}
printf("Update started.\n");
read_subscriptions_alt();
if (!signature_initialize(UPDATE_CA_CERTS_PATH "/" SIGNATURE_CA_CERT)) {
goto clean_curl;
}
/* Step 1: get versions */
ret = check_versions(¤t_version, &server_version, path_prefix);
if (ret < 0) {
goto clean_curl;
}
if (server_version <= current_version) {
printf("Version on server (%i) is not newer than system version (%i)\n", server_version, current_version);
ret = EXIT_SUCCESS;
goto clean_curl;
}
printf("Preparing to update from %i to %i\n", current_version, server_version);
/* Step 2: housekeeping */
if (rm_staging_dir_contents("download")) {
goto clean_curl;
}
load_current_manifests:
/* Step 3: setup manifests */
/* get the from/to MoM manifests */
printf("Querying current manifest.\n");
ret = load_manifests(current_version, current_version, "MoM", NULL, ¤t_manifest);
if (ret) {
/* TODO: possibly remove this as not getting a "from" manifest is not fatal
* - we just don't apply deltas */
if (retries < MAX_TRIES) {
increment_retries(&retries, &timeout);
printf("Retry #%d downloading from/to MoM Manifests\n", retries);
goto load_current_manifests;
}
printf("Failure retrieving manifest from server\n");
goto clean_exit;
}
/* Reset the retries and timeout for subsequent download calls */
retries = 0;
timeout = 10;
load_server_manifests:
printf("Querying server manifest.\n");
ret = load_manifests(current_version, server_version, "MoM", NULL, &server_manifest);
if (ret) {
if (retries < MAX_TRIES) {
increment_retries(&retries, &timeout);
printf("Retry #%d downloading server Manifests\n", retries);
goto load_server_manifests;
}
printf("Failure retrieving manifest from server\n");
goto clean_exit;
}
if (current_manifest == NULL || server_manifest == NULL) {
printf("Unable to load manifest after retrying (config or network problem?)\n");
goto clean_exit;
}
retries = 0;
timeout = 10;
ret = add_included_manifests(server_manifest);
if (ret) {
goto clean_exit;
}
subscription_versions_from_MoM(current_manifest, 1);
subscription_versions_from_MoM(server_manifest, 0);
link_submanifests(current_manifest, server_manifest);
/* updating subscribed manifests is done as part of recurse_manifest */
/* read the current collective of manifests that we are subscribed to */
current_manifest->submanifests = recurse_manifest(current_manifest, NULL);
if (!current_manifest->submanifests) {
printf("Cannot load current MoM sub-manifests, (%s), exiting\n", strerror(errno));
goto clean_exit;
}
/* consolidate the current collective manifests down into one in memory */
current_manifest->files = files_from_bundles(current_manifest->submanifests);
current_manifest->files = consolidate_files(current_manifest->files);
/* read the new collective of manifests that we are subscribed to */
server_manifest->submanifests = recurse_manifest(server_manifest, NULL);
if (!server_manifest->submanifests) {
printf("Error: Cannot load server MoM sub-manifests, (%s), exiting\n", strerror(errno));
goto clean_exit;
}
/* consolidate the new collective manifests down into one in memory */
server_manifest->files = files_from_bundles(server_manifest->submanifests);
server_manifest->files = consolidate_files(server_manifest->files);
/* prepare for an update process based on comparing two in memory manifests */
link_manifests(current_manifest, server_manifest);
#if 0
debug_write_manifest(current_manifest, "debug_manifest_current.txt");
debug_write_manifest(server_manifest, "debug_manifest_server.txt");
#endif
/* Step 4: check disk state before attempting update */
run_preupdate_scripts(server_manifest);
download_packs:
/* Step 5: get the packs and untar */
ret = download_subscribed_packs(false);
if (ret) {
// packs don't always exist, tolerate that but not ENONET
if (retries < MAX_TRIES) {
increment_retries(&retries, &timeout);
printf("Retry #%d downloading packs\n", retries);
goto download_packs;
}
printf("No network, or server unavailable for pack downloads\n");
goto clean_exit;
}
/* Step 6: some more housekeeping */
/* TODO: consider trying to do less sorting of manifests */
updates = create_update_list(current_manifest, server_manifest);
link_renames(updates, current_manifest); /* TODO: Have special lists for candidate and renames */
print_statistics(current_version, server_version);
/* Step 7: apply the update */
ret = update_loop(updates, server_manifest);
if (ret == 0) {
ret = update_device_latest_version(server_version);
printf("Update was applied.\n");
}
delete_motd();
/* Run any scripts that are needed to complete update */
run_scripts();
clean_exit:
list_free_list(updates);
free_manifest(current_manifest);
free_manifest(server_manifest);
clean_curl:
signature_terminate();
swupd_curl_cleanup();
free_subscriptions();
free_globals();
v_lockfile(lock_fd);
dump_file_descriptor_leaks();
if ((current_version < server_version) && (ret == 0)) {
printf("Update successful. System updated from version %d to version %d\n",
current_version, server_version);
} else if (ret == 0) {
printf("Update complete. System already up-to-date at version %d\n", current_version);
}
return ret;
}
void script_action_gamequit(struct game* g, struct server* s) {
run_scripts(ONGAMEQUIT, g, s);
}
void script_action_gamestart(struct game* g, struct server* s) {
run_scripts(ONGAMESTART, g, s);
}
void script_action_quit() {
run_scripts(ONQUIT, NULL, NULL);
}
void script_action_start() {
run_scripts(ONSTART, NULL, NULL);
}
/*
* This is the engine called by jobq.c:jobq_add() when we were pulled
* from the work queue.
* At this point, we are running in our own thread and all
* necessary resources are allocated -- see jobq.c
*/
static void *job_thread(void *arg)
{
JCR *jcr = (JCR *)arg;
pthread_detach(pthread_self());
Dsm_check(100);
Dmsg0(200, "=====Start Job=========\n");
jcr->setJobStatus(JS_Running); /* this will be set only if no error */
jcr->start_time = time(NULL); /* set the real start time */
jcr->jr.StartTime = jcr->start_time;
if (jcr->res.job->MaxStartDelay != 0 && jcr->res.job->MaxStartDelay <
(utime_t)(jcr->start_time - jcr->sched_time)) {
jcr->setJobStatus(JS_Canceled);
Jmsg(jcr, M_FATAL, 0, _("Job canceled because max start delay time exceeded.\n"));
}
if (job_check_maxrunschedtime(jcr)) {
jcr->setJobStatus(JS_Canceled);
Jmsg(jcr, M_FATAL, 0, _("Job canceled because max run sched time exceeded.\n"));
}
/* TODO : check if it is used somewhere */
if (jcr->res.job->RunScripts == NULL) {
Dmsg0(200, "Warning, job->RunScripts is empty\n");
jcr->res.job->RunScripts = New(alist(10, not_owned_by_alist));
}
if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
}
/* Run any script BeforeJob on dird */
run_scripts(jcr, jcr->res.job->RunScripts, "BeforeJob");
/*
* We re-update the job start record so that the start
* time is set after the run before job. This avoids
* that any files created by the run before job will
* be saved twice. They will be backed up in the current
* job, but not in the next one unless they are changed.
* Without this, they will be backed up in this job and
* in the next job run because in that case, their date
* is after the start of this run.
*/
jcr->start_time = time(NULL);
jcr->jr.StartTime = jcr->start_time;
if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
}
generate_plugin_event(jcr, bDirEventJobRun);
switch (jcr->getJobType()) {
case JT_BACKUP:
switch (jcr->getJobProtocol()) {
case PT_NDMP:
if (!job_canceled(jcr)) {
if (do_ndmp_backup(jcr)) {
do_autoprune(jcr);
} else {
ndmp_backup_cleanup(jcr, JS_ErrorTerminated);
}
} else {
ndmp_backup_cleanup(jcr, JS_Canceled);
}
break;
default:
if (!job_canceled(jcr)) {
if (jcr->is_JobLevel(L_VIRTUAL_FULL)) {
if (do_native_vbackup(jcr)) {
do_autoprune(jcr);
} else {
native_vbackup_cleanup(jcr, JS_ErrorTerminated);
}
} else {
if (do_native_backup(jcr)) {
do_autoprune(jcr);
} else {
native_backup_cleanup(jcr, JS_ErrorTerminated);
}
}
} else {
if (jcr->is_JobLevel(L_VIRTUAL_FULL)) {
native_vbackup_cleanup(jcr, JS_Canceled);
} else {
native_backup_cleanup(jcr, JS_Canceled);
}
}
break;
}
break;
case JT_VERIFY:
if (!job_canceled(jcr)) {
if (do_verify(jcr)) {
do_autoprune(jcr);
} else {
verify_cleanup(jcr, JS_ErrorTerminated);
}
} else {
verify_cleanup(jcr, JS_Canceled);
}
break;
case JT_RESTORE:
switch (jcr->getJobProtocol()) {
case PT_NDMP:
if (!job_canceled(jcr)) {
if (do_ndmp_restore(jcr)) {
do_autoprune(jcr);
} else {
ndmp_restore_cleanup(jcr, JS_ErrorTerminated);
}
} else {
ndmp_restore_cleanup(jcr, JS_Canceled);
}
break;
default:
if (!job_canceled(jcr)) {
if (do_native_restore(jcr)) {
do_autoprune(jcr);
} else {
native_restore_cleanup(jcr, JS_ErrorTerminated);
}
} else {
native_restore_cleanup(jcr, JS_Canceled);
}
break;
}
break;
case JT_ADMIN:
if (!job_canceled(jcr)) {
if (do_admin(jcr)) {
do_autoprune(jcr);
} else {
admin_cleanup(jcr, JS_ErrorTerminated);
}
} else {
admin_cleanup(jcr, JS_Canceled);
}
break;
case JT_COPY:
case JT_MIGRATE:
if (!job_canceled(jcr)) {
if (do_migration(jcr)) {
do_autoprune(jcr);
} else {
migration_cleanup(jcr, JS_ErrorTerminated);
}
} else {
migration_cleanup(jcr, JS_Canceled);
}
break;
default:
Pmsg1(0, _("Unimplemented job type: %d\n"), jcr->getJobType());
break;
}
run_scripts(jcr, jcr->res.job->RunScripts, "AfterJob");
/* Send off any queued messages */
if (jcr->msg_queue && jcr->msg_queue->size() > 0) {
dequeue_messages(jcr);
}
generate_plugin_event(jcr, bDirEventJobEnd);
Dmsg1(50, "======== End Job stat=%c ==========\n", jcr->JobStatus);
Dsm_check(100);
return NULL;
}
int install_bundles(struct list *bundles, int current_version, struct manifest *mom)
{
int ret;
struct file *file;
struct list *iter;
struct sub *sub;
/* step 1: check bundle args are valid if so populate subs struct */
ret = add_subscriptions(bundles, current_version, mom);
if (ret) {
if (ret == 1) {
printf("bundle(s) already installed, exiting now\n");
}
ret = EBUNDLE_INSTALL;
goto out;
}
subscription_versions_from_MoM(mom, 0);
ret = recurse_manifest(mom, NULL);
if (ret != 0) {
printf("Error: Cannot load MoM sub-manifests (ret = %d)\n", ret);
ret = ERECURSE_MANIFEST;
goto out;
}
consolidate_submanifests(mom);
/* step 2: download neccessary packs */
(void)rm_staging_dir_contents("download");
printf("Downloading required packs...\n");
ret = download_subscribed_packs(true);
if (ret != 0) {
printf("pack downloads failed, cannot proceed with the installation, exiting.\n");
goto out;
}
/* step 3: Install all bundle(s) files into the fs */
printf("Installing bundle(s) files...\n");
iter = list_head(mom->files);
while (iter) {
file = iter->data;
iter = iter->next;
if (file->is_deleted || file->do_not_update || ignore(file)) {
continue;
}
ret = do_staging(file, mom);
if (ret == 0) {
rename_staged_file_to_final(file);
}
}
sync();
/* step 4: create bundle(s) subscription entries to track them
*
* Strictly speaking each manifest has an entry to write its own bundle filename
* and thus tracking automagically, here just making sure.
*/
iter = list_head(subs);
while (iter) {
sub = iter->data;
iter = iter->next;
printf("Tracking %s bundle on the system\n", sub->component);
ret = track_bundle_in_system(sub->component);
if (ret != 0) {
printf("Cannot track %s bundle on the system\n", sub->component);
}
}
/* step 5: Run any scripts that are needed to complete update */
run_scripts();
ret = 0;
printf("Bundle(s) installation done.\n");
out:
free_subscriptions();
return ret;
}
int
main(int argc, char *argv[])
{
struct rt_i *rtip = NULL;
char db_title[TITLE_LEN+1];/* title from MGED file */
const char *tmp_str;
extern char local_u_name[65];
extern double base2local;
extern double local2base;
FILE *fPtr;
int Ch; /* Option name */
int mat_flag = 0; /* Read matrix from stdin? */
int use_of_air = 0;
int print_ident_flag = 1;
char ocastring[1024] = {0};
struct bu_list script_list; /* For -e and -f options */
struct script_rec *srp;
extern outval ValTab[];
/* from if.c, callback functions for overlap, hit, and miss shots */
int if_overlap(struct application *, struct partition *, struct region *, struct region *, struct partition *);
int if_hit(struct application *, struct partition *, struct seg *);
int if_miss(struct application *);
BU_LIST_INIT(&script_list);
bu_setprogname(argv[0]);
ocname[OVLP_RESOLVE] = "resolve";
ocname[OVLP_REBUILD_FASTGEN] = "rebuild_fastgen";
ocname[OVLP_REBUILD_ALL] = "rebuild_all";
ocname[OVLP_RETAIN] = "retain";
*ocastring = '\0';
bu_optind = 1; /* restart */
/* Handle command-line options */
while ((Ch = bu_getopt(argc, argv, OPT_STRING)) != -1) {
if (bu_optopt == '?') Ch='h';
switch (Ch) {
case 'A':
attrib_add(bu_optarg, &need_prep);
break;
case 'B':
rt_bot_minpieces = atoi(bu_optarg);
break;
case 'T':
setenv("LIBRT_BOT_MINTIE", bu_optarg, 1);
break;
case 'b':
do_backout = 1;
break;
case 'E':
if (nirt_debug & DEBUG_SCRIPTS)
show_scripts(&script_list, "before erasure");
while (BU_LIST_WHILE(srp, script_rec, &script_list)) {
BU_LIST_DEQUEUE(&(srp->l));
free_script(srp);
}
if (nirt_debug & DEBUG_SCRIPTS)
show_scripts(&script_list, "after erasure");
break;
case 'e':
enqueue_script(&script_list, READING_STRING, bu_optarg);
if (nirt_debug & DEBUG_SCRIPTS)
show_scripts(&script_list, "after enqueueing a literal");
break;
case 'f':
enqueue_script(&script_list, READING_FILE, bu_optarg);
if (nirt_debug & DEBUG_SCRIPTS)
show_scripts(&script_list, "after enqueueing a file name");
break;
case 'L':
listformats();
bu_exit(EXIT_SUCCESS, NULL);
case 'M':
mat_flag = 1;
break;
case 'O':
sscanf(bu_optarg, "%1024s", ocastring);
break;
case 's':
silent_flag = SILENT_YES; /* Positively yes */
break;
case 'v':
silent_flag = SILENT_NO; /* Positively no */
break;
case 'x':
sscanf(bu_optarg, "%x", (unsigned int *)&RTG.debug);
break;
case 'X':
sscanf(bu_optarg, "%x", (unsigned int *)&nirt_debug);
break;
case 'u':
if (sscanf(bu_optarg, "%d", &use_of_air) != 1) {
(void) fprintf(stderr,
"Illegal use-air specification: '%s'\n", bu_optarg);
return 1;
}
break;
case 'H':
if (sscanf(bu_optarg, "%d", &print_ident_flag) != 1) {
(void) fprintf(stderr,
"Illegal header output option specified: '%s'\n", bu_optarg);
return 1;
}
break;
default:
printusage();
bu_exit (Ch != 'h', NULL);
}
} /* end while getopt */
if (argc - bu_optind < 2) {
printusage();
return 1;
}
if (isatty(0)) {
if (silent_flag != SILENT_YES)
silent_flag = SILENT_NO;
} else {
/* stdin is not a TTY */
if (silent_flag != SILENT_NO)
silent_flag = SILENT_YES;
}
if (silent_flag != SILENT_YES && print_ident_flag)
(void) fputs(brlcad_ident("Natalie's Interactive Ray Tracer"), stdout);
if (use_of_air && (use_of_air != 1)) {
fprintf(stderr,
"Warning: useair=%d specified, will set to 1\n", use_of_air);
use_of_air = 1;
}
switch (*ocastring) {
case '\0':
overlap_claims = OVLP_RESOLVE;
break;
case '0':
case '1':
case '2':
case '3':
if (ocastring[1] == '\0') {
sscanf(ocastring, "%d", &overlap_claims);
} else {
fprintf(stderr,
"Illegal overlap_claims specification: '%s'\n", ocastring);
return 1;
}
break;
case 'r':
if (BU_STR_EQUAL(ocastring, "resolve"))
overlap_claims = OVLP_RESOLVE;
else if (BU_STR_EQUAL(ocastring, "rebuild_fastgen"))
overlap_claims = OVLP_REBUILD_FASTGEN;
else if (BU_STR_EQUAL(ocastring, "rebuild_all"))
overlap_claims = OVLP_REBUILD_ALL;
else if (BU_STR_EQUAL(ocastring, "retain"))
overlap_claims = OVLP_RETAIN;
else {
fprintf(stderr,
"Illegal overlap_claims specification: '%s'\n", ocastring);
return 1;
}
break;
default:
fprintf(stderr,
"Illegal overlap_claims specification: '%s'\n", ocastring);
return 1;
}
db_name = argv[bu_optind];
/* build directory for target object */
if (silent_flag != SILENT_YES) {
printf("Database file: '%s'\n", db_name);
printf("Building the directory...");
}
if ((rtip = rt_dirbuild(db_name, db_title, TITLE_LEN)) == RTI_NULL) {
fflush(stdout);
fprintf(stderr, "Could not load file %s\n", db_name);
return 1;
}
rti_tab[use_of_air] = rtip;
rti_tab[1 - use_of_air] = RTI_NULL;
rtip->useair = use_of_air;
rtip->rti_save_overlaps = (overlap_claims > 0);
++bu_optind;
do_rt_gettrees(rtip, argv + bu_optind, argc - bu_optind, &need_prep);
/* Initialize the table of resource structures */
rt_init_resource(&res_tab, 0, rtip);
/* initialization of the application structure */
RT_APPLICATION_INIT(&ap);
ap.a_hit = if_hit; /* branch to if_hit routine */
ap.a_miss = if_miss; /* branch to if_miss routine */
ap.a_overlap = if_overlap;/* branch to if_overlap routine */
ap.a_logoverlap = rt_silent_logoverlap;
ap.a_onehit = 0; /* continue through shotline after hit */
ap.a_resource = &res_tab;
ap.a_purpose = "NIRT ray";
ap.a_rt_i = rtip; /* rt_i pointer */
ap.a_zero1 = 0; /* sanity check, sayth raytrace.h */
ap.a_zero2 = 0; /* sanity check, sayth raytrace.h */
ap.a_uptr = (void *)a_tab.attrib;
/* initialize variables */
azimuth() = 0.0;
elevation() = 0.0;
direct(X) = -1.0;
direct(Y) = 0.0;
direct(Z) = 0.0;
grid(HORZ) = 0.0;
grid(VERT) = 0.0;
grid(DIST) = 0.0;
grid2targ();
set_diameter(rtip);
/* initialize the output specification */
default_ospec();
/* initialize NIRT's local units */
base2local = rtip->rti_dbip->dbi_base2local;
local2base = rtip->rti_dbip->dbi_local2base;
tmp_str = bu_units_string(local2base);
if (tmp_str) {
bu_strlcpy(local_u_name, tmp_str, sizeof(local_u_name));
} else {
bu_strlcpy(local_u_name, "Unknown units", sizeof(local_u_name));
}
if (silent_flag != SILENT_YES) {
printf("Database title: '%s'\n", db_title);
printf("Database units: '%s'\n", local_u_name);
printf("model_min = (%g, %g, %g) model_max = (%g, %g, %g)\n",
rtip->mdl_min[X] * base2local,
rtip->mdl_min[Y] * base2local,
rtip->mdl_min[Z] * base2local,
rtip->mdl_max[X] * base2local,
rtip->mdl_max[Y] * base2local,
rtip->mdl_max[Z] * base2local);
}
/* Run the run-time configuration file, if it exists */
if ((fPtr = fopenrc()) != NULL) {
interact(READING_FILE, fPtr, rtip);
fclose(fPtr);
}
/* Run all scripts specified on the command line */
run_scripts(&script_list, rtip);
/* Perform the user interface */
if (mat_flag) {
read_mat(rtip);
return 0;
} else {
interact(READING_FILE, stdin, rtip);
}
return 0;
}
/* This function does a simple verification of files listed in the
* subscribed bundle manifests. If the optional "fix" or "install" parameter
* is specified, the disk will be modified at each point during the
* sequential comparison of manifest files to disk files, where the disk is
* found to not match the manifest. This is notably different from update,
* which attempts to atomically (or nearly atomically) activate a set of
* pre-computed and validated staged changes as a group. */
int verify_main(int argc, char **argv)
{
struct manifest *official_manifest = NULL;
int ret;
int lock_fd;
struct list *subs = NULL;
copyright_header("software verify");
if (!parse_options(argc, argv)) {
return EINVALID_OPTION;
}
/* parse command line options */
assert(argc >= 0);
assert(argv != NULL);
ret = swupd_init(&lock_fd);
if (ret != 0) {
printf("Failed verify initialization, exiting now.\n");
return ret;
}
/* Gather current manifests */
if (!version) {
version = get_current_version(path_prefix);
if (version < 0) {
printf("Error: Unable to determine current OS version\n");
ret = ECURRENT_VERSION;
goto clean_and_exit;
}
}
if (version == -1) {
version = get_latest_version();
if (version < 0) {
printf("Unable to get latest version for install\n");
ret = EXIT_FAILURE;
goto clean_and_exit;
}
}
printf("Verifying version %i\n", version);
if (!check_network()) {
printf("Error: Network issue, unable to download manifest\n");
ret = ENOSWUPDSERVER;
goto clean_and_exit;
}
read_subscriptions_alt(&subs);
/*
* FIXME: We need a command line option to override this in case the
* certificate is hosed and the admin knows it and wants to recover.
*/
ret = rm_staging_dir_contents("download");
if (ret != 0) {
printf("Failed to remove prior downloads, carrying on anyway\n");
}
official_manifest = load_mom(version);
if (!official_manifest) {
/* This is hit when or if an OS version is specified for --fix which
* is not available, or if there is a server error and a manifest is
* not provided.
*/
printf("Unable to download/verify %d Manifest.MoM\n", version);
ret = EMOM_NOTFOUND;
/* No repair is possible without a manifest, nor is accurate reporting
* of the state of the system. Therefore cleanup, report failure and exit
*/
goto clean_and_exit;
}
ret = add_included_manifests(official_manifest, &subs);
if (ret) {
ret = EMANIFEST_LOAD;
goto clean_and_exit;
}
set_subscription_versions(official_manifest, NULL, &subs);
official_manifest->submanifests = recurse_manifest(official_manifest, subs, NULL);
if (!official_manifest->submanifests) {
printf("Error: Cannot load MoM sub-manifests\n");
ret = ERECURSE_MANIFEST;
goto clean_and_exit;
}
official_manifest->files = files_from_bundles(official_manifest->submanifests);
official_manifest->files = consolidate_files(official_manifest->files);
/* when fixing or installing we need input files. */
if (cmdline_option_fix || cmdline_option_install) {
ret = get_required_files(official_manifest, subs);
if (ret != 0) {
ret = -ret;
goto clean_and_exit;
}
}
/* preparation work complete. */
/*
* NOTHING ELSE IS ALLOWED TO FAIL/ABORT after this line.
* This tool is there to recover a nearly-bricked system. Aborting
* from this point forward, for any reason, will result in a bricked system.
*
* I don't care what your static analysis tools says
* I don't care what valgrind tells you
*
* There shall be no "goto fail;" from this point on.
*
* *** THE SHOW MUST GO ON ***
*/
if (cmdline_option_fix || cmdline_option_install) {
/*
* Next put the files in place that are missing completely.
* This is to avoid updating a symlink to a library before the new full file
* is already there. It's also the most safe operation, adding files rarely
* has unintended side effect. So lets do the safest thing first.
*/
printf("Adding any missing files\n");
add_missing_files(official_manifest);
}
if (cmdline_option_quick) {
/* quick only replaces missing files, so it is done here */
goto brick_the_system_and_clean_curl;
}
if (cmdline_option_fix) {
bool repair = true;
printf("Fixing modified files\n");
deal_with_hash_mismatches(official_manifest, repair);
/* removing files could be risky, so only do it if the
* prior phases had no problems */
if ((file_not_fixed_count == 0) && (file_not_replaced_count == 0)) {
remove_orphaned_files(official_manifest);
}
} else {
bool repair = false;
printf("Verifying files\n");
deal_with_hash_mismatches(official_manifest, repair);
}
free_manifest(official_manifest);
brick_the_system_and_clean_curl:
/* clean up */
/*
* naming convention: All exit goto labels must follow the "brick_the_system_and_FOO:" pattern
*/
/* report a summary of what we managed to do and not do */
printf("Inspected %i files\n", file_checked_count);
if (cmdline_option_fix || cmdline_option_install) {
printf(" %i files were missing\n", file_missing_count);
if (file_missing_count) {
printf(" %i of %i missing files were replaced\n", file_replaced_count, file_missing_count);
printf(" %i of %i missing files were not replaced\n", file_not_replaced_count, file_missing_count);
}
}
if (!cmdline_option_quick && file_mismatch_count > 0) {
printf(" %i files did not match\n", file_mismatch_count);
if (cmdline_option_fix) {
printf(" %i of %i files were fixed\n", file_fixed_count, file_mismatch_count);
printf(" %i of %i files were not fixed\n", file_not_fixed_count, file_mismatch_count);
}
}
if ((file_not_fixed_count == 0) && (file_not_replaced_count == 0) &&
cmdline_option_fix && !cmdline_option_quick) {
printf(" %i files found which should be deleted\n", file_extraneous_count);
if (file_extraneous_count) {
printf(" %i of %i files were deleted\n", file_deleted_count, file_extraneous_count);
printf(" %i of %i files were not deleted\n", file_not_deleted_count, file_extraneous_count);
}
}
if (cmdline_option_fix || cmdline_option_install) {
// always run in a fix or install case
need_update_boot = true;
need_update_bootloader = true;
run_scripts();
}
sync();
if ((file_not_fixed_count == 0) &&
(file_not_replaced_count == 0) &&
(file_not_deleted_count == 0)) {
ret = EXIT_SUCCESS;
} else {
ret = EXIT_FAILURE;
}
/* this concludes the critical section, after this point it's clean up time, the disk content is finished and final */
clean_and_exit:
telemetry(ret ? TELEMETRY_CRIT : TELEMETRY_INFO,
"verify",
"fix=%d\nret=%d\n"
"current_version=%d\n"
"file_replaced_count=%d\n"
"file_not_replaced_count=%d\n"
"file_missing_count=%d\n"
"file_fixed_count=%d\n"
"file_not_fixed_count=%d\n"
"file_deleted_count=%d\n"
"file_not_deleted_count=%d\n"
"file_mismatch_count=%d\n"
"file_extraneous_count=%d\n",
cmdline_option_fix || cmdline_option_install,
ret,
version,
file_replaced_count,
file_not_replaced_count,
file_missing_count,
file_fixed_count,
file_not_fixed_count,
file_deleted_count,
file_not_deleted_count,
file_mismatch_count,
file_extraneous_count);
if (ret == EXIT_SUCCESS) {
if (cmdline_option_fix || cmdline_option_install) {
printf("Fix successful\n");
} else {
/* This is just a verification */
printf("Verify successful\n");
}
} else {
if (cmdline_option_fix || cmdline_option_install) {
printf("Error: Fix did not fully succeed\n");
} else {
/* This is just a verification */
printf("Error: Verify did not fully succeed\n");
}
}
swupd_deinit(lock_fd, &subs);
return ret;
}
