/*
 * Copyright 2000-2004 by Hans Reiser, licensing governed by
 * reiserfsprogs/README
 */

#include "debugreiserfs.h"
#include <sys/resource.h>

#define print_usage_and_exit() die ("Usage: %s [-v] [-b filename] device\n\
-v		prints blocks number of every block unpacked\n\
-b filename	saves bitmap of blocks unpacked to filename\n\
-j filename     stores journal in the filename\n", argv[0]);

/* when super block gets unpacked for the first time - create a bitmap
   and mark in it what have been unpacked. Save that bitmap at the end */
reiserfs_bitmap_t *what_unpacked = 0;

int leaves, full;

int verbose = 0;

int Default_journal = 1;

static void unpack_offset(struct packed_item *pi, struct item_head *ih,
			  int blocksize)
{

	if (get_pi_mask(pi) & OFFSET_BITS_64) {
		__u64 v64;

		if (get_ih_key_format(ih) != KEY_FORMAT_2)
			die("unpack_offset: key format is not set or wrong");
		fread_le64(&v64);
		set_offset(KEY_FORMAT_2, &ih->ih_key, v64);
		return;
	}

	if (get_pi_mask(pi) & OFFSET_BITS_32) {
		__u32 v32;

		fread_le32(&v32);
		set_offset(get_ih_key_format(ih), &ih->ih_key, v32);
		return;
	}

	if ((get_pi_mask(pi) & DIR_ID) == 0
	    && (get_pi_mask(pi) & OBJECT_ID) == 0) {
		/* offset was not sent, as it can be calculated looking at the
		   previous item */
		if (is_stat_data_ih(ih - 1))
			set_offset(get_ih_key_format(ih), &ih->ih_key, 1);
		if (is_indirect_ih(ih - 1))
			set_offset(get_ih_key_format(ih), &ih->ih_key,
				   get_offset(&(ih - 1)->ih_key) +
				   get_bytes_number(ih - 1, blocksize));
	}
	// offset is 0
	return;
}

static void unpack_type(struct packed_item *pi, struct item_head *ih)
{
	set_type(get_ih_key_format(ih), &ih->ih_key, get_pi_type(pi));
	if (type_unknown(&ih->ih_key))
		reiserfs_panic("unpack_type: unknown type %d unpacked for %H\n",
			       get_pi_type(pi), ih);
}

/* direntry item comes in the following format:
   for each entry
      mask - 8 bits
      entry length - 16 bits
      entry itself
      deh_objectid - 32 bits
      	maybe deh_dir_id (32 bits)
	maybe gencounter (16)
	maybe deh_state (16)
*/
static void unpack_direntry(struct packed_item *pi, struct buffer_head *bh,
			    struct item_head *ih, hashf_t hash_func)
{
	__u16 entry_count, namelen, gen_counter, entry_len;
	__u8 mask;
	int i;
	struct reiserfs_de_head *deh;
	int location;
	char *item;

/*    if (!hash_func)
	die ("unpack_direntry: hash function is not set");*/

	if (!(get_pi_mask(pi) & IH_FREE_SPACE))
		die("ih_entry_count must be packed for directory items");

	entry_count = get_ih_entry_count(ih);
/*    if (!entry_count)
	reiserfs_panic ("unpack_direntry: entry count should be set already");*/

