path: root/opkg-opk/opk/read.c

/*
 * Copyright (C) 2023  Patrick McDermott
 *
 * This file is part of opkg-opk.
 *
 * opkg-opk 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.
 *
 * opkg-opk 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 opkg-opk.  If not, see <https://www.gnu.org/licenses/>.
 */

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <time.h>
#include "defs.h"
#include "error.h"
#include "../gzip.h"
#include "../i18n.h"
#include "../opk.h"
#include "../ustar.h"
#include "opk.h"

static int
_opkg_opk_opk_read_file(void *user_data, char **buffer, size_t *size)
{
	struct opkg_opk_opk *opk = user_data;

	*buffer = opk->file_buffer;
	*size   = fread(opk->file_buffer, 1, sizeof(opk->file_buffer),
			opk->file);
	if (feof(opk->file)) {
		return OPKG_OPK_END;
	} else if (ferror(opk->file) || *size == 0) {
		return OPKG_OPK_ERROR;
	} else {
		return OPKG_OPK_OK;
	}
}

static int
_opkg_opk_opk_read_init_inner(struct opkg_opk_opk *opk)
{
	/* Initialize inner gzip decompressor. */
	opk->inner_gzip = opkg_opk_gzip_init_read(
			(opkg_opk_gzip_read_func *) &opkg_opk_ustar_read,
			opk->outer_ustar);
	if (opk->inner_gzip == NULL) {
		opkg_opk_error(_("Failed to initialize"));
		return OPKG_OPK_ERROR;
	}

	/* Initialize inner ustar unarchiver. */
	opk->inner_ustar = opkg_opk_ustar_init(opk->inner_gzip);
	if (opk->inner_ustar == NULL) {
		opkg_opk_error(_("Failed to initialize"));
		opkg_opk_gzip_free(opk->inner_gzip);
		return OPKG_OPK_ERROR;
	}

	return OPKG_OPK_OK;
}

static void
_opkg_opk_opk_read_free_inner(struct opkg_opk_opk *opk)
{
	opkg_opk_ustar_free(opk->inner_ustar);
	opkg_opk_gzip_free(opk->inner_gzip);
}

static int
_opkg_opk_opk_read_check_name(const char *member_name,
		struct _opkg_opk_opk_seek_name **head,
		struct _opkg_opk_opk_seek_name **tail)
{
	struct _opkg_opk_opk_seek_name *seek_name;

	if (member_name[0] == '.' && member_name[1] == '/') {
		member_name += 2;
	} else if (member_name[0] == '/') {
		member_name += 1;
	}

	/* Check each requested name. */
	for (seek_name = *head; seek_name != NULL; seek_name = seek_name->next)
	{
		if (strcmp(member_name, seek_name->name) == 0) {
			if (seek_name->prev != NULL) {
				seek_name->prev->next = seek_name->next;
			} else {
				/* This was the head.  Update. */
				*head = seek_name->next;
			}
			if (seek_name->next != NULL) {
				seek_name->next->prev = seek_name->prev;
			} else {
				/* This was the tail.  Update. */
				*tail = seek_name->prev;
			}
			free(seek_name);
			return OPKG_OPK_OK;
		}
	}

	return OPKG_OPK_ERROR;  /* Member not found */
}

