/*
 * dir.c
 *
 * Copyright (C) 1995-1997, 1999 Martin von Löwis
 * Copyright (C) 1999 Steve Dodd
 * Copyright (C) 1999 Joseph Malicki
 * Copyright (C) 2001 Anton Altaparmakov (AIA)
 */

#include "ntfstypes.h"
#include "struct.h"
#include "dir.h"
#include "macros.h"

#include <linux/errno.h>
#include "super.h"
#include "inode.h"
#include "attr.h"
#include "support.h"
#include "util.h"
#include <linux/smp_lock.h>
#include <linux/bitops.h>

static char I30[] = "$I30";

/* An index record should start with INDX, and the last word in each block
 * should contain the check value. If it passes, the original values need to
 * be restored. */
int ntfs_check_index_record(ntfs_inode *ino, char *record)
{
	return ntfs_fixup_record(record, "INDX", ino->u.index.recordsize);
}

static inline int ntfs_is_top(ntfs_u64 stack)
{
	return stack == 14;
}

static int ntfs_pop(ntfs_u64 *stack)
{
	static int width[16] = {1,2,1,3,1,2,1,4,1,2,1,3,1,2,1,-1};
	int res = -1;
	
	switch (width[*stack & 15]) {
	case 1:
		res = (int)((*stack & 15) >> 1);
		*stack >>= 4;
		break;
	case 2:
		res = (int)(((*stack & 63) >> 2) + 7);
		*stack >>= 6;
		break;
	case 3:
		res = (int)(((*stack & 255) >> 3) + 23);
		*stack >>= 8;
		break;
	case 4:
		res = (int)(((*stack & 1023) >> 4) + 55);
		*stack >>= 10;
		break;
	default:
		ntfs_error("Unknown encoding\n");
	}
	return res;
}

static inline unsigned int ntfs_top(void)
{
	return 14;
}

static ntfs_u64 ntfs_push(ntfs_u64 stack, int i)
{
	if (i < 7)
		return (stack << 4) | (i << 1);
	if (i < 23)
		return (stack << 6) | ((i - 7) << 2) | 1;
	if (i < 55)
		return (stack << 8) | ((i - 23) << 3) | 3;
	if (i < 120)
		return (stack << 10) | ((i - 55) << 4) | 7;
	ntfs_error("Too many entries\n");
	return ~((ntfs_u64)0);
}

#if 0
static void ntfs_display_stack(ntfs_u64 stack)
{
	while(!ntfs_is_top(stack))
	{
		printf("%d ", ntfs_pop(&stack));
	}
	printf("\n");
}
#endif

/* True if the entry points to another block of entries. */
static inline int ntfs_entry_has_subnodes(char *entry)
{
	return (NTFS_GETU16(entry + 0xc) & 1);
}

/* True if it is not the 'end of dir' entry. */
static inline int ntfs_entry_is_used(char *entry)
{
	return !(NTFS_GETU16(entry + 0xc) & 2);
}

/*
 * Removed RACE for allocating index blocks. But stil not too happy.
 * There might be more races afterwards. (AIA)
 */
