Attachment #212454 for bug #207737




/*
 *
 * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
 * Phillip Lougher <phillip@lougher.demon.co.uk>
 *
 * 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 2,
 * 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, write to the Free Software
 * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 * compressor.c
 */

#include <stdio.h>
#include <string.h>
#include "compressor.h"
#include "squashfs_fs.h"

extern int gzip_compress(void **, char *, char *, int, int, int *);
extern int gzip_uncompress(char *, char *, int, int, int *);
extern int lzma_compress(void **, char *, char *, int, int, int *);
extern int lzma_uncompress(char *, char *, int, int, int *);

struct compressor compressor[] = {
	{ gzip_compress, gzip_uncompress, ZLIB_COMPRESSION, "gzip", 1 },
#ifdef LZMA_SUPPORT
	{ lzma_compress, lzma_uncompress, LZMA_COMPRESSION, "lzma", 1 },
#else
	{ NULL, NULL, LZMA_COMPRESSION, "lzma", 0 },
#endif
	{ NULL, NULL , 0, "unknown", 0}
};


struct compressor *lookup_compressor(char *name)
{
	int i;

	for(i = 0; compressor[i].id; i++)
		if(strcmp(compressor[i].name, name) == 0)
			break;

	return &compressor[i];
}


struct compressor *lookup_compressor_id(int id)
{
	int i;

	for(i = 0; compressor[i].id; i++)
		if(id == compressor[i].id)
			break;

	return &compressor[i];
}


void display_compressors(char *indent, char *def_comp)
{
	int i;

	for(i = 0; compressor[i].id; i++)
		if(compressor[i].supported)
			fprintf(stderr, "%s\t%s%s\n", indent,
				compressor[i].name,
				strcmp(compressor[i].name, def_comp) == 0 ?
				" (default)" : "");
}




/*
 *
 * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
 * Phillip Lougher <phillip@lougher.demon.co.uk>
 *
 * 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 2,
 * 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, write to the Free Software
 * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 * compressor.h
 */

struct compressor {
	int (*compress)(void **, char *, char *, int, int, int *);
	int (*uncompress)(char *, char *, int, int, int *);
	int id;
	char *name;
	int supported;
};

extern struct compressor *lookup_compressor(char *);
extern struct compressor *lookup_compressor_id(int);
extern void display_compressors(char *, char *);




/*
 * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
 * Phillip Lougher <phillip@lougher.demon.co.uk>
 *
 * 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 2,
 * 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, write to the Free Software
 * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 * gzip_wrapper.c
 */

#include <stdlib.h>
#include <zlib.h>

int gzip_compress(void **strm, char *d, char *s, int size, int block_size,
		int *error)
{
	int res = 0;
	z_stream *stream = *strm;

	if(stream == NULL) {
		if((stream = *strm = malloc(sizeof(z_stream))) == NULL)
			goto failed;

		stream->zalloc = Z_NULL;
		stream->zfree = Z_NULL;
		stream->opaque = 0;

		if((res = deflateInit(stream, 9)) != Z_OK)
			goto failed;
	} else if((res = deflateReset(stream)) != Z_OK)
		goto failed;

	stream->next_in = (unsigned char *) s;
	stream->avail_in = size;
	stream->next_out = (unsigned char *) d;
	stream->avail_out = block_size;

	res = deflate(stream, Z_FINISH);
	if(res == Z_STREAM_END)
		/*
		 * Success, return the compressed size.
		 */
		return (int) stream->total_out;
	if(res == Z_OK)
		/*
		 * Output buffer overflow.  Return out of buffer space
		 */
		return 0;
failed:
	/*
	 * All other errors return failure, with the compressor
	 * specific error code in *error
	 */
	*error = res;
	return -1;
}


int gzip_uncompress(char *d, char *s, int size, int block_size, int *error)
{
	int res;
	unsigned long bytes = block_size;

	res = uncompress((unsigned char *) d, &bytes,
		(const unsigned char *) s, size);

	*error = res;
	return res == Z_OK ? (int) bytes : -1;
}




/*
 * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
 * Phillip Lougher <phillip@lougher.demon.co.uk>
 *
 * 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 2,
 * 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, write to the Free Software
 * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 * lzma_wrapper.c
 */

#include <LzmaLib.h>

#define LZMA_HEADER_SIZE	(LZMA_PROPS_SIZE + 8)

int lzma_compress(void **strm, char *dest, char *src,  int size,int block_size,
		int *error)
{
	unsigned char *d = (unsigned char *) dest, *s = (unsigned char *) src;
	size_t props_size = LZMA_PROPS_SIZE,
		outlen = block_size - LZMA_HEADER_SIZE;
	int res;

	res = LzmaCompress(d + LZMA_HEADER_SIZE, &outlen, s, size, d,
		&props_size, 5, block_size, 3, 0, 2, 32, 1);
	
	if(res == SZ_ERROR_OUTPUT_EOF) {
		/*
		 * Output buffer overflow.  Return out of buffer space error
		 */
		return 0;
	}

	if(res != SZ_OK) {
		/*
		 * All other errors return failure, with the compressor
		 * specific error code in *error
		 */
		*error = res;
		return -1;
	}

	/*
	 * Fill in the 8 byte little endian uncompressed size field in the
	 * LZMA header.  8 bytes is excessively large for squashfs but
	 * this is the standard LZMA header and which is expected by the kernel
	 * code
	 */
	d[LZMA_PROPS_SIZE] = size & 255;
	d[LZMA_PROPS_SIZE + 1] = (size >> 8) & 255;
	d[LZMA_PROPS_SIZE + 2] = (size >> 16) & 255;
	d[LZMA_PROPS_SIZE + 3] = (size >> 24) & 255;
	d[LZMA_PROPS_SIZE + 4] = 0;
	d[LZMA_PROPS_SIZE + 5] = 0;
	d[LZMA_PROPS_SIZE + 6] = 0;
	d[LZMA_PROPS_SIZE + 7] = 0;

	/*
	 * Success, return the compressed size.  Outlen returned by the LZMA
	 * compressor does not include the LZMA header space
	 */
	return outlen + LZMA_HEADER_SIZE;
}


int lzma_uncompress(char *dest, char *src, int size, int block_size,
	int *error)
{
	unsigned char *d = (unsigned char *) dest, *s = (unsigned char *) src;
	size_t outlen, inlen = size - LZMA_HEADER_SIZE;
	int res;

	outlen = s[LZMA_PROPS_SIZE] |
		(s[LZMA_PROPS_SIZE + 1] << 8) |
		(s[LZMA_PROPS_SIZE + 2] << 16) |
		(s[LZMA_PROPS_SIZE + 3] << 24);

	res = LzmaUncompress(d, &outlen, s + LZMA_HEADER_SIZE, &inlen,
		s, LZMA_PROPS_SIZE);
	
	*error = res;
	return res == SZ_OK ? outlen : -1;
}

Lines 1-40 Link Here

(-)squashfs-tools/Makefile (-16 / +52 lines)
		1	#
		2	# Building LZMA support
		3	# Download LZMA sdk (4.65 used in development, other versions may work),
		4	# set LZMA_DIR to unpacked source, and uncomment next line
		5	LZMA_SUPPORT = 1
		6	LZMA_DIR = ../../
		7
		8	#Compression default.
		9	COMP_DEFAULT = gzip
		10
		11	INCLUDEDIR = -I.
1	INSTALL_DIR = /usr/local/bin	12	INSTALL_DIR = /usr/local/bin
2		13
3	INCLUDEDIR = .	14	MKSQUASHFS_OBJS = mksquashfs.o read_fs.o sort.o swap.o pseudo.o compressor.o \
		15	gzip_wrapper.o
		16
		17	UNSQUASHFS_OBJS = unsquashfs.o unsquash-1.o unsquash-2.o unsquash-3.o \
		18	unsquash-4.o swap.o compressor.o gzip_wrapper.o
4		19
5	CFLAGS := -I$(INCLUDEDIR) -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_GNU_SOURCE -O2	20	CFLAGS := $(INCLUDEDIR) -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE \
		21	-D_GNU_SOURCE -DCOMP_DEFAULT=\"$(COMP_DEFAULT)\" -O2 -Wall
6		22
		23	ifdef LZMA_SUPPORT
		24	LZMA_OBJS = $(LZMA_DIR)/C/Alloc.o $(LZMA_DIR)/C/LzFind.o \
		25	$(LZMA_DIR)/C/LzmaDec.o $(LZMA_DIR)/C/LzmaEnc.o $(LZMA_DIR)/C/LzmaLib.o
		26	INCLUDEDIR += -I$(LZMA_DIR)/C
		27	CFLAGS += -DLZMA_SUPPORT -I../../C
		28	MKSQUASHFS_OBJS += lzma_wrapper.o $(LZMA_OBJS)
		29	UNSQUASHFS_OBJS += lzma_wrapper.o $(LZMA_OBJS)
		30	endif
		31
		32	.PHONY: all
7	all: mksquashfs unsquashfs	33	all: mksquashfs unsquashfs
8		34
9	mksquashfs: mksquashfs.o read_fs.o sort.o swap.o pseudo.o	35	mksquashfs: $(MKSQUASHFS_OBJS)
10	$(CC) mksquashfs.o read_fs.o sort.o swap.o pseudo.o -lz -lpthread -lm -o $@	36	$(CC) $(MKSQUASHFS_OBJS) -lz -lpthread -lm -o $@
		37
		38	mksquashfs.o: mksquashfs.c squashfs_fs.h mksquashfs.h global.h sort.h \
		39	squashfs_swap.h
11		40
12	mksquashfs.o: mksquashfs.c squashfs_fs.h mksquashfs.h global.h sort.h squashfs_swap.h Makefile	41	read_fs.o: read_fs.c squashfs_fs.h read_fs.h global.h squashfs_swap.h
13		42
14	read_fs.o: read_fs.c squashfs_fs.h read_fs.h global.h squashfs_swap.h Makefile	43	sort.o: sort.c squashfs_fs.h global.h sort.h
15		44
16	sort.o: sort.c squashfs_fs.h global.h sort.h Makefile	45	swap.o: swap.c
17		46
18	swap.o: swap.c Makefile	47	pseudo.o: pseudo.c pseudo.h
19		48
20	pseudo.o: pseudo.c pseudo.h Makefile	49	compressor.o: compressor.c compressor.h
21		50
22	unsquashfs: unsquashfs.o unsquash-1.o unsquash-2.o unsquash-3.o unsquash-4.o swap.o	51	unsquashfs: $(UNSQUASHFS_OBJS)
23	$(CC) unsquashfs.o unsquash-1.o unsquash-2.o unsquash-3.o unsquash-4.o swap.o -lz -lpthread -lm -o $@	52	$(CC) $(UNSQUASHFS_OBJS) -lz -lpthread -lm -o $@
24		53
25	unsquashfs.o: unsquashfs.h unsquashfs.c squashfs_fs.h squashfs_swap.h squashfs_compat.h global.h Makefile	54	unsquashfs.o: unsquashfs.h unsquashfs.c squashfs_fs.h squashfs_swap.h \
		55	squashfs_compat.h global.h
26		56
27	unsquash-1.o: unsquashfs.h unsquash-1.c squashfs_fs.h squashfs_compat.h global.h Makefile	57	unsquash-1.o: unsquashfs.h unsquash-1.c squashfs_fs.h squashfs_compat.h \
		58	global.h
28		59
29	unsquash-2.o: unsquashfs.h unsquash-2.c unsquashfs.h squashfs_fs.h squashfs_compat.h global.h Makefile	60	unsquash-2.o: unsquashfs.h unsquash-2.c unsquashfs.h squashfs_fs.h \
		61	squashfs_compat.h global.h