static int
_opkg_opk_opk_read_control(struct opkg_opk_opk *opk)
{
	struct stat                     stat_buf;
	char                           *path;
	struct opkg_opk_ustar_member   *member;
	int                             ret_list;
	FILE                           *fp;
	int                             print;
	int                             ret_read;
	char                           *buffer;
	size_t                          size;
	struct _opkg_opk_opk_seek_name *seek_name;

	if (opk->control_dir != NULL) {
		if (stat(opk->control_dir, &stat_buf) == 0) {
			if (!S_ISDIR(stat_buf.st_mode)) {
				opkg_opk_error(_("Cannot create control "
							"directory"));
				return OPKG_OPK_ERROR;
			}
		} else if (mkdir(opk->control_dir, 0755) != 0) {
			opkg_opk_error(_("Cannot create control directory"));
			return OPKG_OPK_ERROR;
		}
/*		For below #pragmas: path initialized here
 *		(opk->control_dir != NULL). */
		path = malloc(strlen(opk->control_dir) +
				OPKG_OPK_USTAR_NAME_SIZE + 1);
		if (path == NULL) {
			return OPKG_OPK_ERROR;
		}
	} else if (opk->list_control == 0 && opk->print_control_head == NULL) {
		/* Not listing or printing any control files. */
		return OPKG_OPK_OK;
	}

	if (_opkg_opk_opk_read_init_inner(opk) != OPKG_OPK_OK) {
		if (opk->control_dir != NULL) {
#			pragma GCC diagnostic push
#			if __GNUC__ >= 11
#				pragma GCC diagnostic ignored \
					"-Wanalyzer-use-of-uninitialized-value"
#			endif
			free(path);
#			pragma GCC diagnostic pop
		}
		return OPKG_OPK_ERROR;
	}

	while ((ret_list = opkg_opk_ustar_list(opk->inner_ustar, &member)) ==
			OPKG_OPK_OK) {
		/* Remove leading "./" if present and skip if nothing's left. */
		buffer = member->name;
		if (buffer[0] == '.' && buffer[1] == '/') {
			buffer += 2;
		}
		if (buffer[0] == '\0') {
			opkg_opk_ustar_member_free(member);
			continue;
		}

		/* Only extract and/or print regular files. */
		if (member->type != '-') {
			opkg_opk_error(_("Non-regular control files not "
						"supported"));
			opkg_opk_ustar_member_free(member);
			_opkg_opk_opk_read_free_inner(opk);
			if (opk->control_dir != NULL) {
#				pragma GCC diagnostic push
#				if __GNUC__ >= 11
#					pragma GCC diagnostic ignored \
					"-Wanalyzer-use-of-uninitialized-value"
#				endif
				free(path);
#				pragma GCC diagnostic pop
			}
			return OPKG_OPK_ERROR;
		}

		/* Open file for extraction. */
		if (opk->control_dir != NULL) {
#			pragma GCC diagnostic push
#			if __GNUC__ >= 11
#				pragma GCC diagnostic ignored \
					"-Wanalyzer-use-of-uninitialized-value"
#			endif
			/* Guard against buffer overflow. */
			if (strlen(member->name) >= OPKG_OPK_USTAR_NAME_SIZE) {
				opkg_opk_error(_("Control files with long "
							"names not supported"));
				opkg_opk_ustar_member_free(member);
				_opkg_opk_opk_read_free_inner(opk);
				free(path);
				return OPKG_OPK_ERROR;
			}
			if (sprintf(path, "%s/%s", opk->control_dir,
						member->name) <= 0) {
				opkg_opk_ustar_member_free(member);
				_opkg_opk_opk_read_free_inner(opk);
				free(path);
				return OPKG_OPK_ERROR;
#				pragma GCC diagnostic pop
			}
#			pragma GCC diagnostic push
#			pragma GCC diagnostic ignored \
				"-Wmaybe-uninitialized"
/*			For below #pragmas: fp initialized here
 *			(opk->control_dir != NULL). */
/*			GCC analyzer doesn't complain about this use of path? */
			fp = fopen(path, "wb");
#			pragma GCC diagnostic pop
			if (fp == NULL) {
				opkg_opk_error(_("Failed to extract control "
							"file"));
				opkg_opk_ustar_member_free(member);
				_opkg_opk_opk_read_free_inner(opk);
#				pragma GCC diagnostic push
#				if __GNUC__ >= 11
#					pragma GCC diagnostic ignored \
					"-Wanalyzer-use-of-uninitialized-value"
#				endif
				free(path);
#				pragma GCC diagnostic pop
				return OPKG_OPK_ERROR;
			}
		}

		/* List file. */
		if (opk->list_control > 0) {
			puts(buffer);
			opk->previously_printed = 1;
		}

		/* Print file if requested. */
		if (opk->print_control_head != NULL &&
				_opkg_opk_opk_read_check_name(member->name,
					&opk->print_control_head,
					&opk->print_control_tail) ==
				OPKG_OPK_OK) {
			/* Name requested for printing. */
			print = 1;
		} else {
			print = 0;
		}
		opkg_opk_ustar_member_free(member);
		if (print == 1 && opk->previously_printed == 1) {
			puts("");
		}
		while ((ret_read = opkg_opk_ustar_read(opk->inner_ustar,
						&buffer, &size)) == OPKG_OPK_OK)
		{
			if (print == 1 && fwrite(buffer, 1, size, stdout) !=
					size) {
				opkg_opk_error(_("Failed to print control file")
						);
				_opkg_opk_opk_read_free_inner(opk);
				if (opk->control_dir != NULL) {
					free(path);
				}
				return OPKG_OPK_ERROR;
			}
#			pragma GCC diagnostic push
#			if __GNUC__ >= 11
#				pragma GCC diagnostic ignored \
					"-Wanalyzer-use-of-uninitialized-value"
#			endif
			if (opk->control_dir != NULL && fwrite(buffer, 1, size,
						fp) != size) {
				opkg_opk_error(_("Failed to write control file")
						);
				_opkg_opk_opk_read_free_inner(opk);
				free(path);
#				pragma GCC diagnostic pop
				return OPKG_OPK_ERROR;
			}
		}
		if (ret_read == OPKG_OPK_ERROR) {
			opkg_opk_error(_("Failed to read control file"));
			_opkg_opk_opk_read_free_inner(opk);
			if (opk->control_dir != NULL) {
#				pragma GCC diagnostic push
#				if __GNUC__ >= 11
#					pragma GCC diagnostic ignored \
					"-Wanalyzer-use-of-uninitialized-value"
#				endif
#				pragma GCC diagnostic ignored \
					"-Wmaybe-uninitialized"
				free(path);
				fclose(fp);
#				pragma GCC diagnostic pop
			}
#			pragma GCC diagnostic push
#			if __GNUC__ >= 10
#				pragma GCC diagnostic ignored \
					"-Wanalyzer-file-leak"
#			endif
			return OPKG_OPK_ERROR;
#			pragma GCC diagnostic pop
		}
		opk->previously_printed = 1;

		/* Close file for extraction. */
		if (opk->control_dir != NULL) {
#			pragma GCC diagnostic push
#			if __GNUC__ >= 11
#				pragma GCC diagnostic ignored \
					"-Wanalyzer-use-of-uninitialized-value"
#			endif
			if (fclose(fp) != 0) {
				_opkg_opk_opk_read_free_inner(opk);
				free(path);
#				pragma GCC diagnostic pop
				return OPKG_OPK_ERROR;
			}
		}
	}
	if (opk->control_dir != NULL) {
		/* Done with path buffer. */
#		pragma GCC diagnostic push
#		if __GNUC__ >= 11
#			pragma GCC diagnostic ignored \
				"-Wanalyzer-use-of-uninitialized-value"
#		endif
#		pragma GCC diagnostic ignored \
			"-Wmaybe-uninitialized"
		free(path);
#		pragma GCC diagnostic pop
	}
	if (ret_list == OPKG_OPK_ERROR) {
		opkg_opk_error(_("Failed to list control files"));
		_opkg_opk_opk_read_free_inner(opk);
		return OPKG_OPK_ERROR;
	}

	/* Check for files not found. */
	if (opk->print_control_head != NULL) {
		for (seek_name = opk->print_control_head; seek_name != NULL;
				seek_name = seek_name->next) {
			opkg_opk_error(_("Failed to find control file \"%s\""),
					seek_name->name);
		}
		_opkg_opk_opk_read_free_inner(opk);
		return OPKG_OPK_ERROR;
	}

	_opkg_opk_opk_read_free_inner(opk);

	return OPKG_OPK_OK;
}

