tools/squashfs4/patches/110-lzma.patch

   1 diff -Nur squashfs4.0/squashfs-tools/compressor.c squashfs4.0-lzma-snapshot/squashfs-tools/compressor.c
   2 --- squashfs4.0/squashfs-tools/compressor.c     1970-01-01 01:00:00.000000000 +0100
   3 +++ squashfs4.0-lzma-snapshot/squashfs-tools/compressor.c       2009-10-20 06:03:37.000000000 +0200
   4 @@ -0,0 +1,78 @@
   5 +/*
   6 + *
   7 + * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
   8 + * Phillip Lougher <phillip@lougher.demon.co.uk>
   9 + *
  10 + * This program is free software; you can redistribute it and/or
  11 + * modify it under the terms of the GNU General Public License
  12 + * as published by the Free Software Foundation; either version 2,
  13 + * or (at your option) any later version.
  14 + *
  15 + * This program is distributed in the hope that it will be useful,
  16 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 + * GNU General Public License for more details.
  19 + *
  20 + * You should have received a copy of the GNU General Public License
  21 + * along with this program; if not, write to the Free Software
  22 + * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23 + *
  24 + * compressor.c
  25 + */
  26 +
  27 +#include <stdio.h>
  28 +#include <string.h>
  29 +#include "compressor.h"
  30 +#include "squashfs_fs.h"
  31 +
  32 +extern int gzip_compress(void **, char *, char *, int, int, int *);
  33 +extern int gzip_uncompress(char *, char *, int, int, int *);
  34 +extern int lzma_compress(void **, char *, char *, int, int, int *);
  35 +extern int lzma_uncompress(char *, char *, int, int, int *);
  36 +
  37 +struct compressor compressor[] = {
  38 +       { gzip_compress, gzip_uncompress, ZLIB_COMPRESSION, "gzip", 1 },
  39 +#ifdef LZMA_SUPPORT
  40 +       { lzma_compress, lzma_uncompress, LZMA_COMPRESSION, "lzma", 1 },
  41 +#else
  42 +       { NULL, NULL, LZMA_COMPRESSION, "lzma", 0 },
  43 +#endif
  44 +       { NULL, NULL , 0, "unknown", 0}
  45 +};
  46 +
  47 +
  48 +struct compressor *lookup_compressor(char *name)
  49 +{
  50 +       int i;
  51 +
  52 +       for(i = 0; compressor[i].id; i++)
  53 +               if(strcmp(compressor[i].name, name) == 0)
  54 +                       break;
  55 +
  56 +       return &compressor[i];
  57 +}
  58 +
  59 +
  60 +struct compressor *lookup_compressor_id(int id)
  61 +{
  62 +       int i;
  63 +
  64 +       for(i = 0; compressor[i].id; i++)
  65 +               if(id == compressor[i].id)
  66 +                       break;
  67 +
  68 +       return &compressor[i];
  69 +}
  70 +
  71 +
  72 +void display_compressors(char *indent, char *def_comp)
  73 +{
  74 +       int i;
  75 +
  76 +       for(i = 0; compressor[i].id; i++)
  77 +               if(compressor[i].supported)
  78 +                       fprintf(stderr, "%s\t%s%s\n", indent,
  79 +                               compressor[i].name,
  80 +                               strcmp(compressor[i].name, def_comp) == 0 ?
  81 +                               " (default)" : "");
  82 +}
  83 diff -Nur squashfs4.0/squashfs-tools/compressor.h squashfs4.0-lzma-snapshot/squashfs-tools/compressor.h
  84 --- squashfs4.0/squashfs-tools/compressor.h     1970-01-01 01:00:00.000000000 +0100
  85 +++ squashfs4.0-lzma-snapshot/squashfs-tools/compressor.h       2009-10-20 06:03:37.000000000 +0200
  86 @@ -0,0 +1,33 @@
  87 +/*
  88 + *
  89 + * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
  90 + * Phillip Lougher <phillip@lougher.demon.co.uk>
  91 + *
  92 + * This program is free software; you can redistribute it and/or
  93 + * modify it under the terms of the GNU General Public License
  94 + * as published by the Free Software Foundation; either version 2,
  95 + * or (at your option) any later version.
  96 + *
  97 + * This program is distributed in the hope that it will be useful,
  98 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  99 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 100 + * GNU General Public License for more details.
 101 + *
 102 + * You should have received a copy of the GNU General Public License
 103 + * along with this program; if not, write to the Free Software
 104 + * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 105 + *
 106 + * compressor.h
 107 + */
 108 +
 109 +struct compressor {
 110 +       int (*compress)(void **, char *, char *, int, int, int *);
 111 +       int (*uncompress)(char *, char *, int, int, int *);
 112 +       int id;
 113 +       char *name;
 114 +       int supported;
 115 +};
 116 +
 117 +extern struct compressor *lookup_compressor(char *);
 118 +extern struct compressor *lookup_compressor_id(int);
 119 +extern void display_compressors(char *, char *);
 120 diff -Nur squashfs4.0/squashfs-tools/gzip_wrapper.c squashfs4.0-lzma-snapshot/squashfs-tools/gzip_wrapper.c
 121 --- squashfs4.0/squashfs-tools/gzip_wrapper.c   1970-01-01 01:00:00.000000000 +0100
 122 +++ squashfs4.0-lzma-snapshot/squashfs-tools/gzip_wrapper.c     2009-10-20 06:03:37.000000000 +0200
 123 @@ -0,0 +1,80 @@
 124 +/*
 125 + * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
 126 + * Phillip Lougher <phillip@lougher.demon.co.uk>
 127 + *
 128 + * This program is free software; you can redistribute it and/or
 129 + * modify it under the terms of the GNU General Public License
 130 + * as published by the Free Software Foundation; either version 2,
 131 + * or (at your option) any later version.
 132 + *
 133 + * This program is distributed in the hope that it will be useful,
 134 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 135 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 136 + * GNU General Public License for more details.
 137 + *
 138 + * You should have received a copy of the GNU General Public License
 139 + * along with this program; if not, write to the Free Software
 140 + * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 141 + *
 142 + * gzip_wrapper.c
 143 + */
 144 +
 145 +#include <stdlib.h>
 146 +#include <zlib.h>
 147 +
 148 +int gzip_compress(void **strm, char *d, char *s, int size, int block_size,
 149 +               int *error)
 150 +{
 151 +       int res = 0;
 152 +       z_stream *stream = *strm;
 153 +
 154 +       if(stream == NULL) {
 155 +               if((stream = *strm = malloc(sizeof(z_stream))) == NULL)
 156 +                       goto failed;
 157 +
 158 +               stream->zalloc = Z_NULL;
 159 +               stream->zfree = Z_NULL;
 160 +               stream->opaque = 0;
 161 +
 162 +               if((res = deflateInit(stream, 9)) != Z_OK)
 163 +                       goto failed;
 164 +       } else if((res = deflateReset(stream)) != Z_OK)
 165 +               goto failed;
 166 +
 167 +       stream->next_in = (unsigned char *) s;
 168 +       stream->avail_in = size;
 169 +       stream->next_out = (unsigned char *) d;
 170 +       stream->avail_out = block_size;
 171 +
 172 +       res = deflate(stream, Z_FINISH);
 173 +       if(res == Z_STREAM_END)
 174 +               /*
 175 +                * Success, return the compressed size.
 176 +                */
 177 +               return (int) stream->total_out;
 178 +       if(res == Z_OK)
 179 +               /*
 180 +                * Output buffer overflow.  Return out of buffer space
 181 +                */
 182 +               return 0;
 183 +failed:
 184 +       /*
 185 +        * All other errors return failure, with the compressor
 186 +        * specific error code in *error
 187 +        */
 188 +       *error = res;
 189 +       return -1;
 190 +}
 191 +
 192 +
 193 +int gzip_uncompress(char *d, char *s, int size, int block_size, int *error)
 194 +{
 195 +       int res;
 196 +       unsigned long bytes = block_size;
 197 +
 198 +       res = uncompress((unsigned char *) d, &bytes,
 199 +               (const unsigned char *) s, size);
 200 +
 201 +       *error = res;
 202 +       return res == Z_OK ? (int) bytes : -1;
 203 +}
 204 diff -Nur squashfs4.0/squashfs-tools/lzma_wrapper.c squashfs4.0-lzma-snapshot/squashfs-tools/lzma_wrapper.c
 205 --- squashfs4.0/squashfs-tools/lzma_wrapper.c   1970-01-01 01:00:00.000000000 +0100
 206 +++ squashfs4.0-lzma-snapshot/squashfs-tools/lzma_wrapper.c     2009-10-14 05:32:57.000000000 +0200
 207 @@ -0,0 +1,93 @@
 208 +/*
 209 + * Copyright (c) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
 210 + * Phillip Lougher <phillip@lougher.demon.co.uk>
 211 + *
 212 + * This program is free software; you can redistribute it and/or
 213 + * modify it under the terms of the GNU General Public License
 214 + * as published by the Free Software Foundation; either version 2,
 215 + * or (at your option) any later version.
 216 + *
 217 + * This program is distributed in the hope that it will be useful,
 218 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 219 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 220 + * GNU General Public License for more details.
 221 + *
 222 + * You should have received a copy of the GNU General Public License
 223 + * along with this program; if not, write to the Free Software
 224 + * Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 225 + *
 226 + * lzma_wrapper.c
 227 + */
 228 +
 229 +#include <LzmaLib.h>
 230 +
 231 +#define LZMA_HEADER_SIZE       (LZMA_PROPS_SIZE + 8)
 232 +
 233 +int lzma_compress(void **strm, char *dest, char *src,  int size,int block_size,
 234 +               int *error)
 235 +{
 236 +       unsigned char *d = (unsigned char *) dest, *s = (unsigned char *) src;
 237 +       size_t props_size = LZMA_PROPS_SIZE,
 238 +               outlen = block_size - LZMA_HEADER_SIZE;
 239 +       int res;
 240 +
 241 +       res = LzmaCompress(d + LZMA_HEADER_SIZE, &outlen, s, size, d,
 242 +               &props_size, 5, block_size, 3, 0, 2, 32, 1);
 243 +
 244 +       if(res == SZ_ERROR_OUTPUT_EOF) {
 245 +               /*
 246 +                * Output buffer overflow.  Return out of buffer space error
 247 +                */
 248 +               return 0;
 249 +       }
 250 +
 251 +       if(res != SZ_OK) {
 252 +               /*
 253 +                * All other errors return failure, with the compressor
 254 +                * specific error code in *error
 255 +                */
 256 +               *error = res;
 257 +               return -1;
 258 +       }
 259 +
 260 +       /*
 261 +        * Fill in the 8 byte little endian uncompressed size field in the
 262 +        * LZMA header.  8 bytes is excessively large for squashfs but
 263 +        * this is the standard LZMA header and which is expected by the kernel
 264 +        * code
 265 +        */
 266 +       d[LZMA_PROPS_SIZE] = size & 255;
 267 +       d[LZMA_PROPS_SIZE + 1] = (size >> 8) & 255;
 268 +       d[LZMA_PROPS_SIZE + 2] = (size >> 16) & 255;
 269 +       d[LZMA_PROPS_SIZE + 3] = (size >> 24) & 255;
 270 +       d[LZMA_PROPS_SIZE + 4] = 0;
 271 +       d[LZMA_PROPS_SIZE + 5] = 0;
 272 +       d[LZMA_PROPS_SIZE + 6] = 0;
 273 +       d[LZMA_PROPS_SIZE + 7] = 0;
 274 +
 275 +       /*
 276 +        * Success, return the compressed size.  Outlen returned by the LZMA
 277 +        * compressor does not include the LZMA header space
 278 +        */
 279 +       return outlen + LZMA_HEADER_SIZE;
 280 +}
 281 +
 282 +
 283 +int lzma_uncompress(char *dest, char *src, int size, int block_size,
 284 +       int *error)
 285 +{
 286 +       unsigned char *d = (unsigned char *) dest, *s = (unsigned char *) src;
 287 +       size_t outlen, inlen = size - LZMA_HEADER_SIZE;
 288 +       int res;
 289 +
 290 +       outlen = s[LZMA_PROPS_SIZE] |
 291 +               (s[LZMA_PROPS_SIZE + 1] << 8) |
 292 +               (s[LZMA_PROPS_SIZE + 2] << 16) |
 293 +               (s[LZMA_PROPS_SIZE + 3] << 24);
 294 +
 295 +       res = LzmaUncompress(d, &outlen, s + LZMA_HEADER_SIZE, &inlen,
 296 +               s, LZMA_PROPS_SIZE);
 297 +
 298 +       *error = res;
 299 +       return res == SZ_OK ? outlen : -1;
 300 +}
 301 diff -Nur squashfs4.0/squashfs-tools/Makefile squashfs4.0-lzma-snapshot/squashfs-tools/Makefile
 302 --- squashfs4.0/squashfs-tools/Makefile 2009-04-05 04:03:36.000000000 +0200
 303 +++ squashfs4.0-lzma-snapshot/squashfs-tools/Makefile   2009-10-22 06:17:12.000000000 +0200
 304 @@ -1,40 +1,76 @@
 305 +#
 306 +# Building LZMA support
 307 +# Download LZMA sdk (4.65 used in development, other versions may work),
 308 +# set LZMA_DIR to unpacked source, and uncomment next line
 309 +LZMA_SUPPORT = 1
 310 +LZMA_DIR = ../../lzma-4.65
 311 +
 312 +#Compression default.
 313 +COMP_DEFAULT = gzip
 314 +
 315 +INCLUDEDIR = -I.
 316  INSTALL_DIR = /usr/local/bin
 317
 318 -INCLUDEDIR = .
 319 +MKSQUASHFS_OBJS = mksquashfs.o read_fs.o sort.o swap.o pseudo.o compressor.o \
 320 +       gzip_wrapper.o
 321 +
 322 +UNSQUASHFS_OBJS = unsquashfs.o unsquash-1.o unsquash-2.o unsquash-3.o \
 323 +       unsquash-4.o swap.o compressor.o gzip_wrapper.o
 324
 325 -CFLAGS := -I$(INCLUDEDIR) -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE -D_GNU_SOURCE -O2
 326 +CFLAGS = $(INCLUDEDIR) -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE \
 327 +       -D_GNU_SOURCE -DCOMP_DEFAULT=\"$(COMP_DEFAULT)\" -O2 -Wall
 328
 329 +ifdef LZMA_SUPPORT
 330 +LZMA_OBJS = $(LZMA_DIR)/C/Alloc.o $(LZMA_DIR)/C/LzFind.o \
 331 +       $(LZMA_DIR)/C/LzmaDec.o $(LZMA_DIR)/C/LzmaEnc.o $(LZMA_DIR)/C/LzmaLib.o
 332 +INCLUDEDIR += -I$(LZMA_DIR)/C
 333 +CFLAGS += -DLZMA_SUPPORT
 334 +MKSQUASHFS_OBJS += lzma_wrapper.o $(LZMA_OBJS)
 335 +UNSQUASHFS_OBJS += lzma_wrapper.o $(LZMA_OBJS)
 336 +endif
 337 +
 338 +.PHONY: all
 339  all: mksquashfs unsquashfs
 340
 341 -mksquashfs: mksquashfs.o read_fs.o sort.o swap.o pseudo.o
 342 -       $(CC) mksquashfs.o read_fs.o sort.o swap.o pseudo.o -lz -lpthread -lm -o $@
 343 +mksquashfs: $(MKSQUASHFS_OBJS)
 344 +       $(CC) $(MKSQUASHFS_OBJS) -lz -lpthread -lm -o $@
 345 +
 346 +mksquashfs.o: mksquashfs.c squashfs_fs.h mksquashfs.h global.h sort.h \
 347 +       squashfs_swap.h
 348
 349 -mksquashfs.o: mksquashfs.c squashfs_fs.h mksquashfs.h global.h sort.h squashfs_swap.h Makefile
 350 +read_fs.o: read_fs.c squashfs_fs.h read_fs.h global.h squashfs_swap.h
 351
 352 -read_fs.o: read_fs.c squashfs_fs.h read_fs.h global.h squashfs_swap.h Makefile
 353 +sort.o: sort.c squashfs_fs.h global.h sort.h
 354
 355 -sort.o: sort.c squashfs_fs.h global.h sort.h Makefile
 356 +swap.o: swap.c
 357
 358 -swap.o: swap.c Makefile
 359 +pseudo.o: pseudo.c pseudo.h
 360
 361 -pseudo.o: pseudo.c pseudo.h Makefile
 362 +compressor.o: compressor.c compressor.h
 363
 364 -unsquashfs: unsquashfs.o unsquash-1.o unsquash-2.o unsquash-3.o unsquash-4.o swap.o
 365 -       $(CC) unsquashfs.o unsquash-1.o unsquash-2.o unsquash-3.o unsquash-4.o swap.o -lz -lpthread -lm -o $@
 366 +unsquashfs: $(UNSQUASHFS_OBJS)
 367 +       $(CC) $(UNSQUASHFS_OBJS) -lz -lpthread -lm -o $@
 368
 369 -unsquashfs.o: unsquashfs.h unsquashfs.c squashfs_fs.h squashfs_swap.h squashfs_compat.h global.h Makefile
 370 +unsquashfs.o: unsquashfs.h unsquashfs.c squashfs_fs.h squashfs_swap.h \
 371 +       squashfs_compat.h global.h
 372
 373 -unsquash-1.o: unsquashfs.h unsquash-1.c squashfs_fs.h squashfs_compat.h global.h Makefile
 374 +unsquash-1.o: unsquashfs.h unsquash-1.c squashfs_fs.h squashfs_compat.h \
 375 +       global.h
 376
 377 -unsquash-2.o: unsquashfs.h unsquash-2.c unsquashfs.h squashfs_fs.h squashfs_compat.h global.h Makefile
 378 +unsquash-2.o: unsquashfs.h unsquash-2.c unsquashfs.h squashfs_fs.h \
 379 +       squashfs_compat.h global.h
 380
 381 -unsquash-3.o: unsquashfs.h unsquash-3.c squashfs_fs.h squashfs_compat.h global.h Makefile
 382 +unsquash-3.o: unsquashfs.h unsquash-3.c squashfs_fs.h squashfs_compat.h \
 383 +       global.h
 384
 385 -unsquash-4.o: unsquashfs.h unsquash-4.c squashfs_fs.h squashfs_swap.h global.h Makefile
 386 +unsquash-4.o: unsquashfs.h unsquash-4.c squashfs_fs.h squashfs_swap.h \
 387 +       global.h
 388
 389 +.PHONY: clean
 390  clean:
 391         -rm -f *.o mksquashfs unsquashfs
 392
 393 +.PHONY: install
 394  install: mksquashfs unsquashfs
 395         mkdir -p $(INSTALL_DIR)
 396         cp mksquashfs $(INSTALL_DIR)
 397 diff -Nur squashfs4.0/squashfs-tools/mksquashfs.c squashfs4.0-lzma-snapshot/squashfs-tools/mksquashfs.c
 398 --- squashfs4.0/squashfs-tools/mksquashfs.c     2009-04-05 23:22:48.000000000 +0200
 399 +++ squashfs4.0-lzma-snapshot/squashfs-tools/mksquashfs.c       2009-10-20 06:03:38.000000000 +0200
 400 @@ -36,7 +36,6 @@
 401  #include <errno.h>
 402  #include <dirent.h>
 403  #include <string.h>
 404 -#include <zlib.h>
 405  #include <stdlib.h>
 406  #include <signal.h>
 407  #include <setjmp.h>
 408 @@ -47,6 +46,7 @@
 409  #include <math.h>
 410  #include <regex.h>
 411  #include <fnmatch.h>
 412 +#include <sys/wait.h>
 413
 414  #ifndef linux
 415  #define __BYTE_ORDER BYTE_ORDER
 416 @@ -64,6 +64,7 @@
 417  #include "global.h"
 418  #include "sort.h"
 419  #include "pseudo.h"
 420 +#include "compressor.h"
 421
 422  #ifdef SQUASHFS_TRACE
 423  #define TRACE(s, args...)      do { \
 424 @@ -245,10 +246,8 @@
 425  /* list of root directory entries read from original filesystem */
 426  int old_root_entries = 0;
 427  struct old_root_entry_info {
 428 -       char                    name[SQUASHFS_NAME_LEN + 1];
 429 -       squashfs_inode          inode;
 430 -       int                     type;
 431 -       int                     inode_number;
 432 +       char                    *name;
 433 +       struct inode_info       inode;
 434  };
 435  struct old_root_entry_info *old_root_entry;
 436
 437 @@ -371,10 +370,15 @@
 438  int reader_buffer_size;
 439  int fragment_buffer_size;
 440
 441 +/* compression operations structure */
 442 +static struct compressor *comp;
 443 +char *comp_name = COMP_DEFAULT;
 444 +
 445  char *read_from_disk(long long start, unsigned int avail_bytes);
 446  void add_old_root_entry(char *name, squashfs_inode inode, int inode_number,
 447         int type);
 448 -extern int read_super(int fd, squashfs_super_block *sBlk, char *source);
 449 +extern struct compressor  *read_super(int fd, squashfs_super_block *sBlk,
 450 +       char *source);
 451  extern long long read_filesystem(char *root_name, int fd,
 452         squashfs_super_block *sBlk, char **cinode_table, char **data_cache,
 453         char **cdirectory_table, char **directory_data_cache,
 454 @@ -831,83 +835,32 @@
 455  }
 456
 457
 458 -unsigned int mangle2(z_stream **strm, char *d, char *s, int size,
 459 +int mangle2(void **strm, char *d, char *s, int size,
 460         int block_size, int uncompressed, int data_block)
 461  {
 462 -       unsigned long c_byte;
 463 -       unsigned int res;
 464 -       z_stream *stream = *strm;
 465 -
 466 -       if(uncompressed)
 467 -               goto notcompressed;
 468 -
 469 -       if(stream == NULL) {
 470 -               if((stream = *strm = malloc(sizeof(z_stream))) == NULL)
 471 -                       BAD_ERROR("mangle::compress failed, not enough "
 472 -                               "memory\n");
 473 -
 474 -               stream->zalloc = Z_NULL;
 475 -               stream->zfree = Z_NULL;
 476 -               stream->opaque = 0;
 477 -
 478 -               if((res = deflateInit(stream, 9)) != Z_OK) {
 479 -                       if(res == Z_MEM_ERROR)
 480 -                               BAD_ERROR("zlib::compress failed, not enough "
 481 -                                       "memory\n");
 482 -                       else if(res == Z_STREAM_ERROR)
 483 -                               BAD_ERROR("zlib::compress failed, not a valid "
 484 -                                       "compression level\n");
 485 -                       else if(res == Z_VERSION_ERROR)
 486 -                               BAD_ERROR("zlib::compress failed, incorrect "
 487 -                                       "zlib version\n");
 488 -                       else
 489 -                               BAD_ERROR("zlib::compress failed, unknown "
 490 -                                       "error %d\n", res);
 491 -               }
 492 -       } else if((res = deflateReset(stream)) != Z_OK) {
 493 -               if(res == Z_STREAM_ERROR)
 494 -                       BAD_ERROR("zlib::compress failed, stream state "
 495 -                               "inconsistent\n");
 496 -               else
 497 -                       BAD_ERROR("zlib::compress failed, unknown error %d\n",
 498 -                               res);
 499 -       }
 500 +       int error, c_byte = 0;
 501
 502 -       stream->next_in = (unsigned char *) s;
 503 -       stream->avail_in = size;
 504 -       stream->next_out = (unsigned char *) d;
 505 -       stream->avail_out = block_size;
 506 -
 507 -       res = deflate(stream, Z_FINISH);
 508 -       if(res != Z_STREAM_END && res != Z_OK) {
 509 -               if(res == Z_STREAM_ERROR)
 510 -                       BAD_ERROR("zlib::compress failed, stream state "
 511 -                               "inconsistent\n");
 512 -               else if(res == Z_BUF_ERROR)
 513 -                       BAD_ERROR("zlib::compress failed, no progress possible"
 514 -                               "\n");
 515 -               else
 516 -                       BAD_ERROR("zlib::compress failed, unknown error %d\n",
 517 -                               res);
 518 +       if(!uncompressed) {
 519 +               c_byte = comp->compress(strm, d, s, size, block_size, &error);
 520 +               if(c_byte == -1)
 521 +                       BAD_ERROR("mangle2:: %s compress failed with error "
 522 +                               "code %d\n", comp->name, error);
 523         }
 524
 525 -       c_byte = stream->total_out;
 526 -
 527 -       if(res != Z_STREAM_END || c_byte >= size) {
 528 -notcompressed:
 529 +       if(c_byte == 0 || c_byte >= size) {
 530                 memcpy(d, s, size);
 531                 return size | (data_block ? SQUASHFS_COMPRESSED_BIT_BLOCK :
 532                         SQUASHFS_COMPRESSED_BIT);
 533         }
 534
 535 -       return (unsigned int) c_byte;
 536 +       return c_byte;
 537  }
 538
 539
 540 -unsigned int mangle(char *d, char *s, int size, int block_size,
 541 +int mangle(char *d, char *s, int size, int block_size,
 542         int uncompressed, int data_block)
 543  {
 544 -       static z_stream *stream = NULL;
 545 +       static void *stream = NULL;
 546
 547         return mangle2(&stream, d, s, size, block_size, uncompressed,
 548                 data_block);
 549 @@ -1660,8 +1613,7 @@
 550         pthread_mutex_unlock(&fragment_mutex);
 551
 552         if(SQUASHFS_COMPRESSED_BLOCK(disk_fragment->size)) {
 553 -               int res;
 554 -               unsigned long bytes = block_size;
 555 +               int error, res;
 556                 char *data;
 557
 558                 if(compressed_buffer)
 559 @@ -1669,19 +1621,11 @@
 560                 else
 561                         data = read_from_disk(start_block, size);
 562
 563 -               res = uncompress((unsigned char *) buffer->data, &bytes,
 564 -                       (const unsigned char *) data, size);
 565 -               if(res != Z_OK) {
 566 -                       if(res == Z_MEM_ERROR)
 567 -                               BAD_ERROR("zlib::uncompress failed, not enough "
 568 -                                       "memory\n");
 569 -                       else if(res == Z_BUF_ERROR)
 570 -                               BAD_ERROR("zlib::uncompress failed, not enough "
 571 -                                       "room in output buffer\n");
 572 -                       else
 573 -                               BAD_ERROR("zlib::uncompress failed,"
 574 -                                       "  unknown error %d\n", res);
 575 -               }
 576 +               res = comp->uncompress(buffer->data, data, size, block_size,
 577 +                       &error);
 578 +               if(res == -1)
 579 +                       BAD_ERROR("%s uncompress failed with error code %d\n",
 580 +                               comp->name, error);
 581         } else if(compressed_buffer)
 582                 memcpy(buffer->data, compressed_buffer->data, size);
 583         else
 584 @@ -1733,9 +1677,7 @@
 585                 entry->buffer->block = bytes;
 586                 bytes += compressed_size;
 587                 fragments_outstanding --;
 588 -               pthread_mutex_unlock(&fragment_mutex);
 589                 queue_put(to_writer, entry->buffer);
 590 -               pthread_mutex_lock(&fragment_mutex);
 591                 TRACE("fragment_locked writing fragment %d, compressed size %d"
 592                         "\n", entry->fragment, compressed_size);
 593                 free(entry);
 594 @@ -1758,6 +1700,8 @@
 595         pthread_mutex_lock(&fragment_mutex);
 596         insert_fragment_list(&frag_locked_list, entry);
 597         pthread_mutex_unlock(&fragment_mutex);
 598 +
 599 +       return TRUE;
 600  }
 601
 602
 603 @@ -1824,7 +1768,9 @@
 604         unsigned short c_byte;
 605         char cbuffer[(SQUASHFS_METADATA_SIZE << 2) + 2];
 606
 607 +#ifdef SQUASHFS_TRACE
 608         long long obytes = bytes;
 609 +#endif
 610
 611         for(i = 0; i < meta_blocks; i++) {
 612                 int avail_bytes = length > SQUASHFS_METADATA_SIZE ?
 613 @@ -2170,11 +2116,85 @@
 614  }
 615
 616
 617 +static int seq = 0;
 618 +void reader_read_process(struct dir_ent *dir_ent)
 619 +{
 620 +       struct file_buffer *prev_buffer = NULL, *file_buffer;
 621 +       int status, res, byte, count = 0;
 622 +       int file = get_pseudo_file(dir_ent->inode->pseudo_id)->fd;
 623 +       int child = get_pseudo_file(dir_ent->inode->pseudo_id)->child;
 624 +       long long bytes = 0;
 625 +
 626 +       while(1) {
 627 +               file_buffer = cache_get(reader_buffer, 0, 0);
 628 +               file_buffer->sequence = seq ++;
 629 +
 630 +               byte = read_bytes(file, file_buffer->data, block_size);
 631 +               if(byte == -1)
 632 +                       goto read_err;
 633 +
 634 +               file_buffer->size = byte;
 635 +               file_buffer->file_size = -1;
 636 +               file_buffer->block = count ++;
 637 +               file_buffer->error = FALSE;
 638 +               file_buffer->fragment = FALSE;
 639 +               bytes += byte;
 640 +
 641 +               if(byte == 0)
 642 +                       break;
 643 +
 644 +               /*
 645 +                * Update estimated_uncompressed block count.  This is done
 646 +                * on every block rather than waiting for all blocks to be
 647 +                * read incase write_file_process() is running in parallel
 648 +                * with this.  Otherwise cur uncompressed block count may
 649 +                * get ahead of the total uncompressed block count.
 650 +                */
 651 +               estimated_uncompressed ++;
 652 +
 653 +               if(prev_buffer)
 654 +                       queue_put(from_reader, prev_buffer);
 655 +               prev_buffer = file_buffer;
 656 +       }
 657 +
 658 +       /*
 659 +        * Update inode file size now that the size of the dynamic pseudo file
 660 +        * is known.  This is needed for the -info option.
 661 +        */
 662 +       dir_ent->inode->buf.st_size = bytes;
 663 +
 664 +       res = waitpid(child, &status, 0);
 665 +       if(res == -1 || !WIFEXITED(status) || WEXITSTATUS(status) != 0)
 666 +               goto read_err;
 667 +
 668 +       if(prev_buffer == NULL)
 669 +               prev_buffer = file_buffer;
 670 +       else {
 671 +               cache_block_put(file_buffer);
 672 +               seq --;
 673 +       }
 674 +       prev_buffer->file_size = bytes;
 675 +       prev_buffer->fragment = !no_fragments &&
 676 +               (count == 2 || always_use_fragments) && (byte < block_size);
 677 +       queue_put(from_reader, prev_buffer);
 678 +
 679 +       return;
 680 +
 681 +read_err:
 682 +       if(prev_buffer) {
 683 +               cache_block_put(file_buffer);
 684 +               seq --;
 685 +               file_buffer = prev_buffer;
 686 +       }
 687 +       file_buffer->error = TRUE;
 688 +       queue_put(from_deflate, file_buffer);
 689 +}
 690 +
 691 +
 692  void reader_read_file(struct dir_ent *dir_ent)
 693  {
 694         struct stat *buf = &dir_ent->inode->buf, buf2;
 695         struct file_buffer *file_buffer;
 696 -       static int index = 0;
 697         int blocks, byte, count, expected, file, frag_block;
 698         long long bytes, read_size;
 699
 700 @@ -2202,7 +2222,7 @@
 701                 if(file_buffer)
 702                         queue_put(from_reader, file_buffer);
 703                 file_buffer = cache_get(reader_buffer, 0, 0);
 704 -               file_buffer->sequence = index ++;
 705 +               file_buffer->sequence = seq ++;
 706
 707                 byte = file_buffer->size = read_bytes(file, file_buffer->data,
 708                         block_size);
 709 @@ -2238,7 +2258,7 @@
 710
 711  read_err:
 712         file_buffer = cache_get(reader_buffer, 0, 0);
 713 -       file_buffer->sequence = index ++;
 714 +       file_buffer->sequence = seq ++;
 715  read_err2:
 716         file_buffer->error = TRUE;
 717         queue_put(from_deflate, file_buffer);
 718 @@ -2262,9 +2282,14 @@
 719         for(i = 0; i < dir->count; i++) {
 720                 struct dir_ent *dir_ent = dir->list[i];
 721                 struct stat *buf = &dir_ent->inode->buf;
 722 -               if(dir_ent->data)
 723 +               if(dir_ent->inode->root_entry)
 724                         continue;
 725
 726 +               if(dir_ent->inode->pseudo_file) {
 727 +                       reader_read_process(dir_ent);
 728 +                       continue;
 729 +               }
 730 +
 731                 switch(buf->st_mode & S_IFMT) {
 732                         case S_IFREG:
 733                                 reader_read_file(dir_ent);
 734 @@ -2365,7 +2390,7 @@
 735
 736  void *deflator(void *arg)
 737  {
 738 -       z_stream *stream = NULL;
 739 +       void *stream = NULL;
 740         int oldstate;
 741
 742         pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate);
 743 @@ -2402,7 +2427,7 @@
 744
 745  void *frag_deflator(void *arg)
 746  {
 747 -       z_stream *stream = NULL;
 748 +       void *stream = NULL;
 749         int oldstate;
 750
 751         pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate);
 752 @@ -2426,8 +2451,8 @@
 753                         write_buffer->block = bytes;
 754                         bytes += compressed_size;
 755                         fragments_outstanding --;
 756 -                       pthread_mutex_unlock(&fragment_mutex);
 757                         queue_put(to_writer, write_buffer);
 758 +                       pthread_mutex_unlock(&fragment_mutex);
 759                         TRACE("Writing fragment %lld, uncompressed size %d, "
 760                                 "compressed size %d\n", file_buffer->block,
 761                                 file_buffer->size, compressed_size);
 762 @@ -2674,6 +2699,98 @@
 763  }
 764
 765
 766 +int write_file_process(squashfs_inode *inode, struct dir_ent *dir_ent,
 767 +       struct file_buffer *read_buffer, int *duplicate_file)
 768 +{
 769 +       long long read_size, file_bytes, start;
 770 +       struct fragment *fragment;
 771 +       unsigned int *block_list = NULL;
 772 +       int block = 0, status;
 773 +       long long sparse = 0;
 774 +       struct file_buffer *fragment_buffer = NULL;
 775 +
 776 +       *duplicate_file = FALSE;
 777 +
 778 +       lock_fragments();
 779 +
 780 +       file_bytes = 0;
 781 +       start = bytes;
 782 +       while (1) {
 783 +               read_size = read_buffer->file_size;
 784 +               if(read_buffer->fragment && read_buffer->c_byte)
 785 +                       fragment_buffer = read_buffer;
 786 +               else {
 787 +                       block_list = realloc(block_list, (block + 1) *
 788 +                               sizeof(unsigned int));
 789 +                       if(block_list == NULL)
 790 +                               BAD_ERROR("Out of memory allocating block_list"
 791 +                                       "\n");
 792 +                       block_list[block ++] = read_buffer->c_byte;
 793 +                       if(read_buffer->c_byte) {
 794 +                               read_buffer->block = bytes;
 795 +                               bytes += read_buffer->size;
 796 +                               cache_rehash(read_buffer, read_buffer->block);
 797 +                               file_bytes += read_buffer->size;
 798 +                               queue_put(to_writer, read_buffer);
 799 +                       } else {
 800 +                               sparse += read_buffer->size;
 801 +                               cache_block_put(read_buffer);
 802 +                       }
 803 +               }
 804 +               inc_progress_bar();
 805 +
 806 +               if(read_size != -1)
 807 +                       break;
 808 +
 809 +               read_buffer = get_file_buffer(from_deflate);
 810 +               if(read_buffer->error)
 811 +                       goto read_err;
 812 +       }
 813 +
 814 +       unlock_fragments();
 815 +       fragment = get_and_fill_fragment(fragment_buffer);
 816 +       cache_block_put(fragment_buffer);
 817 +
 818 +       if(duplicate_checking)
 819 +               add_non_dup(read_size, file_bytes, block_list, start, fragment,
 820 +                       0, 0, FALSE);
 821 +       file_count ++;
 822 +       total_bytes += read_size;
 823 +
 824 +       if(read_size < (1LL << 32) && start < (1LL << 32) && sparse == 0)
 825 +               create_inode(inode, dir_ent, SQUASHFS_FILE_TYPE, read_size,
 826 +                       start, block, block_list, fragment, NULL, 0);
 827 +       else
 828 +               create_inode(inode, dir_ent, SQUASHFS_LREG_TYPE, read_size,
 829 +                       start, block, block_list, fragment, NULL, sparse);
 830 +
 831 +       if(duplicate_checking == FALSE)
 832 +               free(block_list);
 833 +
 834 +       return 0;
 835 +
 836 +read_err:
 837 +       cur_uncompressed -= block;
 838 +       status = read_buffer->error;
 839 +       bytes = start;
 840 +       if(!block_device) {
 841 +               int res;
 842 +
 843 +               queue_put(to_writer, NULL);
 844 +               if(queue_get(from_writer) != 0)
 845 +                       EXIT_MKSQUASHFS();
 846 +               res = ftruncate(fd, bytes);
 847 +               if(res != 0)
 848 +                       BAD_ERROR("Failed to truncate dest file because %s\n",
 849 +                               strerror(errno));
 850 +       }
 851 +       unlock_fragments();
 852 +       free(block_list);
 853 +       cache_block_put(read_buffer);
 854 +       return status;
 855 +}
 856 +
 857 +
 858  int write_file_blocks(squashfs_inode *inode, struct dir_ent *dir_ent,
 859         long long read_size, struct file_buffer *read_buffer,
 860         int *duplicate_file)
 861 @@ -2941,7 +3058,10 @@
 862
 863         read_size = read_buffer->file_size;
 864
 865 -       if(read_size == 0) {
 866 +       if(read_size == -1)
 867 +               status = write_file_process(inode, dir_ent, read_buffer,
 868 +                       duplicate_file);
 869 +       else if(read_size == 0) {
 870                 write_file_empty(inode, dir_ent, duplicate_file);
 871                 cache_block_put(read_buffer);
 872         } else if(read_buffer->fragment && read_buffer->c_byte)
 873 @@ -3036,6 +3156,8 @@
 874
 875         memcpy(&inode->buf, buf, sizeof(struct stat));
 876         inode->read = FALSE;
 877 +       inode->root_entry = FALSE;
 878 +       inode->pseudo_file = FALSE;
 879         inode->inode = SQUASHFS_INVALID_BLK;
 880         inode->nlink = 1;
 881
 882 @@ -3056,7 +3178,7 @@
 883
 884
 885  inline void add_dir_entry(char *name, char *pathname, struct dir_info *sub_dir,
 886 -       struct inode_info *inode_info, void *data, struct dir_info *dir)
 887 +       struct inode_info *inode_info, struct dir_info *dir)
 888  {
 889         if((dir->count % DIR_ENTRIES) == 0) {
 890                 dir->list = realloc(dir->list, (dir->count + DIR_ENTRIES) *
 891 @@ -3075,8 +3197,7 @@
 892                 NULL;
 893         dir->list[dir->count]->inode = inode_info;
 894         dir->list[dir->count]->dir = sub_dir;
 895 -       dir->list[dir->count]->our_dir = dir;
 896 -       dir->list[dir->count++]->data = data;
 897 +       dir->list[dir->count++]->our_dir = dir;
 898         dir->byte_count += strlen(name) + sizeof(squashfs_dir_entry);
 899  }
 900
 901 @@ -3128,10 +3249,10 @@
 902
 903         if(dir->count < old_root_entries)
 904                 for(i = 0; i < old_root_entries; i++) {
 905 -                       if(old_root_entry[i].type == SQUASHFS_DIR_TYPE)
 906 +                       if(old_root_entry[i].inode.type == SQUASHFS_DIR_TYPE)
 907                                 dir->directory_count ++;
 908 -                       add_dir_entry(old_root_entry[i].name, "", NULL, NULL,
 909 -                               &old_root_entry[i], dir);
 910 +                       add_dir_entry(old_root_entry[i].name, "", NULL,
 911 +                               &old_root_entry[i].inode, dir);
 912                 }
 913
 914         while(index < source) {
 915 @@ -3167,10 +3288,10 @@
 916
 917         if(dir->count < old_root_entries)
 918                 for(i = 0; i < old_root_entries; i++) {
 919 -                       if(old_root_entry[i].type == SQUASHFS_DIR_TYPE)
 920 +                       if(old_root_entry[i].inode.type == SQUASHFS_DIR_TYPE)
 921                                 dir->directory_count ++;
 922 -                       add_dir_entry(old_root_entry[i].name, "", NULL, NULL,
 923 -                               &old_root_entry[i], dir);
 924 +                       add_dir_entry(old_root_entry[i].name, "", NULL,
 925 +                               &old_root_entry[i].inode, dir);
 926                 }
 927
 928         if((d_name = readdir(dir->linuxdir)) != NULL) {
 929 @@ -3215,7 +3336,7 @@
 930         int current_count;
 931
 932         while((current_count = dir_info->current_count++) < dir_info->count)
 933 -               if(dir_info->list[current_count]->data)
 934 +               if(dir_info->list[current_count]->inode->root_entry)
 935                         continue;
 936                 else
 937                         return dir_info->list[current_count];
 938 @@ -3240,11 +3361,11 @@
 939         int current_count;
 940
 941         while((current_count = dir_info->current_count++) < dir_info->count)
 942 -               if(dir_info->list[current_count]->data)
 943 -                       add_dir(dir_info->list[current_count]->data->inode,
 944 -                               dir_info->list[current_count]->data->inode_number,
 945 +               if(dir_info->list[current_count]->inode->root_entry)
 946 +                       add_dir(dir_info->list[current_count]->inode->inode,
 947 +                               dir_info->list[current_count]->inode->inode_number,
 948                                 dir_info->list[current_count]->name,
 949 -                               dir_info->list[current_count]->data->type, dir);
 950 +                               dir_info->list[current_count]->inode->type, dir);
 951                 else
 952                         return dir_info->list[current_count];
 953         return NULL;
 954 @@ -3313,7 +3434,6 @@
 955         dir_ent->name = dir_ent->pathname = strdup(pathname);
 956         dir_ent->dir = dir_info;
 957         dir_ent->our_dir = NULL;
 958 -       dir_ent->data = NULL;
 959         dir_info->dir_ent = dir_ent;
 960
 961         if(sorted)
 962 @@ -3383,7 +3503,7 @@
 963                         sub_dir = NULL;
 964
 965                 add_dir_entry(dir_name, filename, sub_dir, lookup_inode(&buf),
 966 -                       NULL, dir);
 967 +                       dir);
 968         }
 969
 970         scan1_freedir(dir);
 971 @@ -3399,7 +3519,7 @@
 972         struct dir_ent *dir_ent;
 973         struct pseudo_entry *pseudo_ent;
 974         struct stat buf;
 975 -       static pseudo_ino = 1;
 976 +       static int pseudo_ino = 1;
 977
 978         if(dir == NULL && (dir = scan1_opendir("")) == NULL)
 979                 return NULL;
 980 @@ -3415,6 +3535,29 @@
 981
 982         while((pseudo_ent = pseudo_readdir(pseudo)) != NULL) {
 983                 dir_ent = scan2_lookup(dir, pseudo_ent->name);
 984 +               if(pseudo_ent->dev->type == 's') {
 985 +                       struct stat *buf;
 986 +                       if(dir_ent == NULL) {
 987 +                               ERROR("Pseudo set file \"%s\" does not exist "
 988 +                                       "in source filesystem.  Ignoring\n",
 989 +                                       pseudo_ent->pathname);
 990 +                               continue;
 991 +                       }
 992 +                       if(dir_ent->inode->root_entry) {
 993 +                               ERROR("Pseudo set file \"%s\" is a pre-existing"
 994 +                                       " file in the filesystem being appended"
 995 +                                       "  to.  It cannot be modified. "
 996 +                                       "Ignoring!\n", pseudo_ent->pathname);
 997 +                               continue;
 998 +                       }
 999 +                       buf = &dir_ent->inode->buf;
1000 +                       buf->st_mode = (buf->st_mode & S_IFMT) |
1001 +                               pseudo_ent->dev->mode;
1002 +                       buf->st_uid = pseudo_ent->dev->uid;
1003 +                       buf->st_gid = pseudo_ent->dev->gid;
1004 +                       continue;
1005 +               }
1006 +
1007                 if(dir_ent) {
1008                         ERROR("Pseudo file \"%s\" exists in source filesystem "
1009                                 "\"%s\"\n", pseudo_ent->pathname,
1010 @@ -3444,8 +3587,29 @@
1011                 buf.st_mtime = time(NULL);
1012                 buf.st_ino = pseudo_ino ++;
1013
1014 -               add_dir_entry(pseudo_ent->name, pseudo_ent->pathname, sub_dir,
1015 -                       lookup_inode(&buf), NULL, dir);
1016 +               if(pseudo_ent->dev->type == 'f') {
1017 +#ifdef USE_TMP_FILE
1018 +                       struct stat buf2;
1019 +                       int res = stat(pseudo_ent->dev->filename, &buf2);
1020 +                       if(res == -1) {
1021 +                               ERROR("Stat on pseudo file \"%s\" failed, "
1022 +                                       "skipping...", pseudo_ent->pathname);
1023 +                               continue;
1024 +                       }
1025 +                       buf.st_size = buf2.st_size;
1026 +                       add_dir_entry(pseudo_ent->name,
1027 +                               pseudo_ent->dev->filename, sub_dir,
1028 +                               lookup_inode(&buf), dir);
1029 +#else
1030 +                       struct inode_info *inode = lookup_inode(&buf);
1031 +                       inode->pseudo_id = pseudo_ent->dev->pseudo_id;
1032 +                       inode->pseudo_file = TRUE;
1033 +                       add_dir_entry(pseudo_ent->name, pseudo_ent->pathname,
1034 +                               sub_dir, inode, dir);
1035 +#endif
1036 +               } else
1037 +                       add_dir_entry(pseudo_ent->name, pseudo_ent->pathname,
1038 +                               sub_dir, lookup_inode(&buf), dir);
1039         }
1040
1041         scan2_freedir(dir);
1042 @@ -3482,8 +3646,9 @@
1043                                                 &duplicate_file);
1044                                         INFO("file %s, uncompressed size %lld "
1045                                                 "bytes %s\n", filename,
1046 -                                               buf->st_size, duplicate_file ?
1047 -                                               "DUPLICATE" : "");
1048 +                                               (long long) buf->st_size,
1049 +                                               duplicate_file ?  "DUPLICATE" :
1050 +                                                "");
1051                                         break;
1052
1053                                 case S_IFDIR:
1054 @@ -3557,6 +3722,7 @@
1055                                                 INFO("file %s, uncompressed "
1056                                                         "size %lld bytes LINK"
1057                                                         "\n", filename,
1058 +                                                       (long long)
1059                                                         buf->st_size);
1060                                         break;
1061                                 case SQUASHFS_SYMLINK_TYPE:
1062 @@ -3667,10 +3833,11 @@
1063                 BAD_ERROR("Out of memory in old root directory entries "
1064                         "reallocation\n");
1065
1066 -       strcpy(old_root_entry[old_root_entries].name, name);
1067 -       old_root_entry[old_root_entries].inode = inode;
1068 -       old_root_entry[old_root_entries].inode_number = inode_number;
1069 -       old_root_entry[old_root_entries++].type = type;
1070 +       old_root_entry[old_root_entries].name = strdup(name);
1071 +       old_root_entry[old_root_entries].inode.inode = inode;
1072 +       old_root_entry[old_root_entries].inode.inode_number = inode_number;
1073 +       old_root_entry[old_root_entries].inode.type = type;
1074 +       old_root_entry[old_root_entries++].inode.root_entry = TRUE;
1075  }
1076
1077
1078 @@ -4137,7 +4304,7 @@
1079
1080
1081  #define VERSION() \
1082 -       printf("mksquashfs version 4.0 (2009/04/05)\n");\
1083 +       printf("mksquashfs version 4.1-CVS (2009/09/20)\n");\
1084         printf("copyright (C) 2009 Phillip Lougher <phillip@lougher.demon.co.uk>\n\n"); \
1085         printf("This program is free software; you can redistribute it and/or\n");\
1086         printf("modify it under the terms of the GNU General Public License\n");\
1087 @@ -4172,26 +4339,28 @@
1088         source_path = argv + 1;
1089         source = i - 2;
1090         for(; i < argc; i++) {
1091 -               if(strcmp(argv[i], "-pf") == 0) {
1092 +               if(strcmp(argv[i], "-comp") == 0) {
1093                         if(++i == argc) {
1094 -                               ERROR("%s: -pf missing filename\n", argv[0]);
1095 +                               ERROR("%s: -comp missing compression type\n",
1096 +                                       argv[0]);
1097                                 exit(1);
1098                         }
1099 -                       if(read_pseudo_file(&pseudo, argv[i]) == FALSE) {
1100 -                               ERROR("Failed to parse pseudo file \"%s\"\n",
1101 -                                       argv[i]);
1102 +                       comp_name = argv[i];
1103 +               } else if(strcmp(argv[i], "-pf") == 0) {
1104 +                       if(++i == argc) {
1105 +                               ERROR("%s: -pf missing filename\n", argv[0]);
1106                                 exit(1);
1107                         }
1108 +                       if(read_pseudo_file(&pseudo, argv[i]) == FALSE)
1109 +                               exit(1);
1110                 } else if(strcmp(argv[i], "-p") == 0) {
1111                         if(++i == argc) {
1112                                 ERROR("%s: -p missing pseudo file definition\n",
1113                                         argv[0]);
1114                                 exit(1);
1115                         }
1116 -                       if(read_pseudo_def(&pseudo, argv[i]) == FALSE) {
1117 -                               ERROR("Failed to parse pseudo definition\n");
1118 +                       if(read_pseudo_def(&pseudo, argv[i]) == FALSE)
1119                                 exit(1);
1120 -                       }
1121                 } else if(strcmp(argv[i], "-recover") == 0) {
1122                         if(++i == argc) {
1123                                 ERROR("%s: -recover missing recovery file\n",
1124 @@ -4394,34 +4563,16 @@
1125  printOptions:
1126                         ERROR("SYNTAX:%s source1 source2 ...  dest [options] "
1127                                 "[-e list of exclude\ndirs/files]\n", argv[0]);
1128 -                       ERROR("\nOptions are\n");
1129 -                       ERROR("-version\t\tprint version, licence and "
1130 -                               "copyright message\n");
1131 -                       ERROR("-recover <name>\t\trecover filesystem data "
1132 -                               "using recovery file <name>\n");
1133 -                       ERROR("-no-recovery\t\tdon't generate a recovery "
1134 -                               "file\n");
1135 -                       ERROR("-info\t\t\tprint files written to filesystem\n");
1136 -                       ERROR("-no-exports\t\tdon't make the filesystem "
1137 -                               "exportable via NFS\n");
1138 -                       ERROR("-no-progress\t\tdon't display the progress "
1139 -                               "bar\n");
1140 -                       ERROR("-no-sparse\t\tdon't detect sparse files\n");
1141 +                       ERROR("\nFilesystem build options:\n");
1142 +                       ERROR("-comp <comp>\t\tselect <comp> compression\n");
1143 +                       ERROR("\t\t\tCompressors available:\n");
1144 +                       display_compressors("\t\t\t", COMP_DEFAULT);
1145                         ERROR("-b <block_size>\t\tset data block to "
1146                                 "<block_size>.  Default %d bytes\n",
1147                                 SQUASHFS_FILE_SIZE);
1148 -                       ERROR("-processors <number>\tUse <number> processors."
1149 -                               "  By default will use number of\n");
1150 -                       ERROR("\t\t\tprocessors available\n");
1151 -                       ERROR("-read-queue <size>\tSet input queue to <size> "
1152 -                               "Mbytes.  Default %d Mbytes\n",
1153 -                               READER_BUFFER_DEFAULT);
1154 -                       ERROR("-write-queue <size>\tSet output queue to <size> "
1155 -                               "Mbytes.  Default %d Mbytes\n",
1156 -                               WRITER_BUFFER_DEFAULT);
1157 -                       ERROR("-fragment-queue <size>\tSet fagment queue to "
1158 -                               "<size> Mbytes.  Default %d Mbytes\n",
1159 -                               FRAGMENT_BUFFER_DEFAULT);
1160 +                       ERROR("-no-exports\t\tdon't make the filesystem "
1161 +                               "exportable via NFS\n");
1162 +                       ERROR("-no-sparse\t\tdon't detect sparse files\n");
1163                         ERROR("-noI\t\t\tdo not compress inode table\n");
1164                         ERROR("-noD\t\t\tdo not compress data blocks\n");
1165                         ERROR("-noF\t\t\tdo not compress fragment blocks\n");
1166 @@ -4430,13 +4581,34 @@
1167                                 "files larger than block size\n");
1168                         ERROR("-no-duplicates\t\tdo not perform duplicate "
1169                                 "checking\n");
1170 -                       ERROR("-noappend\t\tdo not append to existing "
1171 -                               "filesystem\n");
1172 +                       ERROR("-all-root\t\tmake all files owned by root\n");
1173 +                       ERROR("-force-uid uid\t\tset all file uids to uid\n");
1174 +                       ERROR("-force-gid gid\t\tset all file gids to gid\n");
1175 +                       ERROR("-nopad\t\t\tdo not pad filesystem to a multiple "
1176 +                               "of 4K\n");
1177                         ERROR("-keep-as-directory\tif one source directory is "
1178                                 "specified, create a root\n");
1179                         ERROR("\t\t\tdirectory containing that directory, "
1180                                 "rather than the\n");
1181                         ERROR("\t\t\tcontents of the directory\n");
1182 +                       ERROR("\nFilesystem filter options:\n");
1183 +                       ERROR("-p <pseudo-definition>\tAdd pseudo file definition\n");
1184 +                       ERROR("-pf <pseudo-file>\tAdd list of pseudo file definitions\n");
1185 +                       ERROR("-sort <sort_file>\tsort files according to "
1186 +                               "priorities in <sort_file>.  One\n");
1187 +                       ERROR("\t\t\tfile or dir with priority per line.  "
1188 +                               "Priority -32768 to\n");
1189 +                       ERROR("\t\t\t32767, default priority 0\n");
1190 +                       ERROR("-ef <exclude_file>\tlist of exclude dirs/files."
1191 +                               "  One per line\n");
1192 +                       ERROR("-wildcards\t\tAllow extended shell wildcards "
1193 +                               "(globbing) to be used in\n\t\t\texclude "
1194 +                               "dirs/files\n");
1195 +                       ERROR("-regex\t\t\tAllow POSIX regular expressions to "
1196 +                               "be used in exclude\n\t\t\tdirs/files\n");
1197 +                       ERROR("\nFilesystem append options:\n");
1198 +                       ERROR("-noappend\t\tdo not append to existing "
1199 +                               "filesystem\n");
1200                         ERROR("-root-becomes <name>\twhen appending source "
1201                                 "files/directories, make the\n");
1202                         ERROR("\t\t\toriginal root become a subdirectory in "
1203 @@ -4444,11 +4616,29 @@
1204                         ERROR("\t\t\tcalled <name>, rather than adding the new "
1205                                 "source items\n");
1206                         ERROR("\t\t\tto the original root\n");
1207 -                       ERROR("-all-root\t\tmake all files owned by root\n");
1208 -                       ERROR("-force-uid uid\t\tset all file uids to uid\n");
1209 -                       ERROR("-force-gid gid\t\tset all file gids to gid\n");
1210 -                       ERROR("-nopad\t\t\tdo not pad filesystem to a multiple "
1211 -                               "of 4K\n");
1212 +                       ERROR("\nMksquashfs runtime options:\n");
1213 +                       ERROR("-version\t\tprint version, licence and "
1214 +                               "copyright message\n");
1215 +                       ERROR("-recover <name>\t\trecover filesystem data "
1216 +                               "using recovery file <name>\n");
1217 +                       ERROR("-no-recovery\t\tdon't generate a recovery "
1218 +                               "file\n");
1219 +                       ERROR("-info\t\t\tprint files written to filesystem\n");
1220 +                       ERROR("-no-progress\t\tdon't display the progress "
1221 +                               "bar\n");
1222 +                       ERROR("-processors <number>\tUse <number> processors."
1223 +                               "  By default will use number of\n");
1224 +                       ERROR("\t\t\tprocessors available\n");
1225 +                       ERROR("-read-queue <size>\tSet input queue to <size> "
1226 +                               "Mbytes.  Default %d Mbytes\n",
1227 +                               READER_BUFFER_DEFAULT);
1228 +                       ERROR("-write-queue <size>\tSet output queue to <size> "
1229 +                               "Mbytes.  Default %d Mbytes\n",
1230 +                               WRITER_BUFFER_DEFAULT);
1231 +                       ERROR("-fragment-queue <size>\tSet fagment queue to "
1232 +                               "<size> Mbytes.  Default %d Mbytes\n",
1233 +                               FRAGMENT_BUFFER_DEFAULT);
1234 +                       ERROR("\nMiscellaneous options:\n");
1235                         ERROR("-root-owned\t\talternative name for -all-root"
1236                                 "\n");
1237                         ERROR("-noInodeCompression\talternative name for -noI"
1238 @@ -4457,20 +4647,6 @@
1239                                 "\n");
1240                         ERROR("-noFragmentCompression\talternative name for "
1241                                 "-noF\n");
1242 -                       ERROR("-sort <sort_file>\tsort files according to "
1243 -                               "priorities in <sort_file>.  One\n");
1244 -                       ERROR("\t\t\tfile or dir with priority per line.  "
1245 -                               "Priority -32768 to\n");
1246 -                       ERROR("\t\t\t32767, default priority 0\n");
1247 -                       ERROR("-ef <exclude_file>\tlist of exclude dirs/files."
1248 -                               "  One per line\n");
1249 -                       ERROR("-wildcards\t\tAllow extended shell wildcards "
1250 -                               "(globbing) to be used in\n\t\t\texclude "
1251 -                               "dirs/files\n");
1252 -                       ERROR("-regex\t\t\tAllow POSIX regular expressions to "
1253 -                               "be used in exclude\n\t\t\tdirs/files\n");
1254 -                       ERROR("-p <pseudo-definition>\tAdd pseudo file definition\n");
1255 -                       ERROR("-pf <pseudo-file>\tAdd list of pseudo file definitions\n");
1256                         exit(1);
1257                 }
1258         }
1259 @@ -4548,11 +4724,10 @@
1260                         fclose(fd);
1261                 } else if(strcmp(argv[i], "-e") == 0)
1262                         break;
1263 -               else if(strcmp(argv[i], "-b") == 0 ||
1264 -                               strcmp(argv[i], "-root-becomes") == 0 ||
1265 +               else if(strcmp(argv[i], "-root-becomes") == 0 ||
1266                                 strcmp(argv[i], "-sort") == 0 ||
1267                                 strcmp(argv[i], "-pf") == 0 ||
1268 -                               strcmp(argv[i], "-p") == 0)
1269 +                               strcmp(argv[i], "-comp") == 0)
1270                         i++;
1271
1272         if(i != argc) {
1273 @@ -4574,11 +4749,10 @@
1274                         sorted ++;
1275                 } else if(strcmp(argv[i], "-e") == 0)
1276                         break;
1277 -               else if(strcmp(argv[i], "-b") == 0 ||
1278 -                               strcmp(argv[i], "-root-becomes") == 0 ||
1279 +               else if(strcmp(argv[i], "-root-becomes") == 0 ||
1280                                 strcmp(argv[i], "-ef") == 0 ||
1281                                 strcmp(argv[i], "-pf") == 0 ||
1282 -                               strcmp(argv[i], "-p") == 0)
1283 +                               strcmp(argv[i], "-comp") == 0)
1284                         i++;
1285
1286  #ifdef SQUASHFS_TRACE
1287 @@ -4586,7 +4760,8 @@
1288  #endif
1289
1290         if(!delete) {
1291 -               if(read_super(fd, &sBlk, argv[source + 1]) == 0) {
1292 +               comp = read_super(fd, &sBlk, argv[source + 1]);
1293 +               if(comp == NULL) {
1294                         ERROR("Failed to read existing filesystem - will not "
1295                                 "overwrite - ABORTING!\n");
1296                         ERROR("To force Mksquashfs to write to this block "
1297 @@ -4603,6 +4778,15 @@
1298                 always_use_fragments = SQUASHFS_ALWAYS_FRAGMENTS(sBlk.flags);
1299                 duplicate_checking = SQUASHFS_DUPLICATES(sBlk.flags);
1300                 exportable = SQUASHFS_EXPORTABLE(sBlk.flags);
1301 +       } else {
1302 +               comp = lookup_compressor(comp_name);
1303 +               if(!comp->supported) {
1304 +                       ERROR("FATAL_ERROR: Compressor \"%s\" is not "
1305 +                               "supported!\n", comp_name);
1306 +                       ERROR("Compressors available:\n");
1307 +                       display_compressors("", COMP_DEFAULT);
1308 +                       EXIT_MKSQUASHFS();
1309 +               }
1310         }
1311
1312         initialise_threads();
1313 @@ -4648,8 +4832,8 @@
1314                         "size %d\n", SQUASHFS_MAJOR, s_minor, argv[source + 1],
1315                         block_size);
1316                 printf("All -b, -noI, -noD, -noF, no-duplicates, no-fragments, "
1317 -                       "-always-use-fragments and -exportable options ignored"
1318 -                       "\n");
1319 +                       "-always-use-fragments,\n-exportable and -comp options "
1320 +                       "ignored\n");
1321                 printf("\nIf appending is not wanted, please re-run with "
1322                         "-noappend specified!\n\n");
1323
1324 @@ -4803,8 +4987,7 @@
1325
1326         sBlk.bytes_used = bytes;
1327
1328 -       /* Only compression supported */
1329 -       sBlk.compression = ZLIB_COMPRESSION;
1330 +       sBlk.compression = comp->id;
1331
1332         /* Xattrs are not currently supported */
1333         sBlk.xattr_table_start = SQUASHFS_INVALID_BLK;
1334 @@ -4820,6 +5003,8 @@
1335
1336         close(fd);
1337
1338 +       delete_pseudo_files();
1339 +
1340         if(recovery_file[0] != '\0')
1341                 unlink(recovery_file);
1342
1343 @@ -4827,9 +5012,9 @@
1344                 * sizeof(unsigned short) + guid_count * sizeof(unsigned short) +
1345                 sizeof(squashfs_super_block);
1346
1347 -       printf("\n%sSquashfs %d.%d filesystem, data block size %d\n",
1348 -               exportable ? "Exportable " : "", SQUASHFS_MAJOR, SQUASHFS_MINOR,
1349 -               block_size);
1350 +       printf("\n%sSquashfs %d.%d filesystem, %s compressed, data block size"
1351 +               " %d\n", exportable ? "Exportable " : "", SQUASHFS_MAJOR,
1352 +               SQUASHFS_MINOR, comp->name, block_size);
1353         printf("\t%s data, %s metadata, %s fragments\n",
1354                 noD ? "uncompressed" : "compressed", noI ?  "uncompressed" :
1355                 "compressed", no_fragments ? "no" : noF ? "uncompressed" :
1356 diff -Nur squashfs4.0/squashfs-tools/pseudo.c squashfs4.0-lzma-snapshot/squashfs-tools/pseudo.c
1357 --- squashfs4.0/squashfs-tools/pseudo.c 2009-04-05 04:01:58.000000000 +0200
1358 +++ squashfs4.0-lzma-snapshot/squashfs-tools/pseudo.c   2009-10-20 06:03:38.000000000 +0200
1359 @@ -30,6 +30,7 @@
1360  #include <string.h>
1361  #include <stdlib.h>
1362  #include <sys/types.h>
1363 +#include <sys/wait.h>
1364
1365  #include "pseudo.h"
1366
1367 @@ -55,6 +56,9 @@
1368  #define TRUE 1
1369  #define FALSE 0
1370
1371 +struct pseudo_dev **pseudo_file = NULL;
1372 +int pseudo_count = 0;
1373 +
1374  static void dump_pseudo(struct pseudo *pseudo, char *string)
1375  {
1376         int i;
1377 @@ -99,7 +103,7 @@
1378         char *target, char *alltarget)
1379  {
1380         char targname[1024];
1381 -       int i, error;
1382 +       int i;
1383
1384         target = get_component(target, targname);
1385
1386 @@ -128,12 +132,8 @@
1387                 if(target[0] == '\0') {
1388                         /* at leaf pathname component */
1389                         pseudo->name[i].pseudo = NULL;
1390 -                       pseudo->name[i].dev = malloc(sizeof(struct pseudo_dev));
1391 -                       if(pseudo->name[i].dev == NULL)
1392 -                               BAD_ERROR("failed to allocate pseudo file\n");
1393                         pseudo->name[i].pathname = strdup(alltarget);
1394 -                       memcpy(pseudo->name[i].dev, pseudo_dev,
1395 -                               sizeof(struct pseudo_dev));
1396 +                       pseudo->name[i].dev = pseudo_dev;
1397                 } else {
1398                         /* recurse adding child components */
1399                         pseudo->name[i].dev = NULL;
1400 @@ -169,15 +169,9 @@
1401                         if(target[0] == '\0') {
1402                                 if(pseudo->name[i].dev == NULL &&
1403                                                 pseudo_dev->type == 'd') {
1404 -                                       pseudo->name[i].dev =
1405 -                                               malloc(sizeof(struct pseudo_dev));
1406 -                                       if(pseudo->name[i].dev == NULL)
1407 -                                               BAD_ERROR("failed to allocate "
1408 -                                                       "pseudo file\n");
1409                                         pseudo->name[i].pathname =
1410                                                 strdup(alltarget);
1411 -                                       memcpy(pseudo->name[i].dev, pseudo_dev,
1412 -                                               sizeof(struct pseudo_dev));
1413 +                                       pseudo->name[i].dev = pseudo_dev;
1414                                 } else
1415                                         ERROR("%s already exists as a "
1416                                                 "directory.  Ignoring %s!\n",
1417 @@ -229,16 +223,113 @@
1418  }
1419
1420
1421 +int exec_file(char *command, struct pseudo_dev *dev)
1422 +{
1423 +       int child, res;
1424 +       static pid_t pid = -1;
1425 +       int pipefd[2];
1426 +#ifdef USE_TMP_FILE
1427 +       char filename[1024];
1428 +       int status;
1429 +       static int number = 0;
1430 +#endif
1431 +
1432 +       if(pid == -1)
1433 +               pid = getpid();
1434 +
1435 +#ifdef USE_TMP_FILE
1436 +       sprintf(filename, "/tmp/squashfs_pseudo_%d_%d", pid, number ++);
1437 +       pipefd[1] = open(filename, O_CREAT | O_TRUNC | O_RDWR, S_IRWXU);
1438 +       if(pipefd[1] == -1) {
1439 +               printf("open failed\n");
1440 +               return -1;
1441 +       }
1442 +#else
1443 +       res = pipe(pipefd);
1444 +       if(res == -1) {
1445 +               printf("pipe failed\n");
1446 +               return -1;
1447 +       }
1448 +#endif
1449 +
1450 +       child = fork();
1451 +       if(child == -1) {
1452 +               printf("fork failed\n");
1453 +               goto failed;
1454 +       }
1455 +
1456 +       if(child == 0) {
1457 +               close(STDOUT_FILENO);
1458 +               res = dup(pipefd[1]);
1459 +               if(res == -1) {
1460 +                       printf("dup failed\n");
1461 +                       exit(EXIT_FAILURE);
1462 +               }
1463 +               execl("/bin/sh", "sh", "-c", command, (char *) NULL);
1464 +               printf("execl failed\n");
1465 +               exit(EXIT_FAILURE);
1466 +       }
1467 +
1468 +#ifdef USE_TMP_FILE
1469 +       res = waitpid(child, &status, 0);
1470 +       close(pipefd[1]);
1471 +       if(res != -1 && WIFEXITED(status) && WEXITSTATUS(status) == 0) {
1472 +               dev->filename = strdup(filename);
1473 +               return 0;
1474 +       }
1475 +failed:
1476 +       unlink(filename);
1477 +       return -1;
1478 +#else
1479 +       close(pipefd[1]);
1480 +       dev->fd = pipefd[0];
1481 +       dev->child = child;
1482 +       return 0;
1483 +failed:
1484 +       return -1;
1485 +#endif
1486 +}
1487 +
1488 +
1489 +void add_pseudo_file(struct pseudo_dev *dev)
1490 +{
1491 +       pseudo_file = realloc(pseudo_file, (pseudo_count + 1) *
1492 +               sizeof(struct pseudo_dev *));
1493 +       if(pseudo_file == NULL)
1494 +               BAD_ERROR("Failed to realloc pseudo_file\n");
1495 +
1496 +       dev->pseudo_id = pseudo_count;
1497 +       pseudo_file[pseudo_count ++] = dev;
1498 +}
1499 +
1500 +
1501 +void delete_pseudo_files()
1502 +{
1503 +#ifdef USE_TMP_FILE
1504 +       int i;
1505 +
1506 +       for(i = 0; i < pseudo_count; i++)
1507 +               unlink(pseudo_file[i]->filename);
1508 +#endif
1509 +}
1510 +
1511 +
1512 +struct pseudo_dev *get_pseudo_file(int pseudo_id)
1513 +{
1514 +       return pseudo_file[pseudo_id];
1515 +}
1516 +
1517 +
1518  int read_pseudo_def(struct pseudo **pseudo, char *def)
1519  {
1520 -       int n;
1521 +       int n, bytes;
1522         unsigned int major = 0, minor = 0, mode;
1523         char filename[2048], type, suid[100], sgid[100], *ptr;
1524         long long uid, gid;
1525 -       struct pseudo_dev dev;
1526 +       struct pseudo_dev *dev;
1527
1528 -       n = sscanf(def, "%s %c %o %s %s %u %u", filename, &type, &mode, suid, sgid,
1529 -                       &major, &minor);
1530 +       n = sscanf(def, "%s %c %o %s %s %n", filename, &type, &mode, suid,
1531 +                       sgid, &bytes);
1532
1533         if(n < 5) {
1534                 ERROR("Not enough or invalid arguments in pseudo file "
1535 @@ -249,7 +340,9 @@
1536         switch(type) {
1537         case 'b':
1538         case 'c':
1539 -               if(n < 7) {
1540 +               n = sscanf(def + bytes,  "%u %u", &major, &minor);
1541 +
1542 +               if(n < 2) {
1543                         ERROR("Not enough or invalid arguments in pseudo file "
1544                                 "definition\n");
1545                         goto error;
1546 @@ -265,47 +358,15 @@
1547                         goto error;
1548                 }
1549
1550 -               /* fall through */
1551 -       case 'd':
1552 -               if(mode > 0777) {
1553 -                       ERROR("Mode %o out of range\n", mode);
1554 +       case 'f':
1555 +               if(def[bytes] == '\0') {
1556 +                       ERROR("Not enough arguments in pseudo file "
1557 +                               "definition\n");
1558                         goto error;
1559 -               }
1560 -
1561 -               uid = strtoll(suid, &ptr, 10);
1562 -               if(*ptr == '\0') {
1563 -                       if(uid < 0 || uid > ((1LL << 32) - 1)) {
1564 -                               ERROR("Uid %s out of range\n", suid);
1565 -                               goto error;
1566 -                       }
1567 -               } else {
1568 -                       struct passwd *pwuid = getpwnam(suid);
1569 -                       if(pwuid)
1570 -                               uid = pwuid->pw_uid;
1571 -                       else {
1572 -                               ERROR("Uid %s invalid uid or unknown user\n",
1573 -                                       suid);
1574 -                               goto error;
1575 -                       }
1576 -               }
1577 -
1578 -               gid = strtoll(sgid, &ptr, 10);
1579 -               if(*ptr == '\0') {
1580 -                       if(gid < 0 || gid > ((1LL << 32) - 1)) {
1581 -                               ERROR("Gid %s out of range\n", sgid);
1582 -                               goto error;
1583 -                       }
1584 -               } else {
1585 -                       struct group *grgid = getgrnam(sgid);
1586 -                       if(grgid)
1587 -                               gid = grgid->gr_gid;
1588 -                       else {
1589 -                               ERROR("Gid %s invalid uid or unknown user\n",
1590 -                                       sgid);
1591 -                               goto error;
1592 -                       }
1593 -               }
1594 -
1595 +               }
1596 +               break;
1597 +       case 'd':
1598 +       case 'm':
1599                 break;
1600         default:
1601                 ERROR("Unsupported type %c\n", type);
1602 @@ -313,6 +374,43 @@
1603         }
1604
1605
1606 +       if(mode > 0777) {
1607 +               ERROR("Mode %o out of range\n", mode);
1608 +               goto error;
1609 +       }
1610 +
1611 +       uid = strtoll(suid, &ptr, 10);
1612 +       if(*ptr == '\0') {
1613 +               if(uid < 0 || uid > ((1LL << 32) - 1)) {
1614 +                       ERROR("Uid %s out of range\n", suid);
1615 +                       goto error;
1616 +               }
1617 +       } else {
1618 +               struct passwd *pwuid = getpwnam(suid);
1619 +               if(pwuid)
1620 +                       uid = pwuid->pw_uid;
1621 +               else {
1622 +                       ERROR("Uid %s invalid uid or unknown user\n", suid);
1623 +                       goto error;
1624 +               }
1625 +       }
1626 +
1627 +       gid = strtoll(sgid, &ptr, 10);
1628 +       if(*ptr == '\0') {
1629 +               if(gid < 0 || gid > ((1LL << 32) - 1)) {
1630 +                       ERROR("Gid %s out of range\n", sgid);
1631 +                       goto error;
1632 +               }
1633 +       } else {
1634 +               struct group *grgid = getgrnam(sgid);
1635 +               if(grgid)
1636 +                       gid = grgid->gr_gid;
1637 +               else {
1638 +                       ERROR("Gid %s invalid uid or unknown user\n", sgid);
1639 +                       goto error;
1640 +               }
1641 +       }
1642 +
1643         switch(type) {
1644         case 'b':
1645                 mode |= S_IFBLK;
1646 @@ -323,16 +421,37 @@
1647         case 'd':
1648                 mode |= S_IFDIR;
1649                 break;
1650 +       case 'f':
1651 +               mode |= S_IFREG;
1652 +               break;
1653         }
1654
1655 -       dev.type = type;
1656 -       dev.mode = mode;
1657 -       dev.uid = uid;
1658 -       dev.gid = gid;
1659 -       dev.major = major;
1660 -       dev.minor = minor;
1661 +       dev = malloc(sizeof(struct pseudo_dev));
1662 +       if(dev == NULL)
1663 +               BAD_ERROR("Failed to create pseudo_dev\n");
1664 +
1665 +       dev->type = type;
1666 +       dev->mode = mode;
1667 +       dev->uid = uid;
1668 +       dev->gid = gid;
1669 +       dev->major = major;
1670 +       dev->minor = minor;
1671 +
1672 +       if(type == 'f') {
1673 +               int res;
1674 +
1675 +               printf("Executing dynamic pseudo file\n");
1676 +               printf("\t\"%s\"\n", def);
1677 +               res = exec_file(def + bytes, dev);
1678 +               if(res == -1) {
1679 +                       ERROR("Failed to execute dynamic pseudo file definition"
1680 +                               " \"%s\"\n", def);
1681 +                       return FALSE;
1682 +               }
1683 +               add_pseudo_file(dev);
1684 +       }
1685
1686 -       *pseudo = add_pseudo(*pseudo, &dev, filename, filename);
1687 +       *pseudo = add_pseudo(*pseudo, dev, filename, filename);
1688
1689         return TRUE;
1690
1691 diff -Nur squashfs4.0/squashfs-tools/pseudo.h squashfs4.0-lzma-snapshot/squashfs-tools/pseudo.h
1692 --- squashfs4.0/squashfs-tools/pseudo.h 2009-04-04 03:44:24.000000000 +0200
1693 +++ squashfs4.0-lzma-snapshot/squashfs-tools/pseudo.h   2009-10-20 06:03:38.000000000 +0200
1694 @@ -27,6 +27,12 @@
1695         unsigned int    gid;
1696         unsigned int    major;
1697         unsigned int    minor;
1698 +       int             pseudo_id;
1699 +       int             fd;
1700 +       int             child;
1701 +#ifdef USE_TMP_FILE
1702 +       char            *filename;
1703 +#endif
1704  };
1705
1706  struct pseudo_entry {
1707 @@ -46,3 +52,5 @@
1708  extern int read_pseudo_file(struct pseudo **, char *);
1709  extern struct pseudo *pseudo_subdir(char *, struct pseudo *);
1710  extern struct pseudo_entry *pseudo_readdir(struct pseudo *);
1711 +extern struct pseudo_dev *get_pseudo_file(int);
1712 +extern void delete_pseudo_files();
1713 diff -Nur squashfs4.0/squashfs-tools/read_fs.c squashfs4.0-lzma-snapshot/squashfs-tools/read_fs.c
1714 --- squashfs4.0/squashfs-tools/read_fs.c        2009-03-31 06:23:14.000000000 +0200
1715 +++ squashfs4.0-lzma-snapshot/squashfs-tools/read_fs.c  2009-10-20 06:03:38.000000000 +0200
1716 @@ -36,7 +36,6 @@
1717  #include <fcntl.h>
1718  #include <errno.h>
1719  #include <string.h>
1720 -#include <zlib.h>
1721  #include <sys/mman.h>
1722
1723  #ifndef linux
1724 @@ -51,6 +50,7 @@
1725  #include "squashfs_swap.h"
1726  #include "read_fs.h"
1727  #include "global.h"
1728 +#include "compressor.h"
1729
1730  #include <stdlib.h>
1731
1732 @@ -66,7 +66,9 @@
1733                                                 fprintf(stderr, s, ## args); \
1734                                         } while(0)
1735
1736 -int read_block(int fd, long long start, long long *next, unsigned char *block,
1737 +static struct compressor *comp;
1738 +
1739 +int read_block(int fd, long long start, long long *next, void *block,
1740         squashfs_super_block *sBlk)
1741  {
1742         unsigned short c_byte;
1743 @@ -77,32 +79,24 @@
1744
1745         if(SQUASHFS_COMPRESSED(c_byte)) {
1746                 char buffer[SQUASHFS_METADATA_SIZE];
1747 -               int res;
1748 -               unsigned long bytes = SQUASHFS_METADATA_SIZE;
1749 +               int error, res;
1750
1751                 c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);
1752                 read_destination(fd, start + offset, c_byte, buffer);
1753
1754 -               res = uncompress(block, &bytes, (const unsigned char *) buffer,
1755 -                       c_byte);
1756 -               if(res != Z_OK) {
1757 -                       if(res == Z_MEM_ERROR)
1758 -                               ERROR("zlib::uncompress failed, not enough "
1759 -                                       "memory\n");
1760 -                       else if(res == Z_BUF_ERROR)
1761 -                               ERROR("zlib::uncompress failed, not enough "
1762 -                                       "room in output buffer\n");
1763 -                       else
1764 -                               ERROR("zlib::uncompress failed, unknown error "
1765 -                                       "%d\n", res);
1766 +               res = comp->uncompress(block, buffer, c_byte,
1767 +                       SQUASHFS_METADATA_SIZE, &error);
1768 +               if(res == -1) {
1769 +                       ERROR("%s uncompress failed with error code %d\n",
1770 +                               comp->name, error);
1771                         return 0;
1772                 }
1773                 if(next)
1774                         *next = start + offset + c_byte;
1775 -               return bytes;
1776 +               return res;
1777         } else {
1778                 c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);
1779 -               read_destination(fd, start + offset, c_byte, (char *) block);
1780 +               read_destination(fd, start + offset, c_byte, block);
1781                 if(next)
1782                         *next = start + offset + c_byte;
1783                 return c_byte;
1784 @@ -356,7 +350,7 @@
1785  }
1786
1787
1788 -int read_super(int fd, squashfs_super_block *sBlk, char *source)
1789 +struct compressor *read_super(int fd, squashfs_super_block *sBlk, char *source)
1790  {
1791         read_destination(fd, SQUASHFS_START, sizeof(squashfs_super_block),
1792                 (char *) sBlk);
1793 @@ -388,8 +382,18 @@
1794                 goto failed_mount;
1795         }
1796
1797 +       /* Check the compression type */
1798 +       comp = lookup_compressor_id(sBlk->compression);
1799 +       if(!comp->supported) {
1800 +               ERROR("Filesystem on %s uses %s compression, this is"
1801 +                       "unsupported by this version\n", source, comp->name);
1802 +               display_compressors("", "");
1803 +               goto failed_mount;
1804 +       }
1805 +
1806         printf("Found a valid %sSQUASHFS superblock on %s.\n",
1807                 SQUASHFS_EXPORTABLE(sBlk->flags) ? "exportable " : "", source);
1808 +       printf("\tCompression used %s\n", comp->name);
1809         printf("\tInodes are %scompressed\n",
1810                 SQUASHFS_UNCOMPRESSED_INODES(sBlk->flags) ? "un" : "");
1811         printf("\tData is %scompressed\n",
1812 @@ -417,10 +421,10 @@
1813         TRACE("sBlk->lookup_table_start %llx\n", sBlk->lookup_table_start);
1814         printf("\n");
1815
1816 -       return TRUE;
1817 +       return comp;
1818
1819  failed_mount:
1820 -       return FALSE;
1821 +       return NULL;
1822  }
1823
1824
1825 @@ -514,12 +518,17 @@
1826         SQUASHFS_INSWAP_ID_BLOCKS(index, indexes);
1827
1828         for(i = 0; i < indexes; i++) {
1829 -               int length;
1830 -               length = read_block(fd, index[i], NULL,
1831 +               int length = read_block(fd, index[i], NULL,
1832                         ((unsigned char *) id_table) +
1833                         (i * SQUASHFS_METADATA_SIZE), sBlk);
1834                 TRACE("Read id table block %d, from 0x%llx, length %d\n", i,
1835                         index[i], length);
1836 +               if(length == 0) {
1837 +                       ERROR("Failed to read id table block %d, from 0x%llx, "
1838 +                               "length %d\n", i, index[i], length);
1839 +                       free(id_table);
1840 +                       return NULL;
1841 +               }
1842         }
1843
1844         SQUASHFS_INSWAP_INTS(id_table, sBlk->no_ids);
1845 @@ -563,6 +572,13 @@
1846                         (i * SQUASHFS_METADATA_SIZE), sBlk);
1847                 TRACE("Read fragment table block %d, from 0x%llx, length %d\n",
1848                         i, fragment_table_index[i], length);
1849 +               if(length == 0) {
1850 +                       ERROR("Failed to read fragment table block %d, from "
1851 +                               "0x%llx, length %d\n", i,
1852 +                               fragment_table_index[i], length);
1853 +                       free(*fragment_table);
1854 +                       return 0;
1855 +               }
1856         }
1857
1858         for(i = 0; i < sBlk->fragments; i++)
1859 @@ -599,6 +615,13 @@
1860                         (i * SQUASHFS_METADATA_SIZE), sBlk);
1861                 TRACE("Read inode lookup table block %d, from 0x%llx, length "
1862                         "%d\n", i, index[i], length);
1863 +               if(length == 0) {
1864 +                       ERROR("Failed to read inode lookup table block %d, "
1865 +                               "from 0x%llx, length %d\n", i, index[i],
1866 +                               length);
1867 +                       free(*inode_lookup_table);
1868 +                       return 0;
1869 +               }
1870         }
1871
1872         SQUASHFS_INSWAP_LONG_LONGS(*inode_lookup_table, sBlk->inodes);
1873 diff -Nur squashfs4.0/squashfs-tools/sort.c squashfs4.0-lzma-snapshot/squashfs-tools/sort.c
1874 --- squashfs4.0/squashfs-tools/sort.c   2009-03-31 06:25:53.000000000 +0200
1875 +++ squashfs4.0-lzma-snapshot/squashfs-tools/sort.c     2009-10-20 06:03:38.000000000 +0200
1876 @@ -198,7 +198,7 @@
1877         while(dir->current_count < dir->count) {
1878                 struct dir_ent *dir_ent = dir->list[dir->current_count++];
1879                 struct stat *buf = &dir_ent->inode->buf;
1880 -               if(dir_ent->data)
1881 +               if(dir_ent->inode->root_entry)
1882                         continue;
1883
1884                 switch(buf->st_mode & S_IFMT) {
1885 @@ -254,6 +254,7 @@
1886                                 write_file(&inode, entry->dir, &duplicate_file);
1887                                 INFO("file %s, uncompressed size %lld bytes %s"
1888                                         "\n", entry->dir->pathname,
1889 +                                       (long long)
1890                                         entry->dir->inode->buf.st_size,
1891                                         duplicate_file ? "DUPLICATE" : "");
1892                                 entry->dir->inode->inode = inode;
1893 @@ -261,6 +262,7 @@
1894                         } else
1895                                 INFO("file %s, uncompressed size %lld bytes "
1896                                         "LINK\n", entry->dir->pathname,
1897 +                                       (long long)
1898                                         entry->dir->inode->buf.st_size);
1899                 }
1900  }
1901 diff -Nur squashfs4.0/squashfs-tools/sort.h squashfs4.0-lzma-snapshot/squashfs-tools/sort.h
1902 --- squashfs4.0/squashfs-tools/sort.h   2009-02-08 13:02:53.000000000 +0100
1903 +++ squashfs4.0-lzma-snapshot/squashfs-tools/sort.h     2009-10-20 06:03:38.000000000 +0200
1904 @@ -42,17 +42,19 @@
1905         struct inode_info       *inode;
1906         struct dir_info         *dir;
1907         struct dir_info         *our_dir;
1908 -       struct old_root_entry_info *data;
1909  };
1910
1911  struct inode_info {
1912 -       unsigned int            nlink;
1913         struct stat             buf;
1914 +       struct inode_info       *next;
1915         squashfs_inode          inode;
1916 -       unsigned int            type;
1917         unsigned int            inode_number;
1918 +       unsigned int            nlink;
1919 +       int                     pseudo_id;
1920 +       char                    type;
1921         char                    read;
1922 -       struct inode_info       *next;
1923 +       char                    root_entry;
1924 +       char                    pseudo_file;
1925  };
1926
1927  struct priority_entry {
1928 diff -Nur squashfs4.0/squashfs-tools/squashfs_compat.h squashfs4.0-lzma-snapshot/squashfs-tools/squashfs_compat.h
1929 --- squashfs4.0/squashfs-tools/squashfs_compat.h        2009-03-16 05:27:27.000000000 +0100
1930 +++ squashfs4.0-lzma-snapshot/squashfs-tools/squashfs_compat.h  2009-10-20 06:03:38.000000000 +0200
1931 @@ -777,11 +777,10 @@
1932  #endif
1933
1934  #define _SQUASHFS_SWAP(value, p, pos, tbits, SHIFT) {\
1935 -       int bits;\
1936 -       int b_pos = pos % 8;\
1937 -       unsigned long long val = 0;\
1938 -       unsigned char *s = (unsigned char *)p + (pos / 8);\
1939 -       unsigned char *d = ((unsigned char *) &val) + 7;\
1940 +       b_pos = pos % 8;\
1941 +       val = 0;\
1942 +       s = (unsigned char *)p + (pos / 8);\
1943 +       d = ((unsigned char *) &val) + 7;\
1944         for(bits = 0; bits < (tbits + b_pos); bits += 8) \
1945                 *d-- = *s++;\
1946         value = (val >> (SHIFT))/* & ((1 << tbits) - 1)*/;\
1947 diff -Nur squashfs4.0/squashfs-tools/squashfs_fs.h squashfs4.0-lzma-snapshot/squashfs-tools/squashfs_fs.h
1948 --- squashfs4.0/squashfs-tools/squashfs_fs.h    2009-03-18 03:50:20.000000000 +0100
1949 +++ squashfs4.0-lzma-snapshot/squashfs-tools/squashfs_fs.h      2009-10-20 06:03:38.000000000 +0200
1950 @@ -229,6 +229,7 @@
1951  typedef long long              squashfs_inode_t;
1952
1953  #define ZLIB_COMPRESSION       1
1954 +#define LZMA_COMPRESSION       2
1955
1956  struct squashfs_super_block {
1957         unsigned int            s_magic;
1958 diff -Nur squashfs4.0/squashfs-tools/unsquash-3.c squashfs4.0-lzma-snapshot/squashfs-tools/unsquash-3.c
1959 --- squashfs4.0/squashfs-tools/unsquash-3.c     2009-03-31 06:35:10.000000000 +0200
1960 +++ squashfs4.0-lzma-snapshot/squashfs-tools/unsquash-3.c       2009-10-20 06:03:38.000000000 +0200
1961 @@ -36,7 +36,7 @@
1962                 sBlk.fragment_table_start);
1963
1964         if(sBlk.fragments == 0)
1965 -               return;
1966 +               return TRUE;
1967
1968         if((fragment_table = malloc(sBlk.fragments *
1969                         sizeof(squashfs_fragment_entry_3))) == NULL)
1970 diff -Nur squashfs4.0/squashfs-tools/unsquash-4.c squashfs4.0-lzma-snapshot/squashfs-tools/unsquash-4.c
1971 --- squashfs4.0/squashfs-tools/unsquash-4.c     2009-03-31 06:38:31.000000000 +0200
1972 +++ squashfs4.0-lzma-snapshot/squashfs-tools/unsquash-4.c       2009-10-20 06:03:38.000000000 +0200
1973 @@ -38,7 +38,7 @@
1974                 sBlk.fragment_table_start);
1975
1976         if(sBlk.fragments == 0)
1977 -               return;
1978 +               return TRUE;
1979
1980         if((fragment_table = malloc(sBlk.fragments *
1981                         sizeof(squashfs_fragment_entry))) == NULL)
1982 diff -Nur squashfs4.0/squashfs-tools/unsquashfs.c squashfs4.0-lzma-snapshot/squashfs-tools/unsquashfs.c
1983 --- squashfs4.0/squashfs-tools/unsquashfs.c     2009-04-05 23:23:06.000000000 +0200
1984 +++ squashfs4.0-lzma-snapshot/squashfs-tools/unsquashfs.c       2009-10-20 06:03:39.000000000 +0200
1985 @@ -25,6 +25,7 @@
1986  #include "squashfs_swap.h"
1987  #include "squashfs_compat.h"
1988  #include "read_fs.h"
1989 +#include "compressor.h"
1990
1991  struct cache *fragment_cache, *data_cache;
1992  struct queue *to_reader, *to_deflate, *to_writer, *from_writer;
1993 @@ -36,6 +39,7 @@
1994
1995  struct super_block sBlk;
1996  squashfs_operations s_ops;
1997 +struct compressor *comp;
1998
1999  int bytes = 0, swap, file_count = 0, dir_count = 0, sym_count = 0,
2000         dev_count = 0, fifo_count = 0;
2001 @@ -590,31 +594,23 @@
2002                 offset = 3;
2003         if(SQUASHFS_COMPRESSED(c_byte)) {
2004                 char buffer[SQUASHFS_METADATA_SIZE];
2005 -               int res;
2006 -               unsigned long bytes = SQUASHFS_METADATA_SIZE;
2007 +               int error, res;
2008
2009                 c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);
2010                 if(read_bytes(start + offset, c_byte, buffer) == FALSE)
2011                         goto failed;
2012
2013 -               res = uncompress((unsigned char *) block, &bytes,
2014 -                       (const unsigned char *) buffer, c_byte);
2015 +               res = comp->uncompress(block, buffer, c_byte,
2016 +                       SQUASHFS_METADATA_SIZE, &error);
2017
2018 -               if(res != Z_OK) {
2019 -                       if(res == Z_MEM_ERROR)
2020 -                               ERROR("zlib::uncompress failed, not enough "
2021 -                                       "memory\n");
2022 -                       else if(res == Z_BUF_ERROR)
2023 -                               ERROR("zlib::uncompress failed, not enough "
2024 -                                       "room in output buffer\n");
2025 -                       else
2026 -                               ERROR("zlib::uncompress failed, unknown error "
2027 -                                       "%d\n", res);
2028 +               if(res == -1) {
2029 +                       ERROR("%s uncompress failed with error code %d\n",
2030 +                               comp->name, error);
2031                         goto failed;
2032                 }
2033                 if(next)
2034                         *next = start + offset + c_byte;
2035 -               return bytes;
2036 +               return res;
2037         } else {
2038                 c_byte = SQUASHFS_COMPRESSED_SIZE(c_byte);
2039                 if(read_bytes(start + offset, c_byte, block) == FALSE)
2040 @@ -632,36 +628,26 @@
2041
2042  int read_data_block(long long start, unsigned int size, char *block)
2043  {
2044 -       int res;
2045 -       unsigned long bytes = block_size;
2046 +       int error, res;
2047         int c_byte = SQUASHFS_COMPRESSED_SIZE_BLOCK(size);
2048
2049         TRACE("read_data_block: block @0x%llx, %d %s bytes\n", start,
2050 -               SQUASHFS_COMPRESSED_SIZE_BLOCK(c_byte),
2051 -               SQUASHFS_COMPRESSED_BLOCK(c_byte) ? "compressed" :
2052 +               c_byte, SQUASHFS_COMPRESSED_BLOCK(size) ? "compressed" :
2053                 "uncompressed");
2054
2055         if(SQUASHFS_COMPRESSED_BLOCK(size)) {
2056                 if(read_bytes(start, c_byte, data) == FALSE)
2057                         goto failed;
2058
2059 -               res = uncompress((unsigned char *) block, &bytes,
2060 -                       (const unsigned char *) data, c_byte);
2061 +               res = comp->uncompress(block, data, c_byte, block_size, &error);
2062
2063 -               if(res != Z_OK) {
2064 -                       if(res == Z_MEM_ERROR)
2065 -                               ERROR("zlib::uncompress failed, not enough "
2066 -                                       "memory\n");
2067 -                       else if(res == Z_BUF_ERROR)
2068 -                               ERROR("zlib::uncompress failed, not enough "
2069 -                                       "room in output buffer\n");
2070 -                       else
2071 -                               ERROR("zlib::uncompress failed, unknown error "
2072 -                                       "%d\n", res);
2073 +               if(res == -1) {
2074 +                       ERROR("%s uncompress failed with error code %d\n",
2075 +                               comp->name, error);
2076                         goto failed;
2077                 }
2078
2079 -               return bytes;
2080 +               return res;
2081         } else {
2082                 if(read_bytes(start, c_byte, block) == FALSE)
2083                         goto failed;
2084 @@ -671,7 +657,7 @@
2085
2086  failed:
2087         ERROR("read_data_block: failed to read block @0x%llx, size %d\n", start,
2088 -               size);
2089 +               c_byte);
2090         return FALSE;
2091  }
2092
2093 @@ -1383,6 +1369,11 @@
2094  #endif
2095         printf("Creation or last append time %s", mkfs_str ? mkfs_str :
2096                 "failed to get time\n");
2097 +       printf("Filesystem size %.2f Kbytes (%.2f Mbytes)\n",
2098 +               sBlk.bytes_used / 1024.0, sBlk.bytes_used / (1024.0 * 1024.0));
2099 +       if(sBlk.s_major == 4)
2100 +               printf("Compression %s\n", comp->name);
2101 +       printf("Block size %d\n", sBlk.block_size);
2102         printf("Filesystem is %sexportable via NFS\n",
2103                 SQUASHFS_EXPORTABLE(sBlk.flags) ? "" : "not ");
2104
2105 @@ -1409,9 +1400,6 @@
2106                         SQUASHFS_DUPLICATES(sBlk.flags) ? "" : "not ");
2107         else
2108                 printf("Duplicates are removed\n");
2109 -       printf("Filesystem size %.2f Kbytes (%.2f Mbytes)\n",
2110 -               sBlk.bytes_used / 1024.0, sBlk.bytes_used / (1024.0 * 1024.0));
2111 -       printf("Block size %d\n", sBlk.block_size);
2112         if(sBlk.s_major > 1)
2113                 printf("Number of fragments %d\n", sBlk.fragments);
2114         printf("Number of inodes %d\n", sBlk.inodes);
2115 @@ -1459,6 +1447,18 @@
2116                 s_ops.read_inode = read_inode_4;
2117                 s_ops.read_uids_guids = read_uids_guids_4;
2118                 memcpy(&sBlk, &sBlk_4, sizeof(sBlk_4));
2119 +
2120 +               /*
2121 +                * Check the compression type
2122 +                */
2123 +               comp = lookup_compressor_id(sBlk.compression);
2124 +               if(!comp->supported) {
2125 +                       ERROR("Filesystem uses %s compression, this is "
2126 +                               "unsupported by this version\n", comp->name);
2127 +                       ERROR("Decompressors available:\n");
2128 +                       display_compressors("", "");
2129 +                       goto failed_mount;
2130 +               }
2131                 return TRUE;
2132         }
2133
2134 @@ -1548,6 +1548,11 @@
2135                 goto failed_mount;
2136         }
2137
2138 +       /*
2139 +        * 1.x, 2.x and 3.x filesystems use gzip compression.  Gzip is always
2140 +        * suppported.
2141 +        */
2142 +       comp = lookup_compressor("gzip");
2143         return TRUE;
2144
2145  failed_mount:
2146 @@ -1707,32 +1712,24 @@
2147
2148         while(1) {
2149                 struct cache_entry *entry = queue_get(to_deflate);
2150 -               int res;
2151 -               unsigned long bytes = block_size;
2152 +               int error, res;
2153
2154 -               res = uncompress((unsigned char *) tmp, &bytes,
2155 -                       (const unsigned char *) entry->data,
2156 -                       SQUASHFS_COMPRESSED_SIZE_BLOCK(entry->size));
2157 -
2158 -               if(res != Z_OK) {
2159 -                       if(res == Z_MEM_ERROR)
2160 -                               ERROR("zlib::uncompress failed, not enough"
2161 -                                       "memory\n");
2162 -                       else if(res == Z_BUF_ERROR)
2163 -                               ERROR("zlib::uncompress failed, not enough "
2164 -                                       "room in output buffer\n");
2165 -                       else
2166 -                               ERROR("zlib::uncompress failed, unknown error "
2167 -                                       "%d\n", res);
2168 -               } else
2169 -                       memcpy(entry->data, tmp, bytes);
2170 +               res = comp->uncompress(tmp, entry->data,
2171 +                       SQUASHFS_COMPRESSED_SIZE_BLOCK(entry->size), block_size,
2172 +                       &error);
2173 +
2174 +               if(res == -1)
2175 +                       ERROR("%s uncompress failed with error code %d\n",
2176 +                               comp->name, error);
2177 +               else
2178 +                       memcpy(entry->data, tmp, res);
2179
2180                 /*
2181                  * block has been either successfully decompressed, or an error
2182                  * occurred, clear pending flag, set error appropriately and
2183                  * wake up any threads waiting on this block
2184                  */
2185 -               cache_block_ready(entry, res != Z_OK);
2186 +               cache_block_ready(entry, res == -1);
2187         }
2188  }
2189
2190 @@ -1913,7 +1910,7 @@
2191
2192
2193  #define VERSION() \
2194 -       printf("unsquashfs version 4.0 (2009/04/05)\n");\
2195 +       printf("unsquashfs version 4.1-CVS (2009/08/30)\n");\
2196         printf("copyright (C) 2009 Phillip Lougher <phillip@lougher.demon.co.uk>"\
2197                 "\n\n");\
2198         printf("This program is free software; you can redistribute it and/or\n");\
2199 @@ -1938,7 +1935,6 @@
2200         int fragment_buffer_size = FRAGMENT_BUFFER_DEFAULT;
2201         int data_buffer_size = DATA_BUFFER_DEFAULT;
2202         char *b;
2203 -       struct winsize winsize;
2204
2205         pthread_mutex_init(&screen_mutex, NULL);
2206         root_process = geteuid() == 0;
2207 @@ -2087,6 +2083,8 @@
2208                                 "regular expressions\n");
2209                         ERROR("\t\t\t\trather than use the default shell "
2210                                 "wildcard\n\t\t\t\texpansion (globbing)\n");
2211 +                       ERROR("\nDecompressors available:\n");
2212 +                       display_compressors("", "");
2213                 }
2214                 exit(1);
2215         }
2216 diff -Nur squashfs4.0/squashfs-tools/unsquashfs.h squashfs4.0-lzma-snapshot/squashfs-tools/unsquashfs.h
2217 --- squashfs4.0/squashfs-tools/unsquashfs.h     2009-03-29 04:29:02.000000000 +0200
2218 +++ squashfs4.0-lzma-snapshot/squashfs-tools/unsquashfs.h       2009-10-20 06:03:39.000000000 +0200
2219 @@ -31,7 +31,6 @@
2220  #include <fcntl.h>
2221  #include <errno.h>
2222  #include <string.h>
2223 -#include <zlib.h>
2224  #include <sys/mman.h>
2225  #include <utime.h>
2226  #include <pwd.h>