/*
 *  linux/fs/hpfs/namei.c
 *
 *  Mikulas Patocka (mikulas@artax.karlin.mff.cuni.cz), 1998-1999
 *
 *  adding & removing files & directories
 */

#include <linux/string.h>
#include "hpfs_fn.h"

int hpfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
{
	const char *name = dentry->d_name.name;
	unsigned len = dentry->d_name.len;
	struct quad_buffer_head qbh0;
	struct buffer_head *bh;
	struct hpfs_dirent *de;
	struct fnode *fnode;
	struct dnode *dnode;
	struct inode *result;
	fnode_secno fno;
	dnode_secno dno;
	int r;
	struct hpfs_dirent dee;
	int err;
	if ((err = hpfs_chk_name((char *)name, &len))) return err==-ENOENT ? -EINVAL : err;
	if (!(fnode = hpfs_alloc_fnode(dir->i_sb, dir->i_hpfs_dno, &fno, &bh))) goto bail;
	if (!(dnode = hpfs_alloc_dnode(dir->i_sb, fno, &dno, &qbh0, 1))) goto bail1;
	memset(&dee, 0, sizeof dee);
	dee.directory = 1;
	if (!(mode & 0222)) dee.read_only = 1;
	/*dee.archive = 0;*/
	dee.hidden = name[0] == '.';
	dee.fnode = fno;
	dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, CURRENT_TIME);
	hpfs_lock_inode(dir);
	r = hpfs_add_dirent(dir, (char *)name, len, &dee, 0);
	if (r == 1) goto bail2;
	if (r == -1) {
		brelse(bh);
		hpfs_brelse4(&qbh0);
		hpfs_free_sectors(dir->i_sb, fno, 1);
		hpfs_free_dnode(dir->i_sb, dno);
		hpfs_unlock_inode(dir);
		return -EEXIST;
	}
	fnode->len = len;
	memcpy(fnode->name, name, len > 15 ? 15 : len);
	fnode->up = dir->i_ino;
	fnode->dirflag = 1;
	fnode->btree.n_free_nodes = 7;
	fnode->btree.n_used_nodes = 1;
	fnode->btree.first_free = 0x14;
	fnode->u.external[0].disk_secno = dno;
	fnode->u.external[0].file_secno = -1;
	dnode->root_dnode = 1;
	dnode->up = fno;
	de = hpfs_add_de(dir->i_sb, dnode, "\001\001", 2, 0);
	de->creation_date = de->write_date = de->read_date = gmt_to_local(dir->i_sb, CURRENT_TIME);
	if (!(mode & 0222)) de->read_only = 1;
	de->first = de->directory = 1;
	/*de->hidden = de->system = 0;*/
	de->fnode = fno;
	mark_buffer_dirty(bh, 1);
	brelse(bh);
	hpfs_mark_4buffers_dirty(&qbh0);
	hpfs_brelse4(&qbh0);
	dir->i_nlink++;
	hpfs_lock_iget(dir->i_sb, 1);
	if ((result = iget(dir->i_sb, fno))) {
		result->i_hpfs_parent_dir = dir->i_ino;
		result->i_ctime = result->i_mtime = result->i_atime = local_to_gmt(dir->i_sb, dee.creation_date);
		result->i_hpfs_ea_size = 0;
		if (dee.read_only) result->i_mode &= ~0222;
		if (result->i_uid != current->fsuid ||
		    result->i_gid != current->fsgid ||
		    result->i_mode != (mode | S_IFDIR)) {
			result->i_uid = current->fsuid;
			result->i_gid = current->fsgid;
			result->i_mode = mode | S_IFDIR;
			hpfs_write_inode_nolock(result);
		}
		d_instantiate(dentry, result);
	}
	hpfs_unlock_iget(dir->i_sb);
	hpfs_unlock_inode(dir);
	return 0;
	bail2:
	hpfs_brelse4(&qbh0);
	hpfs_free_dnode(dir->i_sb, dno);
	hpfs_unlock_inode(dir);
	bail1:
	brelse(bh);
	hpfs_free_sectors(dir->i_sb, fno, 1);
	bail:
	return -ENOSPC;
}

