wok rev 4702
squashfs: add lzma support
| author | Pascal Bellard <pascal.bellard@slitaz.org> |
|---|---|
| date | Sun Jan 03 18:38:54 2010 +0100 (2010-01-03) |
| parents | 0c0c693fe4c6 |
| children | 335b02e4e8c8 |
| files | squashfs/receipt squashfs/stuff/lzma.u |
line diff
1.1 --- a/squashfs/receipt Sun Jan 03 17:41:36 2010 +0100 1.2 +++ b/squashfs/receipt Sun Jan 03 18:38:54 2010 +0100 1.3 @@ -19,6 +19,16 @@ 1.4 1.5 cd $src/squashfs-tools 1.6 mkdir -p ../_pkg/usr/sbin ../_pkg/sbin 1.7 + if [ ! -d ../LZMA/lzma465 ]; then 1.8 + SF_MIRROR=http://switch.dl.sourceforge.net/sourceforge 1.9 + [ -s lzma465.tar.bz2 ] || 1.10 + wget $SF_MIRROR/sevenzip/lzma465.tar.bz2 1.11 + mkdir -p ../LZMA/lzma465 1.12 + tar xjf lzma465.tar.bz2 -C ../LZMA/lzma465 1.13 + fi 1.14 + if [ ! -f lzma_wrapper.c ]; then 1.15 + patch -p2 -i ../../stuff/lzma.u 1.16 + fi 1.17 make || return 1 1.18 cp mksquashfs ../_pkg/usr/sbin 1.19 cp unsquashfs ../_pkg/sbin
2.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000 2.2 +++ b/squashfs/stuff/lzma.u Sun Jan 03 18:38:54 2010 +0100 2.3 @@ -0,0 +1,2235 @@ 2.4 +--- squashfs-4.0/squashfs-tools/Makefile 2.5 ++++ squashfs-4.0/squashfs-tools/Makefile 2.6 +@@ -1,40 +1,76 @@ 2.7 ++# 2.8 ++# Building LZMA support 2.9 ++# Download LZMA sdk (4.65 used in development, other versions may work), 2.10 ++# set LZMA_DIR to unpacked source, and uncomment next line 2.11 ++LZMA_SUPPORT = 1 2.12 ++LZMA_DIR = ../LZMA/lzma465 2.13 ++ 2.14 ++#Compression default. 2.15 ++COMP_DEFAULT = gzip 2.16 ++ 2.17 ++INCLUDEDIR = -I. 2.18 + INSTALL_DIR = /usr/local/bin 2.19 + 2.20 +-INCLUDEDIR = . 2.21 ++MKSQUASHFS_OBJS = mksquashfs.o read_fs.o sort.o swap.o pseudo.o compressor.o \ 2.22 ++ gzip_wrapper.o 2.23 + 2.24 +-CFLAGS := -I$(INCLUDEDIR) -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_GNU_SOURCE -O2 2.25 ++UNSQUASHFS_OBJS = unsquashfs.o unsquash-1.o unsquash-2.o unsquash-3.o \ 2.26 ++ unsquash-4.o swap.o compressor.o gzip_wrapper.o 2.27 + 2.28 ++CFLAGS = $(INCLUDEDIR) -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE \ 2.29 ++ -D_GNU_SOURCE -DCOMP_DEFAULT=\"$(COMP_DEFAULT)\" -O2 -Wall 2.30 ++ 2.31 ++ifdef LZMA_SUPPORT 2.32 ++LZMA_OBJS = $(LZMA_DIR)/C/Alloc.o $(LZMA_DIR)/C/LzFind.o \ 2.33 ++ $(LZMA_DIR)/C/LzmaDec.o $(LZMA_DIR)/C/LzmaEnc.o $(LZMA_DIR)/C/LzmaLib.o 2.34 ++INCLUDEDIR += -I$(LZMA_DIR)/C 2.35 ++CFLAGS += -DLZMA_SUPPORT 2.36 ++MKSQUASHFS_OBJS += lzma_wrapper.o $(LZMA_OBJS) 2.37 ++UNSQUASHFS_OBJS += lzma_wrapper.o $(LZMA_OBJS) 2.38 ++endif 2.39 ++ 2.40 ++.PHONY: all 2.41 + all: mksquashfs unsquashfs 2.42 + 2.43 +-mksquashfs: mksquashfs.o read_fs.o sort.o swap.o pseudo.o 2.44 +- $(CC) mksquashfs.o read_fs.o sort.o swap.o pseudo.o -lz -lpthread -lm -o $@ 2.45 ++mksquashfs: $(MKSQUASHFS_OBJS) 2.46 ++ $(CC) $(MKSQUASHFS_OBJS) -lz -lpthread -lm -o $@ 2.47 + 2.48 +-mksquashfs.o: mksquashfs.c squashfs_fs.h mksquashfs.h global.h sort.h squashfs_swap.h Makefile 2.49 ++mksquashfs.o: mksquashfs.c squashfs_fs.h mksquashfs.h global.h sort.h \ 2.50 ++ squashfs_swap.h 2.51 + 2.52 +-read_fs.o: read_fs.c squashfs_fs.h read_fs.h global.h squashfs_swap.h Makefile 2.53 ++read_fs.o: read_fs.c squashfs_fs.h read_fs.h global.h squashfs_swap.h 2.54 + 2.55 +-sort.o: sort.c squashfs_fs.h global.h sort.h Makefile 2.56 ++sort.o: sort.c squashfs_fs.h global.h sort.h 2.57 + 2.58 +-swap.o: swap.c Makefile 2.59 ++swap.o: swap.c 2.60 + 2.61 +-pseudo.o: pseudo.c pseudo.h Makefile 2.62 ++pseudo.o: pseudo.c pseudo.h 2.63 + 2.64 +-unsquashfs: unsquashfs.o unsquash-1.o unsquash-2.o unsquash-3.o unsquash-4.o swap.o 2.65 +- $(CC) unsquashfs.o unsquash-1.o unsquash-2.o unsquash-3.o unsquash-4.o swap.o -lz -lpthread -lm -o $@ 2.66 ++compressor.o: compressor.c compressor.h 2.67 + 2.68 +-unsquashfs.o: unsquashfs.h unsquashfs.c squashfs_fs.h squashfs_swap.h squashfs_compat.h global.h Makefile 2.69 ++unsquashfs: $(UNSQUASHFS_OBJS) 2.70 ++ $(CC) $(UNSQUASHFS_OBJS) -lz -lpthread -lm -o $@ 2.71 + 2.72 +-unsquash-1.o: unsquashfs.h unsquash-1.c squashfs_fs.h squashfs_compat.h global.h Makefile 2.73 ++unsquashfs.o: unsquashfs.h unsquashfs.c squashfs_fs.h squashfs_swap.h \ 2.74 ++ squashfs_compat.h global.h 2.75 + 2.76 +-unsquash-2.o: unsquashfs.h unsquash-2.c unsquashfs.h squashfs_fs.h squashfs_compat.h global.h Makefile 2.77 ++unsquash-1.o: unsquashfs.h unsquash-1.c squashfs_fs.h squashfs_compat.h \ 2.78 ++ global.h 2.79 + 2.80 +-unsquash-3.o: unsquashfs.h unsquash-3.c squashfs_fs.h squashfs_compat.h global.h Makefile 2.81 ++unsquash-2.o: unsquashfs.h unsquash-2.c unsquashfs.h squashfs_fs.h \ 2.82 ++ squashfs_compat.h global.h 2.83 + 2.84 +-unsquash-4.o: unsquashfs.h unsquash-4.c squashfs_fs.h squashfs_swap.h global.h Makefile 2.85 ++unsquash-3.o: unsquashfs.h unsquash-3.c squashfs_fs.h squashfs_compat.h \ 2.86 ++ global.h 2.87 + 2.88 ++unsquash-4.o: unsquashfs.h unsquash-4.c squashfs_fs.h squashfs_swap.h \ 2.89 ++ global.h 2.90 ++ 2.91 ++.PHONY: clean 2.92 + clean: 2.93 + -rm -f *.o mksquashfs unsquashfs 2.94 + 2.95 ++.PHONY: install 2.96 + install: mksquashfs unsquashfs 2.97 + mkdir -p $(INSTALL_DIR) 2.98 + cp mksquashfs $(INSTALL_DIR) 2.99 + 2.100 +--- squashfs-4.0/squashfs-tools/compressor.c Thu Jan 1 01:00:00 1970 2.101 ++++ squashfs-4.0/squashfs-tools/compressor.c Sat Aug 29 03:05:34 2009 2.102 +@@ -0,0 +1,78 @@ 2.103 ++/* 2.104 ++ * 2.105 ++ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 2.106 ++ * Phillip Lougher <phillip@lougher.demon.co.uk> 2.107 ++ * 2.108 ++ * This program is free software; you can redistribute it and/or 2.109 ++ * modify it under the terms of the GNU General Public License 2.110 ++ * as published by the Free Software Foundation; either version 2, 2.111 ++ * or (at your option) any later version. 2.112 ++ * 2.113 ++ * This program is distributed in the hope that it will be useful, 2.114 ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of 2.115 ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 2.116 ++ * GNU General Public License for more details. 2.117 ++ * 2.118 ++ * You should have received a copy of the GNU General Public License 2.119 ++ * along with this program; if not, write to the Free Software 2.120 ++ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 2.121 ++ * 2.122 ++ * compressor.c 2.123 ++ */ 2.124 ++ 2.125 ++#include <stdio.h> 2.126 ++#include <string.h> 2.127 ++#include "compressor.h" 2.128 ++#include "squashfs_fs.h" 2.129 ++ 2.130 ++extern int gzip_compress(void **, char *, char *, int, int, int *); 2.131 ++extern int gzip_uncompress(char *, char *, int, int, int *); 2.132 ++extern int lzma_compress(void **, char *, char *, int, int, int *); 2.133 ++extern int lzma_uncompress(char *, char *, int, int, int *); 2.134 ++ 2.135 ++struct compressor compressor[] = { 2.136 ++ { gzip_compress, gzip_uncompress, ZLIB_COMPRESSION, "gzip", 1 }, 2.137 ++#ifdef LZMA_SUPPORT 2.138 ++ { lzma_compress, lzma_uncompress, LZMA_COMPRESSION, "lzma", 1 }, 2.139 ++#else 2.140 ++ { NULL, NULL, LZMA_COMPRESSION, "lzma", 0 }, 2.141 ++#endif 2.142 ++ { NULL, NULL , 0, "unknown", 0} 2.143 ++}; 2.144 ++ 2.145 ++ 2.146 ++struct compressor *lookup_compressor(char *name) 2.147 ++{ 2.148 ++ int i; 2.149 ++ 2.150 ++ for(i = 0; compressor[i].id; i++) 2.151 ++ if(strcmp(compressor[i].name, name) == 0) 2.152 ++ break; 2.153 ++ 2.154 ++ return &compressor[i]; 2.155 ++} 2.156 ++ 2.157 ++ 2.158 ++struct compressor *lookup_compressor_id(int id) 2.159 ++{ 2.160 ++ int i; 2.161 ++ 2.162 ++ for(i = 0; compressor[i].id; i++) 2.163 ++ if(id == compressor[i].id) 2.164 ++ break; 2.165 ++ 2.166 ++ return &compressor[i]; 2.167 ++} 2.168 ++ 2.169 ++ 2.170 ++void display_compressors(char *indent, char *def_comp) 2.171 ++{ 2.172 ++ int i; 2.173 ++ 2.174 ++ for(i = 0; compressor[i].id; i++) 2.175 ++ if(compressor[i].supported) 2.176 ++ fprintf(stderr, "%s\t%s%s\n", indent, 2.177 ++ compressor[i].name, 2.178 ++ strcmp(compressor[i].name, def_comp) == 0 ? 2.179 ++ " (default)" : ""); 2.180 ++} 2.181 + 2.182 +--- squashfs-4.0/squashfs-tools/compressor.h Thu Jan 1 01:00:00 1970 2.183 ++++ squashfs-4.0/squashfs-tools/compressor.h Mon Aug 24 20:28:04 2009 2.184 +@@ -0,0 +1,33 @@ 2.185 ++/* 2.186 ++ * 2.187 ++ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 2.188 ++ * Phillip Lougher <phillip@lougher.demon.co.uk> 2.189 ++ * 2.190 ++ * This program is free software; you can redistribute it and/or 2.191 ++ * modify it under the terms of the GNU General Public License 2.192 ++ * as published by the Free Software Foundation; either version 2, 2.193 ++ * or (at your option) any later version. 2.194 ++ * 2.195 ++ * This program is distributed in the hope that it will be useful, 2.196 ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of 2.197 ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 2.198 ++ * GNU General Public License for more details. 2.199 ++ * 2.200 ++ * You should have received a copy of the GNU General Public License 2.201 ++ * along with this program; if not, write to the Free Software 2.202 ++ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 2.203 ++ * 2.204 ++ * compressor.h 2.205 ++ */ 2.206 ++ 2.207 ++struct compressor { 2.208 ++ int (*compress)(void **, char *, char *, int, int, int *); 2.209 ++ int (*uncompress)(char *, char *, int, int, int *); 2.210 ++ int id; 2.211 ++ char *name; 2.212 ++ int supported; 2.213 ++}; 2.214 ++ 2.215 ++extern struct compressor *lookup_compressor(char *); 2.216 ++extern struct compressor *lookup_compressor_id(int); 2.217 ++extern void display_compressors(char *, char *); 2.218 + 2.219 +--- squashfs-4.0/squashfs-tools/gzip_wrapper.c Thu Jan 1 01:00:00 1970 2.220 ++++ squashfs-4.0/squashfs-tools/gzip_wrapper.c Fri Aug 7 22:12:53 2009 2.221 +@@ -0,0 +1,80 @@ 2.222 ++/* 2.223 ++ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 2.224 ++ * Phillip Lougher <phillip@lougher.demon.co.uk> 2.225 ++ * 2.226 ++ * This program is free software; you can redistribute it and/or 2.227 ++ * modify it under the terms of the GNU General Public License 2.228 ++ * as published by the Free Software Foundation; either version 2, 2.229 ++ * or (at your option) any later version. 2.230 ++ * 2.231 ++ * This program is distributed in the hope that it will be useful, 2.232 ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of 2.233 ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 2.234 ++ * GNU General Public License for more details. 2.235 ++ * 2.236 ++ * You should have received a copy of the GNU General Public License 2.237 ++ * along with this program; if not, write to the Free Software 2.238 ++ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 2.239 ++ * 2.240 ++ * gzip_wrapper.c 2.241 ++ */ 2.242 ++ 2.243 ++#include <stdlib.h> 2.244 ++#include <zlib.h> 2.245 ++ 2.246 ++int gzip_compress(void **strm, char *d, char *s, int size, int block_size, 2.247 ++ int *error) 2.248 ++{ 2.249 ++ int res = 0; 2.250 ++ z_stream *stream = *strm; 2.251 ++ 2.252 ++ if(stream == NULL) { 2.253 ++ if((stream = *strm = malloc(sizeof(z_stream))) == NULL) 2.254 ++ goto failed; 2.255 ++ 2.256 ++ stream->zalloc = Z_NULL; 2.257 ++ stream->zfree = Z_NULL; 2.258 ++ stream->opaque = 0; 2.259 ++ 2.260 ++ if((res = deflateInit(stream, 9)) != Z_OK) 2.261 ++ goto failed; 2.262 ++ } else if((res = deflateReset(stream)) != Z_OK) 2.263 ++ goto failed; 2.264 ++ 2.265 ++ stream->next_in = (unsigned char *) s; 2.266 ++ stream->avail_in = size; 2.267 ++ stream->next_out = (unsigned char *) d; 2.268 ++ stream->avail_out = block_size; 2.269 ++ 2.270 ++ res = deflate(stream, Z_FINISH); 2.271 ++ if(res == Z_STREAM_END) 2.272 ++ /* 2.273 ++ * Success, return the compressed size. 2.274 ++ */ 2.275 ++ return (int) stream->total_out; 2.276 ++ if(res == Z_OK) 2.277 ++ /* 2.278 ++ * Output buffer overflow. Return out of buffer space 2.279 ++ */ 2.280 ++ return 0; 2.281 ++failed: 2.282 ++ /* 2.283 ++ * All other errors return failure, with the compressor 2.284 ++ * specific error code in *error 2.285 ++ */ 2.286 ++ *error = res; 2.287 ++ return -1; 2.288 ++} 2.289 ++ 2.290 ++ 2.291 ++int gzip_uncompress(char *d, char *s, int size, int block_size, int *error) 2.292 ++{ 2.293 ++ int res; 2.294 ++ unsigned long bytes = block_size; 2.295 ++ 2.296 ++ res = uncompress((unsigned char *) d, &bytes, 2.297 ++ (const unsigned char *) s, size); 2.298 ++ 2.299 ++ *error = res; 2.300 ++ return res == Z_OK ? (int) bytes : -1; 2.301 ++} 2.302 + 2.303 +--- squashfs-4.0/squashfs-tools/lzma_wrapper.c Thu Jan 1 01:00:00 1970 2.304 ++++ squashfs-4.0/squashfs-tools/lzma_wrapper.c Wed Oct 14 05:32:57 2009 2.305 +@@ -0,0 +1,93 @@ 2.306 ++/* 2.307 ++ * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 2.308 ++ * Phillip Lougher <phillip@lougher.demon.co.uk> 2.309 ++ * 2.310 ++ * This program is free software; you can redistribute it and/or 2.311 ++ * modify it under the terms of the GNU General Public License 2.312 ++ * as published by the Free Software Foundation; either version 2, 2.313 ++ * or (at your option) any later version. 2.314 ++ * 2.315 ++ * This program is distributed in the hope that it will be useful, 2.316 ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of 2.317 ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 2.318 ++ * GNU General Public License for more details. 2.319 ++ * 2.320 ++ * You should have received a copy of the GNU General Public License 2.321 ++ * along with this program; if not, write to the Free Software 2.322 ++ * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 2.323 ++ * 2.324 ++ * lzma_wrapper.c 2.325 ++ */ 2.326 ++ 2.327 ++#include <LzmaLib.h> 2.328 ++ 2.329 ++#define LZMA_HEADER_SIZE (LZMA_PROPS_SIZE + 8) 2.330 ++ 2.331 ++int lzma_compress(void **strm, char *dest, char *src, int size,int block_size, 2.332 ++ int *error) 2.333 ++{ 2.334 ++ unsigned char *d = (unsigned char *) dest, *s = (unsigned char *) src; 2.335 ++ size_t props_size = LZMA_PROPS_SIZE, 2.336 ++ outlen = block_size - LZMA_HEADER_SIZE; 2.337 ++ int res; 2.338 ++ 2.339 ++ res = LzmaCompress(d + LZMA_HEADER_SIZE, &outlen, s, size, d, 2.340 ++ &props_size, 5, block_size, 3, 0, 2, 32, 1); 2.341 ++ 2.342 ++ if(res == SZ_ERROR_OUTPUT_EOF) { 2.343 ++ /* 2.344 ++ * Output buffer overflow. Return out of buffer space error 2.345 ++ */ 2.346 ++ return 0; 2.347 ++ } 2.348 ++ 2.349 ++ if(res != SZ_OK) { 2.350 ++ /* 2.351 ++ * All other errors return failure, with the compressor 2.352 ++ * specific error code in *error 2.353 ++ */ 2.354 ++ *error = res; 2.355 ++ return -1; 2.356 ++ } 2.357 ++ 2.358 ++ /* 2.359 ++ * Fill in the 8 byte little endian uncompressed size field in the 2.360 ++ * LZMA header. 8 bytes is excessively large for squashfs but 2.361 ++ * this is the standard LZMA header and which is expected by the kernel 2.362 ++ * code 2.363 ++ */ 2.364 ++ d[LZMA_PROPS_SIZE] = size & 255; 2.365 ++ d[LZMA_PROPS_SIZE + 1] = (size >> 8) & 255; 2.366 ++ d[LZMA_PROPS_SIZE + 2] = (size >> 16) & 255; 2.367 ++ d[LZMA_PROPS_SIZE + 3] = (size >> 24) & 255; 2.368 ++ d[LZMA_PROPS_SIZE + 4] = 0; 2.369 ++ d[LZMA_PROPS_SIZE + 5] = 0; 2.370 ++ d[LZMA_PROPS_SIZE + 6] = 0; 2.371 ++ d[LZMA_PROPS_SIZE + 7] = 0; 2.372 ++ 2.373 ++ /* 2.374 ++ * Success, return the compressed size. Outlen returned by the LZMA 2.375 ++ * compressor does not include the LZMA header space 2.376 ++ */ 2.377 ++ return outlen + LZMA_HEADER_SIZE; 2.378 ++} 2.379 ++ 2.380 ++ 2.381 ++int lzma_uncompress(char *dest, char *src, int size, int block_size, 2.382 ++ int *error) 2.383 ++{ 2.384 ++ unsigned char *d = (unsigned char *) dest, *s = (unsigned char *) src; 2.385 ++ size_t outlen, inlen = size - LZMA_HEADER_SIZE; 2.386 ++ int res; 2.387 ++ 2.388 ++ outlen = s[LZMA_PROPS_SIZE] | 2.389 ++ (s[LZMA_PROPS_SIZE + 1] << 8) | 2.390 ++ (s[LZMA_PROPS_SIZE + 2] << 16) | 2.391 ++ (s[LZMA_PROPS_SIZE + 3] << 24); 2.392 ++ 2.393 ++ res = LzmaUncompress(d, &outlen, s + LZMA_HEADER_SIZE, &inlen, 2.394 ++ s, LZMA_PROPS_SIZE); 2.395 ++ 2.396 ++ *error = res; 2.397 ++ return res == SZ_OK ? outlen : -1; 2.398 ++} 2.399 + 2.400 +--- squashfs-4.0/squashfs-tools/mksquashfs.c Sun Apr 5 23:22:48 2009 2.401 ++++ squashfs-4.0/squashfs-tools/mksquashfs.c Tue Dec 8 19:02:54 2009 2.402 +@@ -36,7 +36,6 @@ 2.403 + #include <errno.h> 2.404 + #include <dirent.h> 2.405 + #include <string.h> 2.406 +-#include <zlib.h> 2.407 + #include <stdlib.h> 2.408 + #include <signal.h> 2.409 + #include <setjmp.h> 2.410 +@@ -47,6 +46,7 @@ 2.411 + #include <math.h> 2.412 + #include <regex.h> 2.413 + #include <fnmatch.h> 2.414 ++#include <sys/wait.h> 2.415 + 2.416 + #ifndef linux 2.417 + #define __BYTE_ORDER BYTE_ORDER 2.418 +@@ -64,6 +64,7 @@ 2.419 + #include "global.h" 2.420 + #include "sort.h" 2.421 + #include "pseudo.h" 2.422 ++#include "compressor.h" 2.423 + 2.424 + #ifdef SQUASHFS_TRACE 2.425 + #define TRACE(s, args...) do { \ 2.426 +@@ -245,10 +246,8 @@ 2.427 + /* list of root directory entries read from original filesystem */ 2.428 + int old_root_entries = 0; 2.429 + struct old_root_entry_info { 2.430 +- char name[SQUASHFS_NAME_LEN + 1]; 2.431 +- squashfs_inode inode; 2.432 +- int type; 2.433 +- int inode_number; 2.434 ++ char *name; 2.435 ++ struct inode_info inode; 2.436 + }; 2.437 + struct old_root_entry_info *old_root_entry; 2.438 + 2.439 +@@ -371,10 +370,15 @@ 2.440 + int reader_buffer_size; 2.441 + int fragment_buffer_size; 2.442 + 2.443 ++/* compression operations structure */ 2.444 ++static struct compressor *comp; 2.445 ++char *comp_name = COMP_DEFAULT; 2.446 ++ 2.447 + char *read_from_disk(long long start, unsigned int avail_bytes); 2.448 + void add_old_root_entry(char *name, squashfs_inode inode, int inode_number, 2.449 + int type); 2.450 +-extern int read_super(int fd, squashfs_super_block *sBlk, char *source); 2.451 ++extern struct compressor *read_super(int fd, squashfs_super_block *sBlk, 2.452 ++ char *source); 2.453 + extern long long read_filesystem(char *root_name, int fd, 2.454 + squashfs_super_block *sBlk, char **cinode_table, char **data_cache, 2.455 + char **cdirectory_table, char **directory_data_cache, 2.456 +@@ -831,83 +835,32 @@ 2.457 + } 2.458 + 2.459 + 2.460 +-unsigned int mangle2(z_stream **strm, char *d, char *s, int size, 2.461 ++int mangle2(void **strm, char *d, char *s, int size, 2.462 + int block_size, int uncompressed, int data_block) 2.463 + { 2.464 +- unsigned long c_byte; 2.465 +- unsigned int res; 2.466 +- z_stream *stream = *strm; 2.467 ++ int error, c_byte = 0; 2.468 + 2.469 +- if(uncompressed) 2.470 +- goto notcompressed; 2.471 +- 2.472 +- if(stream == NULL) { 2.473 +- if((stream = *strm = malloc(sizeof(z_stream))) == NULL) 2.474 +- BAD_ERROR("mangle::compress failed, not enough " 2.475 +- "memory\n"); 2.476 +- 2.477 +- stream->zalloc = Z_NULL; 2.478 +- stream->zfree = Z_NULL; 2.479 +- stream->opaque = 0; 2.480 +- 2.481 +- if((res = deflateInit(stream, 9)) != Z_OK) { 2.482 +- if(res == Z_MEM_ERROR) 2.483 +- BAD_ERROR("zlib::compress failed, not enough " 2.484 +- "memory\n"); 2.485 +- else if(res == Z_STREAM_ERROR) 2.486 +- BAD_ERROR("zlib::compress failed, not a valid " 2.487 +- "compression level\n"); 2.488 +- else if(res == Z_VERSION_ERROR) 2.489 +- BAD_ERROR("zlib::compress failed, incorrect " 2.490 +- "zlib version\n"); 2.491 +- else 2.492 +- BAD_ERROR("zlib::compress failed, unknown " 2.493 +- "error %d\n", res); 2.494 +- } 2.495 +- } else if((res = deflateReset(stream)) != Z_OK) { 2.496 +- if(res == Z_STREAM_ERROR) 2.497 +- BAD_ERROR("zlib::compress failed, stream state " 2.498 +- "inconsistent\n"); 2.499 +- else 2.500 +- BAD_ERROR("zlib::compress failed, unknown error %d\n", 2.501 +- res); 2.502 ++ if(!uncompressed) { 2.503 ++ c_byte = comp->compress(strm, d, s, size, block_size, &error); 2.504 ++ if(c_byte == -1) 2.505 ++ BAD_ERROR("mangle2:: %s compress failed with error " 2.506 ++ "code %d\n", comp->name, error); 2.507 + } 2.508 + 2.509 +- stream->next_in = (unsigned char *) s; 2.510 +- stream->avail_in = size; 2.511 +- stream->next_out = (unsigned char *) d; 2.512 +- stream->avail_out = block_size; 2.513 +- 2.514 +- res = deflate(stream, Z_FINISH); 2.515 +- if(res != Z_STREAM_END && res != Z_OK) { 2.516 +- if(res == Z_STREAM_ERROR) 2.517 +- BAD_ERROR("zlib::compress failed, stream state " 2.518 +- "inconsistent\n"); 2.519 +- else if(res == Z_BUF_ERROR) 2.520 +- BAD_ERROR("zlib::compress failed, no progress possible" 2.521 +- "\n"); 2.522 +- else 2.523 +- BAD_ERROR("zlib::compress failed, unknown error %d\n", 2.524 +- res); 2.525 +- } 2.526 +- 2.527 +- c_byte = stream->total_out; 2.528 +- 2.529 +- if(res != Z_STREAM_END || c_byte >= size) { 2.530 +-notcompressed: 2.531 ++ if(c_byte == 0 || c_byte >= size) { 2.532 + memcpy(d, s, size); 2.533 + return size | (data_block ? SQUASHFS_COMPRESSED_BIT_BLOCK : 2.534 + SQUASHFS_COMPRESSED_BIT); 2.535 + } 2.536 + 2.537 +- return (unsigned int) c_byte; 2.538 ++ return c_byte; 2.539 + } 2.540 + 2.541 + 2.542 +-unsigned int mangle(char *d, char *s, int size, int block_size, 2.543 ++int mangle(char *d, char *s, int size, int block_size, 2.544 + int uncompressed, int data_block) 2.545 + { 2.546 +- static z_stream *stream = NULL; 2.547 ++ static void *stream = NULL; 2.548 + 2.549 + return mangle2(&stream, d, s, size, block_size, uncompressed, 2.550 + data_block); 2.551 +@@ -1660,8 +1613,7 @@ 2.552 + pthread_mutex_unlock(&fragment_mutex); 2.553 + 2.554 + if(SQUASHFS_COMPRESSED_BLOCK(disk_fragment->size)) { 2.555 +- int res; 2.556 +- unsigned long bytes = block_size; 2.557 ++ int error, res; 2.558 + char *data; 2.559 + 2.560 + if(compressed_buffer) 2.561 +@@ -1669,19 +1621,11 @@ 2.562 + else 2.563 + data = read_from_disk(start_block, size); 2.564 + 2.565 +- res = uncompress((unsigned char *) buffer->data, &bytes, 2.566 +- (const unsigned char *) data, size); 2.567 +- if(res != Z_OK) { 2.568 +- if(res == Z_MEM_ERROR) 2.569 +- BAD_ERROR("zlib::uncompress failed, not enough " 2.570 +- "memory\n"); 2.571 +- else if(res == Z_BUF_ERROR) 2.572 +- BAD_ERROR("zlib::uncompress failed, not enough " 2.573 +- "room in output buffer\n"); 2.574 +- else 2.575 +- BAD_ERROR("zlib::uncompress failed," 2.576 +- " unknown error %d\n", res); 2.577 +- } 2.578 ++ res = comp->uncompress(buffer->data, data, size, block_size, 2.579 ++ &error); 2.580 ++ if(res == -1) 2.581 ++ BAD_ERROR("%s uncompress failed with error code %d\n", 2.582 ++ comp->name, error); 2.583 + } else if(compressed_buffer) 2.584 + memcpy(buffer->data, compressed_buffer->data, size); 2.585 + else 2.586 +@@ -1733,9 +1677,7 @@ 2.587 + entry->buffer->block = bytes; 2.588 + bytes += compressed_size; 2.589 + fragments_outstanding --; 2.590 +- pthread_mutex_unlock(&fragment_mutex); 2.591 + queue_put(to_writer, entry->buffer); 2.592 +- pthread_mutex_lock(&fragment_mutex); 2.593 + TRACE("fragment_locked writing fragment %d, compressed size %d" 2.594 + "\n", entry->fragment, compressed_size); 2.595 + free(entry); 2.596 +@@ -1758,6 +1700,8 @@ 2.597 + pthread_mutex_lock(&fragment_mutex); 2.598 + insert_fragment_list(&frag_locked_list, entry); 2.599 + pthread_mutex_unlock(&fragment_mutex); 2.600 ++ 2.601 ++ return TRUE; 2.602 + } 2.603 + 2.604 + 2.605 +@@ -1824,7 +1768,9 @@ 2.606 + unsigned short c_byte; 2.607 + char cbuffer[(SQUASHFS_METADATA_SIZE << 2) + 2]; 2.608 + 2.609 ++#ifdef SQUASHFS_TRACE 2.610 + long long obytes = bytes; 2.611 ++#endif 2.612 + 2.613 + for(i = 0; i < meta_blocks; i++) { 2.614 + int avail_bytes = length > SQUASHFS_METADATA_SIZE ? 2.615 +@@ -2170,11 +2116,85 @@ 2.616 + } 2.617 + 2.618 + 2.619 ++static int seq = 0; 2.620 ++void reader_read_process(struct dir_ent *dir_ent) 2.621 ++{ 2.622 ++ struct file_buffer *prev_buffer = NULL, *file_buffer; 2.623 ++ int status, res, byte, count = 0; 2.624 ++ int file = get_pseudo_file(dir_ent->inode->pseudo_id)->fd; 2.625 ++ int child = get_pseudo_file(dir_ent->inode->pseudo_id)->child; 2.626 ++ long long bytes = 0; 2.627 ++ 2.628 ++ while(1) { 2.629 ++ file_buffer = cache_get(reader_buffer, 0, 0); 2.630 ++ file_buffer->sequence = seq ++; 2.631 ++ 2.632 ++ byte = read_bytes(file, file_buffer->data, block_size); 2.633 ++ if(byte == -1) 2.634 ++ goto read_err; 2.635 ++ 2.636 ++ file_buffer->size = byte; 2.637 ++ file_buffer->file_size = -1; 2.638 ++ file_buffer->block = count ++; 2.639 ++ file_buffer->error = FALSE; 2.640 ++ file_buffer->fragment = FALSE; 2.641 ++ bytes += byte; 2.642 ++ 2.643 ++ if(byte == 0) 2.644 ++ break; 2.645 ++ 2.646 ++ /* 2.647 ++ * Update estimated_uncompressed block count. This is done 2.648 ++ * on every block rather than waiting for all blocks to be 2.649 ++ * read incase write_file_process() is running in parallel 2.650 ++ * with this. Otherwise cur uncompressed block count may 2.651 ++ * get ahead of the total uncompressed block count. 2.652 ++ */ 2.653 ++ estimated_uncompressed ++; 2.654 ++ 2.655 ++ if(prev_buffer) 2.656 ++ queue_put(from_reader, prev_buffer); 2.657 ++ prev_buffer = file_buffer; 2.658 ++ } 2.659 ++ 2.660 ++ /* 2.661 ++ * Update inode file size now that the size of the dynamic pseudo file 2.662 ++ * is known. This is needed for the -info option. 2.663 ++ */ 2.664 ++ dir_ent->inode->buf.st_size = bytes; 2.665 ++ 2.666 ++ res = waitpid(child, &status, 0); 2.667 ++ if(res == -1 || !WIFEXITED(status) || WEXITSTATUS(status) != 0) 2.668 ++ goto read_err; 2.669 ++ 2.670 ++ if(prev_buffer == NULL) 2.671 ++ prev_buffer = file_buffer; 2.672 ++ else { 2.673 ++ cache_block_put(file_buffer); 2.674 ++ seq --; 2.675 ++ } 2.676 ++ prev_buffer->file_size = bytes; 2.677 ++ prev_buffer->fragment = !no_fragments && 2.678 ++ (count == 2 || always_use_fragments) && (byte < block_size); 2.679 ++ queue_put(from_reader, prev_buffer); 2.680 ++ 2.681 ++ return; 2.682 ++ 2.683 ++read_err: 2.684 ++ if(prev_buffer) { 2.685 ++ cache_block_put(file_buffer); 2.686 ++ seq --; 2.687 ++ file_buffer = prev_buffer; 2.688 ++ } 2.689 ++ file_buffer->error = TRUE; 2.690 ++ queue_put(from_deflate, file_buffer); 2.691 ++} 2.692 ++ 2.693 ++ 2.694 + void reader_read_file(struct dir_ent *dir_ent) 2.695 + { 2.696 + struct stat *buf = &dir_ent->inode->buf, buf2; 2.697 + struct file_buffer *file_buffer; 2.698 +- static int index = 0; 2.699 + int blocks, byte, count, expected, file, frag_block; 2.700 + long long bytes, read_size; 2.701 + 2.702 +@@ -2202,7 +2222,7 @@ 2.703 + if(file_buffer) 2.704 + queue_put(from_reader, file_buffer); 2.705 + file_buffer = cache_get(reader_buffer, 0, 0); 2.706 +- file_buffer->sequence = index ++; 2.707 ++ file_buffer->sequence = seq ++; 2.708 + 2.709 + byte = file_buffer->size = read_bytes(file, file_buffer->data, 2.710 + block_size); 2.711 +@@ -2238,7 +2258,7 @@ 2.712 + 2.713 + read_err: 2.714 + file_buffer = cache_get(reader_buffer, 0, 0); 2.715 +- file_buffer->sequence = index ++; 2.716 ++ file_buffer->sequence = seq ++; 2.717 + read_err2: 2.718 + file_buffer->error = TRUE; 2.719 + queue_put(from_deflate, file_buffer); 2.720 +@@ -2262,9 +2282,14 @@ 2.721 + for(i = 0; i < dir->count; i++) { 2.722 + struct dir_ent *dir_ent = dir->list[i]; 2.723 + struct stat *buf = &dir_ent->inode->buf; 2.724 +- if(dir_ent->data) 2.725 ++ if(dir_ent->inode->root_entry) 2.726 + continue; 2.727 + 2.728 ++ if(dir_ent->inode->pseudo_file) { 2.729 ++ reader_read_process(dir_ent); 2.730 ++ continue; 2.731 ++ } 2.732 ++ 2.733 + switch(buf->st_mode & S_IFMT) { 2.734 + case S_IFREG: 2.735 + reader_read_file(dir_ent); 2.736 +@@ -2365,7 +2390,7 @@ 2.737 + 2.738 + void *deflator(void *arg) 2.739 + { 2.740 +- z_stream *stream = NULL; 2.741 ++ void *stream = NULL; 2.742 + int oldstate; 2.743 + 2.744 + pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate); 2.745 +@@ -2402,7 +2427,7 @@ 2.746 + 2.747 + void *frag_deflator(void *arg) 2.748 + { 2.749 +- z_stream *stream = NULL; 2.750 ++ void *stream = NULL; 2.751 + int oldstate; 2.752 + 2.753 + pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate); 2.754 +@@ -2426,8 +2451,8 @@ 2.755 + write_buffer->block = bytes; 2.756 + bytes += compressed_size; 2.757 + fragments_outstanding --; 2.758 +- pthread_mutex_unlock(&fragment_mutex); 2.759 + queue_put(to_writer, write_buffer); 2.760 ++ pthread_mutex_unlock(&fragment_mutex); 2.761 + TRACE("Writing fragment %lld, uncompressed size %d, " 2.762 + "compressed size %d\n", file_buffer->block, 2.763 + file_buffer->size, compressed_size); 2.764 +@@ -2674,6 +2699,98 @@ 2.765 + } 2.766 + 2.767 + 2.768 ++int write_file_process(squashfs_inode *inode, struct dir_ent *dir_ent, 2.769 ++ struct file_buffer *read_buffer, int *duplicate_file) 2.770 ++{ 2.771 ++ long long read_size, file_bytes, start; 2.772 ++ struct fragment *fragment; 2.773 ++ unsigned int *block_list = NULL; 2.774 ++ int block = 0, status; 2.775 ++ long long sparse = 0; 2.776 ++ struct file_buffer *fragment_buffer = NULL; 2.777 ++ 2.778 ++ *duplicate_file = FALSE; 2.779 ++ 2.780 ++ lock_fragments(); 2.781 ++ 2.782 ++ file_bytes = 0; 2.783 ++ start = bytes; 2.784 ++ while (1) { 2.785 ++ read_size = read_buffer->file_size; 2.786 ++ if(read_buffer->fragment && read_buffer->c_byte) 2.787 ++ fragment_buffer = read_buffer; 2.788 ++ else { 2.789 ++ block_list = realloc(block_list, (block + 1) * 2.790 ++ sizeof(unsigned int)); 2.791 ++ if(block_list == NULL) 2.792 ++ BAD_ERROR("Out of memory allocating block_list" 2.793 ++ "\n"); 2.794 ++ block_list[block ++] = read_buffer->c_byte; 2.795 ++ if(read_buffer->c_byte) { 2.796 ++ read_buffer->block = bytes; 2.797 ++ bytes += read_buffer->size; 2.798 ++ cache_rehash(read_buffer, read_buffer->block); 2.799 ++ file_bytes += read_buffer->size; 2.800 ++ queue_put(to_writer, read_buffer); 2.801 ++ } else { 2.802 ++ sparse += read_buffer->size; 2.803 ++ cache_block_put(read_buffer); 2.804 ++ } 2.805 ++ } 2.806 ++ inc_progress_bar(); 2.807 ++ 2.808 ++ if(read_size != -1) 2.809 ++ break; 2.810 ++ 2.811 ++ read_buffer = get_file_buffer(from_deflate); 2.812 ++ if(read_buffer->error) 2.813 ++ goto read_err; 2.814 ++ } 2.815 ++ 2.816 ++ unlock_fragments(); 2.817 ++ fragment = get_and_fill_fragment(fragment_buffer); 2.818 ++ cache_block_put(fragment_buffer); 2.819 ++ 2.820 ++ if(duplicate_checking) 2.821 ++ add_non_dup(read_size, file_bytes, block_list, start, fragment, 2.822 ++ 0, 0, FALSE); 2.823 ++ file_count ++; 2.824 ++ total_bytes += read_size; 2.825 ++ 2.826 ++ if(read_size < (1LL << 32) && start < (1LL << 32) && sparse == 0) 2.827 ++ create_inode(inode, dir_ent, SQUASHFS_FILE_TYPE, read_size, 2.828 ++ start, block, block_list, fragment, NULL, 0); 2.829 ++ else 2.830 ++ create_inode(inode, dir_ent, SQUASHFS_LREG_TYPE, read_size, 2.831 ++ start, block, block_list, fragment, NULL, sparse); 2.832 ++ 2.833 ++ if(duplicate_checking == FALSE) 2.834 ++ free(block_list); 2.835 ++ 2.836 ++ return 0; 2.837 ++ 2.838 ++read_err: 2.839 ++ cur_uncompressed -= block; 2.840 ++ status = read_buffer->error; 2.841 ++ bytes = start; 2.842 ++ if(!block_device) { 2.843 ++ int res; 2.844 ++ 2.845 ++ queue_put(to_writer, NULL); 2.846 ++ if(queue_get(from_writer) != 0) 2.847 ++ EXIT_MKSQUASHFS(); 2.848 ++ res = ftruncate(fd, bytes); 2.849 ++ if(res != 0) 2.850 ++ BAD_ERROR("Failed to truncate dest file because %s\n", 2.851 ++ strerror(errno)); 2.852 ++ } 2.853 ++ unlock_fragments(); 2.854 ++ free(block_list); 2.855 ++ cache_block_put(read_buffer); 2.856 ++ return status; 2.857 ++} 2.858 ++ 2.859 ++ 2.860 + int write_file_blocks(squashfs_inode *inode, struct dir_ent *dir_ent, 2.861 + long long read_size, struct file_buffer *read_buffer, 2.862 + int *duplicate_file) 2.863 +@@ -2941,7 +3058,10 @@ 2.864 + 2.865 + read_size = read_buffer->file_size; 2.866 + 2.867 +- if(read_size == 0) { 2.868 ++ if(read_size == -1) 2.869 ++ status = write_file_process(inode, dir_ent, read_buffer, 2.870 ++ duplicate_file); 2.871 ++ else if(read_size == 0) { 2.872 + write_file_empty(inode, dir_ent, duplicate_file); 2.873 + cache_block_put(read_buffer); 2.874 + } else if(read_buffer->fragment && read_buffer->c_byte) 2.875 +@@ -3036,6 +3156,8 @@ 2.876 + 2.877 + memcpy(&inode->buf, buf, sizeof(struct stat)); 2.878 + inode->read = FALSE; 2.879 ++ inode->root_entry = FALSE; 2.880 ++ inode->pseudo_file = FALSE; 2.881 + inode->inode = SQUASHFS_INVALID_BLK; 2.882 + inode->nlink = 1; 2.883 + 2.884 +@@ -3056,7 +3178,7 @@ 2.885 + 2.886 + 2.887 + inline void add_dir_entry(char *name, char *pathname, struct dir_info *sub_dir, 2.888 +- struct inode_info *inode_info, void *data, struct dir_info *dir) 2.889 ++ struct inode_info *inode_info, struct dir_info *dir) 2.890 + { 2.891 + if((dir->count % DIR_ENTRIES) == 0) { 2.892 + dir->list = realloc(dir->list, (dir->count + DIR_ENTRIES) * 2.893 +@@ -3075,8 +3197,7 @@ 2.894 + NULL; 2.895 + dir->list[dir->count]->inode = inode_info; 2.896 + dir->list[dir->count]->dir = sub_dir; 2.897 +- dir->list[dir->count]->our_dir = dir; 2.898 +- dir->list[dir->count++]->data = data; 2.899 ++ dir->list[dir->count++]->our_dir = dir; 2.900 + dir->byte_count += strlen(name) + sizeof(squashfs_dir_entry); 2.901 + } 2.902 + 2.903 +@@ -3128,10 +3249,10 @@ 2.904 + 2.905 + if(dir->count < old_root_entries) 2.906 + for(i = 0; i < old_root_entries; i++) { 2.907 +- if(old_root_entry[i].type == SQUASHFS_DIR_TYPE) 2.908 ++ if(old_root_entry[i].inode.type == SQUASHFS_DIR_TYPE) 2.909 + dir->directory_count ++; 2.910 +- add_dir_entry(old_root_entry[i].name, "", NULL, NULL, 2.911 +- &old_root_entry[i], dir); 2.912 ++ add_dir_entry(old_root_entry[i].name, "", NULL, 2.913 ++ &old_root_entry[i].inode, dir); 2.914 + } 2.915 + 2.916 + while(index < source) { 2.917 +@@ -3167,10 +3288,10 @@ 2.918 + 2.919 + if(dir->count < old_root_entries) 2.920 + for(i = 0; i < old_root_entries; i++) { 2.921 +- if(old_root_entry[i].type == SQUASHFS_DIR_TYPE) 2.922 ++ if(old_root_entry[i].inode.type == SQUASHFS_DIR_TYPE) 2.923 + dir->directory_count ++; 2.924 +- add_dir_entry(old_root_entry[i].name, "", NULL, NULL, 2.925 +- &old_root_entry[i], dir); 2.926 ++ add_dir_entry(old_root_entry[i].name, "", NULL, 2.927 ++ &old_root_entry[i].inode, dir); 2.928 + } 2.929 + 2.930 + if((d_name = readdir(dir->linuxdir)) != NULL) { 2.931 +@@ -3215,7 +3336,7 @@ 2.932 + int current_count; 2.933 + 2.934 + while((current_count = dir_info->current_count++) < dir_info->count) 2.935 +- if(dir_info->list[current_count]->data) 2.936 ++ if(dir_info->list[current_count]->inode->root_entry) 2.937 + continue; 2.938 + else 2.939 + return dir_info->list[current_count]; 2.940 +@@ -3240,11 +3361,11 @@ 2.941 + int current_count; 2.942 + 2.943 + while((current_count = dir_info->current_count++) < dir_info->count) 2.944 +- if(dir_info->list[current_count]->data) 2.945 +- add_dir(dir_info->list[current_count]->data->inode, 2.946 +- dir_info->list[current_count]->data->inode_number, 2.947 ++ if(dir_info->list[current_count]->inode->root_entry) 2.948 ++ add_dir(dir_info->list[current_count]->inode->inode, 2.949 ++ dir_info->list[current_count]->inode->inode_number, 2.950 + dir_info->list[current_count]->name, 2.951 +- dir_info->list[current_count]->data->type, dir); 2.952 ++ dir_info->list[current_count]->inode->type, dir); 2.953 + else 2.954 + return dir_info->list[current_count]; 2.955 + return NULL; 2.956 +@@ -3313,7 +3434,6 @@ 2.957 + dir_ent->name = dir_ent->pathname = strdup(pathname); 2.958 + dir_ent->dir = dir_info; 2.959 + dir_ent->our_dir = NULL; 2.960 +- dir_ent->data = NULL; 2.961 + dir_info->dir_ent = dir_ent; 2.962 + 2.963 + if(sorted) 2.964 +@@ -3383,7 +3503,7 @@ 2.965 + sub_dir = NULL; 2.966 + 2.967 + add_dir_entry(dir_name, filename, sub_dir, lookup_inode(&buf), 2.968 +- NULL, dir); 2.969 ++ dir); 2.970 + } 2.971 + 2.972 + scan1_freedir(dir); 2.973 +@@ -3399,7 +3519,7 @@ 2.974 + struct dir_ent *dir_ent; 2.975 + struct pseudo_entry *pseudo_ent; 2.976 + struct stat buf; 2.977 +- static pseudo_ino = 1; 2.978 ++ static int pseudo_ino = 1; 2.979 + 2.980 + if(dir == NULL && (dir = scan1_opendir("")) == NULL) 2.981 + return NULL; 2.982 +@@ -3415,6 +3535,29 @@ 2.983 + 2.984 + while((pseudo_ent = pseudo_readdir(pseudo)) != NULL) { 2.985 + dir_ent = scan2_lookup(dir, pseudo_ent->name); 2.986 ++ if(pseudo_ent->dev->type == 's') { 2.987 ++ struct stat *buf; 2.988 ++ if(dir_ent == NULL) { 2.989 ++ ERROR("Pseudo set file \"%s\" does not exist " 2.990 ++ "in source filesystem. Ignoring\n", 2.991 ++ pseudo_ent->pathname); 2.992 ++ continue; 2.993 ++ } 2.994 ++ if(dir_ent->inode->root_entry) { 2.995 ++ ERROR("Pseudo set file \"%s\" is a pre-existing" 2.996 ++ " file in the filesystem being appended" 2.997 ++ " to. It cannot be modified. " 2.998 ++ "Ignoring!\n", pseudo_ent->pathname); 2.999 ++ continue; 2.1000 ++ } 2.1001 ++ buf = &dir_ent->inode->buf; 2.1002 ++ buf->st_mode = (buf->st_mode & S_IFMT) | 2.1003 ++ pseudo_ent->dev->mode; 2.1004 ++ buf->st_uid = pseudo_ent->dev->uid; 2.1005 ++ buf->st_gid = pseudo_ent->dev->gid; 2.1006 ++ continue; 2.1007 ++ } 2.1008 ++ 2.1009 + if(dir_ent) { 2.1010 + ERROR("Pseudo file \"%s\" exists in source filesystem " 2.1011 + "\"%s\"\n", pseudo_ent->pathname, 2.1012 +@@ -3444,8 +3587,29 @@ 2.1013 + buf.st_mtime = time(NULL); 2.1014 + buf.st_ino = pseudo_ino ++; 2.1015 + 2.1016 +- add_dir_entry(pseudo_ent->name, pseudo_ent->pathname, sub_dir, 2.1017 +- lookup_inode(&buf), NULL, dir); 2.1018 ++ if(pseudo_ent->dev->type == 'f') { 2.1019 ++#ifdef USE_TMP_FILE 2.1020 ++ struct stat buf2; 2.1021 ++ int res = stat(pseudo_ent->dev->filename, &buf2); 2.1022 ++ if(res == -1) { 2.1023 ++ ERROR("Stat on pseudo file \"%s\" failed, " 2.1024 ++ "skipping...", pseudo_ent->pathname); 2.1025 ++ continue; 2.1026 ++ } 2.1027 ++ buf.st_size = buf2.st_size; 2.1028 ++ add_dir_entry(pseudo_ent->name, 2.1029 ++ pseudo_ent->dev->filename, sub_dir, 2.1030 ++ lookup_inode(&buf), dir); 2.1031 ++#else 2.1032 ++ struct inode_info *inode = lookup_inode(&buf); 2.1033 ++ inode->pseudo_id = pseudo_ent->dev->pseudo_id; 2.1034 ++ inode->pseudo_file = TRUE; 2.1035 ++ add_dir_entry(pseudo_ent->name, pseudo_ent->pathname, 2.1036 ++ sub_dir, inode, dir); 2.1037 ++#endif 2.1038 ++ } else 2.1039 ++ add_dir_entry(pseudo_ent->name, pseudo_ent->pathname, 2.1040 ++ sub_dir, lookup_inode(&buf), dir); 2.1041 + } 2.1042 + 2.1043 + scan2_freedir(dir); 2.1044 +@@ -3482,8 +3646,9 @@ 2.1045 + &duplicate_file); 2.1046 + INFO("file %s, uncompressed size %lld " 2.1047 + "bytes %s\n", filename, 2.1048 +- buf->st_size, duplicate_file ? 2.1049 +- "DUPLICATE" : ""); 2.1050 ++ (long long) buf->st_size, 2.1051 ++ duplicate_file ? "DUPLICATE" : 2.1052 ++ ""); 2.1053 + break; 2.1054 + 2.1055 + case S_IFDIR: 2.1056 +@@ -3557,6 +3722,7 @@ 2.1057 + INFO("file %s, uncompressed " 2.1058 + "size %lld bytes LINK" 2.1059 + "\n", filename, 2.1060 ++ (long long) 2.1061 + buf->st_size); 2.1062 + break; 2.1063 + case SQUASHFS_SYMLINK_TYPE: 2.1064 +@@ -3667,10 +3833,11 @@ 2.1065 + BAD_ERROR("Out of memory in old root directory entries " 2.1066 + "reallocation\n"); 2.1067 + 2.1068 +- strcpy(old_root_entry[old_root_entries].name, name); 2.1069 +- old_root_entry[old_root_entries].inode = inode; 2.1070 +- old_root_entry[old_root_entries].inode_number = inode_number; 2.1071 +- old_root_entry[old_root_entries++].type = type; 2.1072 ++ old_root_entry[old_root_entries].name = strdup(name); 2.1073 ++ old_root_entry[old_root_entries].inode.inode = inode; 2.1074 ++ old_root_entry[old_root_entries].inode.inode_number = inode_number; 2.1075 ++ old_root_entry[old_root_entries].inode.type = type; 2.1076 ++ old_root_entry[old_root_entries++].inode.root_entry = TRUE; 2.1077 + } 2.1078 + 2.1079 + 2.1080 +@@ -4137,7 +4304,7 @@ 2.1081 + 2.1082 + 2.1083 + #define VERSION() \ 2.1084 +- printf("mksquashfs version 4.0 (2009/04/05)\n");\ 2.1085 ++ printf("mksquashfs version 4.1-CVS (2009/12/08)\n");\ 2.1086 + printf("copyright (C) 2009 Phillip Lougher <phillip@lougher.demon.co.uk>\n\n"); \ 2.1087 + printf("This program is free software; you can redistribute it and/or\n");\ 2.1088 + printf("modify it under the terms of the GNU General Public License\n");\ 2.1089 +@@ -4172,26 +4339,28 @@ 2.1090 + source_path = argv + 1; 2.1091 + source = i - 2; 2.1092 + for(; i < argc; i++) { 2.1093 +- if(strcmp(argv[i], "-pf") == 0) { 2.1094 ++ if(strcmp(argv[i], "-comp") == 0) { 2.1095 + if(++i == argc) { 2.1096 +- ERROR("%s: -pf missing filename\n", argv[0]); 2.1097 ++ ERROR("%s: -comp missing compression type\n", 2.1098 ++ argv[0]); 2.1099 + exit(1); 2.1100 + } 2.1101 +- if(read_pseudo_file(&pseudo, argv[i]) == FALSE) { 2.1102 +- ERROR("Failed to parse pseudo file \"%s\"\n", 2.1103 +- argv[i]); 2.1104 ++ comp_name = argv[i]; 2.1105 ++ } else if(strcmp(argv[i], "-pf") == 0) { 2.1106 ++ if(++i == argc) { 2.1107 ++ ERROR("%s: -pf missing filename\n", argv[0]); 2.1108 + exit(1); 2.1109 + } 2.1110 ++ if(read_pseudo_file(&pseudo, argv[i]) == FALSE) 2.1111 ++ exit(1); 2.1112 + } else if(strcmp(argv[i], "-p") == 0) { 2.1113 + if(++i == argc) { 2.1114 + ERROR("%s: -p missing pseudo file definition\n", 2.1115 + argv[0]); 2.1116 + exit(1); 2.1117 + } 2.1118 +- if(read_pseudo_def(&pseudo, argv[i]) == FALSE) { 2.1119 +- ERROR("Failed to parse pseudo definition\n"); 2.1120 ++ if(read_pseudo_def(&pseudo, argv[i]) == FALSE) 2.1121 + exit(1); 2.1122 +- } 2.1123 + } else if(strcmp(argv[i], "-recover") == 0) { 2.1124 + if(++i == argc) { 2.1125 + ERROR("%s: -recover missing recovery file\n", 2.1126 +@@ -4394,34 +4563,16 @@ 2.1127 + printOptions: 2.1128 + ERROR("SYNTAX:%s source1 source2 ... dest [options] " 2.1129 + "[-e list of exclude\ndirs/files]\n", argv[0]); 2.1130 +- ERROR("\nOptions are\n"); 2.1131 +- ERROR("-version\t\tprint version, licence and " 2.1132 +- "copyright message\n"); 2.1133 +- ERROR("-recover <name>\t\trecover filesystem data " 2.1134 +- "using recovery file <name>\n"); 2.1135 +- ERROR("-no-recovery\t\tdon't generate a recovery " 2.1136 +- "file\n"); 2.1137 +- ERROR("-info\t\t\tprint files written to filesystem\n"); 2.1138 +- ERROR("-no-exports\t\tdon't make the filesystem " 2.1139 +- "exportable via NFS\n"); 2.1140 +- ERROR("-no-progress\t\tdon't display the progress " 2.1141 +- "bar\n"); 2.1142 +- ERROR("-no-sparse\t\tdon't detect sparse files\n"); 2.1143 ++ ERROR("\nFilesystem build options:\n"); 2.1144 ++ ERROR("-comp <comp>\t\tselect <comp> compression\n"); 2.1145 ++ ERROR("\t\t\tCompressors available:\n"); 2.1146 ++ display_compressors("\t\t\t", COMP_DEFAULT); 2.1147 + ERROR("-b <block_size>\t\tset data block to " 2.1148 + "<block_size>. Default %d bytes\n", 2.1149 + SQUASHFS_FILE_SIZE); 2.1150 +- ERROR("-processors <number>\tUse <number> processors." 2.1151 +- " By default will use number of\n"); 2.1152 +- ERROR("\t\t\tprocessors available\n"); 2.1153 +- ERROR("-read-queue <size>\tSet input queue to <size> " 2.1154 +- "Mbytes. Default %d Mbytes\n", 2.1155 +- READER_BUFFER_DEFAULT); 2.1156 +- ERROR("-write-queue <size>\tSet output queue to <size> " 2.1157 +- "Mbytes. Default %d Mbytes\n", 2.1158 +- WRITER_BUFFER_DEFAULT); 2.1159 +- ERROR("-fragment-queue <size>\tSet fagment queue to " 2.1160 +- "<size> Mbytes. Default %d Mbytes\n", 2.1161 +- FRAGMENT_BUFFER_DEFAULT); 2.1162 ++ ERROR("-no-exports\t\tdon't make the filesystem " 2.1163 ++ "exportable via NFS\n"); 2.1164 ++ ERROR("-no-sparse\t\tdon't detect sparse files\n"); 2.1165 + ERROR("-noI\t\t\tdo not compress inode table\n"); 2.1166 + ERROR("-noD\t\t\tdo not compress data blocks\n"); 2.1167 + ERROR("-noF\t\t\tdo not compress fragment blocks\n"); 2.1168 +@@ -4430,13 +4581,34 @@ 2.1169 + "files larger than block size\n"); 2.1170 + ERROR("-no-duplicates\t\tdo not perform duplicate " 2.1171 + "checking\n"); 2.1172 +- ERROR("-noappend\t\tdo not append to existing " 2.1173 +- "filesystem\n"); 2.1174 ++ ERROR("-all-root\t\tmake all files owned by root\n"); 2.1175 ++ ERROR("-force-uid uid\t\tset all file uids to uid\n"); 2.1176 ++ ERROR("-force-gid gid\t\tset all file gids to gid\n"); 2.1177 ++ ERROR("-nopad\t\t\tdo not pad filesystem to a multiple " 2.1178 ++ "of 4K\n"); 2.1179 + ERROR("-keep-as-directory\tif one source directory is " 2.1180 + "specified, create a root\n"); 2.1181 + ERROR("\t\t\tdirectory containing that directory, " 2.1182 + "rather than the\n"); 2.1183 + ERROR("\t\t\tcontents of the directory\n"); 2.1184 ++ ERROR("\nFilesystem filter options:\n"); 2.1185 ++ ERROR("-p <pseudo-definition>\tAdd pseudo file definition\n"); 2.1186 ++ ERROR("-pf <pseudo-file>\tAdd list of pseudo file definitions\n"); 2.1187 ++ ERROR("-sort <sort_file>\tsort files according to " 2.1188 ++ "priorities in <sort_file>. One\n"); 2.1189 ++ ERROR("\t\t\tfile or dir with priority per line. " 2.1190 ++ "Priority -32768 to\n"); 2.1191 ++ ERROR("\t\t\t32767, default priority 0\n"); 2.1192 ++ ERROR("-ef <exclude_file>\tlist of exclude dirs/files." 2.1193 ++ " One per line\n"); 2.1194 ++ ERROR("-wildcards\t\tAllow extended shell wildcards " 2.1195 ++ "(globbing) to be used in\n\t\t\texclude " 2.1196 ++ "dirs/files\n"); 2.1197 ++ ERROR("-regex\t\t\tAllow POSIX regular expressions to " 2.1198 ++ "be used in exclude\n\t\t\tdirs/files\n"); 2.1199 ++ ERROR("\nFilesystem append options:\n"); 2.1200 ++ ERROR("-noappend\t\tdo not append to existing " 2.1201 ++ "filesystem\n"); 2.1202 + ERROR("-root-becomes <name>\twhen appending source " 2.1203 + "files/directories, make the\n"); 2.1204 + ERROR("\t\t\toriginal root become a subdirectory in " 2.1205 +@@ -4444,11 +4616,29 @@ 2.1206 + ERROR("\t\t\tcalled <name>, rather than adding the new " 2.1207 + "source items\n"); 2.1208 + ERROR("\t\t\tto the original root\n"); 2.1209 +- ERROR("-all-root\t\tmake all files owned by root\n"); 2.1210 +- ERROR("-force-uid uid\t\tset all file uids to uid\n"); 2.1211 +- ERROR("-force-gid gid\t\tset all file gids to gid\n"); 2.1212 +- ERROR("-nopad\t\t\tdo not pad filesystem to a multiple " 2.1213 +- "of 4K\n"); 2.1214 ++ ERROR("\nMksquashfs runtime options:\n"); 2.1215 ++ ERROR("-version\t\tprint version, licence and " 2.1216 ++ "copyright message\n"); 2.1217 ++ ERROR("-recover <name>\t\trecover filesystem data " 2.1218 ++ "using recovery file <name>\n"); 2.1219 ++ ERROR("-no-recovery\t\tdon't generate a recovery " 2.1220 ++ "file\n"); 2.1221 ++ ERROR("-info\t\t\tprint files written to filesystem\n"); 2.1222 ++ ERROR("-no-progress\t\tdon't display the progress " 2.1223 ++ "bar\n"); 2.1224 ++ ERROR("-processors <number>\tUse <number> processors." 2.1225 ++ " By default will use number of\n"); 2.1226 ++ ERROR("\t\t\tprocessors available\n"); 2.1227 ++ ERROR("-read-queue <size>\tSet input queue to <size> " 2.1228 ++ "Mbytes. Default %d Mbytes\n", 2.1229 ++ READER_BUFFER_DEFAULT); 2.1230 ++ ERROR("-write-queue <size>\tSet output queue to <size> " 2.1231 ++ "Mbytes. Default %d Mbytes\n", 2.1232 ++ WRITER_BUFFER_DEFAULT); 2.1233 ++ ERROR("-fragment-queue <size>\tSet fagment queue to " 2.1234 ++ "<size> Mbytes. Default %d Mbytes\n", 2.1235 ++ FRAGMENT_BUFFER_DEFAULT); 2.1236 ++ ERROR("\nMiscellaneous options:\n"); 2.1237 + ERROR("-root-owned\t\talternative name for -all-root" 2.1238 + "\n"); 2.1239 + ERROR("-noInodeCompression\talternative name for -noI" 2.1240 +@@ -4457,20 +4647,8 @@ 2.1241 + "\n"); 2.1242 + ERROR("-noFragmentCompression\talternative name for " 2.1243 + "-noF\n"); 2.1244 +- ERROR("-sort <sort_file>\tsort files according to " 2.1245 +- "priorities in <sort_file>. One\n"); 2.1246 +- ERROR("\t\t\tfile or dir with priority per line. " 2.1247 +- "Priority -32768 to\n"); 2.1248 +- ERROR("\t\t\t32767, default priority 0\n"); 2.1249 +- ERROR("-ef <exclude_file>\tlist of exclude dirs/files." 2.1250 +- " One per line\n"); 2.1251 +- ERROR("-wildcards\t\tAllow extended shell wildcards " 2.1252 +- "(globbing) to be used in\n\t\t\texclude " 2.1253 +- "dirs/files\n"); 2.1254 +- ERROR("-regex\t\t\tAllow POSIX regular expressions to " 2.1255 +- "be used in exclude\n\t\t\tdirs/files\n"); 2.1256 +- ERROR("-p <pseudo-definition>\tAdd pseudo file definition\n"); 2.1257 +- ERROR("-pf <pseudo-file>\tAdd list of pseudo file definitions\n"); 2.1258 ++ ERROR("\nCompressors available:\n"); 2.1259 ++ display_compressors("", COMP_DEFAULT); 2.1260 + exit(1); 2.1261 + } 2.1262 + } 2.1263 +@@ -4548,11 +4726,10 @@ 2.1264 + fclose(fd); 2.1265 + } else if(strcmp(argv[i], "-e") == 0) 2.1266 + break; 2.1267 +- else if(strcmp(argv[i], "-b") == 0 || 2.1268 +- strcmp(argv[i], "-root-becomes") == 0 || 2.1269 ++ else if(strcmp(argv[i], "-root-becomes") == 0 || 2.1270 + strcmp(argv[i], "-sort") == 0 || 2.1271 + strcmp(argv[i], "-pf") == 0 || 2.1272 +- strcmp(argv[i], "-p") == 0) 2.1273 ++ strcmp(argv[i], "-comp") == 0) 2.1274 + i++; 2.1275 + 2.1276 + if(i != argc) { 2.1277 +@@ -4574,11 +4751,10 @@ 2.1278 + sorted ++; 2.1279 + } else if(strcmp(argv[i], "-e") == 0) 2.1280 + break; 2.1281 +- else if(strcmp(argv[i], "-b") == 0 || 2.1282 +- strcmp(argv[i], "-root-becomes") == 0 || 2.1283 ++ else if(strcmp(argv[i], "-root-becomes") == 0 || 2.1284 + strcmp(argv[i], "-ef") == 0 || 2.1285 + strcmp(argv[i], "-pf") == 0 || 2.1286 +- strcmp(argv[i], "-p") == 0) 2.1287 ++ strcmp(argv[i], "-comp") == 0) 2.1288 + i++; 2.1289 + 2.1290 + #ifdef SQUASHFS_TRACE 2.1291 +@@ -4586,7 +4762,8 @@ 2.1292 + #endif 2.1293 + 2.1294 + if(!delete) { 2.1295 +- if(read_super(fd, &sBlk, argv[source + 1]) == 0) { 2.1296 ++ comp = read_super(fd, &sBlk, argv[source + 1]); 2.1297 ++ if(comp == NULL) { 2.1298 + ERROR("Failed to read existing filesystem - will not " 2.1299 + "overwrite - ABORTING!\n"); 2.1300 + ERROR("To force Mksquashfs to write to this block " 2.1301 +@@ -4603,6 +4780,15 @@ 2.1302 + always_use_fragments = SQUASHFS_ALWAYS_FRAGMENTS(sBlk.flags); 2.1303 + duplicate_checking = SQUASHFS_DUPLICATES(sBlk.flags); 2.1304 + exportable = SQUASHFS_EXPORTABLE(sBlk.flags); 2.1305 ++ } else { 2.1306 ++ comp = lookup_compressor(comp_name); 2.1307 ++ if(!comp->supported) { 2.1308 ++ ERROR("FATAL_ERROR: Compressor \"%s\" is not " 2.1309 ++ "supported!\n", comp_name); 2.1310 ++ ERROR("Compressors available:\n"); 2.1311 ++ display_compressors("", COMP_DEFAULT); 2.1312 ++ EXIT_MKSQUASHFS(); 2.1313 ++ } 2.1314 + } 2.1315 + 2.1316 + initialise_threads(); 2.1317 +@@ -4648,8 +4834,8 @@ 2.1318 + "size %d\n", SQUASHFS_MAJOR, s_minor, argv[source + 1], 2.1319 + block_size); 2.1320 + printf("All -b, -noI, -noD, -noF, no-duplicates, no-fragments, " 2.1321 +- "-always-use-fragments and -exportable options ignored" 2.1322 +- "\n"); 2.1323 ++ "-always-use-fragments,\n-exportable and -comp options " 2.1324 ++ "ignored\n"); 2.1325 + printf("\nIf appending is not wanted, please re-run with " 2.1326 + "-noappend specified!\n\n"); 2.1327 + 2.1328 +@@ -4803,8 +4989,7 @@ 2.1329 + 2.1330 + sBlk.bytes_used = bytes; 2.1331 + 2.1332 +- /* Only compression supported */ 2.1333 +- sBlk.compression = ZLIB_COMPRESSION; 2.1334 ++ sBlk.compression = comp->id; 2.1335 + 2.1336 + /* Xattrs are not currently supported */ 2.1337 + sBlk.xattr_table_start = SQUASHFS_INVALID_BLK; 2.1338 +@@ -4820,6 +5005,8 @@ 2.1339 + 2.1340 + close(fd); 2.1341 + 2.1342 ++ delete_pseudo_files(); 2.1343 ++ 2.1344 + if(recovery_file[0] != '\0') 2.1345 + unlink(recovery_file); 2.1346 + 2.1347 +@@ -4827,9 +5014,9 @@ 2.1348 + * sizeof(unsigned short) + guid_count * sizeof(unsigned short) + 2.1349 + sizeof(squashfs_super_block); 2.1350 + 2.1351 +- printf("\n%sSquashfs %d.%d filesystem, data block size %d\n", 2.1352 +- exportable ? "Exportable " : "", SQUASHFS_MAJOR, SQUASHFS_MINOR, 2.1353 +- block_size); 2.1354 ++ printf("\n%sSquashfs %d.%d filesystem, %s compressed, data block size" 2.1355 ++ " %d\n", exportable ? "Exportable " : "", SQUASHFS_MAJOR, 2.1356 ++ SQUASHFS_MINOR, comp->name, block_size); 2.1357 + printf("\t%s data, %s metadata, %s fragments\n", 2.1358 + noD ? "uncompressed" : "compressed", noI ? "uncompressed" : 2.1359 + "compressed", no_fragments ? "no" : noF ? "uncompressed" : 2.1360 + 2.1361 +--- squashfs-4.0/squashfs-tools/par_mksquashfs/README Thu Jan 1 01:00:00 1970 2.1362 ++++ squashfs-4.0/squashfs-tools/par_mksquashfs/README Mon Nov 6 01:27:32 2006 2.1363 +@@ -0,0 +1,2 @@ 2.1364 ++par_mksquashfs is now the standard mksquashfs, and so this directory is now empty. 2.1365 ++ 2.1366 + 2.1367 +--- squashfs-4.0/squashfs-tools/pseudo.c Sun Apr 5 04:01:58 2009 2.1368 ++++ squashfs-4.0/squashfs-tools/pseudo.c Thu Sep 10 06:17:48 2009 2.1369 +@@ -30,6 +30,7 @@ 2.1370 + #include <string.h> 2.1371 + #include <stdlib.h> 2.1372 + #include <sys/types.h> 2.1373 ++#include <sys/wait.h> 2.1374 + 2.1375 + #include "pseudo.h" 2.1376 + 2.1377 +@@ -55,6 +56,9 @@ 2.1378 + #define TRUE 1 2.1379 + #define FALSE 0 2.1380 + 2.1381 ++struct pseudo_dev **pseudo_file = NULL; 2.1382 ++int pseudo_count = 0; 2.1383 ++ 2.1384 + static void dump_pseudo(struct pseudo *pseudo, char *string) 2.1385 + { 2.1386 + int i; 2.1387 +@@ -99,7 +103,7 @@ 2.1388 + char *target, char *alltarget) 2.1389 + { 2.1390 + char targname[1024]; 2.1391 +- int i, error; 2.1392 ++ int i; 2.1393 + 2.1394 + target = get_component(target, targname); 2.1395 + 2.1396 +@@ -128,12 +132,8 @@ 2.1397 + if(target[0] == '\0') { 2.1398 + /* at leaf pathname component */ 2.1399 + pseudo->name[i].pseudo = NULL; 2.1400 +- pseudo->name[i].dev = malloc(sizeof(struct pseudo_dev)); 2.1401 +- if(pseudo->name[i].dev == NULL) 2.1402 +- BAD_ERROR("failed to allocate pseudo file\n"); 2.1403 + pseudo->name[i].pathname = strdup(alltarget); 2.1404 +- memcpy(pseudo->name[i].dev, pseudo_dev, 2.1405 +- sizeof(struct pseudo_dev)); 2.1406 ++ pseudo->name[i].dev = pseudo_dev; 2.1407 + } else { 2.1408 + /* recurse adding child components */ 2.1409 + pseudo->name[i].dev = NULL; 2.1410 +@@ -169,15 +169,9 @@ 2.1411 + if(target[0] == '\0') { 2.1412 + if(pseudo->name[i].dev == NULL && 2.1413 + pseudo_dev->type == 'd') { 2.1414 +- pseudo->name[i].dev = 2.1415 +- malloc(sizeof(struct pseudo_dev)); 2.1416 +- if(pseudo->name[i].dev == NULL) 2.1417 +- BAD_ERROR("failed to allocate " 2.1418 +- "pseudo file\n"); 2.1419 + pseudo->name[i].pathname = 2.1420 + strdup(alltarget); 2.1421 +- memcpy(pseudo->name[i].dev, pseudo_dev, 2.1422 +- sizeof(struct pseudo_dev)); 2.1423 ++ pseudo->name[i].dev = pseudo_dev; 2.1424 + } else 2.1425 + ERROR("%s already exists as a " 2.1426 + "directory. Ignoring %s!\n", 2.1427 +@@ -229,16 +223,113 @@ 2.1428 + } 2.1429 + 2.1430 + 2.1431 ++int exec_file(char *command, struct pseudo_dev *dev) 2.1432 ++{ 2.1433 ++ int child, res; 2.1434 ++ static pid_t pid = -1; 2.1435 ++ int pipefd[2]; 2.1436 ++#ifdef USE_TMP_FILE 2.1437 ++ char filename[1024]; 2.1438 ++ int status; 2.1439 ++ static int number = 0; 2.1440 ++#endif 2.1441 ++ 2.1442 ++ if(pid == -1) 2.1443 ++ pid = getpid(); 2.1444 ++ 2.1445 ++#ifdef USE_TMP_FILE 2.1446 ++ sprintf(filename, "/tmp/squashfs_pseudo_%d_%d", pid, number ++); 2.1447 ++ pipefd[1] = open(filename, O_CREAT | O_TRUNC | O_RDWR, S_IRWXU); 2.1448 ++ if(pipefd[1] == -1) { 2.1449 ++ printf("open failed\n"); 2.1450 ++ return -1; 2.1451 ++ } 2.1452 ++#else 2.1453 ++ res = pipe(pipefd); 2.1454 ++ if(res == -1) { 2.1455 ++ printf("pipe failed\n"); 2.1456 ++ return -1; 2.1457 ++ } 2.1458 ++#endif 2.1459 ++ 2.1460 ++ child = fork(); 2.1461 ++ if(child == -1) { 2.1462 ++ printf("fork failed\n"); 2.1463 ++ goto failed; 2.1464 ++ } 2.1465 ++ 2.1466 ++ if(child == 0) { 2.1467 ++ close(STDOUT_FILENO); 2.1468 ++ res = dup(pipefd[1]); 2.1469 ++ if(res == -1) { 2.1470 ++ printf("dup failed\n"); 2.1471 ++ exit(EXIT_FAILURE); 2.1472 ++ } 2.1473 ++ execl("/bin/sh", "sh", "-c", command, (char *) NULL); 2.1474 ++ printf("execl failed\n"); 2.1475 ++ exit(EXIT_FAILURE); 2.1476 ++ } 2.1477 ++ 2.1478 ++#ifdef USE_TMP_FILE 2.1479 ++ res = waitpid(child, &status, 0); 2.1480 ++ close(pipefd[1]); 2.1481 ++ if(res != -1 && WIFEXITED(status) && WEXITSTATUS(status) == 0) { 2.1482 ++ dev->filename = strdup(filename); 2.1483 ++ return 0; 2.1484 ++ } 2.1485 ++failed: 2.1486 ++ unlink(filename); 2.1487 ++ return -1; 2.1488 ++#else 2.1489 ++ close(pipefd[1]); 2.1490 ++ dev->fd = pipefd[0]; 2.1491 ++ dev->child = child; 2.1492 ++ return 0; 2.1493 ++failed: 2.1494 ++ return -1; 2.1495 ++#endif 2.1496 ++} 2.1497 ++ 2.1498 ++ 2.1499 ++void add_pseudo_file(struct pseudo_dev *dev) 2.1500 ++{ 2.1501 ++ pseudo_file = realloc(pseudo_file, (pseudo_count + 1) * 2.1502 ++ sizeof(struct pseudo_dev *)); 2.1503 ++ if(pseudo_file == NULL) 2.1504 ++ BAD_ERROR("Failed to realloc pseudo_file\n"); 2.1505 ++ 2.1506 ++ dev->pseudo_id = pseudo_count; 2.1507 ++ pseudo_file[pseudo_count ++] = dev; 2.1508 ++} 2.1509 ++ 2.1510 ++ 2.1511 ++void delete_pseudo_files() 2.1512 ++{ 2.1513 ++#ifdef USE_TMP_FILE 2.1514 ++ int i; 2.1515 ++ 2.1516 ++ for(i = 0; i < pseudo_count; i++) 2.1517 ++ unlink(pseudo_file[i]->filename); 2.1518 ++#endif 2.1519 ++} 2.1520 ++ 2.1521 ++ 2.1522 ++struct pseudo_dev *get_pseudo_file(int pseudo_id) 2.1523 ++{ 2.1524 ++ return pseudo_file[pseudo_id]; 2.1525 ++} 2.1526 ++ 2.1527 ++ 2.1528 + int read_pseudo_def(struct pseudo **pseudo, char *def) 2.1529 + { 2.1530 +- int n; 2.1531 ++ int n, bytes; 2.1532 + unsigned int major = 0, minor = 0, mode; 2.1533 + char filename[2048], type, suid[100], sgid[100], *ptr; 2.1534 + long long uid, gid; 2.1535 +- struct pseudo_dev dev; 2.1536 ++ struct pseudo_dev *dev; 2.1537 + 2.1538 +- n = sscanf(def, "%s %c %o %s %s %u %u", filename, &type, &mode, suid, sgid, 2.1539 +- &major, &minor); 2.1540 ++ n = sscanf(def, "%s %c %o %s %s %n", filename, &type, &mode, suid, 2.1541 ++ sgid, &bytes); 2.1542 + 2.1543 + if(n < 5) { 2.1544 + ERROR("Not enough or invalid arguments in pseudo file " 2.1545 +@@ -249,7 +340,9 @@ 2.1546 + switch(type) { 2.1547 + case 'b': 2.1548 + case 'c': 2.1549 +- if(n < 7) { 2.1550 ++ n = sscanf(def + bytes, "%u %u", &major, &minor); 2.1551 ++ 2.1552 ++ if(n < 2) { 2.1553 + ERROR("Not enough or invalid arguments in pseudo file " 2.1554 + "definition\n"); 2.1555 + goto error; 2.1556 +@@ -265,54 +358,59 @@ 2.1557 + goto error; 2.1558 + } 2.1559 + 2.1560 +- /* fall through */ 2.1561 +- case 'd': 2.1562 +- if(mode > 0777) { 2.1563 +- ERROR("Mode %o out of range\n", mode); 2.1564 ++ case 'f': 2.1565 ++ if(def[bytes] == '\0') { 2.1566 ++ ERROR("Not enough arguments in pseudo file " 2.1567 ++ "definition\n"); 2.1568 + goto error; 2.1569 +- } 2.1570 +- 2.1571 +- uid = strtoll(suid, &ptr, 10); 2.1572 +- if(*ptr == '\0') { 2.1573 +- if(uid < 0 || uid > ((1LL << 32) - 1)) { 2.1574 +- ERROR("Uid %s out of range\n", suid); 2.1575 +- goto error; 2.1576 +- } 2.1577 +- } else { 2.1578 +- struct passwd *pwuid = getpwnam(suid); 2.1579 +- if(pwuid) 2.1580 +- uid = pwuid->pw_uid; 2.1581 +- else { 2.1582 +- ERROR("Uid %s invalid uid or unknown user\n", 2.1583 +- suid); 2.1584 +- goto error; 2.1585 +- } 2.1586 +- } 2.1587 +- 2.1588 +- gid = strtoll(sgid, &ptr, 10); 2.1589 +- if(*ptr == '\0') { 2.1590 +- if(gid < 0 || gid > ((1LL << 32) - 1)) { 2.1591 +- ERROR("Gid %s out of range\n", sgid); 2.1592 +- goto error; 2.1593 +- } 2.1594 +- } else { 2.1595 +- struct group *grgid = getgrnam(sgid); 2.1596 +- if(grgid) 2.1597 +- gid = grgid->gr_gid; 2.1598 +- else { 2.1599 +- ERROR("Gid %s invalid uid or unknown user\n", 2.1600 +- sgid); 2.1601 +- goto error; 2.1602 +- } 2.1603 +- } 2.1604 +- 2.1605 ++ } 2.1606 + break; 2.1607 ++ case 'd': 2.1608 ++ case 'm': 2.1609 ++ break; 2.1610 + default: 2.1611 + ERROR("Unsupported type %c\n", type); 2.1612 + goto error; 2.1613 + } 2.1614 + 2.1615 + 2.1616 ++ if(mode > 0777) { 2.1617 ++ ERROR("Mode %o out of range\n", mode); 2.1618 ++ goto error; 2.1619 ++ } 2.1620 ++ 2.1621 ++ uid = strtoll(suid, &ptr, 10); 2.1622 ++ if(*ptr == '\0') { 2.1623 ++ if(uid < 0 || uid > ((1LL << 32) - 1)) { 2.1624 ++ ERROR("Uid %s out of range\n", suid); 2.1625 ++ goto error; 2.1626 ++ } 2.1627 ++ } else { 2.1628 ++ struct passwd *pwuid = getpwnam(suid); 2.1629 ++ if(pwuid) 2.1630 ++ uid = pwuid->pw_uid; 2.1631 ++ else { 2.1632 ++ ERROR("Uid %s invalid uid or unknown user\n", suid); 2.1633 ++ goto error; 2.1634 ++ } 2.1635 ++ } 2.1636 ++ 2.1637 ++ gid = strtoll(sgid, &ptr, 10); 2.1638 ++ if(*ptr == '\0') { 2.1639 ++ if(gid < 0 || gid > ((1LL << 32) - 1)) { 2.1640 ++ ERROR("Gid %s out of range\n", sgid); 2.1641 ++ goto error; 2.1642 ++ } 2.1643 ++ } else { 2.1644 ++ struct group *grgid = getgrnam(sgid); 2.1645 ++ if(grgid) 2.1646 ++ gid = grgid->gr_gid; 2.1647 ++ else { 2.1648 ++ ERROR("Gid %s invalid uid or unknown user\n", sgid); 2.1649 ++ goto error; 2.1650 ++ } 2.1651 ++ } 2.1652 ++ 2.1653 + switch(type) { 2.1654 + case 'b': 2.1655 + mode |= S_IFBLK; 2.1656 +@@ -323,16 +421,37 @@ 2.1657 + case 'd': 2.1658 + mode |= S_IFDIR; 2.1659 + break; 2.1660 ++ case 'f': 2.1661 ++ mode |= S_IFREG; 2.1662 ++ break; 2.1663 + } 2.1664 + 2.1665 +- dev.type = type; 2.1666 +- dev.mode = mode; 2.1667 +- dev.uid = uid; 2.1668 +- dev.gid = gid; 2.1669 +- dev.major = major; 2.1670 +- dev.minor = minor; 2.1671 ++ dev = malloc(sizeof(struct pseudo_dev)); 2.1672 ++ if(dev == NULL) 2.1673 ++ BAD_ERROR("Failed to create pseudo_dev\n"); 2.1674 + 2.1675 +- *pseudo = add_pseudo(*pseudo, &dev, filename, filename); 2.1676 ++ dev->type = type; 2.1677 ++ dev->mode = mode; 2.1678 ++ dev->uid = uid; 2.1679 ++ dev->gid = gid; 2.1680 ++ dev->major = major; 2.1681 ++ dev->minor = minor; 2.1682 ++ 2.1683 ++ if(type == 'f') { 2.1684 ++ int res; 2.1685 ++ 2.1686 ++ printf("Executing dynamic pseudo file\n"); 2.1687 ++ printf("\t\"%s\"\n", def); 2.1688 ++ res = exec_file(def + bytes, dev); 2.1689 ++ if(res == -1) { 2.1690 ++ ERROR("Failed to execute dynamic pseudo file definition" 2.1691 ++ " \"%s\"\n", def); 2.1692 ++ return FALSE; 2.1693 ++ } 2.1694 ++ add_pseudo_file(dev); 2.1695 ++ } 2.1696 ++ 2.1697 ++ *pseudo = add_pseudo(*pseudo, dev, filename, filename); 2.1698 + 2.1699 + return TRUE; 2.1700 + 2.1701 + 2.1702 +--- squashfs-4.0/squashfs-tools/pseudo.h Sat Apr 4 03:44:24 2009 2.1703 ++++ squashfs-4.0/squashfs-tools/pseudo.h Fri Sep 11 14:10:58 2009 2.1704 +@@ -27,6 +27,12 @@ 2.1705 + unsigned int gid; 2.1706 + unsigned int major; 2.1707 + unsigned int minor; 2.1708 ++ int pseudo_id; 2.1709 ++ int fd; 2.1710 ++ int child; 2.1711 ++#ifdef USE_TMP_FILE 2.1712 ++ char *filename; 2.1713 ++#endif 2.1714 + }; 2.1715 + 2.1716 + struct pseudo_entry { 2.1717 +@@ -46,3 +52,5 @@ 2.1718 + extern int read_pseudo_file(struct pseudo **, char *); 2.1719 + extern struct pseudo *pseudo_subdir(char *, struct pseudo *); 2.1720 + extern struct pseudo_entry *pseudo_readdir(struct pseudo *); 2.1721 ++extern struct pseudo_dev *get_pseudo_file(int); 2.1722 ++extern void delete_pseudo_files(); 2.1723 + 2.1724 +--- squashfs-4.0/squashfs-tools/read_fs.c Tue Mar 31 06:23:14 2009 2.1725 ++++ squashfs-4.0/squashfs-tools/read_fs.c Mon Aug 24 20:28:04 2009 2.1726 +@@ -36,7 +36,6 @@ 2.1727 + #include <fcntl.h> 2.1728 + #include <errno.h> 2.1729 + #include <string.h> 2.1730 +-#include <zlib.h> 2.1731 + #include <sys/mman.h> 2.1732 + 2.1733 + #ifndef linux 2.1734 +@@ -51,6 +50,7 @@ 2.1735 + #include "squashfs_swap.h" 2.1736 + #include "read_fs.h" 2.1737 + #include "global.h" 2.1738 ++#include "compressor.h" 2.1739 + 2.1740 + #include <stdlib.h> 2.1741 + 2.1742 +@@ -66,7 +66,9 @@ 2.1743 + fprintf(stderr, s, ## args); \ 2.1744 + } while(0) 2.1745 + 2.1746 +-int read_block(int fd, long long start, long long *next, unsigned char *block, 2.1747 ++static struct compressor *comp; 2.1748 ++ 2.1749 ++int read_block(int fd, long long start, long long *next, void *block, 2.1750 + squashfs_super_block *sBlk) 2.1751 + { 2.1752 + unsigned short c_byte; 2.1753 +@@ -77,32 +79,24 @@ 2.1754 + 2.1755 + if(SQUASHFS_COMPRESSED(c_byte)) { 2.1756 + char buffer[SQUASHFS_METADATA_SIZE]; 2.1757 +- int res; 2.1758 +- unsigned long bytes = SQUASHFS_METADATA_SIZE; 2.1759 ++ int error, res; 2.1760 + 2.1761 + c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte); 2.1762 + read_destination(fd, start + offset, c_byte, buffer); 2.1763 + 2.1764 +- res = uncompress(block, &bytes, (const unsigned char *) buffer, 2.1765 +- c_byte); 2.1766 +- if(res != Z_OK) { 2.1767 +- if(res == Z_MEM_ERROR) 2.1768 +- ERROR("zlib::uncompress failed, not enough " 2.1769 +- "memory\n"); 2.1770 +- else if(res == Z_BUF_ERROR) 2.1771 +- ERROR("zlib::uncompress failed, not enough " 2.1772 +- "room in output buffer\n"); 2.1773 +- else 2.1774 +- ERROR("zlib::uncompress failed, unknown error " 2.1775 +- "%d\n", res); 2.1776 ++ res = comp->uncompress(block, buffer, c_byte, 2.1777 ++ SQUASHFS_METADATA_SIZE, &error); 2.1778 ++ if(res == -1) { 2.1779 ++ ERROR("%s uncompress failed with error code %d\n", 2.1780 ++ comp->name, error); 2.1781 + return 0; 2.1782 + } 2.1783 + if(next) 2.1784 + *next = start + offset + c_byte; 2.1785 +- return bytes; 2.1786 ++ return res; 2.1787 + } else { 2.1788 + c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte); 2.1789 +- read_destination(fd, start + offset, c_byte, (char *) block); 2.1790 ++ read_destination(fd, start + offset, c_byte, block); 2.1791 + if(next) 2.1792 + *next = start + offset + c_byte; 2.1793 + return c_byte; 2.1794 +@@ -356,7 +350,7 @@ 2.1795 + } 2.1796 + 2.1797 + 2.1798 +-int read_super(int fd, squashfs_super_block *sBlk, char *source) 2.1799 ++struct compressor *read_super(int fd, squashfs_super_block *sBlk, char *source) 2.1800 + { 2.1801 + read_destination(fd, SQUASHFS_START, sizeof(squashfs_super_block), 2.1802 + (char *) sBlk); 2.1803 +@@ -388,8 +382,18 @@ 2.1804 + goto failed_mount; 2.1805 + } 2.1806 + 2.1807 ++ /* Check the compression type */ 2.1808 ++ comp = lookup_compressor_id(sBlk->compression); 2.1809 ++ if(!comp->supported) { 2.1810 ++ ERROR("Filesystem on %s uses %s compression, this is" 2.1811 ++ "unsupported by this version\n", source, comp->name); 2.1812 ++ display_compressors("", ""); 2.1813 ++ goto failed_mount; 2.1814 ++ } 2.1815 ++ 2.1816 + printf("Found a valid %sSQUASHFS superblock on %s.\n", 2.1817 + SQUASHFS_EXPORTABLE(sBlk->flags) ? "exportable " : "", source); 2.1818 ++ printf("\tCompression used %s\n", comp->name); 2.1819 + printf("\tInodes are %scompressed\n", 2.1820 + SQUASHFS_UNCOMPRESSED_INODES(sBlk->flags) ? "un" : ""); 2.1821 + printf("\tData is %scompressed\n", 2.1822 +@@ -417,10 +421,10 @@ 2.1823 + TRACE("sBlk->lookup_table_start %llx\n", sBlk->lookup_table_start); 2.1824 + printf("\n"); 2.1825 + 2.1826 +- return TRUE; 2.1827 ++ return comp; 2.1828 + 2.1829 + failed_mount: 2.1830 +- return FALSE; 2.1831 ++ return NULL; 2.1832 + } 2.1833 + 2.1834 + 2.1835 +@@ -514,12 +518,17 @@ 2.1836 + SQUASHFS_INSWAP_ID_BLOCKS(index, indexes); 2.1837 + 2.1838 + for(i = 0; i < indexes; i++) { 2.1839 +- int length; 2.1840 +- length = read_block(fd, index[i], NULL, 2.1841 ++ int length = read_block(fd, index[i], NULL, 2.1842 + ((unsigned char *) id_table) + 2.1843 + (i * SQUASHFS_METADATA_SIZE), sBlk); 2.1844 + TRACE("Read id table block %d, from 0x%llx, length %d\n", i, 2.1845 + index[i], length); 2.1846 ++ if(length == 0) { 2.1847 ++ ERROR("Failed to read id table block %d, from 0x%llx, " 2.1848 ++ "length %d\n", i, index[i], length); 2.1849 ++ free(id_table); 2.1850 ++ return NULL; 2.1851 ++ } 2.1852 + } 2.1853 + 2.1854 + SQUASHFS_INSWAP_INTS(id_table, sBlk->no_ids); 2.1855 +@@ -563,6 +572,13 @@ 2.1856 + (i * SQUASHFS_METADATA_SIZE), sBlk); 2.1857 + TRACE("Read fragment table block %d, from 0x%llx, length %d\n", 2.1858 + i, fragment_table_index[i], length); 2.1859 ++ if(length == 0) { 2.1860 ++ ERROR("Failed to read fragment table block %d, from " 2.1861 ++ "0x%llx, length %d\n", i, 2.1862 ++ fragment_table_index[i], length); 2.1863 ++ free(*fragment_table); 2.1864 ++ return 0; 2.1865 ++ } 2.1866 + } 2.1867 + 2.1868 + for(i = 0; i < sBlk->fragments; i++) 2.1869 +@@ -599,6 +615,13 @@ 2.1870 + (i * SQUASHFS_METADATA_SIZE), sBlk); 2.1871 + TRACE("Read inode lookup table block %d, from 0x%llx, length " 2.1872 + "%d\n", i, index[i], length); 2.1873 ++ if(length == 0) { 2.1874 ++ ERROR("Failed to read inode lookup table block %d, " 2.1875 ++ "from 0x%llx, length %d\n", i, index[i], 2.1876 ++ length); 2.1877 ++ free(*inode_lookup_table); 2.1878 ++ return 0; 2.1879 ++ } 2.1880 + } 2.1881 + 2.1882 + SQUASHFS_INSWAP_LONG_LONGS(*inode_lookup_table, sBlk->inodes); 2.1883 + 2.1884 +--- squashfs-4.0/squashfs-tools/sort.c Tue Mar 31 06:25:53 2009 2.1885 ++++ squashfs-4.0/squashfs-tools/sort.c Sat Aug 29 07:41:45 2009 2.1886 +@@ -198,7 +198,7 @@ 2.1887 + while(dir->current_count < dir->count) { 2.1888 + struct dir_ent *dir_ent = dir->list[dir->current_count++]; 2.1889 + struct stat *buf = &dir_ent->inode->buf; 2.1890 +- if(dir_ent->data) 2.1891 ++ if(dir_ent->inode->root_entry) 2.1892 + continue; 2.1893 + 2.1894 + switch(buf->st_mode & S_IFMT) { 2.1895 +@@ -254,6 +254,7 @@ 2.1896 + write_file(&inode, entry->dir, &duplicate_file); 2.1897 + INFO("file %s, uncompressed size %lld bytes %s" 2.1898 + "\n", entry->dir->pathname, 2.1899 ++ (long long) 2.1900 + entry->dir->inode->buf.st_size, 2.1901 + duplicate_file ? "DUPLICATE" : ""); 2.1902 + entry->dir->inode->inode = inode; 2.1903 +@@ -261,6 +262,7 @@ 2.1904 + } else 2.1905 + INFO("file %s, uncompressed size %lld bytes " 2.1906 + "LINK\n", entry->dir->pathname, 2.1907 ++ (long long) 2.1908 + entry->dir->inode->buf.st_size); 2.1909 + } 2.1910 + } 2.1911 + 2.1912 +--- squashfs-4.0/squashfs-tools/sort.h Sun Feb 8 13:02:53 2009 2.1913 ++++ squashfs-4.0/squashfs-tools/sort.h Thu Sep 10 05:50:01 2009 2.1914 +@@ -42,17 +42,19 @@ 2.1915 + struct inode_info *inode; 2.1916 + struct dir_info *dir; 2.1917 + struct dir_info *our_dir; 2.1918 +- struct old_root_entry_info *data; 2.1919 + }; 2.1920 + 2.1921 + struct inode_info { 2.1922 +- unsigned int nlink; 2.1923 + struct stat buf; 2.1924 ++ struct inode_info *next; 2.1925 + squashfs_inode inode; 2.1926 +- unsigned int type; 2.1927 + unsigned int inode_number; 2.1928 ++ unsigned int nlink; 2.1929 ++ int pseudo_id; 2.1930 ++ char type; 2.1931 + char read; 2.1932 +- struct inode_info *next; 2.1933 ++ char root_entry; 2.1934 ++ char pseudo_file; 2.1935 + }; 2.1936 + 2.1937 + struct priority_entry { 2.1938 + 2.1939 +--- squashfs-4.0/squashfs-tools/squashfs_compat.h Mon Mar 16 05:27:27 2009 2.1940 ++++ squashfs-4.0/squashfs-tools/squashfs_compat.h Tue Apr 21 02:52:24 2009 2.1941 +@@ -777,11 +777,10 @@ 2.1942 + #endif 2.1943 + 2.1944 + #define _SQUASHFS_SWAP(value, p, pos, tbits, SHIFT) {\ 2.1945 +- int bits;\ 2.1946 +- int b_pos = pos % 8;\ 2.1947 +- unsigned long long val = 0;\ 2.1948 +- unsigned char *s = (unsigned char *)p + (pos / 8);\ 2.1949 +- unsigned char *d = ((unsigned char *) &val) + 7;\ 2.1950 ++ b_pos = pos % 8;\ 2.1951 ++ val = 0;\ 2.1952 ++ s = (unsigned char *)p + (pos / 8);\ 2.1953 ++ d = ((unsigned char *) &val) + 7;\ 2.1954 + for(bits = 0; bits < (tbits + b_pos); bits += 8) \ 2.1955 + *d-- = *s++;\ 2.1956 + value = (val >> (SHIFT))/* & ((1 << tbits) - 1)*/;\ 2.1957 + 2.1958 +--- squashfs-4.0/squashfs-tools/squashfs_fs.h Wed Mar 18 03:50:20 2009 2.1959 ++++ squashfs-4.0/squashfs-tools/squashfs_fs.h Thu Jul 30 06:45:38 2009 2.1960 +@@ -229,6 +229,7 @@ 2.1961 + typedef long long squashfs_inode_t; 2.1962 + 2.1963 + #define ZLIB_COMPRESSION 1 2.1964 ++#define LZMA_COMPRESSION 2 2.1965 + 2.1966 + struct squashfs_super_block { 2.1967 + unsigned int s_magic; 2.1968 + 2.1969 +--- squashfs-4.0/squashfs-tools/unsquash-3.c Tue Mar 31 06:35:10 2009 2.1970 ++++ squashfs-4.0/squashfs-tools/unsquash-3.c Tue Apr 21 02:58:22 2009 2.1971 +@@ -36,7 +36,7 @@ 2.1972 + sBlk.fragment_table_start); 2.1973 + 2.1974 + if(sBlk.fragments == 0) 2.1975 +- return; 2.1976 ++ return TRUE; 2.1977 + 2.1978 + if((fragment_table = malloc(sBlk.fragments * 2.1979 + sizeof(squashfs_fragment_entry_3))) == NULL) 2.1980 + 2.1981 +--- squashfs-4.0/squashfs-tools/unsquash-4.c Tue Mar 31 06:38:31 2009 2.1982 ++++ squashfs-4.0/squashfs-tools/unsquash-4.c Tue Apr 21 02:59:16 2009 2.1983 +@@ -38,7 +38,7 @@ 2.1984 + sBlk.fragment_table_start); 2.1985 + 2.1986 + if(sBlk.fragments == 0) 2.1987 +- return; 2.1988 ++ return TRUE; 2.1989 + 2.1990 + if((fragment_table = malloc(sBlk.fragments * 2.1991 + sizeof(squashfs_fragment_entry))) == NULL) 2.1992 + 2.1993 +--- squashfs-4.0/squashfs-tools/unsquashfs.c Sun Apr 5 23:23:06 2009 2.1994 ++++ squashfs-4.0/squashfs-tools/unsquashfs.c Sun Aug 30 16:10:31 2009 2.1995 +@@ -25,7 +25,10 @@ 2.1996 + #include "squashfs_swap.h" 2.1997 + #include "squashfs_compat.h" 2.1998 + #include "read_fs.h" 2.1999 ++#include "compressor.h" 2.2000 + 2.2001 ++#include <sys/sysinfo.h> 2.2002 ++ 2.2003 + struct cache *fragment_cache, *data_cache; 2.2004 + struct queue *to_reader, *to_deflate, *to_writer, *from_writer; 2.2005 + pthread_t *thread, *deflator_thread; 2.2006 +@@ -36,6 +39,7 @@ 2.2007 + 2.2008 + struct super_block sBlk; 2.2009 + squashfs_operations s_ops; 2.2010 ++struct compressor *comp; 2.2011 + 2.2012 + int bytes = 0, swap, file_count = 0, dir_count = 0, sym_count = 0, 2.2013 + dev_count = 0, fifo_count = 0; 2.2014 +@@ -590,31 +594,23 @@ 2.2015 + offset = 3; 2.2016 + if(SQUASHFS_COMPRESSED(c_byte)) { 2.2017 + char buffer[SQUASHFS_METADATA_SIZE]; 2.2018 +- int res; 2.2019 +- unsigned long bytes = SQUASHFS_METADATA_SIZE; 2.2020 ++ int error, res; 2.2021 + 2.2022 + c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte); 2.2023 + if(read_bytes(start + offset, c_byte, buffer) == FALSE) 2.2024 + goto failed; 2.2025 + 2.2026 +- res = uncompress((unsigned char *) block, &bytes, 2.2027 +- (const unsigned char *) buffer, c_byte); 2.2028 ++ res = comp->uncompress(block, buffer, c_byte, 2.2029 ++ SQUASHFS_METADATA_SIZE, &error); 2.2030 + 2.2031 +- if(res != Z_OK) { 2.2032 +- if(res == Z_MEM_ERROR) 2.2033 +- ERROR("zlib::uncompress failed, not enough " 2.2034 +- "memory\n"); 2.2035 +- else if(res == Z_BUF_ERROR) 2.2036 +- ERROR("zlib::uncompress failed, not enough " 2.2037 +- "room in output buffer\n"); 2.2038 +- else 2.2039 +- ERROR("zlib::uncompress failed, unknown error " 2.2040 +- "%d\n", res); 2.2041 ++ if(res == -1) { 2.2042 ++ ERROR("%s uncompress failed with error code %d\n", 2.2043 ++ comp->name, error); 2.2044 + goto failed; 2.2045 + } 2.2046 + if(next) 2.2047 + *next = start + offset + c_byte; 2.2048 +- return bytes; 2.2049 ++ return res; 2.2050 + } else { 2.2051 + c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte); 2.2052 + if(read_bytes(start + offset, c_byte, block) == FALSE) 2.2053 +@@ -632,36 +628,26 @@ 2.2054 + 2.2055 + int read_data_block(long long start, unsigned int size, char *block) 2.2056 + { 2.2057 +- int res; 2.2058 +- unsigned long bytes = block_size; 2.2059 ++ int error, res; 2.2060 + int c_byte = SQUASHFS_COMPRESSED_SIZE_BLOCK(size); 2.2061 + 2.2062 + TRACE("read_data_block: block @0x%llx, %d %s bytes\n", start, 2.2063 +- SQUASHFS_COMPRESSED_SIZE_BLOCK(c_byte), 2.2064 +- SQUASHFS_COMPRESSED_BLOCK(c_byte) ? "compressed" : 2.2065 ++ c_byte, SQUASHFS_COMPRESSED_BLOCK(size) ? "compressed" : 2.2066 + "uncompressed"); 2.2067 + 2.2068 + if(SQUASHFS_COMPRESSED_BLOCK(size)) { 2.2069 + if(read_bytes(start, c_byte, data) == FALSE) 2.2070 + goto failed; 2.2071 + 2.2072 +- res = uncompress((unsigned char *) block, &bytes, 2.2073 +- (const unsigned char *) data, c_byte); 2.2074 ++ res = comp->uncompress(block, data, c_byte, block_size, &error); 2.2075 + 2.2076 +- if(res != Z_OK) { 2.2077 +- if(res == Z_MEM_ERROR) 2.2078 +- ERROR("zlib::uncompress failed, not enough " 2.2079 +- "memory\n"); 2.2080 +- else if(res == Z_BUF_ERROR) 2.2081 +- ERROR("zlib::uncompress failed, not enough " 2.2082 +- "room in output buffer\n"); 2.2083 +- else 2.2084 +- ERROR("zlib::uncompress failed, unknown error " 2.2085 +- "%d\n", res); 2.2086 ++ if(res == -1) { 2.2087 ++ ERROR("%s uncompress failed with error code %d\n", 2.2088 ++ comp->name, error); 2.2089 + goto failed; 2.2090 + } 2.2091 + 2.2092 +- return bytes; 2.2093 ++ return res; 2.2094 + } else { 2.2095 + if(read_bytes(start, c_byte, block) == FALSE) 2.2096 + goto failed; 2.2097 +@@ -671,7 +657,7 @@ 2.2098 + 2.2099 + failed: 2.2100 + ERROR("read_data_block: failed to read block @0x%llx, size %d\n", start, 2.2101 +- size); 2.2102 ++ c_byte); 2.2103 + return FALSE; 2.2104 + } 2.2105 + 2.2106 +@@ -1383,6 +1369,11 @@ 2.2107 + #endif 2.2108 + printf("Creation or last append time %s", mkfs_str ? mkfs_str : 2.2109 + "failed to get time\n"); 2.2110 ++ printf("Filesystem size %.2f Kbytes (%.2f Mbytes)\n", 2.2111 ++ sBlk.bytes_used / 1024.0, sBlk.bytes_used / (1024.0 * 1024.0)); 2.2112 ++ if(sBlk.s_major == 4) 2.2113 ++ printf("Compression %s\n", comp->name); 2.2114 ++ printf("Block size %d\n", sBlk.block_size); 2.2115 + printf("Filesystem is %sexportable via NFS\n", 2.2116 + SQUASHFS_EXPORTABLE(sBlk.flags) ? "" : "not "); 2.2117 + 2.2118 +@@ -1409,9 +1400,6 @@ 2.2119 + SQUASHFS_DUPLICATES(sBlk.flags) ? "" : "not "); 2.2120 + else 2.2121 + printf("Duplicates are removed\n"); 2.2122 +- printf("Filesystem size %.2f Kbytes (%.2f Mbytes)\n", 2.2123 +- sBlk.bytes_used / 1024.0, sBlk.bytes_used / (1024.0 * 1024.0)); 2.2124 +- printf("Block size %d\n", sBlk.block_size); 2.2125 + if(sBlk.s_major > 1) 2.2126 + printf("Number of fragments %d\n", sBlk.fragments); 2.2127 + printf("Number of inodes %d\n", sBlk.inodes); 2.2128 +@@ -1459,6 +1447,18 @@ 2.2129 + s_ops.read_inode = read_inode_4; 2.2130 + s_ops.read_uids_guids = read_uids_guids_4; 2.2131 + memcpy(&sBlk, &sBlk_4, sizeof(sBlk_4)); 2.2132 ++ 2.2133 ++ /* 2.2134 ++ * Check the compression type 2.2135 ++ */ 2.2136 ++ comp = lookup_compressor_id(sBlk.compression); 2.2137 ++ if(!comp->supported) { 2.2138 ++ ERROR("Filesystem uses %s compression, this is " 2.2139 ++ "unsupported by this version\n", comp->name); 2.2140 ++ ERROR("Decompressors available:\n"); 2.2141 ++ display_compressors("", ""); 2.2142 ++ goto failed_mount; 2.2143 ++ } 2.2144 + return TRUE; 2.2145 + } 2.2146 + 2.2147 +@@ -1548,6 +1548,11 @@ 2.2148 + goto failed_mount; 2.2149 + } 2.2150 + 2.2151 ++ /* 2.2152 ++ * 1.x, 2.x and 3.x filesystems use gzip compression. Gzip is always 2.2153 ++ * suppported. 2.2154 ++ */ 2.2155 ++ comp = lookup_compressor("gzip"); 2.2156 + return TRUE; 2.2157 + 2.2158 + failed_mount: 2.2159 +@@ -1707,32 +1712,24 @@ 2.2160 + 2.2161 + while(1) { 2.2162 + struct cache_entry *entry = queue_get(to_deflate); 2.2163 +- int res; 2.2164 +- unsigned long bytes = block_size; 2.2165 ++ int error, res; 2.2166 + 2.2167 +- res = uncompress((unsigned char *) tmp, &bytes, 2.2168 +- (const unsigned char *) entry->data, 2.2169 +- SQUASHFS_COMPRESSED_SIZE_BLOCK(entry->size)); 2.2170 ++ res = comp->uncompress(tmp, entry->data, 2.2171 ++ SQUASHFS_COMPRESSED_SIZE_BLOCK(entry->size), block_size, 2.2172 ++ &error); 2.2173 + 2.2174 +- if(res != Z_OK) { 2.2175 +- if(res == Z_MEM_ERROR) 2.2176 +- ERROR("zlib::uncompress failed, not enough" 2.2177 +- "memory\n"); 2.2178 +- else if(res == Z_BUF_ERROR) 2.2179 +- ERROR("zlib::uncompress failed, not enough " 2.2180 +- "room in output buffer\n"); 2.2181 +- else 2.2182 +- ERROR("zlib::uncompress failed, unknown error " 2.2183 +- "%d\n", res); 2.2184 +- } else 2.2185 +- memcpy(entry->data, tmp, bytes); 2.2186 ++ if(res == -1) 2.2187 ++ ERROR("%s uncompress failed with error code %d\n", 2.2188 ++ comp->name, error); 2.2189 ++ else 2.2190 ++ memcpy(entry->data, tmp, res); 2.2191 + 2.2192 + /* 2.2193 + * block has been either successfully decompressed, or an error 2.2194 + * occurred, clear pending flag, set error appropriately and 2.2195 + * wake up any threads waiting on this block 2.2196 + */ 2.2197 +- cache_block_ready(entry, res != Z_OK); 2.2198 ++ cache_block_ready(entry, res == -1); 2.2199 + } 2.2200 + } 2.2201 + 2.2202 +@@ -1913,7 +1910,7 @@ 2.2203 + 2.2204 + 2.2205 + #define VERSION() \ 2.2206 +- printf("unsquashfs version 4.0 (2009/04/05)\n");\ 2.2207 ++ printf("unsquashfs version 4.0 (CVS 2009/08/30)\n");\ 2.2208 + printf("copyright (C) 2009 Phillip Lougher <phillip@lougher.demon.co.uk>"\ 2.2209 + "\n\n");\ 2.2210 + printf("This program is free software; you can redistribute it and/or\n");\ 2.2211 +@@ -1938,7 +1935,6 @@ 2.2212 + int fragment_buffer_size = FRAGMENT_BUFFER_DEFAULT; 2.2213 + int data_buffer_size = DATA_BUFFER_DEFAULT; 2.2214 + char *b; 2.2215 +- struct winsize winsize; 2.2216 + 2.2217 + pthread_mutex_init(&screen_mutex, NULL); 2.2218 + root_process = geteuid() == 0; 2.2219 +@@ -2087,6 +2083,8 @@ 2.2220 + "regular expressions\n"); 2.2221 + ERROR("\t\t\t\trather than use the default shell " 2.2222 + "wildcard\n\t\t\t\texpansion (globbing)\n"); 2.2223 ++ ERROR("\nDecompressors available:\n"); 2.2224 ++ display_compressors("", ""); 2.2225 + } 2.2226 + exit(1); 2.2227 + } 2.2228 + 2.2229 +--- squashfs-4.0/squashfs-tools/unsquashfs.h Sun Mar 29 04:29:02 2009 2.2230 ++++ squashfs-4.0/squashfs-tools/unsquashfs.h Fri Jul 31 19:24:38 2009 2.2231 +@@ -31,7 +31,6 @@ 2.2232 + #include <fcntl.h> 2.2233 + #include <errno.h> 2.2234 + #include <string.h> 2.2235 +-#include <zlib.h> 2.2236 + #include <sys/mman.h> 2.2237 + #include <utime.h> 2.2238 + #include <pwd.h>