[linux-2.6-block.git] / tools / perf / util / lzma.c

// SPDX-License-Identifier: GPL-2.0
#include <errno.h>
#include <lzma.h>
#include <stdio.h>
#include <linux/compiler.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "compress.h"
#include "debug.h"
#include <string.h>
#include <unistd.h>
#include <internal/lib.h>

#define BUFSIZE 8192

static const char *lzma_strerror(lzma_ret ret)
{
	switch ((int) ret) {
	case LZMA_MEM_ERROR:
		return "Memory allocation failed";
	case LZMA_OPTIONS_ERROR:
		return "Unsupported decompressor flags";
	case LZMA_FORMAT_ERROR:
		return "The input is not in the .xz format";
	case LZMA_DATA_ERROR:
		return "Compressed file is corrupt";
	case LZMA_BUF_ERROR:
		return "Compressed file is truncated or otherwise corrupt";
	default:
		return "Unknown error, possibly a bug";
	}
}

int lzma_decompress_to_file(const char *input, int output_fd)
{
	lzma_action action = LZMA_RUN;
	lzma_stream strm   = LZMA_STREAM_INIT;
	lzma_ret ret;
	int err = -1;

	u8 buf_in[BUFSIZE];
	u8 buf_out[BUFSIZE];
	FILE *infile;

	infile = fopen(input, "rb");
	if (!infile) {
		pr_debug("lzma: fopen failed on %s: '%s'\n", input, strerror(errno));
		return -1;
	}

	ret = lzma_stream_decoder(&strm, UINT64_MAX, LZMA_CONCATENATED);
	if (ret != LZMA_OK) {
		pr_debug("lzma: lzma_stream_decoder failed %s (%d)\n", lzma_strerror(ret), ret);
		goto err_fclose;
	}

	strm.next_in   = NULL;
	strm.avail_in  = 0;
	strm.next_out  = buf_out;
	strm.avail_out = sizeof(buf_out);

	while (1) {
		if (strm.avail_in == 0 && !feof(infile)) {
			strm.next_in  = buf_in;
			strm.avail_in = fread(buf_in, 1, sizeof(buf_in), infile);

			if (ferror(infile)) {
				pr_debug("lzma: read error: %s\n", strerror(errno));
				goto err_lzma_end;
			}

			if (feof(infile))
				action = LZMA_FINISH;
		}

		ret = lzma_code(&strm, action);

		if (strm.avail_out == 0 || ret == LZMA_STREAM_END) {
			ssize_t write_size = sizeof(buf_out) - strm.avail_out;

			if (writen(output_fd, buf_out, write_size) != write_size) {
				pr_debug("lzma: write error: %s\n", strerror(errno));
				goto err_lzma_end;
			}

			strm.next_out  = buf_out;
			strm.avail_out = sizeof(buf_out);
		}

		if (ret != LZMA_OK) {
			if (ret == LZMA_STREAM_END)
				break;

			pr_debug("lzma: failed %s\n", lzma_strerror(ret));
			goto err_lzma_end;
		}
	}

	err = 0;
err_lzma_end:
	lzma_end(&strm);
err_fclose:
	fclose(infile);
	return err;
}

bool lzma_is_compressed(const char *input)
{
	int fd = open(input, O_RDONLY);
	const uint8_t magic[6] = { 0xFD, '7', 'z', 'X', 'Z', 0x00 };
	char buf[6] = { 0 };
	ssize_t rc;

	if (fd < 0)
		return -1;

	rc = read(fd, buf, sizeof(buf));
	close(fd);
	return rc == sizeof(buf) ?
	       memcmp(buf, magic, sizeof(buf)) == 0 : false;
}
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
a43783ae	2	#include <errno.h>
80a32e5b JO	3	#include <lzma.h>
	4	#include <stdio.h>
	5	#include <linux/compiler.h>
4b57fd44 JO	6	#include <sys/types.h>
	7	#include <sys/stat.h>
	8	#include <fcntl.h>
