unlzx.c

/* $VER: unlzx.c 1.0 (22.2.98) */
/* Created: 11.2.98 */
/* Added Pipe support to read from stdin (03.4.01, Erik Meusel)           */

/* LZX Extract in (supposedly) portable C.                                */

/* Compile with:                                                          */
/* gcc unlzx.c -ounlzx -O6                                                */

/* Thanks to Dan Fraser for decoding the coredumps and helping me track   */
/* down some HIDEOUSLY ANNOYING bugs.                                     */

/* Everything is accessed as unsigned char's to try and avoid problems    */
/* with byte order and alignment. Most of the decrunch functions          */
/* encourage overruns in the buffers to make things as fast as possible.  */
/* All the time is taken up in crc_calc() and decrunch() so they are      */
/* pretty damn optimized. Don't try to understand this program.           */

/* ---------------------------------------------------------------------- */

#include <stdlib.h>
#include <stdio.h>

/* ---------------------------------------------------------------------- */

static const unsigned char VERSION[]="$VER: unlzx 1.1 (03.4.01)";

/* ---------------------------------------------------------------------- */

int mode;

unsigned char info_header[10];
unsigned char archive_header[31];
unsigned char header_filename[256];
unsigned char header_comment[256];

unsigned int pack_size;
unsigned int unpack_size;

unsigned int crc;
unsigned int year, month, day;
unsigned int hour, minute, second;
unsigned char attributes;
unsigned char pack_mode;

/* ---------------------------------------------------------------------- */

struct filename_node
{
 struct filename_node *next;
 unsigned int length;
 unsigned int crc;
 char filename[256];
};

struct filename_node *filename_list;

/* ---------------------------------------------------------------------- */

unsigned char read_buffer[16384]; /* have a reasonable sized read buffer */
unsigned char decrunch_buffer[258+65536+258]; /* allow overrun for speed */

unsigned char *source;
unsigned char *destination;
unsigned char *source_end;
unsigned char *destination_end;

unsigned int decrunch_method;
unsigned int decrunch_length;
unsigned int last_offset;
unsigned int global_control;
int global_shift;

unsigned char offset_len[8];
unsigned short offset_table[128];
unsigned char huffman20_len[20];
unsigned short huffman20_table[96];
unsigned char literal_len[768];
unsigned short literal_table[5120];

/* ---------------------------------------------------------------------- */

static const char *month_str[16]=
{
 "jan", "feb", "mar", "apr", "may", "jun", "jul", "aug",
 "sep", "oct", "nov", "dec", "?13", "?14", "?15", "?16"
};

/* ---------------------------------------------------------------------- */

unsigned int sum;

