356 lines
8.8 KiB
C
356 lines
8.8 KiB
C
#include "../../include/package.h"
|
|
#include "../../include/error.h"
|
|
#include "../../include/pool.h"
|
|
#include "../../include/util.h"
|
|
#include "../../include/ctx.h"
|
|
|
|
#include <spawn.h>
|
|
#include <wait.h>
|
|
#include <archive.h>
|
|
#include <archive_entry.h>
|
|
#include <errno.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/stat.h>
|
|
#include <unistd.h>
|
|
|
|
bool __lm_ctx_save_install(lm_ctx_t *ctx, lm_pkg_t *pkg, char *install_path){
|
|
if(NULL == ctx->data){
|
|
lm_error_set(LM_ERR_CtxDataNULL);
|
|
return false;
|
|
}
|
|
|
|
// no need to save empty install script :)
|
|
if(is_empty(install_path))
|
|
return true;
|
|
|
|
char script_name[strlen(pkg->data.name)+15];
|
|
char script_dir[strlen(ctx->data)+15];
|
|
|
|
sprintf(script_name, "install_%s", pkg->data.name);
|
|
join(script_dir, ctx->data, "scripts");
|
|
|
|
if(!mkdir_ifnot(script_dir)){
|
|
lm_error_set(LM_ERR_InstallDirFail);
|
|
return false;
|
|
}
|
|
|
|
char dst[sizeof(script_name)+sizeof(script_dir)+10];
|
|
join(dst, script_dir, script_name);
|
|
|
|
return copy_file(dst, install_path);
|
|
}
|
|
|
|
bool __lm_ctx_run_install(char *root, char *install_path) {
|
|
// no need to run empty install script :)
|
|
if(is_empty(install_path))
|
|
return true;
|
|
|
|
char *args[] = {"/bin/bash", install_path, NULL}, *oldpwd = NULL;
|
|
bool ret = false;
|
|
int status = 0;
|
|
pid_t pid = 0;
|
|
|
|
if((oldpwd = getcwd(NULL, 0)) == NULL){
|
|
lm_error_set(LM_ERR_InstallCwdFail);
|
|
goto end;
|
|
}
|
|
|
|
if(chdir(root) < 0){
|
|
lm_error_set(LM_ERR_InstallRootChdirFail);
|
|
goto end;
|
|
}
|
|
|
|
if (posix_spawn(&pid, "/bin/bash", NULL, NULL, args, NULL) != 0) {
|
|
lm_error_set(LM_ERR_InstallSpawnFail);
|
|
goto end;
|
|
}
|
|
|
|
waitpid(pid, &status, 0);
|
|
|
|
if(chdir(root) < 0){
|
|
lm_error_set(LM_ERR_InstallBackChdirFail);
|
|
goto end;
|
|
}
|
|
|
|
if(status != 0){
|
|
lm_error_set(LM_ERR_InstallStatusFail);
|
|
goto end;
|
|
}
|
|
|
|
ret = true;
|
|
end:
|
|
free(oldpwd);
|
|
return ret;
|
|
}
|
|
|
|
bool __lm_ctx_extract_files(lm_ctx_t *ctx, lm_pkg_t *pkg, char *files, lm_ctx_install_callback_t callback, void *data){
|
|
struct archive *reader = NULL, *writer = NULL;
|
|
struct archive_entry *entry = NULL;
|
|
int flags = 0, rc = 0;
|
|
char *oldpwd = NULL, *entry_path = NULL;
|
|
bool ret = false;
|
|
size_t total = 0, current = 0;
|
|
mode_t type = 0;
|
|
struct stat st;
|
|
|
|
if(stat(files, &st) < 0){
|
|
lm_error_set(LM_ERR_ExtractStatFail);
|
|
goto end;
|
|
}
|
|
|
|
oldpwd = getcwd(NULL, 0);
|
|
total = st.st_size;
|
|
|
|
if (NULL == oldpwd) {
|
|
lm_error_set(LM_ERR_GetCwdFail);
|
|
goto end;
|
|
}
|
|
|
|
chdir(ctx->root);
|
|
|
|
flags = ARCHIVE_EXTRACT_PERM;
|
|
flags |= ARCHIVE_EXTRACT_UNLINK;
|
|
|
|
reader = archive_read_new();
|
|
writer = archive_write_disk_new();
|
|
|
|
if (NULL == reader || NULL == writer) {
|
|
lm_error_set(LM_ERR_ArcNewFail);
|
|
goto end;
|
|
}
|
|
|
|
archive_write_disk_set_options(writer, flags);
|
|
archive_write_disk_set_standard_lookup(writer);
|
|
|
|
archive_read_support_format_tar(reader);
|
|
archive_read_support_filter_gzip(reader);
|
|
|
|
if (archive_read_open_filename(reader, files, 1024 * 10) != ARCHIVE_OK) {
|
|
lm_error_set(LM_ERR_ArcOpenFail);
|
|
goto end;
|
|
}
|
|
|
|
while ((rc = archive_read_next_header(reader, &entry)) == ARCHIVE_OK) {
|
|
entry_path = (char *)archive_entry_pathname(entry);
|
|
current += archive_entry_size(entry);
|
|
type = archive_entry_filetype(entry);
|
|
|
|
if(type == AE_IFREG && !lm_database_files_contains(ctx->db, &pkg->data, entry_path)){
|
|
pdebug(__func__, "archive file not included in the database: %s (%s)", entry_path, pkg->data.name);
|
|
continue;
|
|
}
|
|
|
|
rc = archive_write_header(writer, entry);
|
|
if (rc != ARCHIVE_OK) {
|
|
lm_error_set(LM_ERR_ArcWHeaderFail);
|
|
goto end;
|
|
}
|
|
|
|
if (!copy_blocks(writer, reader))
|
|
goto end;
|
|
|
|
rc = archive_write_finish_entry(writer);
|
|
if (rc != ARCHIVE_OK) {
|
|
lm_error_set(LM_ERR_ArcWEntryFail);
|
|
goto end;
|
|
}
|
|
|
|
if(NULL != callback)
|
|
if(!callback(ctx, pkg, entry_path, current, total, data))
|
|
goto end;
|
|
}
|
|
|
|
if (rc != ARCHIVE_EOF) {
|
|
lm_error_set(LM_ERR_ArcNextHeaderFail);
|
|
goto end;
|
|
}
|
|
|
|
ret = true;
|
|
|
|
end:
|
|
if (NULL != reader) {
|
|
archive_read_close(reader);
|
|
archive_read_free(reader);
|
|
}
|
|
|
|
if (NULL != writer) {
|
|
archive_write_close(writer);
|
|
archive_write_free(writer);
|
|
}
|
|
|
|
if (NULL != oldpwd) {
|
|
chdir(oldpwd);
|
|
free(oldpwd);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool lm_ctx_install(lm_ctx_t *ctx, lm_pkg_t *pkg, bool run_install, lm_ctx_install_callback_t callback, void *data) {
|
|
if(NULL == ctx->temp || NULL == pkg){
|
|
lm_error_set(LM_ERR_CtxTempNULL);
|
|
return false;
|
|
}
|
|
|
|
if(NULL == ctx->root){
|
|
lm_error_set(LM_ERR_CtxRootNULL);
|
|
return false;
|
|
}
|
|
|
|
if(!mkdir_ifnot(ctx->temp)){
|
|
lm_error_set(LM_ERR_CtxTempFailMkdir);
|
|
return false;
|
|
}
|
|
|
|
if(!lm_ctx_database_init(ctx))
|
|
return false; // error set by function
|
|
|
|
if(lm_ctx_database_is_installed(ctx, pkg->data.name, NULL)){
|
|
lm_error_set(LM_ERR_PkgAlreadyInstalled);
|
|
return false;
|
|
}
|
|
|
|
if(lm_package_path_is_empty(pkg)){
|
|
lm_error_set(LM_ERR_PkgPathsEmpty);
|
|
return false;
|
|
}
|
|
|
|
if(!extract_archive(ctx->temp, pkg->archive))
|
|
return false; // error set by function
|
|
|
|
size_t bufsize = strlen(ctx->temp) + 25;
|
|
char data_file[bufsize], changes_file[bufsize], hashes_file[bufsize];
|
|
char install_file[bufsize], files_archive[bufsize];
|
|
lm_pkg_t temp;
|
|
|
|
lm_package_init(&temp);
|
|
|
|
join(data_file, ctx->temp, "DATA");
|
|
join(hashes_file, ctx->temp, "HASHES");
|
|
join(changes_file, ctx->temp, "CHANGES");
|
|
join(install_file, ctx->temp, "INSTALL");
|
|
join(files_archive, ctx->temp, "files.tar.gz");
|
|
|
|
if(!exists(data_file) || !is_file(data_file) ||
|
|
!exists(hashes_file) || !is_file(hashes_file) ||
|
|
!exists(changes_file) || !is_file(changes_file) ||
|
|
!exists(install_file) || !is_file(install_file) ||
|
|
!exists(files_archive) || !is_file(files_archive)){
|
|
lm_error_set(LM_ERR_PkgBadArchive);
|
|
return false;
|
|
}
|
|
|
|
if(!lm_package_data_load(&temp.data, data_file))
|
|
return false; // error set by function
|
|
|
|
if(!lm_package_is_same(&temp, pkg)){
|
|
pdebug(__func__, "DATA file does not match with stored %s data", pkg->data.name);
|
|
lm_error_set(LM_ERR_PkgDataNotMatch);
|
|
return false;
|
|
}
|
|
|
|
if(!lm_database_changes_update(ctx->db, &pkg->data, changes_file)){
|
|
char *suberr = lm_strerror_dup();
|
|
pdebug(__func__, "failed to update changes file for %s: %s", pkg->data.name, suberr);
|
|
lm_error_set(LM_ERR_PkgChangesUpdateFail, suberr);
|
|
return false;
|
|
}
|
|
|
|
char *line = NULL, *hash = NULL, *file = NULL;
|
|
ssize_t line_len = 0, file_len = 0;
|
|
FILE *hashes = NULL;
|
|
bool ret = false;
|
|
|
|
if((hashes = fopen(hashes_file, "r")) == NULL){
|
|
pdebug(__func__, "failed to open hash file for %s", pkg->data.name);
|
|
lm_error_set(LM_ERR_PkgHashesOpenFail);
|
|
return false;
|
|
}
|
|
|
|
while((line_len = getline(&line, (size_t*)&line_len, hashes)) > 0){
|
|
if(NULL == line)
|
|
goto next;
|
|
|
|
if(HASH_LEN+2 >= line_len)
|
|
goto next;
|
|
|
|
line[HASH_LEN] = 0;
|
|
hash = line;
|
|
|
|
file = line+HASH_LEN+2;
|
|
file_len = strlen(file);
|
|
file[file_len-1] = 0;
|
|
|
|
if(file[0] == '.')
|
|
file++;
|
|
|
|
if(file_len >= 2 && file[0] == '/')
|
|
file++;
|
|
|
|
pdebug(__func__, "(%lu) %s => %s", line_len, file, hash);
|
|
|
|
if(!lm_database_files_add(ctx->db, &pkg->data, file, hash)){
|
|
char *suberr = lm_strerror_dup();
|
|
pdebug(__func__, "failed to add file to the database for %s: %s", pkg->data.name, suberr);
|
|
lm_error_set(LM_ERR_PkgFilesAddFail, file, suberr);
|
|
free(suberr);
|
|
goto end;
|
|
}
|
|
|
|
next:
|
|
free(line);
|
|
line = NULL;
|
|
line_len = 0;
|
|
}
|
|
|
|
if(!__lm_ctx_extract_files(ctx, pkg, files_archive, callback, data)){
|
|
char *suberr = lm_strerror_dup();
|
|
pdebug(__func__, "failed to extract the files archive for %s: %s", pkg->data.name, suberr);
|
|
lm_error_set(LM_ERR_PkgExtractFilesFail, suberr);
|
|
free(suberr);
|
|
goto end;
|
|
}
|
|
|
|
if(!lm_database_entry_add(ctx->db, &pkg->data)){
|
|
char *suberr = lm_strerror_dup();
|
|
pdebug(__func__, "failed to add %s to the database: %s", pkg->data.name, lm_strerror());
|
|
lm_error_set(LM_ERR_PkgDatabaseAddFail, suberr);
|
|
free(suberr);
|
|
goto end;
|
|
}
|
|
|
|
if(run_install && !__lm_ctx_run_install(ctx->root, install_file)){
|
|
char *suberr = lm_strerror_dup();
|
|
pdebug(__func__, "failed to run install script: %s", lm_strerror());
|
|
lm_error_set(LM_ERR_InstallRunFail, suberr);
|
|
free(suberr);
|
|
goto end;
|
|
}
|
|
|
|
if(!run_install && !__lm_ctx_save_install(ctx, pkg, install_file)){
|
|
char *suberr = lm_strerror_dup();
|
|
pdebug(__func__, "failed to save install script: %s", lm_strerror());
|
|
lm_error_set(LM_ERR_InstallSaveFail, suberr);
|
|
free(suberr);
|
|
goto end;
|
|
}
|
|
|
|
ret = true;
|
|
end:
|
|
free(line);
|
|
|
|
if(NULL != hashes)
|
|
fclose(hashes);
|
|
|
|
if(!ret){
|
|
lm_database_entry_del(ctx->db, &pkg->data);
|
|
lm_database_changes_del(ctx->db, &pkg->data);
|
|
lm_database_files_del(ctx->db, &pkg->data);
|
|
}
|
|
|
|
unlink(pkg->archive);
|
|
unlink(pkg->signature);
|
|
return ret;
|
|
}
|