libglacier/libglacier.c

/*
 * 	libglacier.c - Backend C library for Glacier
 *
 * 	This file is part of Glacier.
 *
 * 	Glacier is free software: you can redistribute it and/or modify it under the terms of the
 * 	GNU General Public License as published by the Free Software Foundation, either
 * 	version 3 of the License, or (at your option) any later version.
 *
 * 	Glacier is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * 	without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 * 	PARTICULAR PURPOSE. See the GNU General Public License for more details.
 *
 * 	You should have received a copy of the GNU General Public License along with Glacier. If
 * 	not, see <https://www.gnu.org/licenses/>.
 */

#include <color.h>
#include <dirent.h>
#include <errno.h>
#include <libconfig.h>
#include <locale.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <wchar.h>

/* Global variables */

config_t cfg;
config_setting_t *setting;
const char str;

int GLACIER_ALLOW_SERVICES;
char GLACIER_ALLOWED_LICENSES;
int GLACIER_DO_INT_CHECK;
int GLACIER_VERBOSE;

const char *GLACIER_REPO;
const char *GLACIER_ARCH;
const char *GLACIER_TARGET;
const char *GLACIER_SYSTEM_PROFILE;

const char *runtime_files[] = { 
	"/etc/glacier.cfg",
	"/etc/glacier/call-hooks",
	"/etc/make.conf"
	};

/*
 * infolog
 *
 * DESCRIPTION: Output a stylized info message.
 * PARAMETERS: char MSG[]
 * DEFINED IN: glacier_log.h
 *
 */

void
infolog(char MSG[])
{
	if (MSG == NULL) {
		return;
	}

	printf(COL_BLUE "[i]" COL_RESET " %s\n", MSG);
	return;
}

/*
 * warnlog
 *
 * DESCRIPTION: Output a stylized warning message.
 * Parameters: char MSG[]
 * DEFINED IN: glacier_log.h
 *
 */

void
warnlog(char MSG[])
{
	if (MSG == NULL) {
		return;
	}

	printf(COL_YELLOW "[!]" COL_RESET " %s\n", MSG);
	return;
}

/*
 * errlog
 * 
 * DESCRIPTION: Output a stylized error message.
 * PARAMETERS: char MSG[]
 * DEFINED IN: glacier_log.h
 *
 */

void
errlog(char MSG[])
{
	if (MSG == NULL) {
		return;
	}

	fprintf(stderr, COL_RED "[x]" COL_RESET " %s\n", MSG);
	return;
}

/*
 * successlog
 * 
 * DESCRIPTION: Output a stylized success message.
 * PARAMETERS: char MSG[]
 * DEFINED IN: glacier_log.h
 *
 */

void
successlog(char MSG[])
{
	const wchar_t w_check = 0x2713;
	setlocale(LC_CTYPE, "");

	if (MSG == NULL) {
		return;
	}

	printf(COL_GREEN "[%lc]" COL_RESET " %s\n", w_check, MSG);
	return;
}

/*
 * runtime_exists
 *
 * DESCRIPTION: Check if necesary runtime files exist.
 * PARAMETERS: None.
 * DEFINED IN: glacier_runtime.h
 *
 */

int
runtime_exists()
{
	int f;

	for (f = 0; f < 3; f++) {
		if (access(runtime_files[f], F_OK) == 0) {
			printf("%s exists\n", runtime_files[f]);
		} else {
			printf("%s does not exist\n", runtime_files[f]);
		}
	}
	return 1;
}

/*
 * is_process_root
 *
 * DESCRIPTION: Check if process is running as root.
 * PARAMETERS: None.
 * DEFINED IN: glacier_runtime.h
 *
 */

int
is_process_root()
{
	if (getuid() != 0) {
		errlog("Failed to open package index: permission denied. Are you root?");
		exit(1);
	}
}

/*
 * init_config
 *
 * DESCRIPTION: Initialize libconfig.
 * PARAMETERS: None.
 * DEFINED IN: glacier_config.h
 *
 */

int
init_config()
{
	config_init(&cfg);

	if (! config_read_file(&cfg, runtime_files[0])) {
		fprintf(stderr, "%s:%d - %s\n", config_error_file(&cfg),
			config_error_line(&cfg), config_error_text(&cfg));
		config_destroy(&cfg);
		return(EXIT_FAILURE);
	}

	infolog("Initialized libconfig");
	return 0;
}

/*
 * die_config
 *
 * DESCRIPTION: Kill libconfig.
 * PARAMETERS: None.
 * DEFINED IN: glacier_config.h
 *
 */

int
die_config()
{
	config_destroy(&cfg);
	infolog("Destroyed libconfig");
	return(EXIT_SUCCESS);
}

/*
 * load_all_from_config
 *
 * DESCRIPTION: Loads all settings from the Glacier config file.
 * PARAMETERS: None.
 * DEFINED IN: glacier_config.h
 *
 */

int
load_all_from_config()
{
	config_lookup_bool(&cfg, "GLACIER_DO_INT_CHECK", &GLACIER_DO_INT_CHECK);
	config_lookup_bool(&cfg, "GLACIER_VERBOSE", &GLACIER_VERBOSE);
	
	config_lookup_string(&cfg, "GLACIER_REPO", 	     &GLACIER_REPO);
	config_lookup_string(&cfg, "GLACIER_ARCH",           &GLACIER_ARCH);
	config_lookup_string(&cfg, "GLACIER_TARGET", 	     &GLACIER_TARGET);
	config_lookup_string(&cfg, "GLACIER_SYSTEM_PROFILE", &GLACIER_SYSTEM_PROFILE);
}