static int ntfs_allocate_index_block(ntfs_iterate_s *walk)
{
	ntfs_attribute *allocation, *bitmap = 0;
	int error, size, i, bit;
	ntfs_u8 *bmap;
	ntfs_io io;
	ntfs_volume *vol = walk->dir->vol;

	/* Check for allocation attribute. */
	allocation = ntfs_find_attr(walk->dir, vol->at_index_allocation, I30);
	if (!allocation) {
		ntfs_u8 bmp[8];
		/* Create index allocation attribute. */
		error = ntfs_create_attr(walk->dir, vol->at_index_allocation,
					 I30, 0, 0, &allocation);
		if (error)
			goto err_ret;
		ntfs_bzero(bmp, sizeof(bmp));
		error = ntfs_create_attr(walk->dir, vol->at_bitmap, I30, bmp,
					 sizeof(bmp), &bitmap);
		if (error)
			goto err_ret;
	} else
		bitmap = ntfs_find_attr(walk->dir, vol->at_bitmap, I30);
	if (!bitmap) {
		ntfs_error("Directory w/o bitmap\n");
		error = -EINVAL;
		goto err_ret;
	}
	size = bitmap->size;
	bmap = ntfs_malloc(size);
	if (!bmap) {
		error = -ENOMEM;
		goto err_ret;
	}
	io.fn_put = ntfs_put;
	io.fn_get = ntfs_get;
try_again:
	io.param = bmap;
	io.size = size;
	error = ntfs_read_attr(walk->dir, vol->at_bitmap, I30, 0, &io);
	if (error || (io.size != size && (error = -EIO, 1)))
		goto err_fb_out;
	/* Allocate a bit. */
	for (bit = i = 0; i < size; i++) {
		if (bmap[i] == 0xFF)
			continue;
		bit = ffz(bmap[i]);
		if (bit < 8)
			break;
	}
	if (i >= size) {
		/* FIXME: Extend bitmap. */
		error = -EOPNOTSUPP;
		goto err_fb_out;
	}
	/* Get the byte containing our bit again, now taking the BKL. */
	io.param = bmap;
	io.size = 1;
	lock_kernel();
	error = ntfs_read_attr(walk->dir, vol->at_bitmap, I30, i, &io);
	if (error || (io.size != 1 && (error = -EIO, 1)))
		goto err_unl_out;
	if (ntfs_test_and_set_bit(bmap, bit)) {
		unlock_kernel();
		/* Give other process(es) a chance to finish. */
		schedule();
		goto try_again;
	}
	walk->newblock = (i * 8 + bit) * walk->dir->u.index.clusters_per_record;
	io.param = bmap;
	error = ntfs_write_attr(walk->dir, vol->at_bitmap, I30, i, &io);
	if (error || (io.size != size && (error = -EIO, 1)))
		goto err_unl_out;
	/* Change inode on disk, required when bitmap is resident. */
	error = ntfs_update_inode(walk->dir);
	if (error)
		goto err_unl_out;
	unlock_kernel();
	ntfs_free(bmap);
	/* Check whether record is out of allocated range. */
	size = allocation->size;
	if (walk->newblock * vol->cluster_size >= size) {
		/* Build index record. */
		int hsize;
		int s1 = walk->dir->u.index.recordsize;
		int nr_fix = (s1 >> vol->sector_size) + 1;
		char *record = ntfs_malloc(s1);
		if (!record) {
			error = -ENOMEM;
			goto err_ret;
		}
		ntfs_bzero(record, s1);
		/* Magic */
		ntfs_memcpy(record, "INDX", 4);
		/* Offset to fixups */
		NTFS_PUTU16(record + 4, 0x28);
		/* Number of fixups. */
		NTFS_PUTU16(record + 6, nr_fix);
		/* Log file sequence number - We don't do journalling so we
		 * just set it to zero which should be the Right Thing. (AIA) */
		NTFS_PUTU64(record + 8, 0);
		/* VCN of buffer */
		NTFS_PUTU64(record + 0x10, walk->newblock);
		/* Header size. */
		hsize = 0x10 + 2 * nr_fix;
		hsize = (hsize + 7) & ~7; /* Align. */
		NTFS_PUTU16(record + 0x18, hsize);
		/* Total size of record. */
		NTFS_PUTU32(record + 0x20, s1 - 0x18);
		/* Writing the data will extend the attribute. */
		io.param = record;
		io.size = s1;
		io.do_read = 0;
		error = ntfs_readwrite_attr(walk->dir, allocation, size, &io);
		ntfs_free(record);
		if (error || (io.size != s1 && (error = -EIO, 1)))
			goto err_ret;
		error = ntfs_update_inode(walk->dir);
		if (error)
			goto err_ret;
	}
	return 0;
err_unl_out:
	unlock_kernel();
err_fb_out:
	ntfs_free(bmap);
err_ret:
	return error;
}

/* Write an index block (root or allocation) back to storage.
 * Used is the total number of bytes in buf, including all headers. */
static int ntfs_index_writeback(ntfs_iterate_s *walk, ntfs_u8 *buf, int block,
				int used)
{
	ntfs_io io;
	int error;
	ntfs_attribute *a;
	ntfs_volume *vol = walk->dir->vol;
	
	io.fn_put = 0;
	io.fn_get = ntfs_get;
	io.param = buf;
	if (block == -1) {	/* Index root. */
		NTFS_PUTU16(buf + 0x14, used - 0x10);
		/* 0x18 is a copy thereof. */
		NTFS_PUTU16(buf + 0x18, used - 0x10);
		io.size = used;
		error = ntfs_write_attr(walk->dir, vol->at_index_root, I30, 0,
					&io);
		if (error || (io.size != used && (error = -EIO, 1)))
			return error;
		/* Shrink if necessary. */
		a = ntfs_find_attr(walk->dir, vol->at_index_root, I30);
		ntfs_resize_attr(walk->dir, a, used);
	} else {
		NTFS_PUTU16(buf + 0x1C, used - 0x18);
		io.size = walk->dir->u.index.recordsize;
		error = ntfs_insert_fixups(buf, io.size);
		if (error) {
			printk(KERN_ALERT "NTFS: ntfs_index_writeback() caught "
					"corrupt index record ntfs record "
					"header. Refusing to write corrupt "
					"data to disk. Unmount and run chkdsk "
					"immediately!\n");
			return -EIO;
		}
		error = ntfs_write_attr(walk->dir, vol->at_index_allocation,
				I30, (__s64)block << vol->cluster_size_bits,
				&io);
		if (error || (io.size != walk->dir->u.index.recordsize &&
				(error = -EIO, 1)))
			return error;
	}
	return 0;
}