	item = bh->b_data + get_ih_location(ih);
	deh = (struct reiserfs_de_head *)item;
	location = get_pi_item_len(pi);
	for (i = 0; i < entry_count; i++, deh++) {
		fread8(&mask);
		fread_le16(&entry_len);
		location -= entry_len;
		set_deh_location(deh, location);
		fread(item + location, entry_len, 1, stdin);

		/* find name length */
		if (*(item + location + entry_len - 1))
			namelen = entry_len;
		else
			namelen = strlen(item + location);

		fread32(&deh->deh2_objectid);
		if (mask & HAS_DIR_ID)
			fread32(&deh->deh2_dir_id);
		else
			set_deh_dirid(deh, get_key_objectid(&ih->ih_key));

		if (*(item + location) == '.' && namelen == 1)
			/* old or new "." */
			set_deh_offset(deh, DOT_OFFSET);
		else if (*(item + location) == '.'
			 && *(item + location + 1) == '.' && namelen == 2)
			/* old or new ".." */
			set_deh_offset(deh, DOT_DOT_OFFSET);
		else if (hash_func)
			set_deh_offset(deh,
				       hash_value(hash_func, item + location,
						  namelen));
		if (mask & HAS_GEN_COUNTER) {
			fread_le16(&gen_counter);
			set_deh_offset(deh, get_deh_offset(deh) | gen_counter);
		}

		if (mask & HAS_STATE)
			fread16(&deh->deh2_state);
		else
			set_deh_state(deh, (1 << DEH_Visible2));
	}

	return;
}

/* struct packed_item is already unpacked */
static void unpack_stat_data(struct packed_item *pi, struct buffer_head *bh,
			     struct item_head *ih)
{
	if (!(get_pi_mask(pi) & IH_FREE_SPACE)) {
		/* ih_free_space was not packed - set default */
		set_ih_entry_count(ih, 0xffff);
	}

	if (get_ih_key_format(ih) == KEY_FORMAT_1) {
		/* stat data comes in the following format:
		   if this is old stat data:
		   mode - 16 bits
		   nlink - 16 bits
		   size - 32 bits
		   blocks/rdev - 32 bits
		   maybe first_direct byte 32 bits
		 */
		struct stat_data_v1 *sd;

		sd = (struct stat_data_v1 *)ih_item_body(bh, ih);
		memset(sd, 0, sizeof(sd));

		fread16(&sd->sd_mode);
		fread16(&sd->sd_nlink);
		fread32(&sd->sd_size);
		fread32(&sd->u.sd_blocks);

		if (get_pi_mask(pi) & WITH_SD_FIRST_DIRECT_BYTE) {
			fread32(&sd->sd_first_direct_byte);
		} else {
			sd->sd_first_direct_byte = 0xffffffff;
		}
	} else {
		/* for new stat data
		   mode - 16 bits
		   nlink in either 16 or 32 bits
		   size in either 32 or 64 bits
		   blocks - 32 bits
		 */
		struct stat_data *sd;

		sd = (struct stat_data *)ih_item_body(bh, ih);
		memset(sd, 0, sizeof(sd));

		fread16(&sd->sd_mode);

		if (get_pi_mask(pi) & NLINK_BITS_32) {
			fread32(&sd->sd_nlink);
		} else {
			__u16 nlink16;

			fread16(&nlink16);
			set_sd_v2_nlink(sd, le16_to_cpu(nlink16));
		}

		if (get_pi_mask(pi) & SIZE_BITS_64) {
			fread64(&sd->sd_size);
		} else {
			__u32 size32;

			/* We need the endian conversions since sd->sd_size is 64 bit */
			fread_le32(&size32);
			set_sd_v2_size(sd, size32);
		}

		fread32(&sd->sd_blocks);
	}

	return;
}

/* indirect item comes either in packed form or as is. ih_free_space
   can go first */
static void unpack_indirect(struct packed_item *pi, struct buffer_head *bh,
			    struct item_head *ih)
{
	__le32 *ind_item, *end;
	int i;
	__u16 v16;

	if (!(get_pi_mask(pi) & IH_FREE_SPACE)) {
		/* ih_free_space was not packed - set default */
		set_ih_entry_count(ih, 0);
	}

	ind_item = (__le32 *) ih_item_body(bh, ih);

	if (get_pi_mask(pi) & SAFE_LINK) {
		d32_put(ind_item, 0, get_key_dirid(&ih->ih_key));
		set_key_dirid(&ih->ih_key, (__u32) - 1);
		return;
	}

	if (get_pi_mask(pi) & WHOLE_INDIRECT) {
		fread(ind_item, get_pi_item_len(pi), 1, stdin);
		return;
	}