static const unsigned int crc_table[256]=
{
 0x00000000,0x77073096,0xEE0E612C,0x990951BA,0x076DC419,0x706AF48F,
 0xE963A535,0x9E6495A3,0x0EDB8832,0x79DCB8A4,0xE0D5E91E,0x97D2D988,
 0x09B64C2B,0x7EB17CBD,0xE7B82D07,0x90BF1D91,0x1DB71064,0x6AB020F2,
 0xF3B97148,0x84BE41DE,0x1ADAD47D,0x6DDDE4EB,0xF4D4B551,0x83D385C7,
 0x136C9856,0x646BA8C0,0xFD62F97A,0x8A65C9EC,0x14015C4F,0x63066CD9,
 0xFA0F3D63,0x8D080DF5,0x3B6E20C8,0x4C69105E,0xD56041E4,0xA2677172,
 0x3C03E4D1,0x4B04D447,0xD20D85FD,0xA50AB56B,0x35B5A8FA,0x42B2986C,
 0xDBBBC9D6,0xACBCF940,0x32D86CE3,0x45DF5C75,0xDCD60DCF,0xABD13D59,
 0x26D930AC,0x51DE003A,0xC8D75180,0xBFD06116,0x21B4F4B5,0x56B3C423,
 0xCFBA9599,0xB8BDA50F,0x2802B89E,0x5F058808,0xC60CD9B2,0xB10BE924,
 0x2F6F7C87,0x58684C11,0xC1611DAB,0xB6662D3D,0x76DC4190,0x01DB7106,
 0x98D220BC,0xEFD5102A,0x71B18589,0x06B6B51F,0x9FBFE4A5,0xE8B8D433,
 0x7807C9A2,0x0F00F934,0x9609A88E,0xE10E9818,0x7F6A0DBB,0x086D3D2D,
 0x91646C97,0xE6635C01,0x6B6B51F4,0x1C6C6162,0x856530D8,0xF262004E,
 0x6C0695ED,0x1B01A57B,0x8208F4C1,0xF50FC457,0x65B0D9C6,0x12B7E950,
 0x8BBEB8EA,0xFCB9887C,0x62DD1DDF,0x15DA2D49,0x8CD37CF3,0xFBD44C65,
 0x4DB26158,0x3AB551CE,0xA3BC0074,0xD4BB30E2,0x4ADFA541,0x3DD895D7,
 0xA4D1C46D,0xD3D6F4FB,0x4369E96A,0x346ED9FC,0xAD678846,0xDA60B8D0,
 0x44042D73,0x33031DE5,0xAA0A4C5F,0xDD0D7CC9,0x5005713C,0x270241AA,
 0xBE0B1010,0xC90C2086,0x5768B525,0x206F85B3,0xB966D409,0xCE61E49F,
 0x5EDEF90E,0x29D9C998,0xB0D09822,0xC7D7A8B4,0x59B33D17,0x2EB40D81,
 0xB7BD5C3B,0xC0BA6CAD,0xEDB88320,0x9ABFB3B6,0x03B6E20C,0x74B1D29A,
 0xEAD54739,0x9DD277AF,0x04DB2615,0x73DC1683,0xE3630B12,0x94643B84,
 0x0D6D6A3E,0x7A6A5AA8,0xE40ECF0B,0x9309FF9D,0x0A00AE27,0x7D079EB1,
 0xF00F9344,0x8708A3D2,0x1E01F268,0x6906C2FE,0xF762575D,0x806567CB,
 0x196C3671,0x6E6B06E7,0xFED41B76,0x89D32BE0,0x10DA7A5A,0x67DD4ACC,
 0xF9B9DF6F,0x8EBEEFF9,0x17B7BE43,0x60B08ED5,0xD6D6A3E8,0xA1D1937E,
 0x38D8C2C4,0x4FDFF252,0xD1BB67F1,0xA6BC5767,0x3FB506DD,0x48B2364B,
 0xD80D2BDA,0xAF0A1B4C,0x36034AF6,0x41047A60,0xDF60EFC3,0xA867DF55,
 0x316E8EEF,0x4669BE79,0xCB61B38C,0xBC66831A,0x256FD2A0,0x5268E236,
 0xCC0C7795,0xBB0B4703,0x220216B9,0x5505262F,0xC5BA3BBE,0xB2BD0B28,
 0x2BB45A92,0x5CB36A04,0xC2D7FFA7,0xB5D0CF31,0x2CD99E8B,0x5BDEAE1D,
 0x9B64C2B0,0xEC63F226,0x756AA39C,0x026D930A,0x9C0906A9,0xEB0E363F,
 0x72076785,0x05005713,0x95BF4A82,0xE2B87A14,0x7BB12BAE,0x0CB61B38,
 0x92D28E9B,0xE5D5BE0D,0x7CDCEFB7,0x0BDBDF21,0x86D3D2D4,0xF1D4E242,
 0x68DDB3F8,0x1FDA836E,0x81BE16CD,0xF6B9265B,0x6FB077E1,0x18B74777,
 0x88085AE6,0xFF0F6A70,0x66063BCA,0x11010B5C,0x8F659EFF,0xF862AE69,
 0x616BFFD3,0x166CCF45,0xA00AE278,0xD70DD2EE,0x4E048354,0x3903B3C2,
 0xA7672661,0xD06016F7,0x4969474D,0x3E6E77DB,0xAED16A4A,0xD9D65ADC,
 0x40DF0B66,0x37D83BF0,0xA9BCAE53,0xDEBB9EC5,0x47B2CF7F,0x30B5FFE9,
 0xBDBDF21C,0xCABAC28A,0x53B39330,0x24B4A3A6,0xBAD03605,0xCDD70693,
 0x54DE5729,0x23D967BF,0xB3667A2E,0xC4614AB8,0x5D681B02,0x2A6F2B94,
 0xB40BBE37,0xC30C8EA1,0x5A05DF1B,0x2D02EF8D
};

/* ---------------------------------------------------------------------- */

static const unsigned char table_one[32]=
{
 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,14,14
};

static const unsigned int table_two[32]=
{
 0,1,2,3,4,6,8,12,16,24,32,48,64,96,128,192,256,384,512,768,1024,
 1536,2048,3072,4096,6144,8192,12288,16384,24576,32768,49152
};

static const unsigned int table_three[16]=
{
 0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767
};

static const unsigned char table_four[34]=
{
 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,
 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16
};

/* ---------------------------------------------------------------------- */

/* Possible problems with 64 bit machines here. It kept giving warnings   */
/* for people so I changed back to ~.                                     */

void crc_calc(unsigned char *memory, unsigned int length)
{
 register unsigned int temp;

 if(length)
 {
  temp = ~sum; /* was (sum ^ 4294967295) */
  do
  {
   temp = crc_table[(*memory++ ^ temp) & 255] ^ (temp >> 8);
  } while(--length);
  sum = ~temp; /* was (temp ^ 4294967295) */
 }
}

/* ---------------------------------------------------------------------- */

/* Build a fast huffman decode table from the symbol bit lengths.         */
/* There is an alternate algorithm which is faster but also more complex. */