static int ntfs_split_record(ntfs_iterate_s *walk, char *start, int bsize,
			     int usize)
{
	char *entry, *prev;
	ntfs_u8 *newbuf = 0, *middle = 0;
	int error, othersize, mlen;
	ntfs_io io;
	ntfs_volume *vol = walk->dir->vol;
	int oldblock;

	error = ntfs_allocate_index_block(walk);
	if (error)
		return error;
	/* This should not happen. */
	if (walk->block == -1) {
		ntfs_error("Trying to split root");
		return -EOPNOTSUPP;
	}
	entry = start + NTFS_GETU16(start + 0x18) + 0x18; 
	for (prev = entry; entry - start < usize / 2; 
					       entry += NTFS_GETU16(entry + 8))
		prev = entry;
	newbuf = ntfs_malloc(vol->index_record_size);
	if (!newbuf)
		return -ENOMEM;
	io.fn_put = ntfs_put;
	io.fn_get = ntfs_get;
	io.param = newbuf;
	io.size = vol->index_record_size;
	/* Read in old header. FIXME: Reading everything is overkill. */
	error = ntfs_read_attr(walk->dir, vol->at_index_allocation, I30,
			(__s64)walk->newblock << vol->cluster_size_bits, &io);
	if (error)
		goto out;
	if (io.size != vol->index_record_size) {
		error = -EIO;
		goto out;
	}
	/* FIXME: Adjust header. */
	/* Copy everything from entry to new block. */
	othersize = usize - (entry - start);
	ntfs_memcpy(newbuf + NTFS_GETU16(newbuf + 0x18) + 0x18, entry,
								    othersize);
	/* Copy flags. */
	NTFS_PUTU32(newbuf + 0x24, NTFS_GETU32(start + 0x24));
	error = ntfs_index_writeback(walk, newbuf, walk->newblock,
				othersize + NTFS_GETU16(newbuf + 0x18) + 0x18);
	if (error)
		goto out;
	/* Move prev to walk. */
	mlen = NTFS_GETU16(prev + 0x8);
	/* Remember old child node. */
	if (ntfs_entry_has_subnodes(prev))
		oldblock = NTFS_GETU32(prev + mlen - 8);
	else
		oldblock = -1;
	/* Allow for pointer to subnode. */
	middle = ntfs_malloc(ntfs_entry_has_subnodes(prev) ? mlen : mlen + 8);
	if (!middle){
		error = -ENOMEM;
		goto out;
	}
	ntfs_memcpy(middle, prev, mlen);
	/* Set has_subnodes flag. */
	NTFS_PUTU8(middle + 0xC, NTFS_GETU8(middle + 0xC) | 1);
	/* Middle entry points to block, parent entry will point to newblock. */
	NTFS_PUTU64(middle + mlen - 8, walk->block);
	if (walk->new_entry)
		ntfs_error("Entry not reset");
	walk->new_entry = middle;
	walk->u.flags |= ITERATE_SPLIT_DONE;
	/* Terminate old block. */
	othersize = usize - (prev-start);
	NTFS_PUTU64(prev, 0);
	if (oldblock == -1) {
		NTFS_PUTU32(prev + 8, 0x10);
		NTFS_PUTU32(prev + 0xC, 2);
		othersize += 0x10;
	} else {
		NTFS_PUTU32(prev + 8, 0x18);
		NTFS_PUTU32(prev + 0xC, 3);
		NTFS_PUTU64(prev + 0x10, oldblock);
		othersize += 0x18;
	}
	/* Write back original block. */
	error = ntfs_index_writeback(walk, start, walk->block, othersize);
 out:
	if (newbuf)
		ntfs_free(newbuf);
	if (middle)
		ntfs_free(middle);
	return error;
}

static int ntfs_dir_insert(ntfs_iterate_s *walk, char *start, char* entry)
{
	int blocksize, usedsize, error, offset;
	int do_split = 0;
	offset = entry - start;
	if (walk->block == -1) { /* index root */
		blocksize = walk->dir->vol->mft_record_size;
		usedsize = NTFS_GETU16(start + 0x14) + 0x10;
	} else {
		blocksize = walk->dir->u.index.recordsize;
		usedsize = NTFS_GETU16(start + 0x1C) + 0x18;
	}
	if (usedsize + walk->new_entry_size > blocksize) {
		char* s1 = ntfs_malloc(blocksize + walk->new_entry_size);
		if (!s1)
			return -ENOMEM;
		ntfs_memcpy(s1, start, usedsize);
		do_split = 1;
		/* Adjust entry to s1. */
		entry = s1 + (entry - start);
		start = s1;
	}
	ntfs_memmove(entry + walk->new_entry_size, entry, usedsize - offset);
	ntfs_memcpy(entry, walk->new_entry, walk->new_entry_size);
	usedsize += walk->new_entry_size;
	ntfs_free(walk->new_entry);
	walk->new_entry = 0;
	if (do_split) {
		error = ntfs_split_record(walk, start, blocksize, usedsize);
		ntfs_free(start);
	} else {
		error = ntfs_index_writeback(walk, start, walk->block,usedsize);
		if (error)
			return error;
	}
	return 0;
}

