libglacier/src/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 <openssl/evp.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>

#include "config.h"

#define BUFFER_SIZE 1024
#define MAX_CHILDREN 64
#define MAX_SIZE 256

typedef unsigned int uint;
typedef unsigned char uchar;

/*
 * Global Variables
 * 
 * Descriptions are given as comments after the variable declaration.
 * DEFINED IN: globals.h
 *
 */

config_t cfg; /* Context for libconfig */
config_setting_t *setting; /* Pointer for setting */
const char str; /* Unsure what this does, will possibly remove later */ 

int GLACIER_ALLOW_SERVICES; /* Declaration of GLACIER_ALLOW_SERVICES as given in glacier.cfg */
char GLACIER_ALLOWED_LICENSES; /* Declaration of GLACIER_ALLOWED_LICENSES as given in glacier.cfg */
int GLACIER_DO_INT_CHECK; /* Declaration of GLACIER_DO_INT_CHECK as given in glacier.cfg */
int GLACIER_VERBOSE; /* Declaration of GLACIER_VERBOSE as given in glacier.cfg */

const char *GLACIER_REPO; /* Declaration of GLACIER_REPO as defined in profile.cfg */
const char *GLACIER_ARCH; /* Declaration of GLACIER_ARCH as defined in profile.cfg */
const char *GLACIER_TARGET; /* Declaration of GLACIER_TARGET as defined in profile.cfg */
const char *GLACIER_LOCALDB; /* Declaration of GLACIER_LOCALDB as defined in profile.cfg */
const char *GLACIER_SYSTEM_PROFILE; /* Declaration of GLACIER_SYSTEM_PROFILE as defined in profile.cfg */

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

FILE *expected_hash; /* File pointer for expected hash */
FILE *pkg; /* File pointer for package hash */

/*
 * END GLOBAL VARIABLES
 */

/*
 * node
 *
 * DESCRIPTION: Definition of node type.
 * DEFINED IN: data.h
 *
 */

struct node {
	char *data;
	struct node *children[MAX_CHILDREN];
	int numChildren;
};

/*
 * infolog
 *
 * DESCRIPTION: Output a stylized info message.
 * PARAMETERS: char MSG[]
 * DEFINED IN: 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: 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: 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: log.h
 *
 */

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

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

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

int
runtime_exists(void)
{
	int f;

	for (f = 0; f < sizeof(runtime_files); f++) {
		if (access(runtime_files[f], F_OK) == 0) {
			continue;
		} else {
			/* might keep this message, might not, idk */
			/* errlog("Runtime files are missing, cannot continue with operation.");
			printf(COL_RED "[x]" COL_RESET " The following files are missing:\n");
			printf(COL_RED "[x]" COL_RESET " \t%s\n", runtime_files[f]); */
			return 0;
		}
	}
	return 1;
}

/*
 * is_process_root
 *
 * DESCRIPTION: Check if process is running as root.
 * PARAMETERS: char MSG[]
 * DEFINED IN: runtime.h
 *
 */

int
is_process_root(void)
{
	if (getuid() != 0) {
		return 0; /* process is not running as root */
	}
	else {
		return 1; /* process is running as root */
	}
}

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

int
init_config(void)
{
	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);
	}

	if (LG_VERBOSE == 1) {
		infolog("Initialized libconfig");
	}

	return 0;
}

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

int
die_config(void)
{
	config_destroy(&cfg);

	if (LG_VERBOSE == 1) {
		infolog("Destroyed libconfig");
	}

	return(EXIT_SUCCESS);
}

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

int
load_all_from_config(void)
{
	/* this is probably really ugly but it works */
	if (! config_lookup_bool(&cfg, "GLACIER_DO_INT_CHECK", &GLACIER_DO_INT_CHECK)) { return 1; }
	if (! config_lookup_bool(&cfg, "GLACIER_VERBOSE",      &GLACIER_VERBOSE)) { return 1; }
	
	return 0;
}

/*
 * load_all_from_profile
 *
 * DESCRIPTION: Loads all settings from the Glacier system profile.
 * PARAMETERS: None.
 * DEFINED IN: config.h
 *
 */