int make_decode_table(int number_symbols, int table_size,
                      unsigned char *length, unsigned short *table)
{
 register unsigned char bit_num = 0;
 register int symbol;
 unsigned int leaf; /* could be a register */
 unsigned int table_mask, bit_mask, pos, fill, next_symbol, reverse;
 int abort = 0;

 pos = 0; /* consistantly used as the current position in the decode table */

 bit_mask = table_mask = 1 << table_size;

 bit_mask >>= 1; /* don't do the first number */
 bit_num++;

 while((!abort) && (bit_num <= table_size))
 {
  for(symbol = 0; symbol < number_symbols; symbol++)
  {
   if(length[symbol] == bit_num)
   {
    reverse = pos; /* reverse the order of the position's bits */
    leaf = 0;
    fill = table_size;
    do /* reverse the position */
    {
     leaf = (leaf << 1) + (reverse & 1);
     reverse >>= 1;
    } while(--fill);
    if((pos += bit_mask) > table_mask)
    {
     abort = 1;
     break; /* we will overrun the table! abort! */
    }
    fill = bit_mask;
    next_symbol = 1 << bit_num;
    do
    {
     table[leaf] = symbol;
     leaf += next_symbol;
    } while(--fill);
   }
  }
  bit_mask >>= 1;
  bit_num++;
 }

 if((!abort) && (pos != table_mask))
 {
  for(symbol = pos; symbol < table_mask; symbol++) /* clear the rest of the table */
  {
   reverse = symbol; /* reverse the order of the position's bits */
   leaf = 0;
   fill = table_size;
   do /* reverse the position */
   {
    leaf = (leaf << 1) + (reverse & 1);
    reverse >>= 1;
   } while(--fill);
   table[leaf] = 0;
  }
  next_symbol = table_mask >> 1;
  pos <<= 16;
  table_mask <<= 16;
  bit_mask = 32768;

  while((!abort) && (bit_num <= 16))
  {
   for(symbol = 0; symbol < number_symbols; symbol++)
   {
    if(length[symbol] == bit_num)
    {
     reverse = pos >> 16; /* reverse the order of the position's bits */
     leaf = 0;
     fill = table_size;
     do /* reverse the position */
     {
      leaf = (leaf << 1) + (reverse & 1);
      reverse >>= 1;
     } while(--fill);
     for(fill = 0; fill < bit_num - table_size; fill++)
     {
      if(table[leaf] == 0)
      {
       table[(next_symbol << 1)] = 0;
       table[(next_symbol << 1) + 1] = 0;
       table[leaf] = next_symbol++;
      }
      leaf = table[leaf] << 1;
      leaf += (pos >> (15 - fill)) & 1;
     }
     table[leaf] = symbol;
     if((pos += bit_mask) > table_mask)
     {
      abort = 1;
      break; /* we will overrun the table! abort! */
     }
    }
   }
   bit_mask >>= 1;
   bit_num++;
  }
 }
 if(pos != table_mask) abort = 1; /* the table is incomplete! */

 return(abort);
}

/* ---------------------------------------------------------------------- */

/* Read and build the decrunch tables. There better be enough data in the */
/* source buffer or it's stuffed. */

int read_literal_table()
{
 register unsigned int control;
 register int shift;
 unsigned int temp; /* could be a register */
 unsigned int symbol, pos, count, fix, max_symbol;
 int abort = 0;

 control = global_control;
 shift = global_shift;

 if(shift < 0) /* fix the control word if necessary */
 {
  shift += 16;
  control += *source++ << (8 + shift);
  control += *source++ << shift;
 }

/* read the decrunch method */

 decrunch_method = control & 7;
 control >>= 3;
 if((shift -= 3) < 0)
 {
  shift += 16;
  control += *source++ << (8 + shift);
  control += *source++ << shift;
 }

/* Read and build the offset huffman table */

 if((!abort) && (decrunch_method == 3))
 {
  for(temp = 0; temp < 8; temp++)
  {
   offset_len[temp] = control & 7;
   control >>= 3;
   if((shift -= 3) < 0)
   {
    shift += 16;
    control += *source++ << (8 + shift);
    control += *source++ << shift;
   }
  }
  abort = make_decode_table(8, 7, offset_len, offset_table);
 }

/* read decrunch length */

 if(!abort)
 {
  decrunch_length = (control & 255) << 16;
  control >>= 8;
  if((shift -= 8) < 0)
  {
   shift += 16;
   control += *source++ << (8 + shift);
   control += *source++ << shift;
  }
  decrunch_length += (control & 255) << 8;
  control >>= 8;
  if((shift -= 8) < 0)
  {
   shift += 16;
   control += *source++ << (8 + shift);
   control += *source++ << shift;
  }
  decrunch_length += (control & 255);
  control >>= 8;
  if((shift -= 8) < 0)
  {
   shift += 16;
   control += *source++ << (8 + shift);
   control += *source++ << shift;
  }
 }

/* read and build the huffman literal table */

 if((!abort) && (decrunch_method != 1))
 {
  pos = 0;
  fix = 1;
  max_symbol = 256;

  do
  {
   for(temp = 0; temp < 20; temp++)
   {
    huffman20_len[temp] = control & 15;
    control >>= 4;
    if((shift -= 4) < 0)
    {
     shift += 16;
     control += *source++ << (8 + shift);
     control += *source++ << shift;
    }
   }
   abort = make_decode_table(20, 6, huffman20_len, huffman20_table);

   if(abort) break; /* argh! table is corrupt! */

   do
   {
    if((symbol = huffman20_table[control & 63]) >= 20)
    {
     do /* symbol is longer than 6 bits */
     {
      symbol = huffman20_table[((control >> 6) & 1) + (symbol << 1)];
      if(!shift--)
      {
       shift += 16;
       control += *source++ << 24;
       control += *source++ << 16;
      }
      control >>= 1;
     } while(symbol >= 20);
     temp = 6;
    }
    else
    {
     temp = huffman20_len[symbol];
    }
    control >>= temp;
    if((shift -= temp) < 0)
    {
     shift += 16;
     control += *source++ << (8 + shift);
     control += *source++ << shift;
    }
    switch(symbol)
    {
     case 17:
     case 18:
     {
      if(symbol == 17)
      {
       temp = 4;
       count = 3;
      }
      else /* symbol == 18 */
      {
       temp = 6 - fix;
       count = 19;
      }
      count += (control & table_three[temp]) + fix;
      control >>= temp;
      if((shift -= temp) < 0)
      {
       shift += 16;
       control += *source++ << (8 + shift);
       control += *source++ << shift;
      }
      while((pos < max_symbol) && (count--))
       literal_len[pos++] = 0;
      break;
     }
     case 19:
     {
      count = (control & 1) + 3 + fix;
      if(!shift--)
      {
       shift += 16;
       control += *source++ << 24;
       control += *source++ << 16;
      }
      control >>= 1;
      if((symbol = huffman20_table[control & 63]) >= 20)
      {
       do /* symbol is longer than 6 bits */
       {
        symbol = huffman20_table[((control >> 6) & 1) + (symbol << 1)];
        if(!shift--)
        {
         shift += 16;
         control += *source++ << 24;
         control += *source++ << 16;
        }
        control >>= 1;
       } while(symbol >= 20);
       temp = 6;
      }
      else
      {
       temp = huffman20_len[symbol];
      }
      control >>= temp;
      if((shift -= temp) < 0)
      {
       shift += 16;
       control += *source++ << (8 + shift);
       control += *source++ << shift;
      }
      symbol = table_four[literal_len[pos] + 17 - symbol];
      while((pos < max_symbol) && (count--))
       literal_len[pos++] = symbol;
      break;
     }
     default:
     {
      symbol = table_four[literal_len[pos] + 17 - symbol];
      literal_len[pos++] = symbol;
      break;
     }
    }
   } while(pos < max_symbol);
   fix--;
   max_symbol += 512;
  } while(max_symbol == 768);

  if(!abort)
   abort = make_decode_table(768, 12, literal_len, literal_table);
 }

 global_control = control;
 global_shift = shift;

 return(abort);
}