static int
_opkg_opk_opk_read_data(struct opkg_opk_opk *opk)
{
	struct opkg_opk_ustar_member *head;
	struct opkg_opk_ustar_member *tail;
	struct opkg_opk_ustar_member *member;
	int                           ret;
	size_t                        uname_len;
	size_t                        uname_len_max;
	size_t                        gname_len;
	size_t                        gname_len_max;
	uint64_t                      size_max;
	uint32_t                      devmajor_max;
	uint32_t                      devminor_max;
	int                           ret_read;
	char                         *buffer;
	size_t                        size;
	long int                      size_len_max;
	long int                      devmajor_len_max;
	long int                      devminor_len_max;
	long int                      dev_len_max;
	char                          fmt[26];
	                              /* "%c%s %-32s/%-32s %16d %s " */
	char                          fmt_dev[30];
	                              /* "%c%s %-32s/%-32s %9d, %7d %s " */
	int                           len;
	char                          mode[10];
	char                          mtime[20];

	if (opk->list_data == 0 && opk->print_data_head == NULL) {
		/* Not listing or printing any data files. */
		return OPKG_OPK_OK;
	}

	if (_opkg_opk_opk_read_init_inner(opk) != OPKG_OPK_OK) {
		return OPKG_OPK_ERROR;
	}

	/* Build singly-linked list and find maximum column widths. */
	head = NULL;
	tail = NULL;
	uname_len_max = 0;
	gname_len_max = 0;
	size_max      = 0;
	devmajor_max  = 0;
	devminor_max  = 0;
	while ((ret = opkg_opk_ustar_list(opk->inner_ustar, &member)) ==
			OPKG_OPK_OK) {
		/* If listing, link members and update max column widths. */
		if (opk->list_data > 0) {
			if (head == NULL) {
				head = member;
			} else {
				tail->next = member;
			}
			tail = member;
			uname_len = strlen(member->uname);
			if (uname_len > uname_len_max) {
				uname_len_max = uname_len;
			}
			gname_len = strlen(member->gname);
			if (gname_len > gname_len_max) {
				gname_len_max = gname_len;
			}
			if (member->size > size_max) {
				size_max = member->size;
			}
			if (member->devmajor > devmajor_max) {
				devmajor_max = member->devmajor;
			}
			if (member->devminor > devminor_max) {
				devminor_max = member->devminor;
			}
		}

		if (opk->print_data_head == NULL) {
			if (opk->list_data == 0) {
				opkg_opk_ustar_member_free(member);
			}
			continue;
		}
		if (_opkg_opk_opk_read_check_name(member->name,
					&opk->print_data_head,
					&opk->print_data_tail) !=
				OPKG_OPK_OK) {
			/* Name not requested for printing. */
			if (opk->list_data == 0) {
				opkg_opk_ustar_member_free(member);
			}
			continue;
		}
		if (opk->list_data == 0) {
			opkg_opk_ustar_member_free(member);
		}
		if (opk->previously_printed == 1) {
			puts("");
		}
		while ((ret_read = opkg_opk_ustar_read(opk->inner_ustar,
						&buffer, &size)) == OPKG_OPK_OK)
		{
			if (fwrite(buffer, 1, size, stdout) != size) {
				opkg_opk_error(_("Failed to print data file"));
				_opkg_opk_opk_read_free_inner(opk);
				return OPKG_OPK_ERROR;
			}
		}
		if (ret_read == OPKG_OPK_ERROR) {
			opkg_opk_error(_("Failed to read data file"));
			_opkg_opk_opk_read_free_inner(opk);
			return OPKG_OPK_ERROR;
		}
		opk->previously_printed = 1;
	}
	if (ret == OPKG_OPK_ERROR) {
		opkg_opk_error(_("Failed to list data files"));
		_opkg_opk_opk_read_free_inner(opk);
		return OPKG_OPK_ERROR;
	}
	if (tail != NULL) {
		tail->next = NULL;
	}

	if (opk->list_data == 0) {
		_opkg_opk_opk_read_free_inner(opk);
		return OPKG_OPK_OK;
	}

	/* Print and free members. */
	if (opk->previously_printed == 1) {
		puts("");
	}
	ret = OPKG_OPK_OK;
	size_len_max     = lrint(ceil(log10(    size_max)));
	devmajor_len_max = lrint(ceil(log10(devmajor_max)));
	devminor_len_max = lrint(ceil(log10(devminor_max)));
	if (devmajor_len_max == 0) {
		devmajor_len_max = 1;
	}
	if (devminor_len_max == 0) {
		devminor_len_max = 1;
	}
	dev_len_max = devmajor_len_max + 2 /* ", " */ + devminor_len_max;
	if (dev_len_max > size_len_max) {
		size_len_max = dev_len_max;
	}
	snprintf(fmt    , sizeof(fmt    ), "%%c%%s %%-%zus/%%-%zus %%%lid %%s ",
			uname_len_max, gname_len_max, size_len_max);
	snprintf(fmt_dev, sizeof(fmt_dev), "%%c%%s %%-%zus/%%-%zus "
			"%%%lid, %%%lid %%s ",
			uname_len_max, gname_len_max,
			size_len_max - devminor_len_max - 2, devminor_len_max);
	len = 34 + uname_len_max + gname_len_max + size_len_max;
	for (member = head; member != NULL;) {
		if (member->mode & 00400) mode[0] = 'r'; else mode[0] = '-';
		if (member->mode & 00200) mode[1] = 'w'; else mode[1] = '-';
		if (member->mode & 00100) mode[2] = 'x'; else mode[2] = '-';
		if (member->mode & 04000) mode[2] = 's';
		if (member->mode & 00040) mode[3] = 'r'; else mode[3] = '-';
		if (member->mode & 00020) mode[4] = 'w'; else mode[4] = '-';
		if (member->mode & 00010) mode[5] = 'x'; else mode[5] = '-';
		if (member->mode & 02000) mode[5] = 's';
		if (member->mode & 00004) mode[6] = 'r'; else mode[6] = '-';
		if (member->mode & 00002) mode[7] = 'w'; else mode[7] = '-';
		if (member->mode & 00001) mode[8] = 'x'; else mode[8] = '-';
		if (member->mode & 01000) mode[8] = 't';
		mode[9] = '\0';
		strftime(mtime, sizeof(mtime), "%Y-%m-%d %H:%M:%S",
				localtime((const time_t *) &member->mtime));
#		pragma GCC diagnostic push
#		pragma GCC diagnostic ignored "-Wformat-nonliteral"
		if (member->type != 'b' && member->type != 'c') {
			if (printf(fmt, member->type, mode,
					member->uname, member->gname,
					member->size, mtime) != len) {
				ret = OPKG_OPK_ERROR;
			}
		} else {
			if (printf(fmt_dev, member->type, mode,
					member->uname, member->gname,
					member->devmajor, member->devminor,
					mtime) != len) {
				ret = OPKG_OPK_ERROR;
			}
		}
#		pragma GCC diagnostic pop
		/* Print name, ensuring it begins with "/". */
		if (member->name[0] == '.' && member->name[1] == '/') {
			if (fputs(member->name + 1, stdout) == EOF) {
				ret = OPKG_OPK_ERROR;
			}
		} else {
			if (member->name[0] != '/' && putchar('/') == EOF) {
				ret = OPKG_OPK_ERROR;
			}
			if (fputs(member->name, stdout) == EOF) {
				ret = OPKG_OPK_ERROR;
			}
		}
		/* Print link name, if any. */
		if (member->type == 'l' && printf(" -> %s", member->linkname) !=
				(int) (strlen(member->linkname) + 4)) {
			ret = OPKG_OPK_ERROR;
		}
		if (puts("") == EOF) {
			ret = OPKG_OPK_ERROR;
		}
		head   = member;
		member = member->next;
		opkg_opk_ustar_member_free(head);
	}

	opk->previously_printed = 1;

	_opkg_opk_opk_read_free_inner(opk);

	return ret;
}

