#include <inttypes.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <unistd.h>

#include <libintl.h>

#include <ctype.h>

#include <fcntl.h>

#define _(String) gettext(String)

#include <logging.h>

#include "libgfs2.h"

#include "fsck.h"

#include "afterpass1_common.h"

#include "metawalk.h"

#include "util.h"

/**

 * find_remove_dup - find out if this is a duplicate ref.  If so, remove it.

 *

 * Returns: 1 if there are any remaining references to this block, else 0.

 */

static int find_remove_dup(struct gfs2_inode *ip, uint64_t block,

			   const char *btype, int *removed_last_meta)

{

	struct duptree *dt;

	struct inode_with_dups *id;

	int deleted_a_meta_ref = 0;

	int meta_refs_left = 0;

	dt = dupfind(block);

	if (!dt)

		return 0;

	/* remove the inode reference id structure for this reference. */

	id = find_dup_ref_inode(dt, ip);

	if (!id)

		goto more_refs;

	if (id->reftypecount[ref_as_meta])

		deleted_a_meta_ref = 1;

	dup_listent_delete(dt, id);

	if (dt->refs == 0) {

		log_info( _("This was the last reference: it's no longer a "

			    "duplicate.\n"));

		dup_delete(dt); /* not duplicate now */

		if (deleted_a_meta_ref) {

			log_debug("Removed the last reference as metadata.\n");

			*removed_last_meta = 1;

		}

		return 0;

	} else if (deleted_a_meta_ref) {

		/* If we deleted a metadata reference, see if there are more

		   references as meta, or if it was the last one. */

		meta_refs_left = count_dup_meta_refs(dt);

	}

more_refs:

	log_info(_("%d block reference(s) remain (%d as metadata).\n"),

		 dt->refs, meta_refs_left);

	if (deleted_a_meta_ref && meta_refs_left == 0) {

		log_debug("Removed the last reference as metadata.\n");

		*removed_last_meta = 1;

	}

	return 1; /* references still exist so do not free the block. */

}

/**

 * delete_block_if_notdup - delete blocks associated with an inode

 *

 * Ignore blocks that are already marked free.

 * If it has been identified as duplicate, remove the duplicate reference.

 * If all duplicate references have been removed, delete the block.

 */

static int delete_block_if_notdup(struct gfs2_inode *ip, uint64_t block,

				  struct gfs2_buffer_head **bh,

				  const char *btype, int *was_duplicate,

				  void *private)

{

	int q;

	int removed_lastmeta = 0;

	if (!valid_block_ip(ip, block))

		return meta_error;

	q = bitmap_type(ip->i_sbd, block);

	if (q == GFS2_BLKST_FREE) {

		log_info( _("%s block %lld (0x%llx), part of inode "

			    "%lld (0x%llx), was already free.\n"),

			  btype, (unsigned long long)block,

			  (unsigned long long)block,

			  (unsigned long long)ip->i_di.di_num.no_addr,

			  (unsigned long long)ip->i_di.di_num.no_addr);

		return meta_is_good;

	}

	if (find_remove_dup(ip, block, btype, &removed_lastmeta)) { /* a dup */

		if (was_duplicate) {

			if (removed_lastmeta)

				log_debug("Removed last reference as meta.\n");

			else

				*was_duplicate = 1;

		}

		log_err( _("Not clearing duplicate reference in inode "

			   "at block #%llu (0x%llx) to block #%llu (0x%llx) "

			   "because it's referenced by another inode.\n"),

			 (unsigned long long)ip->i_di.di_num.no_addr,

			 (unsigned long long)ip->i_di.di_num.no_addr,

			 (unsigned long long)block, (unsigned long long)block);

	} else {

		check_n_fix_bitmap(ip->i_sbd, ip->i_rgd, block, 0,

				   GFS2_BLKST_FREE);

	}

	return meta_is_good;

}

static int remove_dentry(struct gfs2_inode *ip, struct gfs2_dirent *dent,

			 struct gfs2_dirent *prev_de,

			 struct gfs2_buffer_head *bh,

			 char *filename, uint32_t *count, int *lindex,

			 void *private)

{

	/* the metawalk_fxn's private field must be set to the dentry

	 * block we want to clear */

	uint64_t *dentryblock = (uint64_t *) private;

	struct gfs2_dirent dentry, *de;

	memset(&dentry, 0, sizeof(struct gfs2_dirent));

	gfs2_dirent_in(&dentry, (char *)dent);

	de = &dentry;

	if (de->de_inum.no_addr == *dentryblock)

		dirent2_del(ip, bh, prev_de, dent);

	else

		(*count)++;

	return 0;

}

int remove_dentry_from_dir(struct gfs2_sbd *sdp, uint64_t dir,

			   uint64_t dentryblock)

{

	struct metawalk_fxns remove_dentry_fxns = {0};

	struct gfs2_inode *ip;

	int q;

	int error;

	log_debug( _("Removing dentry %llu (0x%llx) from directory %llu"

		     " (0x%llx)\n"), (unsigned long long)dentryblock,

		  (unsigned long long)dentryblock,

		  (unsigned long long)dir, (unsigned long long)dir);

	if (!valid_block(sdp, dir)) {

		log_err( _("Parent directory is invalid\n"));

		return 1;

	}

	remove_dentry_fxns.private = &dentryblock;

	remove_dentry_fxns.check_dentry = remove_dentry;

	q = bitmap_type(sdp, dir);

	if (q != GFS2_BLKST_DINODE) {

		log_info( _("Parent block is not an inode...ignoring\n"));

		return 1;

	}

	ip = fsck_load_inode(sdp, dir);

	if (ip == NULL) {

		stack;

		return -1;

	}

	/* Need to run check_dir with a private var of dentryblock,

	 * and fxns that remove that dentry if found */

	error = check_dir(sdp, ip, &remove_dentry_fxns);

	fsck_inode_put(&ip);

	return error;

}