30		62
31	unsquash-3.o: unsquashfs.h unsquash-3.c squashfs_fs.h squashfs_compat.h global.h Makefile	63	unsquash-3.o: unsquashfs.h unsquash-3.c squashfs_fs.h squashfs_compat.h \
		64	global.h
32		65
33	unsquash-4.o: unsquashfs.h unsquash-4.c squashfs_fs.h squashfs_swap.h global.h Makefile	66	unsquash-4.o: unsquashfs.h unsquash-4.c squashfs_fs.h squashfs_swap.h \
		67	global.h
34		68
		69	.PHONY: clean
35	clean:	70	clean:
36	-rm -f *.o mksquashfs unsquashfs	71	-rm -f *.o mksquashfs unsquashfs
37		72
		73	.PHONY: install
38	install: mksquashfs unsquashfs	74	install: mksquashfs unsquashfs
39	mkdir -p $(INSTALL_DIR)	75	mkdir -p $(INSTALL_DIR)
40	cp mksquashfs $(INSTALL_DIR)	76	cp mksquashfs $(INSTALL_DIR)




#include <errno.h>
#include <dirent.h>
#include <string.h>
#include <zlib.h>
#include <stdlib.h>
#include <signal.h>
#include <setjmp.h>

#include <math.h>
#include <regex.h>
#include <fnmatch.h>
#include <sys/wait.h>

#ifndef linux
#define __BYTE_ORDER BYTE_ORDER

#include "global.h"
#include "sort.h"
#include "pseudo.h"
#include "compressor.h"

#ifdef SQUASHFS_TRACE
#define TRACE(s, args...)	do { \

/* list of root directory entries read from original filesystem */
int old_root_entries = 0;
struct old_root_entry_info {
	char			*name;
	struct inode_info	inode;
	int			type;
	int			inode_number;
};
struct old_root_entry_info *old_root_entry;


int reader_buffer_size;
int fragment_buffer_size;

/* compression operations structure */
static struct compressor *comp;
char *comp_name = COMP_DEFAULT;

char *read_from_disk(long long start, unsigned int avail_bytes);
void add_old_root_entry(char *name, squashfs_inode inode, int inode_number,
	int type);
extern struct compressor  *read_super(int fd, squashfs_super_block *sBlk,
	char *source);
extern long long read_filesystem(char *root_name, int fd,
	squashfs_super_block *sBlk, char **cinode_table, char **data_cache,
	char **cdirectory_table, char **directory_data_cache,

}


int mangle2(void **strm, char *d, char *s, int size,
	int block_size, int uncompressed, int data_block)
{
	int error, c_byte = 0;
	unsigned int res;
	z_stream *stream = *strm;

	if(uncompressed)
		goto notcompressed;

	if(stream == NULL) {
		if((stream = *strm = malloc(sizeof(z_stream))) == NULL)
			BAD_ERROR("mangle::compress failed, not enough "
				"memory\n");

		stream->zalloc = Z_NULL;
		stream->zfree = Z_NULL;
		stream->opaque = 0;

		if((res = deflateInit(stream, 9)) != Z_OK) {
			if(res == Z_MEM_ERROR)
				BAD_ERROR("zlib::compress failed, not enough "
					"memory\n");
			else if(res == Z_STREAM_ERROR)
				BAD_ERROR("zlib::compress failed, not a valid "
					"compression level\n");
			else if(res == Z_VERSION_ERROR)
				BAD_ERROR("zlib::compress failed, incorrect "
					"zlib version\n");
			else
				BAD_ERROR("zlib::compress failed, unknown "
					"error %d\n", res);
		}
	} else if((res = deflateReset(stream)) != Z_OK) {
		if(res == Z_STREAM_ERROR)
			BAD_ERROR("zlib::compress failed, stream state "
				"inconsistent\n");
		else
			BAD_ERROR("zlib::compress failed, unknown error %d\n",
				res);
	}

	if(!uncompressed) {
		c_byte = comp->compress(strm, d, s, size, block_size, &error);
		if(c_byte == -1)
			BAD_ERROR("mangle2:: %s compress failed with error "
				"code %d\n", comp->name, error);
	res = deflate(stream, Z_FINISH);
	if(res != Z_STREAM_END && res != Z_OK) {
		if(res == Z_STREAM_ERROR)
			BAD_ERROR("zlib::compress failed, stream state "
				"inconsistent\n");
		else if(res == Z_BUF_ERROR)
			BAD_ERROR("zlib::compress failed, no progress possible"
				"\n");
		else
			BAD_ERROR("zlib::compress failed, unknown error %d\n",
				res);
	}

	if(c_byte == 0 || c_byte >= size) {

	if(res != Z_STREAM_END || c_byte >= size) {
notcompressed:
		memcpy(d, s, size);
		return size | (data_block ? SQUASHFS_COMPRESSED_BIT_BLOCK :
			SQUASHFS_COMPRESSED_BIT);
	}

	return c_byte;
}


int mangle(char *d, char *s, int size, int block_size,
	int uncompressed, int data_block)
{
	static void *stream = NULL;

	return mangle2(&stream, d, s, size, block_size, uncompressed,
		data_block);

	pthread_mutex_unlock(&fragment_mutex);

	if(SQUASHFS_COMPRESSED_BLOCK(disk_fragment->size)) {
		int error, res;
		unsigned long bytes = block_size;
		char *data;

		if(compressed_buffer)

		else
			data = read_from_disk(start_block, size);

		res = comp->uncompress(buffer->data, data, size, block_size,
			&error);
		if(res == -1)
			BAD_ERROR("%s uncompress failed with error code %d\n",
				comp->name, error);
					"memory\n");
			else if(res == Z_BUF_ERROR)
				BAD_ERROR("zlib::uncompress failed, not enough "
					"room in output buffer\n");
			else
				BAD_ERROR("zlib::uncompress failed,"
					"  unknown error %d\n", res);
		}
	} else if(compressed_buffer)
		memcpy(buffer->data, compressed_buffer->data, size);
	else

		entry->buffer->block = bytes;
		bytes += compressed_size;
		fragments_outstanding --;
		pthread_mutex_unlock(&fragment_mutex);
		queue_put(to_writer, entry->buffer);
		pthread_mutex_lock(&fragment_mutex);
		TRACE("fragment_locked writing fragment %d, compressed size %d"
			"\n", entry->fragment, compressed_size);
		free(entry);

	pthread_mutex_lock(&fragment_mutex);
	insert_fragment_list(&frag_locked_list, entry);
	pthread_mutex_unlock(&fragment_mutex);

	return TRUE;
}



	unsigned short c_byte;
	char cbuffer[(SQUASHFS_METADATA_SIZE << 2) + 2];
	
#ifdef SQUASHFS_TRACE
	long long obytes = bytes;
#endif

	for(i = 0; i < meta_blocks; i++) {
		int avail_bytes = length > SQUASHFS_METADATA_SIZE ?

}


static int seq = 0;
void reader_read_process(struct dir_ent *dir_ent)
{
	struct file_buffer *prev_buffer = NULL, *file_buffer;
	int status, res, byte, count = 0;
	int file = get_pseudo_file(dir_ent->inode->pseudo_id)->fd;
	int child = get_pseudo_file(dir_ent->inode->pseudo_id)->child;
	long long bytes = 0;

	while(1) {
		file_buffer = cache_get(reader_buffer, 0, 0);
		file_buffer->sequence = seq ++;

		byte = read_bytes(file, file_buffer->data, block_size);
		if(byte == -1)
			goto read_err;

		file_buffer->size = byte;
		file_buffer->file_size = -1;
		file_buffer->block = count ++;
		file_buffer->error = FALSE;
		file_buffer->fragment = FALSE;
		bytes += byte;

		if(byte == 0)
			break;

		/*
		 * Update estimated_uncompressed block count.  This is done
		 * on every block rather than waiting for all blocks to be
		 * read incase write_file_process() is running in parallel
		 * with this.  Otherwise cur uncompressed block count may
		 * get ahead of the total uncompressed block count.
		 */ 
		estimated_uncompressed ++;

		if(prev_buffer)
			queue_put(from_reader, prev_buffer);
		prev_buffer = file_buffer;
	}

	/*
 	 * Update inode file size now that the size of the dynamic pseudo file
	 * is known.  This is needed for the -info option.
	 */
	dir_ent->inode->buf.st_size = bytes;

	res = waitpid(child, &status, 0);
	if(res == -1 || !WIFEXITED(status) || WEXITSTATUS(status) != 0)
		goto read_err;

	if(prev_buffer == NULL)
		prev_buffer = file_buffer;
	else {
		cache_block_put(file_buffer);
		seq --;
	}
	prev_buffer->file_size = bytes;
	prev_buffer->fragment = !no_fragments &&
		(count == 2 || always_use_fragments) && (byte < block_size);
	queue_put(from_reader, prev_buffer);

	return;

read_err:
	if(prev_buffer) {
		cache_block_put(file_buffer);
		seq --;
		file_buffer = prev_buffer;
	}
	file_buffer->error = TRUE;
	queue_put(from_deflate, file_buffer);
}