int
opkg_opk_opk_read(struct opkg_opk_opk *opk, const char *file_name)
{
	int                           ret;
	struct opkg_opk_ustar_member *member;
	char                         *version_buffer;
	size_t                        version_size;

	ret = OPKG_OPK_OK;

	/* Open outer archive. */
	opk->file = fopen(file_name, "rb");
	if (opk->file == NULL) {
		opkg_opk_error(_("Failed to open file \"%s\""), file_name);
		ret = OPKG_OPK_ERROR;
		goto out0;
	}

	/* Initialize outer gzip decompressor. */
	opk->outer_gzip = opkg_opk_gzip_init_read(&_opkg_opk_opk_read_file,
			opk);
	if (opk->outer_gzip == NULL) {
		opkg_opk_error(_("Failed to initialize"));
		ret = OPKG_OPK_ERROR;
		goto out1;
	}

	/* Initialize outer ustar unarchiver. */
	opk->outer_ustar = opkg_opk_ustar_init(opk->outer_gzip);
	if (opk->outer_ustar == NULL) {
		opkg_opk_error(_("Failed to initialize"));
		ret = OPKG_OPK_ERROR;
		goto out2;
	}

	/* Check package version. */
	if (opkg_opk_ustar_list(opk->outer_ustar, &member) != OPKG_OPK_OK) {
		opkg_opk_error(_("Failed to find \"debian-binary\" in archive")
				);
		ret = OPKG_OPK_ERROR;
		goto out3;
	}
	if (strcmp(member->name, "debian-binary") != 0) {
		opkg_opk_ustar_member_free(member);
		opkg_opk_error(_("Failed to find \"debian-binary\" in archive")
				);
		ret = OPKG_OPK_ERROR;
		goto out3;
	}
	opkg_opk_ustar_member_free(member);
	if (opkg_opk_ustar_read(opk->outer_ustar,
				&version_buffer, &version_size) !=
			OPKG_OPK_OK) {
		opkg_opk_error(_("Failed to read \"debian-binary\" in archive")
				);
		ret = OPKG_OPK_ERROR;
		goto out3;
	}
	if (version_size < 4 || strncmp(version_buffer, "2.", 2) != 0) {
		opkg_opk_error(_("Unsupported package version"));
		ret = OPKG_OPK_ERROR;
		goto out3;
	}

	/* Read control archive. */
	if (opkg_opk_ustar_list(opk->outer_ustar, &member) != OPKG_OPK_OK) {
		opkg_opk_error(_("Failed to find \"control.tar.gz\" in archive")
				);
		return OPKG_OPK_ERROR;
	}
	if (strcmp(member->name, "control.tar.gz") != 0) {
		opkg_opk_ustar_member_free(member);
		opkg_opk_error(_("Failed to find \"control.tar.gz\" in archive")
				);
		return OPKG_OPK_ERROR;
	}
	opkg_opk_ustar_member_free(member);
	if (_opkg_opk_opk_read_control(opk) != OPKG_OPK_OK) {
		ret = OPKG_OPK_ERROR;
		goto out3;
	}

	/* Read data archive. */
	if (opkg_opk_ustar_list(opk->outer_ustar, &member) != OPKG_OPK_OK) {
		opkg_opk_error(_("Failed to find \"data.tar.gz\" in archive"));
		return OPKG_OPK_ERROR;
	}
	if (strcmp(member->name, "data.tar.gz") != 0) {
		opkg_opk_ustar_member_free(member);
		opkg_opk_error(_("Failed to find \"data.tar.gz\" in archive"));
		return OPKG_OPK_ERROR;
	}
	opkg_opk_ustar_member_free(member);
	if (_opkg_opk_opk_read_data(opk) != OPKG_OPK_OK) {
		ret = OPKG_OPK_ERROR;
		goto out3;
	}

 out3:
	opkg_opk_ustar_free(opk->outer_ustar);
 out2:
	opkg_opk_gzip_free(opk->outer_gzip);
 out1:
	fclose(opk->file);
 out0:
	return ret;
}