wok-next rev 8994

Up: squashfs to 4.2.
author Christopher Rogers <slaxemulator@gmail.com>
date Thu Mar 03 06:36:12 2011 +0000 (2011-03-03)
parents e8b87b9efb7d
children 45fab90b3a6a
files squashfs/receipt squashfs/stuff/xz.patch
line diff
     1.1 --- a/squashfs/receipt	Thu Mar 03 06:01:52 2011 +0000
     1.2 +++ b/squashfs/receipt	Thu Mar 03 06:36:12 2011 +0000
     1.3 @@ -1,7 +1,7 @@
     1.4  # SliTaz package receipt.
     1.5  
     1.6  PACKAGE="squashfs"
     1.7 -VERSION="4.1"
     1.8 +VERSION="4.2"
     1.9  CATEGORY="base-system"
    1.10  SHORT_DESC="Linux squashfs userland tools."
    1.11  MAINTAINER="pascal.bellard@slitaz.org"
    1.12 @@ -15,15 +15,13 @@
    1.13  # Rules to configure and make the package.
    1.14  compile_rules()
    1.15  {
    1.16 -	mv ${PACKAGE}${VERSION} $src 2> /dev/null
    1.17  	cd $src
    1.18 -	patch -Np1 -i $stuff/xz.patch
    1.19  	cd $src/squashfs-tools
    1.20 -	#sed -i 's|#XZ_SUPPORT = 1|XZ_SUPPORT = 1|g' Makefile
    1.21 -	mkdir -p ../_pkg/usr/sbin ../_pkg/sbin
    1.22 +	sed -i 's|#XZ_SUPPORT = 1|XZ_SUPPORT = 1|g' Makefile
    1.23 +	mkdir -p $DESTDIR/usr/sbin $DESTDIR/sbin
    1.24  	make || return 1
    1.25 -	cp mksquashfs ../_pkg/usr/sbin
    1.26 -	cp unsquashfs ../_pkg/sbin
    1.27 +	cp -a mksquashfs  $DESTDIR/usr/sbin
    1.28 +	cp -a unsquashfs $DESTDIR/sbin
    1.29  }
    1.30  
    1.31  # Rules to gen a SliTaz package suitable for Tazpkg.
     2.1 --- a/squashfs/stuff/xz.patch	Thu Mar 03 06:01:52 2011 +0000
     2.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.3 @@ -1,1432 +0,0 @@
     2.4 -diff -r 2ab2996036dd squashfs-tools/Makefile
     2.5 ---- a/squashfs-tools/Makefile	Tue Dec 14 12:19:33 2010 +0000
     2.6 -+++ b/squashfs-tools/Makefile	Tue Dec 14 14:18:11 2010 +0000
     2.7 -@@ -20,20 +20,33 @@
     2.8 - 
     2.9 - ########### Building LZMA support #############
    2.10 - #
    2.11 --# Both XZ Utils liblzma  (http://tukaani.org/xz/) and LZMA SDK
    2.12 -+# LZMA1 compression.
    2.13 -+#
    2.14 -+# Both XZ Utils liblzma (http://tukaani.org/xz/) and LZMA SDK
    2.15 - # (http://www.7-zip.org/sdk.html) are supported
    2.16 - #
    2.17 - # To build using XZ Utils liblzma - install the library and uncomment
    2.18 --# the XZ_SUPPORT line below.
    2.19 -+# the LZMA_XZ_SUPPORT line below.
    2.20 - #
    2.21 - # To build using the LZMA SDK (4.65 used in development, other versions may
    2.22 - # work) - download and unpack it, uncomment and set LZMA_DIR to unpacked source,
    2.23 - # and uncomment the LZMA_SUPPORT line below.
    2.24 - #
    2.25 --#XZ_SUPPORT = 1
    2.26 -+LZMA_XZ_SUPPORT = 1
    2.27 - #LZMA_SUPPORT = 1
    2.28 - #LZMA_DIR = ../../../LZMA/lzma465
    2.29 - 
    2.30 -+########### Building XZ support #############
    2.31 -+#
    2.32 -+# LZMA2 compression.
    2.33 -+#
    2.34 -+# XZ Utils liblzma (http://tukaani.org/xz/) is supported
    2.35 -+#
    2.36 -+# To build using XZ Utils liblzma - install the library and uncomment
    2.37 -+# the XZ_SUPPORT line below.
    2.38 -+#
    2.39 -+XZ_SUPPORT = 1
    2.40 -+
    2.41 - 
    2.42 - ############ Building LZO support ##############
    2.43 - #
    2.44 -@@ -109,12 +122,20 @@
    2.45 - COMPRESSORS += lzma
    2.46 - endif
    2.47 - 
    2.48 -+ifdef LZMA_XZ_SUPPORT
    2.49 -+CFLAGS += -DLZMA_SUPPORT
    2.50 -+MKSQUASHFS_OBJS += lzma_xz_wrapper.o
    2.51 -+UNSQUASHFS_OBJS += lzma_xz_wrapper.o
    2.52 -+LIBS += -llzma
    2.53 -+COMPRESSORS += lzma
    2.54 -+endif
    2.55 -+
    2.56 - ifdef XZ_SUPPORT
    2.57 --CFLAGS += -DLZMA_SUPPORT
    2.58 -+CFLAGS += -DXZ_SUPPORT
    2.59 - MKSQUASHFS_OBJS += xz_wrapper.o
    2.60 - UNSQUASHFS_OBJS += xz_wrapper.o
    2.61 - LIBS += -llzma
    2.62 --COMPRESSORS += lzma
    2.63 -+COMPRESSORS += xz
    2.64 - endif
    2.65 - 
    2.66 - ifdef LZO_SUPPORT
    2.67 -@@ -149,11 +170,11 @@
    2.68 - endif
    2.69 - 
    2.70 - #
    2.71 --# Both XZ_SUPPORT and LZMA_SUPPORT cannot be specified
    2.72 -+# Both LZMA_XZ_SUPPORT and LZMA_SUPPORT cannot be specified
    2.73 - #
    2.74 --ifdef XZ_SUPPORT
    2.75 -+ifdef LZMA_XZ_SUPPORT
    2.76 - ifdef LZMA_SUPPORT
    2.77 --$(error "Both XZ_SUPPORT and LZMA_SUPPORT cannot be specified")
    2.78 -+$(error "Both LZMA_XZ_SUPPORT and LZMA_SUPPORT cannot be specified")
    2.79 - endif
    2.80 - endif
    2.81 - 
    2.82 -@@ -161,7 +182,7 @@
    2.83 - # At least one compressor must have been selected
    2.84 - #
    2.85 - ifndef COMPRESSORS
    2.86 --$(error "No compressor selected! Select one or more of GZIP, LZMA, or LZO!")
    2.87 -+$(error "No compressor selected! Select one or more of GZIP, LZMA, XZ or LZO!")
    2.88 - endif
    2.89 - 
    2.90 - #
    2.91 -diff -r 2ab2996036dd squashfs-tools/compressor.c
    2.92 ---- a/squashfs-tools/compressor.c	Tue Dec 14 12:19:33 2010 +0000
    2.93 -+++ b/squashfs-tools/compressor.c	Tue Dec 14 14:18:11 2010 +0000
    2.94 -@@ -25,31 +25,50 @@
    2.95 - #include "compressor.h"
    2.96 - #include "squashfs_fs.h"
    2.97 - 
    2.98 --extern int gzip_compress(void **, char *, char *, int, int, int *);
    2.99 --extern int gzip_uncompress(char *, char *, int, int, int *);
   2.100 --extern int lzma_compress(void **, char *, char *, int, int, int *);
   2.101 --extern int lzma_uncompress(char *, char *, int, int, int *);
   2.102 --extern int lzo_compress(void **, char *, char *, int, int, int *);
   2.103 --extern int lzo_uncompress(char *, char *, int, int, int *);
   2.104 --
   2.105 --struct compressor compressor[] = {
   2.106 --#ifdef GZIP_SUPPORT
   2.107 --	{ gzip_compress, gzip_uncompress, ZLIB_COMPRESSION, "gzip", 1 },
   2.108 -+#ifndef GZIP_SUPPORT
   2.109 -+static struct compressor gzip_comp_ops =  {
   2.110 -+	NULL, NULL, NULL, NULL, NULL, ZLIB_COMPRESSION, "gzip", 0
   2.111 -+};
   2.112 - #else
   2.113 --	{ NULL, NULL, ZLIB_COMPRESSION, "gzip", 0 },
   2.114 --#endif
   2.115 --#ifdef LZMA_SUPPORT
   2.116 --	{ lzma_compress, lzma_uncompress, LZMA_COMPRESSION, "lzma", 1 },
   2.117 --#else
   2.118 --	{ NULL, NULL, LZMA_COMPRESSION, "lzma", 0 },
   2.119 --#endif
   2.120 --#ifdef LZO_SUPPORT
   2.121 --	{ lzo_compress, lzo_uncompress, LZO_COMPRESSION, "lzo", 1 },
   2.122 --#else
   2.123 --	{ NULL, NULL, LZO_COMPRESSION, "lzo", 0 },
   2.124 -+extern struct compressor gzip_comp_ops;
   2.125 - #endif
   2.126 - 
   2.127 --	{ NULL, NULL , 0, "unknown", 0}
   2.128 -+#ifndef LZMA_SUPPORT
   2.129 -+static struct compressor lzma_comp_ops = {
   2.130 -+	NULL, NULL, NULL, NULL, NULL, LZMA_COMPRESSION, "lzma", 0
   2.131 -+};
   2.132 -+#else
   2.133 -+extern struct compressor lzma_comp_ops;
   2.134 -+#endif
   2.135 -+
   2.136 -+#ifndef LZO_SUPPORT
   2.137 -+static struct compressor lzo_comp_ops = {
   2.138 -+	NULL, NULL, NULL, NULL, NULL, LZO_COMPRESSION, "lzo", 0
   2.139 -+};
   2.140 -+#else
   2.141 -+extern struct compressor lzo_comp_ops;
   2.142 -+#endif
   2.143 -+
   2.144 -+#ifndef XZ_SUPPORT
   2.145 -+static struct compressor xz_comp_ops = {
   2.146 -+	NULL, NULL, NULL, NULL, NULL, XZ_COMPRESSION, "xz", 0
   2.147 -+};
   2.148 -+#else
   2.149 -+extern struct compressor xz_comp_ops;
   2.150 -+#endif
   2.151 -+
   2.152 -+
   2.153 -+static struct compressor unknown_comp_ops = {
   2.154 -+	NULL, NULL, NULL , NULL, NULL, 0, "unknown", 0
   2.155 -+};
   2.156 -+
   2.157 -+
   2.158 -+struct compressor *compressor[] = {
   2.159 -+	&gzip_comp_ops,
   2.160 -+	&lzma_comp_ops,
   2.161 -+	&lzo_comp_ops,
   2.162 -+	&xz_comp_ops,
   2.163 -+	&unknown_comp_ops
   2.164 - };
   2.165 - 
   2.166 - 
   2.167 -@@ -57,11 +76,11 @@
   2.168 - {
   2.169 - 	int i;
   2.170 - 
   2.171 --	for(i = 0; compressor[i].id; i++)
   2.172 --		if(strcmp(compressor[i].name, name) == 0)
   2.173 -+	for(i = 0; compressor[i]->id; i++)
   2.174 -+		if(strcmp(compressor[i]->name, name) == 0)
   2.175 - 			break;
   2.176 - 
   2.177 --	return &compressor[i];
   2.178 -+	return compressor[i];
   2.179 - }
   2.180 - 
   2.181 - 
   2.182 -@@ -69,11 +88,11 @@
   2.183 - {
   2.184 - 	int i;
   2.185 - 
   2.186 --	for(i = 0; compressor[i].id; i++)
   2.187 --		if(id == compressor[i].id)
   2.188 -+	for(i = 0; compressor[i]->id; i++)
   2.189 -+		if(id == compressor[i]->id)
   2.190 - 			break;
   2.191 - 
   2.192 --	return &compressor[i];
   2.193 -+	return compressor[i];
   2.194 - }
   2.195 - 
   2.196 - 
   2.197 -@@ -81,10 +100,29 @@
   2.198 - {
   2.199 - 	int i;
   2.200 - 
   2.201 --	for(i = 0; compressor[i].id; i++)
   2.202 --		if(compressor[i].supported)
   2.203 -+	for(i = 0; compressor[i]->id; i++)
   2.204 -+		if(compressor[i]->supported)
   2.205 - 			fprintf(stderr, "%s\t%s%s\n", indent,
   2.206 --				compressor[i].name,
   2.207 --				strcmp(compressor[i].name, def_comp) == 0 ?
   2.208 -+				compressor[i]->name,
   2.209 -+				strcmp(compressor[i]->name, def_comp) == 0 ?
   2.210 - 				" (default)" : "");
   2.211 - }
   2.212 -+
   2.213 -+
   2.214 -+void display_compressor_usage(char *def_comp)
   2.215 -+{
   2.216 -+	int i;
   2.217 -+
   2.218 -+	for(i = 0; compressor[i]->id; i++)
   2.219 -+		if(compressor[i]->supported) {
   2.220 -+			char *str = strcmp(compressor[i]->name, def_comp) == 0 ?
   2.221 -+				" (default)" : "";
   2.222 -+			if(compressor[i]->usage) {
   2.223 -+				fprintf(stderr, "\t%s%s\n",
   2.224 -+					compressor[i]->name, str);
   2.225 -+				compressor[i]->usage();
   2.226 -+			} else
   2.227 -+				fprintf(stderr, "\t%s (no options)%s\n",
   2.228 -+					compressor[i]->name, str);
   2.229 -+		}
   2.230 -+}
   2.231 -diff -r 2ab2996036dd squashfs-tools/compressor.h
   2.232 ---- a/squashfs-tools/compressor.h	Tue Dec 14 12:19:33 2010 +0000
   2.233 -+++ b/squashfs-tools/compressor.h	Tue Dec 14 14:18:11 2010 +0000
   2.234 -@@ -21,8 +21,11 @@
   2.235 -  */
   2.236 - 
   2.237 - struct compressor {
   2.238 --	int (*compress)(void **, char *, char *, int, int, int *);
   2.239 --	int (*uncompress)(char *, char *, int, int, int *);
   2.240 -+	int (*init)(void **, int, int);
   2.241 -+	int (*compress)(void *, void *, void *, int, int, int *);
   2.242 -+	int (*uncompress)(void *, void *, int, int, int *);
   2.243 -+	int (*options)(char **, int);
   2.244 -+	void (*usage)();
   2.245 - 	int id;
   2.246 - 	char *name;
   2.247 - 	int supported;
   2.248 -@@ -31,3 +34,25 @@
   2.249 - extern struct compressor *lookup_compressor(char *);
   2.250 - extern struct compressor *lookup_compressor_id(int);
   2.251 - extern void display_compressors(char *, char *);
   2.252 -+extern void display_compressor_usage(char *);
   2.253 -+
   2.254 -+static inline int compressor_options(struct compressor *comp, char *argv[],
   2.255 -+	int argc)
   2.256 -+{
   2.257 -+	if(comp->options == NULL)
   2.258 -+		return -1;
   2.259 -+
   2.260 -+	return comp->options(argv, argc);
   2.261 -+}
   2.262 -+
   2.263 -+
   2.264 -+static inline int compressor_init(struct compressor *comp, void **stream,
   2.265 -+	int block_size, int flags)
   2.266 -+{
   2.267 -+	if(comp->init == NULL)
   2.268 -+		return 0;
   2.269 -+	return comp->init(stream, block_size, flags);
   2.270 -+}
   2.271 -+
   2.272 -+
   2.273 -+
   2.274 -diff -r 2ab2996036dd squashfs-tools/gzip_wrapper.c
   2.275 ---- a/squashfs-tools/gzip_wrapper.c	Tue Dec 14 12:19:33 2010 +0000
   2.276 -+++ b/squashfs-tools/gzip_wrapper.c	Tue Dec 14 14:18:11 2010 +0000
   2.277 -@@ -22,28 +22,48 @@
   2.278 - #include <stdlib.h>
   2.279 - #include <zlib.h>
   2.280 - 
   2.281 --int gzip_compress(void **strm, char *d, char *s, int size, int block_size,
   2.282 -+#include "squashfs_fs.h"
   2.283 -+#include "compressor.h"
   2.284 -+
   2.285 -+static int gzip_init(void **strm, int block_size, int flags)
   2.286 -+{
   2.287 -+	int res;
   2.288 -+	z_stream *stream;
   2.289 -+
   2.290 -+	stream = *strm = malloc(sizeof(z_stream));
   2.291 -+	if(stream == NULL)
   2.292 -+		goto failed;
   2.293 -+
   2.294 -+	stream->zalloc = Z_NULL;
   2.295 -+	stream->zfree = Z_NULL;
   2.296 -+	stream->opaque = 0;
   2.297 -+
   2.298 -+	res = deflateInit(stream, 9);
   2.299 -+	if(res != Z_OK)
   2.300 -+		goto failed2;
   2.301 -+
   2.302 -+	return 0;
   2.303 -+
   2.304 -+failed2:
   2.305 -+	free(stream);
   2.306 -+failed:
   2.307 -+	return -1;
   2.308 -+}
   2.309 -+
   2.310 -+
   2.311 -+static int gzip_compress(void *strm, void *d, void *s, int size, int block_size,
   2.312 - 		int *error)
   2.313 - {
   2.314 --	int res = 0;
   2.315 --	z_stream *stream = *strm;
   2.316 -+	int res;
   2.317 -+	z_stream *stream = strm;
   2.318 - 
   2.319 --	if(stream == NULL) {
   2.320 --		if((stream = *strm = malloc(sizeof(z_stream))) == NULL)
   2.321 --			goto failed;
   2.322 --
   2.323 --		stream->zalloc = Z_NULL;
   2.324 --		stream->zfree = Z_NULL;
   2.325 --		stream->opaque = 0;
   2.326 --
   2.327 --		if((res = deflateInit(stream, 9)) != Z_OK)
   2.328 --			goto failed;
   2.329 --	} else if((res = deflateReset(stream)) != Z_OK)
   2.330 -+	res = deflateReset(stream);
   2.331 -+	if(res != Z_OK)
   2.332 - 		goto failed;
   2.333 - 
   2.334 --	stream->next_in = (unsigned char *) s;
   2.335 -+	stream->next_in = s;
   2.336 - 	stream->avail_in = size;
   2.337 --	stream->next_out = (unsigned char *) d;
   2.338 -+	stream->next_out = d;
   2.339 - 	stream->avail_out = block_size;
   2.340 - 
   2.341 - 	res = deflate(stream, Z_FINISH);
   2.342 -@@ -67,14 +87,26 @@
   2.343 - }
   2.344 - 
   2.345 - 
   2.346 --int gzip_uncompress(char *d, char *s, int size, int block_size, int *error)
   2.347 -+static int gzip_uncompress(void *d, void *s, int size, int block_size, int *error)
   2.348 - {
   2.349 - 	int res;
   2.350 - 	unsigned long bytes = block_size;
   2.351 - 
   2.352 --	res = uncompress((unsigned char *) d, &bytes,
   2.353 --		(const unsigned char *) s, size);
   2.354 -+	res = uncompress(d, &bytes, s, size);
   2.355 - 
   2.356 - 	*error = res;
   2.357 - 	return res == Z_OK ? (int) bytes : -1;
   2.358 - }
   2.359 -+
   2.360 -+
   2.361 -+struct compressor gzip_comp_ops = {
   2.362 -+	.init = gzip_init,
   2.363 -+	.compress = gzip_compress,
   2.364 -+	.uncompress = gzip_uncompress,
   2.365 -+	.options = NULL,
   2.366 -+	.usage = NULL,
   2.367 -+	.id = ZLIB_COMPRESSION,
   2.368 -+	.name = "gzip",
   2.369 -+	.supported = 1
   2.370 -+};
   2.371 -+
   2.372 -diff -r 2ab2996036dd squashfs-tools/lzma_wrapper.c
   2.373 ---- a/squashfs-tools/lzma_wrapper.c	Tue Dec 14 12:19:33 2010 +0000
   2.374 -+++ b/squashfs-tools/lzma_wrapper.c	Tue Dec 14 14:18:11 2010 +0000
   2.375 -@@ -17,21 +17,27 @@
   2.376 -  * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
   2.377 -  *
   2.378 -  * lzma_wrapper.c
   2.379 -+ *
   2.380 -+ * Support for LZMA1 compression using LZMA SDK (4.65 used in
   2.381 -+ * development, other versions may work) http://www.7-zip.org/sdk.html
   2.382 -  */
   2.383 - 
   2.384 - #include <LzmaLib.h>
   2.385 - 
   2.386 -+#include "squashfs_fs.h"
   2.387 -+#include "compressor.h"
   2.388 -+
   2.389 - #define LZMA_HEADER_SIZE	(LZMA_PROPS_SIZE + 8)
   2.390 - 
   2.391 --int lzma_compress(void **strm, char *dest, char *src, int size, int block_size,
   2.392 -+static int lzma_compress(void *strm, void *dest, void *src, int size, int block_size,
   2.393 - 		int *error)
   2.394 - {
   2.395 --	unsigned char *d = (unsigned char *) dest, *s = (unsigned char *) src;
   2.396 -+	unsigned char *d = dest;
   2.397 - 	size_t props_size = LZMA_PROPS_SIZE,
   2.398 - 		outlen = block_size - LZMA_HEADER_SIZE;
   2.399 - 	int res;
   2.400 - 
   2.401 --	res = LzmaCompress(d + LZMA_HEADER_SIZE, &outlen, s, size, d,
   2.402 -+	res = LzmaCompress(dest + LZMA_HEADER_SIZE, &outlen, src, size, dest,
   2.403 - 		&props_size, 5, block_size, 3, 0, 2, 32, 1);
   2.404 - 	
   2.405 - 	if(res == SZ_ERROR_OUTPUT_EOF) {
   2.406 -@@ -73,10 +79,10 @@
   2.407 - }
   2.408 - 
   2.409 - 
   2.410 --int lzma_uncompress(char *dest, char *src, int size, int block_size,
   2.411 -+static int lzma_uncompress(void *dest, void *src, int size, int block_size,
   2.412 - 	int *error)
   2.413 - {
   2.414 --	unsigned char *d = (unsigned char *) dest, *s = (unsigned char *) src;
   2.415 -+	unsigned char *s = src;
   2.416 - 	size_t outlen, inlen = size - LZMA_HEADER_SIZE;
   2.417 - 	int res;
   2.418 - 
   2.419 -@@ -85,9 +91,22 @@
   2.420 - 		(s[LZMA_PROPS_SIZE + 2] << 16) |
   2.421 - 		(s[LZMA_PROPS_SIZE + 3] << 24);
   2.422 - 
   2.423 --	res = LzmaUncompress(d, &outlen, s + LZMA_HEADER_SIZE, &inlen,
   2.424 --		s, LZMA_PROPS_SIZE);
   2.425 -+	res = LzmaUncompress(dest, &outlen, src + LZMA_HEADER_SIZE, &inlen, src,
   2.426 -+		LZMA_PROPS_SIZE);
   2.427 - 	
   2.428 - 	*error = res;
   2.429 - 	return res == SZ_OK ? outlen : -1;
   2.430 - }
   2.431 -+
   2.432 -+
   2.433 -+struct compressor lzma_comp_ops = {
   2.434 -+	.init = NULL,
   2.435 -+	.compress = lzma_compress,
   2.436 -+	.uncompress = lzma_uncompress,
   2.437 -+	.options = NULL,
   2.438 -+	.usage = NULL,
   2.439 -+	.id = LZMA_COMPRESSION,
   2.440 -+	.name = "lzma",
   2.441 -+	.supported = 1
   2.442 -+};
   2.443 -+
   2.444 -diff -r 2ab2996036dd squashfs-tools/lzma_xz_wrapper.c
   2.445 ---- /dev/null	Thu Jan 01 00:00:00 1970 +0000
   2.446 -+++ b/squashfs-tools/lzma_xz_wrapper.c	Tue Dec 14 14:18:11 2010 +0000
   2.447 -@@ -0,0 +1,156 @@
   2.448 -+/*
   2.449 -+ * Copyright (c) 2010
   2.450 -+ * Phillip Lougher <phillip@lougher.demon.co.uk>
   2.451 -+ *
   2.452 -+ * This program is free software; you can redistribute it and/or
   2.453 -+ * modify it under the terms of the GNU General Public License
   2.454 -+ * as published by the Free Software Foundation; either version 2,
   2.455 -+ * or (at your option) any later version.
   2.456 -+ *
   2.457 -+ * This program is distributed in the hope that it will be useful,
   2.458 -+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
   2.459 -+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   2.460 -+ * GNU General Public License for more details.
   2.461 -+ *
   2.462 -+ * You should have received a copy of the GNU General Public License
   2.463 -+ * along with this program; if not, write to the Free Software
   2.464 -+ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
   2.465 -+ *
   2.466 -+ * lzma_xz_wrapper.c
   2.467 -+ *
   2.468 -+ * Support for LZMA1 compression using XZ Utils liblzma http://tukaani.org/xz/
   2.469 -+ */
   2.470 -+
   2.471 -+#include <stdio.h>
   2.472 -+#include <string.h>
   2.473 -+#include <lzma.h>
   2.474 -+
   2.475 -+#include "squashfs_fs.h"
   2.476 -+#include "compressor.h"
   2.477 -+
   2.478 -+#define LZMA_PROPS_SIZE 5
   2.479 -+#define LZMA_UNCOMP_SIZE 8
   2.480 -+#define LZMA_HEADER_SIZE (LZMA_PROPS_SIZE + LZMA_UNCOMP_SIZE)
   2.481 -+
   2.482 -+#define LZMA_OPTIONS 5
   2.483 -+#define MEMLIMIT (32 * 1024 * 1024)
   2.484 -+
   2.485 -+static int lzma_compress(void *dummy, void *dest, void *src,  int size,
   2.486 -+	int block_size, int *error)
   2.487 -+{
   2.488 -+	unsigned char *d = (unsigned char *) dest;
   2.489 -+	lzma_options_lzma opt;
   2.490 -+	lzma_stream strm = LZMA_STREAM_INIT;
   2.491 -+	int res;
   2.492 -+
   2.493 -+	lzma_lzma_preset(&opt, LZMA_OPTIONS);
   2.494 -+	opt.dict_size = block_size;
   2.495 -+	res = lzma_alone_encoder(&strm, &opt);
   2.496 -+	if(res != LZMA_OK) {
   2.497 -+		lzma_end(&strm);
   2.498 -+		goto failed;
   2.499 -+	}
   2.500 -+
   2.501 -+	strm.next_out = dest;
   2.502 -+	strm.avail_out = block_size;
   2.503 -+	strm.next_in = src;
   2.504 -+	strm.avail_in = size;
   2.505 -+
   2.506 -+	res = lzma_code(&strm, LZMA_FINISH);
   2.507 -+	lzma_end(&strm);
   2.508 -+
   2.509 -+	if(res == LZMA_STREAM_END) {
   2.510 -+		/*
   2.511 -+	 	 * Fill in the 8 byte little endian uncompressed size field in
   2.512 -+		 * the LZMA header.  8 bytes is excessively large for squashfs
   2.513 -+		 * but this is the standard LZMA header and which is expected by
   2.514 -+		 * the kernel code
   2.515 -+	 	 */
   2.516 -+
   2.517 -+		d[LZMA_PROPS_SIZE] = size & 255;
   2.518 -+		d[LZMA_PROPS_SIZE + 1] = (size >> 8) & 255;
   2.519 -+		d[LZMA_PROPS_SIZE + 2] = (size >> 16) & 255;
   2.520 -+		d[LZMA_PROPS_SIZE + 3] = (size >> 24) & 255;
   2.521 -+		d[LZMA_PROPS_SIZE + 4] = 0;
   2.522 -+		d[LZMA_PROPS_SIZE + 5] = 0;
   2.523 -+		d[LZMA_PROPS_SIZE + 6] = 0;
   2.524 -+		d[LZMA_PROPS_SIZE + 7] = 0;
   2.525 -+
   2.526 -+		return (int) strm.total_out;
   2.527 -+	}
   2.528 -+
   2.529 -+	if(res == LZMA_OK)
   2.530 -+		/*
   2.531 -+	 	 * Output buffer overflow.  Return out of buffer space
   2.532 -+	 	 */
   2.533 -+		return 0;
   2.534 -+
   2.535 -+failed:
   2.536 -+	/*
   2.537 -+	 * All other errors return failure, with the compressor
   2.538 -+	 * specific error code in *error
   2.539 -+	 */
   2.540 -+	*error = res;
   2.541 -+	return -1;
   2.542 -+}
   2.543 -+
   2.544 -+
   2.545 -+static int lzma_uncompress(void *dest, void *src, int size, int block_size,
   2.546 -+	int *error)
   2.547 -+{
   2.548 -+	lzma_stream strm = LZMA_STREAM_INIT;
   2.549 -+	int uncompressed_size = 0, res;
   2.550 -+	unsigned char lzma_header[LZMA_HEADER_SIZE];
   2.551 -+
   2.552 -+	res = lzma_alone_decoder(&strm, MEMLIMIT);
   2.553 -+	if(res != LZMA_OK) {
   2.554 -+		lzma_end(&strm);
   2.555 -+		goto failed;
   2.556 -+	}
   2.557 -+
   2.558 -+	memcpy(lzma_header, src, LZMA_HEADER_SIZE);
   2.559 -+	uncompressed_size = lzma_header[LZMA_PROPS_SIZE] |
   2.560 -+		(lzma_header[LZMA_PROPS_SIZE + 1] << 8) |
   2.561 -+		(lzma_header[LZMA_PROPS_SIZE + 2] << 16) |
   2.562 -+		(lzma_header[LZMA_PROPS_SIZE + 3] << 24);
   2.563 -+	memset(lzma_header + LZMA_PROPS_SIZE, 255, LZMA_UNCOMP_SIZE);
   2.564 -+
   2.565 -+	strm.next_out = dest;
   2.566 -+	strm.avail_out = block_size;
   2.567 -+	strm.next_in = lzma_header;
   2.568 -+	strm.avail_in = LZMA_HEADER_SIZE;
   2.569 -+
   2.570 -+	res = lzma_code(&strm, LZMA_RUN);
   2.571 -+
   2.572 -+	if(res != LZMA_OK || strm.avail_in != 0) {
   2.573 -+		lzma_end(&strm);
   2.574 -+		goto failed;
   2.575 -+	}
   2.576 -+
   2.577 -+	strm.next_in = src + LZMA_HEADER_SIZE;
   2.578 -+	strm.avail_in = size - LZMA_HEADER_SIZE;
   2.579 -+
   2.580 -+	res = lzma_code(&strm, LZMA_FINISH);
   2.581 -+	lzma_end(&strm);
   2.582 -+
   2.583 -+	if(res == LZMA_STREAM_END || (res == LZMA_OK &&
   2.584 -+		strm.total_out >= uncompressed_size && strm.avail_in == 0))
   2.585 -+		return uncompressed_size;
   2.586 -+
   2.587 -+failed:
   2.588 -+	*error = res;
   2.589 -+	return -1;
   2.590 -+}
   2.591 -+
   2.592 -+
   2.593 -+struct compressor lzma_comp_ops = {
   2.594 -+	.init = NULL,
   2.595 -+	.compress = lzma_compress,
   2.596 -+	.uncompress = lzma_uncompress,
   2.597 -+	.options = NULL,
   2.598 -+	.usage = NULL,
   2.599 -+	.id = LZMA_COMPRESSION,
   2.600 -+	.name = "lzma",
   2.601 -+	.supported = 1
   2.602 -+};
   2.603 -+
   2.604 -diff -r 2ab2996036dd squashfs-tools/lzo_wrapper.c
   2.605 ---- a/squashfs-tools/lzo_wrapper.c	Tue Dec 14 12:19:33 2010 +0000
   2.606 -+++ b/squashfs-tools/lzo_wrapper.c	Tue Dec 14 14:18:11 2010 +0000
   2.607 -@@ -2,6 +2,9 @@
   2.608 -  * Copyright (c) 2010 LG Electronics
   2.609 -  * Chan Jeong <chan.jeong@lge.com>
   2.610 -  *
   2.611 -+ * All modifications Copyright (c) 2010
   2.612 -+ * Phillip Lougher <phillip@lougher.demon.co.uk>
   2.613 -+ *
   2.614 -  * This program is free software; you can redistribute it and/or
   2.615 -  * modify it under the terms of the GNU General Public License
   2.616 -  * as published by the Free Software Foundation; either version 2,
   2.617 -@@ -25,6 +28,9 @@
   2.618 - #include <lzo/lzoconf.h>
   2.619 - #include <lzo/lzo1x.h>
   2.620 - 
   2.621 -+#include "squashfs_fs.h"
   2.622 -+#include "compressor.h"
   2.623 -+
   2.624 - /* worst-case expansion calculation during compression,
   2.625 -    see LZO FAQ for more information */
   2.626 - #define LZO_OUTPUT_BUFFER_SIZE(size)	(size + (size/16) + 64 + 3)
   2.627 -@@ -34,25 +40,39 @@
   2.628 - 	lzo_bytep out;
   2.629 - };
   2.630 - 
   2.631 --int lzo_compress(void **strm, char *d, char *s, int size, int block_size,
   2.632 -+
   2.633 -+static int squashfs_lzo_init(void **strm, int block_size, int flags)
   2.634 -+{
   2.635 -+	struct lzo_stream *stream;
   2.636 -+
   2.637 -+	if((stream = *strm = malloc(sizeof(struct lzo_stream))) == NULL)
   2.638 -+		goto failed;
   2.639 -+	/* work memory for compression */
   2.640 -+	if((stream->wrkmem = malloc(LZO1X_999_MEM_COMPRESS)) == NULL)
   2.641 -+		goto failed2;
   2.642 -+	/* temporal output buffer */
   2.643 -+	if((stream->out = malloc(LZO_OUTPUT_BUFFER_SIZE(block_size))) == NULL)
   2.644 -+		goto failed3;
   2.645 -+
   2.646 -+	return 0;
   2.647 -+
   2.648 -+failed3:
   2.649 -+	free(stream->wrkmem);
   2.650 -+failed2:
   2.651 -+	free(stream);
   2.652 -+failed:
   2.653 -+	return -1;
   2.654 -+}
   2.655 -+
   2.656 -+
   2.657 -+static int lzo_compress(void *strm, void *d, void *s, int size, int block_size,
   2.658 - 		int *error)
   2.659 - {
   2.660 --	int res = 0;
   2.661 -+	int res;
   2.662 - 	lzo_uint outlen;
   2.663 --	struct lzo_stream *stream = *strm;
   2.664 -+	struct lzo_stream *stream = strm;
   2.665 - 
   2.666 --	if(stream == NULL) {
   2.667 --		if((stream = *strm = malloc(sizeof(struct lzo_stream))) == NULL)
   2.668 --			goto failed;
   2.669 --		/* work memory for compression */
   2.670 --		if((stream->wrkmem = malloc(LZO1X_999_MEM_COMPRESS)) == NULL)
   2.671 --			goto failed;
   2.672 --		/* temporal output buffer */
   2.673 --		if((stream->out = malloc(LZO_OUTPUT_BUFFER_SIZE(block_size))) == NULL)
   2.674 --			goto failed;
   2.675 --	}
   2.676 --
   2.677 --	res = lzo1x_999_compress((lzo_bytep)s, size, stream->out, &outlen, stream->wrkmem);
   2.678 -+	res = lzo1x_999_compress(s, size, stream->out, &outlen, stream->wrkmem);
   2.679 - 	if(res != LZO_E_OK)
   2.680 - 		goto failed;
   2.681 - 	if(outlen >= size)
   2.682 -@@ -77,13 +97,26 @@
   2.683 - }
   2.684 - 
   2.685 - 
   2.686 --int lzo_uncompress(char *d, char *s, int size, int block_size, int *error)
   2.687 -+static int lzo_uncompress(void *d, void *s, int size, int block_size, int *error)
   2.688 - {
   2.689 - 	int res;
   2.690 - 	lzo_uint bytes = block_size;
   2.691 - 
   2.692 --	res = lzo1x_decompress_safe((lzo_bytep)s, size, (lzo_bytep)d, &bytes, NULL);
   2.693 -+	res = lzo1x_decompress_safe(s, size, d, &bytes, NULL);
   2.694 - 
   2.695 - 	*error = res;
   2.696 - 	return res == LZO_E_OK ? bytes : -1;
   2.697 - }
   2.698 -+
   2.699 -+
   2.700 -+struct compressor lzo_comp_ops = {
   2.701 -+	.init = squashfs_lzo_init,
   2.702 -+	.compress = lzo_compress,
   2.703 -+	.uncompress = lzo_uncompress,
   2.704 -+	.options = NULL,
   2.705 -+	.usage = NULL,
   2.706 -+	.id = LZO_COMPRESSION,
   2.707 -+	.name = "lzo",
   2.708 -+	.supported = 1
   2.709 -+};
   2.710 -+
   2.711 -diff -r 2ab2996036dd squashfs-tools/mksquashfs.c
   2.712 ---- a/squashfs-tools/mksquashfs.c	Tue Dec 14 12:19:33 2010 +0000
   2.713 -+++ b/squashfs-tools/mksquashfs.c	Tue Dec 14 14:18:11 2010 +0000
   2.714 -@@ -384,9 +384,10 @@
   2.715 - #define FRAGMENT_BUFFER_DEFAULT 64
   2.716 - int writer_buffer_size;
   2.717 - 
   2.718 --/* compression operations structure */
   2.719 -+/* compression operations */
   2.720 - static struct compressor *comp;
   2.721 --char *comp_name = COMP_DEFAULT;
   2.722 -+int compressor_opts_parsed = 0;
   2.723 -+void *stream = NULL;
   2.724 - 
   2.725 - /* xattr stats */
   2.726 - unsigned int xattr_bytes = 0, total_xattr_bytes = 0;
   2.727 -@@ -859,7 +860,7 @@
   2.728 - }
   2.729 - 
   2.730 - 
   2.731 --int mangle2(void **strm, char *d, char *s, int size,
   2.732 -+int mangle2(void *strm, char *d, char *s, int size,
   2.733 - 	int block_size, int uncompressed, int data_block)
   2.734 - {
   2.735 - 	int error, c_byte = 0;
   2.736 -@@ -884,9 +885,7 @@
   2.737 - int mangle(char *d, char *s, int size, int block_size,
   2.738 - 	int uncompressed, int data_block)
   2.739 - {
   2.740 --	static void *stream = NULL;
   2.741 --
   2.742 --	return mangle2(&stream, d, s, size, block_size, uncompressed,
   2.743 -+	return mangle2(stream, d, s, size, block_size, uncompressed,
   2.744 - 		data_block);
   2.745 - }
   2.746 - 
   2.747 -@@ -2556,11 +2555,15 @@
   2.748 - void *deflator(void *arg)
   2.749 - {
   2.750 - 	void *stream = NULL;
   2.751 --	int oldstate;
   2.752 -+	int res, oldstate;
   2.753 - 
   2.754 - 	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate);
   2.755 - 	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldstate);
   2.756 - 
   2.757 -+	res = compressor_init(comp, &stream, block_size, 1);
   2.758 -+	if(res)
   2.759 -+		BAD_ERROR("deflator:: compressor_init failed\n");
   2.760 -+
   2.761 - 	while(1) {
   2.762 - 		struct file_buffer *file_buffer = queue_get(from_reader);
   2.763 - 		struct file_buffer *write_buffer;
   2.764 -@@ -2573,7 +2576,7 @@
   2.765 - 			queue_put(from_deflate, file_buffer);
   2.766 - 		} else {
   2.767 - 			write_buffer = cache_get(writer_buffer, 0, 0);
   2.768 --			write_buffer->c_byte = mangle2(&stream,
   2.769 -+			write_buffer->c_byte = mangle2(stream,
   2.770 - 				write_buffer->data, file_buffer->data,
   2.771 - 				file_buffer->size, block_size, noD, 1);
   2.772 - 			write_buffer->sequence = file_buffer->sequence;
   2.773 -@@ -2593,11 +2596,15 @@
   2.774 - void *frag_deflator(void *arg)
   2.775 - {
   2.776 - 	void *stream = NULL;
   2.777 --	int oldstate;
   2.778 -+	int res, oldstate;
   2.779 - 
   2.780 - 	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate);
   2.781 - 	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldstate);
   2.782 - 
   2.783 -+	res = compressor_init(comp, &stream, block_size, 1);
   2.784 -+	if(res)
   2.785 -+		BAD_ERROR("frag_deflator:: compressor_init failed\n");
   2.786 -+
   2.787 - 	while(1) {
   2.788 - 		int c_byte, compressed_size;
   2.789 - 		struct file_buffer *file_buffer = queue_get(to_frag);
   2.790 -@@ -2605,7 +2612,7 @@
   2.791 - 			cache_get(writer_buffer, file_buffer->block +
   2.792 - 			FRAG_INDEX, 1);
   2.793 - 
   2.794 --		c_byte = mangle2(&stream, write_buffer->data, file_buffer->data,
   2.795 -+		c_byte = mangle2(stream, write_buffer->data, file_buffer->data,
   2.796 - 			file_buffer->size, block_size, noF, 1);
   2.797 - 		compressed_size = SQUASHFS_COMPRESSED_SIZE_BLOCK(c_byte);
   2.798 - 		write_buffer->size = compressed_size;
   2.799 -@@ -4501,7 +4508,7 @@
   2.800 - 
   2.801 - 
   2.802 - #define VERSION() \
   2.803 --	printf("mksquashfs version 4.1 (2010/09/19)\n");\
   2.804 -+	printf("mksquashfs version 4.1-CVS (2010/12/07)\n");\
   2.805 - 	printf("copyright (C) 2010 Phillip Lougher "\
   2.806 - 		"<phillip@lougher.demon.co.uk>\n\n"); \
   2.807 - 	printf("This program is free software; you can redistribute it and/or"\
   2.808 -@@ -4521,7 +4528,7 @@
   2.809 - int main(int argc, char *argv[])
   2.810 - {
   2.811 - 	struct stat buf, source_buf;
   2.812 --	int i;
   2.813 -+	int res, i;
   2.814 - 	squashfs_super_block sBlk;
   2.815 - 	char *b, *root_name = NULL;
   2.816 - 	int nopad = FALSE, keep_as_directory = FALSE;
   2.817 -@@ -4542,14 +4549,50 @@
   2.818 - 		goto printOptions;
   2.819 - 	source_path = argv + 1;
   2.820 - 	source = i - 2;
   2.821 -+	/*
   2.822 -+	 * lookup default compressor.  Note the Makefile ensures the default
   2.823 -+	 * compressor has been built, and so we don't need to to check
   2.824 -+	 * for failure here
   2.825 -+	 */
   2.826 -+	comp = lookup_compressor(COMP_DEFAULT);
   2.827 - 	for(; i < argc; i++) {
   2.828 - 		if(strcmp(argv[i], "-comp") == 0) {
   2.829 -+			if(compressor_opts_parsed) {
   2.830 -+				ERROR("%s: -comp must appear before -X options"
   2.831 -+					"\n", argv[0]);
   2.832 -+				exit(1);
   2.833 -+			}
   2.834 - 			if(++i == argc) {
   2.835 - 				ERROR("%s: -comp missing compression type\n",
   2.836 - 					argv[0]);
   2.837 - 				exit(1);
   2.838 - 			}
   2.839 --			comp_name = argv[i];
   2.840 -+			comp = lookup_compressor(argv[i]);
   2.841 -+			if(!comp->supported) {
   2.842 -+				ERROR("%s: Compressor \"%s\" is not supported!"
   2.843 -+					"\n", argv[0], argv[i]);
   2.844 -+				ERROR("%s: Compressors available:\n", argv[0]);
   2.845 -+				display_compressors("", COMP_DEFAULT);
   2.846 -+				exit(1);
   2.847 -+			}
   2.848 -+
   2.849 -+		} else if(strncmp(argv[i], "-X", 2) == 0) {
   2.850 -+			int args = compressor_options(comp, argv + i, argc - i);
   2.851 -+			if(args < 0) {
   2.852 -+				if(args == -1) {
   2.853 -+					ERROR("%s: Unrecognised compressor"
   2.854 -+						" option %s\n", argv[0],
   2.855 -+						argv[i]);
   2.856 -+					ERROR("%s: Did you forget to specify"
   2.857 -+						" -comp, or specify it after"
   2.858 -+						" the compressor specific"
   2.859 -+						" option?\n", argv[0]);
   2.860 -+					}
   2.861 -+				exit(1);
   2.862 -+			}
   2.863 -+			i += args;
   2.864 -+			compressor_opts_parsed = 1;
   2.865 -+
   2.866 - 		} else if(strcmp(argv[i], "-pf") == 0) {
   2.867 - 			if(++i == argc) {
   2.868 - 				ERROR("%s: -pf missing filename\n", argv[0]);
   2.869 -@@ -4857,7 +4900,7 @@
   2.870 - 			ERROR("-write-queue <size>\tSet output queue to <size> "
   2.871 - 				"Mbytes.  Default %d Mbytes\n",
   2.872 - 				WRITER_BUFFER_DEFAULT);
   2.873 --			ERROR("-fragment-queue <size>\tSet fagment queue to "
   2.874 -+			ERROR("-fragment-queue <size>\tSet fragment queue to "
   2.875 - 				"<size> Mbytes.  Default %d Mbytes\n",
   2.876 - 				FRAGMENT_BUFFER_DEFAULT);
   2.877 - 			ERROR("\nMiscellaneous options:\n");
   2.878 -@@ -4871,8 +4914,9 @@
   2.879 - 				"-noF\n");
   2.880 - 			ERROR("-noXattrCompression\talternative name for "
   2.881 - 				"-noX\n");
   2.882 --			ERROR("\nCompressors available:\n");
   2.883 --			display_compressors("", COMP_DEFAULT);
   2.884 -+			ERROR("\nCompressors available and compressor specific "
   2.885 -+				"options:\n");
   2.886 -+			display_compressor_usage(COMP_DEFAULT);
   2.887 - 			exit(1);
   2.888 - 		}
   2.889 - 	}
   2.890 -@@ -5005,19 +5049,14 @@
   2.891 - 		always_use_fragments = SQUASHFS_ALWAYS_FRAGMENTS(sBlk.flags);
   2.892 - 		duplicate_checking = SQUASHFS_DUPLICATES(sBlk.flags);
   2.893 - 		exportable = SQUASHFS_EXPORTABLE(sBlk.flags);
   2.894 --	} else {
   2.895 --		comp = lookup_compressor(comp_name);
   2.896 --		if(!comp->supported) {
   2.897 --			ERROR("FATAL_ERROR: Compressor \"%s\" is not "
   2.898 --				"supported!\n", comp_name);
   2.899 --			ERROR("Compressors available:\n");
   2.900 --			display_compressors("", COMP_DEFAULT);
   2.901 --			EXIT_MKSQUASHFS();
   2.902 --		}
   2.903 - 	}
   2.904 - 
   2.905 - 	initialise_threads(readb_mbytes, writeb_mbytes, fragmentb_mbytes);
   2.906 - 
   2.907 -+	res = compressor_init(comp, &stream, SQUASHFS_METADATA_SIZE, 0);
   2.908 -+	if(res)
   2.909 -+		BAD_ERROR("compressor_init failed\n");
   2.910 -+
   2.911 - 	if(delete) {
   2.912 - 		printf("Creating %d.%d filesystem on %s, block size %d.\n",
   2.913 - 			SQUASHFS_MAJOR, s_minor, argv[source + 1], block_size);
   2.914 -diff -r 2ab2996036dd squashfs-tools/read_fs.c
   2.915 ---- a/squashfs-tools/read_fs.c	Tue Dec 14 12:19:33 2010 +0000
   2.916 -+++ b/squashfs-tools/read_fs.c	Tue Dec 14 14:18:11 2010 +0000
   2.917 -@@ -363,7 +363,8 @@
   2.918 - 		}
   2.919 - 	}
   2.920 - 	
   2.921 --	return files;
   2.922 -+	printf("Read existing filesystem, %d inodes scanned\n", files);
   2.923 -+	return TRUE;
   2.924 - 
   2.925 - 
   2.926 - failed:
   2.927 -@@ -414,6 +415,7 @@
   2.928 - 	if(!comp->supported) {
   2.929 - 		ERROR("Filesystem on %s uses %s compression, this is"
   2.930 - 			"unsupported by this version\n", source, comp->name);
   2.931 -+		ERROR("Compressors available:\n");
   2.932 - 		display_compressors("", "");
   2.933 - 		goto failed_mount;
   2.934 - 	}
   2.935 -@@ -691,7 +693,7 @@
   2.936 - 		SQUASHFS_INODE_BLK(sBlk->root_inode);
   2.937 - 	unsigned int root_inode_offset =
   2.938 - 		SQUASHFS_INODE_OFFSET(sBlk->root_inode);
   2.939 --	unsigned int root_inode_block, files;
   2.940 -+	unsigned int root_inode_block;
   2.941 - 	squashfs_inode_header inode;
   2.942 - 	unsigned int *id_table;
   2.943 - 	int res;
   2.944 -@@ -711,20 +713,18 @@
   2.945 - 	if(id_table == NULL)
   2.946 - 		goto error;
   2.947 - 
   2.948 --	if((files = scan_inode_table(fd, start, end, root_inode_start,
   2.949 --			root_inode_offset, sBlk, &inode, &inode_table,
   2.950 --			&root_inode_block, root_inode_size, uncompressed_file,
   2.951 --			uncompressed_directory, file_count, sym_count,
   2.952 --			dev_count, dir_count, fifo_count, sock_count, id_table))
   2.953 --			== 0) {
   2.954 -+	res = scan_inode_table(fd, start, end, root_inode_start,
   2.955 -+		root_inode_offset, sBlk, &inode, &inode_table,
   2.956 -+		&root_inode_block, root_inode_size, uncompressed_file,
   2.957 -+		uncompressed_directory, file_count, sym_count, dev_count,
   2.958 -+		dir_count, fifo_count, sock_count, id_table);
   2.959 -+	if(res == 0) {
   2.960 - 		ERROR("read_filesystem: inode table read failed\n");
   2.961 - 		goto error;
   2.962 - 	}
   2.963 - 
   2.964 - 	*uncompressed_inode = root_inode_block;
   2.965 - 
   2.966 --	printf("Read existing filesystem, %d inodes scanned\n", files);
   2.967 --
   2.968 - 	if(inode.base.inode_type == SQUASHFS_DIR_TYPE ||
   2.969 - 			inode.base.inode_type == SQUASHFS_LDIR_TYPE) {
   2.970 - 		if(inode.base.inode_type == SQUASHFS_DIR_TYPE) {
   2.971 -diff -r 2ab2996036dd squashfs-tools/squashfs_fs.h
   2.972 ---- a/squashfs-tools/squashfs_fs.h	Tue Dec 14 12:19:33 2010 +0000
   2.973 -+++ b/squashfs-tools/squashfs_fs.h	Tue Dec 14 14:18:11 2010 +0000
   2.974 -@@ -259,6 +259,7 @@
   2.975 - #define ZLIB_COMPRESSION	1
   2.976 - #define LZMA_COMPRESSION	2
   2.977 - #define LZO_COMPRESSION		3
   2.978 -+#define XZ_COMPRESSION		4
   2.979 - 
   2.980 - struct squashfs_super_block {
   2.981 - 	unsigned int		s_magic;
   2.982 -diff -r 2ab2996036dd squashfs-tools/unsquash-1.c
   2.983 ---- a/squashfs-tools/unsquash-1.c	Tue Dec 14 12:19:33 2010 +0000
   2.984 -+++ b/squashfs-tools/unsquash-1.c	Tue Dec 14 14:18:11 2010 +0000
   2.985 -@@ -138,7 +138,7 @@
   2.986 - 
   2.987 - 			i.data = inode->file_size;
   2.988 - 			i.time = inode->mtime;
   2.989 --			i.blocks = (inode->file_size + sBlk.s.block_size - 1) >>
   2.990 -+			i.blocks = (i.data + sBlk.s.block_size - 1) >>
   2.991 - 				sBlk.s.block_log;
   2.992 - 			i.start = inode->start_block;
   2.993 - 			i.block_ptr = block_ptr + sizeof(*inode);
   2.994 -diff -r 2ab2996036dd squashfs-tools/unsquash-2.c
   2.995 ---- a/squashfs-tools/unsquash-2.c	Tue Dec 14 12:19:33 2010 +0000
   2.996 -+++ b/squashfs-tools/unsquash-2.c	Tue Dec 14 14:18:11 2010 +0000
   2.997 -@@ -205,8 +205,8 @@
   2.998 - 			i.fragment = inode->fragment;
   2.999 - 			i.offset = inode->offset;
  2.1000 - 			i.blocks = inode->fragment == SQUASHFS_INVALID_FRAG ?
  2.1001 --				(inode->file_size + sBlk.s.block_size - 1) >>
  2.1002 --				sBlk.s.block_log : inode->file_size >>
  2.1003 -+				(i.data + sBlk.s.block_size - 1) >>
  2.1004 -+				sBlk.s.block_log : i.data >>
  2.1005 - 				sBlk.s.block_log;
  2.1006 - 			i.start = inode->start_block;
  2.1007 - 			i.sparse = 0;
  2.1008 -diff -r 2ab2996036dd squashfs-tools/unsquash-3.c
  2.1009 ---- a/squashfs-tools/unsquash-3.c	Tue Dec 14 12:19:33 2010 +0000
  2.1010 -+++ b/squashfs-tools/unsquash-3.c	Tue Dec 14 14:18:11 2010 +0000
  2.1011 -@@ -188,9 +188,9 @@
  2.1012 - 			i.fragment = inode->fragment;
  2.1013 - 			i.offset = inode->offset;
  2.1014 - 			i.blocks = inode->fragment == SQUASHFS_INVALID_FRAG ?
  2.1015 --				(inode->file_size + sBlk.s.block_size - 1) >>
  2.1016 -+				(i.data + sBlk.s.block_size - 1) >>
  2.1017 - 				sBlk.s.block_log :
  2.1018 --				inode->file_size >> sBlk.s.block_log;
  2.1019 -+				i.data >> sBlk.s.block_log;
  2.1020 - 			i.start = inode->start_block;
  2.1021 - 			i.sparse = 1;
  2.1022 - 			i.block_ptr = block_ptr + sizeof(*inode);
  2.1023 -diff -r 2ab2996036dd squashfs-tools/unsquash-4.c
  2.1024 ---- a/squashfs-tools/unsquash-4.c	Tue Dec 14 12:19:33 2010 +0000
  2.1025 -+++ b/squashfs-tools/unsquash-4.c	Tue Dec 14 14:18:11 2010 +0000
  2.1026 -@@ -143,9 +143,9 @@
  2.1027 - 			i.fragment = inode->fragment;
  2.1028 - 			i.offset = inode->offset;
  2.1029 - 			i.blocks = inode->fragment == SQUASHFS_INVALID_FRAG ?
  2.1030 --				(inode->file_size + sBlk.s.block_size - 1) >>
  2.1031 -+				(i.data + sBlk.s.block_size - 1) >>
  2.1032 - 				sBlk.s.block_log :
  2.1033 --				inode->file_size >> sBlk.s.block_log;
  2.1034 -+				i.data >> sBlk.s.block_log;
  2.1035 - 			i.start = inode->start_block;
  2.1036 - 			i.sparse = 0;
  2.1037 - 			i.block_ptr = block_ptr + sizeof(*inode);
  2.1038 -diff -r 2ab2996036dd squashfs-tools/unsquashfs.c
  2.1039 ---- a/squashfs-tools/unsquashfs.c	Tue Dec 14 12:19:33 2010 +0000
  2.1040 -+++ b/squashfs-tools/unsquashfs.c	Tue Dec 14 14:18:11 2010 +0000
  2.1041 -@@ -737,7 +737,7 @@
  2.1042 - int lseek_broken = FALSE;
  2.1043 - char *zero_data = NULL;
  2.1044 - 
  2.1045 --int write_block(int file_fd, char *buffer, int size, int hole, int sparse)
  2.1046 -+int write_block(int file_fd, char *buffer, int size, long long hole, int sparse)
  2.1047 - {
  2.1048 - 	off_t off = hole;
  2.1049 - 
  2.1050 -@@ -1299,9 +1299,12 @@
  2.1051 - 		print_filename(parent_name, i);
  2.1052 - 
  2.1053 - 	if(!lsonly && mkdir(parent_name, (mode_t) dir->mode) == -1 &&
  2.1054 --			(!force || errno != EEXIST))
  2.1055 --		ERROR("dir_scan: failed to open directory %s, because %s\n",
  2.1056 -+			(!force || errno != EEXIST)) {
  2.1057 -+		ERROR("dir_scan: failed to make directory %s, because %s\n",
  2.1058 - 			parent_name, strerror(errno));
  2.1059 -+		squashfs_closedir(dir);
  2.1060 -+		return;
  2.1061 -+	}
  2.1062 - 
  2.1063 - 	while(squashfs_readdir(dir, &name, &start_block, &offset, &type)) {
  2.1064 - 		TRACE("dir_scan: name %s, start_block %d, offset %d, type %d\n",
  2.1065 -@@ -1604,7 +1607,7 @@
  2.1066 - 	while(1) {
  2.1067 - 		struct squashfs_file *file = queue_get(to_writer);
  2.1068 - 		int file_fd;
  2.1069 --		int hole = 0;
  2.1070 -+		long long hole = 0;
  2.1071 - 		int failed = FALSE;
  2.1072 - 		int error;
  2.1073 - 
  2.1074 -@@ -1903,7 +1906,7 @@
  2.1075 - 
  2.1076 - 
  2.1077 - #define VERSION() \
  2.1078 --	printf("unsquashfs version 4.1 (2010/09/19)\n");\
  2.1079 -+	printf("unsquashfs version 4.1-CVS (2010/10/23)\n");\
  2.1080 - 	printf("copyright (C) 2010 Phillip Lougher "\
  2.1081 - 		"<phillip@lougher.demon.co.uk>\n\n");\
  2.1082 -     	printf("This program is free software; you can redistribute it and/or"\
  2.1083 -@@ -2081,7 +2084,7 @@
  2.1084 - 			ERROR("\t-da[ta-queue] <size>\tSet data queue to "
  2.1085 - 				"<size> Mbytes.  Default %d\n\t\t\t\tMbytes\n",
  2.1086 - 				DATA_BUFFER_DEFAULT);
  2.1087 --			ERROR("\t-fr[ag-queue] <size>\tSet fagment queue to "
  2.1088 -+			ERROR("\t-fr[ag-queue] <size>\tSet fragment queue to "
  2.1089 - 				"<size> Mbytes.  Default %d\n\t\t\t\t Mbytes\n",
  2.1090 - 				FRAGMENT_BUFFER_DEFAULT);
  2.1091 - 			ERROR("\t-r[egex]\t\ttreat extract names as POSIX "
  2.1092 -diff -r 2ab2996036dd squashfs-tools/unsquashfs_xattr.c
  2.1093 ---- a/squashfs-tools/unsquashfs_xattr.c	Tue Dec 14 12:19:33 2010 +0000
  2.1094 -+++ b/squashfs-tools/unsquashfs_xattr.c	Tue Dec 14 14:18:11 2010 +0000
  2.1095 -@@ -25,7 +25,7 @@
  2.1096 - #include "unsquashfs.h"
  2.1097 - #include "xattr.h"
  2.1098 - 
  2.1099 --#include <attr/xattr.h>
  2.1100 -+#include <sys/xattr.h>
  2.1101 - 
  2.1102 - extern int root_process;
  2.1103 - 
  2.1104 -diff -r 2ab2996036dd squashfs-tools/xattr.c
  2.1105 ---- a/squashfs-tools/xattr.c	Tue Dec 14 12:19:33 2010 +0000
  2.1106 -+++ b/squashfs-tools/xattr.c	Tue Dec 14 14:18:11 2010 +0000
  2.1107 -@@ -34,7 +34,7 @@
  2.1108 - #include <dirent.h>
  2.1109 - #include <string.h>
  2.1110 - #include <stdlib.h>
  2.1111 --#include <attr/xattr.h>
  2.1112 -+#include <sys/xattr.h>
  2.1113 - 
  2.1114 - #include "squashfs_fs.h"
  2.1115 - #include "global.h"
  2.1116 -@@ -219,6 +219,10 @@
  2.1117 - 			break;
  2.1118 - 		}
  2.1119 - 		xattr_list[i].vsize = vsize;
  2.1120 -+
  2.1121 -+		TRACE("read_xattrs_from_system: filename %s, xattr name %s,"
  2.1122 -+			" vsize %d\n", filename, xattr_list[i].full_name,
  2.1123 -+			xattr_list[i].vsize);
  2.1124 - 	}
  2.1125 - 	free(xattr_names);
  2.1126 - 	*xattrs = xattr_list;
  2.1127 -diff -r 2ab2996036dd squashfs-tools/xz_wrapper.c
  2.1128 ---- a/squashfs-tools/xz_wrapper.c	Tue Dec 14 12:19:33 2010 +0000
  2.1129 -+++ b/squashfs-tools/xz_wrapper.c	Tue Dec 14 14:18:11 2010 +0000
  2.1130 -@@ -17,69 +17,192 @@
  2.1131 -  * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  2.1132 -  *
  2.1133 -  * xz_wrapper.c
  2.1134 -+ *
  2.1135 -+ * Support for XZ (LZMA2) compression using XZ Utils liblzma http://tukaani.org/xz/
  2.1136 -  */
  2.1137 - 
  2.1138 - #include <stdio.h>
  2.1139 - #include <string.h>
  2.1140 -+#include <stdlib.h>
  2.1141 - #include <lzma.h>
  2.1142 - 
  2.1143 --#define LZMA_PROPS_SIZE 5
  2.1144 --#define LZMA_UNCOMP_SIZE 8
  2.1145 --#define LZMA_HEADER_SIZE (LZMA_PROPS_SIZE + LZMA_UNCOMP_SIZE)
  2.1146 -+#include "squashfs_fs.h"
  2.1147 -+#include "compressor.h"
  2.1148 - 
  2.1149 --#define LZMA_OPTIONS 5
  2.1150 - #define MEMLIMIT (32 * 1024 * 1024)
  2.1151 - 
  2.1152 --int lzma_compress(void **dummy, void *dest, void *src,  int size,
  2.1153 -+static struct bcj {
  2.1154 -+	char	 	*name;
  2.1155 -+	lzma_vli	id;
  2.1156 -+	int		selected;
  2.1157 -+} bcj[] = {
  2.1158 -+	{ "x86", LZMA_FILTER_X86, 0 },
  2.1159 -+	{ "powerpc", LZMA_FILTER_POWERPC, 0 },
  2.1160 -+	{ "ia64", LZMA_FILTER_IA64, 0 },
  2.1161 -+	{ "arm", LZMA_FILTER_ARM, 0 },
  2.1162 -+	{ "armthumb", LZMA_FILTER_ARMTHUMB, 0 },
  2.1163 -+	{ "sparc", LZMA_FILTER_SPARC, 0 },
  2.1164 -+	{ NULL, LZMA_VLI_UNKNOWN, 0 }
  2.1165 -+};
  2.1166 -+
  2.1167 -+struct filter {
  2.1168 -+	void		*buffer;
  2.1169 -+	lzma_filter	filter[3];
  2.1170 -+	size_t		length;
  2.1171 -+};
  2.1172 -+
  2.1173 -+struct xz_stream {
  2.1174 -+	struct filter	*filter;
  2.1175 -+	int		filters;
  2.1176 -+	lzma_options_lzma opt;
  2.1177 -+};
  2.1178 -+
  2.1179 -+static int filter_count = 1;
  2.1180 -+
  2.1181 -+
  2.1182 -+static int xz_options(char *argv[], int argc)
  2.1183 -+{
  2.1184 -+	int i;
  2.1185 -+	char *name;
  2.1186 -+
  2.1187 -+	if(strcmp(argv[0], "-Xbcj") == 0) {
  2.1188 -+		if(argc < 2) {
  2.1189 -+			fprintf(stderr, "xz: -Xbcj missing filter\n");
  2.1190 -+			goto failed;
  2.1191 -+		}
  2.1192 -+
  2.1193 -+		name = argv[1];
  2.1194 -+		while(name[0] != '\0') {
  2.1195 -+			for(i = 0; bcj[i].name; i++) {
  2.1196 -+				int n = strlen(bcj[i].name);
  2.1197 -+				if((strncmp(name, bcj[i].name, n) == 0) &&
  2.1198 -+						(name[n] == '\0' ||
  2.1199 -+						 name[n] == ',')) {
  2.1200 -+					if(bcj[i].selected == 0) {
  2.1201 -+				 		bcj[i].selected = 1;
  2.1202 -+						filter_count++;
  2.1203 -+					}
  2.1204 -+					name += name[n] == ',' ? n + 1 : n;
  2.1205 -+					break;
  2.1206 -+				}
  2.1207 -+			}
  2.1208 -+			if(bcj[i].name == NULL) {
  2.1209 -+				fprintf(stderr, "xz: -Xbcj unrecognised filter\n");
  2.1210 -+				goto failed;
  2.1211 -+			}
  2.1212 -+		}
  2.1213 -+	
  2.1214 -+		return 1;
  2.1215 -+	}
  2.1216 -+
  2.1217 -+	return -1;
  2.1218 -+	
  2.1219 -+failed:
  2.1220 -+	return -2;
  2.1221 -+}
  2.1222 -+		
  2.1223 -+
  2.1224 -+void xz_usage()
  2.1225 -+{
  2.1226 -+	fprintf(stderr, "\t  -Xbcj filter1,filter2,...,filterN\n");
  2.1227 -+	fprintf(stderr, "\t\tCompress using filter1,filter2,...,filterN in");
  2.1228 -+	fprintf(stderr, " turn\n\t\t(in addition to no filter), and choose");
  2.1229 -+	fprintf(stderr, " the best compression.\n");
  2.1230 -+	fprintf(stderr, "\t\tAvailable filters: x86, arm, armthumb,");
  2.1231 -+	fprintf(stderr, " powerpc, sparc, ia64\n");
  2.1232 -+}
  2.1233 -+
  2.1234 -+
  2.1235 -+static int xz_init(void **strm, int block_size, int flags)
  2.1236 -+{
  2.1237 -+	int i, j, filters = flags ? filter_count : 1;
  2.1238 -+	struct filter *filter = malloc(filters * sizeof(struct filter));
  2.1239 -+	struct xz_stream *stream;
  2.1240 -+
  2.1241 -+	if(filter == NULL)
  2.1242 -+		goto failed;
  2.1243 -+
  2.1244 -+	stream = *strm = malloc(sizeof(struct xz_stream));
  2.1245 -+	if(stream == NULL)
  2.1246 -+		goto failed2;
  2.1247 -+
  2.1248 -+	stream->filter = filter;
  2.1249 -+	stream->filters = filters;
  2.1250 -+
  2.1251 -+	memset(filter, 0, filters * sizeof(struct filter));
  2.1252 -+
  2.1253 -+	filter[0].filter[0].id = LZMA_FILTER_LZMA2;
  2.1254 -+	filter[0].filter[0].options = &stream->opt;
  2.1255 -+	filter[0].filter[1].id = LZMA_VLI_UNKNOWN;
  2.1256 -+
  2.1257 -+	for(i = 0, j = 1; flags && bcj[i].name; i++) {
  2.1258 -+		if(bcj[i].selected) {
  2.1259 -+			filter[j].buffer = malloc(block_size);
  2.1260 -+			if(filter[j].buffer == NULL)
  2.1261 -+				goto failed3;
  2.1262 -+			filter[j].filter[0].id = bcj[i].id;
  2.1263 -+			filter[j].filter[1].id = LZMA_FILTER_LZMA2;
  2.1264 -+			filter[j].filter[1].options = &stream->opt;
  2.1265 -+			filter[j].filter[2].id = LZMA_VLI_UNKNOWN;
  2.1266 -+			j++;
  2.1267 -+		}
  2.1268 -+	}
  2.1269 -+
  2.1270 -+	return 0;
  2.1271 -+
  2.1272 -+failed3:
  2.1273 -+	for(i = 1; i < filters; i++)
  2.1274 -+		free(filter[i].buffer);
  2.1275 -+	free(stream);
  2.1276 -+
  2.1277 -+failed2:
  2.1278 -+	free(filter);
  2.1279 -+
  2.1280 -+failed:
  2.1281 -+	return -1;
  2.1282 -+}
  2.1283 -+
  2.1284 -+
  2.1285 -+static int xz_compress(void *strm, void *dest, void *src,  int size,
  2.1286 - 	int block_size, int *error)
  2.1287 - {
  2.1288 --	unsigned char *d = (unsigned char *) dest;
  2.1289 --	lzma_options_lzma opt;
  2.1290 --	lzma_stream strm = LZMA_STREAM_INIT;
  2.1291 --	int res;
  2.1292 -+	int i;
  2.1293 -+        lzma_ret res = 0;
  2.1294 -+	struct xz_stream *stream = strm;
  2.1295 -+	struct filter *selected = NULL;
  2.1296 - 
  2.1297 --	lzma_lzma_preset(&opt, LZMA_OPTIONS);
  2.1298 --	opt.dict_size = block_size;
  2.1299 --	res = lzma_alone_encoder(&strm, &opt);
  2.1300 --	if(res != LZMA_OK) {
  2.1301 --		lzma_end(&strm);
  2.1302 --		goto failed;
  2.1303 -+	stream->filter[0].buffer = dest;
  2.1304 -+
  2.1305 -+	for(i = 0; i < stream->filters; i++) {
  2.1306 -+		struct filter *filter = &stream->filter[i];
  2.1307 -+
  2.1308 -+        	if(lzma_lzma_preset(&stream->opt, LZMA_PRESET_DEFAULT))
  2.1309 -+                	goto failed;
  2.1310 -+
  2.1311 -+		stream->opt.dict_size = block_size;
  2.1312 -+		filter->length = 0;
  2.1313 -+		res = lzma_stream_buffer_encode(filter->filter,
  2.1314 -+			LZMA_CHECK_CRC32, NULL, src, size, filter->buffer,
  2.1315 -+			&filter->length, block_size);
  2.1316 -+	
  2.1317 -+		if(res == LZMA_OK) {
  2.1318 -+			if(!selected || selected->length > filter->length)
  2.1319 -+				selected = filter;
  2.1320 -+		} else if(res != LZMA_BUF_ERROR)
  2.1321 -+			goto failed;
  2.1322 - 	}
  2.1323 - 
  2.1324 --	strm.next_out = dest;
  2.1325 --	strm.avail_out = block_size;
  2.1326 --	strm.next_in = src;
  2.1327 --	strm.avail_in = size;
  2.1328 --
  2.1329 --	res = lzma_code(&strm, LZMA_FINISH);
  2.1330 --	lzma_end(&strm);
  2.1331 --
  2.1332 --	if(res == LZMA_STREAM_END) {
  2.1333 --		/*
  2.1334 --	 	 * Fill in the 8 byte little endian uncompressed size field in
  2.1335 --		 * the LZMA header.  8 bytes is excessively large for squashfs
  2.1336 --		 * but this is the standard LZMA header and which is expected by
  2.1337 --		 * the kernel code
  2.1338 --	 	 */
  2.1339 --
  2.1340 --		d[LZMA_PROPS_SIZE] = size & 255;
  2.1341 --		d[LZMA_PROPS_SIZE + 1] = (size >> 8) & 255;
  2.1342 --		d[LZMA_PROPS_SIZE + 2] = (size >> 16) & 255;
  2.1343 --		d[LZMA_PROPS_SIZE + 3] = (size >> 24) & 255;
  2.1344 --		d[LZMA_PROPS_SIZE + 4] = 0;
  2.1345 --		d[LZMA_PROPS_SIZE + 5] = 0;
  2.1346 --		d[LZMA_PROPS_SIZE + 6] = 0;
  2.1347 --		d[LZMA_PROPS_SIZE + 7] = 0;
  2.1348 --
  2.1349 --		return (int) strm.total_out;
  2.1350 --	}
  2.1351 --
  2.1352 --	if(res == LZMA_OK)
  2.1353 -+	if(!selected)
  2.1354 - 		/*
  2.1355 - 	 	 * Output buffer overflow.  Return out of buffer space
  2.1356 - 	 	 */
  2.1357 - 		return 0;
  2.1358 - 
  2.1359 -+	if(selected->buffer != dest)
  2.1360 -+		memcpy(dest, selected->buffer, selected->length);
  2.1361 -+
  2.1362 -+	return (int) selected->length;
  2.1363 -+
  2.1364 - failed:
  2.1365 - 	/*
  2.1366 - 	 * All other errors return failure, with the compressor
  2.1367 -@@ -90,49 +213,29 @@
  2.1368 - }
  2.1369 - 
  2.1370 - 
  2.1371 --int lzma_uncompress(void *dest, void *src, int size, int block_size,
  2.1372 -+static int xz_uncompress(void *dest, void *src, int size, int block_size,
  2.1373 - 	int *error)
  2.1374 - {
  2.1375 --	lzma_stream strm = LZMA_STREAM_INIT;
  2.1376 --	int uncompressed_size = 0, res;
  2.1377 --	unsigned char lzma_header[LZMA_HEADER_SIZE];
  2.1378 -+	size_t src_pos = 0;
  2.1379 -+	size_t dest_pos = 0;
  2.1380 -+	uint64_t memlimit = MEMLIMIT;
  2.1381 - 
  2.1382 --	res = lzma_alone_decoder(&strm, MEMLIMIT);
  2.1383 --	if(res != LZMA_OK) {
  2.1384 --		lzma_end(&strm);
  2.1385 --		goto failed;
  2.1386 --	}
  2.1387 -+	lzma_ret res = lzma_stream_buffer_decode(&memlimit, 0, NULL,
  2.1388 -+			src, &src_pos, size, dest, &dest_pos, block_size);
  2.1389 - 
  2.1390 --	memcpy(lzma_header, src, LZMA_HEADER_SIZE);
  2.1391 --	uncompressed_size = lzma_header[LZMA_PROPS_SIZE] |
  2.1392 --		(lzma_header[LZMA_PROPS_SIZE + 1] << 8) |
  2.1393 --		(lzma_header[LZMA_PROPS_SIZE + 2] << 16) |
  2.1394 --		(lzma_header[LZMA_PROPS_SIZE + 3] << 24);
  2.1395 --	memset(lzma_header + LZMA_PROPS_SIZE, 255, LZMA_UNCOMP_SIZE);
  2.1396 -+	*error = res;
  2.1397 -+	return res == LZMA_OK && size == (int) src_pos ? (int) dest_pos : -1;
  2.1398 -+}
  2.1399 - 
  2.1400 --	strm.next_out = dest;
  2.1401 --	strm.avail_out = block_size;
  2.1402 --	strm.next_in = lzma_header;
  2.1403 --	strm.avail_in = LZMA_HEADER_SIZE;
  2.1404 - 
  2.1405 --	res = lzma_code(&strm, LZMA_RUN);
  2.1406 -+struct compressor xz_comp_ops = {
  2.1407 -+	.init = xz_init,
  2.1408 -+	.compress = xz_compress,
  2.1409 -+	.uncompress = xz_uncompress,
  2.1410 -+	.options = xz_options,
  2.1411 -+	.usage = xz_usage,
  2.1412 -+	.id = XZ_COMPRESSION,
  2.1413 -+	.name = "xz",
  2.1414 -+	.supported = 1
  2.1415 -+};
  2.1416 - 
  2.1417 --	if(res != LZMA_OK || strm.avail_in != 0) {
  2.1418 --		lzma_end(&strm);
  2.1419 --		goto failed;
  2.1420 --	}
  2.1421 --
  2.1422 --	strm.next_in = src + LZMA_HEADER_SIZE;
  2.1423 --	strm.avail_in = size - LZMA_HEADER_SIZE;
  2.1424 --
  2.1425 --	res = lzma_code(&strm, LZMA_FINISH);
  2.1426 --	lzma_end(&strm);
  2.1427 --
  2.1428 --	if(res == LZMA_STREAM_END || (res == LZMA_OK &&
  2.1429 --		strm.total_out >= uncompressed_size && strm.avail_in == 0))
  2.1430 --		return uncompressed_size;
  2.1431 --
  2.1432 --failed:
  2.1433 --	*error = res;
  2.1434 --	return -1;
  2.1435 --}