/* ---------------------------------------------------------------------- */

/* Fill up the decrunch buffer. Needs lots of overrun for both destination */
/* and source buffers. Most of the time is spent in this routine so it's  */
/* pretty damn optimized. */

void decrunch()
{
 register unsigned int control;
 register int shift;
 unsigned int temp; /* could be a register */
 unsigned int symbol, count;
 unsigned char *string;

 control = global_control;
 shift = global_shift;

 do
 {
  if((symbol = literal_table[control & 4095]) >= 768)
  {
   control >>= 12;
   if((shift -= 12) < 0)
   {
    shift += 16;
    control += *source++ << (8 + shift);
    control += *source++ << shift;
   }
   do /* literal is longer than 12 bits */
   {
    symbol = literal_table[(control & 1) + (symbol << 1)];
    if(!shift--)
    {
     shift += 16;
     control += *source++ << 24;
     control += *source++ << 16;
    }
    control >>= 1;
   } while(symbol >= 768);
  }
  else
  {
   temp = literal_len[symbol];
   control >>= temp;
   if((shift -= temp) < 0)
   {
    shift += 16;
    control += *source++ << (8 + shift);
    control += *source++ << shift;
   }
  }
  if(symbol < 256)
  {
   *destination++ = symbol;
  }
  else
  {
   symbol -= 256;
   count = table_two[temp = symbol & 31];
   temp = table_one[temp];
   if((temp >= 3) && (decrunch_method == 3))
   {
    temp -= 3;
    count += ((control & table_three[temp]) << 3);
    control >>= temp;
    if((shift -= temp) < 0)
    {
     shift += 16;
     control += *source++ << (8 + shift);
     control += *source++ << shift;
    }
    count += (temp = offset_table[control & 127]);
    temp = offset_len[temp];
   }
   else
   {
    count += control & table_three[temp];
    if(!count) count = last_offset;
   }
   control >>= temp;
   if((shift -= temp) < 0)
   {
    shift += 16;
    control += *source++ << (8 + shift);
    control += *source++ << shift;
   }
   last_offset = count;

   count = table_two[temp = (symbol >> 5) & 15] + 3;
   temp = table_one[temp];
   count += (control & table_three[temp]);
   control >>= temp;
   if((shift -= temp) < 0)
   {
    shift += 16;
    control += *source++ << (8 + shift);
    control += *source++ << shift;
   }
   string = (decrunch_buffer + last_offset < destination) ?
            destination - last_offset : destination + 65536 - last_offset;
   do
   {
    *destination++ = *string++;
   } while(--count);
  }
 } while((destination < destination_end) && (source < source_end));

 global_control = control;
 global_shift = shift;
}

/* ---------------------------------------------------------------------- */

/* Opens a file for writing & creates the full path if required. */