/* Try to split INDEX_ROOT attributes. Return -E2BIG if nothing changed. */
int ntfs_split_indexroot(ntfs_inode *ino)
{
	ntfs_attribute *ra;
	ntfs_u8 *root = 0, *index = 0;
	ntfs_io io;
	int error, off, i, bsize, isize;
	ntfs_iterate_s walk;

	ra = ntfs_find_attr(ino, ino->vol->at_index_root, I30);
	if (!ra)
		return -ENOTDIR;
	bsize = ino->vol->mft_record_size;
	root = ntfs_malloc(bsize);
	if (!root)
		return -E2BIG;
	io.fn_put = ntfs_put;
	io.param = root;
	io.size = bsize;
	error = ntfs_read_attr(ino, ino->vol->at_index_root, I30, 0, &io);
	if (error)
		goto out;
	off = 0x20;
	/* Count number of entries. */
	for (i = 0; ntfs_entry_is_used(root + off); i++)
		off += NTFS_GETU16(root + off + 8);
	if (i <= 2) {
		/* We don't split small index roots. */
		error = -E2BIG;
		goto out;
	}
	index = ntfs_malloc(ino->vol->index_record_size);
	if (!index) {
		error = -ENOMEM;
		goto out;
	}
	walk.dir = ino;
	walk.block = -1;
	walk.result = walk.new_entry = 0;
	walk.name = 0;
	error = ntfs_allocate_index_block(&walk);
	if (error)
		goto out;
	/* Write old root to new index block. */
	io.param = index;
	io.size = ino->vol->index_record_size;
	error = ntfs_read_attr(ino, ino->vol->at_index_allocation, I30,
		(__s64)walk.newblock << ino->vol->cluster_size_bits, &io);
	if (error)
		goto out;
	isize = NTFS_GETU16(root + 0x18) - 0x10;
	ntfs_memcpy(index + NTFS_GETU16(index + 0x18) + 0x18, root+0x20, isize);
	/* Copy flags. */
	NTFS_PUTU32(index + 0x24, NTFS_GETU32(root + 0x1C));
	error = ntfs_index_writeback(&walk, index, walk.newblock, 
				     isize + NTFS_GETU16(index + 0x18) + 0x18);
	if (error)
		goto out;
	/* Mark root as split. */
	NTFS_PUTU32(root + 0x1C, 1);
	/* Truncate index root. */
	NTFS_PUTU64(root + 0x20, 0);
	NTFS_PUTU32(root + 0x28, 0x18);
	NTFS_PUTU32(root + 0x2C, 3);
	NTFS_PUTU64(root + 0x30, walk.newblock);
	error = ntfs_index_writeback(&walk, root, -1, 0x38);
 out:
	ntfs_free(root);
	ntfs_free(index);
	return error;
}

/* The entry has been found. Copy the result in the caller's buffer */
static int ntfs_copyresult(char *dest, char *source)
{
	int length = NTFS_GETU16(source + 8);
	ntfs_memcpy(dest, source, length);
	return 1;
}

/* Use $UpCase some day. */
static inline unsigned short ntfs_my_toupper(ntfs_volume *vol, ntfs_u16 x)
{
	/* We should read any pending rest of $UpCase here. */
	if (x >= vol->upcase_length)
		return x;
	return vol->upcase[x];
}

/* Everything passed in walk and entry. */
static int ntfs_my_strcmp(ntfs_iterate_s *walk, const unsigned char *entry)
{
	int lu = *(entry + 0x50);
	int i;

	ntfs_u16* name = (ntfs_u16*)(entry + 0x52);
	ntfs_volume *vol = walk->dir->vol;
	for (i = 0; i < lu && i < walk->namelen; i++)
		if (ntfs_my_toupper(vol, NTFS_GETU16(name + i)) != 
			     ntfs_my_toupper(vol, NTFS_GETU16(walk->name + i)))
			break;
	if (i == lu && i == walk->namelen)
		return 0;
	if (i == lu)
		return 1;
	if (i == walk->namelen)
		return -1;
	if (ntfs_my_toupper(vol, NTFS_GETU16(name + i)) < 
			    ntfs_my_toupper(vol, NTFS_GETU16(walk->name + i)))
		return 1;
	return -1;
}

/* Necessary forward declaration. */
static int ntfs_getdir_iterate(ntfs_iterate_s *walk, char *start, char *entry);

/* Parse a block of entries. Load the block, fix it up, and iterate over the
 * entries. The block is given as virtual cluster number. */
static int ntfs_getdir_record(ntfs_iterate_s *walk, int block)
{
	int length = walk->dir->u.index.recordsize;
	char *record = (char*)ntfs_malloc(length);
	char *offset;
	int retval,error;
	int oldblock;
	ntfs_io io;

	if (!record)
		return -ENOMEM;
	io.fn_put = ntfs_put;
	io.param = record;
	io.size = length;
	/* Read the block from the index allocation attribute. */
	error = ntfs_read_attr(walk->dir, walk->dir->vol->at_index_allocation,
		I30, (__s64)block << walk->dir->vol->cluster_size_bits, &io);
	if (error || io.size != length) {
		ntfs_error("read failed\n");
		ntfs_free(record);
		return 0;
	}
	if (!ntfs_check_index_record(walk->dir, record)) {
		ntfs_error("%x is not an index record\n", block);
		ntfs_free(record);
		return 0;
	}
	offset = record + NTFS_GETU16(record + 0x18) + 0x18;
	oldblock = walk->block;
	walk->block = block;
	retval = ntfs_getdir_iterate(walk, record, offset);
	walk->block = oldblock;
	ntfs_free(record);
	return retval;
}

