extract-adf.c

/*
 * extract-adf.c 
 *
 * (C)2008 Michael Steil, http://www.pagetable.com/
 * Do whatever you want with it, but please give credit.
 *
 * (C)2011-2019 Sigurbjorn B. Larusson, http://www.dot1q.org/
 *
 */

// Define if you have ZLIB support, don't forget to compile with -lz
// Comment out if zlib support is not available (support for adz will not work)
#define	_HAVE_ZLIB

#include <libc.h>
#include <sys/_endian.h>
#include <sys/stat.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <inttypes.h>
#include <ctype.h>
#ifdef _HAVE_ZLIB
	#include <zlib.h>
#endif
#include <assert.h>
#include <utime.h>

// These are defaults
#define SECTORS 1760
#define FIRST_SECTOR 0 

// These are hard coded, no way to set them
#define	T_HEADER 2
#define	T_DATA 8
#define	T_LIST 16

// DMS statics
#define	DMS_NOZERO	1
#define DMS_ENCRYPT	2
#define DMS_APPENDS	4
#define DMS_BANNER	8
#define DMS_HIGHDENSITY 16
#define DMS_PC		32
#define DMS_DEVICEFIX	64
#define DMS_FILEIDBIZ	256

// Size of zlib chunks
#define CHUNK 0x4000

// Maximum number of sectors
#define MAX_SECTORS 3520

// Set this to 1 (or anything higher) if you want debugging information printed out, this can now be set at the command line 
#define DEBUG 0

// Maximum AmigaDOS filename length
#define MAX_AMIGADOS_FILENAME_LENGTH 32
// Maximum filename length generated by the program and on the input, this is a reasonably large assumption
#define MAX_FILENAME_LENGTH 256
// Maximum path depth, I'm not sure there is an explicit limit, but the max path length is 255 characters, so it can
// never go over that (or even reach it), we'll use 256 just to be safe
#define MAX_PATH_DEPTH 256

typedef unsigned int uint32_t;

// Stucture for the raw sector
struct sector_raw {
	uint8_t byte[512];
};

// Tthe blockheader
struct blkhdr {
	uint32_t type;
	uint32_t header_key;
	uint32_t seq_num;
	uint32_t data_size;
	uint32_t next_data;
	uint32_t chksum;
};

// The fileheader
struct fileheader {
	struct blkhdr hdr;
	uint8_t misc[288];
	uint32_t unused1;
	uint16_t uid;
	uint16_t gid;
	uint32_t protect;
	uint32_t byte_size;
	uint8_t comm_len;
	uint8_t comment[79];
	uint8_t unused2[12];
	int32_t days;
	int32_t mins;
	int32_t ticks;
	uint8_t name_len;
	char filename[30];
	uint8_t unused3;
	uint32_t unused4;
	uint32_t real_entry;
	uint32_t next_link;
	uint32_t unused5[5];
	uint32_t hash_chain;
	uint32_t parent;
	uint32_t extension;
	uint32_t sec_type;
};

// The dataheader
struct dataheader {
	struct blkhdr hdr;
	uint8_t data[488];
};

// The sector
union sector {
	struct blkhdr hdr;
	struct fileheader fh;
	struct dataheader dh;
};

// Added sibbi 2019, DMS packing variables and tables along with DMS unpacking functions

// Copy paste from code written by David Tritscher, with slight formatting changes
#define BUFFERSIZE 48000

unsigned char pack_buffer[BUFFERSIZE];
unsigned char unpack_buffer[BUFFERSIZE];

unsigned char info_header[4];
unsigned char archive_header[52];
unsigned char track_header[20];

unsigned char quick_buffer[256];

unsigned char medium_buffer[16384];

unsigned char deep_buffer[16384];
unsigned short deep_weights[628];
unsigned short deep_symbols[628];
unsigned short deep_hash[942];

unsigned char heavy_buffer[8192];
unsigned short heavy_literal_table[5120];
unsigned short heavy_offset_table[320];
unsigned char heavy_literal_len[512];
unsigned char heavy_offset_len[32];

unsigned int quick_local;
unsigned int medium_local;
unsigned int deep_local;
unsigned int heavy_local;
unsigned int heavy_last_offset;


static const unsigned short CRCTable[256]=
{
   0x0000,0xC0C1,0xC181,0x0140,0xC301,0x03C0,0x0280,0xC241,
   0xC601,0x06C0,0x0780,0xC741,0x0500,0xC5C1,0xC481,0x0440,
   0xCC01,0x0CC0,0x0D80,0xCD41,0x0F00,0xCFC1,0xCE81,0x0E40,
   0x0A00,0xCAC1,0xCB81,0x0B40,0xC901,0x09C0,0x0880,0xC841,
   0xD801,0x18C0,0x1980,0xD941,0x1B00,0xDBC1,0xDA81,0x1A40,
   0x1E00,0xDEC1,0xDF81,0x1F40,0xDD01,0x1DC0,0x1C80,0xDC41,
   0x1400,0xD4C1,0xD581,0x1540,0xD701,0x17C0,0x1680,0xD641,
   0xD201,0x12C0,0x1380,0xD341,0x1100,0xD1C1,0xD081,0x1040,
   0xF001,0x30C0,0x3180,0xF141,0x3300,0xF3C1,0xF281,0x3240,
   0x3600,0xF6C1,0xF781,0x3740,0xF501,0x35C0,0x3480,0xF441,
   0x3C00,0xFCC1,0xFD81,0x3D40,0xFF01,0x3FC0,0x3E80,0xFE41,
   0xFA01,0x3AC0,0x3B80,0xFB41,0x3900,0xF9C1,0xF881,0x3840,
   0x2800,0xE8C1,0xE981,0x2940,0xEB01,0x2BC0,0x2A80,0xEA41,
   0xEE01,0x2EC0,0x2F80,0xEF41,0x2D00,0xEDC1,0xEC81,0x2C40,
   0xE401,0x24C0,0x2580,0xE541,0x2700,0xE7C1,0xE681,0x2640,
   0x2200,0xE2C1,0xE381,0x2340,0xE101,0x21C0,0x2080,0xE041,
   0xA001,0x60C0,0x6180,0xA141,0x6300,0xA3C1,0xA281,0x6240,
   0x6600,0xA6C1,0xA781,0x6740,0xA501,0x65C0,0x6480,0xA441,
   0x6C00,0xACC1,0xAD81,0x6D40,0xAF01,0x6FC0,0x6E80,0xAE41,
   0xAA01,0x6AC0,0x6B80,0xAB41,0x6900,0xA9C1,0xA881,0x6840,
   0x7800,0xB8C1,0xB981,0x7940,0xBB01,0x7BC0,0x7A80,0xBA41,
   0xBE01,0x7EC0,0x7F80,0xBF41,0x7D00,0xBDC1,0xBC81,0x7C40,
   0xB401,0x74C0,0x7580,0xB541,0x7700,0xB7C1,0xB681,0x7640,
   0x7200,0xB2C1,0xB381,0x7340,0xB101,0x71C0,0x7080,0xB041,
   0x5000,0x90C1,0x9181,0x5140,0x9301,0x53C0,0x5280,0x9241,
   0x9601,0x56C0,0x5780,0x9741,0x5500,0x95C1,0x9481,0x5440,
   0x9C01,0x5CC0,0x5D80,0x9D41,0x5F00,0x9FC1,0x9E81,0x5E40,
   0x5A00,0x9AC1,0x9B81,0x5B40,0x9901,0x59C0,0x5880,0x9841,
   0x8801,0x48C0,0x4980,0x8941,0x4B00,0x8BC1,0x8A81,0x4A40,
   0x4E00,0x8EC1,0x8F81,0x4F40,0x8D01,0x4DC0,0x4C80,0x8C41,
   0x4400,0x84C1,0x8581,0x4540,0x8701,0x47C0,0x4680,0x8641,
   0x8201,0x42C0,0x4380,0x8341,0x4100,0x81C1,0x8081,0x4040
};

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

static const unsigned char table_one[256]=
{
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
   3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,
   6,6,6,6,6,6,6,6,7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,9,9,9,9,9,9,9,9,
   10,10,10,10,10,10,10,10,11,11,11,11,11,11,11,11,
   12,12,12,12,13,13,13,13,14,14,14,14,15,15,15,15,
   16,16,16,16,17,17,17,17,18,18,18,18,19,19,19,19,
   20,20,20,20,21,21,21,21,22,22,22,22,23,23,23,23,
   24,24,25,25,26,26,27,27,28,28,29,29,30,30,31,31,
   32,32,33,33,34,34,35,35,36,36,37,37,38,38,39,39,
   40,40,41,41,42,42,43,43,44,44,45,45,46,46,47,47,
   48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63
};

static const unsigned char table_two[256]=
{
   3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
   4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,
   4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
   5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,
   5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
   6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
   7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
};

// Helper function to convert Amiga timestamp to unix timestamp
struct tm *amigatoepoch(unsigned int amigatime,struct tm *tm) {

	// Time variable for epoch at 1978-01-01
	time_t origstamp = 252460800;

	// Add to the origstampto get epoch time
	origstamp += amigatime;

	// Make tm struct from timestamp
	tm = localtime(&origstamp);

	// Return the timestruct
	return tm;

}

// Helper function to convert Amiga days, minutes, ticks to timestamp
struct utimbuf *amigadaystoutimbuf(uint32_t days, uint32_t minutes, uint32_t ticks,struct utimbuf *utim) {

	// Time variable for epoch at 1978-01-01
	time_t origstamp = 252460800;

	// Div by zero check and fix for ticks
	if(!ticks)
		ticks=1;

	// Add to the origstampto get epoch time
	// Multiply days with 86400 seconds per day, minutes with 60 seconds, and divide the ticks by 50 (ticks per second)
	origstamp += (time_t)(days*86400)+(minutes*60)+(ticks/50);

	// Set struct mod and access times as the current timestamp

	utim->actime = (time_t)origstamp;
	utim->modtime = (time_t)origstamp;

	// Return the utimstruct
	return utim;

}

// DMS helper functions to calculate CRC, (C) 1998 David Tritscher
unsigned int mycrc(unsigned char *memory, unsigned int length)
{
   register unsigned int temp = 0;

   while(length--)
      temp = CRCTable[(temp ^ *memory++) & 255] ^ ((temp >> 8) & 255);

   return (temp & 65535);
}

// DMS helper functions to calculate CRC, (C) 1998 David Tritscher
unsigned int mysimplecrc(unsigned char *memory, uint32_t length)
{
   register uint32_t temp = 0;

   while(length--) temp += *memory++;

   return (temp & 65535);
}

// DMS helper functions to depack sectors

// Store (unpacked) function, (C) 1998 David Tritscher
int crunch_store(unsigned char *source, unsigned char *source_end,
                 unsigned char *destination, unsigned char *destination_end,
	         unsigned int debug,FILE *debugfile)
{
	while((destination < destination_end) && (source < source_end))
		*destination++ = *source++;

	// Print debug output if wanted
	if(debug) 
		fprintf(debugfile,"\tstore: %s",((source != source_end) || (destination != destination_end)) ? "bad" : "good");

	return((source != source_end) || (destination != destination_end));
}


// RLE crunch function, (C) 1998 David Tritscher
// Commented and modified by Sigurbjorn B. Larusson, >255 count didn't work
int crunch_rle(unsigned char *source, unsigned char *source_end,
               unsigned char *destination, unsigned char *destination_end,
	       unsigned int debug, FILE *debugfile) 
{
	
	register unsigned char temp = 0;
	register unsigned char rlechar = 0;
	register unsigned int count = 0;

	int tempcount = 0;

	int rlebytes = 0;
	int rlesaved = 0;

	int totalbytes = 0;
	int unpackedsize = 0;
	int rletotalbytes = 0;

	// Until we've completed reading all the destination bytes...
	while((destination < destination_end) && (source < source_end)) {
		// Read current pointed to of source into temp and then increment source
		temp = *source++;
		totalbytes++;
		rletotalbytes++;
		// Not RLE encoded, just copy bytes
		if(temp != 144) {
			*destination++ = temp;
		} else {
			// We've wasted a character here on rlebytes
			rlebytes++;
			// Count is in next seat
			count = *source++;
			// Another character here on rlebytes
			rlebytes++;
			totalbytes++;
			rletotalbytes++;
			// Count uses more than one byte?
			if(count==255) {
				// Next byte is rlechar
				rlechar = *source++;
				totalbytes++;
				rletotalbytes++;
				// Next two bytes are the counter
				temp = *source++;
				totalbytes++;
				rletotalbytes++;
				tempcount = (temp <<8);
				count = tempcount;
				temp = *source++;
				totalbytes++;
				rletotalbytes++;
				count += temp;
				rlebytes+=3;
			} else if(count != 0) {
				// Next byte is rlechar
				rlechar = *source++;
				totalbytes++;
				rletotalbytes++;
			}
			// Count is 0 than this is a literal É character
			if(count == 0) {
				*destination++ = temp;
				// And we've saved one rle byte
				rlebytes--;
			// Counter is not 0, procceed with unRLE
			} else {
				// While we have repeats, fill the destination array with the repeated byte
				while(count > 0) {
					*destination++ = rlechar;
					count--;
					rlesaved++;
					rletotalbytes++;
				}
				rlesaved--;
			}
		}
	}  // End while
	unpackedsize = totalbytes - rlebytes + rlesaved;

	if(debug) {
		fprintf(debugfile,"\tTotal bytes used on RLE: %u, total bytes saved by RLE: %u, Totalbytes read: %u Totalbytes processed: %u Unpacked size: %u\n",rlebytes,rlesaved,totalbytes,rletotalbytes,unpackedsize);
		fprintf(debugfile,"\trunlength: %s\n",((source != source_end) || (destination != destination_end)) ? "bad" : "good");
	}

	return((source != source_end) || (destination != destination_end));
}