FILE *open_output(char *filename)
{
 unsigned int temp;
 FILE *file;

 if(!(file = fopen(filename, "wb")))
 {
/* couldn't open the file. try and create directories */
  for(temp = 0; filename[temp]; temp++)
  {
   if(filename[temp] == '/')
   {
    filename[temp] = 0;
    mkdir(filename, 511); /* I don't care if it works or not */
    filename[temp] = '/';
   }
  }
  if(!(file = fopen(filename, "wb")))
  {
   perror("FOpen");
  }
 }
 return(file);
}

/* ---------------------------------------------------------------------- */

/* Trying to understand this function is hazardous. */

int extract_normal(FILE *in_file)
{
 struct filename_node *node;
 FILE *out_file = 0;
 unsigned char *pos;
 unsigned char *temp;
 unsigned int count;
 int abort = 0;

 global_control = 0; /* initial control word */
 global_shift = -16;
 last_offset = 1;
 unpack_size = 0;
 decrunch_length = 0;

 for(count = 0; count < 8; count++)
  offset_len[count] = 0;
 for(count = 0; count < 768; count ++)
  literal_len[count] = 0;

 source_end = (source = read_buffer + 16384) - 1024;
 pos = destination_end = destination = decrunch_buffer + 258 + 65536;

 for(node = filename_list; (!abort) && node; node = node->next)
 {
  printf("Extracting \"%s\"...", node->filename);
  fflush(stdout);

  out_file = open_output(node->filename);

  sum = 0; /* reset CRC */

  unpack_size = node->length;

  while(unpack_size > 0)
  {

   if(pos == destination) /* time to fill the buffer? */
   {
/* check if we have enough data and read some if not */
    if(source >= source_end) /* have we exhausted the current read buffer? */
    {
     temp = read_buffer;
     if(count == temp - source + 16384)
     {
      do /* copy the remaining overrun to the start of the buffer */
      {
       *temp++ = *source++;
      } while(--count);
     }
     source = read_buffer;
     count = source - temp + 16384;

     if(pack_size < count) count = pack_size; /* make sure we don't read too much */

     if(fread(temp, 1, count, in_file) != count)
     {
      printf("\n");
      if(ferror(in_file))
       perror("FRead(Data)");
      else
       fprintf(stderr, "EOF: Data\n");
      abort = 1;
      break; /* fatal error */
     }
     pack_size -= count;

     temp += count;
     if(source >= temp) break; /* argh! no more data! */
    } /* if(source >= source_end) */

/* check if we need to read the tables */
    if(decrunch_length <= 0)
    {
     if(read_literal_table()) break; /* argh! can't make huffman tables! */
    }

/* unpack some data */
    if(destination >= decrunch_buffer + 258 + 65536)
    {
     if(count == destination - decrunch_buffer - 65536)
     {
      temp = (destination = decrunch_buffer) + 65536;
      do /* copy the overrun to the start of the buffer */
      {
       *destination++ = *temp++;
      } while(--count);
     }
     pos = destination;
    }
    destination_end = destination + decrunch_length;
    if(destination_end > decrunch_buffer + 258 + 65536)
     destination_end = decrunch_buffer + 258 + 65536;
    temp = destination;

    decrunch();

    decrunch_length -= (destination - temp);
   }

/* calculate amount of data we can use before we need to fill the buffer again */
   count = destination - pos;
   if(count > unpack_size) count = unpack_size; /* take only what we need */

   crc_calc(pos, count);

   if(out_file) /* Write the data to the file */
   {
    if(fwrite(pos, 1, count, out_file) != count)
    {
     perror("FWrite"); /* argh! write error */
     fclose(out_file);
     out_file = 0;
    }
   }
   unpack_size -= count;
   pos += count;
  }

  if(out_file)
  {
   fclose(out_file);
   if(!abort) printf(" crc %s\n", (node->crc == sum) ? "good" : "bad");
  }
 } /* for */

 return(abort);
}

/* ---------------------------------------------------------------------- */

/* This is less complex than extract_normal. Almost decipherable. */

int extract_store(FILE *in_file)
{
 struct filename_node *node;
 FILE *out_file;
 unsigned int count;
 int abort = 0;

 for(node = filename_list; (!abort) && node; node = node->next)
 {
  printf("Storing \"%s\"...", node->filename);
  fflush(stdout);

  out_file = open_output(node->filename);

  sum = 0; /* reset CRC */

  unpack_size = node->length;
  if(unpack_size > pack_size) unpack_size = pack_size;

  while(unpack_size > 0)
  {
   count = (unpack_size > 16384) ? 16384 : unpack_size;

   if(fread(read_buffer, 1, count, in_file) != count)
   {
    printf("\n");
    if(ferror(in_file))
     perror("FRead(Data)");
    else
     fprintf(stderr, "EOF: Data\n");
    abort = 1;
    break; /* fatal error */
   }
   pack_size -= count;

   crc_calc(read_buffer, count);

   if(out_file) /* Write the data to the file */
   {
    if(fwrite(read_buffer, 1, count, out_file) != count)
    {
     perror("FWrite"); /* argh! write error */
     fclose(out_file);
     out_file = 0;
    }
   }
   unpack_size -= count;
  }

  if(out_file)
  {
   fclose(out_file);
   if(!abort) printf(" crc %s\n", (node->crc == sum) ? "good" : "bad");
  }
 } /* for */

 return(abort);
}