int hpfs_create(struct inode *dir, struct dentry *dentry, int mode)
{
	const char *name = dentry->d_name.name;
	unsigned len = dentry->d_name.len;
	struct inode *result = NULL;
	struct buffer_head *bh;
	struct fnode *fnode;
	fnode_secno fno;
	int r;
	struct hpfs_dirent dee;
	int err;
	if ((err = hpfs_chk_name((char *)name, &len))) return err==-ENOENT ? -EINVAL : err;
	if (!(fnode = hpfs_alloc_fnode(dir->i_sb, dir->i_hpfs_dno, &fno, &bh))) goto bail;
	memset(&dee, 0, sizeof dee);
	if (!(mode & 0222)) dee.read_only = 1;
	dee.archive = 1;
	dee.hidden = name[0] == '.';
	dee.fnode = fno;
	dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, CURRENT_TIME);
	hpfs_lock_inode(dir);
	r = hpfs_add_dirent(dir, (char *)name, len, &dee, 0);
	if (r == 1) goto bail1;
	if (r == -1) {
		brelse(bh);
		hpfs_free_sectors(dir->i_sb, fno, 1);
		hpfs_unlock_inode(dir);
		return -EEXIST;
	}
	fnode->len = len;
	memcpy(fnode->name, name, len > 15 ? 15 : len);
	fnode->up = dir->i_ino;
	mark_buffer_dirty(bh, 1);
	brelse(bh);
	hpfs_lock_iget(dir->i_sb, 2);
	if ((result = iget(dir->i_sb, fno))) {
		hpfs_decide_conv(result, (char *)name, len);
		result->i_hpfs_parent_dir = dir->i_ino;
		result->i_ctime = result->i_mtime = result->i_atime = local_to_gmt(dir->i_sb, dee.creation_date);
		result->i_hpfs_ea_size = 0;
		if (dee.read_only) result->i_mode &= ~0222;
		if (result->i_blocks == -1) result->i_blocks = 1;
		if (result->i_size == -1) result->i_size = 0;
		if (result->i_uid != current->fsuid ||
		    result->i_gid != current->fsgid ||
		    result->i_mode != (mode | S_IFREG)) {
			result->i_uid = current->fsuid;
			result->i_gid = current->fsgid;
			result->i_mode = mode | S_IFREG;
			hpfs_write_inode_nolock(result);
		}
		d_instantiate(dentry, result);
	}
	hpfs_unlock_iget(dir->i_sb);
	hpfs_unlock_inode(dir);
	return 0;
	bail1:
	brelse(bh);
	hpfs_free_sectors(dir->i_sb, fno, 1);
	hpfs_unlock_inode(dir);
	bail:
	return -ENOSPC;
}

int hpfs_mknod(struct inode *dir, struct dentry *dentry, int mode, int rdev)
{
	const char *name = dentry->d_name.name;
	unsigned len = dentry->d_name.len;
	struct buffer_head *bh;
	struct fnode *fnode;
	fnode_secno fno;
	int r;
	struct hpfs_dirent dee;
	struct inode *result = NULL;
	int err;
	if ((err = hpfs_chk_name((char *)name, &len))) return err==-ENOENT ? -EINVAL : err;
	if (dir->i_sb->s_hpfs_eas < 2) return -EPERM;
	if (!(fnode = hpfs_alloc_fnode(dir->i_sb, dir->i_hpfs_dno, &fno, &bh))) goto bail;
	memset(&dee, 0, sizeof dee);
	if (!(mode & 0222)) dee.read_only = 1;
	dee.archive = 1;
	dee.hidden = name[0] == '.';
	dee.fnode = fno;
	dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, CURRENT_TIME);
	hpfs_lock_inode(dir);
	r = hpfs_add_dirent(dir, (char *)name, len, &dee, 0);
	if (r == 1) goto bail1;
	if (r == -1) {
		brelse(bh);
		hpfs_free_sectors(dir->i_sb, fno, 1);
		hpfs_unlock_inode(dir);
		return -EEXIST;
	}
	fnode->len = len;
	memcpy(fnode->name, name, len > 15 ? 15 : len);
	fnode->up = dir->i_ino;
	mark_buffer_dirty(bh, 1);
	hpfs_lock_iget(dir->i_sb, 2);
	if ((result = iget(dir->i_sb, fno))) {
		result->i_hpfs_parent_dir = dir->i_ino;
		result->i_ctime = result->i_mtime = result->i_atime = local_to_gmt(dir->i_sb, dee.creation_date);
		result->i_hpfs_ea_size = 0;
		/*if (result->i_blocks == -1) result->i_blocks = 1;
		if (result->i_size == -1) result->i_size = 0;*/
		result->i_uid = current->fsuid;
		result->i_gid = current->fsgid;
		result->i_nlink = 1;
		result->i_size = 0;
		result->i_blocks = 1;
		init_special_inode(result, mode, rdev);
		hpfs_write_inode_nolock(result);
		d_instantiate(dentry, result);
	}
	hpfs_unlock_iget(dir->i_sb);
	hpfs_unlock_inode(dir);
	brelse(bh);
	return 0;
	bail1:
	brelse(bh);
	hpfs_free_sectors(dir->i_sb, fno, 1);
	hpfs_unlock_inode(dir);
	bail:
	return -ENOSPC;
}