// Quick crunch function, (C) 1998 David Tritscher
int crunch_quick(unsigned char *source, unsigned char *source_end,
                 unsigned char *destination, unsigned char *destination_end,
	         unsigned int debug, FILE *debugfile,unsigned int no_clear_flag) 
{
	register unsigned int control = 0;
	register int shift = 0;
	int count, offset;

	quick_local += 5; /* i have no idea why it adds 5 */
	if(!no_clear_flag)
	for(quick_local = count = 0; count < 256; count++)
		quick_buffer[count] = 0;

	while((destination < destination_end) && (source < source_end)) {
		control <<= 9; /* all codes are at least 9 bits long */
		if((shift += 9) > 0) {
			control += *source++ << (8 + shift);
			control += *source++ << shift;
			shift -= 16;
		}
		if(control & 16777216) {
			*destination++ = quick_buffer[quick_local++ & 255] = control >> 16;
		} else {
			control <<= 2; /* 2 extra bits for length */
			if((shift += 2) > 0) {
				control += *source++ << (8 + shift);
				control += *source++ << shift;
				shift -= 16;
			}
			count = ((control >> 24) & 3) + 2;
			offset = quick_local - ((control >> 16) & 255) - 1;
			while((destination < destination_end) && (count--))
				*destination++ = quick_buffer[quick_local++ & 255] =
			quick_buffer[offset++ & 255];
		}
	} /* while */

	if(debug)
		fprintf(debugfile,"\tquick: %s\n",((source > source_end) || (destination != destination_end)) ? "bad" : "good");

	return((source > source_end) || (destination != destination_end));
}

// Medium crunch function, (C) 1998 David Tritscher
int crunch_medium(unsigned char *source, unsigned char *source_end,
                  unsigned char *destination, unsigned char *destination_end,
	          unsigned int debug, FILE *debugfile, unsigned int no_clear_flag) 
{
	register unsigned int control = 0;
	register int shift = 0;
	int count, offset, temp;

	medium_local += 66; /* i have no idea why it adds 66 */
	if(!no_clear_flag)
		for(medium_local = count = 0; count < 16384; count++)
			medium_buffer[count] = 0;

	while((destination < destination_end) && (source < source_end)) {
		control <<= 9; /* all codes are 9 bits long */
		if((shift += 9) > 0) {
			control += *source++ << (8 + shift);
			control += *source++ << shift;
			shift -= 16;
		}
		if((temp = (control >> 16) & 511) >= 256) {
			*destination++ = medium_buffer[medium_local++ & 16383] = temp;
		} else {
			count = table_one[temp] + 3;
			temp = table_two[temp];
			control <<= temp;
			if((shift += temp) > 0) {
				control += *source++ << (8 + shift);
				control += *source++ << shift;
				shift -= 16;
			}
			temp = (control >> 16) & 255;
			offset = table_one[temp] << 8;
			temp = table_two[temp];
			control <<= temp;
			if((shift += temp) > 0) {
				control += *source++ << (8 + shift);
				control += *source++ << shift;
				shift -= 16;
			}
			offset += (control >> 16) & 255;
			offset = medium_local - offset - 1;
			while((destination < destination_end) && (count--))
				*destination++ = medium_buffer[medium_local++ & 16383] = medium_buffer[offset++ & 16383];
		}
	} /* while */

	if(debug)
		fprintf(debugfile,"\tmedium: %s\n",((source > source_end) || (destination != destination_end)) ? "bad" : "good");

	return((source > source_end) || (destination != destination_end));
}

// Deep clear helper function (C) 1998 David Tritscher
void deep_clear(unsigned int debug, FILE *debugfile) {
	unsigned short count, temp;
	temp = 627;
	for(count = 0; count < 314; count++) {
		deep_weights[count] = 1;
		deep_symbols[count] = temp;
		deep_hash[temp] = count;
		temp++;
	}
	temp = 0;
	for(count = 314; count < 627; count++) {
		deep_weights[count] = deep_weights[temp] + deep_weights[temp + 1];
		deep_symbols[count] = temp;
		deep_hash[temp] = deep_hash[temp + 1] = count;
		temp += 2;
	}
	deep_weights[count] = 65535;
	deep_hash[temp] = 0;

	if(debug)
		fprintf(debugfile," ...clear");
}

// Deep scale helper function (C) 1998 David Tritscher
void deep_scale(unsigned int debug, FILE *debugfile)
{
	int symbol, swap, temp, weight;

	temp = 0;
	for(symbol = 0; symbol < 627; symbol++) {
		if(deep_symbols[symbol] >= 627)
		{
			deep_weights[temp] = (deep_weights[symbol] + 1) >> 1;
			deep_symbols[temp] = deep_symbols[symbol];
			temp++;
		}
	}
	temp = 0;
	for(symbol = 314; symbol < 627; symbol++) {
		weight = deep_weights[temp] + deep_weights[temp + 1];
		for(swap = symbol; deep_weights[swap - 1] > weight; swap--)
		{
			deep_weights[swap] = deep_weights[swap - 1];
			deep_symbols[swap] = deep_symbols[swap - 1];
		}
		deep_weights[swap] = weight;
		deep_symbols[swap] = temp;
		temp += 2;
	}
	for(symbol = 0; symbol < 627; symbol++) {
		temp = deep_symbols[symbol];
		deep_hash[temp] = symbol; if(temp < 627) deep_hash[temp + 1] = symbol;
	}

	if(debug)
		fprintf(debugfile," ...scale");
} 

// Deep crunch function, (C) 1998 David Tritscher
int crunch_deep(unsigned char *source, unsigned char *source_end,
                unsigned char *destination, unsigned char *destination_end,
		unsigned int debug, FILE *debugfile, unsigned int no_clear_flag)
{
	register unsigned int control = 0;
	register int shift = 0;
	int count, offset, temp, symbol, swap, temp1, temp2;

	deep_local += 60; /* i have no idea why it adds 60 */
	if(!no_clear_flag) {
		deep_clear(debug,debugfile);
		for(deep_local = count = 0; count < 16384; count++)
			deep_buffer[count] = 0;
	}

	while((destination < destination_end) && (source < source_end)) {
		count = deep_symbols[626]; /* start from the root of the trie */
		do {
			if(!shift++) {
				control += *source++ << 8;
				control += *source++;
				shift = -15;
			}
			control <<= 1;
			count += (control >> 16) & 1;
		} while((count = deep_symbols[count]) < 627);

		if(deep_weights[626] == 32768) /* scale the trie if the weight gets too large */
			deep_scale(debug,debugfile);

		symbol = deep_hash[count];
		do {
			deep_weights[symbol]++; /* increase the weight of this node */
			if(deep_weights[symbol + 1] < deep_weights[symbol]) {
				temp1 = deep_weights[(swap = symbol)];
				do {
					swap++;
				} while(deep_weights[swap + 1] < temp1);
				deep_weights[symbol] = deep_weights[swap];
				deep_weights[swap] = temp1;
				temp1 = deep_symbols[symbol];
				temp2 = deep_symbols[swap];
				deep_symbols[swap] = temp1;
				deep_symbols[symbol] = temp2;
				deep_hash[temp1] = swap; 
				if(temp1 < 627) 
					deep_hash[temp1 + 1] = swap;
				deep_hash[temp2] = symbol; 
				if(temp2 < 627) 
					deep_hash[temp2 + 1] = symbol;
				symbol = swap;
			}
		} while((symbol = deep_hash[symbol])); /* repeat until we reach root */

		if((count -= 627) < 256) {
			*destination++ = deep_buffer[deep_local++ & 16383] = count;
		} else {
			count -= 253; /* length is always at least 3 characters */
			control <<= 8;
			if((shift += 8) > 0) {
				control += *source++ << (8 + shift);
				control += *source++ << shift;
				shift -= 16;
			}
			temp = (control >> 16) & 255;
			offset = table_one[temp] << 8;
			temp = table_two[temp];
			control <<= temp;
			if((shift += temp) > 0) {
				control += *source++ << (8 + shift);
				control += *source++ << shift;
				shift -= 16;
			}
			offset += (control >> 16) & 255;
			offset = deep_local - offset - 1;
			while((destination < destination_end) && (count--))
				*destination++ = deep_buffer[deep_local++ & 16383] = deep_buffer[offset++ & 16383];
		}
	} /* while */

	if(debug)
		fprintf(debugfile,"\tdeep: %s\n",((source > source_end) || (destination != destination_end)) ? "bad" : "good");

	return((source > source_end) || (destination != destination_end));
}