/* Go down to the next block of entries. These collate before the current
 * entry. */
static int ntfs_descend(ntfs_iterate_s *walk, ntfs_u8 *start, ntfs_u8 *entry)
{
	int length = NTFS_GETU16(entry + 8);
	int nextblock = NTFS_GETU32(entry + length - 8);
	int error;

	if (!ntfs_entry_has_subnodes(entry)) {
		ntfs_error("illegal ntfs_descend call\n");
		return 0;
	}
	error = ntfs_getdir_record(walk, nextblock);
	if (!error && walk->type == DIR_INSERT && 
	    (walk->u.flags & ITERATE_SPLIT_DONE)) {
		/* Split has occurred. Adjust entry, insert new_entry. */
		NTFS_PUTU32(entry + length - 8, walk->newblock);
		/* Reset flags, as the current block might be split again. */
		walk->u.flags &= ~ITERATE_SPLIT_DONE;
		error = ntfs_dir_insert(walk, start, entry);
	}
	return error;
}

static int ntfs_getdir_iterate_byposition(ntfs_iterate_s *walk, char* start,
					  char *entry)
{
	int retval = 0;
	int curpos = 0, destpos = 0;
	int length;
	if (walk->u.pos != 0) {
		if (ntfs_is_top(walk->u.pos))
			return 0;
		destpos = ntfs_pop(&walk->u.pos);
	}
	while (1) {
		if (walk->u.pos == 0) {
			if (ntfs_entry_has_subnodes(entry))
				ntfs_descend(walk, start, entry);
			else
				walk->u.pos = ntfs_top();
			if (ntfs_is_top(walk->u.pos) && 
			    !ntfs_entry_is_used(entry))
				return 1;
			walk->u.pos = ntfs_push(walk->u.pos, curpos);
			return 1;
		}
		if (curpos == destpos) {
			if (!ntfs_is_top(walk->u.pos) && 
			    ntfs_entry_has_subnodes(entry)) {
				retval = ntfs_descend(walk, start, entry);
				if (retval) {
					walk->u.pos = ntfs_push(walk->u.pos,
								curpos);
					return retval;
				}
				if (!ntfs_entry_is_used(entry))
					return 0;
				walk->u.pos = 0;
			}
			if (ntfs_entry_is_used(entry)) {
				retval = ntfs_copyresult(walk->result, entry);
				walk->u.pos = 0;
			} else {
				walk->u.pos = ntfs_top();
				return 0;
			}
		}
		curpos++;
		if (!ntfs_entry_is_used(entry))
			break;
		length = NTFS_GETU16(entry + 8);
		if (!length) {
			ntfs_error("infinite loop\n");
			break;
		}
		entry += length;
	}
	return -1;
}
	
/* Iterate over a list of entries, either from an index block, or from the
 * index root.
 * If searching BY_POSITION, pop the top index from the position. If the
 * position stack is empty then, return the item at the index and set the
 * position to the next entry. If the position stack is not empty, 
 * recursively proceed for subnodes. If the entry at the position is the
 * 'end of dir' entry, return 'not found' and the empty stack.
 * If searching BY_NAME, walk through the items until found or until
 * one item is collated after the requested item. In the former case, return
 * the result. In the latter case, recursively proceed to the subnodes.
 * If 'end of dir' is reached, the name is not in the directory */
static int ntfs_getdir_iterate(ntfs_iterate_s *walk, char *start, char *entry)
{
	int length;
	int cmp;

	if (walk->type == BY_POSITION)
		return ntfs_getdir_iterate_byposition(walk, start, entry);
	do {
		/* If the current entry is a real one, compare with the
		 * requested item. If the current entry is the last item, it
		 * is always larger than the requested item. */
		cmp = ntfs_entry_is_used(entry) ? 
						ntfs_my_strcmp(walk,entry) : -1;
		switch (walk->type) {
		case BY_NAME:
			switch (cmp) {
			case -1:
				return ntfs_entry_has_subnodes(entry) ?
					ntfs_descend(walk, start, entry) : 0;
			case  0:
				return ntfs_copyresult(walk->result, entry);
			case  1:
				break;
			}
			break;
		case DIR_INSERT:
			switch (cmp) {
			case -1:
				return ntfs_entry_has_subnodes(entry) ?
					ntfs_descend(walk, start, entry) :
					ntfs_dir_insert(walk, start, entry);
			case  0:
				return -EEXIST;
			case  1:
				break;
			}
			break;
		default:
			ntfs_error("TODO\n"); /* FIXME: ? */
		}
		if (!ntfs_entry_is_used(entry))
			break;
		length = NTFS_GETU16(entry + 8);
		if (!length) {
			ntfs_error("infinite loop\n");
			break;
		}
		entry += length;
	} while (1);
	return 0;
}