extern const struct inode_operations hpfs_symlink_iops;

int hpfs_symlink(struct inode *dir, struct dentry *dentry, const char *symlink)
{
	const char *name = dentry->d_name.name;
	unsigned len = dentry->d_name.len;
	struct buffer_head *bh;
	struct fnode *fnode;
	fnode_secno fno;
	int r;
	struct hpfs_dirent dee;
	struct inode *result;
	int err;
	if ((err = hpfs_chk_name((char *)name, &len))) return err==-ENOENT ? -EINVAL : err;
	if (dir->i_sb->s_hpfs_eas < 2) return -EPERM;
	if (!(fnode = hpfs_alloc_fnode(dir->i_sb, dir->i_hpfs_dno, &fno, &bh))) goto bail;
	memset(&dee, 0, sizeof dee);
	dee.archive = 1;
	dee.hidden = name[0] == '.';
	dee.fnode = fno;
	dee.creation_date = dee.write_date = dee.read_date = gmt_to_local(dir->i_sb, CURRENT_TIME);
	hpfs_lock_inode(dir);
	r = hpfs_add_dirent(dir, (char *)name, len, &dee, 0);
	if (r == 1) goto bail1;
	if (r == -1) {
		brelse(bh);
		hpfs_free_sectors(dir->i_sb, fno, 1);
		hpfs_unlock_inode(dir);
		return -EEXIST;
	}
	fnode->len = len;
	memcpy(fnode->name, name, len > 15 ? 15 : len);
	fnode->up = dir->i_ino;
	mark_buffer_dirty(bh, 1);
	brelse(bh);
	hpfs_lock_iget(dir->i_sb, 2);
	if ((result = iget(dir->i_sb, fno))) {
		result->i_hpfs_parent_dir = dir->i_ino;
		result->i_ctime = result->i_mtime = result->i_atime = local_to_gmt(dir->i_sb, dee.creation_date);
		result->i_hpfs_ea_size = 0;
		/*if (result->i_blocks == -1) result->i_blocks = 1;
		if (result->i_size == -1) result->i_size = 0;*/
		result->i_mode = S_IFLNK | 0777;
		result->i_uid = current->fsuid;
		result->i_gid = current->fsgid;
		result->i_blocks = 1;
		result->i_size = strlen(symlink);
		result->i_op = (struct inode_operations *) &hpfs_symlink_iops;
		if ((fnode = hpfs_map_fnode(dir->i_sb, fno, &bh))) {
			hpfs_set_ea(result, fnode, "SYMLINK", (char *)symlink, strlen(symlink));
			mark_buffer_dirty(bh, 1);
			brelse(bh);
		}
		hpfs_write_inode_nolock(result);
		d_instantiate(dentry, result);
	}
	hpfs_unlock_iget(dir->i_sb);
	hpfs_unlock_inode(dir);
	return 0;
	bail1:
	brelse(bh);
	hpfs_free_sectors(dir->i_sb, fno, 1);
	hpfs_unlock_inode(dir);
	bail:
	return -ENOSPC;
}

