jail: Set some default environment variables

[people/ms/pakfire.git] / src / libpakfire / jail.c

/*#############################################################################
#                                                                             #
# Pakfire - The IPFire package management system                              #
# Copyright (C) 2022 Pakfire development team                                 #
#                                                                             #
# This program 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.                                         #
#                                                                             #
# This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.       #
#                                                                             #
#############################################################################*/

#include <errno.h>
#include <stdlib.h>

#include <pakfire/logging.h>
#include <pakfire/jail.h>
#include <pakfire/pakfire.h>
#include <pakfire/util.h>

#define ENVIRON_SIZE 128

// The default environment that will be set for every command
static const struct environ {
	const char* key;
	const char* val;
} ENV[] = {
	{ "LANG", "en_US.utf-8" },
	{ "TERM", "vt100" },
	{ NULL, NULL },
};

struct pakfire_jail {
	struct pakfire* pakfire;
	int nrefs;

	// Environment
	char* env[ENVIRON_SIZE];
};

static void pakfire_jail_free(struct pakfire_jail* jail) {
	DEBUG(jail->pakfire, "Freeing jail at %p\n", jail);

	// Free environment
	for (unsigned int i = 0; jail->env[i]; i++)
		free(jail->env[i]);

	pakfire_unref(jail->pakfire);
	free(jail);
}

int pakfire_jail_create(struct pakfire_jail** jail, struct pakfire* pakfire) {
	int r;

	// Allocate a new jail
	struct pakfire_jail* j = calloc(1, sizeof(*j));
	if (!j)
		return 1;

	// Reference Pakfire
	j->pakfire = pakfire_ref(pakfire);

	// Initialize reference counter
	j->nrefs = 1;

	DEBUG(j->pakfire, "Allocated new jail at %p\n", j);

	// Set default environment
	for (const struct environ* e = ENV; e->key; e++) {
		r = pakfire_jail_set_env(j, e->key, e->val);
		if (r)
			goto ERROR;
	}

	// Done
	*jail = j;
	return 0;

ERROR:
	pakfire_jail_free(j);

	return r;
}

struct pakfire_jail* pakfire_jail_ref(struct pakfire_jail* jail) {
	++jail->nrefs;

	return jail;
}

struct pakfire_jail* pakfire_jail_unref(struct pakfire_jail* jail) {
	if (--jail->nrefs > 0)
		return jail;

	pakfire_jail_free(jail);
	return NULL;
}

// Environment

// Returns the length of the environment
static unsigned int pakfire_jail_env_length(struct pakfire_jail* jail) {
	unsigned int i = 0;

	// Count everything in the environment
	for (char** e = jail->env; *e; e++)
		i++;

	return i;
}

// Finds an existing environment variable and returns its index or -1 if not found
static int pakfire_jail_find_env(struct pakfire_jail* jail, const char* key) {
	if (!key) {
		errno = EINVAL;
		return -1;
	}

	char buffer[strlen(key) + 2];
	pakfire_string_format(buffer, "%s=", key);

	for (unsigned int i = 0; jail->env[i]; i++) {
		if (pakfire_string_startswith(jail->env[i], buffer))
			return i;
	}

	// Nothing found
	return -1;
}

// Returns the value of an environment variable or NULL
const char* pakfire_jail_get_env(struct pakfire_jail* jail, const char* key) {
	int i = pakfire_jail_find_env(jail, key);
	if (i < 0)
		return NULL;

	return jail->env[i] + strlen(key) + 1;
}

// Sets an environment variable
int pakfire_jail_set_env(struct pakfire_jail* jail, const char* key, const char* value) {
	// Find the index where to write this value to
	int i = pakfire_jail_find_env(jail, key);
	if (i < 0)
		i = pakfire_jail_env_length(jail);

	// Return -ENOSPC when the environment is full
	if (i >= ENVIRON_SIZE) {
		errno = ENOSPC;
		return -1;
	}

	// Free any previous value
	if (jail->env[i])
		free(jail->env[i]);

	// Format and set environment variable
	asprintf(&jail->env[i], "%s=%s", key, value);

	DEBUG(jail->pakfire, "Set environment variable: %s\n", jail->env[i]);

	return 0;
}