/*  Tree walking is done using position numbers. The following numbers have a
 *  special meaning:
 *       0   start (.)
 *      -1   no more entries
 *      -2   ..
 *  All other numbers encode sequences of indices. The sequence a, b, c is 
 *  encoded as <stop><c><b><a>, where <foo> is the encoding of foo. The
 *  first few integers are encoded as follows:
 *      0:    0000    1:    0010    2:    0100    3:    0110
 *      4:    1000    5:    1010    6:    1100 stop:    1110
 *      7:  000001    8:  000101    9:  001001   10:  001101
 *  The least significant bits give the width of this encoding, the other bits
 *  encode the value, starting from the first value of the interval.
 *   tag     width  first value  last value
 *   0       3      0            6
 *   01      4      7            22
 *   011     5      23           54
 *   0111    6      55           119
 *   More values are hopefully not needed, as the file position has currently
 *   64 bits in total. */

/* Find an entry in the directory. Return 0 if not found, otherwise copy the
 * entry to the result buffer. */
int ntfs_getdir(ntfs_iterate_s *walk)
{
	int length = walk->dir->vol->mft_record_size;
	int retval, error;
	/* Start at the index root. */
	char *root = ntfs_malloc(length);
	ntfs_io io;

	if (!root)
		return -ENOMEM;
	io.fn_put = ntfs_put;
	io.param = root;
	io.size = length;
	error = ntfs_read_attr(walk->dir, walk->dir->vol->at_index_root, I30,
			       0, &io);
	if (error) {
		ntfs_error("Not a directory\n");
		return 0;
	}
	walk->block = -1;
	/* FIXME: Move these to walk. */
	walk->dir->u.index.recordsize = NTFS_GETU32(root + 0x8);
	walk->dir->u.index.clusters_per_record = NTFS_GETU32(root + 0xC);
	/* FIXME: Consistency check. */
	/* Skip header. */
	retval = ntfs_getdir_iterate(walk, root, root + 0x20);
	ntfs_free(root);
	return retval;
}

/* Find an entry in the directory by its position stack. Iteration starts
 * if the stack is 0, in which case the position is set to the first item
 * in the directory. If the position is nonzero, return the item at the
 * position and change the position to the next item. The position is -1
 * if there are no more items. */
int ntfs_getdir_byposition(ntfs_iterate_s *walk)
{
	walk->type = BY_POSITION;
	return ntfs_getdir(walk);
}

/* Find an entry in the directory by its name. Return 0 if not found. */
int ntfs_getdir_byname(ntfs_iterate_s *walk)
{
	walk->type = BY_NAME;
	return ntfs_getdir(walk);
}