int hpfs_unlink(struct inode *dir, struct dentry *dentry)
{
	const char *name = dentry->d_name.name;
	unsigned len = dentry->d_name.len;
	struct quad_buffer_head qbh;
	struct hpfs_dirent *de;
	struct inode *inode = dentry->d_inode;
	dnode_secno dno;
	fnode_secno fno;
	int r;
	int rep = 0;
	hpfs_adjust_length((char *)name, &len);
	again:
	hpfs_lock_2inodes(dir, inode);
	if (!(de = map_dirent(dir, dir->i_hpfs_dno, (char *)name, len, &dno, &qbh))) {
		hpfs_unlock_2inodes(dir, inode);
		return -ENOENT;
	}
	if (de->first) {
		hpfs_brelse4(&qbh);
		hpfs_unlock_2inodes(dir, inode);
		return -EPERM;
	}
	if (de->directory) {
		hpfs_brelse4(&qbh);
		hpfs_unlock_2inodes(dir, inode);
		return -EISDIR;
	}
	fno = de->fnode;
	if ((r = hpfs_remove_dirent(dir, dno, de, &qbh, 1)) == 1) hpfs_error(dir->i_sb, "there was error when removing dirent");
	if (r != 2) {
		inode->i_nlink--;
		hpfs_unlock_2inodes(dir, inode);
		d_delete(dentry);
	} else {	/* no space for deleting, try to truncate file */
		struct iattr newattrs;
		hpfs_unlock_2inodes(dir, inode);
		if (rep || dentry->d_count > 1 || permission(inode, MAY_WRITE) || get_write_access(inode)) goto ret;
		/*printk("HPFS: truncating file before delete.\n");*/
		down(&inode->i_sem);	/* do_truncate should be called here, but it's */
		newattrs.ia_size = 0;	/* not exported */
		newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
		if (notify_change(dentry, &newattrs)) {
			up(&inode->i_sem);
			put_write_access(inode);
			goto ret;
		}
		vmtruncate(inode, 0);
		if (inode->i_op && inode->i_op->truncate) inode->i_op->truncate(inode);
		up(&inode->i_sem);
		put_write_access(inode);
		rep = 1;
		goto again;
	}
	ret:
	return r == 2 ? -ENOSPC : r == 1 ? -EFSERROR : 0;
}

int hpfs_rmdir(struct inode *dir, struct dentry *dentry)
{
	const char *name = dentry->d_name.name;
	unsigned len = dentry->d_name.len;
	struct quad_buffer_head qbh;
	struct hpfs_dirent *de;
	struct inode *inode = dentry->d_inode;
	dnode_secno dno;
	fnode_secno fno;
	int n_items = 0;
	int r;
	hpfs_adjust_length((char *)name, &len);
	hpfs_lock_2inodes(dir, inode);
	if (!(de = map_dirent(dir, dir->i_hpfs_dno, (char *)name, len, &dno, &qbh))) {
		hpfs_unlock_2inodes(dir, inode);
		return -ENOENT;
	}	
	if (de->first) {
		hpfs_brelse4(&qbh);
		hpfs_unlock_2inodes(dir, inode);
		return -EPERM;
	}
	if (!de->directory) {
		hpfs_brelse4(&qbh);
		hpfs_unlock_2inodes(dir, inode);
		return -ENOTDIR;
	}
	if (!list_empty(&dentry->d_hash)) {
		hpfs_brelse4(&qbh);
		hpfs_unlock_2inodes(dir, inode);
		return -EBUSY;
	}
	hpfs_count_dnodes(dir->i_sb, inode->i_hpfs_dno, NULL, NULL, &n_items);
	if (n_items) {
		hpfs_brelse4(&qbh);
		hpfs_unlock_2inodes(dir, inode);
		return -ENOTEMPTY;
	}
	fno = de->fnode;
	if ((r = hpfs_remove_dirent(dir, dno, de, &qbh, 1)) == 1)
		hpfs_error(dir->i_sb, "there was error when removing dirent");
	if (r != 2) {
		dir->i_nlink--;
		inode->i_nlink = 0;
		hpfs_unlock_2inodes(dir, inode);
		d_delete(dentry);
	} else hpfs_unlock_2inodes(dir, inode);
	return r == 2 ? -ENOSPC : r == 1 ? -EFSERROR : 0;
}

int hpfs_readlink(struct dentry *dentry, char *buf, int len)
{
	struct inode *i = dentry->d_inode;
	struct fnode *fnode;
	struct buffer_head *bh;
	char *symlink;
	int slen;
	if (!S_ISLNK(i->i_mode)) {
		return -EINVAL;
	}
	if (!(fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh))) {
		return -EIO;
	}
	if (!(symlink = hpfs_get_ea(i->i_sb, fnode, "SYMLINK", &slen))) {
		brelse(bh);
		return -EFSERROR;
	}
	brelse(bh);
	if (slen > len) slen = len;
	memcpy_tofs(buf, symlink, slen);
	kfree(symlink);
	return slen;
}

struct dentry *hpfs_follow_link(struct dentry *dinode, struct dentry *ddir,
				unsigned int follow)
{
	struct inode *inode = dinode->d_inode;
	char *link;
	unsigned len;
	struct buffer_head *bh;
	struct fnode *fnode;
	if (!(fnode = hpfs_map_fnode(inode->i_sb, inode->i_ino, &bh))) {
		dput(dinode);
		return ERR_PTR(-EIO);
	}
	if (!(link = hpfs_get_ea(inode->i_sb, fnode, "SYMLINK", &len))) {
		brelse(bh);
		dput(dinode);
		return ERR_PTR(-EIO);
	}
	brelse(bh);
	UPDATE_ATIME(inode);
	ddir = lookup_dentry(link, ddir, follow);
	kfree(link);
	return ddir;
}