611f0afe	9	#include "compress.h"
80a32e5b	10	#include "debug.h"
8520a98d	11	#include <string.h>
4b57fd44	12	#include <unistd.h>
fb71c86c	13	#include <internal/lib.h>
80a32e5b JO	14
	15	#define BUFSIZE 8192
	16
	17	static const char *lzma_strerror(lzma_ret ret)
	18	{
	19	switch ((int) ret) {
	20	case LZMA_MEM_ERROR:
	21	return "Memory allocation failed";
	22	case LZMA_OPTIONS_ERROR:
	23	return "Unsupported decompressor flags";
	24	case LZMA_FORMAT_ERROR:
	25	return "The input is not in the .xz format";
	26	case LZMA_DATA_ERROR:
	27	return "Compressed file is corrupt";
	28	case LZMA_BUF_ERROR:
	29	return "Compressed file is truncated or otherwise corrupt";
	30	default:
	31	return "Unknown error, possibly a bug";
	32	}
	33	}
	34
	35	int lzma_decompress_to_file(const char *input, int output_fd)
	36	{
	37	lzma_action action = LZMA_RUN;
	38	lzma_stream strm = LZMA_STREAM_INIT;
	39	lzma_ret ret;
ffe67c2f	40	int err = -1;
80a32e5b JO	41
	42	u8 buf_in[BUFSIZE];
	43	u8 buf_out[BUFSIZE];
	44	FILE *infile;
	45
	46	infile = fopen(input, "rb");
	47	if (!infile) {
7a46404b	48	pr_debug("lzma: fopen failed on %s: '%s'\n", input, strerror(errno));
80a32e5b JO	49	return -1;
	50	}
	51
	52	ret = lzma_stream_decoder(&strm, UINT64_MAX, LZMA_CONCATENATED);
	53	if (ret != LZMA_OK) {
7a46404b	54	pr_debug("lzma: lzma_stream_decoder failed %s (%d)\n", lzma_strerror(ret), ret);
ffe67c2f	55	goto err_fclose;
80a32e5b JO	56	}
	57
	58	strm.next_in = NULL;
	59	strm.avail_in = 0;
	60	strm.next_out = buf_out;
	61	strm.avail_out = sizeof(buf_out);
	62
	63	while (1) {
	64	if (strm.avail_in == 0 && !feof(infile)) {
	65	strm.next_in = buf_in;
	66	strm.avail_in = fread(buf_in, 1, sizeof(buf_in), infile);
	67
	68	if (ferror(infile)) {
7a46404b	69	pr_debug("lzma: read error: %s\n", strerror(errno));
f8cbb0f9	70	goto err_lzma_end;
80a32e5b JO	71	}
	72
	73	if (feof(infile))
	74	action = LZMA_FINISH;
	75	}
	76
	77	ret = lzma_code(&strm, action);
	78
	79	if (strm.avail_out == 0 \|\| ret == LZMA_STREAM_END) {
	80	ssize_t write_size = sizeof(buf_out) - strm.avail_out;
	81
	82	if (writen(output_fd, buf_out, write_size) != write_size) {
7a46404b	83	pr_debug("lzma: write error: %s\n", strerror(errno));
f8cbb0f9	84	goto err_lzma_end;
80a32e5b JO	85	}
	86
	87	strm.next_out = buf_out;
	88	strm.avail_out = sizeof(buf_out);
	89	}
	90
	91	if (ret != LZMA_OK) {
	92	if (ret == LZMA_STREAM_END)
ffe67c2f	93	break;
80a32e5b	94
7a46404b	95	pr_debug("lzma: failed %s\n", lzma_strerror(ret));
f8cbb0f9	96	goto err_lzma_end;
80a32e5b JO	97	}
	98	}
	99
ffe67c2f	100	err = 0;
f8cbb0f9 RM	101	err_lzma_end:
f8cbb0f9 RM	102	lzma_end(&strm);
ffe67c2f	103	err_fclose:
80a32e5b	104	fclose(infile);
ffe67c2f	105	return err;
80a32e5b	106	}
8b42b7e5	107
4b57fd44	108	bool lzma_is_compressed(const char *input)
8b42b7e5	109	{
4b57fd44 JO	110	int fd = open(input, O_RDONLY);
	111	const uint8_t magic[6] = { 0xFD, '7', 'z', 'X', 'Z', 0x00 };
	112	char buf[6] = { 0 };
	113	ssize_t rc;
	114
	115	if (fd < 0)
	116	return -1;
	117
	118	rc = read(fd, buf, sizeof(buf));
	119	close(fd);
	120	return rc == sizeof(buf) ?
	121	memcmp(buf, magic, sizeof(buf)) == 0 : false;
8b42b7e5	122	}