// Helper function for heavy crunch, (C) 1998 David Tritscher
int make_decode_table(int number_symbols, int table_size,
                      unsigned char *length, unsigned short *table,
		      unsigned int debug, FILE *debugfile)
{
	register unsigned char bit_num = 0;
	register int symbol;
	unsigned int table_mask, bit_mask, pos, fill, next_symbol, leaf;
	int abort = 0;

	pos = 0;
	fill = 0;
	bit_mask = table_mask = 1 << table_size;

	while((!abort) && (bit_num <= table_size)) {
		for(symbol = 0; symbol < number_symbols; symbol++) {
			if(length[symbol] == bit_num) {
				if((pos += bit_mask) > table_mask) {
					abort = 1;
					break; /* we will overrun the table! abort! */
				}
				while(fill < pos)
					table[fill++] = symbol;
			}
		}
		bit_mask >>= 1;
		bit_num++;
	}

	if((!abort) && (pos != table_mask)) {
		for(; fill < table_mask; fill++)
			table[fill] = 0; /* clear the rest of the table */
		next_symbol = table_mask >> 1;
		pos <<= 16;
		table_mask <<= 16;
		bit_mask = 32768;

		while((!abort) && (bit_num <= 18)) {
			for(symbol = 0; symbol < number_symbols; symbol++) {
				if(length[symbol] == bit_num) {
					leaf = pos >> 16;
					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(debug)
		fprintf(debugfile,"\tcreate_table: %s\n",((pos != table_mask) || abort) ? "bad" : "good");

	return((pos != table_mask) || abort);
}

// Heavy crunch function, (C) 1998 David Tritscher
int crunch_heavy(unsigned char *source, unsigned char *source_end,
                unsigned char *destination, unsigned char *destination_end,
                int flag, int special,
		int debug, FILE *debugfile, int no_clear_flag)
{
	register unsigned int control = 0;
	register int shift = 0;

	int count, offset, temp;

	if(!no_clear_flag) 
		heavy_local = 0;

	if(flag) {
		flag = 0;

		/* read the literal table */
		if(!flag) {
			for(count = 0; count < 512; count++)
				heavy_literal_len[count] = 255;
			control <<= 9; /* get number of literals */
			if((shift += 9) > 0) {
				control += *source++ << (8 + shift);
				control += *source++ << shift;
				shift -= 16;
			}
			if((offset = (control >> 16) & 511))
				for(count = 0; count < offset; count++) {
					control <<= 5; /* get the length of this literal */
					if((shift += 5) > 0) {
						control += *source++ << (8 + shift);
						control += *source++ << shift;
						shift -= 16;
					}
					temp = (control >> 16) & 31;
					heavy_literal_len[count] = (temp ? temp : 255);
				} 
			else {
				control <<= 9; /* get the defined literal */
				if((shift += 9) > 0) {
					control += *source++ << (8 + shift);
					control += *source++ << shift;
					shift -= 16;
				}
				heavy_literal_len[(control >> 16) & 511] = 0;
			}

			flag = make_decode_table(512, 12, heavy_literal_len, heavy_literal_table,debug,debugfile);
		}

		/* read the offset table */
		if(!flag) {
			for(count = 0; count < 32; count++)
				heavy_offset_len[count] = 255;

			control <<= 5; /* get number of offsets */
			if((shift += 5) > 0) {
				control += *source++ << (8 + shift);
				control += *source++ << shift;
				shift -= 16;
			}
			if((offset = (control >> 16) & 31))
				for(count = 0; count < offset; count++) {
					control <<= 4; /* get the length of this offset */
					if((shift += 4) > 0) {
						control += *source++ << (8 + shift);
						control += *source++ << shift;
						shift -= 16;
					}
					temp = (control >> 16) & 15;
					heavy_offset_len[count] = (temp ? temp : 255);
				}
			else {
				control <<= 5; /* get the defined offset */
				if((shift += 5) > 0) {
					control += *source++ << (8 + shift);
					control += *source++ << shift;
					shift -= 16;
				}
				heavy_offset_len[(control >> 16) & 31] = 0;
			}
			temp = heavy_offset_len[special];
			heavy_offset_len[special] = heavy_offset_len[31];
			heavy_offset_len[31] = temp;

			flag = make_decode_table(32, 8, heavy_offset_len, heavy_offset_table,debug,debugfile);
		}

	} /* if(flag) */

	if(!flag) {
		/* prefetch 12 bits for fast huffman decoding */
		control <<= 12;
		if((shift += 12) > 0) {
			control += *source++ << (8 + shift);
			control += *source++ << shift;
			shift -= 16;
		}

		while((destination < destination_end) && (source < source_end)) {

			/* get a literal */
			if((count = heavy_literal_table[(control >> 16) & 4095]) >= 512) {
				do /* literal is longer than 12 bits */ {
					if(!shift++) {
						control += *source++ << 8;
						control += *source++;
						shift = -15;
					}
					control <<= 1;
					count = heavy_literal_table[((control >> 16) & 1) + (count << 1)];
				} while(count >= 512);
				temp = 12; /* skip the original 12 bits */
			} else {
				temp = heavy_literal_len[count];
			}
			control <<= temp;
			if((shift += temp) > 0) {
				control += *source++ << (8 + shift);
				control += *source++ << shift;
				shift -= 16;
			}

			/* less than 256 = literal, otherwise = length of string */
			if(count < 256) {
				*destination++ = heavy_buffer[heavy_local++ & 8191] = count;
			} else { /* must have been a string */
				count -= 253; /* length is always at least 3 characters */
				if((offset = heavy_offset_table[(control >> 20) & 255]) >= 32) {
					do { /* offset is longer than 8 bits */
						if(!shift++) {
							control += *source++ << 8;
							control += *source++;
							shift = -15;
						}
						control <<= 1;
						offset = heavy_offset_table[((control >> 20) & 1) + (offset << 1)];
					} while(offset >= 32);
					temp = 8; /* skip the original 8 bits */
				} else {
					temp = heavy_offset_len[offset];
				}
				control <<= temp;
				if((shift += temp) > 0) {
					control += *source++ << (8 + shift);
					control += *source++ << shift;
					shift -= 16;
				}

				if(offset == 31) {
					offset = heavy_last_offset;
				} else {
					if(offset) {
						temp = offset - 1;
						offset = ((control & 268369920) | 268435456) >> (28 - temp);
						control <<= temp;
						if((shift += temp) > 0) {
							control += *source++ << (8 + shift);
							control += *source++ << shift;
							shift -= 16;
						}
					}
					heavy_last_offset = offset;
				}
				offset = heavy_local - offset - 1;
				while((destination < destination_end) && (count--))
					*destination++ = heavy_buffer[heavy_local++ & 8191] = heavy_buffer[offset++ & 8191];
			} /* if(string) */
		}
	} /* if(!flag) */

	if(debug)
		fprintf(debugfile,"\theavy: %s\n",((source > source_end) || (destination != destination_end) || flag) ? "bad" : "good");

	return((source > source_end) || (destination != destination_end) || flag);
}

#define DATABYTES (sizeof(union sector)-sizeof(struct blkhdr))

// Print usage information, Added Sibbi 2011, added 2017, 2019
void usage(char *programname) {
	fprintf(stderr,"Extract-ADF 4.0 Originally (C)2008 Michael Steil with many further additions by Sigurbjorn B. Larusson\n");
	fprintf(stderr,"DMS extraction code (C) 1998 David Tritscher\n");
        fprintf(stderr,"\nUsage: %s [-D] [-a] [-z] [-d] [-s <startsector>] [-e <endsector>] [-o <outputfilename>] <adf/adz/dmsfilename>\n",programname);
	fprintf(stderr,"\n\t-a will force ADF extraction (if the filename ends in adf ADF will be assumed");
	fprintf(stderr,"\n\t-z will force ADZ extraction (if the filename ends in adz or adf.gz ADZ will be assumed");
	fprintf(stderr,"\n\t-d will force DMS extraction (if the filename ends in dms DMS format will be assumed");
	fprintf(stderr,"\n\t-D will activate debugging output which will print very detailed information about everything that is going on");
	fprintf(stderr,"\n\t-s along with an integer argument from 0 to 1760 (DD) or 3520 (HD), will set the starting sector of the extraction process");
	fprintf(stderr,"\n\t-e along with an integer argument from 0 to 1760 (DD) or 3520 (HD), will set the end sector of the extraction process");
	fprintf(stderr,"\n\t-o along with an outputfilename will redirect output (including debugging output) to a file instead of to the screen");
	fprintf(stderr,"\n\tFinally the last argument is the ADF/ADZ or DMS filename to process");
	fprintf(stderr,"\n\nThe defaults for start and end sector are 0 and 1760 respectively, this tool was originally"),
	fprintf(stderr,"\ncreated to salvage lost data from kickstart disks (which contain the kickstart on sectors 0..512)");
	fprintf(stderr,"\nin order to skip the sectors on kickstart disks which might contain non OFS data, set the start sector to 513\n");
	fprintf(stderr,"\nTo use this tool on a HD floppy, the end sector needs to be 3520\n");
	fprintf(stderr,"\nIf you get a Bus error it means that you specificed a non-existing end sector\n");
	fprintf(stderr,"\nThis program does not support FFS floppies(!), it only supports OFS style Amiga Floppies\n");
	fprintf(stderr,"\nHappy hunting!\n");
}

// Added Sibbi for version 4
// Uncompress file to temporary location and return a filepointer to the temporary uncompressed file
#ifdef _HAVE_ZLIB
FILE *uncompressfile(char *inputfile,unsigned int debug, FILE *debugfile) {
	// File pointers
	FILE *infile;
	FILE *outfile;

	// Temporary filename
	char tmptemplate[] = "/tmp/extractadf.XXXXX";

	// File descriptor for temp file
	int fd = 0;

	// To store whether this is a gzip or zip file, both of which are (annoyingly) common
	int iszip = 0;
	// To store the filename length for a zip file header
	int zipfilenamelength = 0;
	//  To store the extra header length for a zip file header
	int zipextraheader = 0;

	if(debug)
	fprintf(debugfile,"Input filename is %s\n",inputfile);
	
	
	// Define ZLib stream, and input and output chunks (CHUNK is defined as 0x4000 earlier in thsi program)
	z_stream strm;
	unsigned char in[CHUNK];
	unsigned char out[CHUNK];

	// For reading in the file header
	unsigned char header[5];
	// How many bytes we have
	unsigned int have = 0;
	// Store return code of inflate
	int ret = 0;

	// Open input and output files
	if(inputfile != NULL) {
		infile = fopen(inputfile,"r");
		if(infile == NULL)  {
			fprintf(stderr,"Can't open input file\n");
			// Can't open file
			return NULL;
		}
		// Is this a zip file?  A lot of people assume gzip/zip are the same, they are obviously not, zip is an archive file format
		// However, even if this is a zip file, we might still be able to decompress it
		// Read in the first four bytes
		if(fread(header,1,4,infile) == 4) {
			if(header[0] == 0x50 && header[1] == 0x4B && header[2] == 0x03 && header[3] == 0x04)  {
				fprintf(stderr,"Input file appears to be in zip format\n");
				// It's a zip file
				iszip=1;
				// Check the minimum version fields
				if(fread(header,1,2,infile) == 2) {
					if(header[1] != 0) {
						// Seek to byte 5, after the pkzip + min version
						fseek(infile,5,SEEK_SET);
					// Otherwise this is a regular zip file
					} else {
						// Skip to byte 26 in the header
						fseek(infile,26,SEEK_SET);
						// Read the next 2 bytes which represent the length of the filename 
						if(fread(header,1,2,infile) == 2) {
							// Get length of filename (which is in LSB format) 
							zipfilenamelength = (header[1]<<8)+header[0];
							if(debug)
								fprintf(debugfile,"Filename length %u %u\n",header[0],header[1]);
							// Then the length of the extra header
							if(fread(header,1,2,infile) == 2) {
								zipextraheader = (header[1]<<8)+header[0];
								// Skip 30+zipfilenamelength + zipextraheader bytes into the file
								if(debug)
									fprintf(debugfile,"Extra header length %u %u\n",header[0],header[1]);
								fseek(infile,30+zipextraheader+zipfilenamelength,SEEK_SET);
							} else {
								fprintf(stderr,"ZIP header damaged\n");
								return NULL;
							}
						} else {
							fprintf(stderr,"ZIP header damaged\n");
							return NULL;
						}
					} 
				} else {
					fprintf(stderr,"ZIP header damaged\n");
					return NULL;
				}
			} else {
				// Rewind to start of file
				rewind(infile);
			}
		} else {
			// Can't read 4 bytes from file
			fprintf(stderr,"Can't read from input file\n");
			return NULL;
		}	
		// Open temporary outfile
		fd = mkstemp(tmptemplate);
		// Can't create temp file
		if(fd == -1) {
			fprintf(stderr,"Can't open temporary file\n");
			return NULL;
		}
		outfile = fdopen(fd,"w+");
		if(outfile == NULL) {
			fprintf(stderr,"Can't write temporary file\n");
			// Can't write temporary outfile
			return NULL;
		}
	} else {
		fprintf(stderr,"Inputfile is not valid\n");
		// Input file is not valid
		return NULL;
	}

	// Initial inflate state
	strm.zalloc = Z_NULL;
	strm.zfree = Z_NULL;
	strm.opaque = Z_NULL;
	strm.avail_in = 0;
	strm.next_in = Z_NULL;

	// if zip file return header, if we can't init, exit with NULL
	if(!iszip) {
		// Rewind to start of file
		if(inflateInit2(&strm,32+MAX_WBITS) != Z_OK) {
			fprintf(stderr,"Can't init zlib\n");
			return NULL;
		}
	} else {
		if(inflateInit2(&strm,-MAX_WBITS) != Z_OK) {
			fprintf(stderr,"Can't init zlib\n");
			return NULL;
		}
	}


	// Otherwise decompress until end of stream
	do {
		// Read CHUNK bytes from inputfile into the in buffer
		strm.avail_in = fread(in,1,CHUNK,infile);
		// Check for file error
		if(ferror(infile)) {
			fprintf(stderr,"Can't read inputfile\n");
			// Error reading from inputfile, end inflate, return NULL
			(void)inflateEnd(&strm);
			return NULL;
		}
		if(strm.avail_in == 0)
			// We are done reading, end this loop
			break;
		strm.next_in = in;
		// Decompress data until available out bytes i 0
		do {
			strm.avail_out = CHUNK;
			strm.next_out = out;

			// Inflate and check for return code
			ret = inflate(&strm,Z_NO_FLUSH);
			assert(ret != Z_STREAM_ERROR);  /* state not clobbered, if so exit */
			// If we encounter errors then exit
			switch(ret) {
				case Z_NEED_DICT:
					fprintf(stderr,"Dictionary error while decompressing\n");
					ret = Z_DATA_ERROR;     /* and fall through */
				case Z_DATA_ERROR:
					fprintf(stderr,"Data error while decompressing\n");
				case Z_MEM_ERROR:
					(void)inflateEnd(&strm);
					return NULL;
			}
			// Number of bytes we have to write
			have = CHUNK - strm.avail_out;
			// If we can't write out or there's a file error, exit
			if(fwrite(out,1,have,outfile) != have || ferror(outfile)) {
				fprintf(stderr,"Can't write to output file\n");
				(void)inflateEnd(&strm);
				return NULL;
			}
		} while(strm.avail_out == 0);
	} while (ret != Z_STREAM_END);
	// If we reached here the file is uncompressed...
	// Close the input file
	fclose(infile);
	// Seek to 0 in the output file
	rewind(outfile);
	//  Return filepointer
	return outfile;
}	// End function uncompressfile
#endif 	// if defined _HAVE_ZLIB

// Added Sibbi for version 4
// Unpack DMS file to temporary location and return a filepointer to the temporary uncompressed file
// Loosely based on code (C) 1998 David Tritscher
FILE *undmsfile(char *inputfile,int endsector, unsigned int debug, FILE *debugfile) {
	// File pointers
	FILE *infile;
	FILE *outfile;

	// Temporary filename
	char tmptemplate[] = "/tmp/extractadf.XXXXX";

	// File descriptor for temp file
	int fd = 0;

	if(debug)
		fprintf(debugfile,"Input filename is %s\n",inputfile);
	
	// Header array to read the dms header
	unsigned char header[64];

	//  Track header array to read the trackk header
	unsigned char trackheader[32];

	// Infobits integer
	unsigned int infobits = 0;

	//  Start and end track of DMS file
	unsigned short dmsstarttrack = 0;
	unsigned short dmsendtrack =  0;

	// Size of compressed and uncompressed file
	unsigned int dmspacksize = 0;
	unsigned int dmsunpacksize = 0;

	// Serial number of DMS file
	unsigned int dmsserial = 0;

	// DMS creator machine information
	unsigned int dmscpu = 0;
	unsigned int dmscopro = 0;
	unsigned int dmsmachine = 0;
	unsigned int dmsextra = 0;
	unsigned int dmscpuspeed = 0;

	// Time taken to create archive
	unsigned int dmscreatetime = 0;

	// Versions used to create and needed to extract this DMS
	unsigned short dmscreateversion = 0;
	unsigned short dmsextractversion = 0;

	// Type of disk in this archive
	unsigned short dmsdisktype = 0;

	// Struct to store dms time
	struct tm *dmstime;
	dmstime = malloc(sizeof(struct tm));

	// Crunchmode used
	unsigned short dmscrunchmode = 0;

	// DMS header CRC
	unsigned short dmsheadercrc = 0;

	// Timestamp integer
	time_t dmstimestamp = 0;

	// Track header variables
	unsigned int trackcurrent = 0;
	unsigned int trackpacked = 0;
	unsigned int trackrlesize = 0;
	unsigned int trackunpacked = 0;
	unsigned int trackpackmode = 0;
	unsigned int trackcrc = 0;
	unsigned int trackpackcrc = 0;
	unsigned int trackunpackcrc = 0;
	unsigned int trackcflags = 0;

	// Flags set in trackcflags
	unsigned int trackcflag_noclear = 0;
	unsigned int trackcflag_compressed = 0;
	unsigned int trackcflag_rle = 0;

	// Pointer to the current buffer
	unsigned char *buffer;

	// String to print time
	char timestring[80];

	// Temporary loop variable
	int i=0;

	// Open input and output files
	if(inputfile != NULL) {
		infile = fopen(inputfile,"r");
		if(infile == NULL)  {
			fprintf(stderr,"Can't open input file\n");
			// Can't open file
			return NULL;
		}
		// Open temporary outfile
		fd = mkstemp(tmptemplate);
		// Can't create temp file
		if(fd == -1) {
			fprintf(stderr,"Can't open temporary file\n");
			return NULL;
		}
		// Open outfile for read/write
		outfile = fdopen(fd,"w+");
		if(outfile == NULL) {
			fprintf(stderr,"Can't write temporary file\n");
			// Can't write temporary outfile
			return NULL;
		}
		// We're ready to start processing the header...
		if((fread(header,1,4,infile) == 4)) {
			// Check for DMS header
			if(header[0] == 'D' && header[1] == 'M' && header[2] == 'S' && header[3] == '!') {
				if(debug)
					fprintf(debugfile,"Valid DMS header found, proceeding\n");
			}
		}
		// Read the rest of the header
		if((fread(header,1,52,infile) == 52)) {
			if((header[0] == ' ' && header[1] == 'P' && header[2] == 'R' && header[3] == 'O') && debug) 
				fprintf(debugfile,"File is a DMS PRO file\n");

			// Infobits is a long word stored in MSB at header locations 8-11
			infobits=(header[4]<<24)+(header[5]<<16)+(header[6]<<8)+header[7];

			if(debug)
				fprintf(debugfile,"Infobits %u %u %u %u total: %u\n",header[4],header[5],header[6],header[7],infobits);

			// DMS no zero flag is set
			if((infobits & DMS_NOZERO) && debug)
				fprintf(debugfile,"DMS No zero flag is set\n");
			// Encrypted DMS file, return null, print error
			if(infobits & DMS_ENCRYPT) {
				fprintf(stderr,"This is an encrypted DMS file, those are unsupported, please decrypt the file before using thisi program\n");
				return NULL;	
			}

			// Optimized DMS file (appends)
			if((infobits & DMS_APPENDS) && debug) 
				fprintf(debugfile,"DMS Appens flag is set\n");

			// Banner in file
			if((infobits & DMS_BANNER) && debug) 
				fprintf(debugfile,"DMS banner exists in file\n");
			
			// File is high density file...
			if((infobits & DMS_HIGHDENSITY) && endsector < MAX_SECTORS) {
				fprintf(stderr,"File is high density and endsector is less than 3520\n");
				return NULL;
			}

			// File is a PC floppy
			if(infobits & DMS_PC)  {
				fprintf(stderr,"File is a PC floppy\n");
				return NULL;
			}

			// DMS device fix bit is set
			if((infobits & DMS_DEVICEFIX) && debug)
				fprintf(debugfile,"DMS Device Fix bit is set\n");
	
			// DMS FILE_ID.DIZ bit is set
			if((infobits & DMS_FILEIDBIZ) && debug)
				fprintf(debugfile,"DMS FILE.ID_BIZ bit is set\n");

			// Get amiga timestamp from header (Amiga seconds since 1. jan 1978)
			dmstimestamp=(time_t)(header[8]<<24)+(header[9]<<16)+(header[10]<<8)+header[11];	

			// Convert DMS timestring into epoch, and then to a valid timestring
			strftime(timestring,80,"%c",amigatoepoch(dmstimestamp,dmstime));

			if(debug)
				fprintf(debugfile,"File created %s\n",timestring);

			// Start and end track
			dmsstarttrack = (header[12]<<8)+header[13];
			dmsendtrack = (header[14]<<8)+header[15];

			if(debug)
				fprintf(debugfile,"DMS start track: %u, end track: %u\n",dmsstarttrack,dmsendtrack);

			// Before and after compression sizes
			dmspacksize = (header[16]<<24)+(header[17]<<16)+(header[18]<<8)+header[19];
			dmsunpacksize = (header[20]<<24)+(header[21]<<16)+(header[22]<<8)+header[23];

			if(debug)
				fprintf(debugfile,"DMS Packed size: %u, unpacked size: %u\n",dmspacksize,dmsunpacksize);

			// Serial number of the creator
			dmsserial = (header[24]<<24)+(header[25]<<16)+(header[26]<<8)+header[27];
			if(debug) {
				if(dmsserial == 4292345787)
					fprintf(debugfile,"DMS Serial number of creator: Unregistered copy\n");
				else
					fprintf(debugfile,"DMS Serial number of creator: %u\n",dmsserial);
			}

			// CPU, co-pro, machine type and cpu speed of creator
			dmscpu = (header[28]<<8)+header[29];
			dmscopro = (header[30]<<8)+header[30];
			dmsmachine = (header[32]<<8)+header[33];
			dmsextra = (header[34]<<8)+header[35];	
			dmscpuspeed = ((header[36]<<8)+header[37]);

			if(debug) {
				switch(dmscpu) {
					case 0:
						fprintf(debugfile,"DMS CPU type of creator: M68000\n");
						break;
					case 1:
						fprintf(debugfile,"DMS CPU type of creator: M68010\n");
						break;
					case 2:
						fprintf(debugfile,"DMS CPU type of creator: M68020\n");
						break;
					case 3:
						fprintf(debugfile,"DMS CPU type of creator: M68030\n");
						break;
					case 4:
						fprintf(debugfile,"DMS CPU type of creator: M68040\n");
						break;
					case 5:
						fprintf(debugfile,"DMS CPU type of creator: M68060\n");
						break;
					case 6:
						fprintf(debugfile,"DMS CPU type of creator: i8086\n");
						break;
					case 7:
						fprintf(debugfile,"DMS CPU type of creator: i8088\n");
						break;
					case 8:
						fprintf(debugfile,"DMS CPU type of creator: i80188\n");
						break;
					case 9:
						fprintf(debugfile,"DMS CPU type of creator: i80186\n");
						break;
					case 10:
						fprintf(debugfile,"DMS CPU type of creator: i80286\n");
						break;
					case 11:
						fprintf(debugfile,"DMS CPU type of creator: i80386SX\n");
						break;
					case 12:
						fprintf(debugfile,"DMS CPU type of creator: i80386\n");
						break;
					case 13:
						fprintf(debugfile,"DMS CPU type of creator: i80486\n");
						break;
					case 14:
						fprintf(debugfile,"DMS CPU type of creator: i80586\n");
						break;
					default:
						fprintf(debugfile,"DMS CPU type of creator: unknown\n");
						break;
				}
				switch(dmscopro) {
					case 0:
						fprintf(debugfile,"DMS Math Coprocessor type of creator: None\n");
						break;
					case 1:
						fprintf(debugfile,"DMS Math Coprocessor type of creator: M68881\n");
						break;
					case 2:
						fprintf(debugfile,"DMS Math Coprocessor type of creator: M68882\n");
						break;
					case 3:
						fprintf(debugfile,"DMS Math Coprocessor type of creator: i8087\n");
						break;
					case 4:
						fprintf(debugfile,"DMS Math Coprocessor type of creator: i80287SX\n");
						break;
					case 5:
						fprintf(debugfile,"DMS Math Coprocessor type of creator: i80387\n");
						break;
					default:
						fprintf(debugfile,"DMS Math Coprocessor type of creator: unknown\n");
						break;
				}
				switch(dmsmachine) {
					case 0:
						fprintf(debugfile,"DMS Machine type of creator: Unknown\n");
						break;
					case 1:
						fprintf(debugfile,"DMS Machine type of creator: Amiga\n");
						break;
					case 2:
						fprintf(debugfile,"DMS Machine type of creator: x86 Clone\n");
						break;
					case 3:
						fprintf(debugfile,"DMS Machine type of creator: Mac\n");
						break;
					case 4:
						fprintf(debugfile,"DMS Machine type of creator: Atari\n");
						break;
					default:
						fprintf(debugfile,"DMS Machine type of creator: Unknown\n");
						break;
				}
				switch(dmsextra) {
					case 0x8000:
						fprintf(debugfile,"DMS Machine of creator is AGA\n");
						break;

				}
				fprintf(debugfile,"DMS CPU speed of creator (approx) in Mhz: %d\n",dmscpuspeed);
			} // if debug print creator machine info

			dmscreatetime = (header[38]<<24)+(header[39]<<16)+(header[40]<<8)+header[41];
			if(debug)
				fprintf(debugfile,"DMS Time taken to create archive by creator: %u\n",dmscreatetime);

			dmscreateversion = (header[42]<<8)+header[43];
			dmsextractversion = (header[44]<<8)+header[45];

			if(debug) {
				fprintf(debugfile,"DMS version used to create this archive: %u\n",dmscreateversion);
				fprintf(debugfile,"DMS version required to extract this archive: %u\n",dmsextractversion);
			}

			dmsdisktype = (header[46]<<8)+header[47];
		
			if(debug) {
				switch(dmsdisktype) {
					case 0:
						fprintf(debugfile,"DMS Diskette type: Unknown, proceeding anyway\n");
						break;
					case 1:
						fprintf(debugfile,"DMS Diskette type: Amiga OFS\n");
						break;
					case 2:
						fprintf(debugfile,"DMS Diskette type: Amiga FFS, this program does not support non OFS floppies\n");
						return NULL;
						break;
					case 3:
						fprintf(debugfile,"DMS Diskette type: Amiga 3.0 International mode, this program does not support non OFS floppies\n");
						return NULL;
						break;
					case 4:
						fprintf(debugfile,"DMS Diskette type: Amiga 3.0 FFS International mode, this program does not support non OFS floppies\n");
						return NULL;
						break;
					case 5:
						fprintf(debugfile,"DMS Diskette type: Amiga 3.0 Dircache mode, this program does not support non OFS floppies\n");
						return NULL;
						break;
					case 6:
						fprintf(debugfile,"DMS Diskette type: Amiga 3.0 FFS Dircache mode, this program does not support non OFS floppies\n");
						return NULL;
						break;
					case 7:
						fprintf(debugfile,"DMS Diskette type: FMS (Filemasher) mode, this program does not support non OFS floppies\n");
						return NULL;
						break;
					default:
						fprintf(debugfile,"DMS Diskette type: Unknown, proceeding anyway\n");
						break;

				}
			}

			dmscrunchmode = (header[48]<<8) + header[49];
			dmsheadercrc = (header[50]<<8)+header[51];

			if(mycrc(header, 50) == dmsheadercrc) 
				fprintf(debugfile,"DMS header CRC is OK\n");
			else
				fprintf(debugfile,"DMS header CRC mismatch, changes are this is a damaged archive, continuing anyway\n");

			if(debug) {
				fprintf(debugfile,"DMS Header CRC: %u\n",dmsheadercrc);
			}
			// Print the crunch mode
			switch(dmscrunchmode) {
				case 0:
					fprintf(debugfile,"DMS crunch mode: No compression\n");
					break;
				case 1:
					fprintf(debugfile,"DMS crunch mode: Simple compression\n");
					break;
				case 2:
					fprintf(debugfile,"DMS crunch mode: Quick compression\n");
					break;
				case 3:
					fprintf(debugfile,"DMS crunch mode: Medium compression\n");
					break;
				case 4:
					fprintf(debugfile,"DMS crunch mode: Deep compression\n");
					break;
				case 5:
					fprintf(debugfile,"DMS crunch mode: Heavy (1) compression\n");
					break;
				case 6:
					fprintf(debugfile,"DMS crunch mode: Heavy (2) compression\n");
					break;
				case 7:
					fprintf(debugfile,"DMS crunch mode: Heavy (3) compression\n");
					break;
				case 8:
					fprintf(debugfile,"DMS crunch mode: Heavy (4) compression\n");
					break;
				case 9:
					fprintf(debugfile,"DMS crunch mode: Heavy (5) compression\n");
					break;
				default:
					fprintf(debugfile,"Unknown crunch mode used in DMSg\n");
					return NULL;
			}
			// Read the track headers and on and on until we're done..
			for(i=dmsstarttrack;i<=dmsendtrack;i++) {
				if((fread(trackheader,1,20,infile)) == 20)  {
					// Read the trackheader successfully, check if it's valid
					if(trackheader[0] == 'T' && trackheader[1] == 'R')  {
						if(debug) 
							fprintf(debugfile,"Valid track header on track %u, file position: 0x%lx\n",i,ftell(infile));
						// Get CRC of header
						trackcrc = (trackheader[18]<<8) + trackheader[19];
						// Get CRC of packed track
						trackpackcrc = (trackheader[16]<<8) + trackheader[17];
						// Get CRC of unpacked track
						trackunpackcrc = (trackheader[14]<<8) + trackheader[15];
						// Get flags
						trackcflags = trackheader[12];

						// Set flags accordingly
						trackcflag_noclear = trackcflags & 1;
						trackcflag_compressed = trackcflags & 2;
						trackcflag_rle = trackcflags & 4;

						// This is a valid trackheader, check if CRC is valid
						if( mycrc(trackheader, 18) == trackcrc) {
							if(debug)
								fprintf(debugfile,"\tTrack header CRC is OK\n");
							trackcurrent = (trackheader[2]<<8)+trackheader[3];
							if(trackcurrent != i) 
								fprintf(debugfile,"\tCurrent track, track header mismatch, current: %u header: %u\n",trackcurrent,i);
							else if(debug)
								fprintf(debugfile,"\tCurrent track OK, current: %u header: %u\n",trackcurrent,i);
							trackpacked = (trackheader[6]<<8)+trackheader[7];
							trackrlesize = (trackheader[8]<<8)+trackheader[9];
							trackunpacked = (trackheader[10]<<8)+trackheader[11];
							if(debug) {
									fprintf(debugfile,"\tPacked track size: %u, RLE size: %u, Unpacked size: %u\n",trackpacked,trackrlesize,trackunpacked);
									fprintf(debugfile,"\tTrack compression flags set: %u noclear: %u compressed: %u rle: %u\n",trackcflags,trackcflag_noclear,trackcflag_compressed,trackcflag_rle);
							}

							trackpackmode = trackheader[13]; 

							// Read in the packed bytes
							if((fread(pack_buffer,1,trackpacked,infile) == trackpacked) && mycrc(pack_buffer, trackpacked) == trackpackcrc) {
								// Managed to read in the packed bytes from the file
	
								// Deal with the decompression
								// This is in order of increasing compression, the simplest is just store encryption where there is no compression and no RLE encoding
								// Then there is just RLE, followed by quick, medium, deep, heavy and heavy 2 compression, there are further 3 options available in DMS which are not supported in this program, heavy(3), heavy(4) and heavy(5) 
				
								switch(trackpackmode) {
									case 0:
										if(debug)
											fprintf(debugfile,"\tTrack crunch mode: No compression\n");
										if(!crunch_store(unpack_buffer, unpack_buffer + trackrlesize,
											         pack_buffer, pack_buffer + trackunpacked,
												 debug,debugfile))
											buffer = unpack_buffer;
										break;
									case 1:
										if(debug)
											fprintf(debugfile,"\tDMS crunch mode: Simple compression\n");
										if(!crunch_rle(unpack_buffer, unpack_buffer + trackrlesize,
											       pack_buffer, pack_buffer + trackunpacked,
											       debug,debugfile))
											buffer=unpack_buffer;
										break;
									case 2:
										if(debug)
											fprintf(debugfile,"\tDMS crunch mode: Quick compression\n");
										if(!crunch_quick(pack_buffer, pack_buffer + trackpacked + 16,
											        unpack_buffer, unpack_buffer + trackrlesize,
												debug,debugfile,trackcflag_noclear))
											if(!crunch_rle(unpack_buffer, unpack_buffer + trackrlesize,
											               pack_buffer, pack_buffer + trackunpacked,
												       debug,debugfile))
												buffer=pack_buffer;
										break;
									case 3:
										if(debug)
											fprintf(debugfile,"\tDMS crunch mode: Medium compression\n");
										if(!crunch_medium(pack_buffer, pack_buffer + trackpacked + 16,
											        unpack_buffer, unpack_buffer + trackrlesize,
												debug,debugfile,trackcflag_noclear))
											if(!crunch_rle(unpack_buffer, unpack_buffer + trackrlesize,
											               pack_buffer, pack_buffer + trackunpacked,
												       debug,debugfile))
												buffer = pack_buffer;
										break;
									case 4:
										if(debug)
											fprintf(debugfile,"\tDMS crunch mode: Deep compression\n");

										if(!crunch_deep(pack_buffer, pack_buffer + trackpacked + 16,
											        unpack_buffer, unpack_buffer + trackrlesize,
												debug,debugfile,trackcflag_noclear))
											if(!crunch_rle(unpack_buffer, unpack_buffer + trackrlesize,
											               pack_buffer, pack_buffer + trackunpacked,
													debug,debugfile))
												buffer = pack_buffer;
										break;
									case 5:
										if(debug)
											fprintf(debugfile,"\tDMS crunch mode: Heavy (1) compression\n");
										// Decrunch, the track
										if(!crunch_heavy(pack_buffer, pack_buffer + trackpacked + 16, 
											        unpack_buffer, unpack_buffer + trackrlesize,
											        trackcflag_compressed, 13,
												debug,debugfile, trackcflag_noclear)) {	
											// If RLE is set, also use RLE
											if(trackcflag_rle) { 
												if(!crunch_rle(unpack_buffer, unpack_buffer + trackrlesize,
                                        							               pack_buffer, pack_buffer + trackunpacked,
													       debug,debugfile)) {
                          										buffer = pack_buffer;	
													if(debug)
														fprintf(debugfile,"\tBuffer is set to pack buffer\n");
												}
											} else {
												if(debug)
													fprintf(debugfile,"Buffer is set to unpack buffer\n");
												buffer = unpack_buffer;
											}
										} else {
											fprintf(debugfile,"Cannot heavy(2) decompress track %u\n",i);
											return NULL;
										}
										break;
									case 6:
										if(debug)
											fprintf(debugfile,"\tDMS crunch mode: Heavy (2) compression\n");
										// Decrunch, the track
										if(!crunch_heavy(pack_buffer, pack_buffer + trackpacked + 16, 
											        unpack_buffer, unpack_buffer + trackrlesize,
											        trackcflag_compressed, 14,
												debug,debugfile, trackcflag_noclear)) {	
											// If RLE is set, also use RLE
											if(trackcflag_rle) { 
												if(!crunch_rle(unpack_buffer, unpack_buffer + trackrlesize,
                                        							               pack_buffer, pack_buffer + trackunpacked,
													       debug,debugfile)) {
                          										buffer = pack_buffer;	
													if(debug)
														fprintf(debugfile,"\tBuffer is set to pack buffer\n");
												}
											} else {
												if(debug)
													fprintf(debugfile,"Buffer is set to unpack buffer\n");
												buffer = unpack_buffer;
											}
										} else {
											fprintf(debugfile,"Cannot heavy(2) decompress track %u\n",i);
											return NULL;
										}
										break;
									case 7:
										if(debug)
											fprintf(debugfile,"\tDMS crunch mode: Heavy (3) compression\n");

										fprintf(stderr,"Heavy(3) compression not supported\n");
										return NULL;
										break;
									case 8:
										if(debug)
											fprintf(debugfile,"\tDMS crunch mode: Heavy (4) compression\n");
										fprintf(stderr,"Heavy(4) compression not supported\n");
										return NULL;
										break;
									case 9:
										if(debug)
											fprintf(debugfile,"\tDMS crunch mode: Heavy (5) compression\n");
										fprintf(stderr,"Heavy(5) compression not supported\n");
										return NULL;
										break;
									default:
										fprintf(debugfile,"Unknown crunch mode used in DMS\n");
										return NULL;
								}
								// Verify CRC of unpacked track vs unpack CRC
								if(mysimplecrc(buffer,trackunpacked) == trackunpackcrc) {
									// Unpack CRC is okay, track was unpacked succesfully
									if(debug)
										fprintf(debugfile,"\tUnpack CRC: %u Trackheader unpack CRC: %u\n",mysimplecrc(buffer,trackunpacked),trackunpackcrc);
									// Write track and buffer to outfile
									if(fwrite(buffer,1,trackunpacked,outfile) != trackunpacked) {
										fprintf(debugfile,"Cannot write to outputfile, exiting\n");
										return NULL;
									} else if(debug) {
										fprintf(debugfile,"\tSuccessfully wrote track %u, output file offset: %lx\n",i,ftell(outfile));
									}
								} else {
									fprintf(debugfile,"Unpack CRC does not match, header: %u, actual: %u, uncrunch or file error\n",trackunpackcrc,mysimplecrc(buffer,trackunpacked));
									return NULL;
								}
							} else {
								fprintf(debugfile,"Can't read packed bytes from DMS file or CRC error, file is probably corrupt\n");
							}
						} else {
							fprintf(debugfile,"Track header CRC on track %u is invalid\n",i);
							if(debug)
								fprintf(debugfile,"Track header CRC: %u Calculated CRC: %u\n",((trackheader[18]<<8)+trackheader[19]),mycrc(trackheader, 18));
						}
					} else {
						fprintf(debugfile,"Corrupt track header %u from DMS file\n",i);
						return NULL;
					}
				} else {
					fprintf(debugfile,"Error reading track %u from DMS file\n",i);
					return NULL;
				}
			}
		} else {
			fprintf(stderr,"File is not a valid DMS file or header is corrupt\n");
			return NULL;
		}	
	} else {
		fprintf(stderr,"Inputfile is not valid\n");
		// Input file is not valid
		return NULL;
	}

	// If we reached here the file is uncompressed...
	// Close the input file
	fclose(infile);
	// Seek to 0 in the temporary file before returning
	rewind(outfile);
	// Free time struct
	free(dmstime);
	//  Return filepointer
	return outfile;
} // End function undmsfile


int main(int argc,char **argv) {
	// The Filepointer used to write the file to the disk
	FILE *f;
	// Temporary variables
	int i=0; int j=0; int n=0;
	// Type of file, 0 is unset (determined by filename, or exit if unsuccesful)
	int format=0;
	// A integer to store whether the file is an orphan
	int orphan = 0;
	// A integer to store whether the filename or parent path name is a legal string
	int invalidstring=0; int invalidparentstring=0;
	// A integer to store the header key
	uint32_t type, header_key;
	// To store the name of the file
	char *filename;
	// To store the extension of the file
	char *extension;
	/* Generate a array of strings to store the filepath and each directory name used in it */
	char **filepath;
	// We also need three arrays of uint32_t to store the days, minutes and ticks timestamps of the directories
	uint32_t days[MAX_PATH_DEPTH];
	uint32_t minutes[MAX_PATH_DEPTH];
	uint32_t ticks[MAX_PATH_DEPTH];
	// Array to keep track of orphaned sectors
	int *orphansector;
	// Array to keep track of orphan filenames
	char **orphanfilename;
	// Arrays to keep track of days, minutes and tick for orphans
	uint32_t orphandays[MAX_SECTORS];
	uint32_t orphanminutes[MAX_SECTORS];
	uint32_t orphanticks[MAX_SECTORS];
	// Variables to temporarily store orphandays, minutes and ticks
	uint32_t orphanday = 0;
	uint32_t orphanminute = 0;
	uint32_t orphantick = 0;
	// Time struct to store access and mod times
	struct utimbuf *utim;
	utim=malloc(sizeof(struct utimbuf));
	// A string to store the previous filepath, used for orphaned files
	char previousfilepath[MAX_FILENAME_LENGTH] = "";
	// Strings for orphan string splitting
	char *orphansplit = malloc(MAX_FILENAME_LENGTH +1 * sizeof(char *));
	/* A integer to store the root and orphan directories */
	int root = 0; int orphandir = 0;
	/* A integer to hold the start sector, defaults to the defined value FIRST_SECTOR */
	int startsector = FIRST_SECTOR;
	/* A integer to hold the last sector, defaults to the defined value SECTORS */
	unsigned int endsector = SECTORS;
	/* Variable to hold the debugging value */
	int debug = DEBUG;
	// int to read option value from getopt and a temp variable to read in the option index
        int optionflag; int index = 0;
	// File descriptor used either for the outfile, or set as stdout
        FILE *outfile = NULL;
	// Boolean to check whether system is big or little endian
	short bigendian = 1;
	// Allocate space for filename and extension
	filename = malloc(MAX_FILENAME_LENGTH + 1 * sizeof(char *));
	extension = malloc(MAX_FILENAME_LENGTH + 1 * sizeof(char *));
	/* Allocate space for MAX_PATH_DEPTH rows in filepath[X][] */
	filepath = malloc(MAX_PATH_DEPTH * sizeof(char *));
	if(filepath == NULL) {
		fprintf(stderr, "Out of memory\n");
		return 1;
	}
	// Alloc and init the filepath array
	for(i = 0; i < MAX_PATH_DEPTH ; i++) {
		/* Allocate space for MAX_AMIGADOS_FILENAME_LENGTH entries in filepath[X][Y] */
		filepath[i] = malloc(MAX_AMIGADOS_FILENAME_LENGTH * sizeof(char));
		if(filepath[i] == NULL) {
			fprintf(stderr, "Out of memory\n");
			return 1;
		}
		snprintf(filepath[i],MAX_AMIGADOS_FILENAME_LENGTH,"");
	}
	// Alloc and init the orphanfilename array as well as the orphan day, minutes, seconds array
	orphanfilename = malloc(MAX_SECTORS * sizeof(char *));
	for(i = 0; i<MAX_SECTORS; i++) {
		orphanfilename[i] = malloc(MAX_FILENAME_LENGTH * sizeof(char));
		if(orphanfilename[i] == NULL) {
			fprintf(stderr, "Out of memory\n");
			return 1;
		}
		snprintf(orphanfilename[i],MAX_FILENAME_LENGTH,"");
		orphandays[i] = 0;
		orphanminutes[i] = 0;
		orphanticks[i] = 0;
	}
	
	// Malloc and init Init the orphansector array, all sectors are not orphans to start with
	orphansector = malloc(MAX_SECTORS * sizeof(*orphansector));
	for(i = 0; i<MAX_SECTORS ; i++) {
		orphansector[i]=0;
	}

	// Check for endianness
	uint8_t swaptest[2] = {1,0};
	if ( *(short *)swaptest == 1) 
    		bigendian = 0;

	// Read the passed options if any (-d sets debug, -o sets an optional filename to pipe the output to)
        while((optionflag = getopt(argc, argv, "adzDo:s:e:")) != -1) 
		switch(optionflag) {
			// ADF format forced
			case 'a':
				format=1;
				break;
			// ADZ format forced
			case 'z':
				format=2;
				break;
			// DMS format forced
			case 'd':
				format=3;
				break;
                        // Debug flag is set to on
                        case 'D':
                                debug=1;
                                break;
                        // Output file flag is specified
                        case 'o':
                                outfile = fopen(optarg,"w");
                                // If output file didn't open, error occured, print error, exit
                                if(outfile == NULL) {
                                        fprintf(stderr,"Can't open output file %s for writing, error returned was: %s\n",optarg,strerror(errno));
                                        return 1;
                                } else {
                                        // Announce that we're writing the output to a file on stdout
                                        fprintf(stdout,"Writing output to %s\n",optarg);
                                }
                                break;
			// Start sector is specified
			case 's':
				i=strtoimax(optarg,NULL,10);
				// Not an integer or value over 3520 (last sector on a HD adf), print usage
				if(i>3520 || i <0 || i>endsector) {
					usage(argv[0]);
					return 2;
				// Otherwise set the start sector
				} else {
					startsector = i;
				}
				break;
			case 'e':		
				i=strtoimax(optarg,NULL,10);
				// Not an integer or value over 3520 (last sector on a HD adf), print usage
				if(i>3520 || i <0 || i<startsector) {
					usage(argv[0]);
					return 2;
				// Otherwise set the end sector
				} else {
					endsector = i;
				}
				break;
                        // Missing argument to o,s or e
                        case '?':
                                usage(argv[0]);
                                return 2;
                                break;
                }
	// Check if outfile is set, if not set outfile as stdout
	if(outfile == NULL)
		outfile=stdout;
	if(debug) {
		if(format==0)
			fprintf(outfile,"File format is not set!\n");
		else if(format==1) 
			fprintf(outfile,"File format is ADF\n");
		else if(format==2) 
			fprintf(outfile,"File format is ADZ\n");
		else if(format==3) 
			fprintf(outfile,"File format is DMS\n");
	}
	// The filename should be the last non-option argument given
	for (index = optind; index < argc; index++) {
		// Copy argument into the filename variable
		snprintf(filename,MAX_FILENAME_LENGTH-1,"%s",argv[index]);
		// Try opening the file for reading...
		f = fopen(filename,"r");
		if(f == NULL) {
			fprintf(stderr,"Can't open file %s for reading, error returned was: %s\n",filename,strerror(errno));
			return 1;
		} else {
			// Close the file for now
			fclose(f);			
			// If format not already set, determine format from file ending
			if(!format) {
				if(debug)
					fprintf(outfile,"Input filename is %s\n",argv[index]);
				// Get the extension of the file
				extension = strrchr(argv[index],'.');
				// No extension, assume ADF
				if(extension == NULL)  {
					fprintf(outfile,"No file extension, assuming ADF");
					format=1;
				} else {
					if(debug)
						fprintf(outfile,"Extension is %s\n",extension);
					// Lowercase the extension
					for (i = 0; extension[i] != '\0'; i++)
					    extension[i] = (char)tolower(extension[i]);
					if(debug)
						fprintf(outfile,"Extension lowercase is %s\n",extension);
					// Reset i
					i=0;
					// Is this an adf file?
					if(strncmp(".adf",extension,MAX_FILENAME_LENGTH) == 0) {
						format=1;
						fprintf(outfile,"Autodetected fileformat from extension is ADF\n");
					// or an adz file?
					} else if(strncmp(".adz",extension,MAX_FILENAME_LENGTH) == 0) {
						format=2;
						fprintf(outfile,"Autodetected fileformat from extension is ADZ (.adz)\n");
					// or an adf.gz file (same thing as an adz, but perhaps more *nix like)
					} else if(strncmp(".adf.gz",extension,MAX_FILENAME_LENGTH) == 0) {
						format=2;
						fprintf(outfile,"Autodetected fileformat from extension is ADZ (.adf.gz)\n");
					// or a zip file (this will also work since there's support in the adz decompression code to skip the zip header)
					} else if(strncmp(".zip",extension,MAX_FILENAME_LENGTH) == 0) {
						format=2;
						fprintf(outfile,"Autodetected fileformat from extension is ZIP (.zip)\n");
					// or a DMS file
					} else if(strncmp(".dms",extension,MAX_FILENAME_LENGTH) == 0) {
						format=3;
						fprintf(outfile,"Autodetected fileformat from extension is DMS (.dms)\n");
					// Otherwise have no idea what it is and we'll assume it's an adf
					} else {
						fprintf(outfile,"Can not figure out file format from file extension, assuming ADF");
						format=1;
					}
				}
			}
		}
	}
	// No file given, print usage instructions
	if(f == NULL) {
		usage(argv[0]);
		return 2;
	}
	// Define and allocate memory for the sectors
	union sector *sector = malloc((endsector+1)*sizeof(union sector));
	
	// Print start and end sector
	fprintf(outfile,"Startsector is %d\n",startsector);
	fprintf(outfile,"Endsector is %d\n",endsector);

	// Integer to hold total sectors read..
	int r=0;

	// How we fill up the sector array depends on the file format
	switch(format) {
		// Simplest case, simple uncompressed ADF file, we can simply read the sectors directly into an array...
		case 1:
			// Open the ADF file
			f=fopen(filename,"r");
			// If Null exit
			if(f == NULL) {
				fprintf(stderr,"Can't open file %s for reading, error returned was: %s\n",filename,strerror(errno));
				return 1;
			}
			break;
		case 2:
			#ifdef _HAVE_ZLIB
			// Uncompress the adf file and get a pointer to the open file
			f=uncompressfile(filename,debug,outfile);
			// If we get null back (TODO, would be good to do more error checking here)
			if(f == NULL) {
				fprintf(stderr,"Can't uncompress file %s\n",filename);
				return 1;
			}
			break;
			#else
			fprintf(outfile,"No zlib support, try changing _HAVE_ZLIB define and compiling with -lz\n");
			return 1;
			break;
			#endif
		case 3:
			// Decrunch DMS file and write to temporary raw file which we'll use to extract from
			if(debug)
				fprintf(outfile,"Decoding DMS file\n");
			f=undmsfile(filename,endsector,debug,outfile);
			if(f == NULL) {
				fprintf(stderr,"Fatal error, exiting\n");
				return 1;
			}
			break;
		default:
			// We've reached here and the format is not clear, print error and exit
			fprintf(outfile,"No format selected, don't know what to do, exiting\n");
			return 1;
			break;
	}
	// Read from the file (which is in the ADF sector format regardless of what the input file was) into the sector array
	r= fread(sector, sizeof(union sector), endsector, f);
	if(debug)
		fprintf(outfile,"Total sectors: %d\n\n", r);

	// Not enough sectors read?
	if(r < (endsector-startsector)) {
		fprintf(stderr,"Only managed to read %d sectors out of %d requested, cowardly refusing to continue\n",r,(endsector-startsector));
		return 1;
	}
	// Close the file
	fclose(f);


	// Loop through the sectors we are supposed to read and recover the data
	for (i=startsector; i<endsector; i++) {
		if(bigendian)
			type = sector[i].hdr.type;
		else
			type = ntohl(sector[i].hdr.type);
		if (type != T_HEADER && type != T_DATA && type != T_LIST)
			continue;
		if(debug) {
			if(bigendian) {
				fprintf(outfile,"%x: type       %x\n", i, sector[i].hdr.type);
				fprintf(outfile,"%x: header_key %x\n", i, sector[i].hdr.header_key);
				fprintf(outfile,"%x: seq_num    %x\n", i, sector[i].hdr.seq_num);
				fprintf(outfile,"%x: data_size  %x\n", i, sector[i].hdr.data_size);
				fprintf(outfile,"%x: next_data  %x\n", i, sector[i].hdr.next_data);
				fprintf(outfile,"%x: chksum     %x\n", i, sector[i].hdr.chksum);
			} else {
				fprintf(outfile,"%x: type       %x\n", i, ntohl(sector[i].hdr.type));
				fprintf(outfile,"%x: header_key %x\n", i, ntohl(sector[i].hdr.header_key));
				fprintf(outfile,"%x: seq_num    %x\n", i, ntohl(sector[i].hdr.seq_num));
				fprintf(outfile,"%x: data_size  %x\n", i, ntohl(sector[i].hdr.data_size));
				fprintf(outfile,"%x: next_data  %x\n", i, ntohl(sector[i].hdr.next_data));
				fprintf(outfile,"%x: chksum     %x\n", i, ntohl(sector[i].hdr.chksum));
			}
		}
		switch (type) {
			case T_HEADER:
				if(bigendian)
					header_key=sector[i].hdr.header_key;
				else
					header_key=ntohl(sector[i].hdr.header_key);
				if(debug) {
					fprintf(outfile,"%x:  filename  \"%s\"\n", i, sector[i].fh.filename);
					if(bigendian) 
						fprintf(outfile,"%x:  byte_size %d\n", i, sector[i].fh.byte_size);
					else 
						fprintf(outfile,"%x:  byte_size %d\n", i, ntohl(sector[i].fh.byte_size));
					
				}
				// Set n here as the header key of the current sector, we'll use it to find all parent headers so we can re-create the directory structure of the disk
				n=i;
				// J is used here to reverse the directory structure (from the disk root and downwards) 
				j=0;
				while(n >= 0) {
					// Add the current filename to the array of paths
					snprintf(filepath[j],MAX_AMIGADOS_FILENAME_LENGTH,"%s",sector[n].fh.filename);
					//  Also store days, minutes and ticks to recreate the correct date and time of the files
					if(bigendian) {
						days[j] = sector[n].fh.days;
						minutes[j] = sector[n].fh.mins;
						ticks[j] = sector[n].fh.ticks;
					} else { 
						days[j] = ntohl(sector[n].fh.days);
						minutes[j] = ntohl(sector[n].fh.mins);
						ticks[j] = ntohl(sector[n].fh.ticks);
					}
					
					if(debug) {
						fprintf(outfile,"N: %d I: %d J: %d Current object is %s\n",n,i,j,sector[n].fh.filename);
						if(bigendian)
							fprintf(outfile,"Parent object is %s\n",sector[sector[n].fh.parent].fh.filename);
						else
							fprintf(outfile,"Parent object is %s\n",sector[ntohl(sector[n].fh.parent)].fh.filename);
					}
					// If the current path is the root sector we don't need more iterations	
					if(n == 880) {
						if(debug)
							fprintf(outfile,"Parent is root block 880, stopping this loop\n");
						break;
					} else if(!sector[n].fh.parent) {
						// No parent object, leave the loop
						break;
					} else {
						// Increment j since the path length is increasing
						j++;
					}
					// Set n as the parent to recurse backwards
					if(bigendian)
						n = sector[n].fh.parent;
					else
						n = ntohl(sector[n].fh.parent);
				}
				// We should now have an array of all the filepaths belonging to this header, we'll now re-create all the directories in that path (we might do this multiple times for the top level directories but there is no harm in that)
				// Open the current directory so we can return to it later
				root = open(".",O_RDONLY);
				if(root == -1 ) {
					fprintf(stderr,"Can't write to root directory, exiting\n");
					return 1;
				}
				// Make a directory for orphaned files and directories, ignore if it already exists but stop on other errors
				if(mkdir("Orphaned",0777) > 0 && errno != EEXIST) 
					fprintf(stderr,"Can't create directory in current path, check permissions\n");

				chdir("Orphaned");
				// Save the orphandir so we cacn return laer
				orphandir = open(".",O_RDONLY);
				if(orphandir == -1 ) {
					fprintf(stderr,"Can't write to orphan directory, exiting\n");
					return 1;
				}
				
				// Change back to root directory
				fchdir(root);
				// Reverse loop through the filepath to change into the correct directory to output the file 
				// filepath for this file other than the root filepath
				for(n=j;n>0;n--) {
					// If we can't create the directory, and it's not because it already exists 
					// That will happen quite a bit since this code is executed once per block, 
					// and the same file (and directory) can be passed over hundreds of times. 
					// This isn't very efficient, but it does work.
					if(mkdir(filepath[n],0777) < 0 && errno != EEXIST) {
						fprintf(stderr,"Can't create directory %s, exiting\n",filepath[n]);
					} else {
						if(debug)
							fprintf(outfile,"Created directory %s\n",filepath[n]);
						// Set correct timestamp for directory
						utime(filepath[n],amigadaystoutimbuf(days[n],minutes[n],ticks[n],utim));
						// Change directory to the newly created directory
						if(chdir(filepath[n]) == -1) {
							// There is a chance, there's a filename that's the same as the name of the directory we're trying to create, in that case this is most likely
							// an orphaned directory (there can't be a directory and a file with the same name in the same directory so that means one of the entries is corrupted,
							// an orphaned file would never have been created under the restored directory structure, but rather at the root level, so there is a high probability
							// that this directory is an orphan, in which case we should place it at the root level, like an orphaned file
							// Return to the root directory
							if(fchdir(orphandir) == -1) {
								fprintf(stderr,"Can't return to previous working directory, exiting\n");
								return 1;
							} 
							// Try to create the directory at the root level instead of down the filesystem level
							if(mkdir(filepath[n],0777) < 0 && errno != EEXIST) {
								fprintf(stderr,"Can't create directory %s\n",filepath[n]);
							} else {
								if(debug)
									fprintf(outfile,"Created Orphaned directory %s\n",filepath[n]);
								// Set correct timestamp for directory
								utime(filepath[n],amigadaystoutimbuf(days[n],minutes[n],ticks[n],utim));
								// Change directory to the newly created directory
								if(chdir(filepath[n]) == -1) {
									fprintf(stderr,"Can't change to newly created directory, exiting\n");
									return 1;
								} else { 
									if(debug)
										fprintf(outfile,"Changing directory to %s\n",filepath[n]);
								}
							}
						}
					}
				}
				// Here we "touch" the file name this header belongs to, to create the file on the filesystem, in some cases there are no surviving data entries in which case
				// the file won't be created, since we want to know about every file that is there, even if none of it is recoverable, we'll create the file here
				// First we check whether the entry is 0 bytes, if it is, then it's very likely that it's a directory entry and not a file entry
				// If it really is a file entry, and it is 0 bytes, and it is orphaned, then we're out of luck, if the file is okay (even though it's 0 bytes), it will be created later 
				// This should hopefully make the work of puzzling together the structure relatively easy
				if(((ntohl(sector[i].fh.byte_size) == 0) && !bigendian) || (bigendian && (sector[i].fh.byte_size == 0))) {
					// Make a directory for this entry instead
					if(mkdir(sector[i].fh.filename,0777) < 0 && errno != EEXIST) 
						fprintf(stderr,"Can't create directory %s\n",sector[i].fh.filename);
					else {
						if(bigendian)
							// Set correct timestamp for directory
							utime(sector[i].fh.filename,amigadaystoutimbuf(sector[i].fh.days,sector[i].fh.mins,sector[i].fh.ticks,utim));
						else
							utime(sector[i].fh.filename,amigadaystoutimbuf(ntohl(sector[i].fh.days),ntohl(sector[i].fh.mins),ntohl(sector[i].fh.ticks),utim));
					}
				} else {
					// Make a file for this entry (empty)
					f = fopen(sector[i].fh.filename, "r+"); /* try to open existing file, if it already exists we won't need to creqte it */
					if (!f) 
						f = fopen(sector[i].fh.filename, "w"); /* doesn't exist, so create */
					// Close the file again
					fclose(f);
					// Modify the timestamp
					if(bigendian)
						// Set correct timestamp for directory
						utime(sector[i].fh.filename,amigadaystoutimbuf(sector[i].fh.days,sector[i].fh.mins,sector[i].fh.ticks,utim));
					else
						utime(sector[i].fh.filename,amigadaystoutimbuf(ntohl(sector[i].fh.days),ntohl(sector[i].fh.mins),ntohl(sector[i].fh.ticks),utim));
				}
				// Return to the previous working directory
				if(fchdir(root) == -1) {
					fprintf(stderr,"Can't return to previous working directory, exiting\n");
					return 1;
				} 
				// Close the previously opened working directories
				close(root);
				close(orphandir);
				// Leave this sector
				break;
			case T_DATA:
				if( (!bigendian && (ntohl(sector[i].hdr.header_key % 32 != 0))) || (bigendian && (sector[i].hdr.header_key % 32 != 0)))
					continue;
				if(bigendian)
					header_key = sector[i].hdr.header_key;
				else
					header_key = ntohl(sector[i].hdr.header_key);
				if (header_key<SECTORS && ( (!bigendian && (ntohl(sector[header_key].hdr.type) == T_HEADER)) || (bigendian && (sector[header_key].hdr.type == T_HEADER)))) {
					if(debug) {
						fprintf(outfile,"%x:  filename  \"%s\"\n", i, sector[header_key].fh.filename);
						if(bigendian)
							fprintf(outfile,"%x:  byte_size %d\n", i, sector[header_key].fh.byte_size);
						else
							fprintf(outfile,"%x:  byte_size %d\n", i, ntohl(sector[header_key].fh.byte_size));
					}
					snprintf(filename,MAX_AMIGADOS_FILENAME_LENGTH,"%s",sector[header_key].fh.filename);
					orphan = 0;
				} else {
					if(debug) {
						fprintf(outfile,"Orphaned file found at header key %d previous orphansector value: %d\n",header_key,orphansector[header_key]);
						fprintf(outfile,"%x:  filename  \"%s\"\n", i, sector[header_key].fh.filename);
						if(bigendian)
							fprintf(outfile,"%x:  byte_size %d\n", i, sector[header_key].fh.byte_size);
						else
							fprintf(outfile,"%x:  byte_size %d\n", i, ntohl(sector[header_key].fh.byte_size));
					}
					// Defaults for days, minutes, ticks if nothing else is readable, date will be set as 1978-01-01 
					orphanday = 0;
					orphanminute = 0;
					orphantick = 0; 
					// Check whether we've come across this orphaned file before and given it a name, if so we'll keep that name so that we don't write to many different files
					if(orphansector[header_key]) {
						// Fetch the filename from the orphanfilename array
						snprintf(filename,MAX_FILENAME_LENGTH,"%s",orphanfilename[header_key]);
						// Fetch days, minutes, ticks from orphandays/minutes/ticks arrays
						orphanday=orphandays[header_key];
						orphanminute=orphanminutes[header_key];
						orphantick=orphanticks[header_key];
						// Mark this file as an orphan so it gets placed in the Orphaned directory
						orphan=1;
						if(debug) 
							fprintf(outfile,"This orphan already has a filename selected, it is %s\n",filename);
					} else {
						// This is the first time we've come across this orphaned file
						// If this file is an orphan, the filename might not be a legal string since it might be corrupted so we setup some variables to check whether that is the cause to avoid crashes
						invalidstring=0; invalidparentstring=0;
						// Check whether there are invalid characters in the filename string and mark it as invalid if there are
						for(n=0;n<sizeof(sector[header_key].fh.filename)/sizeof(sector[header_key].fh.filename[0]);n++) {
								if((((unsigned char)sector[header_key].fh.filename[n] <32) && (unsigned char)sector[header_key].fh.filename[n] > 0) || (unsigned char)sector[header_key].fh.filename[n] ==47 || ((unsigned char)sector[header_key].fh.filename[n] >127 && (unsigned char)sector[header_key].fh.filename[n] < 161))
								invalidstring=1;
						}
						// If the filename is longer than the max_filename_length or it's empty, then it's invalid
						if(strlen(sector[header_key].fh.filename) > MAX_AMIGADOS_FILENAME_LENGTH || strlen(sector[header_key].fh.filename) ==  0)
							invalidstring=1;
						// Check whether there is a filepath still stored from a previous run if so we'll use that instead of the filename
						if(strlen(previousfilepath) > 0) {
							invalidstring=1;
						}
						// Extra boundary check here to verify that we have a valid parent index, it's possible that the parent number is corrupt
						if(bigendian) {
					
							if(sector[header_key].fh.parent && (sector[header_key].fh.parent % 32) == 0 && sector[header_key].fh.parent < endsector) {
								// Check whether there are invalid characters in the parent filename string and mark it as invalid if there are
								for(n=0;n<sizeof(sector[sector[header_key].fh.parent].fh.filename)/sizeof(sector[sector[header_key].fh.parent].fh.filename[0]);n++) {
									if((((unsigned char)sector[sector[header_key].fh.parent].fh.filename[n] <32) && (unsigned char)sector[sector[header_key].fh.parent].fh.filename[n] > 0) || (unsigned char)sector[sector[header_key].fh.parent].fh.filename[n] ==47 || ((unsigned char)sector[sector[header_key].fh.parent].fh.filename[n] >127 && (unsigned char)sector[sector[header_key].fh.parent].fh.filename[n] < 161))
										invalidparentstring=1;
								}
								// If the parent filename is longer than the max_filename_length or it's empty, then it's invalid
								if(strlen(sector[sector[header_key].fh.parent].fh.filename) > MAX_AMIGADOS_FILENAME_LENGTH || strlen(sector[sector[header_key].fh.parent].fh.filename) == 0)
									invalidparentstring=1;
							// If there is no parent then we can't use that to construct the string
							} else {
								invalidparentstring=1;
							}
						} else {
							if(sector[header_key].fh.parent && (sector[header_key].fh.parent % 32) == 0 && sector[header_key].fh.parent < endsector) {
								// Check whether there are invalid characters in the parent filename string and mark it as invalid if there are
								for(n=0;n<sizeof(sector[sector[header_key].fh.parent].fh.filename)/sizeof(sector[sector[header_key].fh.parent].fh.filename[0]);n++) {
									if((((unsigned char)sector[sector[header_key].fh.parent].fh.filename[n] <32) && (unsigned char)sector[sector[header_key].fh.parent].fh.filename[n] > 0) || (unsigned char)sector[sector[header_key].fh.parent].fh.filename[n] ==47 || ((unsigned char)sector[sector[header_key].fh.parent].fh.filename[n] >127 && (unsigned char)sector[sector[header_key].fh.parent].fh.filename[n] < 161))
										invalidparentstring=1;
								}
								// If the parent filename is longer than the max_filename_length or it's empty, then it's invalid
								if(strlen(sector[sector[header_key].fh.parent].fh.filename) > MAX_AMIGADOS_FILENAME_LENGTH || strlen(sector[sector[header_key].fh.parent].fh.filename) == 0)
									invalidparentstring=1;
							// If there is no parent then we can't use that to construct the string
							} else {
								invalidparentstring=1;
							}
						}
						
						// If the filename string is good and the parent string is good, we'll use both (only one parent used here)
						if(!invalidstring && !invalidparentstring) {
							// Store days, minutes, ticks from file since it's available
							if(bigendian) {
								snprintf(filename, MAX_FILENAME_LENGTH,"Orphan-%d-%s-%s",header_key,sector[sector[header_key].fh.parent].fh.filename,sector[header_key].fh.filename);
								orphandays[header_key] = sector[header_key].fh.days;
								orphanminutes[header_key] = sector[header_key].fh.mins;
								orphanticks[header_key] = sector[header_key].fh.ticks;
								orphanday = sector[header_key].fh.days;
								orphanminute = sector[header_key].fh.mins;
								orphantick = sector[header_key].fh.ticks;
								if(sector[header_key].fh.parent == 880) {
									fprintf(outfile,"Parent er 880\n");
								}
							} else {
								snprintf(filename, MAX_FILENAME_LENGTH,"Orphan-%d-%s-%s",header_key,sector[ntohl(sector[header_key].fh.parent)].fh.filename,sector[header_key].fh.filename);
								orphandays[header_key] = ntohl(sector[header_key].fh.days);
								orphanminutes[header_key] = ntohl(sector[header_key].fh.mins);
								orphanticks[header_key] = ntohl(sector[header_key].fh.ticks);
								orphanday = ntohl(sector[header_key].fh.days);
								orphanminute = ntohl(sector[header_key].fh.mins);
								orphantick = ntohl(sector[header_key].fh.ticks);
								if(ntohl(sector[header_key].fh.parent) == 880) {
									fprintf(outfile,"Parent er 880\n");
								}
							}
						// Otherwise, if the filename string is good, but the parent string is not, we'll use that
						} else if(!invalidstring) {
							snprintf(filename, MAX_FILENAME_LENGTH,"Orphan-%d-%s",header_key,sector[header_key].fh.filename);
							// Store days, minutes, ticks from file since it's available
							if(bigendian) {
								orphandays[header_key] = sector[header_key].fh.days;
								orphanminutes[header_key] = sector[header_key].fh.mins;
								orphanticks[header_key] = sector[header_key].fh.ticks;
								orphanday = sector[header_key].fh.days;
								orphanminute = sector[header_key].fh.mins;
								orphantick = sector[header_key].fh.ticks;
							} else {
								orphandays[header_key] = ntohl(sector[header_key].fh.days);
								orphanminutes[header_key] = ntohl(sector[header_key].fh.mins);
								orphanticks[header_key] = ntohl(sector[header_key].fh.ticks);
								orphanday = ntohl(sector[header_key].fh.days);
								orphanminute = ntohl(sector[header_key].fh.mins);
								orphantick = ntohl(sector[header_key].fh.ticks);
							}
						// Otherwise, if the parent filepath is good, we'll use that
						} else if(!invalidparentstring) {
							// Store days, minutes, ticks from parent since that's all we have
							if(bigendian) {
								snprintf(filename, MAX_FILENAME_LENGTH,"Orphan-%d-%s",header_key,sector[sector[header_key].fh.parent].fh.filename);
								orphandays[header_key] = sector[ntohl(sector[header_key].fh.parent)].fh.days;
								orphanminutes[header_key] = sector[ntohl(sector[header_key].fh.parent)].fh.mins;
								orphanticks[header_key] = sector[ntohl(sector[header_key].fh.parent)].fh.ticks;
								orphanday = sector[ntohl(sector[header_key].fh.parent)].fh.days;
								orphanminute = sector[ntohl(sector[header_key].fh.parent)].fh.mins;
								orphantick = sector[ntohl(sector[header_key].fh.parent)].fh.ticks;
							} else {
								snprintf(filename, MAX_FILENAME_LENGTH,"Orphan-%d-%s",header_key,sector[ntohl(sector[header_key].fh.parent)].fh.filename);
								orphandays[header_key] = ntohl(sector[ntohl(sector[header_key].fh.parent)].fh.days);
								orphanminutes[header_key] = ntohl(sector[ntohl(sector[header_key].fh.parent)].fh.mins);
								orphanticks[header_key] = ntohl(sector[ntohl(sector[header_key].fh.parent)].fh.ticks);
								orphanday = ntohl(sector[ntohl(sector[header_key].fh.parent)].fh.days);
								orphanminute = ntohl(sector[ntohl(sector[header_key].fh.parent)].fh.mins);
								orphantick = ntohl(sector[ntohl(sector[header_key].fh.parent)].fh.ticks);
							}
						// Otherwise, if the previous filepath is good, we'll use that instead of the parent
						} else if(strlen(previousfilepath) > 0) {
							snprintf(filename, MAX_FILENAME_LENGTH,"Orphan-%s-%s",previousfilepath,previousfilepath);
						// Else we'll have to settle for just the header key value to identify the file since both the filename and parent filename strings are corrupt
						} else {
							snprintf(filename, MAX_FILENAME_LENGTH,"Orphan-%d-%d",header_key,header_key);
						}
						// Set the orphan flag to 1
						orphan = 1;
						// Mark this sector as an orphan so if we come across it again we'll use the same filename and dates
						orphansector[header_key] = 1;
						// And set the orphan filename to our current filename
						snprintf(orphanfilename[header_key],MAX_FILENAME_LENGTH,"%s",filename);
						if(debug) {
							if(!invalidstring && !invalidparentstring) {	
								if(bigendian)
									fprintf(outfile, "Filename:%s: Parent Filename: %s Orphan Filename: %s\n",sector[header_key].fh.filename,sector[sector[header_key].fh.parent].fh.filename,filename);
								else
									fprintf(outfile, "Filename:%s: Parent Filename: %s Orphan Filename: %s\n",sector[header_key].fh.filename,sector[ntohl(sector[header_key].fh.parent)].fh.filename,filename);
							} else if(!invalidstring) {
								fprintf(outfile, "Filename:%s: Orphan Filename: %s\n",sector[header_key].fh.filename,filename);
							} else if(!invalidparentstring) {
								if(bigendian)
									fprintf(outfile, "Parent Filename: %s Orphan Filename: %s\n",sector[sector[header_key].fh.parent].fh.filename,filename);
								else
									fprintf(outfile, "Parent Filename: %s Orphan Filename: %s\n",sector[ntohl(sector[header_key].fh.parent)].fh.filename,filename);
							} else if(strlen(previousfilepath) > 0) {
								fprintf(outfile, "Previous filepath: %s Orphan Filename: %s\n",previousfilepath,filename);
							} else {
								fprintf(outfile, "Orphan Filename: %s\n",filename);
							}
						}
					}
				}

				// Find the file path and put it into the filepath array
				j = 0; n=header_key;
				// If this is a regular file (has a regular filename, and a directory structure) as well as a valid parent find the path
				while( n != 0 && header_key<SECTORS && ( (!bigendian && (ntohl(sector[header_key].hdr.type) == T_HEADER)) || (bigendian && (sector[header_key].hdr.type == T_HEADER))) && (sector[n].fh.parent % 32) == 0) {
					if(sector[n].fh.parent && n != 880)  {
						//  Also store days, minutes and ticks to recreate the correct date and time of the files
						if(bigendian) {
							// Get the path entry name into the filepath array
							snprintf(filepath[j],MAX_AMIGADOS_FILENAME_LENGTH,"%s",sector[sector[n].fh.parent].fh.filename);
							days[j] = sector[n].fh.days;
							minutes[j] = sector[n].fh.mins;
							ticks[j] = sector[n].fh.ticks;
							// Set n as the parent to recurse backwards
							n = sector[n].fh.parent;
						} else { 
							// Get the path entry name into the filepath array
							snprintf(filepath[j],MAX_AMIGADOS_FILENAME_LENGTH,"%s",sector[ntohl(sector[n].fh.parent)].fh.filename);
							days[j] = ntohl(sector[n].fh.days);
							minutes[j] = ntohl(sector[n].fh.mins);
							ticks[j] = ntohl(sector[n].fh.ticks);
							// Set n as the parent to recurse backwards
							n = ntohl(sector[n].fh.parent);
						}
						if(debug)
							fprintf(outfile,"File belongs to Directory tree %d, found path %s\n",j,filepath[j]);
						// If the parent is the root sector we don't need more iterations	
						if(n == 880) {
							
							if(debug) {
								fprintf(outfile,"Parent is root block 880, stopping this loop\n");
							}
							break;
						} else {
							// Increment loop count by 1
							j++;
						}
					} else {
					 	break;
					}
				}
				// We should now have an array of all the filepaths belonging to this header, we'll now re-create all the directories in that path (we might do this multiple times for the top level directories but there is no harm in that)
				// Open the current directory so we can return to it later
				root = open(".",O_RDONLY);
				if(root == -1 ) {
					fprintf(stderr,"Can't write to root directory, exiting\n");
					return 1;
				}

				// Make a directory for orphaned files and directories, ignore if it already exists but stop on other errors
				if(mkdir("Orphaned",0777) > 0 && errno != EEXIST)
					fprintf(stderr,"Can't create directory in current path, check permissions\n");

				chdir("Orphaned");
				orphandir = open(".",O_RDONLY);
	
				if(orphandir == -1) {
					fprintf(stderr,"Can't write to orphan directory, exiting\n");
					return 1;
				}
				// Change back to root directory
				fchdir(root);

				// Struct we'll use for filestats
				struct stat st;
				// Integer to get error code from stat
				int staterr = 0;
				// Reverse loop through the filepath to change into the correct directory to output the file 
				// filepath for this file other than the root filepath, this will re-create directory structures of orphaned directories as well
				for(n=j;n>=0;n--) {
					// Recreate directory tree
					// That will happen quite a bit since this code is executed once per block, 
					// and the same file (and directory) can be passed over hundreds of times. 
					// If the filepath is NULL the parent directory is lost in the filesystem and we'll set it as orphaned
					if(filepath[n] != NULL) 
						staterr=stat(filepath[n],&st);
					else {
						// NULL filepaths get put into a directory in the root called Orphaned
						snprintf(filepath[n],9,"Orphaned");
						// Stat the orphaned directory
						staterr=stat(filepath[n],&st);
					}
					// File/Directory does not exist, let's create it
					if(staterr != -1 && S_ISDIR(st.st_mode) && !orphan) {
						if(debug)
							fprintf(outfile,"Directory %s already exists, not creating\n",filepath[n]);
						// Set correct timestamp for directory
						utime(filepath[n],amigadaystoutimbuf(days[n],minutes[n],ticks[n],utim));
						if(chdir(filepath[n])) 
							fprintf(outfile,"Can't CD to directory %s\n",filepath[n]);
						else
							if(debug)
								fprintf(outfile,"Changing directory to %s\n",filepath[n]);
					} else if(staterr != -1 && !S_ISDIR(st.st_mode) && st.st_size != 0 && !orphan) {
						if(debug)		
							fprintf(outfile,"File with same name as directory (%s) already exists and is not empty, cowardly refusing to delete it\n",filepath[n]);
					} else if(staterr != -1 && !S_ISDIR(st.st_mode) && st.st_size == 0 && !orphan) {
						if(remove(filepath[n])) {
							fprintf(outfile,"Cannot delete file %s, placing directory in orphanpath instead\n",filepath[n]);
							// Return to the previous working directory
							if(fchdir(root) == -1) {
								fprintf(stderr,"Can't return to previous working directory, exiting\n");
								return 1;
							}
						} else {
							if(debug)
								fprintf(outfile,"Deleted empty file %s to make room for directory of the same name\n",filepath[n]);
						}
						// Create directory
						if(mkdir(filepath[n],0777) < 0) {
							fprintf(outfile,"Can't create directory %s\n",filepath[n]);
						} else {
							if(debug)
								fprintf(outfile,"Created directory %s in place of file\n",filepath[n]);
							// Set correct timestamp for directory
							utime(filepath[n],amigadaystoutimbuf(days[n],minutes[n],ticks[n],utim));
							if(chdir(filepath[n])) {;
								fprintf(stderr,"Can't change to newly created directory, exiting\n");
								return 1;
							} else { 
								if(debug)
									fprintf(outfile,"Changing directory to %s\n",filepath[n]);
							}
						}
								
					} else if(staterr == -1 && errno == ENOENT && !orphan) {
						// Create directories for files
						if(mkdir(filepath[n],0777) < 0) {
							fprintf(outfile,"Can't create directory %s\n",filepath[n]);
						} else {
							if(debug)
								fprintf(outfile,"Created directory %s\n",filepath[n]);
							// Set correct timestamp for directory
							utime(filepath[n],amigadaystoutimbuf(days[n],minutes[n],ticks[n],utim));
							// Change directory to the newly created directory
							if(chdir(filepath[n]) == -1) {
								fprintf(stderr,"Can't change to newly created directory, exiting\n");
								return 1;
							} else { 
								if(debug)
									fprintf(outfile,"Changing directory to %s\n",filepath[n]);
							}
						}
					}
					
				}
				// Store the current filepath, this can help us realise where orphaned files belong
				if(filepath[0] && strlen(filepath[0]) > 0)
					snprintf(previousfilepath,MAX_AMIGADOS_FILENAME_LENGTH,"%s",filepath[0]);
				// If this is an orphan file we'll need to treat it a little differently, we can't fully recreate the path but we most likely have at least the parent directory
				if(orphan) {
					// Split the file 
					// Temporary variable for strsep
					char *orphanfilenamecopy = malloc(MAX_FILENAME_LENGTH*sizeof(char *));
					char *temp;
					// Copy the filename into the copy
					snprintf(orphanfilenamecopy,MAX_FILENAME_LENGTH,"%s",filename);
					// Variable to hold number of splits in the string
					int splits=0;
					// Store orphansplit before going into function
					temp=orphansplit;
					// Use strsep to split the string by -  (Orphan, Sector, Parent if there was a parent)
					while((orphansplit = strsep(&orphanfilenamecopy,"-")) != NULL && splits <2) {
						splits++;
					}
					// If there are 3 parts to the filename, there is a path component which either the last directory traversed or the parent directory of the orphaned file
					// then we can place the file in that path, making it easier to sort out which orphans belong in which directory (and therefore, what could be in the file)
					if(splits == 2) {
						// Return to the orphaned directory first
						if(fchdir(orphandir) == -1) {
							fprintf(stderr,"Can't return to previous working directory, exiting\n");
							return 1;
						}
						// Create a directory based on the path component of the oprhan
						if(mkdir(orphansplit,0777) < 0 && errno != EEXIST) {
							fprintf(stderr,"Can't create directory %s\n",orphansplit);
						} else {
							if(debug)
								fprintf(outfile,"Created orphan directory %s\n",orphansplit);
							// Set modification time
							//utime(orphansplit,amigadaystoutimbuf(orphanday,orphanminute,orphantick,utim));
							// Change directory to the newly created directory
							if(chdir(orphansplit) == -1) {
								fprintf(stderr,"Can't change to newly created directory,placing orphan in the root directory");
							} else 
								if(debug)
									fprintf(outfile,"Changing directory to orphaned %s\n",orphansplit);
						}
					} else {
						// Return to the previous working directory and place the file in the root
						if(fchdir(orphandir) == -1) {
							fprintf(stderr,"Can't return to previous working directory, exiting\n");
							return 1;
						}
					}
					// Restore orphansplit
					orphansplit=temp;
					// Free memory used by orphanfilenamecopy
					free(orphanfilenamecopy);
				}

					
					
				// Open the file for appending (in the current directory with the path intact)
				f = fopen(filename, "r+"); /* try to open existing file */
				if (!f) 
					f = fopen(filename, "w"); /* doesn't exist, so create */
				if(!f) {
					// File could already exist under the same name or even as a directory, try append the sector header to the filename and try again
					if(bigendian)
						snprintf(filename,MAX_AMIGADOS_FILENAME_LENGTH,"%s-%d",filename,sector[i].hdr.header_key);
					else
						snprintf(filename,MAX_AMIGADOS_FILENAME_LENGTH,"%s-%d",filename,ntohl(sector[i].hdr.header_key));
					f = fopen(filename, "w"); /* doesn't exist, so create */
					if(!f) 
						fprintf(stderr,"Can't create file, this is probably fatal!\n");
				}

				// Dumper function that dumps out ascii text, isn't really useful, only active if you enable debug
				if(debug == 8) {
					char outascii[21];
					char outhex[61];
					uint8_t c;
					for (j=0; j<sizeof(sector[i].dh.data)/sizeof(sector[i].dh.data[0]); j++) {
						// Every 20 characters print out the ascii and hex dump as well as a newline
						if(j%20 == 0u && j!= 0)  {
							fprintf(outfile,"%s %s\n",outascii,outhex);
							snprintf(outascii,sizeof(outascii),"");
							snprintf(outhex,sizeof(outhex),"");
						}
						// Collect the ascii and hex dumps into two seperate concatenated strings
						c=sector[i].dh.data[j];
						if (c>=32 && c<127) {
							snprintf(outascii,sizeof(outascii),"%s%c",outascii,c);
							snprintf(outhex,sizeof(outhex),"%s %02x",outhex,c);
						} else {
							snprintf(outascii,sizeof(outascii),"%s%c",outascii,'.');
							snprintf(outhex,sizeof(outhex),"%s %02x",outhex,c);
						}
					}
					fprintf(outfile,"debug done\n");
					// Print out the remaining characters
					fprintf(outfile,"%-20s %s\n",outascii,outhex);
					// End with a final newline
					fprintf(outfile,"\n");
				}
				// Write the content to the file
				if(debug) {
					if(bigendian)	
						fprintf(outfile,"Seek seq_num %02x : DATABYTES: %lu SEEKSET: %d \n",sector[i].hdr.seq_num,DATABYTES,SEEK_SET);
					else
						fprintf(outfile,"Seek seq_num %02x : DATABYTES: %lu SEEKSET: %d \n",ntohl(sector[i].hdr.seq_num),DATABYTES,SEEK_SET);
				}
				if(bigendian)
					fseek(f, (sector[i].hdr.seq_num-1)*DATABYTES, SEEK_SET);
				else
					fseek(f, (ntohl(sector[i].hdr.seq_num)-1)*DATABYTES, SEEK_SET);
				if(debug) {
					if(bigendian)
						fprintf(outfile,"seek to %ld\n",  (sector[i].hdr.seq_num-1)*DATABYTES);
					else
						fprintf(outfile,"seek to %ld\n",  (ntohl(sector[i].hdr.seq_num)-1)*DATABYTES);
				}
				if(bigendian)
					fwrite(sector[i].dh.data, sector[i].hdr.data_size, 1, f);
				else 
					fwrite(sector[i].dh.data, ntohl(sector[i].hdr.data_size), 1, f);
				// Close file
				fclose(f);
				// Set modification time based on the days/minutes/ticks timestamp of the original file
				if(bigendian) 
					utime(filename,amigadaystoutimbuf(sector[header_key].fh.days,sector[header_key].fh.mins,sector[header_key].fh.ticks,utim));
				else
					//All the stamps are in big-endian so need to be converted..
					utime(filename,amigadaystoutimbuf(ntohl(sector[header_key].fh.days),ntohl(sector[header_key].fh.mins),ntohl(sector[header_key].fh.ticks),utim));
				// Return to the previous working directory
				if(fchdir(root) == -1) {
					fprintf(stderr,"Can't return to previous working directory, exiting\n");
					return 1;
				}
				// Close the previously opened working directories
				close(root);
				close(orphandir);
		}
		if(debug)
			fprintf(outfile,"\n");
	}

	// Free the space allocated for the filepath array, in reverse order to the malloc obviously
	for(i=0; i< MAX_AMIGADOS_FILENAME_LENGTH; i++) {
		free(filepath[i]);
	}
	// Free the filepath array itself
	free(filepath);

	// Free the space allocated for the orphanfilename array, in reverse order to the malloc
	for(i=0; i<3520; i++) {
		free(orphanfilename[i]);
	}
	free(orphanfilename);

	// Free the space used by the orphansector array
	free(orphansector);

	// Free the space used by the sector array
	free(sector);

	// Free the time struct
	free(utim);

	// Free the orphansplit
	free(orphansplit);

	// Successful run	
	return 0;
	fprintf(stderr,"ermahgerdus\n");
}