/* issues with this idk
int
load_all_from_config()
{
	if(config_lookup_bool(&cfg, "GLACIER_ALLOW_SERVICES", &GLACIER_ALLOW_SERVICES))
		printf("Services allowed: %s\n", GLACIER_ALLOW_SERVICES ? "true" : "false");
	else
		warnlog("GLACIER_SERVICES_ALLOWED is not defined in glacier.cfg.");

	if(config_lookup_bool(&cfg, "GLACIER_DO_INT_CHECK", &GLACIER_DO_INT_CHECK))
		printf("Integrity checking enabled: %s\n", GLACIER_DO_INT_CHECK ? "true" : "false");
	else
		warnlog("GLACIER_DO_INT_CHECK is not defined in glacier.cfg.");

	if(config_lookup_bool(&cfg, "GLACIER_VERBOSE", &GLACIER_VERBOSE))
		printf("Verbose logging: %s\n", GLACIER_VERBOSE ? "true" : "false");
	else
		warnlog("GLACIER_VERBOSE is not defined in glacier.cfg.");
}
*/

/*
 * load_setting_from_config
 *
 * DESCRIPTION: Load a specified setting from the Glacier config file.
 * PARAMETERS: char SETTING[]
 * DEFINED IN: glacier_config.h
 *
 */

/* int
load_setting_from_config(char SETTING[])
{} */

/*
 * mkworkspace
 *
 * DESCRIPTION: Creates a new Glacier workspace in /tmp.
 * PARAMETERS: None.
 * DEFINED IN: glacier_pkgops.h
 *
 */

int
mkworkspace()
{
	DIR* workspace = opendir("/tmp/glacier-workspace");
	if (workspace) {
		infolog("Not creating new workspace, valid workspace already exists.");
	} else if (ENOENT == errno) {
		infolog("Creating new Glacier workspace...");
		mkdir("/tmp/glacier-workspace", 0777);
	} else {
		printf("LIBRARY ERROR: opendir() failed\n");
		return 2;
	}
}

/*
 * prepare_pkg
 *
 * DESCRIPTION: Copies a package archive from the localdb to the workspace, and unpacks it.
 * PARAMETERS: char PACKAGE[]
 * DEFINED IN: glacier_pkgops.h
 *
 */


int
prepare_pkg(char PACKAGE[])
{
	if (PACKAGE == NULL) {
		printf(COL_RED "[x] " COL_RESET "Package '%s' does not exist in the local database.\n", PACKAGE);
		errlog("Ensure your local database is up to date and try again.");
		errlog("This can be done by running 'glacier-update-pkgdb' as root.");
		return 1;
	} else {
		char PKG_NEW[512];
		strcat(PKG_NEW, "/tmp/glacier-workspace/");
		strcat(PKG_NEW, PACKAGE);
		strcat(PKG_NEW, ".tar");
		FILE *pkg_old, *pkg_new;
		char filename[100], contents;

		pkg_old = fopen(PACKAGE, "r");
		pkg_new = fopen(PKG_NEW, "a+");

		contents = fgetc(pkg_old);

		while (contents != EOF) {
			fputc(contents, pkg_new);
			contents = fgetc(pkg_old);
		}

		fclose(pkg_old);
		fclose(pkg_new);
		char *tar_args[] = {
			"/bin/tar", /* This should be changed to /glacier/bin/tar later on */
			"-xvf",
			PKG_NEW,
			NULL,
		};

		execvp(
			"/bin/tar", /* Above comment applies here */
			tar_args
		);
		if (errno != 0) {
			printf(COL_RED "[x] " COL_RESET "Error while unpacking archive for package %s.\n", PACKAGE);
			return errno;
		}
		remove(PKG_NEW);
		char pkg_dir[512];
		strcat(pkg_dir, "/tmp/glacier-workspace/");
		strcat(pkg_dir, PACKAGE);
		chdir(pkg_dir);
	}
}

/* download_package_sources() is deprecated and will be removed in a later release. */

/* int
download_package_sources(char PACKAGE[])
{
	printf(COL_BLUE "[i] " COL_RESET "Downloading package archive for %s...\n", PACKAGE);
	if (GLACIER_SYSTEM_PROFILE == "x86-musl") {
		execl("/glacier/tools/wget", "https://git.everestlinux.org/EverestLinux/epkgs-x86-musl/", NULL);
	} else {
		printf(COL_RED "[x] " COL_RESET "System profile '%s' is not supported.\n", GLACIER_SYSTEM_PROFILE);
	}
} */

void
TEST_chdir(char dir[])
{
	char *buf;
	chdir(dir);
	buf = (char *) malloc(100*sizeof(char));
	getcwd(buf, 100);
	printf("%s\n", buf);
}

/*
 * run_make_task
 *
 * DESCRIPTION: Runs a make task in current working directory 
 * PARAMETERS: char TASK[]
 * DEFINED IN: glacier_pkgops.h
 *
 */

int
run_make_task(char TASK[])
{
	char *build_args[] = {
		"/bin/make", /* This should be changed to /glacier/bin/make later on */
		TASK,
		NULL
	};

	execvp(
		"/bin/make", /* Above comment applies here */
		build_args
	);
	if (errno != 0) {
		errlog("An error occurred while running the make task.");
		return errno;
	}
}