int hpfs_rename(struct inode *old_dir, struct dentry *old_dentry,
		struct inode *new_dir, struct dentry *new_dentry)
{
	char *old_name = (char *)old_dentry->d_name.name;
	int old_len = old_dentry->d_name.len;
	char *new_name = (char *)new_dentry->d_name.name;
	int new_len = new_dentry->d_name.len;
	struct inode *i = old_dentry->d_inode;
	struct inode *new_inode = new_dentry->d_inode;
	struct quad_buffer_head qbh, qbh1;
	struct hpfs_dirent *dep, *nde;
	struct hpfs_dirent de;
	dnode_secno dno;
	int r;
	struct buffer_head *bh;
	struct fnode *fnode;
	int err;
	if ((err = hpfs_chk_name((char *)new_name, &new_len))) return err;
	err = 0;
	hpfs_adjust_length((char *)old_name, &old_len);

	hpfs_lock_3inodes(old_dir, new_dir, i);
	
	/* Erm? Moving over the empty non-busy directory is perfectly legal */
	if (new_inode && S_ISDIR(new_inode->i_mode)) {
		err = -EINVAL;
		goto end1;
	}

	if (!(dep = map_dirent(old_dir, old_dir->i_hpfs_dno, (char *)old_name, old_len, &dno, &qbh))) {
		hpfs_error(i->i_sb, "lookup succeeded but map dirent failed");
		err = -ENOENT;
		goto end1;
	}
	copy_de(&de, dep);
	de.hidden = new_name[0] == '.';

	if (new_inode) {
		int r;
		if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 1)) != 2) {
			if ((nde = map_dirent(new_dir, new_dir->i_hpfs_dno, (char *)new_name, new_len, NULL, &qbh1))) {
				new_inode->i_nlink = 0;
				copy_de(nde, &de);
				memcpy(nde->name, new_name, new_len);
				hpfs_mark_4buffers_dirty(&qbh1);
				hpfs_brelse4(&qbh1);
				goto end;
			}
			hpfs_error(new_dir->i_sb, "hpfs_rename: could not find dirent");
			err = -EFSERROR;
			goto end1;
		}
		err = r == 2 ? -ENOSPC : r == 1 ? -EFSERROR : 0;
		goto end1;
	}

	if (new_dir == old_dir) hpfs_brelse4(&qbh);

	hpfs_lock_creation(i->i_sb);
	if ((r = hpfs_add_dirent(new_dir, new_name, new_len, &de, 1))) {
		hpfs_unlock_creation(i->i_sb);
		if (r == -1) hpfs_error(new_dir->i_sb, "hpfs_rename: dirent already exists!");
		err = r == 1 ? -ENOSPC : -EFSERROR;
		if (new_dir != old_dir) hpfs_brelse4(&qbh);
		goto end1;
	}
	
	if (new_dir == old_dir)
		if (!(dep = map_dirent(old_dir, old_dir->i_hpfs_dno, (char *)old_name, old_len, &dno, &qbh))) {
			hpfs_unlock_creation(i->i_sb);
			hpfs_error(i->i_sb, "lookup succeeded but map dirent failed at #2");
			err = -ENOENT;
			goto end1;
		}

	if ((r = hpfs_remove_dirent(old_dir, dno, dep, &qbh, 0))) {
		hpfs_unlock_creation(i->i_sb);
		hpfs_error(i->i_sb, "hpfs_rename: could not remove dirent");
		err = r == 2 ? -ENOSPC : -EFSERROR;
		goto end1;
	}
	hpfs_unlock_creation(i->i_sb);
	
	end:
	i->i_hpfs_parent_dir = new_dir->i_ino;
	if (S_ISDIR(i->i_mode)) {
		new_dir->i_nlink++;
		old_dir->i_nlink--;
	}
	if ((fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh))) {
		fnode->up = new_dir->i_ino;
		fnode->len = new_len;
		memcpy(fnode->name, new_name, new_len>15?15:new_len);
		if (new_len < 15) memset(&fnode->name[new_len], 0, 15 - new_len);
		mark_buffer_dirty(bh, 1);
		brelse(bh);
	}
	i->i_hpfs_conv = i->i_sb->s_hpfs_conv;
	hpfs_decide_conv(i, (char *)new_name, new_len);
	end1:
	hpfs_unlock_3inodes(old_dir, new_dir, i);
	return err;
}
