progressbar: Fallback if output is not a TTY

[people/stevee/pakfire.git] / src / libpakfire / file.c

/*#############################################################################
#                                                                             #
# Pakfire - The IPFire package management system                              #
# Copyright (C) 2014 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 <assert.h>
#include <errno.h>
#include <linux/limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <tar.h>
#include <time.h>

#include <archive_entry.h>

#include <pakfire/constants.h>
#include <pakfire/file.h>
#include <pakfire/pakfire.h>
#include <pakfire/private.h>
#include <pakfire/util.h>

struct _PakfireFile {
	Pakfire pakfire;
	int nrefs;

	const char* path;
	char abspath[PATH_MAX];
	char type;
	ssize_t size;

	char user[256];
	char group[256];

	mode_t mode;

	time_t ctime;
	time_t mtime;

	char* chksum;

	#warning TODO capabilities, config, data
	// capabilities
	//int is_configfile;
	//int is_datafile;
};

PAKFIRE_EXPORT int pakfire_file_create(PakfireFile* file, Pakfire pakfire) {
	PakfireFile f = calloc(1, sizeof(*f));
	if (!f)
		return -ENOMEM;

	f->pakfire = pakfire_ref(pakfire);
	f->nrefs = 1;

	*file = f;
	return 0;
}

PAKFIRE_EXPORT int pakfire_file_copy_stat(PakfireFile file, struct stat* stat) {
	if (!stat)
		return EINVAL;

	// Set mode
	pakfire_file_set_mode(file, stat->st_mode);

	// Set size
	pakfire_file_set_size(file, stat->st_size);

	// Set user
	// XXX
	pakfire_file_set_user(file, "root");
	pakfire_file_set_group(file, "root");

	// Set times
	pakfire_file_set_ctime(file, stat->st_ctime);
	pakfire_file_set_mtime(file, stat->st_mtime);

	return 0;
}

struct archive_entry* pakfire_file_archive_entry(PakfireFile file) {
	struct archive_entry* entry = archive_entry_new();
	if (!entry)
		return NULL;

	// Set path
	archive_entry_copy_pathname(entry, pakfire_file_get_path(file));

	// Set source path
	archive_entry_copy_sourcepath(entry, file->abspath);

	// Set size
	archive_entry_set_size(entry, pakfire_file_get_size(file));

	// Set mode
	archive_entry_set_mode(entry, pakfire_file_get_mode(file));

	// Set user
	archive_entry_set_uname(entry, pakfire_file_get_user(file));

	// Set group
	archive_entry_set_gname(entry, pakfire_file_get_group(file));

	// Set times
	archive_entry_set_ctime(entry, pakfire_file_get_ctime(file), 0);
	archive_entry_set_mtime(entry, pakfire_file_get_mtime(file), 0);

	return entry;
}

int pakfire_file_copy_archive_entry(PakfireFile file, struct archive_entry* entry) {
	// Set path
	pakfire_file_set_path(file, archive_entry_pathname(entry));

	// Set size
	pakfire_file_set_size(file, archive_entry_size(entry));

	// Set mode
	pakfire_file_set_mode(file, archive_entry_mode(entry));

	// Set user
	pakfire_file_set_user(file, archive_entry_uname(entry));

	// Set group
	pakfire_file_set_group(file, archive_entry_gname(entry));

	// Set times
	pakfire_file_set_ctime(file, archive_entry_ctime(entry));
	pakfire_file_set_mtime(file, archive_entry_mtime(entry));

	return 0;
}

static void pakfire_file_free(PakfireFile file) {
	pakfire_unref(file->pakfire);

	if (file->chksum)
		free(file->chksum);

	free(file);
}

PAKFIRE_EXPORT PakfireFile pakfire_file_ref(PakfireFile file) {
	file->nrefs++;

	return file;
}

PAKFIRE_EXPORT PakfireFile pakfire_file_unref(PakfireFile file) {
	if (--file->nrefs > 0)
		return file;

	pakfire_file_free(file);
	return NULL;
}

PAKFIRE_EXPORT int pakfire_file_cmp(PakfireFile file1, PakfireFile file2) {
	const char* path1 = pakfire_file_get_path(file1);
	const char* path2 = pakfire_file_get_path(file2);

	return strcmp(path1, path2);
}

PAKFIRE_EXPORT const char* pakfire_file_get_path(PakfireFile file) {
	return file->path;
}

PAKFIRE_EXPORT int pakfire_file_set_path(PakfireFile file, const char* path) {
	char* p = pakfire_make_path(file->pakfire, path);
	if (!p)
		return 1;

	// Copy to abspath
	snprintf(file->abspath, sizeof(file->abspath) - 1, "%s", p);
	free(p);

	// Store relative path
	file->path = file->abspath + strlen(file->abspath) - strlen(path);

	return 0;
}

PAKFIRE_EXPORT int pakfire_file_get_type(PakfireFile file) {
	return file->mode & S_IFMT;
}

PAKFIRE_EXPORT ssize_t pakfire_file_get_size(PakfireFile file) {
	return file->size;
}

PAKFIRE_EXPORT void pakfire_file_set_size(PakfireFile file, ssize_t size) {
	file->size = size;
}

PAKFIRE_EXPORT const char* pakfire_file_get_user(PakfireFile file) {
	return file->user;
}

PAKFIRE_EXPORT void pakfire_file_set_user(PakfireFile file, const char* user) {
	snprintf(file->user, sizeof(file->user) - 1, "%s", user);
}

PAKFIRE_EXPORT const char* pakfire_file_get_group(PakfireFile file) {
	return file->group;
}

PAKFIRE_EXPORT void pakfire_file_set_group(PakfireFile file, const char* group) {
	snprintf(file->group, sizeof(file->group) - 1, "%s", group);
}

PAKFIRE_EXPORT mode_t pakfire_file_get_mode(PakfireFile file) {
	return file->mode;
}

PAKFIRE_EXPORT void pakfire_file_set_mode(PakfireFile file, mode_t mode) {
	file->mode = mode;
}

PAKFIRE_EXPORT time_t pakfire_file_get_ctime(PakfireFile file) {
	return file->ctime;
}

PAKFIRE_EXPORT void pakfire_file_set_ctime(PakfireFile file, time_t time) {
	file->ctime = time;
}

PAKFIRE_EXPORT time_t pakfire_file_get_mtime(PakfireFile file) {
	return file->mtime;
}

PAKFIRE_EXPORT void pakfire_file_set_mtime(PakfireFile file, time_t time) {
	file->mtime = time;
}

PAKFIRE_EXPORT const char* pakfire_file_get_chksum(PakfireFile file) {
	return file->chksum;
}

PAKFIRE_EXPORT void pakfire_file_set_chksum(PakfireFile file, const char* chksum) {
	if (file->chksum) {
		free(file->chksum);
		file->chksum = NULL;
	}

	if (chksum)
		file->chksum = strdup(chksum);
}

FILE* pakfire_file_fopen(PakfireFile file, const char* mode) {
	if (!*file->abspath)
		return NULL;

	return fopen(file->abspath, mode);
}