/* ---------------------------------------------------------------------- */

/* Easiest of the three. Just print the file(s) we didn't understand. */

int extract_unknown(FILE *in_file)
{
 struct filename_node *node;
 int abort = 0;

 for(node = filename_list; node; node = node->next)
 {
  printf("Unknown \"%s\"\n", node->filename);
 }

 return(abort);
}

/* ---------------------------------------------------------------------- */

/* Read the archive and build a linked list of names. Merged files is     */
/* always assumed. Will fail if there is no memory for a node. Sigh.      */

int extract_archive(FILE *in_file)
{
 unsigned int temp;
 struct filename_node **filename_next;
 struct filename_node *node;
 struct filename_node *temp_node;
 int actual;
 int abort;
 int result = 1; /* assume an error */

 filename_list = 0; /* clear the list */
 filename_next = &filename_list;

 do
 {
  abort = 1; /* assume an error */
  actual = fread(archive_header, 1, 31, in_file);
  if(!ferror(in_file))
  {
   if(actual) /* 0 is normal and means EOF */
   {
    if(actual == 31)
    {
     sum = 0; /* reset CRC */
     crc = (archive_header[29] << 24) + (archive_header[28] << 16) + (archive_header[27] << 8) + archive_header[26]; /* header crc */
     archive_header[29] = 0; /* Must set the field to 0 before calculating the crc */
     archive_header[28] = 0;
     archive_header[27] = 0;
     archive_header[26] = 0;
     crc_calc(archive_header, 31);
     temp = archive_header[30]; /* filename length */
     actual = fread(header_filename, 1, temp, in_file);
     if(!ferror(in_file))
     {
      if(actual == temp)
      {
       header_filename[temp] = 0;
       crc_calc(header_filename, temp);
       temp = archive_header[14]; /* comment length */
       actual = fread(header_comment, 1, temp, in_file);
       if(!ferror(in_file))
       {
        if(actual == temp)
        {
         header_comment[temp] = 0;
         crc_calc(header_comment, temp);
         if(sum == crc)
         {
          unpack_size = (archive_header[5] << 24) + (archive_header[4] << 16) + (archive_header[3] << 8) + archive_header[2]; /* unpack size */
          pack_size = (archive_header[9] << 24) + (archive_header[8] << 16) + (archive_header[7] << 8) + archive_header[6]; /* packed size */
          pack_mode = archive_header[11]; /* pack mode */
          crc = (archive_header[25] << 24) + (archive_header[24] << 16) + (archive_header[23] << 8) + archive_header[22]; /* data crc */

          if(node == (struct filename_node *)malloc(sizeof(struct filename_node))) /* allocate a filename node */
          {
           *filename_next = node; /* add this node to the list */
           filename_next = &(node->next);
           node->next = 0;
           node->length = unpack_size;
           node->crc = crc;
           for(temp = 0; (node->filename[temp] = header_filename[temp]); temp++);

           if(pack_size)
           {
            switch(pack_mode)
            {
             case 0: /* store */
             {
              abort = extract_store(in_file);
              break;
             }
             case 2: /* normal */
             {
              abort = extract_normal(in_file);
              break;
             }
             default: /* unknown */
             {
              abort = extract_unknown(in_file);
              break;
             }
            }
            if(abort) break; /* a read error occured */

            temp_node = filename_list; /* free the list now */
            while(node == temp_node)
            {
             temp_node = node->next;
             free(node);
            }
            filename_list = 0; /* clear the list */
            filename_next = &filename_list;

            if(fseek(in_file, pack_size, SEEK_CUR))
            {
             perror("FSeek(Data)");
             break;
            }
           }
           else
            abort = 0; /* continue */
          }
          else
           fprintf(stderr, "MAlloc(Filename_node)\n");
         }
         else
          fprintf(stderr, "CRC: Archive_Header\n");
        }
        else
         fprintf(stderr, "EOF: Header_Comment\n");
       }
       else
        perror("FRead(Header_Comment)");
      }
      else
       fprintf(stderr, "EOF: Header_Filename\n");
     }
     else
      perror("FRead(Header_Filename)");
    }
    else
     fprintf(stderr, "EOF: Archive_Header\n");
   }
   else
   {
    result = 0; /* normal termination */
   }
  }
  else
   perror("FRead(Archive_Header)");
 } while(!abort);

/* free the filename list in case an error occured */
 temp_node = filename_list;
 while(node == temp_node)
 {
  temp_node = node->next;
  free(node);
 }

 return(result);
}

/* ---------------------------------------------------------------------- */

/* List the contents of an archive in a nice formatted kinda way.         */