int
load_all_from_profile(void)
{
	if (! config_lookup_string(&cfg, "GLACIER_REPO", 	     &GLACIER_REPO)) { return 1; }
	if (! config_lookup_string(&cfg, "GLACIER_ARCH",             &GLACIER_ARCH)) { return 1; }
	if (! config_lookup_string(&cfg, "GLACIER_TARGET", 	     &GLACIER_TARGET)) { return 1; }
	if (! config_lookup_string(&cfg, "GLACIER_SYSTEM_PROFILE",   &GLACIER_SYSTEM_PROFILE)) { return 1; }

	return 0;
}

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

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

/*
* create_node
*
* DESCRIPTION: Create a dependency tree node.
* PARAMETERS: char *data
* DEFINED IN: data.h
*
*/

struct node
*create_node(char *data)
{
	struct node *newNode = (struct node*)malloc(sizeof(struct node));
	newNode->data 	     = strdup(data);
	newNode->numChildren = 0;
	return newNode;
}

/*
 * add_child
 *
 * DESCRIPTION: Add a child node to a parent node.
 * PARAMETERS: struct node *parent, struct node *child
 * DEFINED IN: data.h
 *
 */

void
add_child(struct node *parent, struct node *child)
{
	if (parent->numChildren < MAX_CHILDREN) {
		parent->children[parent->numChildren++] = child;
	} else {
		if (LG_VERBOSE == 1) { errlog("Maximum number of children exceeded"); }
		exit(1);
	}
}

/*
* print_tree
*
* DESCRIPTION: Print a dependency tree.
* PARAMETERS: struct node *root, int level
* DEFINED IN: data.h
*
*/

void
print_tree(struct node *root, int level)
{
	if (root == NULL) {
		return;
	}

	for (int i = 0; i < level; i++) {
		printf("	");
	}

	printf("%s\n", root->data);

	for (int i = 0; i < root->numChildren; i++) {
		print_tree(root->children[i], level + 1);
	}
}

/*
 * queue
 *
 * DESCRIPTION: Definition of queue type.
 * DEFINED IN: data.h
 *
 */

typedef struct {
	int items[MAX_SIZE];
	int front;
	int rear;
} queue;

/*
* init_queue
*
* DESCRIPTION: Initialize a queue.
* PARAMETERS: queue *q
* DEFINED IN: data.h
*
*/

void
init_queue(queue *q)
{
	q -> front = -1;
	q -> rear = 0;
}

/*
* queue_is_empty
*
* DESCRIPTION: Check if queue is empty.
* PARAMETERS: struct node *root, int level
* DEFINED IN: data.h
*
*/

bool queue_is_empty(queue *q) { return (q -> front == q -> rear -1); }

/*
* queue_is_full
*
* DESCRIPTION: Check if queue is full.
* PARAMETERS: queue *q
* DEFINED IN: data.h
*
*/

bool queue_is_full(queue *q) { return (q -> rear == MAX_SIZE); }

/*
* enqueue
*
* DESCRIPTION: Enqueue an element at the back of the queue.
* PARAMETERS: queue *q, int value
* DEFINED IN: data.h
*
*/

void
enqueue (queue *q, int value)
{
	if (queue_is_full(q)) {
		printf("Queue is full\n");
		return;
	}
	
	q -> items[q -> rear] = value;
	q -> rear++;
}

/*
* dequeue
*
* DESCRIPTION: Dequeue the element at the front of the queue.
* PARAMETERS: queue *q, int value
* DEFINED IN: data.h
*
*/

void
dequeue(queue *q)
{
	if (queue_is_empty(q)) {
		printf("Queue is empty\n");
		return;
	}

	q -> front++;
}

/*
* peek
*
* DESCRIPTION: View the element at the front of the queue.
* PARAMETERS: struct node *root, int level
* DEFINED IN: data.h
*
*/

int
peek(queue *q)
{
	if (queue_is_empty(q)) {
		printf("Queue is empty\n");
		return -1;
	}

	return q -> items[q -> front + 1];
}

/*
* print_queue
*
* DESCRIPTION: Print the queue.
* PARAMETERS: queue *q
* DEFINED IN: data.h
*
*/

