/* bundle_name: this is the name for the bundle we want to be loaded
* version: this is the MoM version from which we pull last changed for bundle manifest
* submanifest: where bundle manifest is going to be loaded
*
* Basically we read MoM version then get the submanifest only for our bundle (component)
* put it into submanifest pointer, then dispose MoM data.
*/
static int load_bundle_manifest(const char *bundle_name, int version, struct manifest **submanifest)
{
struct list *sub_list = NULL;
struct manifest *mom = NULL;
int ret = 0;
*submanifest = NULL;
swupd_curl_set_current_version(version);
ret = load_manifests(version, version, "MoM", NULL, &mom);
if (ret != 0) {
ret = EMOM_NOTFOUND;
goto out;
}
ret = recurse_manifest(mom, bundle_name);
if (ret != 0) {
ret = ERECURSE_MANIFEST;
goto free_out;
}
sub_list = list_head(mom->submanifests);
if (sub_list != NULL) {
*submanifest = sub_list->data;
sub_list->data = NULL;
ret = 0;
}
free_out:
free_manifest(mom);
out:
return ret;
}
/*
* list_installable_bundles()
* Parse the full manifest for the current version of the OS and print
* all available bundles.
*/
int list_installable_bundles()
{
struct list *list;
struct file *file;
struct manifest *MoM = NULL;
int current_version;
int lock_fd;
int ret;
if (!init_globals()) {
return EINIT_GLOBALS;
}
current_version = read_version_from_subvol_file(path_prefix);
if (swupd_init(&lock_fd) != 0) {
printf("Error: Failed updater initialization. Exiting now\n");
return ECURL_INIT;
}
ret = create_required_dirs();
if (ret != 0) {
printf("State directory %s cannot be recreated, aborting removal\n", STATE_DIR);
v_lockfile(lock_fd);
return EXIT_FAILURE;
}
get_mounted_directories();
if (!check_network()) {
printf("Error: Network issue, unable to download manifest\n");
v_lockfile(lock_fd);
return EXIT_FAILURE;
}
swupd_curl_set_current_version(current_version);
ret = load_manifests(current_version, current_version, "MoM", NULL, &MoM);
if (ret != 0) {
v_lockfile(lock_fd);
return ret;
}
list = MoM->manifests;
while (list) {
file = list->data;
list = list->next;
printf("%s\n", file->filename);
}
free_manifest(MoM);
v_lockfile(lock_fd);
return 0;
}
/*
* list_installable_bundles()
* Parse the full manifest for the current version of the OS and print
* all available bundles.
*/
int list_installable_bundles()
{
struct list *list;
struct file *file;
struct manifest *MoM = NULL;
int current_version;
int lock_fd;
int ret;
ret = swupd_init(&lock_fd);
if (ret != 0) {
printf("Error: Failed updater initialization. Exiting now\n");
return ret;
}
if (!check_network()) {
printf("Error: Network issue, unable to download manifest\n");
v_lockfile(lock_fd);
return EXIT_FAILURE;
}
current_version = read_version_from_subvol_file(path_prefix);
swupd_curl_set_current_version(current_version);
ret = load_manifests(current_version, current_version, "MoM", NULL, &MoM);
if (ret != 0) {
v_lockfile(lock_fd);
return ret;
}
list = MoM->manifests;
while (list) {
file = list->data;
list = list->next;
printf("%s\n", file->filename);
}
free_manifest(MoM);
v_lockfile(lock_fd);
return 0;
}
/* Bundle install one ore more bundles passed in bundles
* param as a null terminated array of strings
*/
int install_bundles_frontend(char **bundles)
{
int lock_fd;
int ret = 0;
int current_version;
struct list *bundles_list = NULL;
struct manifest *mom;
/* initialize swupd and get current version from OS */
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);
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;
}
for (; *bundles; ++bundles) {
bundles_list = list_prepend_data(bundles_list, *bundles);
}
ret = install_bundles(bundles_list, current_version, mom);
list_free_list(bundles_list);
free_manifest(mom);
clean_and_exit:
swupd_curl_cleanup();
v_lockfile(lock_fd);
dump_file_descriptor_leaks();
free_globals();
return ret;
}
/* download_manifests()
* Description: To search Clear bundles for a particular entry, a complete set of
* manifests must be downloaded. This function does so, asynchronously, using
* the curl_multi interface */
int download_manifests(struct manifest **MoM)
{
struct list *list;
struct file *file;
char *tarfile, *untard_file, *url;
struct manifest *subMan = NULL;
int current_version;
int ret = 0;
double size;
current_version = read_version_from_subvol_file(path_prefix);
swupd_curl_set_current_version(current_version);
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);
return ret;
}
subscription_versions_from_MoM(*MoM, 0);
list = (*MoM)->manifests;
size = query_total_download_size(list);
if (size == -1) {
printf("Downloading manifests. Expect a delay, up to 100MB may be downloaded\n");
} else if (size > 0) {
printf("Downloading Clear Linux manifests\n");
printf(" %.2f MB total...\n\n", size);
}
while (list) {
file = list->data;
list = list->next;
create_and_append_subscription(file->filename);
string_or_die(&untard_file, "%s/%i/Manifest.%s", STATE_DIR, file->last_change,
file->filename);
string_or_die(&tarfile, "%s/%i/Manifest.%s.tar", STATE_DIR, file->last_change,
file->filename);
if (access(untard_file, F_OK) == -1) {
/* Do download */
printf(" '%s' manifest...\n", file->filename);
ret = load_manifests(current_version, file->last_change, file->filename, NULL, &subMan);
if (ret != 0) {
printf("Cannot load official manifest MoM for version %i\n", current_version);
}
free_manifest(subMan);
}
if (access(untard_file, F_OK) == -1) {
string_or_die(&url, "%s/%i/Manifest.%s.tar", preferred_content_url, current_version,
file->filename);
printf("Error: Failure reading from %s\n", url);
free(url);
}
unlink(tarfile);
free(untard_file);
free(tarfile);
}
return ret;
}
/* do_search()
* Description: Perform a lookup of the specified search string in all Clear manifests
* for the current os release.
*/
void do_search(struct manifest *MoM, char search_type, char *search_term)
{
struct list *list;
struct list *sublist;
struct file *file;
struct file *subfile;
struct manifest *subman = NULL;
int i, ret;
bool done_with_bundle, done = false;
bool hit = false;
list = MoM->manifests;
while (list && !done) {
file = list->data;
list = list->next;
done_with_bundle = false;
/* Load sub-manifest */
ret = load_manifests(file->last_change, file->last_change, file->filename, NULL, &subman);
if (ret != 0) {
printf("Failed to load manifest %s\n", file->filename);
continue;
}
if (display_files) {
/* Display bundle name. Marked up for pattern matchability */
printf("--Bundle: %s--\n", file->filename);
}
/* Loop through sub-manifest, searching for files matching the desired pattern */
sublist = subman->files;
while (sublist && !done_with_bundle) {
subfile = sublist->data;
sublist = sublist->next;
if (!subfile->is_file) {
continue;
}
if (display_files) {
/* Just display filename */
file_search(subfile->filename, NULL, NULL);
} else if (search_type == 'e') {
/* Search for exact match, not path addition */
if (file_search(subfile->filename, "", search_term)) {
report_find(file->filename, subfile->filename);
hit = true;
if (!display_all) {
done = true;
}
done_with_bundle = true;
break;
}
} else if (search_type == 'l') {
/* Check each supported library path for a match */
for (i = 0; lib_paths[i] != NULL; i++) {
if (file_search(subfile->filename, lib_paths[i], search_term)) {
report_find(file->filename, subfile->filename);
hit = true;
if (!display_all) {
done = true;
}
done_with_bundle = true;
break;
}
}
} else if (search_type == 'b') {
/* Check each supported path for binaries */
for (i = 0; bin_paths[i] != NULL; i++) {
if (file_search(subfile->filename, bin_paths[i], search_term)) {
report_find(file->filename, subfile->filename);
hit = true;
if (!display_all) {
done = true;
}
done_with_bundle = true;
break;
}
}
} else {
printf("Unrecognized search type. -b or -l supported\n");
done = true;
break;
}
}
free_manifest(subman);
}
if (!hit) {
printf("Search term not found.\n");
}
}
/* 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;
}
/* This function is a fresh new implementation for a bundle
* remove without being tied to verify loop, this means
* improved speed and space as well as more roubustness and
* flexibility. What it does is basically:
*
* 1) Read MoM and load all submanifests except the one to be
* removed and then consolidate them.
* 2) Load the removed bundle submanifest.
* 3) Order the file list by filename
* 4) Deduplicate removed submanifest file list that happens
* to be on the MoM (minus bundle to be removed).
* 5) iterate over to be removed bundle submanifest file list
* performing a unlink(2) for each filename.
* 6) Done.
*/
int remove_bundle(const char *bundle_name)
{
int lock_fd;
int ret = 0;
int current_version = CURRENT_OS_VERSION;
struct manifest *current_mom, *bundle_manifest;
/* Initially we don't support format nor path_prefix
* for bundle_rm but eventually that will be added, then
* set_format_string() and init_globals() must be pulled out
* to the caller to properly initialize in case those opts
* passed to the command.
*/
set_format_string(NULL);
if (!init_globals()) {
return EINIT_GLOBALS;
}
ret = swupd_init(&lock_fd);
if (ret != 0) {
printf("Failed updater initialization, exiting now.\n");
return ret;
}
/* os-core bundle not allowed to be removed...
* although this is going to be caught later because of all files
* being marked as 'duplicated' and note removing anything
* anyways, better catch here and return success, no extra work to be done.
*/
if (strcmp(bundle_name, "os-core") == 0) {
ret = EBUNDLE_NOT_TRACKED;
goto out_free_curl;
}
if (!is_tracked_bundle(bundle_name)) {
ret = EBUNDLE_NOT_TRACKED;
goto out_free_curl;
}
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 removal\n", STATE_DIR);
goto out_free_curl;
}
ret = load_manifests(current_version, current_version, "MoM", NULL, ¤t_mom);
if (ret != 0) {
goto out_free_curl;
}
/* load all tracked bundles into memory */
read_subscriptions_alt();
/* now popout the one to be removed */
ret = unload_tracked_bundle(bundle_name);
if (ret != 0) {
goto out_free_mom;
}
subscription_versions_from_MoM(current_mom, 0);
/* load all submanifest minus the one to be removed */
recurse_manifest(current_mom, NULL);
consolidate_submanifests(current_mom);
/* Now that we have the consolidated list of all files, load bundle to be removed submanifest*/
ret = load_bundle_manifest(bundle_name, current_version, &bundle_manifest);
if (ret != 0) {
goto out_free_mom;
}
/* deduplication needs file list sorted by filename, do so */
bundle_manifest->files = list_sort(bundle_manifest->files, file_sort_filename);
deduplicate_files_from_manifest(&bundle_manifest, current_mom);
printf("Deleting bundle files...\n");
remove_files_in_manifest_from_fs(bundle_manifest);
printf("Untracking bundle from system...\n");
rm_bundle_file(bundle_name);
printf("Success: Bundle removed\n");
free_manifest(bundle_manifest);
out_free_mom:
free_manifest(current_mom);
out_free_curl:
if (ret) {
printf("Error: Bundle remove failed\n");
}
swupd_curl_cleanup();
v_lockfile(lock_fd);
dump_file_descriptor_leaks();
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;
}
/* tristate return, -1 for errors, 1 for no errors but no new subscriptions, 0 for no errors and new subscriptions */
int add_subscriptions(struct list *bundles, int current_version, struct manifest *mom)
{
bool new_bundles = false;
char *bundle;
int ret;
int retries = 0;
int timeout = 10;
struct file *file;
struct list *iter;
struct manifest *manifest;
srand(time(NULL));
iter = list_head(bundles);
while (iter) {
bundle = iter->data;
iter = iter->next;
file = search_bundle_in_manifest(mom, bundle);
if (!file) {
printf("%s bundle name is invalid, skipping it...\n", bundle);
continue;
}
retry_manifest_download:
ret = load_manifests(current_version, file->last_change, bundle, file, &manifest);
if (ret) {
if (retries < MAX_TRIES) {
increment_retries(&retries, &timeout);
goto retry_manifest_download;
}
printf("Unable to download manifest %s version %d, exiting now\n", bundle, file->last_change);
ret = -1;
goto out;
}
if (!manifest) {
printf("Unable to load manifest %s version %d, exiting now\n", bundle, file->last_change);
ret = -1;
goto out;
}
if (manifest->includes) {
ret = add_subscriptions(manifest->includes, current_version, mom);
if (ret == -1) {
free_manifest(manifest);
goto out;
} else if (ret == 0) {
new_bundles = true;
}
}
free(manifest);
if (is_tracked_bundle(bundle)) {
continue;
}
if (component_subscribed(bundle)) {
continue;
}
create_and_append_subscription(bundle);
new_bundles = true;
}
if (new_bundles) {
ret = 0;
} else {
ret = 1;
}
out:
return ret;
}
/* This function is a fresh new implementation for a bundle
* remove without being tied to verify loop, this means
* improved speed and space as well as more roubustness and
* flexibility. What it does is basically:
*
* 1) Read MoM and load all submanifests except the one to be
* removed and then consolidate them.
* 2) Load the removed bundle submanifest.
* 3) Order the file list by filename
* 4) Deduplicate removed submanifest file list that happens
* to be on the MoM (minus bundle to be removed).
* 5) iterate over to be removed bundle submanifest file list
* performing a unlink(2) for each filename.
* 6) Done.
*/
int remove_bundle(const char *bundle_name)
{
int lock_fd;
int ret = 0;
int current_version = CURRENT_OS_VERSION;
struct manifest *current_mom, *bundle_manifest;
ret = swupd_init(&lock_fd);
if (ret != 0) {
printf("Failed updater initialization, exiting now.\n");
return ret;
}
/* os-core bundle not allowed to be removed...
* although this is going to be caught later because of all files
* being marked as 'duplicated' and note removing anything
* anyways, better catch here and return success, no extra work to be done.
*/
if (strcmp(bundle_name, "os-core") == 0) {
ret = EBUNDLE_NOT_TRACKED;
goto out_free_curl;
}
if (!is_tracked_bundle(bundle_name)) {
ret = EBUNDLE_NOT_TRACKED;
goto out_free_curl;
}
current_version = read_version_from_subvol_file(path_prefix);
swupd_curl_set_current_version(current_version);
ret = load_manifests(current_version, current_version, "MoM", NULL, ¤t_mom);
if (ret != 0) {
goto out_free_curl;
}
if (!search_bundle_in_manifest(current_mom, bundle_name)) {
printf("Bundle name is invalid, aborting removal\n");
ret = EBUNDLE_REMOVE;
goto out_free_mom;
}
/* load all tracked bundles into memory */
read_subscriptions_alt();
/* now popout the one to be removed */
ret = unload_tracked_bundle(bundle_name);
if (ret != 0) {
goto out_free_mom;
}
subscription_versions_from_MoM(current_mom, 0);
/* load all submanifest minus the one to be removed */
ret = recurse_manifest(current_mom, NULL);
if (ret != 0) {
printf("Error: Cannot load MoM sub-manifests (ret = %d)\n", ret);
ret = ERECURSE_MANIFEST;
goto out_free_mom;
}
consolidate_submanifests(current_mom);
/* Now that we have the consolidated list of all files, load bundle to be removed submanifest*/
ret = load_bundle_manifest(bundle_name, current_version, &bundle_manifest);
if (ret != 0) {
printf("Error: Cannot load %s sub-manifest (ret = %d)\n", bundle_name, ret);
goto out_free_mom;
}
/* deduplication needs file list sorted by filename, do so */
bundle_manifest->files = list_sort(bundle_manifest->files, file_sort_filename);
deduplicate_files_from_manifest(&bundle_manifest, current_mom);
printf("Deleting bundle files...\n");
remove_files_in_manifest_from_fs(bundle_manifest);
printf("Untracking bundle from system...\n");
rm_bundle_file(bundle_name);
printf("Success: Bundle removed\n");
free_manifest(bundle_manifest);
out_free_mom:
free_manifest(current_mom);
out_free_curl:
if (ret) {
printf("Error: Bundle remove failed\n");
}
swupd_curl_cleanup();
v_lockfile(lock_fd);
dump_file_descriptor_leaks();
return ret;
}