	end = ind_item + I_UNFM_NUM(ih);
	while (ind_item < end) {
		__u32 base;
		fread32(ind_item);
		fread_le16(&v16);
		base = d32_get(ind_item, 0);
		for (i = 1; i < v16; i++) {
			if (base != 0)
				d32_put(ind_item, i, base + i);
			else
				d32_put(ind_item, i, 0);
		}
		ind_item += i;
	}
	return;
}

// FIXME: we have no way to preserve symlinks
static void unpack_direct(struct packed_item *pi, struct buffer_head *bh,
			  struct item_head *ih)
{
	__le32 *d_item = (__le32 *) ih_item_body(bh, ih);

	if (!(get_pi_mask(pi) & IH_FREE_SPACE))
		/* ih_free_space was not packed - set default */
		set_ih_entry_count(ih, 0xffff);

	if (get_pi_mask(pi) & SAFE_LINK) {
		d32_put(d_item, 0, get_key_dirid(&ih->ih_key));
		set_key_dirid(&ih->ih_key, (__u32) - 1);
	} else {
		memset(d_item, 'a', get_pi_item_len(pi));
	}
	return;
}

static void unpack_leaf(int dev, hashf_t hash_func, __u16 blocksize)
{
	static int unpacked_leaves = 0;
	struct buffer_head *bh;
	struct packed_item pi;
	struct item_head *ih;
	int i;
	__le16 v16;
	__le32 v32;

	/* block number */
	fread_le32(&v32);

	/* item number */
	fread_le16(&v16);

	if (verbose)
		reiserfs_warning(stderr, "leaf %d: %d items\n", v32, v16);

	bh = getblk(dev, v32, blocksize);
	if (!bh)
		die("unpack_leaf: getblk failed");

	set_blkh_nr_items(B_BLK_HEAD(bh), v16);
	set_blkh_level(B_BLK_HEAD(bh), DISK_LEAF_NODE_LEVEL);
	set_blkh_free_space(B_BLK_HEAD(bh), MAX_FREE_SPACE(bh->b_size));

	ih = item_head(bh, 0);
	for (i = 0; i < get_blkh_nr_items(B_BLK_HEAD(bh)); i++, ih++) {
#if 0
		fread32(&v32);
		if (v32 != ITEM_START_MAGIC)
			die("unpack_leaf: no start item magic found: block %lu, item %i", bh->b_blocknr, i);
#endif

		fread(&pi, sizeof(struct packed_item), 1, stdin);

		/* dir_id - if it is there */
		if (get_pi_mask(&pi) & DIR_ID) {
			fread32(&v32);
			set_key_dirid(&ih->ih_key, le32_to_cpu(v32));
		} else {
			if (!i)
				die("unpack_leaf: dir_id is not set");
			set_key_dirid(&ih->ih_key,
				      get_key_dirid(&(ih - 1)->ih_key));
		}

		/* object_id - if it is there */
		if (get_pi_mask(&pi) & OBJECT_ID) {
			fread32(&v32);
			set_key_objectid(&ih->ih_key, le32_to_cpu(v32));
		} else {
			if (!i)
				die("unpack_leaf: object_id is not set");
			set_key_objectid(&ih->ih_key,
					 get_key_objectid(&(ih - 1)->ih_key));
		}

		// we need to set item format before offset unpacking
		set_ih_key_format(ih,
				  (get_pi_mask(&pi) & NEW_FORMAT) ? KEY_FORMAT_2
				  : KEY_FORMAT_1);

		// offset
		unpack_offset(&pi, ih, bh->b_size);

		/* type */
		unpack_type(&pi, ih);

		/* ih_free_space and ih_format */
		if (get_pi_mask(&pi) & IH_FREE_SPACE) {
			fread16(&v16);
			set_ih_entry_count(ih, le16_to_cpu(v16));
		}

		if (get_pi_mask(&pi) & IH_FORMAT)
			fread16(&ih->ih_format);

		/* item length and item location */
		set_ih_item_len(ih, get_pi_item_len(&pi));
		set_ih_location(ih,
				(i ? get_ih_location(ih - 1) : bh->b_size) -
				get_pi_item_len(&pi));

		// item itself
		if (is_direct_ih(ih)) {
			unpack_direct(&pi, bh, ih);
		} else if (is_indirect_ih(ih)) {
			unpack_indirect(&pi, bh, ih);
		} else if (is_direntry_ih(ih)) {
			unpack_direntry(&pi, bh, ih, hash_func);
		} else if (is_stat_data_ih(ih)) {
			unpack_stat_data(&pi, bh, ih);
		}
		set_blkh_free_space(B_BLK_HEAD(bh),
				    get_blkh_free_space(B_BLK_HEAD(bh)) -
				    (IH_SIZE + get_ih_item_len(ih)));

#if 0
		fread32(&v32);
		if (v32 != ITEM_END_MAGIC)
			die("unpack_leaf: no end item magic found: block %lu, item %i", bh->b_blocknr, i);
		if (verbose)
			reiserfs_warning(stderr, "%d: %H\n", i, ih);
#endif
	}

	fread_le16(&v16);
	if (v16 != LEAF_END_MAGIC)
		die("unpack_leaf: wrong end signature found - %x, block %lu",
		    v16, bh->b_blocknr);

	mark_buffer_uptodate(bh, 1);
	mark_buffer_dirty(bh);
	bwrite(bh);
	/*
	   if (!not_data_block (bh->b_blocknr))
	   data_blocks_unpacked ++;
	 */
	brelse(bh);

	if (what_unpacked)
		reiserfs_bitmap_set_bit(what_unpacked, bh->b_blocknr);
	/*unpacked ++; */

	if (!(++unpacked_leaves % 10))
		fprintf(stderr, "#");
}