int delete_metadata(struct gfs2_inode *ip, uint64_t block,

		    struct gfs2_buffer_head **bh, int h, int *is_valid,

		    int *was_duplicate, void *private)

{

	*is_valid = 1;

	*was_duplicate = 0;

	return delete_block_if_notdup(ip, block, bh, _("metadata"),

				      was_duplicate, private);

}

int delete_leaf(struct gfs2_inode *ip, uint64_t block, void *private)

{

	return delete_block_if_notdup(ip, block, NULL, _("leaf"), NULL,

				      private);

}

int delete_data(struct gfs2_inode *ip, uint64_t metablock,

		uint64_t block, void *private, struct gfs2_buffer_head *bh,

		uint64_t *ptr)

{

	return delete_block_if_notdup(ip, block, NULL, _("data"), NULL,

				      private);

}

static int del_eattr_generic(struct gfs2_inode *ip, uint64_t block,

			     uint64_t parent, struct gfs2_buffer_head **bh,

			     void *private, const char *eatype)

{

	int ret = 0;

	int was_free = 0;

	int q;

	if (valid_block_ip(ip, block)) {

		q = bitmap_type(ip->i_sbd, block);

		if (q == GFS2_BLKST_FREE)

			was_free = 1;

		ret = delete_block_if_notdup(ip, block, NULL, eatype,

					     NULL, private);

		if (!ret) {

			*bh = bread(ip->i_sbd, block);

			if (!was_free)

				ip->i_di.di_blocks--;

			bmodified(ip->i_bh);

		}

	}

	/* Even if it's a duplicate reference, we want to eliminate the

	   reference itself, and adjust di_blocks accordingly. */

	if (ip->i_di.di_eattr) {

		if (block == ip->i_di.di_eattr)

			ip->i_di.di_eattr = 0;

		bmodified(ip->i_bh);

	}

	return ret;

}

int delete_eattr_indir(struct gfs2_inode *ip, uint64_t block, uint64_t parent,

		       struct gfs2_buffer_head **bh, void *private)

{

	return del_eattr_generic(ip, block, parent, bh, private,

				 _("extended attribute"));

}

int delete_eattr_leaf(struct gfs2_inode *ip, uint64_t block, uint64_t parent,

		      struct gfs2_buffer_head **bh, void *private)

{

	return del_eattr_generic(ip, block, parent, bh, private,

				 _("indirect extended attribute"));

}

int delete_eattr_entry(struct gfs2_inode *ip, struct gfs2_buffer_head *leaf_bh,

		       struct gfs2_ea_header *ea_hdr,

		       struct gfs2_ea_header *ea_hdr_prev, void *private)

{

	struct gfs2_sbd *sdp = ip->i_sbd;

	char ea_name[256];

	uint32_t avail_size;

	int max_ptrs;

	if (!ea_hdr->ea_name_len){

		/* Skip this entry for now */

		return 1;

	}

	memset(ea_name, 0, sizeof(ea_name));

	strncpy(ea_name, (char *)ea_hdr + sizeof(struct gfs2_ea_header),

		ea_hdr->ea_name_len);

	if (!GFS2_EATYPE_VALID(ea_hdr->ea_type) &&

	   ((ea_hdr_prev) || (!ea_hdr_prev && ea_hdr->ea_type))){

		/* Skip invalid entry */

		return 1;

	}

	if (!ea_hdr->ea_num_ptrs)

		return 0;

	avail_size = sdp->sd_sb.sb_bsize - sizeof(struct gfs2_meta_header);

	max_ptrs = (be32_to_cpu(ea_hdr->ea_data_len) + avail_size - 1) /

		avail_size;

	if (max_ptrs > ea_hdr->ea_num_ptrs)

		return 1;

	log_debug( _("  Pointers Required: %d\n  Pointers Reported: %d\n"),

		   max_ptrs, ea_hdr->ea_num_ptrs);

	return 0;

}

int delete_eattr_extentry(struct gfs2_inode *ip, int i, uint64_t *ea_data_ptr,

			  struct gfs2_buffer_head *leaf_bh, uint32_t tot_ealen,

			  struct gfs2_ea_header *ea_hdr,

			  struct gfs2_ea_header *ea_hdr_prev, void *private)

{

	uint64_t block = be64_to_cpu(*ea_data_ptr);

	int error;

	error = delete_block_if_notdup(ip, block, NULL,

				       _("extended attribute"), NULL, private);

	if (error) {

		log_err(_("Bad extended attribute found at block %lld "

			  "(0x%llx)"),

			(unsigned long long)be64_to_cpu(*ea_data_ptr),

			(unsigned long long)be64_to_cpu(*ea_data_ptr));

		if (query( _("Repair the bad Extended Attribute? (y/n) "))) {

			ea_hdr->ea_num_ptrs = i;

			ea_hdr->ea_data_len = cpu_to_be32(tot_ealen);

			*ea_data_ptr = 0;

			bmodified(leaf_bh);

			/* Endianness doesn't matter in this case because it's

			   a single byte. */

			fsck_bitmap_set(ip, ip->i_di.di_eattr,

					_("extended attribute"),

					ip->i_sbd->gfs1 ? GFS2_BLKST_DINODE :

					GFS2_BLKST_USED);

			log_err( _("The EA was fixed.\n"));

		} else {

			error = 1;

			log_err( _("The bad EA was not fixed.\n"));

		}

	}

	return error;

}