int view_archive(FILE *in_file)
{
 unsigned int temp;
 unsigned int total_pack = 0;
 unsigned int total_unpack = 0;
 unsigned int total_files = 0;
 unsigned int merge_size = 0;
 int actual;
 int abort;
 int result = 1; /* assume an error */

 printf("Unpacked   Packed Time     Date        Attrib   Name\n");
 printf("-------- -------- -------- ----------- -------- ----\n");

 do
 {
  abort = 1; /* assume an error */
  actual = fread(archive_header, 1, 31, in_file);
  if(!ferror(in_file))
  {
   if(actual) /* 0 is normal and means EOF */
   {
    if(actual == 31)
    {
     sum = 0; /* reset CRC */
     crc = (archive_header[29] << 24) + (archive_header[28] << 16) + (archive_header[27] << 8) + archive_header[26];
     archive_header[29] = 0; /* Must set the field to 0 before calculating the crc */
     archive_header[28] = 0;
     archive_header[27] = 0;
     archive_header[26] = 0;
     crc_calc(archive_header, 31);
     temp = archive_header[30]; /* filename length */
     actual = fread(header_filename, 1, temp, in_file);
     if(!ferror(in_file))
     {
      if(actual == temp)
      {
       header_filename[temp] = 0;
       crc_calc(header_filename, temp);
       temp = archive_header[14]; /* comment length */
       actual = fread(header_comment, 1, temp, in_file);
       if(!ferror(in_file))
       {
        if(actual == temp)
        {
         header_comment[temp] = 0;
         crc_calc(header_comment, temp);
         if(sum == crc)
         {
          attributes = archive_header[0]; /* file protection modes */
          unpack_size = (archive_header[5] << 24) + (archive_header[4] << 16) + (archive_header[3] << 8) + archive_header[2]; /* unpack size */
          pack_size = (archive_header[9] << 24) + (archive_header[8] << 16) + (archive_header[7] << 8) + archive_header[6]; /* packed size */
          temp = (archive_header[18] << 24) + (archive_header[19] << 16) + (archive_header[20] << 8) + archive_header[21]; /* date */
          year = ((temp >> 17) & 63) + 1970;
          month = (temp >> 23) & 15;
          day = (temp >> 27) & 31;
          hour = (temp >> 12) & 31;
          minute = (temp >> 6) & 63;
          second = temp & 63;

          total_pack += pack_size;
          total_unpack += unpack_size;
          total_files++;
          merge_size += unpack_size;

          printf("%8ld ", (long int)unpack_size);
          if(archive_header[12] & 1)
           printf("     n/a ");
          else
           printf("%8ld ", (long int)pack_size);
          printf("%02ld:%02ld:%02ld ", (long int)hour, (long int)minute, (long int)second);
          printf("%2ld-%s-%4ld ", (long int)day, month_str[month], (long int)year);
          printf("%c%c%c%c%c%c%c%c ",
                 (attributes & 32) ? 'h' : '-',
                 (attributes & 64) ? 's' : '-',
                 (attributes & 128) ? 'p' : '-',
                 (attributes & 16) ? 'a' : '-',
                 (attributes & 1) ? 'r' : '-',
                 (attributes & 2) ? 'w' : '-',
                 (attributes & 8) ? 'e' : '-',
                 (attributes & 4) ? 'd' : '-');
          printf("\"%s\"\n", header_filename);
          if(header_comment[0])
           printf(": \"%s\"\n", header_comment);
          if((archive_header[12] & 1) && pack_size)
          {
           printf("%8ld %8ld Merged\n", (long int)merge_size, (long int)pack_size);
          }

          if(pack_size) /* seek past the packed data */
          {
           merge_size = 0;
           if(!fseek(in_file, pack_size, SEEK_CUR))
           {
            abort = 0; /* continue */
           }
           else
            perror("FSeek()");
          }
          else
           abort = 0; /* continue */
         }
         else
          fprintf(stderr, "CRC: Archive_Header\n");
        }
        else
         fprintf(stderr, "EOF: Header_Comment\n");
       }
       else
        perror("FRead(Header_Comment)");
      }
      else
       fprintf(stderr, "EOF: Header_Filename\n");
     }
     else
      perror("FRead(Header_Filename)");
    }
    else
     fprintf(stderr, "EOF: Archive_Header\n");
   }
   else
   {
    printf("-------- -------- -------- ----------- -------- ----\n");
    printf("%8ld %8ld ", (long int)total_unpack, (long int)total_pack);
    printf("%ld file%s\n", (long int)total_files, (((long int)total_files == 1) ? "" : "s"));

    result = 0; /* normal termination */
   }
  }
  else
   perror("FRead(Archive_Header)");
 } while(!abort);

 return(result);
}

/* ---------------------------------------------------------------------- */

/* Process a single archive. */

int process_archive(char *filename)
{
 int result = 1; /* assume an error */
 FILE *in_file;
 int actual;

 if(NULL == filename)
  in_file = stdin;
 else if(NULL == (in_file = fopen(filename,"rb")))
 {
  perror("FOpen(Archive)");
  return(result);
 }

 actual = fread(info_header, 1, 10, in_file);
 if(!ferror(in_file))
 {
  if(actual == 10)
  {
   if((info_header[0] == 76) && (info_header[1] == 90) && (info_header[2] == 88)) /* LZX */
   {
    switch(mode)
    {
     case 1: /* extract archive */
     {
      result = extract_archive(in_file);
      break;
     }
     case 2: /* view archive */
     {
      result = view_archive(in_file);
      break;
     }
    }
   }
   else
    fprintf(stderr, "Info_Header: Bad ID\n");
  }
  else
   fprintf(stderr, "EOF: Info_Header\n");
 }
 else
  perror("FRead(Info_Header)");
 fclose(in_file);

 return(result);
}