void reader_read_file(struct dir_ent *dir_ent)
{
	struct stat *buf = &dir_ent->inode->buf, buf2;
	struct file_buffer *file_buffer;
	static int index = 0;
	int blocks, byte, count, expected, file, frag_block;
	long long bytes, read_size;


		if(file_buffer)
			queue_put(from_reader, file_buffer);
		file_buffer = cache_get(reader_buffer, 0, 0);
		file_buffer->sequence = seq ++;

		byte = file_buffer->size = read_bytes(file, file_buffer->data,
			block_size);


read_err:
	file_buffer = cache_get(reader_buffer, 0, 0);
	file_buffer->sequence = seq ++;
read_err2:
	file_buffer->error = TRUE;
	queue_put(from_deflate, file_buffer);

	for(i = 0; i < dir->count; i++) {
		struct dir_ent *dir_ent = dir->list[i];
		struct stat *buf = &dir_ent->inode->buf;
		if(dir_ent->inode->root_entry)
			continue;

		if(dir_ent->inode->pseudo_file) {
			reader_read_process(dir_ent);
			continue;
		}

		switch(buf->st_mode & S_IFMT) {
			case S_IFREG:
				reader_read_file(dir_ent);


void *deflator(void *arg)
{
	void *stream = NULL;
	int oldstate;

	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate);


void *frag_deflator(void *arg)
{
	void *stream = NULL;
	int oldstate;

	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate);

			write_buffer->block = bytes;
			bytes += compressed_size;
			fragments_outstanding --;
			pthread_mutex_unlock(&fragment_mutex);
			queue_put(to_writer, write_buffer);
			pthread_mutex_unlock(&fragment_mutex);
			TRACE("Writing fragment %lld, uncompressed size %d, "
				"compressed size %d\n", file_buffer->block,
				file_buffer->size, compressed_size);

}


int write_file_process(squashfs_inode *inode, struct dir_ent *dir_ent,
	struct file_buffer *read_buffer, int *duplicate_file)
{
	long long read_size, file_bytes, start;
	struct fragment *fragment;
	unsigned int *block_list = NULL;
	int block = 0, status;
	long long sparse = 0;
	struct file_buffer *fragment_buffer = NULL;

	*duplicate_file = FALSE;

	lock_fragments();

	file_bytes = 0;
	start = bytes;
	while (1) {
		read_size = read_buffer->file_size;
		if(read_buffer->fragment && read_buffer->c_byte)
			fragment_buffer = read_buffer;
		else {
			block_list = realloc(block_list, (block + 1) *
				sizeof(unsigned int));
			if(block_list == NULL)
				BAD_ERROR("Out of memory allocating block_list"
					"\n");
			block_list[block ++] = read_buffer->c_byte;
			if(read_buffer->c_byte) {
				read_buffer->block = bytes;
				bytes += read_buffer->size;
				cache_rehash(read_buffer, read_buffer->block);
				file_bytes += read_buffer->size;
				queue_put(to_writer, read_buffer);
			} else {
				sparse += read_buffer->size;
				cache_block_put(read_buffer);
			}
		}
		inc_progress_bar();

		if(read_size != -1)
			break;

		read_buffer = get_file_buffer(from_deflate);
		if(read_buffer->error)
			goto read_err;
	}

	unlock_fragments();
	fragment = get_and_fill_fragment(fragment_buffer);
	cache_block_put(fragment_buffer);

	if(duplicate_checking)
		add_non_dup(read_size, file_bytes, block_list, start, fragment,
			0, 0, FALSE);
	file_count ++;
	total_bytes += read_size;

	if(read_size < (1LL << 32) && start < (1LL << 32) && sparse == 0)
		create_inode(inode, dir_ent, SQUASHFS_FILE_TYPE, read_size,
			start, block, block_list, fragment, NULL, 0);
	else
		create_inode(inode, dir_ent, SQUASHFS_LREG_TYPE, read_size,
			start, block, block_list, fragment, NULL, sparse);

	if(duplicate_checking == FALSE)
		free(block_list);

	return 0;

read_err:
	cur_uncompressed -= block;
	status = read_buffer->error;
	bytes = start;
	if(!block_device) {
		int res;

		queue_put(to_writer, NULL);
		if(queue_get(from_writer) != 0)
			EXIT_MKSQUASHFS();
		res = ftruncate(fd, bytes);
		if(res != 0)
			BAD_ERROR("Failed to truncate dest file because %s\n",
				strerror(errno));
	}
	unlock_fragments();
	free(block_list);
	cache_block_put(read_buffer);
	return status;
}


int write_file_blocks(squashfs_inode *inode, struct dir_ent *dir_ent,
	long long read_size, struct file_buffer *read_buffer,
	int *duplicate_file)

	
	read_size = read_buffer->file_size;

	if(read_size == -1)
		status = write_file_process(inode, dir_ent, read_buffer,
			duplicate_file);
	else if(read_size == 0) {
		write_file_empty(inode, dir_ent, duplicate_file);
		cache_block_put(read_buffer);
	} else if(read_buffer->fragment && read_buffer->c_byte)


	memcpy(&inode->buf, buf, sizeof(struct stat));
	inode->read = FALSE;
	inode->root_entry = FALSE;
	inode->pseudo_file = FALSE;
	inode->inode = SQUASHFS_INVALID_BLK;
	inode->nlink = 1;




inline void add_dir_entry(char *name, char *pathname, struct dir_info *sub_dir,
	struct inode_info *inode_info, struct dir_info *dir)
{
	if((dir->count % DIR_ENTRIES) == 0) {
		dir->list = realloc(dir->list, (dir->count + DIR_ENTRIES) *

		NULL;
	dir->list[dir->count]->inode = inode_info;
	dir->list[dir->count]->dir = sub_dir;
	dir->list[dir->count++]->our_dir = dir;
	dir->list[dir->count++]->data = data;
	dir->byte_count += strlen(name) + sizeof(squashfs_dir_entry);
}



	if(dir->count < old_root_entries)
		for(i = 0; i < old_root_entries; i++) {
			if(old_root_entry[i].inode.type == SQUASHFS_DIR_TYPE)
				dir->directory_count ++;
			add_dir_entry(old_root_entry[i].name, "", NULL,
				&old_root_entry[i].inode, dir);
		}

	while(index < source) {


	if(dir->count < old_root_entries)
		for(i = 0; i < old_root_entries; i++) {
			if(old_root_entry[i].inode.type == SQUASHFS_DIR_TYPE)
				dir->directory_count ++;
			add_dir_entry(old_root_entry[i].name, "", NULL,
				&old_root_entry[i].inode, dir);
		}

	if((d_name = readdir(dir->linuxdir)) != NULL) {

	int current_count;

	while((current_count = dir_info->current_count++) < dir_info->count)
		if(dir_info->list[current_count]->inode->root_entry)
			continue;
		else 
			return dir_info->list[current_count];

	int current_count;

	while((current_count = dir_info->current_count++) < dir_info->count)
		if(dir_info->list[current_count]->inode->root_entry)
			add_dir(dir_info->list[current_count]->inode->inode,
				dir_info->list[current_count]->inode->inode_number,
				dir_info->list[current_count]->name,
				dir_info->list[current_count]->inode->type, dir);
		else 
			return dir_info->list[current_count];
	return NULL;	

	dir_ent->name = dir_ent->pathname = strdup(pathname);
	dir_ent->dir = dir_info;
	dir_ent->our_dir = NULL;
	dir_ent->data = NULL;
	dir_info->dir_ent = dir_ent;

	if(sorted)

			sub_dir = NULL;

		add_dir_entry(dir_name, filename, sub_dir, lookup_inode(&buf),
			dir);
	}

	scan1_freedir(dir);

	struct dir_ent *dir_ent;
	struct pseudo_entry *pseudo_ent;
	struct stat buf;
	static int pseudo_ino = 1;
	
	if(dir == NULL && (dir = scan1_opendir("")) == NULL)
		return NULL;


	while((pseudo_ent = pseudo_readdir(pseudo)) != NULL) {
		dir_ent = scan2_lookup(dir, pseudo_ent->name);
		if(pseudo_ent->dev->type == 's') {
			struct stat *buf;
			if(dir_ent == NULL) {
				ERROR("Pseudo set file \"%s\" does not exist "
					"in source filesystem.  Ignoring\n",
					pseudo_ent->pathname);
				continue;
			}
			if(dir_ent->inode->root_entry) {
				ERROR("Pseudo set file \"%s\" is a pre-existing"
					" file in the filesystem being appended"
					"  to.  It cannot be modified. "
					"Ignoring!\n", pseudo_ent->pathname);
				continue;
			}
			buf = &dir_ent->inode->buf;
			buf->st_mode = (buf->st_mode & S_IFMT) |
				pseudo_ent->dev->mode;
			buf->st_uid = pseudo_ent->dev->uid;
			buf->st_gid = pseudo_ent->dev->gid;
			continue;
		}

		if(dir_ent) {
			ERROR("Pseudo file \"%s\" exists in source filesystem "
				"\"%s\"\n", pseudo_ent->pathname,

		buf.st_mtime = time(NULL);
		buf.st_ino = pseudo_ino ++;

		if(pseudo_ent->dev->type == 'f') {
#ifdef USE_TMP_FILE
			struct stat buf2;
			int res = stat(pseudo_ent->dev->filename, &buf2);
			if(res == -1) {
				ERROR("Stat on pseudo file \"%s\" failed, "
					"skipping...", pseudo_ent->pathname);
				continue;
			}
			buf.st_size = buf2.st_size;
			add_dir_entry(pseudo_ent->name,
				pseudo_ent->dev->filename, sub_dir,
				lookup_inode(&buf), dir);
#else
			struct inode_info *inode = lookup_inode(&buf);
			inode->pseudo_id = pseudo_ent->dev->pseudo_id;
			inode->pseudo_file = TRUE;		
			add_dir_entry(pseudo_ent->name, pseudo_ent->pathname,
				sub_dir, inode, dir);
#endif
		} else
			add_dir_entry(pseudo_ent->name, pseudo_ent->pathname,
				sub_dir, lookup_inode(&buf), dir);
	}

	scan2_freedir(dir);

						&duplicate_file);
					INFO("file %s, uncompressed size %lld "
						"bytes %s\n", filename,
						(long long) buf->st_size,
						duplicate_file ?  "DUPLICATE" :
						 "");
					break;

				case S_IFDIR:

						INFO("file %s, uncompressed "
							"size %lld bytes LINK"
							"\n", filename,
							(long long)
							buf->st_size);
					break;
				case SQUASHFS_SYMLINK_TYPE:

		BAD_ERROR("Out of memory in old root directory entries "
			"reallocation\n");

	old_root_entry[old_root_entries].name = strdup(name);
	old_root_entry[old_root_entries].inode.inode = inode;
	old_root_entry[old_root_entries].inode.inode_number = inode_number;
	old_root_entry[old_root_entries].inode.type = type;
	old_root_entry[old_root_entries++].inode.root_entry = TRUE;
}



	source_path = argv + 1;
	source = i - 2;
	for(; i < argc; i++) {
		if(strcmp(argv[i], "-comp") == 0) {
			if(++i == argc) {
				ERROR("%s: -comp missing compression type\n",
					argv[0]);
				exit(1);
			}
			comp_name = argv[i];
		} else if(strcmp(argv[i], "-pf") == 0) {
			if(++i == argc) {
				ERROR("%s: -pf missing filename\n", argv[0]);
				exit(1);
			}
			if(read_pseudo_file(&pseudo, argv[i]) == FALSE)
				exit(1);
		} else if(strcmp(argv[i], "-p") == 0) {
			if(++i == argc) {
				ERROR("%s: -p missing pseudo file definition\n",
					argv[0]);
				exit(1);
			}
			if(read_pseudo_def(&pseudo, argv[i]) == FALSE)
				ERROR("Failed to parse pseudo definition\n");
				exit(1);
			}
		} else if(strcmp(argv[i], "-recover") == 0) {
			if(++i == argc) {
				ERROR("%s: -recover missing recovery file\n",

printOptions:
			ERROR("SYNTAX:%s source1 source2 ...  dest [options] "
				"[-e list of exclude\ndirs/files]\n", argv[0]);
			ERROR("\nFilesystem build options:\n");
			ERROR("-comp <comp>\t\tselect <comp> compression\n");
			ERROR("\t\t\tCompressors available:\n");
			display_compressors("\t\t\t", COMP_DEFAULT);
				"using recovery file <name>\n");
			ERROR("-no-recovery\t\tdon't generate a recovery "
				"file\n");
			ERROR("-info\t\t\tprint files written to filesystem\n");
			ERROR("-no-exports\t\tdon't make the filesystem "
				"exportable via NFS\n");
			ERROR("-no-progress\t\tdon't display the progress "
				"bar\n");
			ERROR("-no-sparse\t\tdon't detect sparse files\n");
			ERROR("-b <block_size>\t\tset data block to "
				"<block_size>.  Default %d bytes\n",
				SQUASHFS_FILE_SIZE);
			ERROR("-no-exports\t\tdon't make the filesystem "
				"exportable via NFS\n");
			ERROR("-no-sparse\t\tdon't detect sparse files\n");
			ERROR("-read-queue <size>\tSet input queue to <size> "
				"Mbytes.  Default %d Mbytes\n",
				READER_BUFFER_DEFAULT);
			ERROR("-write-queue <size>\tSet output queue to <size> "
				"Mbytes.  Default %d Mbytes\n",
				WRITER_BUFFER_DEFAULT);
			ERROR("-fragment-queue <size>\tSet fagment queue to "
				"<size> Mbytes.  Default %d Mbytes\n",
				FRAGMENT_BUFFER_DEFAULT);
			ERROR("-noI\t\t\tdo not compress inode table\n");
			ERROR("-noD\t\t\tdo not compress data blocks\n");
			ERROR("-noF\t\t\tdo not compress fragment blocks\n");

				"files larger than block size\n");
			ERROR("-no-duplicates\t\tdo not perform duplicate "
				"checking\n");
			ERROR("-all-root\t\tmake all files owned by root\n");
			ERROR("-force-uid uid\t\tset all file uids to uid\n");
			ERROR("-force-gid gid\t\tset all file gids to gid\n");
			ERROR("-nopad\t\t\tdo not pad filesystem to a multiple "
				"of 4K\n");
			ERROR("-keep-as-directory\tif one source directory is "
				"specified, create a root\n");
			ERROR("\t\t\tdirectory containing that directory, "
				"rather than the\n");
			ERROR("\t\t\tcontents of the directory\n");
			ERROR("\nFilesystem filter options:\n");
			ERROR("-p <pseudo-definition>\tAdd pseudo file definition\n");
			ERROR("-pf <pseudo-file>\tAdd list of pseudo file definitions\n");
			ERROR("-sort <sort_file>\tsort files according to "
				"priorities in <sort_file>.  One\n");
			ERROR("\t\t\tfile or dir with priority per line.  "
				"Priority -32768 to\n");
			ERROR("\t\t\t32767, default priority 0\n");
			ERROR("-ef <exclude_file>\tlist of exclude dirs/files."
				"  One per line\n");
			ERROR("-wildcards\t\tAllow extended shell wildcards "
				"(globbing) to be used in\n\t\t\texclude "
				"dirs/files\n");
			ERROR("-regex\t\t\tAllow POSIX regular expressions to "
				"be used in exclude\n\t\t\tdirs/files\n");
			ERROR("\nFilesystem append options:\n");
			ERROR("-noappend\t\tdo not append to existing "
				"filesystem\n");
			ERROR("-root-becomes <name>\twhen appending source "
				"files/directories, make the\n");
			ERROR("\t\t\toriginal root become a subdirectory in "

			ERROR("\t\t\tcalled <name>, rather than adding the new "
				"source items\n");
			ERROR("\t\t\tto the original root\n");
			ERROR("\nMksquashfs runtime options:\n");
			ERROR("-version\t\tprint version, licence and "
				"copyright message\n");
			ERROR("-recover <name>\t\trecover filesystem data "
				"using recovery file <name>\n");
			ERROR("-no-recovery\t\tdon't generate a recovery "
				"file\n");
			ERROR("-info\t\t\tprint files written to filesystem\n");
			ERROR("-no-progress\t\tdon't display the progress "
				"bar\n");
			ERROR("-processors <number>\tUse <number> processors."
				"  By default will use number of\n");
			ERROR("\t\t\tprocessors available\n");
			ERROR("-read-queue <size>\tSet input queue to <size> "
				"Mbytes.  Default %d Mbytes\n",
				READER_BUFFER_DEFAULT);
			ERROR("-write-queue <size>\tSet output queue to <size> "
				"Mbytes.  Default %d Mbytes\n",
				WRITER_BUFFER_DEFAULT);
			ERROR("-fragment-queue <size>\tSet fagment queue to "
				"<size> Mbytes.  Default %d Mbytes\n",
				FRAGMENT_BUFFER_DEFAULT);
			ERROR("\nMiscellaneous options:\n");
			ERROR("-root-owned\t\talternative name for -all-root"
				"\n");
			ERROR("-noInodeCompression\talternative name for -noI"

				"\n");
			ERROR("-noFragmentCompression\talternative name for "
				"-noF\n");
			ERROR("-sort <sort_file>\tsort files according to "
				"priorities in <sort_file>.  One\n");
			ERROR("\t\t\tfile or dir with priority per line.  "
				"Priority -32768 to\n");
			ERROR("\t\t\t32767, default priority 0\n");
			ERROR("-ef <exclude_file>\tlist of exclude dirs/files."
				"  One per line\n");
			ERROR("-wildcards\t\tAllow extended shell wildcards "
				"(globbing) to be used in\n\t\t\texclude "
				"dirs/files\n");
			ERROR("-regex\t\t\tAllow POSIX regular expressions to "
				"be used in exclude\n\t\t\tdirs/files\n");
			ERROR("-p <pseudo-definition>\tAdd pseudo file definition\n");
			ERROR("-pf <pseudo-file>\tAdd list of pseudo file definitions\n");
			exit(1);
		}
	}

			fclose(fd);
		} else if(strcmp(argv[i], "-e") == 0)
			break;
		else if(strcmp(argv[i], "-root-becomes") == 0 ||
				strcmp(argv[i], "-root-becomes") == 0 ||
				strcmp(argv[i], "-sort") == 0 ||
				strcmp(argv[i], "-pf") == 0 ||
				strcmp(argv[i], "-comp") == 0)
			i++;

	if(i != argc) {

			sorted ++;
		} else if(strcmp(argv[i], "-e") == 0)
			break;
		else if(strcmp(argv[i], "-root-becomes") == 0 ||
				strcmp(argv[i], "-root-becomes") == 0 ||
				strcmp(argv[i], "-ef") == 0 ||
				strcmp(argv[i], "-pf") == 0 ||
				strcmp(argv[i], "-comp") == 0)
			i++;

#ifdef SQUASHFS_TRACE

#endif

	if(!delete) {
	        comp = read_super(fd, &sBlk, argv[source + 1]);
	        if(comp == NULL) {
			ERROR("Failed to read existing filesystem - will not "
				"overwrite - ABORTING!\n");
			ERROR("To force Mksquashfs to write to this block "

		always_use_fragments = SQUASHFS_ALWAYS_FRAGMENTS(sBlk.flags);
		duplicate_checking = SQUASHFS_DUPLICATES(sBlk.flags);
		exportable = SQUASHFS_EXPORTABLE(sBlk.flags);
	} else {
		comp = lookup_compressor(comp_name);
		if(!comp->supported) {
			ERROR("FATAL_ERROR: Compressor \"%s\" is not "
				"supported!\n", comp_name);
			ERROR("Compressors available:\n");
			display_compressors("", COMP_DEFAULT);
			EXIT_MKSQUASHFS();
		}
	}

	initialise_threads();

			"size %d\n", SQUASHFS_MAJOR, s_minor, argv[source + 1],
			block_size);
		printf("All -b, -noI, -noD, -noF, no-duplicates, no-fragments, "
			"-always-use-fragments,\n-exportable and -comp options "
			"ignored\n");
		printf("\nIf appending is not wanted, please re-run with "
			"-noappend specified!\n\n");



	sBlk.bytes_used = bytes;

	sBlk.compression = comp->id;
	sBlk.compression = ZLIB_COMPRESSION;

	/* Xattrs are not currently supported */
	sBlk.xattr_table_start = SQUASHFS_INVALID_BLK;


	close(fd);

	delete_pseudo_files();

	if(recovery_file[0] != '\0')
		unlink(recovery_file);


		* sizeof(unsigned short) + guid_count * sizeof(unsigned short) +
		sizeof(squashfs_super_block);

	printf("\n%sSquashfs %d.%d filesystem, %s compressed, data block size"
		" %d\n", exportable ? "Exportable " : "", SQUASHFS_MAJOR,
		SQUASHFS_MINOR, comp->name, block_size);
	printf("\t%s data, %s metadata, %s fragments\n",
		noD ? "uncompressed" : "compressed", noI ?  "uncompressed" :
		"compressed", no_fragments ? "no" : noF ? "uncompressed" :

Lines 30-35 Link Here

(-)squashfs-tools/pseudo.c (-65 / +184 lines)
30	#include <string.h>	30	#include <string.h>
31	#include <stdlib.h>	31	#include <stdlib.h>
32	#include <sys/types.h>	32	#include <sys/types.h>
		33	#include <sys/wait.h>
33		34
34	#include "pseudo.h"	35	#include "pseudo.h"
35		36
Lines 55-60 Link Here
55	#define TRUE 1	56	#define TRUE 1
56	#define FALSE 0	57	#define FALSE 0
57		58
		59	struct pseudo_dev **pseudo_file = NULL;
		60	int pseudo_count = 0;
		61
58	static void dump_pseudo(struct pseudo pseudo, char string)	62	static void dump_pseudo(struct pseudo pseudo, char string)
59	{	63	{
60	int i;	64	int i;
Lines 99-105 struct pseudo *add_pseudo(struct pseudo Link Here
99	char target, char alltarget)	103	char target, char alltarget)
100	{	104	{
101	char targname[1024];	105	char targname[1024];
102	int i, error;	106	int i;
103		107
104	target = get_component(target, targname);	108	target = get_component(target, targname);
105		109
Lines 128-139 struct pseudo *add_pseudo(struct pseudo Link Here
128	if(target[0] == '\0') {	132	if(target[0] == '\0') {
129	/* at leaf pathname component */	133	/* at leaf pathname component */
130	pseudo->name[i].pseudo = NULL;	134	pseudo->name[i].pseudo = NULL;
131	pseudo->name[i].dev = malloc(sizeof(struct pseudo_dev));
132	if(pseudo->name[i].dev == NULL)
133	BAD_ERROR("failed to allocate pseudo file\n");
134	pseudo->name[i].pathname = strdup(alltarget);	135	pseudo->name[i].pathname = strdup(alltarget);
135	memcpy(pseudo->name[i].dev, pseudo_dev,	136	pseudo->name[i].dev = pseudo_dev;
136	sizeof(struct pseudo_dev));
137	} else {	137	} else {
138	/* recurse adding child components */	138	/* recurse adding child components */
139	pseudo->name[i].dev = NULL;	139	pseudo->name[i].dev = NULL;
Lines 169-183 struct pseudo *add_pseudo(struct pseudo Link Here
169	if(target[0] == '\0') {	169	if(target[0] == '\0') {
170	if(pseudo->name[i].dev == NULL &&	170	if(pseudo->name[i].dev == NULL &&
171	pseudo_dev->type == 'd') {	171	pseudo_dev->type == 'd') {
172	pseudo->name[i].dev =
173	malloc(sizeof(struct pseudo_dev));
174	if(pseudo->name[i].dev == NULL)
175	BAD_ERROR("failed to allocate "
176	"pseudo file\n");
177	pseudo->name[i].pathname =	172	pseudo->name[i].pathname =
178	strdup(alltarget);	173	strdup(alltarget);
179	memcpy(pseudo->name[i].dev, pseudo_dev,	174	pseudo->name[i].dev = pseudo_dev;
180	sizeof(struct pseudo_dev));
181	} else	175	} else
182	ERROR("%s already exists as a "	176	ERROR("%s already exists as a "
183	"directory. Ignoring %s!\n",	177	"directory. Ignoring %s!\n",
Lines 229-244 struct pseudo_entry *pseudo_readdir(stru Link Here
229	}	223	}
230		224
231		225
		226	int exec_file(char command, struct pseudo_dev dev)
		227	{
		228	int child, res;
		229	static pid_t pid = -1;
		230	int pipefd[2];
		231	#ifdef USE_TMP_FILE
		232	char filename[1024];
		233	int status;
		234	static int number = 0;
		235	#endif
		236
		237	if(pid == -1)
		238	pid = getpid();
		239
		240	#ifdef USE_TMP_FILE
		241	sprintf(filename, "/tmp/squashfs_pseudo_%d_%d", pid, number ++);
		242	pipefd[1] = open(filename, O_CREAT \| O_TRUNC \| O_RDWR, S_IRWXU);
		243	if(pipefd[1] == -1) {
		244	printf("open failed\n");
		245	return -1;
		246	}
		247	#else
		248	res = pipe(pipefd);
		249	if(res == -1) {
		250	printf("pipe failed\n");
		251	return -1;
		252	}
		253	#endif
		254
		255	child = fork();
		256	if(child == -1) {
		257	printf("fork failed\n");
		258	goto failed;
		259	}
		260
		261	if(child == 0) {
		262	close(STDOUT_FILENO);
		263	res = dup(pipefd[1]);
		264	if(res == -1) {
		265	printf("dup failed\n");
		266	exit(EXIT_FAILURE);
		267	}
		268	execl("/bin/sh", "sh", "-c", command, (char *) NULL);
		269	printf("execl failed\n");
		270	exit(EXIT_FAILURE);
		271	}
		272
		273	#ifdef USE_TMP_FILE
		274	res = waitpid(child, &status, 0);
		275	close(pipefd[1]);
		276	if(res != -1 && WIFEXITED(status) && WEXITSTATUS(status) == 0) {
		277	dev->filename = strdup(filename);
		278	return 0;
		279	}
		280	failed:
		281	unlink(filename);
		282	return -1;
		283	#else
		284	close(pipefd[1]);
		285	dev->fd = pipefd[0];
		286	dev->child = child;
		287	return 0;
		288	failed:
		289	return -1;
290	#endif
291	}
292
293
294	void add_pseudo_file(struct pseudo_dev *dev)
295	{
296	pseudo_file = realloc(pseudo_file, (pseudo_count + 1) *
297	sizeof(struct pseudo_dev *));
298	if(pseudo_file == NULL)
299	BAD_ERROR("Failed to realloc pseudo_file\n");
300
301	dev->pseudo_id = pseudo_count;
302	pseudo_file[pseudo_count ++] = dev;
303	}
304
305
306	void delete_pseudo_files()
307	{
308	#ifdef USE_TMP_FILE
309	int i;
310
311	for(i = 0; i < pseudo_count; i++)
312	unlink(pseudo_file[i]->filename);
313	#endif
314	}
315
316
317	struct pseudo_dev *get_pseudo_file(int pseudo_id)
318	{
319	return pseudo_file[pseudo_id];
320	}
321
322
232	int read_pseudo_def(struct pseudo *pseudo, char def)	323	int read_pseudo_def(struct pseudo *pseudo, char def)
233	{	324	{
234	int n;	325	int n, bytes;
235	unsigned int major = 0, minor = 0, mode;	326	unsigned int major = 0, minor = 0, mode;
236	char filename[2048], type, suid[100], sgid[100], *ptr;	327	char filename[2048], type, suid[100], sgid[100], *ptr;
237	long long uid, gid;	328	long long uid, gid;
238	struct pseudo_dev dev;	329	struct pseudo_dev *dev;
239		330
240	n = sscanf(def, "%s %c %o %s %s %u %u", filename, &type, &mode, suid, sgid,	331	n = sscanf(def, "%s %c %o %s %s %n", filename, &type, &mode, suid,
241	&major, &minor);	332	sgid, &bytes);
242		333
243	if(n < 5) {	334	if(n < 5) {
244	ERROR("Not enough or invalid arguments in pseudo file "	335	ERROR("Not enough or invalid arguments in pseudo file "
Lines 249-255 int read_pseudo_def(struct pseudo **pseu Link Here
249	switch(type) {	340	switch(type) {
250	case 'b':	341	case 'b':
251	case 'c':	342	case 'c':
252	if(n < 7) {	343	n = sscanf(def + bytes, "%u %u", &major, &minor);
		344
		345	if(n < 2) {
253	ERROR("Not enough or invalid arguments in pseudo file "	346	ERROR("Not enough or invalid arguments in pseudo file "
254	"definition\n");	347	"definition\n");
255	goto error;	348	goto error;
Lines 265-311 int read_pseudo_def(struct pseudo **pseu Link Here
265	goto error;	358	goto error;
266	}	359	}
267		360
268	/* fall through */	361	case 'f':
269	case 'd':	362	if(def[bytes] == '\0') {
270	if(mode > 0777) {	363	ERROR("Not enough arguments in pseudo file "
271	ERROR("Mode %o out of range\n", mode);	364	"definition\n");
272	goto error;	365	goto error;
273	}	366	}
274		367	break;
275	uid = strtoll(suid, &ptr, 10);	368	case 'd':
276	if(*ptr == '\0') {	369	case 'm':
277	if(uid < 0 \|\| uid > ((1LL << 32) - 1)) {
278	ERROR("Uid %s out of range\n", suid);
279	goto error;
280	}
281	} else {
282	struct passwd *pwuid = getpwnam(suid);
283	if(pwuid)
284	uid = pwuid->pw_uid;
285	else {
286	ERROR("Uid %s invalid uid or unknown user\n",
287	suid);
288	goto error;
289	}
290	}
291
292	gid = strtoll(sgid, &ptr, 10);
293	if(*ptr == '\0') {
294	if(gid < 0 \|\| gid > ((1LL << 32) - 1)) {
295	ERROR("Gid %s out of range\n", sgid);
296	goto error;
297	}
298	} else {
299	struct group *grgid = getgrnam(sgid);
300	if(grgid)
301	gid = grgid->gr_gid;
302	else {
303	ERROR("Gid %s invalid uid or unknown user\n",
304	sgid);
305	goto error;
306	}
307	}
308
309	break;	370	break;
310	default:	371	default:
311	ERROR("Unsupported type %c\n", type);	372	ERROR("Unsupported type %c\n", type);
Lines 313-318 int read_pseudo_def(struct pseudo **pseu Link Here
313	}	374	}
314		375
315		376
		377	if(mode > 0777) {
		378	ERROR("Mode %o out of range\n", mode);
		379	goto error;
		380	}
		381
		382	uid = strtoll(suid, &ptr, 10);
		383	if(*ptr == '\0') {
		384	if(uid < 0 \|\| uid > ((1LL << 32) - 1)) {
		385	ERROR("Uid %s out of range\n", suid);
		386	goto error;
		387	}
		388	} else {
		389	struct passwd *pwuid = getpwnam(suid);
		390	if(pwuid)
		391	uid = pwuid->pw_uid;
		392	else {
		393	ERROR("Uid %s invalid uid or unknown user\n", suid);
		394	goto error;
		395	}
		396	}
		397
		398	gid = strtoll(sgid, &ptr, 10);
		399	if(*ptr == '\0') {
		400	if(gid < 0 \|\| gid > ((1LL << 32) - 1)) {
		401	ERROR("Gid %s out of range\n", sgid);
		402	goto error;
		403	}
		404	} else {
		405	struct group *grgid = getgrnam(sgid);
		406	if(grgid)
		407	gid = grgid->gr_gid;
		408	else {
		409	ERROR("Gid %s invalid uid or unknown user\n", sgid);
		410	goto error;
		411	}
		412	}
		413
316	switch(type) {	414	switch(type) {
317	case 'b':	415	case 'b':
318	mode \|= S_IFBLK;	416	mode \|= S_IFBLK;
Lines 323-338 int read_pseudo_def(struct pseudo **pseu Link Here
323	case 'd':	421	case 'd':
324	mode \|= S_IFDIR;	422	mode \|= S_IFDIR;
325	break;	423	break;
		424	case 'f':
		425	mode \|= S_IFREG;
		426	break;
326	}	427	}
327		428
328	dev.type = type;	429	dev = malloc(sizeof(struct pseudo_dev));
329	dev.mode = mode;	430	if(dev == NULL)
330	dev.uid = uid;	431	BAD_ERROR("Failed to create pseudo_dev\n");
331	dev.gid = gid;	432
332	dev.major = major;	433	dev->type = type;
333	dev.minor = minor;	434	dev->mode = mode;
		435	dev->uid = uid;
		436	dev->gid = gid;
		437	dev->major = major;
		438	dev->minor = minor;
		439
		440	if(type == 'f') {
		441	int res;
		442
		443	printf("Executing dynamic pseudo file\n");
		444	printf("\t\"%s\"\n", def);
		445	res = exec_file(def + bytes, dev);
		446	if(res == -1) {
		447	ERROR("Failed to execute dynamic pseudo file definition"
		448	" \"%s\"\n", def);
		449	return FALSE;
		450	}
		451	add_pseudo_file(dev);
		452	}
334		453
335	pseudo = add_pseudo(pseudo, &dev, filename, filename);	454	pseudo = add_pseudo(pseudo, dev, filename, filename);
336		455
337	return TRUE;	456	return TRUE;
338		457

Lines 27-32 struct pseudo_dev { Link Here

(-)squashfs-tools/pseudo.h (+8 lines)
27	unsigned int gid;	27	unsigned int gid;
28	unsigned int major;	28	unsigned int major;
29	unsigned int minor;	29	unsigned int minor;
		30	int pseudo_id;
		31	int fd;
		32	int child;
		33	#ifdef USE_TMP_FILE
		34	char *filename;
		35	#endif
30	};	36	};
31		37
32	struct pseudo_entry {	38	struct pseudo_entry {
Lines 46-48 extern int read_pseudo_def(struct pseudo Link Here
46	extern int read_pseudo_file(struct pseudo *, char );	52	extern int read_pseudo_file(struct pseudo *, char );
47	extern struct pseudo pseudo_subdir(char , struct pseudo *);	53	extern struct pseudo pseudo_subdir(char , struct pseudo *);
48	extern struct pseudo_entry pseudo_readdir(struct pseudo );	54	extern struct pseudo_entry pseudo_readdir(struct pseudo );
		55	extern struct pseudo_dev *get_pseudo_file(int);
		56	extern void delete_pseudo_files();

Lines 36-42 extern unsigned int get_guid(unsigned in Link Here

(-)squashfs-tools/read_fs.c (-23 / +46 lines)
36	#include <fcntl.h>	36	#include <fcntl.h>
37	#include <errno.h>	37	#include <errno.h>
38	#include <string.h>	38	#include <string.h>
39	#include <zlib.h>
40	#include <sys/mman.h>	39	#include <sys/mman.h>
41		40
42	#ifndef linux	41	#ifndef linux
Lines 51-56 extern unsigned int get_guid(unsigned in Link Here
51	#include "squashfs_swap.h"	50	#include "squashfs_swap.h"
52	#include "read_fs.h"	51	#include "read_fs.h"
53	#include "global.h"	52	#include "global.h"
		53	#include "compressor.h"
54		54
55	#include <stdlib.h>	55	#include <stdlib.h>
56		56
Lines 66-72 extern unsigned int get_guid(unsigned in Link Here
66	fprintf(stderr, s, ## args); \	66	fprintf(stderr, s, ## args); \
67	} while(0)	67	} while(0)
68		68
69	int read_block(int fd, long long start, long long next, unsigned char block,	69	static struct compressor *comp;
		70
		71	int read_block(int fd, long long start, long long next, void block,
70	squashfs_super_block *sBlk)	72	squashfs_super_block *sBlk)
71	{	73	{
72	unsigned short c_byte;	74	unsigned short c_byte;
Lines 77-108 int read_block(int fd, long long start, Link Here
77		79
78	if(SQUASHFS_COMPRESSED(c_byte)) {	80	if(SQUASHFS_COMPRESSED(c_byte)) {
79	char buffer[SQUASHFS_METADATA_SIZE];	81	char buffer[SQUASHFS_METADATA_SIZE];
80	int res;	82	int error, res;
81	unsigned long bytes = SQUASHFS_METADATA_SIZE;
82		83
83	c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);	84	c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);
84	read_destination(fd, start + offset, c_byte, buffer);	85	read_destination(fd, start + offset, c_byte, buffer);
85		86
86	res = uncompress(block, &bytes, (const unsigned char *) buffer,	87	res = comp->uncompress(block, buffer, c_byte,
87	c_byte);	88	SQUASHFS_METADATA_SIZE, &error);
88	if(res != Z_OK) {	89	if(res == -1) {
89	if(res == Z_MEM_ERROR)	90	ERROR("%s uncompress failed with error code %d\n",
90	ERROR("zlib::uncompress failed, not enough "	91	comp->name, error);
91	"memory\n");
92	else if(res == Z_BUF_ERROR)
93	ERROR("zlib::uncompress failed, not enough "
94	"room in output buffer\n");
95	else
96	ERROR("zlib::uncompress failed, unknown error "
97	"%d\n", res);
98	return 0;	92	return 0;
99	}	93	}
100	if(next)	94	if(next)
101	*next = start + offset + c_byte;	95	*next = start + offset + c_byte;
102	return bytes;	96	return res;
103	} else {	97	} else {
104	c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);	98	c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);
105	read_destination(fd, start + offset, c_byte, (char *) block);	99	read_destination(fd, start + offset, c_byte, block);
106	if(next)	100	if(next)
107	*next = start + offset + c_byte;	101	*next = start + offset + c_byte;
108	return c_byte;	102	return c_byte;
Lines 356-362 failed: Link Here
356	}	350	}
357		351
358		352
359	int read_super(int fd, squashfs_super_block sBlk, char source)	353	struct compressor read_super(int fd, squashfs_super_block sBlk, char *source)
360	{	354	{
361	read_destination(fd, SQUASHFS_START, sizeof(squashfs_super_block),	355	read_destination(fd, SQUASHFS_START, sizeof(squashfs_super_block),
362	(char *) sBlk);	356	(char *) sBlk);
Lines 388-395 int read_super(int fd, squashfs_super_bl Link Here
388	goto failed_mount;	382	goto failed_mount;
389	}	383	}
390		384
		385	/* Check the compression type */
		386	comp = lookup_compressor_id(sBlk->compression);
		387	if(!comp->supported) {
		388	ERROR("Filesystem on %s uses %s compression, this is"
		389	"unsupported by this version\n", source, comp->name);
		390	display_compressors("", "");
		391	goto failed_mount;
		392	}
		393
391	printf("Found a valid %sSQUASHFS superblock on %s.\n",	394	printf("Found a valid %sSQUASHFS superblock on %s.\n",
392	SQUASHFS_EXPORTABLE(sBlk->flags) ? "exportable " : "", source);	395	SQUASHFS_EXPORTABLE(sBlk->flags) ? "exportable " : "", source);
		396	printf("\tCompression used %s\n", comp->name);
393	printf("\tInodes are %scompressed\n",	397	printf("\tInodes are %scompressed\n",
394	SQUASHFS_UNCOMPRESSED_INODES(sBlk->flags) ? "un" : "");	398	SQUASHFS_UNCOMPRESSED_INODES(sBlk->flags) ? "un" : "");
395	printf("\tData is %scompressed\n",	399	printf("\tData is %scompressed\n",
Lines 417-426 int read_super(int fd, squashfs_super_bl Link Here
417	TRACE("sBlk->lookup_table_start %llx\n", sBlk->lookup_table_start);	421	TRACE("sBlk->lookup_table_start %llx\n", sBlk->lookup_table_start);
418	printf("\n");	422	printf("\n");
419		423
420	return TRUE;	424	return comp;
421		425
422	failed_mount:	426	failed_mount:
423	return FALSE;	427	return NULL;
424	}	428	}
425		429
426		430
Lines 514-525 unsigned int *read_id_table(int fd, squa Link Here
514	SQUASHFS_INSWAP_ID_BLOCKS(index, indexes);	518	SQUASHFS_INSWAP_ID_BLOCKS(index, indexes);
515		519
516	for(i = 0; i < indexes; i++) {	520	for(i = 0; i < indexes; i++) {
517	int length;	521	int length = read_block(fd, index[i], NULL,
518	length = read_block(fd, index[i], NULL,
519	((unsigned char *) id_table) +	522	((unsigned char *) id_table) +
520	(i * SQUASHFS_METADATA_SIZE), sBlk);	523	(i * SQUASHFS_METADATA_SIZE), sBlk);
521	TRACE("Read id table block %d, from 0x%llx, length %d\n", i,	524	TRACE("Read id table block %d, from 0x%llx, length %d\n", i,
522	index[i], length);	525	index[i], length);
		526	if(length == 0) {
		527	ERROR("Failed to read id table block %d, from 0x%llx, "
		528	"length %d\n", i, index[i], length);
		529	free(id_table);
		530	return NULL;
		531	}
523	}	532	}
524		533
525	SQUASHFS_INSWAP_INTS(id_table, sBlk->no_ids);	534	SQUASHFS_INSWAP_INTS(id_table, sBlk->no_ids);
Lines 563-568 int read_fragment_table(int fd, squashfs Link Here
563	(i * SQUASHFS_METADATA_SIZE), sBlk);	572	(i * SQUASHFS_METADATA_SIZE), sBlk);
564	TRACE("Read fragment table block %d, from 0x%llx, length %d\n",	573	TRACE("Read fragment table block %d, from 0x%llx, length %d\n",
565	i, fragment_table_index[i], length);	574	i, fragment_table_index[i], length);
		575	if(length == 0) {
		576	ERROR("Failed to read fragment table block %d, from "
		577	"0x%llx, length %d\n", i,
		578	fragment_table_index[i], length);
		579	free(*fragment_table);
		580	return 0;
		581	}
566	}	582	}
567		583
568	for(i = 0; i < sBlk->fragments; i++)	584	for(i = 0; i < sBlk->fragments; i++)
Lines 599-604 int read_inode_lookup_table(int fd, squa Link Here
599	(i * SQUASHFS_METADATA_SIZE), sBlk);	615	(i * SQUASHFS_METADATA_SIZE), sBlk);
600	TRACE("Read inode lookup table block %d, from 0x%llx, length "	616	TRACE("Read inode lookup table block %d, from 0x%llx, length "
601	"%d\n", i, index[i], length);	617	"%d\n", i, index[i], length);
		618	if(length == 0) {
		619	ERROR("Failed to read inode lookup table block %d, "
		620	"from 0x%llx, length %d\n", i, index[i],
		621	length);
		622	free(*inode_lookup_table);
		623	return 0;
		624	}
602	}	625	}
603		626
604	SQUASHFS_INSWAP_LONG_LONGS(*inode_lookup_table, sBlk->inodes);	627	SQUASHFS_INSWAP_LONG_LONGS(*inode_lookup_table, sBlk->inodes);




	while(dir->current_count < dir->count) {
		struct dir_ent *dir_ent = dir->list[dir->current_count++];
		struct stat *buf = &dir_ent->inode->buf;
		if(dir_ent->inode->root_entry)
			continue;

		switch(buf->st_mode & S_IFMT) {

				write_file(&inode, entry->dir, &duplicate_file);
				INFO("file %s, uncompressed size %lld bytes %s"
					"\n", entry->dir->pathname,
					(long long)
					entry->dir->inode->buf.st_size,
					duplicate_file ? "DUPLICATE" : "");
				entry->dir->inode->inode = inode;

			} else
				INFO("file %s, uncompressed size %lld bytes "
					"LINK\n", entry->dir->pathname,
					(long long)
					entry->dir->inode->buf.st_size);
		}
}




	struct inode_info	*inode;
	struct dir_info		*dir;
	struct dir_info		*our_dir;
	struct old_root_entry_info *data;
};

struct inode_info {
	unsigned int		nlink;
	struct stat		buf;
	struct inode_info	*next;
	squashfs_inode		inode;
	unsigned int		type;
	unsigned int		inode_number;
	unsigned int		nlink;
	int			pseudo_id;
	char			type;
	char			read;
	char			root_entry;
	char			pseudo_file;
};

struct priority_entry {

Lines 777-787 typedef union squashfs_inode_header_2 sq Link Here

(-)squashfs-tools/squashfs_compat.h (-5 / +4 lines)
777	#endif	777	#endif
778		778
779	#define _SQUASHFS_SWAP(value, p, pos, tbits, SHIFT) {\	779	#define _SQUASHFS_SWAP(value, p, pos, tbits, SHIFT) {\
780	int bits;\	780	b_pos = pos % 8;\
781	int b_pos = pos % 8;\	781	val = 0;\
782	unsigned long long val = 0;\	782	s = (unsigned char *)p + (pos / 8);\
783	unsigned char s = (unsigned char )p + (pos / 8);\	783	d = ((unsigned char *) &val) + 7;\
784	unsigned char d = ((unsigned char ) &val) + 7;\
785	for(bits = 0; bits < (tbits + b_pos); bits += 8) \	784	for(bits = 0; bits < (tbits + b_pos); bits += 8) \
786	d-- = s++;\	785	d-- = s++;\
787	value = (val >> (SHIFT))/* & ((1 << tbits) - 1)*/;\	786	value = (val >> (SHIFT))/* & ((1 << tbits) - 1)*/;\

Lines 229-234 typedef long long squashfs_block_t; Link Here

(-)squashfs-tools/squashfs_fs.h (+1 lines)
229	typedef long long squashfs_inode_t;	229	typedef long long squashfs_inode_t;
230		230
231	#define ZLIB_COMPRESSION 1	231	#define ZLIB_COMPRESSION 1
		232	#define LZMA_COMPRESSION 2
232		233
233	struct squashfs_super_block {	234	struct squashfs_super_block {
234	unsigned int s_magic;	235	unsigned int s_magic;

Lines 36-42 int read_fragment_table_3() Link Here

(-)squashfs-tools/unsquash-3.c (-1 / +1 lines)
36	sBlk.fragment_table_start);	36	sBlk.fragment_table_start);
37		37
38	if(sBlk.fragments == 0)	38	if(sBlk.fragments == 0)
39	return;	39	return TRUE;
40		40
41	if((fragment_table = malloc(sBlk.fragments *	41	if((fragment_table = malloc(sBlk.fragments *
42	sizeof(squashfs_fragment_entry_3))) == NULL)	42	sizeof(squashfs_fragment_entry_3))) == NULL)

Lines 38-44 int read_fragment_table_4() Link Here

(-)squashfs-tools/unsquash-4.c (-1 / +1 lines)
38	sBlk.fragment_table_start);	38	sBlk.fragment_table_start);
39		39
40	if(sBlk.fragments == 0)	40	if(sBlk.fragments == 0)
41	return;	41	return TRUE;
42		42
43	if((fragment_table = malloc(sBlk.fragments *	43	if((fragment_table = malloc(sBlk.fragments *
44	sizeof(squashfs_fragment_entry))) == NULL)	44	sizeof(squashfs_fragment_entry))) == NULL)

Lines 25-30 Link Here

(-)squashfs-tools/unsquashfs.c (-56 / +54 lines)
25	#include "squashfs_swap.h"	25	#include "squashfs_swap.h"
26	#include "squashfs_compat.h"	26	#include "squashfs_compat.h"
27	#include "read_fs.h"	27	#include "read_fs.h"
		28	#include "compressor.h"
		29
		30	#include <sys/sysinfo.h>
28		31
29	struct cache fragment_cache, data_cache;	32	struct cache fragment_cache, data_cache;
30	struct queue to_reader, to_deflate, to_writer, from_writer;	33	struct queue to_reader, to_deflate, to_writer, from_writer;
Lines 36-41 int processors = -1; Link Here
36		39
37	struct super_block sBlk;	40	struct super_block sBlk;
38	squashfs_operations s_ops;	41	squashfs_operations s_ops;
		42	struct compressor *comp;
39		43
40	int bytes = 0, swap, file_count = 0, dir_count = 0, sym_count = 0,	44	int bytes = 0, swap, file_count = 0, dir_count = 0, sym_count = 0,
41	dev_count = 0, fifo_count = 0;	45	dev_count = 0, fifo_count = 0;
Lines 590-620 int read_block(long long start, long lon Link Here
590	offset = 3;	594	offset = 3;
591	if(SQUASHFS_COMPRESSED(c_byte)) {	595	if(SQUASHFS_COMPRESSED(c_byte)) {
592	char buffer[SQUASHFS_METADATA_SIZE];	596	char buffer[SQUASHFS_METADATA_SIZE];
593	int res;	597	int error, res;
594	unsigned long bytes = SQUASHFS_METADATA_SIZE;
595		598
596	c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);	599	c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);
597	if(read_bytes(start + offset, c_byte, buffer) == FALSE)	600	if(read_bytes(start + offset, c_byte, buffer) == FALSE)
598	goto failed;	601	goto failed;
599		602
600	res = uncompress((unsigned char *) block, &bytes,	603	res = comp->uncompress(block, buffer, c_byte,
601	(const unsigned char *) buffer, c_byte);	604	SQUASHFS_METADATA_SIZE, &error);
602		605
603	if(res != Z_OK) {	606	if(res == -1) {
604	if(res == Z_MEM_ERROR)	607	ERROR("%s uncompress failed with error code %d\n",
605	ERROR("zlib::uncompress failed, not enough "	608	comp->name, error);
606	"memory\n");
607	else if(res == Z_BUF_ERROR)
608	ERROR("zlib::uncompress failed, not enough "
609	"room in output buffer\n");
610	else
611	ERROR("zlib::uncompress failed, unknown error "
612	"%d\n", res);
613	goto failed;	609	goto failed;
614	}	610	}
615	if(next)	611	if(next)
616	*next = start + offset + c_byte;	612	*next = start + offset + c_byte;
617	return bytes;	613	return res;
618	} else {	614	} else {
619	c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);	615	c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);
620	if(read_bytes(start + offset, c_byte, block) == FALSE)	616	if(read_bytes(start + offset, c_byte, block) == FALSE)
Lines 632-667 failed: Link Here
632		628
633	int read_data_block(long long start, unsigned int size, char *block)	629	int read_data_block(long long start, unsigned int size, char *block)
634	{	630	{
635	int res;	631	int error, res;
636	unsigned long bytes = block_size;
637	int c_byte = SQUASHFS_COMPRESSED_SIZE_BLOCK(size);	632	int c_byte = SQUASHFS_COMPRESSED_SIZE_BLOCK(size);
638		633
639	TRACE("read_data_block: block @0x%llx, %d %s bytes\n", start,	634	TRACE("read_data_block: block @0x%llx, %d %s bytes\n", start,
640	SQUASHFS_COMPRESSED_SIZE_BLOCK(c_byte),	635	c_byte, SQUASHFS_COMPRESSED_BLOCK(size) ? "compressed" :
641	SQUASHFS_COMPRESSED_BLOCK(c_byte) ? "compressed" :
642	"uncompressed");	636	"uncompressed");
643		637
644	if(SQUASHFS_COMPRESSED_BLOCK(size)) {	638	if(SQUASHFS_COMPRESSED_BLOCK(size)) {
645	if(read_bytes(start, c_byte, data) == FALSE)	639	if(read_bytes(start, c_byte, data) == FALSE)
646	goto failed;	640	goto failed;
647		641
648	res = uncompress((unsigned char *) block, &bytes,	642	res = comp->uncompress(block, data, c_byte, block_size, &error);
649	(const unsigned char *) data, c_byte);
650		643
651	if(res != Z_OK) {	644	if(res == -1) {
652	if(res == Z_MEM_ERROR)	645	ERROR("%s uncompress failed with error code %d\n",
653	ERROR("zlib::uncompress failed, not enough "	646	comp->name, error);
654	"memory\n");
655	else if(res == Z_BUF_ERROR)
656	ERROR("zlib::uncompress failed, not enough "
657	"room in output buffer\n");
658	else
659	ERROR("zlib::uncompress failed, unknown error "
660	"%d\n", res);
661	goto failed;	647	goto failed;
662	}	648	}
663		649
664	return bytes;	650	return res;
665	} else {	651	} else {
666	if(read_bytes(start, c_byte, block) == FALSE)	652	if(read_bytes(start, c_byte, block) == FALSE)
667	goto failed;	653	goto failed;
Lines 671-677 int read_data_block(long long start, uns Link Here
671		657
672	failed:	658	failed:
673	ERROR("read_data_block: failed to read block @0x%llx, size %d\n", start,	659	ERROR("read_data_block: failed to read block @0x%llx, size %d\n", start,
674	size);	660	c_byte);
675	return FALSE;	661	return FALSE;
676	}	662	}
677		663
Lines 1383-1388 void squashfs_stat(char *source) Link Here
1383	#endif	1369	#endif
1384	printf("Creation or last append time %s", mkfs_str ? mkfs_str :	1370	printf("Creation or last append time %s", mkfs_str ? mkfs_str :
1385	"failed to get time\n");	1371	"failed to get time\n");
		1372	printf("Filesystem size %.2f Kbytes (%.2f Mbytes)\n",
		1373	sBlk.bytes_used / 1024.0, sBlk.bytes_used / (1024.0 * 1024.0));
		1374	if(sBlk.s_major == 4)
		1375	printf("Compression %s\n", comp->name);
		1376	printf("Block size %d\n", sBlk.block_size);
1386	printf("Filesystem is %sexportable via NFS\n",	1377	printf("Filesystem is %sexportable via NFS\n",
1387	SQUASHFS_EXPORTABLE(sBlk.flags) ? "" : "not ");	1378	SQUASHFS_EXPORTABLE(sBlk.flags) ? "" : "not ");
1388		1379
Lines 1409-1417 void squashfs_stat(char *source) Link Here
1409	SQUASHFS_DUPLICATES(sBlk.flags) ? "" : "not ");	1400	SQUASHFS_DUPLICATES(sBlk.flags) ? "" : "not ");
1410	else	1401	else
1411	printf("Duplicates are removed\n");	1402	printf("Duplicates are removed\n");
1412	printf("Filesystem size %.2f Kbytes (%.2f Mbytes)\n",
1413	sBlk.bytes_used / 1024.0, sBlk.bytes_used / (1024.0 * 1024.0));
1414	printf("Block size %d\n", sBlk.block_size);
1415	if(sBlk.s_major > 1)	1403	if(sBlk.s_major > 1)
1416	printf("Number of fragments %d\n", sBlk.fragments);	1404	printf("Number of fragments %d\n", sBlk.fragments);
1417	printf("Number of inodes %d\n", sBlk.inodes);	1405	printf("Number of inodes %d\n", sBlk.inodes);
Lines 1459-1464 int read_super(char *source) Link Here
1459	s_ops.read_inode = read_inode_4;	1447	s_ops.read_inode = read_inode_4;
1460	s_ops.read_uids_guids = read_uids_guids_4;	1448	s_ops.read_uids_guids = read_uids_guids_4;
1461	memcpy(&sBlk, &sBlk_4, sizeof(sBlk_4));	1449	memcpy(&sBlk, &sBlk_4, sizeof(sBlk_4));
		1450
		1451	/*
		1452	* Check the compression type
		1453	*/
		1454	comp = lookup_compressor_id(sBlk.compression);
		1455	if(!comp->supported) {
		1456	ERROR("Filesystem uses %s compression, this is "
		1457	"unsupported by this version\n", comp->name);
		1458	ERROR("Decompressors available:\n");
		1459	display_compressors("", "");
		1460	goto failed_mount;
		1461	}
1462	return TRUE;	1462	return TRUE;
1463	}	1463	}
1464		1464
Lines 1548-1553 int read_super(char *source) Link Here
1548	goto failed_mount;	1548	goto failed_mount;
1549	}	1549	}
1550		1550
		1551	/*
		1552	* 1.x, 2.x and 3.x filesystems use gzip compression. Gzip is always
		1553	* suppported.
		1554	*/
		1555	comp = lookup_compressor("gzip");
1551	return TRUE;	1556	return TRUE;
1552		1557
1553	failed_mount:	1558	failed_mount:
Lines 1707-1738 void deflator(void arg) Link Here
1707		1712
1708	while(1) {	1713	while(1) {
1709	struct cache_entry *entry = queue_get(to_deflate);	1714	struct cache_entry *entry = queue_get(to_deflate);
1710	int res;	1715	int error, res;
1711	unsigned long bytes = block_size;
1712		1716
1713	res = uncompress((unsigned char *) tmp, &bytes,	1717	res = comp->uncompress(tmp, entry->data,
1714	(const unsigned char *) entry->data,	1718	SQUASHFS_COMPRESSED_SIZE_BLOCK(entry->size), block_size,
1715	SQUASHFS_COMPRESSED_SIZE_BLOCK(entry->size));	1719	&error);
1716		1720
1717	if(res != Z_OK) {	1721	if(res == -1)
1718	if(res == Z_MEM_ERROR)	1722	ERROR("%s uncompress failed with error code %d\n",
1719	ERROR("zlib::uncompress failed, not enough"	1723	comp->name, error);
1720	"memory\n");	1724	else
1721	else if(res == Z_BUF_ERROR)	1725	memcpy(entry->data, tmp, res);
1722	ERROR("zlib::uncompress failed, not enough "
1723	"room in output buffer\n");
1724	else
1725	ERROR("zlib::uncompress failed, unknown error "
1726	"%d\n", res);
1727	} else
1728	memcpy(entry->data, tmp, bytes);
1729		1726
1730	/*	1727	/*
1731	* block has been either successfully decompressed, or an error	1728	* block has been either successfully decompressed, or an error
1732	* occurred, clear pending flag, set error appropriately and	1729	* occurred, clear pending flag, set error appropriately and
1733	* wake up any threads waiting on this block	1730	* wake up any threads waiting on this block
1734	*/	1731	*/
1735	cache_block_ready(entry, res != Z_OK);	1732	cache_block_ready(entry, res == -1);
1736	}	1733	}
1737	}	1734	}
1738		1735
Lines 1938-1944 int main(int argc, char *argv[]) Link Here
1938	int fragment_buffer_size = FRAGMENT_BUFFER_DEFAULT;	1935	int fragment_buffer_size = FRAGMENT_BUFFER_DEFAULT;
1939	int data_buffer_size = DATA_BUFFER_DEFAULT;	1936	int data_buffer_size = DATA_BUFFER_DEFAULT;
1940	char *b;	1937	char *b;
1941	struct winsize winsize;
1942		1938
1943	pthread_mutex_init(&screen_mutex, NULL);	1939	pthread_mutex_init(&screen_mutex, NULL);
1944	root_process = geteuid() == 0;	1940	root_process = geteuid() == 0;
Lines 2087-2092 options: Link Here
2087	"regular expressions\n");	2083	"regular expressions\n");
2088	ERROR("\t\t\t\trather than use the default shell "	2084	ERROR("\t\t\t\trather than use the default shell "
2089	"wildcard\n\t\t\t\texpansion (globbing)\n");	2085	"wildcard\n\t\t\t\texpansion (globbing)\n");
		2086	ERROR("\nDecompressors available:\n");
		2087	display_compressors("", "");
2090	}	2088	}
2091	exit(1);	2089	exit(1);
2092	}	2090	}

Lines 31-37 Link Here

(-)squashfs-tools/unsquashfs.h (-1 lines)
31	#include <fcntl.h>	31	#include <fcntl.h>
32	#include <errno.h>	32	#include <errno.h>
33	#include <string.h>	33	#include <string.h>
34	#include <zlib.h>
35	#include <sys/mman.h>	34	#include <sys/mman.h>
36	#include <utime.h>	35	#include <utime.h>
37	#include <pwd.h>	36	#include <pwd.h>

Return to bug 207737

Line 0 Link Here

(-)squashfs-tools/compressor.c (+78 lines)
		1	/*
		2	*
		3	* Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
		4	* Phillip Lougher <phillip@lougher.demon.co.uk>
		5	*
		6	* This program is free software; you can redistribute it and/or
		7	* modify it under the terms of the GNU General Public License
		8	* as published by the Free Software Foundation; either version 2,
		9	* or (at your option) any later version.
		10	*
		11	* This program is distributed in the hope that it will be useful,
		12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		14	* GNU General Public License for more details.
		15	*
		16	* You should have received a copy of the GNU General Public License
		17	* along with this program; if not, write to the Free Software
		18	* Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
		19	*
		20	* compressor.c
		21	*/
		22
		23	#include <stdio.h>
		24	#include <string.h>
		25	#include "compressor.h"
		26	#include "squashfs_fs.h"
		27
		28	extern int gzip_compress(void *, char , char , int, int, int );
		29	extern int gzip_uncompress(char , char , int, int, int *);
		30	extern int lzma_compress(void *, char , char , int, int, int );
		31	extern int lzma_uncompress(char , char , int, int, int *);
		32
		33	struct compressor compressor[] = {
		34	{ gzip_compress, gzip_uncompress, ZLIB_COMPRESSION, "gzip", 1 },
		35	#ifdef LZMA_SUPPORT
		36	{ lzma_compress, lzma_uncompress, LZMA_COMPRESSION, "lzma", 1 },
		37	#else
		38	{ NULL, NULL, LZMA_COMPRESSION, "lzma", 0 },
		39	#endif
		40	{ NULL, NULL , 0, "unknown", 0}
		41	};
		42
		43
		44	struct compressor lookup_compressor(char name)
		45	{
		46	int i;
		47
		48	for(i = 0; compressor[i].id; i++)
		49	if(strcmp(compressor[i].name, name) == 0)
		50	break;
		51
		52	return &compressor[i];
		53	}
		54
		55
		56	struct compressor *lookup_compressor_id(int id)
		57	{
		58	int i;
		59
		60	for(i = 0; compressor[i].id; i++)
		61	if(id == compressor[i].id)
		62	break;
		63
		64	return &compressor[i];
65	}
66
67
68	void display_compressors(char indent, char def_comp)
69	{
70	int i;
71
72	for(i = 0; compressor[i].id; i++)
73	if(compressor[i].supported)
74	fprintf(stderr, "%s\t%s%s\n", indent,
75	compressor[i].name,
76	strcmp(compressor[i].name, def_comp) == 0 ?
77	" (default)" : "");
78	}

Line 0 Link Here

(-)squashfs-tools/compressor.h (+33 lines)
	1	/*
	2	*
	3	* Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
	4	* Phillip Lougher <phillip@lougher.demon.co.uk>
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version 2,
	9	* or (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	19	*
	20	* compressor.h
	21	*/
	22
	23	struct compressor {
	24	int (compress)(void , char , char , int, int, int );
	25	int (uncompress)(char , char , int, int, int );
	26	int id;
	27	char *name;
	28	int supported;
	29	};
	30
	31	extern struct compressor lookup_compressor(char );
	32	extern struct compressor *lookup_compressor_id(int);
	33	extern void display_compressors(char , char );

Line 0 Link Here

(-)squashfs-tools/gzip_wrapper.c (+80 lines)
		1	/*
		2	* Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
		3	* Phillip Lougher <phillip@lougher.demon.co.uk>
		4	*
		5	* This program is free software; you can redistribute it and/or
		6	* modify it under the terms of the GNU General Public License
		7	* as published by the Free Software Foundation; either version 2,
		8	* or (at your option) any later version.
		9	*
		10	* This program is distributed in the hope that it will be useful,
		11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	* GNU General Public License for more details.
		14	*
		15	* You should have received a copy of the GNU General Public License
		16	* along with this program; if not, write to the Free Software
		17	* Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
		18	*
		19	* gzip_wrapper.c
		20	*/
		21
		22	#include <stdlib.h>
		23	#include <zlib.h>
		24
		25	int gzip_compress(void *strm, char d, char *s, int size, int block_size,
		26	int *error)
		27	{
		28	int res = 0;
		29	z_stream stream = strm;
		30
		31	if(stream == NULL) {
		32	if((stream = *strm = malloc(sizeof(z_stream))) == NULL)
		33	goto failed;
		34
		35	stream->zalloc = Z_NULL;
		36	stream->zfree = Z_NULL;
		37	stream->opaque = 0;
		38
		39	if((res = deflateInit(stream, 9)) != Z_OK)
		40	goto failed;
		41	} else if((res = deflateReset(stream)) != Z_OK)
		42	goto failed;
		43
		44	stream->next_in = (unsigned char *) s;
		45	stream->avail_in = size;
		46	stream->next_out = (unsigned char *) d;
		47	stream->avail_out = block_size;
		48
		49	res = deflate(stream, Z_FINISH);
		50	if(res == Z_STREAM_END)
		51	/*
		52	* Success, return the compressed size.
		53	*/
		54	return (int) stream->total_out;
		55	if(res == Z_OK)
		56	/*
		57	* Output buffer overflow. Return out of buffer space
		58	*/
		59	return 0;
		60	failed:
		61	/*
		62	* All other errors return failure, with the compressor
		63	* specific error code in *error
		64	*/
65	*error = res;
66	return -1;
67	}
68
69
70	int gzip_uncompress(char d, char s, int size, int block_size, int *error)
71	{
72	int res;
73	unsigned long bytes = block_size;
74
75	res = uncompress((unsigned char *) d, &bytes,
76	(const unsigned char *) s, size);
77
78	*error = res;
79	return res == Z_OK ? (int) bytes : -1;
80	}

Line 0 Link Here

(-)squashfs-tools/lzma_wrapper.c (+93 lines)
		1	/*
		2	* Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
		3	* Phillip Lougher <phillip@lougher.demon.co.uk>
		4	*
		5	* This program is free software; you can redistribute it and/or
		6	* modify it under the terms of the GNU General Public License
		7	* as published by the Free Software Foundation; either version 2,
		8	* or (at your option) any later version.
		9	*
		10	* This program is distributed in the hope that it will be useful,
		11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		13	* GNU General Public License for more details.
		14	*
		15	* You should have received a copy of the GNU General Public License
		16	* along with this program; if not, write to the Free Software
		17	* Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
		18	*
		19	* lzma_wrapper.c
		20	*/
		21
		22	#include <LzmaLib.h>
		23
		24	#define LZMA_HEADER_SIZE (LZMA_PROPS_SIZE + 8)
		25
		26	int lzma_compress(void *strm, char dest, char *src, int size,int block_size,
		27	int *error)
		28	{
		29	unsigned char d = (unsigned char ) dest, s = (unsigned char ) src;
		30	size_t props_size = LZMA_PROPS_SIZE,
		31	outlen = block_size - LZMA_HEADER_SIZE;
		32	int res;
		33
		34	res = LzmaCompress(d + LZMA_HEADER_SIZE, &outlen, s, size, d,
		35	&props_size, 5, block_size, 3, 0, 2, 32, 1);
		36
		37	if(res == SZ_ERROR_OUTPUT_EOF) {
		38	/*
		39	* Output buffer overflow. Return out of buffer space error
		40	*/
		41	return 0;
		42	}
		43
		44	if(res != SZ_OK) {
		45	/*
		46	* All other errors return failure, with the compressor
		47	* specific error code in *error
		48	*/
		49	*error = res;
		50	return -1;
		51	}
		52
		53	/*
		54	* Fill in the 8 byte little endian uncompressed size field in the
		55	* LZMA header. 8 bytes is excessively large for squashfs but
		56	* this is the standard LZMA header and which is expected by the kernel
		57	* code
		58	*/
		59	d[LZMA_PROPS_SIZE] = size & 255;
		60	d[LZMA_PROPS_SIZE + 1] = (size >> 8) & 255;
		61	d[LZMA_PROPS_SIZE + 2] = (size >> 16) & 255;
		62	d[LZMA_PROPS_SIZE + 3] = (size >> 24) & 255;
		63	d[LZMA_PROPS_SIZE + 4] = 0;
		64	d[LZMA_PROPS_SIZE + 5] = 0;
65	d[LZMA_PROPS_SIZE + 6] = 0;
66	d[LZMA_PROPS_SIZE + 7] = 0;
67
68	/*
69	* Success, return the compressed size. Outlen returned by the LZMA
70	* compressor does not include the LZMA header space
71	*/
72	return outlen + LZMA_HEADER_SIZE;
73	}
74
75
76	int lzma_uncompress(char dest, char src, int size, int block_size,
77	int *error)
78	{
79	unsigned char d = (unsigned char ) dest, s = (unsigned char ) src;
80	size_t outlen, inlen = size - LZMA_HEADER_SIZE;
81	int res;
82
83	outlen = s[LZMA_PROPS_SIZE] \|
84	(s[LZMA_PROPS_SIZE + 1] << 8) \|
85	(s[LZMA_PROPS_SIZE + 2] << 16) \|
86	(s[LZMA_PROPS_SIZE + 3] << 24);
87
88	res = LzmaUncompress(d, &outlen, s + LZMA_HEADER_SIZE, &inlen,
89	s, LZMA_PROPS_SIZE);
90
91	*error = res;
92	return res == SZ_OK ? outlen : -1;
93	}

Lines 198-204 void generate_file_priorities(struct dir Link Here

(-)squashfs-tools/sort.c (-1 / +3 lines)
198	while(dir->current_count < dir->count) {	198	while(dir->current_count < dir->count) {
199	struct dir_ent *dir_ent = dir->list[dir->current_count++];	199	struct dir_ent *dir_ent = dir->list[dir->current_count++];
200	struct stat *buf = &dir_ent->inode->buf;	200	struct stat *buf = &dir_ent->inode->buf;
201	if(dir_ent->data)	201	if(dir_ent->inode->root_entry)
202	continue;	202	continue;
203		203
204	switch(buf->st_mode & S_IFMT) {	204	switch(buf->st_mode & S_IFMT) {
Lines 254-259 void sort_files_and_write(struct dir_inf Link Here
254	write_file(&inode, entry->dir, &duplicate_file);	254	write_file(&inode, entry->dir, &duplicate_file);
255	INFO("file %s, uncompressed size %lld bytes %s"	255	INFO("file %s, uncompressed size %lld bytes %s"
256	"\n", entry->dir->pathname,	256	"\n", entry->dir->pathname,
		257	(long long)
257	entry->dir->inode->buf.st_size,	258	entry->dir->inode->buf.st_size,
258	duplicate_file ? "DUPLICATE" : "");	259	duplicate_file ? "DUPLICATE" : "");
259	entry->dir->inode->inode = inode;	260	entry->dir->inode->inode = inode;
Lines 261-266 void sort_files_and_write(struct dir_inf Link Here
261	} else	262	} else
262	INFO("file %s, uncompressed size %lld bytes "	263	INFO("file %s, uncompressed size %lld bytes "
263	"LINK\n", entry->dir->pathname,	264	"LINK\n", entry->dir->pathname,
		265	(long long)
264	entry->dir->inode->buf.st_size);	266	entry->dir->inode->buf.st_size);
265	}	267	}
266	}	268	}

Lines 42-58 struct dir_ent { Link Here

(-)squashfs-tools/sort.h (-4 / +6 lines)
42	struct inode_info *inode;	42	struct inode_info *inode;
43	struct dir_info *dir;	43	struct dir_info *dir;
44	struct dir_info *our_dir;	44	struct dir_info *our_dir;
45	struct old_root_entry_info *data;
46	};	45	};
47		46
48	struct inode_info {	47	struct inode_info {
49	unsigned int nlink;
50	struct stat buf;	48	struct stat buf;
		49	struct inode_info *next;
51	squashfs_inode inode;	50	squashfs_inode inode;
52	unsigned int type;
53	unsigned int inode_number;	51	unsigned int inode_number;
		52	unsigned int nlink;
		53	int pseudo_id;
		54	char type;
54	char read;	55	char read;
55	struct inode_info *next;	56	char root_entry;
		57	char pseudo_file;
56	};	58	};
57		59
58	struct priority_entry {	60	struct priority_entry {