static void unpack_full_block(int dev, int blocksize)
{
	static int full_blocks_unpacked = 0;
	__u32 block;
	struct buffer_head *bh;

	fread_le32(&block);

	if (verbose)
		fprintf(stderr, "full #%d\n", block);

	bh = getblk(dev, block, blocksize);
	if (!bh)
		die("unpack_full_block: getblk failed");

	fread(bh->b_data, bh->b_size, 1, stdin);

	if (who_is_this(bh->b_data, bh->b_size) == THE_SUPER && !what_unpacked) {
		unsigned long blocks;
		struct buffer_head *tmp;

		blocks =
		    get_sb_block_count((struct reiserfs_super_block *)(bh->
								       b_data));
		fprintf(stderr, "There were %lu blocks on the device\n",
			blocks);
		what_unpacked = reiserfs_create_bitmap(blocks);

		/* make file as long as filesystem is */
		tmp = getblk(dev, blocks - 1, blocksize);
		mark_buffer_dirty(tmp);
		mark_buffer_uptodate(tmp, 0);
		bwrite(tmp);
		brelse(tmp);
	}

	mark_buffer_uptodate(bh, 1);
	mark_buffer_dirty(bh);
	bwrite(bh);
/*
    if (!not_data_block (bh->b_blocknr))
	data_blocks_unpacked ++;
*/
	brelse(bh);

	if (what_unpacked)
		reiserfs_bitmap_set_bit(what_unpacked, block);
	/*unpacked ++; */

	if (!(++full_blocks_unpacked % 50))
		fprintf(stderr, ".");
}

/* just skip bitmaps of unformatted nodes */
static void unpack_unformatted_bitmap(int dev, int blocksize)
{
	__u16 bmap_num;
	__u32 block_count;
	int i;
	char *buf;

	fread_le16(&bmap_num);
	fread_le32(&block_count);

	buf = malloc(blocksize);
	if (!buf)
		reiserfs_panic("unpack_unformatted_bitmap: malloc failed: %m");

	for (i = 0; i < bmap_num; i++) {
		if (fread(buf, blocksize, 1, stdin) != 1)
			reiserfs_panic("unpack_unformatted_bitmap: "
				       "could not read bitmap #%d: %m", i);
	}
	free(buf);
}