/* ---------------------------------------------------------------------- */

/* Handle options & multiple filenames. */

int main(int argc, char **argv)
{
 int result = 0;
 int read_from_stdin = 0;
 int option;
 extern int optind;

 mode = 1; /* default mode is extract */
 while ((option = getopt(argc, argv, "vxc")) != EOF)
 {
  switch(option)
  {
   case 'v': /* (v)iew archive */
   {
    mode = 2;
    break;
   }
   case 'x': /* e(x)tract archive */
   {
    mode = 1;
    break;
   }
   case 'c': /* use stdin to extract/view from */
   {
    read_from_stdin = 1;
    break;
   }
   case '?': /* unknown option */
   {
    result = 1;
    break;
   }
  }
 }
 if(!read_from_stdin && optind >= argc) result = 1;
 /* gotta have a filename or read from stdin */

 if(!result)
 {
  if (read_from_stdin)
  {
   printf("\nReading from stdin...\n\n");
   process_archive(NULL);
   result = 0;
  }
  if((argc - optind) > 1)
  {
   for(; optind < argc; optind++)
   {
    printf("\nArchive \"%s\"...\n\n", argv[optind]);
    process_archive(argv[optind]);
   }
   result = 0; /* Can't give a reliable result for multiple archives */
  }
  else
  {
   result = process_archive(argv[optind]); /* do a single archive */
  }
 }
 else
 {
  fprintf(stderr, "Usage: unlzx [-v][-x][-c] [archive...]\n");
  fprintf(stderr, "\t-c : extract/list from stdin\n");
  fprintf(stderr, "\t-v : list archive(s)\n");
  fprintf(stderr, "\t-x : extract (default)\n");
  result = 2;
 }

 return(result);
}

/* ---------------------------------------------------------------------- */

/* Some info for the reader only. This is unused by the program and can   */
/* safely be deleted.                                                     */

#define INFO_DAMAGE_PROTECT 1
#define INFO_FLAG_LOCKED 2

/* STRUCTURE Info_Header
{
  UBYTE ID[3]; 0 - "LZX"
  UBYTE flags; 3 - INFO_FLAG_#?
  UBYTE[6]; 4
} */ /* SIZE = 10 */

#define HDR_FLAG_MERGED 1

#define HDR_PROT_READ    1
#define HDR_PROT_WRITE   2
#define HDR_PROT_DELETE  4
#define HDR_PROT_EXECUTE 8
#define HDR_PROT_ARCHIVE 16
#define HDR_PROT_HOLD    32
#define HDR_PROT_SCRIPT  64
#define HDR_PROT_PURE    128

#define HDR_TYPE_MSDOS   0
#define HDR_TYPE_WINDOWS 1
#define HDR_TYPE_OS2     2
#define HDR_TYPE_AMIGA   10
#define HDR_TYPE_UNIX    20

#define HDR_PACK_STORE    0
#define HDR_PACK_NORMAL   2
#define HDR_PACK_EOF      32

/* STRUCTURE Archive_Header
{
  UBYTE attributes; 0 - HDR_PROT_#?
  UBYTE; 1
  ULONG unpacked_length; 2 - FUCKED UP LITTLE ENDIAN SHIT
  ULONG packed_length; 6 - FUCKED UP LITTLE ENDIAN SHIT
  UBYTE machine_type; 10 - HDR_TYPE_#?
  UBYTE pack_mode; 11 - HDR_PACK_#?
  UBYTE flags; 12 - HDR_FLAG_#?
  UBYTE; 13
  UBYTE len_comment; 14 - comment length [0,79]
  UBYTE extract_ver; 15 - version needed to extract
  UBYTE; 16
  UBYTE; 17
  ULONG date; 18 - Packed_Date
  ULONG data_crc; 22 - FUCKED UP LITTLE ENDIAN SHIT
  ULONG header_crc; 26 - FUCKED UP LITTLE ENDIAN SHIT
  UBYTE filename_len; 30 - filename length
} */ /* SIZE = 31 */

#define DATE_SHIFT_YEAR   17
#define DATE_SHIFT_MONTH  23
#define DATE_SHIFT_DAY    27
#define DATE_SHIFT_HOUR   12
#define DATE_SHIFT_MINUTE 6
#define DATE_SHIFT_SECOND 0
#define DATE_MASK_YEAR    0x007E0000
#define DATE_MASK_MONTH   0x07800000
#define DATE_MASK_DAY     0xF8000000
#define DATE_MASK_HOUR    0x0001F000
#define DATE_MASK_MINUTE  0x00000FC0
#define DATE_MASK_SECOND  0x0000003F

/* STRUCTURE DATE_Unpacked
{
  UBYTE year; 80 - Year 0=1970 1=1971 63=2033
  UBYTE month; 81 - 0=january 1=february .. 11=december
  UBYTE day; 82
  UBYTE hour; 83
  UBYTE minute; 84
  UBYTE second; 85
} */ /* SIZE = 6 */

/* STRUCTURE DATE_Packed
{
  UBYTE packed[4]; bit 0 is MSB, 31 is LSB
; bit # 0-4=Day 5-8=Month 9-14=Year 15-19=Hour 20-25=Minute 26-31=Second
} */ /* SIZE = 4 */