int ntfs_getdir_unsorted(ntfs_inode *ino, u32 *p_high, u32 *p_low,
		int (*cb)(ntfs_u8 *, void *), void *param)
{
	s64 ib_ofs;
	char *buf = 0, *entry = 0;
	ntfs_attribute *attr;
	ntfs_volume *vol;
	int byte, bit, err = 0;
	u32 start, finish, ibs, max_size;
	ntfs_io io;
	u8 ibs_bits;

	if (!ino) {
		ntfs_error(__FUNCTION__ "(): No inode! Returning -EINVAL.\n");
		return -EINVAL;
	}
	vol = ino->vol;
	if (!vol) {
		ntfs_error(__FUNCTION__ "(): Inode 0x%lx has no volume. "
				"Returning -EINVAL.\n", ino->i_number);
		return -EINVAL;
	}
	ntfs_debug(DEBUG_DIR3, __FUNCTION__ "(): Unsorted 1: Entering for "
			"inode 0x%lx, p_high = 0x%x, p_low = 0x%x.\n",
			ino->i_number, *p_high, *p_low);
	if (!*p_high) {
		/* We are still in the index root. */
		buf = ntfs_malloc(io.size = vol->mft_record_size);
		if (!buf)
			return -ENOMEM;
		io.fn_put = ntfs_put;
		io.param = buf;
		err = ntfs_read_attr(ino, vol->at_index_root, I30, 0, &io);
		if (err || !io.size)
			goto read_err_ret;
		ino->u.index.recordsize = ibs = NTFS_GETU32(buf + 0x8);
		ino->u.index.clusters_per_record = NTFS_GETU32(buf + 0xC);
		entry = buf + 0x20;
		ntfs_debug(DEBUG_DIR3, __FUNCTION__ "(): Unsorted 2: In index "
				"root.\n");
		ibs_bits = ffs(ibs) - 1;
		/* Compensate for faked "." and "..". */
		start = 2;
	} else { /* We are in an index record. */
		io.size = ibs = ino->u.index.recordsize;
		buf = ntfs_malloc(ibs);
		if (!buf)
			return -ENOMEM;
		ibs_bits = ffs(ibs) - 1;
		io.fn_put = ntfs_put;
		io.param = buf;
		/*
		 * 0 is index root, index allocation starts at 1 and works in
		 * units of index block size (ibs).
		 */
		ib_ofs = (s64)(*p_high - 1) << ibs_bits;
		err = ntfs_read_attr(ino, vol->at_index_allocation, I30, ib_ofs,
				&io);
		if (err || io.size != ibs)
			goto read_err_ret;
		if (!ntfs_check_index_record(ino, buf)) {
			ntfs_error(__FUNCTION__ "(): Index block 0x%x is not "
					"an index record. Returning "
					"-ENOTDIR.\n", *p_high - 1);
			ntfs_free(buf);
			return -ENOTDIR;
		}
		entry = buf + 0x18 + NTFS_GETU16(buf + 0x18);
		ntfs_debug(DEBUG_DIR3, __FUNCTION__ "(): Unsorted 3: In index "
				"allocation.\n");
		start = 0;
	}
	/* Process the entries. */
	finish = *p_low;
	for (; entry < (buf + ibs) && ntfs_entry_is_used(entry);
			entry += NTFS_GETU16(entry + 8)) {
		if (start < finish) {
			/* Skip entries that were already processed. */
			ntfs_debug(DEBUG_DIR3, __FUNCTION__ "(): Unsorted 4: "
					"Skipping already processed entry "
					"p_high 0x%x, p_low 0x%x.\n", *p_high,
					start);
			start++;
			continue;
		}
		ntfs_debug(DEBUG_DIR3, __FUNCTION__ "(): Unsorted 5: "
				"Processing entry p_high 0x%x, p_low 0x%x.\n",
				*p_high, *p_low);
		if ((err = cb(entry, param))) {
			/* filldir signalled us to stop. */
			ntfs_debug(DEBUG_DIR3, __FUNCTION__ "(): "
					"Unsorted 6: cb returned %i, "
					"returning 0, p_high 0x%x, p_low 0x%x."
					"\n", *p_high, *p_low);
			ntfs_free(buf);
			return 0;
		}
		++*p_low;
	}
	ntfs_debug(DEBUG_DIR3, __FUNCTION__ "(): Unsorted 7: After processing "
			"entries, p_high 0x%x, p_low 0x%x.\n", *p_high, *p_low);
	/* We have to locate the next record. */
	ntfs_free(buf);
	buf = 0;
	*p_low = 0;
	attr = ntfs_find_attr(ino, vol->at_bitmap, I30);
	if (!attr) {
		/* Directory does not have index bitmap and index allocation. */
		*p_high = 0x7fff;
		ntfs_debug(DEBUG_DIR3, __FUNCTION__ "(): Unsorted 8: No index "
				"allocation. Returning 0, p_high 0x7fff, "
				"p_low 0x0.\n");
		return 0;
	}
	max_size = attr->size;
	if (max_size > 0x7fff >> 3) {
		ntfs_error(__FUNCTION__ "(): Directory too large. Visible "
				"length is truncated.\n");
		max_size = 0x7fff >> 3;
	}
	buf = ntfs_malloc(max_size);
	if (!buf)
		return -ENOMEM;
	io.param = buf;
	io.size = max_size;
	err = ntfs_read_attr(ino, vol->at_bitmap, I30, 0, &io);
	if (err || io.size != max_size)
		goto read_err_ret;
	attr = ntfs_find_attr(ino, vol->at_index_allocation, I30);
	if (!attr) {
		ntfs_free(buf);
		ntfs_debug(DEBUG_DIR3, __FUNCTION__ "(): Unsorted 9: Find "
				"attr failed. Returning -EIO.\n");
		return -EIO;
	}
	if (attr->resident) {
		ntfs_free(buf);
		ntfs_debug(DEBUG_DIR3, __FUNCTION__ "(): Unsorted 9.5: IA is "
				"resident. Not allowed. Returning EINVAL.\n");
		return -EINVAL;
	}
	/* Loop while going through non-allocated index records. */
	max_size <<= 3;
	while (1) {
		if (++*p_high >= 0x7fff) {
			ntfs_error(__FUNCTION__ "(): Unsorted 10: Directory "
					"inode 0x%lx overflowed the maximum "
					"number of index allocation buffers "
					"the driver can cope with. Pretending "
					"to be at end of directory.\n",
					ino->i_number);
			goto fake_eod;
		}
		if (*p_high > max_size || (s64)*p_high << ibs_bits >
				attr->initialized) {
fake_eod:
			/* No more index records. */
			*p_high = 0x7fff;
			*p_low = 0;
			ntfs_free(buf);
			ntfs_debug(DEBUG_DIR3, __FUNCTION__ "(): Unsorted "
					"10.5: No more index records. "
					"Returning 0, p_high 0x7fff, p_low "
					"0.\n");
			return 0;
		}
		byte = (ntfs_cluster_t)(*p_high - 1);
		bit = 1 << (byte & 7);
		byte >>= 3;
		if ((buf[byte] & bit))
			break;
	};
	ntfs_debug(DEBUG_DIR3, __FUNCTION__ "(): Unsorted 11: Done. "
			"Returning 0, p_high 0x%x, p_low 0x%x.\n", *p_high,
			*p_low);
	ntfs_free(buf);
	return 0;
read_err_ret:
	if (!err)
		err = -EIO;
	ntfs_error(__FUNCTION__ "(): Read failed. Returning error code %i.\n",
			err);
	ntfs_free(buf);
	return err;
}