// read packed reiserfs partition metadata from stdin
void unpack_partition(int fd, int jfd)
{
	__u32 magic32;
	long position;
	__le16 magic16;
	__u16 blocksize;
	int dev = fd;

	fread_le32(&magic32);
	if (magic32 != REISERFS_SUPER_MAGIC)
		die("unpack_partition: reiserfs magic number (0x%x) not found - %x\n", REISERFS_SUPER_MAGIC, magic32);

	fread_le16(&blocksize);

	if (verbose)
		fprintf(stderr, "Blocksize %d\n", blocksize);

	while (!feof(stdin)) {
		char c[2];

		fread(c, 1, 1, stdin);
		switch (c[0]) {
		case '.':
			if (verbose)
				fprintf(stderr, "\".\" skipped\n");
			continue;

		case '1':
			fread(c, 1, 1, stdin);	/* that was 100%, read in first 0 */
		case '2':
		case '4':
		case '6':
		case '8':
			fread(c, 1, 1, stdin);
		case '0':
			fread(c + 1, 1, 1, stdin);	/* read % */

			if (c[0] != '0' || c[1] != '%')
				die("0%% expected\n");

			if (verbose)
				fprintf(stderr, "0%% skipped\n");
			continue;
		}

		fread16(&magic16);
		magic16 = le16_to_cpu(magic16);

		switch (magic16 & 0xff) {
		case LEAF_START_MAGIC:
			leaves++;
			unpack_leaf(dev, code2func(magic16 >> 8), blocksize);
			break;

		case SEPARATED_JOURNAL_START_MAGIC:
			if (Default_journal)
				die("file name for separated journal has to be specified");
			dev = jfd;
			break;

		case SEPARATED_JOURNAL_END_MAGIC:
			dev = fd;
			break;

		case FULL_BLOCK_START_MAGIC:
			full++;
			unpack_full_block(dev, blocksize);
			break;

		case UNFORMATTED_BITMAP_START_MAGIC:
			fprintf(stderr, "\nBitmap of unformatted - ignored\n");
			unpack_unformatted_bitmap(dev, blocksize);
			break;

		case END_MAGIC:
			goto out;

		default:
			position = ftell(stdin);
			if (position == ~(long)0)
				die("unpack_partition: bad magic found - %x",
				    magic16 & 0xff);
			else
				die("unpack_partition: bad magic found - %x, position %lu", magic16 & 0xff, ftell(stdin));
		}
	}
out:
	fprintf(stderr, "Unpacked %d leaves, %d full blocks\n", leaves, full);

	/*    fclose (block_list); */
}

int do_unpack(char *host, char *j_filename, char *filename, int verbose)
{
	int fd, fdj = -2;
	struct rlimit lim = { RLIM_INFINITY, RLIM_INFINITY };

	if (filename == NULL)
		filename = ".bitmap";

	if (j_filename)
		Default_journal = 0;

	/* with this 2.4.0-test9's file_write does not send SIGXFSZ */
	if (setrlimit(RLIMIT_FSIZE, &lim)) {
		fprintf(stderr, "sertlimit failed: %m\n");
	}

	if (misc_device_mounted(host) > 0) {
		fprintf(stderr, "%s seems mounted, umount it first\n", host);
		return 0;
	}

	fd = open(host, O_RDWR | O_LARGEFILE);
	if (fd == -1) {
		perror("open failed");
		return 0;
	}

	if (!Default_journal) {
		fdj = open(j_filename, O_RDWR | O_LARGEFILE);
		if (fdj == -1) {
			perror("open failed");
			return 0;
		}
	}

	unpack_partition(fd, fdj);

	if (what_unpacked && filename) {
		FILE *file = open_file(filename, "w+");
		reiserfs_bitmap_save(file, what_unpacked);
		close_file(file);
	}

	close(fd);
	if (!Default_journal)
		close(fdj);
	return 0;
}