void
print_queue(queue *q)
{
	if (queue_is_empty(q)) {
		printf("Queue is empty\n");
		return;
	}

	printf("Current Queue: ");
	
	for (int i = q -> front + 1; i < q -> rear; i++) {
		printf("%d ", q -> items[i]);
	}
	printf("\n");
}

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

int
mkworkspace(void)
{
	DIR* workspace = opendir("/tmp/glacier-workspace");
	if (workspace) {
		/* infolog("Not creating new workspace, valid workspace already exists."); */
		return 0;
	} else if (ENOENT == errno) {
		/* infolog("Creating new Glacier workspace..."); */
		mkdir("/tmp/glacier-workspace", 0777);
		return 1;
	} else {
		if (LG_VERBOSE == 1) {
			errlog("in mkworkspace()");
			errlog("mkdir() failed to run");
		}
		return -1;
	}
}

/*
 * prepare_pkg
 *
 * DESCRIPTION: Copies a package archive from the localdb to the workspace, and unpacks it.
 * PARAMETERS: char PACKAGE[]
 * DEFINED IN: 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);
	}
}

/*
 * run_make_task
 *
 * DESCRIPTION: Runs a make task in current working directory 
 * PARAMETERS: char TASK[]
 * DEFINED IN: 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;
	}
}

/*
 * print_hash
 *
 * DESCRIPTION: Prints a specified hash string
 * PARAMETERS: unsigned char *hash, unsigned int length
 * DEFINED IN: security.h
 *
 */

int
print_hash(uchar *hash, uint length)
{
	for (uint index = 0; index < length; index++) {
		printf("%02x", hash[index]);
	}

	printf("\n");

	return 0;
}

/*
 * stash_hash
 *
 * DESCRIPTION: Stores a hash inside a string
 * PARAMETERS: unsigned char *stored_hash, unsigned char *hash, unsigned int length
 * DEFINED IN: security.h
 *
 */

/*int
stash_hash(uchar *stored_hash, uchar *hash, uint length)
{
	if (sizeof(stored_hash) != 32 && LG_VERBOSE == 1) {
		errlog("in stash_hash()");
		errlog("size of stored hash string must equal 32 bytes");
		return 1;
	}
	else if (sizeof(stored_hash) != 32) {
		return 1;
	}

	uint max_size_of_input = 3;

	for (uint index = 0; index < length; index++) {
		if (hash[index] > max_size_of_input) {
			errlog("in stash_hash()");
			errlog("size of input exceeds maximum allowed size (hash[index] > 3)");
			return 1;
		}
		snprintf(stored_hash[index], max_size_of_input, "%02x", hash[index]);
	}

	return 0;
} */

/*
 * hash_file
 *
 * DESCRIPTION: Performs a hashing operation on a file and stores the result
 * PARAMETERS: unsigned char *h
 * DEFINED IN: security.h
 *
 */

unsigned char
hash_file(const char *filename)
{
	FILE *data = fopen(filename, "rb");
	if (! data && LG_VERBOSE == 1) {
		errlog("in hash_file()");
		errlog("error opening file handle");
		return 1;
	}
	else if (! data) {
		return 1;
	}

	EVP_MD_CTX *context = EVP_MD_CTX_new();
	if (! context && LG_VERBOSE == 1) {
		errlog("in hash_file()");
		errlog("error creating envelope context");
		return 2;
	}
	else if (! context) {
		return 2;
	}

	if (EVP_DigestInit_ex(context, EVP_sha256(), NULL) != 1) {
		if (LG_VERBOSE == 1) {
			errlog("in hash_file()");
			errlog("error initializing digest");
		}
		EVP_MD_CTX_free(context);
		fclose(data);
		return 3;
	}

	if (ferror(data)) {
		if (LG_VERBOSE == 1) {
			errlog("in hash_file()");
			errlog("error reading file");
		}
		EVP_MD_CTX_free(context);
		fclose(data);
		return 4;
	}

	fclose(data);

	uchar hash[EVP_MAX_MD_SIZE];
	uint hash_length;

	if (EVP_DigestFinal_ex(context, hash, &hash_length) != 1) {
		if (LG_VERBOSE == 1) {
			errlog("in hash_file()");
			errlog("error finalizing digest");
		}
		EVP_MD_CTX_free(context);
		return 5;
	}
	
	EVP_MD_CTX_free(context);

	return *hash;
}