int ntfs_dir_add(ntfs_inode *dir, ntfs_inode *new, ntfs_attribute *name)
{
	ntfs_iterate_s walk;
	int nsize, esize;
	ntfs_u8* entry, *ndata;
	int error;

	walk.type = DIR_INSERT;
	walk.dir = dir;
	walk.u.flags = 0;
	nsize = name->size;
	ndata = name->d.data;
	walk.name = (ntfs_u16*)(ndata + 0x42);
	walk.namelen = NTFS_GETU8(ndata + 0x40);
	walk.new_entry_size = esize = (nsize + 0x10 + 7) & ~7;
	walk.new_entry = entry = ntfs_malloc(esize);
	if (!entry)
		return -ENOMEM;
	NTFS_PUTINUM(entry, new);
	NTFS_PUTU16(entry + 0x8, esize); /* Size of entry. */
	NTFS_PUTU16(entry + 0xA, nsize); /* Size of original name attribute. */
	NTFS_PUTU16(entry + 0xC, 0);     /* Flags. */
	NTFS_PUTU16(entry + 0xE, 0);	 /* Reserved. */
	ntfs_memcpy(entry + 0x10, ndata, nsize);
	ntfs_bzero(entry + 0x10 + nsize, esize - 0x10 - nsize);
	error = ntfs_getdir(&walk);
	if (walk.new_entry)
		ntfs_free(walk.new_entry);
	return error;
}

#if 0
int ntfs_dir_add1(ntfs_inode *dir, const char* name, int namelen,
		  ntfs_inode *ino)
{
	ntfs_iterate_s walk;
	int error;
	int nsize;
	char *entry;
	ntfs_attribute *name_attr;
	error = ntfs_decodeuni(dir->vol, name, namelen, &walk.name,
			       &walk.namelen);
	if (error)
		return error;
	/* FIXME: Set flags. */
	walk.type = DIR_INSERT;
	walk.dir = dir;
	/* walk.new = ino; */
	/* Prepare new entry. */
	/* Round up to a multiple of 8. */
	walk.new_entry_size = nsize = ((0x52 + 2 * walk.namelen + 7) / 8) * 8;
	walk.new_entry = entry = ntfs_malloc(nsize);
	if (!entry)
		return -ENOMEM;
	ntfs_bzero(entry, nsize);
	NTFS_PUTINUM(entry, ino);
	NTFS_PUTU16(entry + 8, nsize);
	NTFS_PUTU16(entry + 0xA, 0x42 + 2 * namelen); /* FIXME: Size of name 
						       * attribute. */
	NTFS_PUTU32(entry + 0xC, 0); /* FIXME: D-F? */
	name_attr = ntfs_find_attr(ino, vol->at_file_name, 0);
						    /* FIXME: multiple names */
	if (!name_attr || !name_attr->resident)
		return -EIDRM;
	/* Directory, file stamps, sizes, filename. */
	ntfs_memcpy(entry + 0x10, name_attr->d.data, 0x42 + 2 * namelen);
	error = ntfs_getdir(&walk);
	ntfs_free(walk.name);
	return error;
}
#endif

/* Fills out and creates an INDEX_ROOT attribute. */
int ntfs_add_index_root(ntfs_inode *ino, int type)
{
	ntfs_attribute *da;
	ntfs_u8 data[0x30]; /* 0x20 header, 0x10 last entry. */
	char name[10];

	NTFS_PUTU32(data, type);
	/* Collation rule. 1 == COLLATION_FILENAME */
	NTFS_PUTU32(data + 4, 1);
	NTFS_PUTU32(data + 8, ino->vol->index_record_size);
	NTFS_PUTU32(data + 0xC, ino->vol->index_clusters_per_record);
	/* Byte offset to first INDEX_ENTRY. */
	NTFS_PUTU32(data + 0x10, 0x10);
	/* Size of entries, including header. */
	NTFS_PUTU32(data + 0x14, 0x20);
	NTFS_PUTU32(data + 0x18, 0x20);
	/* No index allocation, yet. */
	NTFS_PUTU32(data + 0x1C, 0);
	/* Add last entry. */
	/* Indexed MFT record. */
	NTFS_PUTU64(data + 0x20, 0);
	/* Size of entry. */
	NTFS_PUTU32(data + 0x28, 0x10);
	/* Flags: Last entry, no child nodes. */
	NTFS_PUTU32(data + 0x2C, 2);
	/* Compute name. */
	ntfs_indexname(name, type);
	return ntfs_create_attr(ino, ino->vol->at_index_root, name,
				data, sizeof(data), &da);
}

int ntfs_mkdir(ntfs_inode *dir, const char *name, int namelen,
	       ntfs_inode *result)
{
	int error;
	
	error = ntfs_alloc_inode(dir, result, name, namelen, NTFS_AFLAG_DIR);
	if (error)
		goto out;
	error = ntfs_add_index_root(result, 0x30);
	if (error)
		goto out;
	/* Set directory bit. */
	result->attr[0x16] |= 2;
	error = ntfs_update_inode(dir);
	if (error)
		goto out;
	error = ntfs_update_inode(result);
	if (error)
		goto out;
 out:
	return error;
}

